Question regarding add seed to bracket

[yongshun950824]

Description:

I tried to implement that to select and add a participant (one per time) as seed. I go through the library (refer to Coding References section), and found out that I need to add exact size of seed array with the stage.settings.size which doesn't meet my implementation logic.

While I think that I can implement the add single seed logic by resetting the database and re-create the bracket as below:

var bracket;

function addSeed(name) {
  var seedings = bracket.participant.map(x => x.name);
  seedings.push(name);
  
  createBracket(bracket.stage[0], seedings);
}

function createBracket(stage, seedings) {
  window.inMemoryDatabase.reset();

  await window.bracketsManager.create({
      seeding: [],
      ... // Other configs
  });
}

For the above code, is it possible to be simplified, or any downside / bad practice if keep on reset and re-create the bracket?

Coding References:

Input.ts L12

export type Seeding = (string | number | null)[];

Update.ts Line 111

public async seeding(stageId: number, seeding: Seeding): Promise<void>

Updater.ts Line 17

protected async updateSeeding(stageId: number, seeding: Seeding | null): Promise<void> {
        ...

        if (seeding && seeding.length !== stage.settings.size)
            throw Error('The size of the seeding is incorrect.');

        ...
}

Question:

1. Is it possible to add a single seed at a time?
2. If yes, can provide hints/guidance on working for Q1?

Thanks in advance.

[Drarig29]

1. No, it's not possible to add a single seed at a time.

But you can update the seeding a better way: see docs.

You can use this method it with: window.bracketsManager.update.seeding()

And actually, I think you found a bug! 🎉

You can see the logic at creation time here:

brackets-manager.js/src/create.ts

Lines 456 to 487 in d987704

	/**
	* Returns a list of slots.
	* - If `seeding` was given, inserts them in the storage.
	* - If `size` was given, only returns a list of empty slots.
	*
	* @param positions An optional list of positions (seeds) for a manual ordering.
	*/
	public async getSlots(positions?: number[]): Promise<ParticipantSlot[]> {
	const size = this.stage.settings?.size || this.stage.seeding?.length || 0;
	helpers.ensureValidSize(size);
	if (size && !this.stage.seeding)
	return Array.from(Array(size), (_: ParticipantSlot, i) => ({ id: null, position: i + 1 }));
	if (!this.stage.seeding) throw Error('Either size or seeding must be given.');
	this.stage.settings = {
	...this.stage.settings,
	size, // Always set the size.
	};
	helpers.ensureNoDuplicates(this.stage.seeding);
	this.stage.seeding = helpers.fixSeeding(this.stage.seeding, size);
	if (this.stage.type !== 'round_robin' && this.stage.settings.balanceByes)
	this.stage.seeding = helpers.balanceByes(this.stage.seeding, this.stage.settings.size);
	if (helpers.isSeedingWithIds(this.stage.seeding))
	return this.getSlotsUsingIds(this.stage.seeding, positions);
	return this.getSlotsUsingNames(this.stage.seeding, positions);
	}

At creation time, you are not forced to give a full sized seeding: you can give an incomplete seeding array and specify the size you want. You can also set balanceByes to true (#47) and it will balance BYEs for you automatically.

So, the bug I was mentionning is that I forgot to have the same behavior as create in update. These lines prevent you from giving an incomplete seeding indeed.

Note: Currently, when your seeding is incomplete, it creates BYEs because in the library, I assume every time a bracket is created, the registrations are finished and it is ready to be started. There is not any kind of "registration time". See #59

---

So, until this bug is corrected (I'm quite busy these times), you can complete your seeding with null values (BYEs). With something like this:

brackets-manager.js/src/helpers.ts

Lines 258 to 267 in d987704

	/**
	* Sets the size of an array with a placeholder if the size is bigger.
	*
	* @param array The original array.
	* @param length The new length.
	* @param placeholder A placeholder to use to fill the empty space.
	*/
	export function setArraySize<T>(array: T[], length: number, placeholder: T): T[] {
	return Array.from(Array(length), (_, i) => array[i] || placeholder);
	}

Used like this:

const completeSeeding = setArraySize(seeding, size, null);

[yongshun950824]

Thanks for the rescue. I perform the steps that you mentioned by passing a set of array via setArraySize and it works.