@lofcz/pptxtojson 2.2.2 → 2.2.4

package/dist/index.d.ts

@@ -343,12 +343,41 @@ export interface SlideTransition {
   direction: string | null
 }
 
+export type AnimationTrigger = 'onClick' | 'withPrevious' | 'afterPrevious'
+export type AnimationClass = 'entr' | 'exit' | 'emph' | 'path' | 'verb' | 'mediacall'
+export type SlideBuildType = 'paragraph' | 'diagram' | 'graphic' | 'oleChart'
+
+export interface SlideAnimation {
+  /** cNvPr id of the target shape (`p:spTgt@spid`) */
+  spid: string
+  trigger: AnimationTrigger
+  class: AnimationClass
+  presetId: number
+  presetSubtype: number
+  /** Duration in milliseconds */
+  duration: number
+  /** Delay in milliseconds before the effect starts */
+  delay: number
+  /** `p:animEffect@filter` when present (fade, wipe, barn, …) */
+  filter?: string
+}
+
+export interface SlideBuild {
+  spid: string
+  type: SlideBuildType
+  animBg?: boolean
+}
+
 export interface Slide {
   fill: Fill
   elements: Element[]
   layoutElements: Element[]
   note: string
   transition?: SlideTransition | null
+  /** Click / withPrevious / afterPrevious effects in presenter order */
+  animations: SlideAnimation[]
+  /** `p:bldLst` paragraph / graphic / diagram builds */
+  builds: SlideBuild[]
 }
 
 export interface Options {

package/dist/index.js

@@ -9431,6 +9431,164 @@ function parseTransition(transitionNode) {
     }
     return transition;
 }
