pptxtojson 1.0.3 → 1.1.1

package/index.html

@@ -4,8 +4,8 @@
 	<meta charset="utf-8">
 	<meta http-equiv="X-UA-Compatible" content="IE=edge">
 	<meta name="viewport" content="width=device-width, initial-scale=1">
-	<meta name="description" content="基于JavaScript的 .pptx 文件解析工具丨A javascript tool for parsing .pptx file" />
-	<meta name="keywords" content="ppt,powerpoint,office powerpoint,json,javascript,PPT解析,PPT转JSON" />
+	<meta name="description" content="Office PowerPoint(.pptx) file to JSON | 将 PPTX 文件转为可读的 JSON 数据" />
+	<meta name="keywords" content="pptx2json,pptxtojson,ppt,powerpoint,json,javascript,PPT解析,PPT转JSON" />
 	<link rel="icon" href="favicon.ico">
 	<title>pptxtojson - PPTX转JSON</title>	
 
@@ -80,6 +80,13 @@
 		.upload-input {
 			display: none;
 		}
+		.link {
+			display: flex;
+		}
+		.link a {
+			padding: 5px 10px;
+			color: #d14424;
+		}
 	</style>
 </head>
 
@@ -90,7 +97,10 @@
 			<input class="upload-input" type="file" accept="application/vnd.openxmlformats-officedocument.presentationml.presentation"/>
 		</div>
 
-		<a href="https://github.com/pipipi-pikachu/pptx2json">Github</a>
+		<div class="link">
+			<a target="_blank" href="https://github.com/pipipi-pikachu/pptx2json">Github仓库</a>
+			<a target="_blank" href="https://pipipi-pikachu.github.io/PPTist/">可视化测试</a>
+		</div>
 	</div>
 	<div id="jsoneditor"></div>
 	

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pptxtojson",
-	"version": "1.0.3",
+	"version": "1.1.1",
 	"description": "A javascript tool for parsing .pptx file",
 	"type": "module",
 	"main": "./dist/index.umd.js",
