@bendyline/squisq-formats 1.3.0 → 1.4.0

package/src/pptx/export.ts

@@ -27,10 +27,10 @@
  * ```
  */
 
-import type { Doc } from '@bendyline/squisq/schemas';
-import { resolveTheme, resolveFontFamily } from '@bendyline/squisq/schemas';
+import type { Doc, Transition, TransitionDirection } from '@bendyline/squisq/schemas';
+import { resolveFontFamily } from '@bendyline/squisq/schemas';
 import type { Theme } from '@bendyline/squisq/schemas';
-import { docToMarkdown } from '@bendyline/squisq/doc';
+import { docToMarkdown, resolveThemeForDoc } from '@bendyline/squisq/doc';
 import type {
   MarkdownDocument,
   MarkdownBlockNode,
@@ -52,9 +52,18 @@ import { readFrontmatterThemeId } from '@bendyline/squisq/markdown';
 
 import { createPackage } from '../ooxml/writer.js';
 import { xmlDeclaration, escapeXml } from '../ooxml/xmlUtils.js';
+import { inferMimeType } from '../html/imageUtils.js';
+import { stripHtmlTags, extractPlainText } from '../shared/text.js';
+import {
+  inlineNodesToRuns,
+  inlineNodeToRuns,
+  type InlineRunHandlers,
+} from '../shared/inlineRuns.js';
 import {
   NS_PML,
+  NS_PML_2010,
   NS_DRAWINGML,
+  NS_MC,
   NS_R,
   REL_OFFICE_DOCUMENT,
   REL_SLIDE,
@@ -143,7 +152,7 @@ export async function markdownDocToPptx(
   // shorter legacy `themeId` / `theme` aliases — see
   // `readFrontmatterThemeId` for the precedence.
   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');
 
@@ -196,7 +205,11 @@ interface SlideStyle {
   hasTheme: boolean;
 }
 
-function resolveSlideStyle(themeId: string | undefined, options: PptxExportOptions): SlideStyle {
+function resolveSlideStyle(
+  themeId: string | undefined,
+  options: PptxExportOptions,
+  doc: MarkdownDocument,
+): SlideStyle {
   if (!themeId) {
     return {
       background: 'FFFFFF',
@@ -211,7 +224,7 @@ function resolveSlideStyle(themeId: string | undefined, options: PptxExportOptio
     };
   }
 
-  const theme: Theme = resolveTheme(themeId);
+  const theme: Theme = resolveThemeForDoc(doc, themeId);
   const c = theme.colors;
 
   return {
@@ -238,6 +251,7 @@ function stripHash(color: string): string {
 interface SlideData {
   title?: string;
   titleDepth?: number;
+  transition?: Transition;
   bodyNodes: MarkdownBlockNode[];
 }
 
@@ -255,6 +269,7 @@ function segmentIntoSlides(
       current = {
         title: extractPlainText(node.children),
         titleDepth: node.depth,
+        transition: node.attributes?.blockMeta?.transition,
         bodyNodes: [],
       };
     } else {
@@ -269,37 +284,6 @@ function segmentIntoSlides(
   return slides;
 }
 
-function extractPlainText(nodes: MarkdownInlineNode[]): string {
-  const parts: string[] = [];
-  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('');
-}
-
 // ============================================
 // Slide Context
 // ============================================
@@ -450,20 +434,208 @@ function buildSlideXml(slide: SlideData, ctx: SlideContext): string {
   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>`
     : '';
+  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}">` +
+    `<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>`
   );
 }
 
