@a3s-lab/office 0.13.1 → 0.15.0

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

@@ -2,14 +2,21 @@ import type { Cell, Selection, Sheet } from '@fortune-sheet/core';
 import { type SpreadsheetGridSize } from '../spreadsheet-sparse';
 import type { WorkSpreadsheetContent } from '../work-types';
 import { type OfficeEditorCanCommands, type OfficeEditorExtension } from './office-editor-extension';
+import type { SpreadsheetAutoSumFunction } from './spreadsheet-auto-sum';
 import { type SpreadsheetCellClearMode } from './spreadsheet-cell-clear';
 import type { SpreadsheetCellBorderFormat } from './spreadsheet-cell-border';
+import type { SpreadsheetCellFormatRequest } from './spreadsheet-cell-format';
+import type { SpreadsheetCellRange } from './spreadsheet-cell-range';
 import type { SpreadsheetCellStyleChoice } from './spreadsheet-cell-style';
 import type { SpreadsheetCellFillDirection } from './spreadsheet-cell-fill';
+import type { SpreadsheetDataValidationRequest, SpreadsheetDataValidationTarget } from './spreadsheet-data-validation';
 import { type SpreadsheetCellMergeCommand } from './spreadsheet-cell-merge';
 import type { SpreadsheetFormatPainterMode } from './spreadsheet-format-painter';
+import type { SpreadsheetHyperlinkCell, SpreadsheetHyperlinkRequest } from './spreadsheet-hyperlink';
 import { type SpreadsheetFreezePanePreset } from './spreadsheet-freeze-panes';
 import { type SpreadsheetKeyboardSelection, type SpreadsheetSelectionMove, type SpreadsheetSelectionScope } from './spreadsheet-keyboard-navigation';
