@json-layout/core 2.8.0 → 2.8.2

package/types/i18n/types.d.ts

@@ -0,0 +1,24 @@
+import { type NormalizeMessages } from '@json-layout/vocabulary';
+export interface CompileOptionsMessages {
+    errorOneOf: string;
+    errorRequired: string;
+}
+export interface StateOptionsMessages {
+    addItem: string;
+    delete: string;
+    confirm: string;
+    edit: string;
+    close: string;
+    duplicate: string;
+    insertAfter: string;
+    copy: string;
+    paste: string;
+    sort: string;
+    up: string;
+    down: string;
+    showHelp: string;
+    keyboardDate: string;
+    keyboardDateTime: string;
+}
+export type LocaleMessages = NormalizeMessages & CompileOptionsMessages & StateOptionsMessages;
+//# sourceMappingURL=types.d.ts.map

package/types/i18n/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/i18n/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAEhE,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,MAAM,CAAA;IAClB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,gBAAgB,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,MAAM,cAAc,GAAG,iBAAiB,GAAG,sBAAsB,GAAG,oBAAoB,CAAA"}

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./compile/index.js";
+export * from "./state/index.js";
+export { default as i18n } from "./i18n/index.js";
+export { clone } from "@json-layout/vocabulary";
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":""}

package/types/state/index.d.ts

