@a3s-lab/office 0.1.0

package/dist/internal/features/work/editors/spreadsheet-protection-panel.d.ts

@@ -0,0 +1,7 @@
+import type { WorkSpreadsheetContent } from '../work-types';
+interface SpreadsheetProtectionPanelProps {
+    content: WorkSpreadsheetContent;
+    onChange: (content: WorkSpreadsheetContent) => void;
+}
+export declare function SpreadsheetProtectionPanel({ content, onChange, }: SpreadsheetProtectionPanelProps): import("react").JSX.Element;
+export {};

package/dist/internal/features/work/editors/spreadsheet-sheet-bar.d.ts

@@ -0,0 +1,17 @@
+import type { WorkSpreadsheetSheet } from '../work-types';
+import { type SpreadsheetSheetMoveDirection } from './spreadsheet-sheet-model';
+export interface SpreadsheetSheetBarProps {
+    activeSheetId: string;
+    editable: boolean;
+    sheets: readonly WorkSpreadsheetSheet[];
+    onActivate(sheetId: string): void;
+    onCreate(): void;
+    onDelete(sheetId: string): void;
+    onDuplicate(sheetId: string): void;
+    onHide(sheetId: string): void;
+    onMove(sheetId: string, direction: SpreadsheetSheetMoveDirection): void;
+    onRename(sheetId: string, name: string): void;
+    onSetColor(sheetId: string, color: string | null): void;
+    onShow(sheetId: string): void;
+}
+export declare function SpreadsheetSheetBar({ activeSheetId, editable, sheets, onActivate, onCreate, onDelete, onDuplicate, onHide, onMove, onRename, onSetColor, onShow, }: SpreadsheetSheetBarProps): import("react").JSX.Element[];

package/dist/internal/features/work/editors/spreadsheet-sheet-model.d.ts

@@ -0,0 +1,13 @@
+import type { WorkSpreadsheetContent, WorkSpreadsheetSheet } from '../work-types';
+export type SpreadsheetSheetMoveDirection = -1 | 1;
+export declare function addSpreadsheetSheet(content: WorkSpreadsheetContent): WorkSpreadsheetContent;
+export declare function activateSpreadsheetSheet(content: WorkSpreadsheetContent, sheetId: string): WorkSpreadsheetContent | null;
+export declare function deleteSpreadsheetSheet(content: WorkSpreadsheetContent, sheetId: string): WorkSpreadsheetContent | null;
+export declare function duplicateSpreadsheetSheet(content: WorkSpreadsheetContent, sheetId: string): WorkSpreadsheetContent | null;
+export declare function renameSpreadsheetSheet(content: WorkSpreadsheetContent, sheetId: string, name: string): WorkSpreadsheetContent | null;
+export declare function spreadsheetSheetNameValidationMessage(sheets: readonly WorkSpreadsheetSheet[], sheetId: string, name: string): string | null;
+export declare function setSpreadsheetSheetColor(content: WorkSpreadsheetContent, sheetId: string, color: string | null): WorkSpreadsheetContent | null;
+export declare function hideSpreadsheetSheet(content: WorkSpreadsheetContent, sheetId: string, hidden: boolean): WorkSpreadsheetContent | null;
+export declare function moveSpreadsheetSheet(content: WorkSpreadsheetContent, sheetId: string, direction: SpreadsheetSheetMoveDirection): WorkSpreadsheetContent | null;
+export declare function adjacentSpreadsheetSheetId(content: WorkSpreadsheetContent, activeSheetId: string, direction: SpreadsheetSheetMoveDirection): string | null;
+export declare function isSpreadsheetSheetHidden(sheet: WorkSpreadsheetSheet): boolean;

package/dist/internal/features/work/editors/spreadsheet-trendline-editor.d.ts

@@ -0,0 +1,8 @@
+import type { WorkSpreadsheetTrendline } from '../work-types';
+interface SpreadsheetTrendlineEditorProps {
+    seriesNumber: number;
+    trendlines: WorkSpreadsheetTrendline[];
+    onChange: (trendlines: WorkSpreadsheetTrendline[]) => void;
+}
+export declare function SpreadsheetTrendlineEditor({ seriesNumber, trendlines, onChange, }: SpreadsheetTrendlineEditorProps): import("react").JSX.Element;
+export {};

