pptxtojson 0.0.12 → 0.1.0

package/src/fill.js

@@ -0,0 +1,330 @@
+import tinycolor from 'tinycolor2'
+import { getSchemeColorFromTheme } from './schemeColor'
+import {
+  applyShade,
+  applyTint,
+  applyLumOff,
+  applyLumMod,
+  applyHueMod,
+  applySatMod,
+  hslToRgb,
+} from './color'
+
+import {
+  base64ArrayBuffer,
+  getTextByPathList,
+  angleToDegrees,
+  escapeHtml,
+  getMimeType,
+  toHex,
+} from './utils'
+
+export function getFillType(node) {
+  let fillType = ''
+  if (node['a:noFill']) fillType = 'NO_FILL'
+  if (node['a:solidFill']) fillType = 'SOLID_FILL'
+  if (node['a:gradFill']) fillType = 'GRADIENT_FILL'
+  if (node['a:pattFill']) fillType = 'PATTERN_FILL'
+  if (node['a:blipFill']) fillType = 'PIC_FILL'
+  if (node['a:grpFill']) fillType = 'GROUP_FILL'
+
+  return fillType
+}
+
+export async function getPicFill(type, node, warpObj) {
+  let img
+  const rId = node['a:blip']['attrs']['r:embed']
+  let imgPath
+  if (type === 'slideBg' || type === 'slide') {
+    imgPath = getTextByPathList(warpObj, ['slideResObj', rId, 'target'])
+  }
+  else if (type === 'slideLayoutBg') {
+    imgPath = getTextByPathList(warpObj, ['layoutResObj', rId, 'target'])
+  }
+  else if (type === 'slideMasterBg') {
+    imgPath = getTextByPathList(warpObj, ['masterResObj', rId, 'target'])
+  }
+  else if (type === 'themeBg') {
+    imgPath = getTextByPathList(warpObj, ['themeResObj', rId, 'target'])
+  }
+  if (!imgPath) return imgPath
+
+  img = getTextByPathList(warpObj, ['loaded-images', imgPath])
+  if (!img) {
+    imgPath = escapeHtml(imgPath)
+
+    const imgExt = imgPath.split('.').pop()
+    if (imgExt === 'xml') return undefined
+
+    const imgArrayBuffer = await warpObj['zip'].file(imgPath).async('arraybuffer')
+    const imgMimeType = getMimeType(imgExt)
+    img = `data:${imgMimeType};base64,${base64ArrayBuffer(imgArrayBuffer)}`
+  }
+  return img
+}
+
+export async function getBgPicFill(bgPr, sorce, warpObj) {
+  const picBase64 = await getPicFill(sorce, bgPr['a:blipFill'], warpObj)
+  const aBlipNode = bgPr['a:blipFill']['a:blip']
+
+  const aphaModFixNode = getTextByPathList(aBlipNode, ['a:alphaModFix', 'attrs'])
+  let opacity = 1
+  if (aphaModFixNode && aphaModFixNode['amt'] && aphaModFixNode['amt'] !== '') {
+    opacity = parseInt(aphaModFixNode['amt']) / 100000
+  }
+
+  return {
+    picBase64,
+    opacity,
+  }
+}
+
+export function getBgGradientFill(bgPr, phClr, slideMasterContent, warpObj) {
+  if (bgPr) {
+    const grdFill = bgPr['a:gradFill']
+    const gsLst = grdFill['a:gsLst']['a:gs']
+    const color_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'])
+
+      color_ary[i] = {
+        pos: pos ? (pos / 1000 + '%') : '',
+        color: `#${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.sort((a, b) => parseInt(a.pos) - parseInt(b.pos)),
+    }
+  }
+  else if (phClr) return `#${phClr}`
+  return null
+}
+
+export async function getSlideBackgroundFill(warpObj) {
+  const slideContent = warpObj['slideContent']
+  const slideLayoutContent = warpObj['slideLayoutContent']
+  const slideMasterContent = warpObj['slideMasterContent']
+  
+  let bgPr = getTextByPathList(slideContent, ['p:sld', 'p:cSld', 'p:bg', 'p:bgPr'])
+
+  let background = '#fff'
+  let backgroundType = 'color'
+
+  if (bgPr) {
+    const bgFillTyp = getFillType(bgPr)
+
+    if (bgFillTyp === 'SOLID_FILL') {
+      const sldFill = bgPr['a:solidFill']
+      let clrMapOvr
+      const sldClrMapOvr = getTextByPathList(slideContent, ['p:sld', 'p:clrMapOvr', 'a:overrideClrMapping', 'attrs'])
+      if (sldClrMapOvr) clrMapOvr = sldClrMapOvr
+      else {
+        const sldClrMapOvr = getTextByPathList(slideLayoutContent, ['p:sldLayout', 'p:clrMapOvr', 'a:overrideClrMapping', 'attrs'])
+        if (sldClrMapOvr) clrMapOvr = sldClrMapOvr
+        else clrMapOvr = getTextByPathList(slideMasterContent, ['p:sldMaster', 'p:clrMap', 'attrs'])
+      }
+      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'
+    }
+  }
+  else {
+    bgPr = getTextByPathList(slideLayoutContent, ['p:sldLayout', 'p:cSld', 'p:bg', 'p:bgPr'])
+
+    let clrMapOvr
+    const sldClrMapOvr = getTextByPathList(slideLayoutContent, ['p:sldLayout', 'p:clrMapOvr', 'a:overrideClrMapping', 'attrs'])
+    if (sldClrMapOvr) clrMapOvr = sldClrMapOvr
+    else clrMapOvr = getTextByPathList(slideMasterContent, ['p:sldMaster', 'p:clrMap', 'attrs'])
+
+    if (bgPr) {
+      const bgFillTyp = getFillType(bgPr)
+      if (bgFillTyp === 'SOLID_FILL') {
+        const sldFill = bgPr['a:solidFill']
+        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'
+      }
+    }
+    else {
+      bgPr = getTextByPathList(slideMasterContent, ['p:sldMaster', 'p:cSld', 'p:bg', 'p:bgPr'])
+
+      const clrMap = getTextByPathList(slideMasterContent, ['p:sldMaster', 'p:clrMap', 'attrs'])
+      if (bgPr) {
+        const bgFillTyp = getFillType(bgPr)
+        if (bgFillTyp === 'SOLID_FILL') {
+          const sldFill = bgPr['a:solidFill']
+          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'
+        }
+      }
+    }
+  }
+  return {
+    type: backgroundType,
+    value: background,
+  }
+}
+
+export function getShapeFill(node, isSvgMode, warpObj) {
+  if (getTextByPathList(node, ['p:spPr', 'a:noFill'])) {
+    return isSvgMode ? 'none' : ''
+  }
+
+  let fillColor
+  if (!fillColor) {
+    fillColor = getTextByPathList(node, ['p:spPr', 'a:solidFill', 'a:srgbClr', 'attrs', 'val'])
+  }
+
+  if (!fillColor) {
+    const schemeClr = 'a:' + getTextByPathList(node, ['p:spPr', 'a:solidFill', 'a:schemeClr', 'attrs', 'val'])
+    fillColor = getSchemeColorFromTheme(schemeClr, warpObj)
+  }
+
+  if (!fillColor) {
+    const schemeClr = 'a:' + getTextByPathList(node, ['p:style', 'a:fillRef', 'a:schemeClr', 'attrs', 'val'])
+    fillColor = getSchemeColorFromTheme(schemeClr, warpObj)
+  }
+
+  if (fillColor) {
+    fillColor = `#${fillColor}`
+
+    let lumMod = parseInt(getTextByPathList(node, ['p:spPr', 'a:solidFill', 'a:schemeClr', 'a:lumMod', 'attrs', 'val'])) / 100000
+    let lumOff = parseInt(getTextByPathList(node, ['p:spPr', 'a:solidFill', 'a:schemeClr', 'a:lumOff', 'attrs', 'val'])) / 100000
+    if (isNaN(lumMod)) lumMod = 1.0
+    if (isNaN(lumOff)) lumOff = 0
+
+    const color = tinycolor(fillColor).toHsl()
+    const lum = color.l * (1 + lumOff)
+    return tinycolor({ h: color.h, s: color.s, l: lum, a: color.a }).toHexString()
+  } 
+
+  if (isSvgMode) return 'none'
+  return fillColor
+}
+
+export function getSolidFill(solidFill, clrMap, phClr, warpObj) {
+  if (!solidFill) return solidFill
+
+  let color = 'fff'
+  let clrNode
+
+  if (solidFill['a:srgbClr']) {
+    color = getTextByPathList(solidFill['a:srgbClr'], ['attrs', 'val'])
+  } 
+  else if (solidFill['a:schemeClr']) {
+    const schemeClr = 'a:' + getTextByPathList(solidFill['a:schemeClr'], ['attrs', 'val'])
+    color = getSchemeColorFromTheme(schemeClr, warpObj)
+  }
+  else if (solidFill['a:scrgbClr']) {
+    clrNode = solidFill['a:scrgbClr']
+    const defBultColorVals = clrNode['attrs']
+    const red = (defBultColorVals['r'].indexOf('%') !== -1) ? defBultColorVals['r'].split('%').shift() : defBultColorVals['r']
+    const green = (defBultColorVals['g'].indexOf('%') !== -1) ? defBultColorVals['g'].split('%').shift() : defBultColorVals['g']
+    const blue = (defBultColorVals['b'].indexOf('%') !== -1) ? defBultColorVals['b'].split('%').shift() : defBultColorVals['b']
+    color = toHex(255 * (Number(red) / 100)) + toHex(255 * (Number(green) / 100)) + toHex(255 * (Number(blue) / 100))
+  } 
+  else if (solidFill['a:prstClr']) {
+    clrNode = solidFill['a:prstClr']
+    color = getTextByPathList(clrNode, ['attrs', 'val'])
+  } 
+  else if (solidFill['a:hslClr']) {
+    clrNode = solidFill['a:hslClr']
+    const defBultColorVals = clrNode['attrs']
+    const hue = Number(defBultColorVals['hue']) / 100000
+    const sat = Number((defBultColorVals['sat'].indexOf('%') !== -1) ? defBultColorVals['sat'].split('%').shift() : defBultColorVals['sat']) / 100
+    const lum = Number((defBultColorVals['lum'].indexOf('%') !== -1) ? defBultColorVals['lum'].split('%').shift() : defBultColorVals['lum']) / 100
+    const hsl2rgb = hslToRgb(hue, sat, lum)
+    color = toHex(hsl2rgb.r) + toHex(hsl2rgb.g) + toHex(hsl2rgb.b)
+  } 
+  else if (solidFill['a:sysClr']) {
+    clrNode = solidFill['a:sysClr']
+    const sysClr = getTextByPathList(clrNode, ['attrs', 'lastClr'])
+    if (sysClr) color = sysClr
+  }
+
+  let isAlpha = false
+  const alpha = parseInt(getTextByPathList(clrNode, ['a:alpha', 'attrs', 'val'])) / 100000
+  if (!isNaN(alpha)) {
+    const al_color = tinycolor(color)
+    al_color.setAlpha(alpha)
+    color = al_color.toHex8()
+    isAlpha = true
+  }
+
+  const hueMod = parseInt(getTextByPathList(clrNode, ['a:hueMod', 'attrs', 'val'])) / 100000
+  if (!isNaN(hueMod)) {
+    color = applyHueMod(color, hueMod, isAlpha)
+  }
+  const lumMod = parseInt(getTextByPathList(clrNode, ['a:lumMod', 'attrs', 'val'])) / 100000
+  if (!isNaN(lumMod)) {
+    color = applyLumMod(color, lumMod, isAlpha)
+  }
+  const lumOff = parseInt(getTextByPathList(clrNode, ['a:lumOff', 'attrs', 'val'])) / 100000
+  if (!isNaN(lumOff)) {
+    color = applyLumOff(color, lumOff, isAlpha)
+  }
+  const satMod = parseInt(getTextByPathList(clrNode, ['a:satMod', 'attrs', 'val'])) / 100000
+  if (!isNaN(satMod)) {
+    color = applySatMod(color, satMod, isAlpha)
+  }
+  const shade = parseInt(getTextByPathList(clrNode, ['a:shade', 'attrs', 'val'])) / 100000
+  if (!isNaN(shade)) {
+    color = applyShade(color, shade, isAlpha)
+  }
+  const tint = parseInt(getTextByPathList(clrNode, ['a:tint', 'attrs', 'val'])) / 100000
+  if (!isNaN(tint)) {
+    color = applyTint(color, tint, isAlpha)
+  }
+
+  return color
+}

package/src/fontStyle.js

@@ -0,0 +1,105 @@
+import { getTextByPathList } from './utils'
+import { getShadow } from './shadow'
+
+export function getFontType(node, type, warpObj) {
+  let typeface = getTextByPathList(node, ['a:rPr', 'a:latin', 'attrs', 'typeface'])
+
+  if (!typeface) {
+    const fontSchemeNode = getTextByPathList(warpObj['themeContent'], ['a:theme', 'a:themeElements', 'a:fontScheme'])
+
+    if (type === 'title' || type === 'subTitle' || type === 'ctrTitle') {
+      typeface = getTextByPathList(fontSchemeNode, ['a:majorFont', 'a:latin', 'attrs', 'typeface'])
+    } 
+    else if (type === 'body') {
+      typeface = getTextByPathList(fontSchemeNode, ['a:minorFont', 'a:latin', 'attrs', 'typeface'])
+    } 
+    else {
+      typeface = getTextByPathList(fontSchemeNode, ['a:minorFont', 'a:latin', 'attrs', 'typeface'])
+    }
+  }
+
+  return typeface || ''
+}
+
+export function getFontColor(node) {
+  const color = getTextByPathList(node, ['a:rPr', 'a:solidFill', 'a:srgbClr', 'attrs', 'val'])
+  return color ? `#${color}` : ''
+}
+
+export function getFontSize(node, slideLayoutSpNode, type, slideMasterTextStyles, fontsizeFactor) {
+  let fontSize
+
+  if (node['a:rPr']) fontSize = parseInt(node['a:rPr']['attrs']['sz']) / 100
+
+  if ((isNaN(fontSize) || !fontSize)) {
+    const sz = getTextByPathList(slideLayoutSpNode, ['p:txBody', 'a:lstStyle', 'a:lvl1pPr', 'a:defRPr', 'attrs', 'sz'])
+    fontSize = parseInt(sz) / 100
+  }
+
+  if (isNaN(fontSize) || !fontSize) {
+    let sz
+    if (type === 'title' || type === 'subTitle' || type === 'ctrTitle') {
+      sz = getTextByPathList(slideMasterTextStyles, ['p:titleStyle', 'a:lvl1pPr', 'a:defRPr', 'attrs', 'sz'])
+    } 
+    else if (type === 'body') {
+      sz = getTextByPathList(slideMasterTextStyles, ['p:bodyStyle', 'a:lvl1pPr', 'a:defRPr', 'attrs', 'sz'])
+    } 
+    else if (type === 'dt' || type === 'sldNum') {
+      sz = '1200'
+    } 
+    else if (!type) {
+      sz = getTextByPathList(slideMasterTextStyles, ['p:otherStyle', 'a:lvl1pPr', 'a:defRPr', 'attrs', 'sz'])
+    }
+    if (sz) fontSize = parseInt(sz) / 100
+  }
+
+  const baseline = getTextByPathList(node, ['a:rPr', 'attrs', 'baseline'])
+  if (baseline && !isNaN(fontSize)) fontSize -= 10
+
+  fontSize = (isNaN(fontSize) || !fontSize) ? 18 : fontSize
+
+  return fontSize * fontsizeFactor + 'px'
+}
+
+export function getFontBold(node) {
+  return getTextByPathList(node, ['a:rPr', 'attrs', 'b']) === '1' ? 'bold' : ''
+}
+
+export function getFontItalic(node) {
+  return getTextByPathList(node, ['a:rPr', 'attrs', 'i']) === '1' ? 'italic' : ''
+}
+
+export function getFontDecoration(node) {
+  const underline = getTextByPathList(node, ['a:rPr', 'attrs', 'u']) === 'sng' ? 'underline' : ''
+  const strike = getTextByPathList(node, ['a:rPr', 'attrs', 'strike']) === 'sngStrike' ? 'line-through' : ''
+
+  if (!underline && !strike) return ''
+  else if (underline && !strike) return underline
+  else if (!underline && strike) return strike
+  return `${underline} ${strike}`
+}
+
+export function getFontSpace(node, fontsizeFactor) {
+  const spc = getTextByPathList(node, ['a:rPr', 'attrs', 'spc'])
+  return spc ? (parseInt(spc) / 100 * fontsizeFactor + 'px') : ''
+}
+
+export function getFontSubscript(node) {
+  const baseline = getTextByPathList(node, ['a:rPr', 'attrs', 'baseline'])
+  if (!baseline) return ''
+  return parseInt(baseline) > 0 ? 'super' : 'sub'
+}
+
+export function getFontShadow(node, warpObj, slideFactor) {
+  const txtShadow = getTextByPathList(node, ['a:rPr', 'a:effectLst', 'a:outerShdw'])
+  if (txtShadow) {
+    const shadow = getShadow(txtShadow, warpObj, slideFactor)
+    if (shadow) {
+      const { h, v, blur, color } = shadow
+      if (!isNaN(v) && !isNaN(h)) {
+        return h + 'px ' + v + 'px ' + (blur ? blur + 'px' : '') + ' ' + color
+      }
+    }
+  }
+  return ''
+}

package/src/position.js

@@ -0,0 +1,29 @@
+export function getPosition(slideSpNode, slideLayoutSpNode, slideMasterSpNode, factor) {
+  let off
+
+  if (slideSpNode) off = slideSpNode['a:off']['attrs']
+  else if (slideLayoutSpNode) off = slideLayoutSpNode['a:off']['attrs']
+  else if (slideMasterSpNode) off = slideMasterSpNode['a:off']['attrs']
+
+  if (!off) return { top: 0, left: 0 }
+
+  return {
+    top: parseInt(off['y']) * factor,
+    left: parseInt(off['x']) * factor,
+  }
+}
+
+export function getSize(slideSpNode, slideLayoutSpNode, slideMasterSpNode, factor) {
+  let ext
+
+  if (slideSpNode) ext = slideSpNode['a:ext']['attrs']
+  else if (slideLayoutSpNode) ext = slideLayoutSpNode['a:ext']['attrs']
+  else if (slideMasterSpNode) ext = slideMasterSpNode['a:ext']['attrs']
+
+  if (!ext) return { width: 0, height: 0 }
+
+  return {
+    width: parseInt(ext['cx']) * factor,
+    height: parseInt(ext['cy']) * factor,
+  }
+}