Brackets

https://drarig29.github.io/brackets-docs/
Admin
Brackets is a set of JavaScript libraries for creating and managing tournament brackets, including...
Tokens:81,880
Snippets:929
Trust Score:8.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example Match Object Structure

Source: https://drarig29.github.io/brackets-docs/user-guide/updating-matches

Illustrates the structure of a match object, including IDs for opponents, which can be used for querying in partial updates.

```json
{
  "id": 42,
  "opponent1": { "id": 0 },
  "opponent2": { "id": 1 }
}
```

--------------------------------

### Get Seeding Matches by Stage ID and Type

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Get.html

Returns the matches that contain the initial seeding for a stage, based on the stage's ID and type. This is useful for understanding starting player arrangements.

```typescript
const seedingMatches = await manager.get.getSeedingMatches(stageId, stageType);
```

--------------------------------

### isMatchStarted

Source: https://drarig29.github.io/brackets-docs/reference/manager/functions/helpers.isMatchStarted.html

Checks if a match is started. This is score-based. A completed or archived match is seen as "started" as well. The status progression is Locked > Waiting > Ready > [Running > Completed > Archived].

```APIDOC
## Function isMatchStarted

### Description
Checks if a match is started. This is score-based. A completed or archived match is seen as "started" as well.

### Signature
isMatchStarted(match): boolean

### Parameters
#### match: object
Partial match results.
- `opponent1` (object | null) - Optional - First opponent of the match.
- `opponent2` (object | null) - Optional - Second opponent of the match.
- `status` (Status) - Optional - Status of the match.

### Returns
- boolean - True if the match is considered started, false otherwise.
```

--------------------------------

### RoundRobin Ranking Formula Example

Source: https://drarig29.github.io/brackets-docs/reference/manager/interfaces/RoundRobinFinalStandingsOptions.html

Defines a custom ranking formula for participants in a round-robin stage. This example calculates scores based on wins, draws, and losses.

```typescript
(item) => 3 * item.wins + 1 * item.draws + 0 * item.losses
```

--------------------------------

### createRound

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/StageCreator.html

Creates a round containing multiple matches. It takes a list of duels and an optional starting match number.

```APIDOC
## createRound

### Description
Creates a round, which contain matches.

### Method
createRound(stageId, groupId, roundNumber, matchCount, duels, matchNumberStart?)

### Parameters
#### Path Parameters
* **stageId** (Id) - Required - ID of the parent stage.
* **groupId** (Id) - Required - ID of the parent group.
* **roundNumber** (number) - Required - Number in the group.
* **matchCount** (number) - Required - Duel/match count.
* **duels** (Duel[]) - Required - A list of duels.
* **matchNumberStart** (number) - Optional - Optionally give the starting point for the match numbers. Starts at 1 by default.

### Returns
Promise<void>
```

--------------------------------

### Update Match Scores and Infer Result

Source: https://drarig29.github.io/brackets-docs/user-guide/updating-matches

This example updates match scores and allows the library to infer the opponent's result and the match status automatically. Useful when results are determined by scores.

```javascript
// The second opponent's result is inferred, as well as the status.
await manager.update.match({
  id: 42,
  opponent1: { score: 3, result: 'win' },
  opponent2: { score: 1 },
});
```

--------------------------------

### getPreviousMatches

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Find.html

Gets the matches that lead up to a specified match.

```APIDOC
## getPreviousMatches
  * getPreviousMatches(match, matchLocation, stage, roundNumber): Promise<Match[]>
  * Gets the matches leading to the given match.
#### Parameters
    * ##### match: Match
The current match.
    * ##### matchLocation: GroupType
Location of the current match.
    * ##### stage: Stage
The parent stage.
    * ##### roundNumber: number
Number of the round.
#### Returns Promise<Match[]>
```

--------------------------------

### Async Iteration with AbortSignal

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/BracketsManager.html

This example demonstrates using an AbortSignal to cancel the asynchronous iteration of EventEmitter events. It's useful for scenarios where you need to stop listening before the loop naturally completes.

```javascript
const { on, EventEmitter } = require('events');
const ac = new AbortController();

(async () => {
  const ee = new EventEmitter();

  // Emit later on
  process.nextTick(() => {
    ee.emit('foo', 'bar');
    ee.emit('foo', 42);
  });

  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
    // The execution of this inner block is synchronous and it
    // processes one event at a time (even with await). Do not use
    // if concurrent execution is required.
    console.log(event); // prints ['bar'] [42]
  }
  // Unreachable here
})();

process.nextTick(() => ac.abort());
```

--------------------------------

### Opponent Position Example

Source: https://drarig29.github.io/brackets-docs/user-guide/structure

Illustrates how the `position` property is used to define opponent sources in a match. The `position` value corresponds to the match number whose winner will fill the current participant slot.

```json
{
    "opponent1": {
        "id": null, // TBD
        "position": 1
    },
    "opponent2": {
        "id": null, // TBD
        "position": 2
    }
}
```

--------------------------------

### Get Server Connection Listeners

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/BracketsManager.html

Shows how to retrieve the listeners registered for a specific event, in this case, the 'connection' event on a server object. This is helpful for inspecting active event handlers.

```javascript
server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
```

--------------------------------

### Get Previous Matches Leading to Current Match

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Get.html

Fetches the sequence of matches that directly led to the current match. This is helpful for reconstructing the path to a specific game.

```typescript
const previousMatches = await manager.get.getPreviousMatches(match, matchLocation, stage, roundNumber);
```

--------------------------------

### BracketsManager Properties

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/BracketsManager.html

