@univerjs/core 0.12.3 → 0.12.4

package/lib/types/index.d.ts

@@ -54,7 +54,7 @@ export { composeBody, getBodySlice, getCustomBlockSlice, getCustomDecorationSlic
 export { EventState, EventSubject, fromEventSubject, type IEventObserver } from './observer/observable';
 export { AuthzIoLocalService } from './services/authz-io/authz-io-local.service';
 export { IAuthzIoService } from './services/authz-io/type';
-export { type CommandListener, CommandService, CommandType, type ICommand, type ICommandInfo, ICommandService, type IExecutionOptions, type IMultiCommand, type IMutation, type IMutationCommonParams, type IMutationInfo, type IOperation, type IOperationInfo, NilCommand, sequenceExecute, sequenceExecuteAsync, } from './services/command/command.service';
+export { COMMAND_LOG_EXECUTION_CONFIG_KEY, type CommandListener, CommandService, CommandType, type ICommand, type ICommandInfo, ICommandService, type IExecutionOptions, type IMultiCommand, type IMutation, type IMutationCommonParams, type IMutationInfo, type IOperation, type IOperationInfo, NilCommand, sequenceExecute, sequenceExecuteAsync, } from './services/command/command.service';
 export { IConfigService } from './services/config/config.service';
 export { ConfigService } from './services/config/config.service';
 export * from './services/context/context';
@@ -96,6 +96,7 @@ export { afterTime, bufferDebounceTime, convertObservableToBehaviorSubject, from
 export { textDiff } from './shared/text-diff';
 export { awaitTime, delayAnimationFrame } from './shared/timer';
 export { isNodeEnv } from './shared/tools';
+export * from './sheets/clone';
 export { Range } from './sheets/range';
 export { getCellCoordByIndexSimple, getCellPositionByIndexSimple, getCellWithCoordByIndexCore, SheetSkeleton } from './sheets/sheet-skeleton';
 export type { IGetRowColByPosOptions } from './sheets/sheet-skeleton';

package/lib/types/services/command/command.service.d.ts

@@ -1,7 +1,14 @@
 import { IAccessor, IDisposable, Injector } from '../../common/di';
 import { Disposable } from '../../shared/lifecycle';
+import { IConfigService } from '../config/config.service';
 import { IContextService } from '../context/context.service';
 import { ILogService } from '../log/log.service';
+/**
+ * The config key for enabling command execution logging.
+ * Set via `logCommandExecution` in `IUniverConfig` when calling `new Univer()`.
+ * @default true
+ */
+export declare const COMMAND_LOG_EXECUTION_CONFIG_KEY = "command.logExecution";
 /**
  * The type of a command.
  */
@@ -77,6 +84,15 @@ export interface IMutationCommonParams {
      * It is used to indicate which {@link CommandType.COMMAND} triggers the mutation.
      */
     trigger?: string;
+    /**
+     * Mark this mutation as a split chunk from a large mutation.
+     * When collaboration layer encounters this flag, it will send this mutation
+     * in a separate changeset to avoid oversized payloads.
+     *
+     * This is typically set by operations that split large data (e.g., copy worksheet,
+     * paste large ranges) into smaller chunks for better network transmission.
+     */
+    __splitChunk__?: boolean;
 }
 /**
  * {@link CommandType.MUTATION} should implement this interface.
@@ -142,6 +158,11 @@ export interface IExecutionOptions {
     fromCollab?: boolean;
     /** @deprecated */
     fromChangeset?: boolean;
+    /**
+     * This mutation should be synced to changeset but not executed locally.
+     * The actual execution will be handled asynchronously via onlyLocal.
+     */
+    syncOnly?: boolean;
     [key: PropertyKey]: string | number | boolean | undefined;
 }
 export type CommandListener = (commandInfo: Readonly<ICommandInfo>, options?: IExecutionOptions) => void;
@@ -192,6 +213,7 @@ export interface ICommandService {
     syncExecuteCommand<P extends object = object, R = boolean>(id: string, params?: P, options?: IExecutionOptions): R;
     /**
      * Register a callback function that will be executed after a command is executed.
+     * Note: This will NOT be called for commands with syncOnly option.
      * @param listener
      */
     onCommandExecuted(listener: CommandListener): IDisposable;
@@ -200,6 +222,13 @@ export interface ICommandService {
      * @param listener
      */
     beforeCommandExecuted(listener: CommandListener): IDisposable;
+    /**
+     * Register a callback function specifically for collaboration sync.
+     * This will only be called for mutations (not commands/operations) that need to be synced,
+     * including syncOnly mutations.
+     * @param listener
+     */
+    onMutationExecutedForCollab(listener: CommandListener): IDisposable;
 }
 declare class CommandRegistry {
     private readonly _commands;
@@ -214,13 +243,15 @@ export declare const NilCommand: ICommand;
 export declare class CommandService extends Disposable implements ICommandService {
     private readonly _injector;
     private readonly _logService;
+    private readonly _configService;
     protected readonly _commandRegistry: CommandRegistry;
     private readonly _beforeCommandExecutionListeners;
     private readonly _commandExecutedListeners;
+    private readonly _collabMutationListeners;
     private _multiCommandDisposables;
     private _commandExecutingLevel;
     private _commandExecutionStack;
-    constructor(_injector: Injector, _logService: ILogService);
+    constructor(_injector: Injector, _logService: ILogService, _configService: IConfigService);
     dispose(): void;
     hasCommand(commandId: string): boolean;
     registerCommand(command: ICommand): IDisposable;
@@ -228,6 +259,7 @@ export declare class CommandService extends Disposable implements ICommandServic
     registerMultipleCommand(command: ICommand): IDisposable;
     beforeCommandExecuted(listener: CommandListener): IDisposable;
     onCommandExecuted(listener: (commandInfo: ICommandInfo) => void): IDisposable;
+    onMutationExecutedForCollab(listener: CommandListener): IDisposable;
     executeCommand<P extends object = object, R = boolean>(id: string, params?: P, options?: IExecutionOptions): Promise<R>;
     syncExecuteCommand<P extends object = object, R = boolean>(id: string, params?: P | undefined, options?: IExecutionOptions): R;
     private _pushCommandExecutionStack;

package/lib/types/sheets/clone.d.ts

@@ -0,0 +1,38 @@
+import { IObjectMatrixPrimitiveType, Nullable } from '../shared';
+import { ICellData, ICellDataWithSpanAndDisplay, IWorksheetData } from './typedef';
+/**
+ * Fast clone for primitive values and simple objects.
+ * Avoids type checking overhead when we know the structure.
+ */
+export declare function cloneValue<T>(value: T): T;
+/**
+ * Fast clone for ICellData. Optimized for the known structure.
+ * @param cell - The cell data to clone
+ * @returns A deep clone of the cell data
+ */
+export declare function cloneCellData(cell: Nullable<ICellData>): Nullable<ICellData>;
+/**
+ * Fast clone for ICellDataWithSpanAndDisplay. Optimized for the known structure.
+ * This extends cloneCellData with additional span and display properties.
+ * @param cell - The cell data with span and display info to clone
+ * @returns A deep clone of the cell data
+ */
+export declare function cloneCellDataWithSpanAndDisplay(cell: Nullable<ICellDataWithSpanAndDisplay>): Nullable<ICellDataWithSpanAndDisplay>;
+/**
+ * Fast clone for cell data matrix. Optimized for sparse matrix structure.
+ * @param cellData - The cell data matrix to clone
+ * @returns A deep clone of the cell data matrix
+ */
+export declare function cloneCellDataMatrix(cellData: IObjectMatrixPrimitiveType<ICellData>): IObjectMatrixPrimitiveType<ICellData>;
+/**
+ * Optimized deep clone specifically for IWorksheetData.
+ * This is significantly faster than generic deepClone because:
+ * 1. No recursive type checking - we know the structure
+ * 2. Direct property access instead of Object.keys iteration for known properties
+ * 3. Specialized handlers for cellData matrix (the largest data)
+ * 4. Primitive values copied directly without cloning
+ *
+ * @param worksheet - The worksheet data to clone
+ * @returns A deep clone of the worksheet data
+ */
+export declare function cloneWorksheetData(worksheet: IWorksheetData): IWorksheetData;

package/lib/types/univer.d.ts

@@ -33,6 +33,11 @@ export interface IUniverConfig {
      * The log level of the Univer instance.
      */
     logLevel?: LogLevel;
+    /**
+     * Whether to enable logging for command execution.
+     * @default false
+     */
+    logCommandExecution?: boolean;
     /**
      * The override dependencies of the Univer instance.
      */