@a3s-lab/office 0.33.0 → 0.35.0

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-editor-focus.d.ts

@@ -1,4 +1,5 @@
 import type { PresentationEditorCommands } from './presentation-command-types';
+import type { WorkSlideElement } from '../work-types';
 export interface PresentationObjectFocusState {
     editingElementId: string | null;
     selectedElementIds: readonly string[];
@@ -7,6 +8,7 @@ export interface PresentationWorkspaceFocusState extends PresentationObjectFocus
     selectedSlideId: string;
     viewMode: 'normal' | 'sorter';
 }
+export declare function presentationInitialEditingElementId(elements: readonly WorkSlideElement[]): string | null;
 export declare function restorePresentationObjectFocus(container: HTMLElement | null, getState: () => PresentationObjectFocusState, focusOrigin?: Element | null): void;
 export declare function restorePresentationWorkspaceFocus(root: HTMLElement | null, getState: () => PresentationWorkspaceFocusState, focusOrigin?: Element | null): void;
 export declare function presentationWorkspaceFocusTarget(root: HTMLElement, state: PresentationWorkspaceFocusState): HTMLElement | undefined;

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/presentation-text-editor.d.ts

@@ -13,6 +13,13 @@ export interface PresentationTextEditorProps {
     onSelectionChange?: () => void;
 }
 export declare function PresentationTextEditor({ autoFocus, element, onChange, onEditorChange, onExitEditing, onSelectionChange, }: PresentationTextEditorProps): import("react").JSX.Element | null;
+/**
+ * Keep delayed first-open focus from overriding a deliberate focus move that
+ * happened while the rich-text editor was being created. The document body is
+ * treated as an unfocused baseline so opening from a non-focusable surface can
+ * still enter the editor normally.
+ */
+export declare function presentationFocusOwnerIsUnchanged(initialFocusTarget: HTMLElement | null): boolean;
 export declare function createPresentationTextEditorExtensions(placeholder?: string): Extensions;
 export declare function presentationTextElementHtml(element: WorkSlideElement): string;
 export declare function presentationTextValue(editor: Editor, element: WorkSlideElement): PresentationTextValue;

package/dist/internal/features/work/editors/spreadsheet-command-controller.d.ts

@@ -67,6 +67,15 @@ export interface SpreadsheetCommandSelection {
     sheetId: string;
     selection: Selection;
 }
+/**
+ * Synchronous selection state shared by commands and the Fortune Sheet bridge.
+ * Fortune applies API calls through React state, so reading its imperative API
+ * twice in the same task can otherwise return the previous selection.
+ */
+export interface SpreadsheetSelectionRef {
+    current: SpreadsheetCommandSelection | null;
+    requested: SpreadsheetCommandSelection | null;
+}
 export type SpreadsheetStructureAxis = 'row' | 'column';
 export type SpreadsheetStructureInsertPosition = 'before' | 'after';
 export type SpreadsheetSortDirection = 'ascending' | 'descending';
