@revisium/schema-toolkit 0.19.1 → 0.19.3

package/dist/{chunk-U7N3EEQX.cjs → chunk-X2KLCGJ6.cjs}

@@ -1010,7 +1010,7 @@ var NodePathIndex = class {
   }
 };
 
-// src/model/schema-formula/serialization/FormulaPathBuilder.ts
+// src/core/schema-formula/serialization/FormulaPathBuilder.ts
 var FormulaPathBuilder = class {
   buildWithArrayNotation(fromPath, toPath) {
     const fromSegments = fromPath.parent().segments();
@@ -1078,7 +1078,7 @@ var FormulaPathBuilder = class {
   }
 };
 
-// src/model/schema-formula/core/FormulaError.ts
+// src/core/schema-formula/core/FormulaError.ts
 var FormulaError = class extends Error {
   constructor(message, nodeId, details) {
     super(message);
@@ -1088,7 +1088,7 @@ var FormulaError = class extends Error {
   }
 };
 
-// src/model/schema-formula/serialization/FormulaSerializer.ts
+// src/core/schema-formula/serialization/FormulaSerializer.ts
 var FormulaSerializer = class _FormulaSerializer {
   constructor(tree, formulaNodeId, formula) {
     this.tree = tree;
@@ -1244,10 +1244,17 @@ function areFormulasEqual(currentFormula, baseFormula, currentNodeId, baseNodeId
     context.baseTree,
     baseNodeId
   );
+  if (currentExpr === null || baseExpr === null) {
+    return false;
+  }
   return currentExpr === baseExpr;
 }
 function getSerializedExpression(formula, tree, nodeId) {
-  return FormulaSerializer.serializeExpression(tree, nodeId, formula, { strict: false });
+  try {
+    return FormulaSerializer.serializeExpression(tree, nodeId, formula, { strict: false });
+  } catch {
+    return null;
+  }
 }
 function areObjectsEqual(current, base, context) {
   const propsCurrent = current.properties();
@@ -1501,7 +1508,7 @@ var SchemaDiff = class {
   }
 };
 
-// src/model/schema-formula/core/FormulaDependency.ts
+// src/core/schema-formula/core/FormulaDependency.ts
 var ResolvedDependency = class {
   constructor(nodeId) {
     this.nodeId = nodeId;
@@ -1513,300 +1520,6 @@ var ResolvedDependency = class {
     return this.nodeId;
   }
 };
-var ARRAY_NOTATION_REGEX = /^([^[]+)\[(?:\d+|\*)?\]$/;
-var FormulaPath = class {
-  constructor(basePath, relativePath) {
-    this.basePath = basePath;
-    this.relativePath = relativePath;
-  }
-  resolve() {
-    let ast;
-    try {
-      const parseResult = formula.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;
-  }
-};
-var ParsedFormula = class {
-  _expression;
-  astNode;
-  deps;
-  astPathToNodeId;
-  constructor(tree, formulaNodeId, expression) {
-    this._expression = expression;
-    const parseResult = formula.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/core/schema-serializer/SchemaSerializer.ts
 var SchemaSerializer = class {
@@ -1939,7 +1652,11 @@ var SchemaSerializer = class {
         "Cannot serialize formula without tree context. Use serializeNode with tree."
       );
     }
-    return FormulaSerializer.toXFormula(this.tree, node.id(), formula);
+    try {
+      return FormulaSerializer.toXFormula(this.tree, node.id(), formula);
+    } catch {
+      return { version: 1, expression: "" };
+    }
   }
   addMetadata(schema, node) {
     const meta = node.metadata();
@@ -2387,7 +2104,11 @@ var PatchEnricher = class {
           if (!formula || !node) {
             return void 0;
           }
-          return FormulaSerializer.serializeExpression(tree, node.id(), formula, { strict: false });
+          try {
+            return FormulaSerializer.serializeExpression(tree, node.id(), formula, { strict: false });
+          } catch {
+            return void 0;
+          }
         },
         compare: (from, to) => from === to
       },
@@ -2887,17 +2608,12 @@ function collectValidationErrors(node, errors) {
 function createError(nodeId, type, message) {
   return { nodeId, type, message };
 }
-
-// src/core/validation/formula/FormulaValidator.ts
 function validateFormulas(tree) {
   const errors = [];
   collectFormulaErrors(tree.root(), tree, errors, "");
   return errors;
 }
 function collectFormulaErrors(node, tree, errors, fieldPath) {
-  if (node.isNull()) {
-    return;
-  }
   validateNodeFormula(node, tree, errors, fieldPath);
   collectChildErrors(node, tree, errors, fieldPath);
 }
@@ -2905,11 +2621,11 @@ function validateNodeFormula(node, tree, errors, fieldPath) {
   if (!node.isPrimitive() || !node.hasFormula()) {
     return;
   }
-  const formula = node.formula();
-  if (!formula) {
+  const formula$1 = node.formula();
+  if (!formula$1) {
     return;
   }
-  for (const dep of formula.dependencies()) {
+  for (const dep of formula$1.dependencies()) {
     const targetNode = tree.nodeById(dep.targetNodeId());
     if (targetNode.isNull()) {
       errors.push({
@@ -2917,7 +2633,30 @@ function validateNodeFormula(node, tree, errors, fieldPath) {
         message: "Cannot resolve formula dependency: target node not found",
         fieldPath: fieldPath || node.name()
       });
+      return;
+    }
+  }
+  try {
+    const expression = FormulaSerializer.serializeExpression(
+      tree,
+      node.id(),
+      formula$1,
+      { strict: false }
+    );
+    const result = formula.validateFormulaSyntax(expression);
+    if (!result.isValid) {
+      errors.push({
+        nodeId: node.id(),
+        message: `Invalid formula: ${result.error}`,
+        fieldPath: fieldPath || node.name()
+      });
     }
+  } catch {
+    errors.push({
+      nodeId: node.id(),
+      message: "Invalid formula expression",
+      fieldPath: fieldPath || node.name()
+    });
   }
 }
 function collectChildErrors(node, tree, errors, fieldPath) {
@@ -2947,9 +2686,7 @@ exports.EMPTY_PATH = EMPTY_PATH;
 exports.EnumValidator = EnumValidator;
 exports.FIELD_NAME_ERROR_MESSAGE = FIELD_NAME_ERROR_MESSAGE;
 exports.ForeignKeyValidator = ForeignKeyValidator;
-exports.FormulaChangeDetector = FormulaChangeDetector;
-exports.FormulaDependencyIndex = FormulaDependencyIndex;
-exports.FormulaPath = FormulaPath;
+exports.FormulaError = FormulaError;
 exports.FormulaPathBuilder = FormulaPathBuilder;
 exports.FormulaSerializer = FormulaSerializer;
 exports.ItemsSegment = ItemsSegment;
@@ -2959,7 +2696,6 @@ exports.MinLengthValidator = MinLengthValidator;
 exports.MinimumValidator = MinimumValidator;
 exports.NULL_NODE = NULL_NODE;
 exports.NodePathIndex = NodePathIndex;
-exports.ParsedFormula = ParsedFormula;
 exports.PatchBuilder = PatchBuilder;
 exports.PatchEnricher = PatchEnricher;
 exports.PatchGenerator = PatchGenerator;
@@ -3002,5 +2738,5 @@ exports.runInAction = runInAction;
 exports.setReactivityProvider = setReactivityProvider;
 exports.validateFormulas = validateFormulas;
 exports.validateSchema = validateSchema;
-//# sourceMappingURL=chunk-U7N3EEQX.cjs.map
-//# sourceMappingURL=chunk-U7N3EEQX.cjs.map
+//# sourceMappingURL=chunk-X2KLCGJ6.cjs.map
+//# sourceMappingURL=chunk-X2KLCGJ6.cjs.map