@a3s-lab/office 0.38.0 → 0.39.0

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

@@ -566,7 +566,7 @@ 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 (animationResult.animations.length) addIssue(context, 'pptx.animation', 'Animations', `${animationResult.animations.length} supported object entrance animation(s) are preserved, editable, replayed, and exported.`, 'info');
+    if (animationResult.animations.length) addIssue(context, 'pptx.animation', 'Animations', `${animationResult.animations.length} supported object entrance or exit 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.');

package/dist/0~work-presentation-transition.js

@@ -0,0 +1,38 @@
+const CARDINAL_DIRECTIONS = new Set([
+    'left',
+    'right',
+    'up',
+    'down'
+]);
+const SPLIT_DIRECTIONS = new Set([
+    'in',
+    'out'
+]);
+function createWorkSlideTransition(type, previous) {
+    const common = {
+        type,
+        speed: previous?.speed ?? 'medium',
+        advanceOnClick: previous?.advanceOnClick ?? true,
+        advanceAfterMs: previous?.advanceAfterMs
+    };
+    if ('push' === type || 'wipe' === type) return {
+        ...common,
+        direction: previous?.direction && CARDINAL_DIRECTIONS.has(previous.direction) ? previous.direction : 'left'
+    };
+    if ('split' === type) return {
+        ...common,
+        direction: previous?.direction && SPLIT_DIRECTIONS.has(previous.direction) ? previous.direction : 'out',
+        orientation: previous?.orientation ?? 'horizontal'
+    };
+    return common;
+}
+function slideTransitionDurationMilliseconds(transition) {
+    if (transition?.speed === 'fast') return 500;
+    if (transition?.speed === 'slow') return 2000;
+    return 1000;
+}
+function workSlideTransitionsEqual(left, right) {
+    if (!left || !right) return left === right;
+    return left.type === right.type && left.speed === right.speed && left.direction === right.direction && left.orientation === right.orientation && left.advanceOnClick === right.advanceOnClick && left.advanceAfterMs === right.advanceAfterMs;
+}
+export { createWorkSlideTransition, slideTransitionDurationMilliseconds, workSlideTransitionsEqual };

package/dist/4121.js

@@ -2929,8 +2929,8 @@ const WORK_TEMPLATES = [
     {
         id: 'animated-deck',
         kind: 'presentation',
-        name: '入场动画',
-        description: '出现、淡入、飞入、缩放与三种触发方式',
+        name: '进入与退出动画',
+        description: '进入、退出、触发、计时、排序与放映预览',
         accent: '#7657c8'
     }
 ];
@@ -2967,7 +2967,7 @@ function initialTitle(templateId, kind) {
         'data-validation': '数据验证示例',
         'structured-references': '结构化引用示例',
         'strategy-deck': '业务策略汇报',
-        'animated-deck': '入场动画示例'
+        'animated-deck': '进入与退出动画示例'
     };
     if (titles[templateId]) return titles[templateId];
     if ('document' === kind) return '无标题文字';
@@ -4115,9 +4115,9 @@ function animatedPresentation() {
         slides: [
             {
                 id: createWorkId('slide'),
-                name: '入场动画',
+                name: '进入与退出',
                 background: '#17162b',
-                notes: '从“动画”选项卡编辑效果、触发方式、持续时间、延迟和顺序，再从头放映验证逐步播放。',
+                notes: '从“动画”选项卡分别编辑进入与退出效果、触发方式、持续时间、延迟和顺序，再从头放映验证逐步播放。',
                 elements: [
                     {
                         id: titleId,
@@ -4126,7 +4126,7 @@ function animatedPresentation() {
                         y: 10,
                         width: 76,
                         height: 16,
-                        text: '让信息按叙事顺序出现',
+                        text: '让对象按叙事顺序登场与退场',
                         fontSize: 34,
                         color: '#ffffff',
                         fill: 'transparent',
@@ -4140,7 +4140,7 @@ function animatedPresentation() {
                         y: 28,
                         width: 68,
                         height: 9,
-                        text: '单击开始，下一对象与标题同时淡入',
+                        text: '一次单击完成入场，再次单击依次退场',
                         fontSize: 16,
                         color: '#b9b7dc',
                         fill: 'transparent',
@@ -4154,7 +4154,7 @@ function animatedPresentation() {
                         y: 46,
                         width: 52,
                         height: 20,
-                        text: '上一动画完成后，从左侧飞入',
+                        text: '从左侧飞入，再向右侧飞出',
                         fontSize: 19,
                         color: '#211f35',
                         fill: '#d9d3ff',
@@ -4169,7 +4169,7 @@ function animatedPresentation() {
                         y: 46,
                         width: 26,
                         height: 20,
-                        text: '再次单击\n缩放结论',
+                        text: '最后缩放\n进入与退出',
                         fontSize: 17,
                         color: '#ffffff',
                         fill: '#7657c8',
@@ -4208,7 +4208,40 @@ function animatedPresentation() {
                         id: createWorkId('slide-animation'),
                         elementId: conclusionId,
                         effect: 'zoom',
+                        trigger: 'after-previous',
+                        durationMs: 650,
+                        delayMs: 0
+                    },
+                    {
+                        id: createWorkId('slide-animation'),
+                        elementId: titleId,
+                        effect: 'disappear',
                         trigger: 'on-click',
+                        durationMs: 300,
+                        delayMs: 0
+                    },
+                    {
+                        id: createWorkId('slide-animation'),
+                        elementId: subtitleId,
+                        effect: 'fade-out',
+                        trigger: 'with-previous',
+                        durationMs: 600,
+                        delayMs: 100
+                    },
+                    {
+                        id: createWorkId('slide-animation'),
+                        elementId: sequenceId,
+                        effect: 'fly-out',
+                        trigger: 'after-previous',
+                        durationMs: 700,
+                        delayMs: 150,
+                        direction: 'right'
+                    },
+                    {
+                        id: createWorkId('slide-animation'),
+                        elementId: conclusionId,
+                        effect: 'zoom-out',
+                        trigger: 'after-previous',
                         durationMs: 650,
                         delayMs: 0
                     }

package/dist/4560.js

@@ -1,6 +1,117 @@
+import { createOfficeId as createWorkId } from "./4121.js";
 import { initializeWorkOfficeCollaborationMetadata, assertWorkOfficeCollaborationEditable, OfficeCollaborationError as WorkOfficeCollaborationError, readOfficeCollaborationMetadata as readWorkOfficeCollaborationMetadata, registerWorkOfficeCollaborationInitializer, markWorkOfficeCollaborationInitialized, assertWorkOfficeCollaborationOrigin } from "./9787.js";
 import { workOfficeCollaborationJsonEqual, canonicalWorkOfficeCollaborationJson, isWorkOfficeCollaborationRecord, cloneWorkOfficeCollaborationJson } from "./4650.js";
 import * as __rspack_external_yjs from "yjs";
+function createWorkSlideAnimation(elementId, effect, previous) {
+    return normalizeWorkSlideAnimation({
+        id: previous?.id ?? createWorkId('slide-animation'),
+        elementId,
+        effect,
+        trigger: previous?.trigger ?? 'on-click',
+        durationMs: previous?.durationMs ?? 500,
+        delayMs: previous?.delayMs ?? 0,
+        direction: isFlyAnimationEffect(effect) ? previous?.direction ?? 'left' : void 0
+    });
+}
+function normalizeWorkSlideAnimation(animation) {
+    return {
+        ...animation,
+        durationMs: boundedInteger(animation.durationMs, 100, 60000),
+        delayMs: boundedInteger(animation.delayMs, 0, 60000),
+        direction: isFlyAnimationEffect(animation.effect) ? normalizeWorkSlideAnimationDirection(animation.direction) : void 0
+    };
+}
+function workSlideAnimationClass(effect) {
+    return 'disappear' === effect || 'fade-out' === effect || 'fly-out' === effect || 'zoom-out' === effect ? 'exit' : 'entrance';
+}
+function workSlideAnimationEffectMatchesClass(effect, animationClass) {
+    return workSlideAnimationClass(effect) === animationClass;
+}
+function workSlideAnimationForElement(slide, elementId, animationClass) {
+    if (!elementId) return;
+    return slide.animations?.find((animation)=>animation.elementId === elementId && workSlideAnimationClass(animation.effect) === animationClass);
+}
+function workSlideAnimationIndex(slide, animationId) {
+    if (!animationId) return -1;
+    return slide.animations?.findIndex((animation)=>animation.id === animationId) ?? -1;
+}
+function workSlideAnimationCues(animations) {
+    const cues = [];
+    let current;
+    for (const raw of animations ?? []){
+        const animation = normalizeWorkSlideAnimation(raw);
+        if (!current || 'on-click' === animation.trigger) {
+            current = {
+                automatic: 'on-click' !== animation.trigger,
+                items: [],
+                totalDurationMs: 0
+            };
+            cues.push(current);
+        }
+        const previous = current.items.at(-1);
+        const baseStart = 'after-previous' === animation.trigger ? previous?.endOffsetMs ?? 0 : 'with-previous' === animation.trigger ? previous?.startOffsetMs ?? 0 : 0;
+        const startOffsetMs = baseStart + animation.delayMs;
+        const endOffsetMs = startOffsetMs + animation.durationMs;
+        current.items.push({
+            animation,
+            startOffsetMs,
+            endOffsetMs
+        });
+        current.totalDurationMs = Math.max(current.totalDurationMs, endOffsetMs);
+    }
+    return cues;
+}
+function initialWorkSlideAnimationCueIndex(cues) {
+    return cues[0]?.automatic ? 0 : -1;
+}
+function workSlideAnimationSequenceIssue(animations) {
+    const classTargets = new Set();
+    for (const animation of animations ?? []){
+        const key = `${animation.elementId}\u0000${workSlideAnimationClass(animation.effect)}`;
+        if (classTargets.has(key)) return 'duplicate-class';
+        classTargets.add(key);
+    }
+    for (const cue of workSlideAnimationCues(animations)){
+        const rangesByTarget = new Map();
+        for (const item of cue.items){
+            const ranges = rangesByTarget.get(item.animation.elementId) ?? [];
+            if (ranges.some((range)=>item.startOffsetMs < range.endOffsetMs && item.endOffsetMs > range.startOffsetMs)) return 'overlapping-target';
+            ranges.push(item);
+            rangesByTarget.set(item.animation.elementId, ranges);
+        }
+    }
+}
+function removeWorkSlideAnimationsForElements(slide, elementIds) {
+    const animations = slide.animations?.filter((animation)=>!elementIds.has(animation.elementId));
+    if (animations?.length === slide.animations?.length) return slide;
+    return {
+        ...slide,
+        animations: animations?.length ? animations : void 0
+    };
+}
+function remapWorkSlideAnimations(animations, elementIds) {
+    const remapped = (animations ?? []).flatMap((animation)=>{
+        const elementId = elementIds.get(animation.elementId);
+        return elementId ? [
+            {
+                ...animation,
+                id: createWorkId('slide-animation'),
+                elementId
+            }
+        ] : [];
+    });
+    return remapped.length ? remapped : void 0;
+}
+function normalizeWorkSlideAnimationDirection(direction) {
+    return 'right' === direction || 'up' === direction || 'down' === direction ? direction : 'left';
+}
+function isFlyAnimationEffect(effect) {
+    return 'fly-in' === effect || 'fly-out' === effect;
+}
+function boundedInteger(value, minimum, maximum) {
+    const finite = Number.isFinite(value) ? Math.round(value) : minimum;
+    return Math.min(maximum, Math.max(minimum, finite));
+}
 function validateWorkOfficePresentationContent(content) {
     if (!content || 'presentation' !== content.type) invalidWorkOfficePresentationInput('a Presentation content value');
     const result = {
@@ -50,30 +161,34 @@ function validateSlide(value) {
 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 classTargetIds = new Set();
     const elementIds = new Set(slide.elements.map((element)=>element.id));
-    return value.map((item)=>{
+    const animations = 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');
+        if ('appear' !== record.effect && 'fade' !== record.effect && 'fly-in' !== record.effect && 'zoom' !== record.effect && 'disappear' !== record.effect && 'fade-out' !== record.effect && 'fly-out' !== record.effect && 'zoom-out' !== record.effect) invalidWorkOfficePresentationInput('a supported slide entrance or exit animation effect');
         animation.effect = record.effect;
+        const animationClass = workSlideAnimationClass(animation.effect);
+        const classTargetId = `${animation.elementId}\u0000${animationClass}`;
+        if (classTargetIds.has(classTargetId)) invalidWorkOfficePresentationInput(`at most one ${animationClass} animation for element '${animation.elementId}'`);
         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');
+        if ('fly-in' === animation.effect || 'fly-out' === animation.effect) {
+            if ('left' !== record.direction && 'right' !== record.direction && 'up' !== record.direction && 'down' !== record.direction) invalidWorkOfficePresentationInput('a direction for each fly-in or fly-out animation');
             animation.direction = record.direction;
-        } else if (void 0 !== record.direction) invalidWorkOfficePresentationInput('slide animation directions only on fly-in effects');
+        } else if (void 0 !== record.direction) invalidWorkOfficePresentationInput('slide animation directions only on fly-in or fly-out effects');
         animationIds.add(animation.id);
-        targetIds.add(animation.elementId);
+        classTargetIds.add(classTargetId);
         return animation;
     });
+    if ('overlapping-target' === workSlideAnimationSequenceIssue(animations)) invalidWorkOfficePresentationInput('animations for one element to avoid overlapping inside one playback cue');
+    return animations;
 }
 function validateMaster(value) {
     const record = requiredInputRecord(value, 'presentation master');
@@ -857,4 +972,4 @@ function assertInitializedPresentationSession(session) {
     if (metadata?.initialized) return;
     throw new WorkOfficeCollaborationError('office.collaboration.not_initialized', 'The Presentation collaboration session has not been initialized.');
 }
-export { createWorkOfficePresentationCollaborationBinding as createOfficePresentationCollaborationBinding, initializeWorkOfficePresentationCollaboration as initializeOfficePresentationCollaboration, readWorkOfficePresentationCollaboration as readOfficePresentationCollaboration, replaceWorkOfficePresentationCollaboration as replaceOfficePresentationCollaboration };
+export { createWorkOfficePresentationCollaborationBinding as createOfficePresentationCollaborationBinding, createWorkSlideAnimation, initialWorkSlideAnimationCueIndex, initializeWorkOfficePresentationCollaboration as initializeOfficePresentationCollaboration, normalizeWorkSlideAnimation, readWorkOfficePresentationCollaboration as readOfficePresentationCollaboration, remapWorkSlideAnimations, removeWorkSlideAnimationsForElements, replaceWorkOfficePresentationCollaboration as replaceOfficePresentationCollaboration, workSlideAnimationClass, workSlideAnimationCues, workSlideAnimationEffectMatchesClass, workSlideAnimationForElement, workSlideAnimationIndex, workSlideAnimationSequenceIssue };

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

@@ -1,11 +1,13 @@
-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;
+import type { WorkSlideAnimation, WorkSlideAnimationClass, WorkSlideAnimationEffect } from '../work-types';
+export declare function PresentationAnimationPanel({ animations, canMove, canPreview, canUpdate, editable, elementId, onMove, onPreview, onSetEffect, onUpdate, }: {
+    animations: Record<WorkSlideAnimationClass, WorkSlideAnimation | undefined>;
+    canMove: (animationClass: WorkSlideAnimationClass, direction: -1 | 1) => boolean;
     canPreview: boolean;
+    canUpdate: (animationClass: WorkSlideAnimationClass, patch: Partial<WorkSlideAnimation>) => boolean;
     editable: boolean;
-    onMove: (direction: -1 | 1) => void;
+    elementId: string | undefined;
+    onMove: (animationClass: WorkSlideAnimationClass, direction: -1 | 1) => void;
     onPreview: () => void;
-    onSetEffect: (effect: WorkSlideAnimationEffect | undefined) => void;
-    onUpdate: (patch: Partial<WorkSlideAnimation>) => void;
+    onSetEffect: (animationClass: WorkSlideAnimationClass, effect: WorkSlideAnimationEffect | undefined) => void;
+    onUpdate: (animationClass: WorkSlideAnimationClass, 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, WorkSlideAnimation, WorkSlideAnimationEffect, WorkSlideElement, WorkSlideTransition, WorkSlideTextRun } from '../work-types';
+import type { WorkPresentationContent, WorkSlideAnimation, WorkSlideAnimationClass, 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,7 +37,7 @@ export interface PresentationEditorCommands {
     groupElements: () => boolean;
     instantiatePlaceholder: (definition: WorkSlideElement) => PresentationCommandResult;
     locatePresentationComment: (slideId: string, commentId: string) => PresentationCommandResult;
-    moveEntranceAnimation: (direction: -1 | 1) => PresentationCommandResult;
+    moveAnimation: (animationClass: WorkSlideAnimationClass, direction: -1 | 1) => PresentationCommandResult;
     nudgeSelection: (key: string, distance: number) => boolean;
     openComment: (commentId: string) => PresentationCommandResult;
     pasteSelection: () => boolean;
@@ -52,7 +52,7 @@ export interface PresentationEditorCommands {
     selectSlide: (slideId: string, returnToSlideMode?: boolean) => PresentationCommandResult;
     setPresentationContent: (content: WorkPresentationContent) => PresentationCommandResult;
     setBackground: (color: string) => PresentationCommandResult;
-    setEntranceAnimation: (effect: WorkSlideAnimationEffect | undefined) => PresentationCommandResult;
+    setAnimation: (animationClass: WorkSlideAnimationClass, effect: WorkSlideAnimationEffect | undefined) => PresentationCommandResult;
     setPresentationLayoutBackground: (color: string | undefined) => PresentationCommandResult;
     setPresentationMasterBackground: (color: string) => PresentationCommandResult;
     setTransition: (transition: WorkSlideTransition | undefined) => PresentationCommandResult;
@@ -69,7 +69,7 @@ export interface PresentationEditorCommands {
     updateElement: (patch: Partial<WorkSlideElement>, options?: {
         restoreTextFocus?: boolean;
     }) => PresentationCommandResult;
-    updateEntranceAnimation: (patch: Partial<WorkSlideAnimation>) => PresentationCommandResult;
+    updateAnimation: (animationClass: WorkSlideAnimationClass, patch: Partial<WorkSlideAnimation>) => PresentationCommandResult;
     updateNotes: (notes: string) => PresentationCommandResult;
     updatePresentationComment: (slideId: string, commentId: string, text: string) => PresentationCommandResult;
     updateTextElement: (elementId: string, value: {
@@ -112,14 +112,14 @@ export interface PresentationSlideCommandPort {
     updateNotes: (notes: string) => PresentationCommandResult;
 }
 export interface PresentationAnimationCommandPort {
-    canMoveEntranceAnimation: (direction: -1 | 1) => boolean;
+    canMoveAnimation: (animationClass: WorkSlideAnimationClass, direction: -1 | 1) => boolean;
     canPreviewAnimations: boolean;
-    canSetEntranceAnimation: boolean;
-    canUpdateEntranceAnimation: boolean;
-    moveEntranceAnimation: (direction: -1 | 1) => PresentationCommandResult;
+    canSetAnimation: boolean;
+    canUpdateAnimation: (animationClass: WorkSlideAnimationClass, patch: Partial<WorkSlideAnimation>) => boolean;
+    moveAnimation: (animationClass: WorkSlideAnimationClass, direction: -1 | 1) => PresentationCommandResult;
     previewAnimations: () => PresentationCommandResult;
-    setEntranceAnimation: (effect: WorkSlideAnimationEffect | undefined) => PresentationCommandResult;
-    updateEntranceAnimation: (patch: Partial<WorkSlideAnimation>) => PresentationCommandResult;
+    setAnimation: (animationClass: WorkSlideAnimationClass, effect: WorkSlideAnimationEffect | undefined) => PresentationCommandResult;
+    updateAnimation: (animationClass: WorkSlideAnimationClass, patch: Partial<WorkSlideAnimation>) => PresentationCommandResult;
 }
 export interface PresentationInsertCommandPort {
     enabled: boolean;

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

@@ -1,5 +1,6 @@
 import { type WorkPresentationDesignContent } from '../work-presentation-layouts';
-import type { WorkPresentationContent, WorkSlide, WorkSlideAnimation, WorkSlideElement } from '../work-types';
+import { type WorkSlideAnimationCueItem } from '../work-presentation-animation';
+import type { WorkPresentationContent, WorkSlide, WorkSlideElement } from '../work-types';
 export declare function SlideCanvas({ content, designContent, slide, interactive, aspectRatio, animationCueIndex, showPlaceholders, }: {
     content?: WorkPresentationContent;
     designContent?: WorkPresentationDesignContent;
@@ -21,9 +22,10 @@ export declare function EditableSlideTable({ element, onChange, }: {
 }): import("react").JSX.Element | null;
 export declare function slideElementStyle(element: WorkSlideElement): React.CSSProperties;
 interface SlideElementAnimationPlayback {
-    animation: WorkSlideAnimation;
-    startOffsetMs: number;
-    state: 'finished' | 'pending' | 'playing';
+    animations: WorkSlideAnimationCueItem[];
+    finallyVisible: boolean;
+    initiallyVisible: boolean;
+    state: 'hidden' | 'playing' | 'visible';
 }
 export declare function slideTextStyle(element: WorkSlideElement): React.CSSProperties;
 export declare function SlideElementTextPreview({ element, showPlaceholder, }: {

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

@@ -1,11 +1,11 @@
-import type { WorkPresentationContent, WorkSlide, WorkSlideAnimation, WorkSlideAnimationEffect } from '../work-types';
+import type { WorkPresentationContent, WorkSlide, WorkSlideAnimation, WorkSlideAnimationClass, 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;
+    canMoveAnimation: (animationClass: WorkSlideAnimationClass, direction: -1 | 1) => boolean;
+    canSetAnimation: boolean;
+    canUpdateAnimation: (animationClass: WorkSlideAnimationClass, patch: Partial<WorkSlideAnimation>) => boolean;
+    moveAnimation: (animationClass: WorkSlideAnimationClass, direction: -1 | 1) => boolean;
+    setAnimation: (animationClass: WorkSlideAnimationClass, effect: WorkSlideAnimationEffect | undefined) => boolean;
+    updateAnimation: (animationClass: WorkSlideAnimationClass, patch: Partial<WorkSlideAnimation>) => boolean;
 }
 export declare function usePresentationAnimationCommands({ content, onChange, selectedElementId, selectedSlide, }: {
     content: WorkPresentationContent;

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

@@ -1,4 +1,4 @@
-import type { WorkSlide, WorkSlideAnimation, WorkSlideAnimationEffect } from './work-types';
+import type { WorkSlide, WorkSlideAnimation, WorkSlideAnimationClass, WorkSlideAnimationEffect } from './work-types';
 export { WORK_SLIDE_ANIMATION_LIMIT, WORK_SLIDE_ANIMATION_MAX_DELAY_MS, WORK_SLIDE_ANIMATION_MAX_DURATION_MS, WORK_SLIDE_ANIMATION_MIN_DURATION_MS, } from './work-presentation-animation-constraints';
 export interface WorkSlideAnimationCueItem {
     animation: WorkSlideAnimation;
@@ -10,11 +10,15 @@ export interface WorkSlideAnimationCue {
     items: WorkSlideAnimationCueItem[];
     totalDurationMs: number;
 }
+export type WorkSlideAnimationSequenceIssue = 'duplicate-class' | 'overlapping-target';
 export declare function createWorkSlideAnimation(elementId: string, effect: WorkSlideAnimationEffect, previous?: WorkSlideAnimation): WorkSlideAnimation;
 export declare function normalizeWorkSlideAnimation(animation: WorkSlideAnimation): WorkSlideAnimation;
-export declare function workSlideAnimationForElement(slide: WorkSlide, elementId: string | undefined): WorkSlideAnimation | undefined;
+export declare function workSlideAnimationClass(effect: WorkSlideAnimationEffect): WorkSlideAnimationClass;
+export declare function workSlideAnimationEffectMatchesClass(effect: WorkSlideAnimationEffect, animationClass: WorkSlideAnimationClass): boolean;
+export declare function workSlideAnimationForElement(slide: WorkSlide, elementId: string | undefined, animationClass: WorkSlideAnimationClass): WorkSlideAnimation | undefined;
 export declare function workSlideAnimationIndex(slide: WorkSlide, animationId: string | undefined): number;
 export declare function workSlideAnimationCues(animations: readonly WorkSlideAnimation[] | undefined): WorkSlideAnimationCue[];
 export declare function initialWorkSlideAnimationCueIndex(cues: readonly WorkSlideAnimationCue[]): number;
+export declare function workSlideAnimationSequenceIssue(animations: readonly WorkSlideAnimation[] | undefined): WorkSlideAnimationSequenceIssue | undefined;
 export declare function removeWorkSlideAnimationsForElements(slide: WorkSlide, elementIds: ReadonlySet<string>): WorkSlide;
 export declare function remapWorkSlideAnimations(animations: readonly WorkSlideAnimation[] | undefined, elementIds: ReadonlyMap<string, string>): WorkSlideAnimation[] | undefined;

package/dist/internal/features/work/work-presentation-clipboard.d.ts

@@ -1,10 +1,6 @@
 import type { WorkSlide, WorkSlideAnimation, WorkSlideElement } from './work-types';
 export declare const PRESENTATION_OBJECT_OFFSET_STEP = 5;
 export type WorkPresentationClipboardPayload = {
-    kind: 'element';
-    element: WorkSlideElement;
-    animation?: WorkSlideAnimation;
-} | {
     kind: 'elements';
     elements: WorkSlideElement[];
     animations?: WorkSlideAnimation[];
@@ -20,7 +16,6 @@ export interface WorkPresentationElementPaste {
     animations?: WorkSlideAnimation[];
     elements: WorkSlideElement[];
 }
-export declare function copyPresentationElement(element: WorkSlideElement, animation?: WorkSlideAnimation): void;
 export declare function copyPresentationElements(elements: readonly WorkSlideElement[], animations?: readonly WorkSlideAnimation[]): void;
 export declare function copyPresentationSlide(slide: WorkSlide): void;
 export declare function takePresentationClipboard(): WorkPresentationClipboardRead | null;

package/dist/internal/features/work/work-types.d.ts

@@ -589,12 +589,16 @@ export interface WorkSlideTransition {
     advanceOnClick: boolean;
     advanceAfterMs?: number;
 }
-export type WorkSlideAnimationEffect = 'appear' | 'fade' | 'fly-in' | 'zoom';
+export type WorkSlideAnimationClass = 'entrance' | 'exit';
+export type WorkSlideEntranceAnimationEffect = 'appear' | 'fade' | 'fly-in' | 'zoom';
+export type WorkSlideExitAnimationEffect = 'disappear' | 'fade-out' | 'fly-out' | 'zoom-out';
+export type WorkSlideAnimationEffect = WorkSlideEntranceAnimationEffect | WorkSlideExitAnimationEffect;
 export type WorkSlideAnimationTrigger = 'on-click' | 'with-previous' | 'after-previous';
 export type WorkSlideAnimationDirection = 'left' | 'right' | 'up' | 'down';
 /**
- * One bounded entrance animation applied to one slide-owned element.
- * Array order on `WorkSlide.animations` is the canonical playback order.
+ * One bounded entrance or exit animation applied to one slide-owned element.
+ * An element may own at most one animation from each class. Array order on
+ * `WorkSlide.animations` is the canonical playback order.
  */
 export interface WorkSlideAnimation {
     id: string;