package/dist/internal/features/work/editors/spreadsheet-workbook-panel.d.ts

@@ -0,0 +1,16 @@
+import type { Selection } from '@fortune-sheet/core';
+import type { WorkSpreadsheetContent } from '../work-types';
+import type { SpreadsheetEditorCanCommands, SpreadsheetEditorCommands } from './spreadsheet-command-controller';
+export type SpreadsheetWorkbookPanelView = 'names' | 'print-area' | 'conditional-formatting' | 'protection' | 'charts' | 'formulas' | 'pivots';
+interface SpreadsheetWorkbookPanelProps {
+    id?: string;
+    content: WorkSpreadsheetContent;
+    view: SpreadsheetWorkbookPanelView;
+    activeSheetId: string;
+    selection?: Selection;
+    can: Pick<SpreadsheetEditorCanCommands, 'recalculateFormula'>;
+    commands: Pick<SpreadsheetEditorCommands, 'recalculateFormula' | 'setSpreadsheetContent'>;
+    onClose: () => void;
+}
+export declare function SpreadsheetWorkbookPanel({ id, content, view, activeSheetId, selection, can, commands, onClose, }: SpreadsheetWorkbookPanelProps): import("react").JSX.Element;
+export {};

package/dist/internal/features/work/editors/use-document-comments.d.ts

@@ -0,0 +1,26 @@
+import type { Editor } from '@tiptap/core';
+import { type WorkDocumentCommentView } from '../work-document-comments';
+import type { WorkDocumentContent } from '../work-types';
+import type { DocumentCommentDraft } from './document-comment-composer';
+export interface DocumentCommentsController {
+    canInsert: boolean;
+    close: () => void;
+    closeDraft: (restoreEditorFocus?: boolean) => void;
+    comments: WorkDocumentCommentView[];
+    deleteComment: (id: string) => void;
+    draft: DocumentCommentDraft | null;
+    open: boolean;
+    reply: (id: string, text: string) => void;
+    setOpen: (open: boolean) => void;
+    startDraft: () => void;
+    submitDraft: (text: string) => string | null;
+    toggleOpen: () => void;
+    toggleResolved: (id: string) => void;
+}
+export declare function useDocumentComments({ contentRef, editor, onBeforeDraft, }: {
+    contentRef: {
+        current: WorkDocumentContent;
+    };
+    editor: Editor | null;
+    onBeforeDraft?: () => void;
+}): DocumentCommentsController;

package/dist/internal/features/work/editors/use-document-insert-commands.d.ts

@@ -0,0 +1,19 @@
+import type { Editor } from '@tiptap/core';
+import { type MutableRefObject, type ReactNode } from 'react';
+import type { WorkDocumentCaptionKind } from '../work-document-captions';
+import type { WorkDocumentFieldKind } from '../work-document-fields';
+import type { WorkDocumentNoteKind } from '../work-document-notes';
+import type { WorkDocumentContent } from '../work-types';
+export interface DocumentInsertCommands {
+    dialog: ReactNode;
+    insertCaption: (kind: WorkDocumentCaptionKind) => void;
+    insertCrossReference: () => void;
+    insertField: (kind: WorkDocumentFieldKind) => void;
+    insertImage: (file: File) => Promise<void>;
+    insertNote: (kind: WorkDocumentNoteKind) => boolean;
+    refreshFields: () => boolean;
+}
+export declare function useDocumentInsertCommands({ contentRef, editor, }: {
+    contentRef: MutableRefObject<WorkDocumentContent>;
+    editor: Editor | null;
+}): DocumentInsertCommands;

package/dist/internal/features/work/editors/use-document-layout-fonts.d.ts

@@ -0,0 +1,2 @@
+import { type WorkDocumentLayoutFont } from '../work-document-fonts';
+export declare function useDocumentLayoutFonts(fonts: readonly WorkDocumentLayoutFont[]): ReadonlySet<string>;

package/dist/internal/features/work/editors/use-document-page-chrome.d.ts

