pptx2js 0.4.0

package/lib/convert.js

@@ -0,0 +1,195 @@
+/**
+ * 转换流水线编排器
+ */
+const fs = require('fs');
+const path = require('path');
+const { parseXml } = require('./xml-parser');
+const { unpack } = require('./unpacker');
+const { buildRelationIndex } = require('./rels');
+const { extractEntities } = require('./extractor');
+const { mapToIR } = require('./mapper');
+const { generateScript } = require('./codegen');
+const {
+  packageMedia,
+  writeConversionLog,
+  writeOutputReadme,
+} = require('./packager');
+
+/** @typedef {object} ConvertOptions
+ * @property {string} [outputDir]
+ * @property {boolean} [noMedia]
+ * @property {boolean} [strictDegrade]
+ * @property {boolean} [strictSkip]
+ * @property {'minimal'|'info'|'verbose'} [logLevel]
+ * @property {number} [maxFileSize]
+ */
+
+/** @typedef {object} ConvertResult
+ * @property {string} outputDir
+ * @property {string} scriptPath
+ * @property {string} logPath
+ * @property {object} log
+ */
+
+const DEFAULT_OUTPUT = './pptx2js-output';
+const DEFAULT_MAX_FILE_SIZE = 50 * 1024 * 1024;
+
+/**
+ * @param {string} filePath
+ * @param {ConvertOptions} [options]
+ * @returns {Promise<ConvertResult>}
+ */
+async function convert(filePath, options = {}) {
+  const resolvedPath = path.resolve(filePath);
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(`源文件不存在: ${resolvedPath}`);
+  }
+
+  const stat = fs.statSync(resolvedPath);
+  if (stat.size > (options.maxFileSize ?? DEFAULT_MAX_FILE_SIZE)) {
+    // 大文件流式解析 — 实现阶段补充
+  }
+
+  const outputDir = path.resolve(options.outputDir ?? DEFAULT_OUTPUT);
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  const archive = await unpack(resolvedPath);
+
+  /** @type {Record<string, object>} */
+  const parsed = {};
+  for (const [entryPath, content] of archive.files) {
+    if (content === '__binary__') continue;
+    if (entryPath.endsWith('.xml') || entryPath.endsWith('.rels')) {
+      parsed[entryPath] = await parseXml(content);
+    }
+  }
+
+  const relIndex = buildRelationIndex(parsed);
+  const ctx = { relIndex, parsed, sourcePath: resolvedPath };
+  const entities = extractEntities(ctx);
+  const ir = mapToIR(entities, ctx);
+  const script = generateScript(ir, options);
+
+  const scriptPath = path.join(outputDir, 'output.js');
+  fs.writeFileSync(scriptPath, script, 'utf8');
+
+  await packageMedia({ archive, ir }, outputDir, {
+    noMedia: options.noMedia,
+  });
+
+  const log = buildConversionLog(resolvedPath, stat, entities, ir);
+  writeConversionLog(outputDir, log);
+  writeOutputReadme(outputDir, {
+    sourcePath: resolvedPath,
+    generatedAt: new Date().toISOString(),
+  });
+
+  if (options.strictDegrade && log.statistics.degraded > 0) {
+    const err = new Error('存在退化项（--strict-degrade）');
+    err.code = 'STRICT_DEGRADE';
+    throw err;
+  }
+  if (options.strictSkip) {
+    const errors = (log.omitted || []).filter((o) => o.severity === 'error');
+    if (errors.length > 0) {
+      const err = new Error('存在 error 级别跳过项（--strict-skip）');
+      err.code = 'STRICT_SKIP';
+      throw err;
+    }
+  }
+
+  return {
+    outputDir,
+    scriptPath,
+    logPath: path.join(outputDir, 'conversion.log'),
+    log,
+  };
+}
+
+/**
+ * @param {string} sourcePath
+ * @param {fs.Stats} stat
+ * @param {import('./extractor').SlideEntity[][]} entitiesBySlide
+ * @param {import('./mapper').IntermediateRepresentation} ir
+ */
+function buildConversionLog(sourcePath, stat, entitiesBySlide, ir) {
+  let full = 0;
+  let degraded = 0;
+  let skipped = 0;
+
+  /** @type {object[]} */
+  const slides = [];
+  /** @type {object[]} */
+  const degradedList = [];
+  /** @type {object[]} */
+  const omitted = [];
+  /** @type {object[]} */
+  const warnings = [];
+
+  entitiesBySlide.forEach((entities, slideIndex) => {
+    /** @type {object[]} */
+    const slideItems = [];
+
+    for (const entity of entities) {
+      const bounds = entity.bounds;
+      const base = {
+        slideIndex,
+        elementBounds: bounds,
+        kind: entity.kind,
+        decision: entity.decision,
+      };
+
+      if (entity.decision === 'FULL') full++;
+      else if (entity.decision === 'DEGRADE') degraded++;
+      else skipped++;
+
+      slideItems.push(base);
+
+      if (entity.decision === 'DEGRADE' && entity.degradeReason) {
+        degradedList.push({
+          ...base,
+          reason: entity.degradeReason,
+          severity: 'warn',
+        });
+      }
+
+      if (entity.decision === 'SKIP') {
+        omitted.push({
+          ...base,
+          type: entity.kind,
+          reason: entity.skipReason,
+          severity: entity.skipReason?.includes('尚未支持') ? 'warn' : 'error',
+        });
+      }
+    }
+
+    slides.push({ slideIndex, items: slideItems });
+  });
+
+  if (ir.slides.length === 0) {
+    warnings.push({
+      message: '未解析到任何幻灯片，请检查 presentation.xml 与关系文件',
+      severity: 'warn',
+    });
+  }
+
+  return {
+    source: {
+      path: sourcePath,
+      size: stat.size,
+      slideCount: ir.slides.length,
+    },
+    statistics: {
+      slides: ir.slides.length,
+      full,
+      degraded,
+      skipped,
+    },
+    slides,
+    degraded: degradedList,
+    omitted,
+    warnings,
+  };
+}
+
+module.exports = { convert, DEFAULT_OUTPUT, DEFAULT_MAX_FILE_SIZE };

