pptxtojson-pro 0.1.0

package/scripts/extract-pptx-structure.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+/**
+ * 解压 PPTX 并展示其内部文件结构
+ * 用法: node scripts/extract-pptx-structure.js <pptx路径> [输出目录]
+ * 示例: node scripts/extract-pptx-structure.js ./xxx.pptx
+ *       node scripts/extract-pptx-structure.js ./xxx.pptx ./output
+ */
+
+import JSZip from 'jszip'
+import fs from 'fs'
+import path from 'path'
+
+const args = process.argv.slice(2)
+const pptxPath = args[0]
+const outDir = args[1] || null
+
+if (!pptxPath) {
+  console.error('用法: node scripts/extract-pptx-structure.js <pptx路径> [输出目录]')
+  process.exit(1)
+}
+
+const resolvedPath = path.resolve(pptxPath)
+if (!fs.existsSync(resolvedPath)) {
+  console.error('文件不存在:', resolvedPath)
+  process.exit(1)
+}
+
+/**
+ * 将扁平路径列表转成树形结构
+ * @param {string[]} paths - 如 ['ppt/slides/slide1.xml', 'ppt/slides/slide2.xml']
+ * @returns {Object} 树形对象
+ */
+function pathsToTree(paths) {
+  const tree = {}
+  for (const p of paths) {
+    const parts = p.split('/').filter(Boolean)
+    let current = tree
+    for (let i = 0; i < parts.length; i++) {
+      const name = parts[i]
+      const isLast = i === parts.length - 1
+      if (!current[name]) {
+        current[name] = isLast ? null : {}
+      }
+      if (!isLast) {
+        current = current[name]
+      }
+    }
+  }
+  return tree
+}
+
+/**
+ * 递归打印树
+ */
+function printTree(obj, prefix = '') {
+  const entries = Object.entries(obj).sort((a, b) => {
+    const aIsFile = a[1] === null
+    const bIsFile = b[1] === null
+    if (aIsFile !== bIsFile) return aIsFile ? 1 : -1
+    return a[0].localeCompare(b[0])
+  })
+  for (let i = 0; i < entries.length; i++) {
+    const [name, value] = entries[i]
+    const isLast = i === entries.length - 1
+    const branch = isLast ? '└── ' : '├── '
+    const nextPrefix = isLast ? '    ' : '│   '
+    if (value === null) {
+      console.log(prefix + branch + name)
+    } else {
+      console.log(prefix + branch + name + '/')
+      printTree(value, prefix + nextPrefix)
+    }
+  }
+}
+
+async function main() {
+  console.log('正在读取:', resolvedPath)
+  const buffer = fs.readFileSync(resolvedPath)
+  const zip = await JSZip.loadAsync(buffer)
+
+  const filePaths = []
+  zip.forEach((relativePath) => {
+    filePaths.push(relativePath)
+  })
+  filePaths.sort()
+
+  console.log('\n========== PPTX 内部文件结构 ==========\n')
+  const tree = pathsToTree(filePaths)
+  printTree(tree)
+
+  console.log('\n---------- 扁平文件列表 ----------')
+  filePaths.forEach((p) => console.log(p))
+  console.log('\n总文件数:', filePaths.length)
+
+  if (outDir) {
+    const outResolved = path.resolve(outDir)
+    fs.mkdirSync(outResolved, { recursive: true })
+    console.log('\n正在解压到:', outResolved)
+    for (const relativePath of filePaths) {
+      const file = zip.file(relativePath)
+      if (!file) continue
+      const fullPath = path.join(outResolved, relativePath)
+      const dir = path.dirname(fullPath)
+      fs.mkdirSync(dir, { recursive: true })
+      const content = await file.async('nodebuffer')
+      fs.writeFileSync(fullPath, content)
+    }
+    console.log('解压完成.')
+  }
+}
+
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})

