@officexapp/vidfarm-devcli 0.21.10

package/dist/src/devcli/transitions.js

@@ -0,0 +1,205 @@
+// devcli `vidfarm transitions …` — first-class scene transitions for a
+// composition.html on disk. Pure local DOM edit (linkedom), no cloud, no
+// wallet; a running `vidfarm serve` live-morphs the change into open editor
+// tabs and `publish` pushes it like any browser edit. Same semantics as the
+// editor's timeline chips and the AI's set_transitions action: junction
+// transitions live as data-transition on the INCOMING clip (the stored
+// timeline stays butt-cut — the runtime/publish normalizer grants the
+// overlap), exit transitions as data-transition-out on the departing clip.
+import { readFileSync, writeFileSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { applyTransitionsAcross, clearAllTransitions, readTransitions, setLayerTransitions } from "./composition-edit.js";
+import { TRANSITION_OUT_PRESETS, TRANSITION_PRESETS } from "../hyperframes/composition.js";
+export const TRANSITIONS_HELP = `vidfarm transitions — scene transitions between clips (local file write)
+
+  transitions apply <dir|composition.html>   Apply across the whole timeline in one pass
+    --preset <p>              Junction preset applied at EVERY cut (every scene clip
+                              except each track's first). "none" clears junctions.
+    --duration <sec>          Transition length 0.1-2.5 (default 0.5)
+    --intro <p>               Entrance for the very FIRST clip (e.g. fade-black opens from black)
+    --outro <p>               Exit for the very LAST clip (e.g. fade-black ends on black)
+    --outro-duration <sec>    Outro length (defaults to --duration)
+    --json
+
+  transitions set <dir|composition.html> --layer <key>   Configure one clip
+    --in <p>                  Entrance preset ("none" clears)
+    --in-duration <sec>
+    --out <p>                 Exit preset ("none" clears)
+    --out-duration <sec>
+    --json
+
+  transitions list  <dir|composition.html> [--json]      Show transitions on every scene clip
+  transitions clear <dir|composition.html>               Remove all transitions
+
+Entrance presets: ${TRANSITION_PRESETS.join(" | ")}
+Exit presets:     ${TRANSITION_OUT_PRESETS.join(" | ")}
+
+The incoming clip owns the junction transition; the previous butt-cut clip is held on
+screen beneath it automatically in preview, serve live-morph, local render, and cloud
+render — never retime clips to "make room". Exit transitions play over the clip's last
+seconds via an inline delay, re-derived automatically after retimes.
+`;
+export async function runTransitionsCommand(argv) {
+    const sub = argv[0];
+    const rest = argv.slice(1);
+    switch (sub) {
+        case "apply":
+            return runApply(rest);
+        case "set":
+            return runSet(rest);
+        case "list":
+            return runList(rest);
+        case "clear":
+            return runClear(rest);
+        case undefined:
+        case "help":
+        case "--help":
+        case "-h":
+            console.log(TRANSITIONS_HELP);
+            return;
+        default:
+            console.error(`Unknown transitions subcommand: ${sub}\n`);
+            console.log(TRANSITIONS_HELP);
+            process.exitCode = 1;
+    }
+}
+// Same dir-or-file resolution as `vidfarm place` / `vidfarm captions`.
+function resolveCompositionHtml(target) {
+    if (!target)
+        throw new Error("Provide the composition dir or composition.html path.");
+    const abs = path.resolve(process.cwd(), target);
+    if (existsSync(abs) && statSync(abs).isDirectory()) {
+        const inside = path.join(abs, "composition.html");
+        if (!existsSync(inside))
+            throw new Error(`No composition.html inside ${abs}. Run \`vidfarm pull <forkId> --dir ${target}\` first.`);
+        return inside;
+    }
+    if (!existsSync(abs))
+        throw new Error(`No such composition file or dir: ${abs}.`);
+    return abs;
+}
+function num(values, key) {
+    const raw = values[key];
+    if (typeof raw !== "string" || !raw.trim())
+        return undefined;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        throw new Error(`--${key} must be a number.`);
+    return parsed;
+}
+function runApply(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            preset: { type: "string" },
+            duration: { type: "string" },
+            intro: { type: "string" },
+            outro: { type: "string" },
+            "outro-duration": { type: "string" },
+            json: { type: "boolean" }
+        }
+    });
+    const file = resolveCompositionHtml(positionals[0]);
+    const html = readFileSync(file, "utf8");
+    const result = applyTransitionsAcross(html, {
+        junction: typeof values.preset === "string" ? values.preset : undefined,
+        duration: num(values, "duration"),
+        intro: typeof values.intro === "string" ? values.intro : undefined,
+        outro: typeof values.outro === "string" ? values.outro : undefined,
+        outroDuration: num(values, "outro-duration")
+    });
+    writeFileSync(file, result.html, "utf8");
+    if (values.json) {
+        console.log(JSON.stringify({ file, junctions: result.junctions, intro: result.intro, outro: result.outro }, null, 2));
+        return;
+    }
+    const parts = [];
+    if (typeof values.preset === "string") {
+        parts.push(values.preset === "none" ? `cleared junction transitions on ${result.junctions} clips` : `${values.preset} at ${result.junctions} junctions`);
+    }
+    if (typeof values.intro === "string")
+        parts.push(values.intro === "none" ? "intro cleared" : `intro ${values.intro}`);
+    if (typeof values.outro === "string")
+        parts.push(values.outro === "none" ? "outro cleared" : `outro ${values.outro}`);
+    console.log(`Set scene transitions: ${parts.join(", ")}.`);
+    console.log(`Wrote ${file}`);
+}
+function runSet(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            layer: { type: "string" },
+            in: { type: "string" },
+            "in-duration": { type: "string" },
+            out: { type: "string" },
+            "out-duration": { type: "string" },
+            json: { type: "boolean" }
+        }
+    });
+    const file = resolveCompositionHtml(positionals[0]);
+    if (typeof values.layer !== "string" || !values.layer.trim()) {
+        throw new Error("transitions set requires --layer <layerKey|slug>.");
+    }
+    const html = readFileSync(file, "utf8");
+    const result = setLayerTransitions(html, values.layer, {
+        transition: typeof values.in === "string" ? values.in : undefined,
+        transitionDuration: num(values, "in-duration"),
+        transitionOut: typeof values.out === "string" ? values.out : undefined,
+        transitionOutDuration: num(values, "out-duration")
+    });
+    writeFileSync(file, result.html, "utf8");
+    if (values.json) {
+        console.log(JSON.stringify({ file, layerKey: result.layerKey, in: values.in ?? null, out: values.out ?? null }, null, 2));
+        return;
+    }
+    const parts = [];
+    if (typeof values.in === "string")
+        parts.push(`in=${values.in}`);
+    if (typeof values.out === "string")
+        parts.push(`out=${values.out}`);
+    console.log(`Updated transitions on ${result.layerKey} (${parts.join(" ")}).`);
+    console.log(`Wrote ${file}`);
+}
+function runList(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: { json: { type: "boolean" } }
+    });
+    const file = resolveCompositionHtml(positionals[0]);
+    const entries = readTransitions(readFileSync(file, "utf8"));
+    if (values.json) {
+        console.log(JSON.stringify(entries, null, 2));
+        return;
+    }
+    if (!entries.length) {
+        console.log("No scene clips found.");
+        return;
+    }
+    for (const entry of entries) {
+        const inLabel = entry.transition ? `${entry.transition} (${entry.transition_duration ?? 0.5}s)` : "-";
+        const outLabel = entry.transition_out ? `${entry.transition_out} (${entry.transition_out_duration ?? 0.5}s)` : "-";
+        console.log(`${entry.start.toFixed(2).padStart(8)}s  L${entry.track}  ${entry.layerKey.padEnd(28)}  in: ${inLabel.padEnd(22)}  out: ${outLabel}  ${entry.label ?? ""}`);
+    }
+}
+function runClear(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: { json: { type: "boolean" } }
+    });
+    const file = resolveCompositionHtml(positionals[0]);
+    const result = clearAllTransitions(readFileSync(file, "utf8"));
+    writeFileSync(file, result.html, "utf8");
+    if (values.json) {
+        console.log(JSON.stringify({ file, cleared: result.cleared }, null, 2));
+        return;
+    }
+    console.log(`Cleared transitions on ${result.cleared} clips.`);
+    console.log(`Wrote ${file}`);
+}
+//# sourceMappingURL=transitions.js.map