pptxtojson 0.0.13 → 0.1.1

package/index.html

@@ -106,7 +106,10 @@
 			
 			const reader = new FileReader()
 			reader.onload = async e => {
-				const json = await pptxtojson.parse(e.target.result)
+				const json = await pptxtojson.parse(e.target.result, {
+					// slideFactor: 75 / 914400,
+  				// fontsizeFactor: 100 / 96,
+				})
 				editor.set(json)
 				console.log(json)
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pptxtojson",
-	"version": "0.0.13",
+	"version": "0.1.1",
 	"description": "A javascript tool for parsing .pptx file",
 	"type": "module",
 	"main": "./dist/index.umd.js",
@@ -12,7 +12,7 @@
 		"lint": "eslint src --ext .js,.jsx,.ts,.tsx"
 	},
 	"author": "",
-	"license": "GPL-3.0",
+	"license": "AGPL-3.0",
 	"publishConfig": {
 		"registry": "https://registry.npmjs.com/"
 	},

package/src/align.js

@@ -0,0 +1,36 @@
+import { getTextByPathList } from './utils'
+
+export function getHorizontalAlign(node, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles) {
+  let algn = getTextByPathList(node, ['a:pPr', 'attrs', 'algn'])
+
+  if (!algn) algn = getTextByPathList(slideLayoutSpNode, ['p:txBody', 'a:p', 'a:pPr', 'attrs', 'algn'])
+  if (!algn) algn = getTextByPathList(slideMasterSpNode, ['p:txBody', 'a:p', 'a:pPr', 'attrs', 'algn'])
+  if (!algn) {
+    switch (type) {
+      case 'title':
+      case 'subTitle':
+      case 'ctrTitle':
+        algn = getTextByPathList(slideMasterTextStyles, ['p:titleStyle', 'a:lvl1pPr', 'attrs', 'algn'])
+        break
+      default:
+        algn = getTextByPathList(slideMasterTextStyles, ['p:otherStyle', 'a:lvl1pPr', 'attrs', 'algn'])
+    }
+  }
+  if (!algn) {
+    if (type === 'title' || type === 'subTitle' || type === 'ctrTitle') return 'center'
+    else if (type === 'sldNum') return 'right'
+  }
+  return algn === 'ctr' ? 'center' : algn === 'r' ? 'right' : 'left'
+}
+
+export 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')
+}

package/src/border.js

@@ -0,0 +1,95 @@
+import tinycolor from 'tinycolor2'
+import { getSchemeColorFromTheme } from './schemeColor'
+import { getTextByPathList } from './utils'
+
+export function getBorder(node, elType, warpObj) {
+  const lineNode = node['p:spPr']['a:ln']
+
+  let borderWidth = parseInt(getTextByPathList(lineNode, ['attrs', 'w'])) / 12700
+  if (isNaN(borderWidth)) {
+    if (lineNode) borderWidth = 0
+    else if (elType === 'text') borderWidth = 0
+    else borderWidth = 1
+  }
+
+  let borderColor = getTextByPathList(lineNode, ['a:solidFill', 'a:srgbClr', 'attrs', 'val'])
+  if (!borderColor) {
+    const schemeClrNode = getTextByPathList(lineNode, ['a:solidFill', 'a:schemeClr'])
+    const schemeClr = 'a:' + getTextByPathList(schemeClrNode, ['attrs', 'val'])
+    borderColor = getSchemeColorFromTheme(schemeClr, warpObj)
+  }
+
+  if (!borderColor) {
+    const schemeClrNode = getTextByPathList(node, ['p:style', 'a:lnRef', 'a:schemeClr'])
+    const schemeClr = 'a:' + getTextByPathList(schemeClrNode, ['attrs', 'val'])
+    borderColor = getSchemeColorFromTheme(schemeClr, warpObj)
+
+    if (borderColor) {
+      let shade = getTextByPathList(schemeClrNode, ['a:shade', 'attrs', 'val'])
+
+      if (shade) {
+        shade = parseInt(shade) / 100000
+        
+        const color = tinycolor('#' + borderColor).toHsl()
+        borderColor = tinycolor({ h: color.h, s: color.s, l: color.l * shade, a: color.a }).toHex()
+      }
+    }
+  }
+
+  if (!borderColor) borderColor = '#000'
+  else borderColor = `#${borderColor}`
+
+  const type = getTextByPathList(lineNode, ['a:prstDash', 'attrs', 'val'])
+  let borderType = 'solid'
+  let strokeDasharray = '0'
+  switch (type) {
+    case 'solid':
+      borderType = 'solid'
+      strokeDasharray = '0'
+      break
+    case 'dash':
+      borderType = 'dashed'
+      strokeDasharray = '5'
+      break
+    case 'dashDot':
+      borderType = 'dashed'
+      strokeDasharray = '5, 5, 1, 5'
+      break
+    case 'dot':
+      borderType = 'dotted'
+      strokeDasharray = '1, 5'
+      break
+    case 'lgDash':
+      borderType = 'dashed'
+      strokeDasharray = '10, 5'
+      break
+    case 'lgDashDotDot':
+      borderType = 'dotted'
+      strokeDasharray = '10, 5, 1, 5, 1, 5'
+      break
+    case 'sysDash':
+      borderType = 'dashed'
+      strokeDasharray = '5, 2'
+      break
+    case 'sysDashDot':
+      borderType = 'dotted'
+      strokeDasharray = '5, 2, 1, 5'
+      break
+    case 'sysDashDotDot':
+      borderType = 'dotted'
+      strokeDasharray = '5, 2, 1, 5, 1, 5'
+      break
+    case 'sysDot':
+      borderType = 'dotted'
+      strokeDasharray = '2, 5'
+      break
+    default:
+  }
+
+  return {
+    borderColor,
+    borderWidth,
+    borderType,
+    strokeDasharray,
+  }
+}

