@revisium/schema-toolkit 0.16.1 → 0.16.2

package/dist/{chunk-KTCH6INZ.js → chunk-VQZNN335.js}

@@ -1,10 +1,12 @@
-import { AbstractBasePath, ParsedFormula, createRefNode, createObjectNode, createArrayNode, createStringNode, createNumberNode, createBooleanNode, PatchBuilder, SchemaSerializer, FormulaDependencyIndex, createSchemaTree, validateSchema, validateFormulas } from './chunk-S7GEDTSL.js';
+import { AbstractBasePath, ParsedFormula, createRefNode, createObjectNode, createArrayNode, createStringNode, createNumberNode, createBooleanNode, makeAutoObservable, observable, makeObservable, runInAction, PatchBuilder, SchemaSerializer, FormulaDependencyIndex, createSchemaTree, FormulaSerializer, validateSchema, validateFormulas } from './chunk-KLDN3IHB.js';
 import { nanoid } from 'nanoid';
 
 var SchemaParser = class {
   pendingFormulas = [];
+  _parseErrors = [];
   parse(schema) {
     this.pendingFormulas = [];
+    this._parseErrors = [];
     return this.parseNode(schema, "root");
   }
   parseFormulas(tree) {
@@ -13,19 +15,24 @@ var SchemaParser = class {
       if (node.isNull()) {
         continue;
       }
-      const formula = new ParsedFormula(tree, pending.nodeId, pending.expression);
-      node.setFormula(formula);
+      try {
+        const formula = new ParsedFormula(tree, pending.nodeId, pending.expression);
+        node.setFormula(formula);
+      } catch (error) {
+        this._parseErrors.push({
+          nodeId: pending.nodeId,
+          message: error.message
+        });
+      }
     }
     this.pendingFormulas = [];
   }
+  get parseErrors() {
+    return this._parseErrors;
+  }
   parseNode(schema, name) {
     if ("$ref" in schema) {
-      return createRefNode(
-        nanoid(),
-        name,
-        schema.$ref,
-        this.extractMetadata(schema)
-      );
+      return createRefNode(nanoid(), name, schema.$ref, this.extractMetadata(schema));
     }
     const schemaWithType = schema;
     switch (schemaWithType.type) {
@@ -51,21 +58,11 @@ var SchemaParser = class {
         children.push(this.parseNode(propSchema, propName));
       }
     }
-    return createObjectNode(
-      nanoid(),
-      name,
-      children,
-      this.extractMetadata(schema)
-    );
+    return createObjectNode(nanoid(), name, children, this.extractMetadata(schema));
   }
   parseArray(schema, name) {
     const items = this.parseNode(schema.items, "items");
-    return createArrayNode(
-      nanoid(),
-      name,
-      items,
-      this.extractMetadata(schema)
-    );
+    return createArrayNode(nanoid(), name, items, this.extractMetadata(schema));
   }
   parseString(schema, name) {
     const nodeId = nanoid();
@@ -127,12 +124,12 @@ var NodeFactory = class {
       case "object":
         return createObjectNode(nanoid(), name, []);
       case "array":
-        return this.createArrayNode(name);
+        return this.createArrayNodeInternal(name);
       default:
         throw new Error(`Unknown field type: ${type}`);
     }
   }
-  createArrayNode(name) {
+  createArrayNodeInternal(name) {
     const items = createStringNode(nanoid(), "items", { defaultValue: "" });
     return createArrayNode(nanoid(), name, items);
   }
@@ -232,47 +229,28 @@ function generateDefaultValue(schema, options = {}) {
 var SchemaModelImpl = class {
   _baseTree;
   _currentTree;
-  _reactivity;
   _patchBuilder = new PatchBuilder();
   _serializer = new SchemaSerializer();
   _nodeFactory = new NodeFactory();
   _formulaIndex = new FormulaDependencyIndex();
-  constructor(schema, options) {
+  _formulaParseErrors = [];
+  constructor(schema) {
     const parser = new SchemaParser();
     const rootNode = parser.parse(schema);
     this._currentTree = createSchemaTree(rootNode);
     parser.parseFormulas(this._currentTree);
+    this._formulaParseErrors = parser.parseErrors;
     this._buildFormulaIndex();
     this._baseTree = this._currentTree.clone();
-    this._reactivity = options?.reactivity;
-    if (this._reactivity) {
-      this._reactivity.makeObservable(this, {
-        _currentTree: "observable.ref",
-        _baseTree: "observable.ref",
-        root: "computed",
-        isDirty: "computed",
-        isValid: "computed",
-        patches: "computed",
-        jsonPatches: "computed",
-        plainSchema: "computed",
-        validationErrors: "computed",
-        formulaErrors: "computed",
-        nodeCount: "computed",
-        addField: "action",
-        removeField: "action",
-        renameField: "action",
-        changeFieldType: "action",
-        updateMetadata: "action",
-        updateFormula: "action",
-        updateForeignKey: "action",
-        updateDefaultValue: "action",
-        wrapInArray: "action",
-        wrapRootInArray: "action",
-        replaceRoot: "action",
-        markAsSaved: "action",
-        revert: "action"
-      });
-    }
+    makeAutoObservable(this, {
+      _patchBuilder: false,
+      _serializer: false,
+      _nodeFactory: false,
+      _formulaIndex: false,
+      _currentTree: "observable.ref",
+      _baseTree: "observable.ref",
+      _formulaParseErrors: "observable.ref"
+    });
   }
   get root() {
     return this._currentTree.root();
@@ -333,13 +311,21 @@ var SchemaModelImpl = class {
     if (node.isNull()) {
       return;
     }
+    this._formulaParseErrors = this._formulaParseErrors.filter((e) => e.nodeId !== nodeId);
     if (expression === void 0) {
       node.setFormula(void 0);
       this._formulaIndex.unregisterFormula(nodeId);
     } else {
-      const formula = new ParsedFormula(this._currentTree, nodeId, expression);
-      node.setFormula(formula);
-      this._formulaIndex.registerFormula(nodeId, formula);
+      try {
+        const formula = new ParsedFormula(this._currentTree, nodeId, expression);
+        node.setFormula(formula);
+        this._formulaIndex.registerFormula(nodeId, formula);
+      } catch (error) {
+        this._formulaParseErrors = [
+          ...this._formulaParseErrors,
+          { nodeId, message: error.message }
+        ];
+      }
     }
   }
   updateForeignKey(nodeId, foreignKey) {
@@ -431,8 +417,37 @@ var SchemaModelImpl = class {
     if (targetPath.equals(nodeParentPath)) {
       return false;
     }
+    if (this.isMovingOutOfArray(nodePath, targetPath)) {
+      return false;
+    }
     return true;
   }
+  isMovingOutOfArray(fromPath, toPath) {
+    const fromSegments = fromPath.segments();
+    const toSegments = toPath.segments();
+    for (let i = 0; i < fromSegments.length; i++) {
+      const fromSeg = fromSegments[i];
+      if (fromSeg?.isItems()) {
+        if (!toSegments[i]?.isItems()) {
+          return true;
+        }
+        if (this.hasPathPrefixMismatch(fromSegments, toSegments, i)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  hasPathPrefixMismatch(fromSegments, toSegments, endIndex) {
+    for (let j = 0; j < endIndex; j++) {
+      const fromSeg = fromSegments[j];
+      const toSeg = toSegments[j];
+      if (!fromSeg || !toSeg || !fromSeg.equals(toSeg)) {
+        return true;
+      }
+    }
+    return false;
+  }
   hasValidDropTarget(nodeId) {
     const node = this._currentTree.nodeById(nodeId);
     if (node.isNull()) {
@@ -449,17 +464,39 @@ var SchemaModelImpl = class {
     }
     return false;
   }
+  moveNode(nodeId, targetParentId) {
+    if (!this.canMoveNode(nodeId, targetParentId)) {
+      return;
+    }
+    this._currentTree.moveNode(nodeId, targetParentId);
+  }
   getFormulaDependents(nodeId) {
     return this._formulaIndex.getDependents(nodeId);
   }
   hasFormulaDependents(nodeId) {
     return this._formulaIndex.hasDependents(nodeId);
   }
+  serializeFormula(nodeId) {
+    const node = this._currentTree.nodeById(nodeId);
+    if (node.isNull()) {
+      return "";
+    }
+    const formula = node.formula();
+    if (!formula) {
+      return "";
+    }
+    return FormulaSerializer.serializeExpression(
+      this._currentTree,
+      nodeId,
+      formula,
+      { strict: false }
+    );
+  }
   get validationErrors() {
     return validateSchema(this._currentTree.root());
   }
   get formulaErrors() {
-    return validateFormulas(this._currentTree);
+    return [...this._formulaParseErrors, ...validateFormulas(this._currentTree)];
   }
   get isDirty() {
     return this.patches.length > 0;
@@ -499,31 +536,23 @@ var SchemaModelImpl = class {
     }
   }
 };
-function createSchemaModel(schema, options) {
-  return new SchemaModelImpl(schema, options);
+function createSchemaModel(schema) {
+  return new SchemaModelImpl(schema);
 }
 
 // src/model/table/row/RowModelImpl.ts
 var UNSET_INDEX = -1;
 var RowModelImpl = class {
-  constructor(_rowId, _tree, _reactivity) {
+  constructor(_rowId, _tree) {
     this._rowId = _rowId;
     this._tree = _tree;
-    this._reactivity = _reactivity;
-    this.initObservable();
-  }
-  _tableModel = null;
-  initObservable() {
-    this._reactivity?.makeObservable(this, {
-      _tableModel: "observable.ref",
-      index: "computed",
-      prev: "computed",
-      next: "computed",
-      isDirty: "computed",
-      isValid: "computed",
-      errors: "computed"
+    makeAutoObservable(this, {
+      _rowId: false,
+      _tree: false,
+      _tableModel: "observable.ref"
     });
   }
+  _tableModel = null;
   get rowId() {
     return this._rowId;
   }
@@ -663,10 +692,13 @@ function extractFormulaDefinition(schema) {
 
 // src/model/value-node/ArrayValueNode.ts
 var ArrayValueNode = class extends BaseValueNode {
-  constructor(id, name, schema, items, reactivity) {
+  type = "array" /* Array */;
+  _items;
+  _baseItems;
+  _nodeFactory = null;
+  constructor(id, name, schema, items) {
     super(id, name, schema);
-    this.reactivity = reactivity;
-    this._items = reactivity?.observableArray() ?? [];
+    this._items = observable.array();
     this._baseItems = [];
     if (items) {
       for (const item of items) {
@@ -675,17 +707,7 @@ var ArrayValueNode = class extends BaseValueNode {
       }
     }
     this._baseItems = [...this._items];
-    this.initObservable();
-  }
-  type = "array" /* Array */;
-  _items;
-  _baseItems;
-  _nodeFactory = null;
-  initObservable() {
-    if (!this.reactivity) {
-      return;
-    }
-    this.reactivity.makeObservable(this, {
+    makeObservable(this, {
       _items: "observable",
       _baseItems: "observable",
       value: "computed",
@@ -840,7 +862,7 @@ var ArrayValueNode = class extends BaseValueNode {
     for (const item of this._items) {
       item.parent = null;
     }
-    this._items = this.reactivity?.observableArray() ?? [];
+    this._items = observable.array();
     for (const baseItem of this._baseItems) {
       this._items.push(baseItem);
     }
@@ -872,22 +894,18 @@ var ArrayValueNode = class extends BaseValueNode {
 
 // src/model/value-node/BasePrimitiveValueNode.ts
 var BasePrimitiveValueNode = class extends BaseValueNode {
-  constructor(id, name, schema, value, defaultValue, reactivity) {
+  _value;
+  _baseValue;
+  _formulaWarning = null;
+  constructor(id, name, schema, value, defaultValue) {
     super(id, name, schema);
-    this.reactivity = reactivity;
     const schemaDefault = "default" in schema ? schema.default : void 0;
     const initialValue = value ?? schemaDefault ?? defaultValue;
     this._value = initialValue;
     this._baseValue = initialValue;
   }
-  _value;
-  _baseValue;
-  _formulaWarning = null;
   initObservable() {
-    if (!this.reactivity) {
-      return;
-    }
-    this.reactivity.makeObservable(this, {
+    makeObservable(this, {
       _value: "observable",
       _baseValue: "observable",
       _formulaWarning: "observable",
@@ -976,8 +994,8 @@ var BasePrimitiveValueNode = class extends BaseValueNode {
 // src/model/value-node/BooleanValueNode.ts
 var BooleanValueNode = class extends BasePrimitiveValueNode {
   type = "boolean" /* Boolean */;
-  constructor(id, name, schema, value, reactivity) {
-    super(id, name, schema, value, false, reactivity);
+  constructor(id, name, schema, value) {
+    super(id, name, schema, value, false);
     this.initObservable();
   }
   get defaultValue() {
@@ -1011,8 +1029,8 @@ var ForeignKeyResolverNotConfiguredError = class extends Error {
 // src/model/value-node/StringValueNode.ts
 var StringValueNode = class extends BasePrimitiveValueNode {
   type = "string" /* String */;
-  constructor(id, name, schema, value, reactivity) {
-    super(id, name, schema, value, "", reactivity);
+  constructor(id, name, schema, value) {
+    super(id, name, schema, value, "");
     this.initObservable();
   }
   get defaultValue() {
@@ -1136,8 +1154,8 @@ function isForeignKeyValueNode(node) {
   return node instanceof ForeignKeyValueNodeImpl || "foreignKey" in node && typeof node.foreignKey === "string";
 }
 var ForeignKeyValueNodeImpl = class extends StringValueNode {
-  constructor(id, name, schema, value, reactivity, fkResolver) {
-    super(id, name, schema, value, reactivity);
+  constructor(id, name, schema, value, fkResolver) {
+    super(id, name, schema, value);
     this.fkResolver = fkResolver;
     const schemaFk = "foreignKey" in schema && typeof schema.foreignKey === "string" ? schema.foreignKey : void 0;
     if (!schemaFk) {
@@ -1175,8 +1193,8 @@ var ForeignKeyValueNodeImpl = class extends StringValueNode {
 // src/model/value-node/NumberValueNode.ts
 var NumberValueNode = class extends BasePrimitiveValueNode {
   type = "number" /* Number */;
-  constructor(id, name, schema, value, reactivity) {
-    super(id, name, schema, value, 0, reactivity);
+  constructor(id, name, schema, value) {
+    super(id, name, schema, value, 0);
     this.initObservable();
   }
   get defaultValue() {
@@ -1230,10 +1248,12 @@ var NumberValueNode = class extends BasePrimitiveValueNode {
 
 // src/model/value-node/ObjectValueNode.ts
 var ObjectValueNode = class extends BaseValueNode {
-  constructor(id, name, schema, children, reactivity) {
+  type = "object" /* Object */;
+  _children;
+  _baseChildren;
+  constructor(id, name, schema, children) {
     super(id, name, schema);
-    this.reactivity = reactivity;
-    this._children = reactivity?.observableMap() ?? /* @__PURE__ */ new Map();
+    this._children = observable.map();
     this._baseChildren = /* @__PURE__ */ new Map();
     if (children) {
       for (const child of children) {
@@ -1242,16 +1262,7 @@ var ObjectValueNode = class extends BaseValueNode {
       }
     }
     this._baseChildren = new Map(this._children);
-    this.initObservable();
-  }
-  type = "object" /* Object */;
-  _children;
-  _baseChildren;
-  initObservable() {
-    if (!this.reactivity) {
-      return;
-    }
-    this.reactivity.makeObservable(this, {
+    makeObservable(this, {
       _children: "observable",
       _baseChildren: "observable",
       value: "computed",
@@ -1327,7 +1338,7 @@ var ObjectValueNode = class extends BaseValueNode {
     for (const child of this._children.values()) {
       child.parent = null;
     }
-    this._children = this.reactivity?.observableMap() ?? /* @__PURE__ */ new Map();
+    this._children = observable.map();
     for (const [key, value] of this._baseChildren) {
       this._children.set(key, value);
     }
@@ -1413,7 +1424,7 @@ var NodeFactory2 = class {
     };
   }
 };
-function createStringFactory(reactivity, fkResolver) {
+function createStringFactory(fkResolver) {
   return (name, schema, value, id) => {
     const stringSchema = schema;
     if (stringSchema.foreignKey) {
@@ -1422,7 +1433,6 @@ function createStringFactory(reactivity, fkResolver) {
         name,
         schema,
         value,
-        reactivity,
         fkResolver
       );
     }
@@ -1430,34 +1440,31 @@ function createStringFactory(reactivity, fkResolver) {
       id,
       name,
       schema,
-      value,
-      reactivity
+      value
     );
   };
 }
-function createNumberFactory(reactivity) {
+function createNumberFactory() {
   return (name, schema, value, id) => {
     return new NumberValueNode(
       id,
       name,
       schema,
-      value,
-      reactivity
+      value
     );
   };
 }
-function createBooleanFactory(reactivity) {
+function createBooleanFactory() {
   return (name, schema, value, id) => {
     return new BooleanValueNode(
       id,
       name,
       schema,
-      value,
-      reactivity
+      value
     );
   };
 }
-function createObjectFactory(nodeFactory, reactivity) {
+function createObjectFactory(nodeFactory) {
   return (name, schema, value, id) => {
     const objValue = value ?? {};
     const children = [];
@@ -1468,10 +1475,10 @@ function createObjectFactory(nodeFactory, reactivity) {
       const childNode = nodeFactory.create(propName, propSchema, propValue);
       children.push(childNode);
     }
-    return new ObjectValueNode(id, name, schema, children, reactivity);
+    return new ObjectValueNode(id, name, schema, children);
   };
 }
-function createArrayFactory(nodeFactory, reactivity) {
+function createArrayFactory(nodeFactory) {
   return (name, schema, value, id) => {
     const arrValue = value ?? [];
     const arraySchema = schema;
@@ -1482,23 +1489,23 @@ function createArrayFactory(nodeFactory, reactivity) {
       const itemNode = nodeFactory.create(String(i), itemSchema, itemValue);
       items.push(itemNode);
     }
-    const arrayNode = new ArrayValueNode(id, name, schema, items, reactivity);
+    const arrayNode = new ArrayValueNode(id, name, schema, items);
     arrayNode.setNodeFactory(nodeFactory);
     return arrayNode;
   };
 }
-function createDefaultRegistry(reactivity, fkResolver) {
+function createDefaultRegistry(fkResolver) {
   const registry = new NodeFactoryRegistry();
-  registry.register("string", createStringFactory(reactivity, fkResolver));
-  registry.register("number", createNumberFactory(reactivity));
-  registry.register("boolean", createBooleanFactory(reactivity));
+  registry.register("string", createStringFactory(fkResolver));
+  registry.register("number", createNumberFactory());
+  registry.register("boolean", createBooleanFactory());
   return registry;
 }
 function createNodeFactory(options) {
-  const registry = createDefaultRegistry(options?.reactivity, options?.fkResolver);
+  const registry = createDefaultRegistry(options?.fkResolver);
   const factory = new NodeFactory2(registry, options);
-  registry.register("object", createObjectFactory(factory, options?.reactivity));
-  registry.register("array", createArrayFactory(factory, options?.reactivity));
+  registry.register("object", createObjectFactory(factory));
+  registry.register("array", createArrayFactory(factory));
   return factory;
 }
 
@@ -1631,18 +1638,10 @@ function parseValuePath(path) {
 
 // src/model/value-tree/ValueTree.ts
 var ValueTree = class {
-  constructor(_root, _reactivity) {
+  constructor(_root) {
     this._root = _root;
-    this._reactivity = _reactivity;
-    this.initObservable();
-  }
-  initObservable() {
-    this._reactivity?.makeObservable(this, {
-      isDirty: "computed",
-      isValid: "computed",
-      errors: "computed",
-      commit: "action",
-      revert: "action"
+    makeAutoObservable(this, {
+      _root: false
     });
   }
   get root() {
@@ -1722,38 +1721,24 @@ var TableModelImpl = class {
   _schema;
   _rows;
   _jsonSchema;
-  _reactivity;
   _fkResolver;
-  constructor(options, reactivity) {
+  constructor(options) {
     this._tableId = options.tableId;
     this._baseTableId = options.tableId;
     this._jsonSchema = options.schema;
-    this._schema = createSchemaModel(options.schema, { reactivity });
-    this._reactivity = reactivity;
+    this._schema = createSchemaModel(options.schema);
     this._fkResolver = options.fkResolver;
-    this._rows = reactivity?.observableArray() ?? [];
+    this._rows = observable.array();
     if (options.rows) {
       for (const row of options.rows) {
         this._rows.push(this.createRowModel(row.rowId, row.data));
       }
     }
-    this.initObservable();
-  }
-  initObservable() {
-    this._reactivity?.makeObservable(this, {
-      _tableId: "observable",
-      _baseTableId: "observable",
-      tableId: "computed",
-      baseTableId: "computed",
-      isRenamed: "computed",
-      rows: "computed",
-      rowCount: "computed",
-      isDirty: "computed",
-      rename: "action",
-      addRow: "action",
-      removeRow: "action",
-      commit: "action",
-      revert: "action"
+    makeAutoObservable(this, {
+      _schema: false,
+      _rows: false,
+      _jsonSchema: false,
+      _fkResolver: false
     });
   }
   get tableId() {
@@ -1837,19 +1822,18 @@ var TableModelImpl = class {
   }
   createRowModel(rowId, data) {
     const factory = createNodeFactory({
-      reactivity: this._reactivity,
       fkResolver: this._fkResolver
     });
     const rowData = data ?? generateDefaultValue(this._jsonSchema);
     const rootNode = factory.createTree(this._jsonSchema, rowData);
-    const valueTree = new ValueTree(rootNode, this._reactivity);
-    const rowModel = new RowModelImpl(rowId, valueTree, this._reactivity);
+    const valueTree = new ValueTree(rootNode);
+    const rowModel = new RowModelImpl(rowId, valueTree);
     rowModel.setTableModel(this);
     return rowModel;
   }
 };
-function createTableModel(options, reactivity) {
-  return new TableModelImpl(options, reactivity);
+function createTableModel(options) {
+  return new TableModelImpl(options);
 }
 
 // src/model/foreign-key-resolver/ForeignKeyResolverImpl.ts
@@ -1863,29 +1847,24 @@ var ForeignKeyResolverImpl = class {
   _prefetchEnabled;
   _disposed = false;
   loader;
-  reactivity;
   constructor(options) {
     this.loader = options?.loader;
-    this.reactivity = options?.reactivity;
     this._prefetchEnabled = options?.prefetch ?? false;
-    this._schemaCache = this.reactivity?.observableMap() ?? /* @__PURE__ */ new Map();
-    this._tableCache = this.reactivity?.observableMap() ?? /* @__PURE__ */ new Map();
+    this._schemaCache = observable.map();
+    this._tableCache = observable.map();
     this._loadingTables = /* @__PURE__ */ new Set();
     this._loadingRows = /* @__PURE__ */ new Map();
     this._pendingTableLoads = /* @__PURE__ */ new Map();
     this._pendingRowLoads = /* @__PURE__ */ new Map();
-    this.initObservable();
-  }
-  initObservable() {
-    this.reactivity?.makeObservable(this, {
-      _schemaCache: "observable",
-      _tableCache: "observable",
-      _prefetchEnabled: "observable",
-      isPrefetchEnabled: "computed",
-      addSchema: "action",
-      addTable: "action",
-      addRow: "action",
-      setPrefetch: "action"
+    makeAutoObservable(this, {
+      _schemaCache: false,
+      _tableCache: false,
+      _loadingTables: false,
+      _loadingRows: false,
+      _pendingTableLoads: false,
+      _pendingRowLoads: false,
+      _disposed: false,
+      loader: false
     });
   }
   get isPrefetchEnabled() {
@@ -1915,32 +1894,23 @@ var ForeignKeyResolverImpl = class {
     if (this._disposed) {
       return;
     }
-    if (this.reactivity) {
-      this.reactivity.runInAction(() => {
-        this._schemaCache.set(tableId, schema);
-      });
-    } else {
+    runInAction(() => {
       this._schemaCache.set(tableId, schema);
-    }
+    });
   }
   addTable(tableId, schema, rows) {
     if (this._disposed) {
       return;
     }
-    const rowMap = this.reactivity?.observableMap() ?? /* @__PURE__ */ new Map();
+    const rowMap = observable.map();
     for (const row of rows) {
       rowMap.set(row.rowId, row);
     }
     const cache = { schema, rows: rowMap };
-    if (this.reactivity) {
-      this.reactivity.runInAction(() => {
-        this._tableCache.set(tableId, cache);
-        this._schemaCache.set(tableId, schema);
-      });
-    } else {
+    runInAction(() => {
       this._tableCache.set(tableId, cache);
       this._schemaCache.set(tableId, schema);
-    }
+    });
     if (this._prefetchEnabled) {
       this.prefetchForeignKeysFromTable(tableId, schema, rows);
     }
@@ -1952,13 +1922,9 @@ var ForeignKeyResolverImpl = class {
     const table = this._tableCache.get(tableId);
     if (table) {
       const rowData = { rowId, data };
-      if (this.reactivity) {
-        this.reactivity.runInAction(() => {
-          table.rows.set(rowId, rowData);
-        });
-      } else {
+      runInAction(() => {
         table.rows.set(rowId, rowData);
-      }
+      });
       if (this._prefetchEnabled) {
         this.prefetchForeignKeysFromRow(tableId, table.schema, data);
       }
@@ -1970,18 +1936,7 @@ var ForeignKeyResolverImpl = class {
     }
     const schema = this._schemaCache.get(oldTableId);
     const tableCache = this._tableCache.get(oldTableId);
-    if (this.reactivity) {
-      this.reactivity.runInAction(() => {
-        if (schema) {
-          this._schemaCache.delete(oldTableId);
-          this._schemaCache.set(newTableId, schema);
-        }
-        if (tableCache) {
-          this._tableCache.delete(oldTableId);
-          this._tableCache.set(newTableId, tableCache);
-        }
-      });
-    } else {
+    runInAction(() => {
       if (schema) {
         this._schemaCache.delete(oldTableId);
         this._schemaCache.set(newTableId, schema);
@@ -1990,7 +1945,7 @@ var ForeignKeyResolverImpl = class {
         this._tableCache.delete(oldTableId);
         this._tableCache.set(newTableId, tableCache);
       }
-    }
+    });
   }
   async getSchema(tableId) {
     const cachedSchema = this._schemaCache.get(tableId);
@@ -2083,15 +2038,11 @@ var ForeignKeyResolverImpl = class {
   }
   ensureTableCache(tableId, schema) {
     if (!this._tableCache.has(tableId)) {
-      const rowMap = this.reactivity?.observableMap() ?? /* @__PURE__ */ new Map();
+      const rowMap = observable.map();
       const cache = { schema, rows: rowMap };
-      if (this.reactivity) {
-        this.reactivity.runInAction(() => {
-          this._tableCache.set(tableId, cache);
-        });
-      } else {
+      runInAction(() => {
         this._tableCache.set(tableId, cache);
-      }
+      });
     }
   }
   markRowAsLoading(tableId, rowId) {
@@ -2188,30 +2139,19 @@ var DataModelImpl = class {
   _tables;
   _fk;
   _ownsFkResolver;
-  _reactivity;
   constructor(options) {
-    this._reactivity = options?.reactivity;
-    this._tables = this._reactivity?.observableMap() ?? /* @__PURE__ */ new Map();
+    this._tables = observable.map();
     if (options?.fkResolver) {
       this._fk = options.fkResolver;
       this._ownsFkResolver = false;
     } else {
-      this._fk = createForeignKeyResolver({ reactivity: this._reactivity });
+      this._fk = createForeignKeyResolver();
       this._ownsFkResolver = true;
     }
-    this.initObservable();
-  }
-  initObservable() {
-    this._reactivity?.makeObservable(this, {
-      _tables: "observable",
-      tables: "computed",
-      tableIds: "computed",
-      isDirty: "computed",
-      addTable: "action",
-      removeTable: "action",
-      renameTable: "action",
-      commit: "action",
-      revert: "action"
+    makeAutoObservable(this, {
+      _tables: false,
+      _fk: false,
+      _ownsFkResolver: false
     });
   }
   get fk() {
@@ -2238,15 +2178,12 @@ var DataModelImpl = class {
     return this._tables.get(tableId);
   }
   addTable(tableId, schema, rows) {
-    const tableModel = createTableModel(
-      {
-        tableId,
-        schema,
-        rows,
-        fkResolver: this._fk
-      },
-      this._reactivity
-    );
+    const tableModel = createTableModel({
+      tableId,
+      schema,
+      rows,
+      fkResolver: this._fk
+    });
     this._tables.set(tableId, tableModel);
     this._fk.addSchema(tableId, schema);
     if (rows && rows.length > 0) {
@@ -2292,5 +2229,5 @@ function createDataModel(options) {
 }
 
 export { ArrayValueNode, BasePrimitiveValueNode, BaseValueNode, BooleanValueNode, DataModelImpl, ForeignKeyNotFoundError, ForeignKeyResolverImpl, ForeignKeyResolverNotConfiguredError, ForeignKeyValueNodeImpl, NodeFactory, NodeFactory2, NodeFactoryRegistry, NumberValueNode, ObjectValueNode, RowModelImpl, SchemaParser, StringValueNode, TableModelImpl, ValueType, createDataModel, createDefaultRegistry, createForeignKeyResolver, createNodeFactory, createSchemaModel, createTableModel, extractFormulaDefinition, generateDefaultValue, generateNodeId, isForeignKeyValueNode, resetNodeIdCounter };
-//# sourceMappingURL=chunk-KTCH6INZ.js.map
-//# sourceMappingURL=chunk-KTCH6INZ.js.map
+//# sourceMappingURL=chunk-VQZNN335.js.map
+//# sourceMappingURL=chunk-VQZNN335.js.map