courthive-components 1.1.0 → 1.1.1

package/dist/components/topology-builder/engine/topologyStore.d.ts

@@ -0,0 +1,30 @@
+import { TopologyNode, TopologyEdge, TopologyState, TopologyChangeListener } from '../types';
+export declare class TopologyStore {
+    private state;
+    private listeners;
+    constructor(initialState?: Partial<TopologyState>);
+    getState(): TopologyState;
+    subscribe(listener: TopologyChangeListener): () => void;
+    private notify;
+    setDrawName(name: string): void;
+    addNode(partial: Omit<TopologyNode, 'id' | 'position'>): TopologyNode;
+    updateNode(nodeId: string, updates: Partial<Omit<TopologyNode, 'id'>>): void;
+    removeNode(nodeId: string): void;
+    addEdge(partial: Omit<TopologyEdge, 'id' | 'label'>): TopologyEdge | null;
+    updateEdge(edgeId: string, updates: Partial<Omit<TopologyEdge, 'id'>>): void;
+    removeEdge(edgeId: string): void;
+    selectNode(nodeId: string | null): void;
+    selectEdge(edgeId: string | null): void;
+    /**
+     * If the given node is a consolation structure, clamp its drawSize so it
+     * does not exceed the total capacity of inbound links.
+     */
+    private clampConsolationDrawSize;
+    /** Sum of losers that all inbound edges can deliver to a node. */
+    private inboundCapacity;
+    /** Find a non-overlapping position for a newly added node. */
+    private nextNodePosition;
+    autoLayout(): void;
+    loadState(newState: TopologyState): void;
+    private computeEdgeLabel;
+}

package/dist/components/topology-builder/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Topology Builder — Public API
+ */
+export { TopologyBuilderControl } from './controller/topologyBuilderControl';
+export { TopologyStore } from './engine/topologyStore';
+export { topologyToDrawOptions } from './domain/topologyToDrawOptions';
+export type { DrawOptionsResult } from './domain/topologyToDrawOptions';
+export { generateDrawFromTopology } from './domain/generateDrawFromTopology';
+export type { GenerationResult, StructureInfo } from './domain/generateDrawFromTopology';
+export { validateTopology } from './domain/topologyValidator';
+export type { ValidationError } from './domain/topologyValidator';
+export { generatePreviewMatchUps } from './domain/previewGenerator';
+export { getPlayoffProfiles, clearPlayoffProfilesCache } from './domain/playoffProfilesCache';
+export type { PlayoffProfiles, PlayoffRoundRange, PlayoffFinishingPositionRange } from './domain/playoffProfilesCache';
+export { standardTemplates } from './domain/templates';
+export { buildTopologyCanvas } from './ui/topologyCanvas';
+export { buildStructureCard, getPortPosition, getCardWidth, getNumRounds } from './ui/structureCard';
+export type { RoundAnnotation } from './ui/structureCard';
+export { buildNodeEditor } from './ui/nodeEditor';
+export { buildEdgeEditor } from './ui/edgeEditor';
+export { buildToolbar } from './ui/toolbar';
+export { buildTopologyBuilderLayout } from './ui/topologyBuilderLayout';
+export type { TopologyNode, TopologyEdge, TopologyState, TopologyChangeListener, TopologyBuilderConfig, TopologyTemplate, UIPanel } from './types';

package/dist/components/topology-builder/types.d.ts

@@ -0,0 +1,59 @@
+import { SchematicMatchUp } from '../renderSchematicStructure';
+export interface TopologyNode {
+    id: string;
+    structureName: string;
+    stage: 'MAIN' | 'QUALIFYING' | 'CONSOLATION' | 'PLAY_OFF';
+    structureType: string;
+    drawSize: number;
+    qualifyingPositions?: number;
+    matchUpFormat?: string;
+    structureOptions?: any;
+    position: {
+        x: number;
+        y: number;
+    };
+    matchUps?: SchematicMatchUp[];
+}
+export interface TopologyEdge {
+    id: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+    linkType: 'WINNER' | 'LOSER' | 'POSITION';
+    sourceRoundNumber?: number;
+    targetRoundNumber?: number;
+    feedProfile?: string;
+    finishingPositions?: number[];
+    qualifyingPositions?: number;
+    label?: string;
+}
+export interface TopologyState {
+    nodes: TopologyNode[];
+    edges: TopologyEdge[];
+    selectedNodeId: string | null;
+    selectedEdgeId: string | null;
+    drawName: string;
+    templateName?: string;
+}
+export type TopologyChangeListener = (state: TopologyState) => void;
+export interface TopologyBuilderConfig {
+    initialState?: Partial<TopologyState>;
+    onGenerate?: (state: TopologyState) => void;
+    onDoubleClickNode?: (node: TopologyNode, state: TopologyState) => void;
+    onSaveTemplate?: (state: TopologyState) => void;
+    onClear?: () => void;
+    templates?: TopologyTemplate[];
+    hideTemplates?: boolean;
+    hideGenerate?: boolean;
+    hideDelete?: boolean;
+    readOnly?: boolean;
+}
+export interface TopologyTemplate {
+    name: string;
+    description?: string;
+    state: Omit<TopologyState, 'selectedNodeId' | 'selectedEdgeId'>;
+}
+export interface UIPanel<T = unknown> {
+    element: HTMLElement;
+    update: (state: T) => void;
+    destroy?: () => void;
+}

