courthive-components 1.1.0 → 1.1.1

package/dist/components/temporal-grid/timeline/TimeScale.d.ts

@@ -0,0 +1,106 @@
+/**
+ * TimeScale — Pure math for time↔pixel conversion.
+ *
+ * No DOM dependency. All methods are deterministic given the current state.
+ * State: visibleStart, visibleEnd, containerWidth.
+ *
+ * Daily bounds mode: When set, overnight gaps (endTime→startTime next day)
+ * are collapsed to zero width. Each day only shows the operating window.
+ *
+ * Visible days: When set (together with daily bounds), only the specified
+ * days are shown — gap days between non-contiguous active days are collapsed
+ * entirely.
+ */
+export declare class TimeScale {
+    /** Left edge of the visible window */
+    private _start;
+    /** Right edge of the visible window */
+    private _end;
+    /** Width of the scrollable content area in pixels */
+    private _width;
+    /** Hard limits for panning */
+    private _min;
+    private _max;
+    /** Hard limits for zooming (ms) */
+    private _zoomMin;
+    private _zoomMax;
+    /** Daily bounds: minutes since local midnight */
+    private _dailyStartMin;
+    private _dailyEndMin;
+    private _useDailyBounds;
+    /**
+     * Explicit list of visible day strings ("YYYY-MM-DD"), sorted.
+     * When set, only these days get column space in daily-bounds mode.
+     * Gap days between non-contiguous entries are fully collapsed.
+     */
+    private _visibleDays;
+    /** Precomputed: midnight timestamps for each visible day, for fast lookup */
+    private _visibleDayMs;
+    constructor(start: Date, end: Date, width: number);
+    get start(): Date;
+    get end(): Date;
+    get width(): number;
+    get duration(): number;
+    /** Milliseconds per pixel (uses collapsed duration when daily bounds are set) */
+    get msPerPx(): number;
+    /** Get the daily bounds config (null if not set) */
+    getDailyBounds(): {
+        startMin: number;
+        endMin: number;
+    } | null;
+    /** Get the visible days list (null if not set) */
+    getVisibleDays(): string[] | null;
+    /** Convert a Date to an x-pixel offset from the left edge */
+    timeToX(date: Date): number;
+    /** Convert an x-pixel offset to a Date */
+    xToTime(x: number): Date;
+    /** Snap a Date to the nearest N-minute increment */
+    snap(date: Date, minutes: number): Date;
+    /** Set the visible window */
+    setWindow(start: Date, end: Date): void;
+    /** Set pan/zoom limits */
+    setLimits(opts: {
+        min?: Date;
+        max?: Date;
+        zoomMin?: number;
+        zoomMax?: number;
+    }): void;
+    /** Update container width (e.g. on resize) */
+    setWidth(width: number): void;
+    /**
+     * Set daily operating bounds. When set, overnight gaps are collapsed.
+     * @param startTime "HH:MM" — earliest operating hour
+     * @param endTime "HH:MM" — latest operating hour
+     */
+    setDailyBounds(startTime: string, endTime: string): void;
+    /** Remove daily bounds — return to continuous 24-hour mode */
+    clearDailyBounds(): void;
+    /**
+     * Set the explicit list of days to show. Only meaningful when daily bounds
+     * are active. Gap days between non-contiguous entries are fully collapsed.
+     * @param days Sorted array of "YYYY-MM-DD" strings
+     */
+    setVisibleDays(days: string[]): void;
+    /** Clear visible days restriction while keeping daily bounds active */
+    clearVisibleDays(): void;
+    /** Pan by a pixel delta (positive = scroll right = later times) */
+    pan(deltaPixels: number): void;
+    /**
+     * Zoom by a factor around a center x-pixel.
+     * factor < 1 zooms in, factor > 1 zooms out.
+     */
+    zoom(factor: number, centerX: number): void;
+    /**
+     * Convert a Date to a "collapsed" position in minutes.
+     * Overnight gaps are removed — only operating hours count.
+     *
+     * When _visibleDays is set, only those specific days get column space.
+     * Gap days are fully collapsed (zero width).
+     */
+    private toCollapsedMin;
+    /**
+     * Convert a "collapsed" position (in minutes) back to a real Date.
+     */
+    private fromCollapsedMin;
+    private clampBounds;
+}

