@field/cascade 0.10.0 → 0.11.0

package/dist/cli/chunk-CO22XHNG.js

@@ -0,0 +1,593 @@
+// packages/runtime/src/animation/frameRange.ts
+function frameRange(start, end, step = 1) {
+  if (!Number.isFinite(start) || !Number.isFinite(end)) {
+    throw new Error(`frameRange: start and end must be finite (got ${start}, ${end})`);
+  }
+  if (!Number.isFinite(step) || step <= 0) {
+    throw new Error(`frameRange: step must be a finite number greater than 0 (got ${step})`);
+  }
+  if (end < start) {
+    throw new Error(`frameRange: end (${end}) must not be before start (${start})`);
+  }
+  const span = end - start;
+  const count = Math.floor(span / step + 1e-9) + 1;
+  const frames = new Array(count);
+  for (let i = 0; i < count; i++) frames[i] = start + i * step;
+  return frames;
+}
+async function runFrameRange(clock, options) {
+  const { start, end, step = 1, onFrame, signal, restoreFrame = true } = options;
+  const frames = frameRange(start, end, step);
+  const previousFrame = clock.getFrameFraction();
+  const visited = [];
+  let aborted = false;
+  try {
+    for (let index = 0; index < frames.length; index++) {
+      if (signal?.aborted) {
+        aborted = true;
+        break;
+      }
+      clock.setFrame(frames[index]);
+      clock.markTimeDependentDirty();
+      await onFrame({
+        index,
+        total: frames.length,
+        frame: clock.getFrame(),
+        fframe: clock.getFrameFraction(),
+        time: clock.getTime(),
+        fps: clock.getFps()
+      });
+      visited.push(clock.getFrameFraction());
+    }
+  } finally {
+    if (restoreFrame) {
+      clock.setFrame(previousFrame);
+      clock.markTimeDependentDirty();
+    }
+  }
+  return { frames: visited, frameCount: visited.length, aborted };
+}
+
+// packages/runtime/src/animation/channel.ts
+var DEFAULT_INTERPOLATION = "smooth";
+var INTERPOLATIONS = ["constant", "linear", "smooth"];
+function isInterpolation(value) {
+  return typeof value === "string" && INTERPOLATIONS.includes(value);
+}
+var EMPTY_CHANNEL = Object.freeze({ keys: Object.freeze([]) });
+function createChannel(keys = []) {
+  const byFrame = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    if (!key) continue;
+    const frame = Number(key.frame);
+    const value = Number(key.value);
+    if (!Number.isFinite(frame) || !Number.isFinite(value)) continue;
+    byFrame.set(frame, {
+      frame,
+      value,
+      interpolation: isInterpolation(key.interpolation) ? key.interpolation : DEFAULT_INTERPOLATION
+    });
+  }
+  const sorted = [...byFrame.values()].sort((a, b) => a.frame - b.frame);
+  return { keys: sorted };
+}
+function isEmptyChannel(channel) {
+  return !channel || channel.keys.length === 0;
+}
+function keyAt(channel, frame) {
+  return channel.keys.find((key) => key.frame === frame);
+}
+function setKey(channel, frame, value, interpolation) {
+  const base = channel ?? EMPTY_CHANNEL;
+  if (!Number.isFinite(frame) || !Number.isFinite(value)) return createChannel(base.keys);
+  const existing = keyAt(base, frame);
+  const mode = interpolation ?? existing?.interpolation ?? DEFAULT_INTERPOLATION;
+  const kept = base.keys.filter((key) => key.frame !== frame);
+  return createChannel([...kept, { frame, value, interpolation: mode }]);
+}
+function deleteKey(channel, frame) {
+  const base = channel ?? EMPTY_CHANNEL;
+  return createChannel(base.keys.filter((key) => key.frame !== frame));
+}
+function sampleChannel(channel, frame) {
+  if (!channel || channel.keys.length === 0) return void 0;
+  const keys = channel.keys;
+  if (!Number.isFinite(frame)) return keys[0].value;
+  if (keys.length === 1) return keys[0].value;
+  if (frame <= keys[0].frame) return keys[0].value;
+  if (frame >= keys[keys.length - 1].frame) return keys[keys.length - 1].value;
+  const i = segmentIndex(keys, frame);
+  const k0 = keys[i];
+  const k1 = keys[i + 1];
+  const span = k1.frame - k0.frame;
+  if (span <= 0) return k1.value;
+  const t = (frame - k0.frame) / span;
+  switch (k0.interpolation) {
+    case "constant":
+      return k0.value;
+    case "linear":
+      return k0.value + (k1.value - k0.value) * t;
+    case "smooth":
+    default:
+      return hermite(keys, i, t, span);
+  }
+}
+function segmentIndex(keys, frame) {
+  let lo = 0;
+  let hi = keys.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (keys[mid].frame <= frame) lo = mid;
+    else hi = mid - 1;
+  }
+  return Math.min(lo, keys.length - 2);
+}
+function hermite(keys, i, t, span) {
+  const k0 = keys[i];
+  const k1 = keys[i + 1];
+  const m0 = tangent(keys, i, "out");
+  const m1 = tangent(keys, i + 1, "in");
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const h00 = 2 * t3 - 3 * t2 + 1;
+  const h10 = t3 - 2 * t2 + t;
+  const h01 = -2 * t3 + 3 * t2;
+  const h11 = t3 - t2;
+  return h00 * k0.value + h10 * span * m0 + h01 * k1.value + h11 * span * m1;
+}
+function tangent(keys, i, side) {
+  const prev = keys[i - 1];
+  const next = keys[i + 1];
+  if (!prev || !next) return 0;
+  if (side === "out" && prev.interpolation === "constant") return 0;
+  if (side === "in" && keys[i].interpolation === "constant") return 0;
+  const span = next.frame - prev.frame;
+  if (span <= 0) return 0;
+  return (next.value - prev.value) / span;
+}
+function serializeChannel(channel) {
+  if (isEmptyChannel(channel)) return void 0;
+  return {
+    keys: channel.keys.map((key) => key.interpolation === DEFAULT_INTERPOLATION ? { frame: key.frame, value: key.value } : { frame: key.frame, value: key.value, interpolation: key.interpolation })
+  };
+}
+function deserializeChannel(data) {
+  if (!data || typeof data !== "object") return EMPTY_CHANNEL;
+  const keys = data.keys;
+  if (!Array.isArray(keys)) return EMPTY_CHANNEL;
+  return createChannel(keys);
+}
+
+// packages/runtime/src/expressions/time.ts
+var DEFAULT_FPS = 30;
+var MIN_FRAME = 1;
+var TimeState = class {
+  constructor() {
+    /** Exact, possibly fractional frame. Never below MIN_FRAME. */
+    this._frame = MIN_FRAME;
+    this._fps = DEFAULT_FPS;
+  }
+  /**
+   * Set the current frame. Fractional values are preserved; only the lower
+   * bound is enforced. Non-finite input is ignored.
+   */
+  setFrame(frame) {
+    if (!Number.isFinite(frame)) return;
+    this._frame = Math.max(MIN_FRAME, frame);
+  }
+  /** Set the current time in seconds, keeping the sub-frame remainder. */
+  setTime(seconds) {
+    if (!Number.isFinite(seconds)) return;
+    this.setFrame(seconds * this._fps + MIN_FRAME);
+  }
+  setFps(fps) {
+    if (!Number.isFinite(fps)) return;
+    this._fps = Math.max(1, fps);
+  }
+  /** Integer frame — $F. */
+  get frame() {
+    return Math.floor(this._frame);
+  }
+  /** Fractional frame — $FF. */
+  get frameFraction() {
+    return this._frame;
+  }
+  /**
+   * Seconds — $T. Derived from the fractional frame, so it round-trips.
+   *
+   * Zero at the first frame, which is Houdini's convention: $T = ($FF - 1)/$FPS.
+   * The previous definition was frame/fps, making $T equal 1/fps at frame 1 —
+   * so `sin($T)` started part-way through its cycle and an animation's first
+   * frame was never t=0. Changed 2026-09-07 because Marcus named Houdini as the
+   * reference for these variables, and because "time starts at zero" is the
+   * thing anybody writing an expression will assume.
+   */
+  get time() {
+    return (this._frame - MIN_FRAME) / this._fps;
+  }
+  /** Frame rate — $FPS. */
+  get fps() {
+    return this._fps;
+  }
+  /** Immutable snapshot of the four time variables. */
+  snapshot() {
+    return {
+      frame: this.frame,
+      frameFraction: this.frameFraction,
+      time: this.time,
+      fps: this.fps
+    };
+  }
+};
+
+// packages/runtime/src/expressions/bundlePaths.ts
+var REFERENCE = /\b(?:ch|chs|chv)\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+function parseBundleFieldPath(path) {
+  const local = path.startsWith("./") ? path.slice(2) : path;
+  if (local.includes("/")) return null;
+  const dot = local.indexOf(".");
+  if (dot <= 0 || dot === local.length - 1) return null;
+  return { port: local.slice(0, dot), field: local.slice(dot + 1) };
+}
+function bundleFieldReferences(expression) {
+  const references = [];
+  REFERENCE.lastIndex = 0;
+  let match;
+  while ((match = REFERENCE.exec(expression)) !== null) {
+    const parsed = parseBundleFieldPath(match[1]);
+    if (parsed) references.push({ ...parsed, path: match[1] });
+  }
+  return references;
+}
+function remoteBundlePath(path) {
+  const local = path.startsWith("./") ? path.slice(2) : path;
+  const slash = local.lastIndexOf("/");
+  if (slash === -1) return null;
+  const last = local.slice(slash + 1);
+  const dot = last.indexOf(".");
+  if (dot <= 0 || dot === last.length - 1) return null;
+  const node = local.slice(0, slash).split("/").filter((part) => part && part !== "." && part !== "..").pop();
+  if (!node) return null;
+  return { node, port: last.slice(0, dot), field: last.slice(dot + 1) };
+}
+
+// packages/runtime/src/expressions/math.ts
+function fit(value, oldMin, oldMax, newMin, newMax) {
+  if (oldMax === oldMin) return newMin;
+  const t = (value - oldMin) / (oldMax - oldMin);
+  return newMin + t * (newMax - newMin);
+}
+function fit01(value, newMin, newMax) {
+  return newMin + value * (newMax - newMin);
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function smooth(value, min, max) {
+  if (value <= min) return 0;
+  if (value >= max) return 1;
+  const t = (value - min) / (max - min);
+  return t * t * (3 - 2 * t);
+}
+function noise(...coords) {
+  if (coords.length === 0) return 0;
+  let result = 0;
+  const frequencies = [1, 2.3, 4.7, 8.1];
+  const amplitudes = [1, 0.5, 0.25, 0.125];
+  for (let i = 0; i < frequencies.length; i++) {
+    let sum = 0;
+    for (let j = 0; j < coords.length; j++) {
+      sum += Math.sin(coords[j] * frequencies[i] * (j + 1) * 1.7 + j * 3.14159);
+    }
+    result += sum * amplitudes[i];
+  }
+  return Math.sin(result * 0.5);
+}
+function random(seed) {
+  const x = Math.sin(seed * 12.9898) * 43758.5453;
+  return x - Math.floor(x);
+}
+function padzero(digits, value) {
+  return String(Math.floor(value)).padStart(digits, "0");
+}
+function radians(degrees2) {
+  return degrees2 * Math.PI / 180;
+}
+function degrees(radians2) {
+  return radians2 * 180 / Math.PI;
+}
+function sind(degrees2) {
+  return Math.sin(radians(degrees2));
+}
+function cosd(degrees2) {
+  return Math.cos(radians(degrees2));
+}
+function tand(degrees2) {
+  return Math.tan(radians(degrees2));
+}
+var MATH_SCOPE = {
+  // Trigonometry, in radians
+  sin: Math.sin,
+  cos: Math.cos,
+  tan: Math.tan,
+  asin: Math.asin,
+  acos: Math.acos,
+  atan: Math.atan,
+  atan2: Math.atan2,
+  sinh: Math.sinh,
+  cosh: Math.cosh,
+  tanh: Math.tanh,
+  // Trigonometry, in degrees, for formulae carried over from Houdini
+  sind,
+  cosd,
+  tand,
+  radians,
+  degrees,
+  // Powers and logs
+  sqrt: Math.sqrt,
+  cbrt: Math.cbrt,
+  pow: Math.pow,
+  exp: Math.exp,
+  log: Math.log,
+  log2: Math.log2,
+  log10: Math.log10,
+  hypot: Math.hypot,
+  // Rounding and sign
+  abs: Math.abs,
+  sign: Math.sign,
+  floor: Math.floor,
+  ceil: Math.ceil,
+  round: Math.round,
+  trunc: Math.trunc,
+  min: Math.min,
+  max: Math.max,
+  // Constants
+  PI: Math.PI,
+  TAU: Math.PI * 2,
+  E: Math.E
+};
+
+// packages/runtime/src/expressions/preprocess.ts
+var DOLLAR_TIME_PATTERN = /\$(FPS|FF|F|T)\b/g;
+var BARE_TIME_PATTERN = /\b(?:time|frame|fframe|fps)\b/;
+var DOLLAR_TO_IDENTIFIER = {
+  FPS: "fps",
+  FF: "fframe",
+  F: "frame",
+  T: "time"
+};
+function codeSpans(source) {
+  const spans = [];
+  let spanStart = 0;
+  let index = 0;
+  while (index < source.length) {
+    const char = source[index];
+    if (char === '"' || char === "'" || char === "`") {
+      spans.push({ start: spanStart, end: index });
+      const quote = char;
+      index += 1;
+      while (index < source.length) {
+        if (source[index] === "\\") {
+          index += 2;
+          continue;
+        }
+        if (source[index] === quote) {
+          index += 1;
+          break;
+        }
+        index += 1;
+      }
+      spanStart = index;
+      continue;
+    }
+    index += 1;
+  }
+  spans.push({ start: spanStart, end: source.length });
+  return spans;
+}
+function preprocessExpression(source) {
+  if (!source.includes("$")) return source;
+  let out = "";
+  let cursor = 0;
+  for (const span of codeSpans(source)) {
+    if (span.start > cursor) out += source.slice(cursor, span.start);
+    out += source.slice(span.start, span.end).replace(DOLLAR_TIME_PATTERN, (_match, key) => DOLLAR_TO_IDENTIFIER[key]);
+    cursor = span.end;
+  }
+  if (cursor < source.length) out += source.slice(cursor);
+  return out;
+}
+function hasTimeReference(source) {
+  if (BARE_TIME_PATTERN.test(source)) return true;
+  DOLLAR_TIME_PATTERN.lastIndex = 0;
+  return DOLLAR_TIME_PATTERN.test(source);
+}
+
+// packages/runtime/src/expressions/evaluator.ts
+var DEPENDENCY_PATTERN = /\b(?:ch|chs|chv)\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+var ExpressionEvaluator = class {
+  constructor(scope = null) {
+    this.timeState = new TimeState();
+    this.compiledCache = /* @__PURE__ */ new Map();
+    this.scope = scope;
+  }
+  /** Bind (or rebind) the host scope. Clears nothing: compilation is scope-free. */
+  setScope(scope) {
+    this.scope = scope;
+  }
+  getScope() {
+    return this.scope;
+  }
+  // ============ Time ============
+  /** Set the current frame. Fractional frames are preserved. */
+  setFrame(frame) {
+    this.timeState.setFrame(frame);
+  }
+  /** Set the current time in seconds, keeping the sub-frame remainder. */
+  setTime(seconds) {
+    this.timeState.setTime(seconds);
+  }
+  setFps(fps) {
+    this.timeState.setFps(fps);
+  }
+  /** seconds — $T */
+  get time() {
+    return this.timeState.time;
+  }
+  /** integer frame — $F */
+  get frame() {
+    return this.timeState.frame;
+  }
+  /** fractional frame — $FF */
+  get fframe() {
+    return this.timeState.frameFraction;
+  }
+  /** rate — $FPS */
+  get fps() {
+    return this.timeState.fps;
+  }
+  // ============ Compile / evaluate ============
+  compile(expression) {
+    const cached = this.compiledCache.get(expression);
+    if (cached) return cached;
+    const dependencies = this.extractDependencies(expression);
+    const isTimeDependent = hasTimeReference(expression);
+    const compiledSource = preprocessExpression(expression);
+    try {
+      const fnBody = `
+        with (context) {
+          return (${compiledSource});
+        }
+      `;
+      const evaluator = new Function("context", fnBody);
+      const compiled = {
+        source: expression,
+        compiledSource,
+        evaluate: evaluator,
+        dependencies,
+        isTimeDependent
+      };
+      this.compiledCache.set(expression, compiled);
+      return compiled;
+    } catch (err) {
+      return {
+        source: expression,
+        compiledSource,
+        evaluate: () => void 0,
+        dependencies,
+        isTimeDependent,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  evaluate(expression, node) {
+    const compiled = this.compile(expression);
+    if (compiled.error) return { value: void 0, error: compiled.error };
+    try {
+      return { value: compiled.evaluate(this.createContext(node)) };
+    } catch (err) {
+      return {
+        value: void 0,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /** Build the context an expression sees. */
+  createContext(node) {
+    return {
+      time: this.timeState.time,
+      frame: this.timeState.frame,
+      fframe: this.timeState.frameFraction,
+      fps: this.timeState.fps,
+      self: node,
+      ch: (path) => this.ch(node, path),
+      chs: (path) => this.chs(node, path),
+      chv: (path) => this.chv(node, path),
+      opexist: (path) => this.scope?.nodeExists(node, path) ? 1 : 0,
+      opinput: (index) => this.scope?.inputNode(node, index) ?? null,
+      fit,
+      fit01,
+      clamp,
+      lerp,
+      smooth,
+      noise,
+      random,
+      padzero,
+      // Bare maths — `sin($FF * 0.5)` rather than `Math.sin(...)`. Spread
+      // before `Math` so nothing here can shadow the namespace itself.
+      ...MATH_SCOPE,
+      Math
+    };
+  }
+  // ============ Channel functions ============
+  ch(node, path) {
+    const resolved = this.resolveParam(node, path);
+    if (!resolved) return 0;
+    const value = resolved.value;
+    if (typeof value === "number") return value;
+    if (typeof value === "string") return parseFloat(value) || 0;
+    if (typeof value === "boolean") return value ? 1 : 0;
+    return 0;
+  }
+  chs(node, path) {
+    const resolved = this.resolveParam(node, path);
+    if (!resolved) return "";
+    return String(resolved.value ?? "");
+  }
+  chv(node, path) {
+    const resolved = this.resolveParam(node, path);
+    if (!resolved) return [];
+    const value = resolved.value;
+    if (Array.isArray(value)) {
+      return value.map((v) => typeof v === "number" ? v : parseFloat(String(v)) || 0);
+    }
+    if (typeof value === "number") return [value];
+    return [];
+  }
+  resolveParam(node, path) {
+    return this.scope?.resolveParam(node, path) ?? null;
+  }
+  /** True if a referenced path resolves from this node. */
+  validatePath(fromNode, path) {
+    return this.resolveParam(fromNode, path) !== null;
+  }
+  /** Parameter paths referenced through ch/chs/chv. */
+  extractDependencies(expression) {
+    const deps = [];
+    DEPENDENCY_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = DEPENDENCY_PATTERN.exec(expression)) !== null) {
+      deps.push(match[1]);
+    }
+    return deps;
+  }
+  /** True if the expression references time, in either the bare or `$` spelling. */
+  hasTimeReference(expression) {
+    return hasTimeReference(expression);
+  }
+  clearCache() {
+    this.compiledCache.clear();
+  }
+};
+
+export {
+  isEmptyChannel,
+  setKey,
+  deleteKey,
+  sampleChannel,
+  serializeChannel,
+  deserializeChannel,
+  frameRange,
+  runFrameRange,
+  DEFAULT_FPS,
+  MIN_FRAME,
+  TimeState,
+  ExpressionEvaluator,
+  parseBundleFieldPath,
+  bundleFieldReferences,
+  remoteBundlePath
+};
+//# sourceMappingURL=chunk-CO22XHNG.js.map