courthive-components 3.3.0 → 3.4.0

package/dist/components/policy-catalog/editors/scoring/domain/scoringProjections.d.ts

@@ -0,0 +1,23 @@
+import { ScoringPolicyData, AllowedFormatEntry } from '../types';
+type RegistryEntry = {
+    key?: string;
+    name?: string;
+    format?: string;
+    desc?: string;
+    desc2?: string;
+};
+export declare function lookupRegistryFormat(format: string | undefined): RegistryEntry | undefined;
+export declare const MATCH_UP_FORMAT_REGISTRY_SORTED: RegistryEntry[];
+export declare function formatStringOf(entry: AllowedFormatEntry): string;
+export declare function formatNameOf(entry: AllowedFormatEntry): string;
+export declare function formatDescriptionOf(entry: AllowedFormatEntry): string;
+export declare function asMatchUpFormatEntry(entry: AllowedFormatEntry): {
+    name?: string;
+    description?: string;
+    matchUpFormat: string;
+    categoryNames?: string[];
+    categoryTypes?: string[];
+};
+export declare const FORMAT_STANDARD = "SET3-S:6/TB7";
+export declare function emptyScoringPolicy(): ScoringPolicyData;
+export {};

package/dist/components/policy-catalog/editors/scoring/index.d.ts

@@ -0,0 +1,3 @@
+export { ScoringEditorControl, createScoringEditor } from './scoringEditorControl';
+export type { ScoringPolicyData, ScoringEditorConfig, MatchUpStatusKey, MatchUpFormatEntry, AllowedFormatEntry, } from './types';
+export { MATCH_UP_FORMAT_REGISTRY_SORTED, lookupRegistryFormat, emptyScoringPolicy, FORMAT_STANDARD, } from './domain/scoringProjections';

package/dist/components/policy-catalog/editors/scoring/scoringEditorControl.d.ts

@@ -0,0 +1,21 @@
+import { ScoringEditorStore } from './scoringEditorStore';
+import { ScoringPolicyData, ScoringEditorConfig } from './types';
+import { PolicyEditorInstance as CatalogEditorInstance } from '../../types';
+export declare class ScoringEditorControl {
+    private readonly store;
+    private readonly panel;
+    private readonly unsubscribe;
+    private container;
+    constructor(config: ScoringEditorConfig);
+    render(container: HTMLElement): void;
+    destroy(): void;
+    getData(): ScoringPolicyData;
+    setData(data: ScoringPolicyData): void;
+    getStore(): ScoringEditorStore;
+    static createEditorInstance(config: {
+        initialData: Record<string, unknown>;
+        onChange: (data: Record<string, unknown>) => void;
+        readonly?: boolean;
+    }): CatalogEditorInstance;
+}
+export declare function createScoringEditor(config: ScoringEditorConfig, container: HTMLElement): ScoringEditorControl;

package/dist/components/policy-catalog/editors/scoring/scoringEditorPanel.d.ts

@@ -0,0 +1,6 @@
+import { ScoringEditorState } from './types';
+import { ScoringEditorStore } from './scoringEditorStore';
+export declare function buildScoringEditorPanel(store: ScoringEditorStore): {
+    element: HTMLElement;
+    update(state: ScoringEditorState): void;
+};

package/dist/components/policy-catalog/editors/scoring/scoringEditorStore.d.ts