package/dist/components/temporal-grid/timeline/types.d.ts

@@ -0,0 +1,124 @@
+import { temporal } from 'tods-competition-factory';
+type CourtRef = temporal.CourtRef;
+export interface TimelineGroupData {
+    id: string;
+    content: string;
+    order?: number;
+    courtRef?: CourtRef;
+    surface?: string;
+    indoor?: boolean;
+    hasLights?: boolean;
+    tags?: string[];
+}
+export interface TimelineItemData {
+    id: string;
+    group: string;
+    content: string;
+    start: Date | string;
+    end?: Date | string;
+    type?: 'range' | 'background';
+    className?: string;
+    style?: string;
+    title?: string;
+    editable?: boolean | {
+        updateTime?: boolean;
+        updateGroup?: boolean;
+        remove?: boolean;
+    };
+    blockId?: string;
+    status?: string;
+    reason?: string;
+    isBlock?: boolean;
+    isSegment?: boolean;
+    isConflict?: boolean;
+}
+export interface TimelineOptions {
+    /** Visible window start */
+    start?: Date;
+    /** Visible window end */
+    end?: Date;
+    /** Minimum allowed date (pan limit) */
+    min?: Date;
+    /** Maximum allowed date (pan limit) */
+    max?: Date;
+    /** Minimum visible duration in ms (zoom limit) */
+    zoomMin?: number;
+    /** Maximum visible duration in ms (zoom limit) */
+    zoomMax?: number;
+    /** Snap function: given a Date, return snapped Date */
+    snap?: (date: Date) => Date;
+    /** Row height in pixels (default 40) */
+    rowHeight?: number;
+    /** Time axis formatting */
+    timeAxis?: {
+        scale: string;
+        step: number;
+    };
+    /** Whether to show tooltips on hover */
+    showTooltips?: boolean;
+    /** Enable pinch-to-zoom (ctrl+wheel). Default false. */
+    enablePinchZoom?: boolean;
+    /** Height of the container (CSS value) */
+    height?: string;
+}
+export type InteractionMode = 'IDLE' | 'DRAGGING' | 'RESIZING_LEFT' | 'RESIZING_RIGHT' | 'GHOST_EDITING' | 'RESIZING_TOP' | 'RESIZING_BOTTOM';
+/** State tracked during an active drag/resize gesture */
+export interface GestureState {
+    mode: InteractionMode;
+    /** Item ID being manipulated (null for ghost creation) */
+    itemId: string | null;
+    /** Pointer start position (client coords) */
+    startX: number;
+    startY: number;
+    /** Original item time range at gesture start */
+    originalStart: Date;
+    originalEnd: Date;
+    /** Original group at gesture start */
+    originalGroup: string;
+    /** Current pointer position */
+    currentX: number;
+    currentY: number;
+    /** Whether the drag threshold has been exceeded */
+    thresholdExceeded: boolean;
+}
+export interface MultiRowSpan {
+    /** IDs of all groups covered by the ghost */
+    groupIds: string[];
+    /** Top row index (0-based) */
+    topRowIndex: number;
+    /** Bottom row index (inclusive, 0-based) */
+    bottomRowIndex: number;
+    /** Time range */
+    startTime: Date;
+    endTime: Date;
+}
+export interface TimelineCallbacks {
+    /** Fired when a new item should be created (double-click on empty area) */
+    onAdd?: (item: {
+        group: string;
+        start: Date;
+        end: Date;
+    }) => void;
+    /** Fired when an item is clicked */
+    onItemClick?: (itemId: string, event: PointerEvent) => void;
+    /** Fired during item drag/resize for live validation */
+    onMoving?: (item: {
+        id: string;
+        group: string;
+        start: Date;
+        end: Date;
+    }) => {
+        start: Date;
+        end: Date;
+    } | null;
+    /** Fired when item drag/resize completes */
+    onMove?: (item: {
+        id: string;
+        group: string;
+        start: Date;
+        end: Date;
+    }) => boolean;
+    /** Fired when multi-row ghost is confirmed */
+    onMultiRowCreate?: (span: MultiRowSpan) => void;
+}
+export {};

