courthive-components 6.4.2 → 6.5.1

package/dist/components/inline-scoring/inlineScoringManager.d.ts

@@ -1,5 +1,5 @@
-import { MatchUp } from '../../types';
 import { InlineScoringCallbacks, InlineScoringEngineState } from './inlineScoringTypes';
+import { MatchUp } from '../../types';
 /**
  * Manages ScoringEngine instances for inline scoring in draw brackets.
  * One engine per matchUpId; lazily created on first interaction.

package/dist/components/inline-scoring/inlineScoringTypes.d.ts

@@ -16,9 +16,10 @@ export interface InlineScoringCallbacks {
         matchUp: MatchUp;
         engine: any;
     }) => void;
+    /** `winningSide` is absent when a combined-point total ends level (a tie is a finished result). */
     onMatchComplete?: (params: {
         matchUpId: string;
-        winningSide: number;
+        winningSide?: number;
         engine: any;
     }) => void;
     onEndMatch?: (params: {

package/dist/components/matchUpFormat/machine/options.d.ts

@@ -0,0 +1,21 @@
+/**
+ * What the picker offers for a match root and a set's tiebreak point. Moved unchanged from the retired
+ * `matchUpFormatLogic.ts`, whose other exports served the modal the state machine replaced.
+ */
+export declare const MATCH_ROOTS: readonly ["SET", "HAL", "QTR", "PER", "INN", "RND", "FRM", "MAP"];
+export declare const MATCH_ROOT_LABELS: Record<string, string>;
+/**
+ * Returns valid bestOf options for a given match root.
+ * SET root: [1,3,5,7,9] — odd counts; the factory parses any best-of count (#5136)
+ * Other roots: [1..12] (wide range for cross-sport)
+ */
+export declare function getBestOfOptionsForRoot(matchRoot?: string): number[];
+/**
+ * Calculate valid tiebreakAt options based on setTo value
+ */
+export declare function getTiebreakAtOptions(setTo: number): number[];
+/**
+ * Auto-adjust tiebreakAt when setTo changes
+ * Returns the new tiebreakAt value that should be used
+ */
+export declare function autoAdjustTiebreakAt(newSetTo: number, currentTiebreakAt: number): number;

package/dist/components/matchUpFormat/machine/view.d.ts

@@ -72,5 +72,41 @@ export interface ViewConfig {
     combinedPoints?: CombinedPointsConfig;
 }
 export declare const CUSTOM = "Custom";
+/**
+ * The picker's own words, in English. A consumer translates them through `config.labels` (CA, 2026-10-11):
+ * `what` holds the singular set-type names and `whatPlural` the plural ones, and a label that carries a
+ * number is a template with `{n}`, so a language can put the number where its word order needs it. Each
+ * key falls back to English on its own, so a consumer that translates some keys keeps the rest.
+ */
+export declare const DEFAULT_LABELS: {
+    what: {
+        sets: string;
+        tiebreaks: string;
+        timedSets: string;
+        outs: string;
+        pointsTotal: string;
+    };
+    whatPlural: {
+        sets: string;
+        tiebreaks: string;
+        timedSets: string;
+        outs: string;
+        pointsTotal: string;
+    };
+    advantage: {
+        ad: string;
+        noAd: string;
+    };
+    matchRoots: Record<string, string>;
+    setTo: string;
+    tiebreakTo: string;
+    winBy: string;
+    minutes: string;
+    outs: string;
+    maxMinutes: string;
+    pointsTotal: string;
+    tieAllowed: string;
+    consecutive: string;
+};
 export declare function gameFormatText(gameFormat: GameFormat | undefined, labels?: any): string;
 export declare function deriveView(state: EditorState, config: ViewConfig): EditorView;

package/dist/components/matchUpFormat/matchUpFormat.d.ts

@@ -31,15 +31,46 @@ export interface MatchUpFormatConfig {
             bestOf?: string;
             exactly?: string;
         };
+        /** The set-type names, singular ("Best of 1 Set"). */
         what?: {
             sets?: string;
             tiebreaks?: string;
             timedSets?: string;
+            outs?: string;
+            pointsTotal?: string;
+        };
+        /** The set-type names, plural ("Best of 3 Sets"). */
+        whatPlural?: {
+            sets?: string;
+            tiebreaks?: string;
+            timedSets?: string;
+            outs?: string;
+            pointsTotal?: string;
         };
         advantage?: {
             ad?: string;
             noAd?: string;
         };
+        /** Match-root names by code (SET, HAL, QTR, PER, INN, RND, FRM, MAP). */
+        matchRoots?: Record<string, string>;
+        /** 'to {n}': games to win a set. */
+        setTo?: string;
+        /** 'TB to {n}': points to win a tiebreak. */
+        tiebreakTo?: string;
+        /** 'Win by {n}': a margin to win (a tiebreak, a set, or a points total after a tie). */
+        winBy?: string;
+        /** '{n} Minutes': a timed set's length. */
+        minutes?: string;
+        /** '{n} outs': outs per side. */
+        outs?: string;
+        /** '{n} min': the match time limit. */
+        maxMinutes?: string;
+        /** '{n} points': a points total. */
+        pointsTotal?: string;
+        /** '{n} consecutive': a game format without its own consecutive2-4 label. */
+        consecutive?: string;
+        /** A points total whose tie stands as the result. */
+        tieAllowed?: string;
     };
     options?: {
         bestOf?: number[];

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

@@ -0,0 +1,10 @@
+import { SetScore } from '../types';
+/**
+ * A combined-point total that allows a tie (`SET1-S:P32`) can end level, 16–16: COMPLETED with no winner
+ * (CA, 2026-10-11: ties are valid). The score dialogs otherwise finish a match only on a winner.
+ *
+ * The factory decides whether the set is over (`checkSetIsComplete` hands a combined-point set to its own
+ * `analyzeCombinedPointSet`); this adds only that the format lets a tie stand and the totals are level. A
+ * deciding-point or win-by format (`P32DP`, `P32WB2`) never ends level, so it is never a completed tie.
+ */
+export declare function isCompletedCombinedPointTie(sets: SetScore[], matchUpFormat?: string): boolean;

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

@@ -15,8 +15,8 @@ import { SetScore } from '../types';
  * of 7, and a low of 5 in `S:6NOAD` completed to **7** instead of 6 — a 7-5 in a format where first to
  * six wins.
  *
- * Every OTHER reader of this flag in the package had it right — `freeScore.ts`, `matchUpFormat.ts`,
- * `matchUpFormatLogic.ts` and the format picker all read `.NoAD`. This one type was the outlier, which
+ * Every OTHER reader of this flag in the package had it right — `freeScore.ts` and the format picker
+ * (`matchUpFormat/machine/codec.ts`) both read `.NoAD`. This one type was the outlier, which
  * is the shape the architectural standards call mock divergence: a hand-written mirror that renames a
  * field and then certifies the rename.
  */