@a3s-lab/office 0.1.0

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

@@ -0,0 +1,86 @@
+type CommandArguments<Command> = Command extends (...args: infer Arguments extends unknown[]) => unknown ? Arguments : never;
+type CommandResult<Command> = Command extends (...args: never[]) => infer Result ? Result : never;
+export interface OfficeEditorCommandDefinition<Context, Command> {
+    canExecute?: (context: Context, ...args: CommandArguments<Command>) => boolean;
+    execute: (context: Context, ...args: CommandArguments<Command>) => CommandResult<Command>;
+}
+export type OfficeEditorCommandDefinitions<Context, Commands> = {
+    [Name in keyof Commands]?: OfficeEditorCommandDefinition<Context, Commands[Name]>;
+};
+export type OfficeEditorCanCommands<Commands> = {
+    [Name in keyof Commands]: (...args: CommandArguments<Commands[Name]>) => boolean;
+};
+export interface OfficeEditorExtensionLifecycle<Context, Storage> {
+    context: Context;
+    storage: Storage;
+}
+export interface OfficeEditorExtensionUpdate<Context, Storage> extends OfficeEditorExtensionLifecycle<Context, Storage> {
+    previousContext: Context;
+}
+export interface OfficeEditorKeyboardShortcutProps<Context, Commands, Storage> {
+    can: OfficeEditorCanCommands<Commands>;
+    commands: Commands;
+    context: Context;
+    storage: Storage;
+}
+export type OfficeEditorKeyboardShortcutHandler<Context, Commands, Storage> = (props: OfficeEditorKeyboardShortcutProps<Context, Commands, Storage>, event: KeyboardEvent) => boolean;
+export interface OfficeEditorExtensionConfig<Context, Commands, Storage = Record<string, never>> {
+    name: string;
+    priority?: number;
+    addStorage?: () => Storage;
+    addCommands?: (extension: {
+        storage: Storage;
+    }) => OfficeEditorCommandDefinitions<Context, Commands>;
+    addKeyboardShortcuts?: (extension: {
+        storage: Storage;
+    }) => Record<string, OfficeEditorKeyboardShortcutHandler<Context, Commands, Storage>>;
+    onCreate?: (extension: OfficeEditorExtensionLifecycle<Context, Storage>) => void;
+    onUpdate?: (extension: OfficeEditorExtensionUpdate<Context, Storage>) => void;
+    onDestroy?: (extension: OfficeEditorExtensionLifecycle<Context, Storage>) => void;
+}
+interface ErasedOfficeEditorCommand<Context> {
+    canExecute?: (context: Context, args: readonly unknown[]) => boolean;
+    execute: (context: Context, args: readonly unknown[]) => unknown;
+}
+interface OfficeEditorExtensionInstance<Context> {
+    commands: ReadonlyMap<string, ErasedOfficeEditorCommand<Context>>;
+    keyboardShortcuts: readonly ErasedOfficeEditorKeyboardShortcut<Context>[];
+    onCreate: (context: Context) => void;
+    onDestroy: (context: Context) => void;
+    onUpdate: (context: Context, previousContext: Context) => void;
+    storage: unknown;
+}
+interface ErasedOfficeEditorKeyboardShortcut<Context> {
+    handler: (context: Context, commands: unknown, can: unknown, event: KeyboardEvent) => boolean;
+    shortcut: string;
+}
+export interface OfficeEditorExtension<Context, Commands> {
+    readonly name: string;
+    readonly priority: number;
+    createInstance: () => OfficeEditorExtensionInstance<Context>;
+    /**
+     * Type-only marker used to keep command maps aligned across extensions.
+     * It is intentionally absent at runtime.
+     */
+    readonly commandTypes?: Commands;
+}
+export interface OfficeEditorRuntime<Context, Commands> {
+    readonly commands: Commands;
+    readonly extensionNames: readonly string[];
+    readonly storage: Readonly<Record<string, unknown>>;
+    can: () => OfficeEditorCanCommands<Commands>;
+    handleKeyDown: (event: KeyboardEvent) => boolean;
+    mount: () => void;
+    unmount: () => void;
+    updateContext: (context: Context) => void;
+}
+export interface OfficeEditorRuntimeOptions<Context> {
+    /**
+     * Supplies render-current controlled state to commands and can() checks.
+     * Lifecycle callbacks still receive contexts through updateContext().
+     */
+    getCurrentContext?: () => Context;
+}
+export declare function createOfficeEditorExtension<Context, Commands, Storage = Record<string, never>>(config: OfficeEditorExtensionConfig<Context, Commands, Storage>): OfficeEditorExtension<Context, Commands>;
+export declare function createOfficeEditorRuntime<Context, Commands>(initialContext: Context, extensions: readonly OfficeEditorExtension<Context, Commands>[], options?: OfficeEditorRuntimeOptions<Context>): OfficeEditorRuntime<Context, Commands>;
+export { matchesOfficeEditorKeyboardShortcut } from '../../../keyboard-shortcuts';

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

