@field/cascade 0.10.0 → 0.12.0

package/dist/cli/generators-YU7GB4MD.js

@@ -0,0 +1,210 @@
+import {
+  Planar,
+  normalizeColor,
+  output
+} from "./chunk-WGKPJZDY.js";
+
+// packages/runtime/src/builtins/image/simplex.ts
+var SQRT3 = Math.sqrt(3);
+var F2 = 0.5 * (SQRT3 - 1);
+var G2 = (3 - SQRT3) / 6;
+var fastFloor = (x) => Math.floor(x) | 0;
+var grad2 = new Float64Array([1, 1, -1, 1, 1, -1, -1, -1, 1, 0, -1, 0, 1, 0, -1, 0, 0, 1, 0, -1, 0, 1, 0, -1]);
+function buildPermutationTable(random) {
+  const tableSize = 512;
+  const p = new Uint8Array(tableSize);
+  for (let i = 0; i < tableSize / 2; i++) p[i] = i;
+  for (let i = 0; i < tableSize / 2 - 1; i++) {
+    const r = i + ~~(random() * (256 - i));
+    const aux = p[i];
+    p[i] = p[r];
+    p[r] = aux;
+  }
+  for (let i = 256; i < tableSize; i++) p[i] = p[i - 256];
+  return p;
+}
+function createNoise2D(random) {
+  const perm = buildPermutationTable(random);
+  const permGrad2x = new Float64Array(perm).map((v) => grad2[v % 12 * 2]);
+  const permGrad2y = new Float64Array(perm).map((v) => grad2[v % 12 * 2 + 1]);
+  return function noise2D(x, y) {
+    let n0 = 0;
+    let n1 = 0;
+    let n2 = 0;
+    const s = (x + y) * F2;
+    const i = fastFloor(x + s);
+    const j = fastFloor(y + s);
+    const t = (i + j) * G2;
+    const X0 = i - t;
+    const Y0 = j - t;
+    const x0 = x - X0;
+    const y0 = y - Y0;
+    let i1, j1;
+    if (x0 > y0) {
+      i1 = 1;
+      j1 = 0;
+    } else {
+      i1 = 0;
+      j1 = 1;
+    }
+    const x1 = x0 - i1 + G2;
+    const y1 = y0 - j1 + G2;
+    const x2 = x0 - 1 + 2 * G2;
+    const y2 = y0 - 1 + 2 * G2;
+    const ii = i & 255;
+    const jj = j & 255;
+    let t0 = 0.5 - x0 * x0 - y0 * y0;
+    if (t0 >= 0) {
+      const gi0 = ii + perm[jj];
+      t0 *= t0;
+      n0 = t0 * t0 * (permGrad2x[gi0] * x0 + permGrad2y[gi0] * y0);
+    }
+    let t1 = 0.5 - x1 * x1 - y1 * y1;
+    if (t1 >= 0) {
+      const gi1 = ii + i1 + perm[jj + j1];
+      t1 *= t1;
+      n1 = t1 * t1 * (permGrad2x[gi1] * x1 + permGrad2y[gi1] * y1);
+    }
+    let t2 = 0.5 - x2 * x2 - y2 * y2;
+    if (t2 >= 0) {
+      const gi2 = ii + 1 + perm[jj + 1];
+      t2 *= t2;
+      n2 = t2 * t2 * (permGrad2x[gi2] * x2 + permGrad2y[gi2] * y2);
+    }
+    return 70 * (n0 + n1 + n2);
+  };
+}
+
+// packages/runtime/src/builtins/image/generators.ts
+function size(resolution) {
+  return [resolution[0], resolution[1]];
+}
+async function executeColor(context) {
+  const [width, height] = size(context.props.resolution);
+  await output(context, Planar.solid(width, height, normalizeColor(context.props.color)));
+}
+async function executeCheckers(context) {
+  const { props } = context;
+  const [width, height] = size(props.resolution);
+  const color1 = normalizeColor(props.color1);
+  const color2 = normalizeColor(props.color2);
+  const checkerSize = props.mode === "size" ? props.size : width / props.divisions;
+  let offsetX = 0;
+  let offsetY = 0;
+  if (props.centered) {
+    offsetX = width / 2 % checkerSize - checkerSize / 2;
+    offsetY = height / 2 % checkerSize - checkerSize / 2;
+  }
+  const buffer = Planar.rgba(width, height);
+  const [r, g, b, a] = buffer.channels;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const idx = y * width + x;
+      const even = (Math.floor((x - offsetX) / checkerSize) + Math.floor((y - offsetY) / checkerSize)) % 2 === 0;
+      const color = even ? color1 : color2;
+      r[idx] = color.r;
+      g[idx] = color.g;
+      b[idx] = color.b;
+      a[idx] = color.a;
+    }
+  }
+  await output(context, buffer);
+}
+async function executeNoise(context) {
+  const { props } = context;
+  const [width, height] = size(props.resolution);
+  let rng = props.seed;
+  const noise2D = createNoise2D(() => {
+    rng = (rng * 9301 + 49297) % 233280;
+    return rng / 233280;
+  });
+  const buffer = Planar.grayscale(width, height);
+  const gray = buffer.channels[0];
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      let value = 0;
+      let amplitude = 1;
+      let frequency = props.scale;
+      let maxValue = 0;
+      for (let i = 0; i < props.iterations; i++) {
+        value += noise2D(x * frequency, y * frequency) * amplitude;
+        maxValue += amplitude;
+        amplitude *= 0.5;
+        frequency *= 2;
+      }
+      gray[y * width + x] = (value / maxValue + 1) * 0.5;
+    }
+  }
+  await output(context, buffer);
+}
+function interpolateColor(color1, color2, t, interpolation) {
+  if (interpolation === "constant") return t < 0.5 ? color1 : color2;
+  if (interpolation === "smooth") t = t * t * (3 - 2 * t);
+  return {
+    r: color1.r + (color2.r - color1.r) * t,
+    g: color1.g + (color2.g - color1.g) * t,
+    b: color1.b + (color2.b - color1.b) * t,
+    a: (color1.a ?? 1) + ((color2.a ?? 1) - (color1.a ?? 1)) * t
+  };
+}
+function colorAt(points, position) {
+  const sorted = [...points].sort((a, b) => a.position - b.position);
+  position = Math.max(0, Math.min(1, position));
+  let before = null;
+  let after = null;
+  for (const point of sorted) {
+    if (point.position <= position) before = point;
+    if (point.position >= position && !after) {
+      after = point;
+      break;
+    }
+  }
+  if (!before && after) return normalizeColor(after.color);
+  if (before && !after) return normalizeColor(before.color);
+  if (!before || !after) return { r: 0, g: 0, b: 0, a: 1 };
+  if (before.position === position) return normalizeColor(before.color);
+  if (after.position === position) return normalizeColor(after.color);
+  const t = (position - before.position) / (after.position - before.position);
+  return interpolateColor(normalizeColor(before.color), normalizeColor(after.color), t, after.interpolation || "linear");
+}
+async function executeRamp(context) {
+  const { props } = context;
+  const [width, height] = size(props.resolution);
+  const points = props.points ?? [];
+  if (points.length === 0) return;
+  const buffer = Planar.rgba(width, height);
+  const [r, g, b, a] = buffer.channels;
+  const centerX = width / 2;
+  const centerY = height / 2;
+  const maxDist = Math.sqrt(centerX * centerX + centerY * centerY);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      let position = 0;
+      if (props.type === "horizontal") {
+        position = x / width;
+      } else if (props.type === "vertical") {
+        position = y / height;
+      } else if (props.type === "radial") {
+        position = (Math.atan2(y - centerY, x - centerX) + Math.PI) / (2 * Math.PI);
+      } else if (props.type === "concentric") {
+        const dx = x - centerX;
+        const dy = y - centerY;
+        position = Math.sqrt(dx * dx + dy * dy) / maxDist;
+      }
+      const color = colorAt(points, position);
+      const idx = y * width + x;
+      r[idx] = color.r;
+      g[idx] = color.g;
+      b[idx] = color.b;
+      a[idx] = color.a ?? 1;
+    }
+  }
+  await output(context, buffer);
+}
+export {
+  executeCheckers,
+  executeColor,
+  executeNoise,
+  executeRamp
+};
+//# sourceMappingURL=generators-YU7GB4MD.js.map

