slidemind 0.1.8 → 0.1.9

package/src/pptx/ooxml.mjs

@@ -0,0 +1,169 @@
+// Pure OOXML helpers over a .pptx entry map (zip path → Uint8Array), shared by
+// read-local.mjs and slide-swap.mjs. No fflate import here — callers hand in an
+// already-unzipped `files` map (see zip.mjs). These are deliberately
+// regex-over-XML, not a DOM: the shapes we touch (sldIdLst, rels, placeholders,
+// text runs) are simple, and @xmldom/xmldom is forbidden by the packaging guard.
+
+import { readText } from "./zip.mjs";
+
+// ---------------------------------------------------------------------------
+// Presentation order — the authoritative slide sequence
+// ---------------------------------------------------------------------------
+
+// The slide play order as PowerPoint stores it: the `<p:sldId>` entries in
+// `<p:sldIdLst>` (document order), each `r:id` mapped through
+// presentation.xml.rels to its slide part. This is NOT filename order — after a
+// reorder in PowerPoint, slide3.xml can be the first slide. Returns normalized
+// `ppt/slides/slideN.xml` paths, in play order; non-slide targets are dropped.
+export function slideOrderPaths(files) {
+  const presXml = readText(files, "ppt/presentation.xml");
+  if (!presXml) return [];
+
+  // Isolate the sldIdLst so a stray r:id elsewhere in the part can't leak in.
+  const listMatch = /<p:sldIdLst[\s\S]*?<\/p:sldIdLst>/.exec(presXml);
+  if (!listMatch) return [];
+
+  // r:id in document order (the on-screen slide sequence).
+  const rIds = [];
+  const idRe = /<p:sldId\b[^>]*\br:id\s*=\s*"([^"]+)"/g;
+  let m;
+  while ((m = idRe.exec(listMatch[0])) !== null) rIds.push(m[1]);
+
+  const rels = relsById(files, "ppt/presentation.xml");
+  const out = [];
+  for (const rId of rIds) {
+    const rel = rels[rId];
+    if (!rel) continue;
+    const resolved = resolvePartPath("ppt", rel.target);
+    if (/^ppt\/slides\/slide\d+\.xml$/.test(resolved)) out.push(resolved);
+  }
+  return out;
+}
+
+// The lowest-numbered slide part, `ppt/slides/slideN.xml` with the minimum N, or
+// null if the package has none. This mirrors the add-in render-time splicer
+// byte-for-byte: it picks the lowest-numbered slide part and copies only that
+// slide's dependency tree. Keep this the SINGLE definition of "lowest" so the
+// fold in slide-swap.mjs lands the picked slide exactly where the splicer looks.
+export function firstSlidePath(files) {
+  let best = null;
+  let bestN = Infinity;
+  for (const key of Object.keys(files)) {
+    const m = /^ppt\/slides\/slide(\d+)\.xml$/.exec(key);
+    if (!m) continue;
+    const n = parseInt(m[1], 10);
+    if (n < bestN) {
+      bestN = n;
+      best = key;
+    }
+  }
+  return best;
+}
+
+// ---------------------------------------------------------------------------
+// Relationships
+// ---------------------------------------------------------------------------
+
+// Parse the `.rels` for any part into `[{ id, type, target, targetMode }]`;
+// empty array when the part has no rels. The rels part lives beside the part in
+// a `_rels/` sibling dir, named `<base>.rels` (e.g. ppt/slides/slide1.xml →
+// ppt/slides/_rels/slide1.xml.rels).
+export function relsFor(files, partPath) {
+  const relsPath = relsPathFor(partPath);
+  const xml = readText(files, relsPath);
+  if (!xml) return [];
+  const out = [];
+  const re = /<Relationship\b[^>]*\/?>/g;
+  let m;
+  while ((m = re.exec(xml)) !== null) {
+    const tag = m[0];
+    const id = attr(tag, "Id");
+    const type = attr(tag, "Type");
+    const target = attr(tag, "Target");
+    const targetMode = attr(tag, "TargetMode");
+    if (id === null && type === null && target === null) continue;
+    out.push({ id, type, target, targetMode });
+  }
+  return out;
+}
+
+// relsFor keyed by relationship Id — the r:id → Target lookup slideOrderPaths
+// needs. Internal helper; callers outside this module use relsFor.
+function relsById(files, partPath) {
+  const map = {};
+  for (const rel of relsFor(files, partPath)) {
+    if (rel.id) map[rel.id] = rel;
+  }
+  return map;
+}
+
+// The `_rels/<base>.rels` sibling path for a part. Exported shape is implicit
+// via relsFor/slide-swap; kept internal since callers reason in part paths.
+export function relsPathFor(partPath) {
+  const slash = partPath.lastIndexOf("/");
+  const dir = slash === -1 ? "" : partPath.slice(0, slash);
+  const base = slash === -1 ? partPath : partPath.slice(slash + 1);
+  return `${dir ? dir + "/" : ""}_rels/${base}.rels`;
+}
+
+// ---------------------------------------------------------------------------
+// Path + entity primitives
+// ---------------------------------------------------------------------------
+
+// Resolve a rels Target to a normalized zip path (no leading slash). Targets are
+// either relative to the part's own dir (`../slideLayouts/slideLayout1.xml`,
+// `slides/slide3.xml`) or package-absolute (`/ppt/slides/slide3.xml`). `fromDir`
+// is the directory the relative target is anchored at (e.g. "ppt" for
+// presentation.xml.rels, "ppt/slides" for a slide's rels).
+export function resolvePartPath(fromDir, target) {
+  if (target == null) return "";
+  let t = String(target).trim();
+  // Package-absolute: drop the leading slash, ignore fromDir.
+  if (t.startsWith("/")) return normalizeSegments(t.slice(1).split("/"));
+  const base = fromDir ? fromDir.split("/").filter(Boolean) : [];
+  return normalizeSegments(base.concat(t.split("/")));
+}
+
+// Collapse "." / ".." segments in a split path into a clean slash-joined string.
+function normalizeSegments(parts) {
+  const out = [];
+  for (const seg of parts) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      out.pop();
+      continue;
+    }
+    out.push(seg);
+  }
+  return out.join("/");
+}
+
+// Decode the five predefined XML entities plus numeric character references
+// (`&#233;`, `&#xE9;`). Ampersand is resolved LAST so a decoded `&` from a
+// numeric ref can't be re-read as the head of another entity.
+export function decodeXmlEntities(s) {
+  if (s == null) return s;
+  return String(s)
+    .replace(/&#x([0-9a-fA-F]+);/g, (_, h) => codePoint(parseInt(h, 16)))
+    .replace(/&#(\d+);/g, (_, d) => codePoint(parseInt(d, 10)))
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&amp;/g, "&");
+}
+
+function codePoint(n) {
+  if (!Number.isFinite(n) || n < 0 || n > 0x10ffff) return "";
+  try {
+    return String.fromCodePoint(n);
+  } catch {
+    return "";
+  }
+}
+
+// Read one double-quoted attribute off a start tag, or null if absent.
+function attr(tag, name) {
+  const m = new RegExp(`\\b${name}\\s*=\\s*"([^"]*)"`).exec(tag);
+  return m ? m[1] : null;
+}

package/src/pptx/read-local.mjs

@@ -0,0 +1,206 @@
+// Host-free `slidemind read <file.pptx>`: parse a .pptx on disk into the SAME
+// `{ ok, mode, slideCount, slides[] }` shape the add-in returns for an open
+// presentation (test/read-presentation.test.mjs), so the CLI printer is shared.
+// Everything runs locally over the unzipped entry map — no bridge, no host.
+//
+// All fields are computed regardless of mode; the CLI printer selects what to
+// show. `notes` is additive for `--json` consumers and is always populated here.
+
+import { unzip, readText } from "./zip.mjs";
+import {
+  slideOrderPaths,
+  relsFor,
+  resolvePartPath,
+  decodeXmlEntities,
+} from "./ooxml.mjs";
+
+// Parse a .pptx buffer. Throws a clear, CLI-printable message when the bytes
+// aren't a .pptx (missing presentation.xml) or aren't a zip at all — the CLI
+// prints error.message verbatim.
+export function readLocalPptx(buffer, { mode = "raw" } = {}) {
+  let files;
+  try {
+    files = unzip(buffer);
+  } catch (err) {
+    // fflate's own reason ("invalid zip data") — surface it, framed as .pptx.
+    throw new Error(`not a valid .pptx: ${err.message}`);
+  }
+  if (!files["ppt/presentation.xml"]) {
+    throw new Error("not a valid .pptx (missing ppt/presentation.xml)");
+  }
+
+  const order = slideOrderPaths(files);
+  const slides = order.map((slidePath, i) => {
+    const xml = readText(files, slidePath) ?? "";
+    const { title, subtitle, text } = slideText(xml);
+    return {
+      index: i + 1,
+      layout: layoutName(files, slidePath),
+      title,
+      subtitle,
+      text,
+      notes: notesText(files, slidePath),
+    };
+  });
+
+  return { ok: true, mode, slideCount: slides.length, slides };
+}
+
+// ---------------------------------------------------------------------------
+// Text extraction
+// ---------------------------------------------------------------------------
+
+// Split a slide's XML into its text and pull title/subtitle/body. The host
+// read's raw `text` is the FULL slide text, so a title/subtitle run counts in
+// both the dedicated field and in `text`.
+//   - title:    a shape whose <p:ph type="title"|"ctrTitle">.
+//   - subtitle: a shape whose <p:ph type="subTitle">.
+//   - text:     every paragraph's runs, one line per <a:p>, tables tab/newline
+//               joined, empty paragraphs dropped, entities decoded.
+export function slideText(slideXml) {
+  // Drop <mc:Fallback> branches up front: an AlternateContent block stores the
+  // same shape twice (Choice = canonical, Fallback = legacy rendering), so a
+  // text-bearing fallback would double-print every run.
+  slideXml = stripFallbacks(slideXml);
+  let title = null;
+  let subtitle = null;
+
+  // Title/subtitle come from placeholder shapes (<p:sp> carrying <p:ph>). They
+  // are single outline labels: an <a:br/> or paragraph break inside the
+  // placeholder is visual line-wrapping, not content structure — collapse to one
+  // line so the summary printer stays one line per slide. Body `text` keeps its
+  // breaks.
+  for (const sp of matchAll(slideXml, /<p:sp\b[\s\S]*?<\/p:sp>/g)) {
+    const ph = /<p:ph\b[^>]*\btype\s*=\s*"([^"]+)"/.exec(sp);
+    const phType = ph ? ph[1] : null;
+    if (phType === "title" || phType === "ctrTitle") {
+      if (title === null) title = outlineLabel(sp);
+    } else if (phType === "subTitle") {
+      if (subtitle === null) subtitle = outlineLabel(sp);
+    }
+  }
+
+  // Full slide text = every text-bearing container in document order: shapes
+  // (<p:sp>) and tables (<a:tbl> inside <p:graphicFrame>). Walking the raw XML
+  // once keeps shapes and tables in their on-slide order.
+  const lines = [];
+  const containerRe = /<p:sp\b[\s\S]*?<\/p:sp>|<a:tbl\b[\s\S]*?<\/a:tbl>/g;
+  for (const chunk of matchAll(slideXml, containerRe)) {
+    if (chunk.startsWith("<a:tbl")) {
+      const t = tableText(chunk);
+      if (t) lines.push(t);
+    } else {
+      for (const line of shapeParagraphText(chunk)) lines.push(line);
+    }
+  }
+
+  return { title, subtitle, text: lines.join("\n") };
+}
+
+// A placeholder's text flattened to a single-line label (line breaks → spaces,
+// runs of whitespace collapsed), or null when empty.
+function outlineLabel(spXml) {
+  const label = shapeParagraphText(spXml)
+    .join(" ")
+    .replace(/\s+/g, " ")
+    .trim();
+  return label || null;
+}
+
+// The non-empty paragraph lines of a text body: one line per <a:p>, its <a:t>
+// runs concatenated with <a:br/> rendered as a newline, entities decoded.
+// Whitespace-only paragraphs are dropped.
+function shapeParagraphText(xml) {
+  const out = [];
+  for (const p of matchAll(xml, /<a:p\b[\s\S]*?<\/a:p>/g)) {
+    const line = paragraphLine(p);
+    if (line.trim() !== "") out.push(line);
+  }
+  return out;
+}
+
+// One paragraph → its text, with <a:br/> as newline. We walk runs and breaks in
+// document order so a break lands between the right runs.
+function paragraphLine(pXml) {
+  let s = "";
+  const re = /<a:t>([\s\S]*?)<\/a:t>|<a:br\b[^>]*\/?>/g;
+  let m;
+  while ((m = re.exec(pXml)) !== null) {
+    if (m[1] !== undefined) s += decodeXmlEntities(m[1]);
+    else s += "\n";
+  }
+  return s;
+}
+
+// A table (<a:tbl>): cells tab-joined within a row, rows newline-joined. Each
+// cell's own text is its paragraph lines joined by newline (rare but possible).
+function tableText(tblXml) {
+  const rows = [];
+  for (const tr of matchAll(tblXml, /<a:tr\b[\s\S]*?<\/a:tr>/g)) {
+    const cells = [];
+    for (const tc of matchAll(tr, /<a:tc\b[\s\S]*?<\/a:tc>/g)) {
+      cells.push(shapeParagraphText(tc).join("\n"));
+    }
+    rows.push(cells.join("\t"));
+  }
+  return rows.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Layout + notes (resolved through the slide's rels)
+// ---------------------------------------------------------------------------
+
+// The slide's layout name: follow the slide → slideLayout relationship, then
+// read the layout's <p:cSld name="…">. Null when there's no layout rel or the
+// layout has no name.
+export function layoutName(files, slidePath) {
+  const layoutPath = relTarget(files, slidePath, "/slideLayout");
+  if (!layoutPath) return null;
+  const xml = readText(files, layoutPath);
+  if (!xml) return null;
+  const m = /<p:cSld\b[^>]*\bname\s*=\s*"([^"]*)"/.exec(xml);
+  return m ? decodeXmlEntities(m[1]) : null;
+}
+
+// The slide's speaker notes text, or null when no notesSlide is attached.
+// Extracted with the same paragraph/table rules as the slide body.
+export function notesText(files, slidePath) {
+  const notesPath = relTarget(files, slidePath, "/notesSlide");
+  if (!notesPath) return null;
+  let xml = readText(files, notesPath);
+  if (!xml) return null;
+  xml = stripFallbacks(xml);
+  const lines = [];
+  for (const sp of matchAll(xml, /<p:sp\b[\s\S]*?<\/p:sp>/g)) {
+    for (const line of shapeParagraphText(sp)) lines.push(line);
+  }
+  return lines.join("\n");
+}
+
+// Resolve the single related part whose Type ends with `typeSuffix`
+// (e.g. "/slideLayout", "/notesSlide") to a normalized zip path, or null.
+function relTarget(files, slidePath, typeSuffix) {
+  const fromDir = slidePath.slice(0, slidePath.lastIndexOf("/"));
+  for (const rel of relsFor(files, slidePath)) {
+    if (rel.type && rel.type.endsWith(typeSuffix)) {
+      return resolvePartPath(fromDir, rel.target);
+    }
+  }
+  return null;
+}
+
+// Remove every <mc:Fallback>…</mc:Fallback> block. Fallbacks re-encode their
+// AlternateContent's Choice branch for older consumers, so their runs are
+// duplicates by definition — extracting both would double the text.
+function stripFallbacks(xml) {
+  if (!xml.includes("<mc:Fallback")) return xml;
+  return xml.replace(/<mc:Fallback>[\s\S]*?<\/mc:Fallback>/g, "");
+}
+
+// String.prototype.matchAll over a global regex, yielding the full match text.
+function matchAll(str, re) {
+  const out = [];
+  let m;
+  while ((m = re.exec(str)) !== null) out.push(m[0]);
+  return out;
+}