courthive-components 1.0.4 → 1.1.1

package/dist/components/scheduling-profile/types.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Scheduling Profile — Type Definitions
+ *
+ * All interfaces for the scheduling profile builder component.
+ * The SchedulingProfile shape matches the factory's `scheduleProfileRounds()` input.
+ */
+export interface RoundSegment {
+    segmentNumber: number;
+    segmentsCount: number;
+}
+export interface RoundProfile {
+    tournamentId: string;
+    eventId: string;
+    eventName?: string;
+    drawId: string;
+    drawName?: string;
+    structureId: string;
+    structureType?: string;
+    roundNumber: number;
+    roundName?: string;
+    roundSegment?: RoundSegment;
+    notBeforeTime?: string;
+    sortOrder?: number;
+    matchCountEstimate?: number;
+}
+export interface VenueSchedule {
+    venueId: string;
+    rounds: RoundProfile[];
+}
+export interface ScheduleDay {
+    scheduleDate: string;
+    venues: VenueSchedule[];
+}
+export type SchedulingProfile = ScheduleDay[];
+export interface VenueInfo {
+    venueId: string;
+    name: string;
+}
+export interface CatalogRoundItem {
+    tournamentId: string;
+    eventId: string;
+    eventName: string;
+    drawId: string;
+    drawName?: string;
+    structureId: string;
+    structureType?: string;
+    roundNumber: number;
+    roundName?: string;
+    matchCountEstimate?: number;
+}
+export type CatalogGroupBy = 'event' | 'draw' | 'round';
+export type PlannedRoundBehavior = 'dim' | 'hide' | 'navigate';
+export interface RoundKey {
+    tournamentId: string;
+    eventId: string;
+    drawId: string;
+    structureId: string;
+    roundNumber: number;
+}
+export interface RoundLocator {
+    date: string;
+    venueId: string;
+    index: number;
+    roundKey: RoundKey;
+    roundSegment?: RoundSegment;
+}
+export interface CatalogDragPayload {
+    type: 'CATALOG_ROUND';
+    roundRef: CatalogRoundItem;
+}
+export interface PlannedDragPayload {
+    type: 'PLANNED_ROUND';
+    locator: RoundLocator;
+}
+export type DragPayload = CatalogDragPayload | PlannedDragPayload;
+export interface DropTarget {
+    date: string;
+    venueId: string;
+    index: number;
+}
+export interface DropResult {
+    ok: boolean;
+    profile: SchedulingProfile;
+}
+export type Severity = 'ERROR' | 'WARN' | 'INFO';
+export type ValidationCode = 'DATE_UNAVAILABLE' | 'DUPLICATE_ROUND' | 'DUPLICATE_SEGMENT' | 'INVALID_SEGMENT_CONFIG' | 'ROUND_ORDER_VIOLATION' | 'DEPENDENCY_VIOLATION' | 'DAY_OVERLOAD' | 'DROP_REJECTED';
+export type FixActionKind = 'JUMP_TO_ITEM' | 'OPEN_TEMPORAL_GRID' | 'MOVE_ITEM_AFTER' | 'MOVE_ITEM_BEFORE';
+export interface FixAction {
+    kind: FixActionKind;
+    label: string;
+    locator?: RoundLocator;
+    after?: RoundLocator;
+    before?: RoundLocator;
+    date?: string;
+}
+export interface ValidationResult {
+    code: ValidationCode;
+    severity: Severity;
+    message: string;
+    context: {
+        date?: string;
+        venueId?: string;
+        scope?: string;
+        drawId?: string;
+        structureId?: string;
+        locator?: RoundLocator;
+        prerequisite?: RoundLocator;
+        demandMinutes?: number;
+        capacityMinutes?: number;
+        ratio?: number;
+        reason?: string;
+    };
+    fixActions?: FixAction[];
+}
+export interface SeverityCounts {
+    total: number;
+    ERROR: number;
+    WARN: number;
+    INFO: number;
+}
+export interface IssueIndex {
+    all: ValidationResult[];
+    bySeverity: Record<Severity, ValidationResult[]>;
+    byDate: Record<string, ValidationResult[]>;
+    byVenue: Record<string, ValidationResult[]>;
+    byDraw: Record<string, ValidationResult[]>;
+    counts: {
+        total: number;
+        ERROR: number;
+        WARN: number;
+        INFO: number;
+        byDate: Record<string, SeverityCounts>;
+        byVenue: Record<string, SeverityCounts>;
+        byDraw: Record<string, SeverityCounts>;
+    };
+}
+export interface ProfileStoreState {
+    profileDraft: SchedulingProfile;
+    venues: VenueInfo[];
+    roundCatalog: CatalogRoundItem[];
+    schedulableDates: string[];
+    activeDates?: string[];
+    selectedDate: string | null;
+    selectedLocator: RoundLocator | null;
+    ruleResults: ValidationResult[];
+    issueIndex: IssueIndex;
+    catalogSearchQuery: string;
+    catalogGroupBy: CatalogGroupBy;
+    plannedRoundBehavior: PlannedRoundBehavior;
+}
+export type ProfileChangeListener = (state: ProfileStoreState) => void;
+export interface TemporalAdapter {
+    isDateAvailable: (date: string) => {
+        ok: boolean;
+        reason?: string;
+    };
+    getDayCapacityMinutes?: (date: string) => number;
+}
+export interface DemandAdapter {
+    estimateDayDemandMinutes: (date: string, profile: SchedulingProfile) => number;
+}
+export interface DependencyAdapter {
+    /**
+     * Returns roundKeyStrings for all rounds that must complete
+     * before the given round can proceed.
+     * Key format: "tournamentId|eventId|drawId|structureId|roundNumber"
+     */
+    getRoundDependencies: (roundKeyString: string) => string[];
+}
+export interface SchedulingProfileConfig {
+    venues: VenueInfo[];
+    roundCatalog: CatalogRoundItem[];
+    schedulableDates: string[];
+    activeDates?: string[];
+    /** When true, the left column (date strip + issues panel) is not rendered. */
+    hideLeft?: boolean;
+    /** Which side to place the round catalog. Defaults to 'right'. */
+    catalogSide?: 'left' | 'right';
+    initialProfile?: SchedulingProfile;
+    selectedDate?: string;
+    temporalAdapter?: TemporalAdapter;
+    demandAdapter?: DemandAdapter;
+    dependencyAdapter?: DependencyAdapter;
+    venueOrder?: string[];
+    plannedRoundBehavior?: PlannedRoundBehavior;
+    onProfileChanged?: (profile: SchedulingProfile) => void;
+    onFixAction?: (action: FixAction) => void;
+}
+export interface UIPanel<T = unknown> {
+    element: HTMLElement;
+    update: (state: T) => void;
+    destroy?: () => void;
+}
+export interface FlattenedRound {
+    round: RoundProfile;
+    locator: RoundLocator;
+}