+import type { SpreadsheetPasteContent } from './spreadsheet-paste-special';
+import { type SpreadsheetDecimalPlacesDirection } from './spreadsheet-number-format-command';
 import { type SpreadsheetSheetMoveDirection } from './spreadsheet-sheet-model';
 export interface SpreadsheetWorkbookCommandPort {
     autoFillCell: (copyRange: SpreadsheetCommandRange, applyRange: SpreadsheetCommandRange, direction: SpreadsheetCellFillDirection) => void;
@@ -75,10 +82,14 @@ export interface SpreadsheetHistoryCommandPort {
 export interface SpreadsheetClipboardCommandPort {
     canCopySelection: boolean;
     canCutSelection: boolean;
+    canOpenPasteSpecial: boolean;
     canPasteSelection: boolean;
+    canPasteSpecial: (content: SpreadsheetPasteContent) => boolean;
     copySelection: () => boolean;
     cutSelection: () => boolean;
+    openPasteSpecial: () => boolean;
     pasteSelection: () => boolean;
+    pasteSpecial: (content: SpreadsheetPasteContent) => boolean;
 }
 export interface SpreadsheetAutoFilterCommandPort {
     active: boolean;
@@ -95,6 +106,33 @@ export interface SpreadsheetFormatPainterCommandPort {
     applySelection: (target: SpreadsheetCommandSelection) => boolean;
     cancel: () => boolean;
 }
+export interface SpreadsheetFormatCellsOpenRequest {
+    sheetId: string;
+    range: SpreadsheetCellRange;
+    activeCell: {
+        row: number;
+        column: number;
+    };
+    cells: (Cell | null)[][];
+}
+export interface SpreadsheetFormatCellsCommandPort {
+    canOpen: boolean;
+    open: (request: SpreadsheetFormatCellsOpenRequest) => boolean;
+}
+export interface SpreadsheetDataValidationCommandPort {
+    canOpen: boolean;
+    open: (request: SpreadsheetDataValidationTarget) => boolean;
+}
+export interface SpreadsheetHyperlinkCommandPort {
+    canOpen: boolean;
+    open: (request: SpreadsheetHyperlinkCell) => boolean;
+}
+export interface SpreadsheetNavigationCommandPort {
+    canOpenFind: boolean;
+    canOpenGoTo: boolean;
+    openFind: () => boolean;
+    openGoTo: () => boolean;
+}
 export interface SpreadsheetFormulaBarCommandPort {
     setValue: (value: unknown) => void;
 }
@@ -105,8 +143,13 @@ export interface SpreadsheetEditorCommands {
     activateSheet: (sheetId: string) => boolean;
     activateFormatPainter: (mode: SpreadsheetFormatPainterMode) => boolean;
     addSheet: () => boolean;
+    adjustDecimalPlaces: (direction: SpreadsheetDecimalPlacesDirection) => boolean;
     applyCellStyle: (preset: SpreadsheetCellStyleChoice) => boolean;
+    applyCellFormat: (request: SpreadsheetCellFormatRequest) => boolean;
+    applyDataValidation: (request: SpreadsheetDataValidationRequest) => boolean;
+    applyAutoSum: (functionName: SpreadsheetAutoSumFunction) => boolean;
     applyFormatPainter: (target: SpreadsheetCommandSelection) => boolean;
+    applyHyperlink: (request: SpreadsheetHyperlinkRequest) => boolean;
     cancelFormatPainter: () => boolean;
     clearSelectedCells: (mode?: SpreadsheetCellClearMode) => boolean;
     copySelection: () => boolean;
@@ -121,9 +164,18 @@ export interface SpreadsheetEditorCommands {
     moveSheet: (sheetId: string, direction: SpreadsheetSheetMoveDirection) => boolean;
     moveSelection: (move: SpreadsheetSelectionMove, extend: boolean) => boolean;
     openAutoFilterMenu: () => boolean;
+    openDataValidation: () => boolean;
+    openFind: () => boolean;
+    openFormatCells: () => boolean;
+    openGoTo: () => boolean;
+    openHyperlink: () => boolean;
+    openPasteSpecial: () => boolean;
     pasteCells: (values: readonly (readonly unknown[])[]) => boolean;
     pasteSelection: () => boolean;
+    pasteSpecial: (content: SpreadsheetPasteContent) => boolean;
     recalculateFormula: (scope: 'selection' | 'workbook') => boolean;
+    removeHyperlink: (target: SpreadsheetHyperlinkCell) => boolean;
+    removeDataValidation: (target: SpreadsheetDataValidationTarget) => boolean;
     renameSheet: (sheetId: string, name: string) => boolean;
     redo: () => boolean;
     setCellFormat: (attribute: keyof Cell, value: unknown) => boolean;
@@ -147,11 +199,15 @@ export interface SpreadsheetCommandContext {
     calculation: SpreadsheetCalculationCommandPort | null;
     clipboard: SpreadsheetClipboardCommandPort;
     content: WorkSpreadsheetContent;
+    dataValidation: SpreadsheetDataValidationCommandPort;
     editable: boolean;
     fallbackRange: SpreadsheetCommandRange;
     formulaBar: SpreadsheetFormulaBarCommandPort | null;
     formatPainter: SpreadsheetFormatPainterCommandPort;
+    formatCells: SpreadsheetFormatCellsCommandPort;
+    hyperlink: SpreadsheetHyperlinkCommandPort;
     history: SpreadsheetHistoryCommandPort | null;
+    navigation: SpreadsheetNavigationCommandPort;
     onChange: (content: WorkSpreadsheetContent) => void;
     selection: SpreadsheetCommandSelection | null;
     targetSheetGridSize?: SpreadsheetGridSize | null;

package/dist/internal/features/work/editors/spreadsheet-context-menu.d.ts

@@ -1,19 +1,14 @@
 import type { WorkspaceContextMenuItem } from '../../workspace/components/workspace-context-menu';
 import type { WorkSpreadsheetAgentSelection } from '../work-spreadsheet-agent-context';
 import type { SpreadsheetEditorCanCommands, SpreadsheetEditorCommands, SpreadsheetStructureAxis } from './spreadsheet-command-controller';
-type SpreadsheetContextCan = Pick<SpreadsheetEditorCanCommands, 'clearSelectedCells' | 'pasteCells'>;
-type SpreadsheetContextCommands = Pick<SpreadsheetEditorCommands, 'clearSelectedCells' | 'pasteCells'>;
+type SpreadsheetContextCan = Pick<SpreadsheetEditorCanCommands, 'clearSelectedCells' | 'copySelection' | 'cutSelection' | 'openPasteSpecial' | 'pasteSelection'>;
+type SpreadsheetContextCommands = Pick<SpreadsheetEditorCommands, 'clearSelectedCells' | 'copySelection' | 'cutSelection' | 'openPasteSpecial' | 'pasteSelection'>;
 type SpreadsheetStructureCan = Pick<SpreadsheetEditorCanCommands, 'deleteSelectedStructure' | 'insertSelectedStructure' | 'setSelectedStructureHidden' | 'setSelectedStructureSize' | 'sortSelectedCells'>;
 type SpreadsheetStructureCommands = Pick<SpreadsheetEditorCommands, 'deleteSelectedStructure' | 'insertSelectedStructure' | 'setSelectedStructureHidden' | 'setSelectedStructureSize' | 'sortSelectedCells'>;
 type SpreadsheetSortCan = Pick<SpreadsheetEditorCanCommands, 'sortSelectedCells'>;
 type SpreadsheetSortCommands = Pick<SpreadsheetEditorCommands, 'sortSelectedCells'>;
-export interface SpreadsheetClipboardPort {
-    readText(): Promise<string>;
-    writeText(value: string): Promise<void>;
-}
-export declare function spreadsheetCoreContextMenuItems({ can, clipboard, commands, selection, }: {
+export declare function spreadsheetCoreContextMenuItems({ can, commands, selection, }: {
     can: SpreadsheetContextCan;
-    clipboard?: SpreadsheetClipboardPort;
     commands: SpreadsheetContextCommands;
     selection: Pick<WorkSpreadsheetAgentSelection, 'clipboard' | 'reference'>;
 }): WorkspaceContextMenuItem[];
@@ -29,10 +24,5 @@ export declare function spreadsheetSortContextMenuItems({ can, commands, idSuffi
     idSuffix?: string;
     separatorBefore?: boolean;
 }): WorkspaceContextMenuItem[];
-export declare function parseSpreadsheetClipboardText(value: string): string[][];
-export declare const browserSpreadsheetClipboard: SpreadsheetClipboardPort;
-export declare function readSpreadsheetClipboardText(readSystem: (() => Promise<string>) | undefined, readLocal: () => string, timeoutMs?: number, canReadSystem?: () => boolean | Promise<boolean>): Promise<string>;
-export declare function writeSpreadsheetClipboardText(value: string, writeSystem: ((value: string) => Promise<void>) | undefined, writeLocal: (value: string) => void, timeoutMs?: number): Promise<void>;
-export declare function copySpreadsheetSelection(clipboard: SpreadsheetClipboardPort, value: string, cut: boolean): Promise<boolean>;
-export declare function pasteSpreadsheetSelection(clipboard: SpreadsheetClipboardPort, paste: SpreadsheetContextCommands['pasteCells']): Promise<void>;
-export {};
+export { browserSpreadsheetClipboard, copySpreadsheetSelection, parseSpreadsheetClipboardText, readSpreadsheetClipboardText, writeSpreadsheetClipboardText, } from './spreadsheet-clipboard';
+export type { SpreadsheetClipboardPort } from './spreadsheet-clipboard';

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

@@ -0,0 +1,3 @@
+import type { SpreadsheetCommandContext, SpreadsheetEditorCommands } from './spreadsheet-command-controller';
+import { type OfficeEditorExtension } from './office-editor-extension';
+export declare function createSpreadsheetDataValidationExtension(): OfficeEditorExtension<SpreadsheetCommandContext, SpreadsheetEditorCommands>;

package/dist/internal/features/work/editors/spreadsheet-data-validation-dialog.d.ts

@@ -0,0 +1,9 @@
+import { type SpreadsheetDataValidationDialogSource, type SpreadsheetDataValidationDialogValue } from './spreadsheet-data-validation';
+export declare function SpreadsheetDataValidationDialog({ source, restoreFocusTarget, onApply, onClose, onRemove, onValidate, }: {
+    source: SpreadsheetDataValidationDialogSource;
+    restoreFocusTarget: () => HTMLElement | null;
+    onApply: (value: SpreadsheetDataValidationDialogValue) => boolean;
+    onClose: () => void;
+    onRemove: () => boolean;
+    onValidate: (value: SpreadsheetDataValidationDialogValue) => string | null;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/spreadsheet-data-validation.d.ts

@@ -0,0 +1,50 @@
+import type { WorkSpreadsheetContent, WorkSpreadsheetDataValidationItem, WorkSpreadsheetSheet } from '../work-types';
+import { type SpreadsheetCellRange } from './spreadsheet-cell-range';
+export declare const MAX_SPREADSHEET_DATA_VALIDATION_CELLS = 10000;
+export type SpreadsheetDataValidationType = 'date' | 'dropdown' | 'number' | 'number_integer' | 'text_length';
+export type SpreadsheetDataValidationOperator = 'between' | 'equal' | 'greaterOrEqualTo' | 'lessThan' | 'lessThanOrEqualTo' | 'moreThanThe' | 'noEarlierThan' | 'noLaterThan' | 'notBetween' | 'notEqualTo' | 'earlierThan' | 'laterThan';
+export interface SpreadsheetDataValidationDialogValue {
+    hintShow: boolean;
+    hintValue: string;
+    prohibitInput: boolean;
+    type: SpreadsheetDataValidationType;
+    type2: SpreadsheetDataValidationOperator | '';
+    value1: string;
+    value2: string;
+}
+export interface SpreadsheetDataValidationTarget {
+    activeCell: {
+        row: number;
+        column: number;
+    };
+    ranges: readonly SpreadsheetCellRange[];
+    sheetId: string;
+}
+export interface SpreadsheetDataValidationRequest extends SpreadsheetDataValidationTarget {
+    value: SpreadsheetDataValidationDialogValue;
+}
+export interface SpreadsheetDataValidationDialogSource extends SpreadsheetDataValidationTarget {
+    hasValidation: boolean;
+    mixed: boolean;
+    rangeReference: string;
+    sheetName: string;
+    value: SpreadsheetDataValidationDialogValue;
+}
+export type SpreadsheetDataValidationResult = {
+    item: WorkSpreadsheetDataValidationItem;
+    ok: true;
+    ranges: SpreadsheetCellRange[];
+    sheet: WorkSpreadsheetSheet;
+} | {
+    code: SpreadsheetDataValidationErrorCode;
+    message: string;
+    ok: false;
+};
+export type SpreadsheetDataValidationErrorCode = 'invalid-date' | 'invalid-list-source' | 'invalid-number' | 'invalid-operator' | 'invalid-range' | 'invalid-text-length' | 'missing-value' | 'multiple-list-columns' | 'out-of-bounds' | 'protected-range' | 'range-too-large' | 'sheet-not-found' | 'value-order';
+export declare function spreadsheetDataValidationOperators(type: SpreadsheetDataValidationType): readonly SpreadsheetDataValidationOperator[];
+export declare function createSpreadsheetDataValidationDialogSource(content: WorkSpreadsheetContent, target: SpreadsheetDataValidationTarget): SpreadsheetDataValidationDialogSource | null;
+export declare function validateSpreadsheetDataValidationRequest(content: WorkSpreadsheetContent, request: SpreadsheetDataValidationRequest): SpreadsheetDataValidationResult;
+export declare function applySpreadsheetDataValidation(content: WorkSpreadsheetContent, request: SpreadsheetDataValidationRequest): WorkSpreadsheetContent | null;
+export declare function removeSpreadsheetDataValidation(content: WorkSpreadsheetContent, target: SpreadsheetDataValidationTarget): WorkSpreadsheetContent | null;
+export declare function canRemoveSpreadsheetDataValidation(content: WorkSpreadsheetContent, target: SpreadsheetDataValidationTarget): boolean;
+export declare function spreadsheetDataValidationFailureMessage(content: WorkSpreadsheetContent, request: SpreadsheetDataValidationRequest): string | null;

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

@@ -7,7 +7,7 @@ import type { SpreadsheetFormatPainterMode } from './spreadsheet-format-painter'
 import type { SpreadsheetWorkbookPanelView } from './spreadsheet-workbook-panel';
 import { type WorkOfficeFileAction } from './work-office-chrome';
 export type { SpreadsheetRibbonTabId } from './spreadsheet-command-catalog';
-export declare function SpreadsheetEditorRibbon({ activeTab, autoFilterActive, can, commands, content, fileActions, findOpen, formatPainterMode, freezePanesActive, freezePanesSelection, gridLinesVisible, panelId, onOpenFind, onTabChange, onTogglePanel, panel, toolbarCell, toolbarCellBorders, }: {
+export declare function SpreadsheetEditorRibbon({ activeTab, autoFilterActive, can, commands, content, fileActions, findOpen, formatPainterMode, freezePanesActive, freezePanesSelection, gridLinesVisible, panelId, onTabChange, onTogglePanel, panel, toolbarCell, toolbarCellBorders, }: {
     activeTab: SpreadsheetRibbonTabId;
     autoFilterActive?: boolean;
     can: SpreadsheetEditorCanCommands;
@@ -20,7 +20,6 @@ export declare function SpreadsheetEditorRibbon({ activeTab, autoFilterActive, c
     freezePanesSelection?: Selection;
     gridLinesVisible: boolean;
     panelId: string;
-    onOpenFind: () => void;
     onTabChange: (tab: SpreadsheetRibbonTabId) => void;
     onTogglePanel: (panel: SpreadsheetWorkbookPanelView, trigger: HTMLButtonElement) => void;
     panel: SpreadsheetWorkbookPanelView | null;

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

@@ -32,6 +32,7 @@ export declare function sameSpreadsheetWorkbookState(changed: WorkSpreadsheetCon
 export declare function sameSpreadsheetWorkbookStateAfterOperations(changed: WorkSpreadsheetContent['sheets'], rendered: WorkSpreadsheetContent['sheets'], operations: readonly Op[]): boolean | null;
 export declare function sameSpreadsheetHistoryContent(left: WorkSpreadsheetContent, right: WorkSpreadsheetContent): boolean;
 export declare function spreadsheetContentWithSelection(content: WorkSpreadsheetContent, sheetId: string, selection: Selection | null | undefined): WorkSpreadsheetContent;
+export declare function spreadsheetContentWithSelections(content: WorkSpreadsheetContent, sheetId: string, selections: readonly Selection[]): WorkSpreadsheetContent;
 export declare function isSpreadsheetNativeTextUndoTarget(target: EventTarget | null): boolean;
 export declare function isSpreadsheetCellEditingTarget(target: EventTarget | null): boolean;
 export declare function spreadsheetFormulaBarSelectAllTarget(event: KeyboardEvent): HTMLElement | null;

package/dist/internal/features/work/editors/spreadsheet-format-cells-dialog-model.d.ts

@@ -0,0 +1,86 @@
+import type { Cell } from '@fortune-sheet/core';
+import type { WorkSpreadsheetContent } from '../work-types';
+import { type SpreadsheetCellBorderFormat, type SpreadsheetCellBorderStyle } from './spreadsheet-cell-border';
+import { type SpreadsheetCellFormatPatch, type SpreadsheetHorizontalAlignment, type SpreadsheetVerticalAlignment } from './spreadsheet-cell-format';
+import { type SpreadsheetCellRange } from './spreadsheet-cell-range';
+export declare const spreadsheetFormatCellsTabs: readonly [{
+    readonly id: "number";
+    readonly label: "数字";
+}, {
+    readonly id: "alignment";
+    readonly label: "对齐";
+}, {
+    readonly id: "font";
+    readonly label: "字体";
+}, {
+    readonly id: "border";
+    readonly label: "边框";
+}, {
+    readonly id: "fill";
+    readonly label: "填充";
+}, {
+    readonly id: "protection";
+    readonly label: "保护";
+}];
+export type SpreadsheetFormatCellsTabId = (typeof spreadsheetFormatCellsTabs)[number]['id'];
+export interface SpreadsheetFormatCellsField<T> {
+    value: T;
+    mixed: boolean;
+}
+export interface SpreadsheetFormatCellsFields {
+    numberFormat: SpreadsheetFormatCellsField<string>;
+    horizontalAlignment: SpreadsheetFormatCellsField<SpreadsheetHorizontalAlignment>;
+    verticalAlignment: SpreadsheetFormatCellsField<SpreadsheetVerticalAlignment>;
+    wrapText: SpreadsheetFormatCellsField<boolean>;
+    rotation: SpreadsheetFormatCellsField<number>;
+    fontFamily: SpreadsheetFormatCellsField<string>;
+    fontSize: SpreadsheetFormatCellsField<number>;
+    fontColor: SpreadsheetFormatCellsField<string>;
+    bold: SpreadsheetFormatCellsField<boolean>;
+    italic: SpreadsheetFormatCellsField<boolean>;
+    underline: SpreadsheetFormatCellsField<boolean>;
+    strike: SpreadsheetFormatCellsField<boolean>;
+    fillColor: SpreadsheetFormatCellsField<string | null>;
+    borders: SpreadsheetFormatCellsField<readonly SpreadsheetCellBorderFormat[]>;
+    locked: SpreadsheetFormatCellsField<boolean>;
+    hidden: SpreadsheetFormatCellsField<boolean>;
+}
+export interface SpreadsheetFormatCellsDialogSource {
+    sheetId: string;
+    range: SpreadsheetCellRange;
+    activeCell: Cell | null;
+    fields: SpreadsheetFormatCellsFields;
+}
+export interface SpreadsheetFormatCellsDraft {
+    numberFormat: string;
+    horizontalAlignment: SpreadsheetHorizontalAlignment;
+    verticalAlignment: SpreadsheetVerticalAlignment;
+    wrapText: boolean;
+    rotation: number;
+    fontFamily: string;
+    fontSize: number;
+    fontColor: string;
+    bold: boolean;
+    italic: boolean;
+    underline: boolean;
+    strike: boolean;
+    fillColor: string | null;
+    borders: SpreadsheetCellBorderFormat[];
+    borderColor: string;
+    borderStyle: SpreadsheetCellBorderStyle;
+    locked: boolean;
+    hidden: boolean;
+}
+export type SpreadsheetFormatCellsTouched = Partial<Record<keyof SpreadsheetCellFormatPatch, true>>;
+export interface SpreadsheetFormatCellsDraftErrors {
+    numberFormat?: string;
+    fontSize?: string;
+    rotation?: string;
+}
+export declare function createSpreadsheetFormatCellsDialogSource(content: WorkSpreadsheetContent, sheetId: string, rangeInput: SpreadsheetCellRange, cells: readonly (readonly (Cell | null)[])[], requestedActiveCell: {
+    row: number;
+    column: number;
+}): SpreadsheetFormatCellsDialogSource | null;
+export declare function createSpreadsheetFormatCellsDraft(source: SpreadsheetFormatCellsDialogSource): SpreadsheetFormatCellsDraft;
+export declare function spreadsheetFormatCellsPatch(source: SpreadsheetFormatCellsDialogSource, draft: SpreadsheetFormatCellsDraft, touched: SpreadsheetFormatCellsTouched): SpreadsheetCellFormatPatch;
+export declare function spreadsheetFormatCellsDraftErrors(draft: SpreadsheetFormatCellsDraft): SpreadsheetFormatCellsDraftErrors;

package/dist/internal/features/work/editors/spreadsheet-format-cells-dialog-panels.d.ts

@@ -0,0 +1,15 @@
+import type { Dispatch, SetStateAction } from 'react';
+import type { SpreadsheetCellFormatPatch } from './spreadsheet-cell-format';
+import type { SpreadsheetFormatCellsDialogSource, SpreadsheetFormatCellsDraft, SpreadsheetFormatCellsDraftErrors, SpreadsheetFormatCellsTabId, SpreadsheetFormatCellsTouched } from './spreadsheet-format-cells-dialog-model';
+interface PanelProps {
+    activeTab: SpreadsheetFormatCellsTabId;
+    idBase: string;
+    source: SpreadsheetFormatCellsDialogSource;
+    draft: SpreadsheetFormatCellsDraft;
+    errors: SpreadsheetFormatCellsDraftErrors;
+    touched: SpreadsheetFormatCellsTouched;
+    setDraft: Dispatch<SetStateAction<SpreadsheetFormatCellsDraft>>;
+    touch: (field: keyof SpreadsheetCellFormatPatch) => void;
+}
+export declare function SpreadsheetFormatCellsPanel(props: PanelProps): import("react").JSX.Element;
+export {};

package/dist/internal/features/work/editors/spreadsheet-format-cells-dialog.d.ts

@@ -0,0 +1,8 @@
+import type { SpreadsheetCellFormatPatch } from './spreadsheet-cell-format';
+import { type SpreadsheetFormatCellsDialogSource } from './spreadsheet-format-cells-dialog-model';
+export declare function SpreadsheetFormatCellsDialog({ source, restoreFocusTarget, onApply, onClose, }: {
+    source: SpreadsheetFormatCellsDialogSource;
+    restoreFocusTarget: () => HTMLElement | null;
+    onApply: (patch: SpreadsheetCellFormatPatch) => boolean;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/spreadsheet-go-to.d.ts

@@ -0,0 +1,24 @@
+import type { WorkSpreadsheetContent } from '../work-types';
+import type { SpreadsheetCellRange } from './spreadsheet-cell-range';
+export type SpreadsheetGoToErrorCode = 'ambiguous-name' | 'empty' | 'hidden-sheet' | 'invalid-reference' | 'multiple-ranges' | 'out-of-bounds' | 'sheet-not-found' | 'unsupported-name';
+export interface SpreadsheetGoToTarget {
+    displayReference: string;
+    name?: string;
+    range: SpreadsheetCellRange;
+    selection: SpreadsheetCellRange & {
+        row_focus: number;
+        column_focus: number;
+    };
+    sheetId: string;
+    source: 'named-range' | 'reference';
+}
+export type SpreadsheetGoToResolution = {
+    ok: true;
+    target: SpreadsheetGoToTarget;
+} | {
+    ok: false;
+    code: SpreadsheetGoToErrorCode;
+    message: string;
+};
+export declare function resolveSpreadsheetGoToTarget(content: WorkSpreadsheetContent, activeSheetId: string, input: string): SpreadsheetGoToResolution;
+export declare function spreadsheetGoToValidationMessage(content: WorkSpreadsheetContent, activeSheetId: string, input: string): string | null;

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

@@ -0,0 +1,3 @@
+import type { SpreadsheetCommandContext, SpreadsheetEditorCommands } from './spreadsheet-command-controller';
+import { type OfficeEditorExtension } from './office-editor-extension';
+export declare function createSpreadsheetHyperlinkExtension(): OfficeEditorExtension<SpreadsheetCommandContext, SpreadsheetEditorCommands>;

package/dist/internal/features/work/editors/spreadsheet-hyperlink-dialog.d.ts

@@ -0,0 +1,9 @@
+import type { SpreadsheetHyperlinkDialogSource, SpreadsheetHyperlinkDialogValue } from './spreadsheet-hyperlink';
+export declare function SpreadsheetHyperlinkDialog({ source, restoreFocusTarget, onApply, onClose, onRemove, onValidate, }: {
+    source: SpreadsheetHyperlinkDialogSource;
+    restoreFocusTarget: () => HTMLElement | null;
+    onApply: (value: SpreadsheetHyperlinkDialogValue) => boolean;
+    onClose: () => void;
+    onRemove: () => boolean;
+    onValidate: (value: SpreadsheetHyperlinkDialogValue) => string | null;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,44 @@
+import type { WorkSpreadsheetContent } from '../work-types';
+export type SpreadsheetHyperlinkType = 'webpage' | 'cellrange' | 'sheet';
+export interface SpreadsheetHyperlinkTarget {
+    linkType: SpreadsheetHyperlinkType;
+    linkAddress: string;
+}
+export interface SpreadsheetHyperlinkCell {
+    sheetId: string;
+    row: number;
+    column: number;
+}
+export interface SpreadsheetHyperlinkRequest extends SpreadsheetHyperlinkCell {
+    linkType: SpreadsheetHyperlinkType;
+    linkAddress: string;
+    displayText?: string;
+}
+export type SpreadsheetHyperlinkDialogValue = Pick<SpreadsheetHyperlinkRequest, 'linkType' | 'linkAddress' | 'displayText'>;
+export type SpreadsheetHyperlinkErrorCode = 'empty-address' | 'formula-display-text' | 'invalid-cell-range' | 'invalid-display-text' | 'invalid-web-address' | 'pivot-cell' | 'protected-cell' | 'source-out-of-bounds' | 'source-sheet-not-found' | 'target-out-of-bounds' | 'target-sheet-hidden' | 'target-sheet-not-found' | 'unsupported-link-type';
+export type SpreadsheetHyperlinkValidation = {
+    ok: true;
+    target: SpreadsheetHyperlinkTarget;
+    displayText?: string;
+} | {
+    ok: false;
+    code: SpreadsheetHyperlinkErrorCode;
+    message: string;
+};
+export interface SpreadsheetHyperlinkDialogSource extends SpreadsheetHyperlinkCell {
+    sheetName: string;
+    cellReference: string;
+    displayText: string;
+    displayTextEditable: boolean;
+    hasHyperlink: boolean;
+    link: SpreadsheetHyperlinkTarget | null;
+    sheetOptions: Array<{
+        id: string;
+        name: string;
+    }>;
+}
+export declare function validateSpreadsheetHyperlinkRequest(content: WorkSpreadsheetContent, request: SpreadsheetHyperlinkRequest): SpreadsheetHyperlinkValidation;
+export declare function applySpreadsheetHyperlink(content: WorkSpreadsheetContent, request: SpreadsheetHyperlinkRequest): WorkSpreadsheetContent | null;
+export declare function removeSpreadsheetHyperlink(content: WorkSpreadsheetContent, target: SpreadsheetHyperlinkCell): WorkSpreadsheetContent | null;
+export declare function canRemoveSpreadsheetHyperlink(content: WorkSpreadsheetContent, target: SpreadsheetHyperlinkCell): boolean;
+export declare function createSpreadsheetHyperlinkDialogSource(content: WorkSpreadsheetContent, target: SpreadsheetHyperlinkCell): SpreadsheetHyperlinkDialogSource | null;

package/dist/internal/features/work/editors/spreadsheet-keyboard-navigation.d.ts

@@ -16,3 +16,7 @@ export declare function spreadsheetSelectionContainsFocus(selection: Spreadsheet
     column: number;
     row: number;
 }): boolean;
+export declare function spreadsheetSheetBounds(sheet: WorkSpreadsheetSheet): {
+    lastColumn: number;
+    lastRow: number;
+};

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

@@ -0,0 +1,3 @@
+import type { SpreadsheetCommandContext, SpreadsheetEditorCommands } from './spreadsheet-command-controller';
+import { type OfficeEditorExtension } from './office-editor-extension';
+export declare function createSpreadsheetNavigationExtension(): OfficeEditorExtension<SpreadsheetCommandContext, SpreadsheetEditorCommands>;

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

@@ -0,0 +1,24 @@
+import type { Cell } from '@fortune-sheet/core';
+import type { WorkSpreadsheetContent } from '../work-types';
+import { type SpreadsheetCellRange, type SpreadsheetCellRangeInput } from './spreadsheet-cell-range';
+import type { SpreadsheetCommandContext, SpreadsheetEditorCommands } from './spreadsheet-command-controller';
+import { type OfficeEditorExtension } from './office-editor-extension';
+export type SpreadsheetDecimalPlacesDirection = 'decrease' | 'increase';
+export declare const MAX_SPREADSHEET_DECIMAL_FORMAT_CELLS = 10000;
+export interface SpreadsheetDecimalFormatApiCall {
+    name: 'setCellFormatByRange';
+    args: [
+        'ct',
+        NonNullable<Cell['ct']> & {
+            fa: string;
+            t: string;
+        },
+        SpreadsheetCellRange,
+        {
+            id: string;
+        }
+    ];
+}
+export declare function createSpreadsheetNumberFormatExtension(): OfficeEditorExtension<SpreadsheetCommandContext, SpreadsheetEditorCommands>;
+export declare function canAdjustSpreadsheetDecimalPlaces(content: WorkSpreadsheetContent, sheetId: string, range: SpreadsheetCellRangeInput, direction: SpreadsheetDecimalPlacesDirection): boolean;
+export declare function spreadsheetDecimalFormatApiCalls(cells: readonly (readonly (Cell | null)[])[], range: SpreadsheetCellRangeInput, sheetId: string, direction: SpreadsheetDecimalPlacesDirection): SpreadsheetDecimalFormatApiCall[];

package/dist/internal/features/work/editors/spreadsheet-paste-special-cell.d.ts

@@ -0,0 +1,17 @@
+import type { Cell } from '@fortune-sheet/core';
+import type { SpreadsheetClipboardCell, SpreadsheetPasteContent, SpreadsheetPasteOperation } from './spreadsheet-paste-special-types';
+export declare const spreadsheetPasteCellInvalid: unique symbol;
+export type SpreadsheetPasteCellResult = Cell | null | typeof spreadsheetPasteCellInvalid;
+export declare function pasteSpreadsheetSpecialCell({ source, destination, content, operation, rowOffset, columnOffset, }: {
+    source: SpreadsheetClipboardCell;
+    destination: Cell | null | undefined;
+    content: SpreadsheetPasteContent;
+    operation: SpreadsheetPasteOperation;
+    rowOffset: number;
+    columnOffset: number;
+}): SpreadsheetPasteCellResult;
+export declare function spreadsheetClipboardCellIsBlank(source: SpreadsheetClipboardCell, content: SpreadsheetPasteContent): boolean;
+export declare function spreadsheetPasteContentSupportsOperation(content: SpreadsheetPasteContent): boolean;
+export declare function numericSpreadsheetCellValue(cell: Cell | null | undefined): number | null;
+export declare function spreadsheetCellHasContent(cell: Cell | null | undefined): boolean;
+export declare function translateSpreadsheetFormula(formula: string, rowOffset: number, columnOffset: number): string | null;

package/dist/internal/features/work/editors/spreadsheet-paste-special-dialog.d.ts

@@ -0,0 +1,9 @@
+import { type SpreadsheetPasteSpecialOptions } from './spreadsheet-paste-special';
+import type { SpreadsheetPasteSpecialDialogSource } from './use-spreadsheet-clipboard';
+export declare function SpreadsheetPasteSpecialDialog({ source, restoreFocusTarget, onApply, onClose, onValidate, }: {
+    source: SpreadsheetPasteSpecialDialogSource;
+    restoreFocusTarget: () => HTMLElement | null;
+    onApply: (options: SpreadsheetPasteSpecialOptions) => boolean;
+    onClose: () => void;
+    onValidate: (options: SpreadsheetPasteSpecialOptions) => string | null;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/spreadsheet-paste-special-mode.d.ts

@@ -0,0 +1,11 @@
+import type { WorkSpreadsheetSheet } from '../work-types';
+import type { SpreadsheetPasteContent } from './spreadsheet-paste-special-types';
+export declare function pasteContentCopiesFormulas(content: SpreadsheetPasteContent): boolean;
+export declare function pasteContentCopiesBorders(content: SpreadsheetPasteContent): boolean;
+export declare function pasteContentCopiesMerges(content: SpreadsheetPasteContent): boolean;
+export declare function pasteContentCopiesValidation(content: SpreadsheetPasteContent): boolean;
+export declare function pasteContentCopiesHyperlinks(content: SpreadsheetPasteContent): boolean;
+export declare function pasteContentCopiesProtection(content: SpreadsheetPasteContent): boolean;
+export declare function columnsContainReadOnlyState(sheet: WorkSpreadsheetSheet, range: {
+    column: [number, number];
+}): boolean;

package/dist/internal/features/work/editors/spreadsheet-paste-special-plan.d.ts

@@ -0,0 +1,4 @@
+import type { SpreadsheetCellRange } from './spreadsheet-cell-range';
+import { type SpreadsheetClipboardSnapshot, type SpreadsheetPastePlan, type SpreadsheetPasteSource } from './spreadsheet-paste-special-types';
+export declare function planSpreadsheetPaste(snapshot: SpreadsheetClipboardSnapshot, selection: SpreadsheetCellRange, transpose: boolean): SpreadsheetPastePlan | null;
+export declare function spreadsheetPasteSourceAt(snapshot: SpreadsheetClipboardSnapshot, plan: SpreadsheetPastePlan, row: number, column: number, transpose: boolean): SpreadsheetPasteSource;

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

@@ -0,0 +1,23 @@
+import type { WorkSpreadsheetContent, WorkSpreadsheetSheet } from '../work-types';
+import { type SpreadsheetCellRange } from './spreadsheet-cell-range';
+import type { SpreadsheetCellWriter, SpreadsheetClipboardSnapshot, SpreadsheetPastePlan, SpreadsheetPasteSpecialOptions } from './spreadsheet-paste-special-types';
+type NativeMerge = {
+    r: number;
+    c: number;
+    rs: number;
+    cs: number;
+};
+export declare function applySpreadsheetPasteSheetMetadata(sheet: WorkSpreadsheetSheet, snapshot: SpreadsheetClipboardSnapshot, plan: SpreadsheetPastePlan, processed: Array<{
+    row: number;
+    column: number;
+}>, options: SpreadsheetPasteSpecialOptions): WorkSpreadsheetSheet;
+export declare function applySpreadsheetPasteBorders(content: WorkSpreadsheetContent, sheetId: string, snapshot: SpreadsheetClipboardSnapshot, plan: SpreadsheetPastePlan, processed: Array<{
+    row: number;
+    column: number;
+}>, transpose: boolean): WorkSpreadsheetContent;
+export declare function applySpreadsheetPasteMerges(writer: SpreadsheetCellWriter, snapshot: SpreadsheetClipboardSnapshot, plan: SpreadsheetPastePlan, transpose: boolean): Record<string, NativeMerge>;
+export declare function withSpreadsheetPasteMerges(sheet: WorkSpreadsheetSheet, merges: Record<string, NativeMerge>): WorkSpreadsheetSheet;
+export declare function pasteSpreadsheetColumnWidths(sheet: WorkSpreadsheetSheet, snapshot: SpreadsheetClipboardSnapshot, plan: SpreadsheetPastePlan): WorkSpreadsheetSheet;
+export declare function createSpreadsheetCellWriter(source: WorkSpreadsheetSheet): SpreadsheetCellWriter;
+export declare function withSpreadsheetPasteSelection(sheet: WorkSpreadsheetSheet, range: SpreadsheetCellRange): WorkSpreadsheetSheet;
+export {};

package/dist/internal/features/work/editors/spreadsheet-paste-special-snapshot.d.ts

@@ -0,0 +1,10 @@
+import type { Cell } from '@fortune-sheet/core';
+import type { WorkSpreadsheetContent, WorkSpreadsheetSheet } from '../work-types';
+import { type SpreadsheetCellRangeInput } from './spreadsheet-cell-range';
+import { type SpreadsheetClipboardSnapshot, type SpreadsheetPasteContent } from './spreadsheet-paste-special-types';
+export declare function captureSpreadsheetClipboardSnapshot(content: WorkSpreadsheetContent, sheetId: string, selection: SpreadsheetCellRangeInput, plainText: string): SpreadsheetClipboardSnapshot | null;
+export declare function createSpreadsheetTextClipboardSnapshot(plainText: string): SpreadsheetClipboardSnapshot | null;
+export declare function spreadsheetPasteSpecialModeAvailable(snapshot: SpreadsheetClipboardSnapshot, content: SpreadsheetPasteContent): boolean;
+export declare function validSpreadsheetClipboardSnapshot(snapshot: SpreadsheetClipboardSnapshot): boolean;
+export declare function createSpreadsheetCellReader(sheet: WorkSpreadsheetSheet): (row: number, column: number) => Cell | null | undefined;
+export declare function normalizeSpreadsheetClipboardText(value: string): string;