slidemind 0.1.9 → 0.2.0

package/src/pptx/fill/freeform.mjs

@@ -0,0 +1,156 @@
+// In-deck freeform slides for fill-template decks.
+//
+// Contract: a proposal deck's slides/ may carry create-slides freeform JSX
+// (NN-name.jsx composing the design bundle's layouts) directly next to the
+// master-backed slides — no sibling deck. The rendered native artifact lives
+// beside its source as NN-name.pptx; the fill engine inserts that artifact at
+// the filename position like any native slide. This module keeps the
+// artifacts fresh: stale or missing renders go through the add-in's render
+// path (the ONLY host-dependent step of a proposal build) and are folded to
+// pruned one-slide packages. Unchanged freeform slides rebuild fully offline.
+
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { unzip, readText } from "../zip.mjs";
+import { slideOrderPaths } from "../ooxml.mjs";
+import { foldPickedSlides } from "../slide-swap.mjs";
+import { layoutNumber } from "./parse-slides.mjs";
+
+const SIDE_CAR = ".freeform-renders.json";
+
+// The template's Challenge/Solution slides carry FIXED titles; freeform
+// replacements must keep them so the deck reads like the master.
+const FIXED_TITLES = {
+  en: [
+    { stem: /challenge/i, title: "Challenge" },
+    { stem: /solution/i, title: "Solution" },
+  ],
+  de: [
+    { stem: /challenge|herausforderung/i, title: "Herausforderung" },
+    { stem: /solution|loesung|lösung/i, title: "Lösung" },
+  ],
+};
+
+function isFreeformSource(src) {
+  const comp = src.match(/<([A-Z][A-Za-z0-9]*)/)?.[1];
+  return Boolean(comp) && layoutNumber(comp, "en") === null;
+}
+
+function contentHash(parts) {
+  const h = crypto.createHash("sha256");
+  for (const p of parts) h.update(p ?? "");
+  return h.digest("hex");
+}
+
+function slideText(bytes) {
+  const files = unzip(bytes);
+  const slide = slideOrderPaths(files)[0];
+  const xml = slide ? readText(files, slide) : "";
+  return [...(xml ?? "").matchAll(/<a:t>([^<]*)<\/a:t>/g)].map((m) => m[1]).join("\n");
+}
+
+function fixedTitleWarning(stem, bytes, locale) {
+  const rules = FIXED_TITLES[locale] ?? FIXED_TITLES.en;
+  const rule = rules.find((r) => r.stem.test(stem));
+  if (!rule) return null;
+  if (slideText(bytes).includes(rule.title)) return null;
+  return (
+    `${stem}.pptx: the ${locale.toUpperCase()} template fixes this slide's title to ` +
+    `"${rule.title}" — set title="${rule.title}" in ${stem}.jsx and rebuild`
+  );
+}
+
+/**
+ * Bring every freeform slide's rendered artifact up to date. Returns
+ * `{ rendered, warnings }`; throws with the offending file named when a stale
+ * render is needed but the paired backend cannot render.
+ */
+export async function ensureFreeformRenders({ deckDir, locale = "en", srcDir, onLog = () => {} }) {
+  const slidesDir = path.join(deckDir, "slides");
+  const jsxFiles = fs.existsSync(slidesDir)
+    ? fs.readdirSync(slidesDir).filter((f) => f.endsWith(".jsx")).sort()
+    : [];
+  const items = [];
+  for (const file of jsxFiles) {
+    const src = fs.readFileSync(path.join(slidesDir, file), "utf8");
+    if (isFreeformSource(src)) items.push({ file, stem: file.replace(/\.jsx$/, ""), src });
+  }
+  const warnings = [];
+  if (items.length === 0) return { rendered: 0, warnings };
+
+  const sideCarPath = path.join(deckDir, SIDE_CAR);
+  let sideCar = {};
+  try {
+    sideCar = JSON.parse(fs.readFileSync(sideCarPath, "utf8"));
+  } catch {
+    sideCar = {};
+  }
+  // The render depends on the design bundle, so the deck's bound etag is part
+  // of the freshness key — a CD update re-renders the freeform slides.
+  let etag = "";
+  try {
+    const ref = JSON.parse(fs.readFileSync(path.join(deckDir, ".bundle-ref.json"), "utf8"));
+    etag = ref?.etag ?? "";
+  } catch {
+    etag = "";
+  }
+
+  const stale = items.filter((it) => {
+    const target = path.join(slidesDir, `${it.stem}.pptx`);
+    return !fs.existsSync(target) || sideCar[it.stem]?.hash !== contentHash([it.src, etag]);
+  });
+
+  if (stale.length > 0) {
+    const bp = await import(
+      pathToFileURL(path.join(srcDir, "bridge", "build-and-push.mjs")).href
+    );
+    for (const it of stale) {
+      onLog(`rendering freeform slide ${it.file} via the add-in…`);
+      const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "slidemind-freeform-"));
+      try {
+        fs.mkdirSync(path.join(tmp, "slides"), { recursive: true });
+        fs.writeFileSync(path.join(tmp, "slides", `01-${it.stem}.jsx`), it.src);
+        fs.writeFileSync(path.join(tmp, "plan.md"), `---\nlocale: ${locale}\n---\n`);
+        const assetsDir = path.join(deckDir, "assets");
+        if (fs.existsSync(assetsDir)) {
+          fs.cpSync(assetsDir, path.join(tmp, "assets"), { recursive: true });
+        }
+        const refPath = path.join(deckDir, ".bundle-ref.json");
+        if (fs.existsSync(refPath)) {
+          fs.copyFileSync(refPath, path.join(tmp, ".bundle-ref.json"));
+        }
+        const outPath = path.join(tmp, "render.pptx");
+        try {
+          await bp.buildPptxFile({ deckDir: tmp, outPath, onProgress: () => {} });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          throw new Error(
+            `freeform slide ${it.file} needs a render but the paired add-in could not ` +
+              `build it: ${msg}`,
+          );
+        }
+        const folded = foldPickedSlides(fs.readFileSync(outPath), [1], {
+          sourceName: it.stem,
+        })[0];
+        fs.writeFileSync(path.join(slidesDir, `${it.stem}.pptx`), folded.bytes);
+        sideCar[it.stem] = { hash: contentHash([it.src, etag]) };
+        onLog(`  ✓ ${it.stem}.pptx refreshed`);
+      } finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+      }
+    }
+    fs.writeFileSync(sideCarPath, JSON.stringify(sideCar, null, 2) + "\n");
+  }
+
+  for (const it of items) {
+    const target = path.join(slidesDir, `${it.stem}.pptx`);
+    if (!fs.existsSync(target)) continue;
+    const warn = fixedTitleWarning(it.stem, fs.readFileSync(target), locale);
+    if (warn) warnings.push(warn);
+  }
+  return { rendered: stale.length, warnings };
+}

