@univerjs/core 0.4.1 → 0.4.2-nightly.202410301606

package/lib/types/common/__tests__/interceptor.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/common/const.d.ts

@@ -17,5 +17,6 @@ export declare const DOCS_NORMAL_EDITOR_UNIT_ID_KEY = "__INTERNAL_EDITOR__DOCS_N
 export declare const DOCS_FORMULA_BAR_EDITOR_UNIT_ID_KEY = "__INTERNAL_EDITOR__DOCS_FORMULA_BAR";
 export declare const DOCS_ZEN_EDITOR_UNIT_ID_KEY = "__INTERNAL_EDITOR__ZEN_EDITOR";
 export declare const DEFAULT_EMPTY_DOCUMENT_VALUE = "\r\n";
+export declare const IS_ROW_STYLE_PRECEDE_COLUMN_STYLE = "isRowStylePrecedeColumnStyle";
 export declare function createInternalEditorID(id: string): string;
 export declare function isInternalEditorID(id: string): boolean;

package/lib/types/common/interceptor.d.ts

@@ -26,3 +26,20 @@ export declare class InterceptorManager<P extends Record<string, IInterceptor<an
     getInterceptPoints(): P;
     dispose(): void;
 }
+export declare function createAsyncInterceptorKey<T, C>(key: string): IAsyncInterceptor<T, C>;
+export type AsyncInterceptorHandler<M = unknown, C = unknown> = (value: Nullable<M>, context: C, next: (value: Nullable<M>) => Promise<Nullable<M>>) => Promise<Nullable<M>>;
+export interface IAsyncInterceptor<M, C> {
+    priority?: number;
+    handler: AsyncInterceptorHandler<M, C>;
+}
+export type IComposeAsyncInterceptors<T = any, C = any> = (interceptors: Array<IAsyncInterceptor<T, C>>) => (initValue: Nullable<T>, initContext: C) => Promise<Nullable<T>>;
+export declare const composeAsyncInterceptors: <T, C>(interceptors: Array<IAsyncInterceptor<T, C>>) => ((initialValue: Nullable<T>, context: C) => Promise<Nullable<T>>);
+export declare class AsyncInterceptorManager<P extends Record<string, IAsyncInterceptor<any, any>>> {
+    private _asyncInterceptorsByName;
+    private _asyncInterceptorPoints;
+    constructor(asyncInterceptorPoints: P);
+    fetchThroughAsyncInterceptors<T, C>(name: IAsyncInterceptor<T, C>): (initialValue: Nullable<T>, context: C) => Promise<Nullable<T>>;
+    interceptAsync<T extends IAsyncInterceptor<any, any>>(name: T, interceptor: T): Promise<() => boolean>;
+    getInterceptPoints(): P;
+    dispose(): void;
+}

package/lib/types/docs/data-model/json-x/json-x.d.ts

@@ -1,7 +1,7 @@
 import { Doc, JSONOp, Path } from 'ot-json1';
 import { IDocumentBody, IDocumentData } from '../../../types/interfaces';
-import { TPriority } from '../text-x/text-x';
 import { TextXAction } from '../text-x/action-types';
