@revisium/schema-toolkit 0.20.2 → 0.21.0

package/dist/typed-BinPIf3R.d.ts

@@ -0,0 +1,455 @@
+import { j as SchemaNode, P as Path, h as NodeMetadata, f as SchemaValidationError, T as TreeFormulaValidationError, k as SchemaPatch, B as BasePath, p as BasePathSegment, D as Diagnostic } from './types-C_pTFtSY.js';
+import { g as JsonObjectSchema, j as JsonSchema } from './schema.types-On_VGw2m.js';
+import { h as JsonPatch } from './json-patch.types-BpVnp08Z.js';
+import { c as JsonValue } from './json.types-PrMmLhba.js';
+
+type JsonValuePatchMove = {
+    op: 'move';
+    from: string;
+    path: string;
+};
+type JsonValuePatchReplace = {
+    op: 'replace';
+    path: string;
+    value: JsonValue;
+};
+type JsonValuePatchRemove = {
+    op: 'remove';
+    path: string;
+};
+type JsonValuePatchAdd = {
+    op: 'add';
+    path: string;
+    value: JsonValue;
+};
+type JsonValuePatch = JsonValuePatchMove | JsonValuePatchReplace | JsonValuePatchRemove | JsonValuePatchAdd;
+
+type PrimitiveTypeName = 'string' | 'number' | 'boolean';
+type CompositeTypeName = 'object' | 'array';
+type SimpleFieldType = PrimitiveTypeName | CompositeTypeName;
+interface FieldSchemaSpec {
+    type?: SimpleFieldType;
+    $ref?: string;
+    default?: unknown;
+    title?: string;
+    description?: string;
+    deprecated?: boolean;
+    foreignKey?: string;
+    'x-formula'?: {
+        expression: string;
+    };
+}
+type FieldTypeSpec = SimpleFieldType | FieldSchemaSpec;
+interface TransformContext {
+    sourceNode: SchemaNode;
+    targetSpec: FieldSchemaSpec;
+    refSchemas?: RefSchemas$1;
+}
+interface TransformResult {
+    node: SchemaNode;
+}
+interface TypeTransformer {
+    canTransform(ctx: TransformContext): boolean;
+    transform(ctx: TransformContext): TransformResult;
+}
+
+type RefSchemas$1 = Record<string, JsonSchema>;
+interface SchemaModelOptions {
+    refSchemas?: RefSchemas$1;
+    customTransformers?: TypeTransformer[];
+}
+type FieldType = 'string' | 'number' | 'boolean' | 'object' | 'array';
+
+interface ReplaceResult {
+    replacedNodeId: string;
+    newNodeId: string;
+}
+interface SchemaModel {
+    readonly root: SchemaNode;
+    nodeById(id: string): SchemaNode;
+    pathOf(id: string): Path;
+    addField(parentId: string, name: string, type: FieldType): SchemaNode;
+    insertFieldAt(parentId: string, index: number, name: string, type: FieldType): SchemaNode;
+    removeField(nodeId: string): boolean;
+    renameField(nodeId: string, newName: string): void;
+    changeFieldType(nodeId: string, newType: FieldTypeSpec): SchemaNode;
+    updateMetadata(nodeId: string, meta: Partial<NodeMetadata>): void;
+    updateFormula(nodeId: string, expression: string | undefined): void;
+    updateForeignKey(nodeId: string, foreignKey: string | undefined): void;
+    updateDefaultValue(nodeId: string, value: unknown): void;
+    wrapInArray(nodeId: string): ReplaceResult | null;
+    wrapRootInArray(): ReplaceResult | null;
+    replaceRoot(newType: FieldType): ReplaceResult | null;
+    canMoveNode(nodeId: string, targetParentId: string): boolean;
+    hasValidDropTarget(nodeId: string): boolean;
+    moveNode(nodeId: string, targetParentId: string): void;
+    getFormulaDependents(nodeId: string): readonly string[];
+    hasFormulaDependents(nodeId: string): boolean;
+    serializeFormula(nodeId: string): string;
+    readonly validationErrors: SchemaValidationError[];
+    readonly formulaErrors: TreeFormulaValidationError[];
+    readonly isDirty: boolean;
+    readonly isValid: boolean;
+    readonly patches: SchemaPatch[];
+    readonly jsonPatches: JsonPatch[];
+    markAsSaved(): void;
+    revert(): void;
+    readonly plainSchema: JsonObjectSchema;
+    readonly nodeCount: number;
+    readonly refSchemas: RefSchemas$1 | undefined;
+    generateDefaultValue(options?: {
+        arrayItemCount?: number;
+    }): unknown;
+}
+
+interface ValuePathSegment extends BasePathSegment {
+    isProperty(): boolean;
+    isIndex(): boolean;
+    propertyName(): string;
+    indexValue(): number;
+    equals(other: ValuePathSegment): boolean;
+}
+interface ValuePath extends BasePath<ValuePathSegment, ValuePath> {
+    asString(): string;
+    asJsonPointer(): string;
+    child(name: string): ValuePath;
+    childIndex(index: number): ValuePath;
+}
+
+interface BaseChange {
+    readonly path: ValuePath;
+}
+interface SetValueChange extends BaseChange {
+    readonly type: 'setValue';
+    readonly value: JsonValue;
+    readonly oldValue: JsonValue;
+}
+interface AddPropertyChange extends BaseChange {
+    readonly type: 'addProperty';
+    readonly value: JsonValue;
+}
+interface RemovePropertyChange extends BaseChange {
+    readonly type: 'removeProperty';
+}
+interface ArrayPushChange extends BaseChange {
+    readonly type: 'arrayPush';
+    readonly value: JsonValue;
+}
+interface ArrayInsertChange extends BaseChange {
+    readonly type: 'arrayInsert';
+    readonly index: number;
+    readonly value: JsonValue;
+}
+interface ArrayRemoveChange extends BaseChange {
+    readonly type: 'arrayRemove';
+    readonly index: number;
+}
+interface ArrayMoveChange extends BaseChange {
+    readonly type: 'arrayMove';
+    readonly fromIndex: number;
+    readonly toIndex: number;
+}
+interface ArrayReplaceChange extends BaseChange {
+    readonly type: 'arrayReplace';
+    readonly index: number;
+    readonly value: JsonValue;
+}
+interface ArrayClearChange extends BaseChange {
+    readonly type: 'arrayClear';
+}
+type Change = SetValueChange | AddPropertyChange | RemovePropertyChange | ArrayPushChange | ArrayInsertChange | ArrayRemoveChange | ArrayMoveChange | ArrayReplaceChange | ArrayClearChange;
+interface ValueTreeLike {
+    readonly root: ValueNode;
+    get(path: string): ValueNode | undefined;
+    getValue(path: string): unknown;
+    setValue(path: string, value: unknown, options?: {
+        internal?: boolean;
+    }): void;
+    getPlainValue(): unknown;
+    readonly isDirty: boolean;
+    readonly isValid: boolean;
+    readonly errors: readonly Diagnostic[];
+    getPatches(): readonly JsonValuePatch[];
+    commit(): void;
+    revert(): void;
+    nodeById(id: string): ValueNode | undefined;
+    pathOf(nodeOrId: ValueNode | string): ValuePath;
+    dispose(): void;
+}
+
+interface RowModelOptions {
+    rowId: string;
+    schema: JsonSchema;
+    data?: unknown;
+    fkResolver?: ForeignKeyResolver;
+    refSchemas?: RefSchemas;
+}
+interface TableModelLike {
+    getRowIndex(rowId: string): number;
+    getRowAt(index: number): RowModel | undefined;
+    readonly rowCount: number;
+}
+interface RowModel {
+    readonly rowId: string;
+    readonly tableModel: TableModelLike | null;
+    readonly tree: ValueTreeLike;
+    readonly index: number;
+    readonly prev: RowModel | null;
+    readonly next: RowModel | null;
+    get(path: string): ValueNode | undefined;
+    getValue(path: string): unknown;
+    setValue(path: string, value: unknown): void;
+    getPlainValue(): unknown;
+    nodeById(id: string): ValueNode | undefined;
+    readonly isDirty: boolean;
+    readonly isValid: boolean;
+    readonly errors: readonly Diagnostic[];
+    getPatches(): readonly JsonValuePatch[];
+    commit(): void;
+    revert(): void;
+    dispose(): void;
+}
+
+interface RowData {
+    rowId: string;
+    data: unknown;
+}
+interface TableModelOptions {
+    tableId: string;
+    schema: JsonObjectSchema;
+    rows?: RowData[];
+    fkResolver?: ForeignKeyResolver;
+    refSchemas?: RefSchemas;
+}
+interface TableModel {
+    readonly fk: ForeignKeyResolver | undefined;
+    readonly refSchemas: RefSchemas | undefined;
+    readonly tableId: string;
+    readonly baseTableId: string;
+    readonly isRenamed: boolean;
+    rename(newTableId: string): void;
+    readonly schema: SchemaModel;
+    readonly rows: readonly RowModel[];
+    readonly rowCount: number;
+    addRow(rowId: string, data?: unknown): RowModel;
+    removeRow(rowId: string): void;
+    getRow(rowId: string): RowModel | undefined;
+    getRowIndex(rowId: string): number;
+    getRowAt(index: number): RowModel | undefined;
+    readonly isDirty: boolean;
+    commit(): void;
+    revert(): void;
+    dispose(): void;
+}
+
+interface ForeignKeyResolver {
+    addSchema(tableId: string, schema: JsonObjectSchema): void;
+    addTable(tableId: string, schema: JsonObjectSchema, rows: RowData[]): void;
+    addRow(tableId: string, rowId: string, data: unknown): void;
+    renameTable(oldTableId: string, newTableId: string): void;
+    getSchema(tableId: string): Promise<JsonObjectSchema>;
+    getRowData(tableId: string, rowId: string): Promise<RowData>;
+    isLoading(tableId: string): boolean;
+    isLoadingRow(tableId: string, rowId: string): boolean;
+    hasSchema(tableId: string): boolean;
+    hasTable(tableId: string): boolean;
+    hasRow(tableId: string, rowId: string): boolean;
+    setPrefetch(enabled: boolean): void;
+    readonly isPrefetchEnabled: boolean;
+    dispose(): void;
+}
+
+type NodeFactoryFn = (name: string, schema: JsonSchema, value: unknown, id?: string) => ValueNode;
+declare class NodeFactoryRegistry {
+    private readonly factories;
+    register(schemaType: string, factory: NodeFactoryFn): this;
+    get(schemaType: string): NodeFactoryFn | undefined;
+    has(schemaType: string): boolean;
+}
+type RefSchemas = Record<string, JsonSchema>;
+interface NodeFactoryOptions {
+    refSchemas?: RefSchemas;
+    fkResolver?: ForeignKeyResolver;
+}
+declare class NodeFactory {
+    private readonly registry;
+    private readonly refSchemas;
+    constructor(registry: NodeFactoryRegistry, options?: NodeFactoryOptions);
+    create(name: string, schema: JsonSchema, value: unknown, id?: string): ValueNode;
+    createTree(schema: JsonSchema, value: unknown): ValueNode;
+    private getSchemaType;
+    private resolveSchema;
+}
+declare function createDefaultRegistry(fkResolver?: ForeignKeyResolver): NodeFactoryRegistry;
+declare function createNodeFactory(options?: NodeFactoryOptions): NodeFactory;
+
+declare enum ValueType {
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    Object = "object",
+    Array = "array"
+}
+interface FormulaDefinition {
+    readonly expression: string;
+    readonly version: number;
+}
+interface FormulaWarning {
+    readonly type: 'nan' | 'infinity' | 'type-coercion' | 'division-by-zero' | 'null-reference' | 'runtime-error';
+    readonly message: string;
+    readonly expression: string;
+    readonly computedValue: unknown;
+}
+interface ValueNode {
+    readonly id: string;
+    readonly type: ValueType;
+    readonly schema: JsonSchema;
+    parent: ValueNode | null;
+    readonly name: string;
+    readonly value: unknown;
+    getPlainValue(): unknown;
+    isObject(): this is ObjectValueNode;
+    isArray(): this is ArrayValueNode;
+    isPrimitive(): this is PrimitiveValueNode;
+    readonly errors: readonly Diagnostic[];
+    readonly warnings: readonly Diagnostic[];
+    readonly isValid: boolean;
+    readonly hasWarnings: boolean;
+}
+interface DirtyTrackable {
+    readonly isDirty: boolean;
+    commit(): void;
+    revert(): void;
+}
+interface PrimitiveValueNode extends ValueNode, DirtyTrackable {
+    value: string | number | boolean;
+    readonly baseValue: string | number | boolean;
+    readonly defaultValue: unknown;
+    readonly formula: FormulaDefinition | undefined;
+    readonly formulaWarning: FormulaWarning | null;
+    readonly isReadOnly: boolean;
+    setValue(value: unknown, options?: {
+        internal?: boolean;
+    }): void;
+    setFormulaWarning(warning: FormulaWarning | null): void;
+}
+interface ObjectValueNode extends ValueNode, DirtyTrackable {
+    readonly value: Record<string, ValueNode>;
+    readonly children: readonly ValueNode[];
+    child(name: string): ValueNode | undefined;
+    addChild(node: ValueNode): void;
+    removeChild(name: string): void;
+    hasChild(name: string): boolean;
+    setValue(value: Record<string, unknown>, options?: {
+        internal?: boolean;
+    }): void;
+}
+interface ArrayValueNode extends ValueNode, DirtyTrackable {
+    readonly value: readonly ValueNode[];
+    readonly length: number;
+    at(index: number): ValueNode | undefined;
+    push(node: ValueNode): void;
+    insertAt(index: number, node: ValueNode): void;
+    removeAt(index: number): void;
+    move(fromIndex: number, toIndex: number): void;
+    replaceAt(index: number, node: ValueNode): void;
+    clear(): void;
+    setNodeFactory(factory: NodeFactory): void;
+    pushValue(value?: unknown): void;
+    insertValueAt(index: number, value?: unknown): void;
+    setValue(value: unknown[], options?: {
+        internal?: boolean;
+    }): void;
+}
+interface ValueNodeOptions {
+    readonly id?: string;
+    readonly name: string;
+    readonly schema: JsonSchema;
+    readonly parent?: ValueNode | null;
+}
+interface PrimitiveNodeOptions extends ValueNodeOptions {
+    readonly value?: unknown;
+}
+interface ObjectNodeOptions extends ValueNodeOptions {
+    readonly children?: ValueNode[];
+}
+interface ArrayNodeOptions extends ValueNodeOptions {
+    readonly items?: ValueNode[];
+}
+declare function extractFormulaDefinition(schema: JsonSchema): FormulaDefinition | undefined;
+
+type SchemaType<S> = S extends {
+    readonly type: infer T;
+} ? T : S extends {
+    type: infer T;
+} ? T : never;
+type SchemaProperties<S> = S extends {
+    readonly properties: infer P;
+} ? P : S extends {
+    properties: infer P;
+} ? P : never;
+type SchemaItems<S> = S extends {
+    readonly items: infer I;
+} ? I : S extends {
+    items: infer I;
+} ? I : never;
+type IsNever<T> = [T] extends [never] ? true : false;
+type IsPrimitive<S> = IsNever<SchemaType<S>> extends true ? false : SchemaType<S> extends 'string' | 'number' | 'boolean' ? true : false;
+type PrimitiveValue<T> = T extends 'string' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : never;
+type InferValue<S> = IsNever<SchemaType<S>> extends true ? unknown : IsPrimitive<S> extends true ? PrimitiveValue<SchemaType<S>> : SchemaType<S> extends 'object' ? {
+    [K in keyof SchemaProperties<S>]: InferValue<SchemaProperties<S>[K]>;
+} : SchemaType<S> extends 'array' ? InferValue<SchemaItems<S>>[] : unknown;
+interface TypedPrimitiveValueNode<T extends string | number | boolean> extends PrimitiveValueNode {
+    readonly value: T;
+    readonly baseValue: T;
+    getPlainValue(): T;
+    setValue(value: T, options?: {
+        internal?: boolean;
+    }): void;
+}
+interface TypedObjectValueNode<P> extends ObjectValueNode {
+    child<K extends keyof P & string>(name: K): InferNode<P[K]>;
+    getPlainValue(): {
+        [K in keyof P]: InferValue<P[K]>;
+    };
+    setValue(value: Partial<{
+        [K in keyof P]: InferValue<P[K]>;
+    }>, options?: {
+        internal?: boolean;
+    }): void;
+}
+interface TypedArrayValueNode<I> extends ArrayValueNode {
+    at(index: number): InferNode<I> | undefined;
+    getPlainValue(): InferValue<I>[];
+    setValue(value: InferValue<I>[], options?: {
+        internal?: boolean;
+    }): void;
+}
+type PrimitiveNode<T> = T extends 'string' ? TypedPrimitiveValueNode<string> : T extends 'number' ? TypedPrimitiveValueNode<number> : T extends 'boolean' ? TypedPrimitiveValueNode<boolean> : never;
+type InferNode<S> = IsNever<SchemaType<S>> extends true ? ValueNode : IsPrimitive<S> extends true ? PrimitiveNode<SchemaType<S>> : SchemaType<S> extends 'object' ? TypedObjectValueNode<SchemaProperties<S>> : SchemaType<S> extends 'array' ? TypedArrayValueNode<SchemaItems<S>> : ValueNode;
+type SchemaPaths<S, Prefix extends string = ''> = IsPrimitive<S> extends true ? never : SchemaType<S> extends 'object' ? {
+    [K in keyof SchemaProperties<S> & string]: `${Prefix}${K}` | SchemaPaths<SchemaProperties<S>[K], `${Prefix}${K}.`>;
+}[keyof SchemaProperties<S> & string] : SchemaType<S> extends 'array' ? `${Prefix}[${number}]` | SchemaPaths<SchemaItems<S>, `${Prefix}[${number}].`> : never;
+type SchemaAtPath<S, Path extends string> = Path extends `${infer Key}.${infer Rest}` ? Key extends `[${string}]` ? SchemaAtPath<SchemaItems<S>, Rest> : SchemaAtPath<Key extends keyof SchemaProperties<S> ? SchemaProperties<S>[Key] : never, Rest> : Path extends `[${string}]` ? SchemaItems<S> : Path extends keyof SchemaProperties<S> ? SchemaProperties<S>[Path] : never;
+type NodeAtPath<S, Path extends string> = InferNode<SchemaAtPath<S, Path>>;
+type ValueAtPath<S, Path extends string> = InferValue<SchemaAtPath<S, Path>>;
+type SchemaFromPrimitive<T> = T extends string ? {
+    type: 'string';
+} : T extends number ? {
+    type: 'number';
+} : T extends boolean ? {
+    type: 'boolean';
+} : never;
+type SchemaFromValue<T> = T extends string | number | boolean ? SchemaFromPrimitive<T> : T extends (infer E)[] ? {
+    type: 'array';
+    items: SchemaFromValue<E>;
+} : T extends Record<string, unknown> ? {
+    type: 'object';
+    properties: {
+        [K in keyof T]: SchemaFromValue<T[K]>;
+    };
+} : never;
+type NodeFromValue<T> = InferNode<SchemaFromValue<T>>;
+type ValuePaths<T> = SchemaPaths<SchemaFromValue<T>>;
+
+export { type FieldSchemaSpec as $, type ArrayValueNode as A, type SchemaModel as B, type FieldType as C, type DirtyTrackable as D, type FieldTypeSpec as E, type FormulaDefinition as F, type ReplaceResult as G, type SchemaModelOptions as H, type InferValue as I, type JsonValuePatchMove as J, type TableModel as K, type TableModelOptions as L, type RowData as M, type NodeAtPath as N, type ObjectValueNode as O, type PrimitiveValueNode as P, type RowModel as Q, type RefSchemas as R, type SchemaPaths as S, type TypedPrimitiveValueNode as T, type RowModelOptions as U, type ValueAtPath as V, type TableModelLike as W, type ForeignKeyResolver as X, type TypeTransformer as Y, type TransformContext as Z, type TransformResult as _, type JsonValuePatchReplace as a, type SimpleFieldType as a0, type PrimitiveTypeName as a1, type CompositeTypeName as a2, type RefSchemas$1 as a3, type ValuePath as a4, type Change as a5, type JsonValuePatchRemove as b, type JsonValuePatchAdd as c, type JsonValuePatch as d, type TypedObjectValueNode as e, type TypedArrayValueNode as f, type InferNode as g, type SchemaAtPath as h, type SchemaFromValue as i, type NodeFromValue as j, type ValuePaths as k, ValueType as l, extractFormulaDefinition as m, NodeFactoryRegistry as n, createNodeFactory as o, createDefaultRegistry as p, type ValueNode as q, type FormulaWarning as r, type ValueNodeOptions as s, type PrimitiveNodeOptions as t, type ObjectNodeOptions as u, type ArrayNodeOptions as v, type NodeFactoryFn as w, type NodeFactoryOptions as x, NodeFactory as y, type ValueTreeLike as z };