courthive-components 6.14.0 → 7.1.0

package/README.md

@@ -40,7 +40,7 @@ Update a budget deliberately with `pnpm verify:consumer-bundle --update-baseline
 ## Quick Start
 
 ```javascript
-import { renderMatchUp, scoringModal, compositions } from 'courthive-components';
+import { renderMatchUp, openScoreEntryDialog, compositions } from 'courthive-components';
 
 // Render a match display
 const matchUpElement = renderMatchUp({
@@ -49,11 +49,12 @@ const matchUpElement = renderMatchUp({
 });
 document.getElementById('container').appendChild(matchUpElement);
 
-// Open scoring modal
-scoringModal({
+// Open the score entry dialog
+openScoreEntryDialog({
   matchUp: myMatchUpData,
-  callback: (outcome) => {
-    console.log('Score submitted:', outcome);
+  sides: [{ participantName: 'Ann' }, { participantName: 'Bea' }],
+  onSubmit: ({ outcome }) => {
+    console.log('Engine-ready outcome:', outcome);
   }
 });
 ```
@@ -167,30 +168,24 @@ cModal.open({
 });
 ```
 
-#### **scoringModal**
+#### **openScoreEntryDialog**
 
-Two scoring APIs remain supported. New integrations should use `openScoreEntryDialog`
-(the shared model/store-based card dialog); see `src/components/scoring/TMX_INTEGRATION.md`
-for its engine-outcome handoff. TMX chooses between it and `scoringModal` through a feature flag.
-`scoringModal` below is the existing configurable modal API. Their callback contracts differ.
-
-Interactive score entry with multiple input approaches.
+Score entry in a modal: three interchangeable approaches over one card, a live format picker,
+irregular endings with their policy reason codes, and reopening a recorded outcome.
 
 ```javascript
-import { scoringModal, setScoringConfig } from 'courthive-components';
-
-// Configure scoring behavior
-setScoringConfig({
-  scoringApproach: 'dynamicSets', // 'dynamicSets' | 'freeScore' | 'dialPad'
-  smartComplements: true,
-  composition: 'Australian'
-});
-
-// Open scoring modal
-scoringModal({
-  matchUp: matchUpData,
-  callback: (outcome) => {
-    // outcome: { isValid, sets, winningSide, matchUpStatus }
+import { openScoreEntryDialog } from 'courthive-components';
+
+openScoreEntryDialog({
+  matchUp, // prefills a recorded outcome: matchUp.score.sets, matchUpStatus, winningSide
+  sides: [{ participantName: 'Ann', seed: '1' }, { participantName: 'Bea' }],
+  approach: 'dynamicSets', // 'dynamicSets' | 'freeScore' | 'dialPad'; the operator can switch in the dialog
+  statusCodeGroups, // the scoring policy's matchUpStatusCodes; omit and no reason chips are drawn
+  clearable: true, // false when a later match depends on the result, so an empty submit is refused
+  disabledMatchUpStatuses: [], // statuses the engine's SCORE action refuses for this matchUp
+  onApproachChange: (approach) => savePreference(approach),
+  onSubmit: ({ outcome, sets }) => {
+    // outcome is engine-ready: hand it to setMatchUpStatus as is
   }
 });
 ```
@@ -394,7 +389,7 @@ Components are designed to work with TODS (Tennis Open Data Standards) data stru
 
 ```javascript
 import { tournamentEngine } from 'tods-competition-factory';
-import { renderMatchUp, scoringModal } from 'courthive-components';
+import { renderMatchUp, openScoreEntryDialog } from 'courthive-components';
 
 // Get match data from factory
 const { matchUp } = tournamentEngine.findMatchUp({ matchUpId });
@@ -402,19 +397,12 @@ const { matchUp } = tournamentEngine.findMatchUp({ matchUpId });
 // Render with components
 const display = renderMatchUp({ matchUp });
 
-// Score with modal
-scoringModal({
+// Score with the dialog; its outcome is already the shape setMatchUpStatus reads
+openScoreEntryDialog({
   matchUp,
-  callback: (outcome) => {
-    // Update tournament using factory
-    tournamentEngine.setMatchUpStatus({
-      matchUpId,
-      outcome: {
-        score: { sets: outcome.sets },
-        winningSide: outcome.winningSide,
-        matchUpStatus: outcome.matchUpStatus
-      }
-    });
+  sides: matchUp.sides.map((side) => ({ participantName: side.participant?.participantName ?? '' })),
+  onSubmit: ({ outcome }) => {
+    tournamentEngine.setMatchUpStatus({ matchUpId, drawId: matchUp.drawId, outcome });
   }
 });
 ```

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;

package/dist/components/scoring/logic/irregularEnding.d.ts

@@ -177,7 +177,7 @@ export declare function supportsNeitherSide(selectedOutcome: string | undefined)
  * nobody and propagates a walkover into the next round — so the modal says what it will do before it
  * is submitted rather than after.
  */
-export declare function doubleExitWarning(selectedOutcome: string | undefined): string;
+export declare function doubleExitWarning(selectedOutcome: string | undefined, labels?: Record<string, string | undefined>): string;
 export type IrregularEndingResolution = {
     /** The status to submit. `undefined` while the selection is incomplete. */
     matchUpStatus?: string;

package/dist/components/scoring/logic/scoreEntrySelectors.d.ts

@@ -53,6 +53,8 @@ export declare function matchUpStatus(model: ScoreEntryModel): string | undefine
 export type ErrorOptions = {
     /** Names for the two sides, so a message can say who rather than "side 1". */
     sideNames?: [string, string];
+    /** The host's translations (see `SCORE_ENTRY_TEXT`). */
+    labels?: Record<string, string | undefined>;
 };
 export declare function error(model: ScoreEntryModel, options?: ErrorOptions): string | undefined;
 /**

package/dist/components/scoring/logic/scoreEntryText.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Every word the score entry dialog shows, in English, keyed so a host can translate it.
+ *
+ * A host passes translations through the dialog's `labels`, the same map that already carries the
+ * status names (`RETIRED`, `WALKOVER`, …) and `statusUnavailable`. A key the host leaves out reads the
+ * English below, so a partial translation degrades to English for the missing words rather than to a
+ * key name or a blank.
+ *
+ * Placeholders are `{{name}}`, the i18next form, so a host using i18next can hand its catalog's strings
+ * over untouched (`t(key, { skipInterpolation: true })`) and the dialog fills them in. Status names fill
+ * `{{status}}` already translated, because they come from the same map.
+ *
+ * Two placeholders exist only for translators: set messages carry both `{{ordinal}}` (`1st`, English
+ * only) and `{{number}}` (`1`). English uses the ordinal; a language that has no `1st` uses the number.
+ *
+ * Score strings (`6-4 6-3`), format codes and participant names are data and are never translated here.
+ * Messages the factory itself returns (a set the engine refuses, a parse error) arrive in the factory's
+ * words.
+ */
+export declare const SCORE_ENTRY_TEXT: {
+    readonly title: "Score Entry";
+    readonly submit: "Submit";
+    readonly clear: "Clear";
+    readonly cancel: "Cancel";
+    readonly player: "PLAYER";
+    readonly formatEditTitle: "Edit the scoring format";
+    readonly formatEditAria: "Scoring format {{format}} — edit";
+    readonly approachDynamicSets: "Dynamic Sets";
+    readonly approachFreeScore: "Free Score";
+    readonly approachDialPad: "Dial Pad";
+    readonly other: "Other…";
+    readonly otherBase: "Other";
+    readonly endedEarlyTitle: "How did this match end for them?";
+    readonly endedEarlyAria: "{{name}} — ended early";
+    readonly sidePanelHead: "What happened to {{name}}?";
+    readonly hintWalkover: "Did not play at all — no score";
+    readonly hintRetired: "Started, could not finish — score kept";
+    readonly hintDefaulted: "Removed by the referee";
+    readonly reason: "REASON";
+    readonly bothSidesOut: "{{name}} did not appear either — no one advances";
+    readonly endingNeedsScore: "No score yet — {{status}} keeps the score that was played";
+    readonly endingAfterCompleteScore: "The score is complete — {{status}} cannot follow it";
+    readonly doubleWalkover: "Double walkover";
+    readonly doubleDefault: "Double default";
+    readonly doubleExitWarning: "{{ending}} — neither side advances, and a walkover propagates to the next round.";
+    readonly defeated: "{{winner}} def. {{loser}} {{score}}";
+    readonly advancesTo: "advances to {{round}}";
+    readonly notFinished: "{{score}} — not a finished result";
+    readonly noResultYet: "No result entered yet";
+    readonly neitherAdvances: "{{status}} — neither side advances";
+    readonly sideAdvances: "{{status}} — {{name}} advances";
+    readonly noScoreRecorded: "no score recorded";
+    readonly partScoreCleared: "{{status}} — the part-score of {{score}} has been cleared";
+    readonly nobodyAdvances: "nobody advances";
+    readonly scoreRecorded: "{{status}} — {{score}} recorded";
+    readonly noWinnerYet: "{{status}} — no winner yet";
+    readonly notReadyToSubmit: "not ready to submit";
+    readonly clearedHeadline: "The recorded result will be removed — Submit to clear it.";
+    readonly clearRefused: "Enter a replacement score: a later match depends on this result.";
+    readonly setPrefix: "{{ordinal}} set:";
+    readonly sideFallback: "side {{side}}";
+    readonly tiebreakContradiction: "{{set}} {{name}} won it, so they must win the tiebreak";
+    readonly setHasNoScore: "{{set}} has no score";
+    readonly setNotFinished: "{{set}} is not finished";
+    readonly setHeading: "{{ordinal}}";
+    readonly tiebreakHeading: "TB";
+    readonly editSet: "Click to edit this set";
+    readonly gamesAria: "{{ordinal}} set, side {{side}} games";
+    readonly tiebreakAria: "{{ordinal}} set tiebreak, side {{side}} points";
+    readonly enteredSetAria: "{{ordinal}} set, side {{side}}: {{entered}} — edit";
+    readonly gamesEntered: "{{games}} games";
+    readonly gamesAndTiebreakEntered: "{{games}} games, tiebreak {{points}}";
+    readonly tiebreakSpoken: "tiebreak {{points}}";
+    readonly smartComplements: "Smart";
+    readonly smartComplementsExplain: "Smart complements — fill the opposing score from the one you type";
+    readonly typeTheScore: "TYPE THE SCORE";
+    readonly notAScore: "Not a score this format allows";
+    readonly completeMatch: "A complete match under {{format}}";
+    readonly tiebreak: "Tiebreak";
+    readonly backspace: "Backspace";
+    readonly readoutAria: "Side {{side}}: {{score}}";
+    readonly readoutNoScore: "Side {{side}}: no score";
+};
+export type ScoreEntryTextKey = keyof typeof SCORE_ENTRY_TEXT;
+/** A host's translations: any of the keys above, plus the status names, each optional. */
+export type ScoreEntryLabels = Partial<Record<ScoreEntryTextKey, string>> & Record<string, string | undefined>;
+/**
+ * The host's string for `key`, or the English, with `{{placeholders}}` filled.
+ *
+ * A placeholder with no value is left as written, so a missing variable shows up as `{{name}}` in
+ * review rather than vanishing from the sentence.
+ */
+export declare function scoreEntryText(labels: Record<string, string | undefined> | undefined, key: ScoreEntryTextKey, values?: Record<string, string | number | undefined>): string;