@@ -0,0 +1,33 @@
+import type { Editor } from '@tiptap/core';
+import { type RefObject } from 'react';
+import type { WorkDocumentPageChromeContent, WorkDocumentPageChromeVariant, WorkDocumentSectionLayout } from '../work-types';
+import type { DocumentPageChromeEditingPart } from './document-page-chrome-ribbon';
+import type { DocumentPaginationPageDescriptor } from './use-document-pagination';
+export interface DocumentPageChromeEditingState {
+    part: DocumentPageChromeEditingPart;
+    sectionId: string;
+    variant: WorkDocumentPageChromeVariant;
+}
+export declare function useDocumentPageChrome({ editor, enabled, firstPage, footerRef, headerRef, lastPage, layout, onBeforeEdit, visiblePage, }: {
+    editor: Editor | null;
+    enabled: boolean;
+    firstPage: DocumentPaginationPageDescriptor;
+    footerRef: RefObject<HTMLElement | null>;
+    headerRef: RefObject<HTMLElement | null>;
+    lastPage: DocumentPaginationPageDescriptor;
+    layout: WorkDocumentSectionLayout;
+    onBeforeEdit: () => boolean | undefined | Promise<boolean | undefined>;
+    visiblePage: DocumentPaginationPageDescriptor;
+}): {
+    chromeEditor: Editor | null;
+    close: () => void;
+    edit: (part: DocumentPageChromeEditingPart) => Promise<void>;
+    editing: DocumentPageChromeEditingState | null;
+    footerChrome: WorkDocumentPageChromeContent;
+    headerChrome: WorkDocumentPageChromeContent;
+    reset: () => void;
+    setChromeEditor: import("react").Dispatch<import("react").SetStateAction<Editor | null>>;
+    togglePageNumber: () => void;
+    update: (patch: Partial<WorkDocumentPageChromeContent>) => void;
+    visibleChrome: WorkDocumentPageChromeContent;
+};

package/dist/internal/features/work/editors/use-document-pagination.d.ts

@@ -0,0 +1,46 @@
+import type { Editor } from '@tiptap/core';
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import type { OfficeKernelLayoutResult, OfficeKernelPageMetrics } from '../../../kernel/office-kernel-protocol';
+import { type WorkDocumentLayoutFont } from '../work-document-fonts';
+import { type MeasuredDocumentLayoutBlock } from '../work-document-pagination';
+import { type ResolvedDocumentPageChrome } from '../work-document-page-chrome';
+import type { WorkDocumentSectionLayout } from '../work-types';
+export interface DocumentPaginationResult {
+    layout: OfficeKernelLayoutResult;
+    blocks: MeasuredDocumentLayoutBlock[];
+    pageByBlockId: ReadonlyMap<string, number>;
+    pages: DocumentPaginationPageDescriptor[];
+}
+export interface DocumentPaginationPageDescriptor {
+    pageIndex: number;
+    physicalPage: number;
+    pageNumber: number;
+    previewText: string;
+    selectionPosition: number;
+    sectionPage: number;
+    sectionId: string;
+    sectionIndex: number;
+    layout: WorkDocumentSectionLayout;
+    pageChrome: ResolvedDocumentPageChrome;
+}
+export interface UseDocumentPaginationOptions {
+    editor: Editor | null;
+    documentRevision: number;
+    enabled: boolean;
+    layoutKey: string;
+    page: OfficeKernelPageMetrics;
+    selectionVersion: number;
+    wasmUrl?: string;
+    layoutFonts: readonly WorkDocumentLayoutFont[];
+    loadedLayoutFontIds: ReadonlySet<string>;
+}
+export interface UseDocumentPaginationValue {
+    currentPage: number | null;
+    currentPageDescriptor: DocumentPaginationPageDescriptor | null;
+    pageCount: number | null;
+    pages: readonly DocumentPaginationPageDescriptor[];
+    paginating: boolean;
+}
+export declare function useDocumentPagination({ editor, documentRevision, enabled, layoutKey, page, selectionVersion, wasmUrl, layoutFonts, loadedLayoutFontIds, }: UseDocumentPaginationOptions): UseDocumentPaginationValue;
+export declare function documentPaginationPageDescriptors(layout: OfficeKernelLayoutResult, blocks: readonly MeasuredDocumentLayoutBlock[], documentNode?: ProseMirrorNode): DocumentPaginationPageDescriptor[];
+export declare function pageForPosition(pagination: DocumentPaginationResult, position: number): number;

