@revisium/schema-toolkit 0.14.3 → 0.16.0

package/dist/core/index.d.ts

@@ -0,0 +1,314 @@
+import { R as ReactivityAdapter, b as SchemaNode, N as NodeMetadata, d as Formula, P as Path, e as PathSegment, c as SchemaTree, f as SchemaPatch, J as JsonPatch, V as ValidatorFactoryFn, g as ValidatorRule, h as Validator, i as ValidationContext, D as Diagnostic, j as SchemaLike } from '../types-Cnfj5nLO.js';
+export { A as AnnotationType, k as AnnotationsMap, n as DefaultValueType, l as DiagnosticSeverity, E as EMPTY_METADATA, F as FormulaValidationError, m as NodeType, S as SchemaValidationError, a as SchemaValidationErrorType } from '../types-Cnfj5nLO.js';
+export { F as FIELD_NAME_ERROR_MESSAGE, i as isValidFieldName, a as validateFormulas, v as validateSchema } from '../FormulaValidator-DGGmwqDQ.js';
+export { a as FieldChange, F as FieldChangeType } from '../types-C_GxaUve.js';
+export { c as computeValueDiff } from '../computeValueDiff-CDwbNw8F.js';
+import { i as JsonSchema, f as JsonObjectSchema } from '../schema.types-ZX5fUW1X.js';
+import '@revisium/formula';
+
+declare const noopAdapter: ReactivityAdapter;
+
+declare const NULL_NODE: SchemaNode;
+
+declare function createObjectNode(id: string, name: string, children?: readonly SchemaNode[], metadata?: NodeMetadata): SchemaNode;
+
+declare function createArrayNode(id: string, name: string, items: SchemaNode, metadata?: NodeMetadata): SchemaNode;
+
+interface StringNodeOptions {
+    readonly defaultValue?: string;
+    readonly foreignKey?: string;
+    readonly formula?: Formula;
+    readonly metadata?: NodeMetadata;
+}
+declare function createStringNode(id: string, name: string, options?: StringNodeOptions): SchemaNode;
+
+interface NumberNodeOptions {
+    readonly defaultValue?: number;
+    readonly formula?: Formula;
+    readonly metadata?: NodeMetadata;
+}
+declare function createNumberNode(id: string, name: string, options?: NumberNodeOptions): SchemaNode;
+
+interface BooleanNodeOptions {
+    readonly defaultValue?: boolean;
+    readonly formula?: Formula;
+    readonly metadata?: NodeMetadata;
+}
+declare function createBooleanNode(id: string, name: string, options?: BooleanNodeOptions): SchemaNode;
+
+declare function createRefNode(id: string, name: string, ref: string, metadata?: NodeMetadata): SchemaNode;
+
+declare const EMPTY_PATH: Path;
+declare function createPath(segments: readonly PathSegment[]): Path;
+
+declare class PropertySegment implements PathSegment {
+    private readonly name;
+    constructor(name: string);
+    isProperty(): boolean;
+    isItems(): boolean;
+    propertyName(): string;
+    equals(other: PathSegment): boolean;
+}
+declare class ItemsSegment implements PathSegment {
+    isProperty(): boolean;
+    isItems(): boolean;
+    propertyName(): string;
+    equals(other: PathSegment): boolean;
+}
+
+declare function jsonPointerToSegments(pointer: string): PathSegment[];
+declare function jsonPointerToPath(pointer: string): Path;
+declare function jsonPointerToSimplePath(pointer: string): string;
+
+declare function createSchemaTree(root: SchemaNode): SchemaTree;
+
+declare class PatchBuilder {
+    build(currentTree: SchemaTree, baseTree: SchemaTree): SchemaPatch[];
+    private syncReplacements;
+}
+
+type ChangeType = 'added' | 'removed' | 'moved' | 'modified';
+interface AddedChange {
+    readonly type: 'added';
+    readonly baseNode: null;
+    readonly currentNode: SchemaNode;
+}
+interface RemovedChange {
+    readonly type: 'removed';
+    readonly baseNode: SchemaNode;
+    readonly currentNode: null;
+}
+interface MovedChange {
+    readonly type: 'moved';
+    readonly baseNode: SchemaNode;
+    readonly currentNode: SchemaNode;
+}
+interface ModifiedChange {
+    readonly type: 'modified';
+    readonly baseNode: SchemaNode;
+    readonly currentNode: SchemaNode;
+}
+type RawChange = AddedChange | RemovedChange | MovedChange | ModifiedChange;
+interface CoalescedChanges {
+    readonly moved: readonly MovedChange[];
+    readonly added: readonly AddedChange[];
+    readonly removed: readonly RemovedChange[];
+    readonly modified: readonly ModifiedChange[];
+}
+
+declare class NodePathIndex {
+    private readonly _basePaths;
+    private readonly _replacements;
+    constructor(baseTree: SchemaTree);
+    hasBasePath(nodeId: string): boolean;
+    getBasePath(nodeId: string): Path | undefined;
+    trackReplacement(oldNodeId: string, newNodeId: string): void;
+    getReplacementNodeId(oldNodeId: string): string | undefined;
+    getOriginalNodeId(newNodeId: string): string | undefined;
+    isReplacement(nodeId: string): boolean;
+    get replacements(): ReadonlyMap<string, string>;
+}
+
+declare class SchemaDiff {
+    private _baseTree;
+    private readonly _currentTree;
+    private _index;
+    constructor(currentTree: SchemaTree);
+    get baseTree(): SchemaTree;
+    get currentTree(): SchemaTree;
+    get index(): NodePathIndex;
+    isDirty(): boolean;
+    collectChanges(): RawChange[];
+    coalesceChanges(changes?: readonly RawChange[]): CoalescedChanges;
+    trackReplacement(oldNodeId: string, newNodeId: string): void;
+    markAsSaved(): void;
+}
+
+declare class ChangeCollector {
+    private readonly baseTree;
+    private readonly currentTree;
+    private readonly index;
+    private readonly context;
+    constructor(baseTree: SchemaTree, currentTree: SchemaTree, index: NodePathIndex);
+    collect(): RawChange[];
+    private collectFromCurrentTree;
+    private collectRemovedNodes;
+}
+declare function collectChanges(baseTree: SchemaTree, currentTree: SchemaTree, index: NodePathIndex): RawChange[];
+
+declare class ChangeCoalescer {
+    private readonly currentTree;
+    private readonly index;
+    constructor(currentTree: SchemaTree, index: NodePathIndex);
+    coalesce(changes: readonly RawChange[]): CoalescedChanges;
+    private getMovedPaths;
+    private isNestedChange;
+    private getChangePath;
+    private hasParentChange;
+    private isTypeChangeReplacement;
+    private isAffectedByMove;
+}
+declare function coalesceChanges(changes: readonly RawChange[], currentTree: SchemaTree, index: NodePathIndex): CoalescedChanges;
+
+interface ComparatorContext {
+    currentTree: SchemaTree;
+    baseTree: SchemaTree;
+}
+declare function areNodesEqual(current: SchemaNode, base: SchemaNode, context: ComparatorContext): boolean;
+declare function areNodesContentEqual(current: SchemaNode, base: SchemaNode, context: ComparatorContext): boolean;
+
+declare class PatchGenerator {
+    private readonly currentTree;
+    private readonly baseTree;
+    private readonly serializer;
+    private readonly context;
+    constructor(currentTree: SchemaTree, baseTree: SchemaTree);
+    generate(coalesced: CoalescedChanges): JsonPatch[];
+    private collectMovedNodeIds;
+    private partitionAddPatches;
+    private generateMovePatches;
+    private generateModifyAfterMove;
+    private generateAddPatches;
+    private generateRemovePatches;
+    private generateReplacePatches;
+    private generateArrayReplacePatches;
+    private hasItemsChanged;
+    private isChildOfAny;
+    private hasChildIn;
+    private isActuallyModified;
+    private hasOnlyChildChanges;
+    private hasMetadataChanged;
+    private hasOnlyItemsChanges;
+}
+
+declare class PatchEnricher {
+    private readonly currentTree;
+    private readonly baseTree;
+    constructor(currentTree: SchemaTree, baseTree: SchemaTree);
+    enrich(patch: JsonPatch): SchemaPatch;
+    private enrichAddPatch;
+    private enrichRemovePatch;
+    private enrichMovePatch;
+    private enrichReplacePatch;
+    private computeAddMetadata;
+    private computeTypeChange;
+    private computeFormulaChange;
+    private getFormulaExpression;
+    private computeDefaultChange;
+    private computeDescriptionChange;
+    private computeDeprecatedChange;
+    private computeForeignKeyChange;
+    private getNodeType;
+    private getFieldNameFromPath;
+    private isRenameMove;
+    private getNodeAtPath;
+}
+
+declare class ValidatorRegistry {
+    private readonly validators;
+    private readonly rules;
+    register(type: string, factory: ValidatorFactoryFn): this;
+    addRule(rule: ValidatorRule): this;
+    get(type: string): Validator | undefined;
+    has(type: string): boolean;
+    getRules(): readonly ValidatorRule[];
+    getValidatorTypes(): string[];
+}
+
+declare class ValidatorResolver {
+    private readonly registry;
+    constructor(registry: ValidatorRegistry);
+    resolve(context: ValidationContext): Validator[];
+}
+
+declare class ValidationEngine {
+    private readonly resolver;
+    constructor(resolver: ValidatorResolver);
+    validate(context: ValidationContext): readonly Diagnostic[];
+}
+
+declare function createDefaultValidatorRegistry(): ValidatorRegistry;
+declare function createValidationEngine(registry?: ValidatorRegistry): ValidationEngine;
+
+declare class RequiredValidator implements Validator {
+    readonly type = "required";
+    validate(context: ValidationContext): Diagnostic | null;
+}
+
+declare class PatternValidator implements Validator {
+    readonly type = "pattern";
+    validate(context: ValidationContext): Diagnostic | null;
+}
+
+declare class MinLengthValidator implements Validator {
+    readonly type = "minLength";
+    validate(context: ValidationContext): Diagnostic | null;
+}
+
+declare class MaxLengthValidator implements Validator {
+    readonly type = "maxLength";
+    validate(context: ValidationContext): Diagnostic | null;
+}
+
+declare class MinimumValidator implements Validator {
+    readonly type = "minimum";
+    validate(context: ValidationContext): Diagnostic | null;
+}
+
+declare class MaximumValidator implements Validator {
+    readonly type = "maximum";
+    validate(context: ValidationContext): Diagnostic | null;
+}
+
+declare class EnumValidator implements Validator {
+    readonly type = "enum";
+    validate(context: ValidationContext): Diagnostic | null;
+}
+
+declare class ForeignKeyValidator implements Validator {
+    readonly type = "foreignKey";
+    validate(context: ValidationContext): Diagnostic | null;
+}
+
+declare class SchemaPropertyRule implements ValidatorRule {
+    readonly validatorType: string;
+    private readonly propertyName;
+    constructor(validatorType: string, propertyName: keyof SchemaLike);
+    shouldApply(context: ValidationContext): boolean;
+}
+declare class SchemaTruthyRule implements ValidatorRule {
+    readonly validatorType: string;
+    private readonly propertyName;
+    constructor(validatorType: string, propertyName: keyof SchemaLike);
+    shouldApply(context: ValidationContext): boolean;
+}
+declare class CompositeRule implements ValidatorRule {
+    readonly validatorType: string;
+    private readonly conditions;
+    constructor(validatorType: string, conditions: Array<(context: ValidationContext) => boolean>);
+    shouldApply(context: ValidationContext): boolean;
+}
+
+interface SerializeOptions {
+    excludeNodeIds?: Set<string>;
+}
+
+declare class SchemaSerializer {
+    private tree;
+    private excludeNodeIds;
+    serializeNode(node: SchemaNode, tree: SchemaTree, options?: SerializeOptions): JsonSchema;
+    serializeTree(tree: SchemaTree): JsonObjectSchema;
+    private serialize;
+    private serializeObject;
+    private serializeArray;
+    private serializeRef;
+    private serializePrimitive;
+    private serializeString;
+    private serializeNumber;
+    private serializeBoolean;
+    private serializeFormula;
+    private addMetadata;
+    private shouldExclude;
+}
+
+export { type AddedChange, ChangeCoalescer, ChangeCollector, type ChangeType, type CoalescedChanges, type ComparatorContext, CompositeRule, Diagnostic, EMPTY_PATH, EnumValidator, ForeignKeyValidator, Formula, ItemsSegment, JsonPatch, MaxLengthValidator, MaximumValidator, MinLengthValidator, MinimumValidator, type ModifiedChange, type MovedChange, NULL_NODE, NodeMetadata, NodePathIndex, PatchBuilder, PatchEnricher, PatchGenerator, Path, PathSegment, PatternValidator, PropertySegment, type RawChange, ReactivityAdapter, type RemovedChange, RequiredValidator, SchemaDiff, SchemaLike, SchemaNode, SchemaPatch, SchemaPropertyRule, SchemaSerializer, SchemaTree, SchemaTruthyRule, type SerializeOptions, ValidationContext, ValidationEngine, Validator, ValidatorFactoryFn, ValidatorRegistry, ValidatorResolver, ValidatorRule, areNodesContentEqual, areNodesEqual, coalesceChanges, collectChanges, createArrayNode, createBooleanNode, createDefaultValidatorRegistry, createNumberNode, createObjectNode, createPath, createRefNode, createSchemaTree, createStringNode, createValidationEngine, jsonPointerToPath, jsonPointerToSegments, jsonPointerToSimplePath, noopAdapter };

