courthive-components 6.14.0 → 7.0.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/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;

package/dist/components/scoring/regions/dialPadRegion.d.ts

@@ -7,6 +7,8 @@ export type DialPadRegionParams = {
     matchUpFormat?: string;
     /** Sets already recorded, e.g. from a saved matchUp. Read only when no `store` is given. */
     sets?: SetScore[];
+    /** The host's translations (see `SCORE_ENTRY_TEXT`); anything left out reads English. */
+    labels?: Record<string, string | undefined>;
     onChange?: () => void;
 };
 export type DialPadRegion = ScoreRegion & {

package/dist/components/scoring/regions/dynamicSetsRegion.d.ts

@@ -11,7 +11,10 @@ export type DynamicSetsRegionParams = {
     sets?: SetScore[];
     /** Whether smart complements starts enabled. Defaults to on. */
     smartComplements?: boolean;
+    /** The toggle's word. Wins over `labels.smartComplements`. */
     smartComplementsLabel?: string;
+    /** The host's translations (see `SCORE_ENTRY_TEXT`); anything left out reads English. */
+    labels?: Record<string, string | undefined>;
     /** Called after a change affecting only the score. Wire to the card's `refresh`. */
     onChange?: () => void;
     /** Called when the COLUMNS change. Wire to the card's `rerender`. */

package/dist/components/scoring/regions/freeScoreRegion.d.ts

@@ -9,8 +9,10 @@ export type FreeScoreRegionParams = {
     initialText?: string;
     disabledMatchUpStatuses?: string[];
     statusScopeLabels?: Record<string, string>;
-    /** Label above the field. */
+    /** Label above the field. Wins over `labels.typeTheScore`. */
     label?: string;
+    /** The host's translations (see `SCORE_ENTRY_TEXT`); anything left out reads English. */
+    labels?: Record<string, string | undefined>;
     /** Called after any change. Wire to the card's `refresh`. */
     onChange?: () => void;
 };

package/dist/components/scoring/regions/scoreReadout.d.ts

@@ -8,4 +8,4 @@ export type ScoreReadouts = {
     /** Rewrite every registered readout from the current sets. */
     update: (sets: SetScore[]) => void;
 };
-export declare function createScoreReadouts(): ScoreReadouts;
+export declare function createScoreReadouts(labels?: Record<string, string | undefined>): ScoreReadouts;

package/dist/components/scoring/scoreEntryCard.d.ts

@@ -136,7 +136,10 @@ export type ScoreEntryCardParams = {
     store?: ScoreEntryStore;
     /** The policy's reason-code groups, if the tournament has a scoring policy attached. */
     statusCodeGroups?: StatusCodeGroups;
-    /** Ending labels, so a locale can supply them. */
+    /**
+     * Translations: the status names (`RETIRED`, …) and every key of `SCORE_ENTRY_TEXT`. Anything left out
+     * reads the English default.
+     */
     labels?: Record<string, string>;
     /** The approach switcher's current label, e.g. `'Dynamic Sets'`. Omit to hide the switcher. */
     approachLabel?: string;