@a3s-lab/office 0.11.0 → 0.13.0

package/dist/9356.js

@@ -1,10 +1,130 @@
-async function materializeWorkFile(file) {
-    const bytes = await file.arrayBuffer();
-    return new File([
-        bytes
-    ], file.name, {
-        lastModified: file.lastModified,
-        type: file.type
+const stageRanges = {
+    reading: [
+        0,
+        0.2
+    ],
+    parsing: [
+        0.2,
+        0.75
+    ],
+    analyzing: [
+        0.75,
+        0.95
+    ],
+    finalizing: [
+        0.95,
+        1
+    ]
+};
+class WorkFileImportController {
+    options;
+    totalBytes;
+    progress = 0;
+    constructor(options, totalBytes){
+        this.options = options;
+        this.totalBytes = totalBytes;
+    }
+    get signal() {
+        return this.options.signal;
+    }
+    throwIfAborted() {
+        if (!this.signal?.aborted) return;
+        throw workFileImportAbortError(this.signal.reason);
+    }
+    report(stage, stageProgress, bytesRead = this.totalBytes) {
+        this.throwIfAborted();
+        const boundedStageProgress = Math.max(0, Math.min(1, stageProgress));
+        const [start, end] = stageRanges[stage];
+        this.progress = Math.max(this.progress, start + (end - start) * boundedStageProgress);
+        this.options.onProgress?.({
+            stage,
+            stageProgress: boundedStageProgress,
+            progress: this.progress,
+            bytesRead: Math.max(0, Math.min(this.totalBytes, bytesRead)),
+            totalBytes: this.totalBytes
+        });
+        this.throwIfAborted();
+    }
+    async checkpoint(stage, stageProgress) {
+        this.report(stage, stageProgress);
+        await this.yieldToMainThread();
+    }
+    async yieldToMainThread() {
+        this.throwIfAborted();
+        const taskScheduler = globalThis.scheduler;
+        if ('function' == typeof taskScheduler?.yield) await taskScheduler.yield();
+        else await new Promise((resolve)=>setTimeout(resolve, 0));
+        this.throwIfAborted();
+    }
+    complete() {
+        this.report('finalizing', 1);
+    }
+}
+function workFileImportAbortError(reason) {
+    if (reason instanceof Error && 'AbortError' === reason.name) return reason;
+    if ("u" > typeof DOMException) return new DOMException('Office file import was cancelled.', 'AbortError');
+    const error = new Error('Office file import was cancelled.');
+    error.name = 'AbortError';
+    return error;
+}
+const WORK_FILE_READ_CHUNK_BYTES = 4194304;
+async function materializeWorkFile(file, controller = new WorkFileImportController({}, file.size)) {
+    return (await materializeWorkFileSource(file, controller)).file;
+}
+async function materializeWorkFileSource(file, controller) {
+    const bytes = await readWorkFileBytes(file, controller);
+    return {
+        bytes,
+        file: new File([
+            bytes
+        ], file.name, {
+            lastModified: file.lastModified,
+            type: file.type
+        })
+    };
+}
+async function readWorkFileBytes(file, controller) {
+    controller.report('reading', 0, 0);
+    if (file.size <= WORK_FILE_READ_CHUNK_BYTES) {
+        const bytes = await abortableArrayBuffer(file.arrayBuffer(), controller);
+        controller.report('reading', 1, bytes.byteLength);
+        return bytes;
+    }
+    const bytes = new Uint8Array(file.size);
+    for(let offset = 0; offset < file.size; offset += WORK_FILE_READ_CHUNK_BYTES){
+        controller.throwIfAborted();
+        const end = Math.min(file.size, offset + WORK_FILE_READ_CHUNK_BYTES);
+        const chunk = await abortableArrayBuffer(file.slice(offset, end).arrayBuffer(), controller);
+        bytes.set(new Uint8Array(chunk), offset);
+        controller.report('reading', end / file.size, end);
+        if (end < file.size) await controller.yieldToMainThread();
+    }
+    return bytes.buffer;
+}
+async function abortableArrayBuffer(pending, controller) {
+    controller.throwIfAborted();
+    const signal = controller.signal;
+    if (!signal) return pending;
+    return new Promise((resolve, reject)=>{
+        const abort = ()=>{
+            cleanup();
+            try {
+                controller.throwIfAborted();
+            } catch (error) {
+                reject(error);
+            }
+        };
+        const cleanup = ()=>signal.removeEventListener('abort', abort);
+        signal.addEventListener('abort', abort, {
+            once: true
+        });
+        pending.then((bytes)=>{
+            cleanup();
+            resolve(bytes);
+        }, (error)=>{
+            cleanup();
+            reject(error);
+        });
     });
 }
-export { materializeWorkFile };
+export { WorkFileImportController, materializeWorkFile, materializeWorkFileSource };

package/dist/core.d.ts

@@ -21,6 +21,7 @@ export type { WorkEditorAgentRequest as EditorAgentRequest } from './internal/fe
 export type { WorkDocumentReviewConflict as DocumentReviewConflict, WorkDocumentReviewConflictEvent as DocumentReviewConflictEvent, WorkDocumentReviewConflictReason as DocumentReviewConflictReason, WorkDocumentReviewKind as DocumentReviewKind, } from './internal/features/work/work-document-review-conflicts';
 export type { WorkDocumentSelectionCommandFailure as DocumentSelectionCommandFailure, WorkDocumentSelectionCommandResult as DocumentSelectionCommandResult, WorkDocumentSelectionCommands as DocumentSelectionCommands, WorkDocumentSelectionContext as DocumentSelectionContext, WorkDocumentSelectionMenuIcon as DocumentSelectionMenuIcon, WorkDocumentSelectionMenuItem as DocumentSelectionMenuItem, WorkDocumentSelectionSnapshot as DocumentSelectionSnapshot, WorkGetDocumentSelectionMenuItems as GetDocumentSelectionMenuItems, } from './internal/features/work/work-document-selection-menu';
 export type { WorkArtifactExportOptions as ArtifactExportOptions } from './internal/features/work/work-file-io';
+export type { WorkFileImportOptions as OfficeFileImportOptions, WorkFileImportProgress as OfficeFileImportProgress, WorkFileImportStage as OfficeFileImportStage, } from './internal/features/work/work-file-import';
 export { createWorkArtifactBlob as createArtifactBlob, exportWorkArtifact as downloadArtifact, importWorkFile as importOfficeFile, WORK_IMPORT_ACCEPT as OFFICE_FILE_ACCEPT, workKindForFile as officeKindForFile, } from './internal/features/work/work-file-io';
 export { decodeWorkDocumentSnapshot as decodeDocumentSnapshot, encodeWorkDocumentSnapshot as encodeDocumentSnapshot, WORK_DOCUMENT_SNAPSHOT_MEDIA_TYPE as DOCUMENT_SNAPSHOT_MEDIA_TYPE, WORK_DOCUMENT_SNAPSHOT_SCHEMA as DOCUMENT_SNAPSHOT_SCHEMA, WORK_DOCUMENT_SNAPSHOT_VERSION as DOCUMENT_SNAPSHOT_VERSION, type WorkDocumentSnapshot as DocumentSnapshot, } from './internal/features/work/work-document-snapshot';
 export { applyWorkDocumentSource as applyDocumentSource, projectWorkDocumentSource as projectDocumentSource, WORK_DOCUMENT_SOURCE_MEDIA_TYPE as DOCUMENT_SOURCE_MEDIA_TYPE, WORK_DOCUMENT_SOURCE_SCHEMA as DOCUMENT_SOURCE_SCHEMA, WORK_DOCUMENT_SOURCE_VERSION as DOCUMENT_SOURCE_VERSION, type WorkDocumentSource as DocumentSource, } from './internal/features/work/work-document-source';

package/dist/core.js

@@ -4,7 +4,7 @@ export { DOCUMENT_SNAPSHOT_MEDIA_TYPE, DOCUMENT_SNAPSHOT_SCHEMA, DOCUMENT_SNAPSH
 export { OFFICE_COLLABORATION_NAMESPACE, OFFICE_COLLABORATION_PROTOCOL, OfficeCollaborationError, createOfficeCollaborationSession, readOfficeCollaborationMetadata } from "./9787.js";
 export { assertPdfCollaborationSource, createOfficePdfCollaborationBinding, initializeOfficePdfCollaboration, readOfficePdfCollaboration, readOfficePdfCollaborationSource, replaceOfficePdfCollaboration } from "./3818.js";
 export { createArtifact, createOfficeId, officeTemplates } from "./5184.js";
-export { createOfficeDocumentCollaborationBinding, initializeOfficeDocumentCollaboration, officeDocumentCollaborationFragment, readOfficeDocumentCollaboration } from "./8928.js";
+export { createOfficeDocumentCollaborationBinding, initializeOfficeDocumentCollaboration, officeDocumentCollaborationFragment, readOfficeDocumentCollaboration } from "./6282.js";
 export { createOfficeMarkdownCollaborationBinding, initializeOfficeMarkdownCollaboration, readOfficeMarkdownCollaboration, replaceOfficeMarkdownCollaboration } from "./2591.js";
 export { createOfficePresentationCollaborationBinding, initializeOfficePresentationCollaboration, readOfficePresentationCollaboration, replaceOfficePresentationCollaboration } from "./4560.js";
 export { createOfficeSpreadsheetCollaborationBinding, initializeOfficeSpreadsheetCollaboration, readOfficeSpreadsheetCollaboration, replaceOfficeSpreadsheetCollaboration } from "./4476.js";

package/dist/index.js

@@ -7,7 +7,7 @@ export { DocumentEditor, MarkdownEditor, PDF_EVIDENCE_COORDINATE_BASIS, PdfViewe
 export { OFFICE_COLLABORATION_NAMESPACE, OFFICE_COLLABORATION_PROTOCOL, OfficeCollaborationError, createOfficeCollaborationSession, readOfficeCollaborationMetadata } from "./9787.js";
 export { assertPdfCollaborationSource, createOfficePdfCollaborationBinding, initializeOfficePdfCollaboration, readOfficePdfCollaboration, readOfficePdfCollaborationSource, replaceOfficePdfCollaboration } from "./3818.js";
 export { createArtifact, createOfficeId, officeTemplates } from "./5184.js";
-export { createOfficeDocumentCollaborationBinding, initializeOfficeDocumentCollaboration, officeDocumentCollaborationFragment, readOfficeDocumentCollaboration } from "./8928.js";
+export { createOfficeDocumentCollaborationBinding, initializeOfficeDocumentCollaboration, officeDocumentCollaborationFragment, readOfficeDocumentCollaboration } from "./6282.js";
 export { createOfficeMarkdownCollaborationBinding, initializeOfficeMarkdownCollaboration, readOfficeMarkdownCollaboration, replaceOfficeMarkdownCollaboration } from "./2591.js";
 export { createOfficePresentationCollaborationBinding, initializeOfficePresentationCollaboration, readOfficePresentationCollaboration, replaceOfficePresentationCollaboration } from "./4560.js";
 export { createOfficeSpreadsheetCollaborationBinding, initializeOfficeSpreadsheetCollaboration, readOfficeSpreadsheetCollaboration, replaceOfficeSpreadsheetCollaboration } from "./4476.js";

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

@@ -3,6 +3,7 @@ import type { WorkspaceContextMenuItem } from '../../workspace/components/worksp
 import { type WorkAgentProposalRequest, type WorkAgentProposalTarget } from '../work-agent-proposal';
 import type { WorkEditorAgentRequest } from '../work-agent-request';
 import type { WorkDocumentSelectionAction, WorkDocumentSelectionMenuIcon, WorkDocumentSelectionMenuItem } from '../work-document-selection-menu';
+export { type DocumentTextStatistics, documentTextStatistics, documentWordCount, } from '../work-document-text-statistics';
 export declare function documentEditorSelectionText(editor: Pick<Editor, 'state'>): string;
 export declare function documentAgentMenuItems(selection: string, onAgentRequest: (request: WorkEditorAgentRequest) => void | Promise<void>, proposalOptions?: {
     target: WorkAgentProposalTarget;
@@ -27,12 +28,3 @@ interface CustomSelectionMenuItem<Context> {
 export declare function customSelectionMenuItems<Context>(items: readonly CustomSelectionMenuItem<Context>[], createAction: () => CustomSelectionAction<Context>): WorkspaceContextMenuItem[];
 export declare function documentPageCount(editor: Editor): number;
 export declare function documentCurrentPage(editor: Editor): number;
-export declare function documentWordCount(value: string): number;
-export interface DocumentTextStatistics {
-    characterCountWithSpaces: number;
-    characterCountWithoutSpaces: number;
-    paragraphCount: number;
-    wordCount: number;
-}
-export declare function documentTextStatistics(editor: Pick<Editor, 'getText' | 'state'>): DocumentTextStatistics;
-export {};

package/dist/internal/features/work/editors/document-external-content.d.ts

@@ -5,7 +5,7 @@ export type ExternalDocumentContentResult = 'applied' | 'unchanged' | 'unsupport
  * Returns whether an editor transaction represents a user-authored document
  * change that the controlled host must persist.
  */
-export declare function shouldPublishDocumentUpdate(transaction: Transaction): boolean;
+export declare function shouldPublishDocumentUpdate(transaction: Transaction, appendedTransactions?: readonly Transaction[]): boolean;
 /**
  * Applies controlled host content as the smallest ProseMirror transaction.
  * This keeps selections, editor instances, and local history stable while an

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

@@ -1,6 +1,8 @@
+import { type WorkPresentationDesignContent } from '../work-presentation-layouts';
 import type { WorkPresentationContent, WorkSlide, WorkSlideElement } from '../work-types';
-export declare function SlideCanvas({ content, slide, interactive, aspectRatio, showPlaceholders, }: {
+export declare function SlideCanvas({ content, designContent, slide, interactive, aspectRatio, showPlaceholders, }: {
     content?: WorkPresentationContent;
+    designContent?: WorkPresentationDesignContent;
     slide: WorkSlide;
     interactive: boolean;
     aspectRatio: string;

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

@@ -1,7 +1,8 @@
 import type { WorkspaceContextMenuEvent } from '../../workspace/components/workspace-context-menu';
-import type { WorkPresentationContent, WorkSlide } from '../work-types';
+import type { WorkPresentationDesignContent } from '../work-presentation-layouts';
+import type { WorkSlide } from '../work-types';
 export declare function PresentationSlideThumbnail({ content, slide, index, selected, slideCount, aspectRatio, variant, renderPreview, onFocus, onSelect, onDelete, onNavigate, onContextMenu, onDoubleClick, }: {
-    content: WorkPresentationContent;
+    content: WorkPresentationDesignContent;
     slide: WorkSlide;
     index: number;
     selected: boolean;

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

@@ -1,10 +1,11 @@
 import { type RefObject } from 'react';
 import type { WorkspaceContextMenuEvent } from '../../workspace/components/workspace-context-menu';
+import type { WorkPresentationDesignContent } from '../work-presentation-layouts';
 import type { WorkPresentationContent, WorkSlide, WorkSlideElement } from '../work-types';
 export declare function PresentationThumbnailRail({ aspectRatio, content, designContent, selectedSlide, viewMode, zoom, mobileCloseButtonRef, mobileNavigationModal, mobileNavigationId, onAddSlide, onCloseMobileNavigation, onDeleteSlide, onOpenContextMenu, onSelectSlide, onViewModeChange, }: {
     aspectRatio: string;
     content: WorkPresentationContent;
-    designContent: WorkPresentationContent;
+    designContent: WorkPresentationDesignContent;
     selectedSlide: WorkSlide;
     viewMode: 'normal' | 'sorter';
     zoom: number;

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

@@ -2,6 +2,7 @@ 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 { WorkPresentationDesignContent } from '../work-presentation-layouts';
 import type { WorkPresentationContent, WorkPresentationLayout, WorkPresentationMaster, WorkSlide, WorkSlideElement } from '../work-types';
 import type { PresentationEditorCommands } from './presentation-command-types';
 import type { PresentationDesignMode } from './presentation-editor-types';
@@ -15,7 +16,7 @@ export interface PresentationWorkspaceProps {
     canvasRef: RefObject<HTMLElement | null>;
     commands: PresentationWorkspaceCommands;
     content: WorkPresentationContent;
-    designContent: WorkPresentationContent;
+    designContent: WorkPresentationDesignContent;
     designMode: PresentationDesignMode;
     inheritedElements: WorkSlideElement[];
     placeholderGuides: WorkSlideElement[];

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

@@ -0,0 +1,5 @@
+import type { SpreadsheetEditorCanCommands, SpreadsheetEditorCommands } from './spreadsheet-command-controller';
+export declare function SpreadsheetBorderRibbon({ can, commands, }: {
+    can: SpreadsheetEditorCanCommands;
+    commands: SpreadsheetEditorCommands;
+}): import("react").JSX.Element;

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

@@ -16,6 +16,10 @@ export interface SpreadsheetKernelOperationProjection {
     sourceChanged: boolean;
     workbook: SpreadsheetKernelWorkbook;
 }
+export interface SpreadsheetKernelWorkbookPreparation {
+    hasFormulaCells: boolean;
+    workbook: SpreadsheetKernelWorkbook | null;
+}
 interface SpreadsheetKernelSourceState {
     cellCount: number;
     fingerprintA: bigint;
@@ -24,6 +28,12 @@ interface SpreadsheetKernelSourceState {
     structureKey: string;
 }
 export declare function createSpreadsheetKernelWorkbook(content: Pick<WorkSpreadsheetContent, 'sheets'>): SpreadsheetKernelWorkbook | null;
+/**
+ * Prepares automatic calculation without compiling a value-only workbook that
+ * cannot produce any formula result. A later formula edit will prepare a fresh
+ * snapshot from the updated controlled content.
+ */
+export declare function prepareSpreadsheetKernelWorkbook(content: Pick<WorkSpreadsheetContent, 'sheets'>): SpreadsheetKernelWorkbookPreparation;
 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;

package/dist/internal/features/work/editors/spreadsheet-cell-border-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 createSpreadsheetCellBorderExtension(): OfficeEditorExtension<SpreadsheetCommandContext, SpreadsheetEditorCommands>;

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

@@ -0,0 +1,14 @@
+import type { WorkSpreadsheetContent } from '../work-types';
+import { type SpreadsheetCellRangeInput } from './spreadsheet-cell-range';
+export declare const spreadsheetCellBorderTargets: readonly ["top", "bottom", "left", "right", "none", "all", "outside", "inside", "horizontal", "vertical", "diagonal"];
+export type SpreadsheetCellBorderTarget = (typeof spreadsheetCellBorderTargets)[number];
+export declare const spreadsheetCellBorderStyles: readonly ["thin", "dotted", "dashed", "dash-dot", "dash-dot-dot", "medium", "medium-dashed", "medium-dash-dot", "medium-dash-dot-dot", "thick"];
+export type SpreadsheetCellBorderStyle = (typeof spreadsheetCellBorderStyles)[number];
+export interface SpreadsheetCellBorderFormat {
+    target: SpreadsheetCellBorderTarget;
+    color: string;
+    style: SpreadsheetCellBorderStyle;
+}
+export declare const MAX_SPREADSHEET_DIAGONAL_BORDER_CELLS = 4096;
+export declare function canSetSpreadsheetCellBorders(content: WorkSpreadsheetContent, sheetId: string, range: SpreadsheetCellRangeInput, format: SpreadsheetCellBorderFormat): boolean;
+export declare function setSpreadsheetCellBorders(content: WorkSpreadsheetContent, sheetId: string, range: SpreadsheetCellRangeInput, format: SpreadsheetCellBorderFormat): WorkSpreadsheetContent | null;

package/dist/internal/features/work/editors/spreadsheet-cell-fill-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 createSpreadsheetCellFillExtension(): OfficeEditorExtension<SpreadsheetCommandContext, SpreadsheetEditorCommands>;

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

@@ -0,0 +1,12 @@
+import type { WorkSpreadsheetSheet } from '../work-types';
+import { type SpreadsheetCellRange, type SpreadsheetCellRangeInput } from './spreadsheet-cell-range';
+export declare const spreadsheetCellFillMaximumCells = 50000;
+export type SpreadsheetCellFillDirection = 'down' | 'left' | 'right' | 'up';
+export interface SpreadsheetCellFillPlan {
+    applyRange: SpreadsheetCellRange;
+    copyRange: SpreadsheetCellRange;
+    direction: SpreadsheetCellFillDirection;
+    targetCellCount: number;
+}
+export declare function planSpreadsheetCellFill(selection: SpreadsheetCellRangeInput, direction: SpreadsheetCellFillDirection, maximumCells?: number): SpreadsheetCellFillPlan | null;
+export declare function canApplySpreadsheetCellFill(sheet: WorkSpreadsheetSheet | undefined, plan: SpreadsheetCellFillPlan): boolean;

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

@@ -0,0 +1,14 @@
+export interface SpreadsheetCellRange {
+    row: [number, number];
+    column: [number, number];
+}
+export interface SpreadsheetCellRangeInput {
+    row: readonly number[];
+    column: readonly number[];
+}
+export declare function normalizeSpreadsheetCellRange(value: SpreadsheetCellRangeInput): SpreadsheetCellRange | null;
+export declare function parseSpreadsheetCellRange(value: unknown): SpreadsheetCellRange | null;
+export declare function subtractSpreadsheetCellRange(source: SpreadsheetCellRange, removed: SpreadsheetCellRange): SpreadsheetCellRange[];
+export declare function spreadsheetCellRangesIntersect(left: SpreadsheetCellRange, right: SpreadsheetCellRange): boolean;
+export declare function spreadsheetCellRangeContains(range: SpreadsheetCellRange, row: number, column: number): boolean;
+export declare function spreadsheetCellRangeArea(range: SpreadsheetCellRange): number;

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

@@ -159,6 +159,119 @@ export declare const spreadsheetCommandCatalog: {
             readonly editor: readonly ["Mod-u"];
         };
     };
+    readonly strike: {
+        readonly id: "font.strike";
+        readonly label: "删除线";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "font";
+        };
+        readonly shortcut: {
+            readonly label: "Cmd/Ctrl+5";
+            readonly aria: "Control+5 Meta+5";
+            readonly editor: readonly ["Mod-5"];
+        };
+    };
+    readonly borderTop: {
+        readonly id: "font.borderTop";
+        readonly label: "上框线";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "font";
+        };
+    };
+    readonly borderBottom: {
+        readonly id: "font.borderBottom";
+        readonly label: "下框线";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "font";
+        };
+    };
+    readonly borderLeft: {
+        readonly id: "font.borderLeft";
+        readonly label: "左框线";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "font";
+        };
+    };
+    readonly borderRight: {
+        readonly id: "font.borderRight";
+        readonly label: "右框线";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "font";
+        };
+    };
+    readonly borderNone: {
+        readonly id: "font.borderNone";
+        readonly label: "无框线";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "font";
+        };
+    };
+    readonly borderAll: {
+        readonly id: "font.borderAll";
+        readonly label: "所有框线";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "font";
+        };
+    };
+    readonly borderOutside: {
+        readonly id: "font.borderOutside";
+        readonly label: "外侧框线";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "font";
+        };
+    };
+    readonly borderInside: {
+        readonly id: "font.borderInside";
+        readonly label: "内部框线";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "font";
+        };
+    };
+    readonly borderHorizontal: {
+        readonly id: "font.borderHorizontal";
+        readonly label: "内部横框线";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "font";
+        };
+    };
+    readonly borderVertical: {
+        readonly id: "font.borderVertical";
+        readonly label: "内部竖框线";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "font";
+        };
+    };
+    readonly borderDiagonal: {
+        readonly id: "font.borderDiagonal";
+        readonly label: "斜线框线";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "font";
+        };
+    };
     readonly mergeAndCenter: {
         readonly id: "alignment.mergeAndCenter";
         readonly label: "合并居中";
@@ -272,6 +385,52 @@ export declare const spreadsheetCommandCatalog: {
             readonly group: "cells";
         };
     };
