courthive-components 1.0.4 → 1.1.1

package/dist/styles/centerInfoStyle.d.ts

@@ -0,0 +1,6 @@
+export declare function getInfoStyle({ variant }: {
+    variant?: number | string;
+}): string;
+export declare const columnStyle: () => string;
+export declare const entryStyle: () => string;
+export declare const statusStyle: () => string;

package/dist/styles/containerStyle.d.ts

@@ -0,0 +1 @@
+export declare const containerStyle: () => string;

package/dist/styles/flagStyle.d.ts

@@ -0,0 +1,3 @@
+export declare const flagStyle: (opts?: {
+    variant?: string;
+}) => string;

package/dist/styles/getChevronStyle.d.ts

@@ -0,0 +1,4 @@
+export declare function getChevronStyle({ winnerChevron, isDoubles }: {
+    winnerChevron?: boolean;
+    isDoubles?: boolean;
+}): string;

package/dist/styles/getLinkStyle.d.ts

@@ -0,0 +1,25 @@
+import { Composition } from '../types';
+/**
+ * Computes connector line configuration and returns a two-call API
+ * that matches the previous Stitches pattern.
+ *
+ * Usage:
+ *   const linkResult = getLinkStyle({ composition, isDoubles, roundFactor })({ isFirstRound, link });
+ *   element.className = linkResult.className;
+ *   linkResult.applyStyles(element); // sets CSS custom properties for dynamic dimensions
+ */
+export declare function getLinkStyle({ composition, isDoubles, roundFactor }: {
+    composition?: Composition;
+    isDoubles?: boolean;
+    roundFactor?: number;
+}): (opts: {
+    isFirstRound?: boolean;
+    link?: string;
+    noProgression?: boolean;
+}) => {
+    className: string;
+    /** Apply dynamic connector dimensions as CSS custom properties on the element */
+    applyStyles(element: HTMLElement): void;
+    /** Legacy: return className as string for backward-compat (styles won't include dynamic dimensions) */
+    toString(): string;
+};

package/dist/styles/getMatchUpStyle.d.ts

@@ -0,0 +1,4 @@
+import { Configuration } from '../types';
+export declare function getMatchUpStyle({ configuration }: {
+    configuration?: Configuration;
+}): string;

package/dist/styles/getSelectedMatchUpStyle.d.ts

@@ -0,0 +1 @@
+export declare function getSelectedMatchUpStyle(): string;

package/dist/styles/groupNameStyle.d.ts

@@ -0,0 +1 @@
+export declare const groupNameStyle: () => string;

package/dist/styles/groupSeparatorStyle.d.ts

@@ -0,0 +1,4 @@
+export declare const groupSeparatorStyle: (opts?: {
+    variant?: number | string;
+    roundOrder?: string;
+}) => string;

package/dist/styles/matchUpContainerStyle.d.ts

@@ -0,0 +1 @@
+export declare const matchUpContainerStyle: () => string;

package/dist/styles/participantDetailStyle.d.ts

@@ -0,0 +1 @@
+export declare const participantDetailStyle: () => string;

package/dist/styles/participantStyle.d.ts

@@ -0,0 +1,17 @@
+export declare function getPlacholderStyle({ variant }: {
+    variant?: string;
+}): string;
+export declare const participantStyle: (_opts?: {
+    variant?: string;
+}) => string;
+export declare const participantNameStyle: (opts?: {
+    variant?: string;
+}) => string;
+export declare const participantTypeStyle: (opts?: {
+    variant?: string;
+}) => string;
+export declare function getParticipantContainerStyle({ drawPosition, sideNumber }: {
+    drawPosition?: number | string;
+    sideNumber?: number;
+}): string;
+export declare function getDrawPositionData(drawPosition?: number | string): string | undefined;

package/dist/styles/pillStyle.d.ts

@@ -0,0 +1,3 @@
+export declare const pillStyle: (opts?: {
+    variant?: string;
+}) => string;

package/dist/styles/resultStyles.d.ts

@@ -0,0 +1,4 @@
+export declare const resultsItemStyle: (opts?: {
+    variant?: string;
+}) => string;
+export declare const resultsInfoStyle: () => string;

package/dist/styles/roundContainerStyle.d.ts

@@ -0,0 +1 @@
+export declare const roundContainerStyle: () => string;

