pptxtojson 0.0.12 → 0.1.0

package/src/readXmlFile.js

@@ -0,0 +1,41 @@
+import * as txml from 'txml/dist/txml.mjs'
+
+export function simplifyLostLess(children, parentAttributes = {}) {
+  const out = {}
+  if (!children.length) return out
+
+  if (children.length === 1 && typeof children[0] === 'string') {
+    return Object.keys(parentAttributes).length ? {
+      attrs: parentAttributes,
+      value: children[0],
+    } : children[0]
+  }
+  for (const child of children) {
+    if (typeof child !== 'object') return
+    if (child.tagName === '?xml') continue
+
+    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 = child.attributes
+    }
+  }
+  for (const child in out) {
+    if (out[child].length === 1) out[child] = out[child][0]
+  }
+
+  return out
+}
+
+export async function readXmlFile(zip, filename) {
+  try {
+    const data = await zip.file(filename).async('string')
+    return simplifyLostLess(txml.parse(data))
+  }
+  catch {
+    return null
+  }
+}

package/src/schemeColor.js

@@ -0,0 +1,24 @@
+import { getTextByPathList } from './utils'
+
+export function getSchemeColorFromTheme(schemeClr, warpObj) {
+  switch (schemeClr) {
+    case 'tx1':
+      schemeClr = 'a:dk1'
+      break
+    case 'tx2':
+      schemeClr = 'a:dk2'
+      break
+    case 'bg1':
+      schemeClr = 'a:lt1'
+      break
+    case 'bg2':
+      schemeClr = 'a:lt2'
+      break
+    default:
+      break
+  }
+  const refNode = getTextByPathList(warpObj['themeContent'], ['a:theme', 'a:themeElements', 'a:clrScheme', schemeClr])
+  let color = getTextByPathList(refNode, ['a:srgbClr', 'attrs', 'val'])
+  if (!color && refNode) color = getTextByPathList(refNode, ['a:sysClr', 'attrs', 'lastClr'])
+  return color
+}

package/src/shadow.js

@@ -0,0 +1,18 @@
+import { getSolidFill } from './fill'
+
+export function getShadow(node, warpObj, slideFactor) {
+  const chdwClrNode = getSolidFill(node, undefined, undefined, warpObj)
+  const outerShdwAttrs = node['attrs']
+  const dir = (outerShdwAttrs['dir']) ? (parseInt(outerShdwAttrs['dir']) / 60000) : 0
+  const dist = parseInt(outerShdwAttrs['dist']) * slideFactor
+  const blurRad = outerShdwAttrs['blurRad'] ? (parseInt(outerShdwAttrs['blurRad']) * slideFactor) : ''
+  const vx = dist * Math.sin(dir * Math.PI / 180)
+  const hx = dist * Math.cos(dir * Math.PI / 180)
+
+  return {
+    h: hx,
+    v: vx,
+    blur: blurRad,
+    color: '#' + chdwClrNode,
+  }
+}

package/src/shape.js

@@ -0,0 +1,178 @@
+import { getTextByPathList } from './utils'
+
+export 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
+}
+
+export function getCustomShapePath(custShapType, w, h) {
+  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 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) {
+    Object.keys(moveToNode).forEach(key => {
+      const moveToPtNode = moveToNode[key]['a:pt']
+      if (moveToPtNode) {
+        Object.keys(moveToPtNode).forEach(key => {
+          const moveToNoPt = moveToPtNode[key]
+          const spX = moveToNoPt['attrs', 'x']
+          const spY = moveToNoPt['attrs', 'y']
+          
+          multiSapeAry.push({
+            type: 'movto',
+            x: spX,
+            y: spY,
+          })
+        })
+      }
+    })
+    if (lnToNodes) {
+      Object.keys(lnToNodes).forEach(key => {
+        const lnToPtNode = lnToNodes[key]['a:pt']
+        if (lnToPtNode) {
+          Object.keys(lnToPtNode).forEach(key => {
+            const lnToNoPt = lnToPtNode[key]
+            const ptX = lnToNoPt['attrs', 'x']
+            const ptY = lnToNoPt['attrs', 'y']
+            multiSapeAry.push({
+              type: 'lnto',
+              x: ptX,
+              y: ptY,
+            })
+          })
+        }
+      })
+    }
+    if (cubicBezToNodes) {
+      const cubicBezToPtNodesAry = []
+      if (!Array.isArray(cubicBezToNodes)) {
+        cubicBezToNodes = [cubicBezToNodes]
+      }
+      Object.keys(cubicBezToNodes).forEach(key => {
+        cubicBezToPtNodesAry.push(cubicBezToNodes[key]['a:pt'])
+      })
+
+      cubicBezToPtNodesAry.forEach(key => {
+        const pts_ary = []
+        key.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
+        })
+      })
+    }
+    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,
+      })
+    }
+    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 d
+}

package/src/text.js