Exposes various properties for managing tournament data, including methods for creating, deleting, finding, getting, resetting, and updating data, as well as storage and verbosity settings.

```APIDOC
## Properties

### create
`create`: CallableCreate

### delete
`delete`: Delete

### find
`find`: Find

### get
`get`: Get

### reset
`reset`: Reset

### storage
`storage`: Storage

### update
`update`: Update

### verbose
`verbose`: boolean = false

### `Static` `Readonly` captureRejectionSymbol
`captureRejectionSymbol`: typeof captureRejectionSymbol

### `Static` captureRejections
`captureRejections`: boolean
Sets or gets the default captureRejection value for all emitters.

### `Static` defaultMaxListeners
`defaultMaxListeners`: number

### `Static` `Readonly` errorMonitor
`errorMonitor`: typeof errorMonitor
This symbol shall be used to install a listener for only monitoring `'error'` events. Listeners installed using this symbol are called before the regular `'error'` listeners are called. Installing a listener using this symbol does not change the behavior once an `'error'` event is emitted, therefore the process will still crash if no regular `'error'` listener is installed.
```

--------------------------------

### makePairs<T>(array): [T, T][]

Source: https://drarig29.github.io/brackets-docs/reference/manager/functions/helpers.makePairs.html

This function takes an array and returns a new array where each element is a pair of consecutive elements from the original array. For example, [1, 2, 3, 4] becomes [[1, 2], [3, 4]].

```APIDOC
## Function makePairs

### Description
Makes pairs with each element and its next one.

### Parameters
#### array: T[]
A list of elements.

### Returns
[T, T][]

### Example
```
[1, 2, 3, 4] --> [[1, 2], [3, 4]]
```
```

--------------------------------

### run

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/StageCreator.html

Initiates the stage creation process. This method orchestrates the generation of the stage based on previously configured parameters.

```APIDOC
## run

### Description
Run the creation process.

### Method
Not specified (likely a method call in an SDK)

### Endpoint
Not applicable (SDK method)

### Returns
Promise<Stage>
```

--------------------------------

### select

Source: https://drarig29.github.io/brackets-docs/reference/manager/interfaces/CrudInterface.html

Provides three methods for selecting data: to retrieve all data from a table, to get specific data by ID, or to get data with a filter.

```APIDOC
## select<T>(table: T): Promise<null | DataTypes[T][]>

### Description
Gets all data from a table in the database.

### Parameters
- **table** (T) - Required - Where to get from.

### Returns
Promise<null | DataTypes[T][]>
```

```APIDOC
## select<T>(table: T, id: Id): Promise<null | DataTypes[T]>

### Description
Gets specific data from a table in the database.

### Parameters
- **table** (T) - Required - Where to get from.
- **id** (Id) - Required - What to get.

### Returns
Promise<null | DataTypes[T]>
```

```APIDOC
## select<T>(table: T, filter: Partial<DataTypes[T]>): Promise<null | DataTypes[T][]>

### Description
Gets data from a table in the database with a filter.

### Parameters
- **table** (T) - Required - Where to get from.
- **filter** (Partial<DataTypes[T]>) - Required - An object to filter data.

### Returns
Promise<null | DataTypes[T][]>
```

--------------------------------

### constructor

Source: https://drarig29.github.io/brackets-docs/reference/viewer/classes/BracketsViewer.html

Initializes a new instance of the BracketsViewer class.

```APIDOC
## constructor
  * new BracketsViewer(): BracketsViewer
  * #### Returns BracketsViewer
```

--------------------------------

### constructor

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Find.html

Creates an instance of a Storage getter.

```APIDOC
## constructor
  * new Find(storage): Find
  * Creates an instance of a Storage getter.
#### Parameters
    * ##### storage: Storage
The implementation of Storage.
#### Returns Find
```

--------------------------------

### loserBracket

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Find.html

Gets the loser bracket.

```APIDOC
## loserBracket

### Description
Gets the loser bracket.

### Parameters
#### Path Parameters
- **stageId** (Id) - Required - ID of the stage.

### Returns Promise<Group>
```

--------------------------------

### constructor

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Reset.html

Creates an instance of a Storage getter.

```APIDOC
## constructor
  * new Reset(storage): Reset
  * Creates an instance of a Storage getter.
#### Parameters
    * ##### storage: Storage
The implementation of Storage.
#### Returns Reset
```

--------------------------------

### Initialize JSON Database Storage

Source: https://drarig29.github.io/brackets-docs/getting-started

Instantiate the JsonDatabase for storing tournament data. This is a common choice for file-based storage.

```javascript
const { JsonDatabase } = require('brackets-json-db');
const storage = new JsonDatabase();
```

--------------------------------

### getOriginPosition

Source: https://drarig29.github.io/brackets-docs/reference/manager/functions/helpers.getOriginPosition.html

Gets the origin position of a side of a match.

```APIDOC
## Function getOriginPosition
  * getOriginPosition(match, side): number
  * Gets the origin position of a side of a match.
#### Parameters
    * ##### match: Match
The match.
    * ##### side: Side
The side.
#### Returns number
```

--------------------------------

### Create Stage with Custom Participants and Extra Fields

Source: https://drarig29.github.io/brackets-docs/user-guide/extra-fields

Use `Seeding` with `CustomParticipant` objects when creating a stage to attach arbitrary metadata. Any additional keys on these objects are forwarded to storage. SQL/Prisma backends with fixed schemas may ignore unsupported fields.

