@a3s-lab/office 0.13.0 → 0.14.0

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-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-number-format.d.ts

@@ -1,6 +1,19 @@
 import type { Cell } from '@fortune-sheet/core';
-export type SpreadsheetNumberFormatPreset = 'general' | 'number' | 'percent' | 'custom';
-type SpreadsheetNumberFormatChoice = Exclude<SpreadsheetNumberFormatPreset, 'custom'>;
+export type SpreadsheetNumberFormatPreset = 'general' | 'number' | 'currency' | 'accounting' | 'percent' | 'date' | 'time' | 'scientific' | 'fraction' | 'text' | 'custom';
+export type SpreadsheetNumberFormatChoice = Exclude<SpreadsheetNumberFormatPreset, 'custom'>;
+export declare const spreadsheetNumberFormatPresetLabels: {
+    readonly general: "常规";
+    readonly number: "数字";
+    readonly currency: "货币";
+    readonly accounting: "会计专用";
+    readonly percent: "百分比";
+    readonly date: "短日期";
+    readonly time: "时间";
+    readonly scientific: "科学计数";
+    readonly fraction: "分数";
+    readonly text: "文本";
+    readonly custom: "自定义";
+};
 export declare function spreadsheetNumberFormatPreset(formatCode?: string): SpreadsheetNumberFormatPreset;
 export declare function spreadsheetNumberFormatCode(preset: SpreadsheetNumberFormatChoice): string;
 export declare function spreadsheetNumberFormatValue(formatCode: string, cell?: Cell | null): NonNullable<Cell['ct']> & {
@@ -8,4 +21,3 @@ export declare function spreadsheetNumberFormatValue(formatCode: string, cell?:
     t: string;
 };
 export declare function adjustSpreadsheetNumberFormat(formatCode: string | undefined, direction: -1 | 1): string;
-export {};

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;

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

@@ -0,0 +1,127 @@
+import type { Cell } from '@fortune-sheet/core';
+import type { SpreadsheetResolvedCellBorders } from './spreadsheet-cell-border';
+import type { SpreadsheetCellRange, SpreadsheetCellRangeInput } from './spreadsheet-cell-range';
+import type { WorkSpreadsheetContent, WorkSpreadsheetDataValidationItem, WorkSpreadsheetSheet } from '../work-types';
+export declare const MAX_SPREADSHEET_PASTE_SPECIAL_CELLS = 50000;
+export declare const MAX_SPREADSHEET_ROWS = 1048576;
+export declare const MAX_SPREADSHEET_COLUMNS = 16384;
+export declare const spreadsheetPasteContentOptions: readonly [{
+    readonly value: "all";
+    readonly label: "全部";
+    readonly richOnly: false;
+}, {
+    readonly value: "formulas";
+    readonly label: "公式";
+    readonly richOnly: false;
+}, {
+    readonly value: "values";
+    readonly label: "值";
+    readonly richOnly: false;
+}, {
+    readonly value: "formats";
+    readonly label: "格式";
+    readonly richOnly: true;
+}, {
+    readonly value: "comments";
+    readonly label: "批注";
+    readonly richOnly: true;
+}, {
+    readonly value: "validation";
+    readonly label: "数据验证";
+    readonly richOnly: true;
+}, {
+    readonly value: "all-except-borders";
+    readonly label: "边框除外的全部";
+    readonly richOnly: true;
+}, {
+    readonly value: "formulas-and-number-formats";
+    readonly label: "公式和数字格式";
+    readonly richOnly: true;
+}, {
+    readonly value: "values-and-number-formats";
+    readonly label: "值和数字格式";
+    readonly richOnly: true;
+}, {
+    readonly value: "column-widths";
+    readonly label: "列宽";
+    readonly richOnly: true;
+}];
+export type SpreadsheetPasteContent = (typeof spreadsheetPasteContentOptions)[number]['value'];
+export declare const spreadsheetPasteOperationOptions: readonly [{
+    readonly value: "none";
+    readonly label: "无";
+}, {
+    readonly value: "add";
+    readonly label: "加";
+}, {
+    readonly value: "subtract";
+    readonly label: "减";
+}, {
+    readonly value: "multiply";
+    readonly label: "乘";
+}, {
+    readonly value: "divide";
+    readonly label: "除";
+}];
+export type SpreadsheetPasteOperation = (typeof spreadsheetPasteOperationOptions)[number]['value'];
+export interface SpreadsheetPasteSpecialOptions {
+    content: SpreadsheetPasteContent;
+    operation: SpreadsheetPasteOperation;
+    skipBlanks: boolean;
+    transpose: boolean;
+}
+export interface SpreadsheetClipboardCell {
+    cell: Cell | null;
+    borders: SpreadsheetResolvedCellBorders;
+    validation?: WorkSpreadsheetDataValidationItem;
+    protection?: {
+        locked: boolean;
+        hidden: boolean;
+    };
+    hyperlink?: NonNullable<WorkSpreadsheetSheet['hyperlink']>[string];
+}
+export interface SpreadsheetClipboardMerge {
+    row: number;
+    column: number;
+    rowSpan: number;
+    columnSpan: number;
+}
+export interface SpreadsheetClipboardSnapshot {
+    version: 1;
+    kind: 'rich' | 'text';
+    plainText: string;
+    sourceSheetId?: string;
+    sourceRange: SpreadsheetCellRange;
+    rowCount: number;
+    columnCount: number;
+    cells: SpreadsheetClipboardCell[][];
+    columnWidths?: number[];
+    merges: SpreadsheetClipboardMerge[];
+    containsUnsupportedFormulaState: boolean;
+}
+export interface SpreadsheetPasteSpecialRequest {
+    snapshot: SpreadsheetClipboardSnapshot;
+    targetSheetId: string;
+    targetSelection: SpreadsheetCellRangeInput;
+    options: SpreadsheetPasteSpecialOptions;
+}
+export interface SpreadsheetPasteSpecialResult {
+    content: WorkSpreadsheetContent;
+    targetRange: SpreadsheetCellRange;
+    firstCellValue: unknown;
+}
+export interface SpreadsheetPastePlan {
+    targetRange: SpreadsheetCellRange;
+    rowCount: number;
+    columnCount: number;
+}
+export interface SpreadsheetCellWriter {
+    get(row: number, column: number): Cell | null | undefined;
+    set(row: number, column: number, cell: Cell | null): void;
+    finish(sheet: WorkSpreadsheetSheet): WorkSpreadsheetSheet;
+}
+export interface SpreadsheetPasteSource {
+    cell: SpreadsheetClipboardCell;
+    sourceRow: number;
+    sourceColumn: number;
+}

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

@@ -0,0 +1,7 @@
+import type { WorkSpreadsheetContent } from '../work-types';
+import { type SpreadsheetPasteSpecialRequest, type SpreadsheetPasteSpecialResult } from './spreadsheet-paste-special-types';
+export { captureSpreadsheetClipboardSnapshot, createSpreadsheetTextClipboardSnapshot, normalizeSpreadsheetClipboardText, spreadsheetPasteSpecialModeAvailable, } from './spreadsheet-paste-special-snapshot';
+export { MAX_SPREADSHEET_COLUMNS, MAX_SPREADSHEET_PASTE_SPECIAL_CELLS, MAX_SPREADSHEET_ROWS, spreadsheetPasteContentOptions, spreadsheetPasteOperationOptions, } from './spreadsheet-paste-special-types';
+export type { SpreadsheetClipboardCell, SpreadsheetClipboardMerge, SpreadsheetClipboardSnapshot, SpreadsheetPasteContent, SpreadsheetPasteOperation, SpreadsheetPasteSpecialOptions, SpreadsheetPasteSpecialRequest, SpreadsheetPasteSpecialResult, } from './spreadsheet-paste-special-types';
+export declare function spreadsheetPasteSpecialValidationError(content: WorkSpreadsheetContent, request: SpreadsheetPasteSpecialRequest): string | null;
+export declare function applySpreadsheetPasteSpecial(content: WorkSpreadsheetContent, request: SpreadsheetPasteSpecialRequest): SpreadsheetPasteSpecialResult | null;

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

@@ -0,0 +1,36 @@
+import type { MutableRefObject } from 'react';
+import type { WorkSpreadsheetContent } from '../work-types';
+import { type SpreadsheetClipboardPort } from './spreadsheet-clipboard';
+import type { SpreadsheetClipboardCommandPort } from './spreadsheet-command-controller';
+import type { SpreadsheetCellRange } from './spreadsheet-cell-range';
+import { type SpreadsheetClipboardSnapshot, type SpreadsheetPasteContent, type SpreadsheetPasteSpecialOptions } from './spreadsheet-paste-special';
+export interface SpreadsheetClipboardSelectionSource {
+    sheetId: string;
+    range: SpreadsheetCellRange;
+    plainText: string;
+}
+export interface SpreadsheetPasteSpecialDialogSource {
+    snapshot: SpreadsheetClipboardSnapshot;
+    targetSheetId: string;
+    targetRange: SpreadsheetCellRange;
+    invoker: HTMLElement | null;
+}
+export declare function useSpreadsheetClipboard({ clipboard, canAccessSelection, clearSelection, commit, contentRef, editable, fallbackFocusTarget, getSelection, }: {
+    clipboard?: SpreadsheetClipboardPort;
+    canAccessSelection: boolean;
+    clearSelection: () => boolean;
+    commit: (content: WorkSpreadsheetContent) => boolean;
+    contentRef: MutableRefObject<WorkSpreadsheetContent>;
+    editable: boolean;
+    fallbackFocusTarget: () => HTMLElement | null;
+    getSelection: () => SpreadsheetClipboardSelectionSource | null;
+}): {
+    applyDialog: (options: SpreadsheetPasteSpecialOptions) => boolean;
+    closeDialog: () => void;
+    commandPort: SpreadsheetClipboardCommandPort;
+    copyToDataTransfer: (data: DataTransfer, cut: boolean) => boolean;
+    dialogSource: SpreadsheetPasteSpecialDialogSource | null;
+    pasteText: (plainText: string, content?: SpreadsheetPasteContent, notify?: boolean) => boolean;
+    restoreDialogFocusTarget: () => HTMLElement | null;
+    validateDialog: (options: SpreadsheetPasteSpecialOptions) => string | null;
+};

package/dist/internal/features/work/work-xlsx-cell-borders.d.ts

@@ -0,0 +1,25 @@
+import type { Sheet } from '@fortune-sheet/core';
+export type XlsxCellBorderStyle = 'dashDot' | 'dashDotDot' | 'dashed' | 'dotted' | 'double' | 'hair' | 'medium' | 'mediumDashDot' | 'mediumDashDotDot' | 'mediumDashed' | 'slantDashDot' | 'thick' | 'thin';
+export interface XlsxCellBorderLine {
+    color: string;
+    style: XlsxCellBorderStyle;
+}
+export interface XlsxCellBorder {
+    bottom?: XlsxCellBorderLine | null;
+    diagonal?: XlsxCellBorderLine | null;
+    diagonalDown?: boolean;
+    diagonalUp?: boolean;
+    left?: XlsxCellBorderLine | null;
+    right?: XlsxCellBorderLine | null;
+    top?: XlsxCellBorderLine | null;
+}
+export interface XlsxPositionedCellBorder {
+    border?: XlsxCellBorder;
+    column: number;
+    row: number;
+}
+export declare function collectXlsxCellBorders(sheet: Sheet): ReadonlyMap<string, XlsxCellBorder>;
+export declare function fortuneBorderInfoFromXlsxCells(entries: readonly XlsxPositionedCellBorder[]): unknown[];
+export declare function xlsxCellBorderKey(row: number, column: number): string;
+export declare function xlsxCellBorderLineFromFortune(value: unknown): XlsxCellBorderLine | null | undefined;
+export declare function fortuneBorderStyle(style: XlsxCellBorderStyle): string;

package/dist/internal/features/work/work-xlsx-cell-style-writer.d.ts

@@ -0,0 +1,21 @@
+import type { Cell } from '@fortune-sheet/core';
+import type { XlsxCellBorder } from './work-xlsx-cell-borders';
+export declare class XlsxDirectCellStyleWriter {
+    private readonly styles;
+    private readonly fonts;
+    private readonly fills;
+    private readonly borders;
+    private readonly cellXfs;
+    private readonly generatedFonts;
+    private readonly generatedFills;
+    private readonly generatedBorders;
+    private readonly generatedStyles;
+    changed: boolean;
+    constructor(styles: Document);
+    styleId(baseStyleId: number, cell: Cell, border?: XlsxCellBorder): number;
+    private fontId;
+    private fillId;
+    private borderId;
+    private updateCounts;
+}
+export declare function hasXlsxDirectCellStyle(cell: Cell): boolean;

package/dist/internal/features/work/work-xlsx-cell-style-xml.d.ts

@@ -0,0 +1,17 @@
+import type { XlsxCellBorderLine } from './work-xlsx-cell-borders';
+export interface XlsxDirectAlignmentStyle {
+    horizontal?: 'center' | 'left' | 'right';
+    textRotation?: number;
+    vertical?: 'bottom' | 'center' | 'top';
+    wrapText?: boolean;
+}
+export declare function ensureXlsxStyleCollection(document: Document, name: string, anchors: readonly string[]): Element;
+export declare function defaultXlsxFill(document: Document, patternType: string): Element;
+export declare function defaultXlsxBorder(document: Document): Element;
+export declare function setXlsxBorderLine(document: Document, border: Element, name: 'bottom' | 'diagonal' | 'left' | 'right' | 'top', line: XlsxCellBorderLine | null): void;
+export declare function writeXlsxAlignment(document: Document, xf: Element, style: XlsxDirectAlignmentStyle): void;
+export declare function setXlsxValueChild(document: Document, parent: Element, name: string, value: string, order: readonly string[]): void;
+export declare function setXlsxColorChild(document: Document, parent: Element, color: string, order: readonly string[]): void;
+export declare function setXlsxToggleChild(document: Document, parent: Element, name: string, enabled: boolean, order: readonly string[]): void;
+export declare function setXlsxUnderlineChild(document: Document, parent: Element, enabled: boolean, order: readonly string[]): void;
+export declare function xlsxRgbColor(value: unknown): string | null;

package/dist/internal/features/work/work-xlsx-cell-styles.d.ts

@@ -0,0 +1,13 @@
+import type { Cell, Sheet } from '@fortune-sheet/core';
+import { type XlsxCellBorder } from './work-xlsx-cell-borders';
+import { type XlsxDirectCellStyleWriter } from './work-xlsx-cell-style-writer';
+export { XlsxDirectCellStyleWriter } from './work-xlsx-cell-style-writer';
+export interface XlsxDirectCellStyle {
+    border?: XlsxCellBorder;
+    column: number;
+    row: number;
+    style: Partial<Cell>;
+}
+export declare function readXlsxDirectCellStyles(worksheet: Document, styles: Document | null, theme?: Document | null): XlsxDirectCellStyle[];
+export declare function sheetHasDirectCellStyles(sheet: Sheet): boolean;
+export declare function writeXlsxDirectCellStyles(worksheet: Document, sheet: Sheet, styles: XlsxDirectCellStyleWriter): void;

package/dist/internal/features/work/work-xlsx-colors.d.ts

@@ -0,0 +1,6 @@
+export interface XlsxColorResolver {
+    indexed: readonly string[];
+    theme: readonly string[];
+}
+export declare function createXlsxColorResolver(styles: Document, theme: Document | null): XlsxColorResolver;
+export declare function resolveXlsxColor(element: Element | undefined, resolver: XlsxColorResolver): string | undefined;

package/dist/internal/features/work/work-xlsx-interop.d.ts

@@ -2,18 +2,20 @@ import type { Sheet } from '@fortune-sheet/core';
 import { OoxmlPackage } from './work-ooxml-package';
 import type { WorkSpreadsheetContent, WorkSpreadsheetDataValidationItem } from './work-types';
 import { type XlsxWorksheetChart } from './work-xlsx-charts';
+import { type XlsxDirectCellStyle } from './work-xlsx-cell-styles';
 import { type FortuneConditionalFormatRule } from './work-xlsx-conditional-format';
 import { type XlsxWorksheetImage } from './work-xlsx-images';
 import { type XlsxManualPageBreaks } from './work-xlsx-page-breaks';
 import { type XlsxPageSetup } from './work-xlsx-page-setup';
 import { type XlsxProtectionFeatures } from './work-xlsx-protection';
-import type { XlsxWorksheetXmlScan } from './work-xlsx-worksheet-scan';
+import { type XlsxWorksheetXmlScan } from './work-xlsx-worksheet-scan';
 type FrozenPane = NonNullable<Sheet['frozen']>;
 export interface XlsxDataValidation {
     references: string[];
     item: FortuneDataValidationItem;
 }
 export interface XlsxSheetFeatures {
+    directCellStyles: XlsxDirectCellStyle[];
     frozen?: FrozenPane;
     validations: XlsxDataValidation[];
     conditionalFormats: FortuneConditionalFormatRule[];

package/dist/internal/features/work/work-xlsx-worksheet-scan.d.ts

@@ -1,4 +1,5 @@
 export interface XlsxWorksheetXmlScan {
+    hasDirectCellStyles: boolean;
     hasDiagnosticFeatures: boolean;
     hasFormulaFeatures: boolean;
     hasImportedFeatures: boolean;