package/dist/internal/features/work/editors/use-markdown-source-history.d.ts

@@ -0,0 +1,16 @@
+import type { MarkdownSourceEdit, MarkdownSourceSelection } from './markdown-source-commands';
+interface MarkdownSourceHistorySnapshot extends MarkdownSourceEdit {
+}
+export declare function useMarkdownSourceHistory(initialMarkdown: string): {
+    canUndo: boolean;
+    canRedo: boolean;
+    record: (edit: MarkdownSourceEdit, options?: {
+        typing?: boolean;
+        inputType?: string;
+    }) => boolean;
+    redo: () => MarkdownSourceHistorySnapshot | null;
+    reset: (markdown: string, selection: MarkdownSourceSelection) => void;
+    undo: () => MarkdownSourceHistorySnapshot | null;
+    updateSelection: (selection: MarkdownSourceSelection) => void;
+};
+export {};

package/dist/internal/features/work/editors/use-office-draft.d.ts

@@ -0,0 +1,10 @@
+import { type Dispatch, type SetStateAction } from 'react';
+export declare function useOfficeDraft<Value>(createInitial: () => Value): {
+    cancelDraft: () => void;
+    dirty: boolean;
+    draft: Value;
+    draftRef: import("react").RefObject<Value>;
+    replaceDraft: (next: Value) => void;
+    setDraft: Dispatch<SetStateAction<Value>>;
+    syncDraft: (next: Value, force?: boolean) => void;
+};

package/dist/internal/features/work/editors/use-office-editor-keyboard-shortcuts.d.ts

@@ -0,0 +1,9 @@
+import { type RefObject } from 'react';
+import type { OfficeEditorRuntime } from './office-editor-extension';
+export interface OfficeEditorKeyboardShortcutOptions {
+    capture?: boolean;
+    enabled?: boolean;
+    onHandled?: (event: KeyboardEvent) => void;
+    scopeRef?: RefObject<HTMLElement | null>;
+}
+export declare function useOfficeEditorKeyboardShortcuts<Context, Commands>(editor: OfficeEditorRuntime<Context, Commands>, options?: OfficeEditorKeyboardShortcutOptions): void;

package/dist/internal/features/work/editors/use-office-editor-runtime.d.ts

@@ -0,0 +1,6 @@
+import { type OfficeEditorExtension, type OfficeEditorRuntime } from './office-editor-extension';
+/**
+ * Keeps one extension runtime mounted while React supplies the latest
+ * controlled editor context. Callers should memoize the extension list.
+ */
+export declare function useOfficeEditorRuntime<Context, Commands>(context: Context, extensions: readonly OfficeEditorExtension<Context, Commands>[]): OfficeEditorRuntime<Context, Commands>;

package/dist/internal/features/work/editors/use-office-editor-wheel-zoom.d.ts

@@ -0,0 +1,19 @@
+import { type RefObject } from 'react';
+export interface OfficeEditorWheelZoomOptions {
+    enabled?: boolean;
+    scopeRef: RefObject<HTMLElement | null>;
+    onZoomIn: () => void;
+    onZoomOut: () => void;
+}
+export interface OfficeZoomStepOptions {
+    minimum?: number;
+    maximum?: number;
+    step?: number;
+}
+export declare function stepOfficeZoom(zoom: number, direction: 'in' | 'out', { minimum, maximum, step }?: OfficeZoomStepOptions): number;
+/**
+ * Routes Ctrl/Cmd + wheel to an editor's own zoom model instead of the host
+ * browser. A native non-passive capture listener is required because React's
+ * delegated wheel listener cannot reliably cancel browser zoom.
+ */
+export declare function useOfficeEditorWheelZoom({ enabled, scopeRef, onZoomIn, onZoomOut, }: OfficeEditorWheelZoomOptions): void;

package/dist/internal/features/work/editors/use-office-history.d.ts

@@ -0,0 +1,10 @@
+export declare function useOfficeHistory<Content>({ content, onChange, sameValue, }: {
+    content: Content;
+    onChange: (content: Content) => void;
+    sameValue?: (left: Content, right: Content) => boolean;
+}): {
+    canUndo: boolean;
+    canRedo: boolean;
+    undo: () => boolean;
+    redo: () => boolean;
+};

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