```javascript
await manager.create.stage({
  tournamentId: 1,
  name: 'Groups',
  type: 'round_robin',
  seeding: [
    { name: 'Alpha', region: 'EU', seed: 1, logoUrl: 'https://…' },
    { name: 'Bravo', region: 'NA', seed: 2 },
    { name: 'Charlie', sponsor: 'Acme' },
    'Delta', // also fine
  ],
  settings: { groupCount: 2, seedOrdering: ['groups.effort_balanced'] },
});
```

--------------------------------

### Initialize Brackets Manager

Source: https://drarig29.github.io/brackets-docs/getting-started

Create an instance of BracketsManager, passing the initialized storage implementation. This manager handles tournament data operations.

```javascript
const { BracketsManager } = require('brackets-manager');
const manager = new BracketsManager(storage);
```

--------------------------------

### getNextMatches

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Find.html

Gets the subsequent matches for the opponents of a given match.

```APIDOC
## getNextMatches
  * getNextMatches(match, matchLocation, stage, roundNumber, roundCount): Promise<(null | Match)[]>
  * Gets the match(es) where the opponents of the current match will go just after.
#### Parameters
    * ##### match: Match
The current match.
    * ##### matchLocation: GroupType
Location of the current match.
    * ##### stage: Stage
The parent stage.
    * ##### roundNumber: number
The number of the current round.
    * ##### roundCount: number
Count of rounds.
#### Returns Promise<(null | Match)>
```

--------------------------------

### getUpdatedMatchResults

Source: https://drarig29.github.io/brackets-docs/reference/manager/functions/helpers.getUpdatedMatchResults.html

Gets the values which need to be updated in a match when it's updated on insertion.

```APIDOC
## Function getUpdatedMatchResults

### Description
Gets the values which need to be updated in a match when it's updated on insertion.

### Type Parameters
#### T extends MatchResults

### Parameters
#### match: T
The up to date match.

#### existing: T
The base match.

#### enableByes: boolean
Whether to use BYEs or TBDs for `null` values in an input seeding.

### Returns
T
```

--------------------------------

### import

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/BracketsManager.html

Imports data into the database. Optionally normalizes IDs.

```APIDOC
## import

### Description
Imports data in the database.

### Method Signature
`import(data: ValueToArray<DataTypes>, normalizeIds?: boolean): Promise<void>`

### Parameters
* **data** (ValueToArray<DataTypes>) - The data to import.
* **normalizeIds** (boolean, optional, defaults to `false`) - Enable ID normalization: all IDs (and references to them) are remapped to consecutive IDs starting from 0.

### Returns
* **Promise<void>** - A Promise that resolves when the import is complete.
```

--------------------------------

### getNextSide

Source: https://drarig29.github.io/brackets-docs/reference/manager/functions/helpers.getNextSide.html

Gets the side the winner of the current match will go to in the next match.

```APIDOC
## Function getNextSide

### Description
Gets the side the winner of the current match will go to in the next match.

### Signature
getNextSide(matchNumber: number, roundNumber: number, roundCount: number, matchLocation: GroupType): Side

### Parameters
#### matchNumber
- **Type**: number
- **Description**: Number of the current match.

#### roundNumber
- **Type**: number
- **Description**: Number of the current round.

#### roundCount
- **Type**: number
- **Description**: Count of rounds.

#### matchLocation
- **Type**: GroupType
- **Description**: Location of the current match.

### Returns
- **Type**: Side
```

--------------------------------

### Prepend and Execute One-Time Listeners

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/BracketsManager.html

Demonstrates the order of execution when using `prependOnceListener` and `once`. Listeners added with `prependOnceListener` are executed before those added with `once`.

```javascript
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
```

--------------------------------

### Emit Events with Listeners

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/BracketsManager.html

Demonstrates how to register multiple listeners for an event and emit that event, triggering all registered listeners with provided arguments. This is useful for broadcasting state changes or notifications.

```javascript
const EventEmitter = require('events');
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
```

--------------------------------

### getSide(matchNumber)

Source: https://drarig29.github.io/brackets-docs/reference/manager/functions/helpers.getSide.html

Gets the side where the winner of the given match will go in the next match.

```APIDOC
## Function getSide

### Description
Gets the side where the winner of the given match will go in the next match.

### Parameters
#### matchNumber (number) - Required
Number of the match.

### Returns
Side
```

--------------------------------

### makeRoundRobinDistribution

Source: https://drarig29.github.io/brackets-docs/reference/manager/functions/helpers.makeRoundRobinDistribution.html

Distributes participants in rounds for a round-robin group. Each participant plays each other once, and each participant plays once in each round.

```APIDOC
## Function makeRoundRobinDistribution

### Description
Distributes participants in rounds for a round-robin group.

Conditions:
* Each participant plays each other once.
* Each participant plays once in each round.

### Type Parameters
* #### T

### Parameters
* ##### participants: T[]
  The participants to distribute.

### Returns
* [T, T][][]
A 2D array representing the round-robin distribution.
```

--------------------------------

### upperBracket

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Find.html

Gets the upper bracket (the only bracket if single elimination or the winner bracket in double elimination).

```APIDOC
## upperBracket

### Description
Gets the upper bracket (the only bracket if single elimination or the winner bracket in double elimination).

### Parameters
#### Path Parameters
- **stageId** (Id) - Required - ID of the stage.

### Returns Promise<Group>
```

--------------------------------

### makeFinalStandings

Source: https://drarig29.github.io/brackets-docs/reference/manager/functions/helpers.makeFinalStandings.html

Creates the final standings by processing a list of participants grouped by their ranking.

```APIDOC
## Function makeFinalStandings
  * makeFinalStandings(grouped): FinalStandingsItem[]
  * Makes final standings based on participants grouped by ranking.
#### Parameters
    * ##### grouped: Participant[][]
A list of participants grouped by ranking.
#### Returns FinalStandingsItem[]
```

