@fluidgrids/workflows 0.0.0-stage → 2026.1027.1

package/dist/chunk-E3APHA6O.cjs

@@ -0,0 +1,199 @@
+'use strict';
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// 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);
+}
+
+exports.cloneJson = cloneJson;
+exports.deepEqual = deepEqual;
+exports.formatRefExpression = formatRefExpression;
+exports.formatRefTemplate = formatRefTemplate;
+exports.hasLegacyTemplate = hasLegacyTemplate;
+exports.importMetaUrl = importMetaUrl;
+exports.isJsIdentifier = isJsIdentifier;
+exports.isRecord = isRecord;
+exports.ownValue = ownValue;
+exports.parseRefExpression = parseRefExpression;
+exports.parseTemplate = parseTemplate;
+exports.segmentFromKey = segmentFromKey;
+exports.setOwn = setOwn;