package/dist/components/temporal-grid/ui/blockPopover.d.ts

@@ -0,0 +1,29 @@
+import { TemporalEngine } from 'tods-competition-factory';
+export interface BlockPopoverOptions {
+    itemId: string;
+    blockTypes: Array<{
+        type: string;
+        color: string;
+        label: string;
+    }>;
+    currentType?: string;
+    startTime?: string;
+    endTime?: string;
+    onTypeSelected: (type: string) => void;
+    onAdjustTime?: (startTime: string, endTime: string) => void;
+    onDelete?: () => void;
+}
+export interface EngineBlockPopoverOptions {
+    itemId: string;
+    blockId: string;
+    engine: TemporalEngine;
+    day: string;
+    onBlockChanged: () => void;
+}
+export interface BlockPopoverManager {
+    show(target: HTMLElement, options: BlockPopoverOptions): void;
+    showForEngineBlock(target: HTMLElement, options: EngineBlockPopoverOptions): void;
+    destroy(): void;
+    isActiveFor(itemId: string): boolean;
+}
+export declare function createBlockPopoverManager(): BlockPopoverManager;

package/dist/components/temporal-grid/ui/courtAvailabilityModal.d.ts

@@ -0,0 +1,29 @@
+export interface CourtAvailabilityModalConfig {
+    title: string;
+    currentDay: string;
+    currentStartTime: string;
+    currentEndTime: string;
+    showScopeToggle?: boolean;
+    venueBounds?: {
+        startTime: string;
+        endTime: string;
+    };
+    onConfirm: (params: {
+        startTime: string;
+        endTime: string;
+        scope: 'current-day' | 'all-days';
+    }) => void;
+    onCancel?: () => void;
+    /** Custom labels for UI text */
+    labels?: {
+        startTime?: string;
+        endTime?: string;
+        applyTo?: string;
+        currentDayOnly?: string;
+        allDays?: string;
+        cancel?: string;
+        apply?: string;
+        venueWarning?: string;
+    };
+}
+export declare function showCourtAvailabilityModal(config: CourtAvailabilityModalConfig): Promise<void>;

package/dist/components/temporal-grid/ui/modernTimePicker.d.ts

@@ -0,0 +1,46 @@
+export interface TimePickerConfig {
+    startTime: string;
+    endTime?: string;
+    dayStartTime?: string;
+    dayEndTime?: string;
+    minuteIncrement?: number;
+    minDuration?: number;
+    maxDuration?: number;
+    clockType?: '12h' | '24h';
+    onConfirm: (startTime: string, endTime: string) => void;
+    onCancel: () => void;
+}
+export declare class ModernTimePicker {
+    private readonly container;
+    private readonly config;
+    private picker;
+    private readonly inputElement;
+    private selectedStart;
+    private selectedEnd;
+    constructor(config: TimePickerConfig);
+    /**
+     * Extract HH:mm time from ISO string or time string using factory utilities
+     */
+    private extractTimeAsHHMM;
+    /**
+     * Create a hidden container for the input element
+     * The timepicker-ui library will create its own modal UI
+     */
+    private createUI;
+    /**
+     * Initialize the timepicker-ui instance
+     */
+    private initTimePicker;
+    /**
+     * Show the time picker
+     */
+    show(): Promise<void>;
+    /**
+     * Destroy the time picker
+     */
+    destroy(): void;
+}
+/**
+ * Factory function to create and show a time picker
+ */
+export declare function showModernTimePicker(config: TimePickerConfig): Promise<ModernTimePicker>;