package/dist/styles/roundHeaderStyle.d.ts

@@ -0,0 +1 @@
+export declare const roundHeaderStyle: () => string;

package/dist/styles/roundStyle.d.ts

@@ -0,0 +1,3 @@
+export declare const roundStyle: (opts?: {
+    variant?: string;
+}) => string;

package/dist/styles/scaleStyle.d.ts

@@ -0,0 +1,3 @@
+export declare const scaleStyle: (opts?: {
+    color?: string;
+}) => string;

package/dist/styles/schedulingStyle.d.ts

@@ -0,0 +1 @@
+export declare const schedulingStyle: () => string;

package/dist/styles/scoreStyles.d.ts

@@ -0,0 +1,9 @@
+export declare const tieBreakStyle: () => string;
+export declare const gameScoreStyle: (opts?: {
+    variant?: string;
+}) => string;
+export declare const gameWrapperStyle: () => string;
+export declare const pointScoreStyle: (opts?: {
+    inverted?: boolean;
+    position?: "leading" | "trailing";
+}) => string;

package/dist/styles/scoreWrapperStyle.d.ts

@@ -0,0 +1,4 @@
+export declare const scoreWrapperStyle: (_participantHeight?: number) => (opts?: {
+    sideNumber?: number | string;
+    fontSize?: string;
+}) => string;

package/dist/styles/seedStyle.d.ts

@@ -0,0 +1 @@
+export declare const seedStyle: () => string;

package/dist/styles/sideStyles.d.ts

@@ -0,0 +1,3 @@
+export declare const sideContainerStyle: () => string;
+export declare const sideRowStyle: () => string;
+export declare const tickStyles: () => string;

package/dist/styles/structureStyle.d.ts

@@ -0,0 +1 @@
+export declare const structureStyle: () => string;

package/dist/styles/teamLogoStyle.d.ts

@@ -0,0 +1 @@
+export declare const teamLogoStyle: () => string;

package/dist/styles/themes/australianTheme.d.ts

@@ -0,0 +1 @@
+export declare const australianTheme: string;

package/dist/styles/themes/basicCardTheme.d.ts

@@ -0,0 +1 @@
+export declare const basicCardTheme: string;

package/dist/styles/themes/basicTheme.d.ts

@@ -0,0 +1 @@
+export declare const basicTheme: string;

package/dist/styles/themes/createTheme.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Theme system — plain CSS class names.
+ * Replaces Stitches createTheme(). Theme classes are defined in themes.css.
+ */
+export declare function createTheme(name: string, _overrides: Record<string, any>): string;

package/dist/styles/themes/frenchTheme.d.ts

@@ -0,0 +1 @@
+export declare const frenchTheme: string;

package/dist/styles/themes/index.d.ts

@@ -0,0 +1,7 @@
+export { australianTheme } from './australianTheme';
+export { basicCardTheme } from './basicCardTheme';
+export { wimbledonTheme } from './wimbledonTheme';
+export { frenchTheme } from './frenchTheme';
+export { usOpenTheme } from './usOpenTheme';
+export { basicTheme } from './basicTheme';
+export { itfTheme } from './itfTheme';

package/dist/styles/themes/itfTheme.d.ts

@@ -0,0 +1 @@
+export declare const itfTheme: string;

package/dist/styles/themes/usOpenTheme.d.ts

@@ -0,0 +1 @@
+export declare const usOpenTheme: string;

package/dist/styles/themes/wimbledonTheme.d.ts

@@ -0,0 +1 @@
+export declare const wimbledonTheme: string;

package/dist/tools/freeScore/freeScore.d.ts

