slidemind 0.1.7 → 0.1.9

package/src/pptx/slide-swap.mjs

@@ -0,0 +1,429 @@
+// Host-free `slidemind add-slide --from <file.pptx>`: fold picked slide(s) from a
+// local .pptx into one-slide native packages the deck render splices in. The
+// add-in's render-time splicer copies only the LOWEST-numbered slide part's
+// dependency tree (see firstSlidePath in ooxml.mjs): slide → layout → master →
+// the master's relationships, skipping External targets and dropping notesSlide
+// rels. So to reuse slide N we:
+//   1. SWAP slide N (+ its rels) into the lowest-numbered slot (firstSlidePath),
+//   2. strip the notesSlide rel (the splicer drops it anyway),
+//   3. trim the slide master to the picked slide's actual layout,
+//   4. PRUNE the package to that slide's dependency closure + a trimmed carrier
+//      skeleton — dropping the OTHER slides, unused master layouts, and every
+//      part only they reference.
+//
+// Pruning to the closure cannot break the render: it is exactly the set of parts
+// the splicer copies. It also shrinks a folded slice from the whole source deck
+// (a media-heavy 70MB deck × several picks blew the backend's 256MB body limit)
+// to just what the one slide needs, and makes the folded file a valid standalone
+// one-slide deck (opens clean; `slidemind read` reports 1 slide).
+//
+// The output of foldPickedSlides feeds reusedSlideTargets in
+// src/lib/reused-slides.mjs (which turns each pick's slideId into an NN-reused-
+// <shortid>.pptx filename). We only supply { selection, slideId, bytes } here.
+
+import { unzip, zip, readText } from "./zip.mjs";
+import {
+  slideOrderPaths,
+  firstSlidePath,
+  relsFor,
+  relsPathFor,
+  resolvePartPath,
+} from "./ooxml.mjs";
+import { stripHiddenOleGraphicFrames } from "./hidden-ole.mjs";
+import { stripRiskyImageExtensions } from "./image-extensions.mjs";
+
+// The four package parts we always keep and rewrite for standalone validity.
+const SKELETON = [
+  "[Content_Types].xml",
+  "_rels/.rels",
+  "ppt/presentation.xml",
+  "ppt/_rels/presentation.xml.rels",
+];
+
+// Fold each pick (1-based slide numbers in presentation order) into its own
+// complete .pptx. Returns `[{ selection, slideId, bytes }]`, aligned 1:1 with
+// `picks`. Bytes is a Uint8Array of a one-slide package; for a single-slide
+// source that needs no swap, no notes strip, and no prune, the ORIGINAL buffer
+// is returned untouched (no re-zip, best fidelity).
+export function foldPickedSlides(buffer, picks, { sourceName = "reused" } = {}) {
+  const files = unzip(buffer);
+  const order = slideOrderPaths(files);
+  const count = order.length;
+  const entries = sldIdEntries(files);
+
+  // Validate EVERY pick before doing any work, so a bad batch fails cleanly.
+  for (const n of picks) {
+    if (!Number.isInteger(n) || n < 1 || n > count) {
+      throw new Error(
+        `--from source has ${count} slide(s); --pick ${n} is out of range`,
+      );
+    }
+  }
+
+  const lowest = firstSlidePath(files);
+  const lowestRels = relsPathFor(lowest);
+
+  return picks.map((n) => {
+    const picked = order[n - 1];
+    const sldId = entries[n - 1] ? entries[n - 1].sldId : null;
+    const slideId = makeSlideId(sourceName, sldId, n);
+
+    // Build the post-swap package on a fresh copy. The picked slide's body + rels
+    // must occupy the lowest slot (what the splicer reads); its notesSlide rel is
+    // stripped so the folded file carries no orphan notes/notesMaster.
+    const copy = { ...files };
+    const swapped = picked !== lowest;
+    if (swapped) {
+      copy[lowest] = files[picked];
+      copy[picked] = files[lowest];
+      const pickedRels = relsPathFor(picked);
+      const pickedRelsBytes = files[pickedRels];
+      const lowestRelsBytes = files[lowestRels];
+      if (pickedRelsBytes !== undefined) copy[lowestRels] = pickedRelsBytes;
+      else delete copy[lowestRels];
+      if (lowestRelsBytes !== undefined) copy[pickedRels] = lowestRelsBytes;
+      else delete copy[pickedRels];
+    }
+    let notesStripped = false;
+    if (copy[lowestRels] !== undefined && hasNotesRel(copy[lowestRels])) {
+      copy[lowestRels] = stripNotesRel(copy[lowestRels]);
+      notesStripped = true;
+    }
+    const hiddenOleStripped = stripHiddenOleGraphicFrames(copy);
+    const riskyImagesStripped = stripRiskyImageExtensions(copy);
+
+    // Prune to the lowest slide's dependency closure + trimmed skeleton.
+    const { entries: pruned, changed } = pruneToLowest(copy);
+
+    // Identity fast-path: an already-lowest, notes-free, nothing-to-prune source
+    // (e.g. a single-slide file) returns verbatim — no re-zip, byte-for-byte.
+    if (
+      !swapped &&
+      !notesStripped &&
+      !hiddenOleStripped &&
+      !riskyImagesStripped &&
+      !changed
+    ) {
+      return { selection: n, slideId, bytes: buffer };
+    }
+    return { selection: n, slideId, bytes: zip(pruned) };
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Dependency closure + prune
+// ---------------------------------------------------------------------------
+
+const SLIDE_PART_RE = /^ppt\/slides\/slide\d+\.xml$/;
+
+// BFS the internal-rel closure reachable from `start`, including each visited
+// part's own `_rels/<base>.rels`. Mirrors the splicer's walk: skip
+// TargetMode="External" and Type ".../notesSlide" so the closure is exactly the
+// set of parts the render-time splice copies. NEVER traverse INTO another slide
+// part (a slide is only ever added as an explicit `start`): otherwise walking
+// from e.g. presentation.xml — or a co-authoring revisionInfo part — would drag
+// every other slide's whole tree back in and defeat the prune.
+function dependencyClosure(files, start, { slideMasterLayouts = new Map() } = {}) {
+  const keep = new Set();
+  const queue = [];
+  const visit = (part, isStart) => {
+    if (!part || files[part] === undefined || keep.has(part)) return;
+    if (!isStart && SLIDE_PART_RE.test(part)) return; // slides are roots only
+    keep.add(part);
+    queue.push(part);
+  };
+  visit(start, true);
+  while (queue.length) {
+    const part = queue.shift();
+    const dir = part.includes("/") ? part.slice(0, part.lastIndexOf("/")) : "";
+    // Keep the part's own rels file, and follow its internal targets.
+    const relsPath = relsPathFor(part);
+    if (files[relsPath] !== undefined) keep.add(relsPath);
+    for (const rel of relsFor(files, part)) {
+      if (rel.targetMode === "External") continue;
+      if (rel.type && rel.type.endsWith("/notesSlide")) continue;
+      const target = resolvePartPath(dir, rel.target);
+      if (rel.type && rel.type.endsWith("/slideLayout")) {
+        const allowedLayouts = slideMasterLayouts.get(part);
+        if (allowedLayouts && !allowedLayouts.has(target)) continue;
+      }
+      visit(target, false);
+    }
+  }
+  return keep;
+}
+
+// Prune a post-swap package to the lowest slide's closure plus a carrier skeleton
+// rewritten for standalone validity. Returns { entries, changed } where `changed`
+// is false only when nothing was dropped AND no skeleton bytes were rewritten.
+function pruneToLowest(files) {
+  const lowest = firstSlidePath(files);
+  const slideMasterLayouts = pickedSlideMasterLayouts(files, lowest);
+  const keep = dependencyClosure(files, lowest, { slideMasterLayouts });
+
+  // Classify the presentation's own rels. Keep slide→lowest, masters in the
+  // closure, and every other rel type broadly (presProps/viewProps/tableStyles/
+  // theme/tags/authors/commentAuthors/revisionInfo/customXml) — folding each
+  // kept target's closure in so their sidecars (e.g. customXml itemProps) ride
+  // along. Drop the other slides, and notes/handout masters.
+  const presRelsPath = "ppt/_rels/presentation.xml.rels";
+  const lowestRid = new Set(); // r:id of the kept slide
+  const keptMasterRids = new Set();
+  const droppedPresRelIds = new Set();
+  for (const rel of relsFor(files, "ppt/presentation.xml")) {
+    const type = rel.type || "";
+    if (rel.targetMode === "External") continue;
+    const target = resolvePartPath("ppt", rel.target);
+    if (type.endsWith("/slide")) {
+      if (target === lowest) {
+        if (rel.id) lowestRid.add(rel.id);
+      } else if (rel.id) {
+        droppedPresRelIds.add(rel.id);
+      }
+    } else if (type.endsWith("/slideMaster")) {
+      if (keep.has(target)) {
+        if (rel.id) keptMasterRids.add(rel.id);
+      } else if (rel.id) {
+        droppedPresRelIds.add(rel.id);
+      }
+    } else if (type.endsWith("/notesMaster") || type.endsWith("/handoutMaster")) {
+      if (rel.id) droppedPresRelIds.add(rel.id);
+    } else {
+      // Keep broadly — pull the target and its own closure in.
+      for (const p of dependencyClosure(files, target)) keep.add(p);
+    }
+  }
+
+  // _rels/.rels: keep the document (presentation.xml — skeleton) + doc-properties
+  // (core/custom), drop the stale extended props (app.xml <Slides> count is a
+  // repair trigger), thumbnail, and webext taskpanes pointer. Just add the kept
+  // targets — do NOT walk presentation.xml's closure here (it fans out to every
+  // slide); presentation.xml's own useful parts are covered by the classification
+  // loop above and the lowest slide's closure.
+  const droppedRootRelIds = new Set();
+  for (const rel of relsFor(files, "")) {
+    const type = rel.type || "";
+    if (
+      type.endsWith("/extended-properties") ||
+      type.endsWith("/thumbnail") ||
+      type.endsWith("/webextensiontaskpanes")
+    ) {
+      if (rel.id) droppedRootRelIds.add(rel.id);
+      continue;
+    }
+    if (rel.targetMode === "External") continue;
+    const target = resolvePartPath("", rel.target);
+    keep.add(target);
+    const sidecar = relsPathFor(target);
+    if (files[sidecar] !== undefined) keep.add(sidecar);
+  }
+
+  for (const s of SKELETON) keep.add(s);
+
+  // Everything not in the closure is dropped.
+  const dropped = [];
+  for (const part of Object.keys(files)) if (!keep.has(part)) dropped.push(part);
+
+  // Assemble kept parts verbatim, then overwrite the skeleton with rewrites.
+  const out = {};
+  for (const part of keep) if (files[part] !== undefined) out[part] = files[part];
+
+  let skeletonChanged = false;
+  const rewrite = (part, fn) => {
+    if (files[part] === undefined) return;
+    const before = readText(files, part);
+    const after = fn(before);
+    if (after !== before) skeletonChanged = true;
+    out[part] = new TextEncoder().encode(after);
+  };
+
+  rewrite("[Content_Types].xml", (ct) => {
+    for (const d of dropped) ct = removeOverrideByPartName(ct, "/" + d);
+    return ct;
+  });
+  rewrite("_rels/.rels", (xml) => {
+    for (const id of droppedRootRelIds) xml = removeRelationshipById(xml, id);
+    return xml;
+  });
+  rewrite(presRelsPath, (xml) => {
+    for (const id of droppedPresRelIds) xml = removeRelationshipById(xml, id);
+    return xml;
+  });
+  rewrite("ppt/presentation.xml", (pres) => {
+    pres = pres.replace(/<p:sldIdLst\b[\s\S]*?<\/p:sldIdLst>/, (b) =>
+      trimEntryList(b, "p:sldId", "r:id", lowestRid),
+    );
+    pres = pres.replace(/<p:sldMasterIdLst\b[\s\S]*?<\/p:sldMasterIdLst>/, (b) =>
+      trimEntryList(b, "p:sldMasterId", "r:id", keptMasterRids),
+    );
+    pres = removeListEntirely(pres, "p:notesMasterIdLst");
+    pres = removeListEntirely(pres, "p:handoutMasterIdLst");
+    return pres;
+  });
+
+  rewritePickedMasters(out, files, slideMasterLayouts, rewrite);
+
+  return { entries: out, changed: dropped.length > 0 || skeletonChanged };
+}
+
+function pickedSlideMasterLayouts(files, slidePart) {
+  const out = new Map();
+  const slideDir = slidePart.includes("/") ? slidePart.slice(0, slidePart.lastIndexOf("/")) : "";
+  for (const rel of relsFor(files, slidePart)) {
+    if (rel.targetMode === "External" || !rel.type?.endsWith("/slideLayout")) continue;
+    const layout = resolvePartPath(slideDir, rel.target);
+    const layoutDir = layout.includes("/") ? layout.slice(0, layout.lastIndexOf("/")) : "";
+    for (const layoutRel of relsFor(files, layout)) {
+      if (
+        layoutRel.targetMode === "External" ||
+        !layoutRel.type?.endsWith("/slideMaster")
+      ) {
+        continue;
+      }
+      const master = resolvePartPath(layoutDir, layoutRel.target);
+      if (!out.has(master)) out.set(master, new Set());
+      out.get(master).add(layout);
+    }
+  }
+  return out;
+}
+
+function rewritePickedMasters(out, files, slideMasterLayouts, rewrite) {
+  for (const [master, allowedLayouts] of slideMasterLayouts) {
+    if (out[master] === undefined) continue;
+    const masterDir = master.includes("/") ? master.slice(0, master.lastIndexOf("/")) : "";
+    const keepRids = new Set();
+    const dropRids = new Set();
+    for (const rel of relsFor(files, master)) {
+      if (!rel.type?.endsWith("/slideLayout")) continue;
+      const target = resolvePartPath(masterDir, rel.target);
+      if (allowedLayouts.has(target)) {
+        if (rel.id) keepRids.add(rel.id);
+      } else if (rel.id) {
+        dropRids.add(rel.id);
+      }
+    }
+
+    rewrite(relsPathFor(master), (xml) => {
+      for (const id of dropRids) xml = removeRelationshipById(xml, id);
+      return xml;
+    });
+    rewrite(master, (xml) =>
+      xml.replace(/<p:sldLayoutIdLst\b[\s\S]*?<\/p:sldLayoutIdLst>/, (b) =>
+        trimEntryList(b, "p:sldLayoutId", "r:id", keepRids),
+      ),
+    );
+  }
+}
+
+// ---------------------------------------------------------------------------
+// XML element removal — operate on the ORIGINAL text, never reconstruct a doc.
+// Each helper tolerates both self-closing `<X …/>` and paired `<X …>…</X>`.
+// ---------------------------------------------------------------------------
+
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+// Remove the <Relationship> with the given Id (self-closing or paired form).
+function removeRelationshipById(xml, id) {
+  return xml.replace(
+    new RegExp(
+      `<Relationship\\b(?=[^>]*\\bId="${escapeRe(id)}")[^>]*?(?:/>|>[\\s\\S]*?</Relationship>)`,
+      "g",
+    ),
+    "",
+  );
+}
+
+// Remove the <Override> for a PartName (always self-closing; leading slash).
+function removeOverrideByPartName(xml, partName) {
+  return xml.replace(
+    new RegExp(
+      `<Override\\b(?=[^>]*\\bPartName="${escapeRe(partName)}")[^>]*?/>`,
+      "g",
+    ),
+    "",
+  );
+}
+
+// Drop <tag … idAttr="X" …> entries whose id is not in keepIds (self-closing or
+// paired — sldId can carry a child <p:extLst>).
+function trimEntryList(xml, tag, idAttr, keepIds) {
+  const re = new RegExp(`<${escapeRe(tag)}\\b[^>]*?(?:/>|>[\\s\\S]*?</${escapeRe(tag)}>)`, "g");
+  const idRe = new RegExp(`\\b${escapeRe(idAttr)}\\s*=\\s*"([^"]+)"`);
+  return xml.replace(re, (m) => {
+    const id = idRe.exec(m)?.[1];
+    return id && keepIds.has(id) ? m : "";
+  });
+}
+
+// Remove a list element entirely (e.g. notesMasterIdLst / handoutMasterIdLst).
+function removeListEntirely(xml, tag) {
+  return xml.replace(
+    new RegExp(`<${escapeRe(tag)}\\b[^>]*?(?:/>|>[\\s\\S]*?</${escapeRe(tag)}>)`, "g"),
+    "",
+  );
+}
+
+// ---------------------------------------------------------------------------
+// sldId / slideId helpers (unchanged behaviour)
+// ---------------------------------------------------------------------------
+
+// The `<p:sldId>` entries of presentation.xml in document order, each resolved to
+// its slide part plus the sldId "id" attribute — parallel to slideOrderPaths, but
+// carrying the id we key the folded slide by.
+function sldIdEntries(files) {
+  const presXml = readText(files, "ppt/presentation.xml");
+  if (!presXml) return [];
+  const listMatch = /<p:sldIdLst[\s\S]*?<\/p:sldIdLst>/.exec(presXml);
+  if (!listMatch) return [];
+
+  const rels = {};
+  for (const rel of relsFor(files, "ppt/presentation.xml")) {
+    if (rel.id) rels[rel.id] = rel;
+  }
+
+  const out = [];
+  const re = /<p:sldId\b([^>]*)>/g;
+  let m;
+  while ((m = re.exec(listMatch[0])) !== null) {
+    const attrs = m[1];
+    const idM = /\bid\s*=\s*"([^"]+)"/.exec(attrs);
+    const ridM = /\br:id\s*=\s*"([^"]+)"/.exec(attrs);
+    if (!ridM) continue;
+    const rel = rels[ridM[1]];
+    if (!rel) continue;
+    const path = resolvePartPath("ppt", rel.target);
+    if (!/^ppt\/slides\/slide\d+\.xml$/.test(path)) continue;
+    out.push({ path, sldId: idM ? idM[1] : null });
+  }
+  return out;
+}
+
+// A deterministic, non-empty id for the folded slide: `<source>-<sldId|index>`.
+// It feeds shortIdFor (which lowercases, strips non-alnum, truncates to 8), so a
+// light sanitize here is enough — the exact shape is flexible.
+function makeSlideId(sourceName, sldId, index) {
+  const base =
+    String(sourceName)
+      .replace(/^.*[\\/]/, "") // drop any directory
+      .replace(/\.[^.]+$/, "") // drop the extension
+      .replace(/[^a-z0-9]/gi, "") || "reused";
+  return `${base}-${sldId != null ? sldId : index}`;
+}
+
+// Whether a rels part's bytes declare a notesSlide relationship.
+function hasNotesRel(bytes) {
+  return /\bType="[^"]*\/notesSlide"/.test(
+    new TextDecoder("utf-8").decode(bytes),
+  );
+}
+
+// Remove any `Type="…/notesSlide"` Relationship element from a rels part's bytes.
+function stripNotesRel(bytes) {
+  const xml = new TextDecoder("utf-8").decode(bytes);
+  const stripped = xml.replace(
+    /<Relationship\b[^>]*?Type="[^"]*\/notesSlide"[^>]*?>/g,
+    "",
+  );
+  return new TextEncoder().encode(stripped);
+}