package/dist/components/temporal-grid/ui/statsBar.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Stats Bar — Horizontal capacity statistics strip.
+ *
+ * Shows total hours, blocked, available, and avg per court.
+ */
+export interface StatsBarUpdate {
+    totalHours: number;
+    blockedHours: number;
+    availableHours: number;
+    avgPerCourt: number;
+}
+export interface StatsBarLabels {
+    totalHours?: string;
+    blocked?: string;
+    available?: string;
+    avgPerCourt?: string;
+}
+export declare function buildStatsBar(labels?: StatsBarLabels): {
+    element: HTMLElement;
+    update: (stats: StatsBarUpdate) => void;
+};

package/dist/components/temporal-grid/ui/temporalGrid.d.ts

@@ -0,0 +1,149 @@
+import { TemporalEngine, temporal } from 'tods-competition-factory';
+import { TemporalGridControl, TemporalGridControlConfig } from '../controller/temporalGridControl';
+type DayId = temporal.DayId;
+/**
+ * i18n labels for the temporal grid component.
+ * All fields are optional — English defaults are used when omitted.
+ */
+export interface TemporalGridLabels {
+    view?: string;
+    day1?: string;
+    days3?: string;
+    week?: string;
+    tournament?: string;
+    courtAvailability?: string;
+    totalHours?: string;
+    blocked?: string;
+    available?: string;
+    avgPerCourt?: string;
+    setDefaultAvailability?: string;
+    saveToTournament?: string;
+}
+export interface TemporalGridCallbacks {
+    /**
+     * Called when dirty state changes (blocks/availability modified vs initial)
+     */
+    onDirtyChange?: (isDirty: boolean) => void;
+}
+export interface TemporalGridConfig extends Partial<TemporalGridControlConfig>, TemporalGridCallbacks {
+    /**
+     * Tournament record (TODS format)
+     */
+    tournamentRecord: any;
+    /**
+     * Engine configuration overrides
+     */
+    engineConfig?: {
+        dayStartTime?: string;
+        dayEndTime?: string;
+        slotMinutes?: number;
+    };
+    /**
+     * Initial selected day
+     */
+    initialDay?: DayId;
+    /**
+     * Show facility tree
+     */
+    showVenueTree?: boolean;
+    /**
+     * Show capacity indicator
+     */
+    showCapacity?: boolean;
+    /**
+     * Show toolbar
+     */
+    showToolbar?: boolean;
+    /**
+     * i18n labels
+     */
+    labels?: TemporalGridLabels;
+    /**
+     * Language code for datepicker localization (e.g. 'en', 'fr', 'de')
+     */
+    language?: string;
+    /**
+     * Callback when "Set Default Availability" is clicked
+     */
+    onSetDefaultAvailability?: () => void;
+    /**
+     * Callback when "Save to Tournament" is clicked
+     */
+    onSave?: () => void;
+    /**
+     * Callback when mutations are applied
+     */
+    onMutationsApplied?: (mutations: any[]) => void;
+}
+export declare class TemporalGrid {
+    private engine;
+    private control;
+    private config;
+    private rootElement;
+    private venueTreeElement;
+    private calendarElement;
+    private capacityElement;
+    private statsBarInstance;
+    private viewToolbarResult;
+    private datepicker;
+    private visibleCourts;
+    private initialSnapshot;
+    private isDirty;
+    constructor(config: TemporalGridConfig);
+    /**
+     * Render the component into a container
+     */
+    render(container: HTMLElement): void;
+    /**
+     * Destroy the component and cleanup
+     */
+    destroy(): void;
+    private createRootElement;
+    private renderToolbar;
+    /**
+     * Initialize the datepicker on the toolbar date input.
+     * Must be called after the toolbar element is in the DOM.
+     */
+    private initDatepicker;
+    private handleDateChange;
+    private renderCapacityIndicator;
+    private renderVenueTree;
+    private renderCalendar;
+    /** Serialize current engine state (blocks + availability) for comparison */
+    private takeSnapshot;
+    /** Compare current state to initial snapshot and update dirty flag */
+    private checkDirtyState;
+    /** Reset the snapshot (call after a successful save) */
+    resetDirtyState(): void;
+    private updateStatsBar;
+    private updateCapacityStats;
+    private updateVenueTree;
+    private handleEngineEvent;
+    private handleBlockSelected;
+    private handleCourtSelected;
+    private handleTimeRangeSelected;
+    private handleCourtCheckboxChange;
+    private handleVenueCheckboxChange;
+    private updateVenueCheckboxState;
+    /**
+     * Get the engine instance
+     */
+    getEngine(): TemporalEngine;
+    /**
+     * Get the controller instance
+     */
+    getControl(): TemporalGridControl | null;
+    /**
+     * Set the selected day
+     */
+    setDay(day: DayId): void;
+    /**
+     * Refresh the display
+     */
+    refresh(): void;
+}
+/**
+ * Create and render a temporal grid
+ */
+export declare function createTemporalGrid(config: TemporalGridConfig, container: HTMLElement): TemporalGrid;
+export {};