+    readonly fillDown: {
+        readonly id: "editing.fillDown";
+        readonly label: "向下填充";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "editing";
+        };
+        readonly shortcut: {
+            readonly label: "Cmd/Ctrl+D";
+            readonly aria: "Control+D Meta+D";
+            readonly editor: readonly ["Mod-d"];
+        };
+    };
+    readonly fillRight: {
+        readonly id: "editing.fillRight";
+        readonly label: "向右填充";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "editing";
+        };
+        readonly shortcut: {
+            readonly label: "Cmd/Ctrl+R";
+            readonly aria: "Control+R Meta+R";
+            readonly editor: readonly ["Mod-r"];
+        };
+    };
+    readonly fillUp: {
+        readonly id: "editing.fillUp";
+        readonly label: "向上填充";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "editing";
+        };
+    };
+    readonly fillLeft: {
+        readonly id: "editing.fillLeft";
+        readonly label: "向左填充";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "home";
+            readonly group: "editing";
+        };
+    };
     readonly clearAll: {
         readonly id: "editing.clearAll";
         readonly label: "清除全部";

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

@@ -1,13 +1,17 @@
 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 SpreadsheetCellClearMode } from './spreadsheet-cell-clear';
+import type { SpreadsheetCellBorderFormat } from './spreadsheet-cell-border';
+import type { SpreadsheetCellFillDirection } from './spreadsheet-cell-fill';
 import { type SpreadsheetCellMergeCommand } from './spreadsheet-cell-merge';
