@a3s-lab/office 0.32.0 → 0.34.0

package/dist/internal/features/work/editors/pdf-page-organization-worker-protocol.d.ts

@@ -0,0 +1,13 @@
+import type { PdfPageOrganizationErrorCode, PdfPageOrganizationJob, PdfPageOrganizationResult } from './pdf-page-organization-types';
+export interface PdfPageOrganizationWorkerRequest {
+    job: PdfPageOrganizationJob;
+    kind: 'run';
+}
+export type PdfPageOrganizationWorkerResponse = {
+    kind: 'success';
+    result: PdfPageOrganizationResult;
+} | {
+    code: PdfPageOrganizationErrorCode;
+    kind: 'failure';
+    message: string;
+};

package/dist/internal/features/work/editors/pdf-page-organization.d.ts

@@ -0,0 +1,3 @@
+export { applyPdfPageOrganizationJob } from './pdf-page-organization-engine';
+export { reorderedPdfPageIndexes, validatedPdfInsertionIndex, validatedPdfPageIndexes, validatedPdfPageOrder, validatedPdfPageSize, validatedPdfSplitBoundaries, } from './pdf-page-organization-plan';
+export * from './pdf-page-organization-types';

package/dist/internal/features/work/editors/pdf-page-organization.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/features/work/editors/pdf-page-organizer-dialog.d.ts

@@ -0,0 +1,17 @@
+import type { PluginRegistry } from '@embedpdf/react-pdf-viewer';
+import type { PdfEditorCanCommands, PdfEditorCommands } from './pdf-editor-extensions';
+import type { PdfPageOrganizationControllerError, PdfPageOrganizationControllerState } from './use-pdf-page-organization';
+export interface PdfPageOrganizerDialogProps {
+    busy: boolean;
+    can: PdfEditorCanCommands;
+    commands: PdfEditorCommands;
+    currentPage: number;
+    diagnostics: PdfPageOrganizationControllerState['diagnostics'];
+    error: PdfPageOrganizationControllerError | null;
+    registry: PluginRegistry;
+    restoreFocusTarget: () => HTMLElement | null;
+    totalPages: number;
+    onClose: () => void;
+    onDismissError: () => void;
+}
+export declare function PdfPageOrganizerDialog({ busy, can, commands, currentPage, diagnostics, error, registry, restoreFocusTarget, totalPages, onClose, onDismissError, }: PdfPageOrganizerDialogProps): import("react").JSX.Element;

package/dist/internal/features/work/editors/pdf-thumbnail-rail.d.ts

@@ -23,4 +23,8 @@ export declare function calculatePdfThumbnailRange({ anchorIndex, itemHeight, to
     totalPages: number;
     viewportHeight: number;
 }): PdfThumbnailRange;
+export declare function usePdfThumbnailSource(registry: PluginRegistry, page: number): {
+    sourceUrl: string | null;
+    state: 'error' | 'loading' | 'ready';
+};
 export {};

package/dist/internal/features/work/editors/pdf-toolbar.d.ts

@@ -9,11 +9,12 @@ interface PdfPageNavigationControl {
     onOpen: () => void;
     toggleRef: RefObject<HTMLButtonElement | null>;
 }