package/src/pptx/zip.mjs

@@ -0,0 +1,30 @@
+// The single fflate seam for the local-.pptx modules. A .pptx is an OPC zip, so
+// every read/write of one funnels through here — the rest of src/pptx/ stays
+// dependency-free and works on the plain `Record<path, Uint8Array>` entry map
+// this module produces. Keeping fflate behind one file means the packaging
+// guard (test/packaging.test.mjs) only has to bless one import site.
+
+import { unzipSync, zipSync } from "fflate";
+
+// Unzip a .pptx buffer to its entry map (zip path → raw bytes). `buffer` may be
+// a Node Buffer or a Uint8Array; fflate reads either. Non-zip bytes make fflate
+// throw ("invalid zip data") — callers wrap that into a clear .pptx message.
+export function unzip(buffer) {
+  return unzipSync(
+    buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer),
+  );
+}
+
+// Zip an entry map (zip path → Uint8Array) back into a .pptx byte buffer.
+// Level 6 matches the OOXML-friendly middle ground the add-in uses.
+export function zip(entries) {
+  return zipSync(entries, { level: 6 });
+}
+
+// Decode one zip entry as UTF-8 text, or null when the part is absent. The
+// workhorse for OOXML parsing — every XML part is read through here.
+export function readText(files, partPath) {
+  const bytes = files[partPath];
+  if (!bytes) return null;
+  return new TextDecoder("utf-8").decode(bytes);
+}