--------------------------------

### getNextSideLoserBracket

Source: https://drarig29.github.io/brackets-docs/reference/manager/functions/helpers.getNextSideLoserBracket.html

Gets the side the winner of the current match in the loser bracket will go in the next match.

```APIDOC
## Function getNextSideLoserBracket

### Description
Gets the side the winner of the current match in loser bracket will go in the next match.

### Signature
getNextSideLoserBracket(matchNumber: number, nextMatch: Match, roundNumber: number): Side

### Parameters
#### matchNumber (number) - Required
Number of the match.

#### nextMatch (Match) - Required
The next match.

#### roundNumber (number) - Required
Number of the current round.

### Returns
Side
```

--------------------------------

### Render Tournament Data with Brackets Viewer

Source: https://drarig29.github.io/brackets-docs/getting-started

Use the window.bracketsViewer.render function to display the tournament bracket. Ensure you have the tournament data available in the 'data' variable.

```javascript
window.bracketsViewer.render({
    stages: data.stage,
    matches: data.match,
    matchGames: data.match_game,
    participants: data.participant,
})
```

--------------------------------

### getNextSideConsolationFinalDoubleElimination

Source: https://drarig29.github.io/brackets-docs/reference/manager/functions/helpers.getNextSideConsolationFinalDoubleElimination.html

Gets the side the loser of the current match in the loser bracket will go in the next match.

```APIDOC
## Function getNextSideConsolationFinalDoubleElimination

### Description
Gets the side the loser of the current match in loser bracket will go in the next match.

### Parameters
#### Path Parameters
* **roundNumber** (number) - Required - Number of the current round.

### Returns
* **Side** - The side the loser will go to in the next match.
```

--------------------------------

### render

Source: https://drarig29.github.io/brackets-docs/reference/viewer/classes/BracketsViewer.html

Renders bracket data. If multiple stages are provided, they will all be displayed without visual distinction based on their tournament.

```APIDOC
## Methods
### render
  * render(data, config?): Promise<void>
  * Renders data generated with `brackets-manager.js`. If multiple stages are given, they will all be displayed.
Stages won't be discriminated visually based on the tournament they belong to.
#### Parameters
    * ##### data: ViewerData
The data to display.
    * ##### `Optional` config: Partial<Config>
An optional configuration for the viewer.
`Optional`
#### Returns Promise<void>
```

--------------------------------

### getUpperBracket

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Find.html

Gets the upper bracket (the only bracket if single elimination or the winner bracket in double elimination).

```APIDOC
## getUpperBracket

### Description
Gets the upper bracket (the only bracket if single elimination or the winner bracket in double elimination).

### Parameters
#### Path Parameters
- **stageId** (Id) - Required - ID of the stage.

### Returns Promise<Group>
```

--------------------------------

### Create Stage with TBD Slots using Size Only

Source: https://drarig29.github.io/brackets-docs/user-guide/seeding

When participant data is not yet available, provide only the `size` to create a stage with TBD slots that can be filled later.

```javascript
await manager.create.stage({
  tournamentId: 1,
  name: 'Open Bracket',
  type: 'single_elimination',
  settings: {
    size: 16,
    seedOrdering: ['inner_outer'],
  },
});
```

--------------------------------

### normalizeIds

Source: https://drarig29.github.io/brackets-docs/reference/manager/functions/helpers.normalizeIds.html

Normalizes IDs in a database. All IDs (and references to them) are remapped to consecutive IDs starting from 0.

```APIDOC
## Function normalizeIds

### Description
Normalizes IDs in a database. All IDs (and references to them) are remapped to consecutive IDs starting from 0.

### Parameters
#### data (ValueToArray<DataTypes>) - Required
Data to normalize.

### Returns
Database
```

--------------------------------

### getRoundPositionalInfo

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Find.html

Gets the positional information (number in group and total number of rounds in group) of a round based on its id.

```APIDOC
## getRoundPositionalInfo

### Description
Gets the positional information (number in group and total number of rounds in group) of a round based on its id.

### Parameters
#### Path Parameters
- **roundId** (Id) - Required - ID of the round.

### Returns Promise<RoundPositionalInfo>
```

--------------------------------

### on

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/BracketsManager.html

Registers a listener function to be called when a specific event occurs.

```APIDOC
## on

### Description
Registers a listener function to be called when a specific event occurs.

### Method Signature
`on(eventName: "entity.changed", listener: (event) => void): BracketsManager`

### Parameters
* **eventName** ("entity.changed") - The name of the event to listen for, specifically `"entity.changed"`.
* **listener** ((event) => void) - The function to execute when the event is triggered.
  * **event** (EntityChangedEvent<keyof DataTypes>) - An object containing details about the entity change event.

### Returns
* **BracketsManager** - The BracketsManager instance for chaining.
```

--------------------------------

### select

Source: https://drarig29.github.io/brackets-docs/user-guide/storage

Selects participants from storage, optionally filtered by tournament ID.

```APIDOC
## select()

### Description
Selects participants from storage. Can retrieve all participants or filter by tournament ID.

### Method Signature (Select All)
`select(tableName: string): Promise<Participant[] | null>`

### Method Signature (Select by Filter)
`select(tableName: string, filter: { tournament_id: Id }): Promise<Participant[] | null>`

### Parameters
#### Filter Parameters
- **tournament_id** (Id) - Required - The tournament ID to filter participants by.
```

--------------------------------

### Get Event Names

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/BracketsManager.html

Retrieves an array of all event names for which listeners are registered on an EventEmitter instance. Useful for introspection and debugging.

```javascript
const EventEmitter = require('events');
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
```