@@ -0,0 +1,79 @@
+/**
+ * freeScore Parser
+ *
+ * Parses free-form score input using matchUpFormat context for intelligent interpretation.
+ * Character-by-character state machine that handles ambiguous digit sequences.
+ *
+ * Goals:
+ * - Accept any reasonable score notation (spaces, dashes, brackets optional)
+ * - Use matchUpFormat to disambiguate (e.g., "123" → "12-3" vs "1-23" based on setTo)
+ * - Provide confidence scores and suggestions for ambiguous inputs
+ * - Give helpful error messages with position context
+ * - Support incomplete scores (user typing in real-time)
+ */
+type ParsedFormat = any;
+export interface ParsedSet {
+    side1Score?: number;
+    side2Score?: number;
+    side1TiebreakScore?: number;
+    side2TiebreakScore?: number;
+    winningSide?: number;
+    setNumber: number;
+}
+export interface ParserState {
+    input: string;
+    position: number;
+    setIndex: number;
+    currentSide1Buffer: string;
+    currentSide2Buffer: string;
+    currentTiebreakSide1Buffer: string;
+    currentTiebreakSide2Buffer: string;
+    sets: ParsedSet[];
+    parsedFormat: ParsedFormat;
+    state: TokenizerState;
+    inTiebreak: boolean;
+    expectingTiebreakOnly: boolean;
+    irregularEnding?: string;
+    irregularEndingPosition?: number;
+    isValid: boolean;
+    errors: ParseError[];
+    warnings: string[];
+    confidence: number;
+    ambiguities: string[];
+    suggestions: string[];
+}
+export declare enum TokenizerState {
+    START = "START",
+    PARSING_SIDE1 = "PARSING_SIDE1",
+    PARSING_SIDE2 = "PARSING_SIDE2",
+    PARSING_TIEBREAK_SIDE1 = "PARSING_TIEBREAK_SIDE1",
+    PARSING_TIEBREAK_SIDE2 = "PARSING_TIEBREAK_SIDE2",
+    SET_COMPLETE = "SET_COMPLETE",
+    MATCH_COMPLETE = "MATCH_COMPLETE",
+    ERROR = "ERROR"
+}
+export interface ParseError {
+    position: number;
+    message: string;
+    expected?: string;
+    got?: string;
+    context?: string;
+}
+export interface ParseResult {
+    valid: boolean;
+    formattedScore: string;
+    sets: ParsedSet[];
+    confidence: number;
+    errors: ParseError[];
+    warnings: string[];
+    ambiguities: string[];
+    suggestions: string[];
+    incomplete: boolean;
+    matchComplete: boolean;
+    matchUpStatus?: string;
+}
+/**
+ * Parse free-form score string using matchUpFormat context
+ */
+export declare function parseScore(input: string, matchUpFormat: string | ParsedFormat): ParseResult;
+export {};

package/dist/types.d.ts

