pptx2js 0.4.0 → 0.4.3

package/lib/extractor.js

@@ -2,19 +2,22 @@
  * ③ 实体提取器
  */
 const path = require('path');
-const { asArray, attr, child, textContent } = require('./xml-utils');
-const { boundsFromXfrm } = require('./utils/bounds');
+const { attr, child, childNodes, children, documentRoot } = require('./xml-utils');
+const { boundsFromXfrm } = require('./bounds');
 const {
   loadColorScheme,
   resolveFillColor,
   resolveColorFromContainer,
-} = require('./utils/color');
+} = require('./color');
+const { extractTextRuns } = require('./text-utils');
 const { getSlidePaths, getThemePath } = require('./presentation');
 const {
   buildSlideInheritance,
   getEffectiveXfrm,
+  getPlaceholderKey,
   mergeTxBody,
   resolvePlaceholderSps,
+  shouldShowMasterShapes,
 } = require('./placeholder');
 const { isTableFrame, isChartFrame, isSmartArtFrame } = require('./graphic');
 const { extractTable } = require('./table');
@@ -29,7 +32,7 @@ const { extractSmartArt } = require('./smartart');
  * @property {string} slidePath
  * @property {ConversionDecision} decision
  * @property {string} kind
- * @property {import('./utils/bounds').Bounds} bounds
+ * @property {import('./bounds').Bounds} bounds
  * @property {object} [text]
  * @property {object} [image]
  * @property {object} [shape]
@@ -50,8 +53,17 @@ const PRST_TO_SHAPE = {
   pentagon: 'PENTAGON',
   hexagon: 'HEXAGON',
   star5: 'STAR5',
+  leftBrace: 'LEFT_BRACE',
+  rightBracket: 'RIGHT_BRACKET',
+  rightArrow: 'RIGHT_ARROW',
+  downArrow: 'DOWN_ARROW',
+  curvedLeftArrow: 'LEFT_ARROW',
+  flowChartAlternateProcess: 'ROUNDED_RECTANGLE',
 };
 
+/** prst → 退化为 LINE 并附 degradeReason */
+const PRST_DEGRADE_LINE = new Set(['bentConnector3']);
+
 /**
  * @typedef {object} ExtractContext
  * @property {Record<string, object>} parsed
@@ -82,7 +94,7 @@ function extractEntities(ctx) {
  */
 function extractSlide(slidePath, slideIndex, ctx, scheme) {
   const doc = ctx.parsed[slidePath];
-  const slide = child(doc, 'p:sld');
+  const slide = documentRoot(doc, 'p:sld');
   const cSld = child(slide, 'p:cSld');
   const spTree = child(cSld, 'p:spTree');
   if (!spTree) return [];
@@ -114,57 +126,91 @@ function extractSlide(slidePath, slideIndex, ctx, scheme) {
     inheritance,
     offset: { x: 0, y: 0 },
     entities,
+    decorLayer: false,
   };
 
+  if (
+    shouldShowMasterShapes(slide) &&
+    inheritance.masterSpTree &&
+    inheritance.masterPath
+  ) {
+    walkSpTree(inheritance.masterSpTree, {
+      ...walkCtx,
+      slidePath: inheritance.masterPath,
+      decorLayer: true,
+    });
+  }
+  if (inheritance.layoutSpTree && inheritance.layoutPath) {
+    walkSpTree(inheritance.layoutSpTree, {
+      ...walkCtx,
+      slidePath: inheritance.layoutPath,
+      decorLayer: true,
+    });
+  }
   walkSpTree(spTree, walkCtx);
   return entities;
 }
 
 function extractSlideBackground(cSld, scheme) {
-  const bgPr = child(child(cSld, 'p:bg'), 'p:bgPr');
-  if (!bgPr) return null;
-  const { color, degraded } = resolveFillColor(bgPr, scheme);
-  if (!color) return null;
-  return { color, degraded };
-}
+  const bg = child(cSld, 'p:bg');
+  if (!bg) return null;
 