+interface TransitionXml {
+  xml: string;
+}
+
+function buildTransitionXml(transition: Transition | undefined): string {
+  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: Transition): TransitionXml {
+  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: string, attrs: string = ''): TransitionXml {
+  return { xml: `<p:${tag}${attrs}/>` };
+}
+
+function p14(tag: string, attrs: string = ''): TransitionXml {
+  return { xml: `<p14:${tag}${attrs}/>` };
+}
+
+function pptxSpeedForDuration(duration: number | undefined): 'fast' | 'med' | 'slow' {
+  if (duration != null && duration <= 0.5) return 'fast';
+  if (duration != null && duration >= 1.2) return 'slow';
+  return 'med';
+}
+
+function sideDir(
+  direction: TransitionDirection | undefined,
+  fallback: TransitionDirection,
+): string {
+  switch (direction ?? fallback) {
+    case 'right':
+      return 'r';
+    case 'up':
+      return 'u';
+    case 'down':
+      return 'd';
+    case 'left':
+    default:
+      return 'l';
+  }
+}
+
+function cornerDir(direction: TransitionDirection | undefined): string {
+  switch (direction) {
+    case 'right':
+    case 'down':
+      return 'rd';
+    case 'up':
+      return 'lu';
+    case 'left':
+    default:
+      return 'ld';
+  }
+}
+
+function orientation(direction: TransitionDirection | undefined): string {
+  return direction === 'vertical' || direction === 'up' || direction === 'down' ? 'vert' : 'horz';
+}
+
+function inOutDir(direction: TransitionDirection | undefined, fallback: 'in' | 'out'): string {
+  return direction === 'out' ? 'out' : direction === 'in' ? 'in' : fallback;
+}
+
 function buildTitleShape(title: string, style: SlideStyle): string {
   return (
     `<p:sp>` +
@@ -768,43 +940,29 @@ interface InlineFormat {
   code?: boolean;
 }
 
+/**
+ * PPTX leaf handlers for the shared run-based inline walker. The traversal
+ * (format threading) lives in `shared/inlineRuns.ts`; these emit DrawingML.
+ */
+function pptxRunHandlers(ctx: SlideContext): InlineRunHandlers {
+  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: MarkdownInlineNode[],
   ctx: SlideContext,
   format: InlineFormat = {},
 ): string {
-  const parts: string[] = [];
-  for (const node of nodes) {
-    parts.push(convertInline(node, ctx, format));
-  }
-  return parts.join('');
+  return inlineNodesToRuns(nodes, pptxRunHandlers(ctx), format);
 }
 
 function convertInline(node: MarkdownInlineNode, ctx: SlideContext, format: InlineFormat): string {
-  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: string, format: InlineFormat, style: SlideStyle): string {
@@ -1013,10 +1171,6 @@ async function buildPptxPackage(
 // Helpers
 // ============================================
 
-function stripHtmlTags(html: string): string {
-  return html.replace(/<[^>]*>/g, '');
-}
-
 function inferExtension(path: string): string {
   const dot = path.lastIndexOf('.');
   if (dot === -1) return 'png';
@@ -1026,17 +1180,3 @@ function inferExtension(path: string): string {
     .split('?')[0];
   return ext || 'png';
 }
-
-function inferMimeType(ext: string): string {
-  const mimeTypes: Record<string, string> = {
-    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',
-  };
-  return mimeTypes[ext] || 'image/png';
-}

package/src/pptx/import.ts

@@ -0,0 +1,156 @@
+/**
+ * PPTX import — PresentationML (.pptx) → MarkdownDocument.
+ *
+ * Reuses the shared ooxml/ reader. Reads slide order from
+ * `ppt/presentation.xml` (`<p:sldIdLst>`), resolves each slide part via
+ * relationships, and converts each slide to: an H2 of the title placeholder
+ * (or "Slide N"), the remaining text as a bullet list, and any slide tables
+ * (`<a:tbl>`) as markdown tables. Text lives in the DrawingML namespace
+ * (`a:p` / `a:r` / `a:t`) inside PresentationML shapes (`p:sp`).
+ */
+
+import type {
+  MarkdownBlockNode,
+  MarkdownDocument,
+  MarkdownListItem,
+  MarkdownTable,
+  MarkdownTableCell,
+  MarkdownTableRow,
+} from '@bendyline/squisq/markdown';
+import { getPartRelationships, getPartXml, openPackage } from '../ooxml/reader.js';
+import type { OoxmlPackage } from '../ooxml/types.js';
+import { NS_DRAWINGML, NS_PML, NS_R } from '../ooxml/namespaces.js';
+
+export interface PptxImportOptions {
+  /** Whether to extract embedded images as data URIs (not yet used). */
+  extractImages?: boolean;
+}
+
+function attrNS(el: Element, ns: string, local: string, fallback: string): string | null {
+  return el.getAttributeNS(ns, local) ?? el.getAttribute(fallback);
+}
+
+function resolveTarget(baseDir: string, target: string): string {
+  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: OoxmlPackage): Promise<string[]> {
+  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: string[] = [];
+  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) : undefined;
+    if (target) out.push(resolveTarget('ppt', target));
+  }
+  return out;
+}
+
+/** Concatenate the DrawingML text runs (`a:t`) inside a paragraph element. */
+function paragraphText(para: Element): string {
+  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: Element): boolean {
+  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: Element): MarkdownTable {
+  const rows: MarkdownTableRow[] = [];
+  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: MarkdownTableCell[] = [];
+    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 };
+}
+
+async function convertSlide(
+  pkg: OoxmlPackage,
+  path: string,
+  index: number,
+): Promise<MarkdownBlockNode[]> {
+  const doc = await getPartXml(pkg, path);
+  if (!doc) return [];
+  const out: MarkdownBlockNode[] = [];
+
+  let title = '';
+  const bullets: string[] = [];
+  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: string[] = [];
+    for (let p = 0; p < paras.length; p++) {
+      const t = paragraphText(paras[p]!);
+      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: MarkdownListItem[] = bullets.map((text) => ({
+      type: 'listItem',
+      children: [{ type: 'paragraph', children: [{ type: 'text', value: text }] }],
+    }));
+    out.push({ type: 'list', ordered: false, children: items });
+  }
+
+  const tbls = doc.getElementsByTagNameNS(NS_DRAWINGML, 'tbl');
+  for (let t = 0; t < tbls.length; t++) out.push(tableToMarkdown(tbls[t]!));
+
+  return out;
+}
+
+export async function pptxToMarkdownDoc(
+  data: ArrayBuffer | Blob,
+  _options: PptxImportOptions = {},
+): Promise<MarkdownDocument> {
+  const pkg = await openPackage(data);
+  const paths = await orderedSlidePaths(pkg);
+  const children: MarkdownBlockNode[] = [];
+  for (let i = 0; i < paths.length; i++) {
+    children.push(...(await convertSlide(pkg, paths[i]!, i)));
+  }
+  return { type: 'document', children };
+}

package/src/pptx/index.ts

@@ -7,7 +7,7 @@
  * Slide segmentation: each H1/H2 heading starts a new slide by default.
  * Inline formatting (bold, italic, code, links) is preserved as DrawingML runs.
  *
- * Import is not yet implemented.
+ * Includes both export and import paths.
  *
  * @example
  * ```ts
@@ -19,38 +19,20 @@
 export { markdownDocToPptx, docToPptx } from './export.js';
 export type { PptxExportOptions } from './export.js';
 
-// Import (stubs — not yet implemented)
-import type { MarkdownDocument } from '@bendyline/squisq/markdown';
+// Import
+import { markdownToDoc } from '@bendyline/squisq/doc';
 import type { Doc } from '@bendyline/squisq/schemas';
+import { type PptxImportOptions, pptxToMarkdownDoc } from './import.js';
 
-/**
- * Options for PPTX import (placeholder).
- */
-export interface PptxImportOptions {
-  /** Whether to extract embedded images as data URIs */
-  extractImages?: boolean;
-}
+export type { PptxImportOptions } from './import.js';
+export { pptxToMarkdownDoc } from './import.js';
 
 /**
- * Convert a .pptx file to a MarkdownDocument.
- *
- * @throws Error — PPTX import is not yet implemented
- */
-export async function pptxToMarkdownDoc(
-  _data: ArrayBuffer | Blob,
-  _options?: PptxImportOptions,
-): Promise<MarkdownDocument> {
-  throw new Error('PPTX import is not yet implemented');
-}
-
-/**
- * Convert a .pptx file to a squisq Doc.
- *
- * @throws Error — PPTX import is not yet implemented
+ * Convert a .pptx file to a squisq Doc (via the markdown model).
  */
 export async function pptxToDoc(
-  _data: ArrayBuffer | Blob,
-  _options?: PptxImportOptions,
+  data: ArrayBuffer | Blob,
+  options?: PptxImportOptions,
 ): Promise<Doc> {
-  throw new Error('PPTX import is not yet implemented');
+  return markdownToDoc(await pptxToMarkdownDoc(data, options));
 }