package/scripts/transvert.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * 命令行脚本：接受一个 .pptx 文件路径，解析并输出 JSON。
+ * 用法: node scripts/transvert.js <path-to.pptx>
+ * 或:   pnpm run transvert <path-to.pptx>
+ */
+
+import { parse } from '../dist/index.js'
+import fs from 'fs'
+import path from 'path'
+
+const pptxPath = process.argv[2]
+if (!pptxPath) {
+  console.error('用法: node scripts/transvert.js <path-to.pptx>')
+  process.exit(1)
+}
+
+const resolved = path.resolve(process.cwd(), pptxPath)
+if (!fs.existsSync(resolved)) {
+  console.error('文件不存在:', resolved)
+  process.exit(1)
+}
+
+const buf = fs.readFileSync(resolved)
+const arrayBuffer = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)
+
+parse(arrayBuffer)
+  .then((json) => {
+    console.log(JSON.stringify(json, null, 2))
+  })
+  .catch((err) => {
+    console.error('解析失败:', err.message)
+    process.exit(1)
+  })

package/src/adapter/toPptxtojson.ts

@@ -0,0 +1,46 @@
+/**
+ * Adapter: PresentationData + PptxFiles → pptxtojson/PPTist output format.
+ * All dimensions in output are in pt (px * 0.75).
+ * Delegates slide serialization to the serializer layer (slideToSlide).
+ */
+
+import type { PresentationData } from '../model/Presentation';
+import type { PptxFiles } from '../parser/ZipParser';
+import type { Output, Slide, Size } from './types';
+import { slideToSlide } from '../serializer/slideSerializer';
+
+const PX_TO_PT = 0.75;
+
+function pxToPt(px: number): number {
+  return px * PX_TO_PT;
+}
+
+function getThemeColors(presentation: PresentationData): string[] {
+  const themeColors: string[] = [];
+  const firstTheme = presentation.themes.values().next().value;
+  if (!firstTheme) return ['#000000', '#000000', '#000000', '#000000', '#000000', '#000000'];
+  for (let i = 1; i <= 6; i++) {
+    const hex = firstTheme.colorScheme.get(`accent${i}`) ?? '000000';
+    themeColors.push(hex.startsWith('#') ? hex : `#${hex}`);
+  }
+  return themeColors;
+}
+
+export function toPptxtojsonFormat(
+  presentation: PresentationData,
+  files: PptxFiles,
+): Output {
+  const size: Size = {
+    width: pxToPt(presentation.width),
+    height: pxToPt(presentation.height),
+  };
+  const themeColors = getThemeColors(presentation);
+  const slides: Slide[] = presentation.slides.map((slide) =>
+    slideToSlide(presentation, slide, files),
+  );
+  return {
+    slides,
+    themeColors,
+    size,
+  };
+}

package/src/adapter/types.ts