--------------------------------

### Get Current Stage and Round

Source: https://drarig29.github.io/brackets-docs/user-guide/helpers

Retrieve the current stage and round of a tournament. Handles cases where the tournament might be completed.

```javascript
const currentStage = await manager.get.currentStage(tournamentId);
if (!currentStage) {
  // Tournament completed
}

const currentRound = await manager.get.currentRound(currentStage.id);

```

--------------------------------

### Reset Stage Seeding

Source: https://drarig29.github.io/brackets-docs/user-guide/seeding

Resets the seeding of a stage to an empty state, setting all match opponents to TBDs. This is useful for starting over with seeding.

```javascript
await manager.reset.seeding(stageId);
```

--------------------------------

### Methods.stage

Source: https://drarig29.github.io/brackets-docs/reference/manager/interfaces/CallableCreate.html

Creates a stage for an existing tournament. The tournament itself will not be created.

```APIDOC
## stage(data: InputStage): Promise<Stage>

### Description
Creates a stage for an existing tournament. The tournament won't be created.

### Parameters
#### data: InputStage
The stage to create.

### Returns
Promise<Stage>
```

--------------------------------

### Get event listeners for EventEmitter and EventTarget

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/BracketsManager.html

Retrieves a copy of the listeners array for a given event name from an EventEmitter or EventTarget. Useful for debugging.

```javascript
const { getEventListeners, EventEmitter } = require('events');

{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  getEventListeners(ee, 'foo'); // [listener]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  getEventListeners(et, 'foo'); // [listener]
}
```

--------------------------------

### applyMatchUpdate

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Reset.html

Updates the opponents and status of a match and its child games.

```APIDOC
## applyMatchUpdate
  * applyMatchUpdate(match): Promise<void>
  * Updates the opponents and status of a match and its child games.
#### Parameters
    * ##### match: Match
A match.
#### Returns Promise<void>
```

--------------------------------

### Get Ordered Rounds for a Stage

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Get.html

Retrieves all rounds within a stage that contain participants in a specific order. This method is useful for processing rounds sequentially.

```typescript
const orderedRounds = await manager.get.getOrderedRounds(stage);
```

--------------------------------

### createStage

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/StageCreator.html

Creates a new, empty stage. This is typically the first step before defining the structure and participants of a tournament stage.

```APIDOC
## createStage

### Description
Creates a new stage.

### Method
createStage()

### Returns
Promise<Stage>
```

--------------------------------

### BracketsManager Constructor

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/BracketsManager.html

Initializes a new instance of the BracketsManager class. It requires a storage interface implementation and an optional verbose flag for logging.

```APIDOC
## constructor BracketsManager

### Description
Creates an instance of BracketsManager, which will handle all the stuff from the library.

### Parameters
* **storageInterface** (CrudInterface) - Required - An implementation of CrudInterface.
* **verbose** (boolean) - Optional - Whether to log CRUD operations.

### Returns
BracketsManager
```

--------------------------------

### Get Loser Bracket by Stage ID

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Get.html

Fetches the loser bracket for a given stage. Returns null if no loser bracket exists for the specified stage.

```typescript
const loserBracket = await manager.get.getLoserBracket(stageId);
```

--------------------------------

### Get Stage-Specific Data

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Get.html

Retrieves data exclusively pertaining to a given stage, excluding participant information. This includes groups, match games, matches, and rounds.

```typescript
const stageData = await manager.get.getStageSpecificData(stageId);
```

--------------------------------

### insert

Source: https://drarig29.github.io/brackets-docs/user-guide/storage

Inserts a new match game or multiple match games into the storage.

```APIDOC
## insert()

### Description
Inserts one or more match games into the storage.

### Method Signature (Single Insert)
`insert(tableName: string, value: object): Promise<Id>`

### Parameters (Single Insert)
#### Value Object
- **number** (number) - Required - The match number.
- **stage_id** (Id) - Required - The ID of the stage.
- **parent_id** (Id) - Required - The parent ID.
- **status** (Status) - Required - The status of the match.
- **opponent1** (object) - Required - Details for opponent 1.
  - **id** (null) - Placeholder for opponent 1 ID.
- **opponent2** (object) - Required - Details for opponent 2.
  - **id** (null) - Placeholder for opponent 2 ID.

### Method Signature (Insert with OmitId)
`insert(tableName: string, value: OmitId<MatchGame>): Promise<Id>`

### Method Signature (Multiple Inserts)
`insert(tableName: string, values: MatchGame[]): Promise<boolean>`
```

--------------------------------

### Fetch Rounds and Their Matches

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Get.html

Shows how to retrieve all rounds for a given stage ID and then, for each round, fetch and count its associated matches. This is helpful for understanding the match distribution across rounds.

```javascript
for (const round of await manager.get.rounds({ stage_id: stageId })) {
    const matches = await manager.get.matches({ round_id: round.id });
    console.log(matches.length);
}
```

--------------------------------

### Get Next Matches for Opponents

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Get.html

Determines the subsequent matches where the current match's opponents will play. This is essential for visualizing or calculating future game progressions.

```typescript
const nextMatches = await manager.get.getNextMatches(match, matchLocation, stage, roundNumber, roundCount);
```

--------------------------------

### Get Current Matches for a Stage

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Get.html

Retrieves matches that are currently ongoing or ready to be played within a specific stage. Useful for displaying active matches in a tournament.

```typescript
const tournamentId = 3;
const currentStage = await manager.get.currentStage(tournamentId);
const currentMatches = await manager.get.currentMatches(currentStage.id);
```

--------------------------------

### Add Listener to Beginning of Array

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/BracketsManager.html

