@a3s-lab/office 0.1.0

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

@@ -0,0 +1,38 @@
+import type { Editor } from '@tiptap/core';
+import { type PointerEvent, type RefObject } from 'react';
+import type { OfficeKernelPresentationSnapGuide } from '../../../kernel/office-kernel-protocol';
+import { type WorkspaceContextMenuEvent } from '../../workspace/components/workspace-context-menu';
+import type { WorkPresentationContent, WorkPresentationLayout, WorkPresentationMaster, WorkSlide, WorkSlideElement } from '../work-types';
+import type { PresentationEditorCommands } from './presentation-command-types';
+import type { PresentationDesignMode } from './presentation-editor-types';
+export type PresentationWorkspaceCommands = Pick<PresentationEditorCommands, 'addSlide' | 'deleteSlideById' | 'editElement' | 'exitEditing' | 'instantiatePlaceholder' | 'openComment' | 'selectElement' | 'selectSlide' | 'setViewMode' | 'updateElement' | 'updateNotes' | 'updateTextElement'>;
+export interface PresentationWorkspaceProps {
+    activeBackground: string;
+    activeCommentId: string | null;
+    activeElements: WorkSlideElement[];
+    aspectRatio: string;
+    canvasName: string;
+    canvasRef: RefObject<HTMLElement | null>;
+    commands: PresentationWorkspaceCommands;
+    content: WorkPresentationContent;
+    designContent: WorkPresentationContent;
+    designMode: PresentationDesignMode;
+    inheritedElements: WorkSlideElement[];
+    placeholderGuides: WorkSlideElement[];
+    editingElementId: string | null;
+    selectedElementIds: readonly string[];
+    selectedLayout: WorkPresentationLayout | undefined;
+    selectedMaster: WorkPresentationMaster | undefined;
+    selectedSlide: WorkSlide;
+    snapGuides: OfficeKernelPresentationSnapGuide[];
+    viewMode: 'normal' | 'sorter';
+    zoom: number;
+    onBeginDrag: (event: PointerEvent, element: WorkSlideElement, mode: 'move' | 'resize') => void;
+    onContinueDrag: (event: PointerEvent) => void;
+    onDragCancel: () => void;
+    onDragEnd: (event: PointerEvent) => void;
+    onOpenContextMenu: (event: WorkspaceContextMenuEvent, slide: WorkSlide, slideIndex: number, element?: WorkSlideElement | null) => void;
+    onTextEditorChange: (elementId: string, editor: Editor | null) => void;
+    onTextSelectionChange: () => void;
+}
+export declare function PresentationWorkspace({ activeBackground, activeCommentId, activeElements, aspectRatio, canvasName, canvasRef, commands, content, designContent, designMode, inheritedElements, placeholderGuides, editingElementId, selectedElementIds, selectedLayout, selectedMaster, selectedSlide, snapGuides, viewMode, zoom, onBeginDrag, onContinueDrag, onDragCancel, onDragEnd, onOpenContextMenu, onTextEditorChange, onTextSelectionChange, }: PresentationWorkspaceProps): import("react").JSX.Element;

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

@@ -0,0 +1,8 @@
+import { type Op, type Sheet } from '@fortune-sheet/core';
+import type { OfficeKernelSpreadsheetCalculatedCell, OfficeKernelSpreadsheetCoordinate, OfficeKernelSpreadsheetSessionUpdate } from '../../../kernel/office-kernel-protocol';
+import type { SpreadsheetCalculationCommand } from './spreadsheet-command-controller';
+import { type SpreadsheetKernelFallbackCell, type SpreadsheetKernelWorkbook } from './spreadsheet-calculation-projection';
+export declare function spreadsheetCalculationTargets(workbook: SpreadsheetKernelWorkbook, command: SpreadsheetCalculationCommand): OfficeKernelSpreadsheetCoordinate[] | undefined;
+export declare function spreadsheetCalculationSessionUpdate(previous: SpreadsheetKernelWorkbook | null, current: SpreadsheetKernelWorkbook, baseDocumentRevision: number, forceReplace?: boolean): OfficeKernelSpreadsheetSessionUpdate;
+export declare function spreadsheetCalculationFallbackCells(workbook: SpreadsheetKernelWorkbook, command: SpreadsheetCalculationCommand, includeDataTables?: boolean): SpreadsheetKernelFallbackCell[];
+export declare function spreadsheetCalculationOps(sheets: readonly Sheet[], calculatedCells: readonly OfficeKernelSpreadsheetCalculatedCell[]): Op[];

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

