courthive-components 1.1.0 → 1.1.1

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

@@ -0,0 +1,146 @@
+/**
+ * Ranking Points Editor — Type Definitions
+ *
+ * Mirrors the factory's rankingTypes.ts shapes for the editor state.
+ * Uses `any` for complex polymorphic types (PositionValue, LevelKeyed)
+ * to avoid importing factory internals into the component library.
+ */
+export type RankingEditorSection = 'metadata' | 'awardProfiles' | 'qualityWinProfiles' | 'aggregationRules';
+export interface RankingPointsEditorState {
+    draft: RankingPolicyData;
+    expandedSections: Set<RankingEditorSection>;
+    expandedProfiles: Set<number>;
+    profileFilter: string;
+    dirty: boolean;
+    readonly: boolean;
+}
+export type RankingPointsEditorChangeListener = (state: RankingPointsEditorState) => void;
+export interface RankingPointsEditorConfig {
+    initialPolicy?: RankingPolicyData;
+    onChange?: (policy: RankingPolicyData) => void;
+    readonly?: boolean;
+}
+export interface RankingPolicyData {
+    policyName?: string;
+    policyVersion?: string;
+    validDateRange?: DateRange;
+    awardProfiles?: AwardProfileData[];
+    qualityWinProfiles?: QualityWinProfileData[];
+    aggregationRules?: AggregationRulesData;
+    requireWinForPoints?: boolean;
+    requireWinFirstRound?: boolean;
+    doublesAttribution?: string;
+    categoryResolution?: string;
+}
+export interface AwardProfileData {
+    profileName?: string;
+    finishingPositionRanges?: Record<string, any>;
+    finishingRound?: Record<string, any>;
+    perWinPoints?: any;
+    pointsPerWin?: any;
+    finishingPositionPoints?: {
+        participationOrders: number[];
+    };
+    maxCountableMatches?: any;
+    bonusPoints?: BonusPointData[];
+    requireWinForPoints?: boolean;
+    requireWinFirstRound?: boolean;
+    dateRanges?: DateRange[];
+    eventTypes?: string[];
+    drawTypes?: string[];
+    drawSizes?: number[];
+    maxDrawSize?: number;
+    stages?: string[];
+    stageSequences?: number[];
+    levels?: number[];
+    maxLevel?: number;
+    flights?: any;
+    maxFlightNumber?: number;
+    participationOrder?: number;
+    category?: CategoryScopeData;
+    priority?: number;
+}
+export interface BonusPointData {
+    finishingPositions: number[];
+    value: any;
+}
+export interface QualityWinProfileData {
+    rankingRanges: QualityWinRangeData[];
+    rankingScaleName: string;
+    rankingEventType?: string;
+    rankingSnapshot?: string;
+    unrankedOpponentBehavior?: string;
+    defaultRank?: number;
+    levels?: number[];
+    eventTypes?: string[];
+    drawTypes?: string[];
+    stages?: string[];
+    dateRanges?: DateRange[];
+    category?: CategoryScopeData;
+    maxBonusPerTournament?: number;
+    includeWalkovers?: boolean;
+}
+export interface QualityWinRangeData {
+    rankRange: [number, number];
+    value: number;
+}
+export interface AggregationRulesData {
+    countingBuckets?: CountingBucketData[];
+    bestOfCount?: number;
+    rollingPeriodDays?: number;
+    decayFunction?: string;
+    decaySteps?: {
+        afterDays: number;
+        multiplier: number;
+    }[];
+    separateByGender?: boolean;
+    perCategory?: boolean;
+    minCountableResults?: number;
+    maxResultsPerLevel?: Record<string, number>;
+    doublesAttribution?: string;
+    tiebreakCriteria?: string[];
+}
+export interface CountingBucketData {
+    bucketName?: string;
+    eventTypes?: string[];
+    pointComponents?: string[];
+    bestOfCount?: number;
+    maxResultsPerLevel?: Record<string, number>;
+    minResults?: number;
+    levels?: number[];
+    mandatoryRules?: MandatoryRuleData[];
+}
+export interface MandatoryRuleData {
+    ruleName?: string;
+    levels: number[];
+    bestOfCount?: number;
+}
+export interface CategoryScopeData {
+    ageCategoryCodes?: string[];
+    genders?: string[];
+    categoryNames?: string[];
+    categoryTypes?: string[];
+    ratingTypes?: string[];
+    ballTypes?: string[];
+    wheelchairClasses?: string[];
+    subTypes?: string[];
+}
+export interface DateRange {
+    startDate?: string;
+    endDate?: string;
+}
+export type TableLayout = {
+    type: 'flat';
+} | {
+    type: 'level-columns';
+    levels: number[];
+} | {
+    type: 'flight-columns';
+    flights: number[];
+} | {
+    type: 'level-flight-tabs';
+    levels: number[];
+    flightsPerLevel: Record<number, number[]>;
+} | {
+    type: 'conditional';
+};

