@revisium/schema-toolkit 0.19.1 → 0.19.2

package/dist/{types-EHdxfQpd.d.cts → FormulaPathBuilder-8gmUFlgu.d.cts}

@@ -1,5 +1,6 @@
-import { ASTNode } from '@revisium/formula';
 import { h as JsonPatch } from './json-patch.types-Cu0Medki.cjs';
+import { ASTNode } from '@revisium/formula';
+import { X as XFormula } from './schema.types-B5OgKLpV.cjs';
 
 interface FormulaDependency {
     targetNodeId(): string;
@@ -172,4 +173,28 @@ interface ValidatorRule {
 }
 type ValidatorFactoryFn = () => Validator;
 
-export { type Diagnostic as D, EMPTY_METADATA as E, type FormulaDependency as F, type NodeType as N, type Path as P, ResolvedDependency as R, type SchemaLike as S, type TreeFormulaValidationError as T, type ValidationContext as V, type PathSegment as a, type DiagnosticSeverity as b, type Validator as c, type ValidatorRule as d, type ValidatorFactoryFn as e, type SchemaValidationError as f, type SchemaValidationErrorType as g, type NodeMetadata as h, type Formula as i, type SchemaNode as j, type SchemaTree as k, type SchemaPatch as l, type DefaultValueType as m, type PropertyChange as n, type PropertyName as o, type Formula$1 as p };
+interface SerializeOptions {
+    readonly strict?: boolean;
+}
+declare class FormulaSerializer {
+    private readonly tree;
+    private readonly formulaNodeId;
+    private readonly formula;
+    private readonly pathBuilder;
+    constructor(tree: SchemaTree, formulaNodeId: string, formula: Formula$1);
+    static toXFormula(tree: SchemaTree, formulaNodeId: string, formula: Formula$1): XFormula;
+    static serializeExpression(tree: SchemaTree, formulaNodeId: string, formula: Formula$1, options?: SerializeOptions): string;
+    serialize(options?: SerializeOptions): string;
+    private buildPathReplacements;
+    private needsReplacement;
+    private normalizeArrayNotation;
+}
+
+declare class FormulaPathBuilder {
+    buildWithArrayNotation(fromPath: Path, toPath: Path): string;
+    private findCommonPrefixLength;
+    private buildPartsWithArrayNotation;
+    private formatPartsWithArrayNotation;
+}
+
+export { type Diagnostic as D, EMPTY_METADATA as E, type FormulaDependency as F, type NodeType as N, type Path as P, ResolvedDependency as R, type SchemaLike as S, type TreeFormulaValidationError as T, type ValidationContext as V, FormulaSerializer as a, FormulaPathBuilder as b, type PathSegment as c, type DiagnosticSeverity as d, type Validator as e, type ValidatorRule as f, type ValidatorFactoryFn as g, type SchemaValidationError as h, type SchemaValidationErrorType as i, type NodeMetadata as j, type Formula as k, type SchemaNode as l, type SchemaTree as m, type SchemaPatch as n, type DefaultValueType as o, type PropertyChange as p, type PropertyName as q, type Formula$1 as r };

package/dist/{types-Dw9ba_YE.d.ts → FormulaPathBuilder-B6RyUFN7.d.ts}

@@ -1,5 +1,6 @@
-import { ASTNode } from '@revisium/formula';
 import { h as JsonPatch } from './json-patch.types-DY7k9hxy.js';
+import { ASTNode } from '@revisium/formula';
+import { X as XFormula } from './schema.types-B5OgKLpV.js';
 
 interface FormulaDependency {
     targetNodeId(): string;
@@ -172,4 +173,28 @@ interface ValidatorRule {
 }
 type ValidatorFactoryFn = () => Validator;
 
-export { type Diagnostic as D, EMPTY_METADATA as E, type FormulaDependency as F, type NodeType as N, type Path as P, ResolvedDependency as R, type SchemaLike as S, type TreeFormulaValidationError as T, type ValidationContext as V, type PathSegment as a, type DiagnosticSeverity as b, type Validator as c, type ValidatorRule as d, type ValidatorFactoryFn as e, type SchemaValidationError as f, type SchemaValidationErrorType as g, type NodeMetadata as h, type Formula as i, type SchemaNode as j, type SchemaTree as k, type SchemaPatch as l, type DefaultValueType as m, type PropertyChange as n, type PropertyName as o, type Formula$1 as p };
+interface SerializeOptions {
+    readonly strict?: boolean;
+}
+declare class FormulaSerializer {
+    private readonly tree;
+    private readonly formulaNodeId;
+    private readonly formula;
+    private readonly pathBuilder;
+    constructor(tree: SchemaTree, formulaNodeId: string, formula: Formula$1);
+    static toXFormula(tree: SchemaTree, formulaNodeId: string, formula: Formula$1): XFormula;
+    static serializeExpression(tree: SchemaTree, formulaNodeId: string, formula: Formula$1, options?: SerializeOptions): string;
+    serialize(options?: SerializeOptions): string;
+    private buildPathReplacements;
+    private needsReplacement;
+    private normalizeArrayNotation;
+}
+
+declare class FormulaPathBuilder {
+    buildWithArrayNotation(fromPath: Path, toPath: Path): string;
+    private findCommonPrefixLength;
+    private buildPartsWithArrayNotation;
+    private formatPartsWithArrayNotation;
+}
+
+export { type Diagnostic as D, EMPTY_METADATA as E, type FormulaDependency as F, type NodeType as N, type Path as P, ResolvedDependency as R, type SchemaLike as S, type TreeFormulaValidationError as T, type ValidationContext as V, FormulaSerializer as a, FormulaPathBuilder as b, type PathSegment as c, type DiagnosticSeverity as d, type Validator as e, type ValidatorRule as f, type ValidatorFactoryFn as g, type SchemaValidationError as h, type SchemaValidationErrorType as i, type NodeMetadata as j, type Formula as k, type SchemaNode as l, type SchemaTree as m, type SchemaPatch as n, type DefaultValueType as o, type PropertyChange as p, type PropertyName as q, type Formula$1 as r };

package/dist/chunk-3FJZMVWA.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=chunk-3FJZMVWA.js.map
+//# sourceMappingURL=chunk-3FJZMVWA.js.map

package/dist/{chunk-Y2GYABV7.js.map → chunk-3FJZMVWA.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk-Y2GYABV7.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk-3FJZMVWA.js"}

package/dist/{chunk-45UZ3CJN.js → chunk-3V7AYFDS.js}

@@ -1,7 +1,306 @@
-import { AbstractBasePath, ParsedFormula, createRefNode, createObjectNode, createArrayNode, createStringNode, createNumberNode, createBooleanNode, makeAutoObservable, observable, makeObservable, runInAction, PatchBuilder, SchemaSerializer, FormulaDependencyIndex, createSchemaTree, NULL_NODE, FormulaSerializer, validateSchema, validateFormulas } from './chunk-R6VYCHY2.js';
+import { AbstractBasePath, EMPTY_PATH, FormulaError, ResolvedDependency, FormulaSerializer, createRefNode, createObjectNode, createArrayNode, createStringNode, createNumberNode, createBooleanNode, makeAutoObservable, observable, makeObservable, runInAction, PatchBuilder, SchemaSerializer, createSchemaTree, NULL_NODE, validateSchema, validateFormulas } from './chunk-XL4R6PSM.js';
 import { obj, ref } from './chunk-R4CFU33U.js';
 import { nanoid } from 'nanoid';
+import { parseFormula } from '@revisium/formula';
 
+var ARRAY_NOTATION_REGEX = /^([^[]+)\[(?:\d+|\*)?\]$/;
+var FormulaPath = class {
+  constructor(basePath, relativePath) {
+    this.basePath = basePath;
+    this.relativePath = relativePath;
+  }
+  resolve() {
+    let ast;
+    try {
+      const parseResult = parseFormula(this.relativePath);
+      ast = parseResult.ast;
+    } catch {
+      return null;
+    }
+    return this.astToPath(ast, this.basePath);
+  }
+  astToPath(ast, base) {
+    switch (ast.type) {
+      case "Identifier":
+        return base.child(ast.name);
+      case "MemberExpression": {
+        const objectPath = this.astToPath(ast.object, base);
+        if (!objectPath) {
+          return null;
+        }
+        return objectPath.child(ast.property);
+      }
+      case "IndexExpression":
+      case "WildcardExpression": {
+        const objectPath = this.astToPath(ast.object, base);
+        if (!objectPath) {
+          return null;
+        }
+        return objectPath.childItems();
+      }
+      case "RelativePath":
+        return this.resolveRelativePathString(base, ast.path);
+      case "RootPath":
+        return this.resolveRootPath(ast.path);
+      default:
+        return null;
+    }
+  }
+  resolveRelativePathString(base, path) {
+    const parts = path.split("/");
+    let result = base;
+    for (const part of parts) {
+      if (part === "..") {
+        if (result.isEmpty()) {
+          return null;
+        }
+        result = result.parent();
+      } else if (part === ".") {
+        continue;
+      } else if (part) {
+        result = result.child(part);
+      }
+    }
+    return result;
+  }
+  resolveRootPath(rootPath) {
+    const path = rootPath.startsWith("/") ? rootPath.slice(1) : rootPath;
+    if (!path) {
+      return EMPTY_PATH;
+    }
+    try {
+      return this.parseFormulaPath(path);
+    } catch {
+      return null;
+    }
+  }
+  parseFormulaPath(formulaPath) {
+    const parts = formulaPath.split(".");
+    let result = EMPTY_PATH;
+    for (const part of parts) {
+      if (!part) {
+        throw new Error(`Invalid path: empty segment`);
+      }
+      const match = ARRAY_NOTATION_REGEX.exec(part);
+      if (match?.[1]) {
+        result = result.child(match[1]).childItems();
+      } else {
+        result = result.child(part);
+      }
+    }
+    return result;
+  }
+};
+
+// src/model/schema-formula/parsing/ParsedFormula.ts
+var ParsedFormula = class {
+  _expression;
+  astNode;
+  deps;
+  astPathToNodeId;
+  constructor(tree, formulaNodeId, expression) {
+    this._expression = expression;
+    const parseResult = parseFormula(expression);
+    this.astNode = parseResult.ast;
+    const formulaPath = tree.pathOf(formulaNodeId);
+    if (formulaPath.isEmpty() && tree.root().id() !== formulaNodeId) {
+      throw new FormulaError("Formula node not found in tree", formulaNodeId);
+    }
+    const deps = [];
+    const astPathToNodeId = /* @__PURE__ */ new Map();
+    for (const depPath of parseResult.dependencies) {
+      const targetNodeId = this.resolveDependencyPath(
+        tree,
+        formulaPath,
+        depPath
+      );
+      if (!targetNodeId) {
+        throw new FormulaError(
+          `Cannot resolve formula dependency: ${depPath}`,
+          formulaNodeId,
+          "Path not found in schema"
+        );
+      }
+      if (targetNodeId === formulaNodeId) {
+        throw new FormulaError(
+          "Formula cannot reference itself",
+          formulaNodeId,
+          "Self-reference detected"
+        );
+      }
+      deps.push(new ResolvedDependency(targetNodeId));
+      astPathToNodeId.set(depPath, targetNodeId);
+    }
+    this.deps = deps;
+    this.astPathToNodeId = astPathToNodeId;
+  }
+  version() {
+    return 1;
+  }
+  expression() {
+    return this._expression;
+  }
+  ast() {
+    return this.astNode;
+  }
+  dependencies() {
+    return this.deps;
+  }
+  getNodeIdForAstPath(astPath) {
+    return this.astPathToNodeId.get(astPath) ?? null;
+  }
+  astPaths() {
+    return Array.from(this.astPathToNodeId.keys());
+  }
+  resolveDependencyPath(tree, formulaNodePath, depPath) {
+    const basePath = this.getFormulaBasePath(formulaNodePath);
+    const depFormulaPath = new FormulaPath(basePath, depPath);
+    const targetPath = depFormulaPath.resolve();
+    if (!targetPath) {
+      return null;
+    }
+    const targetNode = tree.nodeAt(targetPath);
+    if (targetNode.isNull()) {
+      return null;
+    }
+    return targetNode.id();
+  }
+  getFormulaBasePath(formulaPath) {
+    let basePath = formulaPath;
+    while (!basePath.isEmpty()) {
+      const segs = basePath.segments();
+      const lastSeg = segs[segs.length - 1];
+      basePath = basePath.parent();
+      if (!lastSeg?.isItems()) {
+        break;
+      }
+    }
+    return basePath;
+  }
+};
+
+// src/model/schema-formula/store/FormulaDependencyIndex.ts
+var FormulaDependencyIndex = class {
+  dependentsMap = /* @__PURE__ */ new Map();
+  formulasByNodeId = /* @__PURE__ */ new Map();
+  registerFormula(formulaNodeId, formula) {
+    this.unregisterFormula(formulaNodeId);
+    this.formulasByNodeId.set(formulaNodeId, formula);
+    for (const dep of formula.dependencies()) {
+      const targetId = dep.targetNodeId();
+      let dependents = this.dependentsMap.get(targetId);
+      if (!dependents) {
+        dependents = /* @__PURE__ */ new Set();
+        this.dependentsMap.set(targetId, dependents);
+      }
+      dependents.add(formulaNodeId);
+    }
+  }
+  unregisterFormula(formulaNodeId) {
+    this.formulasByNodeId.delete(formulaNodeId);
+    for (const [targetId, dependents] of this.dependentsMap) {
+      dependents.delete(formulaNodeId);
+      if (dependents.size === 0) {
+        this.dependentsMap.delete(targetId);
+      }
+    }
+  }
+  getDependents(nodeId) {
+    const dependents = this.dependentsMap.get(nodeId);
+    return dependents ? Array.from(dependents) : [];
+  }
+  hasDependents(nodeId) {
+    const dependents = this.dependentsMap.get(nodeId);
+    return dependents !== void 0 && dependents.size > 0;
+  }
+  getFormula(nodeId) {
+    return this.formulasByNodeId.get(nodeId) ?? null;
+  }
+  hasFormula(nodeId) {
+    return this.formulasByNodeId.has(nodeId);
+  }
+  clear() {
+    this.dependentsMap.clear();
+    this.formulasByNodeId.clear();
+  }
+  forEachFormula(callback) {
+    for (const [nodeId, formula] of this.formulasByNodeId) {
+      callback(nodeId, formula);
+    }
+  }
+  size() {
+    return this.formulasByNodeId.size;
+  }
+};
+
+// src/model/schema-formula/changes/FormulaChangeDetector.ts
+var FormulaChangeDetector = class {
+  constructor(index, currentTree, baseTree) {
+    this.index = index;
+    this.currentTree = currentTree;
+    this.baseTree = baseTree;
+  }
+  detectIndirectChanges(changedNodeIds) {
+    const result = [];
+    const visited = /* @__PURE__ */ new Set();
+    for (const changedId of changedNodeIds) {
+      this.collectDependentChanges(changedId, result, visited, changedNodeIds);
+    }
+    return result;
+  }
+  collectDependentChanges(nodeId, result, visited, directlyChanged) {
+    const dependents = this.index.getDependents(nodeId);
+    for (const dependentId of dependents) {
+      if (visited.has(dependentId)) {
+        continue;
+      }
+      visited.add(dependentId);
+      if (directlyChanged.has(dependentId)) {
+        continue;
+      }
+      const change = this.detectFormulaChange(dependentId);
+      if (change) {
+        result.push(change);
+      }
+      this.collectDependentChanges(dependentId, result, visited, directlyChanged);
+    }
+  }
+  detectFormulaChange(nodeId) {
+    const currentNode = this.currentTree.nodeById(nodeId);
+    const baseNode = this.baseTree.nodeById(nodeId);
+    if (currentNode.isNull() || baseNode.isNull()) {
+      return null;
+    }
+    const currentFormula = currentNode.formula();
+    const baseFormula = baseNode.formula();
+    if (!currentFormula || !baseFormula) {
+      return null;
+    }
+    const fromExpression = this.getSerializedExpression(baseFormula, this.baseTree, nodeId);
+    const toExpression = this.getSerializedExpression(currentFormula, this.currentTree, nodeId);
+    if (fromExpression === null || toExpression === null) {
+      return null;
+    }
+    if (fromExpression === toExpression) {
+      return null;
+    }
+    return {
+      nodeId,
+      fromExpression,
+      toExpression
+    };
+  }
+  getSerializedExpression(formula, tree, nodeId) {
+    try {
+      const xFormula = FormulaSerializer.toXFormula(tree, nodeId, formula);
+      return xFormula.expression;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/model/schema-model/SchemaParser.ts
 var SchemaParser = class {
   pendingFormulas = [];
   _parseErrors = [];
@@ -713,12 +1012,16 @@ var SchemaModelImpl = class {
     if (!formula) {
       return "";
     }
-    return FormulaSerializer.serializeExpression(
-      this._currentTree,
-      nodeId,
-      formula,
-      { strict: false }
-    );
+    try {
+      return FormulaSerializer.serializeExpression(
+        this._currentTree,
+        nodeId,
+        formula,
+        { strict: false }
+      );
+    } catch {
+      return "";
+    }
   }
   get validationErrors() {
     return validateSchema(this._currentTree.root());
@@ -2469,6 +2772,6 @@ function createDataModel(options) {
   return new DataModelImpl(options);
 }
 
-export { ArrayToItemsTypeTransformer, ArrayValueNode, BasePrimitiveValueNode, BaseValueNode, BooleanValueNode, DataModelImpl, DefaultTransformer, ForeignKeyNotFoundError, ForeignKeyResolverImpl, ForeignKeyResolverNotConfiguredError, ForeignKeyValueNodeImpl, NodeFactory, NodeFactory2, NodeFactoryRegistry, NumberValueNode, ObjectToArrayTransformer, ObjectValueNode, PrimitiveToArrayTransformer, RefTransformer, RowModelImpl, SchemaParser, StringValueNode, TableModelImpl, TypeTransformChain, ValueType, createDataModel, createDefaultRegistry, createForeignKeyResolver, createNodeFactory, createSchemaModel, createTableModel, createTypeTransformChain, extractFormulaDefinition, generateDefaultValue, generateNodeId, isForeignKeyValueNode, resetNodeIdCounter };
-//# sourceMappingURL=chunk-45UZ3CJN.js.map
-//# sourceMappingURL=chunk-45UZ3CJN.js.map
+export { ArrayToItemsTypeTransformer, ArrayValueNode, BasePrimitiveValueNode, BaseValueNode, BooleanValueNode, DataModelImpl, DefaultTransformer, ForeignKeyNotFoundError, ForeignKeyResolverImpl, ForeignKeyResolverNotConfiguredError, ForeignKeyValueNodeImpl, FormulaChangeDetector, FormulaDependencyIndex, FormulaPath, NodeFactory, NodeFactory2, NodeFactoryRegistry, NumberValueNode, ObjectToArrayTransformer, ObjectValueNode, ParsedFormula, PrimitiveToArrayTransformer, RefTransformer, RowModelImpl, SchemaParser, StringValueNode, TableModelImpl, TypeTransformChain, ValueType, createDataModel, createDefaultRegistry, createForeignKeyResolver, createNodeFactory, createSchemaModel, createTableModel, createTypeTransformChain, extractFormulaDefinition, generateDefaultValue, generateNodeId, isForeignKeyValueNode, resetNodeIdCounter };
+//# sourceMappingURL=chunk-3V7AYFDS.js.map
+//# sourceMappingURL=chunk-3V7AYFDS.js.map