@opencraw/office-reader 0.0.2

package/dist/read-pptx.use-case.esm.js

@@ -0,0 +1,591 @@
+import { w as walkXml, n as namespacedAttribute, i as isOn, a as OoxmlPackage, r as readSource, b as relationshipOfType, c as relationshipsOf, O as OfficeReadError } from './read-source.client.esm.js';
+import 'fflate';
+
+/**
+ * Reads a chart part: its type, title and series, from the values the chart
+ * caches next to its formulas (`c:strCache`, `c:numCache`), so the embedded
+ * workbook is never needed.
+ *
+ * @param xml - The chart part.
+ * @param mode - `typed`: values as numbers (`null` where missing); `text`: as text.
+ * @returns The chart.
+ */
+function readChart(xml, mode) {
+  let type = '';
+  let title;
+  const series = [];
+  let current;
+  let target;
+  let point = 0;
+  let capturing = false;
+  let inPlotArea = false;
+  let titleText;
+  walkXml(xml, {
+    open: (name, attributes) => {
+      if (name === 'plotArea') {
+        inPlotArea = true;
+      } else if (!inPlotArea && name === 'title' && title === undefined) {
+        titleText = '';
+      } else if (inPlotArea && type === '' && name.endsWith('Chart')) {
+        type = name.slice(0, -'Chart'.length);
+      } else if (name === 'ser') {
+        current = {
+          name: [],
+          categories: [],
+          values: []
+        };
+      } else if (current !== undefined) {
+        const next = targetOf(name);
+        if (next !== undefined) {
+          target = next;
+          point = 0;
+        } else if (name === 'ptCount' && target !== undefined) {
+          // Points left out of the cache are missing values: keep their places.
+          current[target].length = Math.max(current[target].length, Number(attributes.val ?? 0));
+        } else if (name === 'pt') {
+          point = Number(attributes.idx ?? 0);
+        } else if (name === 'v') {
+          capturing = true;
+          if (target !== undefined) current[target][point] = '';
+        }
+      }
+    },
+    text: text => {
+      if (titleText !== undefined) titleText += text;else if (capturing && current !== undefined && target !== undefined) current[target][point] += text;
+    },
+    close: name => {
+      if (name === 'v') {
+        capturing = false;
+      } else if (name === 'title' && titleText !== undefined) {
+        title = titleText.trim();
+        titleText = undefined;
+      } else if (name === 'ser' && current !== undefined) {
+        series.push(current);
+        current = undefined;
+      } else if (targetOf(name) !== undefined) {
+        target = undefined;
+      }
+    }
+  });
+  return {
+    type,
+    ...(!(title === undefined || title === '') && {
+      title
+    }),
+    series: series.map(open => ({
+      name: open.name.join('').trim(),
+      categories: Array.from(open.categories, text => text ?? ''),
+      values: Array.from(open.values, text => valueOf(text, mode))
+    }))
+  };
+}
+/** Where a series element's cached points go: its name, its categories (x values of a scatter), its values. */
+function targetOf(name) {
+  if (name === 'tx') return 'name';
+  if (name === 'cat' || name === 'xVal') return 'categories';
+  return name === 'val' || name === 'yVal' ? 'values' : undefined;
+}
+function valueOf(text, mode) {
+  const number = text === undefined || text.trim() === '' ? NaN : Number(text);
+  if (mode === 'text') return Number.isNaN(number) ? text ?? '' : String(number);
+  return Number.isNaN(number) ? null : number;
+}
+
+/**
+ * The speaker notes of a notes-slide part: the text of its body placeholder
+ * (the slide image and the slide number placeholders are left out).
+ *
+ * @param xml - The notes-slide part.
+ * @returns The notes, paragraphs joined by line breaks.
+ */
+function readNotes(xml) {
+  const paragraphs = [];
+  let inBody = false;
+  let paragraph;
+  let inText = false;
+  walkXml(xml, {
+    open: (name, attributes) => {
+      if (name === 'sp') inBody = false;else if (name === 'ph') inBody = (attributes.type ?? 'body') === 'body';else if (inBody && name === 'p') paragraph = '';else if (name === 't') inText = paragraph !== undefined;else if (name === 'br' && paragraph !== undefined) paragraph += '\n';
+    },
+    text: text => {
+      if (inText && paragraph !== undefined) paragraph += text;
+    },
+    close: name => {
+      if (name === 't') {
+        inText = false;
+      } else if (name === 'p' && paragraph !== undefined) {
+        paragraphs.push(paragraph);
+        paragraph = undefined;
+      }
+    }
+  });
+  return paragraphs.join('\n').trim();
+}
+
+/**
+ * The positioned placeholders of a slide layout or master. A slide's title or
+ * body usually carries no position of its own: it inherits it from the
+ * placeholder with the same index in its layout, else the same type, else the
+ * master's.
+ *
+ * @param xml - The layout or master part.
+ * @returns Its placeholder boxes.
+ */
+function placeholderBoxes(xml) {
+  const boxes = {
+    byIdx: new Map(),
+    byType: new Map()
+  };
+  let key;
+  let box;
+  let inShape = false;
+  let inXfrm = false;
+  walkXml(xml, {
+    open: (name, attributes) => {
+      if (name === 'sp') {
+        inShape = true;
+        key = undefined;
+        box = undefined;
+      } else if (inShape && name === 'ph') {
+        key = {
+          type: attributes.type ?? 'obj',
+          idx: attributes.idx
+        };
+      } else if (inShape && name === 'xfrm') {
+        inXfrm = true;
+        box = {};
+      } else if (inXfrm && box !== undefined) {
+        readGeometry(name, attributes, box);
+      }
+    },
+    close: name => {
+      if (name === 'xfrm') {
+        inXfrm = false;
+      } else if (name === 'sp') {
+        inShape = false;
+        if (key !== undefined && isBox(box)) {
+          if (key.idx !== undefined) boxes.byIdx.set(key.idx, box);
+          if (!boxes.byType.has(key.type)) boxes.byType.set(key.type, box);
+        }
+      }
+    }
+  });
+  return boxes;
+}
+/**
+ * Where an unpositioned placeholder sits: its layout's placeholder with the
+ * same index, else the same type, else the master's of that type.
+ *
+ * @param key - The placeholder.
+ * @param layout - The slide's layout.
+ * @param master - The layout's master.
+ * @returns The box, or `undefined` when neither places it.
+ */
+function inheritedBox(key, layout, master) {
+  const fromIdx = key.idx === undefined ? undefined : layout.byIdx.get(key.idx);
+  return fromIdx ?? layout.byType.get(key.type) ?? master.byType.get(masterType(key.type)) ?? master.byType.get(key.type);
+}
+/**
+ * Reads `a:off` and `a:ext` into a box.
+ *
+ * @param name - The element's local name.
+ * @param attributes - Its attributes.
+ * @param box - The box to fill.
+ */
+function readGeometry(name, attributes, box) {
+  if (name === 'off') {
+    box.x = Number(attributes.x ?? 0);
+    box.y = Number(attributes.y ?? 0);
+  } else if (name === 'ext') {
+    box.width = Number(attributes.cx ?? 0);
+    box.height = Number(attributes.cy ?? 0);
+  }
+}
+/**
+ * Whether a box has all four numbers.
+ *
+ * @param box - A box being read.
+ * @returns Whether it is complete.
+ */
+function isBox(box) {
+  return box?.x !== undefined && box.y !== undefined && box.width !== undefined && box.height !== undefined;
+}
+/** A master has only title, body and the footer placeholders: a centred title is a title, anything else body text. */
+function masterType(type) {
+  if (type === 'ctrTitle') return 'title';
+  return ['subTitle', 'obj', 'body'].includes(type) ? 'body' : type;
+}
+
+const EMU_PER_POINT = 12_700;
+/** Placeholders that repeat on every slide and carry no content. */
+const LAYOUT_NOISE = new Set(['sldNum', 'dt', 'ftr']);
+const TITLES = new Set(['title', 'ctrTitle']);
+/**
+ * Reads a slide part: its text boxes with their positions (group transforms
+ * applied; a placeholder without a position of its own takes the one
+ * `placeholderBox` gives), its tables with their merged cells, the ids of its
+ * charts, its title and whether it is hidden.
+ *
+ * @param xml - The slide part.
+ * @param placeholderBox - Where an unpositioned placeholder sits (from the layout and master).
+ * @returns The content.
+ */
+function readSlide(xml, placeholderBox) {
+  const content = {
+    hidden: false,
+    shapes: [],
+    tables: [],
+    chartIds: []
+  };
+  const groups = [];
+  let shape;
+  let table;
+  let row;
+  let cell;
+  let paragraph;
+  let inText = false;
+  let xfrm;
+  const finishShape = open => {
+    const text = open.paragraphs.join('\n').trim();
+    const type = open.placeholder?.type;
+    if (text === '' || type !== undefined && LAYOUT_NOISE.has(type)) return;
+    if (type !== undefined && TITLES.has(type)) content.title ??= text;
+    const own = isBox(open.box) ? transformed(open.box, groups) : undefined;
+    const box = own ?? (open.placeholder === undefined ? undefined : placeholderBox(open.placeholder)) ?? {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    };
+    content.shapes.push({
+      ...points(box),
+      text,
+      ...(type !== undefined && {
+        placeholder: type
+      })
+    });
+  };
+  walkXml(xml, {
+    open: (name, attributes) => {
+      switch (name) {
+        case 'sld':
+          {
+            content.hidden = attributes.show === '0' || attributes.show === 'false';
+            break;
+          }
+        case 'grpSp':
+          {
+            groups.push({
+              box: {},
+              childBox: {},
+              properties: false
+            });
+            break;
+          }
+        case 'grpSpPr':
+          {
+            const group = groups.at(-1);
+            if (group !== undefined) group.properties = true;
+            break;
+          }
+        case 'sp':
+        case 'graphicFrame':
+          {
+            shape = {
+              paragraphs: []
+            };
+            break;
+          }
+        case 'ph':
+          {
+            if (shape !== undefined) shape.placeholder = {
+              type: attributes.type ?? 'obj',
+              idx: attributes.idx
+            };
+            break;
+          }
+        case 'xfrm':
+          {
+            const group = groups.at(-1);
+            if (group?.properties === true) xfrm = group.box;else if (shape !== undefined && table === undefined) xfrm = shape.box = {};
+            break;
+          }
+        case 'chOff':
+        case 'chExt':
+          {
+            const group = groups.at(-1);
+            if (group?.properties === true) readGeometry(name === 'chOff' ? 'off' : 'ext', attributes, group.childBox);
+            break;
+          }
+        case 'off':
+        case 'ext':
+          {
+            if (xfrm !== undefined) readGeometry(name, attributes, xfrm);
+            break;
+          }
+        case 'tbl':
+          {
+            table = {
+              rows: [],
+              merges: []
+            };
+            break;
+          }
+        case 'tr':
+          {
+            if (table !== undefined) row = [];
+            break;
+          }
+        case 'tc':
+          {
+            if (row !== undefined) cell = {
+              paragraphs: [],
+              columnSpan: Number(attributes.gridSpan ?? 1),
+              rowSpan: Number(attributes.rowSpan ?? 1),
+              continued: isOn(attributes.hMerge) || isOn(attributes.vMerge)
+            };
+            break;
+          }
+        case 'p':
+          {
+            paragraph = '';
+            break;
+          }
+        case 't':
+          {
+            inText = paragraph !== undefined;
+            break;
+          }
+        case 'br':
+          {
+            if (paragraph !== undefined) paragraph += '\n';
+            break;
+          }
+        case 'chart':
+          {
+            const id = namespacedAttribute(attributes, 'id');
+            if (id !== undefined) content.chartIds.push(id);
+            break;
+          }
+        // No default
+      }
+    },
+    text: text => {
+      if (inText && paragraph !== undefined) paragraph += text;
+    },
+    close: name => {
+      switch (name) {
+        case 't':
+          {
+            inText = false;
+            break;
+          }
+        case 'p':
+          {
+            if (paragraph !== undefined) (cell ?? shape)?.paragraphs.push(paragraph);
+            paragraph = undefined;
+            break;
+          }
+        case 'xfrm':
+          {
+            xfrm = undefined;
+            break;
+          }
+        case 'grpSpPr':
+          {
+            const group = groups.at(-1);
+            if (group !== undefined) group.properties = false;
+            break;
+          }
+        case 'grpSp':
+          {
+            groups.pop();
+            break;
+          }
+        case 'tc':
+          {
+            if (cell !== undefined && row !== undefined && table !== undefined) {
+              if (cell.columnSpan > 1 || cell.rowSpan > 1) table.merges.push(rangeOf(table.rows.length, row.length, cell.rowSpan, cell.columnSpan));
+              row.push(cell.continued ? '' : cell.paragraphs.join('\n').trim());
+            }
+            cell = undefined;
+            break;
+          }
+        case 'tr':
+          {
+            if (row !== undefined) table?.rows.push(row);
+            row = undefined;
+            break;
+          }
+        case 'tbl':
+          {
+            if (table !== undefined) content.tables.push({
+              name: `table ${content.tables.length + 1}`,
+              hidden: false,
+              rows: table.rows,
+              hiddenRows: [],
+              merges: table.merges
+            });
+            table = undefined;
+            break;
+          }
+        case 'sp':
+        case 'graphicFrame':
+          {
+            if (shape !== undefined) finishShape(shape);
+            shape = undefined;
+            break;
+          }
+        // No default
+      }
+    }
+  });
+  content.shapes.sort((first, second) => Math.round(first.y) - Math.round(second.y) || first.x - second.x);
+  return content;
+}
+/** A child's box in slide coordinates: each enclosing group maps its child space onto its own box, innermost first. */
+function transformed(box, groups) {
+  let mapped = box;
+  for (let index = groups.length - 1; index >= 0; index -= 1) {
+    const {
+      box: outer,
+      childBox: inner
+    } = groups[index];
+    if (!isBox(outer) || !isBox(inner) || inner.width === 0 || inner.height === 0) continue;
+    const scaleX = outer.width / inner.width;
+    const scaleY = outer.height / inner.height;
+    mapped = {
+      x: outer.x + (mapped.x - inner.x) * scaleX,
+      y: outer.y + (mapped.y - inner.y) * scaleY,
+      width: mapped.width * scaleX,
+      height: mapped.height * scaleY
+    };
+  }
+  return mapped;
+}
+function toPoints(emu) {
+  return Math.round(emu / EMU_PER_POINT * 100) / 100;
+}
+function points(box) {
+  const round = toPoints;
+  return {
+    x: round(box.x),
+    y: round(box.y),
+    width: round(box.width),
+    height: round(box.height)
+  };
+}
+/** A merged range as an A1 reference (`A1:D1`). */
+function rangeOf(row, column, rowSpan, columnSpan) {
+  return `${columnLetter(column)}${row + 1}:${columnLetter(column + columnSpan - 1)}${row + rowSpan}`;
+}
+function columnLetter(index) {
+  let letters = '';
+  for (let rest = index + 1; rest > 0; rest = Math.floor((rest - 1) / 26)) letters = String.fromCodePoint(65 + (rest - 1) % 26) + letters;
+  return letters;
+}
+
+const POINTS = 12_700;
+/** 10 × 7.5 inches, PowerPoint's default before 16:9. */
+const DEFAULT_SIZE = {
+  width: 9_144_000,
+  height: 6_858_000
+};
+async function readPptx(source, options = {}) {
+  const pkg = OoxmlPackage.open(await readSource(source), options.limits);
+  const main = relationshipOfType(relationshipsOf(pkg, ''), 'officeDocument')?.target ?? (pkg.has('ppt/presentation.xml') ? 'ppt/presentation.xml' : '');
+  const ids = [];
+  const size = {
+    ...DEFAULT_SIZE
+  };
+  let isPresentation = false;
+  walkXml(pkg.text(main), {
+    open: (name, attributes) => {
+      switch (name) {
+        case 'presentation':
+          {
+            isPresentation = true;
+            break;
+          }
+        case 'sldId':
+          {
+            ids.push(namespacedAttribute(attributes, 'id') ?? '');
+            break;
+          }
+        case 'sldSz':
+          {
+            {
+              Object.assign(size, {
+                width: Number(attributes.cx ?? DEFAULT_SIZE.width),
+                height: Number(attributes.cy ?? DEFAULT_SIZE.height)
+              });
+              // No default
+            }
+            break;
+          }
+      }
+    }
+  });
+  if (!isPresentation) throw new OfficeReadError('not-pptx', `not a presentation: the package's main part is ${main === '' ? 'missing' : main}${main.endsWith('workbook.xml') ? ' (a spreadsheet: read it with readXlsx)' : ''}`);
+  const relationships = relationshipsOf(pkg, main);
+  const layouts = new Map();
+  const mode = options.values ?? 'typed';
+  const selected = selector(options.slides);
+  const slides = [];
+  for (const [index, id] of ids.entries()) {
+    const part = relationships.get(id);
+    if (part?.type !== 'slide') continue;
+    const slideRelationships = relationshipsOf(pkg, part.target);
+    const layoutPart = relationshipOfType(slideRelationships, 'slideLayout')?.target;
+    const geometry = layoutPart === undefined ? undefined : geometryOf(pkg, layoutPart, layouts);
+    const content = readSlide(pkg.text(part.target), key => geometry === undefined ? undefined : inheritedBox(key, geometry.layout, geometry.master));
+    const number = index + 1;
+    if (!selected({
+      number,
+      title: content.title ?? '',
+      hidden: content.hidden
+    })) continue;
+    const charts = options.charts === false ? [] : content.chartIds.flatMap(chartId => {
+      const chart = slideRelationships.get(chartId);
+      return chart === undefined ? [] : [readChart(pkg.text(chart.target), mode)];
+    });
+    const notesPart = options.notes === false ? undefined : relationshipOfType(slideRelationships, 'notesSlide')?.target;
+    slides.push({
+      number,
+      ...(content.title !== undefined && {
+        title: content.title
+      }),
+      hidden: content.hidden,
+      shapes: content.shapes,
+      tables: content.tables,
+      charts,
+      notes: notesPart === undefined ? '' : readNotes(pkg.text(notesPart))
+    });
+  }
+  return {
+    width: Math.round(size.width / POINTS * 100) / 100,
+    height: Math.round(size.height / POINTS * 100) / 100,
+    slides
+  };
+}
+/** A layout's and its master's placeholder boxes, read once per layout. */
+function geometryOf(pkg, layoutPart, cache) {
+  const cached = cache.get(layoutPart);
+  if (cached !== undefined) return cached;
+  const masterPart = relationshipOfType(relationshipsOf(pkg, layoutPart), 'slideMaster')?.target;
+  const geometry = {
+    layout: placeholderBoxes(pkg.text(layoutPart)),
+    master: placeholderBoxes(masterPart === undefined ? '' : pkg.text(masterPart))
+  };
+  cache.set(layoutPart, geometry);
+  return geometry;
+}
+function selector(filter) {
+  if (filter === undefined) return () => true;
+  if (Array.isArray(filter)) return slide => filter.includes(slide.number);
+  if (filter instanceof RegExp) return slide => filter.test(slide.title);
+  return filter;
+}
+
+export { readPptx as r };
+//# sourceMappingURL=read-pptx.use-case.esm.js.map