@bendyline/squisq-formats 1.3.1 → 1.4.1

package/dist/{chunk-VN2KEOYB.js → chunk-YESS7VY3.js}

@@ -1,3 +1,11 @@
+import {
+  inlineNodeToRuns,
+  inlineNodesToRuns
+} from "./chunk-6M7Z25LA.js";
+import {
+  extractPlainText,
+  stripHtmlTags
+} from "./chunk-PN52A5AA.js";
 import {
   CONTENT_TYPE_PPTX_PRESENTATION,
   CONTENT_TYPE_PPTX_SLIDE,
@@ -5,7 +13,9 @@ import {
   CONTENT_TYPE_PPTX_SLIDE_MASTER,
   CONTENT_TYPE_PPTX_THEME,
   NS_DRAWINGML,
+  NS_MC,
   NS_PML,
+  NS_PML_2010,
   NS_R,
   REL_HYPERLINK,
   REL_IMAGE,
@@ -14,16 +24,29 @@ import {
   REL_SLIDE_LAYOUT,
   REL_SLIDE_MASTER,
   REL_THEME,
-  createPackage
-} from "./chunk-7DEUGIOO.js";
+  createPackage,
+  getPartBinary,
+  getPartRelationships,
+  getPartXml,
+  openPackage
+} from "./chunk-SHLPSADL.js";
 import {
   escapeXml,
   xmlDeclaration
 } from "./chunk-U4MRIFKL.js";
+import {
+  buildContainer
+} from "./chunk-SSUPBUF5.js";
+import {
+  inferMimeType
+} from "./chunk-MJGRI6XR.js";
+import {
+  extToMime
+} from "./chunk-DQAZR57U.js";
 
 // src/pptx/export.ts
-import { resolveTheme, resolveFontFamily } from "@bendyline/squisq/schemas";
-import { docToMarkdown } from "@bendyline/squisq/doc";
+import { resolveFontFamily } from "@bendyline/squisq/schemas";
+import { docToMarkdown, resolveThemeForDoc } from "@bendyline/squisq/doc";
 import { readFrontmatterThemeId } from "@bendyline/squisq/markdown";
 
 // src/pptx/styles.ts
@@ -65,7 +88,7 @@ function buildThemeXml() {
 // src/pptx/export.ts
 async function markdownDocToPptx(doc, options = {}) {
   const themeId = options.themeId ?? readFrontmatterThemeId(doc.frontmatter);
-  const style = resolveSlideStyle(themeId, options);
+  const style = resolveSlideStyle(themeId, options, doc);
   const slides = segmentIntoSlides(doc.children, options.slideBreak ?? "h2");
   if (slides.length === 0) {
     slides.push({ bodyNodes: [] });
@@ -87,7 +110,7 @@ async function docToPptx(doc, options = {}) {
   }
   return markdownDocToPptx(markdownDoc, options);
 }
-function resolveSlideStyle(themeId, options) {
+function resolveSlideStyle(themeId, options, doc) {
   if (!themeId) {
     return {
       background: "FFFFFF",
@@ -101,7 +124,7 @@ function resolveSlideStyle(themeId, options) {
       hasTheme: false
     };
   }
-  const theme = resolveTheme(themeId);
+  const theme = resolveThemeForDoc(doc, themeId);
   const c = theme.colors;
   return {
     background: stripHash(c.background),
@@ -128,6 +151,7 @@ function segmentIntoSlides(children, slideBreak) {
       current = {
         title: extractPlainText(node.children),
         titleDepth: node.depth,
+        transition: node.attributes?.blockMeta?.transition,
         bodyNodes: []
       };
     } else {
@@ -140,36 +164,6 @@ function segmentIntoSlides(children, slideBreak) {
   if (current) slides.push(current);
   return slides;
 }
-function extractPlainText(nodes) {
-  const parts = [];
-  for (const node of nodes) {
-    switch (node.type) {
-      case "text":
-        parts.push(node.value);
-        break;
-      case "inlineCode":
-        parts.push(node.value);
-        break;
-      case "strong":
-      case "emphasis":
-      case "delete":
-        parts.push(extractPlainText(node.children));
-        break;
-      case "link":
-        parts.push(extractPlainText(node.children));
-        break;
-      case "image":
-        parts.push(node.alt ?? "");
-        break;
-      case "inlineMath":
-        parts.push(node.value);
-        break;
-      default:
-        break;
-    }
-  }
-  return parts.join("");
-}
 var SlideContext = class {
   // 1=group, 2=title, 3=body
   constructor(style, images, slideIndex) {
@@ -273,7 +267,175 @@ function buildSlideXml(slide, ctx) {
     );
   }
   const bgXml = ctx.style.hasTheme ? `<p:bg><p:bgPr><a:solidFill><a:srgbClr val="${ctx.style.background}"/></a:solidFill><a:effectLst/></p:bgPr></p:bg>` : "";
-  return xmlDeclaration() + `<p:sld xmlns:a="${NS_DRAWINGML}" xmlns:r="${NS_R}" xmlns:p="${NS_PML}"><p:cSld>` + bgXml + `<p:spTree>` + shapes.join("") + `</p:spTree></p:cSld></p:sld>`;
+  const transitionXml = buildTransitionXml(slide.transition);
+  const extensionAttrs = transitionXml.includes("p14:") ? ` xmlns:mc="${NS_MC}" xmlns:p14="${NS_PML_2010}" mc:Ignorable="p14"` : "";
+  return xmlDeclaration() + `<p:sld xmlns:a="${NS_DRAWINGML}" xmlns:r="${NS_R}" xmlns:p="${NS_PML}"${extensionAttrs}><p:cSld>` + bgXml + `<p:spTree>` + shapes.join("") + `</p:spTree></p:cSld>` + transitionXml + `</p:sld>`;
+}
+function buildTransitionXml(transition) {
+  if (!transition || transition.type === "cut") return "";
+  const child = buildTransitionChildXml(transition);
+  const spd = pptxSpeedForDuration(transition.duration);
+  return `<p:transition spd="${spd}">${child.xml}</p:transition>`;
+}
+function buildTransitionChildXml(transition) {
+  const type = transition.type;
+  switch (type) {
+    case "fade":
+    case "morph":
+      return p("fade");
+    case "dissolve":
+      return p("dissolve");
+    case "push":
+      return p("push", ` dir="${sideDir(transition.direction, "left")}"`);
+    case "slideLeft":
+      return p("push", ` dir="l"`);
+    case "slideRight":
+      return p("push", ` dir="r"`);
+    case "slideUp":
+      return p("push", ` dir="u"`);
+    case "slideDown":
+      return p("push", ` dir="d"`);
+    case "wipe":
+      return p("wipe", ` dir="${sideDir(transition.direction, "left")}"`);
+    case "split":
+      return p("split", ` orient="${orientation(transition.direction)}" dir="out"`);
+    case "randomBars":
+    case "randomBar":
+      return p("randomBar", ` dir="${orientation(transition.direction)}"`);
+    case "shape":
+    case "circle":
+      return p("circle");
+    case "diamond":
+      return p("diamond");
+    case "plus":
+      return p("plus");
+    case "uncover":
+    case "pull":
+      return p("pull", ` dir="${sideDir(transition.direction, "left")}"`);
+    case "cover":
+      return p("cover", ` dir="${sideDir(transition.direction, "left")}"`);
+    case "checkerboard":
+    case "checker":
+      return p("checker", ` dir="${orientation(transition.direction)}"`);
+    case "blinds":
+      return p("blinds", ` dir="${orientation(transition.direction)}"`);
+    case "comb":
+      return p("comb", ` dir="${orientation(transition.direction)}"`);
+    case "clock":
+    case "wheel":
+      return p("wheel", ` spokes="4"`);
+    case "wheelReverse":
+      return p14("wheelReverse");
+    case "newsflash":
+      return p("newsflash");
+    case "random":
+      return p("random");
+    case "strips":
+      return p("strips", ` dir="${cornerDir(transition.direction)}"`);
+    case "wedge":
+      return p("wedge");
+    case "zoom":
+    case "box":
+      return p("zoom", ` dir="${inOutDir(transition.direction, "in")}"`);
+    case "flash":
+      return p14("flash");
+    case "vortex":
+    case "orbit":
+    case "rotate":
+      return p14("vortex");
+    case "switch":
+    case "cube":
+      return p14("switch");
+    case "flip":
+    case "fallOver":
+      return p14("flip");
+    case "ripple":
+      return p14("ripple");
+    case "glitter":
+    case "prestige":
+      return p14("glitter");
+    case "honeycomb":
+      return p14("honeycomb");
+    case "prism":
+      return p14("prism");
+    case "doors":
+    case "drape":
+    case "curtains":
+      return p14("doors");
+    case "window":
+      return p14("window");
+    case "shred":
+    case "fracture":
+    case "crush":
+      return p14("shred");
+    case "ferris":
+    case "ferrisWheel":
+      return p14("ferris");
+    case "flythrough":
+    case "flyThrough":
+    case "airplane":
+    case "origami":
+      return p14("flythrough");
+    case "warp":
+    case "pageCurl":
+    case "pageCurlDouble":
+    case "pageCurlSingle":
+    case "peelOff":
+      return p14("warp");
+    case "gallery":
+      return p14("gallery");
+    case "conveyor":
+      return p14("conveyor");
+    case "pan":
+    case "wind":
+      return p14("pan");
+    case "reveal":
+      return p14("reveal");
+    default:
+      return p("fade");
+  }
+}
+function p(tag, attrs = "") {
+  return { xml: `<p:${tag}${attrs}/>` };
+}
+function p14(tag, attrs = "") {
+  return { xml: `<p14:${tag}${attrs}/>` };
+}
+function pptxSpeedForDuration(duration) {
+  if (duration != null && duration <= 0.5) return "fast";
+  if (duration != null && duration >= 1.2) return "slow";
+  return "med";
+}
+function sideDir(direction, fallback) {
+  switch (direction ?? fallback) {
+    case "right":
+      return "r";
+    case "up":
+      return "u";
+    case "down":
+      return "d";
+    case "left":
+    default:
+      return "l";
+  }
+}
+function cornerDir(direction) {
+  switch (direction) {
+    case "right":
+    case "down":
+      return "rd";
+    case "up":
+      return "lu";
+    case "left":
+    default:
+      return "ld";
+  }
+}
+function orientation(direction) {
+  return direction === "vertical" || direction === "up" || direction === "down" ? "vert" : "horz";
+}
+function inOutDir(direction, fallback) {
+  return direction === "out" ? "out" : direction === "in" ? "in" : fallback;
 }
 function buildTitleShape(title, style) {
   return `<p:sp><p:nvSpPr><p:cNvPr id="2" name="Title"/><p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr><p:nvPr><p:ph type="title"/></p:nvPr></p:nvSpPr><p:spPr><a:xfrm><a:off x="${TITLE_LEFT}" y="${TITLE_TOP}"/><a:ext cx="${TITLE_WIDTH}" cy="${TITLE_HEIGHT}"/></a:xfrm></p:spPr><p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:r><a:rPr lang="en-US" sz="${DEFAULT_TITLE_SIZE}" dirty="0"><a:solidFill><a:srgbClr val="${style.titleColor}"/></a:solidFill><a:latin typeface="${escapeXml(style.titleFont)}"/></a:rPr><a:t>${escapeXml(title)}</a:t></a:r></a:p></p:txBody></p:sp>`;
@@ -420,38 +582,19 @@ function convertHtmlBlock(node, ctx) {
 function convertMathBlock(node) {
   return `<a:p><a:pPr algn="ctr"/><a:r><a:rPr lang="en-US" i="1"><a:latin typeface="Cambria Math"/></a:rPr><a:t>${escapeXml(node.value)}</a:t></a:r></a:p>`;
 }
+function pptxRunHandlers(ctx) {
+  return {
+    run: (text, format) => makeRun(text, format, ctx.style),
+    link: (node, format) => convertLink(node, ctx, format),
+    image: (node, format) => convertImage(node, format, ctx),
+    lineBreak: () => `<a:br/>`
+  };
+}
 function convertInlines(nodes, ctx, format = {}) {
-  const parts = [];
-  for (const node of nodes) {
-    parts.push(convertInline(node, ctx, format));
-  }
-  return parts.join("");
+  return inlineNodesToRuns(nodes, pptxRunHandlers(ctx), format);
 }
 function convertInline(node, ctx, format) {
-  switch (node.type) {
-    case "text":
-      return makeRun(node.value, format, ctx.style);
-    case "strong":
-      return convertInlines(node.children, ctx, { ...format, bold: true });
-    case "emphasis":
-      return convertInlines(node.children, ctx, { ...format, italic: true });
-    case "delete":
-      return convertInlines(node.children, ctx, { ...format, strike: true });
-    case "inlineCode":
-      return makeRun(node.value, { ...format, code: true }, ctx.style);
-    case "link":
-      return convertLink(node, ctx, format);
-    case "image":
-      return convertImage(node, format, ctx);
-    case "break":
-      return `<a:br/>`;
-    case "htmlInline":
-      return makeRun(stripHtmlTags(node.rawHtml), format, ctx.style);
-    case "inlineMath":
-      return makeRun(node.value, { ...format, code: true }, ctx.style);
-    default:
-      return "";
-  }
+  return inlineNodeToRuns(node, pptxRunHandlers(ctx), format);
 }
 function makeRun(text, format, style) {
   if (!text) return "";
@@ -593,41 +736,190 @@ async function buildPptxPackage(slideXmls, slideContexts, options) {
   }
   return pkg.toArrayBuffer();
 }
-function stripHtmlTags(html) {
-  return html.replace(/<[^>]*>/g, "");
-}
 function inferExtension(path) {
   const dot = path.lastIndexOf(".");
   if (dot === -1) return "png";
   const ext = path.substring(dot + 1).toLowerCase().split("?")[0];
   return ext || "png";
 }
-function inferMimeType(ext) {
-  const mimeTypes = {
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    png: "image/png",
-    gif: "image/gif",
-    webp: "image/webp",
-    svg: "image/svg+xml",
-    bmp: "image/bmp",
-    avif: "image/avif"
+
+// src/pptx/index.ts
+import { markdownToDoc } from "@bendyline/squisq/doc";
+
+// src/pptx/import.ts
+import { stringifyMarkdown } from "@bendyline/squisq/markdown";
+function attrNS(el, ns, local, fallback) {
+  return el.getAttributeNS(ns, local) ?? el.getAttribute(fallback);
+}
+function resolveTarget(baseDir, target) {
+  if (target.startsWith("/")) return target.replace(/^\//, "");
+  const stack = baseDir ? baseDir.split("/") : [];
+  for (const seg of target.split("/")) {
+    if (seg === "..") stack.pop();
+    else if (seg !== ".") stack.push(seg);
+  }
+  return stack.join("/");
+}
+async function orderedSlidePaths(pkg) {
+  const pres = await getPartXml(pkg, "ppt/presentation.xml");
+  if (!pres) return [];
+  const rels = await getPartRelationships(pkg, "ppt/presentation.xml");
+  const relById = new Map(rels.map((r) => [r.id, r.target]));
+  const out = [];
+  const ids = pres.getElementsByTagNameNS(NS_PML, "sldId");
+  for (let i = 0; i < ids.length; i++) {
+    const rid = attrNS(ids[i], NS_R, "id", "r:id");
+    const target = rid ? relById.get(rid) : void 0;
+    if (target) out.push(resolveTarget("ppt", target));
+  }
+  return out;
+}
+function paragraphText(para) {
+  const ts = para.getElementsByTagNameNS(NS_DRAWINGML, "t");
+  let s = "";
+  for (let i = 0; i < ts.length; i++) s += ts[i].textContent ?? "";
+  return s.trim();
+}
+function isTitleShape(sp) {
+  const ph = sp.getElementsByTagNameNS(NS_PML, "ph");
+  if (!ph.length) return false;
+  const type = ph[0].getAttribute("type");
+  return type === "title" || type === "ctrTitle";
+}
+function tableToMarkdown(tbl) {
+  const rows = [];
+  const trs = tbl.getElementsByTagNameNS(NS_DRAWINGML, "tr");
+  for (let r = 0; r < trs.length; r++) {
+    const tcs = trs[r].getElementsByTagNameNS(NS_DRAWINGML, "tc");
+    const cells = [];
+    for (let c = 0; c < tcs.length; c++) {
+      const paras = tcs[c].getElementsByTagNameNS(NS_DRAWINGML, "p");
+      const text = Array.from({ length: paras.length }, (_, i) => paragraphText(paras[i])).filter(Boolean).join(" ");
+      cells.push({
+        type: "tableCell",
+        ...r === 0 ? { isHeader: true } : {},
+        children: text ? [{ type: "text", value: text }] : []
+      });
+    }
+    rows.push({ type: "tableRow", children: cells });
+  }
+  return { type: "table", children: rows };
+}
+function baseDirOf(path) {
+  const slash = path.lastIndexOf("/");
+  return slash === -1 ? "" : path.slice(0, slash);
+}
+async function extractSlideImages(doc, slidePath, ctx) {
+  const rels = await getPartRelationships(ctx.pkg, slidePath);
+  const relById = new Map(rels.map((r) => [r.id, r.target]));
+  const baseDir = baseDirOf(slidePath);
+  const images = [];
+  const pics = doc.getElementsByTagNameNS(NS_PML, "pic");
+  for (let i = 0; i < pics.length; i++) {
+    const pic = pics[i];
+    const blips = pic.getElementsByTagNameNS(NS_DRAWINGML, "blip");
+    if (!blips.length) continue;
+    const embed = attrNS(blips[0], NS_R, "embed", "r:embed");
+    if (!embed) continue;
+    const target = relById.get(embed);
+    if (!target) continue;
+    const mediaPath = resolveTarget(baseDir, target);
+    const data = await getPartBinary(ctx.pkg, mediaPath);
+    if (!data) continue;
+    const dot = mediaPath.lastIndexOf(".");
+    const ext = dot !== -1 ? mediaPath.slice(dot).toLowerCase() : ".png";
+    const mimeType = extToMime(ext);
+    ctx.imageCounter++;
+    const imagePath = `images/image${ctx.imageCounter}${ext}`;
+    ctx.extractedImages.set(imagePath, { data, mimeType });
+    const cNvPrs = pic.getElementsByTagNameNS(NS_PML, "cNvPr");
+    const alt = (cNvPrs.length ? cNvPrs[0].getAttribute("descr") || cNvPrs[0].getAttribute("name") : "") || "Image";
+    images.push({ type: "image", url: imagePath, alt });
+  }
+  return images;
+}
+async function convertSlide(path, index, ctx) {
+  const pkg = ctx.pkg;
+  const doc = await getPartXml(pkg, path);
+  if (!doc) return [];
+  const out = [];
+  let title = "";
+  const bullets = [];
+  const shapes = doc.getElementsByTagNameNS(NS_PML, "sp");
+  for (let s = 0; s < shapes.length; s++) {
+    const sp = shapes[s];
+    const txBody = sp.getElementsByTagNameNS(NS_PML, "txBody");
+    if (!txBody.length) continue;
+    const paras = txBody[0].getElementsByTagNameNS(NS_DRAWINGML, "p");
+    const texts = [];
+    for (let p2 = 0; p2 < paras.length; p2++) {
+      const t = paragraphText(paras[p2]);
+      if (t) texts.push(t);
+    }
+    if (texts.length === 0) continue;
+    if (isTitleShape(sp) && !title) {
+      title = texts.join(" ");
+    } else {
+      bullets.push(...texts);
+    }
+  }
+  out.push({
+    type: "heading",
+    depth: 2,
+    children: [{ type: "text", value: title || `Slide ${index + 1}` }]
+  });
+  if (bullets.length > 0) {
+    const items = bullets.map((text) => ({
+      type: "listItem",
+      children: [{ type: "paragraph", children: [{ type: "text", value: text }] }]
+    }));
+    out.push({ type: "list", ordered: false, children: items });
+  }
+  if (ctx.extractImages) {
+    const images = await extractSlideImages(doc, path, ctx);
+    for (const image of images) {
+      out.push({ type: "paragraph", children: [image] });
+    }
+  }
+  const tbls = doc.getElementsByTagNameNS(NS_DRAWINGML, "tbl");
+  for (let t = 0; t < tbls.length; t++) out.push(tableToMarkdown(tbls[t]));
+  return out;
+}
+async function importDocument(pkg, options) {
+  const ctx = {
+    pkg,
+    extractImages: options.extractImages ?? false,
+    extractedImages: /* @__PURE__ */ new Map(),
+    imageCounter: 0
   };
-  return mimeTypes[ext] || "image/png";
+  const paths = await orderedSlidePaths(pkg);
+  const children = [];
+  for (let i = 0; i < paths.length; i++) {
+    children.push(...await convertSlide(paths[i], i, ctx));
+  }
+  return { doc: { type: "document", children }, ctx };
+}
+async function pptxToMarkdownDoc(data, options = {}) {
+  const pkg = await openPackage(data);
+  const { doc } = await importDocument(pkg, options);
+  return doc;
+}
+async function pptxToContainer(data, options = {}) {
+  const pkg = await openPackage(data);
+  const { doc, ctx } = await importDocument(pkg, { ...options, extractImages: true });
+  return buildContainer(stringifyMarkdown(doc), ctx.extractedImages);
 }
 
 // src/pptx/index.ts
-async function pptxToMarkdownDoc(_data, _options) {
-  throw new Error("PPTX import is not yet implemented");
-}
-async function pptxToDoc(_data, _options) {
-  throw new Error("PPTX import is not yet implemented");
+async function pptxToDoc(data, options) {
+  return markdownToDoc(await pptxToMarkdownDoc(data, options));
 }
 
 export {
   markdownDocToPptx,
   docToPptx,
   pptxToMarkdownDoc,
+  pptxToContainer,
   pptxToDoc
 };
-//# sourceMappingURL=chunk-VN2KEOYB.js.map
+//# sourceMappingURL=chunk-YESS7VY3.js.map