@lofcz/pptxtojson 2.2.2 → 2.2.3

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}`;
@@ -9944,6 +10102,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 +10116,9 @@ async function processSingleSlide(zip, sldFileName, themeContent, defaultTextSty
         layoutElements,
         note,
         transition,
-        hideBackground
+        hideBackground,
+        animations,
+        builds
     };
 }
 function getHyperlinkFromCNvPr(cNvPr, warpObj) {