package/dist/components/policy-catalog/editors/scheduling/domain/schedulingProjections.d.ts

@@ -0,0 +1,5 @@
+import { SchedulingPolicyData } from '../types';
+/** Get a human-readable description for a matchUp format code */
+export declare function formatCodeLabel(code: string): string;
+/** Create empty scheduling policy with sensible structure */
+export declare function emptySchedulingPolicy(): SchedulingPolicyData;

package/dist/components/policy-catalog/editors/scheduling/domain/schedulingValidation.d.ts

@@ -0,0 +1,2 @@
+import { SchedulingPolicyData, SchedulingValidationResult } from '../types';
+export declare function validateSchedulingPolicy(data: SchedulingPolicyData): SchedulingValidationResult[];

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

@@ -0,0 +1,11 @@
+/**
+ * Scheduling Editor — Public API
+ *
+ * Standalone exports for the scheduling policy editor.
+ */
+export { SchedulingEditorControl, createSchedulingEditor } from './schedulingEditorControl';
+export { SchedulingEditorStore } from './schedulingEditorStore';
+export { validateSchedulingPolicy } from './domain/schedulingValidation';
+export { formatCodeLabel, emptySchedulingPolicy } from './domain/schedulingProjections';
+export { buildSchedulingEditorPanel } from './schedulingEditorPanel';
+export type { SchedulingPolicyData, SchedulingEditorState, SchedulingEditorSection, SchedulingEditorChangeListener, SchedulingEditorConfig, SchedulingValidationResult, ValidationSeverity, MinutesEntry, AverageTimeEntry, RecoveryTimeEntry, MatchUpAverageTime, MatchUpRecoveryTime } from './types';

package/dist/components/policy-catalog/editors/scheduling/schedulingEditorControl.d.ts

@@ -0,0 +1,26 @@
+import { SchedulingEditorStore } from './schedulingEditorStore';
+import { SchedulingPolicyData, SchedulingEditorConfig } from './types';
+import { PolicyEditorInstance as CatalogEditorInstance } from '../../types';
+export declare class SchedulingEditorControl {
+    private readonly store;
+    private readonly panel;
+    private readonly unsubscribe;
+    private container;
+    constructor(config: SchedulingEditorConfig);
+    render(container: HTMLElement): void;
+    destroy(): void;
+    getData(): SchedulingPolicyData;
+    setData(data: SchedulingPolicyData): void;
+    getStore(): SchedulingEditorStore;
+    /**
+     * Create as a PolicyEditorInstance for embedding in the catalog editor shell.
+     */
+    static createEditorInstance(config: {
+        initialData: Record<string, unknown>;
+        onChange: (data: Record<string, unknown>) => void;
+    }): CatalogEditorInstance;
+}
+/**
+ * Convenience factory for standalone use (e.g., TMX scheduling page).
+ */
+export declare function createSchedulingEditor(config: SchedulingEditorConfig, container: HTMLElement): SchedulingEditorControl;