Use `prependListener` to add an event listener to the start of the listener array for a given event. This ensures the listener is called before others.

```javascript
server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});
```

--------------------------------

### Create a Tournament Stage

Source: https://drarig29.github.io/brackets-docs/getting-started

Use the manager to create a new tournament stage. This includes defining the stage name, tournament ID, type, and seeding.

```javascript
await manager.create.stage({
    name: 'Example stage',
    tournamentId: 0, // 
Why do you need tournamentId? See the answer in the FAQ.

    type: 'single_elimination',
    seeding: [
        'Team 1',
        'Team 2',
        'Team 3',
        'Team 4',
        'Team 5',
        'Team 6',
        'Team 7',
        'Team 8',
    ],
});
```

--------------------------------

### Get Upper Bracket by Stage ID

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Get.html

Fetches the upper bracket for a given stage. In single elimination, this is the only bracket; in double elimination, it's the winner's bracket.

```typescript
const upperBracket = await manager.get.getUpperBracket(stageId);
```

--------------------------------

### Functions

Source: https://drarig29.github.io/brackets-docs/reference/manager/modules/helpers.html

A comprehensive list of functions available for bracket manipulation and logic.

```APIDOC
### Functions
assertRoundRobin
balanceByes
byeLoser
byeWinner
byeWinnerToGrandFinal
convertMatchesToSeeding
convertSlotsToSeeding
convertTBDtoBYE
ensureEquallySized
ensureEvenSized
ensureNoDuplicates
ensureNotRoundRobin
ensureNotTied
ensureOrderingSupported
ensureValidSize
extractParticipantsFromSeeding
findLoserMatchNumber
findParticipant
findPosition
fixSeeding
getChildGamesResults
getDiagonalMatchNumber
getFractionOfFinal
getGrandFinalDecisiveMatch
getInferredResult
getLoser
getLoserCountFromWbForLbRound
getLoserOrdering
getLoserRoundMatchCount
getLosers
getLowerBracketRoundCount
getMatchLocation
getMatchOutcome
getMatchResult
getMatchStatus
getNearestPowerOfTwo
getNextSide
getNextSideConsolationFinalDoubleElimination
getNextSideLoserBracket
getNonNull
getOpponentId
getOriginPosition
getOtherSide
getParentMatchResults
getRanking
getRoundPairCount
getSeedCount
getSeeds
getSide
getUpdatedMatchResults
getUpperBracketRoundCount
getWinner
handleGivenStatus
handleOpponentsInversion
hasBye
invertOpponents
isDefined
isDoubleEliminationNecessary
isDoubleForfeitCompleted
isFinalGroup
isLoserBracket
isMajorRound
isMatchByeCompleted
isMatchCompleted
isMatchDrawCompleted
isMatchForfeitCompleted
isMatchOngoing
isMatchParticipantLocked
isMatchPending
isMatchResultCompleted
isMatchStale
isMatchStarted
isMatchUpdateLocked
isMatchWinCompleted
isMinorRound
isOrderingSupportedLoserBracket
isOrderingSupportedUpperBracket
isParticipantInMatch
isPowerOfTwo
isRoundCompleted
isRoundRobin
isSeedingWithIds
isWinnerBracket
makeFinalStandings
makeGroups
makeNormalizedIdMapping
makePairs
makeRoundRobinDistribution
makeRoundRobinMatches
mapParticipantsIdsToDatabase
mapParticipantsNamesToDatabase
mapParticipantsToDatabase
minScoreToWinBestOfX
normalizeIds
normalizeParticipant
resetMatchResults
resetNextOpponent
setArraySize
setCompleted
setExtraFields
setForfeits
setMatchResults
setNextOpponent
setNextOpponentToBye
setParentMatchCompleted
setResults
setScores
sortSeeding
splitBy
splitByParity
toResult
toResultWithPosition
transitionToMajor
transitionToMinor
uniqueBy
```

--------------------------------

### Get Current Round of a Stage

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Get.html

Fetches the round that is currently in progress within a stage. Returns null if all matches in the stage are completed. Useful for tracking tournament progression.

```typescript
const tournamentId = 3;
const currentStage = await manager.get.currentStage(tournamentId);
const currentRound = await manager.get.currentRound(currentStage.id);
```

--------------------------------

### convertSlotsToSeeding

Source: https://drarig29.github.io/brackets-docs/reference/manager/functions/helpers.convertSlotsToSeeding.html

Converts a list of slots to an input seeding.

```APIDOC
## Function convertSlotsToSeeding

### Description
Converts a list of slots to an input seeding.

### Parameters
#### slots (ParticipantSlot[]) - Required
The slots to convert.

### Returns
Seeding
```

--------------------------------

### getSeeds(inLoserBracket, roundNumber, roundCountLB, matchCount)

Source: https://drarig29.github.io/brackets-docs/reference/manager/functions/helpers.getSeeds.html

Gets the default list of seeds for a round's matches. This function is useful for initializing match seeds based on tournament structure.

```APIDOC
## Function getSeeds
  * getSeeds(inLoserBracket, roundNumber, roundCountLB, matchCount): number[]
  * Gets the default list of seeds for a round's matches.
#### Parameters
    * ##### inLoserBracket: boolean
Whether the match is in the loser bracket.
    * ##### roundNumber: number
The number of the current round.
    * ##### roundCountLB: number
The count of rounds in loser bracket.
    * ##### matchCount: number
The count of matches in the round.
#### Returns number[]
```

--------------------------------

### select

Source: https://drarig29.github.io/brackets-docs/user-guide/storage

Selects match games by ID or filters them by parent ID.

