@timeax/digital-service-engine 0.0.4 → 0.0.5

package/dist/react/index.d.ts

@@ -1,7 +1,15 @@
-import { NodeProps } from 'reactflow';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import React, { ReactNode } from 'react';
 
+type EventMap = Record<string, unknown>;
+declare class EventBus<E extends EventMap> {
+    private listeners;
+    on<K extends keyof E>(event: K, handler: (payload: E[K]) => void): () => void;
+    once<K extends keyof E>(event: K, handler: (payload: E[K]) => void): () => void;
+    emit<K extends keyof E>(event: K, payload: E[K]): void;
+    clear(): void;
+}
+
 interface ButtonValue {
     id: string;
     value: string | number;
@@ -241,17 +249,6 @@ type ServiceFallback = {
     /** Primary→fallback list used when no node-scoped entry is present */
     global?: Record<ServiceIdRef, ServiceIdRef[]>;
 };
-/**
- * Optional service-map shape.
- * Keep this loose for now so the editor can be reused by host apps.
- */
-type FallbackEditorServiceRecord = {
-    id: ServiceIdRef;
-    rate?: number;
-    service_id?: ServiceIdRef;
-    [key: string]: unknown;
-};
-type FallbackEditorServiceMap = DgpServiceMap;
 type FallbackRegistrationScope = "global" | "node";
 type FallbackScopeRef = {
     scope: "global";
@@ -298,31 +295,6 @@ type FallbackEditorState = {
     current: ServiceFallback;
     changed: boolean;
 };
-type FallbackEditorOptions = {
-    /**
-     * The editable payload.
-     * The editor clones this and never mutates the caller’s object directly.
-     */
-    fallbacks?: ServiceFallback;
-    /**
-     * Optional read-only source used to resolve node→service ownership
-     * and validate node-scoped registrations.
-     */
-    props?: ServiceProps;
-    /**
-     * Optional runtime context enhancer.
-     * Useful for ambiguous node contexts / diagnostics.
-     */
-    snapshot?: OrderSnapshot;
-    /**
-     * Optional service map used for rate / existence validation.
-     */
-    services?: FallbackEditorServiceMap;
-    /**
-     * Optional fallback policy.
-     */
-    settings?: FallbackSettings;
-};
 type FallbackMutationOptions = {
     /**
      * When true, reject candidates failing validation.
@@ -335,47 +307,6 @@ type FallbackMutationOptions = {
      */
     index?: number;
 };
-interface FallbackEditor {
-    /** Returns original + current editable state */
-    state(): FallbackEditorState;
-    /** Returns the current editable fallback payload */
-    value(): ServiceFallback;
-    /** Restores current back to original */
-    reset(): FallbackEditorState;
-    /**
-     * Returns all registrations belonging to a given primary DGP service.
-     *
-     * With ServiceProps:
-     * - includes global registrations
-     * - includes node registrations whose node resolves to this primary
-     *
-     * Without ServiceProps:
-     * - global registrations only
-     */
-    get(serviceId: ServiceIdRef): FallbackRegistration[];
-    /**
-     * Direct/raw scope lookup.
-     * - global => current.global[primary] ?? []
-     * - node   => current.nodes[nodeId] ?? []
-     */
-    getScope(context: FallbackScopeRef): ServiceIdRef[];
-    /**
-     * Pure validation/preview.
-     * If candidates omitted, validates the currently stored scope value.
-     */
-    check(context: FallbackScopeRef, candidates?: ServiceIdRef[]): FallbackCheckResult;
-    /** Adds one candidate to an exact scope */
-    add(context: FallbackScopeRef, candidate: ServiceIdRef, options?: FallbackMutationOptions): FallbackEditorState;
-    /** Adds many candidates to an exact scope */
-    addMany(context: FallbackScopeRef, candidates: ServiceIdRef[], options?: FallbackMutationOptions): FallbackEditorState;
-    /** Removes one candidate from an exact scope */
-    remove(context: FallbackScopeRef, candidate: ServiceIdRef): FallbackEditorState;
-    /** Replaces the exact scope value */
-    replace(context: FallbackScopeRef, candidates: ServiceIdRef[], options?: FallbackMutationOptions): FallbackEditorState;
-    /** Clears one exact scope value */
-    clear(context: FallbackScopeRef): FallbackEditorState;
-}
-declare function createFallbackEditor(options?: FallbackEditorOptions): FallbackEditor;
 
 type PricingRole = "base" | "utility";
 type FieldType = "custom" | (string & {});
@@ -481,46 +412,6 @@ interface UiObject {
     required?: string[];
     order?: string[];
 }
-/** ---------------- Typed defaults helpers ---------------- */
-/**
- * UiValue<U>: given a Ui node U, infer the runtime value type.
- */
-type UiValue<U extends Ui> = U extends {
-    type: "string";
-} ? string : U extends {
-    type: "number";
-} ? number : U extends {
-    type: "boolean";
-} ? boolean : U extends {
-    type: "anyOf";
-    multiple: true;
-} ? Array<U["items"][number]["value"]> : U extends {
-    type: "anyOf";
-} ? U["items"][number]["value"] : U extends {
-    type: "array";
-    item: infer I extends Ui;
-} ? Array<UiValue<I>> : U extends {
-    type: "array";
-    items: infer T extends Ui[];
-} ? {
-    [K in keyof T]: UiValue<T[K]>;
-} : U extends {
-    type: "object";
-    fields: infer F extends Record<string, Ui>;
-} ? {
-    [K in keyof F]?: UiValue<F[K]>;
-} : unknown;
-/**
- * FieldWithTypedDefaults<T>: same shape as BaseFieldUI, but:
- *  - ui is a concrete map T (propName → Ui node)
- *  - defaults are auto-typed from T via UiValue
- */
-type FieldWithTypedDefaults<T extends Record<string, Ui>> = Omit<BaseFieldUI, "ui" | "defaults"> & {
-    ui: T;
-    defaults?: Partial<{
-        [K in keyof T]: UiValue<T[K]>;
-    }>;
-};
 type FieldOption = {
     id: string;
     label: string;
@@ -549,11 +440,6 @@ type Field = BaseFieldUI & {
     service_id?: number;
 } & WithQuantityDefault));
 type ConstraintKey = string;
-/**
- * Back-compat alias: older code may still import FlagKey.
- * Keeping this prevents a wave of TS errors while still allowing any string key.
- */
-type FlagKey = ConstraintKey;
 type Tag = {
     id: string;
     label: string;
@@ -637,10 +523,6 @@ type GraphSnapshot = {
     nodes: GraphNode[];
     edges: GraphEdge[];
 };
-type FlowNode = NodeProps<{
-    node: GraphNode;
-    [x: string]: any;
-}>;
 
 type CommentId = string;
 type ThreadId = string;
@@ -769,10 +651,6 @@ type CanvasEvents = {
         error?: any;
     };
 };
-type NodeView = GraphNode & {
-    position?: NodePos;
-};
-type EdgeView = GraphEdge;
 type CanvasOptions = {
     initialViewport?: Partial<Viewport>;
     autoEmitState?: boolean;
@@ -864,6 +742,39 @@ interface Builder {
     getNodeMap(): NodeMap;
 }
 
+/**
+ * Keep the editor contract exactly as discussed:
+ * - mutates only ServiceFallback (internal clone)
+ * - props are read-only context
+ * - get(serviceId) is service-centric
+ * - getScope(context) is raw scope access
+ */
+interface FallbackEditor$1 {
+    state(): FallbackEditorState;
+    value(): ServiceFallback;
+    reset(): FallbackEditorState;
+    /** Service-centric: all registrations that belong to this primary service */
+    get(serviceId: ServiceIdRef): FallbackRegistration[];
+    /** Exact/raw scope access */
+    getScope(context: FallbackScopeRef): ServiceIdRef[];
+    /** Validation preview */
+    check(context: FallbackScopeRef, candidates?: ServiceIdRef[]): FallbackCheckResult;
+    add(context: FallbackScopeRef, candidate: ServiceIdRef, options?: FallbackMutationOptions): FallbackEditorState;
+    addMany(context: FallbackScopeRef, candidates: ServiceIdRef[], options?: FallbackMutationOptions): FallbackEditorState;
+    remove(context: FallbackScopeRef, candidate: ServiceIdRef): FallbackEditorState;
+    replace(context: FallbackScopeRef, candidates: ServiceIdRef[], options?: FallbackMutationOptions): FallbackEditorState;
+    clear(context: FallbackScopeRef): FallbackEditorState;
+    /**
+     * Optional helper for picker UIs:
+     * shows candidates that the core fallback resolver would currently accept.
+     */
+    eligible(context: FallbackScopeRef, options?: {
+        exclude?: ServiceIdRef[];
+        unique?: boolean;
+        limit?: number;
+    }): ServiceIdRef[];
+}
+
 type Env = "client" | "workspace";
 type VisibleGroup = {
     tagId?: string;
@@ -946,30 +857,6 @@ declare class Selection {
     private findOptionById;
 }
 
-type EditorEvents = {
-    "editor:command": {
-        name: string;
-        payload?: any;
-    };
-    "editor:change": {
-        props: ServiceProps;
-        reason: string;
-        command?: string;
-    };
-    "editor:undo": {
-        stackSize: number;
-        index: number;
-    };
-    "editor:redo": {
-        stackSize: number;
-        index: number;
-    };
-    "editor:error": {
-        message: string;
-        code?: string;
-        meta?: any;
-    };
-};
 type Command = {
     name: string;
     do(): void;
@@ -986,19 +873,6 @@ type EditorOptions = {
     policiesRaw?: unknown;
     selectionProps?: SelectionOptions;
 };
-type ConnectKind = "bind" | "include" | "exclude";
-
-/** Exported alias so the schema generator can target an array */
-type AdminPolicies = DynamicRule[];
-
-type EventMap = Record<string, unknown>;
-declare class EventBus<E extends EventMap> {
-    private listeners;
-    on<K extends keyof E>(event: K, handler: (payload: E[K]) => void): () => void;
-    once<K extends keyof E>(event: K, handler: (payload: E[K]) => void): () => void;
-    emit<K extends keyof E>(event: K, payload: E[K]): void;
-    clear(): void;
-}
 
 type PolicyDiagnostic = {
     ruleIndex: number;
@@ -1982,4 +1856,208 @@ declare function useOrderFlow(): UseOrderFlowReturn;
  */
 declare function registerEntries(registry: Registry): void;
 
-export { type Adapter, type AdapterCtx, type AdminPolicies, type BaseFieldUI, type ButtonValue, CanvasAPI, type CanvasEvents, type CanvasOptions, type CanvasState, type Command, type CommentAnchor, type CommentId, type CommentMessage, type CommentNode, type CommentThread, type ConnectKind, type ConstraintKey, type DgpServiceCapability, type DgpServiceMap, type DraftWire, type DynamicRule, type EdgeKind, type EdgeRoute, type EdgeView, type EditorEvents, type EditorOptions, type EditorSnapshot, EventBus, type EventMap, type FallbackCandidateCheck, type FallbackCheckReason, type FallbackCheckResult, type FallbackDiagnostics, type FallbackEditor, type FallbackEditorOptions, type FallbackEditorServiceMap, type FallbackEditorServiceRecord, type FallbackEditorState, type FallbackMutationOptions, type FallbackRegistration, type FallbackRegistrationScope, type FallbackScopeRef, type FallbackSettings, type Field, type FieldOption, type FieldType, type FieldWithTypedDefaults, type FlagKey, type FlowNode, type FormApi, FormProvider, type FormProviderProps, type FormSnapshot, type GraphEdge, type GraphNode, type GraphSnapshot, type IdType, type InputDescriptor, type InputKind, type InputVariant, type InputWrapperProps, type LayoutState, type NodeIdRef, type NodeKind, type NodePos, type NodePositions, type NodeView, type NoticeKind, type NoticeSeverity, type NoticeTarget, type NoticeType, OrderFlowProvider, type OrderSnapshot, type PricingRole, Provider, type QuantityMark, type QuantityRule$1 as QuantityRule, type RatePolicy, type Registry, type Scalar, type ServiceEstimates, type ServiceFallback, type ServiceFallbacks, type ServiceFlag, type ServiceFlags, type ServiceIdRef, type ServiceProps, type ServicePropsNotice, type ServiceWhereClause, type ServiceWhereOp, type SnapshotContext, type SpeedEstimate, type Tag, type ThreadId, type TimeRangeEstimate, type Ui, type UiAnyOf, type UiArray, type UiBoolean, type UiNumber, type UiObject, type UiString, type UiValue, type UtilityLineItem, type UtilityMark, type UtilityMode, type ValidationCode, type ValidationError, type ValidatorOptions, type Viewport, type WithQuantityDefault, Wrapper, createFallbackEditor, createInputRegistry, registerEntries, resolveInputDescriptor, useFormApi, useInputs, useOptionalFormApi, useOrderFlow, useOrderFlowContext };
+type Props$4 = {
+    className?: string;
+    fallbacks?: ServiceProps["fallbacks"];
+    props?: ServiceProps;
+    snapshot?: OrderSnapshot;
+    primaryServices?: DgpServiceMap;
+    eligibleServices?: DgpServiceMap;
+    settings?: FallbackSettings;
+    initialServiceId?: ServiceIdRef;
+    onSettingsChange?: FallbackEditorProviderProps["onSettingsChange"];
+    onSave?: FallbackEditorProviderProps["onSave"];
+    onValidate?: FallbackEditorProviderProps["onValidate"];
+    onReset?: FallbackEditorProviderProps["onReset"];
+};
+declare function FallbackEditor({ className, fallbacks, props, snapshot, primaryServices, eligibleServices, settings, initialServiceId, onSettingsChange, onSave, onValidate, onReset, }: Props$4): react_jsx_runtime.JSX.Element;
+
+declare function useFallbackEditor(): {
+    editor: FallbackEditor$1;
+    version: number;
+    serviceProps?: ServiceProps;
+    snapshot?: OrderSnapshot;
+    primaryServices: DgpServiceMap;
+    eligibleServices: DgpServiceMap;
+    activeServiceId?: ServiceIdRef;
+    setActiveServiceId: React.Dispatch<React.SetStateAction<ServiceIdRef | undefined>>;
+    activeTab: "registrations" | "settings";
+    setActiveTab: React.Dispatch<React.SetStateAction<"registrations" | "settings">>;
+    state: ReturnType<FallbackEditor$1["state"]>;
+    value: ReturnType<FallbackEditor$1["value"]>;
+    settings: FallbackSettings;
+    settingsSaving: boolean;
+    headerSaving: boolean;
+    headerValidating: boolean;
+    headerResetting: boolean;
+    saveSettings: (next: FallbackSettings) => Promise<FallbackSettings>;
+    saveFallbacks: () => Promise<ServiceProps["fallbacks"] | void>;
+    validateFallbacks: () => Promise<void>;
+    resetEditor: () => Promise<void>;
+    reset: () => void;
+    get: FallbackEditor$1["get"];
+    getScope: FallbackEditor$1["getScope"];
+    check: FallbackEditor$1["check"];
+    eligible: FallbackEditor$1["eligible"];
+    add: FallbackEditor$1["add"];
+    addMany: FallbackEditor$1["addMany"];
+    remove: FallbackEditor$1["remove"];
+    replace: FallbackEditor$1["replace"];
+    clear: FallbackEditor$1["clear"];
+};
+declare function useActiveFallbackRegistrations(): FallbackRegistration[];
+declare function usePrimaryServiceList(): {
+    id: ServiceIdRef;
+    name?: string;
+    platform?: string;
+    rate?: number;
+}[];
+declare function useEligibleServiceList(): {
+    id: ServiceIdRef;
+    name?: string;
+    platform?: string;
+    rate?: number;
+}[];
+
+type Item = {
+    id: ServiceIdRef;
+    name?: string;
+    platform?: string;
+    rate?: number;
+};
+type Props$3 = {
+    items: Item[];
+    selected: Set<string>;
+    onToggle: (id: ServiceIdRef) => void;
+    height?: number;
+    rowHeight?: number;
+    emptyText?: string;
+};
+declare function VirtualServiceList({ items, selected, onToggle, height, rowHeight, emptyText, }: Props$3): react_jsx_runtime.JSX.Element;
+
+type EditorSettings = {
+    requireConstraintFit: boolean;
+    ratePolicy: "lte_primary" | "ignore";
+    selectionStrategy: "priority" | "cheapest";
+    mode: "strict" | "dev";
+};
+type ServiceSummary = {
+    id: ServiceIdRef;
+    name: string;
+    platform?: string;
+    rate?: number;
+    flags?: Record<string, boolean>;
+    description?: string;
+};
+type RegistrationScope = "global" | "node";
+type RegistrationItem = {
+    primary: ServiceIdRef;
+    scope: RegistrationScope;
+    scopeId?: string;
+    nodeKind?: "tag" | "field" | "option";
+    nodeLabel?: string;
+    services: ServiceIdRef[];
+};
+type ValidationTone = "ok" | "warn" | "error";
+type ValidationMessage = {
+    primary: ServiceIdRef;
+    scope: RegistrationScope;
+    scopeId?: string;
+    candidate?: ServiceIdRef;
+    tone: ValidationTone;
+    title: string;
+    message: string;
+};
+type FallbackEditorData = {
+    services: ServiceSummary[];
+    registrations: RegistrationItem[];
+    diagnostics: ValidationMessage[];
+    settings: EditorSettings;
+};
+
+declare function FallbackDetailsPanel(): react_jsx_runtime.JSX.Element;
+
+type Props$2 = {
+    onReset?: () => void | Promise<void>;
+    onValidate?: () => void | Promise<void>;
+    onSave?: () => void | Promise<void>;
+    resetting?: boolean;
+    validating?: boolean;
+    saving?: boolean;
+};
+declare function FallbackEditorHeader({ onReset, onValidate, onSave, resetting, validating, saving, }: Props$2): react_jsx_runtime.JSX.Element;
+
+declare function FallbackSettingsPanel(): react_jsx_runtime.JSX.Element;
+
+type TabKey = "registrations" | "settings";
+type FallbackEditorProviderProps = {
+    children: React.ReactNode;
+    fallbacks?: ServiceProps["fallbacks"];
+    props?: ServiceProps;
+    snapshot?: OrderSnapshot;
+    primaryServices?: DgpServiceMap;
+    eligibleServices?: DgpServiceMap;
+    settings?: FallbackSettings;
+    initialServiceId?: ServiceIdRef;
+    initialTab?: TabKey;
+    onSettingsChange?: (next: FallbackSettings) => Promise<FallbackSettings> | FallbackSettings;
+    onSave?: (next: ServiceProps["fallbacks"]) => Promise<ServiceProps["fallbacks"] | void> | ServiceProps["fallbacks"] | void;
+    onValidate?: (next: ServiceProps["fallbacks"]) => Promise<void> | void;
+    onReset?: () => Promise<void> | void;
+};
+type FallbackEditorContextValue = {
+    editor: FallbackEditor$1;
+    version: number;
+    serviceProps?: ServiceProps;
+    snapshot?: OrderSnapshot;
+    primaryServices: DgpServiceMap;
+    eligibleServices: DgpServiceMap;
+    activeServiceId?: ServiceIdRef;
+    setActiveServiceId: React.Dispatch<React.SetStateAction<ServiceIdRef | undefined>>;
+    activeTab: TabKey;
+    setActiveTab: React.Dispatch<React.SetStateAction<TabKey>>;
+    state: ReturnType<FallbackEditor$1["state"]>;
+    value: ReturnType<FallbackEditor$1["value"]>;
+    settings: FallbackSettings;
+    settingsSaving: boolean;
+    headerSaving: boolean;
+    headerValidating: boolean;
+    headerResetting: boolean;
+    saveSettings: (next: FallbackSettings) => Promise<FallbackSettings>;
+    saveFallbacks: () => Promise<ServiceProps["fallbacks"] | void>;
+    validateFallbacks: () => Promise<void>;
+    resetEditor: () => Promise<void>;
+    reset: () => void;
+    get: FallbackEditor$1["get"];
+    getScope: FallbackEditor$1["getScope"];
+    check: FallbackEditor$1["check"];
+    eligible: FallbackEditor$1["eligible"];
+    add: FallbackEditor$1["add"];
+    addMany: FallbackEditor$1["addMany"];
+    remove: FallbackEditor$1["remove"];
+    replace: FallbackEditor$1["replace"];
+    clear: FallbackEditor$1["clear"];
+};
+declare function FallbackEditorProvider({ children, fallbacks, props, snapshot, primaryServices, eligibleServices, settings: initialSettings, initialServiceId, initialTab, onSettingsChange, onSave, onValidate, onReset, }: FallbackEditorProviderProps): react_jsx_runtime.JSX.Element;
+declare function useFallbackEditorContext(): FallbackEditorContextValue;
+
+declare function FallbackServiceSidebar(): react_jsx_runtime.JSX.Element;
+
+declare function FallbackRegistrationsPanel(): react_jsx_runtime.JSX.Element;
+
+type Props$1 = {
+    open: boolean;
+    onClose: () => void;
+    context: FallbackScopeRef | null;
+    primaryId?: ServiceIdRef;
+};
+declare function FallbackAddCandidatesDialog({ open, onClose, context, primaryId, }: Props$1): react_jsx_runtime.JSX.Element | null;
+
+type Props = {
+    open: boolean;
+    onClose: () => void;
+    onSelect: (context: FallbackScopeRef, primaryId: ServiceIdRef) => void;
+};
+declare function FallbackAddRegistrationDialog({ open, onClose, onSelect, }: Props): react_jsx_runtime.JSX.Element | null;
+
+export { type Adapter, type AdapterCtx, CanvasAPI, type EditorSettings, EventBus, type EventMap, FallbackAddCandidatesDialog, FallbackAddRegistrationDialog, FallbackDetailsPanel, FallbackEditor, type FallbackEditorData, FallbackEditorHeader, FallbackEditorProvider, type FallbackEditorProviderProps, FallbackRegistrationsPanel, FallbackServiceSidebar, FallbackSettingsPanel, type FormApi, FormProvider, type FormProviderProps, type FormSnapshot, type InputDescriptor, type InputKind, type InputVariant, type InputWrapperProps, OrderFlowProvider, Provider, type RegistrationItem, type RegistrationScope, type Registry, type ServiceSummary, type ValidationMessage, type ValidationTone, VirtualServiceList, Wrapper, createInputRegistry, registerEntries, resolveInputDescriptor, useActiveFallbackRegistrations, useEligibleServiceList, useFallbackEditor, useFallbackEditorContext, useFormApi, useInputs, useOptionalFormApi, useOrderFlow, useOrderFlowContext, usePrimaryServiceList };