@@ -0,0 +1,33 @@
+import { ScoringPolicyData, ScoringEditorState, ScoringEditorSection, ScoringEditorChangeListener, ScoringEditorConfig, MatchUpStatusKey, AllowedFormatField, MatchUpFormatEntry } from './types';
+export declare class ScoringEditorStore {
+    private state;
+    private readonly listeners;
+    private readonly config;
+    constructor(config: ScoringEditorConfig);
+    isReadonly(): boolean;
+    getState(): ScoringEditorState;
+    getData(): ScoringPolicyData;
+    setData(data: ScoringPolicyData): void;
+    toggleSection(sectionId: ScoringEditorSection): void;
+    toggleStatus(key: MatchUpStatusKey): void;
+    setAdvancedOpen(value: boolean): void;
+    setDefaultMatchUpFormat(value: string): void;
+    setRequireParticipants(value: boolean): void;
+    setRequireAllPositions(value: 'default' | 'true' | 'false'): void;
+    setAllowChangePropagation(value: boolean): void;
+    setAllowDeletionDraws(value: boolean): void;
+    setAllowDeletionStructures(value: boolean): void;
+    addAllowedFormat(seed?: Partial<MatchUpFormatEntry>): void;
+    removeAllowedFormat(index: number): void;
+    setAllowedFormatField(index: number, field: AllowedFormatField, value: string): void;
+    isAllowedFormatDuplicate(format: string, excludeIndex?: number): boolean;
+    addAllowedFormatCategory(index: number, kind: 'categoryNames' | 'categoryTypes', value: string): void;
+    removeAllowedFormatCategory(index: number, kind: 'categoryNames' | 'categoryTypes', valueIndex: number): void;
+    addStatusCode(status: MatchUpStatusKey, value: string): void;
+    removeStatusCode(status: MatchUpStatusKey, index: number): void;
+    addProcessCode(value: string): void;
+    removeProcessCode(index: number): void;
+    subscribe(listener: ScoringEditorChangeListener): () => void;
+    private commitDraft;
+    private emit;
+}

package/dist/components/policy-catalog/editors/scoring/sections/allowedFormatsSection.d.ts

@@ -0,0 +1,6 @@
+import { ScoringEditorState } from '../types';
+import { ScoringEditorStore } from '../scoringEditorStore';
+export declare function buildAllowedFormatsSection(store: ScoringEditorStore): {
+    element: HTMLElement;
+    update(state: ScoringEditorState): void;
+};

package/dist/components/policy-catalog/editors/scoring/sections/defaultsSection.d.ts

@@ -0,0 +1,6 @@
+import { ScoringEditorState } from '../types';
+import { ScoringEditorStore } from '../scoringEditorStore';
+export declare function buildDefaultsSection(store: ScoringEditorStore): {
+    element: HTMLElement;
+    update(state: ScoringEditorState): void;
+};

package/dist/components/policy-catalog/editors/scoring/sections/matchUpFormatPicker.d.ts

@@ -0,0 +1,35 @@
+/**
+ * MatchUp Format Picker — Preset dropdown + free-text + structured builder.
+ *
+ * V1 UX:
+ *   ┌─ Preset ──────────────────────────────────────────┐
+ *   │ [Standard (BO3, sets to 6, TB7)              ▾]   │
+ *   │   ↳ shows the matching preset when the underlying │
+ *   │     format string is one we ship; "Custom" when   │
+ *   │     it isn't.                                      │
+ *   ├─ Custom format (visible only on "Custom" preset) ─┤
+ *   │ [SET3-S:6/TB7                              ] [✓] │
+ *   ├─ Build ▾ (collapsible structured editor) ────────┤
+ *   │   bestOf  [3 ▾]                                  │
+ *   │   set type  ◉ Standard   ○ Tiebreak   ○ Timed    │
+ *   │   …conditional fields per set type…              │
+ *   │   [ ] Different final-set rules                   │
+ *   │ Result: SET3-S:6/TB7  [✓ valid]                  │
+ *   └──────────────────────────────────────────────────┘
+ *
+ * The structured builder targets the SET-rooted tennis-family case (which
+ * covers 95%+ of the consumers' real-world formats). Sports with other
+ * roots (HAL, QTR, RND, MAP…) still set the value via the free-text
+ * field; the picker round-trips them but exposes no specialized UI.
+ */
+export interface MatchUpFormatPickerConfig {
+    initialValue?: string;
+    readonly?: boolean;
+    onChange: (value: string) => void;
+}
+export interface MatchUpFormatPickerHandle {
+    element: HTMLElement;
+    setValue(value: string): void;
+    destroy(): void;
+}
+export declare function buildMatchUpFormatPicker(config: MatchUpFormatPickerConfig): MatchUpFormatPickerHandle;

