pptxtojson 0.0.10 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pptxtojson",
-	"version": "0.0.10",
+	"version": "0.0.11",
 	"description": "A javascript tool for parsing .pptx file",
 	"type": "module",
 	"main": "./dist/index.umd.js",

package/src/pptxtojson.js

@@ -76,8 +76,8 @@ async function readXmlFile(zip, filename) {
 async function getContentTypes(zip) {
   const ContentTypesJson = await readXmlFile(zip, '[Content_Types].xml')
   const subObj = ContentTypesJson['Types']['Override']
-  const slidesLocArray = []
-  const slideLayoutsLocArray = []
+  let slidesLocArray = []
+  let slideLayoutsLocArray = []
 
   for (const item of subObj) {
     switch (item['attrs']['ContentType']) {
@@ -90,6 +90,15 @@ async function getContentTypes(zip) {
       default:
     }
   }
+  
+  const sortSlideXml = (p1, p2) => {
+    const n1 = +/(\d+)\.xml/.exec(p1)[1]
+    const n2 = +/(\d+)\.xml/.exec(p2)[1]
+    return n1 - n2
+  }
+  slidesLocArray = slidesLocArray.sort(sortSlideXml)
+  slideLayoutsLocArray = slideLayoutsLocArray.sort(sortSlideXml)
+  
   return {
     slides: slidesLocArray,
     slideLayouts: slideLayoutsLocArray,
@@ -196,6 +205,8 @@ async function processSingleSlide(zip, sldFileName) {
   const slideMasterResFilename = masterFilename.replace('slideMasters/slideMaster', 'slideMasters/_rels/slideMaster') + '.rels'
   const slideMasterResContent = await readXmlFile(zip, slideMasterResFilename)
   relationshipArray = slideMasterResContent['Relationships']['Relationship']
+
+  let themeFilename = ''
   const masterResObj = {}
   if (relationshipArray.constructor === Array) {
     for (const relationshipArrayItem of relationshipArray) {
@@ -210,6 +221,35 @@ async function processSingleSlide(zip, sldFileName) {
       }
     }
   }
+  else {
+    themeFilename = relationshipArray['attrs']['Target'].replace('../', 'ppt/')
+  }
+
+  const themeResObj = {}
+  if (themeFilename) {
+    const themeName = themeFilename.split('/').pop()
+    const themeResFileName = themeFilename.replace(themeName, '_rels/' + themeName) + '.rels'
+    const themeResContent = await readXmlFile(zip, themeResFileName)
+    if (themeResContent) {
+      relationshipArray = themeResContent['Relationships']['Relationship']
+      if (relationshipArray) {
+        if (relationshipArray.constructor === Array) {
+          for (const relationshipArrayItem of relationshipArray) {
+            themeResObj[relationshipArrayItem['attrs']['Id']] = {
+              'type': relationshipArrayItem['attrs']['Type'].replace('http://schemas.openxmlformats.org/officeDocument/2006/relationships/', ''),
+              'target': relationshipArrayItem['attrs']['Target'].replace('../', 'ppt/')
+            }
+          }
+        } 
+        else {
+          themeResObj[relationshipArray['attrs']['Id']] = {
+            'type': relationshipArray['attrs']['Type'].replace('http://schemas.openxmlformats.org/officeDocument/2006/relationships/', ''),
+            'target': relationshipArray['attrs']['Target'].replace('../', 'ppt/')
+          }
+        }
+      }
+    }
+  }
 
   const diagramResObj = {}
   let digramFileContent = {}
@@ -257,6 +297,7 @@ async function processSingleSlide(zip, sldFileName) {
     layoutResObj: layoutResObj,
     masterResObj: masterResObj,
     themeContent: themeContent,
+    themeResObj: themeResObj,
     digramFileContent: digramFileContent,
     diagramResObj: diagramResObj,
     defaultTextStyle: defaultTextStyle,
@@ -343,6 +384,9 @@ async function processNodesInSlide(nodeKey, nodeValue, warpObj) {
     case 'p:grpSp':
       json = await processGroupSpNode(nodeValue, warpObj)
       break
+    case 'mc:AlternateContent':
+      json = await processGroupSpNode(getTextByPathList(nodeValue, ['mc:Fallback']), warpObj)
+      break
     default:
   }
 
@@ -420,8 +464,55 @@ function processSpNode(node, warpObj) {
 function processCxnSpNode(node, warpObj) {
   const id = node['p:nvCxnSpPr']['p:cNvPr']['attrs']['id']
   const name = node['p:nvCxnSpPr']['p:cNvPr']['attrs']['name']
+  const idx = (node['p:nvCxnSpPr']['p:nvPr']['p:ph'] === undefined) ? undefined : node['p:nvSpPr']['p:nvPr']['p:ph']['attrs']['idx']
+  const type = (node['p:nvCxnSpPr']['p:nvPr']['p:ph'] === undefined) ? undefined : node['p:nvSpPr']['p:nvPr']['p:ph']['attrs']['type']
+
+  return genShape(node, undefined, undefined, id, name, idx, type, warpObj)
+}
+
+function shapeArc(cX, cY, rX, rY, stAng, endAng, isClose) {
+  let dData
+  let angle = stAng
+  if (endAng >= stAng) {
+    while (angle <= endAng) {
+      const radians = angle * (Math.PI / 180)
+      const x = cX + Math.cos(radians) * rX
+      const y = cY + Math.sin(radians) * rY
+      if (angle === stAng) {
+        dData = ' M' + x + ' ' + y
+      }
+      dData += ' L' + x + ' ' + y
+      angle++
+    }
+  } 
+  else {
+    while (angle > endAng) {
+      const radians = angle * (Math.PI / 180)
+      const x = cX + Math.cos(radians) * rX
+      const y = cY + Math.sin(radians) * rY
+      if (angle === stAng) {
+        dData = ' M ' + x + ' ' + y
+      }
+      dData += ' L ' + x + ' ' + y
+      angle--
+    }
+  }
+  dData += (isClose ? ' z' : '')
+  return dData
+}
 
-  return genShape(node, undefined, undefined, id, name, undefined, undefined, warpObj)
+function getVerticalAlign(node, slideLayoutSpNode, slideMasterSpNode) {
+  let anchor = getTextByPathList(node, ['p:txBody', 'a:bodyPr', 'attrs', 'anchor'])
+  if (anchor) {
+    anchor = getTextByPathList(slideLayoutSpNode, ['p:txBody', 'a:bodyPr', 'attrs', 'anchor'])
+    if (anchor) {
+      anchor = getTextByPathList(slideMasterSpNode, ['p:txBody', 'a:bodyPr', 'attrs', 'anchor'])
+      if (anchor) {
+        anchor = 't'
+      }
+    }
+  }
+  return (anchor === 'ctr') ? 'mid' : ((anchor === 'b') ? 'down' : 'up')
 }
 
 function genShape(node, slideLayoutSpNode, slideMasterSpNode, id, name, idx, type, warpObj) {
@@ -431,6 +522,7 @@ function genShape(node, slideLayoutSpNode, slideMasterSpNode, id, name, idx, typ
   const slideMasterXfrmNode = getTextByPathList(slideMasterSpNode, xfrmList)
 
   const shapType = getTextByPathList(node, ['p:spPr', 'a:prstGeom', 'attrs', 'prst'])
+  const custShapType = getTextByPathList(node, ['p:spPr', 'a:custGeom'])
 
   const { top, left } = getPosition(slideXfrmNode, slideLayoutXfrmNode, slideMasterXfrmNode)
   const { width, height } = getSize(slideXfrmNode, slideLayoutXfrmNode, slideMasterXfrmNode)
@@ -460,6 +552,193 @@ function genShape(node, slideLayoutSpNode, slideMasterSpNode, id, name, idx, typ
   const { borderColor, borderWidth, borderType } = getBorder(node, type)
   const fillColor = getShapeFill(node) || ''
 
+  const vAlign = getVerticalAlign(node, slideLayoutSpNode, slideMasterSpNode, type)
+
+  if (custShapType) {
+    const pathLstNode = getTextByPathList(custShapType, ['a:pathLst'])
+    const pathNodes = getTextByPathList(pathLstNode, ['a:path'])
+    const maxX = parseInt(pathNodes['attrs']['w'])
+    const maxY = parseInt(pathNodes['attrs']['h'])
+    const ext = getTextByPathList(slideXfrmNode, ['a:ext', 'attrs'])
+    const cx = parseInt(ext['cx']) * FACTOR
+    const cy = parseInt(ext['cy']) * FACTOR
+    const w = parseInt(ext['cx']) * FACTOR
+    const h = parseInt(ext['cy']) * FACTOR
+    const cX = (1 / maxX) * w
+    const cY = (1 / maxY) * h
+    let d = ''
+
+    let moveToNode = getTextByPathList(pathNodes, ['a:moveTo'])
+
+    const lnToNodes = pathNodes['a:lnTo']
+    let cubicBezToNodes = pathNodes['a:cubicBezTo']
+    const arcToNodes = pathNodes['a:arcTo']
+    let closeNode = getTextByPathList(pathNodes, ['a:close'])
+    if (!Array.isArray(moveToNode)) {
+      moveToNode = [moveToNode]
+    }
+
+    const multiSapeAry = []
+    if (moveToNode.length > 0) {
+      // a:moveTo
+      Object.keys(moveToNode).forEach(key => {
+        const moveToPtNode = moveToNode[key]['a:pt']
+        if (moveToPtNode) {
+          Object.keys(moveToPtNode).forEach(key2 => {
+            const moveToNoPt = moveToPtNode[key2]
+            const spX = moveToNoPt['attrs', 'x']
+            const spY = moveToNoPt['attrs', 'y']
+            
+            multiSapeAry.push({
+              type: 'movto',
+              x: spX,
+              y: spY,
+            })
+          })
+        }
+      })
+      // a:lnTo
+      if (lnToNodes) {
+        Object.keys(lnToNodes).forEach(key => {
+          const lnToPtNode = lnToNodes[key]['a:pt']
+          if (lnToPtNode) {
+            Object.keys(lnToPtNode).forEach(key2 => {
+              const lnToNoPt = lnToPtNode[key2]
+              const ptX = lnToNoPt['attrs', 'x']
+              const ptY = lnToNoPt['attrs', 'y']
+              multiSapeAry.push({
+                type: 'lnto',
+                x: ptX,
+                y: ptY,
+              })
+            })
+          }
+        })
+      }
+      // a:cubicBezTo
+      if (cubicBezToNodes) {
+
+        const cubicBezToPtNodesAry = []
+        if (!Array.isArray(cubicBezToNodes)) {
+          cubicBezToNodes = [cubicBezToNodes]
+        }
+        Object.keys(cubicBezToNodes).forEach(key => {
+          cubicBezToPtNodesAry.push(cubicBezToNodes[key]['a:pt'])
+        })
+
+        cubicBezToPtNodesAry.forEach(key2 => {
+          const pts_ary = []
+          key2.forEach(pt => {
+            const pt_obj = {
+              x: pt['attrs']['x'],
+              y: pt['attrs']['y'],
+            }
+            pts_ary.push(pt_obj)
+          })
+          multiSapeAry.push({
+            type: 'cubicBezTo',
+            cubBzPt: pts_ary
+          })
+        })
+      }
+      // a:arcTo
+      if (arcToNodes) {
+        const arcToNodesAttrs = arcToNodes['attrs']
+        const hR = arcToNodesAttrs['hR']
+        const wR = arcToNodesAttrs['wR']
+        const stAng = arcToNodesAttrs['stAng']
+        const swAng = arcToNodesAttrs['swAng']
+        let shftX = 0
+        let shftY = 0
+        const arcToPtNode = getTextByPathList(arcToNodes, ['a:pt', 'attrs'])
+        if (arcToPtNode) {
+          shftX = arcToPtNode['x']
+          shftY = arcToPtNode['y']
+        }
+        
+        multiSapeAry.push({
+          type: 'arcTo',
+          hR: hR,
+          wR: wR,
+          stAng: stAng,
+          swAng: swAng,
+          shftX: shftX,
+          shftY: shftY,
+        })
+
+      }
+      // a:close
+      if (closeNode) {
+        if (!Array.isArray(closeNode)) closeNode = [closeNode]
+        Object.keys(closeNode).forEach(() => {
+          multiSapeAry.push({
+            type: 'close',
+          })
+        })
+      }
+
+      let k = 0
+      while (k < multiSapeAry.length) {
+
+        if (multiSapeAry[k].type === 'movto') {
+          const spX = parseInt(multiSapeAry[k].x) * cX
+          const spY = parseInt(multiSapeAry[k].y) * cY
+          d += ' M' + spX + ',' + spY
+        } 
+        else if (multiSapeAry[k].type === 'lnto') {
+          const Lx = parseInt(multiSapeAry[k].x) * cX
+          const Ly = parseInt(multiSapeAry[k].y) * cY
+          d += ' L' + Lx + ',' + Ly
+        } 
+        else if (multiSapeAry[k].type === 'cubicBezTo') {
+          const Cx1 = parseInt(multiSapeAry[k].cubBzPt[0].x) * cX
+          const Cy1 = parseInt(multiSapeAry[k].cubBzPt[0].y) * cY
+          const Cx2 = parseInt(multiSapeAry[k].cubBzPt[1].x) * cX
+          const Cy2 = parseInt(multiSapeAry[k].cubBzPt[1].y) * cY
+          const Cx3 = parseInt(multiSapeAry[k].cubBzPt[2].x) * cX
+          const Cy3 = parseInt(multiSapeAry[k].cubBzPt[2].y) * cY
+          d += ' C' + Cx1 + ',' + Cy1 + ' ' + Cx2 + ',' + Cy2 + ' ' + Cx3 + ',' + Cy3
+        } 
+        else if (multiSapeAry[k].type === 'arcTo') {
+          const hR = parseInt(multiSapeAry[k].hR) * cX
+          const wR = parseInt(multiSapeAry[k].wR) * cY
+          const stAng = parseInt(multiSapeAry[k].stAng) / 60000
+          const swAng = parseInt(multiSapeAry[k].swAng) / 60000
+          const endAng = stAng + swAng
+          d += shapeArc(wR, hR, wR, hR, stAng, endAng, false)
+        }
+        else if (multiSapeAry[k].type === 'close') {
+          d += 'z'
+        }
+        k++
+      }
+    }
+
+    return {
+      type: 'shape',
+      left,
+      top,
+      width,
+      height,
+      cx,
+      cy,
+      borderColor,
+      borderWidth,
+      borderType,
+      fillColor,
+      content,
+      isFlipV,
+      isFlipH,
+      rotate,
+      shapType: 'custom',
+      vAlign,
+      path: d,
+      id,
+      name,
+      idx,
+    }
+  }
+
   if (shapType) {
     const ext = getTextByPathList(slideXfrmNode, ['a:ext', 'attrs'])
     const cx = parseInt(ext['cx']) * FACTOR
@@ -482,6 +761,7 @@ function genShape(node, slideLayoutSpNode, slideMasterSpNode, id, name, idx, typ
       isFlipH,
       rotate,
       shapType,
+      vAlign,
       id,
       name,
       idx,
@@ -502,6 +782,7 @@ function genShape(node, slideLayoutSpNode, slideMasterSpNode, id, name, idx, typ
     isFlipH,
     rotate: txtRotate,
     content,
+    vAlign,
     id,
     name,
     idx,
@@ -515,28 +796,8 @@ async function processPicNode(node, warpObj) {
   const zip = warpObj['zip']
   const imgArrayBuffer = await zip.file(imgName).async('arraybuffer')
   const xfrmNode = node['p:spPr']['a:xfrm']
-  let mimeType = ''
 
-  switch (imgFileExt) {
-    case 'jpg':
-    case 'jpeg':
-      mimeType = 'image/jpeg'
-      break
-    case 'png':
-      mimeType = 'image/png'
-      break
-    case 'gif':
-      mimeType = 'image/gif'
-      break
-    case 'emf':
-      mimeType = 'image/x-emf'
-      break
-    case 'wmf':
-      mimeType = 'image/x-wmf'
-      break
-    default:
-      mimeType = 'image/*'
-  }
+  const mimeType = getMimeType(imgFileExt)
   const { top, left } = getPosition(xfrmNode, undefined, undefined)
   const { width, height } = getSize(xfrmNode, undefined, undefined)
   const src = `data:${mimeType};base64,${base64ArrayBuffer(imgArrayBuffer)}`
@@ -570,6 +831,11 @@ async function processGraphicFrameNode(node, warpObj) {
     case 'http://schemas.openxmlformats.org/drawingml/2006/diagram':
       result = genDiagram(node, warpObj)
       break
+    case 'http://schemas.openxmlformats.org/presentationml/2006/ole':
+      let oleObjNode = getTextByPathList(node, ['a:graphic', 'a:graphicData', 'mc:AlternateContent', 'mc:Fallback', 'p:oleObj'])
+      if (!oleObjNode) oleObjNode = getTextByPathList(node, ['a:graphic', 'a:graphicData', 'p:oleObj'])
+      else processGroupSpNode(oleObjNode, warpObj)
+      break
     default:
   }
   return result
@@ -587,7 +853,26 @@ function genTextBody(textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, w
   let isList = ''
 
   for (const pNode of pNodes) {
-    const rNode = pNode['a:r']
+    let rNode = pNode['a:r']
+    let fldNode = pNode['a:fld']
+    let brNode = pNode['a:br']
+    if (rNode) {
+      rNode = (rNode.constructor === Array) ? rNode : [rNode]
+
+      if (fldNode) {
+        fldNode = (fldNode.constructor === Array) ? fldNode : [fldNode]
+        rNode = rNode.concat(fldNode)
+      }
+      if (brNode) {
+        brNode = (brNode.constructor === Array) ? brNode : [brNode]
+        brNode.forEach(item => item.type = 'br')
+  
+        if (brNode.length > 1) brNode.shift()
+        rNode = rNode.concat(brNode)
+        rNode.sort((a, b) => a.attrs.order - b.attrs.order)
+      }
+    }
+
     const align = getHorizontalAlign(pNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles)
 
     const listType = getListType(pNode)
@@ -601,21 +886,22 @@ function genTextBody(textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, w
         text += `<${listType}>`
         isList = listType
       }
-      text += `<li style="text-align: ${align}; color: ${type === 'text' ? '#000000' : '#ffffff'}">`
+      text += `<li style="text-align: ${align};">`
     }
     else {
       if (isList) {
         text += `</${isList}>`
         isList = ''
       }
-      text += `<p style="text-align: ${align}; color: ${type === 'text' ? '#000000' : '#ffffff'}">`
+      text += `<p style="text-align: ${align};">`
     }
     
     if (!rNode) text += genSpanElement(pNode, slideLayoutSpNode, type, warpObj)
-    else if (rNode.constructor === Array) {
-      for (const rNodeItem of rNode) text += genSpanElement(rNodeItem, slideLayoutSpNode, type, warpObj)
-    } 
-    else text += genSpanElement(rNode, slideLayoutSpNode, type, warpObj)
+    else {
+      for (const rNodeItem of rNode) {
+        text += genSpanElement(rNodeItem, slideLayoutSpNode, type, warpObj)
+      }
+    }
 
     if (listType) text += '</li>'
     else text += '</p>'
@@ -1083,6 +1369,37 @@ async function getBgPicFill(bgPr, sorce, warpObj) {
   }
 }
 
+function getBgGradientFill(bgPr, phClr, slideMasterContent, warpObj) {
+  if (bgPr) {
+    const grdFill = bgPr['a:gradFill']
+    const gsLst = grdFill['a:gsLst']['a:gs']
+    const color_ary = []
+    const pos_ary = []
+    
+    for (let i = 0; i < gsLst.length; i++) {
+      const lo_color = getSolidFill(gsLst[i], slideMasterContent['p:sldMaster']['p:clrMap']['attrs'], phClr, warpObj)
+      const pos = getTextByPathList(gsLst[i], ['attrs', 'pos'])
+      
+      if (pos) pos_ary[i] = pos / 1000 + '%'
+      else pos_ary[i] = ''
+      color_ary[i] = `#${lo_color}`
+    }
+    const lin = grdFill['a:lin']
+    let rot = 90
+    if (lin) {
+      rot = angleToDegrees(lin['attrs']['ang'])
+      rot = rot + 90
+    }
+    return {
+      rot,
+      colors: color_ary,
+      pos: pos_ary,
+    }
+  }
+  else if (phClr) return `#${phClr}`
+  return null
+}
+
 async function getSlideBackgroundFill(warpObj) {
   const slideContent = warpObj['slideContent']
   const slideLayoutContent = warpObj['slideLayoutContent']
@@ -1109,6 +1426,16 @@ async function getSlideBackgroundFill(warpObj) {
       const sldBgClr = getSolidFill(sldFill, clrMapOvr, undefined, warpObj)
       background = `#${sldBgClr}`
     }
+    else if (bgFillTyp === 'GRADIENT_FILL') {
+      const gradientFill = getBgGradientFill(bgPr, undefined, slideMasterContent, warpObj)
+      if (typeof gradientFill === 'string') {
+        background = gradientFill
+      }
+      else if (gradientFill) {
+        background = gradientFill
+        backgroundType = 'gradient'
+      }
+    }
     else if (bgFillTyp === 'PIC_FILL') {
       background = await getBgPicFill(bgPr, 'slideBg', warpObj)
       backgroundType = 'image'
@@ -1129,6 +1456,16 @@ async function getSlideBackgroundFill(warpObj) {
         const sldBgClr = getSolidFill(sldFill, clrMapOvr, undefined, warpObj)
         background = `#${sldBgClr}`
       }
+      else if (bgFillTyp === 'GRADIENT_FILL') {
+        const gradientFill = getBgGradientFill(bgPr, undefined, slideMasterContent, warpObj)
+        if (typeof gradientFill === 'string') {
+          background = gradientFill
+        }
+        else if (gradientFill) {
+          background = gradientFill
+          backgroundType = 'gradient'
+        }
+      }
       else if (bgFillTyp === 'PIC_FILL') {
         background = await getBgPicFill(bgPr, 'slideLayoutBg', warpObj)
         backgroundType = 'image'
@@ -1145,6 +1482,16 @@ async function getSlideBackgroundFill(warpObj) {
           const sldBgClr = getSolidFill(sldFill, clrMap, undefined, warpObj)
           background = `#${sldBgClr}`
         }
+        else if (bgFillTyp === 'GRADIENT_FILL') {
+          const gradientFill = getBgGradientFill(bgPr, undefined, slideMasterContent, warpObj)
+          if (typeof gradientFill === 'string') {
+            background = gradientFill
+          }
+          else if (gradientFill) {
+            background = gradientFill
+            backgroundType = 'gradient'
+          }
+        }
         else if (bgFillTyp === 'PIC_FILL') {
           background = await getBgPicFill(bgPr, 'slideMasterBg', warpObj)
           backgroundType = 'image'
@@ -1291,4 +1638,4 @@ function extractChartData(serNode) {
   }
 
   return dataMat
-}
+}