@@ -0,0 +1,316 @@
+export { Display } from "./utils/display.js";
+export { getRegexp } from "./utils/regexps.js";
+/**
+ * @typedef {import('./types.js').StateNode} StateNode
+ * @typedef {import('./types.js').StateTree} StateTree
+ * @typedef {import('./types.js').StatefulLayoutOptions} StatefulLayoutOptions
+ * @typedef {import('./types.js').CreateStateTreeContext} CreateStateTreeContext
+ * @typedef {import('./types.js').TextFieldNode} TextFieldNode
+ * @typedef {import('./types.js').TextareaNode} TextareaNode
+ * @typedef {import('./types.js').NumberFieldNode} NumberFieldNode
+ * @typedef {import('./types.js').SliderNode} SliderNode
+ * @typedef {import('./types.js').SectionNode} SectionNode
+ * @typedef {import('./types.js').SelectNode} SelectNode
+ * @typedef {import('./types.js').AutocompleteNode} AutocompleteNode
+ * @typedef {import('./types.js').RadioGroupNode} RadioGroupNode
+ * @typedef {import('./types.js').CheckboxGroupNode} CheckboxGroupNode
+ * @typedef {import('./types.js').SwitchGroupNode} SwitchGroupNode
+ * @typedef {import('./types.js').ComboboxNode} ComboboxNode
+ * @typedef {import('./types.js').CheckboxNode} CheckboxNode
+ * @typedef {import('./types.js').SwitchNode} SwitchNode
+ * @typedef {import('./types.js').ColorPickerNode} ColorPickerNode
+ * @typedef {import('./types.js').DatePickerNode} DatePickerNode
+ * @typedef {import('./types.js').DateTimePickerNode} DateTimePickerNode
+ * @typedef {import('./types.js').TimePickerNode} TimePickerNode
+ * @typedef {import('./types.js').ExpansionPanelsNode} ExpansionPanelsNode
+ * @typedef {import('./types.js').TabsNode} TabsNode
+ * @typedef {import('./types.js').VerticalTabsNode} VerticalTabsNode
+ * @typedef {import('./types.js').StepperNode} StepperNode
+ * @typedef {import('./types.js').OneOfSelectNode} OneOfSelectNode
+ * @typedef {import('./types.js').ListNode} ListNode
+ * @typedef {import('./types.js').FileInputNode} FileInputNode
+ * @typedef {import('./types.js').CardNode} CardNode
+ * @typedef {import('./types.js').FileRef} FileRef
+ */
+/** @type {(node: StateNode | undefined) => node is SectionNode} */
+export const isSection: (node: StateNode | undefined) => node is SectionNode;
+/** @type {(node: StateNode | undefined, components: Record<string, import('@json-layout/vocabulary').ComponentInfo>) => node is SelectNode | ComboboxNode | AutocompleteNode} */
+export const isItemsNode: (node: StateNode | undefined, components: Record<string, import("@json-layout/vocabulary").ComponentInfo>) => node is SelectNode | ComboboxNode | AutocompleteNode;
+export class StatefulLayout {
+    /**
+     * @param {import("../index.js").CompiledLayout} compiledLayout
+     * @param {import("../index.js").SkeletonTree} skeletonTree
+     * @param {Partial<StatefulLayoutOptions>} options
+     * @param {unknown} [data]
+     * @param {unknown} [savedData]
+     */
+    constructor(compiledLayout: import("../index.js").CompiledLayout, skeletonTree: import("../index.js").SkeletonTree, options: Partial<StatefulLayoutOptions>, data?: unknown, savedData?: unknown);
+    /**
+     * @private
+     * @readonly
+     * @type {import('../index.js').CompiledLayout}
+     */
+    private readonly _compiledLayout;
+    get compiledLayout(): import("../compile/types.js").CompiledLayout;
+    /**
+     * @private
+     * @type {StateTree}
+     */
+    private _stateTree;
+    get stateTree(): import("./types.js").StateTree;
+    /**
+     * @readonly
+     * @type {import('../index.js').SkeletonTree}
+     */
+    readonly skeletonTree: import("../index.js").SkeletonTree;
+    /**
+     * @private
+     * @type {Display}
+     */
+    private _display;
+    get display(): Display;
+    /**
+     * @private
+     * @type {import('./types.js').ValidationState}
+     */
+    private _validationState;
+    /**
+     * @private
+     * @param {Partial<import('./types.js').ValidationState>} validationState
+     */
+    set validationState(validationState: Partial<import("./types.js").ValidationState>);
+    /**
+     * @returns {import('./types.js').ValidationState}
+     */
+    get validationState(): import("./types.js").ValidationState;
+    /**
+     * @private
+     * @type {StatefulLayoutOptions}
+     */
+    private _options;
+    /**
+     * @param {Partial<StatefulLayoutOptions>} options
+     */
+    set options(options: Partial<StatefulLayoutOptions>);
+    /**
+     * @returns {StatefulLayoutOptions}
+     */
+    get options(): StatefulLayoutOptions;
+    /**
+     * @private
+     * @type {unknown}
+     */
+    private _data;
+    set data(data: unknown);
+    get data(): unknown;
+    /**
+     * true after data was replaced from outside, consumed by the next state tree creation
+     * @private
+     * @type {boolean}
+     */
+    private _reResolveActivatedItems;
+    /**
+     * @private
+     * @type {unknown}
+     */
+    private _previousData;
+    /**
+     * @private
+     * @type {boolean}
+     */
+    private _dataWaitingForBlur;
+    /**
+     * @private
+     * @type {string | null}
+     */
+    private _currentInput;
+    /**
+     * @private
+     * @type {CreateStateTreeContext}
+     */
+    private _lastCreateStateTreeContext;
+    /**
+     * @private
+     * @type {string | null}
+     */
+    private _autofocusTarget;
+    /**
+     * @private
+     * @type {string | null}
+     */
+    private _previousAutofocusTarget;
+    /**
+     * @type {FileRef[]}
+     */
+    files: FileRef[];
+    /**
+     * @private
+     * @type {unknown}
+     */
+    private _savedData;
+    /**
+     * @type {Record<string, number | string>}
+     */
+    activatedItems: Record<string, number | string>;
+    /**
+     * @private
+     * @param {Partial<StatefulLayoutOptions>} options
+     */
+    private prepareOptions;
+    /**
+     * @private
+     */
+    private initValidationState;
+    /**
+     * @private
+     */
+    private updateState;
+    /**
+     * @private
+     */
+    private emitData;
+    /**
+     * @private
+     * @param {boolean} rehydrate
+     */
+    private createStateTree;
+    validate(): void;
+    resetValidation(): void;
+    /**
+     * @returns {boolean}
+     */
+    get valid(): boolean;
+    /**
+     * @returns {string[]}
+     */
+    get errors(): string[];
+    /**
+     * @returns {boolean}
+     */
+    get hasHiddenError(): boolean;
+    /**
+     * @returns {boolean}
+     */
+    get modified(): boolean;
+    /** @param {unknown} savedData */
+    set savedData(savedData: unknown);
+    get savedData(): unknown;
+    /**
+     * @private
+     * @param {StateNode} node
+     * @returns {import('../compile/types.js').ParentContextExpression | null}
+     */
+    private getParentContextExpression;
+    /**
+     * @param {StateNode} node
+     * @param {import('@json-layout/vocabulary').Expression} expression
+     * @param {any} data
+     * @returns {any}
+     */
+    evalNodeExpression(node: StateNode, expression: import("@json-layout/vocabulary").Expression, data: any): any;
+    /**
+     * @private
+     * @param {StateNode} node
+     * @param {unknown} data
+     * @param {boolean} [validated]
+     * @param {number} [activateKey]
+     */
+    private applyInput;
+    /**
+     * @private
+     * @type {null | [StateNode, unknown, boolean, number | undefined, ReturnType<typeof setTimeout>]}
+     */
+    private debouncedInput;
+    applyDebouncedInput(): void;
+    /**
+     * @param {StateNode} node
+     * @param {unknown} data
+     * @param {number} [activateKey]
+     */
+    input(node: StateNode, data: unknown, activateKey?: number): void;
+    /**
+     * @param {StateNode} node
+     */
+    blur(node: StateNode): void;
+    /**
+     * @param {StateNode} node
+     */
+    validateNodeRecurse(node: StateNode): void;
+    /**
+     * @private
+     * @type {Record<string, {key: any, appliedQ: boolean, items: import('@json-layout/vocabulary').SelectItems}>}
+     */
+    private _itemsCache;
+    /**
+     * @private
+     * @param {StateNode} node
+     * @param {string} q
+     * @returns {Promise<{appliedQ: boolean, items: import('@json-layout/vocabulary').SelectItems}>}
+     */
+    private getItemsWithoutCache;
+    /**
+     * @param {StateNode} node
+     * @param {string} q
+     * @returns {Promise<import('@json-layout/vocabulary').SelectItems>}
+     */
+    getItems(node: StateNode, q?: string): Promise<import("@json-layout/vocabulary").SelectItems>;
+    /**
+     * @param {StateNode} node
+     * @param {any} rawItem
+     * @returns {import('@json-layout/vocabulary').SelectItem}
+     */
+    prepareSelectItem(node: StateNode, rawItem: any): import("@json-layout/vocabulary").SelectItem;
+    /**
+     * keys of activatedItems that were explicitly selected by the user,
+     * as opposed to auto-activated from the data
+     * @private
+     * @type {Set<string>}
+     */
+    private _explicitActivatedItems;
+    /**
+     * @param {StateNode} node
+     * @param {number | string} key
+     */
+    activateItem(node: StateNode, key: number | string): void;
+    /**
+     * @param {string} fullKey
+     */
+    focusNode(fullKey: string): void;
+    /**
+     * @param {StateNode} node
+     * @param {boolean} skipUpdateState
+     */
+    deactivateItem(node: StateNode, skipUpdateState?: boolean): void;
+    handleAutofocus(): void;
+}
+export type StateNode = import("./types.js").StateNode;
+export type StateTree = import("./types.js").StateTree;
+export type StatefulLayoutOptions = import("./types.js").StatefulLayoutOptions;
+export type CreateStateTreeContext = import("./types.js").CreateStateTreeContext;
+export type TextFieldNode = import("./types.js").TextFieldNode;
+export type TextareaNode = import("./types.js").TextareaNode;
+export type NumberFieldNode = import("./types.js").NumberFieldNode;
+export type SliderNode = import("./types.js").SliderNode;
+export type SectionNode = import("./types.js").SectionNode;
+export type SelectNode = import("./types.js").SelectNode;
+export type AutocompleteNode = import("./types.js").AutocompleteNode;
+export type RadioGroupNode = import("./types.js").RadioGroupNode;
+export type CheckboxGroupNode = import("./types.js").CheckboxGroupNode;
+export type SwitchGroupNode = import("./types.js").SwitchGroupNode;
+export type ComboboxNode = import("./types.js").ComboboxNode;
+export type CheckboxNode = import("./types.js").CheckboxNode;
+export type SwitchNode = import("./types.js").SwitchNode;
+export type ColorPickerNode = import("./types.js").ColorPickerNode;
+export type DatePickerNode = import("./types.js").DatePickerNode;
+export type DateTimePickerNode = import("./types.js").DateTimePickerNode;
+export type TimePickerNode = import("./types.js").TimePickerNode;
+export type ExpansionPanelsNode = import("./types.js").ExpansionPanelsNode;
+export type TabsNode = import("./types.js").TabsNode;
+export type VerticalTabsNode = import("./types.js").VerticalTabsNode;
+export type StepperNode = import("./types.js").StepperNode;
+export type OneOfSelectNode = import("./types.js").OneOfSelectNode;
+export type ListNode = import("./types.js").ListNode;
+export type FileInputNode = import("./types.js").FileInputNode;
+export type CardNode = import("./types.js").CardNode;
+export type FileRef = import("./types.js").FileRef;
+//# sourceMappingURL=index.d.ts.map

