@fluidgrids/workflows 0.0.0-stage → 2026.1027.1

package/dist/chunk-TWOYB4Y7.cjs

@@ -0,0 +1,76 @@
+'use strict';
+
+var chunk7YR7DI7B_cjs = require('./chunk-7YR7DI7B.cjs');
+var chunkE3APHA6O_cjs = require('./chunk-E3APHA6O.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 (chunkE3APHA6O_cjs.deepEqual(before, after)) return;
+  if (chunkE3APHA6O_cjs.isRecord(before) && chunkE3APHA6O_cjs.isRecord(after)) {
+    const keys = [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].sort();
+    for (const key of keys) {
+      const left = chunkE3APHA6O_cjs.ownValue(before, key);
+      const right = chunkE3APHA6O_cjs.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 (!chunkE3APHA6O_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 (!chunkE3APHA6O_cjs.deepEqual(leftOrder, rightOrder)) {
+    out.push({ kind: "reordered", path, before: leftOrder, after: rightOrder });
+  }
+}
+function diffDefinitions(before, after) {
+  const left = chunk7YR7DI7B_cjs.hashedProjection(before);
+  const right = chunk7YR7DI7B_cjs.hashedProjection(after);
+  const out = [];
+  if (!chunkE3APHA6O_cjs.isRecord(left) || !chunkE3APHA6O_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 = chunkE3APHA6O_cjs.isRecord(leftData) ? leftData : {};
+  const rightDataRecord = chunkE3APHA6O_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-UB2BHU2M.js

@@ -0,0 +1,174 @@
+import { formatRefTemplate, segmentFromKey } from './chunk-UJNHTS6D.js';
+
+// src/builder/refs.ts
+var REF_MODEL = /* @__PURE__ */ Symbol.for("fluidgrids.workflows.ref");
+var PREDICATE = /* @__PURE__ */ Symbol.for("fluidgrids.workflows.predicate");
+var PREDICATE_OPERATORS = {
+  eq: { operator: "==", unary: false },
+  neq: { operator: "!=", unary: false },
+  gt: { operator: ">", unary: false },
+  gte: { operator: ">=", unary: false },
+  lt: { operator: "<", unary: false },
+  lte: { operator: "<=", unary: false },
+  contains: { operator: "contains", unary: false },
+  notContains: { operator: "notContains", unary: false },
+  startsWith: { operator: "startsWith", unary: false },
+  endsWith: { operator: "endsWith", unary: false },
+  matches: { operator: "regex", unary: false },
+  hasProperty: { operator: "hasProperty", unary: false },
+  isEmpty: { operator: "isEmpty", unary: true },
+  isNotEmpty: { operator: "isNotEmpty", unary: true },
+  isNull: { operator: "isNull", unary: true },
+  isNotNull: { operator: "isNotNull", unary: true },
+  isTrue: { operator: "isTrue", unary: true },
+  isFalse: { operator: "isFalse", unary: true }
+};
+var RESERVED_REF_KEYS = /* @__PURE__ */ new Set([
+  "then",
+  "toJSON",
+  "toString",
+  "valueOf"
+]);
+var BuilderError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BuilderError";
+  }
+};
+function isRuleValue(value) {
+  return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+}
+function conditionField(ref) {
+  const segments = ref.path.map((segment) => {
+    const text = segment.kind === "index" ? String(segment.index) : segment.key;
+    if (text === "" || text.includes(".")) {
+      throw new BuilderError(
+        `A condition cannot address the key "${text}" (condition fields are dot-separated); use a raw condition tree`
+      );
+    }
+    return text;
+  });
+  switch (ref.root.kind) {
+    case "node":
+      if (ref.root.nodeId.includes(".")) {
+        throw new BuilderError(
+          `A condition cannot address node "${ref.root.nodeId}"; its id contains a dot`
+        );
+      }
+      return ["WorkflowState", ref.root.nodeId, ...segments].join(".");
+    case "json":
+      return ["output", ...segments].join(".");
+    default:
+      throw new BuilderError(
+        `A condition can compare node outputs and $json only, not $${ref.root.kind}; use an expression`
+      );
+  }
+}
+function makePredicate(target, operator, args, unary) {
+  const rule = { type: "rule", field: conditionField(target), operator };
+  if (!unary) {
+    if (args.length < 1 || !isRuleValue(args[0])) {
+      throw new BuilderError(
+        `The "${operator}" comparison needs a string, number, boolean or null value`
+      );
+    }
+    rule.value = args[0];
+  } else if (args.length > 0) {
+    throw new BuilderError(`The "${operator}" comparison takes no value`);
+  }
+  return { [PREDICATE]: rule };
+}
+function callOnRef(model, args) {
+  const last = model.path[model.path.length - 1];
+  if (last?.kind !== "key") {
+    throw new BuilderError("A reference is not a function; call a comparison such as .gte(500)");
+  }
+  const parent = { root: model.root, path: model.path.slice(0, -1) };
+  if (last.key === "is") {
+    const [operator, ...rest] = args;
+    if (typeof operator !== "string" || operator === "") {
+      throw new BuilderError(".is(operator, value) needs an operator name");
+    }
+    return makePredicate(parent, operator, rest, rest.length === 0);
+  }
+  const known = PREDICATE_OPERATORS[last.key];
+  if (!known) {
+    throw new BuilderError(`"${last.key}" is not a comparison; references are data, not functions`);
+  }
+  return makePredicate(parent, known.operator, args, known.unary);
+}
+function makeRef(root, path = []) {
+  const model = { root, path };
+  const render = () => formatRefTemplate(model);
+  const target = function fluidgridsRef() {
+    return void 0;
+  };
+  const handler = {
+    get(_target, property) {
+      if (property === REF_MODEL) return model;
+      if (property === Symbol.toPrimitive) return render;
+      if (typeof property === "symbol") return void 0;
+      if (property === "then") return void 0;
+      if (property === "toJSON" || property === "toString" || property === "valueOf") return render;
+      return makeRef(root, [...path, segmentFromKey(property)]);
+    },
+    apply(_target, _thisArg, args) {
+      return callOnRef(model, args);
+    },
+    has(_target, property) {
+      return property === REF_MODEL;
+    },
+    set() {
+      throw new BuilderError("References are read-only");
+    }
+  };
+  return new Proxy(target, handler);
+}
+function refModelOf(value) {
+  if ((typeof value === "function" || typeof value === "object") && value !== null && REF_MODEL in value) {
+    const model = value[REF_MODEL];
+    return model;
+  }
+  return void 0;
+}
+function isPredicate(value) {
+  return typeof value === "object" && value !== null && PREDICATE in value;
+}
+function predicateTree(predicate) {
+  return predicate[PREDICATE];
+}
+function group(combinator, predicates) {
+  if (predicates.length === 0)
+    throw new BuilderError(`${combinator.toLowerCase()}() needs at least one condition`);
+  for (const predicate of predicates) {
+    if (!isPredicate(predicate))
+      throw new BuilderError(`${combinator.toLowerCase()}() takes conditions only`);
+  }
+  return { [PREDICATE]: { type: "group", combinator, children: predicates.map(predicateTree) } };
+}
+function and(...predicates) {
+  return group("AND", predicates);
+}
+function or(...predicates) {
+  return group("OR", predicates);
+}
+function conditionTreeOf(predicate) {
+  const tree = predicateTree(predicate);
+  return tree.type === "group" ? tree : { type: "group", combinator: "AND", children: [tree] };
+}
+function expr(strings, ...values) {
+  let out = strings[0] ?? "";
+  values.forEach((value, index) => {
+    const model = refModelOf(value);
+    if (model) out += formatRefTemplate(model);
+    else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      out += String(value);
+    } else {
+      throw new BuilderError("expr`\u2026` interpolates references, strings, numbers and booleans only");
+    }
+    out += strings[index + 1] ?? "";
+  });
+  return out;
+}
+
+export { BuilderError, PREDICATE_OPERATORS, RESERVED_REF_KEYS, and, conditionTreeOf, expr, isPredicate, makeRef, or, refModelOf };

package/dist/chunk-UJNHTS6D.js

@@ -0,0 +1,181 @@
+// src/ir/json-utils.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepEqual(left, right) {
+  if (left === right) return true;
+  if (Array.isArray(left)) {
+    if (!Array.isArray(right) || left.length !== right.length) return false;
+    return left.every((item, index) => deepEqual(item, right[index]));
+  }
+  if (isRecord(left)) {
+    if (!isRecord(right)) return false;
+    const leftKeys = Object.keys(left).filter((key) => left[key] !== void 0);
+    const rightKeys = Object.keys(right).filter((key) => right[key] !== void 0);
+    if (leftKeys.length !== rightKeys.length) return false;
+    return leftKeys.every((key) => Object.hasOwn(right, key) && deepEqual(left[key], right[key]));
+  }
+  return false;
+}
+function setOwn(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    writable: true,
+    configurable: true
+  });
+}
+function ownValue(record, key) {
+  return Object.hasOwn(record, key) ? record[key] : void 0;
+}
+function cloneJson(value) {
+  return structuredCloneJson(value);
+}
+function structuredCloneJson(value) {
+  if (Array.isArray(value)) return value.map(structuredCloneJson);
+  if (isRecord(value)) {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      if (child !== void 0) setOwn(out, key, structuredCloneJson(child));
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/ir/expressions.ts
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function segmentFromKey(key) {
+  return /^(0|[1-9][0-9]{0,8})$/.test(key) ? { kind: "index", index: Number(key) } : { kind: "key", key };
+}
+function formatPath(path) {
+  return path.map((segment) => {
+    if (segment.kind === "index") return `[${segment.index}]`;
+    return IDENTIFIER.test(segment.key) ? `.${segment.key}` : `[${JSON.stringify(segment.key)}]`;
+  }).join("");
+}
+function formatRefExpression(ref) {
+  const path = formatPath(ref.path);
+  switch (ref.root.kind) {
+    case "node":
+      return `$node[${JSON.stringify(ref.root.nodeId)}].item${path}`;
+    case "json":
+      return `$json${path}`;
+    case "vars":
+      return `$vars${path}`;
+    case "now":
+      return `$now${path}`;
+    case "execution":
+      return `$execution${path}`;
+  }
+}
+function formatRefTemplate(ref) {
+  return `{{ ${formatRefExpression(ref)} }}`;
+}
+function readJsonString(text, start) {
+  if (text[start] !== '"') return void 0;
+  let index = start + 1;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    if (char === '"') {
+      try {
+        const value = JSON.parse(text.slice(start, index + 1));
+        return typeof value === "string" ? { value, end: index + 1 } : void 0;
+      } catch {
+        return void 0;
+      }
+    }
+    index++;
+  }
+  return void 0;
+}
+function parsePath(text, start) {
+  const path = [];
+  let index = start;
+  while (index < text.length) {
+    if (text[index] === ".") {
+      const match = /^[A-Za-z_$][A-Za-z0-9_$]*/.exec(text.slice(index + 1));
+      if (!match) return void 0;
+      path.push({ kind: "key", key: match[0] });
+      index += 1 + match[0].length;
+      continue;
+    }
+    if (text[index] === "[") {
+      const digits = /^\[(0|[1-9][0-9]{0,8})\]/.exec(text.slice(index));
+      if (digits?.[1] !== void 0) {
+        path.push({ kind: "index", index: Number(digits[1]) });
+        index += digits[0].length;
+        continue;
+      }
+      const literal = readJsonString(text, index + 1);
+      if (!literal || text[literal.end] !== "]") return void 0;
+      path.push({ kind: "key", key: literal.value });
+      index = literal.end + 1;
+      continue;
+    }
+    return void 0;
+  }
+  return path;
+}
+function parseRefExpressionLoose(expression) {
+  if (expression.startsWith("$node[")) {
+    const literal = readJsonString(expression, "$node[".length);
+    if (!literal) return void 0;
+    const rest = expression.slice(literal.end);
+    if (!rest.startsWith("].item")) return void 0;
+    const path = parsePath(expression, literal.end + "].item".length);
+    return path ? { root: { kind: "node", nodeId: literal.value }, path } : void 0;
+  }
+  for (const [prefix, kind] of [
+    ["$json", "json"],
+    ["$vars", "vars"],
+    ["$now", "now"],
+    ["$execution", "execution"]
+  ]) {
+    if (expression === prefix || expression.startsWith(`${prefix}.`) || expression.startsWith(`${prefix}[`)) {
+      const path = parsePath(expression, prefix.length);
+      return path ? { root: { kind }, path } : void 0;
+    }
+  }
+  return void 0;
+}
+function parseRefExpression(expression) {
+  const ref = parseRefExpressionLoose(expression);
+  return ref && formatRefExpression(ref) === expression ? ref : void 0;
+}
+function parseTemplate(text) {
+  if (!text.includes("{{")) return void 0;
+  const parts = [];
+  let index = 0;
+  let sawRef = false;
+  while (index < text.length) {
+    const open = text.indexOf("{{", index);
+    if (open === -1) {
+      parts.push({ kind: "text", text: text.slice(index) });
+      break;
+    }
+    if (open > index) parts.push({ kind: "text", text: text.slice(index, open) });
+    const close = text.indexOf(" }}", open);
+    if (close === -1 || text[open + 2] !== " ") return void 0;
+    const ref = parseRefExpression(text.slice(open + 3, close));
+    if (!ref) return void 0;
+    parts.push({ kind: "ref", ref });
+    sawRef = true;
+    index = close + 3;
+  }
+  if (!sawRef) return void 0;
+  const rebuilt = parts.map((part) => part.kind === "text" ? part.text : formatRefTemplate(part.ref)).join("");
+  return rebuilt === text ? parts : void 0;
+}
+function hasLegacyTemplate(text) {
+  return /\$\{[\s\S]*?\}/.test(text);
+}
+function isJsIdentifier(name) {
+  return IDENTIFIER.test(name);
+}
+
+export { cloneJson, deepEqual, formatRefExpression, formatRefTemplate, hasLegacyTemplate, isJsIdentifier, isRecord, ownValue, parseRefExpression, parseTemplate, segmentFromKey, setOwn };