courthive-components 1.0.4 → 1.1.1

package/dist/components/schedule-page/types.d.ts

@@ -0,0 +1,218 @@
+/**
+ * Schedule Page — Type Definitions
+ *
+ * All interfaces for the schedule page component.
+ * The component provides layout + matchUp catalog; the consumer injects the court grid.
+ */
+export interface MatchUpSide {
+    participantName?: string;
+    participantId?: string;
+    seedNumber?: number;
+    ranking?: number;
+}
+export interface CatalogMatchUpItem {
+    matchUpId: string;
+    eventId: string;
+    eventName: string;
+    drawId: string;
+    drawName?: string;
+    structureId: string;
+    roundNumber: number;
+    roundName?: string;
+    matchUpFormat?: string;
+    matchUpType?: 'SINGLES' | 'DOUBLES';
+    matchUpStatus?: string;
+    gender?: string;
+    sides?: MatchUpSide[];
+    isScheduled: boolean;
+    scheduledTime?: string;
+    scheduledCourtName?: string;
+}
+export interface ScheduleDate {
+    date: string;
+    isActive: boolean;
+    matchUpCount?: number;
+    issueCount?: number;
+}
+export type ScheduleIssueSeverity = 'ERROR' | 'WARN' | 'INFO';
+export interface ScheduleIssue {
+    severity: ScheduleIssueSeverity;
+    message: string;
+    matchUpId?: string;
+    date?: string;
+    /** Structured conflict data for rich rendering */
+    issueType?: string;
+    prefix?: string;
+    participants?: string;
+    conflictParticipants?: string[];
+    /** All matchUpIds involved in this conflict (for click-to-scroll fallback) */
+    conflictMatchUpIds?: string[];
+}
+export type MatchUpCatalogGroupBy = 'event' | 'draw' | 'round' | 'structure';
+export interface CatalogFilters {
+    eventType?: string;
+    eventName?: string;
+    drawName?: string;
+    gender?: string;
+    roundName?: string;
+}
+export type ScheduledBehavior = 'dim' | 'hide';
+/**
+ * Controls how drop/remove actions are committed:
+ * - 'immediate': each drop fires the consumer callback right away (e.g. executionQueue per action)
+ * - 'bulk': actions accumulate in a pending queue; consumer calls save() to flush
+ */
+export type SchedulingMode = 'immediate' | 'bulk';
+export interface PendingScheduleAction {
+    kind: 'schedule' | 'unschedule';
+    matchUpId: string;
+    /** Present for 'schedule' actions — the full item that was dropped */
+    matchUp?: CatalogMatchUpItem;
+    /** The DragEvent from the drop, if available */
+    event?: DragEvent;
+}
+export interface CatalogMatchUpDragPayload {
+    type: 'CATALOG_MATCHUP';
+    matchUp: CatalogMatchUpItem;
+}
+export interface GridMatchUpDragPayload {
+    type: 'GRID_MATCHUP';
+    matchUp: CatalogMatchUpItem;
+    sourceTime?: string;
+    sourceCourt?: string;
+}
+export type SchedulePageDragPayload = CatalogMatchUpDragPayload | GridMatchUpDragPayload;
+export interface SchedulePageConfig {
+    matchUpCatalog: CatalogMatchUpItem[];
+    scheduleDates: ScheduleDate[];
+    issues?: ScheduleIssue[];
+    courtGridElement?: HTMLElement;
+    /** Max height for the court grid viewport (e.g. '500px', '60vh'). Defaults to none (fills available space). */
+    gridMaxHeight?: string;
+    /** When true, the left column (date strip + issues panel) is not rendered at all. */
+    hideLeft?: boolean;
+    /** Which side to place the matchUp catalog. Defaults to 'right'. */
+    catalogSide?: 'left' | 'right';
+    scheduledBehavior?: ScheduledBehavior;
+    schedulingMode?: SchedulingMode;
+    onDateSelected?: (date: string) => void;
+    onMatchUpDrop?: (payload: SchedulePageDragPayload, event: DragEvent) => void;
+    onMatchUpRemove?: (matchUpId: string) => void;
+    onMatchUpSelected?: (matchUp: CatalogMatchUpItem | null) => void;
+    /** Called in 'bulk' mode when the user triggers save — receives all pending actions */
+    onBulkSave?: (actions: PendingScheduleAction[]) => void;
+}
+export interface SchedulePageState {
+    matchUpCatalog: CatalogMatchUpItem[];
+    scheduleDates: ScheduleDate[];
+    issues: ScheduleIssue[];
+    selectedDate: string | null;
+    selectedMatchUp: CatalogMatchUpItem | null;
+    catalogSearchQuery: string;
+    catalogGroupBy: MatchUpCatalogGroupBy;
+    catalogFilters: CatalogFilters;
+    showCompleted: boolean;
+    showScheduled: boolean;
+    scheduledBehavior: ScheduledBehavior;
+    schedulingMode: SchedulingMode;
+    pendingActions: PendingScheduleAction[];
+    hasUnsavedChanges: boolean;
+    leftCollapsed: boolean;
+    hideLeft: boolean;
+}
+export type SchedulePageChangeListener = (state: SchedulePageState) => void;
+export interface ScheduleIssueCounts {
+    total: number;
+    ERROR: number;
+    WARN: number;
+    INFO: number;
+}
+export interface ScheduleIssueIndex {
+    all: ScheduleIssue[];
+    bySeverity: Record<ScheduleIssueSeverity, ScheduleIssue[]>;
+    byDate: Record<string, ScheduleIssue[]>;
+    counts: ScheduleIssueCounts;
+    countsByDate: Record<string, ScheduleIssueCounts>;
+}
+export interface UIPanel<T = unknown> {
+    element: HTMLElement;
+    update: (state: T) => void;
+    destroy?: () => void;
+}
+/** Field identifiers for the 3-zone cell layout */
+export type ScheduleCellField = 'time' | 'eventRound' | 'participants' | 'score' | 'matchUpStatus' | 'matchUpFormat' | 'umpire';
+/** Controls how participant names are rendered inside a cell */
+export interface ParticipantDisplayConfig {
+    nameFormat?: 'full' | 'last' | 'lastFirst' | 'firstLast';
+    showSeed?: boolean;
+    showRanking?: boolean;
+    showNationality?: boolean;
+    boldWinner?: boolean;
+    showPotentials?: boolean;
+}
+/**
+ * JSON-serializable cell configuration.
+ * 3 fixed zones (header, body, footer), each containing an ordered array of field identifiers.
+ * Safe for factory extensions and publishing data.
+ */
+export interface ScheduleCellConfig {
+    header: ScheduleCellField[];
+    body: ScheduleCellField[];
+    footer: ScheduleCellField[];
+    participantDisplay?: ParticipantDisplayConfig;
+}
+/** Participant info for a single side of a matchUp cell */
+export interface ScheduleCellSide {
+    sideNumber?: number;
+    participantName?: string;
+    participantId?: string;
+    seedNumber?: number;
+    ranking?: number;
+    nationality?: string;
+    /** Team name when participant is a member of a team (tie/team event) */
+    teamName?: string;
+    /** True if this side is a BYE (no participant) */
+    bye?: boolean;
+}
+/**
+ * Flat data shape the cell renderer consumes — mapped from factory matchUp objects.
+ * Decouples the renderer from the factory's nested matchUp shape.
+ */
+export interface ScheduleCellData {
+    matchUpId: string;
+    drawId?: string;
+    eventName?: string;
+    roundName?: string;
+    matchUpFormat?: string;
+    matchUpType?: string;
+    matchUpStatus?: string;
+    winningSide?: number;
+    gender?: string;
+    sides?: ScheduleCellSide[];
+    potentialParticipants?: any[][];
+    schedule?: {
+        scheduledTime?: string;
+        startTime?: string;
+        timeModifiers?: string[];
+        courtAnnotation?: string;
+        courtId?: string;
+        courtOrder?: number;
+        venueId?: string;
+    };
+    score?: {
+        scoreStringSide1?: string;
+        scoreStringSide2?: string;
+    };
+    umpire?: string;
+    /** Conflict state injected by proConflicts */
+    scheduleState?: string;
+    issueType?: string;
+    issueIds?: string[];
+    /** Blocked cell (alternative to matchUp) */
+    isBlocked?: boolean;
+    booking?: {
+        bookingType?: string;
+        rowCount?: number;
+        notes?: string;
+    };
+}