package/dist/components/policy-catalog/editors/scheduling/schedulingEditorPanel.d.ts

@@ -0,0 +1,6 @@
+import { SchedulingEditorState, SchedulingEditorConfig } from './types';
+import { SchedulingEditorStore } from './schedulingEditorStore';
+export declare function buildSchedulingEditorPanel(store: SchedulingEditorStore, config: SchedulingEditorConfig): {
+    element: HTMLElement;
+    update(state: SchedulingEditorState): void;
+};

package/dist/components/policy-catalog/editors/scheduling/schedulingEditorStore.d.ts

@@ -0,0 +1,32 @@
+import { SchedulingPolicyData, SchedulingEditorState, SchedulingEditorSection, SchedulingEditorChangeListener, SchedulingEditorConfig } from './types';
+export declare class SchedulingEditorStore {
+    private state;
+    private readonly listeners;
+    private readonly config;
+    constructor(config: SchedulingEditorConfig);
+    getState(): SchedulingEditorState;
+    getData(): SchedulingPolicyData;
+    setData(data: SchedulingPolicyData): void;
+    toggleSection(sectionId: SchedulingEditorSection): void;
+    setModificationFlag(key: 'courts' | 'venues', value: boolean): void;
+    setDailyLimit(key: 'SINGLES' | 'DOUBLES' | 'total', value: number): void;
+    setDefaultAverageTime(index: number, field: 'default' | 'DOUBLES', value: number | undefined): void;
+    setDefaultRecoveryTime(index: number, field: 'default' | 'DOUBLES', value: number | undefined): void;
+    addAverageFormatGroup(): void;
+    removeAverageFormatGroup(index: number): void;
+    setAverageFormatCodes(groupIndex: number, codes: string[]): void;
+    setAverageTime(groupIndex: number, overrideIndex: number, field: 'default' | 'DOUBLES', value: number | undefined): void;
+    addAverageCategoryOverride(groupIndex: number): void;
+    removeAverageCategoryOverride(groupIndex: number, overrideIndex: number): void;
+    setAverageOverrideCategories(groupIndex: number, overrideIndex: number, key: 'categoryNames' | 'categoryTypes', values: string[]): void;
+    addRecoveryFormatGroup(): void;
+    removeRecoveryFormatGroup(index: number): void;
+    setRecoveryFormatCodes(groupIndex: number, codes: string[]): void;
+    setRecoveryTime(groupIndex: number, overrideIndex: number, field: 'default' | 'DOUBLES', value: number | undefined): void;
+    addRecoveryCategoryOverride(groupIndex: number): void;
+    removeRecoveryCategoryOverride(groupIndex: number, overrideIndex: number): void;
+    setRecoveryOverrideCategories(groupIndex: number, overrideIndex: number, key: 'categoryNames' | 'categoryTypes', values: string[]): void;
+    subscribe(listener: SchedulingEditorChangeListener): () => void;
+    private commitDraft;
+    private emit;
+}

package/dist/components/policy-catalog/editors/scheduling/sections/averageTimesSection.d.ts

@@ -0,0 +1,6 @@
+import { SchedulingEditorState, SchedulingEditorConfig } from '../types';
+import { SchedulingEditorStore } from '../schedulingEditorStore';
+export declare function buildAverageTimesSection(store: SchedulingEditorStore, config: SchedulingEditorConfig): {
+    element: HTMLElement;
+    update(state: SchedulingEditorState): void;
+};

package/dist/components/policy-catalog/editors/scheduling/sections/dailyLimitsSection.d.ts

@@ -0,0 +1,6 @@
+import { SchedulingEditorState } from '../types';
+import { SchedulingEditorStore } from '../schedulingEditorStore';
+export declare function buildDailyLimitsSection(store: SchedulingEditorStore): {
+    element: HTMLElement;
+    update(state: SchedulingEditorState): void;
+};