package/types/state/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/state/index.js"],"names":[],"mappings":"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"}

package/types/state/options.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @typedef {import('./types.js').StatefulLayoutOptions} StatefulLayoutOptions
+ */
+/**
+ * @param {Partial<StatefulLayoutOptions>} partialOptions
+ * @param {import('../index.js').CompiledLayout} compiledLayout
+ * @returns {StatefulLayoutOptions}
+ */
+export function fillOptions(partialOptions: Partial<StatefulLayoutOptions>, compiledLayout: import("../index.js").CompiledLayout): StatefulLayoutOptions;
+export type StatefulLayoutOptions = import("./types.js").StatefulLayoutOptions;
+//# sourceMappingURL=options.d.ts.map

package/types/state/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/state/options.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;GAIG;AACH,4CAJW,OAAO,CAAC,qBAAqB,CAAC,kBAC9B,OAAO,aAAa,EAAE,cAAc,GAClC,qBAAqB,CAiCjC;oCAvCY,OAAO,YAAY,EAAE,qBAAqB"}

package/types/state/state-node.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @param {import('../index.js').CompiledExpression[]} expressions
+ * @param {import('@json-layout/vocabulary').Expression} expression
+ * @param {any} data
+ * @param {import('./types.js').StateNodeOptions} options
+ * @param {import('./utils/display.js').Display} display
+ * @param {import('@json-layout/vocabulary').BaseCompObject} layout
+ * @param {Record<string, import('ajv').ValidateFunction>} validates
+ * @param {unknown} rootData
+ * @param {import('../compile/types.js').ParentContextExpression | null} parentContext
+ * @returns {any}
+ */
+export function evalExpression(expressions: import("../index.js").CompiledExpression[], expression: import("@json-layout/vocabulary").Expression, data: any, options: import("./types.js").StateNodeOptions, display: import("./utils/display.js").Display, layout: import("@json-layout/vocabulary").BaseCompObject, validates: Record<string, import("ajv").ValidateFunction>, rootData: unknown, parentContext: import("../compile/types.js").ParentContextExpression | null): any;
+/**
+ *
+ * @param {import('./types.js').CreateStateTreeContext} context
+ * @param {import('./types.js').StateNodeOptions} parentOptions
+ * @param {import('../index.js').CompiledLayout} compiledLayout
+ * @param {string | number} key
+ * @param {string} fullKey
+ * @param {string | null} parentFullKey
+ * @param {string} dataPath
+ * @param {string | null} parentDataPath
+ * @param {import('../index.js').SkeletonNode} skeleton
+ * @param {import('@json-layout/vocabulary').Child | null} childDefinition
+ * @param {import('./utils/display.js').Display} parentDisplay
+ * @param {any} data
+ * @param {import('../compile/types.js').ParentContextExpression | null} parentContext
+ * @param {import('./types.js').ValidationState} validationState
+ * @param {number} titleDepth
+ * @param {import('./types.js').StateNode} [reusedNode]
+ * @returns {import('./types.js').StateNode}
+ */
+export function createStateNode(context: import("./types.js").CreateStateTreeContext, parentOptions: import("./types.js").StateNodeOptions, compiledLayout: import("../index.js").CompiledLayout, key: string | number, fullKey: string, parentFullKey: string | null, dataPath: string, parentDataPath: string | null, skeleton: import("../index.js").SkeletonNode, childDefinition: import("@json-layout/vocabulary").Child | null, parentDisplay: import("./utils/display.js").Display, data: any, parentContext: import("../compile/types.js").ParentContextExpression | null, validationState: import("./types.js").ValidationState, titleDepth: number, reusedNode?: import("./types.js").StateNode): import("./types.js").StateNode;
+export function useDefaultData(data: unknown, layout: import("@json-layout/vocabulary").BaseCompObject, options: import("./types.js").StateNodeOptions): boolean;
+/** @type {(draft: any, node: import('./types.js').StateNode, data: unknown) => any} */
+export const producePatchedData: (draft: any, node: import("./types.js").StateNode, data: unknown) => any;
+/**
+ * Merge a fresh getItems result into the list's current data.
+ *
+ * For every item in newItems, matched by key against existingItems:
+ * - matching key: the existing data entry is preserved (local edits win,
+ * the new item.value is discarded);
+ * - new key: the new item.value is used;
+ * - existing keys absent from newItems: dropped.
+ *
+ * When preserveOrder is true (used when listActions includes 'sort'):
+ * - the user's current order is kept for items that are still present;
+ * - items new in newItems are appended at the end, in newItems order;
+ * - items dropped from newItems are still removed.
+ *
+ * When preserveOrder is false (default), the order from newItems is used.
+ *
+ * When replaceData is true (used when items are not editable locally — i.e.
+ * listActions does not include 'edit' and listEditMode is not 'inline'):
+ * - on a matching key, the new item.value replaces the existing data
+ * entry (server is the source of truth for non-editable items).
+ *
+ * When replaceData is false (default), local data is preserved on match.
+ * @type {(existingData: any[], existingItems: import('@json-layout/vocabulary').SelectItems, newItems: import('@json-layout/vocabulary').SelectItems, preserveOrder?: boolean, replaceData?: boolean) => any}
+ */
+export const produceListData: (existingData: any[], existingItems: import("@json-layout/vocabulary").SelectItems, newItems: import("@json-layout/vocabulary").SelectItems, preserveOrder?: boolean, replaceData?: boolean) => any;
+//# sourceMappingURL=state-node.d.ts.map