-function walkSpTree(spTree, ctx) {
-  for (const sp of asArray(spTree['p:sp'])) {
-    extractShape(sp, ctx);
+  const bgPr = child(bg, 'p:bgPr');
+  if (bgPr) {
+    const { color, degraded } = resolveFillColor(bgPr, scheme);
+    if (color) return { color, degraded };
   }
-  for (const pic of asArray(spTree['p:pic'])) {
-    extractPicture(pic, ctx);
-  }
-  for (const grp of asArray(spTree['p:grpSp'])) {
-    flattenGroup(grp, ctx);
+
+  const bgRef = child(bg, 'p:bgRef');
+  if (bgRef) {
+    const color = resolveColorFromContainer(bgRef, scheme);
+    if (color) return { color, degraded: false };
   }
-  for (const frame of asArray(spTree['p:graphicFrame'])) {
-    if (isTableFrame(frame)) {
-      const entity = extractTable(frame, ctx);
-      if (entity) ctx.entities.push(entity);
-    } else if (isChartFrame(frame)) {
-      const entity = extractChart(frame, ctx);
-      if (entity) ctx.entities.push(entity);
-    } else if (isSmartArtFrame(frame)) {
-      const entity = extractSmartArt(frame, ctx);
-      if (entity) ctx.entities.push(entity);
-    } else {
-      skipElement(frame, ctx, '不支持的 graphicFrame 类型');
+
+  return null;
+}
+
+function walkSpTree(spTree, ctx) {
+  for (const node of childNodes(spTree)) {
+    if (node.tag === 'p:sp') {
+      if (ctx.decorLayer && getPlaceholderKey(node)) continue;
+      extractShape(node, ctx);
+    } else if (node.tag === 'p:pic') {
+      extractPicture(node, ctx);
+    } else if (node.tag === 'p:grpSp') {
+      flattenGroup(node, ctx);
+    } else if (node.tag === 'p:graphicFrame') {
+      if (ctx.decorLayer) continue;
+      if (isTableFrame(node)) {
+        const entity = extractTable(node, ctx);
+        if (entity) ctx.entities.push(entity);
+      } else if (isChartFrame(node)) {
+        const entity = extractChart(node, ctx);
+        if (entity) ctx.entities.push(entity);
+      } else if (isSmartArtFrame(node)) {
+        const entity = extractSmartArt(node, ctx);
+        if (entity) ctx.entities.push(entity);
+      } else {
+        skipElement(node, ctx, '不支持的 graphicFrame 类型');
+      }
+    } else if (node.tag === 'p:cxnSp') {
+      extractConnector(node, ctx);
     }
   }
-  for (const cxn of asArray(spTree['p:cxnSp'])) {
-    extractConnector(cxn, ctx);
-  }
 }
 
 function flattenGroup(grp, ctx) {
   const grpXfrm = child(child(grp, 'p:grpSpPr'), 'a:xfrm');
   const off = readOffset(grpXfrm);
-  const inner = child(grp, 'p:spTree');
-  if (!inner) return;
-  walkSpTree(inner, {
+  const chOff = readChOff(grpXfrm);
+
+  // p:grpSp 子节点直接挂在 grp 上，没有 p:spTree 包装
+  walkSpTree(grp, {
     ...ctx,
-    offset: { x: ctx.offset.x + off.x, y: ctx.offset.y + off.y },
+    offset: {
+      x: ctx.offset.x + off.x - chOff.x,
+      y: ctx.offset.y + off.y - chOff.y,
+    },
   });
 }
 
@@ -181,32 +227,46 @@ function extractShape(sp, ctx) {
       relIndex: ctx.relIndex,
       slidePath: ctx.slidePath,
     });
-    if (runs.length === 0) return;
-
-    const hasGradient = runs.some((r) => r.degraded);
-    ctx.entities.push({
-      slideIndex: ctx.slideIndex,
-      slidePath: ctx.slidePath,
-      decision: hasGradient ? 'DEGRADE' : 'FULL',
-      kind: 'text',
-      bounds,
-      text: { runs: runs.map(({ text, options }) => ({ text, options })) },
-      degradeReason: hasGradient ? '文本渐变退化为纯色' : undefined,
-    });
-    return;
+    if (runs.length > 0) {
+      const hasGradient = runs.some((r) => r.degraded);
+      ctx.entities.push({
+        slideIndex: ctx.slideIndex,
+        slidePath: ctx.slidePath,
+        decision: hasGradient ? 'DEGRADE' : 'FULL',
+        kind: 'text',
+        bounds,
+        text: { runs: runs.map(({ text, options }) => ({ text, options })) },
+        degradeReason: hasGradient ? '文本渐变退化为纯色' : undefined,
+      });
+      return;
+    }
+    // 无 a:r 文本（如 a:fld 页码）或空 txBody → 若有几何则继续按形状提取
   }
 
   const spPr = child(sp, 'p:spPr');
   const prst = attr(child(spPr, 'a:prstGeom'), 'prst');
   if (!prst) return;
 
-  const shapeName = PRST_TO_SHAPE[prst];
+  let shapeName = PRST_TO_SHAPE[prst];
+  let prstDegradeReason;
+  if (PRST_DEGRADE_LINE.has(prst)) {
+    shapeName = 'LINE';
+    prstDegradeReason = `连接器 "${prst}" 退化为直线`;
+  } else if (prst === 'curvedLeftArrow') {
+    prstDegradeReason = 'curvedLeftArrow 退化为 LEFT_ARROW';
+  } else if (prst === 'flowChartAlternateProcess') {
+    prstDegradeReason = 'flowChartAlternateProcess 退化为圆角矩形';
+  }
+
   const { color: fillColor, degraded: fillDegraded } = resolveFillColor(
     spPr,
     ctx.scheme
   );
   const ln = child(spPr, 'a:ln');
   const lineColor = ln ? resolveFillColor(ln, ctx.scheme).color : null;
+  const lineWidth = extractLineWidthPt(ln);
+  const lineDash = extractLineDash(ln);
+  const flip = readFlip(xfrm);
 
   if (!shapeName) {
     ctx.entities.push({
@@ -215,23 +275,87 @@ function extractShape(sp, ctx) {
       decision: 'DEGRADE',
       kind: 'shape',
       bounds,
-      shape: { type: 'RECTANGLE', fill: fillColor, line: lineColor },
+      shape: {
+        type: 'RECTANGLE',
+        fill: fillColor,
+        line: lineColor,
+        lineWidth,
+        lineDash,
+        ...flip,
+      },
       degradeReason: `未知预设形状 "${prst}"，退化为矩形`,
     });
     return;
   }
 
+  const degradeReason =
+    prstDegradeReason ||
+    (fillDegraded ? '渐变/图案填充退化为纯色' : undefined);
+
   ctx.entities.push({
     slideIndex: ctx.slideIndex,
     slidePath: ctx.slidePath,
-    decision: fillDegraded ? 'DEGRADE' : 'FULL',
+    decision: (prstDegradeReason || fillDegraded) ? 'DEGRADE' : 'FULL',
     kind: 'shape',
     bounds,
-    shape: { type: shapeName, fill: fillColor, line: lineColor },
-    degradeReason: fillDegraded ? '渐变填充退化为纯色' : undefined,
+    shape: {
+      type: shapeName,
+      fill: fillColor,
+      line: lineColor,
+      lineWidth,
+      lineDash,
+      ...flip,
+    },
+    degradeReason,
   });
 }
 
+/**
+ * @param {object|null|undefined} xfrm
+ */
+function readFlip(xfrm) {
+  const flip = {};
+  if (attr(xfrm, 'flipH') === '1') flip.flipH = true;
+  if (attr(xfrm, 'flipV') === '1') flip.flipV = true;
+  return flip;
+}
+
+/**
+ * @param {object|null|undefined} ln a:ln
+ * @returns {number|undefined}
+ */
+function extractLineWidthPt(ln) {
+  if (!ln) return undefined;
+  const w = parseInt(attr(ln, 'w') ?? '0', 10);
+  if (!w) return undefined;
+  return Math.max(1, Math.round(w / 12700));
+}
+
+/** OOXML prstDash → PptxGenJS line.dashType */
+const PRST_DASH_MAP = {
+  dash: 'dash',
+  dot: 'dot',
+  dashDot: 'dashDot',
+  lgDash: 'lgDash',
+  lgDashDot: 'lgDashDot',
+  lgDashDotDot: 'lgDashDotDot',
+  sysDash: 'sysDash',
+  sysDot: 'sysDot',
+  sysDashDot: 'sysDashDot',
+  sysDashDotDot: 'sysDashDotDot',
+};
+
+/**
+ * @param {object|null|undefined} ln a:ln
+ * @returns {string|undefined}
+ */
+function extractLineDash(ln) {
+  if (!ln) return undefined;
+  const prstDash = child(ln, 'a:prstDash');
+  const val = attr(prstDash, 'val');
+  return val ? PRST_DASH_MAP[val] : undefined;
+}
+
 function extractPicture(pic, ctx) {
   const spPr = child(pic, 'p:spPr');
   const bounds = boundsFromXfrm(child(spPr, 'a:xfrm'), ctx.offset);
@@ -258,8 +382,10 @@ function extractPicture(pic, ctx) {
 
 function extractConnector(cxn, ctx) {
   const spPr = child(cxn, 'p:spPr');
-  const bounds = boundsFromXfrm(child(spPr, 'a:xfrm'), ctx.offset);
-  const { color: lineColor } = resolveFillColor(child(spPr, 'a:ln'), ctx.scheme);
+  const xfrm = child(spPr, 'a:xfrm');
+  const bounds = boundsFromXfrm(xfrm, ctx.offset);
+  const ln = child(spPr, 'a:ln');
+  const { color: lineColor } = resolveFillColor(ln, ctx.scheme);
 
   ctx.entities.push({
     slideIndex: ctx.slideIndex,
@@ -267,7 +393,14 @@ function extractConnector(cxn, ctx) {
     decision: 'FULL',
     kind: 'shape',
     bounds,
-    shape: { type: 'LINE', fill: null, line: lineColor },
+    shape: {
+      type: 'LINE',
+      fill: null,
+      line: lineColor,
+      lineWidth: extractLineWidthPt(ln),
+      lineDash: extractLineDash(ln),
+      ...readFlip(xfrm),
+    },
   });
 }
 
@@ -290,105 +423,19 @@ function readOffset(xfrm) {
   };
 }
 
-const PARA_ALIGN_MAP = {
-  l: 'left',
-  ctr: 'center',
-  r: 'right',
-  just: 'justify',
-  dist: 'justify',
-};
-
-function extractTextRuns(txBody, scheme, linkCtx) {
-  const runs = [];
-  for (const p of asArray(txBody['a:p'])) {
-    const pPr = child(p, 'a:pPr');
-    const bullet = extractBullet(pPr);
-    const paraOpts = extractParaOptions(pPr);
-
-    for (const r of asArray(p['a:r'])) {
-      const text = textContent(r['a:t']);
-      if (!text) continue;
-      const options = extractRunOptions(r['a:rPr'], scheme, linkCtx);
-      Object.assign(options, paraOpts);
-      if (bullet) Object.assign(options, bullet);
-      runs.push({ text, options, degraded: options._degraded });
-    }
-  }
-  return runs;
-}
-
 /**
- * @param {object|null|undefined} pPr
+ * 组合内部坐标系原点（EMU）
+ * @param {object|null|undefined} xfrm
  */
-function extractParaOptions(pPr) {
-  if (!pPr) return {};
-  const opts = {};
-
-  const algn = attr(pPr, 'algn');
-  if (algn && PARA_ALIGN_MAP[algn]) opts.align = PARA_ALIGN_MAP[algn];
-
-  const lvl = attr(pPr, 'lvl');
-  if (lvl) opts.indentLevel = parseInt(lvl, 10);
-
-  // 注：a:spcPct（百分比段前/段后距）暂不处理
-  const spcBef = attr(child(child(pPr, 'a:spcBef'), 'a:spcPts'), 'val');
-  if (spcBef) opts.paraSpaceBefore = parseInt(spcBef, 10) / 100;
-
-  // 注：a:spcPct（百分比段后距）暂不处理
-  const spcAft = attr(child(child(pPr, 'a:spcAft'), 'a:spcPts'), 'val');
-  if (spcAft) opts.paraSpaceAfter = parseInt(spcAft, 10) / 100;
-
-  // 注：a:spcPct（百分比行距）暂不处理
-  const lnSpc = attr(child(child(pPr, 'a:lnSpc'), 'a:spcPts'), 'val');
-  if (lnSpc) opts.lineSpacing = parseInt(lnSpc, 10) / 100;
-
-  return opts;
-}
-
-function extractBullet(pPr) {
-  if (!pPr) return null;
-  if (child(pPr, 'a:buChar')) return { bullet: true };
-  if (child(pPr, 'a:buAutoNum')) return { bullet: { type: 'number' } };
-  return null;
-}
-
-function extractRunOptions(rPr, scheme, linkCtx) {
-  const options = {};
-  let degraded = false;
-  if (!rPr) return options;
-
-  const sz = attr(rPr, 'sz');
-  if (sz) options.fontSize = parseInt(sz, 10) / 100;
-  if (attr(rPr, 'b') === '1') options.bold = true;
-  if (attr(rPr, 'i') === '1') options.italic = true;
-
-  const face = attr(child(rPr, 'a:latin'), 'typeface');
-  if (face) options.fontFace = face;
-
-  const solid = child(rPr, 'a:solidFill');
-  const grad = child(rPr, 'a:gradFill');
-  if (grad) {
-    degraded = true;
-    const g = resolveFillColor({ 'a:gradFill': grad }, scheme);
-    if (g.color) options.color = g.color;
-  } else if (solid) {
-    const c = resolveColorFromContainer(solid, scheme);
-    if (c) options.color = c;
-  }
-
-  const hlink = child(rPr, 'a:hlinkClick');
-  if (hlink && linkCtx) {
-    const relId = attr(hlink, 'r:id');
-    const url = relId && linkCtx.relIndex.resolve(linkCtx.slidePath, relId);
-    if (url) options.hyperlink = { url };
-  }
-
-  if (degraded) options._degraded = true;
-  return options;
+function readChOff(xfrm) {
+  const chOff = child(xfrm, 'a:chOff');
+  return {
+    x: parseInt(attr(chOff, 'x') ?? '0', 10),
+    y: parseInt(attr(chOff, 'y') ?? '0', 10),
+  };
 }
 
 module.exports = {
   extractEntities,
   PRST_TO_SHAPE,
-  boundsFromXfrm,
 };

package/lib/mapper.js

@@ -84,6 +84,10 @@ function mapToIR(entitiesBySlide, ctx) {
           shape: entity.shape.type,
           fill: entity.shape.fill,
           line: entity.shape.line,
+          lineWidth: entity.shape.lineWidth,
+          lineDash: entity.shape.lineDash,
+          flipH: entity.shape.flipH,
+          flipV: entity.shape.flipV,
           degradeReason: entity.degradeReason,
         });
       }

package/lib/packager.js

@@ -1,7 +1,6 @@
 /**
  * ⑥ 资源打包器
  * 复制 media/ 文件，写入退化生成图片。
- * TODO: 重名冲突处理（不同 zip 路径、同名文件时避免覆盖）
  */
 const fs = require('fs');
 const path = require('path');
@@ -12,30 +11,82 @@ const path = require('path');
  * @property {import('./mapper').IntermediateRepresentation} ir
  */
 
+/**
+ * 为 zip 内媒体路径生成不冲突的输出文件名
+ * @param {string} entryPath 如 ppt/media/image1.png
+ * @param {Set<string>} usedDestNames
+ */
+function uniqueMediaFileName(entryPath, usedDestNames) {
+  const base = path.posix.basename(entryPath);
+  if (!usedDestNames.has(base)) {
+    usedDestNames.add(base);
+    return base;
+  }
+  const ext = path.posix.extname(base);
+  const stem = ext ? base.slice(0, -ext.length) : base;
+  let n = 2;
+  let candidate;
+  do {
+    candidate = `${stem}_${n}${ext}`;
+    n += 1;
+  } while (usedDestNames.has(candidate));
+  usedDestNames.add(candidate);
+  return candidate;
+}
+
+/**
+ * 将 IR 中图片元素的 mediaPath 对齐到实际写入的文件名
+ * @param {import('./mapper').IntermediateRepresentation} ir
+ * @param {Map<string, string>} zipToRel zip 路径 → media/xxx.png
+ */
+function applyMediaPathsToIR(ir, zipToRel) {
+  if (!ir?.slides) return;
+  for (const slide of ir.slides) {
+    for (const el of slide.elements) {
+      if (el.type === 'image' && el.zipPath && zipToRel.has(el.zipPath)) {
+        el.mediaPath = zipToRel.get(el.zipPath);
+      }
+    }
+  }
+}
+
 /**
  * @param {PackagerInput} input
  * @param {string} outputDir
  * @param {{ noMedia?: boolean }} options
- * @returns {Promise<string[]>} 已写入的媒体文件相对路径列表
+ * @returns {Promise<{ written: string[], zipToRel: Map<string, string> }>}
  */
 async function packageMedia(input, outputDir, options = {}) {
-  if (options.noMedia) return [];
+  /** @type {Map<string, string>} */
+  const zipToRel = new Map();
+
+  if (options.noMedia) {
+    return { written: [], zipToRel };
+  }
 
   const mediaDir = path.join(outputDir, 'media');
   fs.mkdirSync(mediaDir, { recursive: true });
 
   const written = [];
+  const usedDestNames = new Set();
   const { zip } = input.archive;
+
   for (const [entryPath, entry] of Object.entries(zip.files)) {
     if (entry.dir) continue;
     if (!entryPath.startsWith('ppt/media/')) continue;
-    const name = path.basename(entryPath); // TODO: 重名冲突时生成唯一文件名
-    const dest = path.join(mediaDir, name);
+
+    const destName = uniqueMediaFileName(entryPath, usedDestNames);
+    const relPath = path.posix.join('media', destName);
+    zipToRel.set(entryPath, relPath);
+
+    const dest = path.join(outputDir, relPath);
     const data = await entry.async('nodebuffer');
     fs.writeFileSync(dest, data);
-    written.push(path.join('media', name));
+    written.push(relPath);
   }
-  return written;
+
+  applyMediaPathsToIR(input.ir, zipToRel);
+  return { written, zipToRel };
 }
 
 /**
@@ -69,4 +120,10 @@ function writeOutputReadme(outputDir, meta) {
   fs.writeFileSync(readmePath, content, 'utf8');
 }
 
-module.exports = { packageMedia, writeConversionLog, writeOutputReadme };
+module.exports = {
+  packageMedia,
+  applyMediaPathsToIR,
+  uniqueMediaFileName,
+  writeConversionLog,
+  writeOutputReadme,
+};