@@ -0,0 +1,131 @@
+import { getHorizontalAlign } from './align'
+import { getTextByPathList } from './utils'
+
+import {
+  getFontType,
+  getFontColor,
+  getFontSize,
+  getFontBold,
+  getFontItalic,
+  getFontDecoration,
+  getFontSpace,
+  getFontSubscript,
+  getFontShadow,
+} from './fontStyle'
+
+export function genTextBody(textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, warpObj, fontsizeFactor, slideFactor) {
+  if (!textBodyNode) return ''
+
+  let text = ''
+  const slideMasterTextStyles = warpObj['slideMasterTextStyles']
+
+  const pNode = textBodyNode['a:p']
+  const pNodes = pNode.constructor === Array ? pNode : [pNode]
+
+  let isList = ''
+
+  for (const pNode of pNodes) {
+    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) => {
+          if (!a.attrs || !b.attrs) return true
+          return a.attrs.order - b.attrs.order
+        })
+      }
+    }
+
+    const align = getHorizontalAlign(pNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles)
+
+    const listType = getListType(pNode)
+    if (listType) {
+      if (!isList) {
+        text += `<${listType}>`
+        isList = listType
+      }
+      else if (isList && isList !== listType) {
+        text += `</${isList}>`
+        text += `<${listType}>`
+        isList = listType
+      }
+      text += `<li style="text-align: ${align};">`
+    }
+    else {
+      if (isList) {
+        text += `</${isList}>`
+        isList = ''
+      }
+      text += `<p style="text-align: ${align};">`
+    }
+    
+    if (!rNode) text += genSpanElement(pNode, slideLayoutSpNode, type, warpObj, fontsizeFactor, slideFactor)
+    else {
+      for (const rNodeItem of rNode) {
+        text += genSpanElement(rNodeItem, slideLayoutSpNode, type, warpObj, fontsizeFactor, slideFactor)
+      }
+    }
+
+    if (listType) text += '</li>'
+    else text += '</p>'
+  }
+  return text
+}
+
+export function getListType(node) {
+  const pPrNode = node['a:pPr']
+  if (!pPrNode) return ''
+
+  if (pPrNode['a:buChar']) return 'ul'
+  if (pPrNode['a:buAutoNum']) return 'ol'
+  
+  return ''
+}
+
+export function genSpanElement(node, slideLayoutSpNode, type, warpObj, fontsizeFactor, slideFactor) {
+  const slideMasterTextStyles = warpObj['slideMasterTextStyles']
+
+  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 fontSize = getFontSize(node, slideLayoutSpNode, type, slideMasterTextStyles, fontsizeFactor)
+  const fontType = getFontType(node, type, warpObj)
+  const fontBold = getFontBold(node)
+  const fontItalic = getFontItalic(node)
+  const fontDecoration = getFontDecoration(node)
+  const fontSpace = getFontSpace(node, fontsizeFactor)
+  const shadow = getFontShadow(node, warpObj, slideFactor)
+  const subscript = getFontSubscript(node)
+
+  if (fontColor) styleText += `color: ${fontColor};`
+  if (fontSize) styleText += `font-size: ${fontSize};`
+  if (fontType) styleText += `font-family: ${fontType};`
+  if (fontBold) styleText += `font-weight: ${fontBold};`
+  if (fontItalic) styleText += `font-style: ${fontItalic};`
+  if (fontDecoration) styleText += `text-decoration: ${fontDecoration};`
+  if (fontSpace) styleText += `letter-spacing: ${fontSpace};`
+  if (subscript) styleText += `vertical-align: ${subscript}; font-size: smaller;`
+  if (shadow) styleText += `text-shadow: ${shadow};`
+
+  const linkID = getTextByPathList(node, ['a:rPr', 'a:hlinkClick', 'attrs', 'r:id'])
+  if (linkID) {
+    const linkURL = warpObj['slideResObj'][linkID]['target']
+    return `<span style="${styleText}"><a href="${linkURL}" target="_blank">${text.replace(/\s/i, '&nbsp;')}</a></span>`
+  } 
+  return `<span style="${styleText}">${text.replace(/\s/i, '&nbsp;')}</span>`
+}

package/src/utils.js

@@ -39,16 +39,16 @@ export function extractFileExtension(filename) {
   return filename.substr((~-filename.lastIndexOf('.') >>> 0) + 2)
 }
 
-export function eachElement(node, doFunction) {
+export function eachElement(node, func) {
   if (!node) return node
 
   let result = ''
   if (node.constructor === Array) {
     for (let i = 0; i < node.length; i++) {
-      result += doFunction(node[i], i)
+      result += func(node[i], i)
     }
   } 
-  else result += doFunction(node, 0)
+  else result += func(node, 0)
 
   return result
 }
@@ -135,4 +135,17 @@ export function getMimeType(imgFileExt) {
     default:
   }
   return mimeType
+}
+
+export function isVideoLink(vdoFile) {
+  const urlRegex = /^(https?|ftp):\/\/([a-zA-Z0-9.-]+(:[a-zA-Z0-9.&%$-]+)*@)*((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+\.(com|edu|gov|int|mil|net|org|biz|arpa|info|name|pro|aero|coop|museum|[a-zA-Z]{2}))(:[0-9]+)*(\/($|[a-zA-Z0-9.,?'\\+&%$#=~_-]+))*$/
+  return urlRegex.test(vdoFile)
+}
+
+export function toHex(n) {
+  let hex = n.toString(16)
+  while (hex.length < 2) {
+    hex = '0' + hex
+  }
+  return hex
 }