+import { TPriority } from '../text-x/text-x';
 import * as json1 from 'ot-json1';
 export interface ISubType {
     name: string;
@@ -15,7 +15,7 @@ export interface ISubType {
     makeInvertible?: (actions: TextXAction[], doc: IDocumentBody) => TextXAction[];
     [k: string]: any;
 }
-export { JSONOp as JSONXActions, Path as JSONXPath, json1 as JSON1 };
+export { json1 as JSON1, JSONOp as JSONXActions, Path as JSONXPath };
 export declare class JSONX {
     static uri: string;
     private static _subTypes;

package/lib/types/docs/data-model/text-x/__tests__/apply.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/docs/data-model/text-x/__tests__/transform-paragraph.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/docs/data-model/text-x/__tests__/transform-textrun.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/docs/data-model/text-x/action-types.d.ts

@@ -14,7 +14,6 @@ export interface IRetainAction {
     body?: IDocumentBody;
     oldBody?: IDocumentBody;
     coverType?: UpdateDocsAttributeType;
-    segmentId?: string;
 }
 /**
  * Insert mutation is used to insert text (maybe with rich text properties) at the given position.
@@ -23,8 +22,6 @@ export interface IInsertAction {
     t: TextXActionType.INSERT;
     body: IDocumentBody;
     len: number;
-    line: number;
-    segmentId?: string;
 }
 /**
  * Delete mutation is used to delete text at the given position.
@@ -32,8 +29,6 @@ export interface IInsertAction {
 export interface IDeleteAction {
     t: TextXActionType.DELETE;
     len: number;
-    line: number;
     body?: IDocumentBody;
-    segmentId?: string;
 }
 export type TextXAction = IRetainAction | IInsertAction | IDeleteAction;

package/lib/types/docs/data-model/text-x/apply-utils/update-apply.d.ts

@@ -1,4 +1,4 @@
 import { IDocumentBody, ITextRun } from '../../../../types/interfaces';
 import { UpdateDocsAttributeType } from '../../../../shared';
 export declare function updateAttribute(body: IDocumentBody, updateBody: IDocumentBody, textLength: number, currentIndex: number, coverType: UpdateDocsAttributeType): IDocumentBody;
-export declare function coverTextRuns(updateDataTextRuns: ITextRun[], removeTextRuns: ITextRun[], coverType: UpdateDocsAttributeType): ITextRun[];
+export declare function coverTextRuns(updateDataTextRuns: ITextRun[], originTextRuns: ITextRun[], coverType: UpdateDocsAttributeType): ITextRun[];

package/lib/types/docs/data-model/text-x/build-utils/custom-range.d.ts

@@ -2,9 +2,17 @@ import { ITextRange } from '../../../../sheets/typedef';
 import { ICustomRange } from '../../../../types/interfaces';
 import { DataStreamTreeTokenType } from '../../types';
 export declare function isCustomRangeSplitSymbol(text: string): text is DataStreamTreeTokenType.CUSTOM_RANGE_START | DataStreamTreeTokenType.CUSTOM_RANGE_END;
+/**
+ * Check if two ranges intersect
+ * @param line1Start - The start of the first range
+ * @param line1End - The end of the first range
+ * @param line2Start - The start of the second range
+ * @param line2End - The end of the second range
+ * @returns True if the ranges intersect, false otherwise
+ */
 export declare function isIntersecting(line1Start: number, line1End: number, line2Start: number, line2End: number): boolean;
 export declare function shouldDeleteCustomRange(deleteStart: number, deleteLen: number, customRange: ICustomRange, dataStream: string): boolean;
-export declare function getCustomRangesInterestsWithRange(range: ITextRange, customRanges: ICustomRange[]): ICustomRange<Record<string, any>>[];
+export declare function getCustomRangesInterestsWithSelection(range: ITextRange, customRanges: ICustomRange[]): ICustomRange<Record<string, any>>[];
 export declare function copyCustomRange(range: ICustomRange): {
     rangeId: string;
     startIndex: number;

package/lib/types/docs/data-model/text-x/build-utils/index.d.ts

@@ -1,4 +1,4 @@
-import { copyCustomRange, getCustomRangesInterestsWithRange, isIntersecting, shouldDeleteCustomRange } from './custom-range';
+import { copyCustomRange, getCustomRangesInterestsWithSelection, isIntersecting, shouldDeleteCustomRange } from './custom-range';
 import { getDeleteSelection, getInsertSelection, getRetainAndDeleteFromReplace, isSegmentIntersects, makeSelection, normalizeSelection } from './selection';
 import { addCustomRangeTextX, deleteCustomRangeTextX, getRetainAndDeleteAndExcludeLineBreak } from './text-x-utils';
 export declare class BuildTextUtils {
@@ -6,7 +6,7 @@ export declare class BuildTextUtils {
         add: typeof addCustomRangeTextX;
         delete: typeof deleteCustomRangeTextX;
         copyCustomRange: typeof copyCustomRange;
-        getCustomRangesInterestsWithRange: typeof getCustomRangesInterestsWithRange;
+        getCustomRangesInterestsWithSelection: typeof getCustomRangesInterestsWithSelection;
         shouldDeleteCustomRange: typeof shouldDeleteCustomRange;
         isIntersecting: typeof isIntersecting;
     };
@@ -17,7 +17,7 @@ export declare class BuildTextUtils {
         getDeleteSelection: typeof getDeleteSelection;
         getInsertSelection: typeof getInsertSelection;
         getDeleteActions: typeof getRetainAndDeleteFromReplace;
-        getDeleteExculdeLastLineBreakActions: typeof getRetainAndDeleteAndExcludeLineBreak;
+        getDeleteExcludeLastLineBreakActions: typeof getRetainAndDeleteAndExcludeLineBreak;
     };
     static range: {
         isIntersects: typeof isSegmentIntersects;

package/lib/types/docs/data-model/text-x/text-x.d.ts

@@ -1,5 +1,5 @@
-import { UpdateDocsAttributeType } from '../../../shared/command-enum';
 import { IDocumentBody } from '../../../types/interfaces/i-document-data';
+import { UpdateDocsAttributeType } from '../../../shared/command-enum';
 import { TextXAction } from './action-types';
 export type TPriority = 'left' | 'right';
 export declare class TextX {
@@ -42,9 +42,9 @@ export declare class TextX {
     static invert(actions: TextXAction[]): TextXAction[];
     static makeInvertible(actions: TextXAction[], doc: IDocumentBody): TextXAction[];
     private _actions;
-    insert(len: number, body: IDocumentBody, segmentId?: string): this;
-    retain(len: number, segmentId?: string, body?: IDocumentBody, coverType?: UpdateDocsAttributeType): this;
-    delete(len: number, segmentId?: string): this;
+    insert(len: number, body: IDocumentBody): this;
+    retain(len: number, body?: IDocumentBody, coverType?: UpdateDocsAttributeType): this;
+    delete(len: number): this;
     empty(): this;
     serialize(): TextXAction[];
     push(...args: TextXAction[]): this;

package/lib/types/docs/data-model/text-x/transform-utils.d.ts

@@ -1,3 +1,9 @@
 import { IDocumentBody } from '../../../types/interfaces';
 import { IRetainAction } from './action-types';
-export declare function transformBody(thisAction: IRetainAction, otherAction: IRetainAction, priority?: boolean): IDocumentBody;
+import { UpdateDocsAttributeType } from '../../../shared';
+interface ITransformBodyResult {
+    body: IDocumentBody;
+    coverType: UpdateDocsAttributeType;
+}
+export declare function transformBody(thisAction: IRetainAction, otherAction: IRetainAction, priority?: boolean): ITransformBodyResult;
+export {};

package/lib/types/docs/data-model/utils.d.ts

@@ -0,0 +1,20 @@
+import { IStyleBase, ITextRotation } from '../../types/interfaces';
+export declare const DEFAULT_FONTFACE_PLANE = "\"Helvetica Neue\", Helvetica, Arial, \"PingFang SC\", \"Hiragino Sans GB\", \"Heiti SC\", \"Microsoft YaHei\", \"WenQuanYi Micro Hei\", sans-serif";
+export interface IDocumentSkeletonFontStyle {
+    fontString: string;
+    fontSize: number;
+    originFontSize: number;
+    fontFamily: string;
+    fontCache: string;
+}
+export declare function getFontStyleString(textStyle?: IStyleBase): IDocumentSkeletonFontStyle;
+export declare function getBaselineOffsetInfo(_fontFamily: string, fontSize: number): {
+    sbr: number;
+    sbo: number;
+    spr: number;
+    spo: number;
+};
+export declare function convertTextRotation(textRotation?: ITextRotation): {
+    centerAngle: number;
+    vertexAngle: number;
+};

package/lib/types/facade/f-base.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * `FBase` is a base class for all facade classes.
+ * It provides a way to extend classes with static and instance methods.
+ * The `_initialize` as a special method that will be called after the constructor. You should never call it directly.
+ */
+export declare abstract class FBase {
+    private static _constructorQueue;
+    constructor();
+    _initialize(): void;
+    static extend(source: any): void;
+}

package/lib/types/facade/f-hooks.d.ts

@@ -0,0 +1,57 @@
+import { IDisposable, Injector } from '../common/di';
+import { IUndoRedoItem } from '../services/undoredo/undoredo.service';
+import { LifecycleService } from '../services/lifecycle/lifecycle.service';
+import { FBase } from './f-base';
+export declare class FHooks extends FBase {
+    protected readonly _injector: Injector;
+    private readonly _lifecycleService;
+    constructor(_injector: Injector, _lifecycleService: LifecycleService);
+    /**
+     * The onStarting event is fired when lifecycle stage is Starting.
+     * @param callback Callback function that will be called when the event is fired
+     * @returns A disposable object that can be used to unsubscribe from the event
+     */
+    onStarting(callback: () => void): IDisposable;
+    /**
+     * The onReady event is fired when lifecycle stage is Ready.
+     * @param callback Callback function that will be called when the event is fired
+     * @returns A disposable object that can be used to unsubscribe from the event
+     */
+    onReady(callback: () => void): IDisposable;
+    /**
+     * The onRendered event is fired when lifecycle stage is Rendered.
+     * @param callback Callback function that will be called when the event is fired
+     * @returns A disposable object that can be used to unsubscribe from the event
+     */
+    onRendered(callback: () => void): IDisposable;
+    /**
+     * The onSteady event is fired when lifecycle stage is Steady.
+     * @param callback Callback function that will be called when the event is fired
+     * @returns A disposable object that can be used to unsubscribe from the event
+     */
+    onSteady(callback: () => void): IDisposable;
+    /**
+     * Hook that fires before an undo operation is executed.
+     * @param callback Function to be called when the event is triggered
+     * @returns A disposable object that can be used to unsubscribe from the event
+     */
+    onBeforeUndo(callback: (action: IUndoRedoItem) => void): IDisposable;
+    /**
+     * Hook that fires after an undo operation is executed.
+     * @param callback Function to be called when the event is triggered
+     * @returns A disposable object that can be used to unsubscribe from the event
+     */
+    onUndo(callback: (action: IUndoRedoItem) => void): IDisposable;
+    /**
+     * Hook that fires before a redo operation is executed.
+     * @param callback Function to be called when the event is triggered
+     * @returns A disposable object that can be used to unsubscribe from the event
+     */
+    onBeforeRedo(callback: (action: IUndoRedoItem) => void): IDisposable;
+    /**
+     * Hook that fires after a redo operation is executed.
+     * @param callback Function to be called when the event is triggered
+     * @returns A disposable object that can be used to unsubscribe from the event
+     */
+    onRedo(callback: (action: IUndoRedoItem) => void): IDisposable;
+}

package/lib/types/facade/f-univer.d.ts

@@ -0,0 +1,76 @@
+import { IDisposable, Injector } from '../common/di';
+import { CommandListener, IExecutionOptions, ICommandService } from '../services/command/command.service';
+import { LifecycleStages } from '../services/lifecycle/lifecycle';
+import { IUniverInstanceService } from '../services/instance/instance.service';
+import { Univer } from '../univer';
+import { FBase } from './f-base';
+import { FHooks } from './f-hooks';
+export declare class FUniver extends FBase {
+    protected readonly _injector: Injector;
+    protected readonly _commandService: ICommandService;
+    protected readonly _univerInstanceService: IUniverInstanceService;
+    /**
+     * Create an FUniver instance, if the injector is not provided, it will create a new Univer instance.
+     *
+     * @static
+     *
+     * @param {Univer | Injector} wrapped - The Univer instance or injector instance.
+     * @returns {FUniver} - The FUniver instance.
+     */
+    static newAPI(wrapped: Univer | Injector): FUniver;
+    constructor(_injector: Injector, _commandService: ICommandService, _univerInstanceService: IUniverInstanceService);
+    /**
+     * Dispose the UniverSheet by the `unitId`. The UniverSheet would be unload from the application.
+     *
+     * @param unitId The unit id of the UniverSheet.
+     * @returns Whether the Univer instance is disposed successfully.
+     */
+    disposeUnit(unitId: string): boolean;
+    /**
+     * Get the current lifecycle stage.
+     *
+     * @returns {LifecycleStages} - The current lifecycle stage.
+     */
+    getCurrentLifecycleStage(): LifecycleStages;
+    /**
+     * Undo an editing on the currently focused document.
+     *
+     * @returns {Promise<boolean>} undo result
+     */
+    undo(): Promise<boolean>;
+    /**
+     * Redo an editing on the currently focused document.
+     *
+     * @returns {Promise<boolean>} redo result
+     */
+    redo(): Promise<boolean>;
+    /**
+     * Register a callback that will be triggered before invoking a command.
+     *
+     * @param {CommandListener} callback The callback.
+     * @returns {IDisposable} The disposable instance.
+     */
+    onBeforeCommandExecute(callback: CommandListener): IDisposable;
+    /**
+     * Register a callback that will be triggered when a command is invoked.
+     *
+     * @param {CommandListener} callback The callback.
+     * @returns {IDisposable} The disposable instance.
+     */
+    onCommandExecuted(callback: CommandListener): IDisposable;
+    /**
+     * Execute command
+     *
+     * @param {string} id Command ID
+     * @param {object} params Command parameters
+     * @param {IExecutionOptions} options Command execution options
+     * @returns {Promise<R>} Command execution result
+     */
+    executeCommand<P extends object = object, R = boolean>(id: string, params?: P, options?: IExecutionOptions): Promise<R>;
+    /**
+     * Get hooks.
+     *
+     * @returns {FHooks} FHooks instance
+     */
+    getHooks(): FHooks;
+}

package/lib/types/index.d.ts

@@ -16,16 +16,19 @@
 export { debounce, get, merge, mergeWith, set } from 'lodash-es';
 export { dedupe, groupBy, makeArray, remove, rotate } from './common/array';
 export { isBooleanString } from './common/boolean';
-export { createInternalEditorID, DEFAULT_EMPTY_DOCUMENT_VALUE, DOCS_FORMULA_BAR_EDITOR_UNIT_ID_KEY, DOCS_NORMAL_EDITOR_UNIT_ID_KEY, DOCS_ZEN_EDITOR_UNIT_ID_KEY, isInternalEditorID, } from './common/const';
+export { createInternalEditorID, DEFAULT_EMPTY_DOCUMENT_VALUE, DOCS_FORMULA_BAR_EDITOR_UNIT_ID_KEY, DOCS_NORMAL_EDITOR_UNIT_ID_KEY, DOCS_ZEN_EDITOR_UNIT_ID_KEY, IS_ROW_STYLE_PRECEDE_COLUMN_STYLE, isInternalEditorID, } from './common/const';
 export * from './common/di';
 export { shallowEqual } from './common/equal';
 export { CustomCommandExecutionError } from './common/error';
 export { throttle } from './common/function';
 export type { ICellInterceptor, IComposeInterceptors, IInterceptor, InterceptorHandler } from './common/interceptor';
-export { composeInterceptors, createInterceptorKey, InterceptorEffectEnum, InterceptorManager } from './common/interceptor';
+export { AsyncInterceptorManager, composeInterceptors, createAsyncInterceptorKey, createInterceptorKey, InterceptorEffectEnum, InterceptorManager } from './common/interceptor';
 export type { Serializable } from './common/json';
 export { MemoryCursor } from './common/memory-cursor';
 export { mixinClass } from './common/mixin';
+export { FBase } from './facade/f-base';
+export { FUniver } from './facade/f-univer';
+export { FHooks } from './facade/f-hooks';
 export { isNumeric, isSafeNumeric } from './common/number';
 export { Registry, RegistryAsMap } from './common/registry';
 export { requestImmediateMacroTask } from './common/request-immediate-macro-task';
@@ -84,7 +87,7 @@ export { isBlackColor, isWhiteColor } from './shared/color/color-kit';
 export { cellToRange } from './shared/common';
 export { getIntersectRange } from './shared/range';
 export { nameCharacterCheck } from './shared/name';
-export { bufferDebounceTime, fromCallback, takeAfter } from './shared/rxjs';
+export { afterTime, bufferDebounceTime, fromCallback, takeAfter } from './shared/rxjs';
 export { awaitTime } from './shared/timer';
 export { Range } from './sheets/range';
 export { DEFAULT_WORKSHEET_COLUMN_COUNT, DEFAULT_WORKSHEET_COLUMN_COUNT_KEY, DEFAULT_WORKSHEET_COLUMN_TITLE_HEIGHT, DEFAULT_WORKSHEET_COLUMN_TITLE_HEIGHT_KEY, DEFAULT_WORKSHEET_COLUMN_WIDTH, DEFAULT_WORKSHEET_COLUMN_WIDTH_KEY, DEFAULT_WORKSHEET_ROW_COUNT, DEFAULT_WORKSHEET_ROW_COUNT_KEY, DEFAULT_WORKSHEET_ROW_HEIGHT, DEFAULT_WORKSHEET_ROW_HEIGHT_KEY, DEFAULT_WORKSHEET_ROW_TITLE_WIDTH, DEFAULT_WORKSHEET_ROW_TITLE_WIDTH_KEY, mergeWorksheetSnapshotWithDefault, } from './sheets/sheet-snapshot-utils';

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

@@ -1,4 +1,6 @@
+import { IDisposable } from '../../common/di';
 import { Nullable } from '../../shared/types';
+import { Observable } from 'rxjs';
 /**
  * IConfig provides universal configuration for the whole application.
  */
@@ -20,11 +22,18 @@ export interface IConfigService {
     getConfig<T>(id: string): Nullable<T>;
     setConfig(id: string | symbol, value: unknown, options?: IConfigOptions): void;
     deleteConfig(id: string): boolean;
+    subscribeConfigValue$<T = unknown>(key: string): Observable<T>;
 }
-export declare class ConfigService implements IConfigService {
+export declare class ConfigService implements IConfigService, IDisposable {
+    private _configChanged$;
+    readonly configChanged$: Observable<{
+        [key: string]: unknown;
+    }>;
     private readonly _config;
+    dispose(): void;
     getConfig<T>(id: string | symbol): Nullable<T>;
     setConfig(id: string, value: unknown, options?: IConfigOptions): void;
     deleteConfig(id: string | symbol): boolean;
+    subscribeConfigValue$<T = unknown>(key: string): Observable<T>;
 }
 export {};

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

@@ -5,6 +5,9 @@ export declare class PermissionService extends Disposable implements IPermission
     private _permissionPointMap;
     private _permissionPointUpdate$;
     permissionPointUpdate$: Observable<IPermissionPoint<unknown>>;
+    private _showComponents;
+    setShowComponents(showComponents: boolean): void;
+    getShowComponents(): boolean;
     deletePermissionPoint(permissionId: string): void;
     addPermissionPoint<T = boolean>(_item: IPermissionPoint<T> | BehaviorSubject<IPermissionPoint<T>>): boolean;
     updatePermissionPoint<T = boolean>(permissionId: string, value: T): void;

package/lib/types/services/permission/type.d.ts

@@ -38,5 +38,7 @@ export interface IPermissionService {
     composePermission$(permissionId: string[]): Observable<IPermissionPoint<unknown>[]>;
     composePermission(permissionId: string[]): IPermissionPoint<unknown>[];
     getAllPermissionPoint(): Map<string, Observable<IPermissionPoint<unknown>>>;
+    getShowComponents(): boolean;
+    setShowComponents(showComponents: boolean): void;
 }
 export declare const IPermissionService: import('@wendellhu/redi').IdentifierDecorator<IPermissionService>;

package/lib/types/services/resource-loader/resource-loader.service.d.ts

@@ -1,7 +1,7 @@
-import { IResourceManagerService } from '../resource-manager/type';
-import { IUniverInstanceService } from '../instance/instance.service';
-import { Disposable } from '../../shared/lifecycle';
 import { IResourceLoaderService } from './type';
+import { Disposable } from '../../shared/lifecycle';
+import { IUniverInstanceService } from '../instance/instance.service';
+import { IResourceManagerService } from '../resource-manager/type';
 export declare class ResourceLoaderService extends Disposable implements IResourceLoaderService {
     private readonly _resourceManagerService;
     private readonly _univerInstanceService;

package/lib/types/shared/__tests__/compose.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/shared/command-enum.d.ts

@@ -15,6 +15,5 @@
  */
 export declare enum UpdateDocsAttributeType {
     COVER = 0,// Default, if not present, add; if present, overwrite, while retaining the original properties.
-    REPLACE = 1,// Replace the original properties entirely.
-    INTERSECTION = 2
+    REPLACE = 1
 }

package/lib/types/shared/lifecycle.d.ts

@@ -17,7 +17,7 @@ export declare class DisposableCollection implements IDisposable {
 export declare class Disposable implements IDisposable {
     protected _disposed: boolean;
     private readonly _collection;
-    protected disposeWithMe(disposable: DisposableLike): IDisposable;
+    disposeWithMe(disposable: DisposableLike): IDisposable;
     protected ensureNotDisposed(): void;
     dispose(): void;
 }

package/lib/types/shared/r-tree.d.ts

@@ -1,10 +1,11 @@
 import { BBox, default as RBush } from 'rbush';
 import { IUnitRange } from '../sheets/typedef';
+type StringOrNumber = string | number;
 export interface IRTreeItem extends IUnitRange {
-    id: string;
+    id: StringOrNumber;
 }
 interface IRBushItem extends BBox {
-    id: string;
+    id: StringOrNumber;
 }
 export interface IRTreeData {
     [unitId: string]: {
@@ -12,13 +13,29 @@ export interface IRTreeData {
     };
 }
 export declare class RTree {
+    private _enableOneCellCache;
     private _tree;
+    private _oneCellCache;
+    private _kdTree;
+    private _kdTreeSearchState;
+    constructor(_enableOneCellCache?: boolean);
     dispose(): void;
     getTree(unitId: string, subUnitId: string): RBush<IRBushItem>;
+    private _getOneCellCache;
+    private _removeOneCellCache;
+    private _insertOneCellCache;
+    private _getRdTreeItems;
+    private _searchByOneCellCache;
+    /**
+     * Open the kd-tree search state.
+     * The kd-tree is used to search for data in a single cell.
+     */
+    openKdTree(): void;
+    closeKdTree(): void;
     insert(item: IRTreeItem): void;
     bulkInsert(items: IRTreeItem[]): void;
-    search(search: IUnitRange): IRTreeItem[];
-    bulkSearch(searchList: IUnitRange[]): Map<string, IRTreeItem>;
+    search(search: IUnitRange): StringOrNumber[];
+    bulkSearch(searchList: IUnitRange[]): Set<StringOrNumber>;
     removeById(unitId: string, subUnitId?: string): void;
     remove(search: IRTreeItem): void;
     bulkRemove(searchList: IRTreeItem[]): void;

package/lib/types/shared/rectangle.d.ts

@@ -45,4 +45,5 @@ export declare class Rectangle {
     static subtractMulti(ranges1: IRange[], ranges2: IRange[]): IRange[];
     static hasIntersectionBetweenTwoRect(rect1: IRectLTRB, rect2: IRectLTRB): boolean;
     static getIntersectionBetweenTwoRect(rect1: IRectLTRB, rect2: IRectLTRB): Required<IRectLTRB> | null;
+    static sort(ranges: IRange[]): IRange[];
 }

package/lib/types/shared/rxjs.d.ts

@@ -16,4 +16,5 @@ export declare function fromCallback<T extends readonly unknown[]>(callback: Cal
  */
 export declare function takeAfter<T>(callback: (value: T) => boolean): (source: Observable<T>) => Observable<T>;
 export declare function bufferDebounceTime<T>(time?: number): OperatorFunction<T, T[]>;
+export declare function afterTime(ms: number): Observable<void>;
 export {};

package/lib/types/shared/tools.d.ts

@@ -1,4 +1,5 @@
-import { IKeyValue } from './types';
+import { IStyleData } from '../types/interfaces';
+import { IKeyValue, Nullable } from './types';
 /**
  * Universal tool library
  */
@@ -17,7 +18,7 @@ export declare class Tools {
     static getClassName(instance: object): string;
     static deepMerge(target: any, ...sources: any[]): any;
     static numberFixed(value: number, digit: number): number;
-    static diffValue(one: any, tow: any): boolean;
+    static diffValue(one: any, two: any): boolean;
     static deepClone<T = unknown>(value: T): T;
     static getLanguage(): string;
     static getValueType(value: any): string;
@@ -106,3 +107,9 @@ export declare class Tools {
     static now(): number;
 }
 export declare function generateRandomId(n?: number, alphabet?: string): string;
+/**
+ * compose styles by priority, the latter will overwrite the former
+ * @param { Nullable<IStyleData>[]} styles the styles to be composed
+ * @returns  { Nullable<IStyleData>[]} Returns the composed style
+ */
+export declare function composeStyles(...styles: Nullable<IStyleData>[]): IStyleData;