package/dist/components/topology-builder/ui/edgeEditor.d.ts

@@ -0,0 +1,7 @@
+import { TopologyEdge, TopologyState, UIPanel } from '../types';
+export interface EdgeEditorCallbacks {
+    onUpdateEdge: (edgeId: string, updates: Partial<TopologyEdge>) => void;
+    onDeleteEdge: (edgeId: string) => void;
+    readOnly?: boolean;
+}
+export declare function buildEdgeEditor(callbacks: EdgeEditorCallbacks): UIPanel<TopologyState>;

package/dist/components/topology-builder/ui/nodeEditor.d.ts

@@ -0,0 +1,9 @@
+import { TopologyEdge, TopologyNode, TopologyState, UIPanel } from '../types';
+export interface NodeEditorCallbacks {
+    onUpdateNode: (nodeId: string, updates: Partial<TopologyNode>) => void;
+    onUpdateEdge: (edgeId: string, updates: Partial<TopologyEdge>) => void;
+    onDeleteNode: (nodeId: string) => void;
+    readOnly?: boolean;
+    hideDelete?: boolean;
+}
+export declare function buildNodeEditor(callbacks: NodeEditorCallbacks): UIPanel<TopologyState>;

package/dist/components/topology-builder/ui/structureCard.d.ts

@@ -0,0 +1,39 @@
+import { TopologyNode } from '../types';
+/**
+ * Compute the number of schematic rounds for a given draw configuration.
+ * For qualifying structures with qualifyingPositions, truncate to only
+ * the rounds needed to produce that many qualifiers.
+ */
+export declare function getNumRounds(node: TopologyNode): number;
+/**
+ * Compute the card width needed to fit the schematic preview.
+ */
+export declare function getCardWidth(node: TopologyNode): number;
+export interface RoundAnnotation {
+    roundNumber: number;
+    linkType: string;
+    direction: 'source' | 'target';
+    edgeId: string;
+    isSelected: boolean;
+}
+export interface PositionChip {
+    position: number;
+    edgeId: string;
+    targetName: string;
+}
+export interface StructureCardCallbacks {
+    onSelect: (nodeId: string) => void;
+    onSelectEdge: (edgeId: string) => void;
+    onDoubleClick?: (nodeId: string) => void;
+    onPortMouseDown: (nodeId: string, portType: 'winner' | 'loser') => void;
+    onPortMouseUp: (nodeId: string) => void;
+    onDragStart: (nodeId: string, startX: number, startY: number) => void;
+}
+export declare function buildStructureCard(node: TopologyNode, callbacks: StructureCardCallbacks, isSelected: boolean, hasWinnerLink: boolean, roundAnnotations?: RoundAnnotation[], warnings?: string[], advanceInfo?: string, positionChips?: PositionChip[]): HTMLElement;
+/**
+ * Get port position relative to canvas for SVG edge rendering.
+ */
+export declare function getPortPosition(node: TopologyNode, portType: 'input' | 'winner' | 'loser'): {
+    x: number;
+    y: number;
+};

package/dist/components/topology-builder/ui/toolbar.d.ts

@@ -0,0 +1,15 @@
+import { TopologyState, TopologyTemplate, UIPanel } from '../types';
+export interface ToolbarCallbacks {
+    onAddStructure: (stage: string, structureType?: string) => void;
+    onLoadTemplate: (template: TopologyTemplate) => void;
+    onAutoLayout: () => void;
+    onGenerate: () => void;
+    onSaveTemplate?: () => void;
+    onClear?: () => void;
+}
+export interface ToolbarOptions {
+    hideTemplates?: boolean;
+    hideGenerate?: boolean;
+    readOnly?: boolean;
+}
+export declare function buildToolbar(callbacks: ToolbarCallbacks, templates: TopologyTemplate[], options?: ToolbarOptions): UIPanel<TopologyState>;

package/dist/components/topology-builder/ui/topologyBuilderLayout.d.ts