```APIDOC
## select()

### Description
Selects match games from storage either by their ID or by a filter.

### Method Signature (Select by ID)
`select(tableName: string, id: Id): Promise<MatchGame | null>`

### Method Signature (Select by Filter)
`select(tableName: string, filter: { parent_id: Id }): Promise<MatchGame[] | null>`

### Parameters
#### Filter Parameters (for select by filter)
- **parent_id** (Id) - Required - The parent ID to filter match games by.
```

--------------------------------

### MatchGame Interface Properties

Source: https://drarig29.github.io/brackets-docs/reference/model/interfaces/MatchGame.html

This snippet details the properties available for the MatchGame interface.

```APIDOC
## Interface MatchGame
A game of a match.

### Properties
- **id** (number) - ID of the match game.
- **number** (number) - The number of the match game in its parent match.
- **opponent1** (null | ParticipantResult) - First opponent of the match.
- **opponent2** (null | ParticipantResult) - Second opponent of the match.
- **parent_id** (Id) - ID of the parent match.
- **stage_id** (Id) - ID of the parent stage.
- **status** (Status) - Status of the match.
```

--------------------------------

### Get Round Positional Information

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Get.html

Retrieves the position of a round within its group and the total number of rounds in that group, identified by the round's ID. This provides context for a round's placement.

```typescript
const roundInfo = await manager.get.getRoundPositionalInfo(roundId);
```

--------------------------------

### Connection Interface

Source: https://drarig29.github.io/brackets-docs/reference/viewer/interfaces/Connection.html

Represents the connection information for a match, including optional previous and next connections.

```APIDOC
## Interface Connection
Contains the information about the connections of a match.

### Properties
#### `Optional` connectPrevious
connectPrevious?: ConnectionType

#### `Optional` connectNext
connectNext?: ConnectionType
```

--------------------------------

### applyToNextMatches Method

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/Update.html

Applies a function to set the next opponent for subsequent matches based on the outcome of the current match. This is a protected method.

```APIDOC
### `Protected` applyToNextMatches
  * applyToNextMatches(setNextOpponent, match, matchLocation, roundNumber, roundCount, nextMatches, winnerSide?): Promise<void>
  * Applies a `SetNextOpponent` function to matches following the current match.
    * `nextMatches[0]` is assumed to be next match for the winner of the current match.
    * `nextMatches[1]` is assumed to be next match for the loser of the current match.
#### Parameters
    * ##### setNextOpponent: SetNextOpponent
The `SetNextOpponent` function.
    * ##### match: Match
The current match.
    * ##### matchLocation: GroupType
Location of the current match.
    * ##### roundNumber: number
Number of the current round.
    * ##### roundCount: number
Count of rounds.
    * ##### nextMatches: (null | Match)[]
The matches following the current match.
    * ##### `Optional` winnerSide: Side
Side of the winner in the current match.
`Optional`
#### Returns Promise<void>
```

--------------------------------

### Partial Match Update with Participant ID

Source: https://drarig29.github.io/brackets-docs/user-guide/updating-matches

Demonstrates how to perform a partial update on a match, including specifying participant IDs and their scores. Note that participant positions in the match remain unchanged.

```javascript
await manager.update.match({
  id: 42,
  opponent1: { id: 1, score: 3 },
  opponent2: { id: 0, score: 1 },
});
```

--------------------------------

### Handling 'error' Event with 'once'

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/BracketsManager.html

This example shows how `events.once()` handles the 'error' event specifically when waiting for another event. If `events.once()` is used to wait for the 'error' event itself, it's treated like any other event.

```javascript
const { EventEmitter, once } = require('events');

const ee = new EventEmitter();

once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.log('error', err.message));

ee.emit('error', new Error('boom'));

// Prints: ok boom
```

--------------------------------

### BracketsManager Methods

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/BracketsManager.html

This section details the methods available within the BracketsManager class, including their parameters and return types.

```APIDOC
## BracketsManager

### Description
Provides methods for managing brackets, including setting listener limits.

### Parameters
#### Optional Parameters
- **n** (number) - Optional - A non-negative number. The maximum number of listeners per `EventTarget` event.
- **...eventTargets** (EventEmitter | _DOMEventTarget)[] - Rest parameter for event targets.

### Returns
void

### Since
v15.4.0
```

--------------------------------

### Create Round Robin Stage with Object Seeding

Source: https://drarig29.github.io/brackets-docs/user-guide/seeding

Provide participant objects with custom fields (e.g., `region`) for a round-robin stage. Participants without IDs will be automatically registered.

```javascript
await manager.create.stage({
  tournamentId: 1,
  name: 'Groups',
  type: 'round_robin',
  seeding: [
    { id: 10, name: 'Alpha', region: 'EU' },
    { name: 'Bravo', region: 'NA' },
    'Charlie',
    'Delta',
  ],
  settings: {
    groupCount: 2,
    seedOrdering: ['groups.effort_balanced'],
  },
});
```

--------------------------------

### Get Next Round Matches

Source: https://drarig29.github.io/brackets-docs/user-guide/helpers

Fetch all matches for the next round of a tournament stage. Useful for scheduling upcoming games. Consider filtering by group ID for finals and using helper functions for match status.

```javascript
// Given a current round, load the next round and its matches
const nextRound = await storage.selectFirst('round', {
  stage_id: currentRound.stage_id,
  number: currentRound.number + 1,
});

if (nextRound) {
  const nextMatches = await storage.select('match', { round_id: nextRound.id });
  // nextMatches contains every match to prepare for the next round
}


```

--------------------------------

### Create Double Elimination Stage with ID Seeding