@@ -24,7 +24,7 @@
 	"homepage": "https://github.com/pipipi-pikachu/pptxtojson",
 	"license": "MIT",
 	"publishConfig": {
-		"registry": "https://registry.npmjs.org"
+		"registry": "https://registry.npmjs.com"
 	},
 	"dependencies": {
 		"jszip": "^3.10.1",

package/src/math.js

@@ -0,0 +1,184 @@
+import { getTextByPathList } from './utils'
+
+export function findOMath(obj) {
+  let results = []
+  if (typeof obj !== 'object') return results
+  if (obj['m:oMath']) results = results.concat(obj['m:oMath'])
+  
+  Object.values(obj).forEach(value => {
+    if (Array.isArray(value) || typeof value === 'object') {
+      results = results.concat(findOMath(value))
+    }
+  })
+  return results
+}
+
+export function parseFraction(fraction) {
+  const numerator = parseOMath(fraction['m:num'])
+  const denominator = parseOMath(fraction['m:den'])
+  return `\\frac{${numerator}}{${denominator}}`
+}
+export function parseSuperscript(superscript) {
+  const base = parseOMath(superscript['m:e'])
+  const sup = parseOMath(superscript['m:sup'])
+  return `${base}^{${sup}}`
+}
+export function parseSubscript(subscript) {
+  const base = parseOMath(subscript['m:e'])
+  const sub = parseOMath(subscript['m:sub'])
+  return `${base}_{${sub}}`
+}
+export function parseRadical(radical) {
+  const degree = parseOMath(radical['m:deg'])
+  const expression = parseOMath(radical['m:e'])
+  return degree ? `\\sqrt[${degree}]{${expression}}` : `\\sqrt{${expression}}`
+}
+export function parseMatrix(matrix) {
+  const rows = matrix['m:mr']
+  const matrixRows = rows.map((row) => {
+    return row['m:e'].map((element) => parseOMath(element)).join(' & ')
+  })
+  return `\\begin{matrix} ${matrixRows.join(' \\\\ ')} \\end{matrix}`
+}
+export function parseNary(nary) {
+  const op = getTextByPathList(nary, ['m:naryPr', 'm:chr', 'attrs', 'm:val']) || '∫'
+  const sub = parseOMath(nary['m:sub'])
+  const sup = parseOMath(nary['m:sup'])
+  const e = parseOMath(nary['m:e'])
+  return `${op}_{${sub}}^{${sup}}{${e}}`
+}
+export function parseLimit(limit, type) {
+  const base = parseOMath(limit['m:e'])
+  const lim = parseOMath(limit['m:lim'])
+  return type === 'low' ? `${base}_{${lim}}` : `${base}^{${lim}}`
+}
+export function parseDelimiter(delimiter) {
+  let left = getTextByPathList(delimiter, ['m:dPr', 'm:begChr', 'attrs', 'm:val'])
+  let right = getTextByPathList(delimiter, ['m:dPr', 'm:endChr', 'attrs', 'm:val'])
+  if (!left && !right) {
+    left = '('
+    right = ')'
+  }
+  if (left && right) {
+    left = `\\left${left}`
+    right = `\\right${right}`
+  }
+  const e = parseOMath(delimiter['m:e'])
+  return `${left}${e}${right}`
+}
+export function parseFunction(func) {
+  const name = parseOMath(func['m:fName'])
+  const arg = parseOMath(func['m:e'])
+  return `\\${name}{${arg}}`
+}
+export function parseGroupChr(groupChr) {
+  const chr = getTextByPathList(groupChr, ['m:groupChrPr', 'm:chr', 'attrs', 'm:val'])
+  const e = parseOMath(groupChr['m:e'])
+  return `${chr}${e}${chr}`
+}
+export function parseEqArr(eqArr) {
+  const equations = eqArr['m:e'].map((eq) => parseOMath(eq)).join(' \\\\ ')
+  return `\\begin{cases} ${equations} \\end{cases}`
+}
+export function parseBar(bar) {
+  const e = parseOMath(bar['m:e'])
+  const pos = getTextByPathList(bar, ['m:barPr', 'm:pos', 'attrs', 'm:val'])
+  return pos === 'top' ? `\\overline{${e}}` : `\\underline{${e}}`
+}
+export function parseAccent(accent) {
+  const chr = getTextByPathList(accent, ['m:accPr', 'm:chr', 'attrs', 'm:val']) || '^'
+  const e = parseOMath(accent['m:e'])
+  switch (chr) {
+    case '\u0301':
+      return `\\acute{${e}}`
+    case '\u0300':
+      return `\\grave{${e}}`
+    case '\u0302':
+      return `\\hat{${e}}`
+    case '\u0303':
+      return `\\tilde{${e}}`
+    case '\u0304':
+      return `\\bar{${e}}`
+    case '\u0306':
+      return `\\breve{${e}}`
+    case '\u0307':
+      return `\\dot{${e}}`
+    case '\u0308':
+      return `\\ddot{${e}}`
+    case '\u030A':
+      return `\\mathring{${e}}`
+    case '\u030B':
+      return `\\H{${e}}`
+    case '\u030C':
+      return `\\check{${e}}`
+    case '\u0327':
+      return `\\c{${e}}`
+    default:
+      return `\\${chr}{${e}}`
+  }
+}
+export function parseBox(box) {
+  const e = parseOMath(box['m:e'])
+  return `\\boxed{${e}}`
+}
+
+
+export function parseOMath(oMath) {
+  if (!oMath) return ''
+
+  if (Array.isArray(oMath)) {
+    return oMath.map(item => parseOMath(item)).join('')
+  }
+
+  const oMathList = []
+  const keys = Object.keys(oMath)
+  for (const key of keys) {
+    if (Array.isArray(oMath[key])) {
+      oMathList.push(...oMath[key].map(item => ({ key, value: item })))
+    }
+    else oMathList.push({ key, value: oMath[key] })
+  }
+
+  oMathList.sort((a, b) => {
+    let oA = 0
+    if (a.key === 'm:r' && a.value && a.value['a:rPr']) oA = a.value['a:rPr']['attrs']['order']
+    else if (a.value[`${a.key}Pr`] && a.value[`${a.key}Pr`]['m:ctrlPr'] && a.value[`${a.key}Pr`]['m:ctrlPr']['a:rPr']) {
+      oA = a.value[`${a.key}Pr`] && a.value[`${a.key}Pr`]['m:ctrlPr'] && a.value[`${a.key}Pr`]['m:ctrlPr']['a:rPr'] && a.value[`${a.key}Pr`]['m:ctrlPr']['a:rPr']['attrs']['order']
+    }
+    let oB = 0
+    if (b.key === 'm:r' && b.value && b.value['a:rPr']) oB = b.value['a:rPr']['attrs']['order']
+    else if (b.value[`${b.key}Pr`] && b.value[`${b.key}Pr`]['m:ctrlPr'] && b.value[`${b.key}Pr`]['m:ctrlPr']['a:rPr']) {
+      oB = b.value[`${b.key}Pr`] && b.value[`${b.key}Pr`]['m:ctrlPr'] && b.value[`${b.key}Pr`]['m:ctrlPr']['a:rPr'] && b.value[`${b.key}Pr`]['m:ctrlPr']['a:rPr']['attrs']['order']
+    }
+    return oA - oB
+  })
+
+  return oMathList.map(({ key, value }) => {
+    if (key === 'm:f') return parseFraction(value)
+    if (key === 'm:sSup') return parseSuperscript(value)
+    if (key === 'm:sSub') return parseSubscript(value)
+    if (key === 'm:rad') return parseRadical(value)
+    if (key === 'm:nary') return parseNary(value)
+    if (key === 'm:limLow') return parseLimit(value, 'low')
+    if (key === 'm:limUpp') return parseLimit(value, 'upp')
+    if (key === 'm:d') return parseDelimiter(value)
+    if (key === 'm:func') return parseFunction(value)
+    if (key === 'm:groupChr') return parseGroupChr(value)
+    if (key === 'm:eqArr') return parseEqArr(value)
+    if (key === 'm:bar') return parseBar(value)
+    if (key === 'm:acc') return parseAccent(value)
+    if (key === 'm:borderBox') return parseBox(value)
+    if (key === 'm:m') return parseMatrix(value)
+    if (key === 'm:r') return parseOMath(value)
+    if (key === 'm:t') return value
+    return ''
+  }).join('')
+}
+
+export function latexFormart(latex) {
+  return latex.replaceAll(/&lt;/g, '<')
+    .replaceAll(/&gt;/g, '>')
+    .replaceAll(/&amp;/g, '&')
+    .replaceAll(/&apos;/g, "'")
+    .replaceAll(/&quot;/g, '"')
+}

package/src/pptxtojson.js

@@ -7,10 +7,11 @@ import { getVerticalAlign } from './align'
 import { getPosition, getSize } from './position'
 import { genTextBody } from './text'
 import { getCustomShapePath } from './shape'
-import { extractFileExtension, base64ArrayBuffer, getTextByPathList, angleToDegrees, getMimeType, isVideoLink, escapeHtml } from './utils'
+import { extractFileExtension, base64ArrayBuffer, getTextByPathList, angleToDegrees, getMimeType, isVideoLink, escapeHtml, hasValidText } from './utils'
 import { getShadow } from './shadow'
 import { getTableBorders, getTableCellParams, getTableRowParams } from './table'
 import { RATIO_EMUs_Points } from './constants'
+import { findOMath, latexFormart, parseOMath } from './math'
 
 export async function parse(file) {
   const slides = []
@@ -105,6 +106,7 @@ async function processSingleSlide(zip, sldFileName, themeContent, defaultTextSty
   let relationshipArray = resContent['Relationships']['Relationship']
   let layoutFilename = ''
   let diagramFilename = ''
+  let notesFilename = ''
   const slideResObj = {}
 
   if (relationshipArray.constructor === Array) {
@@ -121,6 +123,8 @@ async function processSingleSlide(zip, sldFileName, themeContent, defaultTextSty
           }
           break
         case 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide':
+          notesFilename = relationshipArrayItem['attrs']['Target'].replace('../', 'ppt/')
+          break
         case 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/image':
         case 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart':
         case 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink':
@@ -133,6 +137,9 @@ async function processSingleSlide(zip, sldFileName, themeContent, defaultTextSty
     }
   } 
   else layoutFilename = relationshipArray['attrs']['Target'].replace('../', 'ppt/')
+  
+  const slideNotesContent = await readXmlFile(zip, notesFilename)
+  const note = getNote(slideNotesContent)
 
   const slideLayoutContent = await readXmlFile(zip, layoutFilename)
   const slideLayoutTables = await indexNodes(slideLayoutContent)
@@ -283,9 +290,29 @@ async function processSingleSlide(zip, sldFileName, themeContent, defaultTextSty
   return {
     fill: bgColor,
     elements,
+    note,
   }
 }
 
+function getNote(noteContent) {
+  let text = ''
+  let spNodes = getTextByPathList(noteContent, ['p:notes', 'p:cSld', 'p:spTree', 'p:sp'])
+  if (!spNodes) return ''
+
+  if (spNodes.constructor !== Array) spNodes = [spNodes]
+  for (const spNode of spNodes) {
+    let rNodes = getTextByPathList(spNode, ['p:txBody', 'a:p', 'a:r'])
+    if (!rNodes) continue
+
+    if (rNodes.constructor !== Array) rNodes = [rNodes]
+    for (const rNode of rNodes) {
+      const t = getTextByPathList(rNode, ['a:t'])
+      if (t) text += t
+    }
+  }
+  return text
+}
+
 // async function getBackground(warpObj) {
 //   const elements = []
 //   const slideLayoutContent = warpObj['slideLayoutContent']
@@ -390,7 +417,12 @@ async function processNodesInSlide(nodeKey, nodeValue, warpObj, source) {
       json = await processGroupSpNode(nodeValue, warpObj, source)
       break
     case 'mc:AlternateContent':
-      json = await processGroupSpNode(getTextByPathList(nodeValue, ['mc:Fallback']), warpObj, source)
+      if (getTextByPathList(nodeValue, ['mc:Fallback', 'p:grpSpPr', 'a:xfrm'])) {
+        json = await processGroupSpNode(getTextByPathList(nodeValue, ['mc:Fallback']), warpObj, source)
+      }
+      else if (getTextByPathList(nodeValue, ['mc:Choice'])) {
+        json = await processMathNode(getTextByPathList(nodeValue, ['mc:Choice']))
+      }
       break
     default:
   }
@@ -398,7 +430,28 @@ async function processNodesInSlide(nodeKey, nodeValue, warpObj, source) {
   return json
 }
 
+function processMathNode(node) {
+  const order = node['attrs']['order']
+  const xfrmNode = getTextByPathList(node, ['p:sp', 'p:spPr', 'a:xfrm'])
+  const { top, left } = getPosition(xfrmNode, undefined, undefined)
+  const { width, height } = getSize(xfrmNode, undefined, undefined)
+
+  const oMath = findOMath(node)[0]
+  const latex = latexFormart(parseOMath(oMath))
+
+  return {
+    type: 'math',
+    top,
+    left,
+    width, 
+    height,
+    latex,
+    order,
+  }
+}
+
 async function processGroupSpNode(node, warpObj, source) {
+  const order = node['attrs']['order']
   const xfrmNode = getTextByPathList(node, ['p:grpSpPr', 'a:xfrm'])
   if (!xfrmNode) return null
 
@@ -438,6 +491,7 @@ async function processGroupSpNode(node, warpObj, source) {
     width: cx,
     height: cy,
     rotate,
+    order,
     elements: elements.map(element => ({
       ...element,
       left: (element.left - chx) * ws,
@@ -452,6 +506,7 @@ function processSpNode(node, warpObj, source) {
   const name = getTextByPathList(node, ['p:nvSpPr', 'p:cNvPr', 'attrs', 'name'])
   const idx = getTextByPathList(node, ['p:nvSpPr', 'p:nvPr', 'p:ph', 'attrs', 'idx'])
   let type = getTextByPathList(node, ['p:nvSpPr', 'p:nvPr', 'p:ph', 'attrs', 'type'])
+  const order = getTextByPathList(node, ['attrs', 'order'])
 
   let slideLayoutSpNode, slideMasterSpNode
 
@@ -482,17 +537,18 @@ function processSpNode(node, warpObj, source) {
     else type = 'obj'
   }
 
-  return genShape(node, slideLayoutSpNode, slideMasterSpNode, name, type, warpObj)
+  return genShape(node, slideLayoutSpNode, slideMasterSpNode, name, type, order, warpObj)
 }
 
 function processCxnSpNode(node, warpObj) {
   const name = node['p:nvCxnSpPr']['p:cNvPr']['attrs']['name']
   const type = (node['p:nvCxnSpPr']['p:nvPr']['p:ph'] === undefined) ? undefined : node['p:nvSpPr']['p:nvPr']['p:ph']['attrs']['type']
+  const order = node['attrs']['order']
 
-  return genShape(node, undefined, undefined, name, type, warpObj)
+  return genShape(node, undefined, undefined, name, type, order, warpObj)
 }
 
-function genShape(node, slideLayoutSpNode, slideMasterSpNode, name, type, warpObj) {
+function genShape(node, slideLayoutSpNode, slideMasterSpNode, name, type, order, warpObj) {
   const xfrmList = ['p:spPr', 'a:xfrm']
   const slideXfrmNode = getTextByPathList(node, xfrmList)
   const slideLayoutXfrmNode = getTextByPathList(slideLayoutSpNode, xfrmList)
@@ -518,7 +574,10 @@ function genShape(node, slideLayoutSpNode, slideMasterSpNode, name, type, warpOb
   else txtRotate = rotate
 
   let content = ''
-  if (node['p:txBody']) content = genTextBody(node['p:txBody'], node, slideLayoutSpNode, type, warpObj)
+  if (node['p:txBody']) {
+    content = genTextBody(node['p:txBody'], node, slideLayoutSpNode, type, warpObj)
+    if (!hasValidText(content)) content = ''
+  }
 
   const { borderColor, borderWidth, borderType, strokeDasharray } = getBorder(node, type, warpObj)
   const fillColor = getShapeFill(node, undefined, warpObj) || ''
@@ -546,6 +605,7 @@ function genShape(node, slideLayoutSpNode, slideMasterSpNode, name, type, warpOb
     rotate,
     vAlign,
     name,
+    order,
   }
 
   if (shadow) data.shadow = shadow
@@ -583,6 +643,8 @@ async function processPicNode(node, warpObj, source) {
   if (source === 'slideMasterBg') resObj = warpObj['masterResObj']
   else if (source === 'slideLayoutBg') resObj = warpObj['layoutResObj']
   else resObj = warpObj['slideResObj']
+
+  const order = node['attrs']['order']
   
   const rid = node['p:blipFill']['a:blip']['attrs']['r:embed']
   const imgName = resObj[rid]['target']
@@ -647,6 +709,7 @@ async function processPicNode(node, warpObj, source) {
       height,
       rotate,
       blob: videoBlob,
+      order,
     }
   } 
   if (videoNode && isVdeoLink) {
@@ -658,6 +721,7 @@ async function processPicNode(node, warpObj, source) {
       height,
       rotate,
       src: videoFile,
+      order,
     }
   }
   if (audioNode) {
@@ -669,6 +733,7 @@ async function processPicNode(node, warpObj, source) {
       height,
       rotate,
       blob: audioBlob,
+      order,
     }
   }
   return {
@@ -680,7 +745,8 @@ async function processPicNode(node, warpObj, source) {
     rotate,
     src,
     isFlipV,
-    isFlipH
+    isFlipH,
+    order,
   }
 }
 
@@ -709,6 +775,7 @@ async function processGraphicFrameNode(node, warpObj, source) {
 }
 
 function genTable(node, warpObj) {
+  const order = node['attrs']['order']
   const tableNode = getTextByPathList(node, ['a:graphic', 'a:graphicData', 'a:tbl'])
   const xfrmNode = getTextByPathList(node, ['p:xfrm'])
   const { top, left } = getPosition(xfrmNode, undefined, undefined)
@@ -878,11 +945,13 @@ function genTable(node, warpObj) {
     width,
     height,
     data,
+    order,
     ...(tbl_border || {}),
   }
 }
 
 async function genChart(node, warpObj) {
+  const order = node['attrs']['order']
   const xfrmNode = getTextByPathList(node, ['p:xfrm'])
   const { top, left } = getPosition(xfrmNode, undefined, undefined)
   const { width, height } = getSize(xfrmNode, undefined, undefined)
@@ -904,6 +973,7 @@ async function genChart(node, warpObj) {
     height,
     data: chart.data,
     chartType: chart.type,
+    order,
   }
   if (chart.marker !== undefined) data.marker = chart.marker
   if (chart.barDir !== undefined) data.barDir = chart.barDir
@@ -915,6 +985,7 @@ async function genChart(node, warpObj) {
 }
 
 function genDiagram(node, warpObj) {
+  const order = node['attrs']['order']
   const xfrmNode = getTextByPathList(node, ['p:xfrm'])
   const { left, top } = getPosition(xfrmNode, undefined, undefined)
   const { width, height } = getSize(xfrmNode, undefined, undefined)
@@ -935,5 +1006,6 @@ function genDiagram(node, warpObj) {
     width,
     height,
     elements,
+    order,
   }
 }

package/src/readXmlFile.js

@@ -19,11 +19,15 @@ export function simplifyLostLess(children, parentAttributes = {}) {
     if (!out[child.tagName]) out[child.tagName] = []
 
     const kids = simplifyLostLess(child.children || [], child.attributes)
-    out[child.tagName].push(kids)
-
-    if (Object.keys(child.attributes).length) {
-      kids.attrs = { order: cust_attr_order++, ...child.attributes }
+    
+    if (typeof kids === 'object') {
+      if (!kids.attrs) kids.attrs = { order: cust_attr_order++ }
+      else kids.attrs.order = cust_attr_order++
     }
+    if (Object.keys(child.attributes || {}).length) {
+      kids.attrs = { ...kids.attrs, ...child.attributes }
+    }
+    out[child.tagName].push(kids)
   }
   for (const child in out) {
     if (out[child].length === 1) out[child] = out[child][0]

package/src/utils.js

@@ -150,4 +150,13 @@ export function toHex(n) {
     hex = '0' + hex
   }
   return hex
+}
+
+export function hasValidText(htmlString) {
+  if (!DOMParser) return true
+
+  const parser = new DOMParser()
+  const doc = parser.parseFromString(htmlString, 'text/html')
+  const text = doc.body.textContent || doc.body.innerText
+  return text.trim() !== ''
 }