@revisium/schema-toolkit 0.14.2 → 0.15.0

package/dist/chunk-5WZ4YPH5.cjs

@@ -0,0 +1,2209 @@
+'use strict';
+
+var chunkA4E524UU_cjs = require('./chunk-A4E524UU.cjs');
+var nanoid = require('nanoid');
+
+var SchemaParser = class {
+  pendingFormulas = [];
+  parse(schema) {
+    this.pendingFormulas = [];
+    return this.parseNode(schema, "root");
+  }
+  parseFormulas(tree) {
+    for (const pending of this.pendingFormulas) {
+      const node = tree.nodeById(pending.nodeId);
+      if (node.isNull()) {
+        continue;
+      }
+      const formula = new chunkA4E524UU_cjs.ParsedFormula(tree, pending.nodeId, pending.expression);
+      node.setFormula(formula);
+    }
+    this.pendingFormulas = [];
+  }
+  parseNode(schema, name) {
+    if ("$ref" in schema) {
+      return chunkA4E524UU_cjs.createRefNode(
+        nanoid.nanoid(),
+        name,
+        schema.$ref,
+        this.extractMetadata(schema)
+      );
+    }
+    const schemaWithType = schema;
+    switch (schemaWithType.type) {
+      case "object" /* Object */:
+        return this.parseObject(schemaWithType, name);
+      case "array" /* Array */:
+        return this.parseArray(schemaWithType, name);
+      case "string" /* String */:
+        return this.parseString(schemaWithType, name);
+      case "number" /* Number */:
+        return this.parseNumber(schemaWithType, name);
+      case "boolean" /* Boolean */:
+        return this.parseBoolean(schemaWithType, name);
+      default:
+        throw new Error(`Unknown schema type: ${schemaWithType.type}`);
+    }
+  }
+  parseObject(schema, name) {
+    const children = [];
+    for (const propName of Object.keys(schema.properties).sort((a, b) => a.localeCompare(b))) {
+      const propSchema = schema.properties[propName];
+      if (propSchema) {
+        children.push(this.parseNode(propSchema, propName));
+      }
+    }
+    return chunkA4E524UU_cjs.createObjectNode(
+      nanoid.nanoid(),
+      name,
+      children,
+      this.extractMetadata(schema)
+    );
+  }
+  parseArray(schema, name) {
+    const items = this.parseNode(schema.items, "items");
+    return chunkA4E524UU_cjs.createArrayNode(
+      nanoid.nanoid(),
+      name,
+      items,
+      this.extractMetadata(schema)
+    );
+  }
+  parseString(schema, name) {
+    const nodeId = nanoid.nanoid();
+    this.collectFormula(nodeId, schema["x-formula"]);
+    return chunkA4E524UU_cjs.createStringNode(nodeId, name, {
+      defaultValue: schema.default,
+      foreignKey: schema.foreignKey,
+      metadata: this.extractMetadata(schema)
+    });
+  }
+  parseNumber(schema, name) {
+    const nodeId = nanoid.nanoid();
+    this.collectFormula(nodeId, schema["x-formula"]);
+    return chunkA4E524UU_cjs.createNumberNode(nodeId, name, {
+      defaultValue: schema.default,
+      metadata: this.extractMetadata(schema)
+    });
+  }
+  parseBoolean(schema, name) {
+    const nodeId = nanoid.nanoid();
+    this.collectFormula(nodeId, schema["x-formula"]);
+    return chunkA4E524UU_cjs.createBooleanNode(nodeId, name, {
+      defaultValue: schema.default,
+      metadata: this.extractMetadata(schema)
+    });
+  }
+  extractMetadata(schema) {
+    const meta = {};
+    let hasValue = false;
+    if ("title" in schema && schema.title) {
+      meta.title = schema.title;
+      hasValue = true;
+    }
+    if ("description" in schema && schema.description) {
+      meta.description = schema.description;
+      hasValue = true;
+    }
+    if ("deprecated" in schema && schema.deprecated) {
+      meta.deprecated = schema.deprecated;
+      hasValue = true;
+    }
+    return hasValue ? meta : void 0;
+  }
+  collectFormula(nodeId, xFormula) {
+    if (xFormula) {
+      this.pendingFormulas.push({ nodeId, expression: xFormula.expression });
+    }
+  }
+};
+var NodeFactory = class {
+  createNode(name, type) {
+    switch (type) {
+      case "string":
+        return chunkA4E524UU_cjs.createStringNode(nanoid.nanoid(), name, { defaultValue: "" });
+      case "number":
+        return chunkA4E524UU_cjs.createNumberNode(nanoid.nanoid(), name, { defaultValue: 0 });
+      case "boolean":
+        return chunkA4E524UU_cjs.createBooleanNode(nanoid.nanoid(), name, { defaultValue: false });
+      case "object":
+        return chunkA4E524UU_cjs.createObjectNode(nanoid.nanoid(), name, []);
+      case "array":
+        return this.createArrayNode(name);
+      default:
+        throw new Error(`Unknown field type: ${type}`);
+    }
+  }
+  createArrayNode(name) {
+    const items = chunkA4E524UU_cjs.createStringNode(nanoid.nanoid(), "items", { defaultValue: "" });
+    return chunkA4E524UU_cjs.createArrayNode(nanoid.nanoid(), name, items);
+  }
+};
+
+// src/model/default-value/generateDefaultValue.ts
+var DEFAULT_STRING = "";
+var DEFAULT_NUMBER = 0;
+var DEFAULT_BOOLEAN = false;
+function isRefSchema(schema) {
+  return "$ref" in schema;
+}
+function isObjectSchema(schema) {
+  return "type" in schema && schema.type === "object" /* Object */;
+}
+function isArraySchema(schema) {
+  return "type" in schema && schema.type === "array" /* Array */;
+}
+function hasDefaultValue(schema) {
+  return "default" in schema && schema.default !== void 0;
+}
+function generatePrimitiveDefault(schema) {
+  if (!("type" in schema)) {
+    return void 0;
+  }
+  switch (schema.type) {
+    case "string" /* String */:
+      return DEFAULT_STRING;
+    case "number" /* Number */:
+      return DEFAULT_NUMBER;
+    case "boolean" /* Boolean */:
+      return DEFAULT_BOOLEAN;
+    default:
+      return void 0;
+  }
+}
+function generateObjectDefault(schema, options) {
+  const result = {};
+  if (!schema.properties) {
+    return result;
+  }
+  for (const [key, propertySchema] of Object.entries(schema.properties)) {
+    result[key] = generateDefaultValueInternal(propertySchema, options);
+  }
+  return result;
+}
+function generateArrayDefault(schema, options) {
+  const itemCount = options.arrayItemCount ?? 0;
+  if (itemCount === 0 || !schema.items) {
+    return [];
+  }
+  const itemDefault = generateDefaultValueInternal(schema.items, options);
+  return Array.from({ length: itemCount }, () => {
+    if (typeof itemDefault === "object" && itemDefault !== null) {
+      return generateDefaultValueInternal(schema.items, options);
+    }
+    return itemDefault;
+  });
+}
+function generateRefDefault(schema, options) {
+  const refSchemas = options.refSchemas;
+  if (!refSchemas) {
+    return {};
+  }
+  const refSchema = refSchemas[schema.$ref];
+  if (!refSchema) {
+    return {};
+  }
+  return generateDefaultValueInternal(refSchema, options);
+}
+function generateDefaultValueInternal(schema, options) {
+  if (hasDefaultValue(schema)) {
+    return schema.default;
+  }
+  if (isRefSchema(schema)) {
+    return generateRefDefault(schema, options);
+  }
+  if (isObjectSchema(schema)) {
+    return generateObjectDefault(schema, options);
+  }
+  if (isArraySchema(schema)) {
+    return generateArrayDefault(schema, options);
+  }
+  return generatePrimitiveDefault(schema);
+}
+function generateDefaultValue(schema, options = {}) {
+  if (!schema) {
+    return {};
+  }
+  return generateDefaultValueInternal(schema, options);
+}
+
+// src/model/schema-model/SchemaModelImpl.ts
+var SchemaModelImpl = class {
+  _baseTree;
+  _currentTree;
+  _reactivity;
+  _patchBuilder = new chunkA4E524UU_cjs.PatchBuilder();
+  _serializer = new chunkA4E524UU_cjs.SchemaSerializer();
+  _nodeFactory = new NodeFactory();
+  _formulaIndex = new chunkA4E524UU_cjs.FormulaDependencyIndex();
+  constructor(schema, options) {
+    const parser = new SchemaParser();
+    const rootNode = parser.parse(schema);
+    this._currentTree = chunkA4E524UU_cjs.createSchemaTree(rootNode);
+    parser.parseFormulas(this._currentTree);
+    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",
+        getPatches: "computed",
+        getJsonPatches: "computed",
+        getPlainSchema: "computed",
+        addField: "action",
+        removeField: "action",
+        renameField: "action",
+        changeFieldType: "action",
+        updateMetadata: "action",
+        updateFormula: "action",
+        updateForeignKey: "action",
+        updateDefaultValue: "action",
+        markAsSaved: "action",
+        revert: "action"
+      });
+    }
+  }
+  root() {
+    return this._currentTree.root();
+  }
+  nodeById(id) {
+    return this._currentTree.nodeById(id);
+  }
+  pathOf(id) {
+    return this._currentTree.pathOf(id);
+  }
+  addField(parentId, name, type) {
+    const node = this._nodeFactory.createNode(name, type);
+    this._currentTree.addChildTo(parentId, node);
+    return node;
+  }
+  removeField(nodeId) {
+    const path = this._currentTree.pathOf(nodeId);
+    if (path.isEmpty()) {
+      return false;
+    }
+    return this._currentTree.removeNodeAt(path);
+  }
+  renameField(nodeId, newName) {
+    const node = this._currentTree.nodeById(nodeId);
+    if (node.isNull()) {
+      return;
+    }
+    this._currentTree.renameNode(nodeId, newName);
+  }
+  changeFieldType(nodeId, newType) {
+    const node = this._currentTree.nodeById(nodeId);
+    if (node.isNull()) {
+      return node;
+    }
+    const path = this._currentTree.pathOf(nodeId);
+    if (path.isEmpty()) {
+      return node;
+    }
+    const newNode = this._nodeFactory.createNode(node.name(), newType);
+    this._currentTree.setNodeAt(path, newNode);
+    this._currentTree.trackReplacement(nodeId, newNode.id());
+    return newNode;
+  }
+  updateMetadata(nodeId, meta) {
+    const node = this._currentTree.nodeById(nodeId);
+    if (node.isNull()) {
+      return;
+    }
+    const currentMeta = node.metadata();
+    const newMeta = {
+      ...currentMeta,
+      ...meta
+    };
+    node.setMetadata(newMeta);
+  }
+  updateFormula(nodeId, expression) {
+    const node = this._currentTree.nodeById(nodeId);
+    if (node.isNull()) {
+      return;
+    }
+    if (expression === void 0) {
+      node.setFormula(void 0);
+      this._formulaIndex.unregisterFormula(nodeId);
+    } else {
+      const formula = new chunkA4E524UU_cjs.ParsedFormula(this._currentTree, nodeId, expression);
+      node.setFormula(formula);
+      this._formulaIndex.registerFormula(nodeId, formula);
+    }
+  }
+  updateForeignKey(nodeId, foreignKey) {
+    const node = this._currentTree.nodeById(nodeId);
+    if (node.isNull()) {
+      return;
+    }
+    node.setForeignKey(foreignKey);
+  }
+  updateDefaultValue(nodeId, value) {
+    const node = this._currentTree.nodeById(nodeId);
+    if (node.isNull()) {
+      return;
+    }
+    node.setDefaultValue(value);
+  }
+  isDirty() {
+    return this.getPatches().length > 0;
+  }
+  isValid() {
+    return this._currentTree.root().isObject();
+  }
+  getPatches() {
+    return this._patchBuilder.build(this._currentTree, this._baseTree);
+  }
+  getJsonPatches() {
+    return this.getPatches().map((p) => p.patch);
+  }
+  markAsSaved() {
+    this._baseTree = this._currentTree.clone();
+  }
+  revert() {
+    this._currentTree = this._baseTree.clone();
+  }
+  getPlainSchema() {
+    return this._serializer.serializeTree(this._currentTree);
+  }
+  generateDefaultValue(options) {
+    return generateDefaultValue(this.getPlainSchema(), options);
+  }
+  _buildFormulaIndex() {
+    this._formulaIndex.clear();
+    for (const nodeId of this._currentTree.nodeIds()) {
+      const node = this._currentTree.nodeById(nodeId);
+      const formula = node.formula();
+      if (formula) {
+        this._formulaIndex.registerFormula(nodeId, formula);
+      }
+    }
+  }
+};
+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, _reactivity) {
+    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"
+    });
+  }
+  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();
+  }
+  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();
+  }
+  setTableModel(tableModel) {
+    this._tableModel = tableModel;
+  }
+};
+
+// src/model/value-node/BaseValueNode.ts
+var nodeIdCounter = 0;
+function generateNodeId() {
+  return `node-${++nodeIdCounter}`;
+}
+function resetNodeIdCounter() {
+  nodeIdCounter = 0;
+}
+var BaseValueNode = class {
+  id;
+  schema;
+  _parent = null;
+  _name;
+  constructor(id, name, schema) {
+    this.id = id ?? generateNodeId();
+    this._name = name;
+    this.schema = schema;
+  }
+  get parent() {
+    return this._parent;
+  }
+  set parent(value) {
+    this._parent = value;
+  }
+  get name() {
+    return this._name;
+  }
+  isObject() {
+    return false;
+  }
+  isArray() {
+    return false;
+  }
+  isPrimitive() {
+    return false;
+  }
+  get errors() {
+    return [];
+  }
+  get warnings() {
+    return [];
+  }
+  get isValid() {
+    return this.errors.length === 0;
+  }
+  get hasWarnings() {
+    return this.warnings.length > 0;
+  }
+};
+
+// src/model/value-node/types.ts
+var ValueType = /* @__PURE__ */ ((ValueType2) => {
+  ValueType2["String"] = "string";
+  ValueType2["Number"] = "number";
+  ValueType2["Boolean"] = "boolean";
+  ValueType2["Object"] = "object";
+  ValueType2["Array"] = "array";
+  return ValueType2;
+})(ValueType || {});
+function extractFormulaDefinition(schema) {
+  if ("x-formula" in schema && schema["x-formula"]) {
+    const xFormula = schema["x-formula"];
+    return { expression: xFormula.expression, version: xFormula.version };
+  }
+  return void 0;
+}
+
+// src/model/value-node/ArrayValueNode.ts
+var ArrayValueNode = class extends BaseValueNode {
+  constructor(id, name, schema, items, reactivity) {
+    super(id, name, schema);
+    this.reactivity = reactivity;
+    this._items = reactivity?.observableArray() ?? [];
+    this._baseItems = [];
+    if (items) {
+      for (const item of items) {
+        item.parent = this;
+        this._items.push(item);
+      }
+    }
+    this._baseItems = [...this._items];
+    this.initObservable();
+  }
+  type = "array" /* Array */;
+  _items;
+  _baseItems;
+  _nodeFactory = null;
+  initObservable() {
+    if (!this.reactivity) {
+      return;
+    }
+    this.reactivity.makeObservable(this, {
+      _items: "observable",
+      _baseItems: "observable",
+      value: "computed",
+      length: "computed",
+      isDirty: "computed",
+      errors: "computed",
+      warnings: "computed",
+      push: "action",
+      insertAt: "action",
+      removeAt: "action",
+      move: "action",
+      replaceAt: "action",
+      clear: "action",
+      commit: "action",
+      revert: "action",
+      pushValue: "action",
+      insertValueAt: "action"
+    });
+  }
+  get value() {
+    return this._items;
+  }
+  get length() {
+    return this._items.length;
+  }
+  getPlainValue() {
+    return this._items.map((item) => item.getPlainValue());
+  }
+  at(index) {
+    if (index < 0) {
+      return this._items[this._items.length + index];
+    }
+    return this._items[index];
+  }
+  push(node) {
+    node.parent = this;
+    this._items.push(node);
+  }
+  insertAt(index, node) {
+    if (index < 0 || index > this._items.length) {
+      throw new Error(`Index out of bounds: ${index}`);
+    }
+    node.parent = this;
+    this._items.splice(index, 0, node);
+  }
+  removeAt(index) {
+    if (index < 0 || index >= this._items.length) {
+      throw new Error(`Index out of bounds: ${index}`);
+    }
+    const removed = this._items.splice(index, 1)[0];
+    if (removed) {
+      removed.parent = null;
+    }
+  }
+  move(fromIndex, toIndex) {
+    if (fromIndex < 0 || fromIndex >= this._items.length) {
+      throw new Error(`Source index out of bounds: ${fromIndex}`);
+    }
+    if (toIndex < 0 || toIndex >= this._items.length) {
+      throw new Error(`Target index out of bounds: ${toIndex}`);
+    }
+    if (fromIndex === toIndex) {
+      return;
+    }
+    const [item] = this._items.splice(fromIndex, 1);
+    if (item) {
+      this._items.splice(toIndex, 0, item);
+    }
+  }
+  replaceAt(index, node) {
+    if (index < 0 || index >= this._items.length) {
+      throw new Error(`Index out of bounds: ${index}`);
+    }
+    const oldNode = this._items[index];
+    if (oldNode) {
+      oldNode.parent = null;
+    }
+    node.parent = this;
+    this._items[index] = node;
+  }
+  clear() {
+    for (const item of this._items) {
+      item.parent = null;
+    }
+    this._items.length = 0;
+  }
+  setNodeFactory(factory) {
+    this._nodeFactory = factory;
+  }
+  pushValue(value) {
+    const node = this.createItemNode(this._items.length, value);
+    this.push(node);
+  }
+  insertValueAt(index, value) {
+    const node = this.createItemNode(index, value);
+    this.insertAt(index, node);
+  }
+  createItemNode(index, value) {
+    if (!this._nodeFactory) {
+      throw new Error("NodeFactory not set");
+    }
+    const arraySchema = this.schema;
+    const itemSchema = arraySchema.items;
+    if (!itemSchema) {
+      throw new Error("No items schema");
+    }
+    const itemValue = value === void 0 && "default" in itemSchema ? itemSchema.default : value;
+    const node = this._nodeFactory.create(String(index), itemSchema, itemValue);
+    this.propagateFactory(node);
+    return node;
+  }
+  propagateFactory(node) {
+    if (!this._nodeFactory) {
+      return;
+    }
+    if (node.isArray()) {
+      node.setNodeFactory(this._nodeFactory);
+      for (const item of node.value) {
+        this.propagateFactory(item);
+      }
+    } else if (node.isObject()) {
+      for (const child of node.children) {
+        this.propagateFactory(child);
+      }
+    }
+  }
+  get isDirty() {
+    if (this._items.length !== this._baseItems.length) {
+      return true;
+    }
+    for (let i = 0; i < this._items.length; i++) {
+      if (this._items[i] !== this._baseItems[i]) {
+        return true;
+      }
+    }
+    for (const item of this._items) {
+      if ("isDirty" in item && item.isDirty) {
+        return true;
+      }
+    }
+    return false;
+  }
+  commit() {
+    this._baseItems = [...this._items];
+    for (const item of this._items) {
+      if ("commit" in item && typeof item.commit === "function") {
+        item.commit();
+      }
+    }
+  }
+  revert() {
+    for (const item of this._items) {
+      item.parent = null;
+    }
+    this._items = this.reactivity?.observableArray() ?? [];
+    for (const baseItem of this._baseItems) {
+      this._items.push(baseItem);
+    }
+    for (const item of this._items) {
+      item.parent = this;
+      if ("revert" in item && typeof item.revert === "function") {
+        item.revert();
+      }
+    }
+  }
+  isArray() {
+    return true;
+  }
+  get errors() {
+    const errors = [];
+    for (const item of this._items) {
+      errors.push(...item.errors);
+    }
+    return errors;
+  }
+  get warnings() {
+    const warnings = [];
+    for (const item of this._items) {
+      warnings.push(...item.warnings);
+    }
+    return warnings;
+  }
+};
+
+// src/model/value-node/BasePrimitiveValueNode.ts
+var BasePrimitiveValueNode = class extends BaseValueNode {
+  constructor(id, name, schema, value, defaultValue, reactivity) {
+    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, {
+      _value: "observable",
+      _baseValue: "observable",
+      _formulaWarning: "observable",
+      value: "computed",
+      baseValue: "computed",
+      isDirty: "computed",
+      errors: "computed",
+      warnings: "computed",
+      setValue: "action",
+      setFormulaWarning: "action",
+      commit: "action",
+      revert: "action"
+    });
+  }
+  get value() {
+    return this._value;
+  }
+  set value(newValue) {
+    if (this.isReadOnly) {
+      throw new Error(`Cannot set value on read-only field: ${this.name}`);
+    }
+    this._value = newValue;
+  }
+  get baseValue() {
+    return this._baseValue;
+  }
+  get isDirty() {
+    return this._value !== this._baseValue;
+  }
+  get formula() {
+    return extractFormulaDefinition(this.schema);
+  }
+  get formulaWarning() {
+    return this._formulaWarning;
+  }
+  get isReadOnly() {
+    const readOnly = "readOnly" in this.schema ? this.schema.readOnly : false;
+    return readOnly === true || this.formula !== void 0;
+  }
+  getPlainValue() {
+    return this._value;
+  }
+  setValue(value, options) {
+    if (this.isReadOnly && !options?.internal) {
+      throw new Error(`Cannot set value on read-only field: ${this.name}`);
+    }
+    this._value = this.coerceValue(value);
+  }
+  setFormulaWarning(warning) {
+    this._formulaWarning = warning;
+  }
+  commit() {
+    this._baseValue = this._value;
+  }
+  revert() {
+    this._value = this._baseValue;
+  }
+  isPrimitive() {
+    return true;
+  }
+  get errors() {
+    return this.computeErrors();
+  }
+  computeErrors() {
+    return [];
+  }
+  get warnings() {
+    if (!this._formulaWarning) {
+      return [];
+    }
+    return [
+      {
+        severity: "warning",
+        type: this._formulaWarning.type,
+        message: this._formulaWarning.message,
+        path: this.name,
+        params: {
+          expression: this._formulaWarning.expression,
+          computedValue: this._formulaWarning.computedValue
+        }
+      }
+    ];
+  }
+};
+
+// 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);
+    this.initObservable();
+  }
+  get defaultValue() {
+    return "default" in this.schema ? this.schema.default : false;
+  }
+  coerceValue(value) {
+    if (typeof value === "boolean") {
+      return value;
+    }
+    return Boolean(value);
+  }
+};
+
+// src/model/foreign-key-resolver/errors.ts
+var ForeignKeyNotFoundError = class extends Error {
+  constructor(tableId, rowId) {
+    const message = rowId ? `Foreign key row not found: ${tableId}/${rowId}` : `Foreign key table not found: ${tableId}`;
+    super(message);
+    this.tableId = tableId;
+    this.rowId = rowId;
+    this.name = "ForeignKeyNotFoundError";
+  }
+};
+var ForeignKeyResolverNotConfiguredError = class extends Error {
+  constructor() {
+    super("ForeignKeyResolver is not configured with a loader");
+    this.name = "ForeignKeyResolverNotConfiguredError";
+  }
+};
+
+// 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);
+    this.initObservable();
+  }
+  get defaultValue() {
+    return "default" in this.schema ? this.schema.default : "";
+  }
+  coerceValue(value) {
+    if (typeof value === "string") {
+      return value;
+    }
+    if (value === null || value === void 0) {
+      return "";
+    }
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  }
+  computeErrors() {
+    const errors = [];
+    this.validateRequired(errors);
+    this.validateForeignKey(errors);
+    this.validateMinLength(errors);
+    this.validateMaxLength(errors);
+    this.validatePattern(errors);
+    this.validateEnum(errors);
+    return errors;
+  }
+  validateRequired(errors) {
+    const stringSchema = this.schema;
+    if ("required" in stringSchema && stringSchema.required && this._value === "") {
+      errors.push({
+        severity: "error",
+        type: "required",
+        message: "Field is required",
+        path: this.name
+      });
+    }
+  }
+  validateForeignKey(errors) {
+    const stringSchema = this.schema;
+    const foreignKey = stringSchema.foreignKey;
+    if (foreignKey && this._value === "") {
+      errors.push({
+        severity: "error",
+        type: "foreignKey",
+        message: `Reference to ${foreignKey} is required`,
+        path: this.name,
+        params: { table: foreignKey }
+      });
+    }
+  }
+  validateMinLength(errors) {
+    const stringSchema = this.schema;
+    const minLength = stringSchema.minLength;
+    if (minLength !== void 0 && this._value.length > 0 && this._value.length < minLength) {
+      errors.push({
+        severity: "error",
+        type: "minLength",
+        message: `Minimum length is ${minLength}`,
+        path: this.name,
+        params: { min: minLength, actual: this._value.length }
+      });
+    }
+  }
+  validateMaxLength(errors) {
+    const stringSchema = this.schema;
+    const maxLength = stringSchema.maxLength;
+    if (maxLength !== void 0 && this._value.length > maxLength) {
+      errors.push({
+        severity: "error",
+        type: "maxLength",
+        message: `Maximum length is ${maxLength}`,
+        path: this.name,
+        params: { max: maxLength, actual: this._value.length }
+      });
+    }
+  }
+  validatePattern(errors) {
+    const stringSchema = this.schema;
+    const pattern = stringSchema.pattern;
+    if (!pattern || this._value.length === 0) {
+      return;
+    }
+    try {
+      if (!new RegExp(pattern).test(this._value)) {
+        errors.push({
+          severity: "error",
+          type: "pattern",
+          message: "Value does not match pattern",
+          path: this.name,
+          params: { pattern }
+        });
+      }
+    } catch {
+      errors.push({
+        severity: "error",
+        type: "invalidPattern",
+        message: "Invalid regex pattern in schema",
+        path: this.name,
+        params: { pattern }
+      });
+    }
+  }
+  validateEnum(errors) {
+    const stringSchema = this.schema;
+    const enumValues = stringSchema.enum;
+    if (enumValues && enumValues.length > 0 && !enumValues.includes(this._value)) {
+      errors.push({
+        severity: "error",
+        type: "enum",
+        message: "Value is not in allowed list",
+        path: this.name,
+        params: { allowed: enumValues, actual: this._value }
+      });
+    }
+  }
+};
+
+// src/model/value-node/ForeignKeyValueNode.ts
+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);
+    this.fkResolver = fkResolver;
+    const schemaFk = "foreignKey" in schema && typeof schema.foreignKey === "string" ? schema.foreignKey : void 0;
+    if (!schemaFk) {
+      throw new Error("ForeignKeyValueNode requires a schema with foreignKey property");
+    }
+    this._foreignKey = schemaFk;
+  }
+  _foreignKey;
+  get foreignKey() {
+    return this._foreignKey;
+  }
+  get isLoading() {
+    if (!this.fkResolver || !this._value) {
+      return false;
+    }
+    return this.fkResolver.isLoadingRow(this._foreignKey, this._value);
+  }
+  async getRow() {
+    if (!this.fkResolver) {
+      throw new ForeignKeyResolverNotConfiguredError();
+    }
+    if (!this._value) {
+      throw new ForeignKeyNotFoundError(this._foreignKey, this._value);
+    }
+    return this.fkResolver.getRowData(this._foreignKey, this._value);
+  }
+  async getSchema() {
+    if (!this.fkResolver) {
+      throw new ForeignKeyResolverNotConfiguredError();
+    }
+    return this.fkResolver.getSchema(this._foreignKey);
+  }
+};
+
+// 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);
+    this.initObservable();
+  }
+  get defaultValue() {
+    return "default" in this.schema ? this.schema.default : 0;
+  }
+  coerceValue(value) {
+    if (typeof value === "number") {
+      return value;
+    }
+    return Number(value) || 0;
+  }
+  computeErrors() {
+    const errors = [];
+    if (!("type" in this.schema) || this.schema.type !== "number" /* Number */) {
+      return errors;
+    }
+    const numberSchema = this.schema;
+    const minimum = numberSchema.minimum;
+    if (minimum !== void 0 && this._value < minimum) {
+      errors.push({
+        severity: "error",
+        type: "min",
+        message: `Value must be at least ${minimum}`,
+        path: this.name,
+        params: { min: minimum, actual: this._value }
+      });
+    }
+    const maximum = numberSchema.maximum;
+    if (maximum !== void 0 && this._value > maximum) {
+      errors.push({
+        severity: "error",
+        type: "max",
+        message: `Value must be at most ${maximum}`,
+        path: this.name,
+        params: { max: maximum, actual: this._value }
+      });
+    }
+    const enumValues = numberSchema.enum;
+    if (enumValues && enumValues.length > 0 && !enumValues.includes(this._value)) {
+      errors.push({
+        severity: "error",
+        type: "enum",
+        message: "Value is not in allowed list",
+        path: this.name,
+        params: { allowed: enumValues, actual: this._value }
+      });
+    }
+    return errors;
+  }
+};
+
+// src/model/value-node/ObjectValueNode.ts
+var ObjectValueNode = class extends BaseValueNode {
+  constructor(id, name, schema, children, reactivity) {
+    super(id, name, schema);
+    this.reactivity = reactivity;
+    this._children = reactivity?.observableMap() ?? /* @__PURE__ */ new Map();
+    this._baseChildren = /* @__PURE__ */ new Map();
+    if (children) {
+      for (const child of children) {
+        this._children.set(child.name, child);
+        child.parent = this;
+      }
+    }
+    this._baseChildren = new Map(this._children);
+    this.initObservable();
+  }
+  type = "object" /* Object */;
+  _children;
+  _baseChildren;
+  initObservable() {
+    if (!this.reactivity) {
+      return;
+    }
+    this.reactivity.makeObservable(this, {
+      _children: "observable",
+      _baseChildren: "observable",
+      value: "computed",
+      children: "computed",
+      isDirty: "computed",
+      errors: "computed",
+      warnings: "computed",
+      addChild: "action",
+      removeChild: "action",
+      commit: "action",
+      revert: "action"
+    });
+  }
+  get value() {
+    return Object.fromEntries(this._children);
+  }
+  get children() {
+    return Array.from(this._children.values());
+  }
+  getPlainValue() {
+    const result = {};
+    for (const [key, node] of this._children) {
+      result[key] = node.getPlainValue();
+    }
+    return result;
+  }
+  child(name) {
+    return this._children.get(name);
+  }
+  hasChild(name) {
+    return this._children.has(name);
+  }
+  addChild(node) {
+    const existing = this._children.get(node.name);
+    if (existing) {
+      existing.parent = null;
+    }
+    node.parent = this;
+    this._children.set(node.name, node);
+  }
+  removeChild(name) {
+    const node = this._children.get(name);
+    if (node) {
+      node.parent = null;
+      this._children.delete(name);
+    }
+  }
+  get isDirty() {
+    if (this._children.size !== this._baseChildren.size) {
+      return true;
+    }
+    for (const [key, child] of this._children) {
+      if (this._baseChildren.get(key) !== child) {
+        return true;
+      }
+    }
+    for (const child of this._children.values()) {
+      if ("isDirty" in child && child.isDirty) {
+        return true;
+      }
+    }
+    return false;
+  }
+  commit() {
+    this._baseChildren = new Map(this._children);
+    for (const child of this._children.values()) {
+      if ("commit" in child && typeof child.commit === "function") {
+        child.commit();
+      }
+    }
+  }
+  revert() {
+    for (const child of this._children.values()) {
+      child.parent = null;
+    }
+    this._children = this.reactivity?.observableMap() ?? /* @__PURE__ */ new Map();
+    for (const [key, value] of this._baseChildren) {
+      this._children.set(key, value);
+    }
+    for (const child of this._children.values()) {
+      child.parent = this;
+      if ("revert" in child && typeof child.revert === "function") {
+        child.revert();
+      }
+    }
+  }
+  isObject() {
+    return true;
+  }
+  get errors() {
+    const errors = [];
+    for (const child of this._children.values()) {
+      errors.push(...child.errors);
+    }
+    return errors;
+  }
+  get warnings() {
+    const warnings = [];
+    for (const child of this._children.values()) {
+      warnings.push(...child.warnings);
+    }
+    return warnings;
+  }
+};
+
+// src/model/value-node/NodeFactory.ts
+var NodeFactoryRegistry = class {
+  factories = /* @__PURE__ */ new Map();
+  register(schemaType, factory) {
+    this.factories.set(schemaType, factory);
+    return this;
+  }
+  get(schemaType) {
+    return this.factories.get(schemaType);
+  }
+  has(schemaType) {
+    return this.factories.has(schemaType);
+  }
+};
+var NodeFactory2 = class {
+  constructor(registry, options) {
+    this.registry = registry;
+    this.refSchemas = options?.refSchemas;
+  }
+  refSchemas;
+  create(name, schema, value, id) {
+    const resolvedSchema = this.resolveSchema(schema);
+    const schemaType = this.getSchemaType(resolvedSchema);
+    const factory = this.registry.get(schemaType);
+    if (!factory) {
+      throw new Error(`Unknown schema type: ${schemaType}`);
+    }
+    return factory(name, resolvedSchema, value, id);
+  }
+  createTree(schema, value) {
+    return this.create("", schema, value);
+  }
+  getSchemaType(schema) {
+    if ("type" in schema) {
+      return schema.type;
+    }
+    return "object";
+  }
+  resolveSchema(schema) {
+    if (!("$ref" in schema) || !this.refSchemas) {
+      return schema;
+    }
+    const refSchema = schema;
+    const resolved = this.refSchemas[refSchema.$ref];
+    if (!resolved) {
+      return schema;
+    }
+    return {
+      ...resolved,
+      $ref: refSchema.$ref,
+      title: refSchema.title ?? ("title" in resolved ? resolved.title : void 0),
+      description: refSchema.description ?? ("description" in resolved ? resolved.description : void 0),
+      deprecated: refSchema.deprecated ?? ("deprecated" in resolved ? resolved.deprecated : void 0)
+    };
+  }
+};
+function createStringFactory(reactivity, fkResolver) {
+  return (name, schema, value, id) => {
+    const stringSchema = schema;
+    if (stringSchema.foreignKey) {
+      return new ForeignKeyValueNodeImpl(
+        id,
+        name,
+        schema,
+        value,
+        reactivity,
+        fkResolver
+      );
+    }
+    return new StringValueNode(
+      id,
+      name,
+      schema,
+      value,
+      reactivity
+    );
+  };
+}
+function createNumberFactory(reactivity) {
+  return (name, schema, value, id) => {
+    return new NumberValueNode(
+      id,
+      name,
+      schema,
+      value,
+      reactivity
+    );
+  };
+}
+function createBooleanFactory(reactivity) {
+  return (name, schema, value, id) => {
+    return new BooleanValueNode(
+      id,
+      name,
+      schema,
+      value,
+      reactivity
+    );
+  };
+}
+function createObjectFactory(nodeFactory, reactivity) {
+  return (name, schema, value, id) => {
+    const objValue = value ?? {};
+    const children = [];
+    const objectSchema = schema;
+    const properties = objectSchema.properties ?? {};
+    for (const [propName, propSchema] of Object.entries(properties)) {
+      const propValue = objValue[propName];
+      const childNode = nodeFactory.create(propName, propSchema, propValue);
+      children.push(childNode);
+    }
+    return new ObjectValueNode(id, name, schema, children, reactivity);
+  };
+}
+function createArrayFactory(nodeFactory, reactivity) {
+  return (name, schema, value, id) => {
+    const arrValue = value ?? [];
+    const arraySchema = schema;
+    const itemSchema = arraySchema.items ?? { type: "string", default: "" };
+    const items = [];
+    for (let i = 0; i < arrValue.length; i++) {
+      const itemValue = arrValue[i];
+      const itemNode = nodeFactory.create(String(i), itemSchema, itemValue);
+      items.push(itemNode);
+    }
+    const arrayNode = new ArrayValueNode(id, name, schema, items, reactivity);
+    arrayNode.setNodeFactory(nodeFactory);
+    return arrayNode;
+  };
+}
+function createDefaultRegistry(reactivity, fkResolver) {
+  const registry = new NodeFactoryRegistry();
+  registry.register("string", createStringFactory(reactivity, fkResolver));
+  registry.register("number", createNumberFactory(reactivity));
+  registry.register("boolean", createBooleanFactory(reactivity));
+  return registry;
+}
+function createNodeFactory(options) {
+  const registry = createDefaultRegistry(options?.reactivity, options?.fkResolver);
+  const factory = new NodeFactory2(registry, options);
+  registry.register("object", createObjectFactory(factory, options?.reactivity));
+  registry.register("array", createArrayFactory(factory, options?.reactivity));
+  return factory;
+}
+
+// src/core/value-path/ValuePathSegment.ts
+var PropertySegment = class {
+  constructor(name) {
+    this.name = name;
+  }
+  isProperty() {
+    return true;
+  }
+  isIndex() {
+    return false;
+  }
+  propertyName() {
+    return this.name;
+  }
+  indexValue() {
+    throw new Error("Property segment has no index value");
+  }
+  equals(other) {
+    return other.isProperty() && other.propertyName() === this.name;
+  }
+};
+var IndexSegment = class {
+  constructor(index) {
+    this.index = index;
+  }
+  isProperty() {
+    return false;
+  }
+  isIndex() {
+    return true;
+  }
+  propertyName() {
+    throw new Error("Index segment has no property name");
+  }
+  indexValue() {
+    return this.index;
+  }
+  equals(other) {
+    return other.isIndex() && other.indexValue() === this.index;
+  }
+};
+
+// src/core/value-path/ValuePath.ts
+var ValuePathImpl = class _ValuePathImpl extends chunkA4E524UU_cjs.AbstractBasePath {
+  asString() {
+    const parts = [];
+    for (const seg of this.segs) {
+      if (seg.isProperty()) {
+        if (parts.length > 0) {
+          parts.push(".");
+        }
+        parts.push(seg.propertyName());
+      } else if (seg.isIndex()) {
+        parts.push(`[${seg.indexValue()}]`);
+      }
+    }
+    return parts.join("");
+  }
+  parent() {
+    if (this.segs.length <= 1) {
+      return EMPTY_VALUE_PATH;
+    }
+    return new _ValuePathImpl(this.segs.slice(0, -1));
+  }
+  child(name) {
+    return new _ValuePathImpl([...this.segs, new PropertySegment(name)]);
+  }
+  childIndex(index) {
+    return new _ValuePathImpl([...this.segs, new IndexSegment(index)]);
+  }
+};
+var EMPTY_VALUE_PATH = new ValuePathImpl([]);
+
+// src/core/value-path/ValuePathParser.ts
+function parseIndexSegment(path, startIndex) {
+  let i = startIndex;
+  let indexStr = "";
+  while (i < path.length && path[i] !== "]") {
+    indexStr += path[i];
+    i++;
+  }
+  if (path[i] !== "]") {
+    throw new Error(`Invalid path: missing closing bracket in "${path}"`);
+  }
+  if (indexStr === "" || !/^\d+$/.test(indexStr)) {
+    throw new Error(
+      `Invalid path: index must be a non-negative integer, got "${indexStr}" in "${path}"`
+    );
+  }
+  return {
+    segment: new IndexSegment(Number.parseInt(indexStr, 10)),
+    nextIndex: i + 1
+  };
+}
+function pushPropertyIfNotEmpty(segments, current) {
+  if (current) {
+    segments.push(new PropertySegment(current));
+  }
+}
+function parseValuePath(path) {
+  if (!path) {
+    return [];
+  }
+  const segments = [];
+  let current = "";
+  let i = 0;
+  while (i < path.length) {
+    const char = path[i];
+    if (char === ".") {
+      pushPropertyIfNotEmpty(segments, current);
+      current = "";
+      i++;
+    } else if (char === "[") {
+      pushPropertyIfNotEmpty(segments, current);
+      current = "";
+      const result = parseIndexSegment(path, i + 1);
+      segments.push(result.segment);
+      i = result.nextIndex;
+    } else {
+      current += char;
+      i++;
+    }
+  }
+  pushPropertyIfNotEmpty(segments, current);
+  return segments;
+}
+
+// src/model/value-tree/ValueTree.ts
+var ValueTree = class {
+  constructor(_root, _reactivity) {
+    this._root = _root;
+    this._reactivity = _reactivity;
+    this.initObservable();
+  }
+  initObservable() {
+    this._reactivity?.makeObservable(this, {
+      isDirty: "computed",
+      isValid: "computed",
+      errors: "computed",
+      commit: "action",
+      revert: "action"
+    });
+  }
+  get root() {
+    return this._root;
+  }
+  get(path) {
+    const segments = parseValuePath(path);
+    if (segments.length === 0) {
+      return this._root;
+    }
+    let current = this._root;
+    for (const segment of segments) {
+      if (!current) {
+        return void 0;
+      }
+      if (segment.isProperty() && current.isObject()) {
+        current = current.child(segment.propertyName());
+      } else if (segment.isIndex() && current.isArray()) {
+        current = current.at(segment.indexValue());
+      } else {
+        return void 0;
+      }
+    }
+    return current;
+  }
+  getValue(path) {
+    const node = this.get(path);
+    return node?.getPlainValue();
+  }
+  setValue(path, value) {
+    const node = this.get(path);
+    if (!node) {
+      throw new Error(`Path not found: ${path}`);
+    }
+    if (!node.isPrimitive()) {
+      throw new Error(`Cannot set value on non-primitive node: ${path}`);
+    }
+    node.setValue(value);
+  }
+  getPlainValue() {
+    return this._root.getPlainValue();
+  }
+  get isDirty() {
+    const root = this._root;
+    if ("isDirty" in root) {
+      return root.isDirty;
+    }
+    return false;
+  }
+  get isValid() {
+    return this.errors.length === 0;
+  }
+  get errors() {
+    return this._root.errors;
+  }
+  getPatches() {
+    return [];
+  }
+  commit() {
+    const root = this._root;
+    if ("commit" in root && typeof root.commit === "function") {
+      root.commit();
+    }
+  }
+  revert() {
+    const root = this._root;
+    if ("revert" in root && typeof root.revert === "function") {
+      root.revert();
+    }
+  }
+};
+
+// src/model/table/TableModelImpl.ts
+var TableModelImpl = class {
+  _tableId;
+  _baseTableId;
+  _schema;
+  _rows;
+  _jsonSchema;
+  _reactivity;
+  _fkResolver;
+  constructor(options, reactivity) {
+    this._tableId = options.tableId;
+    this._baseTableId = options.tableId;
+    this._jsonSchema = options.schema;
+    this._schema = createSchemaModel(options.schema, { reactivity });
+    this._reactivity = reactivity;
+    this._fkResolver = options.fkResolver;
+    this._rows = reactivity?.observableArray() ?? [];
+    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"
+    });
+  }
+  get tableId() {
+    return this._tableId;
+  }
+  get baseTableId() {
+    return this._baseTableId;
+  }
+  get isRenamed() {
+    return this._tableId !== this._baseTableId;
+  }
+  get fk() {
+    return this._fkResolver;
+  }
+  get schema() {
+    return this._schema;
+  }
+  get rows() {
+    return this._rows;
+  }
+  get rowCount() {
+    return this._rows.length;
+  }
+  rename(newTableId) {
+    this._tableId = newTableId;
+  }
+  addRow(rowId, data) {
+    if (this.getRow(rowId)) {
+      throw new Error(`Row with id already exists: ${rowId}`);
+    }
+    const rowModel = this.createRowModel(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);
+    }
+  }
+  getRow(rowId) {
+    return this._rows.find((row) => row.rowId === rowId);
+  }
+  getRowIndex(rowId) {
+    return this._rows.findIndex((row) => row.rowId === rowId);
+  }
+  getRowAt(index) {
+    return this._rows[index];
+  }
+  get isDirty() {
+    if (this.isRenamed) {
+      return true;
+    }
+    if (this._schema.isDirty()) {
+      return true;
+    }
+    for (const row of this._rows) {
+      if (row.isDirty) {
+        return true;
+      }
+    }
+    return false;
+  }
+  commit() {
+    this._baseTableId = this._tableId;
+    this._schema.markAsSaved();
+    for (const row of this._rows) {
+      row.commit();
+    }
+  }
+  revert() {
+    this._tableId = this._baseTableId;
+    this._schema.revert();
+    for (const row of this._rows) {
+      row.revert();
+    }
+  }
+  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);
+    rowModel.setTableModel(this);
+    return rowModel;
+  }
+};
+function createTableModel(options, reactivity) {
+  return new TableModelImpl(options, reactivity);
+}
+
+// src/model/foreign-key-resolver/ForeignKeyResolverImpl.ts
+var ForeignKeyResolverImpl = class {
+  _schemaCache;
+  _tableCache;
+  _loadingTables;
+  _loadingRows;
+  _pendingTableLoads;
+  _pendingRowLoads;
+  _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._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"
+    });
+  }
+  get isPrefetchEnabled() {
+    return this._prefetchEnabled;
+  }
+  setPrefetch(enabled) {
+    this._prefetchEnabled = enabled;
+  }
+  hasSchema(tableId) {
+    return this._schemaCache.has(tableId) || this._tableCache.has(tableId);
+  }
+  hasTable(tableId) {
+    return this._tableCache.has(tableId);
+  }
+  hasRow(tableId, rowId) {
+    const table = this._tableCache.get(tableId);
+    return table?.rows.has(rowId) ?? false;
+  }
+  isLoading(tableId) {
+    return this._loadingTables.has(tableId);
+  }
+  isLoadingRow(tableId, rowId) {
+    const rowSet = this._loadingRows.get(tableId);
+    return rowSet?.has(rowId) ?? false;
+  }
+  addSchema(tableId, schema) {
+    if (this._disposed) {
+      return;
+    }
+    if (this.reactivity) {
+      this.reactivity.runInAction(() => {
+        this._schemaCache.set(tableId, schema);
+      });
+    } else {
+      this._schemaCache.set(tableId, schema);
+    }
+  }
+  addTable(tableId, schema, rows) {
+    if (this._disposed) {
+      return;
+    }
+    const rowMap = this.reactivity?.observableMap() ?? /* @__PURE__ */ new 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 {
+      this._tableCache.set(tableId, cache);
+      this._schemaCache.set(tableId, schema);
+    }
+    if (this._prefetchEnabled) {
+      this.prefetchForeignKeysFromTable(tableId, schema, rows);
+    }
+  }
+  addRow(tableId, rowId, data) {
+    if (this._disposed) {
+      return;
+    }
+    const table = this._tableCache.get(tableId);
+    if (table) {
+      const rowData = { rowId, data };
+      if (this.reactivity) {
+        this.reactivity.runInAction(() => {
+          table.rows.set(rowId, rowData);
+        });
+      } else {
+        table.rows.set(rowId, rowData);
+      }
+      if (this._prefetchEnabled) {
+        this.prefetchForeignKeysFromRow(tableId, table.schema, data);
+      }
+    }
+  }
+  renameTable(oldTableId, newTableId) {
+    if (this._disposed) {
+      return;
+    }
+    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 {
+      if (schema) {
+        this._schemaCache.delete(oldTableId);
+        this._schemaCache.set(newTableId, schema);
+      }
+      if (tableCache) {
+        this._tableCache.delete(oldTableId);
+        this._tableCache.set(newTableId, tableCache);
+      }
+    }
+  }
+  async getSchema(tableId) {
+    const cachedSchema = this._schemaCache.get(tableId);
+    if (cachedSchema) {
+      return cachedSchema;
+    }
+    const cachedTable = this._tableCache.get(tableId);
+    if (cachedTable) {
+      return cachedTable.schema;
+    }
+    if (!this.loader) {
+      throw new ForeignKeyNotFoundError(tableId);
+    }
+    const pending = this._pendingTableLoads.get(tableId);
+    if (pending) {
+      return pending;
+    }
+    const loadPromise = this.loadSchemaInternal(tableId);
+    this._pendingTableLoads.set(tableId, loadPromise);
+    try {
+      return await loadPromise;
+    } finally {
+      this._pendingTableLoads.delete(tableId);
+    }
+  }
+  async getRowData(tableId, rowId) {
+    const table = this._tableCache.get(tableId);
+    if (table) {
+      const row = table.rows.get(rowId);
+      if (row) {
+        return row;
+      }
+    }
+    if (!this.loader) {
+      throw new ForeignKeyNotFoundError(tableId, rowId);
+    }
+    const tableLoads = this._pendingRowLoads.get(tableId);
+    const pending = tableLoads?.get(rowId);
+    if (pending) {
+      return pending;
+    }
+    const loadPromise = this.loadRowInternal(tableId, rowId);
+    this.setPendingRowLoad(tableId, rowId, loadPromise);
+    try {
+      return await loadPromise;
+    } finally {
+      this.clearPendingRowLoad(tableId, rowId);
+    }
+  }
+  dispose() {
+    this._disposed = true;
+    this._schemaCache.clear();
+    this._tableCache.clear();
+    this._loadingTables.clear();
+    this._loadingRows.clear();
+    this._pendingTableLoads.clear();
+    this._pendingRowLoads.clear();
+  }
+  async loadSchemaInternal(tableId) {
+    if (!this.loader) {
+      throw new ForeignKeyResolverNotConfiguredError();
+    }
+    this._loadingTables.add(tableId);
+    try {
+      const schema = await this.loader.loadSchema(tableId);
+      if (!this._disposed) {
+        this.addSchema(tableId, schema);
+      }
+      return schema;
+    } finally {
+      this._loadingTables.delete(tableId);
+    }
+  }
+  async loadRowInternal(tableId, rowId) {
+    if (!this.loader) {
+      throw new ForeignKeyResolverNotConfiguredError();
+    }
+    this.markRowAsLoading(tableId, rowId);
+    try {
+      const result = await this.loader.loadRow(tableId, rowId);
+      if (!this._disposed) {
+        this.addSchema(tableId, result.schema);
+        this.ensureTableCache(tableId, result.schema);
+        this.addRow(tableId, rowId, result.row.data);
+      }
+      return result.row;
+    } finally {
+      this.clearRowLoading(tableId, rowId);
+    }
+  }
+  ensureTableCache(tableId, schema) {
+    if (!this._tableCache.has(tableId)) {
+      const rowMap = this.reactivity?.observableMap() ?? /* @__PURE__ */ new Map();
+      const cache = { schema, rows: rowMap };
+      if (this.reactivity) {
+        this.reactivity.runInAction(() => {
+          this._tableCache.set(tableId, cache);
+        });
+      } else {
+        this._tableCache.set(tableId, cache);
+      }
+    }
+  }
+  markRowAsLoading(tableId, rowId) {
+    let rowSet = this._loadingRows.get(tableId);
+    if (!rowSet) {
+      rowSet = /* @__PURE__ */ new Set();
+      this._loadingRows.set(tableId, rowSet);
+    }
+    rowSet.add(rowId);
+  }
+  clearRowLoading(tableId, rowId) {
+    const rowSet = this._loadingRows.get(tableId);
+    if (rowSet) {
+      rowSet.delete(rowId);
+      if (rowSet.size === 0) {
+        this._loadingRows.delete(tableId);
+      }
+    }
+  }
+  setPendingRowLoad(tableId, rowId, promise) {
+    let tableLoads = this._pendingRowLoads.get(tableId);
+    if (!tableLoads) {
+      tableLoads = /* @__PURE__ */ new Map();
+      this._pendingRowLoads.set(tableId, tableLoads);
+    }
+    tableLoads.set(rowId, promise);
+  }
+  clearPendingRowLoad(tableId, rowId) {
+    const tableLoads = this._pendingRowLoads.get(tableId);
+    if (tableLoads) {
+      tableLoads.delete(rowId);
+      if (tableLoads.size === 0) {
+        this._pendingRowLoads.delete(tableId);
+      }
+    }
+  }
+  prefetchForeignKeysFromTable(sourceTableId, schema, rows) {
+    for (const row of rows) {
+      this.prefetchForeignKeysFromRow(sourceTableId, schema, row.data);
+    }
+  }
+  prefetchForeignKeysFromRow(_sourceTableId, schema, data) {
+    const foreignKeys = this.extractForeignKeys(schema);
+    if (foreignKeys.length === 0) {
+      return;
+    }
+    const dataObj = data;
+    const properties = schema.properties;
+    for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+      const fk = this.getForeignKeyFromSchema(fieldSchema);
+      if (!fk) {
+        continue;
+      }
+      const fieldValue = dataObj[fieldName];
+      if (typeof fieldValue !== "string" || !fieldValue) {
+        continue;
+      }
+      if (!this.hasRow(fk, fieldValue) && !this.isLoadingRow(fk, fieldValue)) {
+        this.prefetchRow(fk, fieldValue);
+      }
+    }
+  }
+  prefetchRow(tableId, rowId) {
+    if (!this.loader) {
+      return;
+    }
+    const prefetchPromise = this.getRowData(tableId, rowId);
+    prefetchPromise.catch(() => {
+    });
+  }
+  extractForeignKeys(schema) {
+    const foreignKeys = [];
+    for (const fieldSchema of Object.values(schema.properties)) {
+      const fk = this.getForeignKeyFromSchema(fieldSchema);
+      if (fk) {
+        foreignKeys.push(fk);
+      }
+    }
+    return foreignKeys;
+  }
+  getForeignKeyFromSchema(schema) {
+    if ("type" in schema && schema.type === "string" /* String */) {
+      return schema.foreignKey;
+    }
+    return void 0;
+  }
+};
+function createForeignKeyResolver(options) {
+  return new ForeignKeyResolverImpl(options);
+}
+
+// src/model/data-model/DataModelImpl.ts
+var DataModelImpl = class {
+  _tables;
+  _fk;
+  _ownsFkResolver;
+  _reactivity;
+  constructor(options) {
+    this._reactivity = options?.reactivity;
+    this._tables = this._reactivity?.observableMap() ?? /* @__PURE__ */ new Map();
+    if (options?.fkResolver) {
+      this._fk = options.fkResolver;
+      this._ownsFkResolver = false;
+    } else {
+      this._fk = createForeignKeyResolver({ reactivity: this._reactivity });
+      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"
+    });
+  }
+  get fk() {
+    return this._fk;
+  }
+  get tables() {
+    return Array.from(this._tables.values());
+  }
+  get tableIds() {
+    return Array.from(this._tables.keys());
+  }
+  get isDirty() {
+    for (const table of this._tables.values()) {
+      if (table.isDirty) {
+        return true;
+      }
+    }
+    return false;
+  }
+  hasTable(tableId) {
+    return this._tables.has(tableId);
+  }
+  getTable(tableId) {
+    return this._tables.get(tableId);
+  }
+  addTable(tableId, schema, rows) {
+    const tableModel = createTableModel(
+      {
+        tableId,
+        schema,
+        rows,
+        fkResolver: this._fk
+      },
+      this._reactivity
+    );
+    this._tables.set(tableId, tableModel);
+    this._fk.addSchema(tableId, schema);
+    if (rows && rows.length > 0) {
+      this._fk.addTable(tableId, schema, rows);
+    }
+    return tableModel;
+  }
+  removeTable(tableId) {
+    this._tables.delete(tableId);
+  }
+  renameTable(oldTableId, newTableId) {
+    const table = this._tables.get(oldTableId);
+    if (!table) {
+      return;
+    }
+    if (this._tables.has(newTableId)) {
+      throw new Error(`Table with id '${newTableId}' already exists`);
+    }
+    table.rename(newTableId);
+    this._tables.delete(oldTableId);
+    this._tables.set(newTableId, table);
+    this._fk.renameTable(oldTableId, newTableId);
+  }
+  commit() {
+    for (const table of this._tables.values()) {
+      table.commit();
+    }
+  }
+  revert() {
+    for (const table of this._tables.values()) {
+      table.revert();
+    }
+  }
+  dispose() {
+    this._tables.clear();
+    if (this._ownsFkResolver) {
+      this._fk.dispose();
+    }
+  }
+};
+function createDataModel(options) {
+  return new DataModelImpl(options);
+}
+
+exports.ArrayValueNode = ArrayValueNode;
+exports.BasePrimitiveValueNode = BasePrimitiveValueNode;
+exports.BaseValueNode = BaseValueNode;
+exports.BooleanValueNode = BooleanValueNode;
+exports.DataModelImpl = DataModelImpl;
+exports.ForeignKeyNotFoundError = ForeignKeyNotFoundError;
+exports.ForeignKeyResolverImpl = ForeignKeyResolverImpl;
+exports.ForeignKeyResolverNotConfiguredError = ForeignKeyResolverNotConfiguredError;
+exports.ForeignKeyValueNodeImpl = ForeignKeyValueNodeImpl;
+exports.NodeFactory = NodeFactory;
+exports.NodeFactory2 = NodeFactory2;
+exports.NodeFactoryRegistry = NodeFactoryRegistry;
+exports.NumberValueNode = NumberValueNode;
+exports.ObjectValueNode = ObjectValueNode;
+exports.RowModelImpl = RowModelImpl;
+exports.SchemaParser = SchemaParser;
+exports.StringValueNode = StringValueNode;
+exports.TableModelImpl = TableModelImpl;
+exports.ValueType = ValueType;
+exports.createDataModel = createDataModel;
+exports.createDefaultRegistry = createDefaultRegistry;
+exports.createForeignKeyResolver = createForeignKeyResolver;
+exports.createNodeFactory = createNodeFactory;
+exports.createSchemaModel = createSchemaModel;
+exports.createTableModel = createTableModel;
+exports.extractFormulaDefinition = extractFormulaDefinition;
+exports.generateDefaultValue = generateDefaultValue;
+exports.generateNodeId = generateNodeId;
+exports.isForeignKeyValueNode = isForeignKeyValueNode;
+exports.resetNodeIdCounter = resetNodeIdCounter;
+//# sourceMappingURL=chunk-5WZ4YPH5.cjs.map
+//# sourceMappingURL=chunk-5WZ4YPH5.cjs.map