pptxtojson 1.0.2 → 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.2",
+	"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/fill.js

@@ -452,9 +452,9 @@ export function getShapeFill(node, isSvgMode, warpObj) {
 }
 
 export function getSolidFill(solidFill, clrMap, phClr, warpObj) {
-  if (!solidFill) return solidFill
+  if (!solidFill) return ''
 
-  let color = '#ffffff'
+  let color = ''
   let clrNode
 
   if (solidFill['a:srgbClr']) {
@@ -464,7 +464,7 @@ export function getSolidFill(solidFill, clrMap, phClr, warpObj) {
   else if (solidFill['a:schemeClr']) {
     clrNode = solidFill['a:schemeClr']
     const schemeClr = 'a:' + getTextByPathList(clrNode, ['attrs', 'val'])
-    color = getSchemeColorFromTheme(schemeClr, warpObj, clrMap, phClr) || '#ffffff'
+    color = getSchemeColorFromTheme(schemeClr, warpObj, clrMap, phClr) || ''
   }
   else if (solidFill['a:scrgbClr']) {
     clrNode = solidFill['a:scrgbClr']

package/src/fontStyle.js

@@ -1,5 +1,6 @@
 import { getTextByPathList } from './utils'
 import { getShadow } from './shadow'
+import { getFillType, getSolidFill } from './fill'
 
 export function getFontType(node, type, warpObj) {
   let typeface = getTextByPathList(node, ['a:rPr', 'a:latin', 'attrs', 'typeface'])
@@ -21,9 +22,30 @@ export function getFontType(node, type, warpObj) {
   return typeface || ''
 }
 
-export function getFontColor(node) {
-  const color = getTextByPathList(node, ['a:rPr', 'a:solidFill', 'a:srgbClr', 'attrs', 'val'])
-  return color ? `#${color}` : ''
+export function getFontColor(node, pNode, lstStyle, pFontStyle, lvl, warpObj) {
+  const rPrNode = getTextByPathList(node, ['a:rPr'])
+  let filTyp, color
+  if (rPrNode) {
+    filTyp = getFillType(rPrNode)
+    if (filTyp === 'SOLID_FILL') {
+      const solidFillNode = rPrNode['a:solidFill']
+      color = getSolidFill(solidFillNode, undefined, undefined, warpObj)
+    }
+  }
+  if (!color && getTextByPathList(lstStyle, ['a:lvl' + lvl + 'pPr', 'a:defRPr'])) {
+    const lstStyledefRPr = getTextByPathList(lstStyle, ['a:lvl' + lvl + 'pPr', 'a:defRPr'])
+    filTyp = getFillType(lstStyledefRPr)
+    if (filTyp === 'SOLID_FILL') {
+      const solidFillNode = lstStyledefRPr['a:solidFill']
+      color = getSolidFill(solidFillNode, undefined, undefined, warpObj)
+    }
+  }
+  if (!color) {
+    const sPstyle = getTextByPathList(pNode, ['p:style', 'a:fontRef'])
+    if (sPstyle) color = getSolidFill(sPstyle, undefined, undefined, warpObj)
+    if (!color && pFontStyle) color = getSolidFill(pFontStyle, undefined, undefined, warpObj)
+  }
+  return color || ''
 }
 
 export function getFontSize(node, slideLayoutSpNode, type, slideMasterTextStyles) {

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
@@ -410,7 +460,10 @@ async function processGroupSpNode(node, warpObj, source) {
   const cy = parseInt(xfrmNode['a:ext']['attrs']['cy']) * RATIO_EMUs_Points
   const chcx = parseInt(xfrmNode['a:chExt']['attrs']['cx']) * RATIO_EMUs_Points
   const chcy = parseInt(xfrmNode['a:chExt']['attrs']['cy']) * RATIO_EMUs_Points
-  // children coordinate
+
+  let rotate = getTextByPathList(xfrmNode, ['attrs', 'rot']) || 0
+  if (rotate) rotate = angleToDegrees(rotate)
+
   const ws = cx / chcx
   const hs = cy / chcy
 
@@ -434,6 +487,7 @@ async function processGroupSpNode(node, warpObj, source) {
     left: x,
     width: cx,
     height: cy,
+    rotate,
     elements: elements.map(element => ({
       ...element,
       left: (element.left - chx) * ws,

package/src/table.js

@@ -3,7 +3,7 @@ import { getTextByPathList } from './utils'
 import { getBorder } from './border'
 
 export function getTableBorders(node, warpObj) {
-  let borderStyles = {}
+  const borderStyles = {}
   if (node['a:bottom']) {
     const obj = {
       'p:spPr': {

package/src/text.js

@@ -19,6 +19,8 @@ export function genTextBody(textBodyNode, spNode, slideLayoutSpNode, type, warpO
 
   let text = ''
 
+  const pFontStyle = getTextByPathList(spNode, ['p:style', 'a:fontRef'])
+
   const pNode = textBodyNode['a:p']
   const pNodes = pNode.constructor === Array ? pNode : [pNode]
 
@@ -71,10 +73,10 @@ export function genTextBody(textBodyNode, spNode, slideLayoutSpNode, type, warpO
       text += `<p style="text-align: ${align};">`
     }
     
-    if (!rNode) text += genSpanElement(pNode, slideLayoutSpNode, type, warpObj)
+    if (!rNode) text += genSpanElement(pNode, spNode, textBodyNode, pFontStyle, slideLayoutSpNode, type, warpObj)
     else {
       for (const rNodeItem of rNode) {
-        text += genSpanElement(rNodeItem, slideLayoutSpNode, type, warpObj)
+        text += genSpanElement(rNodeItem, pNode, textBodyNode, pFontStyle, slideLayoutSpNode, type, warpObj)
       }
     }
 
@@ -94,15 +96,21 @@ export function getListType(node) {
   return ''
 }
 
-export function genSpanElement(node, slideLayoutSpNode, type, warpObj) {
+export function genSpanElement(node, pNode, textBodyNode, pFontStyle, slideLayoutSpNode, type, warpObj) {
+  const lstStyle = textBodyNode['a:lstStyle']
   const slideMasterTextStyles = warpObj['slideMasterTextStyles']
 
+  let lvl = 1
+  const pPrNode = pNode['a:pPr']
+  const lvlNode = getTextByPathList(pPrNode, ['attrs', 'lvl'])
+  if (lvlNode !== undefined) lvl = parseInt(lvlNode) + 1
+
   let text = node['a:t']
   if (typeof text !== 'string') text = getTextByPathList(node, ['a:fld', 'a:t'])
   if (typeof text !== 'string') text = '&nbsp;'
 
   let styleText = ''
-  const fontColor = getFontColor(node)
+  const fontColor = getFontColor(node, pNode, lstStyle, pFontStyle, lvl, warpObj)
   const fontSize = getFontSize(node, slideLayoutSpNode, type, slideMasterTextStyles)
   const fontType = getFontType(node, type, warpObj)
   const fontBold = getFontBold(node)