Source: https://drarig29.github.io/brackets-docs/user-guide/seeding

Use a list of existing participant IDs and BYEs (`null`) to create a double elimination stage. Participants must already exist in the tournament.

```javascript
await manager.create.stage({
  tournamentId: 1,
  name: 'Playoffs',
  type: 'double_elimination',
  seedingIds: [1, 2, 3, 4, 5, 6, null, null],
  settings: {
    size: 8,
    seedOrdering: ['inner_outer', 'natural'],
    balanceByes: true,
    grandFinal: 'simple',
  },
});
```

--------------------------------

### CallableCreate.stage

Source: https://drarig29.github.io/brackets-docs/reference/manager/interfaces/CallableCreate.html

Creates a stage for an existing tournament. The tournament itself will not be created.

```APIDOC
## stage(stage: InputStage): Promise<Stage>

### Description
Creates a stage for an existing tournament. The tournament won't be created.

### Parameters
#### stage: InputStage
A stage to create.

### Returns
Promise<Stage>

### Deprecated
Please use `manager.create.stage()` instead.
```

--------------------------------

### RoundRobinFinalStandingsItem Properties

Source: https://drarig29.github.io/brackets-docs/reference/manager/interfaces/RoundRobinFinalStandingsItem.html

The RoundRobinFinalStandingsItem interface includes properties inherited from RankingItem, along with specific metrics for round-robin play.

```APIDOC
## Interface RoundRobinFinalStandingsItem
An item in the final standings of a round-robin stage. Each item represents a participant.

### Hierarchy
  * RankingItem
    * RoundRobinFinalStandingsItem

### Properties

#### draws
`draws`: `number`
Number of matches that ended in a draw.

#### forfeits
`forfeits`: `number`
Number of matches forfeited by the participant.

#### groupId
`groupId`: `Id`

#### id
`id`: `Id`
ID of the participant.

#### losses
`losses`: `number`
Number of matches lost by the participant.

#### name
`name`: `string`

#### played
`played`: `number`
Number of matches played by the participant.

#### points
`points`: `number`
Total points of the participant.

#### rank
`rank`: `number`
Resulting rank of the participant.

#### scoreAgainst
`scoreAgainst`: `number`
Total score in favor of the opponents.

#### scoreDifference
`scoreDifference`: `number`
Difference between scoreFor and scoreAgainst.

#### scoreFor
`scoreFor`: `number`
Total score in favor of the participant.

#### wins
`wins`: `number`
Number of matches won by the participant.
```

--------------------------------

### Match Interface Properties

Source: https://drarig29.github.io/brackets-docs/reference/model/interfaces/Match.html

This snippet details the properties available for the Match interface.

```APIDOC
## Interface Match
A match of a round.

### Properties
- **child_count** (number): The count of match games this match has. Can be `0` if it's a simple match, or a positive number for "Best Of" matches.
- **group_id** (Id): ID of the parent group.
- **id** (Id): ID of the match.
- **number** (number): The number of the match in its round.
- **opponent1** (null | ParticipantResult): First opponent of the match.
- **opponent2** (null | ParticipantResult): Second opponent of the match.
- **round_id** (Id): ID of the parent round.
- **stage_id** (Id): ID of the parent stage.
- **status** (Status): Status of the match.
```

--------------------------------

### selectFirst

Source: https://drarig29.github.io/brackets-docs/user-guide/storage

Selects the first match game based on the provided filter criteria.

```APIDOC
## selectFirst()

### Description
Selects the first match game that matches the given filter.

### Method Signature
`selectFirst(tableName: string, filter: object): Promise<MatchGame | null>`

### Parameters
#### Filter Parameters
- **parent_id** (Id) - Required - The parent ID to filter by.
- **number** (number) - Required - The match number to filter by.
```

--------------------------------

### transitionToMinor

Source: https://drarig29.github.io/brackets-docs/reference/manager/functions/helpers.transitionToMinor.html

Makes the transition to a minor round for duels of the previous round. The duel count stays the same.

```APIDOC
## Function transitionToMinor

### Description
Makes the transition to a minor round for duels of the previous round. The duel count stays the same.

### Parameters

*   **previousDuels** (Duel[]) - Required - The previous duels to transition from.
*   **losers** (ParticipantSlot[]) - Required - Losers from the previous major round.
*   **method** (SeedOrdering) - Optional - The ordering method for the losers.

### Returns

*   Duel[]
```

--------------------------------

### createRoundRobinGroup

Source: https://drarig29.github.io/brackets-docs/reference/manager/classes/StageCreator.html

Creates a round-robin group where each participant plays every other participant once. The system automatically determines the number of rounds needed.

```APIDOC
## createRoundRobinGroup

### Description
Creates a round-robin group.
This will make as many rounds as needed to let each participant match every other once.

### Method
createRoundRobinGroup(stageId, groupNumber, slots)

### Parameters
#### Path Parameters
* **stageId** (Id) - Required - ID of the parent stage.
* **groupNumber** (number) - Required - Number of the group in the stage.
* **slots** (ParticipantSlot[]) - Required - A list of slots.

### Returns
Promise<void>
```

--------------------------------

### Round-robin Seed Ordering

Source: https://drarig29.github.io/brackets-docs/user-guide/ordering

Use the 'groups.effort_balanced' method for round-robin tournaments to spread seeds across groups and balance strengths.

```javascript
await manager.create.stage({
  tournamentId: 1,
  name: 'Groups',
  type: 'round_robin',
  seeding: ['A','B','C','D','E','F','G','H'],
  settings: {
    groupCount: 2,
    seedOrdering: ['groups.effort_balanced'],
  },
});
```
Tokens:
Raw