package/dist/components/schedule-page/ui/courtGridSlot.d.ts

@@ -0,0 +1,8 @@
+import { SchedulePageState, UIPanel, SchedulePageDragPayload } from '../types';
+export interface CourtGridSlotCallbacks {
+    onMatchUpDrop?: (payload: SchedulePageDragPayload, event: DragEvent) => void;
+}
+export interface CourtGridSlotOptions {
+    gridMaxHeight?: string;
+}
+export declare function buildCourtGridSlot(courtGridElement: HTMLElement | undefined, callbacks: CourtGridSlotCallbacks, options?: CourtGridSlotOptions): UIPanel<SchedulePageState>;

package/dist/components/schedule-page/ui/dateStrip.d.ts

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

package/dist/components/schedule-page/ui/inspectorPanel.d.ts

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

package/dist/components/schedule-page/ui/issuesPanel.d.ts

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

package/dist/components/schedule-page/ui/matchUpCard.d.ts

@@ -0,0 +1,5 @@
+import { CatalogMatchUpItem } from '../types';
+export interface MatchUpCardCallbacks {
+    onClick?: (matchUp: CatalogMatchUpItem) => void;
+}
+export declare function buildMatchUpCard(item: CatalogMatchUpItem, callbacks: MatchUpCardCallbacks): HTMLElement;