package/dist/components/scheduling-profile/ui/cardPopover.d.ts

@@ -0,0 +1,11 @@
+import { RoundLocator } from '../types';
+export interface CardPopoverCallbacks {
+    onDelete: (locator: RoundLocator) => void;
+    onSetNotBeforeTime: (locator: RoundLocator) => void;
+}
+export interface CardPopoverManager {
+    show(target: HTMLElement, locator: RoundLocator): void;
+    destroy(): void;
+    isActiveFor(locator: RoundLocator): boolean;
+}
+export declare function createCardPopoverManager(callbacks: CardPopoverCallbacks): CardPopoverManager;

package/dist/components/scheduling-profile/ui/dateStrip.d.ts

@@ -0,0 +1,5 @@
+import { ProfileStoreState, UIPanel } from '../types';
+export interface DateStripCallbacks {
+    onDateSelected: (date: string) => void;
+}
+export declare function buildDateStrip(callbacks: DateStripCallbacks): UIPanel<ProfileStoreState>;

package/dist/components/scheduling-profile/ui/inspectorPanel.d.ts

@@ -0,0 +1,2 @@
+import { ProfileStoreState, UIPanel } from '../types';
+export declare function buildInspectorPanel(): UIPanel<ProfileStoreState>;

package/dist/components/scheduling-profile/ui/issuesPanel.d.ts

@@ -0,0 +1,5 @@
+import { ProfileStoreState, UIPanel, FixAction } from '../types';
+export interface IssuesPanelCallbacks {
+    onFixAction: (action: FixAction) => void;
+}
+export declare function buildIssuesPanel(callbacks: IssuesPanelCallbacks): UIPanel<ProfileStoreState>;

package/dist/components/scheduling-profile/ui/roundCard.d.ts

