@field/cascade 0.10.0 → 0.12.0

package/dist/cli/registerStandardNodes-BXJCB6E4.js

@@ -0,0 +1,744 @@
+import {
+  CORE_TYPES,
+  Node,
+  isCoreType,
+  registerNodeClasses
+} from "./chunk-CTPLRSWF.js";
+import "./chunk-RUU3YWXU.js";
+import {
+  randomFromSeed,
+  remap
+} from "./chunk-RXDIMXN5.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-FWMSGKEH.js";
+
+// src/nodes/core/nodes/SwitchNode.ts
+var SwitchNode = class extends Node {
+  constructor(id, graph) {
+    super(id, "Switch", graph);
+  }
+  /**
+   * Get the index of the currently active input
+   * Used by connection rendering to grey out inactive wires
+   */
+  get activeInputIndex() {
+    const inputs = this.getVariadicInputs();
+    return Math.min(this.props.index?.value ?? 0, inputs.length - 1);
+  }
+  /**
+   * Check if a specific input port is active (for connection coloring)
+   */
+  isInputActive(portId) {
+    const inputs = this.getVariadicInputs();
+    const activeIdx = this.activeInputIndex;
+    const portIndex = inputs.findIndex((p) => p.id === portId);
+    return portIndex === activeIdx;
+  }
+  setup() {
+    this.setVariadic();
+    this.output = this.out("output");
+    const index = this.param("index", 0, { type: "int", min: 0, max: 0, step: 1 });
+    index.documentField = "props";
+    this.watchProp("index", () => this.update());
+    this.onUpdate = () => this.update();
+    this.onReady = () => this.update();
+  }
+  onCook() {
+    this.update();
+  }
+  update() {
+    const inputs = this.getVariadicInputs();
+    const connectedCount = inputs.filter((p) => p.connections.length > 0).length;
+    this.updatePropParams("index", { max: Math.max(0, connectedCount - 1) });
+    const idx = Math.min(this.props.index.value, inputs.length - 1);
+    const selectedInput = inputs[idx];
+    if (selectedInput) {
+      this.output.setValue(selectedInput.value);
+      if (this.isPreviewValue(selectedInput.value)) {
+        this.preview = selectedInput.value;
+      } else {
+        this.preview = null;
+      }
+    } else {
+      this.output.setValue(null);
+      this.preview = null;
+    }
+  }
+};
+
+// src/nodes/core/nodes/MergeNode.ts
+var MergeNode = class extends Node {
+  constructor(id, graph) {
+    super(id, "Merge", graph);
+  }
+  setup() {
+    this.setVariadic();
+    this.output = this.out("output");
+    this.addParm("append", {
+      value: false,
+      type: "boolean",
+      displayName: "Append Mode",
+      hidden: () => {
+        const inputs = this.getVariadicInputs();
+        return !Array.isArray(inputs[0]?.value);
+      }
+    });
+    this.watchProp("append", () => this.update());
+    this.onUpdate = () => this.update();
+    this.onReady = () => this.update();
+  }
+  update() {
+    const inputs = this.getVariadicInputs();
+    const values = inputs.filter((p) => p.value !== null).map((p) => p.value);
+    const appendMode = this.props.append.value;
+    if (appendMode && values.length > 0 && Array.isArray(values[0])) {
+      const result = [...values[0], ...values.slice(1)];
+      this.output.setValue(result);
+    } else {
+      this.output.setValue(values);
+    }
+    this.preview = null;
+    for (const val of values) {
+      if (val instanceof HTMLCanvasElement || val instanceof HTMLImageElement) {
+        this.preview = val;
+        break;
+      }
+    }
+  }
+};
+
+// src/nodes/core/nodes/SubnetNode.ts
+var SubnetNode = class extends Node {
+  constructor(id, graph) {
+    super(id, "Subnet", graph);
+  }
+  setup() {
+    this.onUpdate = () => this.update();
+    this.onReady = () => {
+      this.syncPorts();
+      this.update();
+    };
+  }
+  /**
+   * Override: Subnets are networks and can contain children
+   */
+  isNetwork() {
+    return true;
+  }
+  /**
+   * Add a child node to this subnet
+   */
+  addChild(node) {
+    node.parent = this;
+    this._children.push(node);
+    if (node.type === "Input" || node.type === "Output") {
+      this.syncPorts();
+    }
+  }
+  /**
+   * Remove a child node from this subnet
+   */
+  removeChild(node) {
+    const index = this._children.indexOf(node);
+    if (index !== -1) {
+      const wasInputOutput = node.type === "Input" || node.type === "Output";
+      this._children.splice(index, 1);
+      node.parent = null;
+      if (wasInputOutput) {
+        this.syncPorts();
+      }
+    }
+  }
+  /**
+   * Sync input/output ports based on child Input/Output nodes
+   */
+  syncPorts() {
+    const inputNodes = this._children.filter((n) => n.type === "Input");
+    const maxInputIndex = inputNodes.reduce((max, node) => {
+      const idx = node.inputIndex ?? 0;
+      return Math.max(max, idx);
+    }, -1);
+    const outputNodes = this._children.filter((n) => n.type === "Output");
+    const maxOutputIndex = outputNodes.reduce((max, node) => {
+      const idx = node.outputIndex ?? 0;
+      return Math.max(max, idx);
+    }, -1);
+    const requiredInputs = maxInputIndex + 1;
+    const currentInputs = this.inputs.length;
+    for (let i = currentInputs; i < requiredInputs; i++) {
+      const boundary = inputNodes.find((n) => n.inputIndex === i);
+      const port = this.in(boundary?.inputName || `input_${i}`, null, {
+        type: boundary?.dataType || "any"
+      });
+      port.onChange = (value) => {
+        this._children.filter((n) => n.type === "Input" && n.inputIndex === i).forEach((n) => n.markDirty());
+      };
+    }
+    for (let i = requiredInputs; i < currentInputs; i++) {
+      if (this.inputs[i]) {
+        this.inputs[i].options = { ...this.inputs[i].options, hidden: true };
+      }
+    }
+    for (let i = 0; i < requiredInputs; i++) {
+      if (this.inputs[i]) {
+        const boundary = inputNodes.find((n) => n.inputIndex === i);
+        this.inputs[i].name = boundary?.inputName || `input_${i}`;
+        this.inputs[i].dataType = boundary?.dataType || "any";
+        this.inputs[i].options = { ...this.inputs[i].options, hidden: false };
+      }
+    }
+    const requiredOutputs = maxOutputIndex + 1;
+    const currentOutputs = this.outputs.length;
+    for (let i = currentOutputs; i < requiredOutputs; i++) {
+      const boundary = outputNodes.find((n) => n.outputIndex === i);
+      this.out(boundary?.outputName || `output_${i}`, "param", {
+        type: boundary?.dataType || "any"
+      });
+    }
+    for (let i = requiredOutputs; i < currentOutputs; i++) {
+      if (this.outputs[i]) {
+        this.outputs[i].options = { ...this.outputs[i].options, hidden: true };
+      }
+    }
+    for (let i = 0; i < requiredOutputs; i++) {
+      if (this.outputs[i]) {
+        const boundary = outputNodes.find((n) => n.outputIndex === i);
+        this.outputs[i].name = boundary?.outputName || `output_${i}`;
+        this.outputs[i].dataType = boundary?.dataType || "any";
+        this.outputs[i].options = { ...this.outputs[i].options, hidden: false };
+      }
+    }
+    this.inputs = [...this.inputs];
+    this.outputs = [...this.outputs];
+  }
+  /**
+   * Get the node that defines this subnet's output
+   * Priority: Output node > cooking node > last node
+   */
+  outputNode() {
+    const outputNode = this._children.find((n) => n.type === "Output");
+    if (outputNode) return outputNode;
+    const cookingNode = this._children.find((n) => n.cook);
+    if (cookingNode) return cookingNode;
+    return this._children.length > 0 ? this._children[this._children.length - 1] : null;
+  }
+  /**
+   * Get the cooking (display) node in this subnet
+   */
+  displayNode() {
+    return this._children.find((n) => n.cook) ?? null;
+  }
+  /**
+   * Get all Input nodes inside this subnet
+   */
+  indirectInputs() {
+    return this._children.filter((n) => n.type === "Input");
+  }
+  update() {
+    const outputNodes = this._children.filter((n) => n.type === "Output");
+    const outputByIndex = /* @__PURE__ */ new Map();
+    for (const node of outputNodes) {
+      const idx = node.outputIndex ?? 0;
+      outputByIndex.set(idx, node);
+    }
+    for (let i = 0; i < this.outputs.length; i++) {
+      const outNode = outputByIndex.get(i);
+      if (outNode && outNode.inputs.length > 0) {
+        const value = outNode.inputs[0].value;
+        this.outputs[i].setValue(value);
+        if (i === 0 && (value instanceof HTMLCanvasElement || value instanceof HTMLImageElement)) {
+          this.preview = value;
+        }
+      } else if (i === 0) {
+        const cookingNode = this._children.find((n) => n.cook);
+        if (cookingNode && cookingNode.outputs.length > 0) {
+          this.outputs[i].setValue(cookingNode.outputs[0].value);
+          if (cookingNode.preview) {
+            this.preview = cookingNode.preview;
+          }
+        } else {
+          this.outputs[i].setValue(null);
+        }
+      } else {
+        this.outputs[i].setValue(null);
+      }
+    }
+    if (this.outputs.length === 0 || !outputByIndex.has(0)) {
+      const cookingNode = this._children.find((n) => n.cook);
+      if (!cookingNode?.preview) {
+        this.preview = null;
+      }
+    }
+  }
+};
+
+// src/nodes/core/nodes/InputNode.ts
+var TYPE_CHOICES = CORE_TYPES.map((type) => ({ value: type, label: type }));
+var InputNode = class extends Node {
+  constructor(id, graph) {
+    super(id, "Input", graph);
+  }
+  setup() {
+    this.output = this.out("output");
+    this.addParm("inputIndex", {
+      value: 0,
+      type: "int",
+      params: { min: 0, step: 1 },
+      displayName: "Input Index"
+    });
+    this.addParm("inputName", {
+      value: "",
+      type: "text",
+      displayName: "Input Name"
+    });
+    this.addParm("dataType", {
+      value: "any",
+      type: "select",
+      params: { options: TYPE_CHOICES },
+      displayName: "Data Type"
+    });
+    const syncParent = () => {
+      if (this.parent && this.parent.syncPorts) {
+        this.parent.syncPorts();
+      }
+      this.update();
+    };
+    this.watchProp("inputIndex", syncParent);
+    this.watchProp("inputName", syncParent);
+    this.watchProp("dataType", () => {
+      this.output.dataType = this.dataType;
+      syncParent();
+    });
+    this.onUpdate = () => this.update();
+    this.onReady = () => this.update();
+  }
+  /**
+   * Get the input index this node represents
+   */
+  get inputIndex() {
+    return this.props.inputIndex?.value ?? 0;
+  }
+  /**
+   * Get the input name (for documentation)
+   */
+  get inputName() {
+    return this.props.inputName?.value ?? "";
+  }
+  get dataType() {
+    const value = this.props.dataType?.value;
+    return typeof value === "string" && isCoreType(value) ? value : "any";
+  }
+  update() {
+    if (this.parent && this.parent.inputs.length > 0) {
+      const idx = this.inputIndex;
+      const parentInput = this.parent.inputs[idx];
+      if (parentInput) {
+        this.output.setValue(parentInput.value);
+        if (this.isPreviewValue(parentInput.value)) {
+          this.preview = parentInput.value;
+        } else {
+          this.preview = null;
+        }
+        return;
+      }
+    }
+    this.output.setValue(null);
+    this.preview = null;
+  }
+};
+
+// src/nodes/core/nodes/OutputNode.ts
+var TYPE_CHOICES2 = CORE_TYPES.map((type) => ({ value: type, label: type }));
+var OutputNode = class extends Node {
+  constructor(id, graph) {
+    super(id, "Output", graph);
+  }
+  setup() {
+    this.in("input", null);
+    this.addParm("outputIndex", {
+      value: 0,
+      type: "int",
+      params: { min: 0, step: 1 },
+      displayName: "Output Index"
+    });
+    this.addParm("outputName", {
+      value: "",
+      type: "text",
+      displayName: "Output Name"
+    });
+    this.addParm("dataType", {
+      value: "any",
+      type: "select",
+      params: { options: TYPE_CHOICES2 },
+      displayName: "Data Type"
+    });
+    const syncParent = () => {
+      if (this.parent && this.parent.syncPorts) {
+        this.parent.syncPorts();
+      }
+      this.update();
+    };
+    this.watchProp("outputIndex", syncParent);
+    this.watchProp("outputName", syncParent);
+    this.watchProp("dataType", () => {
+      if (this.inputs[0]) this.inputs[0].dataType = this.dataType;
+      syncParent();
+    });
+    this.onUpdate = () => this.update();
+    this.onReady = () => this.update();
+  }
+  /**
+   * Get the output index this node represents
+   */
+  get outputIndex() {
+    return this.props.outputIndex?.value ?? 0;
+  }
+  get outputName() {
+    return this.props.outputName?.value ?? "";
+  }
+  get dataType() {
+    const value = this.props.dataType?.value;
+    return typeof value === "string" && isCoreType(value) ? value : "any";
+  }
+  update() {
+    const input = this.inputs[0];
+    if (input) {
+      if (this.isPreviewValue(input.value)) {
+        this.preview = input.value;
+      } else {
+        this.preview = null;
+      }
+    }
+  }
+};
+
+// src/nodes/core/nodes/RandomNode.ts
+var RandomNode = class extends Node {
+  constructor(id, graph) {
+    super(id, "Random", graph);
+  }
+  setup() {
+    const seed = this.in("seed", 0, { type: "int" });
+    const sample = this.in("sample", 0, { type: "int" });
+    const value = this.out("value");
+    const update = () => value.setValue(randomFromSeed(seed.value, sample.value));
+    seed.onChange = update;
+    sample.onChange = update;
+    this.onUpdate = update;
+    this.onReady = update;
+  }
+};
+
+// src/nodes/core/nodes/RemapNode.ts
+var RemapNode = class extends Node {
+  constructor(id, graph) {
+    super(id, "Remap", graph);
+  }
+  setup() {
+    const value = this.in("value", 0, { type: "float" });
+    const inMin = this.in("inMin", 0, { type: "float" });
+    const inMax = this.in("inMax", 1, { type: "float" });
+    const outMin = this.in("outMin", 0, { type: "float" });
+    const outMax = this.in("outMax", 1, { type: "float" });
+    const result = this.out("result");
+    this.addParm("clamp", { value: false, type: "boolean", displayName: "Clamp" });
+    const update = () => result.setValue(remap(
+      value.value,
+      inMin.value,
+      inMax.value,
+      outMin.value,
+      outMax.value,
+      this.props.clamp.value
+    ));
+    for (const input of [value, inMin, inMax, outMin, outMax]) input.onChange = update;
+    this.watchProp("clamp", update);
+    this.onUpdate = update;
+    this.onReady = update;
+  }
+};
+
+// src/nodes/core/nodes/SelectNode.ts
+var SelectNode = class extends Node {
+  constructor(id, graph) {
+    super(id, "Select", graph);
+  }
+  setup() {
+    this.arrayInput = this.in("array", [], { type: "array" });
+    this.itemOutput = this.out("item", "param");
+    this.countOutput = this.out("count", "param");
+    this.addParm("index", {
+      value: 0,
+      type: "int",
+      params: { min: 0, max: 0, step: 1 },
+      displayName: "Index"
+    });
+    this.addParm("wrap", {
+      value: true,
+      type: "boolean",
+      displayName: "Wrap Index"
+    });
+    this.watchProp("index", () => this.update());
+    this.watchProp("wrap", () => this.update());
+    this.onUpdate = () => this.update();
+    this.onReady = () => this.update();
+  }
+  update() {
+    const array = this.arrayInput.value;
+    if (!Array.isArray(array) || array.length === 0) {
+      this.itemOutput.setValue(null);
+      this.countOutput.setValue(0);
+      this.updatePropParams("index", { max: 0 });
+      return;
+    }
+    this.updatePropParams("index", { max: array.length - 1 });
+    let index = this.props.index?.value ?? 0;
+    const wrap = this.props.wrap?.value ?? true;
+    if (wrap && array.length > 0) {
+      index = (index % array.length + array.length) % array.length;
+    } else {
+      index = Math.max(0, Math.min(index, array.length - 1));
+    }
+    const item = array[index];
+    this.itemOutput.setValue(item);
+    this.countOutput.setValue(array.length);
+    if (item instanceof HTMLCanvasElement || item instanceof HTMLImageElement) {
+      this.preview = item;
+    } else {
+      this.preview = null;
+    }
+  }
+};
+
+// src/nodes/core/nodes/NullNode.ts
+var NullNode = class extends Node {
+  constructor(id, graph) {
+    super(id, "Null", graph);
+  }
+  setup() {
+    const input = this.in("input", null, { type: "any" });
+    const output = this.out("output");
+    const update = () => output.setValue(input.value);
+    input.onChange = update;
+    this.onUpdate = update;
+    this.onReady = update;
+  }
+};
+
+// src/nodes/image/surface.ts
+var globals = () => globalThis;
+function hasPixels(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  if (typeof candidate.width !== "number" || typeof candidate.height !== "number") return false;
+  return typeof candidate.getContext === "function" || "src" in candidate || typeof candidate.close === "function";
+}
+var MissingRenderSurfaceError = class extends Error {
+  constructor(kind) {
+    super(
+      `Cascade has no ${kind} in this environment. Install the optional '@napi-rs/canvas' renderer before cooking a graph that draws.`
+    );
+    this.name = "MissingRenderSurfaceError";
+  }
+};
+function provider() {
+  const host = globals();
+  if (typeof host.document?.createElement === "function") return domProvider;
+  if (typeof host.OffscreenCanvas === "function") return offscreenProvider;
+  return null;
+}
+function createSurface(width, height) {
+  const current = provider();
+  if (!current) throw new MissingRenderSurfaceError("drawing surface");
+  return current.createSurface(width, height);
+}
+function bytesOf(source) {
+  return source instanceof Uint8Array ? source : new Uint8Array(source);
+}
+async function decodeViaBitmap(source) {
+  const host = globals();
+  if (typeof host.createImageBitmap !== "function" || typeof source === "string") return null;
+  const input = source instanceof Uint8Array || source instanceof ArrayBuffer ? typeof host.Blob === "function" ? new host.Blob([bytesOf(source)]) : bytesOf(source) : source;
+  return host.createImageBitmap(input);
+}
+async function decodeViaImage(source) {
+  const host = globals();
+  if (typeof host.Image !== "function") throw new MissingRenderSurfaceError("image decoder");
+  const image = new host.Image();
+  if (typeof source === "string") {
+    if (!/^(data:|blob:)/.test(source)) image.crossOrigin = "anonymous";
+    image.src = source;
+  } else if (source instanceof Uint8Array || source instanceof ArrayBuffer) {
+    image.src = bytesOf(source);
+  } else {
+    image.src = new Uint8Array(await source.arrayBuffer());
+  }
+  await image.decode();
+  if (!image.width || !image.height) throw new Error("cascade: could not decode image data");
+  return image;
+}
+async function decode(source) {
+  if (typeof source !== "string") {
+    const bitmap = await decodeViaBitmap(source);
+    if (bitmap) return bitmap;
+  }
+  return decodeViaImage(source);
+}
+var domProvider = {
+  name: "DOM canvas",
+  createSurface(width, height) {
+    const surface = globals().document.createElement("canvas");
+    surface.width = width;
+    surface.height = height;
+    return surface;
+  },
+  decodeImage: decode
+};
+var offscreenProvider = {
+  name: "OffscreenCanvas",
+  createSurface(width, height) {
+    const Offscreen = globals().OffscreenCanvas;
+    return new Offscreen(width, height);
+  },
+  decodeImage: decode
+};
+
+// src/nodes/core/nodes/FreezeNode.ts
+function previewWanted() {
+  return typeof document !== "undefined";
+}
+var FreezeNode = class extends Node {
+  constructor(id, graph) {
+    super(id, "Freeze", graph);
+    this.frozenValue = null;
+    this.hasCaptured = false;
+  }
+  setup() {
+    this.input = this.in("input", null, { type: "any" });
+    this.output = this.out("output", "param");
+    this.addParm("frozen", {
+      value: false,
+      type: "boolean",
+      displayName: "Frozen"
+    });
+    this.addAction("capture", {
+      label: "Capture",
+      icon: "Camera",
+      callback: () => this.capture()
+    });
+    this.addAction("clear", {
+      label: "Clear",
+      icon: "Trash2",
+      callback: () => this.clear()
+    });
+    this.watchProp("frozen", () => this.update());
+    this.onUpdate = () => this.update();
+    this.onReady = () => this.update();
+  }
+  /**
+   * Capture the current input value
+   */
+  capture() {
+    this.frozenValue = this.deepClone(this.input.value);
+    this.hasCaptured = true;
+    this.setParm("frozen", true);
+    this.update();
+  }
+  /**
+   * Clear the frozen value
+   */
+  clear() {
+    this.frozenValue = null;
+    this.hasCaptured = false;
+    this.setParm("frozen", false);
+    this.update();
+  }
+  /**
+   * Deep clone a value if possible
+   */
+  deepClone(value) {
+    if (value === null || value === void 0) {
+      return value;
+    }
+    if (hasPixels(value)) {
+      const source = value;
+      const width = source.naturalWidth || source.width;
+      const height = source.naturalHeight || source.height;
+      const canvas = createSurface(width, height);
+      const ctx = canvas.getContext("2d");
+      ctx?.drawImage(value, 0, 0);
+      return canvas;
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.deepClone(item));
+    }
+    if (typeof value === "object") {
+      try {
+        return JSON.parse(JSON.stringify(value));
+      } catch {
+        return value;
+      }
+    }
+    return value;
+  }
+  update() {
+    const isFrozen = this.props.frozen?.value ?? false;
+    if (isFrozen && this.hasCaptured) {
+      this.output.setValue(this.frozenValue);
+      if (previewWanted() && hasPixels(this.frozenValue)) {
+        this.preview = this.frozenValue;
+      }
+    } else {
+      this.output.setValue(this.input.value);
+      if (previewWanted() && hasPixels(this.input.value)) {
+        this.preview = this.input.value;
+      } else {
+        this.preview = null;
+      }
+    }
+  }
+  /**
+   * Serialize with frozen state
+   */
+  serialize() {
+    return {
+      hasCaptured: this.hasCaptured
+    };
+  }
+  /**
+   * Deserialize and restore frozen state
+   */
+  deserialize(data) {
+    this.hasCaptured = data.hasCaptured === true;
+  }
+};
+
+// src/nodes/core/classes.ts
+var coreNodeClasses = {
+  "Switch": SwitchNode,
+  "Merge": MergeNode,
+  "Subnet": SubnetNode,
+  "Input": InputNode,
+  "Output": OutputNode,
+  "Random": RandomNode,
+  "Remap": RemapNode,
+  "Select": SelectNode,
+  "Null": NullNode,
+  "Freeze": FreezeNode
+};
+
+// src/nodes/registerStandardNodes.ts
+var registered = false;
+function registerStandardNodes() {
+  if (registered) return;
+  registerNodeClasses("core", coreNodeClasses);
+  registered = true;
+}
+function standardNodesRegistered() {
+  return registered;
+}
+export {
+  registerStandardNodes,
+  standardNodesRegistered
+};
+//# sourceMappingURL=registerStandardNodes-BXJCB6E4.js.map