@@ -0,0 +1,22 @@
+import type { WorkPresentationContent, WorkSlide, WorkSlideElement } from '../work-types';
+import type { PresentationDesignMode } from './presentation-editor-types';
+export declare function usePresentationClipboard({ content, mode, targetId, selectedSlide, selectedElements, onChange, onSelectSlide, onSelectElements, }: {
+    content: WorkPresentationContent;
+    mode: PresentationDesignMode;
+    targetId: string | undefined;
+    selectedSlide: WorkSlide | undefined;
+    selectedElements: readonly WorkSlideElement[];
+    onChange: (content: WorkPresentationContent) => void;
+    onSelectSlide: (id: string) => void;
+    onSelectElements: (ids: readonly string[]) => void;
+}): {
+    copySelection: () => boolean;
+    cutSelection: () => boolean;
+    deleteSelection: () => boolean;
+    duplicateSelection: () => boolean;
+    nudgeSelection: (key: string, distance: number) => boolean;
+    pasteSelection: () => boolean;
+    toggleBold: () => boolean;
+    toggleItalic: () => boolean;
+    toggleUnderline: () => boolean;
+};

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

@@ -0,0 +1,33 @@
+import type { WorkPresentationContent, WorkPresentationLayout, WorkPresentationMaster, WorkSlide, WorkSlideElement } from '../work-types';
+import type { PresentationDesignMode } from './presentation-editor-types';
+export interface PresentationDesignCommands {
+    addPlaceholder: (type: 'body' | 'title') => void;
+    applyLayout: (layoutId: string) => void;
+    close: () => void;
+    createLayout: (copyCurrent: boolean) => void;
+    deleteLayout: () => void;
+    edit: (mode: PresentationDesignMode) => void;
+    renameLayout: (name: string) => void;
+    renameMaster: (name: string) => void;
+    setActiveBackground: (background: string) => void;
+    setLayoutBackground: (background: string | undefined) => void;
+    setMasterBackground: (background: string) => void;
+    toggleDesignPanel: () => void;
+    toggleLayoutBackground: (enabled: boolean) => void;
+}
+export declare function usePresentationDesignCommands({ activeElements, activeTargetId, designContent, designMode, designOpen, onChange, onClearSelection, onCloseComments, onEditElement, onSetDesignMode, onSetDesignOpen, selectedLayout, selectedMaster, selectedSlide, }: {
+    activeElements: readonly WorkSlideElement[];
+    activeTargetId: string | undefined;
+    designContent: WorkPresentationContent;
+    designMode: PresentationDesignMode;
+    designOpen: boolean;
+    onChange: (content: WorkPresentationContent) => void;
+    onClearSelection: () => void;
+    onCloseComments: () => void;
+    onEditElement: (id: string) => void;
+    onSetDesignMode: (mode: PresentationDesignMode) => void;
+    onSetDesignOpen: (open: boolean) => void;
+    selectedLayout: WorkPresentationLayout | undefined;
+    selectedMaster: WorkPresentationMaster | undefined;
+    selectedSlide: WorkSlide;
+}): PresentationDesignCommands;

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

@@ -0,0 +1,29 @@
+import { type MutableRefObject } from 'react';
+import type { WorkPresentationContent, WorkSlide, WorkSlideElement } from '../work-types';
+import type { PresentationDesignMode } from './presentation-editor-types';
+import type { OfficeTableDimensions } from './office-table-dimensions';
+import type { PresentationTextValue } from './presentation-text-editor';
+export interface PresentationElementCommands {
+    addChart: () => void;
+    addElement: (type: 'shape' | 'text') => void;
+    addImage: (file: File) => Promise<void>;
+    addTable: (dimensions: OfficeTableDimensions) => void;
+    groupSelection: () => boolean;
+    instantiatePlaceholder: (definition: WorkSlideElement) => void;
+    ungroupSelection: () => boolean;
+    updateElement: (patch: Partial<WorkSlideElement>) => void;
+    updateTextElement: (elementId: string, value: PresentationTextValue) => void;
+}
+export declare function usePresentationElementCommands({ activeElements, activeTargetId, content, contentRef, designMode, onChange, onEditElement, onSelectElements, selectedElementIds, selectedElements, selectedSlide, }: {
+    activeElements: readonly WorkSlideElement[];
+    activeTargetId: string | undefined;
+    content: WorkPresentationContent;
+    contentRef: MutableRefObject<WorkPresentationContent>;
+    designMode: PresentationDesignMode;
+    onChange: (content: WorkPresentationContent) => void;
+    onEditElement: (id: string) => void;
+    onSelectElements: (ids: readonly string[]) => void;
+    selectedElementIds: readonly string[];
+    selectedElements: readonly WorkSlideElement[];
+    selectedSlide: WorkSlide;
+}): PresentationElementCommands;

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