@@ -0,0 +1,330 @@
+/**
+ * pptxtojson / PPTist 输出格式类型定义
+ * 长度与坐标单位均为 pt。
+ */
+
+export interface Size {
+  width: number
+  height: number
+}
+
+export interface Shadow {
+  h: number
+  v: number
+  blur: number
+  color: string
+}
+
+export interface ColorFill {
+  type: 'color'
+  value: string
+}
+
+export interface ImageFill {
+  type: 'image'
+  value: {
+    picBase64: string
+    opacity: number
+  }
+}
+
+export interface GradientFill {
+  type: 'gradient'
+  value: {
+    path: 'line' | 'circle' | 'rect' | 'shape'
+    rot: number
+    colors: {
+      pos: string
+      color: string
+    }[]
+  }
+}
+
+export interface PatternFill {
+  type: 'pattern'
+  value: {
+    type: string
+    foregroundColor: string
+    backgroundColor: string
+  }
+}
+
+export type Fill = ColorFill | ImageFill | GradientFill | PatternFill
+
+export interface Border {
+  borderColor: string
+  borderWidth: number
+  borderType: 'solid' | 'dashed' | 'dotted'
+}
+
+export interface AutoFit {
+  type: 'shape' | 'text'
+  fontScale?: number
+}
+
+export interface Shape {
+  type: 'shape'
+  left: number
+  top: number
+  width: number
+  height: number
+  borderColor: string
+  borderWidth: number
+  borderType: 'solid' | 'dashed' | 'dotted'
+  borderStrokeDasharray: string
+  shadow?: Shadow
+  fill: Fill
+  content: string
+  isFlipV: boolean
+  isFlipH: boolean
+  rotate: number
+  shapType: string
+  vAlign: string
+  path?: string
+  keypoints?: Record<string, number>
+  name: string
+  order: number
+  autoFit?: AutoFit
+  link?: string
+}
+
+export interface Text {
+  type: 'text'
+  left: number
+  top: number
+  width: number
+  height: number
+  borderColor: string
+  borderWidth: number
+  borderType: 'solid' | 'dashed' | 'dotted'
+  borderStrokeDasharray: string
+  shadow?: Shadow
+  fill: Fill
+  isFlipV: boolean
+  isFlipH: boolean
+  isVertical: boolean
+  rotate: number
+  content: string
+  vAlign: string
+  name: string
+  order: number
+  autoFit?: AutoFit
+  link?: string
+}
+
+export interface Image {
+  type: 'image'
+  left: number
+  top: number
+  width: number
+  height: number
+  src: string
+  rotate: number
+  isFlipH: boolean
+  isFlipV: boolean
+  order: number
+  rect?: {
+    t?: number
+    b?: number
+    l?: number
+    r?: number
+  }
+  geom: string
+  borderColor: string
+  borderWidth: number
+  borderType: 'solid' | 'dashed' | 'dotted'
+  borderStrokeDasharray: string
+  filters?: {
+    sharpen?: number
+    colorTemperature?: number
+    saturation?: number
+    brightness?: number
+    contrast?: number
+  }
+  link?: string
+}
+
+export interface TableCell {
+  text: string
+  rowSpan?: number
+  colSpan?: number
+  vMerge?: number
+  hMerge?: number
+  fillColor?: string
+  fontColor?: string
+  fontBold?: boolean
+  borders: {
+    top?: Border
+    bottom?: Border
+    left?: Border
+    right?: Border
+  }
+}
+
+export interface Table {
+  type: 'table'
+  left: number
+  top: number
+  width: number
+  height: number
+  data: TableCell[][]
+  borders: {
+    top?: Border
+    bottom?: Border
+    left?: Border
+    right?: Border
+  }
+  order: number
+  rowHeights: number[]
+  colWidths: number[]
+}
+
+export type ChartType = 'lineChart' |
+  'line3DChart' |
+  'barChart' |
+  'bar3DChart' |
+  'pieChart' |
+  'pie3DChart' |
+  'doughnutChart' |
+  'areaChart' |
+  'area3DChart' |
+  'scatterChart' |
+  'bubbleChart' |
+  'radarChart' |
+  'surfaceChart' |
+  'surface3DChart' |
+  'stockChart'
+
+export interface ChartValue {
+  x: string
+  y: number
+}
+
+export interface ChartXLabel {
+  [key: string]: string
+}
+
+export interface ChartItem {
+  key: string
+  values: ChartValue[]
+  xlabels: ChartXLabel
+}
+
+export type ScatterChartData = [number[], number[]]
+
+export interface CommonChart {
+  type: 'chart'
+  left: number
+  top: number
+  width: number
+  height: number
+  data: ChartItem[]
+  colors: string[]
+  chartType: Exclude<ChartType, 'scatterChart' | 'bubbleChart'>
+  barDir?: 'bar' | 'col'
+  marker?: boolean
+  holeSize?: string
+  grouping?: string
+  style?: string
+  order: number
+}
+
+export interface ScatterChart {
+  type: 'chart'
+  left: number
+  top: number
+  width: number
+  height: number
+  data: ScatterChartData
+  colors: string[]
+  chartType: 'scatterChart' | 'bubbleChart'
+  order: number
+}
+
+export type Chart = CommonChart | ScatterChart
+
+export interface Video {
+  type: 'video'
+  left: number
+  top: number
+  width: number
+  height: number
+  blob?: string
+  src?: string
+  order: number
+}
+
+export interface Audio {
+  type: 'audio'
+  left: number
+  top: number
+  width: number
+  height: number
+  blob: string
+  order: number
+}
+
+export interface Diagram {
+  type: 'diagram'
+  left: number
+  top: number
+  width: number
+  height: number
+  elements: (Shape | Text)[]
+  textList: string[]
+  order: number
+}
+
+export interface Math {
+  type: 'math'
+  left: number
+  top: number
+  width: number
+  height: number
+  latex: string
+  picBase64: string
+  order: number
+  text?: string
+}
+
+export type BaseElement = Shape | Text | Image | Table | Chart | Video | Audio | Diagram | Math
+
+export interface Group {
+  type: 'group'
+  left: number
+  top: number
+  width: number
+  height: number
+  rotate: number
+  elements: BaseElement[]
+  order: number
+  isFlipH: boolean
+  isFlipV: boolean
+}
+
+export type Element = BaseElement | Group
+
+export interface SlideTransition {
+  type: string
+  duration: number
+  direction: string | null
+}
+
+export interface Slide {
+  fill: Fill
+  elements: Element[]
+  layoutElements: Element[]
+  note: string
+  transition?: SlideTransition | null
+}
+
+export interface Options {
+  slideFactor?: number
+  fontsizeFactor?: number
+}
+
+export interface Output {
+  slides: Slide[]
+  themeColors: string[]
+  size: Size
+}