package/dist/components/policy-catalog/editors/scoring/sections/statusCodesSection.d.ts

@@ -0,0 +1,6 @@
+import { ScoringEditorState } from '../types';
+import { ScoringEditorStore } from '../scoringEditorStore';
+export declare function buildStatusCodesSection(store: ScoringEditorStore): {
+    element: HTMLElement;
+    update(state: ScoringEditorState): void;
+};

package/dist/components/policy-catalog/editors/scoring/sections/tagListEditor.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Small chip-list editor used by the "Allowed match-up formats" section
+ * and each of the six status-code refinement groups. Repeats the same
+ * UX: existing items render as removable chips, a single text input +
+ * Add button appends new values.
+ *
+ * The host owns the array — the editor only emits add(value) /
+ * remove(index). State for the input text is purely local DOM.
+ */
+export interface TagListEditorConfig {
+    values: string[];
+    placeholder?: string;
+    readonly?: boolean;
+    validate?: (value: string) => boolean;
+    invalidMessage?: string;
+    onAdd: (value: string) => void;
+    onRemove: (index: number) => void;
+}
+export interface TagListEditorHandle {
+    element: HTMLElement;
+    setValues(values: string[]): void;
+    destroy(): void;
+}
+export declare function buildTagListEditor(config: TagListEditorConfig): TagListEditorHandle;

package/dist/components/policy-catalog/editors/scoring/types.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Scoring Policy Editor — Type Definitions
+ *
+ * Mirrors the factory's scoring policy data shape (see
+ * factory/src/fixtures/policies/POLICY_SCORING_DEFAULT.ts).
+ *
+ * The factory does not export a TypeScript interface for the scoring
+ * policy itself — the fixture defines the shape via runtime defaults.
+ * We re-derive the shape here so the editor can stay type-safe without
+ * dragging factory internals into courthive-components.
+ */
+export type MatchUpStatusKey = 'ABANDONED' | 'CANCELLED' | 'DEFAULTED' | 'INCOMPLETE' | 'RETIRED' | 'WALKOVER';
+export declare const MATCH_UP_STATUS_KEYS: MatchUpStatusKey[];
+export type RequireAllPositionsTriState = 'default' | 'true' | 'false';
+export interface AllowDeletionWithScoresPresent {
+    drawDefinitions?: boolean;
+    structures?: boolean;
+}
+export interface StageSequenceOverride {
+    requireAllPositionsAssigned?: boolean;
+}
+export interface MatchUpFormatEntry {
+    name?: string;
+    description?: string;
+    matchUpFormat: string;
+    categoryNames?: string[];
+    categoryTypes?: string[];
+}
+export type AllowedFormatEntry = string | MatchUpFormatEntry;
+export type AllowedFormatField = 'name' | 'description' | 'matchUpFormat';
+export interface ScoringPolicyData {
+    policyName?: string;
+    defaultMatchUpFormat?: string;
+    matchUpFormats?: AllowedFormatEntry[];
+    requireParticipantsForScoring?: boolean;
+    requireAllPositionsAssigned?: boolean;
+    allowChangePropagation?: boolean;
+    allowDeletionWithScoresPresent?: AllowDeletionWithScoresPresent;
+    matchUpStatusCodes?: Partial<Record<MatchUpStatusKey, string[]>>;
+    stage?: Record<string, {
+        stageSequence?: Record<string, StageSequenceOverride>;
+    }>;
+    processCodes?: {
+        incompleteAssignmentsOnDefault?: string[];
+    };
+}
+export type ScoringEditorSection = 'defaults' | 'allowedFormats' | 'statusCodes';
+export interface ScoringEditorState {
+    draft: ScoringPolicyData;
+    expandedSections: Set<ScoringEditorSection>;
+    expandedStatuses: Set<MatchUpStatusKey>;
+    advancedOpen: boolean;
+    dirty: boolean;
+}
+export type ScoringEditorChangeListener = (state: ScoringEditorState) => void;
+export interface ScoringEditorConfig {
+    initialPolicy?: ScoringPolicyData;
+    readonly?: boolean;
+    onChange?: (policy: ScoringPolicyData) => void;
+}