package/dist/components/policy-catalog/editors/scheduling/sections/defaultTimesSection.d.ts

@@ -0,0 +1,6 @@
+import { SchedulingEditorState } from '../types';
+import { SchedulingEditorStore } from '../schedulingEditorStore';
+export declare function buildDefaultTimesSection(store: SchedulingEditorStore): {
+    element: HTMLElement;
+    update(state: SchedulingEditorState): void;
+};

package/dist/components/policy-catalog/editors/scheduling/sections/formatTimeRow.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Format Time Row — Reusable card for one format group.
+ *
+ * Format codes are added via the matchUpFormat modal editor.
+ * Tags display existing codes with remove buttons.
+ */
+export interface FormatTimeRowConfig {
+    formatCodes: string[];
+    overrides: {
+        categoryLabel: string;
+        isDefault: boolean;
+        defaultMinutes: number;
+        doublesMinutes?: number;
+    }[];
+    availableFormats: string[];
+    onFormatCodesChange: (codes: string[]) => void;
+    onTimeChange: (overrideIndex: number, field: 'default' | 'DOUBLES', value: number | undefined) => void;
+    onAddOverride: () => void;
+    onRemoveOverride: (index: number) => void;
+    onRemoveGroup: () => void;
+}
+export declare function buildFormatTimeRow(config: FormatTimeRowConfig): HTMLElement;

package/dist/components/policy-catalog/editors/scheduling/sections/modificationFlagsSection.d.ts

@@ -0,0 +1,6 @@
+import { SchedulingEditorState } from '../types';
+import { SchedulingEditorStore } from '../schedulingEditorStore';
+export declare function buildModificationFlagsSection(store: SchedulingEditorStore): {
+    element: HTMLElement;
+    update(state: SchedulingEditorState): void;
+};

package/dist/components/policy-catalog/editors/scheduling/sections/recoveryTimesSection.d.ts

@@ -0,0 +1,6 @@
+import { SchedulingEditorState, SchedulingEditorConfig } from '../types';
+import { SchedulingEditorStore } from '../schedulingEditorStore';
+export declare function buildRecoveryTimesSection(store: SchedulingEditorStore, config: SchedulingEditorConfig): {
+    element: HTMLElement;
+    update(state: SchedulingEditorState): void;
+};

package/dist/components/policy-catalog/editors/scheduling/styles.d.ts

@@ -0,0 +1,27 @@
+export declare const seSectionStyle: () => string;
+export declare const seSectionHeaderStyle: () => string;
+export declare const seSectionChevronStyle: () => string;
+export declare const seSectionBodyStyle: () => string;
+export declare const seFieldRowStyle: () => string;
+export declare const seFieldLabelStyle: () => string;
+export declare const seFieldInputStyle: () => string;
+export declare const seFieldUnitStyle: () => string;
+export declare const seCheckboxRowStyle: () => string;
+export declare const seFormatGroupStyle: () => string;
+export declare const seFormatGroupHeaderStyle: () => string;
+export declare const seFormatGroupLabelStyle: () => string;
+export declare const seTagPickerStyle: () => string;
+export declare const seTagStyle: () => string;
+export declare const seTagRemoveStyle: () => string;
+export declare const seTagAddWrapStyle: () => string;
+export declare const seTagAddBtnStyle: () => string;
+export declare const seTagDropdownStyle: () => string;
+export declare const seTagDropdownInputStyle: () => string;
+export declare const seTagDropdownItemStyle: () => string;
+export declare const seTagDropdownEmptyStyle: () => string;
+export declare const seOverrideRowStyle: () => string;
+export declare const seOverrideCategoriesStyle: () => string;
+export declare const seOverrideRemoveStyle: () => string;
+export declare const seAddBtnStyle: () => string;
+export declare const seRemoveGroupBtnStyle: () => string;
+export declare const seEditorStyle: () => string;

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