@@ -0,0 +1,12 @@
+import { RoundProfile, RoundLocator, Severity } from '../types';
+export interface RoundCardData {
+    round: RoundProfile;
+    locator: RoundLocator;
+    isSelected: boolean;
+    severity: Severity | null;
+}
+export interface RoundCardCallbacks {
+    onClick: (locator: RoundLocator) => void;
+    onContextMenu?: (locator: RoundLocator, target: HTMLElement) => void;
+}
+export declare function buildRoundCard(data: RoundCardData, callbacks: RoundCardCallbacks): HTMLElement;

package/dist/components/scheduling-profile/ui/roundCatalog.d.ts

@@ -0,0 +1,8 @@
+import { ProfileStoreState, UIPanel, CatalogGroupBy, CatalogRoundItem, RoundLocator } from '../types';
+export interface RoundCatalogCallbacks {
+    onSearchChange: (query: string) => void;
+    onGroupByChange: (mode: CatalogGroupBy) => void;
+    onDropRemove?: (locator: RoundLocator) => void;
+    onNavigateToPlanned?: (item: CatalogRoundItem) => void;
+}
+export declare function buildRoundCatalog(callbacks: RoundCatalogCallbacks): UIPanel<ProfileStoreState>;

package/dist/components/scheduling-profile/ui/schedulingProfileLayout.d.ts

@@ -0,0 +1,15 @@
+import { ProfileStoreState, UIPanel } from '../types';
+export interface LayoutPanels {
+    dateStrip: UIPanel<ProfileStoreState>;
+    issuesPanel: UIPanel<ProfileStoreState>;
+    venueBoard: UIPanel<ProfileStoreState>;
+    roundCatalog: UIPanel<ProfileStoreState>;
+    inspectorPanel: UIPanel<ProfileStoreState>;
+}
+export declare function buildSchedulingProfileLayout(panels: LayoutPanels, options?: {
+    hideLeft?: boolean;
+    catalogSide?: 'left' | 'right';
+}): {
+    element: HTMLElement;
+    update: (state: ProfileStoreState) => void;
+};

package/dist/components/scheduling-profile/ui/styles.d.ts

@@ -0,0 +1,46 @@
+export declare const spLayoutStyle: () => string;
+export declare const spColumnStyle: () => string;
+export declare const spPanelStyle: () => string;
+export declare const spPanelHeaderStyle: () => string;
+export declare const spPanelTitleStyle: () => string;
+export declare const spPanelMetaStyle: () => string;
+export declare const spPanelBodyStyle: () => string;
+export declare const spDateStripStyle: () => string;
+export declare const spDateChipStyle: () => string;
+export declare const spBadgesStyle: () => string;
+export declare const spBadgeStyle: () => string;
+export declare const spChipsStyle: () => string;
+export declare const spChipStyle: () => string;
+export declare const spBoardStyle: () => string;
+export declare const spVenueStyle: () => string;
+export declare const spVenueHeaderStyle: () => string;
+export declare const spVenueTitleStyle: () => string;
+export declare const spVenueSubStyle: () => string;
+export declare const spDropzoneStyle: () => string;
+export declare const spCardStyle: () => string;
+export declare const spCardTitleStyle: () => string;
+export declare const spCardMetaStyle: () => string;
+export declare const spIssuesStyle: () => string;
+export declare const spIssueStyle: () => string;
+export declare const spIssueCodeStyle: () => string;
+export declare const spIssueMsgStyle: () => string;
+export declare const spIssueActionsStyle: () => string;
+export declare const spIssueActionBtnStyle: () => string;
+export declare const spCatalogStyle: () => string;
+export declare const spCatalogToolbarStyle: () => string;
+export declare const spInputStyle: () => string;
+export declare const spSelectStyle: () => string;
+export declare const spGroupStyle: () => string;
+export declare const spGroupHeaderStyle: () => string;
+export declare const spGroupBodyStyle: () => string;
+export declare const spCatalogItemStyle: () => string;
+export declare const spInspectorStyle: () => string;
+export declare const spKvStyle: () => string;
+export declare const spKvKeyStyle: () => string;
+export declare const spKvValueStyle: () => string;
+export declare const spSmallStyle: () => string;
+export declare const spPopoverItemStyle: () => string;
+export declare const spPopoverDeleteStyle: () => string;
+export declare const spPopoverDividerStyle: () => string;
+export declare const spInsertionLineStyle: () => string;
+export declare const spGroupChevronStyle: () => string;

package/dist/components/scheduling-profile/ui/venueBoard.d.ts