package/src/pptx/fill/parse-slides.mjs

@@ -0,0 +1,154 @@
+// Parser for proposal slide files. Proposal JSX is declarative by contract —
+// one default export returning exactly one <SlideProposalLayoutNN …/> element
+// whose props are data literals. That constraint is what makes a real JSX
+// runtime unnecessary: attributes are scanned textually and brace expressions
+// are evaluated as plain JS literals in an empty vm sandbox.
+
+import vm from "node:vm";
+
+// Accepted component spellings → template slide number.
+//   SlideProposalLayout07           (canonical, locale-neutral)
+//   SlideProposalEn07Slide7 / SlideProposalDe07Slide7 (generated concrete names)
+export function layoutNumber(component, locale) {
+  let m = component.match(/^SlideProposalLayout(\d{2})$/);
+  if (m) return { no: Number(m[1]) };
+  m = component.match(/^SlideProposal(En|De)(\d{2})Slide\d+$/);
+  if (m) {
+    const compLocale = m[1].toLowerCase();
+    return {
+      no: Number(m[2]),
+      warn:
+        compLocale === locale
+          ? `use the canonical <SlideProposalLayout${m[2]}> alias`
+          : `component locale "${compLocale}" does not match deck locale "${locale}"`,
+    };
+  }
+  return null;
+}
+
+function stripComments(src) {
+  let out = "";
+  let i = 0;
+  let str = null; // ", ', or `
+  while (i < src.length) {
+    const c = src[i];
+    const c2 = src.slice(i, i + 2);
+    if (str) {
+      out += c;
+      if (c === "\\") { out += src[i + 1] ?? ""; i += 2; continue; }
+      if (c === str) str = null;
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") { str = c; out += c; i++; continue; }
+    if (c2 === "//") { const nl = src.indexOf("\n", i); i = nl < 0 ? src.length : nl; continue; }
+    if (c2 === "/*") { const end = src.indexOf("*/", i + 2); i = end < 0 ? src.length : end + 2; continue; }
+    out += c;
+    i++;
+  }
+  return out;
+}
+
+// Scan one balanced {...} starting at src[start] === "{", honoring strings.
+function balancedBraces(src, start) {
+  let depth = 0;
+  let str = null;
+  for (let i = start; i < src.length; i++) {
+    const c = src[i];
+    if (str) {
+      if (c === "\\") { i++; continue; }
+      if (c === str) str = null;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") { str = c; continue; }
+    if (c === "{") depth++;
+    if (c === "}") {
+      depth--;
+      if (depth === 0) return src.slice(start + 1, i);
+    }
+  }
+  return null;
+}
+
+function evalLiteral(expr, file) {
+  try {
+    const value = vm.runInNewContext(`(${expr})`, Object.create(null), {
+      timeout: 250,
+      filename: file,
+    });
+    // Values cross a vm realm boundary — round-trip through JSON so callers
+    // get plain host-realm data (and anything non-data fails loudly here).
+    return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+  } catch (err) {
+    throw new Error(`${file}: cannot evaluate prop expression (${err.message}). ` +
+      `Proposal props must be data literals — strings, numbers, arrays, objects.`);
+  }
+}
+
+// Parse one slide file → { component, props, warnings }.
+export function parseSlideFile(source, file) {
+  const src = stripComments(source);
+  const warnings = [];
+
+  const open = src.match(/<([A-Z][A-Za-z0-9]*)/);
+  if (!open) throw new Error(`${file}: no layout element found`);
+  const component = open[1];
+
+  // Attribute scan from after the component name to the element's close.
+  let i = open.index + open[0].length;
+  const props = {};
+  let selfClosed = false;
+  while (i < src.length) {
+    while (/\s/.test(src[i])) i++;
+    if (src.slice(i, i + 2) === "/>") { selfClosed = true; break; }
+    if (src[i] === ">") break;
+    const name = src.slice(i).match(/^([A-Za-z_][A-Za-z0-9_]*)/);
+    if (!name) throw new Error(`${file}: cannot parse props near "${src.slice(i, i + 30)}"`);
+    i += name[1].length;
+    if (src[i] !== "=") {
+      props[name[1]] = true; // bare boolean prop
+      continue;
+    }
+    i++;
+    if (src[i] === '"' || src[i] === "'") {
+      const q = src[i];
+      const end = src.indexOf(q, i + 1);
+      if (end < 0) throw new Error(`${file}: unterminated string for prop ${name[1]}`);
+      // JSX string attributes are literal text (entities decoded by React; the
+      // masters' fields never rely on them, so raw text is taken as-is).
+      props[name[1]] = src.slice(i + 1, end);
+      i = end + 1;
+    } else if (src[i] === "{") {
+      const expr = balancedBraces(src, i);
+      if (expr === null) throw new Error(`${file}: unbalanced braces for prop ${name[1]}`);
+      props[name[1]] = evalLiteral(expr, file);
+      i += expr.length + 2;
+    } else {
+      throw new Error(`${file}: prop ${name[1]} must be "string" or {literal}`);
+    }
+  }
+
+  if (!selfClosed) {
+    // Children are only legal on freeform slides, which this engine does not
+    // build — surface it as a parse error with the actionable rule.
+    const closing = `</${component}>`;
+    const closeIdx = src.indexOf(closing);
+    const inner = closeIdx > 0 ? src.slice(i + 1, closeIdx).trim() : "";
+    if (inner) {
+      throw new Error(
+        `${file}: <${component}> has children. Master-backed proposal slides are ` +
+          `self-closing props-only elements; freeform content belongs to create-slides.`,
+      );
+    }
+  }
+
+  // A second element in the same file means the slide is not declarative data.
+  const rest = src.slice(i);
+  const second = rest.match(/<([A-Z][A-Za-z0-9]*)/);
+  if (second) {
+    throw new Error(`${file}: more than one component element (<${second[1]}>) — one slide, one element.`);
+  }
+
+  delete props.assetsPath;
+  return { component, props, warnings };
+}