@revisium/schema-toolkit 0.19.4 → 0.20.1

package/dist/{chunk-O4QRUV7I.cjs → chunk-FZ2MS4Q5.cjs}

@@ -1079,87 +1079,525 @@ var SchemaModelImpl = class {
 function createSchemaModel(schema, options) {
   return new SchemaModelImpl(schema, options);
 }
-
-// src/model/table/row/RowModelImpl.ts
-var UNSET_INDEX = -1;
-var RowModelImpl = class {
-  constructor(_rowId, _tree) {
-    this._rowId = _rowId;
-    this._tree = _tree;
-    chunk46ME2TAU_cjs.makeAutoObservable(this, {
-      _rowId: false,
-      _tree: false,
-      _tableModel: "observable.ref"
+var INDEX_REGEX = /^\[(-?\d+)\]/;
+var PROP_REGEX = /^\.?([a-zA-Z_]\w*)/;
+var FormulaCollector = class {
+  root = null;
+  collect(root) {
+    this.root = root;
+    const formulas = [];
+    this.traverse(root, { parent: null, arrayLevels: [] }, formulas);
+    return formulas;
+  }
+  traverse(node, context, formulas) {
+    if (node.isPrimitive()) {
+      this.collectPrimitive(node, context, formulas);
+    } else if (node.isObject()) {
+      for (const child of node.children) {
+        this.traverse(child, { ...context, parent: node }, formulas);
+      }
+    } else if (node.isArray()) {
+      for (let i = 0; i < node.length; i++) {
+        const item = node.at(i);
+        if (item) {
+          this.traverse(
+            item,
+            {
+              ...context,
+              arrayLevels: [...context.arrayLevels, { array: node, index: i }]
+            },
+            formulas
+          );
+        }
+      }
+    }
+  }
+  collectPrimitive(node, context, formulas) {
+    const formula = node.formula;
+    if (!formula) {
+      return;
+    }
+    const rawDependencies = this.extractDependencies(formula.expression);
+    const dependencyNodes = this.resolveDependencies(
+      rawDependencies,
+      node,
+      context
+    );
+    formulas.push({
+      node,
+      expression: formula.expression,
+      parent: context.parent,
+      dependencyNodes,
+      arrayLevels: context.arrayLevels
     });
   }
-  _tableModel = null;
-  get rowId() {
-    return this._rowId;
+  extractDependencies(expression) {
+    try {
+      const parsed = formula.parseExpression(expression);
+      return parsed.dependencies;
+    } catch {
+      return [];
+    }
   }
-  get tableModel() {
-    return this._tableModel;
+  resolveDependencies(rawDeps, formulaNode, context) {
+    const nodes = [];
+    for (const dep of rawDeps) {
+      const node = this.resolveOneDependency(dep, formulaNode, context);
+      if (node) {
+        this.collectPrimitiveNodes(node, nodes);
+      }
+    }
+    return nodes;
   }
-  get tree() {
-    return this._tree;
+  collectPrimitiveNodes(node, result) {
+    if (node.isPrimitive()) {
+      result.push(node);
+    } else if (node.isArray()) {
+      for (let i = 0; i < node.length; i++) {
+        const item = node.at(i);
+        if (item) {
+          this.collectPrimitiveNodes(item, result);
+        }
+      }
+    } else if (node.isObject()) {
+      for (const child of node.children) {
+        this.collectPrimitiveNodes(child, result);
+      }
+    }
   }
-  get index() {
-    if (!this._tableModel) {
-      return UNSET_INDEX;
+  resolveOneDependency(dep, _formulaNode, context) {
+    if (dep.startsWith("/")) {
+      return this.resolveFromRoot(dep.slice(1));
     }
-    return this._tableModel.getRowIndex(this._rowId);
+    if (dep.startsWith("../")) {
+      return this.resolveRelative(dep, context);
+    }
+    if (context.parent) {
+      return this.resolveFromNode(context.parent, dep);
+    }
+    return this.resolveFromRoot(dep);
   }
-  get prev() {
-    if (!this._tableModel) {
+  resolveFromRoot(pathStr) {
+    if (!this.root) {
       return null;
     }
-    const currentIndex = this.index;
-    if (currentIndex <= 0) {
+    return this.resolveFromNode(this.root, pathStr);
+  }
+  resolveFromNode(startNode, pathStr) {
+    const segments = this.parsePathSegments(pathStr);
+    let current = startNode;
+    for (const segment of segments) {
+      if (!current) {
+        return null;
+      }
+      if (segment.type === "property") {
+        if (current.isObject()) {
+          current = current.children.find((c) => c.name === segment.name) ?? null;
+        } else {
+          return null;
+        }
+      } else if (segment.type === "index") {
+        if (current.isArray()) {
+          current = current.at(segment.index) ?? null;
+        } else {
+          return null;
+        }
+      }
+    }
+    return current;
+  }
+  resolveRelative(dep, context) {
+    let upLevels = 0;
+    let remaining = dep;
+    while (remaining.startsWith("../")) {
+      upLevels++;
+      remaining = remaining.slice(3);
+    }
+    let current = context.parent;
+    for (let i = 0; i < upLevels && current; i++) {
+      current = this.findParent(current);
+      if (current?.isArray()) {
+        current = this.findParent(current);
+      }
+    }
+    if (!current) {
       return null;
     }
-    return this._tableModel.getRowAt(currentIndex - 1) ?? null;
+    if (remaining) {
+      return this.resolveFromNode(current, remaining);
+    }
+    return current;
   }
-  get next() {
-    if (!this._tableModel) {
+  findParent(node) {
+    if (!this.root || node === this.root) {
       return null;
     }
-    const currentIndex = this.index;
-    if (currentIndex === UNSET_INDEX || currentIndex >= this._tableModel.rowCount - 1) {
+    return this.findParentRecursive(this.root, node);
+  }
+  findParentRecursive(current, target) {
+    const children = this.getChildNodes(current);
+    for (const child of children) {
+      if (child === target) {
+        return current;
+      }
+      const found = this.findParentRecursive(child, target);
+      if (found) {
+        return found;
+      }
+    }
+    return null;
+  }
+  getChildNodes(node) {
+    if (node.isObject()) {
+      return [...node.children];
+    }
+    if (node.isArray()) {
+      const items = [];
+      for (let i = 0; i < node.length; i++) {
+        const item = node.at(i);
+        if (item) {
+          items.push(item);
+        }
+      }
+      return items;
+    }
+    return [];
+  }
+  parsePathSegments(pathStr) {
+    const segments = [];
+    let current = pathStr;
+    while (current.length > 0) {
+      const indexMatch = INDEX_REGEX.exec(current);
+      if (indexMatch?.[1]) {
+        segments.push({
+          type: "index",
+          index: Number.parseInt(indexMatch[1], 10)
+        });
+        current = current.slice(indexMatch[0].length);
+        continue;
+      }
+      const propMatch = PROP_REGEX.exec(current);
+      if (propMatch?.[1]) {
+        segments.push({ type: "property", name: propMatch[1] });
+        current = current.slice(propMatch[0].length);
+        continue;
+      }
+      break;
+    }
+    return segments;
+  }
+};
+
+// src/model/value-formula/DependencyGraph.ts
+var DependencyGraph = class {
+  buildDependencyMap(formulas) {
+    const map = /* @__PURE__ */ new Map();
+    for (const field of formulas) {
+      for (const depNode of field.dependencyNodes) {
+        let depSet = map.get(depNode);
+        if (!depSet) {
+          depSet = /* @__PURE__ */ new Set();
+          map.set(depNode, depSet);
+        }
+        depSet.add(field);
+      }
+    }
+    return map;
+  }
+  buildEvaluationOrder(formulas) {
+    const formulaNodes = new Set(formulas.map((f) => f.node));
+    const visited = /* @__PURE__ */ new Set();
+    const order = [];
+    const formulaByNode = /* @__PURE__ */ new Map();
+    for (const field of formulas) {
+      formulaByNode.set(field.node, field);
+    }
+    const visit = (field, stack) => {
+      if (visited.has(field.node)) {
+        return;
+      }
+      if (stack.has(field.node)) {
+        return;
+      }
+      stack.add(field.node);
+      for (const depNode of field.dependencyNodes) {
+        if (formulaNodes.has(depNode)) {
+          const depFormula = formulaByNode.get(depNode);
+          if (depFormula) {
+            visit(depFormula, stack);
+          }
+        }
+      }
+      stack.delete(field.node);
+      visited.add(field.node);
+      order.push(field);
+    };
+    for (const field of formulas) {
+      visit(field, /* @__PURE__ */ new Set());
+    }
+    return order;
+  }
+  getAffectedFormulas(changedNode, dependencyMap, evaluationOrder) {
+    const affected = /* @__PURE__ */ new Set();
+    const queue = [changedNode];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (!current) {
+        continue;
+      }
+      const dependents = dependencyMap.get(current);
+      if (dependents) {
+        for (const field of dependents) {
+          if (!affected.has(field)) {
+            affected.add(field);
+            queue.push(field.node);
+          }
+        }
+      }
+    }
+    return evaluationOrder.filter((field) => affected.has(field));
+  }
+};
+var FormulaEvaluator = class {
+  constructor(tree, options = {}) {
+    this.tree = tree;
+    this.options = options;
+  }
+  evaluate(field) {
+    try {
+      const context = this.buildContext(field);
+      const result = formula.evaluateWithContext(field.expression, context);
+      this.setNodeValue(field, result);
+      this.checkForWarnings(field, result);
+    } catch (error) {
+      this.handleError(field, error);
+    }
+  }
+  evaluateAll(fields) {
+    for (const field of fields) {
+      this.evaluate(field);
+    }
+  }
+  buildContext(field) {
+    const rootData = this.tree.getPlainValue();
+    const context = { rootData };
+    if (field.parent) {
+      const itemData = this.getPlainObjectValue(field.parent);
+      if (itemData) {
+        context.itemData = itemData;
+      }
+    }
+    if (field.arrayLevels.length > 0) {
+      context.arrayContext = { levels: this.buildArrayLevels(field) };
+    }
+    return context;
+  }
+  buildArrayLevels(field) {
+    const levels = [];
+    for (let i = field.arrayLevels.length - 1; i >= 0; i--) {
+      const level = field.arrayLevels[i];
+      if (!level) {
+        continue;
+      }
+      const { array, index } = level;
+      levels.push({
+        index,
+        length: array.length,
+        prev: this.getPrevItemValue(array, index),
+        next: this.getNextItemValue(array, index)
+      });
+    }
+    return levels;
+  }
+  getPrevItemValue(array, index) {
+    if (index <= 0) {
       return null;
     }
-    return this._tableModel.getRowAt(currentIndex + 1) ?? null;
+    const prevItem = array.at(index - 1);
+    return prevItem ? this.getPlainNodeValue(prevItem) : null;
   }
-  get(path) {
-    return this._tree.get(path);
+  getNextItemValue(array, index) {
+    if (index >= array.length - 1) {
+      return null;
+    }
+    const nextItem = array.at(index + 1);
+    return nextItem ? this.getPlainNodeValue(nextItem) : null;
   }
-  getValue(path) {
-    return this._tree.getValue(path);
+  getPlainObjectValue(node) {
+    const result = {};
+    for (const child of node.children) {
+      result[child.name] = this.getPlainNodeValue(child);
+    }
+    return result;
   }
-  setValue(path, value) {
-    this._tree.setValue(path, value);
+  getPlainNodeValue(node) {
+    if (node.isPrimitive()) {
+      return node.value;
+    }
+    if (node.isObject()) {
+      return this.getPlainObjectValue(node);
+    }
+    if (node.isArray()) {
+      const result = [];
+      for (let i = 0; i < node.length; i++) {
+        const item = node.at(i);
+        if (item) {
+          result.push(this.getPlainNodeValue(item));
+        }
+      }
+      return result;
+    }
+    return null;
   }
-  getPlainValue() {
-    return this._tree.getPlainValue();
+  setNodeValue(field, result) {
+    const { node } = field;
+    const defaultValue = node.defaultValue;
+    if (result === null || result === void 0) {
+      node.setValue(defaultValue, { internal: true });
+      return;
+    }
+    if (typeof result === "number" && (Number.isNaN(result) || !Number.isFinite(result))) {
+      node.setValue(defaultValue, { internal: true });
+      return;
+    }
+    node.setValue(result, { internal: true });
+  }
+  checkForWarnings(field, result) {
+    const { node } = field;
+    if (typeof result === "number") {
+      if (Number.isNaN(result)) {
+        node.setFormulaWarning({
+          type: "nan",
+          message: "Formula result is NaN",
+          expression: field.expression,
+          computedValue: result
+        });
+        return;
+      }
+      if (!Number.isFinite(result)) {
+        node.setFormulaWarning({
+          type: "infinity",
+          message: "Formula result is Infinity",
+          expression: field.expression,
+          computedValue: result
+        });
+        return;
+      }
+    }
+    node.setFormulaWarning(null);
   }
-  get isDirty() {
-    return this._tree.isDirty;
+  handleError(field, error) {
+    const { node } = field;
+    node.setValue(node.defaultValue, { internal: true });
+    node.setFormulaWarning({
+      type: "runtime-error",
+      message: error.message,
+      expression: field.expression,
+      computedValue: void 0
+    });
+    if (this.options.onError) {
+      this.options.onError(node, error);
+    }
   }
-  get isValid() {
-    return this._tree.isValid;
+};
+
+// src/model/value-formula/FormulaEngine.ts
+var FormulaEngine = class {
+  constructor(tree, options = {}) {
+    this.tree = tree;
+    this.collector = new FormulaCollector();
+    this.graph = new DependencyGraph();
+    this.evaluator = new FormulaEvaluator(tree, options);
+    this.initialize();
+  }
+  collector;
+  graph;
+  evaluator;
+  formulas = [];
+  dependencyMap = /* @__PURE__ */ new Map();
+  evaluationOrder = [];
+  disposers = [];
+  reinitialize() {
+    this.disposeReactions();
+    this.initialize();
   }
-  get errors() {
-    return this._tree.errors;
+  dispose() {
+    this.disposeReactions();
+    this.formulas = [];
+    this.dependencyMap = /* @__PURE__ */ new Map();
+    this.evaluationOrder = [];
   }
-  getPatches() {
-    return this._tree.getPatches();
+  getFormulas() {
+    return this.formulas;
   }
-  commit() {
-    this._tree.commit();
+  getEvaluationOrder() {
+    return this.evaluationOrder;
   }
-  revert() {
-    this._tree.revert();
+  initialize() {
+    this.formulas = this.collector.collect(this.tree.root);
+    this.dependencyMap = this.graph.buildDependencyMap(this.formulas);
+    this.evaluationOrder = this.graph.buildEvaluationOrder(this.formulas);
+    this.evaluateAll();
+    this.setupReactions();
   }
-  setTableModel(tableModel) {
-    this._tableModel = tableModel;
+  evaluateAll() {
+    chunk46ME2TAU_cjs.runInAction(() => {
+      for (const field of this.evaluationOrder) {
+        this.evaluator.evaluate(field);
+      }
+    });
+  }
+  setupReactions() {
+    const watchedNodes = /* @__PURE__ */ new Set();
+    for (const [depNode] of this.dependencyMap) {
+      if (watchedNodes.has(depNode)) {
+        continue;
+      }
+      watchedNodes.add(depNode);
+      const disposer = chunk46ME2TAU_cjs.reaction(
+        () => depNode.value,
+        () => this.handleDependencyChange(depNode)
+      );
+      this.disposers.push(disposer);
+    }
+    this.setupArrayReactions(this.tree.root);
+  }
+  setupArrayReactions(node) {
+    if (node.isArray()) {
+      const disposer = chunk46ME2TAU_cjs.reaction(
+        () => node.length,
+        () => this.handleStructureChange()
+      );
+      this.disposers.push(disposer);
+      for (const item of node.value) {
+        this.setupArrayReactions(item);
+      }
+    } else if (node.isObject()) {
+      for (const child of node.children) {
+        this.setupArrayReactions(child);
+      }
+    }
+  }
+  handleDependencyChange(changedNode) {
+    const affected = this.graph.getAffectedFormulas(
+      changedNode,
+      this.dependencyMap,
+      this.evaluationOrder
+    );
+    chunk46ME2TAU_cjs.runInAction(() => {
+      for (const field of affected) {
+        this.evaluator.evaluate(field);
+      }
+    });
+  }
+  handleStructureChange() {
+    this.reinitialize();
+  }
+  disposeReactions() {
+    for (const disposer of this.disposers) {
+      disposer();
+    }
+    this.disposers = [];
   }
 };
 
@@ -2107,6 +2545,20 @@ var ValuePathImpl = class _ValuePathImpl extends chunk46ME2TAU_cjs.AbstractBaseP
     }
     return parts.join("");
   }
+  asJsonPointer() {
+    if (this.segs.length === 0) {
+      return "";
+    }
+    const parts = [];
+    for (const seg of this.segs) {
+      if (seg.isProperty()) {
+        parts.push(seg.propertyName());
+      } else if (seg.isIndex()) {
+        parts.push(String(seg.indexValue()));
+      }
+    }
+    return "/" + parts.join("/");
+  }
   parent() {
     if (this.segs.length <= 1) {
       return EMPTY_VALUE_PATH;
@@ -2121,6 +2573,9 @@ var ValuePathImpl = class _ValuePathImpl extends chunk46ME2TAU_cjs.AbstractBaseP
   }
 };
 var EMPTY_VALUE_PATH = new ValuePathImpl([]);
+function createValuePath(segments) {
+  return segments.length === 0 ? EMPTY_VALUE_PATH : new ValuePathImpl(segments);
+}
 
 // src/core/value-path/ValuePathParser.ts
 function parseIndexSegment(path, startIndex) {
@@ -2176,17 +2631,194 @@ function parseValuePath(path) {
   return segments;
 }
 
+// src/model/value-tree/ChangeTracker.ts
+var ChangeTracker = class {
+  _changes = [];
+  get changes() {
+    return this._changes;
+  }
+  get hasChanges() {
+    return this._changes.length > 0;
+  }
+  track(change) {
+    this._changes.push(change);
+  }
+  clear() {
+    this._changes = [];
+  }
+  toPatches() {
+    const patches = [];
+    for (const change of this._changes) {
+      const converted = this.changeToPatch(change);
+      patches.push(...converted);
+    }
+    return patches;
+  }
+  changeToPatch(change) {
+    const path = change.path.asJsonPointer();
+    switch (change.type) {
+      case "setValue":
+        return [{ op: "replace", path, value: change.value }];
+      case "addProperty":
+        return [{ op: "add", path, value: change.value }];
+      case "removeProperty":
+        return [{ op: "remove", path }];
+      case "arrayPush":
+        return [{ op: "add", path: `${path}/-`, value: change.value }];
+      case "arrayInsert":
+        return [
+          { op: "add", path: `${path}/${change.index}`, value: change.value }
+        ];
+      case "arrayRemove":
+        return [{ op: "remove", path: `${path}/${change.index}` }];
+      case "arrayMove":
+        return [
+          {
+            op: "move",
+            from: `${path}/${change.fromIndex}`,
+            path: `${path}/${change.toIndex}`
+          }
+        ];
+      case "arrayReplace":
+        return [
+          {
+            op: "replace",
+            path: `${path}/${change.index}`,
+            value: change.value
+          }
+        ];
+      case "arrayClear":
+        return [{ op: "replace", path, value: [] }];
+    }
+  }
+};
+
+// src/model/value-tree/TreeIndex.ts
+var TreeIndex = class {
+  constructor(root) {
+    this.root = root;
+    this.rebuild();
+  }
+  nodesById = /* @__PURE__ */ new Map();
+  pathCache = /* @__PURE__ */ new Map();
+  nodeById(id) {
+    const node = this.nodesById.get(id);
+    if (node) {
+      return node;
+    }
+    this.rebuild();
+    return this.nodesById.get(id);
+  }
+  pathOf(node) {
+    if (this.isInsideArray(node)) {
+      return this.computePath(node);
+    }
+    const cached = this.pathCache.get(node.id);
+    if (cached) {
+      return cached;
+    }
+    const path = this.computePath(node);
+    this.pathCache.set(node.id, path);
+    return path;
+  }
+  rebuild() {
+    this.nodesById.clear();
+    this.pathCache.clear();
+    this.indexNode(this.root);
+  }
+  registerNode(node) {
+    this.indexNode(node);
+  }
+  invalidatePathsUnder(node) {
+    this.pathCache.delete(node.id);
+    this.invalidateChildPaths(node);
+  }
+  isInsideArray(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.isArray()) {
+        return true;
+      }
+      current = current.parent;
+    }
+    return false;
+  }
+  indexNode(node) {
+    this.nodesById.set(node.id, node);
+    if (node.isObject()) {
+      for (const child of node.children) {
+        this.indexNode(child);
+      }
+    } else if (node.isArray()) {
+      for (const item of node.value) {
+        this.indexNode(item);
+      }
+    }
+  }
+  computePath(node) {
+    const segments = [];
+    let current = node;
+    while (current?.parent) {
+      const parent = current.parent;
+      if (parent.isObject()) {
+        segments.unshift(new PropertySegment(current.name));
+      } else if (parent.isArray()) {
+        const index = parent.value.indexOf(current);
+        if (index >= 0) {
+          segments.unshift(new IndexSegment(index));
+        }
+      }
+      current = parent;
+    }
+    if (segments.length === 0) {
+      return EMPTY_VALUE_PATH;
+    }
+    return createValuePath(segments);
+  }
+  invalidateChildPaths(node) {
+    if (node.isObject()) {
+      for (const child of node.children) {
+        this.pathCache.delete(child.id);
+        this.invalidateChildPaths(child);
+      }
+    } else if (node.isArray()) {
+      for (const item of node.value) {
+        this.pathCache.delete(item.id);
+        this.invalidateChildPaths(item);
+      }
+    }
+  }
+};
+
 // src/model/value-tree/ValueTree.ts
 var ValueTree = class {
   constructor(_root) {
     this._root = _root;
+    this.index = new TreeIndex(_root);
+    this.changeTracker = new ChangeTracker();
     chunk46ME2TAU_cjs.makeAutoObservable(this, {
-      _root: false
+      _root: false,
+      index: false,
+      changeTracker: false,
+      _formulaEngine: false
     });
   }
+  index;
+  changeTracker;
+  _formulaEngine = null;
   get root() {
     return this._root;
   }
+  nodeById(id) {
+    return this.index.nodeById(id);
+  }
+  pathOf(nodeOrId) {
+    const node = typeof nodeOrId === "string" ? this.index.nodeById(nodeOrId) : nodeOrId;
+    if (!node) {
+      return EMPTY_VALUE_PATH;
+    }
+    return this.index.pathOf(node);
+  }
   get(path) {
     const segments = parseValuePath(path);
     if (segments.length === 0) {
@@ -2219,7 +2851,14 @@ var ValueTree = class {
     if (!node.isPrimitive()) {
       throw new Error(`Cannot set value on non-primitive node: ${path}`);
     }
+    const oldValue = node.value;
     node.setValue(value);
+    this.changeTracker.track({
+      type: "setValue",
+      path: this.index.pathOf(node),
+      value,
+      oldValue
+    });
   }
   getPlainValue() {
     return this._root.getPlainValue();
@@ -2238,22 +2877,147 @@ var ValueTree = class {
     return this._root.errors;
   }
   getPatches() {
-    return [];
+    return this.changeTracker.toPatches();
+  }
+  trackChange(change) {
+    this.changeTracker.track(change);
   }
   commit() {
     const root = this._root;
     if ("commit" in root && typeof root.commit === "function") {
       root.commit();
     }
+    this.changeTracker.clear();
   }
   revert() {
     const root = this._root;
     if ("revert" in root && typeof root.revert === "function") {
       root.revert();
     }
+    this.changeTracker.clear();
+  }
+  rebuildIndex() {
+    this.index.rebuild();
+  }
+  registerNode(node) {
+    this.index.registerNode(node);
+  }
+  invalidatePathsUnder(node) {
+    this.index.invalidatePathsUnder(node);
+  }
+  setFormulaEngine(engine) {
+    this._formulaEngine = engine;
+  }
+  get formulaEngine() {
+    return this._formulaEngine;
+  }
+  dispose() {
+    this._formulaEngine?.dispose();
+    this._formulaEngine = null;
   }
 };
 
+// src/model/table/row/RowModelImpl.ts
+var UNSET_INDEX = -1;
+var RowModelImpl = class {
+  constructor(_rowId, _tree) {
+    this._rowId = _rowId;
+    this._tree = _tree;
+    chunk46ME2TAU_cjs.makeAutoObservable(this, {
+      _rowId: false,
+      _tree: false,
+      _tableModel: "observable.ref"
+    });
+  }
+  _tableModel = null;
+  get rowId() {
+    return this._rowId;
+  }
+  get tableModel() {
+    return this._tableModel;
+  }
+  get tree() {
+    return this._tree;
+  }
+  get index() {
+    if (!this._tableModel) {
+      return UNSET_INDEX;
+    }
+    return this._tableModel.getRowIndex(this._rowId);
+  }
+  get prev() {
+    if (!this._tableModel) {
+      return null;
+    }
+    const currentIndex = this.index;
+    if (currentIndex <= 0) {
+      return null;
+    }
+    return this._tableModel.getRowAt(currentIndex - 1) ?? null;
+  }
+  get next() {
+    if (!this._tableModel) {
+      return null;
+    }
+    const currentIndex = this.index;
+    if (currentIndex === UNSET_INDEX || currentIndex >= this._tableModel.rowCount - 1) {
+      return null;
+    }
+    return this._tableModel.getRowAt(currentIndex + 1) ?? null;
+  }
+  get(path) {
+    return this._tree.get(path);
+  }
+  getValue(path) {
+    return this._tree.getValue(path);
+  }
+  setValue(path, value) {
+    this._tree.setValue(path, value);
+  }
+  getPlainValue() {
+    return this._tree.getPlainValue();
+  }
+  nodeById(id) {
+    return this._tree.nodeById(id);
+  }
+  get isDirty() {
+    return this._tree.isDirty;
+  }
+  get isValid() {
+    return this._tree.isValid;
+  }
+  get errors() {
+    return this._tree.errors;
+  }
+  getPatches() {
+    return this._tree.getPatches();
+  }
+  commit() {
+    this._tree.commit();
+  }
+  revert() {
+    this._tree.revert();
+  }
+  dispose() {
+    this._tree.dispose();
+  }
+  setTableModel(tableModel) {
+    this._tableModel = tableModel;
+  }
+};
+function createRowModel(options) {
+  const factory = createNodeFactory({
+    fkResolver: options.fkResolver,
+    refSchemas: options.refSchemas
+  });
+  const rowData = options.data ?? generateDefaultValue(options.schema, { refSchemas: options.refSchemas });
+  const rootNode = factory.createTree(options.schema, rowData);
+  const valueTree = new ValueTree(rootNode);
+  const formulaEngine = new FormulaEngine(valueTree);
+  valueTree.setFormulaEngine(formulaEngine);
+  return new RowModelImpl(options.rowId, valueTree);
+}
+
 // src/model/table/TableModelImpl.ts
 var TableModelImpl = class {
   _tableId;
@@ -2273,7 +3037,7 @@ var TableModelImpl = class {
     this._rows = chunk46ME2TAU_cjs.observable.array();
     if (options.rows) {
       for (const row of options.rows) {
-        this._rows.push(this.createRowModel(row.rowId, row.data));
+        this._rows.push(this.createRow(row.rowId, row.data));
       }
     }
     chunk46ME2TAU_cjs.makeAutoObservable(this, {
@@ -2315,19 +3079,24 @@ var TableModelImpl = class {
     if (this.getRow(rowId)) {
       throw new Error(`Row with id already exists: ${rowId}`);
     }
-    const rowModel = this.createRowModel(rowId, data);
+    const rowModel = this.createRow(rowId, data);
     this._rows.push(rowModel);
     return rowModel;
   }
   removeRow(rowId) {
-    const index = this._rows.findIndex((row) => row.rowId === rowId);
-    if (index !== -1) {
-      const row = this._rows[index];
-      if (row instanceof RowModelImpl) {
-        row.setTableModel(null);
-      }
-      this._rows.splice(index, 1);
+    const index = this._rows.findIndex((row2) => row2.rowId === rowId);
+    if (index === -1) {
+      return;
+    }
+    const row = this._rows[index];
+    if (!row) {
+      return;
     }
+    row.dispose();
+    if (row instanceof RowModelImpl) {
+      row.setTableModel(null);
+    }
+    this._rows.splice(index, 1);
   }
   getRow(rowId) {
     return this._rows.find((row) => row.rowId === rowId);
@@ -2366,15 +3135,20 @@ var TableModelImpl = class {
       row.revert();
     }
   }
-  createRowModel(rowId, data) {
-    const factory = createNodeFactory({
+  dispose() {
+    for (const row of this._rows) {
+      row.dispose();
+    }
+    this._rows.splice(0);
+  }
+  createRow(rowId, data) {
+    const rowModel = createRowModel({
+      rowId,
+      schema: this._jsonSchema,
+      data,
       fkResolver: this._fkResolver,
       refSchemas: this._refSchemas
     });
-    const rowData = data ?? generateDefaultValue(this._jsonSchema, { refSchemas: this._refSchemas });
-    const rootNode = factory.createTree(this._jsonSchema, rowData);
-    const valueTree = new ValueTree(rootNode);
-    const rowModel = new RowModelImpl(rowId, valueTree);
     rowModel.setTableModel(this);
     return rowModel;
   }
@@ -2808,6 +3582,7 @@ exports.createDataModel = createDataModel;
 exports.createDefaultRegistry = createDefaultRegistry;
 exports.createForeignKeyResolver = createForeignKeyResolver;
 exports.createNodeFactory = createNodeFactory;
+exports.createRowModel = createRowModel;
 exports.createSchemaModel = createSchemaModel;
 exports.createTableModel = createTableModel;
 exports.createTypeTransformChain = createTypeTransformChain;
@@ -2816,5 +3591,5 @@ exports.generateDefaultValue = generateDefaultValue;
 exports.generateNodeId = generateNodeId;
 exports.isForeignKeyValueNode = isForeignKeyValueNode;
 exports.resetNodeIdCounter = resetNodeIdCounter;
-//# sourceMappingURL=chunk-O4QRUV7I.cjs.map
-//# sourceMappingURL=chunk-O4QRUV7I.cjs.map
+//# sourceMappingURL=chunk-FZ2MS4Q5.cjs.map
+//# sourceMappingURL=chunk-FZ2MS4Q5.cjs.map