@@ -0,0 +1 @@
+export declare function readOfficeFileAsDataUrl(file: File): Promise<string>;

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

@@ -0,0 +1,187 @@
+export type OfficeFontFamilyGroup = '中文字体' | '西文字体' | '等宽字体';
+export interface OfficeFontFamily {
+    id: string;
+    name: string;
+    cssValue: string;
+    cssFamily: string;
+    label: string;
+    group: OfficeFontFamilyGroup;
+}
+export declare const officeFontFamilies: readonly [{
+    readonly id: "microsoft-yahei";
+    readonly name: "Microsoft YaHei";
+    readonly cssValue: "\"Microsoft YaHei\"";
+    readonly cssFamily: "\"Microsoft YaHei\", \"PingFang SC\", sans-serif";
+    readonly label: "微软雅黑";
+    readonly group: "中文字体";
+}, {
+    readonly id: "pingfang-sc";
+    readonly name: "PingFang SC";
+    readonly cssValue: "\"PingFang SC\"";
+    readonly cssFamily: "\"PingFang SC\", \"Microsoft YaHei\", sans-serif";
+    readonly label: "苹方";
+    readonly group: "中文字体";
+}, {
+    readonly id: "simsun";
+    readonly name: "SimSun";
+    readonly cssValue: "SimSun";
+    readonly cssFamily: "SimSun, \"Songti SC\", serif";
+    readonly label: "宋体";
+    readonly group: "中文字体";
+}, {
+    readonly id: "stsong";
+    readonly name: "STSong";
+    readonly cssValue: "STSong";
+    readonly cssFamily: "STSong, \"Songti SC\", SimSun, serif";
+    readonly label: "华文宋体";
+    readonly group: "中文字体";
+}, {
+    readonly id: "simhei";
+    readonly name: "SimHei";
+    readonly cssValue: "SimHei";
+    readonly cssFamily: "SimHei, \"Heiti SC\", sans-serif";
+    readonly label: "黑体";
+    readonly group: "中文字体";
+}, {
+    readonly id: "stheiti";
+    readonly name: "STHeiti";
+    readonly cssValue: "STHeiti";
+    readonly cssFamily: "STHeiti, \"Heiti SC\", SimHei, sans-serif";
+    readonly label: "华文黑体";
+    readonly group: "中文字体";
+}, {
+    readonly id: "kaiti";
+    readonly name: "KaiTi";
+    readonly cssValue: "KaiTi";
+    readonly cssFamily: "KaiTi, \"Kaiti SC\", serif";
+    readonly label: "楷体";
+    readonly group: "中文字体";
+}, {
+    readonly id: "fangsong";
+    readonly name: "FangSong";
+    readonly cssValue: "FangSong";
+    readonly cssFamily: "FangSong, STFangsong, serif";
+    readonly label: "仿宋";
+    readonly group: "中文字体";
+}, {
+    readonly id: "hiragino-sans-gb";
+    readonly name: "Hiragino Sans GB";
+    readonly cssValue: "\"Hiragino Sans GB\"";
+    readonly cssFamily: "\"Hiragino Sans GB\", \"PingFang SC\", sans-serif";
+    readonly label: "冬青黑体";
+    readonly group: "中文字体";
+}, {
+    readonly id: "aptos";
+    readonly name: "Aptos";
+    readonly cssValue: "Aptos";
+    readonly cssFamily: "Aptos, sans-serif";
+    readonly label: "Aptos";
+    readonly group: "西文字体";
+}, {
+    readonly id: "calibri";
+    readonly name: "Calibri";
+    readonly cssValue: "Calibri";
+    readonly cssFamily: "Calibri";
+    readonly label: "Calibri";
+    readonly group: "西文字体";
+}, {
+    readonly id: "arial";
+    readonly name: "Arial";
+    readonly cssValue: "Arial";
+    readonly cssFamily: "Arial, sans-serif";
+    readonly label: "Arial";
+    readonly group: "西文字体";
+}, {
+    readonly id: "helvetica";
+    readonly name: "Helvetica";
+    readonly cssValue: "Helvetica";
+    readonly cssFamily: "Helvetica, Arial, sans-serif";
+    readonly label: "Helvetica";
+    readonly group: "西文字体";
+}, {
+    readonly id: "times-new-roman";
+    readonly name: "Times New Roman";
+    readonly cssValue: "\"Times New Roman\"";
+    readonly cssFamily: "\"Times New Roman\", Times, serif";
+    readonly label: "Times New Roman";
+    readonly group: "西文字体";
+}, {
+    readonly id: "georgia";
+    readonly name: "Georgia";
+    readonly cssValue: "Georgia";
+    readonly cssFamily: "Georgia, \"Times New Roman\", serif";
+    readonly label: "Georgia";
+    readonly group: "西文字体";
+}, {
+    readonly id: "cambria";
+    readonly name: "Cambria";
+    readonly cssValue: "Cambria";
+    readonly cssFamily: "Cambria, Georgia, serif";
+    readonly label: "Cambria";
+    readonly group: "西文字体";
+}, {
+    readonly id: "garamond";
+    readonly name: "Garamond";
+    readonly cssValue: "Garamond";
+    readonly cssFamily: "Garamond, Georgia, serif";
+    readonly label: "Garamond";
+    readonly group: "西文字体";
+}, {
+    readonly id: "verdana";
+    readonly name: "Verdana";
+    readonly cssValue: "Verdana";
+    readonly cssFamily: "Verdana, Arial, sans-serif";
+    readonly label: "Verdana";
+    readonly group: "西文字体";
+}, {
+    readonly id: "tahoma";
+    readonly name: "Tahoma";
+    readonly cssValue: "Tahoma";
+    readonly cssFamily: "Tahoma, Verdana, sans-serif";
+    readonly label: "Tahoma";
+    readonly group: "西文字体";
+}, {
+    readonly id: "trebuchet-ms";
+    readonly name: "Trebuchet MS";
+    readonly cssValue: "\"Trebuchet MS\"";
+    readonly cssFamily: "\"Trebuchet MS\", Arial, sans-serif";
+    readonly label: "Trebuchet MS";
+    readonly group: "西文字体";
+}, {
+    readonly id: "sf-mono";
+    readonly name: "SFMono-Regular";
+    readonly cssValue: "SFMono-Regular";
+    readonly cssFamily: "SFMono-Regular, Menlo, Consolas, monospace";
+    readonly label: "SF Mono";
+    readonly group: "等宽字体";
+}, {
+    readonly id: "menlo";
+    readonly name: "Menlo";
+    readonly cssValue: "Menlo";
+    readonly cssFamily: "Menlo, SFMono-Regular, Consolas, monospace";
+    readonly label: "Menlo";
+    readonly group: "等宽字体";
+}, {
+    readonly id: "consolas";
+    readonly name: "Consolas";
+    readonly cssValue: "Consolas";
+    readonly cssFamily: "Consolas, \"Courier New\", monospace";
+    readonly label: "Consolas";
+    readonly group: "等宽字体";
+}, {
+    readonly id: "courier-new";
+    readonly name: "Courier New";
+    readonly cssValue: "\"Courier New\"";
+    readonly cssFamily: "\"Courier New\", Courier, monospace";
+    readonly label: "Courier New";
+    readonly group: "等宽字体";
+}, {
+    readonly id: "monaco";
+    readonly name: "Monaco";
+    readonly cssValue: "Monaco";
+    readonly cssFamily: "Monaco, Menlo, Consolas, monospace";
+    readonly label: "Monaco";
+    readonly group: "等宽字体";
+}];
+export declare function officeFontFamilyLabel(value: string): string;
+export declare function normalizeOfficeFontFamily(value: string): string;

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