@@ -0,0 +1,7 @@
+import { ProfileStoreState, UIPanel, DragPayload, DropTarget, RoundLocator } from '../types';
+export interface VenueBoardCallbacks {
+    onDrop: (drag: DragPayload, drop: DropTarget) => void;
+    onCardClick: (locator: RoundLocator) => void;
+    onCardContextMenu?: (locator: RoundLocator, target: HTMLElement) => void;
+}
+export declare function buildVenueBoard(callbacks: VenueBoardCallbacks): UIPanel<ProfileStoreState>;

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

@@ -0,0 +1,2 @@
+export { renderScorecard, renderTeamVsHeader, updateTieScore } from './renderScorecard';
+export type { ScorecardOptions, TeamVsOptions } from './renderScorecard';

package/dist/components/scorecard/renderScorecard.d.ts

@@ -0,0 +1,26 @@
+export interface ScorecardOptions {
+    matchUp: any;
+    composition?: any;
+    eventHandlers?: any;
+    swapSides?: boolean;
+}
+export interface TeamVsOptions {
+    side1Name: string;
+    side2Name: string;
+    sets?: any[];
+    winningSide?: number;
+    side1Id?: string;
+    side2Id?: string;
+}
+/**
+ * Render a full team scorecard: header + collection panels + matchUp grids.
+ */
+export declare function renderScorecard({ matchUp, composition, eventHandlers, swapSides }: ScorecardOptions): HTMLDivElement;
+/**
+ * Render the team vs team header with names and aggregate score.
+ */
+export declare function renderTeamVsHeader({ side1Name, side2Name, sets, winningSide, side1Id, side2Id }: TeamVsOptions): HTMLDivElement;
+/**
+ * Update the aggregate tie score in-place (avoids full re-render).
+ */
+export declare function updateTieScore(result: any, side1Id?: string, side2Id?: string, swapSides?: boolean): void;

package/dist/components/scoring/approaches/dialPadApproach.d.ts

@@ -0,0 +1,2 @@
+import { RenderScoreEntryParams } from '../types';
+export declare function renderDialPadScoreEntry(params: RenderScoreEntryParams): void;

package/dist/components/scoring/approaches/dialPadLogic.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared dial pad logic - formats raw digits into score string
+ * Parses matchUpFormat to determine boundaries
+ */
+export type FormatOptions = {
+    matchUpFormat: string;
+};
+/**
+ * Convert raw digits to formatted score string
+ * Example: "6464" with matchUpFormat 'SET3-S:6/TB7' becomes "6-4 6-4"
+ */
+export declare function formatScoreString(digits: string, options: FormatOptions): string;

package/dist/components/scoring/approaches/dynamicSetsApproach.d.ts

@@ -0,0 +1,2 @@
+import { RenderScoreEntryParams } from '../types';
+export declare function renderDynamicSetsScoreEntry(params: RenderScoreEntryParams): void;

package/dist/components/scoring/approaches/freeScoreApproach.d.ts

@@ -0,0 +1,2 @@
+import { RenderScoreEntryParams } from '../types';
+export declare function renderFreeScoreEntry(params: RenderScoreEntryParams): void;

package/dist/components/scoring/approaches/inlineScoringApproach.d.ts

@@ -0,0 +1,2 @@
+import { RenderScoreEntryParams } from '../types';
+export declare function renderInlineScoringEntry(params: RenderScoreEntryParams): void;

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

@@ -0,0 +1,28 @@
+/**
+ * Scoring configuration for courthive-components
+ * This provides a simple configuration object that can be modified by consumers
+ */
+export interface ScoringConfig {
+    scoringApproach?: 'freeScore' | 'dynamicSets' | 'dialPad' | 'inlineScoring';
+    smartComplements?: boolean;
+    composition?: string;
+    idiom?: string;
+    dateFormat?: string;
+    timeFormat?: string;
+}
+/**
+ * Get current scoring configuration
+ */
+export declare function getScoringConfig(): ScoringConfig;
+/**
+ * Set scoring configuration (can be partial)
+ */
+export declare function setScoringConfig(config: Partial<ScoringConfig>): void;
+/**
+ * Reset configuration to defaults
+ */
+export declare function resetScoringConfig(): void;
+/**
+ * Stub for loadSettings (for compatibility with TMX code)
+ */
+export declare function loadSettings(): any;

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

@@ -0,0 +1,6 @@
+/**
+ * Scoring Modal - Modern TypeScript implementation
+ * Entry point for the scoring system
+ */
+export { scoringModal } from './scoringModal';
+export * from './types';

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