package/dist/components/schedule-page/ui/matchUpCatalog.d.ts

@@ -0,0 +1,11 @@
+import { SchedulePageState, UIPanel, MatchUpCatalogGroupBy, CatalogMatchUpItem, CatalogFilters } from '../types';
+export interface MatchUpCatalogCallbacks {
+    onSearchChange: (query: string) => void;
+    onGroupByChange: (mode: MatchUpCatalogGroupBy) => void;
+    onFilterChange: (filters: CatalogFilters) => void;
+    onShowCompletedChange: (show: boolean) => void;
+    onShowScheduledChange?: (show: boolean) => void;
+    onMatchUpSelected?: (matchUp: CatalogMatchUpItem) => void;
+    onDropRemove?: (matchUpId: string) => void;
+}
+export declare function buildMatchUpCatalog(callbacks: MatchUpCatalogCallbacks): UIPanel<SchedulePageState>;

package/dist/components/schedule-page/ui/scheduleCellTypeAhead.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Schedule Cell TypeAhead — inline autocomplete for empty grid cells.
+ *
+ * Activates an Awesomplete typeahead input inside an empty schedule cell.
+ * The consumer provides a list of unscheduled matchUps and a selection callback.
+ * Reuses the existing createTypeAhead helper (Awesomplete wrapper).
+ */
+export interface ScheduleCellTypeAheadOptions {
+    /** The grid cell element to activate the typeahead in */
+    cell: HTMLElement;
+    /** Returns the list of assignable matchUps as { label, value } */
+    listProvider: () => Array<{
+        label: string;
+        value: string;
+    }>;
+    /** Called when a matchUp is selected — value is the matchUpId */
+    onSelect: (matchUpId: string) => void;
+    /** Called when the typeahead is dismissed without selection */
+    onCancel?: () => void;
+}
+export declare function activateScheduleCellTypeAhead({ cell, listProvider, onSelect, onCancel }: ScheduleCellTypeAheadOptions): {
+    destroy: () => void;
+};

package/dist/components/schedule-page/ui/scheduleGridCell.d.ts

@@ -0,0 +1,8 @@
+import { ScheduleCellConfig, ScheduleCellData } from '../types';
+export declare const DEFAULT_SCHEDULE_CELL_CONFIG: ScheduleCellConfig;
+export declare function buildScheduleGridCell(data: ScheduleCellData, config?: ScheduleCellConfig): HTMLElement;
+/**
+ * Maps a factory hydrated matchUp object to the flat ScheduleCellData shape.
+ * Handles sides[].participant.participantName nesting, schedule.* extraction, etc.
+ */
+export declare function mapMatchUpToCellData(matchUp: any): ScheduleCellData;

package/dist/components/schedule-page/ui/schedulePageLayout.d.ts

@@ -0,0 +1,18 @@
+import { SchedulePageState, UIPanel } from '../types';
+export interface SchedulePageLayoutPanels {
+    dateStrip: UIPanel<SchedulePageState>;
+    issuesPanel: UIPanel<SchedulePageState>;
+    courtGridSlot: UIPanel<SchedulePageState>;
+    matchUpCatalog: UIPanel<SchedulePageState>;
+    inspectorPanel: UIPanel<SchedulePageState>;
+}
+export interface SchedulePageLayoutCallbacks {
+    onToggleLeft: () => void;
+}
+export declare function buildSchedulePageLayout(panels: SchedulePageLayoutPanels, callbacks: SchedulePageLayoutCallbacks, options?: {
+    hideLeft?: boolean;
+    catalogSide?: 'left' | 'right';
+}): {
+    element: HTMLElement;
+    update: (state: SchedulePageState) => void;
+};