package/lib/extractor.js

@@ -0,0 +1,394 @@
+/**
+ * ③ 实体提取器
+ */
+const path = require('path');
+const { asArray, attr, child, textContent } = require('./xml-utils');
+const { boundsFromXfrm } = require('./utils/bounds');
+const {
+  loadColorScheme,
+  resolveFillColor,
+  resolveColorFromContainer,
+} = require('./utils/color');
+const { getSlidePaths, getThemePath } = require('./presentation');
+const {
+  buildSlideInheritance,
+  getEffectiveXfrm,
+  mergeTxBody,
+  resolvePlaceholderSps,
+} = require('./placeholder');
+const { isTableFrame, isChartFrame, isSmartArtFrame } = require('./graphic');
+const { extractTable } = require('./table');
+const { extractChart } = require('./chart');
+const { extractSmartArt } = require('./smartart');
+
+/** @typedef {'FULL' | 'DEGRADE' | 'SKIP'} ConversionDecision */
+
+/**
+ * @typedef {object} SlideEntity
+ * @property {number} slideIndex
+ * @property {string} slidePath
+ * @property {ConversionDecision} decision
+ * @property {string} kind
+ * @property {import('./utils/bounds').Bounds} bounds
+ * @property {object} [text]
+ * @property {object} [image]
+ * @property {object} [shape]
+ * @property {object} [table]
+ * @property {object} [chart]
+ * @property {string} [skipReason]
+ * @property {string} [degradeReason]
+ */
+
+const PRST_TO_SHAPE = {
+  rect: 'RECTANGLE',
+  roundRect: 'ROUNDED_RECTANGLE',
+  ellipse: 'OVAL',
+  line: 'LINE',
+  triangle: 'TRIANGLE',
+  rtTriangle: 'RIGHT_TRIANGLE',
+  diamond: 'DIAMOND',
+  pentagon: 'PENTAGON',
+  hexagon: 'HEXAGON',
+  star5: 'STAR5',
+};
+
+/**
+ * @typedef {object} ExtractContext
+ * @property {Record<string, object>} parsed
+ * @property {import('./rels').RelationIndex} relIndex
+ * @property {string} [sourcePath]
+ */
+
+/**
+ * @param {ExtractContext} ctx
+ * @returns {SlideEntity[][]}
+ */
+function extractEntities(ctx) {
+  const { parsed, relIndex } = ctx;
+  const themePath = getThemePath(parsed, relIndex);
+  const scheme = loadColorScheme(parsed, themePath);
+  const slidePaths = getSlidePaths(parsed, relIndex);
+
+  return slidePaths.map((slidePath, slideIndex) =>
+    extractSlide(slidePath, slideIndex, ctx, scheme)
+  );
+}
+
+/**
+ * @param {string} slidePath
+ * @param {number} slideIndex
+ * @param {ExtractContext} ctx
+ * @param {Record<string, string>} scheme
+ */
+function extractSlide(slidePath, slideIndex, ctx, scheme) {
+  const doc = ctx.parsed[slidePath];
+  const slide = child(doc, 'p:sld');
+  const cSld = child(slide, 'p:cSld');
+  const spTree = child(cSld, 'p:spTree');
+  if (!spTree) return [];
+
+  const inheritance = buildSlideInheritance(ctx.parsed, ctx.relIndex, slidePath);
+
+  /** @type {SlideEntity[]} */
+  const entities = [];
+
+  const bg = extractSlideBackground(cSld, scheme);
+  if (bg) {
+    entities.push({
+      slideIndex,
+      slidePath,
+      decision: bg.degraded ? 'DEGRADE' : 'FULL',
+      kind: 'background',
+      bounds: { x: 0, y: 0, w: 0, h: 0 },
+      shape: { type: 'background', fill: bg.color },
+      degradeReason: bg.degraded ? '渐变背景退化为纯色' : undefined,
+    });
+  }
+
+  const walkCtx = {
+    slideIndex,
+    slidePath,
+    relIndex: ctx.relIndex,
+    parsed: ctx.parsed,
+    scheme,
+    inheritance,
+    offset: { x: 0, y: 0 },
+    entities,
+  };
+
+  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 };
+}
+
+function walkSpTree(spTree, ctx) {
+  for (const sp of asArray(spTree['p:sp'])) {
+    extractShape(sp, ctx);
+  }
+  for (const pic of asArray(spTree['p:pic'])) {
+    extractPicture(pic, ctx);
+  }
+  for (const grp of asArray(spTree['p:grpSp'])) {
+    flattenGroup(grp, ctx);
+  }
+  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 类型');
+    }
+  }
+  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, {
+    ...ctx,
+    offset: { x: ctx.offset.x + off.x, y: ctx.offset.y + off.y },
+  });
+}
+
+function extractShape(sp, ctx) {
+  const xfrm = getEffectiveXfrm(sp, ctx.inheritance);
+  const bounds = boundsFromXfrm(xfrm, ctx.offset);
+
+  const { layoutSp, masterSp } = resolvePlaceholderSps(sp, ctx.inheritance);
+  const txBodyRaw = child(sp, 'p:txBody');
+
+  if (txBodyRaw) {
+    const txBody = mergeTxBody(txBodyRaw, layoutSp, masterSp);
+    const runs = extractTextRuns(txBody, ctx.scheme, {
+      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;
+  }
+
+  const spPr = child(sp, 'p:spPr');
+  const prst = attr(child(spPr, 'a:prstGeom'), 'prst');
+  if (!prst) return;
+
+  const shapeName = PRST_TO_SHAPE[prst];
+  const { color: fillColor, degraded: fillDegraded } = resolveFillColor(
+    spPr,
+    ctx.scheme
+  );
+  const ln = child(spPr, 'a:ln');
+  const lineColor = ln ? resolveFillColor(ln, ctx.scheme).color : null;
+
+  if (!shapeName) {
+    ctx.entities.push({
+      slideIndex: ctx.slideIndex,
+      slidePath: ctx.slidePath,
+      decision: 'DEGRADE',
+      kind: 'shape',
+      bounds,
+      shape: { type: 'RECTANGLE', fill: fillColor, line: lineColor },
+      degradeReason: `未知预设形状 "${prst}"，退化为矩形`,
+    });
+    return;
+  }
+
+  ctx.entities.push({
+    slideIndex: ctx.slideIndex,
+    slidePath: ctx.slidePath,
+    decision: fillDegraded ? 'DEGRADE' : 'FULL',
+    kind: 'shape',
+    bounds,
+    shape: { type: shapeName, fill: fillColor, line: lineColor },
+    degradeReason: fillDegraded ? '渐变填充退化为纯色' : undefined,
+  });
+}
+
+function extractPicture(pic, ctx) {
+  const spPr = child(pic, 'p:spPr');
+  const bounds = boundsFromXfrm(child(spPr, 'a:xfrm'), ctx.offset);
+
+  const blip = child(child(pic, 'p:blipFill'), 'a:blip');
+  const embedId = attr(blip, 'r:embed');
+  if (!embedId) return;
+
+  const mediaPath = ctx.relIndex.resolve(ctx.slidePath, embedId);
+  if (!mediaPath) return;
+
+  ctx.entities.push({
+    slideIndex: ctx.slideIndex,
+    slidePath: ctx.slidePath,
+    decision: 'FULL',
+    kind: 'image',
+    bounds,
+    image: {
+      zipPath: mediaPath,
+      fileName: path.posix.basename(mediaPath),
+    },
+  });
+}
+
+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);
+
+  ctx.entities.push({
+    slideIndex: ctx.slideIndex,
+    slidePath: ctx.slidePath,
+    decision: 'FULL',
+    kind: 'shape',
+    bounds,
+    shape: { type: 'LINE', fill: null, line: lineColor },
+  });
+}
+
+function skipElement(_node, ctx, reason) {
+  ctx.entities.push({
+    slideIndex: ctx.slideIndex,
+    slidePath: ctx.slidePath,
+    decision: 'SKIP',
+    kind: 'skip',
+    bounds: { x: 0, y: 0, w: 0, h: 0 },
+    skipReason: reason,
+  });
+}
+
+function readOffset(xfrm) {
+  const off = child(xfrm, 'a:off');
+  return {
+    x: parseInt(attr(off, 'x') ?? '0', 10),
+    y: parseInt(attr(off, 'y') ?? '0', 10),
+  };
+}
+
+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
+ */
+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;
+}
+
+module.exports = {
+  extractEntities,
+  PRST_TO_SHAPE,
+  boundsFromXfrm,
+};