@@ -0,0 +1,32 @@
+import type { Op, Sheet } from '@fortune-sheet/core';
+import type { OfficeKernelSpreadsheetCoordinate, OfficeKernelSpreadsheetInputCell, OfficeKernelSpreadsheetInputSheet, OfficeKernelSpreadsheetSessionCellChange } from '../../../kernel/office-kernel-protocol';
+import type { WorkSpreadsheetContent, WorkSpreadsheetFormulaRangeType, WorkSpreadsheetSheet } from '../work-types';
+export declare const SPREADSHEET_KERNEL_MAX_PATCH_CELLS = 10000;
+export interface SpreadsheetKernelWorkbook {
+    fallbackCells: SpreadsheetKernelFallbackCell[];
+    sheets: OfficeKernelSpreadsheetInputSheet[];
+    sourceKey: string;
+    sourceState: SpreadsheetKernelSourceState;
+}
+export interface SpreadsheetKernelFallbackCell extends OfficeKernelSpreadsheetCoordinate {
+    type: WorkSpreadsheetFormulaRangeType;
+}
+export interface SpreadsheetKernelOperationProjection {
+    changes: OfficeKernelSpreadsheetSessionCellChange[];
+    sourceChanged: boolean;
+    workbook: SpreadsheetKernelWorkbook;
+}
+interface SpreadsheetKernelSourceState {
+    cellCount: number;
+    fingerprintA: bigint;
+    fingerprintB: bigint;
+    sourceCells: Map<string, OfficeKernelSpreadsheetInputCell>;
+    structureKey: string;
+}
+export declare function createSpreadsheetKernelWorkbook(content: Pick<WorkSpreadsheetContent, 'sheets'>): SpreadsheetKernelWorkbook | null;
+export declare function refreshSpreadsheetKernelWorkbook(sheets: readonly Sheet[], fallbackCells: readonly SpreadsheetKernelFallbackCell[]): SpreadsheetKernelWorkbook | null;
+export declare function projectSpreadsheetKernelWorkbookOperations(previous: SpreadsheetKernelWorkbook, sheets: readonly WorkSpreadsheetSheet[], operations: readonly Op[]): SpreadsheetKernelOperationProjection | null;
+export declare function spreadsheetOperationsMayChangeCalculation(operations: readonly Op[], workbook?: SpreadsheetKernelWorkbook | null): boolean;
+export declare function spreadsheetKernelCellKey(cell: Pick<OfficeKernelSpreadsheetInputCell, 'row' | 'column'>): string;
+export declare function sameSpreadsheetKernelInputCell(previous: OfficeKernelSpreadsheetInputCell, current: OfficeKernelSpreadsheetInputCell): boolean;
+export {};

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

