@field/cascade 0.10.0 → 0.12.0

package/dist/cli/chunk-HFHWYL55.js

@@ -0,0 +1,139 @@
+import {
+  ExpressionEvaluator,
+  isEmptyChannel,
+  parseBundleFieldPath,
+  sampleChannel
+} from "./chunk-CO22XHNG.js";
+
+// packages/runtime/src/params/resolve.ts
+function isBoundProp(binding) {
+  if (!binding) return false;
+  return !!binding.expression || !isEmptyChannel(binding.channel);
+}
+function resolvePropBinding(binding, context) {
+  if (!isEmptyChannel(binding.channel)) {
+    const sampled = sampleChannel(binding.channel, context.frame);
+    if (sampled !== void 0) return { value: sampled, source: "channel" };
+  }
+  if (binding.expression && context.evaluateExpression) {
+    const result = context.evaluateExpression(binding.expression);
+    if (result?.error) {
+      return { value: binding.value, source: "value", error: result.error };
+    }
+    if (result) return { value: result.value, source: "expression" };
+  }
+  return { value: binding.value, source: "value" };
+}
+
+// packages/runtime/src/params/animator.ts
+var PropAnimator = class {
+  constructor(topology) {
+    this.topology = topology;
+    this.resolving = /* @__PURE__ */ new Set();
+    this.evaluator = new ExpressionEvaluator(this.scope());
+  }
+  /** True when any parameter in the graph is bound at all — so a host can skip
+   *  the whole pass, and a graph with no animation costs nothing. */
+  get animated() {
+    return this.topology.nodes.some(
+      (node) => Object.values(node.bindings).some((binding) => isBoundProp(binding))
+    );
+  }
+  setFrame(frame) {
+    this.evaluator.setFrame(frame);
+  }
+  setFps(fps) {
+    this.evaluator.setFps(fps);
+  }
+  /** Write every bound parameter's value at the current frame into `props`. */
+  resolveAll() {
+    for (const node of this.topology.nodes)
+      for (const name of Object.keys(node.bindings)) this.resolve(node, name);
+  }
+  /** Re-resolve one node's bound parameters, e.g. once its inputs exist. */
+  resolveNode(node) {
+    for (const name of Object.keys(node.bindings)) this.resolve(node, name);
+  }
+  /**
+   * One parameter, at the current frame.
+   *
+   * Re-entry returns the stored value rather than throwing: a parameter whose
+   * expression refers back to itself is an author's mistake, and the render
+   * that names it is more use than the one that dies.
+   */
+  resolve(node, name) {
+    const binding = node.bindings[name];
+    if (!binding) return node.props[name];
+    const key = `${node.id}.${name}`;
+    if (this.resolving.has(key)) return binding.value;
+    this.resolving.add(key);
+    try {
+      const resolved = resolvePropBinding(binding, {
+        frame: this.evaluator.fframe,
+        evaluateExpression: (expression) => this.evaluator.evaluate(expression, node)
+      });
+      if (resolved.error) this.topology.report?.(node.id, name, resolved.error);
+      node.props[name] = resolved.value;
+      return resolved.value;
+    } finally {
+      this.resolving.delete(key);
+    }
+  }
+  /**
+   * The host binding the expression engine reads through.
+   *
+   * A path names a parameter — `./radius`, `../blur1/amount`,
+   * `/root/blur1/amount` — and the last segment is always the parameter, the
+   * one before it the node. Anything a graph does not have resolves to null,
+   * which the engine turns into 0 / '' / [] per accessor rather than an
+   * exception: one broken reference must not take a render down.
+   */
+  scope() {
+    return {
+      resolveParam: (from, path) => {
+        const segments = split(path);
+        if (!segments.length) return null;
+        const name = segments[segments.length - 1];
+        const owner = this.owner(from, segments.slice(0, -1));
+        if (!owner) return null;
+        if (owner.bindings[name]) return { value: this.resolve(owner, name) };
+        const field = parseBundleFieldPath(name);
+        if (field && this.topology.inputValue) {
+          const bundle = this.topology.inputValue(owner, field.port);
+          if (bundle === null || typeof bundle !== "object") return null;
+          if (!Object.prototype.hasOwnProperty.call(bundle, field.field)) return null;
+          return { value: bundle[field.field] };
+        }
+        if (name in owner.props) return { value: owner.props[name] };
+        if (name in owner.inputs) return { value: owner.inputs[name] };
+        return null;
+      },
+      nodeExists: (from, path) => {
+        const segments = split(path);
+        if (!segments.length) return false;
+        const last = segments[segments.length - 1];
+        if (last === "..") return true;
+        return last === from.id || !!this.topology.node(last);
+      },
+      inputNode: (from, index) => this.topology.inputNode(from, index)
+    };
+  }
+  /** The node a path's leading segments name, or `from` when they name none. */
+  owner(from, segments) {
+    for (let i = segments.length - 1; i >= 0; i--) {
+      if (segments[i] === "..") continue;
+      return this.topology.node(segments[i]);
+    }
+    return from;
+  }
+};
+function split(path) {
+  return String(path ?? "").split("/").filter((segment) => segment.length > 0 && segment !== ".");
+}
+
+export {
+  isBoundProp,
+  resolvePropBinding,
+  PropAnimator
+};
+//# sourceMappingURL=chunk-HFHWYL55.js.map