@@ -0,0 +1,321 @@
+export interface MatchUp {
+    matchUpId: string;
+    matchUpType?: 'SINGLES' | 'DOUBLES';
+    matchUpFormat?: string;
+    matchUpStatus?: string;
+    winningSide?: number;
+    roundNumber?: number;
+    roundPosition?: number;
+    finishingRound?: number;
+    roundFactor?: number;
+    stage?: string;
+    isRoundRobin?: boolean;
+    preFeedRound?: boolean;
+    collectionId?: string;
+    drawPositions?: number[];
+    structureName?: string;
+    structureId: string;
+    drawId?: string;
+    containerStructureId?: string;
+    tournamentId?: string;
+    roundOrder?: number;
+    venueId?: string;
+    courtId?: string;
+    sides?: Side[];
+    score?: Score;
+    schedule?: Schedule;
+    readyToScore?: boolean;
+    [key: string]: any;
+}
+export interface Side {
+    sideNumber: number;
+    drawPosition?: number;
+    participant?: Participant;
+    participantFed?: string;
+    sourceMatchUp?: MatchUp;
+    qualifier?: boolean;
+    bye?: boolean;
+    lineUp?: LineUp[];
+    score?: SideScore;
+    seedNumber?: number;
+    seedValue?: string | number;
+}
+export interface Participant {
+    participantId: string;
+    participantName?: string;
+    participantOtherName?: string;
+    participantType?: 'INDIVIDUAL' | 'PAIR' | 'TEAM';
+    individualParticipants?: IndividualParticipant[];
+    entryStatus?: string;
+    luckyAdvancement?: boolean;
+    person?: Person;
+    useOtherName?: boolean;
+}
+export interface ScaleItem {
+    scaleName?: string;
+    scaleValue?: any;
+    [key: string]: any;
+}
+export interface ScalesByType {
+    SINGLES?: ScaleItem[];
+    DOUBLES?: ScaleItem[];
+}
+export interface IndividualParticipant {
+    participantOtherName?: string;
+    participantId: string;
+    participantName?: string;
+    person?: Person;
+    teams?: Participant[];
+    rankings?: ScalesByType;
+    ratings?: ScalesByType;
+    useOtherName?: boolean;
+}
+export interface Person {
+    personId?: string;
+    standardFamilyName?: string;
+    standardGivenName?: string;
+    nationalityCode?: string;
+    addresses?: Address[];
+    rankings?: Ranking[];
+    ratings?: Rating[];
+    sex?: 'MALE' | 'FEMALE' | 'MIXED';
+    [key: string]: any;
+}
+export interface Address {
+    addressType?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+    countryCode?: string;
+    postalCode?: string;
+}
+export interface Ranking {
+    rankingType?: string;
+    ranking?: number;
+    rankingDate?: string;
+}
+export interface Rating {
+    ratingType?: string;
+    rating?: number;
+    ratingDate?: string;
+    [key: string]: any;
+}
+export interface LineUp {
+    participantId?: string;
+}
+export interface Score {
+    scoreStringSide1?: string;
+    scoreStringSide2?: string;
+    sets?: SetScore[];
+}
+export interface SetScore {
+    setNumber: number;
+    side1Score?: number;
+    side2Score?: number;
+    side1TiebreakScore?: number;
+    side2TiebreakScore?: number;
+    side1PointScore?: number | string;
+    side2PointScore?: number | string;
+    winningSide?: number;
+}
+export interface SideScore {
+    scoreStringSide?: string;
+    games?: number;
+    points?: number;
+}
+export interface Schedule {
+    scheduledDate?: string;
+    scheduledTime?: string;
+    startTime?: string;
+    endTime?: string;
+    courtId?: string;
+    courtName?: string;
+    venueId?: string;
+    venueAbbreviation?: string;
+}
+export interface Configuration {
+    flags?: boolean;
+    flag?: boolean;
+    teamLogo?: boolean;
+    roundHeader?: boolean;
+    winnerChevron?: boolean;
+    centerInfo?: boolean;
+    resultsInfo?: boolean;
+    scoreBox?: boolean;
+    gameScoreOnly?: boolean;
+    gameScore?: {
+        position?: 'leading' | 'trailing';
+        inverted?: boolean;
+    };
+    drawPositions?: boolean;
+    allDrawPositions?: boolean;
+    drawPositionColor?: string;
+    bracketedSeeds?: boolean | 'square';
+    scheduleInfo?: boolean;
+    matchUpFooter?: boolean;
+    showAddress?: boolean;
+    seedingElement?: 'sup' | 'span';
+    matchUpHover?: boolean | string;
+    participantDetail?: string;
+    inlineAssignment?: boolean;
+    participantProvider?: () => Participant[];
+    assignmentInputFontSize?: string;
+    persistInputFields?: boolean;
+    hasQualifying?: boolean;
+    inlineScoring?: {
+        mode: 'points' | 'games';
+        showFooter?: boolean;
+        showSituation?: boolean;
+        canUndo?: boolean;
+        canRedo?: boolean;
+        isComplete?: boolean;
+        isDirty?: boolean;
+        situationText?: string;
+    };
+    useParticipantName?: boolean;
+    genderColor?: boolean | string;
+    winnerColor?: boolean | string;
+    placeHolders?: {
+        tbd?: string;
+        bye?: string;
+        qualifier?: string;
+    };
+    scaleAttributes?: {
+        scaleColor?: string;
+        scaleType?: string;
+        scaleName?: string;
+        accessor?: string;
+        eventType?: string;
+        fallback?: boolean;
+        scalePosition?: 'left' | 'right';
+        rawValue?: any;
+    };
+    clickAway?: boolean;
+    backdrop?: boolean;
+    maxWidth?: number;
+    fontSize?: string;
+    padding?: string;
+    className?: string;
+    style?: Partial<CSSStyleDeclaration>;
+    info?: string;
+    menu?: {
+        menuItems: Array<{
+            label: string;
+            onClick: () => void;
+            active?: boolean;
+        }>;
+    };
+    title?: {
+        padding?: string;
+    };
+    content?: {
+        padding?: string;
+    };
+    footer?: {
+        padding?: string;
+        className?: string;
+    };
+    dictionary?: {
+        close?: string;
+    };
+}
+export interface Composition {
+    theme: string;
+    configuration?: Configuration;
+}
+export interface EventHandlers {
+    matchUpClick?: (params: {
+        pointerEvent: MouseEvent;
+        matchUp: MatchUp;
+    }) => void;
+    participantClick?: (params: {
+        individualParticipant: IndividualParticipant;
+        matchUp?: MatchUp;
+        pointerEvent: MouseEvent;
+        participant?: Participant;
+        side?: Side;
+    }) => void;
+    assignParticipant?: (params: {
+        matchUp: MatchUp;
+        side: Side;
+        sideNumber: number;
+        participant: Participant;
+        pointerEvent?: Event;
+    }) => void;
+    assignBye?: (params: {
+        matchUp: MatchUp;
+        side: Side;
+        sideNumber: number;
+        pointerEvent?: Event;
+    }) => void;
+    assignQualifier?: (params: {
+        matchUp: MatchUp;
+        side: Side;
+        sideNumber: number;
+        pointerEvent?: Event;
+    }) => void;
+    removeAssignment?: (params: {
+        matchUp: MatchUp;
+        side: Side;
+        sideNumber: number;
+        pointerEvent?: Event;
+    }) => void;
+    scoreClick?: (params: {
+        pointerEvent: MouseEvent;
+        matchUp: MatchUp;
+    }) => void;
+    pillClick?: (params: {
+        pointerEvent: MouseEvent;
+        matchUp: MatchUp;
+        sideNumber: number;
+    }) => void;
+    scoreIncrement?: (params: {
+        matchUpId: string;
+        sideNumber: number;
+        scoreType: 'point' | 'game' | 'set';
+    }) => void;
+    inlineUndo?: (params: {
+        matchUpId: string;
+    }) => void;
+    inlineRedo?: (params: {
+        matchUpId: string;
+    }) => void;
+    inlineClear?: (params: {
+        matchUpId: string;
+    }) => void;
+    inlineSubmit?: (params: {
+        matchUpId: string;
+    }) => void;
+    [key: string]: any;
+}
+export interface ModalButton {
+    label?: string;
+    text?: string;
+    id?: string;
+    intent?: string;
+    close?: boolean | (() => void);
+    disabled?: boolean;
+    hide?: boolean;
+    onClick?: (params: {
+        e: MouseEvent;
+        content?: any;
+    }) => void;
+    footer?: {
+        className?: string;
+    };
+}
+export interface ModalConfig extends Configuration {
+    onClose?: (params: {
+        content?: any;
+    }) => void;
+}
+export interface ModalParams {
+    title?: string;
+    content?: string | HTMLElement | ((container: HTMLElement) => any);
+    buttons?: ModalButton[];
+    footer?: string | HTMLElement;
+    config?: ModalConfig;
+    onClose?: (params: {
+        content?: any;
+    }) => void;
+}