+const PRESET_CLASSES = new Set([
+    'entr',
+    'exit',
+    'emph',
+    'path',
+    'verb',
+    'mediacall'
+]);
+const NODE_TYPE_TO_TRIGGER = {
+    clickEffect: 'onClick',
+    withEffect: 'withPrevious',
+    afterEffect: 'afterPrevious',
+    clickPar: 'onClick',
+    withGroup: 'withPrevious',
+    afterGroup: 'afterPrevious',
+    interactiveSeq: 'onClick'
+};
+function asArray(value) {
+    if (null == value) return [];
+    return Array.isArray(value) ? value : [
+        value
+    ];
+}
+function parseMs(value) {
+    if (null == value || '' === value || 'indefinite' === value) return null;
+    const ms = parseInt(value, 10);
+    return Number.isFinite(ms) ? ms : null;
+}
+function findTimingNode(content) {
+    if (!content) return null;
+    return getTextByPathList(content, [
+        'p:sld',
+        'p:timing'
+    ]) || getTextByPathList(content, [
+        'p:sld',
+        'mc:AlternateContent',
+        'mc:Choice',
+        'p:timing'
+    ]) || getTextByPathList(content, [
+        'p:sld',
+        'mc:AlternateContent',
+        'mc:Fallback',
+        'p:timing'
+    ]);
+}
+function collectSpids(node, out = []) {
+    if (!node || 'object' != typeof node) return out;
+    const spid = node.attrs?.spid;
+    if (null != spid && '' !== spid) out.push(String(spid));
+    for (const key of Object.keys(node))if ('attrs' !== key && 'value' !== key) for (const child of asArray(node[key]))collectSpids(child, out);
+    return out;
+}
+function collectDuration(node) {
+    let found = null;
+    const walk = (n)=>{
+        if (!n || 'object' != typeof n) return;
+        const ms = parseMs(n.attrs?.dur);
+        if (null != ms && ms >= 0) found = ms;
+        for (const key of Object.keys(n))if ('attrs' !== key && 'value' !== key) for (const child of asArray(n[key]))walk(child);
+    };
+    walk(node);
+    return found;
+}
+function collectFilter(node) {
+    let filter = '';
+    const walk = (n)=>{
+        if (!n || 'object' != typeof n) return;
+        if (n.attrs?.filter) filter = n.attrs.filter;
+        for (const key of Object.keys(n))if ('attrs' !== key && 'value' !== key) for (const child of asArray(n[key]))walk(child);
+    };
+    walk(node);
+    return filter;
+}
+function collectDelay(node, inherited = 0) {
+    const fromAttr = parseMs(node?.attrs?.delay);
+    if (null != fromAttr && fromAttr >= 0) return fromAttr;
+    const condRoot = node?.['p:stCondLst'];
+    for (const cond of asArray(condRoot?.['p:cond'] || condRoot)){
+        const fromCond = parseMs(cond?.attrs?.delay);
+        if (null != fromCond && fromCond >= 0) return fromCond;
+    }
+    return inherited;
+}
+function collectEffects(node, inheritedTrigger = 'onClick', inheritedDelay = 0, results = []) {
+    if (!node || 'object' != typeof node) return results;
+    const attrs = node.attrs || {};
+    const trigger = NODE_TYPE_TO_TRIGGER[attrs.nodeType] || inheritedTrigger;
+    const delay = collectDelay(node, inheritedDelay);
+    if (attrs.presetClass && PRESET_CLASSES.has(attrs.presetClass)) {
+        const spids = [
+            ...new Set(collectSpids(node))
+        ];
+        const duration = collectDuration(node);
+        const filter = collectFilter(node);
+        const effectTrigger = NODE_TYPE_TO_TRIGGER[attrs.nodeType] || trigger;
+        for (const spid of spids){
+            const animation = {
+                spid,
+                trigger: effectTrigger,
+                class: attrs.presetClass,
+                presetId: parseInt(attrs.presetID || '0', 10) || 0,
+                presetSubtype: parseInt(attrs.presetSubtype || '0', 10) || 0,
+                duration: null != duration ? duration : 1000,
+                delay
+            };
+            if (filter) animation.filter = filter;
+            results.push(animation);
+        }
+        return results;
+    }
+    for (const key of Object.keys(node))if ('attrs' !== key && 'value' !== key) for (const child of asArray(node[key]))collectEffects(child, trigger, delay, results);
+    return results;
+}
+function parseBuildList(timing) {
+    const bldLst = timing?.['p:bldLst'];
+    if (!bldLst) return [];
+    const kinds = [
+        [
+            'p:bldP',
+            'paragraph'
+        ],
+        [
+            'p:bldDgm',
+            'diagram'
+        ],
+        [
+            'p:bldGraphic',
+            'graphic'
+        ],
+        [
+            'p:bldOleChart',
+            'oleChart'
+        ]
+    ];
+    const builds = [];
+    for (const [tag, type] of kinds)for (const node of asArray(bldLst[tag])){
+        const spid = node?.attrs?.spid;
+        if (null == spid || '' === spid) continue;
+        const item = {
+            spid: String(spid),
+            type
+        };
+        if (node.attrs?.animBg === '1' || node.attrs?.animBg === 'true') item.animBg = true;
+        builds.push(item);
+    }
+    return builds;
+}
+function parseTiming(slideContent) {
+    const timing = findTimingNode(slideContent);
+    if (!timing) return {
+        animations: [],
+        builds: []
+    };
+    return {
+        animations: collectEffects(timing),
+        builds: parseBuildList(timing)
+    };
+}
 async function loadDiagramFile(warpObj, filename, transformDrawing = false) {
     if (!filename) return null;
     const cacheKey = `${transformDrawing ? 'drawing:' : 'xml:'}${filename}`;
@@ -9628,27 +9786,97 @@ async function parse(file, options = {}) {
         }
     };
 }