@@ -0,0 +1,17 @@
+import type { OfficeKernelEngine, OfficeKernelPresentationAlignment, OfficeKernelPresentationGeometryElement, OfficeKernelPresentationSnapGuide, OfficeKernelPresentationTransformMode } from '../../../kernel/office-kernel-protocol';
+import type { WorkSlideElement } from '../work-types';
+export interface PresentationSnapResolution {
+    element: OfficeKernelPresentationGeometryElement;
+    guides: OfficeKernelPresentationSnapGuide[];
+}
+export interface PresentationGeometryController {
+    alignElement: (element: WorkSlideElement, alignment: OfficeKernelPresentationAlignment) => Promise<OfficeKernelPresentationGeometryElement | null>;
+    cancel: () => void;
+    engine: OfficeKernelEngine | null;
+    pending: boolean;
+    snapElement: (element: WorkSlideElement, elements: readonly WorkSlideElement[], mode: OfficeKernelPresentationTransformMode, threshold: {
+        x: number;
+        y: number;
+    }) => Promise<PresentationSnapResolution | null>;
+}
+export declare function usePresentationGeometry(wasmUrl?: string, enabled?: boolean): PresentationGeometryController;

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

@@ -0,0 +1,12 @@
+import type { WorkPresentationContent } from '../work-types';
+export declare function usePresentationHistory({ content, onChange, selectedSlideId, onSelectSlide, }: {
+    content: WorkPresentationContent;
+    onChange: (content: WorkPresentationContent) => void;
+    selectedSlideId: string;
+    onSelectSlide: (slideId: string) => void;
+}): {
+    canUndo: boolean;
+    canRedo: boolean;
+    undo: () => boolean;
+    redo: () => boolean;
+};

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

@@ -0,0 +1,22 @@
+import { type ReactNode } from 'react';
+import type { WorkPresentationContent, WorkSlide, WorkSlideElement } from '../work-types';
+export interface PresentationReviewCommands {
+    addComment: () => void;
+    closeComments: () => void;
+    deleteComment: (slideId: string, commentId: string) => void;
+    dialog: ReactNode;
+    locateComment: (slideId: string, commentId: string) => void;
+    openComment: (commentId: string) => void;
+    updateComment: (slideId: string, commentId: string, text: string) => void;
+}
+export declare function usePresentationReviewCommands({ content, onChange, onClearSelection, onCloseComments, onOpenComments, onSelectComment, onSelectSlide, selectedElement, selectedSlide, }: {
+    content: WorkPresentationContent;
+    onChange: (content: WorkPresentationContent) => void;
+    onClearSelection: () => void;
+    onCloseComments: () => void;
+    onOpenComments: () => void;
+    onSelectComment: (id: string | null) => void;
+    onSelectSlide: (id: string) => void;
+    selectedElement: WorkSlideElement | null;
+    selectedSlide: WorkSlide;
+}): PresentationReviewCommands;

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

@@ -0,0 +1,11 @@
+import type { WorkSlideElement } from '../work-types';
+export interface PresentationSelectionController {
+    clear: () => void;
+    edit: (elementId: string) => void;
+    editingElementId: string | null;
+    exitEditing: () => void;
+    replace: (elementIds: readonly string[]) => void;
+    select: (elementId: string | null, additive?: boolean) => void;
+    selectedElementIds: string[];
+}
+export declare function usePresentationSelection(elements: readonly WorkSlideElement[]): PresentationSelectionController;

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