package/dist/components/temporal-grid/ui/viewToolbar.d.ts

@@ -0,0 +1,37 @@
+/**
+ * View Toolbar — View-mode preset switcher with date picker and action buttons.
+ *
+ * Provides a date input + Day / 3 Days / Week view buttons + optional action buttons.
+ */
+type TimeAxisScale = 'millisecond' | 'second' | 'minute' | 'hour' | 'weekday' | 'day' | 'month' | 'year';
+export interface ViewPreset {
+    label: string;
+    days: number;
+    timeAxis: {
+        scale: TimeAxisScale;
+        step: number;
+    };
+}
+export interface ViewToolbarLabels {
+    view?: string;
+    day1?: string;
+    days3?: string;
+    week?: string;
+    tournament?: string;
+    setDefaultAvailability?: string;
+    saveToTournament?: string;
+}
+export interface ViewToolbarResult {
+    element: HTMLElement;
+    dateInput: HTMLInputElement;
+    setActiveView: (viewKey: string) => void;
+    setDate: (dateStr: string) => void;
+    setSaveEnabled: (enabled: boolean) => void;
+}
+export declare const VIEW_PRESETS: Record<string, ViewPreset>;
+export declare function buildViewToolbar(onViewChange: (viewKey: string) => void, initialView?: string, onDateChange?: (dateStr: string) => void, options?: {
+    labels?: ViewToolbarLabels;
+    onSetDefaultAvailability?: () => void;
+    onSave?: () => void;
+}): ViewToolbarResult;
+export {};

package/dist/components/topology-builder/controller/topologyBuilderControl.d.ts

@@ -0,0 +1,19 @@
+import { TopologyState, TopologyBuilderConfig } from '../types';
+export declare class TopologyBuilderControl {
+    private readonly store;
+    private readonly layout;
+    private readonly unsubscribe;
+    private readonly config;
+    constructor(config?: TopologyBuilderConfig);
+    private buildToolbarPanel;
+    private buildCanvasPanel;
+    private handleCreateEdge;
+    render(container: HTMLElement): void;
+    destroy(): void;
+    autoLayout(): void;
+    getState(): TopologyState;
+    loadState(state: TopologyState): void;
+    private addDefaultStructure;
+    private scrollCanvasToNode;
+    private handleGenerate;
+}

package/dist/components/topology-builder/domain/feedRounds.d.ts

