@particle-academy/fancy-flow 0.29.0 → 0.30.0

package/dist/engine.cjs

@@ -3,6 +3,21 @@
 // src/registry/registry.ts
 var kinds = /* @__PURE__ */ new Map();
 var aliases = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Set();
+function registerNodeKind(definition) {
+  kinds.set(definition.name, definition);
+  for (const alias of definition.aliases ?? []) aliases.set(alias, definition.name);
+  notify();
+  return () => {
+    if (kinds.get(definition.name) === definition) {
+      kinds.delete(definition.name);
+      for (const alias of definition.aliases ?? []) {
+        if (aliases.get(alias) === definition.name) aliases.delete(alias);
+      }
+      notify();
+    }
+  };
+}
 function resolveKindId(id) {
   if (kinds.has(id)) return id;
   const canonical = aliases.get(id);
@@ -15,6 +30,104 @@ function getNodeKind(name) {
 function kindIds(kind) {
   return [kind.name, ...kind.aliases ?? []];
 }
+function listNodeKinds(category) {
+  const all = Array.from(kinds.values());
+  return category ? all.filter((k) => k.category === category) : all;
+}
+function notify() {
+  for (const l of listeners) l();
+}
+function defaultConfigFor(kind) {
+  const fromKind = kind.defaultConfig ? { ...kind.defaultConfig } : {};
+  for (const field of kind.configSchema ?? []) {
+    if (fromKind[field.key] !== void 0) continue;
+    if ("default" in field && field.default !== void 0) {
+      fromKind[field.key] = field.default;
+    }
+  }
+  return fromKind;
+}
+function validateConfig(kind, config) {
+  const issues = [];
+  for (const field of kind.configSchema ?? []) {
+    const value = config[field.key];
+    if (field.required && (value === void 0 || value === null || value === "")) {
+      issues.push({ key: field.key, message: `${field.label} is required` });
+      continue;
+    }
+    if (value === void 0 || value === null) continue;
+    const issue = validateField(field, value);
+    if (issue) issues.push({ key: field.key, message: issue });
+  }
+  return issues;
+}
+function validateField(field, value) {
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "expression":
+    case "credential":
+      return typeof value === "string" ? null : `${field.label} must be a string`;
+    case "number": {
+      if (typeof value !== "number" || !Number.isFinite(value)) return `${field.label} must be a number`;
+      if (field.min !== void 0 && value < field.min) return `${field.label} must be >= ${field.min}`;
+      if (field.max !== void 0 && value > field.max) return `${field.label} must be <= ${field.max}`;
+      return null;
+    }
+    case "switch":
+      return typeof value === "boolean" ? null : `${field.label} must be a boolean`;
+    case "select": {
+      const allowed = field.options.map((o) => o.value);
+      return allowed.includes(String(value)) ? null : `${field.label} must be one of ${allowed.join(", ")}`;
+    }
+    case "json":
+      return null;
+    // permissive — just JSON-shaped
+    case "repeater": {
+      if (!Array.isArray(value)) return `${field.label} must be a list`;
+      if (field.minItems !== void 0 && value.length < field.minItems) {
+        return `${field.label} needs at least ${field.minItems}`;
+      }
+      if (field.maxItems !== void 0 && value.length > field.maxItems) {
+        return `${field.label} allows at most ${field.maxItems}`;
+      }
+      for (let i = 0; i < value.length; i++) {
+        const row = value[i];
+        if (!row || typeof row !== "object" || Array.isArray(row)) {
+          return `${field.label} item ${i + 1} must be an object`;
+        }
+        for (const sub of field.fields) {
+          const cell = row[sub.key];
+          if (sub.required && (cell === void 0 || cell === null || cell === "")) {
+            return `${field.label} item ${i + 1}: ${sub.label} is required`;
+          }
+          if (cell === void 0 || cell === null) continue;
+          const issue = validateField(sub, cell);
+          if (issue) return `${field.label} item ${i + 1}: ${issue}`;
+        }
+      }
+      return null;
+    }
+    case "keyvalue": {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return `${field.label} must be a key/value map`;
+      }
+      const allowed = field.valueOptions?.map((o) => o.value);
+      for (const [k, v] of Object.entries(value)) {
+        if (typeof v !== "string") return `${field.label}: "${k}" must be a string`;
+        if (allowed && !allowed.includes(v)) {
+          return `${field.label}: "${k}" must be one of ${allowed.join(", ")}`;
+        }
+      }
+      return null;
+    }
+    case "document":
+      return null;
+    // opaque to fancy-flow — the host's editor owns its shape
+    default:
+      return null;
+  }
+}
 
 // src/registry/ports.ts
 function resolvePortSpec(spec, config) {
@@ -542,7 +655,26 @@ function buildGraph(kindId, testCase) {
   return { graph: { nodes, edges }, ports: effective };
 }
 function deepEqual(a, b) {
-  return JSON.stringify(a) === JSON.stringify(b);
+  if (Object.is(a, b)) return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((item, index) => deepEqual(item, b[index]));
+  }
+  const left = definedEntries(a);
+  const right = definedEntries(b);
+  const keys = Object.keys(left);
+  if (keys.length !== Object.keys(right).length) return false;
+  return keys.every(
+    (key) => Object.prototype.hasOwnProperty.call(right, key) && deepEqual(left[key], right[key])
+  );
+}
+function definedEntries(value) {
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (item !== void 0) out[key] = item;
+  }
+  return out;
 }
 function installStubs(stubs) {
   if (!stubs) return () => {
@@ -752,13 +884,20 @@ exports.PAUSE_PREFIX = PAUSE_PREFIX;
 exports.checkCapabilities = checkCapabilities;
 exports.checkRuntimeSupport = checkRuntimeSupport;
 exports.decodePause = decodePause;
+exports.defaultConfigFor = defaultConfigFor;
 exports.encodePause = encodePause;
+exports.getNodeKind = getNodeKind;
 exports.isPause = isPause;
+exports.kindIds = kindIds;
+exports.listNodeKinds = listNodeKinds;
 exports.pauseForHuman = pauseForHuman;
+exports.registerNodeKind = registerNodeKind;
+exports.resolveKindId = resolveKindId;
 exports.runCohort = runCohort;
 exports.runFixtures = runFixtures;
 exports.runFlow = runFlow;
 exports.satisfiesRange = satisfiesRange;
+exports.validateConfig = validateConfig;
 exports.validateFixtureFile = validateFixtureFile;
 exports.validateNodeManifest = validateNodeManifest;
 //# sourceMappingURL=engine.cjs.map