@revisium/schema-toolkit 0.16.1 → 0.16.3

package/dist/{chunk-S7GEDTSL.js → chunk-PGR2S2BR.js}

@@ -1,4 +1,4 @@
-import { parseFormula, replaceDependencies, serializeAst } from '@revisium/formula';
+import { replaceDependencies, serializeAst, parseFormula } from '@revisium/formula';
 
 // src/core/schema-node/types.ts
 var EMPTY_METADATA = Object.freeze({});
@@ -79,9 +79,104 @@ var NullNodeImpl = class {
   }
   setForeignKey(_key) {
   }
+  contentMediaType() {
+    return void 0;
+  }
+  setContentMediaType(_mediaType) {
+  }
 };
 var NULL_NODE = new NullNodeImpl();
 
+// src/core/reactivity/provider.ts
+var noopProvider = {
+  makeObservable: (target) => target,
+  makeAutoObservable: (target) => target,
+  isObservable: () => false,
+  observable: {
+    map: () => /* @__PURE__ */ new Map(),
+    array: () => []
+  },
+  runInAction: (fn) => fn(),
+  reaction: () => () => {
+  }
+};
+var currentProvider = noopProvider;
+function setReactivityProvider(provider) {
+  currentProvider = provider;
+}
+function getReactivityProvider() {
+  return currentProvider;
+}
+function resetReactivityProvider() {
+  currentProvider = noopProvider;
+}
+
+// src/core/reactivity/api.ts
+function makeObservable(target, annotations) {
+  return getReactivityProvider().makeObservable(target, annotations);
+}
+function makeAutoObservable(target, overrides) {
+  return getReactivityProvider().makeAutoObservable(target, overrides ?? {});
+}
+var observable = {
+  map() {
+    return getReactivityProvider().observable.map();
+  },
+  array() {
+    return getReactivityProvider().observable.array();
+  }
+};
+function runInAction(fn) {
+  return getReactivityProvider().runInAction(fn);
+}
+function reaction(expression, effect) {
+  return getReactivityProvider().reaction(expression, effect);
+}
+
+// src/core/reactivity/mobx-provider.ts
+function convertAnnotations(mobx, annotations) {
+  const result = {};
+  for (const [key, value] of Object.entries(annotations)) {
+    if (typeof value === "string") {
+      switch (value) {
+        case "observable":
+          result[key] = mobx.observable;
+          break;
+        case "observable.ref":
+          result[key] = mobx.observable.ref;
+          break;
+        case "observable.shallow":
+          result[key] = mobx.observable.shallow;
+          break;
+        case "action":
+          result[key] = mobx.action;
+          break;
+        case "computed":
+          result[key] = mobx.computed;
+          break;
+        default:
+          result[key] = value;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function createMobxProvider(mobx) {
+  return {
+    makeObservable: (target, annotations) => mobx.makeObservable(target, convertAnnotations(mobx, annotations)),
+    makeAutoObservable: (target, overrides) => mobx.makeAutoObservable(target, overrides ? convertAnnotations(mobx, overrides) : {}),
+    isObservable: mobx.isObservable,
+    observable: {
+      map: () => mobx.observable.map(),
+      array: () => mobx.observable.array()
+    },
+    runInAction: mobx.runInAction,
+    reaction: mobx.reaction
+  };
+}
+
 // src/core/schema-node/BaseNode.ts
 var BaseNode = class {
   constructor(_id, name, metadata = EMPTY_METADATA) {
@@ -91,6 +186,14 @@ var BaseNode = class {
   }
   _name;
   _metadata;
+  initBaseObservable() {
+    makeObservable(this, {
+      _name: "observable",
+      _metadata: "observable.ref",
+      setName: "action",
+      setMetadata: "action"
+    });
+  }
   id() {
     return this._id;
   }
@@ -139,6 +242,9 @@ var BaseNode = class {
   foreignKey() {
     return void 0;
   }
+  contentMediaType() {
+    return void 0;
+  }
   setName(name) {
     this._name = name;
   }
@@ -161,6 +267,8 @@ var BaseNode = class {
   }
   setForeignKey(_key) {
   }
+  setContentMediaType(_mediaType) {
+  }
 };
 
 // src/core/schema-node/ObjectNode.ts
@@ -169,6 +277,13 @@ var ObjectNode = class _ObjectNode extends BaseNode {
   constructor(id, name, children = [], metadata = EMPTY_METADATA) {
     super(id, name, metadata);
     this._children = [...children];
+    this.initBaseObservable();
+    makeObservable(this, {
+      _children: "observable.shallow",
+      addChild: "action",
+      removeChild: "action",
+      replaceChild: "action"
+    });
   }
   nodeType() {
     return "object";
@@ -220,6 +335,11 @@ var ArrayNode = class _ArrayNode extends BaseNode {
   constructor(id, name, items, metadata = EMPTY_METADATA) {
     super(id, name, metadata);
     this._items = items;
+    this.initBaseObservable();
+    makeObservable(this, {
+      _items: "observable.ref",
+      setItems: "action"
+    });
   }
   nodeType() {
     return "array";
@@ -260,6 +380,20 @@ var PrimitiveNode = class extends BaseNode {
     this._foreignKey = options.foreignKey;
     this._formula = options.formula;
   }
+  initPrimitiveObservable() {
+    makeObservable(this, {
+      _name: "observable",
+      _metadata: "observable.ref",
+      _formula: "observable.ref",
+      _defaultValue: "observable",
+      _foreignKey: "observable",
+      setName: "action",
+      setMetadata: "action",
+      setFormula: "action",
+      setDefaultValue: "action",
+      setForeignKey: "action"
+    });
+  }
   isPrimitive() {
     return true;
   }
@@ -288,12 +422,25 @@ var PrimitiveNode = class extends BaseNode {
 
 // src/core/schema-node/StringNode.ts
 var StringNode = class _StringNode extends PrimitiveNode {
+  _contentMediaType;
   constructor(id, name, options = {}) {
     super(id, name, options);
+    this._contentMediaType = options.contentMediaType;
+    this.initPrimitiveObservable();
+    makeObservable(this, {
+      _contentMediaType: "observable",
+      setContentMediaType: "action"
+    });
   }
   nodeType() {
     return "string";
   }
+  contentMediaType() {
+    return this._contentMediaType;
+  }
+  setContentMediaType(mediaType) {
+    this._contentMediaType = mediaType;
+  }
   clone() {
     return new _StringNode(this.id(), this.name(), this.cloneOptions());
   }
@@ -302,7 +449,8 @@ var StringNode = class _StringNode extends PrimitiveNode {
       defaultValue: this._defaultValue,
       foreignKey: this._foreignKey,
       formula: this._formula,
-      metadata: this._metadata
+      metadata: this._metadata,
+      contentMediaType: this._contentMediaType
     };
   }
 };
@@ -314,6 +462,7 @@ function createStringNode(id, name, options = {}) {
 var NumberNode = class _NumberNode extends PrimitiveNode {
   constructor(id, name, options = {}) {
     super(id, name, options);
+    this.initPrimitiveObservable();
   }
   nodeType() {
     return "number";
@@ -337,6 +486,7 @@ function createNumberNode(id, name, options = {}) {
 var BooleanNode = class _BooleanNode extends PrimitiveNode {
   constructor(id, name, options = {}) {
     super(id, name, options);
+    this.initPrimitiveObservable();
   }
   nodeType() {
     return "boolean";
@@ -365,6 +515,7 @@ var RefNode = class _RefNode extends BaseNode {
       throw new Error("RefNode requires a non-empty ref");
     }
     this._ref = ref;
+    this.initBaseObservable();
   }
   nodeType() {
     return "ref";
@@ -509,23 +660,25 @@ function jsonPointerToSegments(pointer) {
   if (pointer === "" || pointer === "/") {
     return [];
   }
-  const parts = pointer.split("/").filter(Boolean);
+  const parts = pointer.startsWith("/") ? pointer.slice(1).split("/") : pointer.split("/");
   const segments = [];
   let i = 0;
   while (i < parts.length) {
     const part = parts[i];
     if (part === "properties") {
-      const name = parts[i + 1];
-      if (name === void 0 || name === "") {
-        throw new Error(
-          `Invalid path: 'properties' segment requires a name in path ${pointer}`
-        );
+      const hasNextPart = i + 1 < parts.length;
+      if (hasNextPart) {
+        const name = parts[i + 1] ?? "";
+        segments.push(new PropertySegment(name));
+        i += 2;
+      } else {
+        i += 1;
       }
-      segments.push(new PropertySegment(name));
-      i += 2;
     } else if (part === "items") {
       segments.push(new ItemsSegment());
       i += 1;
+    } else if (part === "") {
+      i += 1;
     } else {
       throw new Error(`Invalid path segment: ${part} in path ${pointer}`);
     }
@@ -541,8 +694,14 @@ function jsonPointerToSimplePath(pointer) {
 
 // src/core/schema-tree/TreeNodeIndex.ts
 var TreeNodeIndex = class {
-  nodeIndex = /* @__PURE__ */ new Map();
-  pathIndex = /* @__PURE__ */ new Map();
+  nodeIndex = observable.map();
+  pathIndex = observable.map();
+  constructor() {
+    makeAutoObservable(this, {
+      nodeIndex: false,
+      pathIndex: false
+    });
+  }
   rebuild(rootNode) {
     this.nodeIndex.clear();
     this.pathIndex.clear();
@@ -554,7 +713,7 @@ var TreeNodeIndex = class {
   getPath(id) {
     return this.pathIndex.get(id) ?? EMPTY_PATH;
   }
-  countNodes() {
+  get nodeCount() {
     return this.nodeIndex.size;
   }
   nodeIds() {
@@ -581,6 +740,11 @@ var SchemaTreeImpl = class _SchemaTreeImpl {
   constructor(rootNode) {
     this._rootNode = rootNode;
     this.index.rebuild(rootNode);
+    makeAutoObservable(this, {
+      index: false,
+      _replacements: false,
+      _rootNode: "observable.ref"
+    });
   }
   root() {
     return this._rootNode;
@@ -612,10 +776,11 @@ var SchemaTreeImpl = class _SchemaTreeImpl {
     return this.index.nodeIds();
   }
   countNodes() {
-    return this.index.countNodes();
+    return this.index.nodeCount;
   }
   clone() {
-    const cloned = new _SchemaTreeImpl(this._rootNode.clone());
+    const clonedRoot = this._rootNode.clone();
+    const cloned = new _SchemaTreeImpl(clonedRoot);
     for (const [oldId, newId] of this._replacements) {
       cloned._replacements.set(oldId, newId);
     }
@@ -773,16 +938,6 @@ var NodePathIndex = class {
   }
 };
 
-// src/model/schema-formula/core/FormulaError.ts
-var FormulaError = class extends Error {
-  constructor(message, nodeId, details) {
-    super(message);
-    this.nodeId = nodeId;
-    this.details = details;
-    this.name = "FormulaError";
-  }
-};
-
 // src/model/schema-formula/serialization/FormulaPathBuilder.ts
 var FormulaPathBuilder = class {
   buildWithArrayNotation(fromPath, toPath) {
@@ -851,6 +1006,16 @@ var FormulaPathBuilder = class {
   }
 };
 
+// src/model/schema-formula/core/FormulaError.ts
+var FormulaError = class extends Error {
+  constructor(message, nodeId, details) {
+    super(message);
+    this.nodeId = nodeId;
+    this.details = details;
+    this.name = "FormulaError";
+  }
+};
+
 // src/model/schema-formula/serialization/FormulaSerializer.ts
 var FormulaSerializer = class _FormulaSerializer {
   constructor(tree, formulaNodeId, formula) {
@@ -1051,49 +1216,43 @@ var ChangeCollector = class {
   collectFromCurrentTree(changes) {
     for (const nodeId of this.currentTree.nodeIds()) {
       const currentNode = this.currentTree.nodeById(nodeId);
-      if (this.index.isReplacement(nodeId)) {
-        const originalId = this.index.getOriginalNodeId(nodeId);
-        if (originalId) {
-          const baseNode2 = this.baseTree.nodeById(originalId);
-          changes.push({
-            type: "modified",
-            baseNode: baseNode2,
-            currentNode
-          });
-        }
-        continue;
-      }
-      const basePath = this.index.getBasePath(nodeId);
-      if (!basePath) {
-        changes.push({
-          type: "added",
-          baseNode: null,
-          currentNode
-        });
-        continue;
-      }
-      const currentPath = this.currentTree.pathOf(nodeId);
-      const baseNode = this.baseTree.nodeById(nodeId);
-      if (!basePath.equals(currentPath)) {
-        changes.push({
-          type: "moved",
-          baseNode,
-          currentNode
-        });
-        if (!areNodesContentEqual(currentNode, baseNode, this.context)) {
-          changes.push({
-            type: "modified",
-            baseNode,
-            currentNode
-          });
-        }
-      } else if (!areNodesEqual(currentNode, baseNode, this.context)) {
-        changes.push({
-          type: "modified",
-          baseNode,
-          currentNode
-        });
-      }
+      this.collectNodeChange(changes, nodeId, currentNode);
+    }
+  }
+  collectNodeChange(changes, nodeId, currentNode) {
+    if (this.index.isReplacement(nodeId)) {
+      this.collectReplacementChange(changes, nodeId, currentNode);
+      return;
+    }
+    const basePath = this.index.getBasePath(nodeId);
+    if (!basePath) {
+      changes.push({ type: "added", baseNode: null, currentNode });
+      return;
+    }
+    const currentPath = this.currentTree.pathOf(nodeId);
+    const baseNode = this.baseTree.nodeById(nodeId);
+    if (!basePath.equals(currentPath)) {
+      this.collectMovedChange(changes, baseNode, currentNode);
+    } else if (!areNodesEqual(currentNode, baseNode, this.context)) {
+      changes.push({ type: "modified", baseNode, currentNode });
+    }
+  }
+  collectReplacementChange(changes, nodeId, currentNode) {
+    const originalId = this.index.getOriginalNodeId(nodeId);
+    if (!originalId) {
+      return;
+    }
+    const baseNode = this.baseTree.nodeById(originalId);
+    if (baseNode.isNull()) {
+      changes.push({ type: "added", baseNode: null, currentNode });
+    } else {
+      changes.push({ type: "modified", baseNode, currentNode });
+    }
+  }
+  collectMovedChange(changes, baseNode, currentNode) {
+    changes.push({ type: "moved", baseNode, currentNode });
+    if (!areNodesContentEqual(currentNode, baseNode, this.context)) {
+      changes.push({ type: "modified", baseNode, currentNode });
     }
   }
   collectRemovedNodes(changes) {
@@ -1104,11 +1263,7 @@ var ChangeCollector = class {
       const currentNode = this.currentTree.nodeById(nodeId);
       if (currentNode.isNull()) {
         const baseNode = this.baseTree.nodeById(nodeId);
-        changes.push({
-          type: "removed",
-          baseNode,
-          currentNode: null
-        });
+        changes.push({ type: "removed", baseNode, currentNode: null });
       }
     }
   }
@@ -1192,6 +1347,9 @@ var ChangeCoalescer = class {
           continue;
         }
       }
+      if (change.type === "moved" && other.type === "added") {
+        continue;
+      }
       const otherPath = this.getChangePath(other);
       if (path.isChildOf(otherPath)) {
         return true;
@@ -1361,8 +1519,6 @@ var FormulaPath = class {
     return result;
   }
 };
-
-// src/model/schema-formula/parsing/ParsedFormula.ts
 var ParsedFormula = class {
   _expression;
   astNode;
@@ -1503,6 +1659,73 @@ var FormulaDependencyIndex = class {
   }
 };
 
+// src/model/schema-formula/changes/FormulaChangeDetector.ts
+var FormulaChangeDetector = class {
+  constructor(index, currentTree, baseTree) {
+    this.index = index;
+    this.currentTree = currentTree;
+    this.baseTree = baseTree;
+  }
+  detectIndirectChanges(changedNodeIds) {
+    const result = [];
+    const visited = /* @__PURE__ */ new Set();
+    for (const changedId of changedNodeIds) {
+      this.collectDependentChanges(changedId, result, visited, changedNodeIds);
+    }
+    return result;
+  }
+  collectDependentChanges(nodeId, result, visited, directlyChanged) {
+    const dependents = this.index.getDependents(nodeId);
+    for (const dependentId of dependents) {
+      if (visited.has(dependentId)) {
+        continue;
+      }
+      visited.add(dependentId);
+      if (directlyChanged.has(dependentId)) {
+        continue;
+      }
+      const change = this.detectFormulaChange(dependentId);
+      if (change) {
+        result.push(change);
+      }
+      this.collectDependentChanges(dependentId, result, visited, directlyChanged);
+    }
+  }
+  detectFormulaChange(nodeId) {
+    const currentNode = this.currentTree.nodeById(nodeId);
+    const baseNode = this.baseTree.nodeById(nodeId);
+    if (currentNode.isNull() || baseNode.isNull()) {
+      return null;
+    }
+    const currentFormula = currentNode.formula();
+    const baseFormula = baseNode.formula();
+    if (!currentFormula || !baseFormula) {
+      return null;
+    }
+    const fromExpression = this.getSerializedExpression(baseFormula, this.baseTree, nodeId);
+    const toExpression = this.getSerializedExpression(currentFormula, this.currentTree, nodeId);
+    if (fromExpression === null || toExpression === null) {
+      return null;
+    }
+    if (fromExpression === toExpression) {
+      return null;
+    }
+    return {
+      nodeId,
+      fromExpression,
+      toExpression
+    };
+  }
+  getSerializedExpression(formula, tree, nodeId) {
+    try {
+      const xFormula = FormulaSerializer.toXFormula(tree, nodeId, formula);
+      return xFormula.expression;
+    } catch {
+      return null;
+    }
+  }
+};
+
 // src/core/schema-serializer/SchemaSerializer.ts
 var SchemaSerializer = class {
   tree = null;
@@ -1596,6 +1819,10 @@ var SchemaSerializer = class {
     if (foreignKey) {
       result.foreignKey = foreignKey;
     }
+    const contentMediaType = node.contentMediaType();
+    if (contentMediaType && this.isValidContentMediaType(contentMediaType)) {
+      result.contentMediaType = contentMediaType;
+    }
     const formula = node.formula();
     if (formula) {
       result.readOnly = true;
@@ -1651,6 +1878,17 @@ var SchemaSerializer = class {
   shouldExclude(node) {
     return this.excludeNodeIds.has(node.id());
   }
+  isValidContentMediaType(value) {
+    const validTypes = [
+      "text/plain",
+      "text/markdown",
+      "text/html",
+      "application/json",
+      "application/schema+json",
+      "application/yaml"
+    ];
+    return validTypes.includes(value);
+  }
 };
 
 // src/core/schema-patch/PatchGenerator.ts
@@ -1674,7 +1912,7 @@ var PatchGenerator = class {
     const childChangePaths = /* @__PURE__ */ new Set([
       ...addPatches.map((p) => p.path),
       ...removePatches.map((p) => p.path),
-      ...movePatches.flatMap((p) => [p.path, p.from ?? ""]).filter(Boolean)
+      ...movePatches.flatMap((p) => [p.path, p.from]).filter(Boolean)
     ]);
     const replacePatches = this.generateReplacePatches(
       coalesced.modified,
@@ -1952,27 +2190,36 @@ var PatchEnricher = class {
   enrichAddPatch(patch, fieldName) {
     const currentNode = this.getNodeAtPath(this.currentTree, patch.path);
     if (!currentNode) {
-      return { patch, fieldName };
+      return { patch, fieldName, metadataChanges: [] };
     }
+    const metadata = this.computeAddMetadata(currentNode);
     return {
       patch,
       fieldName,
-      ...this.computeAddMetadata(currentNode)
+      metadataChanges: this.computeMetadataChanges(metadata),
+      ...metadata
     };
   }
   enrichRemovePatch(patch, fieldName) {
-    return { patch, fieldName };
+    return { patch, fieldName, metadataChanges: [] };
   }
   enrichMovePatch(patch, fieldName) {
-    const fromPath = patch.from || "";
+    const fromPath = patch.from;
     const isRename = this.isRenameMove(fromPath, patch.path);
+    const movesIntoArray = this.movesIntoArrayBoundary(fromPath, patch.path);
     const baseNode = this.getNodeAtPath(this.baseTree, fromPath);
     const currentNode = this.getNodeAtPath(this.currentTree, patch.path);
     const formulaChange = this.computeFormulaChange(baseNode, currentNode);
+    const metadataChanges = [];
+    if (formulaChange) {
+      metadataChanges.push("formula");
+    }
     return {
       patch,
       fieldName,
+      metadataChanges,
       isRename: isRename || void 0,
+      movesIntoArray: movesIntoArray || void 0,
       formulaChange
     };
   }
@@ -1980,15 +2227,31 @@ var PatchEnricher = class {
     const baseNode = this.getNodeAtPath(this.baseTree, patch.path);
     const currentNode = this.getNodeAtPath(this.currentTree, patch.path);
     const isArrayMetadataPatch = baseNode?.isArray() && currentNode?.isArray();
+    const formulaChange = this.computeFormulaChange(baseNode, currentNode);
+    const defaultChange = isArrayMetadataPatch ? void 0 : this.computeDefaultChange(baseNode, currentNode);
+    const descriptionChange = this.computeDescriptionChange(baseNode, currentNode);
+    const deprecatedChange = this.computeDeprecatedChange(baseNode, currentNode);
+    const foreignKeyChange = this.computeForeignKeyChange(baseNode, currentNode);
+    const contentMediaTypeChange = this.computeContentMediaTypeChange(baseNode, currentNode);
+    const metadataChanges = this.computeMetadataChanges({
+      formulaChange,
+      defaultChange,
+      descriptionChange,
+      deprecatedChange,
+      foreignKeyChange,
+      contentMediaTypeChange
+    });
     return {
       patch,
       fieldName,
+      metadataChanges,
       typeChange: this.computeTypeChange(baseNode, currentNode, isArrayMetadataPatch),
-      formulaChange: this.computeFormulaChange(baseNode, currentNode),
-      defaultChange: isArrayMetadataPatch ? void 0 : this.computeDefaultChange(baseNode, currentNode),
-      descriptionChange: this.computeDescriptionChange(baseNode, currentNode),
-      deprecatedChange: this.computeDeprecatedChange(baseNode, currentNode),
-      foreignKeyChange: this.computeForeignKeyChange(baseNode, currentNode)
+      formulaChange,
+      defaultChange,
+      descriptionChange,
+      deprecatedChange,
+      foreignKeyChange,
+      contentMediaTypeChange
     };
   }
   computeAddMetadata(node) {
@@ -2029,6 +2292,13 @@ var PatchEnricher = class {
         toForeignKey: foreignKey
       };
     }
+    const contentMediaType = node.contentMediaType();
+    if (contentMediaType) {
+      result.contentMediaTypeChange = {
+        fromContentMediaType: void 0,
+        toContentMediaType: contentMediaType
+      };
+    }
     return result;
   }
   computeTypeChange(baseNode, currentNode, ignoreItems) {
@@ -2108,6 +2378,39 @@ var PatchEnricher = class {
     }
     return void 0;
   }
+  computeContentMediaTypeChange(baseNode, currentNode) {
+    const baseMediaType = baseNode?.contentMediaType();
+    const currentMediaType = currentNode?.contentMediaType();
+    if (baseMediaType !== currentMediaType) {
+      return {
+        fromContentMediaType: baseMediaType,
+        toContentMediaType: currentMediaType
+      };
+    }
+    return void 0;
+  }
+  computeMetadataChanges(changes) {
+    const result = [];
+    if (changes.formulaChange) {
+      result.push("formula");
+    }
+    if (changes.defaultChange) {
+      result.push("default");
+    }
+    if (changes.descriptionChange) {
+      result.push("description");
+    }
+    if (changes.deprecatedChange) {
+      result.push("deprecated");
+    }
+    if (changes.foreignKeyChange) {
+      result.push("foreignKey");
+    }
+    if (changes.contentMediaTypeChange) {
+      result.push("contentMediaType");
+    }
+    return result;
+  }
   getNodeType(node) {
     if (node.isArray()) {
       const items = node.items();
@@ -2131,6 +2434,20 @@ var PatchEnricher = class {
       return false;
     }
   }
+  movesIntoArrayBoundary(fromPointer, toPointer) {
+    try {
+      const fromPath = jsonPointerToPath(fromPointer);
+      const toPath = jsonPointerToPath(toPointer);
+      const fromArrayDepth = this.countArrayDepth(fromPath);
+      const toArrayDepth = this.countArrayDepth(toPath);
+      return toArrayDepth > fromArrayDepth;
+    } catch {
+      return false;
+    }
+  }
+  countArrayDepth(path) {
+    return path.segments().filter((seg) => seg.isItems()).length;
+  }
   getNodeAtPath(tree, jsonPointer) {
     try {
       const path = jsonPointerToPath(jsonPointer);
@@ -2489,6 +2806,12 @@ function collectValidationErrors(node, errors) {
   if (node.isNull()) {
     return;
   }
+  const foreignKey = node.foreignKey();
+  if (foreignKey === "") {
+    errors.push(
+      createError(node.id(), "empty-foreign-key", "Foreign key table reference cannot be empty")
+    );
+  }
   if (node.isObject()) {
     const children = node.properties();
     const nameSet = /* @__PURE__ */ new Set();
@@ -2564,6 +2887,6 @@ function buildArrayItemsPath(parentPath) {
   return parentPath ? `${parentPath}[*]` : "[*]";
 }
 
-export { AbstractBasePath, ChangeCoalescer, ChangeCollector, CompositeRule, EMPTY_METADATA, EMPTY_PATH, EnumValidator, FIELD_NAME_ERROR_MESSAGE, ForeignKeyValidator, FormulaDependencyIndex, ItemsSegment, MaxLengthValidator, MaximumValidator, MinLengthValidator, MinimumValidator, NULL_NODE, NodePathIndex, ParsedFormula, PatchBuilder, PatchEnricher, PatchGenerator, PatternValidator, PropertySegment, RequiredValidator, SchemaDiff, SchemaPropertyRule, SchemaSerializer, SchemaTruthyRule, ValidationEngine, ValidatorRegistry, ValidatorResolver, areNodesContentEqual, areNodesEqual, coalesceChanges, collectChanges, createArrayNode, createBooleanNode, createDefaultValidatorRegistry, createNumberNode, createObjectNode, createPath, createRefNode, createSchemaTree, createStringNode, createValidationEngine, isValidFieldName, jsonPointerToPath, jsonPointerToSegments, jsonPointerToSimplePath, validateFormulas, validateSchema };
-//# sourceMappingURL=chunk-S7GEDTSL.js.map
-//# sourceMappingURL=chunk-S7GEDTSL.js.map
+export { AbstractBasePath, ChangeCoalescer, ChangeCollector, CompositeRule, EMPTY_METADATA, EMPTY_PATH, EnumValidator, FIELD_NAME_ERROR_MESSAGE, ForeignKeyValidator, FormulaChangeDetector, FormulaDependencyIndex, FormulaPath, FormulaPathBuilder, FormulaSerializer, ItemsSegment, MaxLengthValidator, MaximumValidator, MinLengthValidator, MinimumValidator, NULL_NODE, NodePathIndex, ParsedFormula, PatchBuilder, PatchEnricher, PatchGenerator, PatternValidator, PropertySegment, RequiredValidator, ResolvedDependency, SchemaDiff, SchemaPropertyRule, SchemaSerializer, SchemaTruthyRule, ValidationEngine, ValidatorRegistry, ValidatorResolver, areNodesContentEqual, areNodesEqual, coalesceChanges, collectChanges, createArrayNode, createBooleanNode, createDefaultValidatorRegistry, createMobxProvider, createNumberNode, createObjectNode, createPath, createRefNode, createSchemaTree, createStringNode, createValidationEngine, isValidFieldName, jsonPointerToPath, jsonPointerToSegments, jsonPointerToSimplePath, makeAutoObservable, makeObservable, observable, reaction, resetReactivityProvider, runInAction, setReactivityProvider, validateFormulas, validateSchema };
+//# sourceMappingURL=chunk-PGR2S2BR.js.map
+//# sourceMappingURL=chunk-PGR2S2BR.js.map