@bendyline/squisq-cli 1.2.2 → 2.0.0

package/dist/api.js

@@ -1,7 +1,15 @@
+import {
+  GIF_EXPORT_DEFAULTS,
+  framesToGifNative,
+  framesToGifNativeBytes,
+  framesToMp4Native,
+  framesToMp4NativeBytes
+} from "./chunk-ESFEFKY4.js";
+
 // src/api.ts
 import { resolveMediaSchedule } from "@bendyline/squisq/schemas";
 import { flattenBlocks } from "@bendyline/squisq/doc";
-import { generateRenderHtml } from "@bendyline/squisq-video";
+import { ffmpegGifOutputArgs, generateRenderHtml } from "@bendyline/squisq-video";
 import { resolveDimensions } from "@bendyline/squisq-video";
 import { convert as formatsConvert } from "@bendyline/squisq-formats";
 
@@ -49,10 +57,6 @@ async function detectFfmpegDetailed() {
   }
   return null;
 }
-async function detectFfmpeg() {
-  const detection = await detectFfmpegDetailed();
-  return detection?.path ?? null;
-}
 
 // src/util/audioMix.ts
 import { computeAudioTimeline } from "@bendyline/squisq-video";
@@ -127,6 +131,14 @@ async function mixTimelineClips(ffmpegPath, usable) {
   }
 }
 
+// src/util/coverPreRoll.ts
+function resolveAppliedCoverPreRoll(requestedSeconds, hasCover) {
+  if (!Number.isFinite(requestedSeconds) || requestedSeconds < 0) {
+    throw new Error("Cover pre-roll must be a finite number of seconds greater than or equal to 0");
+  }
+  return hasCover ? requestedSeconds : 0;
+}
+
 // src/registry.ts
 import { randomBytes } from "crypto";
 import { readFile, rm } from "fs/promises";