package/dist/cli/chunk-HSNOBIVT.js

@@ -0,0 +1,263 @@
+import {
+  POSITION_ATTRIBUTE,
+  PRIMITIVE_KINDS,
+  attributeArray,
+  attributeArrayFrom,
+  createGeometry,
+  isStringAttribute
+} from "./chunk-J7VK7MNF.js";
+
+// packages/runtime/src/geometry/attributes.ts
+function geometryError(code, message) {
+  throw new TypeError(`geometry/${code}: ${message}`);
+}
+function attributeSet(geometry, level) {
+  return geometry[level];
+}
+function numericAttribute(attribute, path, sizes) {
+  if (attribute === void 0) return void 0;
+  if (isStringAttribute(attribute))
+    geometryError("attribute-storage", `${path} must be numeric`);
+  if (sizes !== void 0 && !sizes.includes(attribute.size))
+    geometryError(
+      "attribute-size",
+      `${path} has size ${attribute.size}; expected ${sizes.join(" or ")}`
+    );
+  return attribute;
+}
+function readComponent(attribute, index, component = 0) {
+  return attribute.data[index * attribute.size + component];
+}
+function readElement(attribute, index) {
+  const values = new Array(attribute.size);
+  for (let component = 0; component < attribute.size; component += 1)
+    values[component] = attribute.data[index * attribute.size + component];
+  return values;
+}
+function readString(attribute, index) {
+  const slot = attribute.data[index];
+  return slot < 0 ? "" : attribute.table[slot] ?? "";
+}
+function positionSize(geometry) {
+  return geometry.point[POSITION_ATTRIBUTE].size;
+}
+function positionAttribute(geometry) {
+  return geometry.point[POSITION_ATTRIBUTE];
+}
+function getPosition(geometry, index) {
+  return readElement(positionAttribute(geometry), index);
+}
+function createAttribute(count, size, storage = "f64", fill) {
+  const data = attributeArray(storage, size * count);
+  if (fill !== void 0) {
+    const values = typeof fill === "number" ? [fill] : fill;
+    for (let index = 0; index < count; index += 1)
+      for (let component = 0; component < size; component += 1)
+        data[index * size + component] = values[component % Math.max(values.length, 1)] ?? 0;
+  }
+  return { storage, size, data };
+}
+function createStringAttribute(values) {
+  const table = [];
+  const slots = /* @__PURE__ */ new Map();
+  const data = new Int32Array(values.length);
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index];
+    let slot = slots.get(value);
+    if (slot === void 0) {
+      slot = table.length;
+      table.push(value);
+      slots.set(value, slot);
+    }
+    data[index] = slot;
+  }
+  return { storage: "string", size: 1, table, data };
+}
+function withAttributeSet(geometry, level, set) {
+  return createGeometry({
+    pointCount: geometry.pointCount,
+    point: level === "point" ? set : geometry.point,
+    vertex: level === "vertex" ? set : geometry.vertex,
+    primitive: level === "primitive" ? set : geometry.primitive,
+    detail: geometry.detail,
+    topology: geometry.topology,
+    pointGroups: geometry.pointGroups,
+    primitiveGroups: geometry.primitiveGroups
+  });
+}
+function setAttribute(geometry, level, name, attribute) {
+  return withAttributeSet(geometry, level, {
+    ...geometry[level],
+    [name]: attribute
+  });
+}
+function copyAttributeArray(attribute) {
+  return attributeArrayFrom(attribute.storage, attribute.data);
+}
+
+// packages/runtime/src/geometry/builder.ts
+var GeometryBuilder = class {
+  constructor(options = {}) {
+    this.positions = [];
+    this.vertexPoints = [];
+    this.offsets = [0];
+    this.kinds = [];
+    this.closed = [];
+    this.attributes = { point: {}, vertex: {}, primitive: {} };
+    this.detail = {};
+    this.pointGroups = /* @__PURE__ */ new Map();
+    this.primitiveGroups = /* @__PURE__ */ new Map();
+    this.size = options.positionSize ?? 2;
+    this.storage = options.positionStorage ?? "f64";
+  }
+  get pointCount() {
+    return this.positions.length / this.size;
+  }
+  get vertexCount() {
+    return this.vertexPoints.length;
+  }
+  get primitiveCount() {
+    return this.offsets.length - 1;
+  }
+  /** Append one point and return its index. */
+  addPoint(x, y, z = 0) {
+    const index = this.pointCount;
+    this.positions.push(x, y);
+    if (this.size === 3) this.positions.push(z);
+    return index;
+  }
+  /** Append points from a flat array of `positionSize`-wide entries. */
+  addPoints(flat) {
+    if (flat.length % this.size !== 0)
+      geometryError(
+        "point-stride",
+        `${flat.length} values is not a multiple of the position size ${this.size}`
+      );
+    const first = this.pointCount;
+    for (let index = 0; index < flat.length; index += 1)
+      this.positions.push(flat[index]);
+    return first;
+  }
+  /**
+   * Append one primitive over existing point indices and return its index. A
+   * closed primitive does not repeat its first point: `closed` is topology, not
+   * a duplicated vertex.
+   */
+  addPrimitive(points, options = {}) {
+    const index = this.primitiveCount;
+    for (const point of points) {
+      if (!Number.isInteger(point) || point < 0 || point >= this.pointCount)
+        geometryError(
+          "vertex-point",
+          `primitive ${index} references point ${point} of ${this.pointCount}`
+        );
+      this.vertexPoints.push(point);
+    }
+    this.offsets.push(this.vertexPoints.length);
+    this.kinds.push(PRIMITIVE_KINDS.indexOf(options.kind ?? "poly"));
+    this.closed.push(options.closed ? 1 : 0);
+    return index;
+  }
+  /** Append points and one primitive over them, the common generator case. */
+  addPolygon(flat, options = {}) {
+    const first = this.addPoints(flat);
+    const points = [];
+    for (let index = first; index < this.pointCount; index += 1)
+      points.push(index);
+    return this.addPrimitive(points, options);
+  }
+  setAttribute(level, name, attribute) {
+    if (level === "point" && name === POSITION_ATTRIBUTE)
+      geometryError(
+        "set-position",
+        "point.P is owned by the builder; use addPoint"
+      );
+    this.attributes[level][name] = attribute;
+    return this;
+  }
+  setNumericAttribute(level, name, values, size = 1, storage = "f64") {
+    return this.setAttribute(level, name, {
+      storage,
+      size,
+      data: attributeArrayFrom(storage, values)
+    });
+  }
+  setStringAttribute(level, name, values) {
+    return this.setAttribute(level, name, createStringAttribute(values));
+  }
+  setDetail(name, value) {
+    this.detail[name] = value;
+    return this;
+  }
+  addToPointGroup(name, index) {
+    const members = this.pointGroups.get(name) ?? /* @__PURE__ */ new Set();
+    members.add(index);
+    this.pointGroups.set(name, members);
+    return this;
+  }
+  addToPrimitiveGroup(name, index) {
+    const members = this.primitiveGroups.get(name) ?? /* @__PURE__ */ new Set();
+    members.add(index);
+    this.primitiveGroups.set(name, members);
+    return this;
+  }
+  build() {
+    const pointCount = this.pointCount;
+    const pointGroups = {};
+    for (const [name, members] of this.pointGroups)
+      pointGroups[name] = mask(members, pointCount);
+    const primitiveGroups = {};
+    for (const [name, members] of this.primitiveGroups)
+      primitiveGroups[name] = mask(members, this.primitiveCount);
+    return createGeometry({
+      pointCount,
+      point: {
+        ...this.attributes.point,
+        [POSITION_ATTRIBUTE]: {
+          storage: this.storage,
+          size: this.size,
+          data: attributeArrayFrom(this.storage, this.positions)
+        }
+      },
+      vertex: this.attributes.vertex,
+      primitive: this.attributes.primitive,
+      detail: this.detail,
+      topology: {
+        vertexPoints: Int32Array.from(this.vertexPoints),
+        offsets: Int32Array.from(this.offsets),
+        kinds: Uint8Array.from(this.kinds),
+        closed: Uint8Array.from(this.closed)
+      },
+      pointGroups,
+      primitiveGroups
+    });
+  }
+};
+function mask(members, count) {
+  const result = new Uint8Array(count);
+  for (const member of members) {
+    if (!Number.isInteger(member) || member < 0 || member >= count)
+      geometryError("group-indices", `group references element ${member}`);
+    result[member] = 1;
+  }
+  return result;
+}
+
+export {
+  geometryError,
+  attributeSet,
+  numericAttribute,
+  readComponent,
+  readElement,
+  readString,
+  positionSize,
+  positionAttribute,
+  getPosition,
+  createAttribute,
+  createStringAttribute,
+  withAttributeSet,
+  setAttribute,
+  copyAttributeArray,
+  GeometryBuilder
+};
+//# sourceMappingURL=chunk-HSNOBIVT.js.map

package/dist/cli/chunk-ICH7N5PN.js

@@ -0,0 +1,26 @@
+// src/cli/sequence.ts
+import path from "node:path";
+function sequenceWidth(end) {
+  return Math.max(4, String(Math.floor(end)).length);
+}
+function sequenceFileName(nodeId, frame, source, width, port) {
+  const extension = path.extname(source) || ".png";
+  const safe = (text) => text.replace(/[^a-zA-Z0-9_-]/g, "_");
+  const stem = port ? `${safe(nodeId)}.${safe(port)}` : safe(nodeId);
+  return `${stem}.${String(Math.floor(frame)).padStart(width, "0")}${extension}`;
+}
+function imagePath(value) {
+  if (typeof value === "string") return value || null;
+  if (value && typeof value === "object") {
+    const candidate = value.path;
+    if (typeof candidate === "string" && candidate) return candidate;
+  }
+  return null;
+}
+
+export {
+  sequenceWidth,
+  sequenceFileName,
+  imagePath
+};
+//# sourceMappingURL=chunk-ICH7N5PN.js.map