@@ -0,0 +1,2 @@
+import type { KeyboardEvent } from 'react';
+export declare function moveOfficeMenuFocus(event: KeyboardEvent<HTMLElement>): boolean;

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

@@ -0,0 +1,21 @@
+export declare function OfficeNumberField({ ariaLabel, value, onValueChange, onCommit, onCancel, min, max, step, disabled, className, placeholder, escapeConsumer, validationInvalid, }: {
+    ariaLabel: string;
+    value: number | string;
+    onValueChange: (value: string) => void;
+    onCommit?: (value: string) => void;
+    onCancel?: () => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    className?: string;
+    placeholder?: string;
+    escapeConsumer?: boolean;
+    validationInvalid?: boolean;
+}): import("react").JSX.Element;
+export declare function CommittedOfficeNumberField<Value extends number | undefined = number>({ value, normalizeValue, onValueCommit, formatValue, ...fieldProps }: Omit<Parameters<typeof OfficeNumberField>[0], 'escapeConsumer' | 'onCancel' | 'onCommit' | 'onValueChange' | 'validationInvalid' | 'value'> & {
+    value: Value;
+    normalizeValue: (value: string) => Value | null;
+    onValueCommit: (value: Value) => void;
+    formatValue?: (value: number) => string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,9 @@
+export interface OfficeNumberNormalizationOptions {
+    decimalPlaces?: number;
+    integer?: boolean;
+    isValid?: (value: number) => boolean;
+    maximum?: number;
+    minimum?: number;
+}
+export declare function normalizeRequiredOfficeNumber(value: string, options?: OfficeNumberNormalizationOptions): number | null;
+export declare function normalizeOptionalOfficeNumber(value: string, options?: OfficeNumberNormalizationOptions): number | undefined | null;

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

@@ -0,0 +1,19 @@
+import { type CSSProperties } from 'react';
+export interface OfficeSelectOption<T extends string = string> {
+    value: T;
+    label: string;
+    disabled?: boolean;
+    group?: string;
+    meta?: string;
+    previewStyle?: CSSProperties;
+    searchText?: string;
+}
+export declare function OfficeSelect<T extends string>({ ariaLabel, value, options, onValueChange, disabled, placeholder, className, }: {
+    ariaLabel: string;
+    value: T;
+    options: readonly OfficeSelectOption<T>[];
+    onValueChange: (value: T) => void;
+    disabled?: boolean;
+    placeholder?: string;
+    className?: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export declare function isOfficeShortcutBlocked(target: EventTarget | null): boolean;

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

@@ -0,0 +1,10 @@
+export declare function OfficeSlider({ ariaLabel, value, min, max, step, onValueChange, disabled, className, }: {
+    ariaLabel: string;
+    value: number;
+    min: number;
+    max: number;
+    step?: number;
+    onValueChange: (value: number) => void;
+    disabled?: boolean;
+    className?: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+export interface OfficeTableDimensions {
+    rows: number;
+    columns: number;
+}

package/dist/internal/features/work/editors/office-table-insert-popover.d.ts

@@ -0,0 +1,7 @@
+import type { OfficeTableDimensions } from './office-table-dimensions';
+export declare function OfficeTableInsertPopover({ className, disabled, label, onInsert, }: {
+    className?: string;
+    disabled?: boolean;
+    label: string;
+    onInsert: (dimensions: OfficeTableDimensions) => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,7 @@
+import { type KeyboardEvent } from 'react';
+export declare const OFFICE_TASK_PANE_MODAL_QUERY = "(max-width: 900px)";
+type OfficeTaskPaneClose = () => unknown;
+export declare function handleOfficeTaskPaneKeyDown(event: KeyboardEvent<HTMLElement>, onClose: OfficeTaskPaneClose): void;
+export declare function useOfficeTaskPaneEscape(active: boolean, onClose: OfficeTaskPaneClose): void;
+export declare function useOfficeTaskPaneModal(): boolean;
+export {};

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

@@ -0,0 +1,20 @@
+import { type InputHTMLAttributes, type TextareaHTMLAttributes } from 'react';
+export declare const OfficeTextField: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "type"> & {
+    type?: "text" | "search" | "password";
+} & import("react").RefAttributes<HTMLInputElement>>;
+export declare const OfficeTextArea: import("react").ForwardRefExoticComponent<TextareaHTMLAttributes<HTMLTextAreaElement> & import("react").RefAttributes<HTMLTextAreaElement>>;
+export declare function CommittedOfficeTextField<Value>({ value, formatValue, parseValue, onValueCommit, ...fieldProps }: Omit<InputHTMLAttributes<HTMLInputElement>, 'aria-invalid' | 'defaultValue' | 'onBlur' | 'onChange' | 'onKeyDown' | 'type' | 'value'> & {
+    value: Value;
+    formatValue: (value: Value) => string;
+    parseValue: (draft: string) => Value | null;
+    onValueCommit: (value: Value) => void;
+}): import("react").JSX.Element;
+export declare function CommittedOfficeTextArea<Value>({ value, formatValue, parseValue, onValueCommit, ...textAreaProps }: Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'aria-invalid' | 'defaultValue' | 'onBlur' | 'onChange' | 'onKeyDown' | 'value'> & {
+    value: Value;
+    formatValue: (value: Value) => string;
+    parseValue: (draft: string) => Value | null;
+    onValueCommit: (value: Value) => void;
+}): import("react").JSX.Element;
+export declare const OfficeFileInput: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> & {
+    onFileSelect: (file: File) => unknown;
+} & import("react").RefAttributes<HTMLInputElement>>;

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

@@ -0,0 +1,2 @@
+import type { Extensions } from '@tiptap/core';
+export declare function mergeOfficeTiptapExtensions(editorName: string, builtInExtensions: Extensions, additionalExtensions: Extensions): Extensions;

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

@@ -0,0 +1,23 @@
+import { type PluginRegistry } from '@embedpdf/react-pdf-viewer';
+export type PdfAnnotationToolId = 'highlight' | 'underline' | 'strikeout' | 'ink' | 'freeText';
+export interface PdfAnnotationControllerState {
+    activeToolId: string | null;
+    annotationColor: string;
+    annotationOpacity: number;
+    annotationStrokeWidth: number;
+    available: boolean;
+    availableToolIds: readonly PdfAnnotationToolId[];
+    hasPendingChanges: boolean;
+    selectedCount: number;
+    supportsOpacity: boolean;
+    supportsStrokeWidth: boolean;
+}
+export interface PdfAnnotationController {
+    state: PdfAnnotationControllerState;
+    deleteSelection: () => void;
+    setAnnotationColor: (color: string) => void;
+    setAnnotationOpacity: (opacity: number) => void;
+    setAnnotationStrokeWidth: (strokeWidth: number) => void;
+    selectTool: (toolId: PdfAnnotationToolId | null) => void;
+}
+export declare function usePdfAnnotationController(registry: PluginRegistry | null): PdfAnnotationController;

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

@@ -0,0 +1,36 @@
+import type { PdfAnnotationController, PdfAnnotationToolId } from './pdf-annotation-controller';
+import type { PdfViewerController } from './pdf-viewer-controller';
+import { type OfficeEditorCanCommands, type OfficeEditorExtension } from './office-editor-extension';
+export interface PdfEditorCommands {
+    clearSearch: () => void;
+    deleteAnnotationSelection: () => void;
+    fitPage: () => void;
+    fitWidth: () => void;
+    goToPage: (page: number) => void;
+    nextPage: () => void;
+    nextSearchResult: () => void;
+    previousPage: () => void;
+    previousSearchResult: () => void;
+    redo: () => void;
+    save: () => Promise<void>;
+    search: (query: string) => void;
+    setAnnotationColor: (color: string) => void;
+    setAnnotationOpacity: (opacity: number) => void;
+    setAnnotationStrokeWidth: (strokeWidth: number) => void;
+    selectAnnotationTool: (toolId: PdfAnnotationToolId | null) => void;
+    undo: () => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+}
+export type PdfEditorCanCommands = OfficeEditorCanCommands<PdfEditorCommands>;
+export interface PdfEditorCommandContext {
+    annotation: PdfAnnotationController;
+    editable: boolean;
+    focusSearch: () => void;
+    save: {
+        enabled: boolean;
+        execute: () => Promise<void>;
+    };
+    viewer: PdfViewerController;
+}
+export declare function createPdfEditorExtensions(): readonly OfficeEditorExtension<PdfEditorCommandContext, PdfEditorCommands>[];

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

@@ -0,0 +1,26 @@
+import { type PluginRegistry } from '@embedpdf/react-pdf-viewer';
+import { type RefObject } from 'react';
+export declare const PDF_THUMBNAIL_WINDOW_LIMIT = 32;
+interface PdfThumbnailRange {
+    end: number;
+    start: number;
+    windowed: boolean;
+}
+export interface PdfThumbnailRailProps {
+    currentPage: number;
+    mobileCloseButtonRef?: RefObject<HTMLButtonElement | null>;
+    mobileNavigationId?: string;
+    mobileNavigationModal?: boolean;
+    registry: PluginRegistry;
+    totalPages: number;
+    onCloseMobileNavigation?: () => void;
+    onSelectPage: (page: number) => void;
+}
+export declare function PdfThumbnailRail({ currentPage, mobileCloseButtonRef, mobileNavigationId, mobileNavigationModal, registry, totalPages, onCloseMobileNavigation, onSelectPage, }: PdfThumbnailRailProps): import("react").JSX.Element;
+export declare function calculatePdfThumbnailRange({ anchorIndex, itemHeight, totalPages, viewportHeight, }: {
+    anchorIndex: number;
+    itemHeight?: number;
+    totalPages: number;
+    viewportHeight: number;
+}): PdfThumbnailRange;
+export {};

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

@@ -0,0 +1,23 @@
+import { type RefObject } from 'react';
+import type { PdfAnnotationControllerState } from './pdf-annotation-controller';
+import type { PdfEditorCanCommands, PdfEditorCommands } from './pdf-editor-extensions';
+import type { PdfViewerControllerState } from './pdf-viewer-controller';
+export type PdfSaveState = 'idle' | 'saving' | 'saved' | 'error';
+interface PdfPageNavigationControl {
+    controlsId: string;
+    expanded: boolean;
+    onOpen: () => void;
+    toggleRef: RefObject<HTMLButtonElement | null>;
+}
+export declare function PdfToolbar({ annotationState, can, commands, editable, pageNavigation, saveLabel, saveState, searchInputRef, state, }: {
+    annotationState: PdfAnnotationControllerState;
+    can: PdfEditorCanCommands;
+    commands: PdfEditorCommands;
+    editable: boolean;
+    pageNavigation?: PdfPageNavigationControl;
+    saveLabel: string;
+    saveState: PdfSaveState;
+    searchInputRef: RefObject<HTMLInputElement | null>;
+    state: PdfViewerControllerState;
+}): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,48 @@
+import { type PluginRegistry, ZoomMode } from '@embedpdf/react-pdf-viewer';
+export interface PdfSearchState {
+    active: boolean;
+    activeResultIndex: number;
+    error: boolean;
+    loading: boolean;
+    query: string;
+    total: number;
+}
+export interface PdfViewerFeatures {
+    export: boolean;
+    history: boolean;
+    navigation: boolean;
+    search: boolean;
+    zoom: boolean;
+}
+export interface PdfViewerControllerState {
+    canRedo: boolean;
+    canUndo: boolean;
+    currentPage: number;
+    documentOpen: boolean;
+    error: string | null;
+    features: PdfViewerFeatures;
+    ready: boolean;
+    search: PdfSearchState;
+    totalPages: number;
+    zoomMode: ZoomMode | null;
+    zoomPercent: number;
+}
+export interface PdfViewerController {
+    state: PdfViewerControllerState;
+    clearSearch: () => void;
+    fitPage: () => void;
+    fitWidth: () => void;
+    goToPage: (page: number) => void;
+    nextPage: () => void;
+    nextSearchResult: () => void;
+    previousPage: () => void;
+    previousSearchResult: () => void;
+    redo: () => void;
+    saveAsCopy: () => Promise<Blob>;
+    search: (query: string) => void;
+    undo: () => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+}
+export declare const initialPdfViewerControllerState: PdfViewerControllerState;
+export declare function usePdfViewerController(registry: PluginRegistry | null): PdfViewerController;

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

@@ -0,0 +1,11 @@
+import { type UISchema } from '@embedpdf/react-pdf-viewer';
+export declare const a3sPdfUiSchema: UISchema;
+export interface PdfViewerProps {
+    fileName?: string;
+    loadSource: () => Promise<Blob>;
+    onSave?: (pdf: Blob) => Promise<boolean>;
+    saveLabel?: string;
+    sourceKey?: string;
+    wasmUrl?: string;
+}
+export declare function PdfViewer({ fileName, loadSource, onSave, saveLabel, sourceKey, wasmUrl, }: PdfViewerProps): import("react").JSX.Element;

package/dist/internal/features/work/editors/presentation-arrangement-controller.d.ts

@@ -0,0 +1,19 @@
+import type { OfficeKernelPresentationAlignment } from '../../../kernel/office-kernel-protocol';
+import type { WorkPresentationContent, WorkSlideElement } from '../work-types';
+import type { PresentationDesignMode } from './presentation-editor-types';
+import { type PresentationDistribution } from './presentation-selection';
+import type { PresentationGeometryController } from './use-presentation-geometry';
+export interface PresentationArrangementController {
+    align: (alignment: OfficeKernelPresentationAlignment) => Promise<void>;
+    distribute: (direction: PresentationDistribution) => void;
+    reorder: (direction: -1 | 1) => void;
+}
+export declare function createPresentationArrangementController({ getContent, geometry, mode, onChange, selectedElements, selectedElementIds, targetId, }: {
+    getContent: () => WorkPresentationContent;
+    geometry: PresentationGeometryController;
+    mode: PresentationDesignMode;
+    onChange: (content: WorkPresentationContent) => void;
+    selectedElements: readonly WorkSlideElement[];
+    selectedElementIds: readonly string[];
+    targetId: string | undefined;
+}): PresentationArrangementController;

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

@@ -0,0 +1,21 @@
+import { type WorkSlideChart, type WorkSpreadsheetErrorBarDirection } from '../work-types';
+type CanvasPoint = readonly [number, number];
+export interface PresentationChartAnalysisBounds {
+    x: number[];
+    y: number[];
+}
+export declare function presentationChartAnalysisBounds(chart: WorkSlideChart, xValues: readonly number[]): PresentationChartAnalysisBounds;
+export declare function drawPresentationChartSeriesAnalysis({ context, chart, seriesIndex, xValues, color, trendlinePosition, errorBarPosition, }: {
+    context: CanvasRenderingContext2D;
+    chart: WorkSlideChart;
+    seriesIndex: number;
+    xValues: readonly number[];
+    color: string;
+    trendlinePosition: (x: number, y: number) => CanvasPoint;
+    errorBarPosition: (direction: WorkSpreadsheetErrorBarDirection, pointIndex: number, value: number) => CanvasPoint;
+}): void;
+export declare function drawPresentationChartXyLine(context: CanvasRenderingContext2D, points: Array<{
+    x: number;
+    y: number;
+}>, smooth: boolean): void;
+export {};

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

@@ -0,0 +1,33 @@
+import { type SpreadsheetChartAxisScale } from '../work-spreadsheet-chart-axis';
+import type { WorkSlideChart } from '../work-types';
+export interface PresentationChartRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface PresentationCartesianAxisCanvas {
+    plot: PresentationChartRect;
+    scale: SpreadsheetChartAxisScale;
+    baseline: number;
+    categoryPosition: (index: number) => number;
+    valuePosition: (value: number) => number;
+}
+export interface PresentationXyAxisCanvas {
+    plot: PresentationChartRect;
+    xScale: SpreadsheetChartAxisScale;
+    yScale: SpreadsheetChartAxisScale;
+    xPosition: (value: number) => number;
+    yPosition: (value: number) => number;
+}
+export interface PresentationRadarAxisCanvas {
+    scale: SpreadsheetChartAxisScale;
+    valueRatio: (value: number) => number;
+    point: (index: number, ratio: number) => {
+        x: number;
+        y: number;
+    };
+}
+export declare function drawPresentationCartesianAxes(context: CanvasRenderingContext2D, chart: WorkSlideChart, sourceRect: PresentationChartRect, values: readonly number[], categoryCount: number): PresentationCartesianAxisCanvas;
+export declare function drawPresentationXyAxes(context: CanvasRenderingContext2D, chart: WorkSlideChart, sourceRect: PresentationChartRect, xValues: readonly number[], yValues: readonly number[]): PresentationXyAxisCanvas;
+export declare function drawPresentationRadarAxes(context: CanvasRenderingContext2D, chart: WorkSlideChart, sourceRect: PresentationChartRect, categoryCount: number, values: readonly number[]): PresentationRadarAxisCanvas;

package/dist/internal/features/work/editors/presentation-chart-axis-editor.d.ts

@@ -0,0 +1,5 @@
+import type { WorkSlideChart } from '../work-types';
+export declare function PresentationChartAxisEditor({ chart, onChange, }: {
+    chart: WorkSlideChart;
+    onChange: (chart: WorkSlideChart) => void;
+}): import("react").JSX.Element;