package/src/export/serializePresentation.ts

@@ -0,0 +1,200 @@
+/**
+ * Serialize PresentationData into a plain JSON-serializable structure.
+ * Strips all SafeXmlNode references and re-parses group children.
+ */
+
+import { PresentationData } from '../model/Presentation';
+import { SlideNode } from '../model/Slide';
+import { ShapeNodeData, TextBody } from '../model/nodes/ShapeNode';
+import { PicNodeData } from '../model/nodes/PicNode';
+import { TableNodeData, TableRow, TableCell } from '../model/nodes/TableNode';
+import { GroupNodeData } from '../model/nodes/GroupNode';
+import { ChartNodeData } from '../model/nodes/ChartNode';
+import { BaseNodeData } from '../model/nodes/BaseNode';
+import { parseShapeNode } from '../model/nodes/ShapeNode';
+import { parsePicNode } from '../model/nodes/PicNode';
+import { parseTableNode } from '../model/nodes/TableNode';
+import { parseGroupNode } from '../model/nodes/GroupNode';
+import { SafeXmlNode } from '../parser/XmlParser';
+
+// ---------------------------------------------------------------------------
+// Serialized Types (JSON-safe)
+// ---------------------------------------------------------------------------
+
+interface SerializedParagraph {
+  level: number;
+  text: string;
+}
+
+interface SerializedTextBody {
+  paragraphs: SerializedParagraph[];
+  totalText: string;
+}
+
+interface SerializedCell {
+  text: string;
+  gridSpan: number;
+  rowSpan: number;
+}
+
+interface SerializedRow {
+  height: number;
+  cells: SerializedCell[];
+}
+
+export interface SerializedNode {
+  id: string;
+  name: string;
+  nodeType: string;
+  position: { x: number; y: number };
+  size: { w: number; h: number };
+  rotation: number;
+  flipH: boolean;
+  flipV: boolean;
+  presetGeometry?: string;
+  textBody?: SerializedTextBody;
+  columns?: number[];
+  rows?: SerializedRow[];
+  tableStyleId?: string;
+  blipEmbed?: string;
+  chartPath?: string;
+  children?: SerializedNode[];
+}
+
+export interface SerializedSlide {
+  index: number;
+  nodes: SerializedNode[];
+}
+
+export interface SerializedPresentation {
+  width: number;
+  height: number;
+  slideCount: number;
+  slides: SerializedSlide[];
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function serializeTextBody(tb: TextBody | undefined): SerializedTextBody | undefined {
+  if (!tb) return undefined;
+  const paragraphs: SerializedParagraph[] = tb.paragraphs.map((p) => ({
+    level: p.level,
+    text: p.runs.map((r) => r.text).join(''),
+  }));
+  const totalText = paragraphs.map((p) => p.text).join('\n');
+  if (!totalText.trim()) return undefined;
+  return { paragraphs, totalText };
+}
+
+function serializeCell(cell: TableCell): SerializedCell {
+  const text = cell.textBody
+    ? cell.textBody.paragraphs.map((p) => p.runs.map((r) => r.text).join('')).join('\n')
+    : '';
+  return { text, gridSpan: cell.gridSpan, rowSpan: cell.rowSpan };
+}
+
+function serializeRow(row: TableRow): SerializedRow {
+  return {
+    height: row.height,
+    cells: row.cells.map(serializeCell),
+  };
+}
+
+/**
+ * Parse a raw XML child node from a group into a typed node.
+ */
+function parseGroupChild(childXml: SafeXmlNode): BaseNodeData | undefined {
+  const tag = childXml.localName;
+  switch (tag) {
+    case 'sp':
+    case 'cxnSp':
+      return parseShapeNode(childXml);
+    case 'pic':
+      return parsePicNode(childXml);
+    case 'grpSp':
+      return parseGroupNode(childXml);
+    case 'graphicFrame': {
+      const graphic = childXml.child('graphic');
+      const graphicData = graphic.child('graphicData');
+      if (graphicData.child('tbl').exists()) {
+        return parseTableNode(childXml);
+      }
+      return undefined;
+    }
+    default:
+      return undefined;
+  }
+}
+
+function serializeNode(node: SlideNode | BaseNodeData): SerializedNode {
+  const base: SerializedNode = {
+    id: node.id,
+    name: node.name,
+    nodeType: node.nodeType,
+    position: { x: node.position.x, y: node.position.y },
+    size: { w: node.size.w, h: node.size.h },
+    rotation: node.rotation,
+    flipH: node.flipH,
+    flipV: node.flipV,
+  };
+
+  switch (node.nodeType) {
+    case 'shape': {
+      const s = node as ShapeNodeData;
+      base.presetGeometry = s.presetGeometry;
+      base.textBody = serializeTextBody(s.textBody);
+      break;
+    }
+    case 'picture': {
+      const p = node as PicNodeData;
+      base.blipEmbed = p.blipEmbed;
+      break;
+    }
+    case 'table': {
+      const t = node as TableNodeData;
+      base.columns = [...t.columns];
+      base.rows = t.rows.map(serializeRow);
+      base.tableStyleId = t.tableStyleId;
+      break;
+    }
+    case 'chart': {
+      const c = node as ChartNodeData;
+      base.chartPath = c.chartPath;
+      break;
+    }
+    case 'group': {
+      const g = node as GroupNodeData;
+      const children: SerializedNode[] = [];
+      for (const childXml of g.children) {
+        try {
+          const parsed = parseGroupChild(childXml);
+          if (parsed) children.push(serializeNode(parsed));
+        } catch {
+          // skip unparseable group children
+        }
+      }
+      base.children = children;
+      break;
+    }
+  }
+
+  return base;
+}
+
+// ---------------------------------------------------------------------------
+// Main Export
+// ---------------------------------------------------------------------------
+
+export function serializePresentation(pres: PresentationData): SerializedPresentation {
+  return {
+    width: pres.width,
+    height: pres.height,
+    slideCount: pres.slides.length,
+    slides: pres.slides.map((slide, i) => ({
+      index: i,
+      nodes: slide.nodes.map(serializeNode),
+    })),
+  };
+}