package/dist/utilities/isElement.d.ts

@@ -0,0 +1 @@
+export declare function isElement(element: any): element is Element;

package/dist/validators/dateValidator.d.ts

@@ -0,0 +1 @@
+export declare function dateValidator(value: any): boolean;

package/dist/validators/emailValidator.d.ts

@@ -0,0 +1 @@
+export declare const emailValidator: (value: string) => RegExpMatchArray | null;

package/dist/validators/index.d.ts

@@ -0,0 +1,7 @@
+export { nameValidator } from './nameValidator';
+export { numericValidator } from './numericValidator';
+export { numericRange } from './numericRange';
+export { passwordValidator } from './passwordValidator';
+export { dateValidator } from './dateValidator';
+export { wordValidator } from './wordValidator';
+export { emailValidator } from './emailValidator';

package/dist/validators/nameValidator.d.ts

@@ -0,0 +1 @@
+export declare const nameValidator: (minLength: number, maxLength?: number) => (value: string) => boolean;

package/dist/validators/numericRange.d.ts

@@ -0,0 +1 @@
+export declare const numericRange: (min: number, max: number) => (value: string | number) => boolean;

package/dist/validators/numericValidator.d.ts

@@ -0,0 +1 @@
+export declare function numericValidator(value: string | number): boolean;

package/dist/validators/passwordValidator.d.ts

@@ -0,0 +1 @@
+export declare const passwordValidator: (value: any) => boolean;

package/dist/validators/wordValidator.d.ts

@@ -0,0 +1 @@
+export declare const wordValidator: (minWords: number, maxWords?: number) => (value: string) => boolean;

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare function courthiveComponentsVersion(): string;