+function asNodeArray(node) {
+    if (!node) return [];
+    return node.constructor === Array ? node : [
+        node
+    ];
+}
+function sortSlideXml(p1, p2) {
+    const n1 = +(/(\d+)\.xml/.exec(p1)?.[1] || 0);
+    const n2 = +(/(\d+)\.xml/.exec(p2)?.[1] || 0);
+    return n1 - n2;
+}
+function resolvePresentationTarget(target) {
+    let relTarget = String(target || '').replace(/\\/g, '/');
+    if (!relTarget) return '';
+    if (0 === relTarget.indexOf('/ppt/')) return relTarget.substr(1);
+    if (-1 !== relTarget.indexOf('../')) return relTarget.replace('../', 'ppt/');
+    if (0 === relTarget.indexOf('ppt/')) return relTarget;
+    return 'ppt/' + relTarget.replace(/^\//, '');
+}
+function relationshipRid(attrs) {
+    if (!attrs) return '';
+    return attrs['r:id'] || attrs.rId || '';
+}
+async function getSlidesFromPresentation(zip) {
+    const relsContent = await readXmlFile(zip, 'ppt/_rels/presentation.xml.rels');
+    const relItems = asNodeArray(getTextByPathList(relsContent, [
+        'Relationships',
+        'Relationship'
+    ]));
+    const relsMap = {};
+    const slideTargets = [];
+    for (const rel of relItems){
+        const id = getTextByPathList(rel, [
+            'attrs',
+            'Id'
+        ]);
+        const type = getTextByPathList(rel, [
+            'attrs',
+            'Type'
+        ]);
+        const target = getTextByPathList(rel, [
+            'attrs',
+            'Target'
+        ]);
+        if (!id || !target) continue;
+        const loc = resolvePresentationTarget(target);
+        if (loc) {
+            relsMap[id] = loc;
+            if ('slide' === getRelTypeName(type)) slideTargets.push(loc);
+        }
+    }
+    const presentation = await readXmlFile(zip, 'ppt/presentation.xml');
+    const sldIds = asNodeArray(getTextByPathList(presentation, [
+        'p:presentation',
+        'p:sldIdLst',
+        'p:sldId'
+    ]));
+    const ordered = [];
+    for (const sldId of sldIds){
+        const rid = relationshipRid(sldId?.attrs);
+        if (rid && relsMap[rid]) ordered.push(relsMap[rid]);
+    }
+    if (ordered.length) return ordered;
+    return slideTargets.sort(sortSlideXml);
+}
 async function getContentTypes(zip) {
     const ContentTypesJson = await readXmlFile(zip, '[Content_Types].xml');
-    const subObj = ContentTypesJson['Types']['Override'];
+    const overrides = asNodeArray(getTextByPathList(ContentTypesJson, [
+        'Types',
+        'Override'
+    ]));
     let slidesLocArray = [];
     let slideLayoutsLocArray = [];
-    for (const item of subObj)switch(item['attrs']['ContentType']){
-        case 'application/vnd.openxmlformats-officedocument.presentationml.slide+xml':
-            slidesLocArray.push(item['attrs']['PartName'].substr(1));
-            break;
-        case 'application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml':
-            slideLayoutsLocArray.push(item['attrs']['PartName'].substr(1));
-            break;
-        default:
+    for (const item of overrides){
+        const contentType = item?.attrs?.ContentType;
+        const partName = item?.attrs?.PartName;
+        if (!contentType || !partName) continue;
+        const loc = String(partName).replace(/^\//, '');
+        switch(contentType){
+            case 'application/vnd.openxmlformats-officedocument.presentationml.slide+xml':
+                slidesLocArray.push(loc);
+                break;
+            case 'application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml':
+                slideLayoutsLocArray.push(loc);
+                break;
+            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);
+    if (!slidesLocArray.length) slidesLocArray = await getSlidesFromPresentation(zip);
     return {
         slides: slidesLocArray,
         slideLayouts: slideLayoutsLocArray
@@ -9944,6 +10172,7 @@ async function processSingleSlide(zip, sldFileName, themeContent, defaultTextSty
     if (!transitionNode) transitionNode = findTransitionNode(slideLayoutContent, 'p:sldLayout');
     if (!transitionNode) transitionNode = findTransitionNode(slideMasterContent, 'p:sldMaster');
     const transition = parseTransition(transitionNode);
+    const { animations, builds } = parseTiming(slideContent);
     const showMasterSpOnSlide = getTextByPathList(slideContent, [
         'p:sld',
         'attrs',
@@ -9957,7 +10186,9 @@ async function processSingleSlide(zip, sldFileName, themeContent, defaultTextSty
         layoutElements,
         note,
         transition,
-        hideBackground
+        hideBackground,
+        animations,
+        builds
     };
 }
 function getHyperlinkFromCNvPr(cNvPr, warpObj) {