package/lib/graphic.js

@@ -0,0 +1,63 @@
+/**
+ * graphicFrame 辅助：识别表格 / 图表等 graphicData URI
+ */
+const { attr, child } = require('./xml-utils');
+
+const URI_TABLE =
+  'http://schemas.openxmlformats.org/drawingml/2006/table';
+const URI_CHART =
+  'http://schemas.openxmlformats.org/drawingml/2006/chart';
+
+/**
+ * @param {object} graphicFrame
+ * @returns {string|undefined}
+ */
+function getGraphicUri(graphicFrame) {
+  const graphicData = child(child(graphicFrame, 'a:graphic'), 'a:graphicData');
+  return attr(graphicData, 'uri');
+}
+
+/**
+ * @param {object} graphicFrame
+ * @returns {boolean}
+ */
+function isTableFrame(graphicFrame) {
+  const uri = getGraphicUri(graphicFrame);
+  return Boolean(uri && uri.includes('table'));
+}
+
+/**
+ * @param {object} graphicFrame
+ * @returns {boolean}
+ */
+function isChartFrame(graphicFrame) {
+  const uri = getGraphicUri(graphicFrame);
+  return Boolean(uri && uri.includes('chart'));
+}
+
+/**
+ * @param {object} graphicFrame
+ * @returns {boolean}
+ */
+function isSmartArtFrame(graphicFrame) {
+  const uri = getGraphicUri(graphicFrame);
+  return Boolean(uri && uri.includes('diagram'));
+}
+
+/**
+ * @param {object} graphicFrame
+ * @returns {object|null} p:xfrm 节点
+ */
+function getGraphicXfrm(graphicFrame) {
+  return child(graphicFrame, 'p:xfrm');
+}
+
+module.exports = {
+  URI_TABLE,
+  URI_CHART,
+  getGraphicUri,
+  isTableFrame,
+  isChartFrame,
+  isSmartArtFrame,
+  getGraphicXfrm,
+};

package/lib/index.js

@@ -0,0 +1,7 @@
+const { convert, DEFAULT_OUTPUT, DEFAULT_MAX_FILE_SIZE } = require('./convert');
+
+module.exports = {
+  convert,
+  DEFAULT_OUTPUT,
+  DEFAULT_MAX_FILE_SIZE,
+};