@@ -0,0 +1,124 @@
+import { SetScore } from '../types';
+/**
+ * Set format information returned by matchUpFormatCode.parse()
+ */
+export type SetFormat = {
+    setTo?: number;
+    tiebreakAt?: number;
+    tiebreakFormat?: {
+        tiebreakTo?: number;
+        noAd?: boolean;
+    };
+    tiebreakSet?: {
+        tiebreakTo?: number;
+        noAd?: boolean;
+    };
+    timed?: boolean;
+    minutes?: number;
+};
+/**
+ * Configuration for a matchUp
+ * Should be derived from TODS matchUpFormat strings using matchUpFormatCode.parse()
+ */
+export type MatchUpConfig = {
+    bestOf: number;
+    exactly?: number;
+    setFormat?: SetFormat;
+    finalSetFormat?: SetFormat;
+};
+/**
+ * Result of smart complement calculation
+ */
+export type SmartComplementResult = {
+    field1Value: number;
+    field2Value: number;
+    shouldApply: boolean;
+    reason?: string;
+};
+/**
+ * Get the format for a specific set index
+ * Uses finalSetFormat for deciding set if available
+ */
+export declare function getSetFormatForIndex(setIndex: number, config: MatchUpConfig): SetFormat | undefined;
+/**
+ * Check if a set is tiebreak-only (e.g., TB10)
+ */
+export declare function isSetTiebreakOnly(format?: SetFormat): boolean;
+/**
+ * Check if a set format is timed (e.g., T10, T20)
+ */
+export declare function isSetTimed(format?: SetFormat): boolean;
+/**
+ * Calculate the maximum allowed score for a regular set game score
+ * based on the opponent's score and set rules
+ *
+ * For timed sets, returns Infinity (no maximum) since scores don't need relationships
+ */
+export declare function getMaxAllowedScore(setIndex: number, side: 1 | 2, currentScores: {
+    side1: number;
+    side2: number;
+}, config: MatchUpConfig): number;
+/**
+ * Determine if a set is complete based on its scores
+ */
+export declare function isSetComplete(setIndex: number, scores: {
+    side1: number;
+    side2: number;
+    tiebreak?: number;
+}, config: MatchUpConfig): boolean;
+/**
+ * Calculate which side won a set
+ * Returns undefined if set is not complete
+ */
+export declare function getSetWinner(setIndex: number, scores: {
+    side1: number;
+    side2: number;
+    tiebreak?: number;
+}, config: MatchUpConfig): 1 | 2 | undefined;
+/**
+ * Determine if match is complete based on sets won
+ */
+export declare function isMatchComplete(sets: SetScore[], bestOf: number, exactly?: number): boolean;
+/**
+ * Get the match winner based on sets won
+ * Returns undefined if match is not complete
+ */
+export declare function getMatchWinner(sets: SetScore[], bestOf: number, exactly?: number): 1 | 2 | undefined;
+/**
+ * Calculate the complement score for smart complement entry
+ * Returns null if no predictable complement exists
+ *
+ * @param digit - The digit entered (0-9)
+ * @param setFormat - The format for this set
+ * @returns Complement value or null if digit >= setTo (no predictable complement)
+ */
+export declare function calculateComplement(digit: number, setFormat?: SetFormat): number | null;
+/**
+ * Determine if smart complement should be applied for a given input
+ *
+ * @param digit - The digit being entered
+ * @param isShiftPressed - Whether Shift key is pressed
+ * @param setIndex - Index of the current set
+ * @param sets - Current sets array
+ * @param config - Match configuration
+ * @param smartComplementsUsed - Set of indices where complement was already used
+ * @param smartComplementsEnabled - Whether feature is enabled in settings
+ * @returns Result indicating if/how complement should be applied
+ */
+export declare function shouldApplySmartComplement(digit: number, isShiftPressed: boolean, setIndex: number, sets: SetScore[], config: MatchUpConfig, smartComplementsUsed: Set<number>, smartComplementsEnabled: boolean): SmartComplementResult;
+/**
+ * Determine if tiebreak input should be visible for a set
+ */
+export declare function shouldShowTiebreak(setIndex: number, scores: {
+    side1: number;
+    side2: number;
+}, config: MatchUpConfig): boolean;
+/**
+ * Determine if a new set row should be created
+ */
+export declare function shouldCreateNextSet(currentSetIndex: number, sets: SetScore[], config: MatchUpConfig): boolean;
+/**
+ * Build a SetScore object from input values
+ * Assigns winningSide if set is complete
+ */
+export declare function buildSetScore(setIndex: number, side1Value: string, side2Value: string, tiebreakValue: string | undefined, config: MatchUpConfig): SetScore;

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