-import { type SpreadsheetFreezePanePreset } from './spreadsheet-freeze-panes';
 import type { SpreadsheetFormatPainterMode } from './spreadsheet-format-painter';
+import { type SpreadsheetFreezePanePreset } from './spreadsheet-freeze-panes';
 import { type SpreadsheetKeyboardSelection, type SpreadsheetSelectionMove, type SpreadsheetSelectionScope } from './spreadsheet-keyboard-navigation';
 import { type SpreadsheetSheetMoveDirection } from './spreadsheet-sheet-model';
 export interface SpreadsheetWorkbookCommandPort {
+    autoFillCell: (copyRange: SpreadsheetCommandRange, applyRange: SpreadsheetCommandRange, direction: SpreadsheetCellFillDirection) => void;
     batchCallApis: (apiCalls: Array<{
         name: string;
         args: unknown[];
@@ -22,9 +26,6 @@ export interface SpreadsheetWorkbookCommandPort {
     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;
     setCellValuesByRange: (values: unknown[][], range: SpreadsheetCommandRange, options?: {
@@ -111,6 +112,7 @@ export interface SpreadsheetEditorCommands {
     deleteSelectedStructure: (axis: SpreadsheetStructureAxis) => boolean;
     deleteSheet: (sheetId: string) => boolean;
     duplicateSheet: (sheetId: string) => boolean;
+    fillSelectedCells: (direction: SpreadsheetCellFillDirection) => boolean;
     hideSheet: (sheetId: string) => boolean;
     insertSelectedStructure: (axis: SpreadsheetStructureAxis, position: SpreadsheetStructureInsertPosition) => boolean;
     mergeSelectedCells: (command: SpreadsheetCellMergeCommand) => boolean;
@@ -123,6 +125,7 @@ export interface SpreadsheetEditorCommands {
     renameSheet: (sheetId: string, name: string) => boolean;
     redo: () => boolean;
     setCellFormat: (attribute: keyof Cell, value: unknown) => boolean;
+    setSelectedCellBorders: (format: SpreadsheetCellBorderFormat) => boolean;
     setFreezePanes: (preset: SpreadsheetFreezePanePreset) => boolean;
     setGridLines: (visible: boolean) => boolean;
     selectCellRange: (scope: SpreadsheetSelectionScope) => boolean;
@@ -149,6 +152,7 @@ export interface SpreadsheetCommandContext {
     history: SpreadsheetHistoryCommandPort | null;
     onChange: (content: WorkSpreadsheetContent) => void;
     selection: SpreadsheetCommandSelection | null;
+    targetSheetGridSize?: SpreadsheetGridSize | null;
     targetSheetId: string;
     toolbarCell: Cell | null;
     view: SpreadsheetViewCommandPort | null;

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

@@ -1,4 +1,4 @@
-import type { Cell, Selection } from '@fortune-sheet/core';
+import type { Cell, Op, Selection } from '@fortune-sheet/core';
 import type { WorkSpreadsheetContent } from '../work-types';
 import type { OfficeSelectOption } from './office-select';
 export interface SpreadsheetSelectionSummary {
@@ -21,8 +21,15 @@ export declare function spreadsheetFontSizeOptions(current: number | undefined):
 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 spreadsheetSheetsFromFortune(sheets: WorkSpreadsheetContent['sheets'], sourceSheets: WorkSpreadsheetContent['sheets'], operations?: readonly Op[]): WorkSpreadsheetContent['sheets'];
 export declare function finiteSpreadsheetSelection(selection: Selection | undefined): Selection;
 export declare function sameSpreadsheetWorkbookState(changed: WorkSpreadsheetContent['sheets'], rendered: WorkSpreadsheetContent['sheets']): boolean;
+/**
+ * Answers the workbook equality check from Fortune's exact operation batch
+ * without walking unrelated matrix cells. A null result requires the legacy
+ * full comparison because the batch is missing or too broad to prove safely.
+ */
+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 isSpreadsheetNativeTextUndoTarget(target: EventTarget | null): boolean;

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

@@ -0,0 +1,10 @@
+import type { Cell } from '@fortune-sheet/core';
+import type { SpreadsheetEditorCanCommands, SpreadsheetEditorCommands } from './spreadsheet-command-controller';
+interface SpreadsheetHomeFormatRibbonProps {
+    can: SpreadsheetEditorCanCommands;
+    commands: SpreadsheetEditorCommands;
+    toolbarCell: Cell | null | undefined;
+}
+export declare function SpreadsheetFontRibbonGroup({ can, commands, toolbarCell, }: SpreadsheetHomeFormatRibbonProps): import("react").JSX.Element;
+export declare function SpreadsheetNumberRibbonGroup({ can, commands, toolbarCell, }: SpreadsheetHomeFormatRibbonProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import type { WorkbookInstance } from '@fortune-sheet/react';
+import type { WorkSpreadsheetContent } from '../work-types';
+type SpreadsheetWorkbookUpdateTarget = Pick<WorkbookInstance, 'updateSheet'>;
+/**
+ * Replaces only the data of an already-mounted, structurally simple workbook.
+ * Fortune keeps additional active-sheet state outside `luckysheetfile`, so
+ * richer workbook structures must continue through the remount path.
+ */
+export declare function synchronizeSpreadsheetWorkbookInPlace(workbook: SpreadsheetWorkbookUpdateTarget | null, previous: WorkSpreadsheetContent, next: WorkSpreadsheetContent, projectedSheets: WorkSpreadsheetContent['sheets'], preview: boolean): boolean;
+export {};

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

@@ -0,0 +1,14 @@
+import type { Op } from '@fortune-sheet/core';
+import type { WorkSpreadsheetContent } from '../work-types';
+export declare const MAXIMUM_INCREMENTAL_SPREADSHEET_OPERATIONS = 10000;
+export interface SpreadsheetOperationProjection {
+    affectedCellCount: number;
+    sheets: WorkSpreadsheetContent['sheets'];
+}
+/**
+ * Reconciles a bounded Fortune operation batch against authenticated
+ * controlled matrices. Only the outer matrix and affected rows/cells are
+ * copied; structural or incomplete batches return null for the full-scan
+ * compatibility path.
+ */
+export declare function projectSpreadsheetSheetsFromFortuneOperations(sheets: WorkSpreadsheetContent['sheets'], sourceSheets: WorkSpreadsheetContent['sheets'], operations: readonly Op[]): SpreadsheetOperationProjection | null;

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

@@ -0,0 +1,7 @@
+import type { SpreadsheetKeyboardSelection } from './spreadsheet-keyboard-navigation';
+/**
+ * Fortune clears its live selection after deleting rows or columns. Keep the
+ * user's selection on the structure that moved into the deleted range while
+ * clamping terminal deletions to the new grid boundary.
+ */
+export declare function spreadsheetSelectionAfterStructureDeletion(selection: SpreadsheetKeyboardSelection, axis: 'column' | 'row', extent: number, start: number, end: number): SpreadsheetKeyboardSelection;