@@ -0,0 +1,9 @@
+import type { WorkSpreadsheetChartAxes, WorkSpreadsheetChartType } from '../work-types';
+interface SpreadsheetChartAxisEditorProps {
+    axes: WorkSpreadsheetChartAxes | undefined;
+    chartType: WorkSpreadsheetChartType;
+    showSecondaryAxes: boolean;
+    onChange: (axes: WorkSpreadsheetChartAxes) => void;
+}
+export declare function SpreadsheetChartAxisEditor({ axes, chartType, showSecondaryAxes, onChange, }: SpreadsheetChartAxisEditorProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,17 @@
+import { type WorkSpreadsheetChart, type WorkSpreadsheetChartSeries, type WorkSpreadsheetChartType, type WorkSpreadsheetContent } from '../work-types';
+export interface ChartListItem {
+    sheetId: string;
+    sheetName: string;
+    chart: WorkSpreadsheetChart;
+}
+export interface ChartDraft extends Omit<WorkSpreadsheetChart, 'series'> {
+    sheetId: string;
+    series: WorkSpreadsheetChartSeries[];
+}
+export declare function chartDraft(item: ChartListItem): ChartDraft;
+export declare function chartDraftWithType(draft: ChartDraft, type: WorkSpreadsheetChartType): ChartDraft;
+export declare function newChartSeries(type: WorkSpreadsheetChartType, index: number): WorkSpreadsheetChartSeries;
+export declare function chartKey(item: ChartListItem | undefined): string | null;
+export declare function replaceSeries(series: WorkSpreadsheetChartSeries[], index: number, change: Partial<WorkSpreadsheetChartSeries>): WorkSpreadsheetChartSeries[];
+export declare function validateSeriesErrorBars(content: WorkSpreadsheetContent, ownerSheet: WorkSpreadsheetContent['sheets'][number], series: WorkSpreadsheetChartSeries, seriesIndex: number, chartType: WorkSpreadsheetChartType): string | null;
+export declare function validateChartAxes(content: WorkSpreadsheetContent, ownerSheet: WorkSpreadsheetContent['sheets'][number], axes: WorkSpreadsheetChart['axes'], hasSecondaryAxes: boolean): string | null;

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

@@ -0,0 +1,13 @@
+import { type WorkSpreadsheetChartLayout } from '../work-spreadsheet-chart-layout';
+import type { WorkSpreadsheetChartType } from '../work-types';
+interface SpreadsheetChartLayoutEditorProps {
+    chart: WorkSpreadsheetChartLayout & {
+        type: WorkSpreadsheetChartType;
+        showLegend: boolean;
+    };
+    onChange: (change: Partial<WorkSpreadsheetChartLayout & {
+        showLegend: boolean;
+    }>) => void;
+}
+export declare function SpreadsheetChartLayoutEditor({ chart, onChange, }: SpreadsheetChartLayoutEditorProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import type { Selection } from '@fortune-sheet/core';
+import { type WorkSpreadsheetContent } from '../work-types';
+interface SpreadsheetChartPanelProps {
+    content: WorkSpreadsheetContent;
+    activeSheetId: string;
+    selection?: Selection;
+    onChange: (content: WorkSpreadsheetContent) => void;
+}
+export declare function SpreadsheetChartPanel({ content, activeSheetId, selection, onChange, }: SpreadsheetChartPanelProps): import("react").JSX.Element;
+export {};

package/dist/internal/features/work/editors/spreadsheet-chart-series-style-editor.d.ts

@@ -0,0 +1,9 @@
+import type { WorkSpreadsheetChartSeriesStyle } from '../work-types';
+interface SpreadsheetChartSeriesStyleEditorProps {
+    seriesNumber: number;
+    supportsMarkers: boolean;
+    value?: WorkSpreadsheetChartSeriesStyle;
+    onChange: (style: WorkSpreadsheetChartSeriesStyle | undefined) => void;
+}
+export declare function SpreadsheetChartSeriesStyleEditor({ seriesNumber, supportsMarkers, value, onChange, }: SpreadsheetChartSeriesStyleEditorProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import { type SpreadsheetClipboardPort } from './spreadsheet-context-menu';
+export interface SpreadsheetClipboardShortcutOptions {
+    clipboard: SpreadsheetClipboardPort;
+    clearSelectedCells(): boolean;
+    pasteCells(values: readonly (readonly unknown[])[]): boolean;
+    readSelectionText(): string | null;
+    restoreFocus(): void;
+}
+export declare function runSpreadsheetClipboardShortcut(event: KeyboardEvent, options: SpreadsheetClipboardShortcutOptions): boolean;

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

@@ -0,0 +1,121 @@
+import type { Cell, Selection } from '@fortune-sheet/core';
+import type { WorkSpreadsheetContent } from '../work-types';
+import { type OfficeEditorCanCommands, type OfficeEditorExtension } from './office-editor-extension';
+import { type SpreadsheetKeyboardSelection, type SpreadsheetSelectionMove, type SpreadsheetSelectionScope } from './spreadsheet-keyboard-navigation';
+import { type SpreadsheetSheetMoveDirection } from './spreadsheet-sheet-model';
+export interface SpreadsheetWorkbookCommandPort {
+    batchCallApis: (apiCalls: Array<{
+        name: string;
+        args: unknown[];
+    }>) => void;
+    cancelMerge: (ranges: SpreadsheetCommandRange[], options?: {
+        id?: string;
+    }) => void;
+    getSelection: () => SpreadsheetCommandRange[] | undefined;
+    getCellsByRange: (range: SpreadsheetCommandRange, options?: {
+        id?: string;
+    }) => (Cell | null)[][];
+    insertRowOrColumn: (type: SpreadsheetStructureAxis, index: number, count: number, direction: 'lefttop' | 'rightbottom', options?: {
+        id?: string;
+    }) => void;
+    deleteRowOrColumn: (type: SpreadsheetStructureAxis, start: number, end: number, options?: {
+        id?: string;
+    }) => void;
+    hideRowOrColumn: (rowOrColumnInfo: string[], type: SpreadsheetStructureAxis) => void;
+    showRowOrColumn: (rowOrColumnInfo: string[], type: SpreadsheetStructureAxis) => void;
+    mergeCells: (ranges: SpreadsheetCommandRange[], type: string, options?: {
+        id?: string;
+    }) => void;
+    setCellValuesByRange: (values: unknown[][], range: SpreadsheetCommandRange, options?: {
+        id?: string;
+    }) => void;
+    setCellFormatByRange: (attribute: keyof Cell, value: unknown, range: SpreadsheetCommandRange, options?: {
+        id?: string;
+    }) => void;
+    setRowHeight: (rowInfo: Record<string, number>, options?: {
+        id?: string;
+    }, custom?: boolean) => void;
+    setColumnWidth: (columnInfo: Record<string, number>, options?: {
+        id?: string;
+    }, custom?: boolean) => void;
+    setSelection: (range: SpreadsheetCommandRange[], options?: {
+        id?: string;
+    }) => void;
+}
+export interface SpreadsheetCommandRange extends SpreadsheetKeyboardSelection {
+    row: number[];
+    column: number[];
+}
+export interface SpreadsheetCommandSelection {
+    sheetId: string;
+    selection: Selection;
+}
+export type SpreadsheetStructureAxis = 'row' | 'column';
+export type SpreadsheetStructureInsertPosition = 'before' | 'after';
+export type SpreadsheetSortDirection = 'ascending' | 'descending';
+export type SpreadsheetCalculationCommand = {
+    scope: 'workbook';
+} | {
+    scope: 'selection';
+    sheetId: string;
+    range: SpreadsheetCommandRange;
+};
+export interface SpreadsheetCalculationCommandPort {
+    recalculate: (request: SpreadsheetCalculationCommand) => void;
+}
+export interface SpreadsheetHistoryCommandPort {
+    canRedo: boolean;
+    canUndo: boolean;
+    redo: () => boolean;
+    undo: () => boolean;
+}
+export interface SpreadsheetFormulaBarCommandPort {
+    setValue: (value: unknown) => void;
+}
+export interface SpreadsheetViewCommandPort {
+    activateSheet: (sheetId: string) => boolean;
+}
+export interface SpreadsheetEditorCommands {
+    activateSheet: (sheetId: string) => boolean;
+    addSheet: () => boolean;
+    clearSelectedCells: () => boolean;
+    deleteSelectedStructure: (axis: SpreadsheetStructureAxis) => boolean;
+    deleteSheet: (sheetId: string) => boolean;
+    duplicateSheet: (sheetId: string) => boolean;
+    hideSheet: (sheetId: string) => boolean;
+    insertSelectedStructure: (axis: SpreadsheetStructureAxis, position: SpreadsheetStructureInsertPosition) => boolean;
+    moveSheet: (sheetId: string, direction: SpreadsheetSheetMoveDirection) => boolean;
+    moveSelection: (move: SpreadsheetSelectionMove, extend: boolean) => boolean;
+    pasteCells: (values: readonly (readonly unknown[])[]) => boolean;
+    recalculateFormula: (scope: 'selection' | 'workbook') => boolean;
+    renameSheet: (sheetId: string, name: string) => boolean;
+    redo: () => boolean;
+    setCellFormat: (attribute: keyof Cell, value: unknown) => boolean;
+    setGridLines: (visible: boolean) => boolean;
+    selectCellRange: (scope: SpreadsheetSelectionScope) => boolean;
+    setSheetColor: (sheetId: string, color: string | null) => boolean;
+    setSelectedStructureHidden: (axis: SpreadsheetStructureAxis, hidden: boolean) => boolean;
+    setSelectedStructureSize: (axis: SpreadsheetStructureAxis, size: number) => boolean;
+    setSpreadsheetContent: (content: WorkSpreadsheetContent) => boolean;
+    setZoom: (percent: number) => boolean;
+    sortSelectedCells: (direction: SpreadsheetSortDirection) => boolean;
+    toggleCellMerge: (merged: boolean) => boolean;
+    undo: () => boolean;
+}
+export type SpreadsheetEditorCanCommands = OfficeEditorCanCommands<SpreadsheetEditorCommands>;
+export interface SpreadsheetCommandContext {
+    activeSheetId: string;
+    calculation: SpreadsheetCalculationCommandPort | null;
+    content: WorkSpreadsheetContent;
+    editable: boolean;
+    fallbackRange: SpreadsheetCommandRange;
+    formulaBar: SpreadsheetFormulaBarCommandPort | null;
+    history: SpreadsheetHistoryCommandPort | null;
+    onChange: (content: WorkSpreadsheetContent) => void;
+    selection: SpreadsheetCommandSelection | null;
+    targetSheetId: string;
+    toolbarCell: Cell | null;
+    view: SpreadsheetViewCommandPort | null;
+    workbook: SpreadsheetWorkbookCommandPort | null;
+}
+export declare function createSpreadsheetEditorExtensions(): readonly OfficeEditorExtension<SpreadsheetCommandContext, SpreadsheetEditorCommands>[];

package/dist/internal/features/work/editors/spreadsheet-conditional-comparison-fields.d.ts

@@ -0,0 +1,7 @@
+import { type ConditionalRuleDraft } from './spreadsheet-conditional-format-model';
+interface SpreadsheetConditionalComparisonFieldsProps {
+    draft: ConditionalRuleDraft;
+    onChange: (patch: Partial<ConditionalRuleDraft>) => void;
+}
+export declare function SpreadsheetConditionalComparisonFields({ draft, onChange, }: SpreadsheetConditionalComparisonFieldsProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,72 @@
+import type { Sheet } from '@fortune-sheet/core';
+import { type SpreadsheetConditionalComparisonOperator } from '../work-spreadsheet-conditional-comparisons';
+import { type SpreadsheetConditionalIconSetName, type SpreadsheetConditionalIconThreshold } from '../work-spreadsheet-conditional-icons';
+import { type SpreadsheetConditionalThreshold } from '../work-spreadsheet-conditional-values';
+import type { FortuneConditionalFormatRule } from '../work-xlsx-conditional-format';
+import type { WorkSpreadsheetContent } from '../work-types';
+export interface SpreadsheetConditionalThresholdDraft {
+    type: SpreadsheetConditionalThreshold['type'];
+    value: string;
+    gte: boolean;
+}
+export declare const SPREADSHEET_CONDITIONAL_COMPARISONS: {
+    name: "between" | "greaterThan" | "greaterThanOrEqual" | "lessThan" | "lessThanOrEqual" | "equal" | "notEqual" | "notBetween";
+    label: string;
+}[];
+export interface ConditionalRuleDraft {
+    sheetId: string;
+    type: 'cellComparison' | 'colorGradation' | 'dataBar' | 'icons' | 'toolbarRule';
+    reference: string;
+    stopIfTrue: boolean;
+    preservedRule: FortuneConditionalFormatRule | null;
+    comparisonOperator: SpreadsheetConditionalComparisonOperator;
+    comparisonValue: string;
+    comparisonUpperValue: string;
+    comparisonTextColor: string;
+    comparisonCellColor: string;
+    comparisonUseTextColor: boolean;
+    comparisonUseCellColor: boolean;
+    scaleSize: '2' | '3';
+    minimumColor: string;
+    midpointColor: string;
+    maximumColor: string;
+    scaleThresholds: SpreadsheetConditionalThresholdDraft[];
+    barColor: string;
+    barThresholds: SpreadsheetConditionalThresholdDraft[];
+    barShowValue: boolean;
+    barMinLength: string;
+    barMaxLength: string;
+    iconSet: SpreadsheetConditionalIconSetName;
+    iconShowValue: boolean;
+    iconReverse: boolean;
+    iconThresholds: SpreadsheetConditionalThresholdDraft[];
+}
+export interface ConditionalRuleEntry {
+    sheet: Sheet & {
+        id: string;
+    };
+    rule: FortuneConditionalFormatRule;
+    index: number;
+}
+export declare function managedConditionalFormatCount(content: WorkSpreadsheetContent): number;
+export declare function managedConditionalRuleEntries(sheets: Array<Sheet & {
+    id: string;
+}>): ConditionalRuleEntry[];
+export declare function sheetConditionalRules(sheet: Sheet): unknown[];
+export declare function withConditionalRules(sheet: Sheet, rules: unknown[]): Sheet;
+export declare function isManagedConditionalRule(value: unknown): value is FortuneConditionalFormatRule;
+export declare function newConditionalRuleDraft(sheetId: string): ConditionalRuleDraft;
+export declare function conditionalRuleDraftForRule(sheetId: string, rule: FortuneConditionalFormatRule): ConditionalRuleDraft;
+export type ConditionalRuleBuildResult = {
+    rule: FortuneConditionalFormatRule;
+} | {
+    error: string;
+};
+export declare function buildConditionalRule(draft: ConditionalRuleDraft): ConditionalRuleBuildResult;
+export declare function conditionalRuleLabel(rule: FortuneConditionalFormatRule): string;
+export declare function conditionalToolbarRuleSummary(rule: FortuneConditionalFormatRule | null): string;
+export declare function conditionalThresholdDrafts(thresholds: Array<SpreadsheetConditionalThreshold & {
+    gte?: boolean;
+}>): SpreadsheetConditionalThresholdDraft[];
+export declare function savedIconThresholds(thresholds: SpreadsheetConditionalThresholdDraft[]): SpreadsheetConditionalIconThreshold[] | null;
+export declare function savedVisualThresholds(thresholds: SpreadsheetConditionalThresholdDraft[]): SpreadsheetConditionalThreshold[] | null;

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

@@ -0,0 +1,7 @@
+import type { WorkSpreadsheetContent } from '../work-types';
+export { managedConditionalFormatCount } from './spreadsheet-conditional-format-model';
+interface SpreadsheetConditionalFormatPanelProps {
+    content: WorkSpreadsheetContent;
+    onChange: (content: WorkSpreadsheetContent) => void;
+}
+export declare function SpreadsheetConditionalFormatPanel({ content, onChange, }: SpreadsheetConditionalFormatPanelProps): import("react").JSX.Element;

package/dist/internal/features/work/editors/spreadsheet-conditional-threshold-fields.d.ts

@@ -0,0 +1,10 @@
+import type { SpreadsheetConditionalThresholdDraft } from './spreadsheet-conditional-format-model';
+interface SpreadsheetConditionalThresholdFieldsProps {
+    label: string;
+    thresholds: SpreadsheetConditionalThresholdDraft[];
+    startIndex?: number;
+    showEquality?: boolean;
+    onChange: (index: number, patch: Partial<SpreadsheetConditionalThresholdDraft>) => void;
+}
+export declare function SpreadsheetConditionalThresholdFields({ label, thresholds, startIndex, showEquality, onChange, }: SpreadsheetConditionalThresholdFieldsProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,36 @@
+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 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, }: {
+    can: SpreadsheetContextCan;
+    clipboard?: SpreadsheetClipboardPort;
+    commands: SpreadsheetContextCommands;
+    selection: Pick<WorkSpreadsheetAgentSelection, 'clipboard' | 'reference'>;
+}): WorkspaceContextMenuItem[];
+export declare function spreadsheetStructureContextMenuItems({ axis, can, commands, onResize, }: {
+    axis: SpreadsheetStructureAxis;
+    can: SpreadsheetStructureCan;
+    commands: SpreadsheetStructureCommands;
+    onResize(axis: SpreadsheetStructureAxis): void;
+}): WorkspaceContextMenuItem[];
+export declare function spreadsheetSortContextMenuItems({ can, commands, idSuffix, separatorBefore, }: {
+    can: SpreadsheetSortCan;
+    commands: SpreadsheetSortCommands;
+    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 {};

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

@@ -0,0 +1,9 @@
+import { type WorkSpreadsheetChartType, type WorkSpreadsheetDataLabels } from '../work-types';
+interface SpreadsheetDataLabelEditorProps {
+    chartType: WorkSpreadsheetChartType;
+    seriesNumber: number;
+    value?: WorkSpreadsheetDataLabels;
+    onChange: (value: WorkSpreadsheetDataLabels | undefined) => void;
+}
+export declare function SpreadsheetDataLabelEditor({ chartType, seriesNumber, value, onChange, }: SpreadsheetDataLabelEditorProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,46 @@
+import type { Cell } from '@fortune-sheet/core';
+import type { WorkSpreadsheetContent } from '../work-types';
+import type { SpreadsheetEditorCanCommands, SpreadsheetEditorCommands } from './spreadsheet-command-controller';
+import type { SpreadsheetWorkbookPanelView } from './spreadsheet-workbook-panel';
+import { type WorkOfficeFileAction } from './work-office-chrome';
+declare const spreadsheetRibbonTabs: readonly [{
+    readonly id: "home";
+    readonly label: "开始";
+}, {
+    readonly id: "insert";
+    readonly label: "插入";
+}, {
+    readonly id: "pageLayout";
+    readonly label: "页面布局";
+    readonly compactLabel: "布局";
+}, {
+    readonly id: "formulas";
+    readonly label: "公式";
+}, {
+    readonly id: "data";
+    readonly label: "数据";
+}, {
+    readonly id: "review";
+    readonly label: "审阅";
+}, {
+    readonly id: "view";
+    readonly label: "视图";
+}];
+export type SpreadsheetRibbonTabId = (typeof spreadsheetRibbonTabs)[number]['id'];
+export declare function SpreadsheetEditorRibbon({ activeTab, can, commands, content, fileActions, findOpen, gridLinesVisible, multipleCellsSelected, panelId, onOpenFind, onTabChange, onTogglePanel, panel, toolbarCell, }: {
+    activeTab: SpreadsheetRibbonTabId;
+    can: SpreadsheetEditorCanCommands;
+    commands: SpreadsheetEditorCommands;
+    content: WorkSpreadsheetContent;
+    fileActions?: readonly WorkOfficeFileAction[];
+    findOpen: boolean;
+    gridLinesVisible: boolean;
+    multipleCellsSelected: boolean;
+    panelId: string;
+    onOpenFind: () => void;
+    onTabChange: (tab: SpreadsheetRibbonTabId) => void;
+    onTogglePanel: (panel: SpreadsheetWorkbookPanelView, trigger: HTMLButtonElement) => void;
+    panel: SpreadsheetWorkbookPanelView | null;
+    toolbarCell: Cell | null | undefined;
+}): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,31 @@
+import type { Cell, Selection } from '@fortune-sheet/core';
+import type { WorkSpreadsheetContent } from '../work-types';
+import type { OfficeSelectOption } from './office-select';
+export interface SpreadsheetSelectionSummary {
+    average: number | null;
+    nonEmptyCount: number;
+    numericCount: number;
+    sum: number | null;
+}
+export declare function spreadsheetSelectionReference(selection: Pick<Selection, 'row' | 'column'>): string;
+export declare function spreadsheetSingleRange(selection: Pick<Selection, 'row' | 'column'>): {
+    row: number[];
+    column: number[];
+};
+export declare function spreadsheetCellAt(sheet: WorkSpreadsheetContent['sheets'][number] | undefined, row: number | undefined, column: number | undefined): Cell | null;
+export declare function spreadsheetSelectionSummary(sheet: WorkSpreadsheetContent['sheets'][number] | undefined, selection: Pick<Selection, 'row' | 'column'>): SpreadsheetSelectionSummary;
+export declare function spreadsheetFontSizeOptions(current: number | undefined): {
+    value: string;
+    label: string;
+}[];
+export declare function spreadsheetFontFamilyOptions(current: string | undefined): OfficeSelectOption[];
+export declare function spreadsheetSheetsWithFiniteSelections(sheets: WorkSpreadsheetContent['sheets']): WorkSpreadsheetContent['sheets'];
+export declare function spreadsheetSheetsForFortune(sheets: WorkSpreadsheetContent['sheets']): WorkSpreadsheetContent['sheets'];
+export declare function finiteSpreadsheetSelection(selection: Selection | undefined): Selection;
+export declare function sameSpreadsheetWorkbookState(changed: WorkSpreadsheetContent['sheets'], rendered: WorkSpreadsheetContent['sheets']): boolean;
+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 isSpreadsheetNativeTextUndoTarget(target: EventTarget | null): boolean;
+export declare function isSpreadsheetCellEditingTarget(target: EventTarget | null): boolean;
+export declare function spreadsheetFormulaBarSelectAllTarget(event: KeyboardEvent): HTMLElement | null;
+export declare function selectSpreadsheetFormulaBarContents(event: KeyboardEvent): boolean;

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

@@ -0,0 +1,16 @@
+import type { WorkEditorAgentRequest } from '../work-agent-request';
+import type { WorkSpreadsheetContent } from '../work-types';
+import { type SpreadsheetEditorCommands } from './spreadsheet-command-controller';
+import { type WorkOfficeFileAction } from './work-office-chrome';
+export interface SpreadsheetEditorProps {
+    content: WorkSpreadsheetContent;
+    kernelWasmUrl?: string;
+    preview: boolean;
+    saveStatus?: string;
+    fileActions?: readonly WorkOfficeFileAction[];
+    onChange: (content: WorkSpreadsheetContent) => void;
+    onAgentRequest?: (request: WorkEditorAgentRequest) => void | Promise<void>;
+}
+export declare function SpreadsheetEditor({ content, kernelWasmUrl, preview, saveStatus, fileActions, onChange, onAgentRequest, }: SpreadsheetEditorProps): import("react").JSX.Element;
+export declare function focusSpreadsheetGrid(container: HTMLElement | null): void;
+export declare function spreadsheetCommandsWithGridFocus(commands: SpreadsheetEditorCommands, restoreFocus: () => void): SpreadsheetEditorCommands;

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

@@ -0,0 +1,10 @@
+import { type WorkSpreadsheetChartType, type WorkSpreadsheetErrorBars } from '../work-types';
+interface SpreadsheetErrorBarEditorProps {
+    chartType: WorkSpreadsheetChartType;
+    seriesNumber: number;
+    errorBars: WorkSpreadsheetErrorBars[];
+    onChange: (errorBars: WorkSpreadsheetErrorBars[]) => void;
+    customInput?: 'references' | 'values';
+}
+export declare function SpreadsheetErrorBarEditor({ chartType, seriesNumber, errorBars, onChange, customInput, }: SpreadsheetErrorBarEditorProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,8 @@
+import type { WorkSpreadsheetContent } from '../work-types';
+import { type SpreadsheetFindMatch } from './spreadsheet-find';
+export declare function SpreadsheetFindBar({ sheet, focusRequest, onClose, onSelectMatch, }: {
+    sheet: WorkSpreadsheetContent['sheets'][number] | undefined;
+    focusRequest: number;
+    onClose: () => void;
+    onSelectMatch: (match: SpreadsheetFindMatch) => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,9 @@
+import type { WorkSpreadsheetContent } from '../work-types';
+export interface SpreadsheetFindMatch {
+    sheetId: string;
+    row: number;
+    column: number;
+    reference: string;
+    text: string;
+}
+export declare function spreadsheetFindMatches(sheet: WorkSpreadsheetContent['sheets'][number] | undefined, query: string): SpreadsheetFindMatch[];

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

@@ -0,0 +1,10 @@
+import type { WorkSpreadsheetContent } from '../work-types';
+interface SpreadsheetFormulaPanelProps {
+    content: WorkSpreadsheetContent;
+    canRecalculateSelection: boolean;
+    canRecalculateWorkbook: boolean;
+    onChange: (content: WorkSpreadsheetContent) => void;
+    onRecalculate: (scope: 'workbook' | 'selection') => boolean;
+}
+export declare function SpreadsheetFormulaPanel({ content, canRecalculateSelection, canRecalculateWorkbook, onChange, onRecalculate, }: SpreadsheetFormulaPanelProps): import("react").JSX.Element;
+export {};

package/dist/internal/features/work/editors/spreadsheet-header-footer-fields.d.ts

@@ -0,0 +1,5 @@
+import type { EffectiveSpreadsheetPageSetup } from '../work-spreadsheet-page-setup';
+export declare function SpreadsheetHeaderFooterFields({ pageSetup, onChange, }: {
+    pageSetup: EffectiveSpreadsheetPageSetup;
+    onChange: (pageSetup: EffectiveSpreadsheetPageSetup) => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,18 @@
+import type { WorkSpreadsheetSheet } from '../work-types';
+export type SpreadsheetSelectionMove = 'down' | 'left' | 'next-cell' | 'page-down' | 'page-up' | 'previous-cell' | 'right' | 'row-start' | 'sheet-start' | 'up' | 'used-end';
+export type SpreadsheetSelectionScope = 'all' | 'column' | 'row';
+export interface SpreadsheetKeyboardSelection {
+    row: number[];
+    column: number[];
+    row_focus?: number;
+    column_focus?: number;
+}
+export declare function moveSpreadsheetKeyboardSelection(sheet: WorkSpreadsheetSheet, selection: SpreadsheetKeyboardSelection, move: SpreadsheetSelectionMove, extend: boolean): SpreadsheetKeyboardSelection;
+export declare function scopeSpreadsheetKeyboardSelection(sheet: WorkSpreadsheetSheet, selection: SpreadsheetKeyboardSelection, scope: SpreadsheetSelectionScope): SpreadsheetKeyboardSelection;
+export declare function isSpreadsheetGridKeyboardTarget(target: EventTarget | null): boolean;
+export declare function runSpreadsheetSelectionMoveShortcut(event: KeyboardEvent, canExecute: (move: SpreadsheetSelectionMove, extend: boolean) => boolean, execute: (move: SpreadsheetSelectionMove, extend: boolean) => boolean, move: SpreadsheetSelectionMove, extend: boolean): boolean;
+export declare function runSpreadsheetSelectionScopeShortcut(event: KeyboardEvent, canExecute: (scope: SpreadsheetSelectionScope) => boolean, execute: (scope: SpreadsheetSelectionScope) => boolean, scope: SpreadsheetSelectionScope): boolean;
+export declare function spreadsheetSelectionContainsFocus(selection: SpreadsheetKeyboardSelection, focus: {
+    column: number;
+    row: number;
+}): boolean;

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

@@ -0,0 +1,11 @@
+import type { Cell } from '@fortune-sheet/core';
+export type SpreadsheetNumberFormatPreset = 'general' | 'number' | 'percent' | 'custom';
+type SpreadsheetNumberFormatChoice = Exclude<SpreadsheetNumberFormatPreset, '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']> & {
+    fa: string;
+    t: string;
+};
+export declare function adjustSpreadsheetNumberFormat(formatCode: string | undefined, direction: -1 | 1): string;
+export {};

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

@@ -0,0 +1,10 @@
+import type { Selection } from '@fortune-sheet/core';
+import type { WorkSpreadsheetContent } from '../work-types';
+interface SpreadsheetPivotPanelProps {
+    content: WorkSpreadsheetContent;
+    activeSheetId: string;
+    selection?: Selection;
+    onChange: (content: WorkSpreadsheetContent) => void;
+}
+export declare function SpreadsheetPivotPanel({ content, activeSheetId, selection, onChange, }: SpreadsheetPivotPanelProps): import("react").JSX.Element;
+export {};

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

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