@@ -0,0 +1,2 @@
+import { ScoringModalParams } from './types';
+export declare function scoringModal(params: ScoringModalParams): void;

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

@@ -0,0 +1,60 @@
+/**
+ * Type definitions for scoring modal V2
+ */
+export type SetScore = {
+    setNumber?: number;
+    side1Score?: number;
+    side2Score?: number;
+    side1TiebreakScore?: number;
+    side2TiebreakScore?: number;
+    side1PointScore?: string | number;
+    side2PointScore?: string | number;
+    winningSide?: number;
+};
+export type ScoreOutcome = {
+    isValid: boolean;
+    sets: SetScore[];
+    scoreObject?: any;
+    winningSide?: number;
+    matchUpStatus?: string;
+    error?: string;
+    matchUpFormat?: string;
+    score?: string;
+};
+export type ScoringModalLabels = {
+    title?: string;
+    cancel?: string;
+    clear?: string;
+    submit?: string;
+    format?: string;
+    formatEditTitle?: string;
+    irregularEnding?: string;
+    winner?: string;
+    retired?: string;
+    walkover?: string;
+    defaulted?: string;
+    validScore?: string;
+    scoreIncomplete?: string;
+    invalidScore?: string;
+    scoreTips?: string;
+    setScores?: string;
+    tiebreaks?: string;
+    matchTiebreaks?: string;
+    irregularEndings?: string;
+    addSet?: boolean;
+    dynamicSetsTips?: string;
+    dialPadTips?: string;
+};
+export type ScoringModalParams = {
+    matchUp: any;
+    callback: (outcome: any) => void;
+    onClose?: () => void;
+    labels?: ScoringModalLabels;
+};
+export type ScoreChangeHandler = (outcome: ScoreOutcome) => void;
+export type RenderScoreEntryParams = {
+    matchUp: any;
+    container: HTMLElement;
+    onScoreChange: ScoreChangeHandler;
+    labels?: ScoringModalLabels;
+};

package/dist/components/scoring/utils/scoreFormatters.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared utilities for formatting scores for display in scoring modals
+ */
+/**
+ * Format existing score object into string for input field
+ */
+export declare function formatExistingScore(scoreObject: any, matchUpStatus?: string): string;
+/**
+ * Get short abbreviation for matchUpStatus
+ * Returns empty string for unknown or unhandled statuses
+ */
+export declare function getStatusAbbreviation(status: string): string;

package/dist/components/scoring/utils/scoreValidator.d.ts

@@ -0,0 +1,16 @@
+import { ScoreOutcome } from '../types';
+/**
+ * Validate a score string using generateOutcomeFromScoreString with preserveSideOrder
+ */
+export declare function validateScore(scoreString: string, matchUpFormat?: string, matchUpStatus?: string): ScoreOutcome;
+/**
+ * Validate individual set scores (for Dynamic Sets approach)
+ * Builds a scoreString from the sets and uses validateScore for consistent validation
+ */
+export declare function validateSetScores(sets: Array<{
+    side1?: number;
+    side2?: number;
+    side1TiebreakScore?: number;
+    side2TiebreakScore?: number;
+    winningSide?: number;
+}>, matchUpFormat?: string, allowIncomplete?: boolean): ScoreOutcome;

package/dist/components/scoring/utils/setExpansionLogic.d.ts

@@ -0,0 +1,24 @@
+import { SetScore } from '../types';
+type MatchUpFormatInfo = {
+    bestOf: number;
+    exactly?: number;
+    setsToWin: number;
+    isTimed: boolean;
+    isExactlyFormat: boolean;
+};
+/**
+ * Parse match format string to extract best-of information
+ * Examples: "SET3-S:6/TB7" → bestOf=3, "SET5-S:6/TB7" → bestOf=5
+ * Examples: "SET3X-S:T10" → exactly=3, isTimed=true
+ */
+export declare function parseMatchUpFormat(matchUpFormat?: string): MatchUpFormatInfo;
+/**
+ * Determine if another set should be added based on current scores
+ */
+export declare function shouldExpandSets(sets: SetScore[], matchUpFormat?: string): boolean;
+/**
+ * Determine the winning side based on set scores
+ * Handles both regular scoring (sets won) and aggregate scoring (total points)
+ */
+export declare function determineWinningSide(sets: SetScore[], matchUpFormat?: string): number | undefined;
+export {};