@@ -238,6 +247,7 @@ export interface SpreadsheetCommandContext {
     onChange: (content: WorkSpreadsheetContent) => void;
     richTextFormat?: SpreadsheetRichTextFormatCommandPort | null;
     selection: SpreadsheetCommandSelection | null;
+    selectionRef?: SpreadsheetSelectionRef;
     table: SpreadsheetTableCommandPort;
     targetSheetGridSize?: SpreadsheetGridSize | null;
     targetSheetId: string;

package/dist/internal/features/work/editors/spreadsheet-command-selection.d.ts

@@ -1,3 +1,24 @@
-import type { SpreadsheetCommandContext, SpreadsheetCommandRange } from './spreadsheet-command-controller';
+import type { SpreadsheetCommandContext, SpreadsheetCommandSelection, SpreadsheetCommandRange, SpreadsheetSelectionRef } from './spreadsheet-command-controller';
 export declare function canEditSpreadsheetSelection(context: SpreadsheetCommandContext): boolean;
 export declare function spreadsheetLiveCommandRange(context: SpreadsheetCommandContext): SpreadsheetCommandRange;
+/**
+ * Returns the most recent selection known to the Office bridge. The ref is
+ * intentionally checked before Fortune's imperative API because that API is
+ * backed by React state and can lag behind a just-issued keyboard command.
+ */
+export declare function spreadsheetLiveCommandSelection(context: SpreadsheetCommandContext): SpreadsheetCommandRange | undefined;
+/**
+ * Returns all current selections while preserving the workbook's multi-range
+ * semantics. A synchronous command selection is represented as one range.
+ */
+export declare function spreadsheetLiveCommandSelections(context: SpreadsheetCommandContext): SpreadsheetCommandRange[] | undefined;
+/**
+ * Accept a Fortune selection callback unless it is older than a pending
+ * programmatic selection request. The returned value is the normalized state
+ * that should be published to React and collaboration consumers.
+ */
+export declare function acceptSpreadsheetSelectionChange(selectionRef: SpreadsheetSelectionRef, sheetId: string, selection: SpreadsheetCommandRange): SpreadsheetCommandSelection | null;
+export declare function rememberSpreadsheetCommandSelection(context: SpreadsheetCommandContext, selection: SpreadsheetCommandRange): void;
+/** Clear a pending programmatic request when a fresh user intent arrives. */
+export declare function releaseSpreadsheetSelectionRequest(selectionRef: SpreadsheetSelectionRef): void;
+export declare function sameSpreadsheetSelectionValue(left: SpreadsheetCommandRange, right: SpreadsheetCommandRange): boolean;

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/editors/use-presentation-selection.d.ts

@@ -8,4 +8,4 @@ export interface PresentationSelectionController {
     select: (elementId: string | null, additive?: boolean) => void;
     selectedElementIds: string[];
 }
-export declare function usePresentationSelection(elements: readonly WorkSlideElement[]): PresentationSelectionController;
+export declare function usePresentationSelection(elements: readonly WorkSlideElement[], initialEditingElementId?: string | null): PresentationSelectionController;

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;

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

@@ -0,0 +1,20 @@
+import type { WorkSlide, WorkSlideAnimation, 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;
+    endOffsetMs: number;
+    startOffsetMs: number;
+}
+export interface WorkSlideAnimationCue {
+    automatic: boolean;
+    items: WorkSlideAnimationCueItem[];
+    totalDurationMs: number;
+}
+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 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 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,11 +1,13 @@
-import type { WorkSlide, WorkSlideElement } from './work-types';
+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[];
 } | {
     kind: 'slide';
     slide: WorkSlide;
@@ -14,13 +16,18 @@ export interface WorkPresentationClipboardRead {
     payload: WorkPresentationClipboardPayload;
     offset: number;
 }
-export declare function copyPresentationElement(element: WorkSlideElement): void;
-export declare function copyPresentationElements(elements: readonly WorkSlideElement[]): void;
+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;
 export declare function hasPresentationClipboard(): boolean;
 export declare function clearPresentationClipboard(): void;
 export declare function clonePresentationElementForPaste(element: WorkSlideElement, offset: number): WorkSlideElement;
 export declare function clonePresentationElementsForPaste(elements: readonly WorkSlideElement[], offset: number): WorkSlideElement[];
+export declare function clonePresentationElementsAndAnimationsForPaste(elements: readonly WorkSlideElement[], animations: readonly WorkSlideAnimation[], offset: number): WorkPresentationElementPaste;
 export declare function clonePresentationSlideForPaste(slide: WorkSlide, existingSlideNames?: readonly string[]): WorkSlide;
 export declare function nextPresentationSlideCopyName(sourceName: string, existingSlideNames: readonly string[]): string;

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

@@ -543,6 +543,22 @@ export interface WorkSlideTransition {
     advanceOnClick: boolean;
     advanceAfterMs?: number;
 }
+export type WorkSlideAnimationEffect = 'appear' | 'fade' | 'fly-in' | 'zoom';
+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.
+ */
+export interface WorkSlideAnimation {
+    id: string;
+    elementId: string;
+    effect: WorkSlideAnimationEffect;
+    trigger: WorkSlideAnimationTrigger;
+    durationMs: number;
+    delayMs: number;
+    direction?: WorkSlideAnimationDirection;
+}
 export interface WorkSlideElement {
     id: string;
     type: WorkSlideElementType;
@@ -587,6 +603,7 @@ export interface WorkSlide {
     notes?: string;
     comments?: WorkSlideComment[];
     transition?: WorkSlideTransition;
+    animations?: WorkSlideAnimation[];
 }
 export interface WorkSlideComment {
     id: string;