@dustfeather/deckrun 2.0.0

package/dist/pdf.js

@@ -0,0 +1,200 @@
+import { spawn } from "child_process";
+import { access, mkdtemp, readFile, rm, stat } from "fs/promises";
+import { constants } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+/**
+ * PDF export without the print dialog.
+ *
+ * The deck already prints correctly, but only if the person exporting picks
+ * landscape and turns on background graphics. Driving a headless browser
+ * ourselves removes that step: same renderer, same stylesheet, no choices.
+ *
+ * Nothing is installed for this. It uses a Chromium-family browser that is
+ * already on the machine, and the caller falls back to the print dialog when
+ * there is not one.
+ */
+const CANDIDATES = {
+    darwin: [
+        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        "/Applications/Chromium.app/Contents/MacOS/Chromium",
+        "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+        "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+        "/Applications/Arc.app/Contents/MacOS/Arc",
+        "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+    ],
+    linux: [
+        "/usr/bin/google-chrome",
+        "/usr/bin/google-chrome-stable",
+        "/usr/bin/chromium",
+        "/usr/bin/chromium-browser",
+        "/usr/bin/microsoft-edge",
+        "/usr/bin/brave-browser",
+        "/snap/bin/chromium",
+        "/opt/google/chrome/chrome",
+    ],
+    win32: [
+        "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+        "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+        "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+        "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
+        "C:\\Program Files\\Chromium\\Application\\chrome.exe",
+    ],
+};
+/** Env overrides, checked before the well-known locations. */
+const ENV_KEYS = [
+    "DECKRUN_BROWSER",
+    "CHROME_PATH",
+    "PUPPETEER_EXECUTABLE_PATH",
+];
+let cached;
+async function isExecutable(path) {
+    try {
+        await access(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Path to a usable browser, or null when the machine has none we recognise. */
+export async function findBrowser() {
+    if (cached !== undefined)
+        return cached;
+    for (const key of ENV_KEYS) {
+        const value = process.env[key];
+        if (value && (await isExecutable(value))) {
+            cached = value;
+            return cached;
+        }
+    }
+    for (const path of CANDIDATES[process.platform] ?? []) {
+        if (await isExecutable(path)) {
+            cached = path;
+            return cached;
+        }
+    }
+    cached = null;
+    return cached;
+}
+export class PdfError extends Error {
+}
+const RENDER_TIMEOUT_MS = 45_000;
+const POLL_MS = 150;
+function sleep(ms) {
+    return new Promise((done) => setTimeout(done, ms));
+}
+function killTree(child) {
+    try {
+        // Chrome leaves helper processes behind, so kill the whole group where the
+        // platform has them.
+        if (process.platform !== "win32" && child.pid)
+            process.kill(-child.pid, "SIGKILL");
+        else
+            child.kill("SIGKILL");
+    }
+    catch {
+        // Already gone.
+    }
+}
+/**
+ * Waits for the PDF itself rather than for the browser to exit.
+ *
+ * Chrome writes the file in about a second and then lingers, running update
+ * checks and other background work, so waiting on process exit would stall for
+ * as long as the timeout allows. A size that stops changing means the write is
+ * finished.
+ */
+async function waitForPdf(out, hasExited, spawnError) {
+    const deadline = Date.now() + RENDER_TIMEOUT_MS;
+    let lastSize = -1;
+    while (Date.now() < deadline) {
+        const failure = spawnError();
+        if (failure)
+            throw failure;
+        let size = -1;
+        try {
+            size = (await stat(out)).size;
+        }
+        catch {
+            // Not written yet.
+        }
+        if (size > 0 && size === lastSize)
+            return readFile(out);
+        lastSize = size;
+        if (hasExited() && size <= 0) {
+            // One last look, in case the write landed as the process was leaving.
+            try {
+                if ((await stat(out)).size > 0)
+                    return readFile(out);
+            }
+            catch {
+                // Nothing there.
+            }
+            throw new PdfError("the browser exited without producing a PDF");
+        }
+        await sleep(POLL_MS);
+    }
+    throw new PdfError("the browser took too long to render the deck");
+}
+/**
+ * Renders a served deck to PDF bytes.
+ *
+ * `--virtual-time-budget` matters: without it the browser prints before the
+ * webfont and the syntax highlighter have arrived, and the PDF comes out in a
+ * fallback font with plain code blocks.
+ */
+export async function renderPdf(url, browser) {
+    const dir = await mkdtemp(join(tmpdir(), "deckrun-pdf-"));
+    const out = join(dir, "deck.pdf");
+    const args = [
+        "--headless",
+        "--disable-gpu",
+        "--hide-scrollbars",
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-extensions",
+        "--disable-sync",
+        "--disable-default-apps",
+        "--disable-component-update",
+        "--no-service-autorun",
+        "--mute-audio",
+        // Never touch the browser profile the person is actually using.
+        `--user-data-dir=${join(dir, "profile")}`,
+        // Mermaid performs an asynchronous layout pass after its local script has
+        // loaded. Give that pass room to settle and flush every compositor stage
+        // before Chrome snapshots the pages.
+        "--virtual-time-budget=10000",
+        "--run-all-compositor-stages-before-draw",
+        // Header/footer flag names differ across versions; unknown switches are ignored.
+        "--no-pdf-header-footer",
+        "--print-to-pdf-no-header",
+        `--print-to-pdf=${out}`,
+        url,
+    ];
+    let exited = false;
+    let failure = null;
+    const child = spawn(browser, args, {
+        stdio: "ignore",
+        detached: process.platform !== "win32",
+    });
+    child.on("exit", () => { exited = true; });
+    child.on("error", (err) => {
+        failure = new PdfError(`could not run ${browser}: ${err.message}`);
+        exited = true;
+    });
+    try {
+        return await waitForPdf(out, () => exited, () => failure);
+    }
+    finally {
+        killTree(child);
+        await rm(dir, { recursive: true, force: true }).catch(() => { });
+    }
+}
+/** One render at a time, so a stuck or repeated request cannot spawn a fleet. */
+let queue = Promise.resolve();
+export function renderPdfSerial(url, browser) {
+    const run = queue.then(() => renderPdf(url, browser), () => renderPdf(url, browser));
+    queue = run.catch(() => { });
+    return run;
+}

package/dist/presentation-options.js

@@ -0,0 +1,289 @@
+export const DEFAULT_TEMPLATE = "classic";
+export const DEFAULT_TRANSITION = "slide";
+export const TEMPLATE_IDS = [
+    "classic",
+    "minimal",
+    "editorial",
+    "spotlight",
+];
+export const TRANSITION_IDS = [
+    "slide",
+    "fade",
+    "zoom",
+    "lift",
+    "none",
+];
+export const TEMPLATE_SPECS = {
+    classic: {
+        label: "Classic",
+        blurb: "The original balanced deckrun layout",
+    },
+    minimal: {
+        label: "Minimal",
+        blurb: "Quiet surfaces, wider margins, fewer decorative treatments",
+    },
+    editorial: {
+        label: "Editorial",
+        blurb: "Strong rules and magazine-like reading rhythm",
+    },
+    spotlight: {
+        label: "Spotlight",
+        blurb: "Centered, high-impact composition for concise keynote slides",
+    },
+};
+export const TRANSITION_SPECS = {
+    slide: {
+        label: "Slide",
+        blurb: "Horizontal sliding transition between slides",
+    },
+    fade: {
+        label: "Fade",
+        blurb: "Cross-fade between slides",
+    },
+    zoom: {
+        label: "Zoom",
+        blurb: "Scale up and down between slides",
+    },
+    lift: {
+        label: "Lift",
+        blurb: "Vertical rising transition between slides",
+    },
+    none: {
+        label: "None",
+        blurb: "Instant cut between slides",
+    },
+};
+export function findTemplate(input) {
+    if (!input)
+        return null;
+    const key = String(input).trim().toLowerCase();
+    for (const id of TEMPLATE_IDS) {
+        if (id === key)
+            return id;
+        if (TEMPLATE_SPECS[id].label.toLowerCase() === key)
+            return id;
+    }
+    return null;
+}
+export function resolveTemplateName(input) {
+    return findTemplate(input) ?? DEFAULT_TEMPLATE;
+}
+export function templateSummaries() {
+    return TEMPLATE_IDS.map((id) => ({
+        id,
+        label: TEMPLATE_SPECS[id].label,
+        blurb: TEMPLATE_SPECS[id].blurb,
+    }));
+}
+export function templateListing() {
+    const pad = Math.max(...TEMPLATE_IDS.map((id) => id.length));
+    return TEMPLATE_IDS.map((id) => {
+        const s = TEMPLATE_SPECS[id];
+        return `${id.padEnd(pad)}  ${s.label.padEnd(10)}  ${s.blurb}`;
+    });
+}
+export function findTransition(input) {
+    if (!input)
+        return null;
+    const key = String(input).trim().toLowerCase();
+    for (const id of TRANSITION_IDS) {
+        if (id === key)
+            return id;
+        if (TRANSITION_SPECS[id].label.toLowerCase() === key)
+            return id;
+    }
+    return null;
+}
+export function resolveTransitionName(input) {
+    return findTransition(input) ?? DEFAULT_TRANSITION;
+}
+export function transitionSummaries() {
+    return TRANSITION_IDS.map((id) => ({
+        id,
+        label: TRANSITION_SPECS[id].label,
+        blurb: TRANSITION_SPECS[id].blurb,
+    }));
+}
+export function transitionListing() {
+    const pad = Math.max(...TRANSITION_IDS.map((id) => id.length));
+    return TRANSITION_IDS.map((id) => {
+        const s = TRANSITION_SPECS[id];
+        return `${id.padEnd(pad)}  ${s.label.padEnd(8)}  ${s.blurb}`;
+    });
+}
+export const TEMPLATE_CSS = `/* ── Templates ──────────────────────────────────────────────────────────── */
+
+/* Minimal */
+:root[data-template="minimal"] {
+  --slide-pad-x: 10vw;
+  --slide-pad-y: 8vh;
+}
+:root[data-template="minimal"] #backdrop {
+  opacity: 0.15;
+}
+:root[data-template="minimal"] .slide__content h1 {
+  letter-spacing: -0.02em;
+}
+:root[data-template="minimal"] blockquote {
+  border-left-width: 2px;
+  background: transparent;
+}
+:root[data-template="minimal"] pre {
+  border: 1px solid var(--surface0);
+}
+
+/* Editorial */
+:root[data-template="editorial"] {
+  --slide-pad-x: 7vw;
+}
+:root[data-template="editorial"] .slide__content h1 {
+  border-bottom: 3px solid var(--accent);
+  padding-bottom: 0.3em;
+  margin-bottom: 0.6em;
+}
+:root[data-template="editorial"] .slide__content h2 {
+  border-bottom: 1px solid var(--surface1);
+  padding-bottom: 0.2em;
+}
+:root[data-template="editorial"] blockquote {
+  border-left: 4px solid var(--accent);
+  font-style: italic;
+  background: var(--surface0);
+}
+:root[data-template="editorial"] table th {
+  border-bottom: 2px solid var(--accent);
+}
+:root[data-template="editorial"] hr {
+  border: none;
+  border-top: 2px solid var(--surface2);
+  margin: 2em 0;
+}
+
+/* Spotlight */
+:root[data-template="spotlight"] .slide {
+  justify-content: center;
+  align-items: center;
+  text-align: center;
+}
+:root[data-template="spotlight"] .slide__content {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  text-align: center;
+}
+:root[data-template="spotlight"] .slide__content h1 {
+  /* A shade larger than a normal heading: on a template built around one
+     statement a slide, the statement carries it. */
+  font-size: calc(clamp(2.1rem, 4.6vw, 3.6rem) * 1.15);
+  text-align: center;
+}
+:root[data-template="spotlight"] .slide__content p {
+  max-width: 80%;
+  margin-left: auto;
+  margin-right: auto;
+}
+:root[data-template="spotlight"] .slide__content ul,
+:root[data-template="spotlight"] .slide__content ol {
+  text-align: left;
+  display: inline-block;
+  margin-left: auto;
+  margin-right: auto;
+}
+:root[data-template="spotlight"] .slide__content blockquote {
+  text-align: center;
+  border-left: none;
+  border-top: 2px solid var(--accent);
+  border-bottom: 2px solid var(--accent);
+  padding: 1em 2em;
+  background: transparent;
+}
+:root[data-template="spotlight"] .slide__content pre {
+  text-align: left;
+}
+`;
+export const TRANSITION_CSS = `/* ── Transitions ────────────────────────────────────────────────────────── */
+
+/* Fade */
+:root[data-transition="fade"] .slide {
+  transition: opacity 0.3s ease;
+  transform: none !important;
+}
+:root[data-transition="fade"] .slide.exit-left,
+:root[data-transition="fade"] .slide.exit-right,
+:root[data-transition="fade"] .slide.enter-from-left,
+:root[data-transition="fade"] .slide.enter-from-right {
+  transform: none !important;
+  opacity: 0;
+}
+:root[data-transition="fade"] .slide.is-active {
+  opacity: 1;
+  transform: none !important;
+}
+
+/* Zoom */
+:root[data-transition="zoom"] .slide {
+  transform: scale(0.92);
+  transition: opacity 0.35s ease, transform 0.35s cubic-bezier(0.4, 0, 0.2, 1);
+}
+:root[data-transition="zoom"] .slide.is-active {
+  transform: scale(1);
+  opacity: 1;
+}
+:root[data-transition="zoom"] .slide.exit-left,
+:root[data-transition="zoom"] .slide.exit-right {
+  transform: scale(1.08);
+  opacity: 0;
+}
+:root[data-transition="zoom"] .slide.enter-from-left,
+:root[data-transition="zoom"] .slide.enter-from-right {
+  transform: scale(0.92);
+  opacity: 0;
+}
+
+/* Lift */
+:root[data-transition="lift"] .slide {
+  transform: translateY(48px);
+  transition: opacity 0.35s ease, transform 0.35s cubic-bezier(0.4, 0, 0.2, 1);
+}
+:root[data-transition="lift"] .slide.is-active {
+  transform: translateY(0);
+  opacity: 1;
+}
+:root[data-transition="lift"] .slide.exit-left,
+:root[data-transition="lift"] .slide.exit-right {
+  transform: translateY(-48px);
+  opacity: 0;
+}
+:root[data-transition="lift"] .slide.enter-from-left,
+:root[data-transition="lift"] .slide.enter-from-right {
+  transform: translateY(48px);
+  opacity: 0;
+}
+
+/* None */
+:root[data-transition="none"] .slide,
+:root[data-transition="none"] .slide.is-active,
+:root[data-transition="none"] .slide.exit-left,
+:root[data-transition="none"] .slide.exit-right,
+:root[data-transition="none"] .slide.enter-from-left,
+:root[data-transition="none"] .slide.enter-from-right {
+  transition: none !important;
+  transform: none !important;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  :root[data-transition] .slide {
+    transition: opacity 0.2s linear !important;
+    transform: none !important;
+  }
+}
+
+@media print {
+  :root[data-transition] .slide {
+    transition: none !important;
+    transform: none !important;
+    opacity: 1 !important;
+  }
+}
+`;