@@ -0,0 +1,65 @@
+/**
+ * Scheduling Policy Editor — Type Definitions
+ *
+ * Mirrors the factory's scheduling policy data shape exactly.
+ */
+export interface MinutesEntry {
+    default: number;
+    DOUBLES?: number;
+}
+export interface AverageTimeEntry {
+    categoryNames?: string[];
+    categoryTypes?: string[];
+    minutes: MinutesEntry;
+}
+export interface RecoveryTimeEntry {
+    categoryNames?: string[];
+    categoryTypes?: string[];
+    minutes: MinutesEntry;
+}
+export interface MatchUpAverageTime {
+    matchUpFormatCodes: string[];
+    averageTimes: AverageTimeEntry[];
+}
+export interface MatchUpRecoveryTime {
+    matchUpFormatCodes: string[];
+    recoveryTimes: RecoveryTimeEntry[];
+}
+export interface SchedulingPolicyData {
+    allowModificationWhenMatchUpsScheduled?: {
+        courts: boolean;
+        venues: boolean;
+    };
+    defaultTimes?: {
+        averageTimes?: AverageTimeEntry[];
+        recoveryTimes?: RecoveryTimeEntry[];
+    };
+    defaultDailyLimits?: {
+        SINGLES?: number;
+        DOUBLES?: number;
+        total?: number;
+    };
+    matchUpAverageTimes?: MatchUpAverageTime[];
+    matchUpRecoveryTimes?: MatchUpRecoveryTime[];
+    matchUpDailyLimits?: unknown[];
+}
+export type SchedulingEditorSection = 'modificationFlags' | 'dailyLimits' | 'defaultTimes' | 'averageTimes' | 'recoveryTimes';
+export interface SchedulingEditorState {
+    draft: SchedulingPolicyData;
+    expandedSections: Set<SchedulingEditorSection>;
+    dirty: boolean;
+}
+export type SchedulingEditorChangeListener = (state: SchedulingEditorState) => void;
+export type ValidationSeverity = 'error' | 'warning';
+export interface SchedulingValidationResult {
+    severity: ValidationSeverity;
+    path: string;
+    message: string;
+}
+export interface SchedulingEditorConfig {
+    initialPolicy?: SchedulingPolicyData;
+    categoryNames?: string[];
+    categoryTypes?: string[];
+    matchUpFormatCodes?: string[];
+    onChange?: (policy: SchedulingPolicyData) => void;
+}

package/dist/components/policy-catalog/engine/policyCatalogStore.d.ts

@@ -0,0 +1,25 @@
+import { PolicyCatalogState, PolicyCatalogChangeListener, PolicyCatalogConfig, PolicyCatalogItem, CatalogGroupBy } from '../types';
+export declare class PolicyCatalogStore {
+    private state;
+    private readonly listeners;
+    private readonly config;
+    constructor(config: PolicyCatalogConfig);
+    getState(): PolicyCatalogState;
+    getSelectedItem(): PolicyCatalogItem | null;
+    setCatalogSearch(query: string): void;
+    setCatalogGroupBy(mode: CatalogGroupBy): void;
+    selectPolicy(id: string): void;
+    clearSelection(): void;
+    updateEditorDraft(data: Record<string, unknown>): void;
+    markDirty(): void;
+    markClean(): void;
+    savePolicy(): void;
+    resetDraft(): void;
+    applyPolicy(): void;
+    addNewPolicy(policyType: string): string;
+    duplicatePolicy(sourceId: string): string | null;
+    deletePolicy(id: string): void;
+    subscribe(listener: PolicyCatalogChangeListener): () => void;
+    private setState;
+    private emit;
+}

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