package/dist/components/schedule-page/ui/styles.d.ts

@@ -0,0 +1,41 @@
+export declare const splLayoutStyle: () => string;
+export declare const splLeftStyle: () => string;
+export declare const splToggleStyle: () => string;
+export declare const splCenterStyle: () => string;
+export declare const splCenterHeaderStyle: () => string;
+export declare const splCenterTitleStyle: () => string;
+export declare const splCenterMetaStyle: () => string;
+export declare const splGridSlotStyle: () => string;
+export declare const splRightStyle: () => string;
+export declare const splMatchUpCardStyle: () => string;
+export declare const splCardTitleStyle: () => string;
+export declare const splCardSidesStyle: () => string;
+export declare const splCardMetaStyle: () => string;
+export declare const splCardChipsStyle: () => string;
+export declare const splCardChipStyle: () => 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 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 spGroupChevronStyle: () => string;
+export declare const spIssuesStyle: () => string;
+export declare const spIssueStyle: () => string;
+export declare const spIssueCodeStyle: () => string;
+export declare const spIssueMsgStyle: () => 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;

package/dist/components/scheduling-profile/controller/schedulingProfileControl.d.ts

@@ -0,0 +1,14 @@
+import { ProfileStore } from '../engine/profileStore';
+import { SchedulingProfileConfig, SchedulingProfile } from '../types';
+export declare class SchedulingProfileControl {
+    private readonly store;
+    private readonly layout;
+    private readonly unsubscribe;
+    private readonly popover;
+    private container;
+    constructor(config: SchedulingProfileConfig);
+    render(container: HTMLElement): void;
+    destroy(): void;
+    getProfile(): SchedulingProfile;
+    getStore(): ProfileStore;
+}

package/dist/components/scheduling-profile/domain/catalogProjections.d.ts

@@ -0,0 +1,16 @@
+import { CatalogRoundItem, CatalogGroupBy, PlannedRoundBehavior } from '../types';
+export declare function filterCatalog(catalog: CatalogRoundItem[], query: string, plannedKeys: Set<string>, behavior?: PlannedRoundBehavior): Array<CatalogRoundItem & {
+    isPlanned: boolean;
+}>;
+export declare function groupCatalog(items: Array<CatalogRoundItem & {
+    isPlanned: boolean;
+}>, mode: CatalogGroupBy): Map<string, Array<CatalogRoundItem & {
+    isPlanned: boolean;
+}>>;
+export declare function getPlannedRoundKeys(profile: {
+    venues: {
+        rounds: {
+            roundSegment?: unknown;
+        }[];
+    }[];
+}[]): Set<string>;

package/dist/components/scheduling-profile/domain/dndApply.d.ts

@@ -0,0 +1,2 @@
+import { SchedulingProfile, DragPayload, DropTarget, DropResult } from '../types';
+export declare function applyDropCommit(profileDraft: SchedulingProfile, drag: DragPayload, drop: DropTarget): DropResult;

package/dist/components/scheduling-profile/domain/issueIndex.d.ts

@@ -0,0 +1,2 @@
+import { ValidationResult, IssueIndex } from '../types';
+export declare function buildIssueIndex(results: ValidationResult[]): IssueIndex;

package/dist/components/scheduling-profile/domain/profileProjections.d.ts

@@ -0,0 +1,6 @@
+import { SchedulingProfile, RoundProfile, RoundKey, RoundLocator, ValidationResult, Severity } from '../types';
+export declare function getVenueRounds(profile: SchedulingProfile, date: string, venueId: string): RoundProfile[];
+export declare function getRoundAt(profile: SchedulingProfile, locator: RoundLocator): RoundProfile | null;
+export declare function findIssuesForLocator(ruleResults: ValidationResult[], locator: RoundLocator): ValidationResult[];
+export declare function maxSeverity(issues: ValidationResult[]): Severity | null;
+export declare function findRoundInProfile(profile: SchedulingProfile, roundKey: RoundKey): RoundLocator | null;

package/dist/components/scheduling-profile/domain/utils.d.ts

@@ -0,0 +1,7 @@
+import { RoundProfile, RoundLocator, RoundKey } from '../types';
+export declare function deepClone<T>(obj: T): T;
+export declare function clamp(n: number, lo: number, hi: number): number;
+export declare function roundKeyString(r: RoundKey | RoundProfile): string;
+export declare function roundLabel(r: RoundProfile): string;
+export declare function sameLocator(a: RoundLocator | null, b: RoundLocator | null): boolean;
+export declare function pickRoundKey(r: RoundProfile): RoundKey;