@@ -0,0 +1,42 @@
+/**
+ * For a given drawSize, return a Map from round number → feed capacity.
+ * Feed rounds are the extra rounds inserted when drawSize > nearest power of 2.
+ *
+ * Example: drawSize=36, base=32, feedIn=4
+ *   → { 4 → 4 }  (feed round 4 has capacity 4)
+ */
+export declare function getFeedRoundCapacities(drawSize: number): Map<number, number>;
+/**
+ * Total number of rounds for a given drawSize, including feed rounds.
+ * Equivalent to getNumRounds but works with drawSize directly.
+ */
+export declare function getTotalRounds(drawSize: number): number;
+/**
+ * Compute round profiles for a lucky draw — mirrors the factory's luckyRoundProfiles().
+ * Returns array of { participantsCount, preFeedRound, feedRound } per round.
+ */
+export declare function luckyRoundProfiles(drawSize: number): {
+    participantsCount: number;
+    preFeedRound: boolean;
+    feedRound?: boolean;
+}[];
+/** Total rounds for a lucky draw structure. */
+export declare function getLuckyDrawTotalRounds(drawSize: number): number;
+/**
+ * Number of losers that exit a lucky draw structure at a given round.
+ * For pre-feed rounds, one lucky loser is retained → losers = matchUps - 1.
+ * For non-pre-feed rounds, all losers exit → losers = matchUps.
+ * In round 1, BYE positions don't produce real losers, so subtract BYEs.
+ */
+export declare function getLuckyDrawLosersForRound(drawSize: number, roundNumber: number): number;
+/**
+ * Structure-type-aware total rounds.
+ * Dispatches to the correct algorithm based on structureType.
+ */
+export declare function getNodeTotalRounds(structureType: string, drawSize: number, structureOptions?: any): number;
+/**
+ * Structure-type-aware losers count for a given round.
+ * For elimination/feed-in: drawSize / 2^round
+ * For lucky draw: uses luckyRoundProfiles
+ */
+export declare function getNodeLosersForRound(structureType: string, drawSize: number, roundNumber: number): number;

package/dist/components/topology-builder/domain/generateDrawFromTopology.d.ts

@@ -0,0 +1,16 @@
+import { TopologyState } from '../types';
+export interface StructureInfo {
+    structureName: string;
+    stage: string;
+    stageSequence: number;
+    matchUpCount: number;
+    positionCount: number;
+}
+export interface GenerationResult {
+    success: boolean;
+    drawOptions?: any;
+    structures?: StructureInfo[];
+    linkCount?: number;
+    error?: string;
+}
+export declare function generateDrawFromTopology(state: TopologyState, participantsCount?: number): GenerationResult;

package/dist/components/topology-builder/domain/playoffProfilesCache.d.ts

@@ -0,0 +1,16 @@
+export interface PlayoffRoundRange {
+    roundNumber: number;
+    finishingPositionRange: string;
+}
+export interface PlayoffFinishingPositionRange {
+    finishingPosition: number;
+    finishingPositionRange: string;
+}
+export interface PlayoffProfiles {
+    playoffRounds?: number[];
+    playoffRoundsRanges?: PlayoffRoundRange[];
+    playoffFinishingPositionRanges?: PlayoffFinishingPositionRange[];
+    finishingPositionsAvailable?: number[];
+}
+export declare function getPlayoffProfiles(structureType: string, drawSize: number, groupSize?: number): PlayoffProfiles;
+export declare function clearPlayoffProfilesCache(): void;

package/dist/components/topology-builder/domain/previewGenerator.d.ts

@@ -0,0 +1,9 @@
+import { SchematicMatchUp } from '../../renderSchematicStructure';
+export declare function generatePreviewMatchUps({ structureType, drawSize, stage, structureId, qualifyingPositions, structureOptions }: {
+    structureType: string;
+    drawSize: number;
+    stage?: string;
+    structureId?: string;
+    qualifyingPositions?: number;
+    structureOptions?: any;
+}): SchematicMatchUp[];

package/dist/components/topology-builder/domain/templates.d.ts

@@ -0,0 +1,2 @@
+import { TopologyTemplate } from '../types';
+export declare const standardTemplates: TopologyTemplate[];

package/dist/components/topology-builder/domain/topologyToDrawOptions.d.ts

@@ -0,0 +1,6 @@
+import { TopologyState } from '../types';
+export interface DrawOptionsResult {
+    drawOptions: any;
+    postGenerationMethods: any[];
+}
+export declare function topologyToDrawOptions(state: TopologyState): DrawOptionsResult;

package/dist/components/topology-builder/domain/topologyValidator.d.ts

@@ -0,0 +1,8 @@
+import { TopologyState } from '../types';
+export interface ValidationError {
+    severity: 'error' | 'warning';
+    message: string;
+    nodeId?: string;
+    edgeId?: string;
+}
+export declare function validateTopology(state: TopologyState): ValidationError[];