@@ -0,0 +1,22 @@
+import { PolicyCatalogConfig } from './types';
+import { PolicyCatalogControl } from './controller/policyCatalogControl';
+/**
+ * Policy Catalog — Public API
+ *
+ * Main entry point for the policy catalog component.
+ */
+export { PolicyCatalogControl } from './controller/policyCatalogControl';
+export { PolicyCatalogStore } from './engine/policyCatalogStore';
+export { filterPolicyCatalog, groupPolicyCatalog } from './domain/catalogProjections';
+export { POLICY_TYPE_METADATA, POLICY_TYPE_GROUPS, getPolicyTypeMeta, getEmptyPolicyData } from './domain/policyDefaults';
+export { deepClone } from './domain/utils';
+export { buildPolicyCatalogPanel } from './ui/policyCatalogPanel';
+export { buildEditorShell } from './ui/editorShell';
+export { buildPolicyCatalogLayout } from './ui/policyCatalogLayout';
+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 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';
+export declare function createPolicyCatalog(config: PolicyCatalogConfig, container: HTMLElement): PolicyCatalogControl;

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

@@ -0,0 +1,57 @@
+/**
+ * Policy Catalog — Type Definitions
+ */
+export type PolicyTypeGroup = 'Tournament Operations' | 'Scoring & Results' | 'Ranking Points' | 'Draw Configuration' | 'Participants' | 'Display & Audit';
+export interface PolicyTypeMeta {
+    policyType: string;
+    label: string;
+    description: string;
+    group: PolicyTypeGroup;
+    hasEditor: boolean;
+}
+export type PolicySource = 'builtin' | 'user';
+export interface PolicyCatalogItem {
+    id: string;
+    name: string;
+    policyType: string;
+    source: PolicySource;
+    description: string;
+    policyData: Record<string, unknown>;
+}
+export type CatalogGroupBy = 'type' | 'source';
+export interface PolicyCatalogState {
+    catalog: PolicyCatalogItem[];
+    searchQuery: string;
+    groupBy: CatalogGroupBy;
+    selectedId: string | null;
+    editorDraft: Record<string, unknown> | null;
+    dirty: boolean;
+}
+export type PolicyCatalogChangeListener = (state: PolicyCatalogState) => void;
+export interface PolicyEditorInstance {
+    element: HTMLElement;
+    setData(data: Record<string, unknown>): void;
+    getData(): Record<string, unknown>;
+    destroy(): void;
+}
+export interface PolicyEditorPlugin {
+    policyType: string;
+    create(config: {
+        initialData: Record<string, unknown>;
+        onChange: (data: Record<string, unknown>) => void;
+    }): PolicyEditorInstance;
+}
+export interface PolicyCatalogConfig {
+    builtinPolicies?: PolicyCatalogItem[];
+    userPolicies?: PolicyCatalogItem[];
+    editorPlugins?: PolicyEditorPlugin[];
+    onPolicySaved?: (item: PolicyCatalogItem) => void;
+    onPolicyApplied?: (item: PolicyCatalogItem) => void;
+    onPolicyCreated?: (item: PolicyCatalogItem) => void;
+    onPolicyDeleted?: (id: string) => void;
+    onSelectionChanged?: (item: PolicyCatalogItem | null) => void;
+}
+export interface UIPanel<S> {
+    element: HTMLElement;
+    update(state: S): void;
+}

package/dist/components/policy-catalog/ui/editorShell.d.ts

@@ -0,0 +1,11 @@
+import { PolicyCatalogState, UIPanel } from '../types';
+export interface EditorShellCallbacks {
+    onSave: () => void;
+    onReset: () => void;
+    onApply: () => void;
+    onDuplicate: () => void;
+}
+export interface EditorShellPanel extends UIPanel<PolicyCatalogState> {
+    bodyElement: HTMLElement;
+}
+export declare function buildEditorShell(callbacks: EditorShellCallbacks): EditorShellPanel;

package/dist/components/policy-catalog/ui/jsonEditor.d.ts