@@ -0,0 +1,18 @@
+import type { WorkPresentationContent, WorkSlide, WorkSlideTransition } from '../work-types';
+export interface PresentationSlideCommands {
+    addSlide: () => void;
+    applyTransitionToAll: (transition: WorkSlideTransition | undefined) => boolean;
+    canApplyTransitionToAll: (transition: WorkSlideTransition | undefined) => boolean;
+    deleteSlide: () => boolean;
+    deleteSlideById: (slideId: string) => boolean;
+    duplicateSlide: () => void;
+    setTransition: (transition: WorkSlideTransition | undefined) => boolean;
+    updateNotes: (notes: string) => void;
+}
+export declare function usePresentationSlideCommands({ content, onChange, onClearSelection, onSelectSlide, selectedSlide, }: {
+    content: WorkPresentationContent;
+    onChange: (content: WorkPresentationContent) => void;
+    onClearSelection: () => void;
+    onSelectSlide: (id: string) => void;
+    selectedSlide: WorkSlide;
+}): PresentationSlideCommands;

package/dist/internal/features/work/editors/use-presentation-thumbnail-visibility.d.ts

@@ -0,0 +1,4 @@
+export declare function usePresentationThumbnailVisibility(slideIds: readonly string[], viewMode: 'normal' | 'sorter'): {
+    viewportRef: import("react").RefObject<HTMLElement | null>;
+    visibleIds: ReadonlySet<string>;
+};

package/dist/internal/features/work/editors/use-presentation-thumbnail-window.d.ts

@@ -0,0 +1,17 @@
+import { type RefObject } from 'react';
+export interface PresentationThumbnailWindow {
+    bottomSpacerHeight: number;
+    end: number;
+    requestFocus: (index: number) => void;
+    requestFocusById: (slideId: string) => void;
+    start: number;
+    topSpacerHeight: number;
+    windowed: boolean;
+}
+export declare function usePresentationThumbnailWindow({ slideIds, selectedSlideId, viewMode, viewportRef, zoom, }: {
+    slideIds: readonly string[];
+    selectedSlideId: string;
+    viewMode: 'normal' | 'sorter';
+    viewportRef: RefObject<HTMLElement | null>;
+    zoom: number;
+}): PresentationThumbnailWindow;

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

@@ -0,0 +1,53 @@
+import { type PointerEvent as ReactPointerEvent, type RefObject } from 'react';
+import type { OfficeKernelPresentationSnapGuide } from '../../../kernel/office-kernel-protocol';
+import type { WorkSlideElement } from '../work-types';
+import type { PresentationGeometryController } from './use-presentation-geometry';
+export interface PresentationTransformDrag {
+    element: WorkSlideElement;
+    elements?: readonly WorkSlideElement[];
+    frame?: WorkSlideElement;
+    mode: 'move' | 'resize';
+    pointerId: number;
+    startX: number;
+    startY: number;
+}
+export interface PresentationTransformPoint {
+    clientX: number;
+    clientY: number;
+}
+export interface PresentationTransformBounds {
+    width: number;
+    height: number;
+}
+export interface PresentationTransformPatch {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    borderWidth?: number;
+    fontSize?: number;
+    textRuns?: WorkSlideElement['textRuns'];
+}
+export interface PresentationTransformCommit {
+    elementId: string;
+    patch: PresentationTransformPatch;
+}
+export interface PresentationTransformController {
+    cancelDrag: () => void;
+    displayElements: WorkSlideElement[];
+    dragging: boolean;
+    guides: OfficeKernelPresentationSnapGuide[];
+    beginDrag: (event: ReactPointerEvent, element: WorkSlideElement, mode: 'move' | 'resize') => void;
+    continueDrag: (event: ReactPointerEvent) => void;
+    endDrag: (event: ReactPointerEvent) => void;
+}
+export declare function usePresentationTransform({ canvasRef, elements, geometry, onCommit, onSelect, selectedElementIds, snapTargets, }: {
+    canvasRef: RefObject<HTMLElement | null>;
+    elements: WorkSlideElement[];
+    geometry: PresentationGeometryController;
+    onCommit: (changes: readonly PresentationTransformCommit[]) => void;
+    onSelect: (elementId: string) => void;
+    selectedElementIds: readonly string[];
+    snapTargets: WorkSlideElement[];
+}): PresentationTransformController;
+export declare function presentationTransformCandidate(drag: PresentationTransformDrag, point: PresentationTransformPoint, bounds: PresentationTransformBounds): WorkSlideElement;