package/dist/core/index.js

@@ -0,0 +1,29 @@
+export { ChangeCoalescer, ChangeCollector, CompositeRule, EMPTY_METADATA, EMPTY_PATH, EnumValidator, FIELD_NAME_ERROR_MESSAGE, ForeignKeyValidator, ItemsSegment, MaxLengthValidator, MaximumValidator, MinLengthValidator, MinimumValidator, NULL_NODE, NodePathIndex, PatchBuilder, PatchEnricher, PatchGenerator, PatternValidator, PropertySegment, RequiredValidator, SchemaDiff, SchemaPropertyRule, SchemaSerializer, SchemaTruthyRule, ValidationEngine, ValidatorRegistry, ValidatorResolver, areNodesContentEqual, areNodesEqual, coalesceChanges, collectChanges, createArrayNode, createBooleanNode, createDefaultValidatorRegistry, createNumberNode, createObjectNode, createPath, createRefNode, createSchemaTree, createStringNode, createValidationEngine, isValidFieldName, jsonPointerToPath, jsonPointerToSegments, jsonPointerToSimplePath, validateFormulas, validateSchema } from '../chunk-S7GEDTSL.js';
+import '../chunk-3IKI64T2.js';
+export { computeValueDiff } from '../chunk-YFWOURZL.js';
+export { FieldChangeType } from '../chunk-ZBPUTF3Q.js';
+import '../chunk-CYTPQYVM.js';
+
+// src/core/reactivity/noop-adapter.ts
+var NoopReactivityAdapter = class {
+  makeObservable(_target, _annotations) {
+  }
+  observableArray() {
+    return [];
+  }
+  observableMap() {
+    return /* @__PURE__ */ new Map();
+  }
+  reaction(_expression, _effect) {
+    return () => {
+    };
+  }
+  runInAction(fn) {
+    return fn();
+  }
+};
+var noopAdapter = new NoopReactivityAdapter();
+
+export { noopAdapter };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/reactivity/noop-adapter.ts"],"names":[],"mappings":";;;;;;;AAGA,IAAM,wBAAN,MAAyD;AAAA,EACvD,cAAA,CACE,SACA,YAAA,EACM;AAAA,EAER;AAAA,EAEA,eAAA,GAA0B;AACxB,IAAA,OAAO,EAAC;AAAA,EACV;AAAA,EAEA,aAAA,GAAiC;AAC/B,IAAA,2BAAW,GAAA,EAAI;AAAA,EACjB;AAAA,EAEA,QAAA,CACE,aACA,OAAA,EACY;AACZ,IAAA,OAAO,MAAM;AAAA,IAAC,CAAA;AAAA,EAChB;AAAA,EAEA,YAAe,EAAA,EAAgB;AAC7B,IAAA,OAAO,EAAA,EAAG;AAAA,EACZ;AACF,CAAA;AAEO,IAAM,WAAA,GAAiC,IAAI,qBAAA","file":"index.js","sourcesContent":["import type { AnnotationsMap } from '../types/index.js';\nimport type { ReactivityAdapter } from './types.js';\n\nclass NoopReactivityAdapter implements ReactivityAdapter {\n  makeObservable<T extends object>(\n    _target: T,\n    _annotations: AnnotationsMap<T>,\n  ): void {\n    // noop\n  }\n\n  observableArray<T>(): T[] {\n    return [];\n  }\n\n  observableMap<K, V>(): Map<K, V> {\n    return new Map();\n  }\n\n  reaction<T>(\n    _expression: () => T,\n    _effect: (value: T) => void,\n  ): () => void {\n    return () => {};\n  }\n\n  runInAction<T>(fn: () => T): T {\n    return fn();\n  }\n}\n\nexport const noopAdapter: ReactivityAdapter = new NoopReactivityAdapter();\n"]}

package/dist/formula/index.d.cts

@@ -1,4 +1,4 @@
-import { i as JsonSchema } from '../schema.types-CLHMJmkJ.cjs';
+import { i as JsonSchema } from '../schema.types-ZX5fUW1X.cjs';
 export { formulaSpec } from '@revisium/formula/spec';
 
 interface XFormulaInput {

package/dist/formula/index.d.ts

@@ -1,4 +1,4 @@
-import { i as JsonSchema } from '../schema.types-CLHMJmkJ.js';
+import { i as JsonSchema } from '../schema.types-ZX5fUW1X.js';
 export { formulaSpec } from '@revisium/formula/spec';
 
 interface XFormulaInput {