-export declare function PdfToolbar({ annotationState, can, commands, editable, pageNavigation, saveAvailable, saveLabel, saveState, searchInputRef, state, }: {
+export declare function PdfToolbar({ annotationState, can, commands, editable, pageOrganizationAvailable, pageNavigation, saveAvailable, saveLabel, saveState, searchInputRef, state, }: {
     annotationState: PdfAnnotationControllerState;
     can: PdfEditorCanCommands;
     commands: PdfEditorCommands;
     editable: boolean;
+    pageOrganizationAvailable?: boolean;
     pageNavigation?: PdfPageNavigationControl;
     saveAvailable?: boolean;
     saveLabel: string;

package/dist/internal/features/work/editors/pdf-viewer.d.ts

@@ -2,6 +2,7 @@ import { type UISchema } from '@embedpdf/react-pdf-viewer';
 import type { WorkOfficeCollaborationSession } from '../../../collaboration/office-collaboration';
 import type { WorkPdfCollaborationContent } from '../../../collaboration/office-pdf-collaboration-types';
 import type { PdfEvidenceOverlay, PdfEvidenceRegion } from './pdf-evidence-contract';
+import { type PdfPageOrganizationExport } from './use-pdf-page-organization';
 export declare const a3sPdfUiSchema: UISchema;
 export interface PdfViewerProps {
     collaboration?: WorkOfficeCollaborationSession;
@@ -11,6 +12,7 @@ export interface PdfViewerProps {
     onCollaborationChange?: (content: WorkPdfCollaborationContent) => void;
     onEvidenceRegionSelect?: (region: PdfEvidenceRegion) => void;
     onPageChange?: (pageNumber: number) => void;
+    onPageExport?: (files: readonly PdfPageOrganizationExport[]) => boolean | Promise<boolean>;
     onSave?: (pdf: Blob) => Promise<boolean>;
     saveLabel?: string;
     selectedEvidenceRegionId?: string;
@@ -18,4 +20,4 @@ export interface PdfViewerProps {
     wasmUrl?: string;
     worker?: boolean;
 }
-export declare function PdfViewer({ collaboration, evidenceOverlay, fileName, loadSource, onCollaborationChange, onEvidenceRegionSelect, onPageChange, onSave, saveLabel, selectedEvidenceRegionId, sourceKey, wasmUrl, worker, }: PdfViewerProps): import("react").JSX.Element;
+export declare function PdfViewer({ collaboration, evidenceOverlay, fileName, loadSource, onCollaborationChange, onEvidenceRegionSelect, onPageChange, onPageExport, onSave, saveLabel, selectedEvidenceRegionId, sourceKey, wasmUrl, worker, }: PdfViewerProps): import("react").JSX.Element;

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

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

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

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

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

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

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

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

package/dist/internal/features/work/editors/use-pdf-page-organization.d.ts

@@ -0,0 +1,38 @@
+import type { PdfPageOrganizationDiagnostic, PdfPageOrganizationErrorCode, PdfPageOrganizationExportOperation, PdfPageOrganizationJob, PdfPageOrganizationMutation, PdfPageOrganizationResult } from './pdf-page-organization';
+export interface PdfPageOrganizationExport {
+    fileName: string;
+    pageCount: number;
+    pdf: Blob;
+}
+export interface PdfPageOrganizationControllerError {
+    code: PdfPageOrganizationErrorCode;
+    message: string;
+}
+export interface PdfPageOrganizationControllerState {
+    available: boolean;
+    busy: boolean;
+    canRedo: boolean;
+    canUndo: boolean;
+    diagnostics: readonly PdfPageOrganizationDiagnostic[];
+    error: PdfPageOrganizationControllerError | null;
+    revision: number;
+}
+export interface PdfPageOrganizationController {
+    state: PdfPageOrganizationControllerState;
+    dismissError: () => void;
+    exportPages: (operation: PdfPageOrganizationExportOperation) => Promise<boolean>;
+    mutate: (mutation: PdfPageOrganizationMutation, importSource?: Blob) => Promise<boolean>;
+    redo: () => void;
+    undo: () => void;
+}
+interface UsePdfPageOrganizationOptions {
+    enabled: boolean;
+    fileName: string;
+    onExport?: (files: readonly PdfPageOrganizationExport[]) => boolean | Promise<boolean>;
+    readCurrentSource: () => Promise<Blob>;
+    replaceSource: (source: Blob) => void;
+    resetKey?: string;
+}
+type RunPdfPageOrganizationJob = (job: PdfPageOrganizationJob, signal?: AbortSignal) => Promise<PdfPageOrganizationResult>;
+export declare function usePdfPageOrganization(options: UsePdfPageOrganizationOptions, runJob?: RunPdfPageOrganizationJob): PdfPageOrganizationController;
+export {};

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

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

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

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

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

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

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

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

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;