package/types/state/state-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-node.d.ts","sourceRoot":"","sources":["../../src/state/state-node.js"],"names":[],"mappings":"AAkRA;;;;;;;;;;;GAWG;AACH,4CAXW,OAAO,aAAa,EAAE,kBAAkB,EAAE,cAC1C,OAAO,yBAAyB,EAAE,UAAU,QAC5C,GAAG,WACH,OAAO,YAAY,EAAE,gBAAgB,WACrC,OAAO,oBAAoB,EAAE,OAAO,UACpC,OAAO,yBAAyB,EAAE,cAAc,aAChD,MAAM,CAAC,MAAM,EAAE,OAAO,KAAK,EAAE,gBAAgB,CAAC,YAC9C,OAAO,iBACP,OAAO,qBAAqB,EAAE,uBAAuB,GAAG,IAAI,GAC1D,GAAG,CAsBf;AAiCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yCAlBW,OAAO,YAAY,EAAE,sBAAsB,iBAC3C,OAAO,YAAY,EAAE,gBAAgB,kBACrC,OAAO,aAAa,EAAE,cAAc,OACpC,MAAM,GAAG,MAAM,WACf,MAAM,iBACN,MAAM,GAAG,IAAI,YACb,MAAM,kBACN,MAAM,GAAG,IAAI,YACb,OAAO,aAAa,EAAE,YAAY,mBAClC,OAAO,yBAAyB,EAAE,KAAK,GAAG,IAAI,iBAC9C,OAAO,oBAAoB,EAAE,OAAO,QACpC,GAAG,iBACH,OAAO,qBAAqB,EAAE,uBAAuB,GAAG,IAAI,mBAC5D,OAAO,YAAY,EAAE,eAAe,cACpC,MAAM,eACN,OAAO,YAAY,EAAE,SAAS,GAC5B,OAAO,YAAY,EAAE,SAAS,CAipB1C;AAx9BM,qCALI,OAAO,UACP,OAAO,yBAAyB,EAAE,cAAc,WAChD,OAAO,YAAY,EAAE,gBAAgB,GACnC,OAAO,CAMnB;AAs9BD,uFAAuF;AACvF,iCADW,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,YAAY,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,KAAK,GAAG,CAgBjF;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,8BAFU,CAAC,YAAY,EAAE,GAAG,EAAE,EAAE,aAAa,EAAE,OAAO,yBAAyB,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,yBAAyB,EAAE,WAAW,EAAE,aAAa,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,OAAO,KAAK,GAAG,CAkC5M"}

