@field/cascade 0.8.0 → 0.11.0

package/dist/cli/chunk-YAT5Y25U.js

@@ -0,0 +1,121 @@
+// src/cli/encode.ts
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+var DEFAULT_CRF = 18;
+function timelineFrameSpec(document) {
+  const start = document?.timeline?.start;
+  const end = document?.timeline?.end;
+  if (typeof start !== "number" || typeof end !== "number") {
+    throw new Error("--frames timeline: the graph has no saved timeline range (set it in Studio's Timeline and save, or name the range: --frames 1-250)");
+  }
+  if (end < start) throw new Error(`--frames timeline: the saved end (${end}) is before the start (${start})`);
+  return { start, end };
+}
+function frameSequences(files) {
+  const sequences = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const match = /^(.*)\.(\d+)(\.[^./]+)$/.exec(file);
+    if (!match) throw new Error(`${file} is not a numbered frame`);
+    const key = `${match[1]}|${match[2].length}|${match[3]}`;
+    const entry = sequences.get(key) ?? { prefix: match[1], width: match[2].length, extension: match[3], files: [] };
+    entry.files.push(file);
+    sequences.set(key, entry);
+  }
+  return [...sequences.values()];
+}
+async function encodeMp4(options) {
+  const sequences = frameSequences(options.files);
+  if (sequences.length !== 1) {
+    const names = sequences.map((sequence) => path.basename(sequence.prefix));
+    throw new Error(`--mp4 encodes one sequence, and this run wrote ${sequences.length} (${names.join(", ")}). Name the one to encode with --node.`);
+  }
+  const { scale: _scale, ...video } = await encodeSequence({ ...options, sequence: sequences[0], codec: "h264" });
+  return video;
+}
+async function hasFfmpeg() {
+  try {
+    await run("ffmpeg", ["-version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function encodeSequence(options) {
+  const frames = options.frames;
+  const scale = options.scale ?? 1;
+  if (!(scale > 0 && scale <= 1)) throw new Error(`video scale must be greater than 0 and at most 1 (got ${scale})`);
+  if (!frames.length) throw new Error("--mp4: no frames were rendered");
+  for (let index = 1; index < frames.length; index += 1) {
+    if (frames[index] !== frames[index - 1] + 1) throw new Error("--mp4 needs a contiguous range of whole frames (no step)");
+  }
+  const { prefix, width, extension } = options.sequence;
+  const pattern = path.join(options.root, `${prefix}.%0${width}d${extension}`);
+  const output = path.resolve(options.root, options.file);
+  await fs.mkdir(path.dirname(output), { recursive: true });
+  const size = scale === 1 ? "pad=ceil(iw/2)*2:ceil(ih/2)*2" : `scale=trunc(iw*${scale}/2)*2:trunc(ih*${scale}/2)*2:flags=lanczos`;
+  const crf = options.crf ?? DEFAULT_CRF;
+  let pixelFormat;
+  let codecArgs;
+  if (options.codec === "prores") {
+    const first = path.join(options.root, `${prefix}.${String(frames[0]).padStart(width, "0")}${extension}`);
+    const alpha = await hasTransparency(first);
+    pixelFormat = alpha ? "yuva444p10le" : "yuv422p10le";
+    codecArgs = ["-c:v", "prores_ks", "-profile:v", alpha ? "4" : "3", "-vendor", "apl0", "-pix_fmt", pixelFormat];
+  } else {
+    pixelFormat = "yuv420p";
+    codecArgs = ["-c:v", "libx264", "-pix_fmt", pixelFormat, "-crf", String(crf), "-movflags", "+faststart"];
+  }
+  try {
+    await run("ffmpeg", [
+      "-nostdin",
+      "-y",
+      "-loglevel",
+      "error",
+      "-framerate",
+      String(options.fps),
+      "-start_number",
+      String(frames[0]),
+      "-i",
+      pattern,
+      "-frames:v",
+      String(frames.length),
+      "-vf",
+      size,
+      ...codecArgs,
+      "-r",
+      String(options.fps),
+      output
+    ], { maxBuffer: 16 * 1024 * 1024 });
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT") throw new Error("Encoding needs ffmpeg on the PATH (brew install ffmpeg)");
+    throw new Error(`ffmpeg failed: ${(err.stderr || err.message).trim()}`);
+  }
+  return {
+    file: path.relative(options.root, output).split(path.sep).join("/"),
+    codec: options.codec,
+    pixelFormat,
+    ...options.codec === "h264" ? { crf } : {},
+    fps: options.fps,
+    frames: frames.length,
+    scale
+  };
+}
+async function hasTransparency(file) {
+  const sharp = (await import("sharp")).default;
+  const stats = await sharp(file).stats();
+  return !stats.isOpaque;
+}
+
+export {
+  DEFAULT_CRF,
+  timelineFrameSpec,
+  frameSequences,
+  encodeMp4,
+  hasFfmpeg,
+  encodeSequence
+};
+//# sourceMappingURL=chunk-YAT5Y25U.js.map

package/dist/cli/chunk-ZL4JTG5Y.js

@@ -0,0 +1,37 @@
+// src/cli/runEnv.ts
+function parseEnvArgs(args) {
+  const pairs = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] !== "--env") continue;
+    const pair = args[index + 1];
+    if (pair === void 0) throw new Error("--env takes NAME=value");
+    pairs.push(pair);
+  }
+  if (!pairs.length) return void 0;
+  const env = {};
+  for (const pair of pairs) {
+    const at = pair.indexOf("=");
+    const name = at > 0 ? pair.slice(0, at) : "";
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) throw new Error(`--env takes NAME=value (got "${pair}")`);
+    env[name] = pair.slice(at + 1);
+  }
+  return env;
+}
+function applyEnv(env) {
+  if (!env) return () => {
+  };
+  const previous = Object.keys(env).map((name) => [name, process.env[name]]);
+  for (const [name, value] of Object.entries(env)) process.env[name] = value;
+  return () => {
+    for (const [name, value] of previous) {
+      if (value === void 0) delete process.env[name];
+      else process.env[name] = value;
+    }
+  };
+}
+
+export {
+  parseEnvArgs,
+  applyEnv
+};
+//# sourceMappingURL=chunk-ZL4JTG5Y.js.map