package/dist/cli/geo-6ZPGKZRU.js

@@ -0,0 +1,43 @@
+import {
+  browserAssetCapability
+} from "./chunk-ZSCUZE6I.js";
+import {
+  registerDefinitionNodes
+} from "./chunk-BPODRH52.js";
+import "./chunk-CTPLRSWF.js";
+import "./chunk-RUU3YWXU.js";
+import {
+  geoNodeDefinitions,
+  geoNodeRegistrations
+} from "./chunk-GRIN2DDP.js";
+import "./chunk-DEQSEFFH.js";
+import "./chunk-HSNOBIVT.js";
+import "./chunk-L6B6FUQP.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-J7VK7MNF.js";
+import "./chunk-FWMSGKEH.js";
+
+// src/nodes/geo/library.ts
+var geoLibrary = {
+  id: "geo",
+  label: "Geometry",
+  icon: "Shapes",
+  categories: [{
+    id: "geometry",
+    label: "Geometry",
+    nodes: geoNodeDefinitions.map(([moduleId, definition]) => ({
+      name: definition.label ?? moduleId.split(".").pop(),
+      icon: definition.icon ?? "Shapes",
+      description: definition.description ?? "",
+      type: moduleId
+    }))
+  }]
+};
+
+// src/nodes/geo/index.ts
+registerDefinitionNodes(geoNodeRegistrations, { assets: browserAssetCapability });
+export {
+  geoLibrary
+};
+//# sourceMappingURL=geo-6ZPGKZRU.js.map