package/dist/components/policy-catalog/index.d.ts

@@ -17,6 +17,8 @@ export { buildJsonEditor } from './ui/jsonEditor';
 export { SchedulingEditorControl, createSchedulingEditor, SchedulingEditorStore, validateSchedulingPolicy, formatCodeLabel, emptySchedulingPolicy, buildSchedulingEditorPanel } from './editors/scheduling';
 export { RankingPointsEditorControl, createRankingPointsEditor, RankingPointsEditorStore, buildRankingPointsEditorPanel, emptyRankingPolicy } from './editors/ranking';
 export { SeedingEditorControl, createSeedingEditor, SeedingEditorStore, buildSeedingEditorPanel, emptySeedingPolicy, POSITIONING_OPTIONS, DRAW_TYPE_OPTIONS } from './editors/seeding';
+export { ScoringEditorControl, createScoringEditor, MATCH_UP_FORMAT_REGISTRY_SORTED, lookupRegistryFormat, emptyScoringPolicy, FORMAT_STANDARD, } from './editors/scoring';
+export type { ScoringPolicyData, ScoringEditorConfig, MatchUpStatusKey, MatchUpFormatEntry, AllowedFormatEntry, } from './editors/scoring';
 export type { PolicyCatalogItem, PolicyCatalogState, PolicyCatalogChangeListener, PolicyCatalogConfig, PolicyEditorInstance, PolicyEditorPlugin, PolicySource, PolicyTypeGroup, PolicyTypeMeta, CatalogGroupBy, UIPanel } from './types';
 export type { SchedulingPolicyData, SchedulingEditorState, SchedulingEditorSection, SchedulingEditorChangeListener, SchedulingEditorConfig, SchedulingValidationResult, ValidationSeverity, MinutesEntry, AverageTimeEntry, RecoveryTimeEntry, MatchUpAverageTime, MatchUpRecoveryTime } from './editors/scheduling';
 export type { RankingPolicyData, RankingPointsEditorState, RankingEditorSection, RankingPointsEditorChangeListener, RankingPointsEditorConfig, AwardProfileData, QualityWinProfileData, AggregationRulesData, TableLayout } from './editors/ranking';

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

@@ -17,6 +17,12 @@ export interface CatalogMatchUpItem {
     drawId: string;
     drawName?: string;
     structureId: string;
+    /** Human-readable structure label set by the factory (e.g. "Main",
+     *  "Consolation", "Compass NE"). Optional because some structures
+     *  ship without one — the catalog falls back to a labeled stage and
+     *  finally the eventName alone so the "by structure" group header
+     *  never shows a raw structureId GUID. */
+    structureName?: string;
     /** Draw stage — MAIN / CONSOLATION / PLAYOFF / QUALIFYING / ROUND_ROBIN /
      *  etc. Rendered as a chip when present and not MAIN so a Quarterfinal in
      *  the consolation bracket reads distinctly from a Quarterfinal in the
@@ -53,7 +59,7 @@ export interface ScheduleIssue {
     /** All matchUpIds involved in this conflict (for click-to-scroll fallback) */
     conflictMatchUpIds?: string[];
 }
-export type MatchUpCatalogGroupBy = 'event' | 'draw' | 'round' | 'structure';
+export type MatchUpCatalogGroupBy = 'event' | 'draw' | 'round' | 'structure' | 'time';
 export interface CatalogFilters {
     eventType?: string;
     eventName?: string;