courthive-components 7.0.0 → 7.1.0

package/dist/components/composition-editor/sections/colorsSection.d.ts

@@ -1,3 +1,3 @@
-import { CompositionEditorStore } from '../compositionEditorStore';
 import { EditorPanel } from '../compositionEditorTypes';
+import { CompositionEditorStore } from '../compositionEditorStore';
 export declare function buildColorsSection(store: CompositionEditorStore): EditorPanel;

package/dist/components/composition-editor/sections/layoutSection.d.ts

@@ -1,3 +1,3 @@
-import { CompositionEditorStore } from '../compositionEditorStore';
 import { EditorPanel } from '../compositionEditorTypes';
+import { CompositionEditorStore } from '../compositionEditorStore';
 export declare function buildLayoutSection(store: CompositionEditorStore): EditorPanel;

package/dist/components/renderSchematicStructure/index.d.ts

@@ -1,4 +1,4 @@
 export { renderSchematicStructure } from './renderSchematicStructure';
 export { renderSchematicRound } from './renderSchematicRound';
 export { renderSchematicMatchUp } from './renderSchematicMatchUp';
-export type { SchematicMatchUp } from './renderSchematicMatchUp';
+export type { SchematicMatchUp, SchematicOptions } from './renderSchematicMatchUp';

package/dist/components/renderSchematicStructure/renderSchematicMatchUp.d.ts

