@fluidgrids/workflows 0.0.0-stage → 2026.1027.1

package/dist/chunk-W32BSO3M.js

@@ -0,0 +1,74 @@
+import { hashedProjection } from './chunk-6U446SKY.js';
+import { isRecord, deepEqual, ownValue } from './chunk-UJNHTS6D.js';
+
+// src/ir/diff.ts
+function keyPath(base, key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? base ? `${base}.${key}` : key : `${base}[${JSON.stringify(key)}]`;
+}
+function diffValues(before, after, path, out) {
+  if (deepEqual(before, after)) return;
+  if (isRecord(before) && isRecord(after)) {
+    const keys = [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].sort();
+    for (const key of keys) {
+      const left = ownValue(before, key);
+      const right = ownValue(after, key);
+      if (left === void 0 && right !== void 0)
+        out.push({ kind: "added", path: keyPath(path, key), after: right });
+      else if (left !== void 0 && right === void 0)
+        out.push({ kind: "removed", path: keyPath(path, key), before: left });
+      else diffValues(left, right, keyPath(path, key), out);
+    }
+    return;
+  }
+  out.push({ kind: "changed", path, before, after });
+}
+function byId(items) {
+  const map = /* @__PURE__ */ new Map();
+  if (!Array.isArray(items)) return map;
+  items.forEach((item, index) => {
+    if (!isRecord(item)) return;
+    const id = typeof item["id"] === "string" ? item["id"] : `#${index}`;
+    if (!map.has(id)) map.set(id, item);
+  });
+  return map;
+}
+function diffCollection(before, after, path, out) {
+  const left = byId(before);
+  const right = byId(after);
+  for (const [id, item] of left) {
+    if (!right.has(id)) out.push({ kind: "removed", path: `${path}[${id}]`, before: item });
+  }
+  for (const [id, item] of right) {
+    const previous = left.get(id);
+    if (!previous) out.push({ kind: "added", path: `${path}[${id}]`, after: item });
+    else diffValues(previous, item, `${path}[${id}]`, out);
+  }
+  const common = (ids, other) => ids.filter((id) => other.has(id));
+  const leftOrder = common([...left.keys()], right);
+  const rightOrder = common([...right.keys()], left);
+  if (!deepEqual(leftOrder, rightOrder)) {
+    out.push({ kind: "reordered", path, before: leftOrder, after: rightOrder });
+  }
+}
+function diffDefinitions(before, after) {
+  const left = hashedProjection(before);
+  const right = hashedProjection(after);
+  const out = [];
+  if (!isRecord(left) || !isRecord(right)) {
+    diffValues(left, right, "", out);
+    return out;
+  }
+  const { data: leftData, ...leftRest } = left;
+  const { data: rightData, ...rightRest } = right;
+  diffValues(leftRest, rightRest, "", out);
+  const leftDataRecord = isRecord(leftData) ? leftData : {};
+  const rightDataRecord = isRecord(rightData) ? rightData : {};
+  const { nodes: leftNodes, edges: leftEdges, ...leftDataRest } = leftDataRecord;
+  const { nodes: rightNodes, edges: rightEdges, ...rightDataRest } = rightDataRecord;
+  diffCollection(leftNodes, rightNodes, "data.nodes", out);
+  diffCollection(leftEdges, rightEdges, "data.edges", out);
+  diffValues(leftDataRest, rightDataRest, "data", out);
+  return out;
+}
+
+export { diffDefinitions };