package/types/state/state-tree.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @param {import('./types.js').CreateStateTreeContext} context
+ * @param {import('./types.js').StatefulLayoutOptions} options
+ * @param {import('../index.js').CompiledLayout} compiledLayout
+ * @param {import('../index.js').SkeletonTree} skeleton
+ * @param {import('./utils/display.js').Display} display
+ * @param {unknown} data
+ * @param {import('./types.js').ValidationState} validationState
+ * @param {import('./types.js').StateTree} [reusedStateTree]
+ * @returns {import('./types.js').StateTree}
+ */
+export function createStateTree(context: import("./types.js").CreateStateTreeContext, options: import("./types.js").StatefulLayoutOptions, compiledLayout: import("../index.js").CompiledLayout, skeleton: import("../index.js").SkeletonTree, display: import("./utils/display.js").Display, data: unknown, validationState: import("./types.js").ValidationState, reusedStateTree?: import("./types.js").StateTree): import("./types.js").StateTree;
+//# sourceMappingURL=state-tree.d.ts.map

package/types/state/state-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-tree.d.ts","sourceRoot":"","sources":["../../src/state/state-tree.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;GAUG;AACH,yCAVW,OAAO,YAAY,EAAE,sBAAsB,WAC3C,OAAO,YAAY,EAAE,qBAAqB,kBAC1C,OAAO,aAAa,EAAE,cAAc,YACpC,OAAO,aAAa,EAAE,YAAY,WAClC,OAAO,oBAAoB,EAAE,OAAO,QACpC,OAAO,mBACP,OAAO,YAAY,EAAE,eAAe,oBACpC,OAAO,YAAY,EAAE,SAAS,GAC5B,OAAO,YAAY,EAAE,SAAS,CAoF1C"}