@@ -1,3 +1,26 @@
+/**
+ * The schematic's geometry and colours. Every value has a default equal to the original fixed rendering, so
+ * leaving it out changes nothing. Set on the structure root as CSS variables, which the stylesheet reads.
+ */
+export interface SchematicOptions {
+    /** height in px of one participant slot; a matchUp is two slots and a 1px divider. Default 5 */
+    slotHeight?: number;
+    /** width in px of the connector between rounds. Default 8 */
+    connectorWidth?: number;
+    /** width in px of a matchUp. Default 40 */
+    matchUpWidth?: number;
+    /** corner radius of a slot, any CSS length. Default 1px */
+    radius?: string;
+    /** connector colour, any CSS colour. Default the structure's connector colour */
+    connectorColor?: string;
+    /** slot fill, any CSS colour. Default `--chc-border-primary` */
+    slotColor?: string;
+}
+export declare const SCHEMATIC_DEFAULTS: {
+    slotHeight: number;
+    connectorWidth: number;
+    matchUpWidth: number;
+};
 export interface SchematicMatchUp {
     matchUpId: string;
     roundNumber: number;
@@ -12,10 +35,10 @@ export interface SchematicMatchUp {
     collectionId?: string;
 }
 /**
- * Renders a compact matchup: two 5px-tall slots separated by a 1px divider.
- * Total height 11px vs ~60px for the full renderMatchUp.
+ * Renders a compact matchup: two slots (5px tall by default, `slotHeight`) separated by a 1px divider.
+ * Total height 11px by default, vs ~60px for the full renderMatchUp.
  */
-export declare function renderSchematicMatchUp({ matchUp, moiety, isFirstRound, isFinalRound, isRoundRobin, roundFactor: roundFactorParam, isLucky }: {
+export declare function renderSchematicMatchUp({ matchUp, moiety, isFirstRound, isFinalRound, isRoundRobin, roundFactor: roundFactorParam, connectorWidth, slotHeight, isLucky }: {
     matchUp: SchematicMatchUp;
     moiety?: boolean;
     isFirstRound?: boolean;
@@ -28,4 +51,7 @@ export declare function renderSchematicMatchUp({ matchUp, moiety, isFirstRound,
      * Falls back to the matchUp's own factor for direct callers.
      */
     roundFactor?: number;
+    /** `SchematicOptions.slotHeight`, which the connector heights scale with */
+    slotHeight?: number;
+    connectorWidth?: number;
 }): HTMLElement;

package/dist/components/renderSchematicStructure/renderSchematicRound.d.ts

@@ -1,9 +1,9 @@
-import { SchematicMatchUp } from './renderSchematicMatchUp';
+import { SchematicMatchUp, SchematicOptions } from './renderSchematicMatchUp';
 /**
  * Renders a round column with optional simplified header (round number only)
  * and compact schematic matchups.
  */
-export declare function renderSchematicRound({ initialRoundFactor, initialRoundNumber, isFinalRound, isRoundRobin, roundNumber, matchUps, showHeader, isLucky }: {
+export declare function renderSchematicRound({ initialRoundFactor, initialRoundNumber, isFinalRound, isRoundRobin, roundNumber, matchUps, showHeader, options, isLucky }: {
     initialRoundFactor?: number;
     initialRoundNumber?: number;
     isFinalRound?: boolean;
@@ -11,5 +11,6 @@ export declare function renderSchematicRound({ initialRoundFactor, initialRoundN
     roundNumber: number;
     matchUps: SchematicMatchUp[];
     showHeader?: boolean;
+    options?: SchematicOptions;
     isLucky?: boolean;
 }): HTMLElement;

package/dist/components/renderSchematicStructure/renderSchematicStructure.d.ts

@@ -1,12 +1,14 @@
-import { SchematicMatchUp } from './renderSchematicMatchUp';
+import { SchematicMatchUp, SchematicOptions } from './renderSchematicMatchUp';
 /**
  * Compact bracket renderer showing structure shape without participant details.
  * Uses the same getRoundMatchUps() engine call as renderStructure but produces
  * a much smaller visual (~14px per matchup vs ~60px).
  */
-export declare function renderSchematicStructure({ initialRoundNumber, showHeaders, structureId, matchUps }: {
+export declare function renderSchematicStructure({ initialRoundNumber, showHeaders, structureId, matchUps, options }: {
     initialRoundNumber?: number;
     showHeaders?: boolean;
     structureId?: string;
     matchUps: SchematicMatchUp[];
+    /** geometry and colours; defaults reproduce the original rendering */
+    options?: SchematicOptions;
 }): HTMLElement;

package/dist/components/renderStructure/connectors.d.ts

@@ -0,0 +1,25 @@
+import { MatchUp } from '../../types';
+/**
+ * How a matchUp connects to the next round: `m1` / `m2` the upper / lower matchUp of a pair (the line turns
+ * down / up to their junction), `m0` straight across (a feed or qualifying round), `noProgression` the final,
+ * `mr` no connector at all (round robin, ad hoc, lucky, a search result, a tie's collection).
+ */
+export type ConnectorVariant = 'm1' | 'm2' | 'm0' | 'noProgression' | 'mr';
+export declare function connectorVariant({ searchActive, isFinalRound, matchUp, isAdHoc, isLucky, moiety }: {
+    searchActive?: boolean;
+    isFinalRound?: boolean;
+    matchUp: MatchUp;
+    isAdHoc?: boolean;
+    isLucky?: boolean;
+    moiety?: boolean;
+}): ConnectorVariant;
+/**
+ * The cell a connected matchUp sits in. A round of cells is a grid of equal rows, so a cell in the next round
+ * spans exactly the two it is fed by, and the connector is drawn from the cell as percentages of its height:
+ * no JS heights, and nothing depends on how tall a card is.
+ */
+export declare function renderConnectorCell({ connectorWidth, isFirstRound, variant }: {
+    connectorWidth?: number;
+    isFirstRound?: boolean;
+    variant: ConnectorVariant;
+}): HTMLElement;

package/dist/components/renderStructure/matchUpState.d.ts

@@ -0,0 +1,32 @@
+import { MatchUp, Side } from '../../types';
+/**
+ * Entry statuses shown beside the seed, with their abbreviation and full name. LUCKY_LOSER is absent on
+ * purpose: the name already carries an `LL` badge. Registration states (CONFIRMED, REGISTERED, ...) are
+ * not draw entries and are absent too.
+ */
+export declare const ENTRY_STATUS_LABELS: Record<string, {
+    abbr: string;
+    name: string;
+}>;
+/**
+ * The entry-status label to show for a side, or undefined. `setting` is `configuration.entryStatus`:
+ * `true` shows every status but direct acceptance, the ordinary case; `'all'` shows that too.
+ */
+export declare function entryStatusLabel(side: Side | undefined, setting: boolean | 'all' | undefined): {
+    abbr: string;
+    name: string;
+} | undefined;
+/**
+ * A seed beaten in a fully scored result by an unseeded side or a lower seed: `{ winnerSeed, loserSeed, winningSide }`,
+ * else undefined. The verdict is the factory's `getMatchUpUpset` (CA, 2026-10-26: upset belongs in the factory, played
+ * results only and only fully scored), on its default SEEDING basis.
+ */
+export declare function upsetOf(matchUp?: MatchUp): {
+    winnerSeed?: number;
+    loserSeed: number;
+    winningSide: number;
+} | undefined;
+export declare function upsetTitle(upset: {
+    winnerSeed?: number;
+    loserSeed: number;
+}): string;

package/dist/components/renderStructure/renderMatchUp.d.ts

@@ -3,6 +3,10 @@ export declare function renderMatchUp(params: {
     composition?: Composition;
     initialRoundNumber?: number;
     matchUp: MatchUp;
+    /**
+     * @deprecated The connector is drawn by the cell `renderRound` puts the matchUp in, so a matchUp no longer
+     * needs to know whether it is the upper or lower of a pair. Ignored.
+     */
     moiety?: boolean;
     selectedMatchUpId?: string;
     searchActive?: boolean;
@@ -12,9 +16,8 @@ export declare function renderMatchUp(params: {
     eventHandlers?: EventHandlers;
     className?: string;
     /**
-     * Connector-height scale for THIS render. `renderRound` computes it for the
-     * round the view currently starts at and passes it down; direct callers can
-     * leave it out and the matchUp's own factor is used.
+     * @deprecated Connector heights are no longer computed: a round is a grid of equal rows and the connector is
+     * drawn as percentages of its cell. Ignored.
      */
     roundFactor?: number;
 }): HTMLElement;

package/dist/components/renderStructure/renderMatchUpActions.d.ts

@@ -0,0 +1,14 @@
+import { Configuration, EventHandlers, MatchUp } from '../../types';
+/**
+ * `configuration.matchUpActions`: Watch and Share under the card, or undefined when neither can do anything.
+ *
+ * Watch needs a STREAM or VIDEO resource and opens it as the header icons do: `eventHandlers.onlineResourceClick`
+ * when the host gives one, else the resource's http(s) link in a new tab. Share needs `eventHandlers.matchUpShare`;
+ * a share button that did nothing would be worse than none. Clicks are properties, not listeners (TMX's morphdom
+ * carries properties across a refresh), and stop propagating so they do not also select the matchUp.
+ */
+export declare function renderMatchUpActions({ configuration, eventHandlers, matchUp }: {
+    configuration?: Configuration;
+    eventHandlers?: EventHandlers;
+    matchUp: MatchUp;
+}): HTMLElement | undefined;

package/dist/components/renderStructure/renderMatchUpInPlace.d.ts

@@ -0,0 +1,19 @@
+import { Composition, EventHandlers, MatchUp } from '../../types';
+/**
+ * Re-render one matchUp of a rendered structure and swap it in, instead of rebuilding the structure and
+ * diffing the whole tree, e.g. on a live score update. The matchUp's place in the structure (the view's first
+ * round, final / lucky / ad hoc / search) is read from what `renderMatchUp` recorded on its `.tmx-m`, so the
+ * swapped node is what a full render would have produced. Its connector belongs to the cell around it, which
+ * the swap keeps.
+ *
+ * Returns the new node, or undefined when the matchUp is not in `root`. The path index behind
+ * `configuration.pathHighlight` is built per structure render, so a path reflects the last full render.
+ */
+export declare function renderMatchUpInPlace({ selectedMatchUpId, eventHandlers, composition, favourites, matchUp, root }: {
+    selectedMatchUpId?: string;
+    eventHandlers?: EventHandlers;
+    composition?: Composition;
+    favourites?: string[] | Set<string>;
+    matchUp: MatchUp;
+    root: Element | Document;
+}): HTMLElement | undefined;

package/dist/components/renderStructure/renderOnlineResources.d.ts

@@ -0,0 +1,20 @@
+import { Configuration, EventHandlers, MatchUp, OnlineResource, OnlineResourceSubType } from '../../types';
+/** True when the matchUp carries a URL resource of subtype VIDEO or STREAM. Read for `data-has-video`. */
+export declare function hasVideo(matchUp?: MatchUp): boolean;
+/** The first URL resource of each wanted subtype, in display order. */
+export declare function getMatchUpOnlineResources(matchUp?: MatchUp, subTypes?: OnlineResourceSubType[]): OnlineResource[];
+/** Only http(s): an identifier is data from the record, and `javascript:` must never become a link. */
+export declare function isWebUrl(identifier?: string): boolean;
+/**
+ * The matchUp's online resources as icons, or `undefined` when the option is off or nothing renders.
+ *
+ * Clicks are bound as PROPERTIES (`onclick`), never with `addEventListener`: TMX refreshes a draw with
+ * morphdom, which carries handler properties across to a reused node and cannot carry listeners. Each
+ * click stops propagating, so it opens the resource without also selecting the matchUp or the schedule.
+ */
+export declare function renderOnlineResources({ configuration, eventHandlers, placement, matchUp }: {
+    configuration?: Configuration;
+    eventHandlers?: EventHandlers;
+    placement: 'schedule' | 'corner';
+    matchUp?: MatchUp;
+}): HTMLElement | undefined;

package/dist/components/renderStructure/renderParticipantDetail.d.ts

@@ -4,4 +4,4 @@ export declare function renderParticipantDetail(params: {
     individualParticipant?: IndividualParticipant;
     className?: string;
     [key: string]: any;
-}): HTMLElement;
+}): HTMLElement | undefined;

package/dist/components/renderStructure/renderRound.d.ts

@@ -1,5 +1,5 @@
 import { Composition, EventHandlers, MatchUp } from '../../types';
-export declare function renderRound({ initialRoundNumber, selectedMatchUpId, eventHandlers, isFinalRound, isRoundRobin, searchActive, composition, roundFactor, roundNumber, roundProfile, minWidth, matchUps, context, isLucky }: {
+export declare function renderRound({ initialRoundNumber, selectedMatchUpId, eventHandlers, isFinalRound, isRoundRobin, searchActive, composition, roundNumber, roundProfile, minWidth, matchUps, context, isLucky }: {
     initialRoundNumber?: number;
     selectedMatchUpId?: string;
     eventHandlers?: EventHandlers;
@@ -7,6 +7,10 @@ export declare function renderRound({ initialRoundNumber, selectedMatchUpId, eve
     isRoundRobin?: boolean;
     searchActive?: boolean;
     composition?: Composition;
+    /**
+     * @deprecated Connector heights are no longer computed (see `connectors.ts`), so there is no scale to
+     * override. Ignored.
+     */
     roundFactor?: number;
     roundNumber: number;
     roundProfile?: any;

package/dist/components/renderStructure/renderRoundHeader.d.ts

@@ -1,8 +1,9 @@
-import { EventHandlers, MatchUp } from '../../types';
-export declare function renderRoundHeader({ eventHandlers, roundMatchUps, roundProfile, roundNumber, context }: {
+import { EventHandlers, MatchUp, StructureRenderers } from '../../types';
+export declare function renderRoundHeader({ eventHandlers, roundMatchUps, roundProfile, roundNumber, renderers, context }: {
     eventHandlers?: EventHandlers;
     roundMatchUps?: MatchUp[];
     roundProfile?: any;
     roundNumber: number;
+    renderers?: StructureRenderers;
     context?: any;
 }): HTMLElement;

package/dist/components/renderStructure/renderRoundPager.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A pager for a structure rendered with `carousel`: one button per round that scrolls the carousel to it,
+ * with `aria-current` on the round in view. Mount it next to the structure; call `destroy` when the structure
+ * is removed or re-rendered, which disconnects the observer that tracks the round in view.
+ *
+ * Labels come from each round's header when it has one (`configuration.roundHeader`), else `R1`, `R2`, ...
+ */
+export declare function renderRoundPager({ behavior, structure }: {
+    behavior?: 'smooth' | 'instant' | 'auto';
+    structure: HTMLElement;
+}): {
+    element: HTMLElement;
+    destroy: () => void;
+};

package/dist/components/renderStructure/renderSchedule.d.ts

@@ -1,5 +1,12 @@
-import { EventHandlers, MatchUp } from '../../types';
-export declare function renderSchedule({ matchUp, eventHandlers }: {
-    matchUp?: MatchUp;
+import { Configuration, EventHandlers, MatchUp } from '../../types';
+export declare function renderSchedule({ configuration, eventHandlers, matchUp }: {
+    configuration?: Configuration;
     eventHandlers?: EventHandlers;
+    matchUp?: MatchUp;
 }): HTMLElement;
+/**
+ * The schedule header's date and time, compact enough not to wrap beside a court name: `Mon 26 Oct., 8:00AM`.
+ * The month is abbreviated with a period when it is shortened (`May` stays as it is), and the hour drops the
+ * leading zero and the space before AM/PM (CA, 2026-10-26: `07:30 AM` wrapped the header).
+ */
+export declare function formatScheduleDate(date: string, time?: string): string;

package/dist/components/renderStructure/renderSlot.d.ts

@@ -0,0 +1,7 @@
+import { StructureRenderers } from '../../types';
+/**
+ * Call a host's slot renderer and wrap what it returns, or return undefined when there is no renderer or it
+ * renders nothing. The host's element is wrapped, never modified: `chc-slot chc-slot--<name>` goes on the
+ * wrapper. A renderer that throws is a host defect and is left to surface.
+ */
+export declare function renderSlot<K extends keyof StructureRenderers>(renderers: StructureRenderers | undefined, name: K, ctx: Parameters<NonNullable<StructureRenderers[K]>>[0], tagName?: 'div' | 'span'): HTMLElement | undefined;

package/dist/components/renderStructure/renderStructure.d.ts

@@ -1,5 +1,5 @@
 import { Composition, EventHandlers, MatchUp } from '../../types';
-export declare function renderStructure({ initialRoundNumber, selectedMatchUpId, eventHandlers, searchActive, composition, structureId, finalColumn, matchUps, minWidth, context }: {
+export declare function renderStructure({ initialRoundNumber, selectedMatchUpId, eventHandlers, searchActive, composition, structureId, finalColumn, favourites, carousel, matchUps, minWidth, context }: {
     initialRoundNumber?: number;
     selectedMatchUpId?: string;
     eventHandlers?: EventHandlers;
@@ -7,7 +7,26 @@ export declare function renderStructure({ initialRoundNumber, selectedMatchUpId,
     composition?: Composition;
     structureId?: string;
     finalColumn?: boolean | HTMLElement;
+    /**
+     * participantIds the host pins (a pair's or an individual's): their sides take the favourite style and
+     * their matchUps carry `data-favourite`. Host state, so a parameter rather than a composition option.
+     */
+    favourites?: string[] | Set<string>;
+    /**
+     * Lay the rounds out as a horizontal carousel for narrow screens: one round per scroll-snap stop, with
+     * `peek` (default 0.2) of the next round showing, so connectors lead somewhere. Round headers move with
+     * their column. Pair it with `renderRoundPager` for a pager. The host decides when, e.g. by viewport.
+     */
+    carousel?: boolean | {
+        peek?: number;
+    };
     matchUps: MatchUp[];
     minWidth?: string;
     context?: any;
 }): HTMLElement;
+/**
+ * Mark the sides of pinned participants. A side matches on its own participantId (a pair, a team) or on any
+ * of its individuals', so pinning one player of a pair pins the pair's side. Exported for hosts that render
+ * matchUps one at a time.
+ */
+export declare function applyFavourites(root: HTMLElement, favourites?: string[] | Set<string>): void;

package/dist/components/renderStructure/renderStructureMinimap.d.ts

@@ -3,5 +3,9 @@ export interface StructureMinimapOptions {
     matchUps: MatchUp[];
     width?: number;
     quarterCount?: number;
+    /** connector line colour, any CSS colour. Default the structure's connector colour */
+    connectorColor?: string;
+    /** connector stroke width in px. Default 1 */
+    strokeWidth?: number;
 }
-export declare function buildStructureMinimap({ matchUps, width, quarterCount }: StructureMinimapOptions): HTMLDivElement | null;
+export declare function buildStructureMinimap({ matchUps, width, quarterCount, connectorColor, strokeWidth }: StructureMinimapOptions): HTMLDivElement | null;

package/dist/components/renderStructure/scoreboardState.d.ts

@@ -0,0 +1,17 @@
+import { Configuration, MatchUp, ScheduleInfoOptions } from '../../types';
+/** `configuration.scheduleInfo` in its object form; `true` (or nothing) is the plain header. */
+export declare function scheduleInfoOptions(configuration?: Configuration): ScheduleInfoOptions;
+/** The side's colour from `configuration.sideColors`, or undefined. */
+export declare function sideColorOf(configuration: Configuration | undefined, matchUp: MatchUp, sideNumber: number): string;
+export declare function isFinished(matchUp?: MatchUp): boolean;
+/** The side due to serve, while the matchUp is unfinished; undefined when nobody is tracking service. */
+export declare function servingSideOf(matchUp?: MatchUp): 1 | 2 | undefined;
+/**
+ * Playing time in milliseconds, or undefined before the matchUp starts. The factory's `schedule.milliseconds`
+ * first (it excludes suspensions); otherwise `startTime` to `endTime`, or to `now` while the matchUp is unfinished.
+ */
+export declare function elapsedOf(matchUp?: MatchUp, now?: number): number | undefined;
+/** `h:mm`: `0:16`, `1:42`, `12:05`. */
+export declare function formatElapsed(milliseconds: number): string;
+/** `Men's Singles - R32`, from what the matchUp carries; empty when it carries neither. */
+export declare function eventRoundLabel(matchUp?: MatchUp): string;

package/dist/components/renderStructure/structurePaths.d.ts

@@ -0,0 +1,21 @@
+import { MatchUp } from '../../types';
+export type ParticipantPath = {
+    /** every matchUp the participant appears in */
+    played: string[];
+    /** the matchUps the participant won: their outgoing connector is part of the path */
+    won: string[];
+    /** the matchUps ahead while the participant is still alive, by draw position */
+    projected: string[];
+};
+/**
+ * Index a structure's matchUps by participant, for path highlighting. `projectable` is false for draws whose
+ * later rounds are not reached by position (round robin, ad hoc, lucky); their paths are then the matchUps
+ * played, with nothing projected.
+ */
+export declare function buildPathIndex({ roundProfile, projectable, matchUps }: {
+    roundProfile?: Record<string, {
+        matchUpsCount?: number;
+    }>;
+    projectable: boolean;
+    matchUps: MatchUp[];
+}): (participantId: string) => ParticipantPath | undefined;