package/src/chart.js

@@ -0,0 +1,173 @@
+import { eachElement, getTextByPathList } from './utils'
+
+function extractChartData(serNode) {
+  const dataMat = []
+  if (!serNode) return dataMat
+
+  if (serNode['c:xVal']) {
+    let dataRow = []
+    eachElement(serNode['c:xVal']['c:numRef']['c:numCache']['c:pt'], innerNode => {
+      dataRow.push(parseFloat(innerNode['c:v']))
+      return ''
+    })
+    dataMat.push(dataRow)
+    dataRow = []
+    eachElement(serNode['c:yVal']['c:numRef']['c:numCache']['c:pt'], innerNode => {
+      dataRow.push(parseFloat(innerNode['c:v']))
+      return ''
+    })
+    dataMat.push(dataRow)
+  } 
+  else {
+    eachElement(serNode, (innerNode, index) => {
+      const dataRow = []
+      const colName = getTextByPathList(innerNode, ['c:tx', 'c:strRef', 'c:strCache', 'c:pt', 'c:v']) || index
+
+      const rowNames = {}
+      if (getTextByPathList(innerNode, ['c:cat', 'c:strRef', 'c:strCache', 'c:pt'])) {
+        eachElement(innerNode['c:cat']['c:strRef']['c:strCache']['c:pt'], innerNode => {
+          rowNames[innerNode['attrs']['idx']] = innerNode['c:v']
+          return ''
+        })
+      } 
+      else if (getTextByPathList(innerNode, ['c:cat', 'c:numRef', 'c:numCache', 'c:pt'])) {
+        eachElement(innerNode['c:cat']['c:numRef']['c:numCache']['c:pt'], innerNode => {
+          rowNames[innerNode['attrs']['idx']] = innerNode['c:v']
+          return ''
+        })
+      }
+
+      if (getTextByPathList(innerNode, ['c:val', 'c:numRef', 'c:numCache', 'c:pt'])) {
+        eachElement(innerNode['c:val']['c:numRef']['c:numCache']['c:pt'], innerNode => {
+          dataRow.push({
+            x: innerNode['attrs']['idx'],
+            y: parseFloat(innerNode['c:v']),
+          })
+          return ''
+        })
+      }
+
+      dataMat.push({
+        key: colName,
+        values: dataRow,
+        xlabels: rowNames,
+      })
+      return ''
+    })
+  }
+
+  return dataMat
+}
+
+export function getChartInfo(plotArea) {
+  let chart = null
+  for (const key in plotArea) {
+    switch (key) {
+      case 'c:lineChart':
+        chart = {
+          type: 'lineChart',
+          data: extractChartData(plotArea[key]['c:ser']),
+          grouping: getTextByPathList(plotArea[key], ['c:grouping', 'attrs', 'val']),
+          marker: plotArea[key]['c:marker'] ? true : false,
+        }
+        break
+      case 'c:line3DChart':
+        chart = {
+          type: 'line3DChart',
+          data: extractChartData(plotArea[key]['c:ser']),
+          grouping: getTextByPathList(plotArea[key], ['c:grouping', 'attrs', 'val']),
+        }
+        break
+      case 'c:barChart':
+        chart = {
+          type: 'barChart',
+          data: extractChartData(plotArea[key]['c:ser']),
+          grouping: getTextByPathList(plotArea[key], ['c:grouping', 'attrs', 'val']),
+          barDir: getTextByPathList(plotArea[key], ['c:barDir', 'attrs', 'val']),
+        }
+        break
+      case 'c:bar3DChart':
+        chart = {
+          type: 'bar3DChart',
+          data: extractChartData(plotArea[key]['c:ser']),
+          grouping: getTextByPathList(plotArea[key], ['c:grouping', 'attrs', 'val']),
+          barDir: getTextByPathList(plotArea[key], ['c:barDir', 'attrs', 'val']),
+        }
+        break
+      case 'c:pieChart':
+        chart = {
+          type: 'pieChart',
+          data: extractChartData(plotArea[key]['c:ser']),
+        }
+        break
+      case 'c:pie3DChart':
+        chart = {
+          type: 'pie3DChart',
+          data: extractChartData(plotArea[key]['c:ser']),
+        }
+        break
+      case 'c:doughnutChart':
+        chart = {
+          type: 'doughnutChart',
+          data: extractChartData(plotArea[key]['c:ser']),
+          holeSize: getTextByPathList(plotArea[key], ['c:holeSize', 'attrs', 'val']),
+        }
+        break
+      case 'c:areaChart':
+        chart = {
+          type: 'areaChart',
+          data: extractChartData(plotArea[key]['c:ser']),
+          grouping: getTextByPathList(plotArea[key], ['c:grouping', 'attrs', 'val']),
+        }
+        break
+      case 'c:area3DChart':
+        chart = {
+          type: 'area3DChart',
+          data: extractChartData(plotArea[key]['c:ser']),
+          grouping: getTextByPathList(plotArea[key], ['c:grouping', 'attrs', 'val']),
+        }
+        break
+      case 'c:scatterChart':
+        chart = {
+          type: 'scatterChart',
+          data: extractChartData(plotArea[key]['c:ser']),
+          style: getTextByPathList(plotArea[key], ['c:scatterStyle', 'attrs', 'val']),
+        }
+        break
+      case 'c:bubbleChart':
+        chart = {
+          type: 'bubbleChart',
+          data: extractChartData(plotArea[key]['c:ser']),
+        }
+        break
+      case 'c:radarChart':
+        chart = {
+          type: 'radarChart',
+          data: extractChartData(plotArea[key]['c:ser']),
+          style: getTextByPathList(plotArea[key], ['c:radarStyle', 'attrs', 'val']),
+        }
+        break
+      case 'c:surfaceChart':
+        chart = {
+          type: 'surfaceChart',
+          data: extractChartData(plotArea[key]['c:ser']),
+        }
+        break
+      case 'c:surface3DChart':
+        chart = {
+          type: 'surface3DChart',
+          data: extractChartData(plotArea[key]['c:ser']),
+        }
+        break
+      case 'c:stockChart':
+        chart = {
+          type: 'stockChart',
+          data: extractChartData(plotArea[key]['c:ser']),
+        }
+        break
+      default:
+    }
+  }
+
+  return chart
+}