package/types/state/types.d.ts

@@ -0,0 +1,200 @@
+import { type ErrorObject } from 'ajv/dist/2019.js';
+import { type BaseCompObject, type Cols, type StateNodeOptionsBase, type TextField, type Textarea, type NumberField, type Slider, type Checkbox, type Switch, type DatePicker, type DateTimePicker, type TimePicker, type ColorPicker, type Section, type OneOfSelect, type Select, type Autocomplete, type Tabs, type VerticalTabs, type ExpansionPanels, type Stepper, type List, type Combobox, type FileInput, type Card, type Child, type StateNodePropsLib, type Slots } from '@json-layout/vocabulary';
+import { type SkeletonTree, type SkeletonNode, type StatefulLayout, type CompiledLayout } from '../index.js';
+import { type LocaleMessages } from '../i18n/types.js';
+export interface StateNode {
+    key: string | number;
+    fullKey: string;
+    parentFullKey: string | null;
+    dataPath: string;
+    parentDataPath: string | null;
+    skeleton: SkeletonNode;
+    layout: BaseCompObject;
+    cols: Cols;
+    data: unknown;
+    error: string | undefined;
+    childError: boolean | undefined;
+    modified: boolean | undefined;
+    childModified: boolean | undefined;
+    validated: boolean;
+    width: number;
+    options: StateNodeOptions;
+    titleDepth: number;
+    messages: LocaleMessages;
+    autofocus?: boolean;
+    loading?: boolean;
+    autofocusChild?: string | number;
+    props?: StateNodePropsLib;
+    slots?: Slots;
+    itemsCacheKey: any;
+    children?: StateNode[];
+}
+export interface StateTree {
+    root: StateNode;
+    valid: boolean;
+}
+export interface CreateStateTreeContext {
+    allErrors?: ErrorObject[];
+    errors?: ErrorObject[];
+    rehydrateErrors?: ErrorObject[];
+    additionalPropertiesErrors?: ErrorObject[];
+    files: FileRef[];
+    activatedItems: Record<string, number | string>;
+    explicitActivatedItems: Set<string>;
+    reResolveActivatedItems: boolean;
+    autoActivatedItems: Record<string, number | number>;
+    autofocusTarget: string | null;
+    currentInput: string | null;
+    initial: boolean;
+    rehydrate: boolean;
+    cacheKeys: Record<string, StateNodeCacheKey>;
+    rootData: unknown;
+    savedData: unknown;
+    nodes: StateNode[];
+    nodesMap: Map<string, StateNode>;
+    getItemsDataRequests: StateNode[];
+}
+export interface FileRef {
+    file: File;
+    dataPath: string;
+}
+export type StateNodeCacheKey = [
+    StateNode | undefined,
+    StateNodeOptions,
+    CompiledLayout,
+    string,
+    boolean,
+    SkeletonNode,
+    Child | null,
+    number,
+    boolean,
+    Record<string, number | string>,
+    boolean,
+    number,
+    unknown,
+    number,
+    unknown
+];
+export interface ValidationState {
+    initialized: boolean;
+    validatedForm: boolean;
+    validatedChildren: Set<string>;
+}
+export type StateNodeOptions = Required<StateNodeOptionsBase & {
+    context: Record<string, any>;
+    messages: LocaleMessages;
+    fetchBaseURL: string;
+    fetchOptions: Omit<RequestInit, 'body'> | ((url: URL) => Omit<RequestInit, 'body'>);
+    fetch: ((url: string, fetchOptions: RequestInit) => any);
+    onData: (data: any) => void;
+    onUpdate: (statefulLayout: StatefulLayout) => void;
+    onAutofocus: (key: string) => void;
+    noStateCache: boolean;
+}>;
+export type StatefulLayoutOptions = StateNodeOptions & {
+    width: number;
+};
+export type TextFieldNode = Omit<StateNode, 'children'> & {
+    layout: TextField;
+    data: string | undefined | null;
+};
+export type TextareaNode = Omit<StateNode, 'children'> & {
+    layout: Textarea;
+    data: string | undefined | null;
+};
+export type NumberFieldNode = Omit<StateNode, 'children'> & {
+    layout: NumberField;
+    data: number | undefined | null;
+};
+export type SliderNode = Omit<StateNode, 'children'> & {
+    layout: Slider;
+    data: number | undefined | null;
+};
+export type CheckboxNode = Omit<StateNode, 'children'> & {
+    layout: Checkbox;
+    data: boolean | undefined | null;
+};
+export type SwitchNode = Omit<StateNode, 'children'> & {
+    layout: Switch;
+    data: boolean | undefined | null;
+};
+export type DatePickerNode = Omit<StateNode, 'children'> & {
+    layout: DatePicker;
+    data: string | undefined | null;
+};
+export type DateTimePickerNode = Omit<StateNode, 'children'> & {
+    layout: DateTimePicker;
+    data: string | undefined | null;
+};
+export type TimePickerNode = Omit<StateNode, 'children'> & {
+    layout: TimePicker;
+    data: string | undefined | null;
+};
+export type ColorPickerNode = Omit<StateNode, 'children'> & {
+    layout: ColorPicker;
+    data: string | undefined | null;
+};
+export type SectionNode = StateNode & {
+    layout: Section;
+    children: StateNode[];
+};
+export type OneOfSelectNode = StateNode & {
+    layout: OneOfSelect;
+    data: Record<string, unknown>;
+    childrenTrees: SkeletonTree[];
+};
+export type SelectNode = Omit<StateNode, 'children'> & {
+    layout: Select;
+    data: any;
+};
+export type AutocompleteNode = Omit<StateNode, 'children'> & {
+    layout: Autocomplete;
+    data: any;
+};
+export type RadioGroupNode = Omit<StateNode, 'children'> & {
+    layout: Select;
+    data: any;
+};
+export type CheckboxGroupNode = Omit<StateNode, 'children'> & {
+    layout: Select;
+    data: any;
+};
+export type SwitchGroupNode = Omit<StateNode, 'children'> & {
+    layout: Select;
+    data: any;
+};
+export type TabsNode = StateNode & {
+    layout: Tabs;
+    children: StateNode[];
+};
+export type VerticalTabsNode = StateNode & {
+    layout: VerticalTabs;
+    children: StateNode[];
+};
+export type ExpansionPanelsNode = StateNode & {
+    layout: ExpansionPanels;
+    children: StateNode[];
+};
+export type StepperNode = StateNode & {
+    layout: Stepper;
+    children: StateNode[];
+};
+export type ListNode = StateNode & {
+    layout: List;
+    data: any[];
+    children: StateNode[];
+    childrenTrees: SkeletonTree[];
+};
+export type ComboboxNode = Omit<StateNode, 'children'> & {
+    layout: Combobox;
+    data: any[];
+};
+export type FileInputNode = Omit<StateNode, 'children'> & {
+    layout: FileInput;
+    data: object | undefined | null;
+};
+export type CardNode = StateNode & {
+    layout: Card;
+    children: StateNode[];
+};
+//# sourceMappingURL=types.d.ts.map