slidemind 0.1.8 → 0.2.0

package/src/pptx/app-props.mjs

@@ -0,0 +1,222 @@
+// Normalize PowerPoint package metadata after server-side assembly.
+//
+// The render backend can assemble authored JSX slides plus reused native .pptx
+// slides correctly while leaving docProps/app.xml counted from the JSX-only
+// source deck. PowerPoint treats stale <Slides>, HeadingPairs, or TitlesOfParts
+// metadata as repairable corruption on open. This post-process keeps those
+// extended properties aligned with the actual slide order in ppt/presentation.xml.
+//
+// Reused native slides can also bring duplicate copies of a source deck's slide
+// master tree. Those copies legitimately need distinct relationship targets, but
+// PowerPoint allocates <p:sldMasterId id> and <p:sldLayoutId id> from a single
+// shared id space and treats any collision across that whole space as repairable
+// corruption on open. A splicer that assigns new master ids from a watermark that
+// only scanned presentation.xml can hand a spliced master the same numeric id as
+// an existing brand layout. Treat the sldMasterId values as fixed anchors and
+// renumber only the colliding sldLayoutId values, keeping every r:id pointer
+// untouched and never rewriting presentation.xml.
+
+import { unzip, zip, readText } from "./zip.mjs";
+import { slideOrderPaths, decodeXmlEntities } from "./ooxml.mjs";
+import { slideText } from "./read-local.mjs";
+import { stripHiddenOleGraphicFrames } from "./hidden-ole.mjs";
+import { stripRiskyImageExtensions } from "./image-extensions.mjs";
+
+const APP_PROPS = "docProps/app.xml";
+
+export function normalizePptxAppProperties(buffer) {
+  let files;
+  try {
+    files = unzip(buffer);
+  } catch {
+    return { bytes: buffer, changed: false, slideCount: null };
+  }
+
+  if (!files["ppt/presentation.xml"]) {
+    return { bytes: buffer, changed: false, slideCount: null };
+  }
+
+  const order = slideOrderPaths(files);
+  const slideCount = order.length;
+  let entries = files;
+  let changed = false;
+
+  const before = readText(files, APP_PROPS);
+  if (before && slideCount > 0) {
+    let after = replaceElementText(before, "Slides", String(slideCount));
+    after = replaceSlideTitleHeadingCount(after, slideCount);
+    after = replaceTitlesOfParts(after, slideTitles(files, order));
+    if (after !== before) {
+      entries = { ...entries, [APP_PROPS]: new TextEncoder().encode(after) };
+      changed = true;
+    }
+  }
+
+  const idResult = normalizeMasterAndLayoutIds(entries);
+  if (idResult.changed) {
+    entries = idResult.entries;
+    changed = true;
+  }
+
+  if (stripHiddenOleGraphicFrames(entries)) {
+    changed = true;
+  }
+  if (stripRiskyImageExtensions(entries)) {
+    changed = true;
+  }
+
+  return {
+    bytes: changed ? zip(entries) : buffer,
+    changed,
+    slideCount,
+  };
+}
+
+export function normalizePptxAppPropertiesBase64(base64) {
+  const normalized = normalizePptxAppProperties(Buffer.from(base64, "base64"));
+  if (!normalized.changed) {
+    return { ...normalized, base64 };
+  }
+  return {
+    ...normalized,
+    base64: Buffer.from(normalized.bytes).toString("base64"),
+  };
+}
+
+function slideTitles(files, order) {
+  return order.map((slidePath, i) => {
+    const xml = readText(files, slidePath) ?? "";
+    const { title, subtitle } = slideText(xml);
+    return title || subtitle || `Slide ${i + 1}`;
+  });
+}
+
+const LAYOUT_ID_FLOOR = 2147483648;
+
+function normalizeMasterAndLayoutIds(files) {
+  const masterParts = Object.keys(files)
+    .filter((part) => /^ppt\/slideMasters\/slideMaster\d+\.xml$/.test(part))
+    .sort(numericPartSort);
+  if (masterParts.length === 0) return { entries: files, changed: false };
+
+  // sldMasterId values live in presentation.xml and are the fixed anchors of the
+  // shared id space — never renumbered here (that would mean rewriting
+  // presentation.xml, and a master-vs-master collision is the server's to fix).
+  const presentationXml = readText(files, "ppt/presentation.xml") ?? "";
+  const masterIds = [];
+  for (const tag of presentationXml.matchAll(/<p:sldMasterId\b[^>]*>/g)) {
+    const id = attr(tag[0], "id");
+    if (id !== null) masterIds.push(id);
+  }
+
+  const layoutIds = [];
+  for (const part of masterParts) {
+    const xml = readText(files, part) ?? "";
+    for (const tag of xml.matchAll(/<p:sldLayoutId\b[^>]*>/g)) {
+      const id = attr(tag[0], "id");
+      if (id !== null) layoutIds.push(id);
+    }
+  }
+
+  // Inert unless the master and layout ids collide somewhere across the union —
+  // keeps well-formed (and server-fixed) output byte-stable.
+  const union = [...masterIds, ...layoutIds];
+  if (new Set(union).size === union.length) {
+    return { entries: files, changed: false };
+  }
+
+  const numericIds = union.map((id) => Number(id)).filter(Number.isFinite);
+  let nextId = numericIds.length ? Math.max(...numericIds) + 1 : LAYOUT_ID_FLOOR;
+
+  // Seed with the master anchors so a layout id equal to a master id is treated
+  // as a collision and moved off it. Then walk masters/layouts in document order,
+  // renumbering only ids already claimed.
+  const seen = new Set(masterIds);
+  let entries = files;
+  let changed = false;
+
+  for (const part of masterParts) {
+    const before = readText(files, part) ?? "";
+    const after = before.replace(/<p:sldLayoutId\b[^>]*>/g, (tag) => {
+      const id = attr(tag, "id");
+      if (id === null || !seen.has(id)) {
+        if (id !== null) seen.add(id);
+        return tag;
+      }
+      while (seen.has(String(nextId))) nextId += 1;
+      const replacement = String(nextId);
+      nextId += 1;
+      seen.add(replacement);
+      return replaceAttr(tag, "id", replacement);
+    });
+    if (after !== before) {
+      entries = { ...entries, [part]: new TextEncoder().encode(after) };
+      changed = true;
+    }
+  }
+
+  return { entries, changed };
+}
+
+function replaceElementText(xml, tagName, value) {
+  return xml.replace(
+    new RegExp(`(<${tagName}>)[\\s\\S]*?(</${tagName}>)`),
+    `$1${value}$2`,
+  );
+}
+
+function attr(tag, name) {
+  const m = new RegExp(`(^|\\s)${name}="([^"]*)"`).exec(tag);
+  return m ? m[2] : null;
+}
+
+function replaceAttr(tag, name, value) {
+  return tag.replace(
+    new RegExp(`(^|\\s)${name}="[^"]*"`),
+    `$1${name}="${value}"`,
+  );
+}
+
+function numericPartSort(a, b) {
+  const na = Number(a.match(/(\d+)\.xml$/)?.[1] ?? 0);
+  const nb = Number(b.match(/(\d+)\.xml$/)?.[1] ?? 0);
+  return na - nb || a.localeCompare(b);
+}
+
+function replaceSlideTitleHeadingCount(xml, slideCount) {
+  return xml.replace(
+    /(<vt:variant>\s*<vt:lpstr>Slide Titles<\/vt:lpstr>\s*<\/vt:variant>\s*<vt:variant>\s*<vt:i4>)-?\d+(<\/vt:i4>\s*<\/vt:variant>)/,
+    `$1${slideCount}$2`,
+  );
+}
+
+function replaceTitlesOfParts(xml, titles) {
+  return xml.replace(
+    /<TitlesOfParts>\s*<vt:vector\b[^>]*>[\s\S]*?<\/vt:vector>\s*<\/TitlesOfParts>/,
+    (match) => {
+      const themeName = firstLpstr(match) || "Theme";
+      const values = [themeName, ...titles]
+        .map((title) => `<vt:lpstr>${escapeXml(title)}</vt:lpstr>`)
+        .join("");
+      return (
+        `<TitlesOfParts><vt:vector size="${titles.length + 1}" baseType="lpstr">` +
+        values +
+        `</vt:vector></TitlesOfParts>`
+      );
+    },
+  );
+}
+
+function firstLpstr(xml) {
+  const m = /<vt:lpstr>([\s\S]*?)<\/vt:lpstr>/.exec(xml);
+  return m ? decodeXmlEntities(m[1]) : null;
+}
+
+function escapeXml(value) {
+  return String(value)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}