package/src/color.js

@@ -0,0 +1,168 @@
+import tinycolor from 'tinycolor2'
+
+export function hueToRgb(t1, t2, hue) {
+  if (hue < 0) hue += 6
+  if (hue >= 6) hue -= 6
+  if (hue < 1) return (t2 - t1) * hue + t1
+  else if (hue < 3) return t2
+  else if (hue < 4) return (t2 - t1) * (4 - hue) + t1
+  return t1
+}
+
+export function hslToRgb(hue, sat, light) {
+  let t2
+  hue = hue / 60
+  if (light <= 0.5) {
+    t2 = light * (sat + 1)
+  } 
+  else {
+    t2 = light + sat - (light * sat)
+  }
+  const t1 = light * 2 - t2
+  const r = hueToRgb(t1, t2, hue + 2) * 255
+  const g = hueToRgb(t1, t2, hue) * 255
+  const b = hueToRgb(t1, t2, hue - 2) * 255
+  return { r, g, b }
+}
+
+export function applyShade(rgbStr, shadeValue, isAlpha) {
+  const color = tinycolor(rgbStr).toHsl()
+  if (shadeValue >= 1) shadeValue = 1
+  const cacl_l = Math.min(color.l * shadeValue, 1)
+  if (isAlpha) {
+    return tinycolor({
+      h: color.h,
+      s: color.s,
+      l: cacl_l,
+      a: color.a
+    }).toHex8()
+  }
+
+  return tinycolor({
+    h: color.h,
+    s: color.s,
+    l: cacl_l,
+    a: color.a,
+  }).toHex()
+}
+
+export function applyTint(rgbStr, tintValue, isAlpha) {
+  const color = tinycolor(rgbStr).toHsl()
+  if (tintValue >= 1) tintValue = 1
+  const cacl_l = color.l * tintValue + (1 - tintValue)
+  if (isAlpha) {
+    return tinycolor({
+      h: color.h,
+      s: color.s,
+      l: cacl_l,
+      a: color.a
+    }).toHex8()
+  }
+
+  return tinycolor({
+    h: color.h,
+    s: color.s,
+    l: cacl_l,
+    a: color.a
+  }).toHex()
+}
+
+export function applyLumOff(rgbStr, offset, isAlpha) {
+  const color = tinycolor(rgbStr).toHsl()
+  const lum = offset + color.l
+  if (lum >= 1) {
+    if (isAlpha) {
+      return tinycolor({
+        h: color.h,
+        s: color.s,
+        l: 1,
+        a: color.a
+      }).toHex8()
+    }
+      
+    return tinycolor({
+      h: color.h,
+      s: color.s,
+      l: 1,
+      a: color.a
+    }).toHex()
+  }
+  if (isAlpha) {
+    return tinycolor({
+      h: color.h,
+      s: color.s,
+      l: lum,
+      a: color.a
+    }).toHex8()
+  }
+
+  return tinycolor({
+    h: color.h,
+    s: color.s,
+    l: lum,
+    a: color.a
+  }).toHex()
+}
+
+export function applyLumMod(rgbStr, multiplier, isAlpha) {
+  const color = tinycolor(rgbStr).toHsl()
+  let cacl_l = color.l * multiplier
+  if (cacl_l >= 1) cacl_l = 1
+  if (isAlpha) {
+    return tinycolor({
+      h: color.h,
+      s: color.s,
+      l: cacl_l,
+      a: color.a
+    }).toHex8()
+  }
+
+  return tinycolor({
+    h: color.h,
+    s: color.s,
+    l: cacl_l,
+    a: color.a
+  }).toHex()
+}
+
+export function applyHueMod(rgbStr, multiplier, isAlpha) {
+  const color = tinycolor(rgbStr).toHsl()
+  let cacl_h = color.h * multiplier
+  if (cacl_h >= 360) cacl_h = cacl_h - 360
+  if (isAlpha) {
+    return tinycolor({
+      h: cacl_h,
+      s: color.s,
+      l: color.l,
+      a: color.a
+    }).toHex8()
+  }
+
+  return tinycolor({
+    h: cacl_h,
+    s: color.s,
+    l: color.l,
+    a: color.a
+  }).toHex()
+}
+
+export function applySatMod(rgbStr, multiplier, isAlpha) {
+  const color = tinycolor(rgbStr).toHsl()
+  let cacl_s = color.s * multiplier
+  if (cacl_s >= 1) cacl_s = 1
+  if (isAlpha) {
+    return tinycolor({
+      h: color.h,
+      s: cacl_s,
+      l: color.l,
+      a: color.a
+    }).toHex8()
+  }
+
+  return tinycolor({
+    h: color.h,
+    s: cacl_s,
+    l: color.l,
+    a: color.a
+  }).toHex()
+}