package/dist/components/scheduling-profile/domain/validateProfile.d.ts

@@ -0,0 +1,13 @@
+import { SchedulingProfile, ValidationResult, TemporalAdapter, DependencyAdapter, FlattenedRound } from '../types';
+export interface ValidateProfileParams {
+    profile: SchedulingProfile;
+    temporal?: TemporalAdapter;
+    dependencies?: DependencyAdapter;
+    venueOrder?: string[];
+}
+export declare function validateProfile({ profile, temporal, dependencies, venueOrder }: ValidateProfileParams): ValidationResult[];
+export declare function validateRoundPrecedenceLocal({ profile }: {
+    profile: SchedulingProfile;
+    venueOrder?: string[];
+}): ValidationResult[];
+export declare function flatten(profile: SchedulingProfile): FlattenedRound[];

package/dist/components/scheduling-profile/engine/profileStore.d.ts

@@ -0,0 +1,27 @@
+import { ProfileStoreState, ProfileChangeListener, SchedulingProfileConfig, SchedulingProfile, RoundLocator, DragPayload, DropTarget, CatalogGroupBy, CatalogRoundItem, FixAction } from '../types';
+export declare class ProfileStore {
+    private state;
+    private readonly listeners;
+    private readonly config;
+    constructor(config: SchedulingProfileConfig);
+    getState(): ProfileStoreState;
+    getSchedulingProfile(): SchedulingProfile;
+    selectDate(date: string): void;
+    selectCard(locator: RoundLocator | null): void;
+    setCatalogSearch(query: string): void;
+    setCatalogGroupBy(mode: CatalogGroupBy): void;
+    navigateToRound(item: CatalogRoundItem): void;
+    dropRound(drag: DragPayload, drop: DropTarget): {
+        ok: boolean;
+        errorMessage?: string;
+    };
+    removeRound(locator: RoundLocator): void;
+    setNotBeforeTime(locator: RoundLocator, time: string | undefined): void;
+    applyFixAction(action: FixAction): void;
+    subscribe(listener: ProfileChangeListener): () => void;
+    private setState;
+    private commitProfile;
+    private addRejectionNotice;
+    private revalidate;
+    private emit;
+}

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

@@ -0,0 +1,25 @@
+import { SchedulingProfileConfig } from './types';
+import { SchedulingProfileControl } from './controller/schedulingProfileControl';
+/**
+ * Scheduling Profile — Public API
+ *
+ * Main entry point for the scheduling profile builder component.
+ */
+export { SchedulingProfileControl } from './controller/schedulingProfileControl';
+export { ProfileStore } from './engine/profileStore';
+export { validateProfile, type ValidateProfileParams } from './domain/validateProfile';
+export { buildIssueIndex } from './domain/issueIndex';
+export { applyDropCommit } from './domain/dndApply';
+export { filterCatalog, groupCatalog, getPlannedRoundKeys } from './domain/catalogProjections';
+export { getVenueRounds, getRoundAt, findIssuesForLocator, maxSeverity, findRoundInProfile } from './domain/profileProjections';
+export { deepClone, clamp, roundKeyString, roundLabel, sameLocator, pickRoundKey } from './domain/utils';
+export { buildDateStrip } from './ui/dateStrip';
+export { buildVenueBoard } from './ui/venueBoard';
+export { buildRoundCatalog } from './ui/roundCatalog';
+export { buildInspectorPanel } from './ui/inspectorPanel';
+export { buildIssuesPanel } from './ui/issuesPanel';
+export { buildRoundCard } from './ui/roundCard';
+export { createCardPopoverManager } from './ui/cardPopover';
+export { buildSchedulingProfileLayout } from './ui/schedulingProfileLayout';
+export type { SchedulingProfile, ScheduleDay, VenueSchedule, RoundProfile, RoundSegment, VenueInfo, CatalogRoundItem, CatalogGroupBy, RoundKey, RoundLocator, DragPayload, CatalogDragPayload, PlannedDragPayload, DropTarget, DropResult, Severity, ValidationCode, FixActionKind, FixAction, ValidationResult, SeverityCounts, IssueIndex, ProfileStoreState, ProfileChangeListener, TemporalAdapter, DemandAdapter, DependencyAdapter, SchedulingProfileConfig, UIPanel, FlattenedRound, PlannedRoundBehavior } from './types';
+export declare function createSchedulingProfile(config: SchedulingProfileConfig, container: HTMLElement): SchedulingProfileControl;