pptxtojson 1.0.3 → 1.1.0

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.0",
 	"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

@@ -11,6 +11,7 @@ import { extractFileExtension, base64ArrayBuffer, getTextByPathList, angleToDegr
 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,6 +430,24 @@ async function processNodesInSlide(nodeKey, nodeValue, warpObj, source) {
   return json
 }
 
+function processMathNode(node) {
+  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,
+  }
+}
+
 async function processGroupSpNode(node, warpObj, source) {
   const xfrmNode = getTextByPathList(node, ['p:grpSpPr', 'a:xfrm'])
   if (!xfrmNode) return null