@a3s-lab/office 0.38.1 → 0.40.0

package/dist/0~presentation-editor.js

@@ -19,14 +19,14 @@ import { officePresenceColorStyle, office_text_field_OfficeTextArea, stepOfficeZ
 import { useOfficeTaskPaneEscape, normalizeOfficeFontFamily, OfficeCheckbox, CommittedOfficeNumberField, useOfficeTaskPaneModal, officeFontFamilyLabel, useOfficeDialog, officeFontFamilies, CollectionState, createOfficeKernelClient, OfficeNumberField, handleOfficeTaskPaneKeyDown } from "./0~7048.js";
 import { WorkspaceContextMenu, isWorkspaceContextMenuKeyboardEvent, WorkOfficeZoomControls, WorkOfficeStatusBar, WorkOfficeRibbon, workspaceContextMenuPosition, OfficeSelect, WorkOfficeRibbonGroup, WorkOfficePreviewBar, WorkOfficeRibbonButton } from "./0~9073.js";
 import { presentationAgentProposalTargets, SpreadsheetChartSeriesStyleEditor, applyPresentationAgentProposalChanges, normalizeOptionalOfficeNumber, SpreadsheetErrorBarEditor, useOfficeHistory, presentationNotesProposalTarget, presentationAgentSelection, SpreadsheetTrendlineEditor, presentationAgentMenuItems } from "./0~3539.js";
-import { slideTransitionDurationMilliseconds, workSlideAnimationIndex, workSlideAnimationForElement, remapWorkSlideAnimations, createWorkSlideTransition, workSlideTransitionsEqual, workSlideAnimationCues, initialWorkSlideAnimationCueIndex, normalizeWorkSlideAnimation, createWorkSlideAnimation, removeWorkSlideAnimationsForElements } from "./0~5809.js";
+import { readOfficePresentationCollaboration as readWorkOfficePresentationCollaboration, workSlideAnimationIndex, workSlideAnimationForElement, remapWorkSlideAnimations, createOfficePresentationCollaborationBinding as createWorkOfficePresentationCollaborationBinding, workSlideAnimationEffectMatchesClass, workSlideAnimationCues, workSlideAnimationSequenceIssue, initialWorkSlideAnimationCueIndex, normalizeWorkSlideAnimation, workSlideAnimationClass, removeWorkSlideAnimationsForElements, createWorkSlideAnimation } from "./4560.js";
 import { createOfficeEditorExtension, useOfficeEditorRuntime, useOfficeEditorKeyboardShortcuts } from "./0~3557.js";
 import { isOfficeShortcutBlocked, OfficeColorPicker, isOfficeCompositionKeyboardEvent } from "./0~3635.js";
+import { slideTransitionDurationMilliseconds, createWorkSlideTransition, workSlideTransitionsEqual } from "./0~work-presentation-transition.js";
 import { ControlledEditorComposition } from "./0~controlled-editor-composition.js";
 import { normalizeDocumentHref, DOCUMENT_LINK_VALIDATION_MESSAGE } from "./0~work-document-links.js";
 import { showToast } from "./6489.js";
 import { scaledPresentationVisuals } from "./0~work-presentation-visual-scale.js";
-import { readOfficePresentationCollaboration as readWorkOfficePresentationCollaboration, createOfficePresentationCollaborationBinding as createWorkOfficePresentationCollaborationBinding } from "./4560.js";
 import { useOfficeEditorInitialFocus, useOfficeCollaborationLocationNavigator } from "./432.js";
 var presentation_editor_namespaceObject = {};
 __webpack_require__.r(presentation_editor_namespaceObject);
@@ -1735,21 +1735,21 @@ function createPresentationEditorExtensions() {
         createOfficeEditorExtension({
             name: 'presentationAnimations',
             addCommands: ()=>({
-                    moveEntranceAnimation: {
-                        canExecute: ({ animations }, direction)=>animations.canMoveEntranceAnimation(direction),
-                        execute: ({ animations }, direction)=>animations.moveEntranceAnimation(direction)
+                    moveAnimation: {
+                        canExecute: ({ animations }, animationClass, direction)=>animations.canMoveAnimation(animationClass, direction),
+                        execute: ({ animations }, animationClass, direction)=>animations.moveAnimation(animationClass, direction)
                     },
                     previewAnimations: {
                         canExecute: ({ animations })=>animations.canPreviewAnimations,
                         execute: ({ animations })=>animations.previewAnimations()
                     },
-                    setEntranceAnimation: {
-                        canExecute: ({ animations })=>animations.canSetEntranceAnimation,
-                        execute: ({ animations }, effect)=>animations.setEntranceAnimation(effect)
+                    setAnimation: {
+                        canExecute: ({ animations })=>animations.canSetAnimation,
+                        execute: ({ animations }, animationClass, effect)=>animations.setAnimation(animationClass, effect)
                     },
-                    updateEntranceAnimation: {
-                        canExecute: ({ animations })=>animations.canUpdateEntranceAnimation,
-                        execute: ({ animations }, patch)=>animations.updateEntranceAnimation(patch)
+                    updateAnimation: {
+                        canExecute: ({ animations }, animationClass, patch)=>animations.canUpdateAnimation(animationClass, patch),
+                        execute: ({ animations }, animationClass, patch)=>animations.updateAnimation(animationClass, patch)
                     }
                 })
         }),
@@ -2479,12 +2479,12 @@ function presentationCommandsWithObjectFocus(commands, restoreFocus) {
         distributeElements: afterSuccessfulCommand(commands.distributeElements),
         duplicateSlide: afterSuccessfulCommand(commands.duplicateSlide),
         groupElements: afterSuccessfulCommand(commands.groupElements),
-        moveEntranceAnimation: afterSuccessfulCommand(commands.moveEntranceAnimation),
+        moveAnimation: afterSuccessfulCommand(commands.moveAnimation),
         pasteSelection: afterSuccessfulCommand(commands.pasteSelection),
         redo: afterSuccessfulCommand(commands.redo),
         reorderElement: afterSuccessfulCommand(commands.reorderElement),
         setTransition: afterSuccessfulCommand(commands.setTransition),
-        setEntranceAnimation: afterSuccessfulCommand(commands.setEntranceAnimation),
+        setAnimation: afterSuccessfulCommand(commands.setAnimation),
         setViewMode: afterSuccessfulCommand(commands.setViewMode),
         toggleBold: afterSuccessfulCommand(commands.toggleBold),
         toggleItalic: afterSuccessfulCommand(commands.toggleItalic),
@@ -2492,7 +2492,7 @@ function presentationCommandsWithObjectFocus(commands, restoreFocus) {
         undo: afterSuccessfulCommand(commands.undo),
         ungroupElements: afterSuccessfulCommand(commands.ungroupElements),
         updateElement: afterSuccessfulCommand(commands.updateElement),
-        updateEntranceAnimation: afterSuccessfulCommand(commands.updateEntranceAnimation)
+        updateAnimation: afterSuccessfulCommand(commands.updateAnimation)
     };
 }
 function presentationChartAnalysisBounds(chart, xValues) {
@@ -3644,7 +3644,10 @@ function SlideElementPreview({ animationPlayback, element, origin, showPlacehold
         className: `work-slide-element ${element.type} ${origin} ${showPlaceholder && element.placeholder ? 'placeholder' : ''}`.trim(),
         "data-slide-preview-element-id": element.id,
         "data-slide-element-origin": origin,
-        "data-slide-animation-effect": animationPlayback?.animation.effect,
+        "data-slide-animation-effect": animationPlayback?.animations.at(-1)?.animation.effect,
+        "data-slide-animation-effects": animationPlayback?.animations.map(({ animation })=>animation.effect).join(' '),
+        "data-slide-animation-final-visibility": animationPlayback ? animationPlayback.finallyVisible ? 'visible' : 'hidden' : void 0,
+        "data-slide-animation-initial-visibility": animationPlayback ? animationPlayback.initiallyVisible ? 'visible' : 'hidden' : void 0,
         "data-slide-animation-state": animationPlayback?.state,
         style: {
             ...slideElementStyle(element),
@@ -3716,26 +3719,58 @@ function slideElementStyle(element) {
     };
 }
 function slideAnimationPlayback(animations, activeCueIndex) {
+    const cues = workSlideAnimationCues(animations);
     const playback = new Map();
-    for (const [cueIndex, cue] of workSlideAnimationCues(animations).entries())for (const item of cue.items)playback.set(item.animation.elementId, {
-        animation: item.animation,
-        startOffsetMs: item.startOffsetMs,
-        state: cueIndex < activeCueIndex ? 'finished' : cueIndex === activeCueIndex ? 'playing' : 'pending'
-    });
+    for (const animation of animations ?? []){
+        if (playback.has(animation.elementId)) continue;
+        const visible = 'exit' === workSlideAnimationClass(animation.effect);
+        playback.set(animation.elementId, {
+            animations: [],
+            finallyVisible: visible,
+            initiallyVisible: visible,
+            state: visible ? 'visible' : 'hidden'
+        });
+    }
+    if (activeCueIndex < 0) return playback;
+    for (const [cueIndex, cue] of cues.entries()){
+        if (cueIndex > activeCueIndex) break;
+        for (const item of cue.items){
+            const state = playback.get(item.animation.elementId);
+            if (!state) continue;
+            const finallyVisible = 'entrance' === workSlideAnimationClass(item.animation.effect);
+            if (cueIndex < activeCueIndex) {
+                state.finallyVisible = finallyVisible;
+                state.initiallyVisible = finallyVisible;
+                state.state = finallyVisible ? 'visible' : 'hidden';
+                continue;
+            }
+            if (!state.animations.length) state.initiallyVisible = state.finallyVisible;
+            state.animations.push(item);
+            state.finallyVisible = finallyVisible;
+            state.state = 'playing';
+        }
+    }
     return playback;
 }
 function slideElementAnimationStyle(playback) {
-    if (!playback) return {};
-    const direction = playback.animation.direction ?? 'left';
-    const translateX = 'left' === direction ? '-18%' : 'right' === direction ? '18%' : '0';
-    const translateY = 'up' === direction ? '-18%' : 'down' === direction ? '18%' : '0';
+    if (!playback?.animations.length) return {};
     return {
-        '--work-slide-animation-delay': `${playback.startOffsetMs}ms`,
-        '--work-slide-animation-duration': `${playback.animation.durationMs}ms`,
-        '--work-slide-animation-translate-x': translateX,
-        '--work-slide-animation-translate-y': translateY
+        animationDelay: playback.animations.map(({ startOffsetMs })=>`${startOffsetMs}ms`).join(', '),
+        animationDuration: playback.animations.map(({ animation })=>`${animation.durationMs}ms`).join(', '),
+        animationFillMode: 'forwards',
+        animationName: playback.animations.map(({ animation })=>slideAnimationName(animation)).join(', '),
+        animationTimingFunction: playback.animations.map(({ animation })=>slideAnimationTimingFunction(animation)).join(', ')
     };
 }
+function slideAnimationName(animation) {
+    if ('fly-in' === animation.effect || 'fly-out' === animation.effect) return `work-slide-animation-${animation.effect}-${animation.direction ?? 'left'}`;
+    return `work-slide-animation-${animation.effect}`;
+}
+function slideAnimationTimingFunction(animation) {
+    if ('appear' === animation.effect) return 'steps(1, start)';
+    if ('disappear' === animation.effect) return 'steps(1, end)';
+    return 'cubic-bezier(0.16, 1, 0.3, 1)';
+}
 function slideTextStyle(element) {
     return {
         color: element.color,
@@ -4754,51 +4789,111 @@ function commonRunValue(runs, getValue, fallback) {
     const values = runs.map((run)=>getValue(run) ?? fallback);
     return values.every((value)=>value === values[0]) ? values[0] : fallback;
 }
-function PresentationAnimationPanel({ animation, canMove, canPreview, editable, onMove, onPreview, onSetEffect, onUpdate }) {
+function PresentationAnimationPanel({ animations, canMove, canPreview, canUpdate, editable, elementId, onMove, onPreview, onSetEffect, onUpdate }) {
+    const defaultClass = animations.entrance ? 'entrance' : animations.exit ? 'exit' : 'entrance';
+    const [selection, setSelection] = useState({
+        animationClass: defaultClass,
+        elementId
+    });
+    const animationClass = selection.elementId === elementId ? selection.animationClass : defaultClass;
+    const animation = animations[animationClass];
+    const flyEffect = animation?.effect === 'fly-in' || animation?.effect === 'fly-out';
+    const effectOptions = 'entrance' === animationClass ? [
+        {
+            value: 'none',
+            label: '无'
+        },
+        {
+            value: 'appear',
+            label: '出现'
+        },
+        {
+            value: 'fade',
+            label: '淡入'
+        },
+        {
+            value: 'fly-in',
+            label: '飞入'
+        },
+        {
+            value: 'zoom',
+            label: '缩放'
+        }
+    ] : [
+        {
+            value: 'none',
+            label: '无'
+        },
+        {
+            value: 'disappear',
+            label: '消失'
+        },
+        {
+            value: 'fade-out',
+            label: '淡出'
+        },
+        {
+            value: 'fly-out',
+            label: '飞出'
+        },
+        {
+            value: 'zoom-out',
+            label: '缩小'
+        }
+    ];
     return /*#__PURE__*/ jsxs(Fragment, {
         children: [
             /*#__PURE__*/ jsx(WorkOfficeRibbonGroup, {
-                label: "入场动画",
+                label: "对象动画",
                 children: /*#__PURE__*/ jsxs("fieldset", {
                     className: "work-presentation-animation-options",
+                    "data-animation-class": animationClass,
                     children: [
                         /*#__PURE__*/ jsx("legend", {
                             className: "sr-only",
-                            children: "对象入场动画设置"
+                            children: "对象动画设置"
                         }),
                         /*#__PURE__*/ jsxs("div", {
-                            className: "work-office-field effect",
+                            className: "work-office-field animation-class",
                             children: [
                                 /*#__PURE__*/ jsx("span", {
-                                    children: "效果"
+                                    children: "类型"
                                 }),
                                 /*#__PURE__*/ jsx(OfficeSelect, {
-                                    ariaLabel: "对象入场动画效果",
+                                    ariaLabel: "对象动画类型",
                                     disabled: !editable,
-                                    value: animation?.effect ?? 'none',
+                                    value: animationClass,
                                     options: [
                                         {
-                                            value: 'none',
-                                            label: '无'
-                                        },
-                                        {
-                                            value: 'appear',
-                                            label: '出现'
-                                        },
-                                        {
-                                            value: 'fade',
-                                            label: '淡入'
-                                        },
-                                        {
-                                            value: 'fly-in',
-                                            label: '飞入'
+                                            value: 'entrance',
+                                            label: '进入',
+                                            meta: '让对象出现'
                                         },
                                         {
-                                            value: 'zoom',
-                                            label: '缩放'
+                                            value: 'exit',
+                                            label: '退出',
+                                            meta: '让对象消失'
                                         }
                                     ],
-                                    onValueChange: (effect)=>onSetEffect('none' === effect ? void 0 : effect)
+                                    onValueChange: (nextClass)=>setSelection({
+                                            animationClass: nextClass,
+                                            elementId
+                                        })
+                                })
+                            ]
+                        }),
+                        /*#__PURE__*/ jsxs("div", {
+                            className: "work-office-field effect",
+                            children: [
+                                /*#__PURE__*/ jsx("span", {
+                                    children: "效果"
+                                }),
+                                /*#__PURE__*/ jsx(OfficeSelect, {
+                                    ariaLabel: "对象动画效果",
+                                    disabled: !editable,
+                                    value: animation?.effect ?? 'none',
+                                    options: effectOptions,
+                                    onValueChange: (effect)=>onSetEffect(animationClass, 'none' === effect ? void 0 : effect)
                                 })
                             ]
                         }),
@@ -4809,57 +4904,66 @@ function PresentationAnimationPanel({ animation, canMove, canPreview, editable,
                                     children: "开始"
                                 }),
                                 /*#__PURE__*/ jsx(OfficeSelect, {
-                                    ariaLabel: "对象入场动画触发方式",
+                                    ariaLabel: "对象动画触发方式",
                                     disabled: !animation,
                                     value: animation?.trigger ?? 'on-click',
                                     options: [
                                         {
                                             value: 'on-click',
-                                            label: '单击时'
+                                            label: '单击时',
+                                            disabled: Boolean(animation) && !canUpdate(animationClass, {
+                                                trigger: 'on-click'
+                                            })
                                         },
                                         {
                                             value: 'with-previous',
-                                            label: '与上一动画同时'
+                                            label: '与上一动画同时',
+                                            disabled: Boolean(animation) && !canUpdate(animationClass, {
+                                                trigger: 'with-previous'
+                                            })
                                         },
                                         {
                                             value: 'after-previous',
-                                            label: '上一动画之后'
+                                            label: '上一动画之后',
+                                            disabled: Boolean(animation) && !canUpdate(animationClass, {
+                                                trigger: 'after-previous'
+                                            })
                                         }
                                     ],
-                                    onValueChange: (trigger)=>onUpdate({
+                                    onValueChange: (trigger)=>onUpdate(animationClass, {
                                             trigger: trigger
                                         })
                                 })
                             ]
                         }),
-                        animation?.effect === 'fly-in' && /*#__PURE__*/ jsxs("div", {
+                        flyEffect && /*#__PURE__*/ jsxs("div", {
                             className: "work-office-field direction",
                             children: [
                                 /*#__PURE__*/ jsx("span", {
                                     children: "方向"
                                 }),
                                 /*#__PURE__*/ jsx(OfficeSelect, {
-                                    ariaLabel: "对象飞入方向",
+                                    ariaLabel: "对象动画方向",
                                     value: animation.direction ?? 'left',
                                     options: [
                                         {
                                             value: 'left',
-                                            label: '从左侧'
+                                            label: 'entrance' === animationClass ? '从左侧' : '向左侧'
                                         },
                                         {
                                             value: 'right',
-                                            label: '从右侧'
+                                            label: 'entrance' === animationClass ? '从右侧' : '向右侧'
                                         },
                                         {
                                             value: 'up',
-                                            label: '从上方'
+                                            label: 'entrance' === animationClass ? '从上方' : '向上方'
                                         },
                                         {
                                             value: 'down',
-                                            label: '从下方'
+                                            label: 'entrance' === animationClass ? '从下方' : '向下方'
                                         }
                                     ],
-                                    onValueChange: (direction)=>onUpdate({
+                                    onValueChange: (direction)=>onUpdate(animationClass, {
                                             direction: direction
                                         })
                                 })
@@ -4875,27 +4979,39 @@ function PresentationAnimationPanel({ animation, canMove, canPreview, editable,
                     children: [
                         /*#__PURE__*/ jsx(AnimationTimingField, {
                             animationId: animation?.id,
-                            ariaLabel: "对象入场动画持续秒数",
+                            ariaLabel: "对象动画持续秒数",
                             disabled: !animation,
                             label: "持续",
                             maximumMs: 60000,
                             minimumMs: 100,
                             valueMs: animation?.durationMs ?? 500,
-                            onCommit: (durationMs)=>onUpdate({
+                            onCommit: (durationMs)=>{
+                                if (!canUpdate(animationClass, {
                                     durationMs
-                                })
+                                })) return false;
+                                onUpdate(animationClass, {
+                                    durationMs
+                                });
+                                return true;
+                            }
                         }),
                         /*#__PURE__*/ jsx(AnimationTimingField, {
                             animationId: animation?.id,
-                            ariaLabel: "对象入场动画延迟秒数",
+                            ariaLabel: "对象动画延迟秒数",
                             disabled: !animation,
                             label: "延迟",
                             maximumMs: 60000,
                             minimumMs: 0,
                             valueMs: animation?.delayMs ?? 0,
-                            onCommit: (delayMs)=>onUpdate({
+                            onCommit: (delayMs)=>{
+                                if (!canUpdate(animationClass, {
                                     delayMs
-                                })
+                                })) return false;
+                                onUpdate(animationClass, {
+                                    delayMs
+                                });
+                                return true;
+                            }
                         })
                     ]
                 })
@@ -4906,8 +5022,8 @@ function PresentationAnimationPanel({ animation, canMove, canPreview, editable,
                     /*#__PURE__*/ jsx(WorkOfficeRibbonButton, {
                         label: "提前对象动画",
                         visibleLabel: "提前",
-                        disabled: !canMove(-1),
-                        onClick: ()=>onMove(-1),
+                        disabled: !canMove(animationClass, -1),
+                        onClick: ()=>onMove(animationClass, -1),
                         children: /*#__PURE__*/ jsx(ArrowUp, {
                             size: 19
                         })
@@ -4915,8 +5031,8 @@ function PresentationAnimationPanel({ animation, canMove, canPreview, editable,
                     /*#__PURE__*/ jsx(WorkOfficeRibbonButton, {
                         label: "推后对象动画",
                         visibleLabel: "推后",
-                        disabled: !canMove(1),
-                        onClick: ()=>onMove(1),
+                        disabled: !canMove(animationClass, 1),
+                        onClick: ()=>onMove(animationClass, 1),
                         children: /*#__PURE__*/ jsx(ArrowDown, {
                             size: 19
                         })
@@ -4947,8 +5063,9 @@ function AnimationTimingField({ animationId, ariaLabel, disabled, label, maximum
     ]);
     const commit = (value)=>{
         const next = normalizedAnimationMilliseconds(value, valueMs, minimumMs, maximumMs);
-        setDraft(animationSecondsDraft(next));
-        if (next !== valueMs) onCommit(next);
+        if (next === valueMs) return void setDraft(animationSecondsDraft(next));
+        const accepted = onCommit(next);
+        setDraft(animationSecondsDraft(false === accepted ? valueMs : next));
     };
     return /*#__PURE__*/ jsxs("div", {
         className: "work-office-field seconds",
@@ -5364,7 +5481,8 @@ function PresentationToolbar({ selectedSlide, selectedElement, selectedUnitCount
     });
     const [fontSizeDraft, setFontSizeDraft] = useState(selectedFontSize);
     const fontFamilyValue = presentationFontFamilyValue(selectedElement?.fontFamily);
-    const selectedAnimation = workSlideAnimationForElement(selectedSlide, selectedElement?.id);
+    const selectedEntranceAnimation = workSlideAnimationForElement(selectedSlide, selectedElement?.id, 'entrance');
+    const selectedExitAnimation = workSlideAnimationForElement(selectedSlide, selectedElement?.id, 'exit');
     useEffect(()=>{
         const previous = selectedFontSizeRef.current;
         const elementId = selectedElement?.id ?? null;
@@ -5786,14 +5904,19 @@ function PresentationToolbar({ selectedSlide, selectedElement, selectedUnitCount
                         onApplyToAll: commands.applyTransitionToAll
                     }),
                     animations: /*#__PURE__*/ jsx(PresentationAnimationPanel, {
-                        animation: selectedAnimation,
-                        canMove: can.moveEntranceAnimation,
+                        animations: {
+                            entrance: selectedEntranceAnimation,
+                            exit: selectedExitAnimation
+                        },
+                        canMove: can.moveAnimation,
                         canPreview: can.previewAnimations(),
-                        editable: can.setEntranceAnimation(selectedAnimation?.effect),
-                        onMove: commands.moveEntranceAnimation,
+                        canUpdate: can.updateAnimation,
+                        editable: can.setAnimation('entrance', selectedEntranceAnimation?.effect),
+                        elementId: selectedElement?.id,
+                        onMove: commands.moveAnimation,
                         onPreview: commands.previewAnimations,
-                        onSetEffect: commands.setEntranceAnimation,
-                        onUpdate: commands.updateEntranceAnimation
+                        onSetEffect: commands.setAnimation,
+                        onUpdate: commands.updateAnimation
                     }),
                     slideshow: /*#__PURE__*/ jsxs(WorkOfficeRibbonGroup, {
                         label: "开始放映",
@@ -7002,15 +7125,9 @@ function usePresentationClipboard({ content, mode, targetId, selectedSlide, sele
             showToast('没有可粘贴的演示内容。', 'info');
             return true;
         }
-        if ('element' === clipboard.payload.kind || 'elements' === clipboard.payload.kind) {
+        if ('elements' === clipboard.payload.kind) {
             if (!targetId) return false;
-            const sourceElements = 'element' === clipboard.payload.kind ? [
-                clipboard.payload.element
-            ] : clipboard.payload.elements;
-            const sourceAnimations = 'element' === clipboard.payload.kind ? clipboard.payload.animation ? [
-                clipboard.payload.animation
-            ] : [] : clipboard.payload.animations ?? [];
-            const pasted = clonePresentationElementsAndAnimationsForPaste(sourceElements, sourceAnimations, clipboard.offset);
+            const pasted = clonePresentationElementsAndAnimationsForPaste(clipboard.payload.elements, clipboard.payload.animations ?? [], clipboard.offset);
             if ('slide' === mode && !canAppendSlideAnimations(content, targetId, pasted.animations)) {
                 showToast('对象动画数量已达到每张幻灯片 256 条的上限。', 'info');
                 return true;
@@ -7205,10 +7322,9 @@ function use_presentation_clipboard_structuredCopy(value) {
 }
 function usePresentationAnimationCommands({ content, onChange, selectedElementId, selectedSlide }) {
     const selectedElementExists = Boolean(selectedElementId && selectedSlide.elements.some((element)=>element.id === selectedElementId));
-    const selectedAnimation = workSlideAnimationForElement(selectedSlide, selectedElementId);
-    const setEntranceAnimation = useCallback((effect)=>{
+    const setAnimation = useCallback((animationClass, effect)=>{
         if (!selectedElementId || !selectedElementExists) return false;
-        const current = workSlideAnimationForElement(selectedSlide, selectedElementId);
+        const current = workSlideAnimationForElement(selectedSlide, selectedElementId, animationClass);
         if (!effect) {
             if (!current) return false;
             updateSlide(content, selectedSlide.id, (slide)=>{
@@ -7220,6 +7336,7 @@ function usePresentationAnimationCommands({ content, onChange, selectedElementId
             }, onChange);
             return true;
         }
+        if (!workSlideAnimationEffectMatchesClass(effect, animationClass)) return false;
         if (current?.effect === effect) return false;
         if (!current && (selectedSlide.animations?.length ?? 0) >= 256) return false;
         updateSlide(content, selectedSlide.id, (slide)=>{
@@ -7243,13 +7360,31 @@ function usePresentationAnimationCommands({ content, onChange, selectedElementId
         selectedElementId,
         selectedSlide
     ]);
-    const updateEntranceAnimation = useCallback((patch)=>{
+    const canUpdateAnimation = useCallback((animationClass, patch)=>{
+        const selectedAnimation = workSlideAnimationForElement(selectedSlide, selectedElementId, animationClass);
         if (!selectedAnimation) return false;
         const next = normalizeWorkSlideAnimation({
             ...selectedAnimation,
             ...patch,
             id: selectedAnimation.id,
-            elementId: selectedAnimation.elementId
+            elementId: selectedAnimation.elementId,
+            effect: selectedAnimation.effect
+        });
+        const animations = selectedSlide.animations?.map((animation)=>animation.id === selectedAnimation.id ? next : animation);
+        return void 0 === workSlideAnimationSequenceIssue(animations);
+    }, [
+        selectedElementId,
+        selectedSlide
+    ]);
+    const updateAnimation = useCallback((animationClass, patch)=>{
+        const selectedAnimation = workSlideAnimationForElement(selectedSlide, selectedElementId, animationClass);
+        if (!selectedAnimation || !canUpdateAnimation(animationClass, patch)) return false;
+        const next = normalizeWorkSlideAnimation({
+            ...selectedAnimation,
+            ...patch,
+            id: selectedAnimation.id,
+            elementId: selectedAnimation.elementId,
+            effect: selectedAnimation.effect
         });
         if (animationsEqual(selectedAnimation, next)) return false;
         updateSlide(content, selectedSlide.id, (slide)=>({
@@ -7258,21 +7393,32 @@ function usePresentationAnimationCommands({ content, onChange, selectedElementId
             }), onChange);
         return true;
     }, [
+        canUpdateAnimation,
         content,
         onChange,
-        selectedAnimation,
-        selectedSlide.id
+        selectedElementId,
+        selectedSlide
     ]);
-    const canMoveEntranceAnimation = useCallback((direction)=>{
+    const canMoveAnimation = useCallback((animationClass, direction)=>{
+        const selectedAnimation = workSlideAnimationForElement(selectedSlide, selectedElementId, animationClass);
         const index = workSlideAnimationIndex(selectedSlide, selectedAnimation?.id);
         const target = index + direction;
-        return index >= 0 && target >= 0 && target < (selectedSlide.animations?.length ?? 0);
+        if (index < 0 || target < 0 || target >= (selectedSlide.animations?.length ?? 0)) return false;
+        const animations = [
+            ...selectedSlide.animations ?? []
+        ];
+        [animations[index], animations[target]] = [
+            animations[target],
+            animations[index]
+        ];
+        return void 0 === workSlideAnimationSequenceIssue(animations);
     }, [
-        selectedAnimation?.id,
+        selectedElementId,
         selectedSlide
     ]);
-    const moveEntranceAnimation = useCallback((direction)=>{
-        if (!selectedAnimation || !canMoveEntranceAnimation(direction)) return false;
+    const moveAnimation = useCallback((animationClass, direction)=>{
+        const selectedAnimation = workSlideAnimationForElement(selectedSlide, selectedElementId, animationClass);
+        if (!selectedAnimation || !canMoveAnimation(animationClass, direction)) return false;
         updateSlide(content, selectedSlide.id, (slide)=>{
             const animations = [
                 ...slide.animations ?? []
@@ -7290,19 +7436,19 @@ function usePresentationAnimationCommands({ content, onChange, selectedElementId
         }, onChange);
         return true;
     }, [
-        canMoveEntranceAnimation,
+        canMoveAnimation,
         content,
         onChange,
-        selectedAnimation,
-        selectedSlide.id
+        selectedElementId,
+        selectedSlide
     ]);
     return {
-        canMoveEntranceAnimation,
-        canSetEntranceAnimation: selectedElementExists,
-        canUpdateEntranceAnimation: Boolean(selectedAnimation),
-        moveEntranceAnimation,
-        setEntranceAnimation,
-        updateEntranceAnimation
+        canMoveAnimation,
+        canSetAnimation: selectedElementExists,
+        canUpdateAnimation,
+        moveAnimation,
+        setAnimation,
+        updateAnimation
     };
 }
 function animationsEqual(left, right) {
@@ -8862,14 +9008,14 @@ function PresentationEditingSurface({ initialSlide, autoFocus = true, collaborat
     const presentationExtensions = useMemo(createPresentationEditorExtensions, []);
     const presentationEditor = useOfficeEditorRuntime({
         animations: {
-            canMoveEntranceAnimation: (direction)=>'slide' === designMode && presentationAnimations.canMoveEntranceAnimation(direction),
+            canMoveAnimation: (animationClass, direction)=>'slide' === designMode && presentationAnimations.canMoveAnimation(animationClass, direction),
             canPreviewAnimations: 'slide' === designMode && Boolean(selectedSlide.animations?.length),
-            canSetEntranceAnimation: 'slide' === designMode && presentationAnimations.canSetEntranceAnimation,
-            canUpdateEntranceAnimation: 'slide' === designMode && presentationAnimations.canUpdateEntranceAnimation,
-            moveEntranceAnimation: presentationAnimations.moveEntranceAnimation,
+            canSetAnimation: 'slide' === designMode && presentationAnimations.canSetAnimation,
+            canUpdateAnimation: (animationClass, patch)=>'slide' === designMode && presentationAnimations.canUpdateAnimation(animationClass, patch),
+            moveAnimation: presentationAnimations.moveAnimation,
             previewAnimations: ()=>startPresentationSlideshow('current'),
-            setEntranceAnimation: presentationAnimations.setEntranceAnimation,
-            updateEntranceAnimation: presentationAnimations.updateEntranceAnimation
+            setAnimation: presentationAnimations.setAnimation,
+            updateAnimation: presentationAnimations.updateAnimation
         },
         clipboard: {
             canCopySelection: selectedElements.length > 0 || 'slide' === designMode && Boolean(selectedSlide),