@a3s-lab/office 0.33.0 → 0.34.0

package/dist/0~work-pptx-export.js

@@ -3,7 +3,7 @@ import { normalizeRadarStyle, presentationChartShowsLegend, presentationChartAxe
 import { directChildren, xmlNamespacePrefix, parseXml, firstDescendant, directChild, descendants, childPath, attribute } from "./4121.js";
 import { workSpreadsheetChartAxisShowsMajorGridlinesByDefault, workSpreadsheetChartAxisDefaultLabelPosition, workSpreadsheetChartAxisIsCategoryAxis, workSpreadsheetChartAxisIsValueAxis } from "./8715.js";
 import { presentationGroupPath, withPresentationDesign } from "./0~1403.js";
-import { patchPptxChartLayoutAndSeriesStyles, patchPptxTransitions, patchPptxComments, patchPptxChartDataLabels, patchPptxChartSeriesAnalysis } from "./0~7614.js";
+import { patchPptxChartLayoutAndSeriesStyles, patchPptxTransitions, patchPptxComments, patchPptxChartDataLabels, patchPptxChartSeriesAnalysis, patchPptxAnimations } from "./0~7828.js";
 const DRAWING_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/main';
 async function patchPptxChartAxes(buffer, slides) {
     const charts = slides.flatMap((slide)=>slide.elements.flatMap((element)=>'chart' === element.type && element.chart ? [
@@ -270,27 +270,40 @@ const PRESENTATIONML_NAMESPACE = 'http://schemas.openxmlformats.org/presentation
 const DRAWINGML_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/main';
 const GROUPABLE_PART = /^ppt\/(?:slides|slideLayouts|slideMasters)\/[^/]+\.xml$/;
 class PptxGroupExportRegistry {
+    animatedElementKeys = new Set();
     bindings = new Map();
+    bindingsByElement = new Map();
     roleCounts = new Map();
     markerSequence = 0;
     get size() {
         return this.bindings.size;
     }
+    registerAnimatedElements(scope, elementIds) {
+        for (const elementId of elementIds)this.animatedElementKeys.add(exportElementKey(scope, elementId));
+    }
     objectName(scope, element, role) {
         const groupPath = presentationGroupPath(element);
-        if (!groupPath.length) return;
+        const elementKey = exportElementKey(scope, element.id);
+        if (!groupPath.length && !this.animatedElementKeys.has(elementKey)) return;
+        const existing = this.bindingsByElement.get(elementKey);
+        if (existing) return existing.marker;
         const roleCount = (this.roleCounts.get(role) ?? 0) + 1;
         this.roleCounts.set(role, roleCount);
         this.markerSequence += 1;
         const marker = `${EXPORT_MARKER_PREFIX}${this.markerSequence}`;
-        this.bindings.set(marker, {
+        const binding = {
             displayName: `${pptxRoleName(role)} ${roleCount}`,
             groupPath,
             groupScope: scope,
             marker
-        });
+        };
+        this.bindings.set(marker, binding);
+        this.bindingsByElement.set(elementKey, binding);
         return marker;
     }
+    markerForElement(scope, elementId) {
+        return this.bindingsByElement.get(exportElementKey(scope, elementId))?.marker;
+    }
     binding(marker) {
         return this.bindings.get(marker);
     }
@@ -315,7 +328,7 @@ async function patchPptxNativeGroups(buffer, registry) {
     }
     for (const binding of registry.values()){
         const count = found.get(binding.marker) ?? 0;
-        if (1 !== count) throw new Error(`PPTX group export expected one generated object for ${binding.displayName}, but found ${count}.`);
+        if (1 !== count) throw new Error(`PPTX export expected one generated object for ${binding.displayName}, but found ${count}.`);
     }
     return archive.generateAsync({
         type: 'arraybuffer',
@@ -323,6 +336,7 @@ async function patchPptxNativeGroups(buffer, registry) {
     });
 }
 function patchPptxShapeTree(shapeTree, registry, found) {
+    normalizePptxNonVisualIds(shapeTree);
     const sceneNodes = directChildren(shapeTree).filter(isPptxSceneNode).map((node, order)=>{
         const properties = firstDescendant(node, 'cNvPr');
         const objectName = properties ? attribute(properties, 'name') : null;
@@ -342,9 +356,9 @@ function patchPptxShapeTree(shapeTree, registry, found) {
     });
     if (!sceneNodes.some((item)=>item.binding)) return false;
     const roots = new Map();
-    const rootNodes = sceneNodes.filter((item)=>!item.binding);
+    const rootNodes = sceneNodes.filter((item)=>!item.binding?.groupPath.length);
     for (const item of sceneNodes){
-        if (!item.binding) continue;
+        if (!item.binding?.groupPath.length) continue;
         let siblings = roots;
         let bucket;
         for (const groupId of item.binding.groupPath){
@@ -378,7 +392,6 @@ function patchPptxShapeTree(shapeTree, registry, found) {
     ].sort((left, right)=>left.order - right.order);
     const extensionList = directChild(shapeTree, 'extLst') ?? null;
     for (const item of renderedRoots)shapeTree.insertBefore(item.node, extensionList);
-    normalizePptxNonVisualIds(shapeTree);
     return true;
 }
 function renderPptxGroup(bucket, document, nextId, nextGroupNumber) {
@@ -492,6 +505,9 @@ function normalizePptxNonVisualIds(shapeTree) {
 function groupBucketKey(scope, groupId) {
     return `${scope}\u0000${groupId}`;
 }
+function exportElementKey(scope, elementId) {
+    return `${scope}\u0000${elementId}`;
+}
 function isPptxSceneNode(node) {
     return [
         'contentPart',
@@ -735,7 +751,9 @@ function createPptxExportState(artifact, PptxGenJS) {
         if (!source.useLayoutBackground) slide.background = {
             color: source.background.replace('#', '')
         };
-        for (const element of source.elements)addPresentationElement(slide, element, presentation, slideWidth, slideHeight, groups, `slide:${source.id}`, element.placeholder ? binding?.placeholderNames.get(element.placeholder.key) : void 0);
+        const groupScope = `slide:${source.id}`;
+        groups.registerAnimatedElements(groupScope, source.animations?.map((animation)=>animation.elementId) ?? []);
+        for (const element of source.elements)addPresentationElement(slide, element, presentation, slideWidth, slideHeight, groups, groupScope, element.placeholder ? binding?.placeholderNames.get(element.placeholder.key) : void 0);
         if (source.notes?.trim()) slide.addNotes(source.notes);
     }
     return {
@@ -758,7 +776,8 @@ async function createPptxBlob(artifact, PptxGenJS) {
     const withChartSeriesAnalysis = await patchPptxChartSeriesAnalysis(withChartAxes, slides);
     const withTransitions = await patchPptxTransitions(withChartSeriesAnalysis, slides);
     const withComments = await patchPptxComments(withTransitions, slides, 'presentation' === artifact.content.type ? artifact.content.width ?? 13.333 : 13.333, 'presentation' === artifact.content.type ? artifact.content.height ?? 7.5 : 7.5);
-    const patched = await patchPptxNativeGroups(withComments, groups);
+    const withAnimations = await patchPptxAnimations(withComments, slides, groups);
+    const patched = await patchPptxNativeGroups(withAnimations, groups);
     return new Blob([
         patched
     ], {
@@ -886,8 +905,13 @@ function addPresentationElement(slide, element, presentation, slideWidth, slideH
         });
         return;
     }
-    if ('shape' === element.type) addShape(slide, element, presentation, x, y, width, height, resolvedPlaceholder, groups.objectName(groupScope, element, 'shape'));
-    if (element.text) addText(slide, element, x, y, width, height, resolvedPlaceholder, groups.objectName(groupScope, element, 'text'));
+    if ('shape' === element.type) {
+        const objectName = groups.objectName(groupScope, element, 'shape');
+        if (element.text || element.textRuns?.length) addText(slide, element, x, y, width, height, resolvedPlaceholder, objectName, pptxShapeType(presentation, element));
+        else addShape(slide, element, presentation, x, y, width, height, resolvedPlaceholder, objectName);
+        return;
+    }
+    if ('text' === element.type) addText(slide, element, x, y, width, height, resolvedPlaceholder, groups.objectName(groupScope, element, 'text'));
 }
 function pptxChartData(chart) {
     if (presentationChartUsesNumericXAxis(chart.type)) return [
@@ -926,7 +950,7 @@ function pptxLegendPosition(position) {
     return 'r';
 }
 function addShape(slide, element, presentation, x, y, width, height, placeholder, objectName) {
-    const shapeType = 'ellipse' === element.shapeType ? presentation.ShapeType.ellipse : 'triangle' === element.shapeType ? presentation.ShapeType.triangle : 'diamond' === element.shapeType ? presentation.ShapeType.diamond : 'roundRect' === element.shapeType ? presentation.ShapeType.roundRect : presentation.ShapeType.rect;
+    const shapeType = pptxShapeType(presentation, element);
     const fillColor = element.fill.replace('#', '');
     const borderColor = (element.borderColor ?? element.fill).replace('#', '');
     const options = {
@@ -954,7 +978,7 @@ function addShape(slide, element, presentation, x, y, width, height, placeholder
     };
     slide.addShape(shapeType, options);
 }
-function addText(slide, element, x, y, width, height, placeholder, objectName) {
+function addText(slide, element, x, y, width, height, placeholder, objectName, shape) {
     const text = element.textRuns?.length ? element.textRuns.map((run)=>({
             text: run.text,
             options: {
@@ -989,9 +1013,14 @@ function addText(slide, element, x, y, width, height, placeholder, objectName) {
         valign: element.verticalAlign ?? 'middle',
         margin: 'transparent' === element.fill ? 0 : 10,
         breakLine: false,
+        shape,
         fill: 'transparent' === element.fill ? void 0 : {
             color: element.fill.replace('#', '')
         },
+        line: element.borderWidth && element.borderColor ? {
+            color: element.borderColor.replace('#', ''),
+            width: element.borderWidth
+        } : void 0,
         hyperlink: element.href ? {
             url: element.href
         } : void 0,
@@ -1001,6 +1030,13 @@ function addText(slide, element, x, y, width, height, placeholder, objectName) {
         } : {}
     });
 }
+function pptxShapeType(presentation, element) {
+    if ('ellipse' === element.shapeType) return presentation.ShapeType.ellipse;
+    if ('triangle' === element.shapeType) return presentation.ShapeType.triangle;
+    if ('diamond' === element.shapeType) return presentation.ShapeType.diamond;
+    if ('roundRect' === element.shapeType) return presentation.ShapeType.roundRect;
+    return presentation.ShapeType.rect;
+}
 async function presentationArrayBuffer(output) {
     if (output instanceof ArrayBuffer) return output;
     if (output instanceof Blob) return output.arrayBuffer();

package/dist/0~work-pptx-import.js

@@ -1,6 +1,6 @@
 import { contentTypeForPart, directChildren, bytesToDataUrl, OoxmlPackage, firstDescendant, descendants, directChild, childPath, attribute, createOfficeId as createWorkId } from "./4121.js";
 import { normalizeRadarStyle, normalizePresentationChartLegendPosition, presentationChartUsesNumericXAxis, normalizePresentationBubbleScale, normalizePresentationBubbleSizeRepresents, withPresentationChartLayout, normalizeDoughnutHoleSize, normalizePresentationScatterStyle } from "./0~work-presentation-charts.js";
-import { loadPptxCommentAuthors, readPptxSlideComments, readPptxChartLayoutAndSeriesStyles, readPptxTransition, readPptxChartSeriesAnalysis, readPptxChartDataLabels } from "./0~7614.js";
+import { loadPptxCommentAuthors, readPptxSlideComments, readPptxChartLayoutAndSeriesStyles, readPptxAnimations, readPptxTransition, readPptxChartSeriesAnalysis, readPptxChartDataLabels } from "./0~7828.js";
 import { parseXlsxChartAxes } from "./4166.js";
 import { scaledPresentationVisuals } from "./0~work-presentation-visual-scale.js";
 async function loadPptxTheme(archive, presentationRelationships) {
@@ -547,6 +547,7 @@ async function parseSlide(archive, slidePart, slideNumber, slideWidthEmu, slideH
         theme,
         issues,
         imageBudget,
+        elementIdByPptxShapeId: new Map(),
         location: `幻灯片 ${slideNumber}`
     };
     const design = await ensurePptxDesignDefinitions(archive, inheritance.layout, inheritance.master, context, designs);
@@ -554,6 +555,7 @@ async function parseSlide(archive, slidePart, slideNumber, slideWidthEmu, slideH
     const shapeTree = firstDescendant(document1, 'spTree');
     for (const child of shapeTree ? directChildren(shapeTree) : [])elements.push(...await parseSlideNode(child, context));
     const resolvedElements = inheritPptxPlaceholderStyles(elements, design.master, design.layout);
+    const animationResult = readPptxAnimations(document1, context.elementIdByPptxShapeId);
     const transition = readPptxTransition(document1);
     const commentResult = await readPptxSlideComments(archive, relationships, commentAuthors, slideNumber, slideWidthEmu, slideHeightEmu);
     if (commentResult.comments.length) addIssue(context, 'pptx.comments', 'Comments', `${commentResult.comments.length} traditional slide comment(s), authors, dates, and positions are preserved and editable.`, 'info');
@@ -564,7 +566,8 @@ async function parseSlide(archive, slidePart, slideNumber, slideWidthEmu, slideH
         addIssue(context, 'pptx.transition', 'Slide transitions', transition.transition ? 'Basic slide transitions and advance timing are preserved, editable, and replayed in presentation preview.' : 'This slide transition is not editable and remains in the original PPTX only.', transition.transition ? 'info' : 'warning');
         for (const diagnostic of transition.diagnostics)addIssue(context, diagnostic.code, 'Slide transitions', diagnostic.message);
     }
-    if (firstDescendant(document1, 'timing')) addIssue(context, 'pptx.animation', 'Animations', 'Object animations are not replayed and will be omitted on export.');
+    if (animationResult.animations.length) addIssue(context, 'pptx.animation', 'Animations', `${animationResult.animations.length} supported object entrance animation(s) are preserved, editable, replayed, and exported.`, 'info');
+    for (const diagnostic of animationResult.diagnostics)addIssue(context, diagnostic.code, 'Animations', diagnostic.message);
     for (const relationship of relationships.values())if (relationship.type.includes('/audio') || relationship.type.includes('/video') || relationship.type.includes('/media')) addIssue(context, 'pptx.media', 'Embedded media', 'Audio and video remain in the original file but are not playable yet.');
     else if (relationship.type.endsWith('/oleObject') || relationship.type.endsWith('/package')) addIssue(context, 'pptx.ole', 'Embedded objects', 'Embedded Office or OLE objects remain in the original file only.');
     const slideBackground = readPptxBackground(document1, theme);
@@ -578,7 +581,8 @@ async function parseSlide(archive, slidePart, slideNumber, slideWidthEmu, slideH
         elements: resolvedElements,
         notes: await readSpeakerNotes(archive, relationships, context),
         comments: commentResult.comments.length ? commentResult.comments : void 0,
-        transition: transition.transition
+        transition: transition.transition,
+        animations: animationResult.animations.length ? animationResult.animations : void 0
     };
 }
 async function loadPptxPresentationDesigns(archive, relationships, slideWidthEmu, slideHeightEmu, theme, issues, imageBudget, registry) {
@@ -592,6 +596,7 @@ async function loadPptxPresentationDesigns(archive, relationships, slideWidthEmu
         theme,
         issues,
         imageBudget,
+        elementIdByPptxShapeId: new Map(),
         location: '母版与布局'
     };
     for (const relationship of relationships.values()){
@@ -659,6 +664,7 @@ function ensureFallbackPptxMaster(registry) {
 async function parsePptxDesignElements(part, context) {
     const partContext = {
         ...context,
+        elementIdByPptxShapeId: new Map(),
         relationships: part.relationships,
         placeholders: new Map()
     };
@@ -712,24 +718,30 @@ function inheritPptxPlaceholderStyle(element, definition) {
     };
 }
 async function parseSlideNode(node, context, transform) {
-    if ('sp' === node.localName) return [
+    let elements;
+    if ('sp' === node.localName) elements = [
         withImportedGroupTransform(parseShape(node, context, transform), transform)
     ];
-    if ('pic' === node.localName) return [
+    else if ('pic' === node.localName) elements = [
         withImportedGroupTransform(await parsePicture(node, context, transform), transform)
     ];
-    if ('graphicFrame' === node.localName) return [
+    else if ('graphicFrame' === node.localName) elements = [
         withImportedGroupTransform(await parseGraphicFrame(node, context, transform), transform)
     ];
-    if ('cxnSp' === node.localName) return [
+    else if ('cxnSp' === node.localName) elements = [
         withImportedGroupTransform(parseConnector(node, context, transform), transform)
     ];
-    if ('grpSp' === node.localName) return parseGroup(node, context, transform);
+    else {
+        if ('grpSp' === node.localName) return parseGroup(node, context, transform);
+        elements = [];
+    }
     if ([
         'contentPart',
         'oleObj'
     ].includes(node.localName)) addIssue(context, 'pptx.content-part', 'Embedded content', 'An embedded slide object remains available in the original PPTX only.');
-    return [];
+    const pptxShapeId = attribute(firstDescendant(node, 'cNvPr') ?? node, 'id');
+    if (pptxShapeId && 1 === elements.length) context.elementIdByPptxShapeId.set(pptxShapeId, elements[0].id);
+    return elements;
 }
 function parseShape(node, context, transform) {
     const box = elementBox(node, context, transform);

package/dist/4121.js

@@ -2918,6 +2918,13 @@ const WORK_TEMPLATES = [
         name: '策略汇报',
         description: '结论先行的三页汇报',
         accent: '#c85637'
+    },
+    {
+        id: 'animated-deck',
+        kind: 'presentation',
+        name: '入场动画',
+        description: '出现、淡入、飞入、缩放与三种触发方式',
+        accent: '#7657c8'
     }
 ];
 function createWorkArtifact(templateId) {
@@ -2951,7 +2958,8 @@ function initialTitle(templateId, kind) {
         'proofing-languages': '校对语言示例',
         'quarterly-plan': '季度执行计划',
         'data-validation': '数据验证示例',
-        'strategy-deck': '业务策略汇报'
+        'strategy-deck': '业务策略汇报',
+        'animated-deck': '入场动画示例'
     };
     if (titles[templateId]) return titles[templateId];
     if ('document' === kind) return '无标题文字';
@@ -3250,6 +3258,7 @@ function contentForTemplate(templateId) {
         sheets: dataValidationTemplateSheets()
     };
     if ('strategy-deck' === templateId) return strategyPresentation();
+    if ('animated-deck' === templateId) return animatedPresentation();
     if ('blank-spreadsheet' === templateId) return {
         type: 'spreadsheet',
         sheets: [
@@ -3836,6 +3845,118 @@ function strategyPresentation() {
         slides
     };
 }
+function animatedPresentation() {
+    const titleId = createWorkId('element');
+    const subtitleId = createWorkId('element');
+    const sequenceId = createWorkId('element');
+    const conclusionId = createWorkId('element');
+    return {
+        type: 'presentation',
+        slides: [
+            {
+                id: createWorkId('slide'),
+                name: '入场动画',
+                background: '#17162b',
+                notes: '从“动画”选项卡编辑效果、触发方式、持续时间、延迟和顺序，再从头放映验证逐步播放。',
+                elements: [
+                    {
+                        id: titleId,
+                        type: 'text',
+                        x: 8,
+                        y: 10,
+                        width: 76,
+                        height: 16,
+                        text: '让信息按叙事顺序出现',
+                        fontSize: 34,
+                        color: '#ffffff',
+                        fill: 'transparent',
+                        bold: true,
+                        align: 'left'
+                    },
+                    {
+                        id: subtitleId,
+                        type: 'text',
+                        x: 8,
+                        y: 28,
+                        width: 68,
+                        height: 9,
+                        text: '单击开始，下一对象与标题同时淡入',
+                        fontSize: 16,
+                        color: '#b9b7dc',
+                        fill: 'transparent',
+                        bold: false,
+                        align: 'left'
+                    },
+                    {
+                        id: sequenceId,
+                        type: 'shape',
+                        x: 8,
+                        y: 46,
+                        width: 52,
+                        height: 20,
+                        text: '上一动画完成后，从左侧飞入',
+                        fontSize: 19,
+                        color: '#211f35',
+                        fill: '#d9d3ff',
+                        bold: true,
+                        align: 'center',
+                        radius: 4
+                    },
+                    {
+                        id: conclusionId,
+                        type: 'shape',
+                        x: 66,
+                        y: 46,
+                        width: 26,
+                        height: 20,
+                        text: '再次单击\n缩放结论',
+                        fontSize: 17,
+                        color: '#ffffff',
+                        fill: '#7657c8',
+                        bold: true,
+                        align: 'center',
+                        radius: 5
+                    }
+                ],
+                animations: [
+                    {
+                        id: createWorkId('slide-animation'),
+                        elementId: titleId,
+                        effect: 'appear',
+                        trigger: 'on-click',
+                        durationMs: 300,
+                        delayMs: 0
+                    },
+                    {
+                        id: createWorkId('slide-animation'),
+                        elementId: subtitleId,
+                        effect: 'fade',
+                        trigger: 'with-previous',
+                        durationMs: 600,
+                        delayMs: 100
+                    },
+                    {
+                        id: createWorkId('slide-animation'),
+                        elementId: sequenceId,
+                        effect: 'fly-in',
+                        trigger: 'after-previous',
+                        durationMs: 700,
+                        delayMs: 150,
+                        direction: 'left'
+                    },
+                    {
+                        id: createWorkId('slide-animation'),
+                        elementId: conclusionId,
+                        effect: 'zoom',
+                        trigger: 'on-click',
+                        durationMs: 650,
+                        delayMs: 0
+                    }
+                ]
+            }
+        ]
+    };
+}
 const OFFICE_KERNEL_SPREADSHEET_MAX_ROWS = 1048576;
 const spreadsheetErrors = new Set([
     '#BLOCKED!',

package/dist/4560.js

@@ -44,8 +44,37 @@ function validateSlide(value) {
     slide.elements = validateRecords(record.elements, `element in slide '${slide.id}'`, validateElement);
     if (void 0 !== record.layoutId) slide.layoutId = requiredIdentifier(record.layoutId, 'slide layout');
     if (void 0 !== record.comments) slide.comments = validateRecords(record.comments, `comment in slide '${slide.id}'`, validateComment);
+    if (void 0 !== record.animations) slide.animations = validateSlideAnimations(record.animations, slide);
     return slide;
 }
+function validateSlideAnimations(value, slide) {
+    if (!Array.isArray(value) || value.length > 256) invalidWorkOfficePresentationInput("an array of at most 256 slide animations");
+    const animationIds = new Set();
+    const targetIds = new Set();
+    const elementIds = new Set(slide.elements.map((element)=>element.id));
+    return value.map((item)=>{
+        const record = requiredInputRecord(item, 'slide animation');
+        const animation = validateJsonRecord(record, 'slide animation');
+        animation.id = requiredIdentifier(record.id, 'slide animation');
+        animation.elementId = requiredIdentifier(record.elementId, 'slide animation element');
+        if (animationIds.has(animation.id)) invalidWorkOfficePresentationInput(`a unique slide animation ID; '${animation.id}' is repeated`);
+        if (!elementIds.has(animation.elementId)) invalidWorkOfficePresentationInput(`slide animation '${animation.id}' to reference an existing element`);
+        if (targetIds.has(animation.elementId)) invalidWorkOfficePresentationInput(`at most one entrance animation for element '${animation.elementId}'`);
+        if ('appear' !== record.effect && 'fade' !== record.effect && 'fly-in' !== record.effect && 'zoom' !== record.effect) invalidWorkOfficePresentationInput('a supported slide entrance animation effect');
+        animation.effect = record.effect;
+        if ('on-click' !== record.trigger && 'with-previous' !== record.trigger && 'after-previous' !== record.trigger) invalidWorkOfficePresentationInput('a supported slide animation trigger');
+        animation.trigger = record.trigger;
+        animation.durationMs = requiredIntegerInRange(record.durationMs, 100, 60000, 'slide animation duration');
+        animation.delayMs = requiredIntegerInRange(record.delayMs, 0, 60000, 'slide animation delay');
+        if ('fly-in' === animation.effect) {
+            if ('left' !== record.direction && 'right' !== record.direction && 'up' !== record.direction && 'down' !== record.direction) invalidWorkOfficePresentationInput('a direction for each fly-in animation');
+            animation.direction = record.direction;
+        } else if (void 0 !== record.direction) invalidWorkOfficePresentationInput('slide animation directions only on fly-in effects');
+        animationIds.add(animation.id);
+        targetIds.add(animation.elementId);
+        return animation;
+    });
+}
 function validateMaster(value) {
     const record = requiredInputRecord(value, 'presentation master');
     const master = validateJsonRecord(record, 'presentation master');
@@ -129,6 +158,10 @@ function requiredFiniteNumber(value, label) {
     if ('number' != typeof value || !Number.isFinite(value)) invalidWorkOfficePresentationInput(`a finite number for ${label}`);
     return value;
 }
+function requiredIntegerInRange(value, minimum, maximum, label) {
+    if ('number' != typeof value || !Number.isSafeInteger(value) || value < minimum || value > maximum) invalidWorkOfficePresentationInput(`an integer ${label} from ${minimum} through ${maximum}`);
+    return value;
+}
 function invalidWorkOfficePresentationInput(expected) {
     throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `Presentation collaboration requires ${expected}.`);
 }

package/dist/internal/features/work/editors/presentation-animation-panel.d.ts

@@ -0,0 +1,11 @@
+import type { WorkSlideAnimation, WorkSlideAnimationEffect } from '../work-types';
+export declare function PresentationAnimationPanel({ animation, canMove, canPreview, editable, onMove, onPreview, onSetEffect, onUpdate, }: {
+    animation: WorkSlideAnimation | undefined;
+    canMove: (direction: -1 | 1) => boolean;
+    canPreview: boolean;
+    editable: boolean;
+    onMove: (direction: -1 | 1) => void;
+    onPreview: () => void;
+    onSetEffect: (effect: WorkSlideAnimationEffect | undefined) => void;
+    onUpdate: (patch: Partial<WorkSlideAnimation>) => void;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/presentation-command-types.d.ts

@@ -1,5 +1,5 @@
 import type { OfficeKernelPresentationAlignment } from '../../../kernel/office-kernel-protocol';
-import type { WorkPresentationContent, WorkSlideElement, WorkSlideTransition, WorkSlideTextRun } from '../work-types';
+import type { WorkPresentationContent, WorkSlideAnimation, WorkSlideAnimationEffect, WorkSlideElement, WorkSlideTransition, WorkSlideTextRun } from '../work-types';
 import type { OfficeEditorCanCommands } from './office-editor-extension';
 import type { PresentationDesignMode } from './presentation-editor-types';
 import type { PresentationDistribution } from './presentation-selection';
@@ -37,9 +37,11 @@ export interface PresentationEditorCommands {
     groupElements: () => boolean;
     instantiatePlaceholder: (definition: WorkSlideElement) => PresentationCommandResult;
     locatePresentationComment: (slideId: string, commentId: string) => PresentationCommandResult;
+    moveEntranceAnimation: (direction: -1 | 1) => PresentationCommandResult;
     nudgeSelection: (key: string, distance: number) => boolean;
     openComment: (commentId: string) => PresentationCommandResult;
     pasteSelection: () => boolean;
+    previewAnimations: () => PresentationCommandResult;
     redo: () => boolean;
     renamePresentationLayout: (name: string) => PresentationCommandResult;
     renamePresentationMaster: (name: string) => PresentationCommandResult;
@@ -50,6 +52,7 @@ export interface PresentationEditorCommands {
     selectSlide: (slideId: string, returnToSlideMode?: boolean) => PresentationCommandResult;
     setPresentationContent: (content: WorkPresentationContent) => PresentationCommandResult;
     setBackground: (color: string) => PresentationCommandResult;
+    setEntranceAnimation: (effect: WorkSlideAnimationEffect | undefined) => PresentationCommandResult;
     setPresentationLayoutBackground: (color: string | undefined) => PresentationCommandResult;
     setPresentationMasterBackground: (color: string) => PresentationCommandResult;
     setTransition: (transition: WorkSlideTransition | undefined) => PresentationCommandResult;
@@ -66,6 +69,7 @@ export interface PresentationEditorCommands {
     updateElement: (patch: Partial<WorkSlideElement>, options?: {
         restoreTextFocus?: boolean;
     }) => PresentationCommandResult;
+    updateEntranceAnimation: (patch: Partial<WorkSlideAnimation>) => PresentationCommandResult;
     updateNotes: (notes: string) => PresentationCommandResult;
     updatePresentationComment: (slideId: string, commentId: string, text: string) => PresentationCommandResult;
     updateTextElement: (elementId: string, value: {
@@ -107,6 +111,16 @@ export interface PresentationSlideCommandPort {
     setTransition: (transition: WorkSlideTransition | undefined) => PresentationCommandResult;
     updateNotes: (notes: string) => PresentationCommandResult;
 }
+export interface PresentationAnimationCommandPort {
+    canMoveEntranceAnimation: (direction: -1 | 1) => boolean;
+    canPreviewAnimations: boolean;
+    canSetEntranceAnimation: boolean;
+    canUpdateEntranceAnimation: boolean;
+    moveEntranceAnimation: (direction: -1 | 1) => PresentationCommandResult;
+    previewAnimations: () => PresentationCommandResult;
+    setEntranceAnimation: (effect: WorkSlideAnimationEffect | undefined) => PresentationCommandResult;
+    updateEntranceAnimation: (patch: Partial<WorkSlideAnimation>) => PresentationCommandResult;
+}
 export interface PresentationInsertCommandPort {
     enabled: boolean;
     addChart: () => PresentationCommandResult;
@@ -192,6 +206,7 @@ export interface PresentationKeyboardCommandPort {
     selectedElementCount: number;
 }
 export interface PresentationCommandContext {
+    animations: PresentationAnimationCommandPort;
     clipboard: PresentationClipboardCommandPort;
     design: PresentationDesignCommandPort;
     document: PresentationDocumentCommandPort;

package/dist/internal/features/work/editors/presentation-presenter-view.d.ts

@@ -4,7 +4,8 @@ export interface PresentationTimerController {
     runningSinceMilliseconds: number | null;
 }
 export declare function createPresentationTimerController(now?: number): PresentationTimerController;
-export declare function PresentationPresenterView({ content, slide, nextSlide, index, total, aspectRatio, timer, }: {
+export declare function PresentationPresenterView({ animationCueIndex, content, slide, nextSlide, index, total, aspectRatio, timer, }: {
+    animationCueIndex?: number;
     content: WorkPresentationContent;
     slide: WorkSlide;
     nextSlide?: WorkSlide;

package/dist/internal/features/work/editors/presentation-slide-canvas.d.ts

@@ -1,14 +1,16 @@
 import { type WorkPresentationDesignContent } from '../work-presentation-layouts';
-import type { WorkPresentationContent, WorkSlide, WorkSlideElement } from '../work-types';
-export declare function SlideCanvas({ content, designContent, slide, interactive, aspectRatio, showPlaceholders, }: {
+import type { WorkPresentationContent, WorkSlide, WorkSlideAnimation, WorkSlideElement } from '../work-types';
+export declare function SlideCanvas({ content, designContent, slide, interactive, aspectRatio, animationCueIndex, showPlaceholders, }: {
     content?: WorkPresentationContent;
     designContent?: WorkPresentationDesignContent;
     slide: WorkSlide;
     interactive: boolean;
     aspectRatio: string;
+    animationCueIndex?: number;
     showPlaceholders?: boolean;
 }): import("react").JSX.Element;
-export declare function SlideElementPreview({ element, origin, showPlaceholder, }: {
+export declare function SlideElementPreview({ animationPlayback, element, origin, showPlaceholder, }: {
+    animationPlayback?: SlideElementAnimationPlayback;
     element: WorkSlideElement;
     origin: 'inherited' | 'slide';
     showPlaceholder?: boolean;
@@ -18,6 +20,11 @@ export declare function EditableSlideTable({ element, onChange, }: {
     onChange: (rows: string[][]) => void;
 }): import("react").JSX.Element | null;
 export declare function slideElementStyle(element: WorkSlideElement): React.CSSProperties;
+interface SlideElementAnimationPlayback {
+    animation: WorkSlideAnimation;
+    startOffsetMs: number;
+    state: 'finished' | 'pending' | 'playing';
+}
 export declare function slideTextStyle(element: WorkSlideElement): React.CSSProperties;
 export declare function SlideElementTextPreview({ element, showPlaceholder, }: {
     element: WorkSlideElement;
@@ -26,3 +33,4 @@ export declare function SlideElementTextPreview({ element, showPlaceholder, }: {
 export declare function SlideTablePreview({ element }: {
     element: WorkSlideElement;
 }): import("react").JSX.Element | null;
+export {};

package/dist/internal/features/work/editors/use-presentation-animation-commands.d.ts

@@ -0,0 +1,15 @@
+import type { WorkPresentationContent, WorkSlide, WorkSlideAnimation, WorkSlideAnimationEffect } from '../work-types';
+export interface PresentationAnimationCommands {
+    canMoveEntranceAnimation: (direction: -1 | 1) => boolean;
+    canSetEntranceAnimation: boolean;
+    canUpdateEntranceAnimation: boolean;
+    moveEntranceAnimation: (direction: -1 | 1) => boolean;
+    setEntranceAnimation: (effect: WorkSlideAnimationEffect | undefined) => boolean;
+    updateEntranceAnimation: (patch: Partial<WorkSlideAnimation>) => boolean;
+}
+export declare function usePresentationAnimationCommands({ content, onChange, selectedElementId, selectedSlide, }: {
+    content: WorkPresentationContent;
+    onChange: (content: WorkPresentationContent) => void;
+    selectedElementId: string | undefined;
+    selectedSlide: WorkSlide;
+}): PresentationAnimationCommands;

package/dist/internal/features/work/work-pptx-animation.d.ts

@@ -0,0 +1,13 @@
+import type { PptxGroupExportRegistry } from './work-pptx-groups';
+import type { WorkSlide, WorkSlideAnimation } from './work-types';
+interface PptxAnimationDiagnostic {
+    code: string;
+    message: string;
+}
+interface PptxAnimationReadResult {
+    animations: WorkSlideAnimation[];
+    diagnostics: PptxAnimationDiagnostic[];
+}
+export declare function readPptxAnimations(document: Document, elementIdByPptxShapeId: ReadonlyMap<string, string>): PptxAnimationReadResult;
+export declare function patchPptxAnimations(buffer: ArrayBuffer, slides: readonly WorkSlide[], registry: PptxGroupExportRegistry): Promise<ArrayBuffer>;
+export {};

package/dist/internal/features/work/work-pptx-groups.d.ts

@@ -7,11 +7,15 @@ interface PptxExportBinding {
     marker: string;
 }
 export declare class PptxGroupExportRegistry {
+    private readonly animatedElementKeys;
     private readonly bindings;
+    private readonly bindingsByElement;
     private readonly roleCounts;
     private markerSequence;
     get size(): number;
+    registerAnimatedElements(scope: string, elementIds: Iterable<string>): void;
     objectName(scope: string, element: WorkSlideElement, role: PptxExportObjectRole): string | undefined;
+    markerForElement(scope: string, elementId: string): string | undefined;
     binding(marker: string): PptxExportBinding | undefined;
     values(): IterableIterator<PptxExportBinding>;
 }

package/dist/internal/features/work/work-presentation-animation-constraints.d.ts

@@ -0,0 +1,4 @@
+export declare const WORK_SLIDE_ANIMATION_LIMIT = 256;
+export declare const WORK_SLIDE_ANIMATION_MIN_DURATION_MS = 100;
+export declare const WORK_SLIDE_ANIMATION_MAX_DURATION_MS = 60000;
+export declare const WORK_SLIDE_ANIMATION_MAX_DELAY_MS = 60000;