@theclearsky/react-blender-nodes 0.0.11 → 0.0.13

package/dist/contract-DxqU738Q.js

@@ -0,0 +1,514 @@
+const i = [
+  "string",
+  "number",
+  "boolean",
+  "complex",
+  "noEquivalent",
+  "inferFromConnection"
+], L = {
+  [i[0]]: i[0],
+  [i[1]]: i[1],
+  [i[2]]: i[2],
+  [i[3]]: i[3],
+  [i[4]]: i[4],
+  [i[5]]: i[5]
+};
+function O(t) {
+  return t in L;
+}
+function U(t) {
+  return t;
+}
+function k(t, e) {
+  return t in e;
+}
+function q(t) {
+  return t;
+}
+function A(t) {
+  return t;
+}
+function M(t) {
+  return t;
+}
+function R(t) {
+  return t;
+}
+const m = {
+  locationInContextMenu: ["Standard Nodes"],
+  priorityInContextMenu: 200
+}, B = {
+  locationInContextMenu: ["Group Nodes"],
+  priorityInContextMenu: 100
+}, u = [
+  "groupInfer",
+  "loopInfer",
+  "switchInfer",
+  "condition",
+  "bindLoopNodes",
+  "bindSwitchNodes"
+], n = {
+  [u[0]]: u[0],
+  [u[1]]: u[1],
+  [u[2]]: u[2],
+  [u[3]]: u[3],
+  [u[4]]: u[4],
+  [u[5]]: u[5]
+}, s = [
+  "groupInput",
+  "groupOutput",
+  "loopStart",
+  "loopEnd",
+  "loopStop",
+  "switchStart",
+  "switchEnd"
+], r = {
+  [s[0]]: s[0],
+  [s[1]]: s[1],
+  [s[2]]: s[2],
+  [s[3]]: s[3],
+  [s[4]]: s[4],
+  [s[5]]: s[5],
+  [s[6]]: s[6]
+}, W = {
+  [n.groupInfer]: {
+    name: "Group Infer",
+    underlyingType: "inferFromConnection",
+    color: "#333333"
+  },
+  [n.loopInfer]: {
+    name: "Loop Infer",
+    underlyingType: "inferFromConnection",
+    color: "#333333"
+  },
+  [n.condition]: {
+    name: "Condition",
+    underlyingType: "boolean",
+    color: "#cca6d6",
+    allowInput: !0
+  },
+  [n.bindLoopNodes]: {
+    name: "Bind Loop Nodes",
+    underlyingType: "noEquivalent",
+    color: "#8c52d1",
+    maxConnections: 1
+  },
+  [n.switchInfer]: {
+    name: "Switch Infer",
+    underlyingType: "inferFromConnection",
+    color: "#333333"
+  },
+  [n.bindSwitchNodes]: {
+    name: "Bind Switch Nodes",
+    underlyingType: "noEquivalent",
+    color: "#8c52d1",
+    maxConnections: 1
+  }
+}, G = {
+  [r.groupInput]: {
+    name: "Group Input",
+    headerColor: "#1d1d1d",
+    ...m,
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        dataType: n.groupInfer
+      }
+    ]
+  },
+  [r.groupOutput]: {
+    name: "Group Output",
+    headerColor: "#1d1d1d",
+    ...m,
+    inputs: [
+      {
+        name: "",
+        dataType: n.groupInfer
+      }
+    ],
+    outputs: []
+  },
+  [r.loopStart]: {
+    name: "Loop Start",
+    headerColor: "#1d1d1d",
+    ...m,
+    inputs: [
+      {
+        name: "",
+        dataType: n.loopInfer
+      }
+    ],
+    outputs: [
+      {
+        name: "Bind Loop Nodes",
+        dataType: n.bindLoopNodes
+      },
+      {
+        name: "",
+        dataType: n.loopInfer
+      }
+    ]
+  },
+  [r.loopStop]: {
+    name: "Loop Stop",
+    headerColor: "#1d1d1d",
+    ...m,
+    inputs: [
+      {
+        name: "Bind Loop Nodes",
+        dataType: n.bindLoopNodes
+      },
+      {
+        name: "Continue If Condition Is True",
+        dataType: n.condition
+      },
+      {
+        name: "",
+        dataType: n.loopInfer
+      }
+    ],
+    outputs: [
+      {
+        name: "Bind Loop Nodes",
+        dataType: n.bindLoopNodes
+      },
+      {
+        name: "",
+        dataType: n.loopInfer
+      }
+    ]
+  },
+  [r.loopEnd]: {
+    name: "Loop End",
+    headerColor: "#1d1d1d",
+    ...m,
+    inputs: [
+      {
+        name: "Bind Loop Nodes",
+        dataType: n.bindLoopNodes
+      },
+      {
+        name: "",
+        dataType: n.loopInfer
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        dataType: n.loopInfer
+      }
+    ]
+  },
+  [r.switchStart]: {
+    name: "Switch Start",
+    headerColor: "#1d1d1d",
+    ...m,
+    inputs: [
+      {
+        name: "",
+        dataType: n.switchInfer
+      },
+      {
+        name: "Condition",
+        dataType: n.condition
+      }
+    ],
+    outputs: [
+      {
+        name: "Bind Switch Nodes",
+        dataType: n.bindSwitchNodes
+      },
+      {
+        name: "",
+        dataType: n.switchInfer
+      },
+      {
+        name: "",
+        dataType: n.switchInfer
+      }
+    ]
+  },
+  [r.switchEnd]: {
+    name: "Switch End",
+    headerColor: "#1d1d1d",
+    ...m,
+    inputs: [
+      {
+        name: "Bind Switch Nodes",
+        dataType: n.bindSwitchNodes
+      },
+      {
+        name: "",
+        dataType: n.switchInfer
+      },
+      {
+        name: "",
+        dataType: n.switchInfer
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        dataType: n.switchInfer
+      }
+    ]
+  }
+}, F = {
+  [r.groupInput]: !0,
+  [r.groupOutput]: !0,
+  [r.loopStart]: !0,
+  [r.loopStop]: !0,
+  [r.loopEnd]: !0,
+  [r.switchStart]: !0,
+  [r.switchEnd]: !0
+}, V = {
+  // A graph may declare its own I/O via ONE root-level Graph Input + ONE Graph
+  // Output (maxInRoot: 1) — these become the compiled program's parameters and
+  // return. Inside a group exactly one of each is still required (the group's
+  // boundary). See `.claude/plans/root-io-editors.md`.
+  [r.groupInput]: {
+    maxInRoot: 1,
+    minInRoot: 0,
+    minWithinANodeGroup: 1,
+    maxWithinANodeGroup: 1
+  },
+  [r.groupOutput]: {
+    maxInRoot: 1,
+    minInRoot: 0,
+    minWithinANodeGroup: 1,
+    maxWithinANodeGroup: 1
+  }
+}, $ = 0, j = 1, _ = 1, P = 2, z = 1, J = 2, K = 0, Y = 0, Q = 1, X = 2, Z = 1, ee = 1, ne = 0;
+function N(t, e) {
+  return process.env.NODE_ENV !== "production" && ((t.includes(":") || t.includes(">")) && console.warn(
+    `react-blender-nodes: Node ID "${t}" contains reserved characters (: or >). This may cause data corruption in the runner.`
+  ), (e.includes(":") || e.includes(">")) && console.warn(
+    `react-blender-nodes: Handle ID "${e}" contains reserved characters (: or >). This may cause data corruption in the runner.`
+  )), `${t}:${e}`;
+}
+function E(t) {
+  const e = [];
+  if (!t) return e;
+  for (const o of t)
+    if ("inputs" in o)
+      for (const a of o.inputs)
+        e.push(a);
+    else
+      e.push(o);
+  return e;
+}
+class C {
+  store;
+  prefix;
+  parent;
+  constructor(e = "", o = null) {
+    this.store = /* @__PURE__ */ new Map(), this.prefix = e, this.parent = o;
+  }
+  /**
+   * Store a value for an output handle.
+   */
+  set(e, o, a) {
+    this.store.set(this.prefix + N(e, o), a);
+  }
+  /**
+   * Get a value from a specific output handle.
+   * Falls back to parent scope if not found locally.
+   */
+  get(e, o) {
+    const a = this.prefix + N(e, o);
+    if (this.store.has(a))
+      return this.store.get(a);
+    if (this.parent)
+      return this.parent.get(e, o);
+  }
+  /**
+   * Check if a value exists for the given handle.
+   */
+  has(e, o) {
+    const a = this.prefix + N(e, o);
+    return this.store.has(a) ? !0 : this.parent ? this.parent.has(e, o) : !1;
+  }
+  /**
+   * Resolve all input values for a node based on the inputResolutionMap.
+   *
+   * Returns a Map keyed by handle **name** (as required by the
+   * FunctionImplementation contract).
+   *
+   * Fan-in: multiple edges into one handle → connections array has N entries.
+   * No edges + allowInput → isDefault=true, defaultValue from the UI.
+   */
+  resolveInputs(e, o, a, c) {
+    const p = /* @__PURE__ */ new Map(), l = E(o.inputs);
+    for (const d of l) {
+      if (!d.id || !d.name) continue;
+      const I = d.id, f = d.name, T = d.inferredDataType?.dataTypeUniqueId ?? d.dataType?.dataTypeUniqueId ?? "", g = N(e, I), y = a.get(g);
+      if (y && y.length > 0) {
+        const x = [];
+        for (const h of y) {
+          const w = c.get(h.sourceNodeId), S = (w?.data.outputs ?? []).find(
+            (b) => b.id === h.sourceHandleId
+          );
+          x.push({
+            value: this.get(h.sourceNodeId, h.sourceHandleId),
+            sourceNodeId: h.sourceNodeId,
+            sourceNodeName: w?.typeOfNode?.name ?? "",
+            sourceNodeCustomName: w?.data.customName,
+            sourceNodeTypeId: w?.data.nodeTypeUniqueId ?? "",
+            sourceHandleId: h.sourceHandleId,
+            sourceHandleName: S?.name ?? "",
+            sourceDataTypeId: S?.inferredDataType?.dataTypeUniqueId ?? S?.dataType?.dataTypeUniqueId ?? "",
+            edgeId: h.edgeId
+          });
+        }
+        p.set(f, {
+          connections: x,
+          handleId: I,
+          handleName: f,
+          dataTypeId: T,
+          isDefault: !1
+        });
+      } else d.allowInput && d.value !== void 0 ? p.set(f, {
+        connections: [],
+        handleId: I,
+        handleName: f,
+        dataTypeId: T,
+        isDefault: !0,
+        defaultValue: d.value
+      }) : p.set(f, {
+        connections: [],
+        handleId: I,
+        handleName: f,
+        dataTypeId: T,
+        isDefault: !0,
+        defaultValue: void 0
+      });
+    }
+    return p;
+  }
+  /**
+   * Build output handle info for a node.
+   *
+   * Returns a Map keyed by handle **name** (as required by the
+   * FunctionImplementation contract).
+   */
+  buildOutputInfo(e, o, a) {
+    const c = /* @__PURE__ */ new Map(), p = o.outputs;
+    if (!p) return c;
+    for (const l of p) {
+      if (!l.id || !l.name) continue;
+      const d = l.id, I = l.name, f = l.inferredDataType?.dataTypeUniqueId ?? l.dataType?.dataTypeUniqueId ?? "", T = N(e, d), g = a.get(T) ?? [];
+      c.set(I, {
+        handleId: d,
+        handleName: I,
+        dataTypeId: f,
+        connections: g.map((y) => ({
+          targetNodeId: y.targetNodeId,
+          targetHandleId: y.targetHandleId,
+          edgeId: y.edgeId
+        }))
+      });
+    }
+    return c;
+  }
+  /**
+   * Snapshot the entire store for recording in ExecutionRecord.
+   */
+  snapshot() {
+    return new Map(this.store);
+  }
+  /**
+   * Create a scoped store for group execution.
+   * The scoped store prefixes all IDs with "groupNodeId>" and
+   * falls back to the parent store for reads.
+   *
+   * **Important:** The `prefix` (typically a groupNodeId) must NOT contain
+   * `>` or `:` characters. `>` is the scope separator and `:` is the
+   * handle separator used by {@link qualifiedId}. Using these characters
+   * will cause key collisions and data corruption.
+   */
+  createScope(e) {
+    return process.env.NODE_ENV !== "production" && (e.includes(">") || e.includes(":")) && console.warn(
+      `react-blender-nodes: Scope prefix "${e}" contains reserved characters (> or :). This may cause data corruption in the runner.`
+    ), new C(`${e}>`, this);
+  }
+  /**
+   * Clear all values with the given prefix (for loop iteration reset).
+   */
+  clearScope(e) {
+    const o = `${e}>`;
+    for (const a of this.store.keys())
+      a.startsWith(o) && this.store.delete(a);
+  }
+}
+const D = /* @__PURE__ */ new Set([
+  n.bindLoopNodes,
+  n.loopInfer,
+  n.bindSwitchNodes,
+  n.switchInfer,
+  n.condition
+]);
+function H(t) {
+  return t.inferredDataType?.dataTypeUniqueId ?? t.dataType?.dataTypeUniqueId;
+}
+function te(t) {
+  return t.filter((e) => {
+    const o = H(e);
+    return e.id && o && !D.has(o);
+  }).map((e) => e.id);
+}
+function oe(t) {
+  return t.find(
+    (e) => H(e) === n.condition
+  )?.id;
+}
+function ae(t, e, o = "text/plain") {
+  if (typeof document > "u" || typeof URL > "u" || typeof URL.createObjectURL != "function")
+    return;
+  const a = new Blob([e], { type: o }), c = URL.createObjectURL(a), p = document.createElement("a");
+  p.href = c, p.download = t, p.click(), URL.revokeObjectURL(c);
+}
+function re(t, e) {
+  const o = t.get(e);
+  return o && o.connections.length > 0 ? o.connections.map((a) => a.value) : [o ? o.defaultValue : void 0];
+}
+export {
+  V as A,
+  u as B,
+  s as C,
+  $ as D,
+  j as E,
+  _ as F,
+  P as G,
+  z as H,
+  J as I,
+  K as J,
+  re as K,
+  C as V,
+  Q as a,
+  X as b,
+  Z as c,
+  ee as d,
+  ne as e,
+  n as f,
+  B as g,
+  E as h,
+  te as i,
+  oe as j,
+  ae as k,
+  Y as l,
+  O as m,
+  U as n,
+  q as o,
+  A as p,
+  N as q,
+  M as r,
+  r as s,
+  R as t,
+  L as u,
+  k as v,
+  m as w,
+  W as x,
+  G as y,
+  F as z
+};