@ethlete/cdk 2.3.1

package/esm2020/lib/components/bracket/partials/bracket-round-header/bracket-round-header.component.mjs

@@ -0,0 +1,19 @@
+import { AsyncPipe, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, inject, ViewEncapsulation } from '@angular/core';
+import { BracketRoundDirective } from '../../directives';
+import * as i0 from "@angular/core";
+import * as i1 from "../../directives/bracket-round/bracket-round.directive";
+export class BracketRoundHeaderComponent {
+    constructor() {
+        this.roundData = inject(BracketRoundDirective);
+    }
+}
+BracketRoundHeaderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: BracketRoundHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+BracketRoundHeaderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.7", type: BracketRoundHeaderComponent, isStandalone: true, selector: "et-bracket-round-header", host: { classAttribute: "et-bracket-round-header" }, hostDirectives: [{ directive: i1.BracketRoundDirective }], ngImport: i0, template: "<ng-container *ngIf=\"roundData.round$ | async as round\">\n  {{ round.name }}\n</ng-container>\n", styles: [""], dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: BracketRoundHeaderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'et-bracket-round-header', standalone: true, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        class: 'et-bracket-round-header',
+                    }, imports: [AsyncPipe, NgIf], hostDirectives: [BracketRoundDirective], template: "<ng-container *ngIf=\"roundData.round$ | async as round\">\n  {{ round.name }}\n</ng-container>\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/bracket/partials/bracket-round-header/index.mjs

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvYnJhY2tldC9wYXJ0aWFscy9icmFja2V0LXJvdW5kLWhlYWRlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2020/lib/components/bracket/partials/bracket-round-header/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './bracket-round-header.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvY29tcG9uZW50cy9icmFja2V0L3BhcnRpYWxzL2JyYWNrZXQtcm91bmQtaGVhZGVyL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQ0FBa0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYnJhY2tldC1yb3VuZC1oZWFkZXIuY29tcG9uZW50JztcbiJdfQ==

package/esm2020/lib/components/bracket/partials/index.mjs

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvYnJhY2tldC9wYXJ0aWFscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2020/lib/components/bracket/partials/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './bracket-match/public-api';
+export * from './bracket-round-header/public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvY29tcG9uZW50cy9icmFja2V0L3BhcnRpYWxzL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLG1DQUFtQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9icmFja2V0LW1hdGNoL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9icmFja2V0LXJvdW5kLWhlYWRlci9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/lib/components/bracket/public-api.mjs

@@ -0,0 +1,8 @@
+export * from './bracket.imports';
+export * from './components/public-api';
+export * from './constants/public-api';
+export * from './directives/public-api';
+export * from './partials/public-api';
+export * from './types/public-api';
+export * from './utils/public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvY29tcG9uZW50cy9icmFja2V0L3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYnJhY2tldC5pbXBvcnRzJztcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vY29uc3RhbnRzL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9kaXJlY3RpdmVzL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9wYXJ0aWFscy9wdWJsaWMtYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxzL3B1YmxpYy1hcGknO1xuIl19

package/esm2020/lib/components/bracket/types/bracket-config.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJhY2tldC1jb25maWcudHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvYnJhY2tldC90eXBlcy9icmFja2V0LWNvbmZpZy50eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50VHlwZSB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9wb3J0YWwnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEJyYWNrZXRDb25maWcge1xuICByb3VuZEhlYWRlckNvbXBvbmVudDogQ29tcG9uZW50VHlwZTx1bmtub3duPiB8IG51bGw7XG4gIG1hdGNoQ29tcG9uZW50OiBDb21wb25lbnRUeXBlPHVua25vd24+O1xufVxuIl19

package/esm2020/lib/components/bracket/types/bracket.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJhY2tldC50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvY29tcG9uZW50cy9icmFja2V0L3R5cGVzL2JyYWNrZXQudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1hdGNoTGlzdFZpZXcsIFJvdW5kU3RhZ2VTdHJ1Y3R1cmVWaWV3IH0gZnJvbSAnQGV0aGxldGUvdHlwZXMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEJyYWNrZXRSb3VuZCB7XG4gIG1hdGNoQ291bnQ6IG51bWJlcjtcbiAgbmFtZTogc3RyaW5nIHwgbnVsbDtcbiAgbWF0Y2hlczogQnJhY2tldE1hdGNoW107XG4gIGRhdGE6IFJvdW5kU3RhZ2VTdHJ1Y3R1cmVWaWV3O1xuXG4gIHJvdzoge1xuICAgIHN0YXJ0OiBudW1iZXI7XG4gICAgZW5kOiBudW1iZXI7XG4gIH07XG5cbiAgY29sdW1uOiB7XG4gICAgc3RhcnQ6IG51bWJlcjtcbiAgICBlbmQ6IG51bWJlcjtcbiAgfTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBCcmFja2V0TWF0Y2gge1xuICBkYXRhOiBNYXRjaExpc3RWaWV3O1xuXG4gIHJvdzoge1xuICAgIHN0YXJ0OiBudW1iZXI7XG4gICAgZW5kOiBudW1iZXI7XG4gIH07XG5cbiAgcHJldmlvdXNNYXRjaGVzOiB7XG4gICAgcm91bmRJZDogc3RyaW5nO1xuICAgIG1hdGNoSWRzOiBzdHJpbmdbXTtcbiAgfSB8IG51bGw7XG5cbiAgbmV4dE1hdGNoOiB7XG4gICAgcm91bmRJZDogc3RyaW5nO1xuICAgIG1hdGNoSWQ6IHN0cmluZztcbiAgfSB8IG51bGw7XG59XG4iXX0=

package/esm2020/lib/components/bracket/types/index.mjs

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvYnJhY2tldC90eXBlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2020/lib/components/bracket/types/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './bracket-config.types';
+export * from './bracket.types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvY29tcG9uZW50cy9icmFja2V0L3R5cGVzL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9icmFja2V0LWNvbmZpZy50eXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL2JyYWNrZXQudHlwZXMnO1xuIl19

package/esm2020/lib/components/bracket/utils/bracket-config.utils.mjs

