@fluidgrids/workflows 0.0.0-stage → 2026.1027.0

package/dist/chunk-BYJ7QTLY.cjs

@@ -0,0 +1,76 @@
+'use strict';
+
+var chunkAU3YW7FZ_cjs = require('./chunk-AU3YW7FZ.cjs');
+var chunkLRM6JXJA_cjs = require('./chunk-LRM6JXJA.cjs');
+
+// 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 (chunkLRM6JXJA_cjs.deepEqual(before, after)) return;
+  if (chunkLRM6JXJA_cjs.isRecord(before) && chunkLRM6JXJA_cjs.isRecord(after)) {
+    const keys = [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].sort();
+    for (const key of keys) {
+      const left = before[key];
+      const right = 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 (!chunkLRM6JXJA_cjs.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 (!chunkLRM6JXJA_cjs.deepEqual(leftOrder, rightOrder)) {
+    out.push({ kind: "reordered", path, before: leftOrder, after: rightOrder });
+  }
+}
+function diffDefinitions(before, after) {
+  const left = chunkAU3YW7FZ_cjs.hashedProjection(before);
+  const right = chunkAU3YW7FZ_cjs.hashedProjection(after);
+  const out = [];
+  if (!chunkLRM6JXJA_cjs.isRecord(left) || !chunkLRM6JXJA_cjs.isRecord(right)) {
+    diffValues(left, right, "", out);
+    return out;
+  }
+  const { data: leftData, ...leftRest } = left;
+  const { data: rightData, ...rightRest } = right;
+  diffValues(leftRest, rightRest, "", out);
+  const leftDataRecord = chunkLRM6JXJA_cjs.isRecord(leftData) ? leftData : {};
+  const rightDataRecord = chunkLRM6JXJA_cjs.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;
+}
+
+exports.diffDefinitions = diffDefinitions;

package/dist/chunk-G4UEPUGO.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+// src/ir/layout.ts
+var LAYOUT_COLUMN_WIDTH = 300;
+var LAYOUT_ROW_HEIGHT = 170;
+function autoLayout(nodeIds, edges) {
+  const depth = /* @__PURE__ */ new Map();
+  const roots = nodeIds.filter((id) => !edges.some((edge) => edge.target === id));
+  const queue = [...roots];
+  for (const id of queue) depth.set(id, 0);
+  const guardLimit = nodeIds.length * nodeIds.length + 1;
+  for (let guard = 0; queue.length > 0 && guard < guardLimit; guard++) {
+    const current = queue.shift();
+    if (current === void 0) break;
+    const currentDepth = depth.get(current) ?? 0;
+    for (const edge of edges) {
+      if (edge.source !== current) continue;
+      const next = currentDepth + 1;
+      if (next > (depth.get(edge.target) ?? -1) && next < nodeIds.length) {
+        depth.set(edge.target, next);
+        queue.push(edge.target);
+      }
+    }
+  }
+  const maxDepth = Math.max(0, ...depth.values());
+  const columns = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    const column = depth.get(id) ?? maxDepth + 1;
+    columns.set(column, [...columns.get(column) ?? [], id]);
+  }
+  const positions = /* @__PURE__ */ new Map();
+  for (const [column, ids] of columns) {
+    ids.forEach((id, row) => {
+      positions.set(id, {
+        x: column * LAYOUT_COLUMN_WIDTH,
+        // `+ 0` turns the -0 Math.round can return into 0, so JSON never sees -0.
+        y: Math.round((row - (ids.length - 1) / 2) * LAYOUT_ROW_HEIGHT) + 0
+      });
+    });
+  }
+  return positions;
+}
+
+exports.LAYOUT_COLUMN_WIDTH = LAYOUT_COLUMN_WIDTH;
+exports.LAYOUT_ROW_HEIGHT = LAYOUT_ROW_HEIGHT;
+exports.autoLayout = autoLayout;

package/dist/chunk-GO34UHSY.js

@@ -0,0 +1,95 @@
+import { isRecord } from './chunk-REV7ZOA4.js';
+
+// src/ir/manifest.ts
+function operationsOf(manifest) {
+  const operations = Array.isArray(manifest.operations) ? manifest.operations : manifest.operations.operations;
+  return Array.isArray(operations) ? operations.filter((operation) => isRecord(operation) && typeof operation.name === "string") : [];
+}
+function isTriggerOperation(operation) {
+  if (typeof operation.role === "string") return operation.role.toLowerCase() === "trigger";
+  return operation.type === "trigger" || operation.type === "subscription";
+}
+function fieldOf(value) {
+  if (typeof value === "string") return { type: value };
+  return isRecord(value) ? value : {};
+}
+function fieldSchema(value) {
+  const field = fieldOf(value);
+  const description = typeof field.description === "string" ? { description: field.description } : {};
+  const choices = Array.isArray(field.enum) ? field.enum : Array.isArray(field.options) ? field.options : void 0;
+  if (choices && choices.every((choice) => typeof choice === "string")) {
+    return { enum: choices, ...description };
+  }
+  if (field.format === "binary") {
+    return {
+      type: "object",
+      description: field.description ?? "File reference",
+      properties: { fileId: { type: "string" } }
+    };
+  }
+  switch (field.type) {
+    case "string":
+    case "code":
+    case "workflow":
+    case "time":
+      return { type: "string", ...description };
+    case "date":
+    case "datetime":
+      return { type: "string", format: "date-time", ...description };
+    case "integer":
+      return { type: "integer", ...description };
+    case "number":
+      return { type: "number", ...description };
+    case "boolean":
+      return { type: "boolean", ...description };
+    case "array": {
+      const items = field.items !== void 0 ? { items: fieldSchema(field.items) } : {};
+      return { type: "array", ...items, ...description };
+    }
+    case "object": {
+      if (isRecord(field.properties)) {
+        const properties = {};
+        for (const [name, child] of Object.entries(field.properties))
+          properties[name] = fieldSchema(child);
+        return { type: "object", properties, ...description };
+      }
+      return { type: "object", ...description };
+    }
+    default:
+      return { ...description };
+  }
+}
+function fieldsSchema(fields) {
+  const properties = {};
+  const required = [];
+  for (const [name, field] of Object.entries(fields ?? {})) {
+    properties[name] = fieldSchema(field);
+    if (fieldOf(field).required === true) required.push(name);
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
+}
+function findManifest(manifests, nodeType) {
+  const candidates = manifests.filter((manifest) => manifest.nodeType === nodeType);
+  return candidates.sort((a, b) => compareVersions(b.nodeVersion, a.nodeVersion))[0];
+}
+function compareVersions(left, right) {
+  const a = (left ?? "").split(".");
+  const b = (right ?? "").split(".");
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const x = a[i] ?? "";
+    const y = b[i] ?? "";
+    const nx = Number(x);
+    const ny = Number(y);
+    if (x !== y) {
+      if (Number.isFinite(nx) && Number.isFinite(ny) && x !== "" && y !== "") return nx - ny;
+      return x < y ? -1 : 1;
+    }
+  }
+  return 0;
+}
+
+export { compareVersions, fieldSchema, fieldsSchema, findManifest, isTriggerOperation, operationsOf };