@@ -137,7 +149,19 @@ var MP4_DEFAULTS = {
   fps: 30,
   quality: "normal",
   orientation: "landscape",
-  coverPreRoll: 0
+  coverPreRoll: 0,
+  animationsEnabled: true
+};
+var GIF_DEFAULTS = {
+  fps: 10,
+  orientation: "landscape",
+  width: 960,
+  height: 540,
+  coverPreRoll: 0,
+  animationsEnabled: false,
+  loop: 0,
+  maxColors: 256,
+  dither: "sierra2_4a"
 };
 function mp4Format() {
   return {
@@ -151,14 +175,20 @@ function mp4Format() {
       const quality = typeof mp4Opts.quality === "string" ? mp4Opts.quality : MP4_DEFAULTS.quality;
       const orientation = typeof mp4Opts.orientation === "string" ? mp4Opts.orientation : MP4_DEFAULTS.orientation;
       const coverPreRoll = typeof mp4Opts.coverPreRoll === "number" ? mp4Opts.coverPreRoll : MP4_DEFAULTS.coverPreRoll;
+      const animationsEnabled = typeof mp4Opts.animationsEnabled === "boolean" ? mp4Opts.animationsEnabled : MP4_DEFAULTS.animationsEnabled;
       const outputPath = join(tmpdir(), `squisq-mp4-${randomBytes(8).toString("hex")}.mp4`);
       try {
-        await renderDocToMp4(input.doc, input.container, {
+        const { renderDocToMp4: renderDocToMp42 } = await import("./api.js");
+        await renderDocToMp42(input.doc, input.container, {
           outputPath,
           fps,
           quality,
           orientation,
-          coverPreRoll
+          width: mp4Opts.width,
+          height: mp4Opts.height,
+          captionStyle: mp4Opts.captionStyle,
+          coverPreRoll,
+          animationsEnabled
         });
         const data = await readFile(outputPath);
         const bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
@@ -169,27 +199,64 @@ function mp4Format() {
     }
   };
 }
+function gifFormat() {
+  return {
+    id: "gif",
+    label: "Animated GIF",
+    mimeType: "image/gif",
+    extensions: [".gif"],
+    async exportDoc(input, options) {
+      const gifOpts = options.formatOptions?.gif ?? {};
+      const orientation = typeof gifOpts.orientation === "string" ? gifOpts.orientation : GIF_DEFAULTS.orientation;
+      const portrait = orientation === "portrait";
+      const defaultWidth = portrait ? GIF_DEFAULTS.height : GIF_DEFAULTS.width;
+      const defaultHeight = portrait ? GIF_DEFAULTS.width : GIF_DEFAULTS.height;
+      const outputPath = join(tmpdir(), `squisq-gif-${randomBytes(8).toString("hex")}.gif`);
+      try {
+        const { renderDocToGif: renderDocToGif2 } = await import("./api.js");
+        const result = await renderDocToGif2(input.doc, input.container, {
+          outputPath,
+          fps: typeof gifOpts.fps === "number" ? gifOpts.fps : GIF_DEFAULTS.fps,
+          orientation,
+          width: typeof gifOpts.width === "number" ? gifOpts.width : defaultWidth,
+          height: typeof gifOpts.height === "number" ? gifOpts.height : defaultHeight,
+          captionStyle: gifOpts.captionStyle,
+          coverPreRoll: typeof gifOpts.coverPreRoll === "number" ? gifOpts.coverPreRoll : GIF_DEFAULTS.coverPreRoll,
+          animationsEnabled: typeof gifOpts.animationsEnabled === "boolean" ? gifOpts.animationsEnabled : GIF_DEFAULTS.animationsEnabled,
+          loop: typeof gifOpts.loop === "number" ? gifOpts.loop : GIF_DEFAULTS.loop,
+          maxColors: typeof gifOpts.maxColors === "number" ? gifOpts.maxColors : GIF_DEFAULTS.maxColors,
+          dither: gifOpts.dither ?? GIF_DEFAULTS.dither,
+          bayerScale: gifOpts.bayerScale
+        });
+        const data = await readFile(outputPath);
+        const bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        return {
+          bytes,
+          mimeType: "image/gif",
+          suggestedFilename: "",
+          warnings: result.warnings
+        };
+      } finally {
+        await rm(outputPath, { force: true });
+      }
+    }
+  };
+}
 function createCliRegistry() {
   const registry = defaultRegistry();
   registry.register(mp4Format());
+  registry.register(gifFormat());
   return registry;
 }
 
 // src/api.ts
 import { MemoryContentContainer as MemoryContentContainer2 } from "@bendyline/squisq/storage";
 
-// src/util/domPolyfill.ts
-import { DOMParser as XmldomDOMParser } from "@xmldom/xmldom";
-var globalScope = globalThis;
-if (typeof globalScope.DOMParser === "undefined") {
-  globalScope.DOMParser = XmldomDOMParser;
-}
-
 // src/util/readInput.ts
 import { readFile as readFile2, readdir, stat } from "fs/promises";
 import { join as join2, extname } from "path";
 import { parseMarkdown, stringifyMarkdown } from "@bendyline/squisq/markdown";
-import { markdownToDoc } from "@bendyline/squisq/doc";
+import { markdownToDoc, resolveAudioMapping } from "@bendyline/squisq/doc";
 import { MemoryContentContainer } from "@bendyline/squisq/storage";
 import { zipToContainer } from "@bendyline/squisq-formats/container";
 import { defaultRegistry as defaultRegistry2 } from "@bendyline/squisq-formats";
@@ -226,7 +293,12 @@ async function walkDir(root, prefix = "") {
   }
   return paths;
 }
-async function readInput(inputPath) {
+async function readInput(inputPath, options) {
+  const result = await readInputRaw(inputPath, options);
+  const doc = await resolveAudioMapping(result.doc, result.container);
+  return doc === result.doc ? result : { ...result, doc };
+}
+async function readInputRaw(inputPath, options) {
   const info = await stat(inputPath);
   if (info.isDirectory()) {
     return readFolder(inputPath);
@@ -241,7 +313,7 @@ async function readInput(inputPath) {
   if (IMPORTER_EXTS.includes(ext)) {
     const def = defaultRegistry2().byExtension(ext);
     if (def && (def.importContainer || def.importDoc)) {
-      return readViaImporter(inputPath, def);
+      return readViaImporter(inputPath, def, options);
     }
   }
   return readMarkdownFile(inputPath);
@@ -263,16 +335,24 @@ async function readDocJsonFile(filePath) {
   const container = new MemoryContentContainer();
   return { doc, container, sourceFormat: "json" };
 }
-async function readViaImporter(filePath, def) {
+async function readViaImporter(filePath, def, options) {
   const buffer = await readArrayBuffer(filePath);
+  const convertOptions = {
+    formatOptions: {
+      [def.id]: {
+        inferTheme: options?.inferTheme !== false,
+        inferLayouts: options?.inferLayouts !== false
+      }
+    }
+  };
   let container;
   let markdownDoc;
   if (def.importContainer) {
-    container = await def.importContainer(buffer, {});
+    container = await def.importContainer(buffer, convertOptions);
     const text = await container.readDocument();
     markdownDoc = text ? parseMarkdown(text) : { type: "document", children: [] };
   } else {
-    markdownDoc = await def.importDoc(buffer, {});
+    markdownDoc = await def.importDoc(buffer, convertOptions);
     const mem = new MemoryContentContainer();
     await mem.writeDocument(stringifyMarkdown(markdownDoc));
     container = mem;
@@ -331,22 +411,10 @@ async function convert(source, to, options = {}) {
     ...options
   });
 }
-async function renderDocToMp4(doc, container, options) {
-  const {
-    outputPath,
-    fps = 30,
-    quality = "normal",
-    orientation = "landscape",
-    captionStyle,
-    coverPreRoll = 0,
-    onProgress
-  } = options;
-  const dimensions = resolveDimensions({
-    orientation,
-    width: options.width,
-    height: options.height
-  });
-  const ffmpegPath = await detectFfmpeg();
+async function captureDocFrames(doc, container, options) {
+  const { fps, width, height, captionStyle, coverPreRoll, animationsEnabled, onProgress } = options;
+  resolveAppliedCoverPreRoll(coverPreRoll, true);
+  const ffmpegPath = (await detectFfmpegDetailed())?.path ?? null;
   if (!ffmpegPath) {
     throw new Error(
       "ffmpeg is required but not found in PATH.\nInstall it with:\n  macOS:   brew install ffmpeg\n  Ubuntu:  sudo apt install ffmpeg\n  Windows: winget install ffmpeg\nOr: npm install ffmpeg-static, or set SQUISQ_FFMPEG to an ffmpeg binary."
@@ -354,25 +422,20 @@ async function renderDocToMp4(doc, container, options) {
   }
   onProgress?.("collecting media", 0);
   const { collectImagePaths } = await import("@bendyline/squisq-formats/html");
-  const imagePaths = collectImagePaths(doc);
   const images = /* @__PURE__ */ new Map();
-  for (const imgPath of imagePaths) {
+  for (const imgPath of collectImagePaths(doc)) {
     const data = await container.readFile(imgPath);
-    if (data) {
-      images.set(imgPath, data);
-    }
+    if (data) images.set(imgPath, data);
   }
   const audio = /* @__PURE__ */ new Map();
-  if (doc.audio?.segments?.length) {
-    for (const seg of doc.audio.segments) {
-      const data = await container.readFile(seg.src);
-      if (data) {
-        audio.set(seg.src, data);
-        audio.set(seg.name, data);
-      }
+  for (const seg of doc.audio?.segments ?? []) {
+    const data = await container.readFile(seg.src);
+    if (data) {
+      audio.set(seg.src, data);
+      audio.set(seg.name, data);
     }
   }
-  const mediaSrcs = new Set(resolveMediaSchedule(doc).map((c) => c.src));
+  const mediaSrcs = new Set(resolveMediaSchedule(doc).map((clip) => clip.src));
   for (const block of flattenBlocks(doc.blocks)) {
     for (const layer of block.layers ?? []) {
       if (layer.type === "video") mediaSrcs.add(layer.content.src);
@@ -389,9 +452,10 @@ async function renderDocToMp4(doc, container, options) {
     playerScript: PLAYER_BUNDLE,
     images,
     audio: audio.size > 0 ? audio : void 0,
-    width: dimensions.width,
-    height: dimensions.height,
-    captionStyle
+    width,
+    height,
+    captionStyle,
+    animationsEnabled
   });
   onProgress?.("launching browser", 15);
   const { chromium } = await import("playwright-core");
@@ -405,91 +469,163 @@ async function renderDocToMp4(doc, container, options) {
 (launch failed: ${detail})`
     );
   }
-  const page = await browser.newPage({
-    viewport: { width: dimensions.width, height: dimensions.height }
-  });
+  const page = await browser.newPage({ viewport: { width, height } });
   const pageErrors = [];
   page.on("pageerror", (err) => pageErrors.push(err.message));
-  await page.setContent(renderHtml, { waitUntil: "load" });
-  await page.waitForTimeout(500);
+  let renderAPI = null;
   try {
-    await page.waitForFunction(
-      () => typeof window.getDuration === "function",
-      { timeout: 15e3 }
-    );
-  } catch {
-    await browser.close();
-    const errorDetail = pageErrors.length ? `
+    await page.setContent(renderHtml, { waitUntil: "load" });
+    await page.waitForTimeout(500);
+    try {
+      await page.waitForFunction(
+        () => {
+          const root = document.getElementById("squisq-root");
+          const player = window.SquisqPlayer;
+          return root ? player?.getHandle(root)?.getRenderAPI() != null : false;
+        },
+        { timeout: 15e3 }
+      );
+    } catch {
+      const errorDetail = pageErrors.length ? `
 Page errors:
   ${pageErrors.join("\n  ")}` : "\nNo page errors captured \u2014 the player may have failed to mount.";
-    throw new Error(
-      `The standalone player failed to boot in headless Chromium. Render API did not initialize within 15 seconds.${errorDetail}`
-    );
-  }
-  const docDuration = await page.evaluate(() => {
-    return window.getDuration();
-  });
-  if (docDuration <= 0) {
-    await browser.close();
-    throw new Error("Document has zero duration \u2014 nothing to render");
-  }
-  const storyFrameCount = Math.ceil(docDuration * fps);
-  const preRollFrameCount = Math.ceil(coverPreRoll * fps);
-  const totalFrames = preRollFrameCount + storyFrameCount;
-  const frames = [];
-  onProgress?.("capturing frames", 20);
-  if (preRollFrameCount > 0) {
-    const hasCover = await page.evaluate(() => {
-      const w = window;
-      return typeof w.hasCoverBlock === "function" ? w.hasCoverBlock() : false;
+      throw new Error(
+        `The standalone player failed to boot in headless Chromium. Render API did not initialize within 15 seconds.${errorDetail}`
+      );
+    }
+    renderAPI = await page.evaluateHandle(() => {
+      const root = document.getElementById("squisq-root");
+      const player = window.SquisqPlayer;
+      const api = root ? player?.getHandle(root)?.getRenderAPI() : null;
+      if (!api) throw new Error("Squisq render API disappeared after initialization.");
+      return api;
     });
-    if (hasCover) {
-      await page.evaluate(() => {
-        window.showCover();
-      });
+    const docDuration = await renderAPI.evaluate((api) => api.getDuration());
+    if (docDuration <= 0) throw new Error("Document has zero duration \u2014 nothing to render");
+    const hasCover = coverPreRoll > 0 ? await renderAPI.evaluate((api) => api.hasCoverBlock()) : false;
+    const appliedCoverPreRoll = resolveAppliedCoverPreRoll(coverPreRoll, hasCover);
+    const storyFrameCount = Math.ceil(docDuration * fps);
+    const preRollFrameCount = Math.ceil(appliedCoverPreRoll * fps);
+    const totalFrames = preRollFrameCount + storyFrameCount;
+    const frames = [];
+    onProgress?.("capturing frames", 20);
+    if (preRollFrameCount > 0) {
+      await renderAPI.evaluate((api) => api.showCover());
       await page.waitForTimeout(100);
       const coverFrame = new Uint8Array(await page.screenshot({ type: "png" }));
-      for (let i = 0; i < preRollFrameCount; i++) {
-        frames.push(coverFrame);
-      }
-      await page.evaluate(() => {
-        window.hideCover();
-      });
+      for (let i = 0; i < preRollFrameCount; i++) frames.push(coverFrame);
+      await renderAPI.evaluate((api) => api.hideCover());
     }
-  }
-  const frameInterval = 1 / fps;
-  for (let i = 0; i < storyFrameCount; i++) {
-    const time = i * frameInterval;
-    await page.evaluate((t) => {
-      return window.seekTo(t);
-    }, time);
-    const screenshot = await page.screenshot({ type: "png" });
-    frames.push(new Uint8Array(screenshot));
-    if (i % Math.max(1, Math.floor(fps / 2)) === 0 || i === storyFrameCount - 1) {
-      const pct = 20 + Math.round(frames.length / totalFrames * 60);
-      onProgress?.("capturing frames", pct);
+    const frameInterval = 1 / fps;
+    for (let i = 0; i < storyFrameCount; i++) {
+      const time = i * frameInterval;
+      await renderAPI.evaluate((api, t) => api.seekTo(t), time);
+      frames.push(new Uint8Array(await page.screenshot({ type: "png" })));
+      if (i % Math.max(1, Math.floor(fps / 2)) === 0 || i === storyFrameCount - 1) {
+        onProgress?.("capturing frames", 20 + Math.round(frames.length / totalFrames * 60));
+      }
     }
+    return {
+      frames,
+      totalDuration: docDuration + appliedCoverPreRoll,
+      appliedCoverPreRoll,
+      ffmpegPath
+    };
+  } finally {
+    await renderAPI?.dispose();
+    await browser.close();
   }
-  await browser.close();
-  onProgress?.("encoding video", 80);
-  const encodingAudio = await buildMixedAudioTrack(doc, container, ffmpegPath, coverPreRoll);
-  const { framesToMp4Native } = await import("./nativeEncoder-2HGWDEZZ.js");
-  await framesToMp4Native(ffmpegPath, frames, encodingAudio, outputPath, {
+}
+async function renderDocToMp4(doc, container, options) {
+  const fps = options.fps ?? 30;
+  const quality = options.quality ?? "normal";
+  const orientation = options.orientation ?? "landscape";
+  const dimensions = resolveDimensions({
+    orientation,
+    width: options.width,
+    height: options.height,
+    fps,
+    quality
+  });
+  const capture = await captureDocFrames(doc, container, {
+    fps,
+    width: dimensions.width,
+    height: dimensions.height,
+    captionStyle: options.captionStyle,
+    coverPreRoll: options.coverPreRoll ?? 0,
+    animationsEnabled: options.animationsEnabled ?? true,
+    onProgress: options.onProgress
+  });
+  options.onProgress?.("encoding video", 80);
+  const encodingAudio = await buildMixedAudioTrack(
+    doc,
+    container,
+    capture.ffmpegPath,
+    capture.appliedCoverPreRoll
+  );
+  const { framesToMp4Native: framesToMp4Native2 } = await import("./nativeEncoder-IQPN2RMC.js");
+  await framesToMp4Native2(capture.ffmpegPath, capture.frames, encodingAudio, options.outputPath, {
     fps,
     quality,
     orientation,
     width: dimensions.width,
     height: dimensions.height,
-    onProgress: (percent, phase) => {
-      onProgress?.(`encoding: ${phase}`, 80 + Math.round(percent * 0.2));
-    }
+    onProgress: (percent, phase) => options.onProgress?.(`encoding: ${phase}`, 80 + Math.round(percent * 0.2))
+  });
+  options.onProgress?.("done", 100);
+  return {
+    duration: capture.totalDuration,
+    frameCount: capture.frames.length,
+    outputPath: options.outputPath
+  };
+}
+async function renderDocToGif(doc, container, options) {
+  const fps = options.fps ?? GIF_EXPORT_DEFAULTS.fps;
+  if (!Number.isFinite(fps) || fps <= 0 || fps > 100) {
+    throw new RangeError("GIF FPS must be a finite number between 1 and 100.");
+  }
+  const orientation = options.orientation ?? "landscape";
+  const portrait = orientation === "portrait";
+  const width = options.width ?? (portrait ? GIF_EXPORT_DEFAULTS.height : GIF_EXPORT_DEFAULTS.width);
+  const height = options.height ?? (portrait ? GIF_EXPORT_DEFAULTS.width : GIF_EXPORT_DEFAULTS.height);
+  resolveDimensions({ orientation, width, height, fps });
+  ffmpegGifOutputArgs({
+    width,
+    height,
+    loop: options.loop ?? GIF_EXPORT_DEFAULTS.loop,
+    maxColors: options.maxColors ?? GIF_EXPORT_DEFAULTS.maxColors,
+    dither: options.dither ?? GIF_EXPORT_DEFAULTS.dither,
+    bayerScale: options.bayerScale
+  });
+  const capture = await captureDocFrames(doc, container, {
+    fps,
+    width,
+    height,
+    captionStyle: options.captionStyle,
+    coverPreRoll: options.coverPreRoll ?? 0,
+    animationsEnabled: options.animationsEnabled ?? false,
+    onProgress: options.onProgress
+  });
+  options.onProgress?.("encoding GIF", 80);
+  const { framesToGifNative: framesToGifNative2 } = await import("./nativeEncoder-IQPN2RMC.js");
+  await framesToGifNative2(capture.ffmpegPath, capture.frames, options.outputPath, {
+    fps,
+    orientation,
+    width,
+    height,
+    loop: options.loop,
+    maxColors: options.maxColors,
+    dither: options.dither,
+    bayerScale: options.bayerScale,
+    onProgress: (percent, phase) => options.onProgress?.(`encoding: ${phase}`, 80 + Math.round(percent * 0.2))
   });
-  onProgress?.("done", 100);
-  const totalDuration = docDuration + coverPreRoll;
+  options.onProgress?.("done", 100);
+  const hasAudio = (doc.audio?.segments?.length ?? 0) > 0 || resolveMediaSchedule(doc).some((clip) => clip.kind === "audio");
   return {
-    duration: totalDuration,
-    frameCount: frames.length,
-    outputPath
+    duration: capture.totalDuration,
+    frameCount: capture.frames.length,
+    outputPath: options.outputPath,
+    warnings: hasAudio ? ["Animated GIF does not support audio; audio tracks were omitted."] : []
   };
 }
 async function extractThumbnails(options) {
@@ -497,7 +633,7 @@ async function extractThumbnails(options) {
   const { existsSync } = await import("fs");
   const { join: join3 } = await import("path");
   const { execFile: execFile2 } = await import("child_process");
-  const ffmpegPath = await detectFfmpeg();
+  const ffmpegPath = (await detectFfmpegDetailed())?.path ?? null;
   if (!ffmpegPath) {
     throw new Error(
       "ffmpeg is required for thumbnail extraction but not found in PATH.\nInstall it with:\n  macOS:   brew install ffmpeg\n  Ubuntu:  sudo apt install ffmpeg\n  Windows: winget install ffmpeg"
@@ -521,11 +657,17 @@ async function extractThumbnails(options) {
 }
 export {
   ConversionError,
+  GIF_EXPORT_DEFAULTS,
   MemoryContentContainer2 as MemoryContentContainer,
   convert,
   createCliRegistry,
   extractThumbnails,
+  framesToGifNative,
+  framesToGifNativeBytes,
+  framesToMp4Native,
+  framesToMp4NativeBytes,
   readInput,
+  renderDocToGif,
   renderDocToMp4
 };
 //# sourceMappingURL=api.js.map