package/dist/internal/features/work/editors/use-spreadsheet-calculation.d.ts

@@ -0,0 +1,17 @@
+import type { Op } from '@fortune-sheet/core';
+import type { WorkbookInstance } from '@fortune-sheet/react';
+import { type RefObject } from 'react';
+import type { WorkSpreadsheetContent } from '../work-types';
+import type { SpreadsheetCalculationCommandPort } from './spreadsheet-command-controller';
+interface UseSpreadsheetCalculationOptions {
+    content: WorkSpreadsheetContent;
+    kernelWasmUrl?: string;
+    workbookRef: RefObject<WorkbookInstance | null>;
+}
+export interface SpreadsheetCalculationController extends SpreadsheetCalculationCommandPort {
+    hasPendingResultPatches: () => boolean;
+    notifyWorkbookOperations: (operations: readonly Op[]) => void;
+    synchronizeWorkbook: (content: WorkSpreadsheetContent, operations: readonly Op[]) => void;
+}
+export declare function useSpreadsheetCalculation({ content, kernelWasmUrl, workbookRef, }: UseSpreadsheetCalculationOptions): SpreadsheetCalculationController;
+export {};

package/dist/internal/features/work/editors/use-spreadsheet-workbook-sync.d.ts

@@ -0,0 +1,10 @@
+import type { Op } from '@fortune-sheet/core';
+import type { WorkSpreadsheetContent } from '../work-types';
+export interface SpreadsheetWorkbookSyncController {
+    acceptContent: (content: WorkSpreadsheetContent) => void;
+    ignoreChangeDuringExternalSync: (matchesExternalContent: boolean) => boolean;
+    mountRevision: number;
+    recordOperations: (operations: readonly Op[]) => void;
+    takeOperations: () => Op[];
+}
+export declare function useSpreadsheetWorkbookSync(content: WorkSpreadsheetContent): SpreadsheetWorkbookSyncController;

package/dist/internal/features/work/editors/work-office-chrome.d.ts

@@ -0,0 +1,61 @@
+import { type ButtonHTMLAttributes, type ReactNode } from 'react';
+export interface WorkOfficeRibbonTab<T extends string> {
+    id: T;
+    label: string;
+    compactLabel?: string;
+}
+export interface WorkOfficeFileAction {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    shortcut?: string;
+    disabled?: boolean;
+    separatorBefore?: boolean;
+    onSelect: () => void | Promise<void>;
+}
+export declare function WorkOfficeRibbon<T extends string>({ ariaLabel, tabs, defaultTab, activeTab, onTabChange, panels, fileActions, className, toolbarClassName, }: {
+    ariaLabel: string;
+    tabs: readonly WorkOfficeRibbonTab<T>[];
+    defaultTab: T;
+    activeTab?: T;
+    onTabChange?: (tab: T) => void;
+    panels: Record<T, ReactNode>;
+    fileActions?: readonly WorkOfficeFileAction[];
+    className?: string;
+    toolbarClassName?: string;
+}): import("react").JSX.Element;
+export declare function WorkOfficePreviewBar({ ariaLabel, label, detail, fileActions, className, }: {
+    ariaLabel: string;
+    label: string;
+    detail?: string;
+    fileActions?: readonly WorkOfficeFileAction[];
+    className?: string;
+}): import("react").JSX.Element;
+export declare function WorkOfficeRibbonGroup({ label, children, }: {
+    label: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function WorkOfficeRibbonButton({ label, visibleLabel, badge, active, displayLabel, className, title, children, ...props }: Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'aria-label' | 'children'> & {
+    label: string;
+    visibleLabel?: string;
+    badge?: ReactNode;
+    active?: boolean;
+    displayLabel?: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function WorkOfficeStatusBar({ children, controls, className, }: {
+    children: ReactNode;
+    controls?: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+export declare function WorkOfficeZoomControls({ zoom, minimum, maximum, step, decreaseLabel, increaseLabel, outputLabel, sliderLabel, onChange, }: {
+    zoom: number;
+    minimum?: number;
+    maximum?: number;
+    step?: number;
+    decreaseLabel: string;
+    increaseLabel: string;
+    outputLabel: string;
+    sliderLabel: string;
+    onChange: (zoom: number) => void;
+}): import("react").JSX.Element;