@@ -0,0 +1,5 @@
+import { PolicyEditorInstance } from '../types';
+export declare function buildJsonEditor(config: {
+    initialData: Record<string, unknown>;
+    onChange: (data: Record<string, unknown>) => void;
+}): PolicyEditorInstance;

package/dist/components/policy-catalog/ui/policyCatalogLayout.d.ts

@@ -0,0 +1,6 @@
+import { PolicyCatalogState, UIPanel } from '../types';
+import { EditorShellPanel } from './editorShell';
+export declare function buildPolicyCatalogLayout(panels: {
+    catalogPanel: UIPanel<PolicyCatalogState>;
+    editorShell: EditorShellPanel;
+}): UIPanel<PolicyCatalogState>;

package/dist/components/policy-catalog/ui/policyCatalogPanel.d.ts

@@ -0,0 +1,10 @@
+import { PolicyCatalogState, UIPanel, CatalogGroupBy } from '../types';
+export interface PolicyCatalogPanelCallbacks {
+    onSearchChange: (query: string) => void;
+    onGroupByChange: (mode: CatalogGroupBy) => void;
+    onSelectPolicy: (id: string) => void;
+    onNewPolicy?: (policyType: string) => void;
+    onDuplicatePolicy?: (id: string) => void;
+    onDeletePolicy?: (id: string) => void;
+}
+export declare function buildPolicyCatalogPanel(callbacks: PolicyCatalogPanelCallbacks): UIPanel<PolicyCatalogState>;

package/dist/components/policy-catalog/ui/styles.d.ts

@@ -0,0 +1,28 @@
+export declare const pcLayoutStyle: () => string;
+export declare const pcPanelStyle: () => string;
+export declare const pcPanelHeaderStyle: () => string;
+export declare const pcPanelTitleStyle: () => string;
+export declare const pcPanelMetaStyle: () => string;
+export declare const pcToolbarStyle: () => string;
+export declare const pcInputStyle: () => string;
+export declare const pcSelectStyle: () => string;
+export declare const pcCatalogStyle: () => string;
+export declare const pcGroupStyle: () => string;
+export declare const pcGroupHeaderStyle: () => string;
+export declare const pcGroupChevronStyle: () => string;
+export declare const pcGroupBodyStyle: () => string;
+export declare const pcCardStyle: () => string;
+export declare const pcCardTitleStyle: () => string;
+export declare const pcCardMetaStyle: () => string;
+export declare const pcTypeBadgeStyle: () => string;
+export declare const pcEditorStyle: () => string;
+export declare const pcEditorHeaderStyle: () => string;
+export declare const pcEditorHeaderLeftStyle: () => string;
+export declare const pcEditorActionsStyle: () => string;
+export declare const pcBtnStyle: () => string;
+export declare const pcBtnPrimaryStyle: () => string;
+export declare const pcDirtyDotStyle: () => string;
+export declare const pcEditorBodyStyle: () => string;
+export declare const pcEmptyStyle: () => string;
+export declare const pcJsonEditorStyle: () => string;
+export declare const pcJsonErrorStyle: () => string;

package/dist/components/popover/tipster.d.ts

@@ -0,0 +1,14 @@
+import { Instance } from 'tippy.js';
+export declare function destroyTipster(target?: HTMLElement | any): void;
+type TipsterParams = {
+    title?: string;
+    options?: any[];
+    menuItems?: any[];
+    coords?: any;
+    callback?: (result: any) => void;
+    config?: any;
+    target?: HTMLElement;
+    items?: any[];
+};
+export declare function tipster(params: TipsterParams): Instance | undefined;
+export {};

package/dist/components/print-composition-editor/printCompositionEditor.d.ts

@@ -0,0 +1,2 @@
+import { PrintCompositionEditorConfig, PrintCompositionEditorHandle } from './printCompositionEditorTypes';
+export declare function createPrintCompositionEditor(container: HTMLElement, config: PrintCompositionEditorConfig): PrintCompositionEditorHandle;