@@ -0,0 +1,7 @@
+import { TopologyState, UIPanel } from '../types';
+export declare function buildTopologyBuilderLayout({ toolbar, canvas, nodeEditor, edgeEditor }: {
+    toolbar: UIPanel<TopologyState>;
+    canvas: UIPanel<TopologyState>;
+    nodeEditor: UIPanel<TopologyState>;
+    edgeEditor: UIPanel<TopologyState>;
+}): UIPanel<TopologyState>;

package/dist/components/topology-builder/ui/topologyCanvas.d.ts

@@ -0,0 +1,10 @@
+import { TopologyState, UIPanel } from '../types';
+export interface CanvasCallbacks {
+    onSelectNode: (nodeId: string | null) => void;
+    onSelectEdge: (edgeId: string | null) => void;
+    onDoubleClickNode?: (nodeId: string) => void;
+    onMoveNode: (nodeId: string, x: number, y: number) => void;
+    onCreateEdge: (sourceNodeId: string, targetNodeId: string, linkType: 'WINNER' | 'LOSER' | 'POSITION') => void;
+    onPortMouseDown: (nodeId: string, portType: 'winner' | 'loser') => void;
+}
+export declare function buildTopologyCanvas(callbacks: CanvasCallbacks): UIPanel<TopologyState>;

package/dist/components/validators/numericRange.d.ts

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

package/dist/components/validators/numericValidator.d.ts

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

package/dist/compositions/compositions.d.ts

@@ -0,0 +1,2 @@
+import { Composition } from '../types';
+export declare const compositions: Record<string, Composition>;

package/dist/compositions/lineHeights.d.ts

@@ -0,0 +1,5 @@
+export declare const lineHeights: {
+    scheduleInfo: number;
+    centerInfo: number;
+    gameScore: number;
+};

package/dist/compositions/resolvePublishedComposition.d.ts

@@ -0,0 +1,12 @@
+import { Composition, Configuration } from '../types';
+export interface DisplayExtensionValue {
+    compositionName?: string;
+    theme?: string;
+    configuration?: Partial<Configuration>;
+}
+/**
+ * Resolves a published composition from a DISPLAY extension value.
+ * Returns a new composition object (never mutates the built-in singletons).
+ * Falls back to 'National' if the named composition is not found.
+ */
+export declare function resolvePublishedComposition(display?: DisplayExtensionValue, fallbackName?: string): Composition;

package/dist/constants/matchUpFormats.d.ts

@@ -0,0 +1,34 @@
+/**
+ * MatchUp format constants
+ * Generated from matchUpFormats.json for use in tests
+ */
+export declare const MATCH_FORMATS: {
+    readonly SET3_S6_TB7: "SET3-S:6/TB7";
+    readonly SET3_S6_TB7_F_TB10: "SET3-S:6/TB7-F:TB10";
+    readonly SET3_S6_TB10: "SET3-S:6/TB10";
+    readonly SET3_S6_F_TB10: "SET3-S:6-F:TB10";
+    readonly SET3_S6_TB7_NOAD: "SET3-S:6/TB7NOAD";
+    readonly SET3_S8_TB7: "SET3-S:8/TB7";
+    readonly SET3_S8_TB7_AT7: "SET3-S:8/TB7@7";
+    readonly SET3_S4_TB7: "SET3-S:4/TB7";
+    readonly SET3_S4_TB7_F_TB10: "SET3-S:4/TB7-F:TB10";
+    readonly SET3_S4_TB5_AT3_F_TB10: "SET3-S:4/TB5@3-F:TB10";
+    readonly SET5_S6_TB7: "SET5-S:6/TB7";
+    readonly SET5_S6_TB7_F_TB10: "SET5-S:6/TB7-F:TB10";
+    readonly SET1_S6_TB7: "SET1-S:6/TB7";
+    readonly SET1_S6_TB10: "SET1-S:6/TB10";
+    readonly SET1_S6_TB7_AT5: "SET1-S:6/TB7@5";
+    readonly SET1_S8_TB7: "SET1-S:8/TB7";
+    readonly SET1_S4_TB7: "SET1-S:4/TB7";
+    readonly SET1_S5_TB9_AT4: "SET1-S:5/TB9@4";
+    readonly SET1_S_TB7: "SET1-S:T7";
+    readonly SET1_S_TB10: "SET1-S:TB10";
+    readonly SET1_S_TB21: "SET1-S:T21";
+    readonly SET1_S8: "SET1-S:8";
+    readonly SET1_S10: "SET1-S:10";
+    readonly FAST4: "SET5-S:4/NOAD";
+    readonly SET3X_T10A_TB1: "SET3XA-S:T10-F:TB1";
+    readonly SET3X_T10A_TB1_NOAD: "SET3XA-S:T10-F:TB1NOAD";
+    readonly SET4X_T10A_TB1: "SET4XA-S:T10-F:TB1";
+};
+export type MatchUpFormatCode = (typeof MATCH_FORMATS)[keyof typeof MATCH_FORMATS];