package/dist/cli/graphCommands-EOUOBOIJ.js

@@ -0,0 +1,184 @@
+import {
+  VERBS,
+  graphOptions
+} from "./chunk-G23A2BZZ.js";
+
+// src/cli/graphCommands.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+var loadGraphFile = async () => (await import("./graphFile-YTGJB5F5.js")).GraphFile;
+async function runGraphCommand(args, options) {
+  const parsed = parseArguments(args);
+  const [command, ...rest] = parsed.positional;
+  const say = options.json ? () => {
+  } : (line) => console.log(line);
+  if (command === "graph") {
+    const [sub, file2] = rest;
+    if (sub === "create") {
+      const created = await (await loadGraphFile()).create(required(file2, "cascade graph create <graph>"), optional(parsed.values.name));
+      say(`created ${created}`);
+      return { file: created };
+    }
+    if (sub === "read") {
+      const graph = await (await loadGraphFile()).open(required(file2, "cascade graph read <graph>"));
+      const { readGraph } = await import("./edit-S5KEQ5RA.js");
+      const read = readGraph(graph.document, optional(parsed.values.in, "in"));
+      if (!options.json) printGraph(read);
+      return { file: graph.file, ...read };
+    }
+    if (sub === "list") {
+      const listed = await listGraphs(file2 ?? ".");
+      for (const entry of listed) say(`${entry.file}  ${entry.name ?? ""}  (${entry.nodes} nodes, ${entry.wires} wires)`);
+      return { graphs: listed };
+    }
+    throw new Error("usage: cascade graph create|read|list ...");
+  }
+  const twoWords = command === "node" || command === "subnet";
+  const [file, ...operands] = twoWords ? rest.slice(1) : rest;
+  const graphFile = required(file, `cascade ${command} <graph> ...`);
+  const operations = command === "edit" ? await readOperations(required(operands[0], "cascade edit <graph> <operations.json | ->")) : [operationFor(twoWords ? `${command} ${rest[0]}` : command, operands, parsed)];
+  return applyEdits(graphFile, operations, { dryRun: parsed.flags.has("dry-run"), json: options.json });
+}
+function operationFor(name, operands, parsed) {
+  const verb = VERBS.find((candidate) => candidate.handler === "graph" && (candidate.name === name || candidate.aliases?.includes(name)));
+  if (!verb?.operation) throw new Error(`Unknown graph command: cascade ${name}. Run "cascade --help".`);
+  return verb.operation(operands, parsed);
+}
+async function applyEdits(file, operations, options = {}) {
+  const graph = await (await loadGraphFile()).open(file);
+  const outcome = await graph.applyAll(operations, { dryRun: options.dryRun === true });
+  if (!options.json) for (const result of outcome.results) console.log(describe(result));
+  for (const warning of outcome.warnings) console.warn(options.json ? warning : `warning: ${warning}`);
+  if (options.dryRun && !options.json) console.log("dry run: nothing written");
+  return { file: graph.file, changed: outcome.changed, dryRun: options.dryRun === true, results: outcome.results };
+}
+function describe(result) {
+  const node = result.node;
+  const at = (summary) => `${summary.position.x},${summary.position.y}`;
+  switch (result.op) {
+    case "node.add":
+      return `added ${node.id} (${node.module})${node.parent ? ` in ${node.parent}` : ""} at ${at(node)}`;
+    case "node.remove": {
+      const wires = result.wires;
+      return `removed ${result.removed.join(", ")}${wires.length ? `; unwired ${wires.join(", ")}` : ""}`;
+    }
+    case "connect": {
+      const moved = result.moved;
+      return `connected ${result.wire}${result.replaced ? ` (replaced ${result.replaced})` : ""}${moved ? `; placed ${moved.id} at ${at(moved)}` : ""}`;
+    }
+    case "disconnect":
+      return `disconnected ${result.removed.join(", ")}`;
+    case "set":
+      return `set ${result.node}.${result.param}: ${show(result.before)} -> ${show(result.after)}`;
+    case "subnet.create": {
+      const subnet = result.subnet;
+      const inputs = result.inputs;
+      const outputs = result.outputs;
+      return `created subnet ${subnet.id}${inputs.length ? `; inputs ${inputs.join(", ")}` : ""}${outputs.length ? `; outputs ${outputs.join(", ")}` : ""}`;
+    }
+    case "subnet.move":
+      return `moved ${result.moved.join(", ")} to ${result.to ?? "the top level"}`;
+    case "subnet.dissolve":
+      return `dissolved; lifted ${result.lifted.join(", ") || "nothing"}`;
+    default:
+      return JSON.stringify(result);
+  }
+}
+function show(value) {
+  return value === void 0 || value === null ? "(default)" : JSON.stringify(value);
+}
+function printGraph(read) {
+  console.log(`${read.name ?? "(untitled)"}: ${read.nodes.length} nodes, ${read.wires.length} wires`);
+  const byParent = /* @__PURE__ */ new Map();
+  for (const node of read.nodes) byParent.set(node.parent, [...byParent.get(node.parent) ?? [], node]);
+  const print = (parent, depth) => {
+    for (const node of byParent.get(parent) ?? []) {
+      const ports = node.ports ? `  in: ${node.ports.inputs.join(", ") || "-"}  out: ${node.ports.outputs.join(", ") || "-"}` : "";
+      const props = node.props ? `  ${JSON.stringify(node.props)}` : "";
+      console.log(`${"  ".repeat(depth)}${node.id}  ${node.module}${ports}${props}`);
+      print(node.id, depth + 1);
+    }
+  };
+  print(read.nodes.some((node) => node.parent === null) ? null : read.nodes[0]?.parent ?? null, 1);
+  if (read.wires.length) console.log("wires:");
+  for (const wire of read.wires) console.log(`  ${wire}`);
+}
+async function listGraphs(directory) {
+  const skip = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".cascade-cache", ".cascade", "renders", "out"]);
+  const found = [];
+  const walk = async (dir, depth) => {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      if (entry.isDirectory() && depth < 3 && !skip.has(entry.name) && !entry.name.startsWith(".")) await walk(path.join(dir, entry.name), depth + 1);
+      else if (entry.isFile() && entry.name.endsWith(".cascade")) found.push(path.join(dir, entry.name));
+    }
+  };
+  await walk(path.resolve(directory), 0);
+  return Promise.all(found.map(async (file) => {
+    try {
+      const document = JSON.parse(await fs.readFile(file, "utf8"));
+      return {
+        file: path.relative(process.cwd(), file) || file,
+        name: typeof document.metadata?.name === "string" ? document.metadata.name : null,
+        nodes: Array.isArray(document.nodes) ? document.nodes.length : 0,
+        wires: Array.isArray(document.connections) ? document.connections.length : 0
+      };
+    } catch {
+      return { file: path.relative(process.cwd(), file) || file, name: null, nodes: 0, wires: 0 };
+    }
+  }));
+}
+async function readOperations(source) {
+  const text = source === "-" ? await readStdin() : await fs.readFile(source, "utf8");
+  const parsed = JSON.parse(text);
+  const operations = Array.isArray(parsed) ? parsed : parsed?.operations;
+  if (!Array.isArray(operations)) throw new Error('cascade edit expects a JSON array of operations, or { "operations": [...] }');
+  return operations;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+var OPTIONS = graphOptions();
+function parseArguments(args) {
+  const positional = [];
+  const values = {};
+  const lists = {};
+  const flags = /* @__PURE__ */ new Set();
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (!argument.startsWith("--")) {
+      positional.push(argument);
+      continue;
+    }
+    const [name, inline] = argument.slice(2).split(/=(.*)/s, 2);
+    if (OPTIONS.flag.has(name)) {
+      flags.add(name);
+      continue;
+    }
+    if (!OPTIONS.value.has(name) && !OPTIONS.list.has(name)) throw new Error(`Unknown option --${name}`);
+    const value = inline ?? args[++index];
+    if (value === void 0) throw new Error(`--${name} needs a value`);
+    if (OPTIONS.list.has(name)) (lists[name] ??= []).push(value);
+    else values[name] = value;
+  }
+  return { positional, values, lists, flags };
+}
+function required(value, usage) {
+  if (!value) throw new Error(`usage: ${usage}`);
+  return value;
+}
+function optional(value, key = "name") {
+  return value === void 0 ? {} : { [key]: value };
+}
+export {
+  applyEdits,
+  runGraphCommand
+};
+//# sourceMappingURL=graphCommands-EOUOBOIJ.js.map