@@ -0,0 +1,13 @@
+import { BRACKET_CONFIG_TOKEN, BRACKET_DEFAULT_CONFIG } from '../constants';
+export const createBracketConfig = (globalConfig = {}, localConfig = {}) => ({
+    ...BRACKET_DEFAULT_CONFIG,
+    ...(globalConfig || {}),
+    ...(localConfig || {}),
+});
+export const provideBracketConfig = (config = {}) => {
+    return {
+        provide: BRACKET_CONFIG_TOKEN,
+        useValue: createBracketConfig(config),
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJhY2tldC1jb25maWcudXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvYnJhY2tldC91dGlscy9icmFja2V0LWNvbmZpZy51dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFHNUUsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsQ0FDakMsZUFBMEQsRUFBRSxFQUM1RCxjQUF5RCxFQUFFLEVBQzVDLEVBQUUsQ0FBQyxDQUFDO0lBQ25CLEdBQUcsc0JBQXNCO0lBQ3pCLEdBQUcsQ0FBQyxZQUFZLElBQUksRUFBRSxDQUFDO0lBQ3ZCLEdBQUcsQ0FBQyxXQUFXLElBQUksRUFBRSxDQUFDO0NBQ3ZCLENBQUMsQ0FBQztBQUVILE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLENBQUMsU0FBb0QsRUFBRSxFQUFFLEVBQUU7SUFDN0YsT0FBTztRQUNMLE9BQU8sRUFBRSxvQkFBb0I7UUFDN0IsUUFBUSxFQUFFLG1CQUFtQixDQUFDLE1BQU0sQ0FBQztLQUN0QyxDQUFDO0FBQ0osQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQlJBQ0tFVF9DT05GSUdfVE9LRU4sIEJSQUNLRVRfREVGQVVMVF9DT05GSUcgfSBmcm9tICcuLi9jb25zdGFudHMnO1xuaW1wb3J0IHsgQnJhY2tldENvbmZpZyB9IGZyb20gJy4uL3R5cGVzJztcblxuZXhwb3J0IGNvbnN0IGNyZWF0ZUJyYWNrZXRDb25maWcgPSAoXG4gIGdsb2JhbENvbmZpZzogUGFydGlhbDxCcmFja2V0Q29uZmlnPiB8IG51bGwgfCB1bmRlZmluZWQgPSB7fSxcbiAgbG9jYWxDb25maWc6IFBhcnRpYWw8QnJhY2tldENvbmZpZz4gfCBudWxsIHwgdW5kZWZpbmVkID0ge30sXG4pOiBCcmFja2V0Q29uZmlnID0+ICh7XG4gIC4uLkJSQUNLRVRfREVGQVVMVF9DT05GSUcsXG4gIC4uLihnbG9iYWxDb25maWcgfHwge30pLFxuICAuLi4obG9jYWxDb25maWcgfHwge30pLFxufSk7XG5cbmV4cG9ydCBjb25zdCBwcm92aWRlQnJhY2tldENvbmZpZyA9IChjb25maWc6IFBhcnRpYWw8QnJhY2tldENvbmZpZz4gfCBudWxsIHwgdW5kZWZpbmVkID0ge30pID0+IHtcbiAgcmV0dXJuIHtcbiAgICBwcm92aWRlOiBCUkFDS0VUX0NPTkZJR19UT0tFTixcbiAgICB1c2VWYWx1ZTogY3JlYXRlQnJhY2tldENvbmZpZyhjb25maWcpLFxuICB9O1xufTtcbiJdfQ==

package/esm2020/lib/components/bracket/utils/bracket.utils.mjs

@@ -0,0 +1,335 @@
+let bracketId = 0;
+export const isUpperBracketMatch = (match) => {
+    if (!match) {
+        return false;
+    }
+    return (match.round.type === 'winner_bracket' ||
+        match.round.type === 'final' ||
+        match.round.type === 'normal' ||
+        match.round.type === 'reverse_final' ||
+        !match.round.type);
+};
+export const orderRounds = (rounds) => {
+    const normalRounds = orderRoundsByRoundNumber(rounds.filter((r) => r.round.type === 'normal'));
+    const winnerRounds = orderRoundsByRoundNumber(rounds.filter((r) => r.round.type === 'winner_bracket'));
+    const loserRounds = orderRoundsByRoundNumber(rounds.filter((r) => r.round.type === 'loser_bracket'));
+    const finalRounds = rounds.filter((r) => r.round.type === 'final');
+    const reverseFinalRounds = rounds.filter((r) => r.round.type === 'reverse_final');
+    const thirdPlaceRounds = rounds.filter((r) => r.round.type === 'third_place');
+    return [...winnerRounds, ...normalRounds, ...finalRounds, ...reverseFinalRounds, ...loserRounds, ...thirdPlaceRounds];
+};
+export const orderRoundsByRoundNumber = (rounds) => {
+    return rounds.slice(0).sort((a, b) => {
+        if (a.round.number < b.round.number) {
+            return -1;
+        }
+        if (a.round.number > b.round.number) {
+            return 1;
+        }
+        return 0;
+    });
+};
+export const normalizeRoundType = (roundType) => {
+    if (!roundType) {
+        return null;
+    }
+    if (roundType === 'normal' ||
+        roundType === 'winner_bracket' ||
+        roundType === 'final' ||
+        roundType === 'reverse_final') {
+        return 'upper';
+    }
+    return 'lower';
+};
+export class Bracket {
+    get winnerRounds() {
+        return this._roundsWithMatches.filter((r) => isUpperBracketMatch(r));
+    }
+    get loserRounds() {
+        return this._roundsWithMatches.filter((r) => r.round.type === 'loser_bracket');
+    }
+    get firstWinnerRound() {
+        return this.winnerRounds[0];
+    }
+    get firstLoserRound() {
+        return (this.loserRounds[0] ?? null);
+    }
+    get winnerRoundCount() {
+        return this.winnerRounds.length;
+    }
+    get loserRoundCount() {
+        return this.loserRounds.length;
+    }
+    get bracketSize() {
+        return this.firstWinnerRound.matches.length * 2;
+    }
+    get bracketType() {
+        return !this.loserRoundCount ? 'single' : 'double';
+    }
+    get winnerBracketRowCount() {
+        return this.firstWinnerRound.matches.length;
+    }
+    get loserBracketRowCount() {
+        return this.firstLoserRound?.matches.length ?? 0;
+    }
+    get totalRowCount() {
+        return this.winnerBracketRowCount + this.loserBracketRowCount + 1;
+    }
+    get totalColCount() {
+        return this.bracketType === 'single'
+            ? this.winnerRoundCount
+            : this.loserRoundCount + (this.winnerRoundCount - this.loserRoundCount / 2) - 1;
+    }
+    get winnerRowStart() {
+        return 1;
+    }
+    get winnerRowEnd() {
+        return this.bracketType === 'single' ? this.totalRowCount : this.totalRowCount - this.winnerBracketRowCount;
+    }
+    get loserRowStart() {
+        return this.winnerBracketRowCount + 1;
+    }
+    get loserRowEnd() {
+        return this.totalRowCount;
+    }
+    get indexOfLooserRoundStart() {
+        return this._roundsWithMatches.findIndex((r) => r.round.type === 'loser_bracket');
+    }
+    get looserRowAdditionalRoundCount() {
+        if (this.bracketType === 'single') {
+            return 0;
+        }
+        const winnerRounds = this._roundsWithMatches.filter((r) => r.round.type === 'winner_bracket');
+        const winnerRoundCount = winnerRounds.length;
+        const loserRounds = this._roundsWithMatches.filter((r) => r.round.type === 'loser_bracket');
+        const loserRoundCount = loserRounds.length;
+        return loserRoundCount - winnerRoundCount;
+    }
+    get isPartialDoubleElimination() {
+        return (this.bracketType === 'double' && this.firstWinnerRound.matches.length === this.firstLoserRound?.matches.length);
+    }
+    constructor(_roundsWithMatches) {
+        this._roundsWithMatches = _roundsWithMatches;
+        this.id = bracketId++;
+        this._transformRound = (currentRound, currentRoundIndex, previousRound, nextRound) => {
+            const matchCount = currentRound.matches.length;
+            const name = currentRound.round.name;
+            const isWinnerBracket = isUpperBracketMatch(currentRound);
+            const isDoubleElimination = this.bracketType === 'double';
+            let colStart = 0;
+            let colEnd = 0;
+            let rowStart = isWinnerBracket ? this.winnerRowStart : this.loserRowStart;
+            let rowEnd = isWinnerBracket ? this.winnerRowEnd : this.loserRowEnd;
+            let firstRoundMatchCount = isWinnerBracket
+                ? this.firstWinnerRound.matches.length
+                : this.firstLoserRound?.matches.length;
+            if (isDoubleElimination) {
+                if (isWinnerBracket) {
+                    if (currentRoundIndex === 0) {
+                        // The first winner bracket round is always 1 col wide.
+                        colStart = 1;
+                        colEnd = 1;
+                    }
+                    else {
+                        const colStartDouble = currentRoundIndex * 2;
+                        const colEndDouble = colStartDouble + 1;
+                        const isSemiFinalRound = currentRound.round.type === 'winner_bracket' && matchCount === 1;
+                        // If the col end is greater than the total looser rounds, then we need to span 2 cols,
+                        // since the loser bracket will always play 2 rounds per winner bracket round.
+                        // We also need to span 2 col if the current round is the semi final round AND we have an async start.
+                        // Async start means that the first winner round's matches length is equal to the first loser round's matches length.
+                        // This is produced by only showing a part (eg. the last 5 rounds) of a much bigger bracket.
+                        if (colEndDouble < this.loserRoundCount || (isSemiFinalRound && this.isPartialDoubleElimination)) {
+                            colStart = colStartDouble;
+                            // We need to add one to the col to create a actual grid span
+                            colEnd = colEndDouble + 1;
+                        }
+                        else {
+                            // If the col end is greater than the total looser rounds, then we need to go back to 1 col wide,
+                            // since this is the point where semi finals, finals (and second chance final) are played
+                            const overshoot = colEndDouble - this.loserRoundCount;
+                            let delta = Math.floor(overshoot / 2);
+                            if (this.isPartialDoubleElimination) {
+                                delta = delta - 1;
+                            }
+                            colStart = colStartDouble - delta;
+                            colEnd = colStartDouble - delta;
+                            // If the overshoot is bigger than 1, we need to adjust the row start and end to span over the whole grid,
+                            // since we are in the final round(s).
+                            // Overshoot 1 means we are in the semi final round and there is a loser bracket round in this step (the last one).
+                            if (overshoot > 1) {
+                                rowStart = 1;
+                                rowEnd = this.totalRowCount;
+                                firstRoundMatchCount = this.totalRowCount - 1;
+                            }
+                        }
+                    }
+                }
+                else if (currentRound.round.type === 'third_place') {
+                    const hasSecondChanceFinal = this._roundsWithMatches.some((r) => r.round.type === 'reverse_final');
+                    // Span the third place match form final to second chance final
+                    if (hasSecondChanceFinal) {
+                        colStart = currentRoundIndex + 1;
+                        colEnd = currentRoundIndex + 3;
+                    }
+                    else {
+                        // Keep the third place match in the same col as the final
+                        colStart = currentRoundIndex + 1;
+                        colEnd = currentRoundIndex + 1;
+                    }
+                }
+                else {
+                    // Loser bracket rounds are always 1 col wide.
+                    colStart = currentRoundIndex + 1;
+                    colEnd = currentRoundIndex + 1;
+                }
+            }
+            else {
+                if (currentRound.round.type === 'third_place') {
+                    // The third place match is always in the same col as the final
+                    colStart = currentRoundIndex - 1;
+                    colEnd = currentRoundIndex - 1;
+                    if (this.winnerRowEnd - 1 === 2) {
+                        // Special case for 2 match brackets
+                        rowStart = 2;
+                        rowEnd = 2;
+                    }
+                    else if (this.winnerRowEnd - 1 === 4) {
+                        // Special case for 4 match brackets
+                        rowStart = 3;
+                        rowEnd = 3;
+                    }
+                    else if (this.winnerRowEnd - 1 > 4) {
+                        // Special case for 8+ match brackets. This will result in it being in the same row as the second semi final match.
+                        rowStart = (this.winnerRowEnd - 1) / 2 + (this.winnerRowEnd - 1) / 2 / 2;
+                        rowEnd = this.winnerRowEnd;
+                    }
+                }
+                else {
+                    // All other single elimination rounds are always 1 col wide.
+                    colStart = currentRoundIndex;
+                    colEnd = currentRoundIndex;
+                }
+            }
+            const matches = currentRound.matches.map((match, matchIndex) => {
+                return this._transformMatch(match, matchIndex, rowStart, matchCount, firstRoundMatchCount ?? 0, previousRound, nextRound, currentRound, currentRoundIndex);
+            });
+            return {
+                matchCount,
+                name,
+                matches,
+                data: currentRound.round,
+                row: {
+                    start: rowStart,
+                    end: rowEnd,
+                },
+                column: {
+                    start: colStart,
+                    end: colEnd,
+                },
+            };
+        };
+        this._transformMatch = (match, matchIndex, roundRowStart, matchCount, firstRoundMatchCount, previousRound, nextRound, currentRound, currentRoundIndex) => {
+            const diff = firstRoundMatchCount / matchCount;
+            let rowStart = roundRowStart + matchIndex * diff;
+            let rowEnd = rowStart + diff;
+            if (currentRound?.round.type === 'third_place' && this.bracketType === 'single') {
+                // Special case for 8+ single elimination brackets. This will result in the current match being in the same row as the second semi final match.
+                if (this.winnerRowEnd - 1 > 4) {
+                    rowStart = (this.winnerRowEnd - 1) / 2;
+                    rowEnd = this.winnerRowEnd - 1;
+                }
+            }
+            let roundsSameSize = previousRound?.matches.length === matchCount;
+            let logicalNextRound = null;
+            if ((currentRound?.round.type === 'loser_bracket' && !nextRound) ||
+                (currentRound?.round.type === 'loser_bracket' && nextRound?.round.type === 'third_place')) {
+                // Transition from last round of looser bracket to semi final round of winner bracket
+                logicalNextRound = this._roundsWithMatches[currentRoundIndex - this.looserRowAdditionalRoundCount + 1];
+            }
+            else if (((currentRound && isUpperBracketMatch(currentRound)) || !currentRound?.round.type) &&
+                nextRound?.round.type === 'loser_bracket') {
+                // The last winner round (final) does not have a next round, but the next round is the first looser round.
+                logicalNextRound = null;
+            }
+            else {
+                logicalNextRound = nextRound;
+            }
+            const previousMatchA = (roundsSameSize ? previousRound?.matches[matchIndex]?.id : previousRound?.matches[matchIndex * 2]?.id) ?? null;
+            let previousMatchB = previousRound?.matches[matchIndex * 2 + 1]?.id ?? null;
+            // previousMatchB could be the last loser bracket match
+            if (!previousMatchB && currentRound && isUpperBracketMatch(currentRound)) {
+                if (this.loserRounds.length === currentRoundIndex + this.looserRowAdditionalRoundCount) {
+                    previousMatchB = this.loserRounds[currentRoundIndex + this.looserRowAdditionalRoundCount - 1].matches[0].id;
+                    roundsSameSize = false;
+                }
+            }
+            const nextMatch = logicalNextRound?.matches[Math.floor(matchIndex / 2)]?.id ?? null;
+            let previousRoundMatches = null;
+            if (previousRound) {
+                if (roundsSameSize && previousMatchA) {
+                    // 1 match to 1 match
+                    previousRoundMatches = {
+                        roundId: previousRound.round.id,
+                        matchIds: [previousMatchA],
+                    };
+                }
+                else if (previousMatchA && previousMatchB) {
+                    // 2 matches to 1 match
+                    previousRoundMatches = {
+                        roundId: previousRound.round.id,
+                        matchIds: [previousMatchA, previousMatchB],
+                    };
+                }
+            }
+            const nextRoundMatch = nextMatch && logicalNextRound
+                ? {
+                    roundId: logicalNextRound.round.id,
+                    matchId: nextMatch,
+                }
+                : null;
+            return {
+                row: {
+                    start: rowStart,
+                    end: rowEnd,
+                },
+                data: match,
+                previousMatches: currentRound?.round.type !== 'third_place' ? previousRoundMatches : null,
+                nextMatch: currentRound?.round.type !== 'third_place' ? nextRoundMatch : null,
+            };
+        };
+        this.bracketRounds = this._computeBracket(_roundsWithMatches);
+        const rounds = this.bracketRounds.map((r) => r.matches);
+        const flatMatches = [];
+        for (const round of rounds) {
+            for (const match of round) {
+                flatMatches.push(match);
+            }
+        }
+        this._bracketMatches = flatMatches;
+    }
+    getRoundById(roundId) {
+        return this.bracketRounds.find((r) => r.data.id === roundId);
+    }
+    getMatchById(matchId) {
+        return this._bracketMatches.find((m) => m.data.id === matchId);
+    }
+    _computeBracket(data) {
+        const rounds = [];
+        for (const [index, round] of data.entries()) {
+            let relativeIndex = index;
+            if (index === this.indexOfLooserRoundStart || index > this.indexOfLooserRoundStart) {
+                relativeIndex = index - this.indexOfLooserRoundStart;
+            }
+            let previousRound = data[index - 1] ?? null;
+            const nextRound = data[index + 1] ?? null;
+            // Switching to loser bracket should reset the previousRound.
+            if (normalizeRoundType(previousRound?.round.type) !== normalizeRoundType(round.round.type)) {
+                previousRound = null;
+            }
+            rounds.push(this._transformRound(round, relativeIndex, previousRound, nextRound));
+        }
+        return rounds;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bracket.utils.js","sourceRoot":"","sources":["../../../../../../../../libs/cdk/src/lib/components/bracket/utils/bracket.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { MatchListView, RoundStageStructureWithMatchesView } from '@ethlete/types';\nimport { BracketMatch, BracketRound } from '../types';\n\nlet bracketId = 0;\n\nexport const isUpperBracketMatch = (match: RoundStageStructureWithMatchesView | null | undefined) => {\n  if (!match) {\n    return false;\n  }\n\n  return (\n    match.round.type === 'winner_bracket' ||\n    match.round.type === 'final' ||\n    match.round.type === 'normal' ||\n    match.round.type === 'reverse_final' ||\n    !match.round.type\n  );\n};\n\nexport const orderRounds = (rounds: RoundStageStructureWithMatchesView[]) => {\n  const normalRounds = orderRoundsByRoundNumber(rounds.filter((r) => r.round.type === 'normal'));\n  const winnerRounds = orderRoundsByRoundNumber(rounds.filter((r) => r.round.type === 'winner_bracket'));\n  const loserRounds = orderRoundsByRoundNumber(rounds.filter((r) => r.round.type === 'loser_bracket'));\n  const finalRounds = rounds.filter((r) => r.round.type === 'final');\n  const reverseFinalRounds = rounds.filter((r) => r.round.type === 'reverse_final');\n  const thirdPlaceRounds = rounds.filter((r) => r.round.type === 'third_place');\n\n  return [...winnerRounds, ...normalRounds, ...finalRounds, ...reverseFinalRounds, ...loserRounds, ...thirdPlaceRounds];\n};\n\nexport const orderRoundsByRoundNumber = (rounds: RoundStageStructureWithMatchesView[]) => {\n  return rounds.slice(0).sort((a, b) => {\n    if (a.round.number < b.round.number) {\n      return -1;\n    }\n    if (a.round.number > b.round.number) {\n      return 1;\n    }\n    return 0;\n  });\n};\n\nexport const normalizeRoundType = (roundType: string | null | undefined) => {\n  if (!roundType) {\n    return null;\n  }\n\n  if (\n    roundType === 'normal' ||\n    roundType === 'winner_bracket' ||\n    roundType === 'final' ||\n    roundType === 'reverse_final'\n  ) {\n    return 'upper';\n  }\n\n  return 'lower';\n};\n\nexport class Bracket {\n  get winnerRounds() {\n    return this._roundsWithMatches.filter((r) => isUpperBracketMatch(r));\n  }\n\n  get loserRounds() {\n    return this._roundsWithMatches.filter((r) => r.round.type === 'loser_bracket');\n  }\n\n  get firstWinnerRound() {\n    return this.winnerRounds[0];\n  }\n\n  get firstLoserRound() {\n    return (this.loserRounds[0] ?? null) as RoundStageStructureWithMatchesView | null;\n  }\n\n  get winnerRoundCount() {\n    return this.winnerRounds.length;\n  }\n\n  get loserRoundCount() {\n    return this.loserRounds.length;\n  }\n\n  get bracketSize() {\n    return this.firstWinnerRound.matches.length * 2;\n  }\n\n  get bracketType() {\n    return !this.loserRoundCount ? 'single' : 'double';\n  }\n\n  get winnerBracketRowCount() {\n    return this.firstWinnerRound.matches.length;\n  }\n\n  get loserBracketRowCount() {\n    return this.firstLoserRound?.matches.length ?? 0;\n  }\n\n  get totalRowCount() {\n    return this.winnerBracketRowCount + this.loserBracketRowCount + 1;\n  }\n\n  get totalColCount() {\n    return this.bracketType === 'single'\n      ? this.winnerRoundCount\n      : this.loserRoundCount + (this.winnerRoundCount - this.loserRoundCount / 2) - 1;\n  }\n\n  get winnerRowStart() {\n    return 1;\n  }\n\n  get winnerRowEnd() {\n    return this.bracketType === 'single' ? this.totalRowCount : this.totalRowCount - this.winnerBracketRowCount;\n  }\n\n  get loserRowStart() {\n    return this.winnerBracketRowCount + 1;\n  }\n\n  get loserRowEnd() {\n    return this.totalRowCount;\n  }\n\n  get indexOfLooserRoundStart() {\n    return this._roundsWithMatches.findIndex((r) => r.round.type === 'loser_bracket');\n  }\n\n  get looserRowAdditionalRoundCount() {\n    if (this.bracketType === 'single') {\n      return 0;\n    }\n\n    const winnerRounds = this._roundsWithMatches.filter((r) => r.round.type === 'winner_bracket');\n    const winnerRoundCount = winnerRounds.length;\n    const loserRounds = this._roundsWithMatches.filter((r) => r.round.type === 'loser_bracket');\n    const loserRoundCount = loserRounds.length;\n\n    return loserRoundCount - winnerRoundCount;\n  }\n\n  get isPartialDoubleElimination() {\n    return (\n      this.bracketType === 'double' && this.firstWinnerRound.matches.length === this.firstLoserRound?.matches.length\n    );\n  }\n\n  readonly bracketRounds: BracketRound[];\n  readonly id = bracketId++;\n\n  private readonly _bracketMatches: BracketMatch[];\n\n  constructor(private _roundsWithMatches: RoundStageStructureWithMatchesView[]) {\n    this.bracketRounds = this._computeBracket(_roundsWithMatches);\n\n    const rounds = this.bracketRounds.map((r) => r.matches);\n    const flatMatches: BracketMatch[] = [];\n\n    for (const round of rounds) {\n      for (const match of round) {\n        flatMatches.push(match);\n      }\n    }\n\n    this._bracketMatches = flatMatches;\n  }\n\n  getRoundById(roundId: string) {\n    return this.bracketRounds.find((r) => r.data.id === roundId);\n  }\n\n  getMatchById(matchId: string) {\n    return this._bracketMatches.find((m) => m.data.id === matchId);\n  }\n\n  private _computeBracket(data: RoundStageStructureWithMatchesView[]) {\n    const rounds: BracketRound[] = [];\n\n    for (const [index, round] of data.entries()) {\n      let relativeIndex = index;\n\n      if (index === this.indexOfLooserRoundStart || index > this.indexOfLooserRoundStart) {\n        relativeIndex = index - this.indexOfLooserRoundStart;\n      }\n\n      let previousRound: RoundStageStructureWithMatchesView | null = data[index - 1] ?? null;\n      const nextRound: RoundStageStructureWithMatchesView | null = data[index + 1] ?? null;\n\n      // Switching to loser bracket should reset the previousRound.\n      if (normalizeRoundType(previousRound?.round.type) !== normalizeRoundType(round.round.type)) {\n        previousRound = null;\n      }\n\n      rounds.push(this._transformRound(round, relativeIndex, previousRound, nextRound));\n    }\n\n    return rounds;\n  }\n\n  private _transformRound = (\n    currentRound: RoundStageStructureWithMatchesView,\n    currentRoundIndex: number,\n    previousRound: RoundStageStructureWithMatchesView | null,\n    nextRound: RoundStageStructureWithMatchesView | null,\n  ): BracketRound => {\n    const matchCount = currentRound.matches.length;\n    const name = currentRound.round.name;\n    const isWinnerBracket = isUpperBracketMatch(currentRound);\n    const isDoubleElimination = this.bracketType === 'double';\n\n    let colStart = 0;\n    let colEnd = 0;\n\n    let rowStart = isWinnerBracket ? this.winnerRowStart : this.loserRowStart;\n    let rowEnd = isWinnerBracket ? this.winnerRowEnd : this.loserRowEnd;\n    let firstRoundMatchCount = isWinnerBracket\n      ? this.firstWinnerRound.matches.length\n      : this.firstLoserRound?.matches.length;\n\n    if (isDoubleElimination) {\n      if (isWinnerBracket) {\n        if (currentRoundIndex === 0) {\n          // The first winner bracket round is always 1 col wide.\n          colStart = 1;\n          colEnd = 1;\n        } else {\n          const colStartDouble = currentRoundIndex * 2;\n          const colEndDouble = colStartDouble + 1;\n          const isSemiFinalRound = currentRound.round.type === 'winner_bracket' && matchCount === 1;\n\n          // If the col end is greater than the total looser rounds, then we need to span 2 cols,\n          // since the loser bracket will always play 2 rounds per winner bracket round.\n          // We also need to span 2 col if the current round is the semi final round AND we have an async start.\n          // Async start means that the first winner round's matches length is equal to the first loser round's matches length.\n          // This is produced by only showing a part (eg. the last 5 rounds) of a much bigger bracket.\n          if (colEndDouble < this.loserRoundCount || (isSemiFinalRound && this.isPartialDoubleElimination)) {\n            colStart = colStartDouble;\n\n            // We need to add one to the col to create a actual grid span\n            colEnd = colEndDouble + 1;\n          } else {\n            // If the col end is greater than the total looser rounds, then we need to go back to 1 col wide,\n            // since this is the point where semi finals, finals (and second chance final) are played\n            const overshoot = colEndDouble - this.loserRoundCount;\n            let delta = Math.floor(overshoot / 2);\n\n            if (this.isPartialDoubleElimination) {\n              delta = delta - 1;\n            }\n\n            colStart = colStartDouble - delta;\n            colEnd = colStartDouble - delta;\n\n            // If the overshoot is bigger than 1, we need to adjust the row start and end to span over the whole grid,\n            // since we are in the final round(s).\n            // Overshoot 1 means we are in the semi final round and there is a loser bracket round in this step (the last one).\n            if (overshoot > 1) {\n              rowStart = 1;\n              rowEnd = this.totalRowCount;\n              firstRoundMatchCount = this.totalRowCount - 1;\n            }\n          }\n        }\n      } else if (currentRound.round.type === 'third_place') {\n        const hasSecondChanceFinal = this._roundsWithMatches.some((r) => r.round.type === 'reverse_final');\n\n        // Span the third place match form final to second chance final\n        if (hasSecondChanceFinal) {\n          colStart = currentRoundIndex + 1;\n          colEnd = currentRoundIndex + 3;\n        } else {\n          // Keep the third place match in the same col as the final\n          colStart = currentRoundIndex + 1;\n          colEnd = currentRoundIndex + 1;\n        }\n      } else {\n        // Loser bracket rounds are always 1 col wide.\n        colStart = currentRoundIndex + 1;\n        colEnd = currentRoundIndex + 1;\n      }\n    } else {\n      if (currentRound.round.type === 'third_place') {\n        // The third place match is always in the same col as the final\n        colStart = currentRoundIndex - 1;\n        colEnd = currentRoundIndex - 1;\n\n        if (this.winnerRowEnd - 1 === 2) {\n          // Special case for 2 match brackets\n          rowStart = 2;\n          rowEnd = 2;\n        } else if (this.winnerRowEnd - 1 === 4) {\n          // Special case for 4 match brackets\n          rowStart = 3;\n          rowEnd = 3;\n        } else if (this.winnerRowEnd - 1 > 4) {\n          // Special case for 8+ match brackets. This will result in it being in the same row as the second semi final match.\n          rowStart = (this.winnerRowEnd - 1) / 2 + (this.winnerRowEnd - 1) / 2 / 2;\n          rowEnd = this.winnerRowEnd;\n        }\n      } else {\n        // All other single elimination rounds are always 1 col wide.\n        colStart = currentRoundIndex;\n        colEnd = currentRoundIndex;\n      }\n    }\n\n    const matches = currentRound.matches.map((match, matchIndex) => {\n      return this._transformMatch(\n        match,\n        matchIndex,\n        rowStart,\n        matchCount,\n        firstRoundMatchCount ?? 0,\n        previousRound,\n        nextRound,\n        currentRound,\n        currentRoundIndex,\n      );\n    });\n\n    return {\n      matchCount,\n      name,\n      matches,\n      data: currentRound.round,\n\n      row: {\n        start: rowStart,\n        end: rowEnd,\n      },\n      column: {\n        start: colStart,\n        end: colEnd,\n      },\n    };\n  };\n\n  private _transformMatch = (\n    match: MatchListView,\n    matchIndex: number,\n    roundRowStart: number,\n    matchCount: number,\n    firstRoundMatchCount: number,\n    previousRound: RoundStageStructureWithMatchesView | null,\n    nextRound: RoundStageStructureWithMatchesView | null,\n    currentRound: RoundStageStructureWithMatchesView | null,\n    currentRoundIndex: number,\n  ): BracketMatch => {\n    const diff = firstRoundMatchCount / matchCount;\n\n    let rowStart = roundRowStart + matchIndex * diff;\n    let rowEnd = rowStart + diff;\n\n    if (currentRound?.round.type === 'third_place' && this.bracketType === 'single') {\n      // Special case for 8+ single elimination brackets. This will result in the current match being in the same row as the second semi final match.\n      if (this.winnerRowEnd - 1 > 4) {\n        rowStart = (this.winnerRowEnd - 1) / 2;\n        rowEnd = this.winnerRowEnd - 1;\n      }\n    }\n\n    let roundsSameSize = previousRound?.matches.length === matchCount;\n    let logicalNextRound: RoundStageStructureWithMatchesView | null = null;\n\n    if (\n      (currentRound?.round.type === 'loser_bracket' && !nextRound) ||\n      (currentRound?.round.type === 'loser_bracket' && nextRound?.round.type === 'third_place')\n    ) {\n      // Transition from last round of looser bracket to semi final round of winner bracket\n      logicalNextRound = this._roundsWithMatches[currentRoundIndex - this.looserRowAdditionalRoundCount + 1];\n    } else if (\n      ((currentRound && isUpperBracketMatch(currentRound)) || !currentRound?.round.type) &&\n      nextRound?.round.type === 'loser_bracket'\n    ) {\n      // The last winner round (final) does not have a next round, but the next round is the first looser round.\n      logicalNextRound = null;\n    } else {\n      logicalNextRound = nextRound;\n    }\n\n    const previousMatchA =\n      (roundsSameSize ? previousRound?.matches[matchIndex]?.id : previousRound?.matches[matchIndex * 2]?.id) ?? null;\n    let previousMatchB = previousRound?.matches[matchIndex * 2 + 1]?.id ?? null;\n\n    // previousMatchB could be the last loser bracket match\n    if (!previousMatchB && currentRound && isUpperBracketMatch(currentRound)) {\n      if (this.loserRounds.length === currentRoundIndex + this.looserRowAdditionalRoundCount) {\n        previousMatchB = this.loserRounds[currentRoundIndex + this.looserRowAdditionalRoundCount - 1].matches[0].id;\n        roundsSameSize = false;\n      }\n    }\n\n    const nextMatch = logicalNextRound?.matches[Math.floor(matchIndex / 2)]?.id ?? null;\n\n    let previousRoundMatches = null;\n\n    if (previousRound) {\n      if (roundsSameSize && previousMatchA) {\n        // 1 match to 1 match\n        previousRoundMatches = {\n          roundId: previousRound.round.id,\n          matchIds: [previousMatchA],\n        };\n      } else if (previousMatchA && previousMatchB) {\n        // 2 matches to 1 match\n        previousRoundMatches = {\n          roundId: previousRound.round.id,\n          matchIds: [previousMatchA, previousMatchB],\n        };\n      }\n    }\n\n    const nextRoundMatch =\n      nextMatch && logicalNextRound\n        ? {\n            roundId: logicalNextRound.round.id,\n            matchId: nextMatch,\n          }\n        : null;\n\n    return {\n      row: {\n        start: rowStart,\n        end: rowEnd,\n      },\n      data: match,\n\n      previousMatches: currentRound?.round.type !== 'third_place' ? previousRoundMatches : null,\n      nextMatch: currentRound?.round.type !== 'third_place' ? nextRoundMatch : null,\n    };\n  };\n}\n"]}

package/esm2020/lib/components/bracket/utils/index.mjs

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvYnJhY2tldC91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2020/lib/components/bracket/utils/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './bracket-config.utils';
+export * from './bracket.utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvY29tcG9uZW50cy9icmFja2V0L3V0aWxzL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9icmFja2V0LWNvbmZpZy51dGlscyc7XG5leHBvcnQgKiBmcm9tICcuL2JyYWNrZXQudXRpbHMnO1xuIl19

package/esm2020/lib/components/button/button.imports.mjs

@@ -0,0 +1,3 @@
+import { ButtonComponent, QueryButtonComponent } from './components';
+export const ButtonImports = [ButtonComponent, QueryButtonComponent];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnV0dG9uLmltcG9ydHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvYnV0dG9uL2J1dHRvbi5pbXBvcnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFckUsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLENBQUMsZUFBZSxFQUFFLG9CQUFvQixDQUFVLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCdXR0b25Db21wb25lbnQsIFF1ZXJ5QnV0dG9uQ29tcG9uZW50IH0gZnJvbSAnLi9jb21wb25lbnRzJztcblxuZXhwb3J0IGNvbnN0IEJ1dHRvbkltcG9ydHMgPSBbQnV0dG9uQ29tcG9uZW50LCBRdWVyeUJ1dHRvbkNvbXBvbmVudF0gYXMgY29uc3Q7XG4iXX0=

package/esm2020/lib/components/button/components/button/button.component.mjs

@@ -0,0 +1,18 @@
+import { ChangeDetectionStrategy, Component, ViewEncapsulation, inject } from '@angular/core';
+import { ButtonDirective } from '../../directives';
+import * as i0 from "@angular/core";
+import * as i1 from "../../directives/button/button.directive";
+export class ButtonComponent {
+    constructor() {
+        this.button = inject(ButtonDirective);
+    }
+}
+ButtonComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ButtonComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.7", type: ButtonComponent, isStandalone: true, selector: "[et-button]", host: { classAttribute: "et-button" }, hostDirectives: [{ directive: i1.ButtonDirective, inputs: ["disabled", "disabled", "type", "type", "pressed", "pressed"] }], ngImport: i0, template: "<span class=\"et-button-content\">\n  <span class=\"et-button-text\">\n    <ng-content></ng-content>\n  </span>\n</span>\n", styles: [""], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[et-button]', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, hostDirectives: [{ directive: ButtonDirective, inputs: ['disabled', 'type', 'pressed'] }], host: {
+                        class: 'et-button',
+                    }, template: "<span class=\"et-button-content\">\n  <span class=\"et-button-text\">\n    <ng-content></ng-content>\n  </span>\n</span>\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/button/components/button/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './button.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvY29tcG9uZW50cy9idXR0b24vY29tcG9uZW50cy9idXR0b24vcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9idXR0b24uY29tcG9uZW50JztcbiJdfQ==

package/esm2020/lib/components/button/components/index.mjs

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL2NvbXBvbmVudHMvYnV0dG9uL2NvbXBvbmVudHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2020/lib/components/button/components/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './button/public-api';
+export * from './query-button/public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvY29tcG9uZW50cy9idXR0b24vY29tcG9uZW50cy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYnV0dG9uL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9xdWVyeS1idXR0b24vcHVibGljLWFwaSc7XG4iXX0=

package/esm2020/lib/components/button/components/query-button/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './query-button.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvY29tcG9uZW50cy9idXR0b24vY29tcG9uZW50cy9xdWVyeS1idXR0b24vcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9xdWVyeS1idXR0b24uY29tcG9uZW50JztcbiJdfQ==

package/esm2020/lib/components/button/components/query-button/query-button.component.mjs

@@ -0,0 +1,25 @@
+import { AsyncPipe, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ViewEncapsulation, inject } from '@angular/core';
+import { LetDirective } from '@ethlete/core';
+import { QueryDirective } from '@ethlete/query';
+import { ButtonDirective, QueryButtonDirective } from '../../directives';
+import * as i0 from "@angular/core";
+import * as i1 from "../../directives/query-button/query-button.directive";
+import * as i2 from "../../directives/button/button.directive";
+export class QueryButtonComponent {
+    constructor() {
+        this.queryButton = inject(QueryButtonDirective);
+    }
+}
+QueryButtonComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: QueryButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+QueryButtonComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.7", type: QueryButtonComponent, isStandalone: true, selector: "[et-query-button]", host: { classAttribute: "et-query-button" }, hostDirectives: [{ directive: i1.QueryButtonDirective, inputs: ["query", "query"] }, { directive: i2.ButtonDirective, inputs: ["disabled", "disabled", "type", "type", "pressed", "pressed"] }], ngImport: i0, template: "<ng-container *etLet=\"queryButton.showSuccess$ | async as showSuccess\">\n  <ng-container *etLet=\"queryButton.showFailure$ | async as showFailure\">\n    <span *etQuery=\"queryButton.query$ | async; loading as loading\" class=\"et-button-content et-query-button-content\">\n      <span\n        [attr.aria-hidden]=\"loading || showSuccess || showFailure ? 'true' : undefined\"\n        class=\"et-button-text et-query-button-text et-query-button-text--default\"\n      >\n        <ng-content></ng-content>\n      </span>\n\n      <span *ngIf=\"loading\" class=\"et-query-button-loading\"> </span>\n      <span *ngIf=\"loading\" class=\"et-button-text et-query-button-text et-query-button-text--loading\">Loading</span>\n\n      <span *ngIf=\"showSuccess\" class=\"et-button-text et-query-button-text et-query-button-text--success\">Success</span>\n      <span *ngIf=\"showFailure\" class=\"et-button-text et-query-button-text et-query-button-text--failure\">Failure</span>\n    </span>\n  </ng-container>\n</ng-container>\n", styles: [".et-query-button .et-button-content{display:grid}.et-query-button .et-query-button-text,.et-query-button .et-query-button-loading{grid-area:1/1/2/2}.et-query-button.et-query-button--loading .et-query-button-text--default,.et-query-button.et-query-button--success .et-query-button-text--default,.et-query-button.et-query-button--failure .et-query-button-text--default{opacity:0;-webkit-user-select:none;user-select:none}\n"], dependencies: [{ kind: "directive", type: QueryDirective, selector: "[etQuery]", inputs: ["etQuery", "etQueryCache"] }, { kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: LetDirective, selector: "[etLet]", inputs: ["etLet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: QueryButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[et-query-button]', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, hostDirectives: [
+                        { directive: QueryButtonDirective, inputs: ['query'] },
+                        { directive: ButtonDirective, inputs: ['disabled', 'type', 'pressed'] },
+                    ], imports: [QueryDirective, AsyncPipe, NgIf, LetDirective], host: {
+                        class: 'et-query-button',
+                    }, template: "<ng-container *etLet=\"queryButton.showSuccess$ | async as showSuccess\">\n  <ng-container *etLet=\"queryButton.showFailure$ | async as showFailure\">\n    <span *etQuery=\"queryButton.query$ | async; loading as loading\" class=\"et-button-content et-query-button-content\">\n      <span\n        [attr.aria-hidden]=\"loading || showSuccess || showFailure ? 'true' : undefined\"\n        class=\"et-button-text et-query-button-text et-query-button-text--default\"\n      >\n        <ng-content></ng-content>\n      </span>\n\n      <span *ngIf=\"loading\" class=\"et-query-button-loading\"> </span>\n      <span *ngIf=\"loading\" class=\"et-button-text et-query-button-text et-query-button-text--loading\">Loading</span>\n\n      <span *ngIf=\"showSuccess\" class=\"et-button-text et-query-button-text et-query-button-text--success\">Success</span>\n      <span *ngIf=\"showFailure\" class=\"et-button-text et-query-button-text et-query-button-text--failure\">Failure</span>\n    </span>\n  </ng-container>\n</ng-container>\n", styles: [".et-query-button .et-button-content{display:grid}.et-query-button .et-query-button-text,.et-query-button .et-query-button-loading{grid-area:1/1/2/2}.et-query-button.et-query-button--loading .et-query-button-text--default,.et-query-button.et-query-button--success .et-query-button-text--default,.et-query-button.et-query-button--failure .et-query-button-text--default{opacity:0;-webkit-user-select:none;user-select:none}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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