@univerjs/core 0.5.3 → 0.5.4

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

@@ -1,7 +1,7 @@
 import { addCustomDecorationTextX, deleteCustomDecorationTextX } from './custom-decoration';
 import { copyCustomRange, getCustomRangesInterestsWithSelection, isIntersecting } from './custom-range';
 import { isSegmentIntersects, makeSelection, normalizeSelection } from './selection';
-import { addCustomRangeTextX, deleteCustomRangeTextX, deleteSelectionTextX } from './text-x-utils';
+import { addCustomRangeTextX, deleteCustomRangeTextX, deleteSelectionTextX, retainSelectionTextX } from './text-x-utils';
 export declare class BuildTextUtils {
     static customRange: {
         add: typeof addCustomRangeTextX;
@@ -19,6 +19,7 @@ export declare class BuildTextUtils {
         makeSelection: typeof makeSelection;
         normalizeSelection: typeof normalizeSelection;
         delete: typeof deleteSelectionTextX;
+        retain: typeof retainSelectionTextX;
     };
     static range: {
         isIntersects: typeof isSegmentIntersects;

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

@@ -1,4 +1,3 @@
-import { IAccessor } from '@wendellhu/redi';
 import { ITextRange, ITextRangeParam } from '../../../../sheets/typedef';
 import { CustomRangeType, IDocumentBody } from '../../../../types/interfaces';
 import { DocumentDataModel } from '../../document-data-model';
@@ -11,7 +10,7 @@ export interface IDeleteCustomRangeParam {
     documentDataModel: DocumentDataModel;
     insert?: Nullable<IDocumentBody>;
 }
-export declare function deleteCustomRangeTextX(accessor: IAccessor, params: IDeleteCustomRangeParam): false | TextXSelection;
+export declare function deleteCustomRangeTextX(params: IDeleteCustomRangeParam): false | TextXSelection;
 export interface IAddCustomRangeTextXParam {
     ranges: ITextRange[];
     segmentId?: string;
@@ -25,6 +24,7 @@ export declare function addCustomRangeTextX(param: IAddCustomRangeTextXParam): f
     selections?: ITextRange[];
 });
 export declare function deleteSelectionTextX(selections: ITextRange[], body: IDocumentBody, memoryCursor?: number, insertBody?: Nullable<IDocumentBody>, keepBullet?: boolean): Array<TextXAction>;
+export declare function retainSelectionTextX(selections: ITextRange[], body: IDocumentBody, memoryCursor?: number): TextXAction[];
 export interface IReplaceSelectionTextXParams {
     /**
      * range to be replaced.

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

@@ -21,7 +21,7 @@ export declare class FBlob extends FBase {
      * @returns a new blob by copying the current blob
      * @example
      * ```ts
-     * const blob = UniverApi.newBlob(blob);
+     * const blob = univerAPI.newBlob(blob);
      * const newBlob = blob.copyBlob();
      * console.log(newBlob);
      * ```
@@ -33,29 +33,29 @@ export declare class FBlob extends FBase {
      * @returns a new blob by converting the current blob to the specified content type
      * @example
      * ```ts
-     * const blob = UniverApi.newBlob(blob);
+     * const blob = univerAPI.newBlob(blob);
      * const newBlob = blob.getBlob();
      * ```
      */
     getAs(contentType: string): FBlob;
     /**
-     * get the blob as a string
+     * Get the blob as a string.
      * @returns
      * @example
      * ```ts
-     * const blob = UniverApi.newBlob(blob);
+     * const blob = univerAPI.newBlob(blob);
      * const newBlob = blob.getDataAsString();
      * console.log(newBlob);
      * ```
      */
     getDataAsString(): Promise<string>;
     /**
-     * get the blob as a string
+     * Get the blob as a string.
      * @param charset the charset
      * @returns the blob content as a string
      * @example
      * ```ts
-     * const blob = UniverApi.newBlob(blob);
+     * const blob = univerAPI.newBlob(blob);
      * const newBlob = blob.getDataAsString('iso-8859-1');
      * console.log(newBlob);
      * ```
@@ -66,7 +66,7 @@ export declare class FBlob extends FBase {
      * @returns the blob content as a byte array
      * @example
      * ```ts
-     * const blob = UniverApi.newBlob(blob);
+     * const blob = univerAPI.newBlob(blob);
      * const newBlob = blob.getBytes();
      * console.log(newBlob);
      * ```
@@ -78,7 +78,7 @@ export declare class FBlob extends FBase {
      * @returns the blob object
      * @example
      * ```ts
-     * const blob = UniverApi.newBlob();
+     * const blob = univerAPI.newBlob();
      * const bytes = new Uint8Array(10);
      * blob.setBytes(bytes);
      * ```
@@ -90,7 +90,7 @@ export declare class FBlob extends FBase {
      * @returns the blob object
      * @example
      * ```ts
-     * const blob = UniverApi.newBlob();
+     * const blob = univerAPI.newBlob();
      * blob.setDataFromString('Hello, World!');
      * ```
      */
@@ -102,7 +102,7 @@ export declare class FBlob extends FBase {
      * @returns the blob object
      * @example
      * ```ts
-     * const blob = UniverApi.newBlob();
+     * const blob = univerAPI.newBlob();
      * blob.setDataFromString('Hello, World!', 'text/plain');
      * ```
      */
@@ -112,7 +112,7 @@ export declare class FBlob extends FBase {
      * @returns the content type
      * @example
      * ```ts
-     * const blob = UniverApi.newBlob(blob);
+     * const blob = univerAPI.newBlob(blob);
      * const newBlob = blob.getContentType();
      * console.log(newBlob);
      * ```
@@ -124,7 +124,7 @@ export declare class FBlob extends FBase {
      * @returns the blob object
      * @example
      * ```ts
-     * const blob = UniverApi.newBlob(blob);
+     * const blob = univerAPI.newBlob(blob);
      * const newBlob = blob.setContentType('text/plain');
      * console.log(newBlob);
      * ```

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

@@ -0,0 +1,7 @@
+import { DocumentDataModel } from '../docs';
+import { Injector } from '../common/di';
+import { FBaseInitialable } from './f-base';
+export declare class FDoc extends FBaseInitialable {
+    protected doc: DocumentDataModel;
+    constructor(doc: DocumentDataModel, _injector: Injector);
+}

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

@@ -1,5 +1,7 @@
 import { UniverInstanceType } from '../common/unit';
+import { CommandType } from '../services/command/command.service';
 import { LifecycleStages } from '../services/lifecycle/lifecycle';
+import { BaselineOffset, BooleanNumber, HorizontalAlign, TextDecoration, TextDirection, VerticalAlign } from '../types/enum';
 import { DataValidationErrorStyle } from '../types/enum/data-validation-error-style';
 import { DataValidationOperator } from '../types/enum/data-validation-operator';
 import { DataValidationRenderMode } from '../types/enum/data-validation-render-mode';
@@ -10,11 +12,60 @@ export declare class FEnum {
     static get(): FEnum;
     static extend(source: any): void;
     constructor();
+    /**
+     *  Defines different types of Univer instances
+     */
     get UniverInstanceType(): typeof UniverInstanceType;
+    /**
+     * Represents different stages in the lifecycle
+     */
     get LifecycleStages(): typeof LifecycleStages;
+    /**
+     * Different types of data validation
+     */
     get DataValidationType(): typeof DataValidationType;
+    /**
+     * Different error display styles
+     */
     get DataValidationErrorStyle(): typeof DataValidationErrorStyle;
+    /**
+     * Different validation rendering modes
+     */
     get DataValidationRenderMode(): typeof DataValidationRenderMode;
+    /**
+     * Different validation operators
+     */
     get DataValidationOperator(): typeof DataValidationOperator;
+    /**
+     * Different validation states
+     */
     get DataValidationStatus(): typeof DataValidationStatus;
+    /**
+     * Different types of commands
+     */
+    get CommandType(): typeof CommandType;
+    /**
+     * Different baseline offsets for text baseline positioning
+     */
+    get BaselineOffset(): typeof BaselineOffset;
+    /**
+     * Boolean number representations
+     */
+    get BooleanNumber(): typeof BooleanNumber;
+    /**
+     * Different horizontal text alignment options
+     */
+    get HorizontalAlign(): typeof HorizontalAlign;
+    /**
+     * Different text decoration styles
+     */
+    get TextDecoration(): typeof TextDecoration;
+    /**
+     * Different text direction options
+     */
+    get TextDirection(): typeof TextDirection;
+    /**
+     * Different vertical text alignment options
+     */
+    get VerticalAlign(): typeof VerticalAlign;
 }

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

@@ -1,33 +1,188 @@
 import { UniverInstanceType } from '../common/unit';
+import { CommandType } from '../services/command/command.service';
 import { LifecycleStages } from '../services/lifecycle/lifecycle';
-import { IWorkbookData } from '../sheets/typedef';
 import { IDocumentData } from '../types/interfaces';
-export interface ISheetCreateParam {
-    unitId: string;
-    type: UniverInstanceType.UNIVER_SHEET;
-    data: IWorkbookData;
+import { FDoc } from './f-doc';
+/**
+ * Base interface for all event parameters
+ * @interface IEventBase
+ */
+export interface IEventBase {
+    /** Flag to cancel the event if supported */
+    cancel?: boolean;
 }
-export interface IDocumentCreateParam {
+/**
+ * Event interface triggered when a document is created
+ * @interface IDocCreatedParam
+ * @augments {IEventBase}
+ */
+export interface IDocCreatedParam extends IEventBase {
+    /** Unique identifier of the document unit */
     unitId: string;
+    /** Type identifier for document instances */
     type: UniverInstanceType.UNIVER_DOC;
-    data: IDocumentData;
+    /** The created document instance */
+    doc: FDoc;
+    /** Reference to the document unit */
+    unit: FDoc;
 }
-export interface ILifeCycleChangedParam {
+/**
+ * Event interface triggered when a document is disposed
+ * @interface IDocDisposedEvent
+ * @augments {IEventBase}
+ */
+export interface IDocDisposedEvent extends IEventBase {
+    /** Unique identifier of the disposed document unit */
+    unitId: string;
+    /** Type identifier for document instances */
+    unitType: UniverInstanceType.UNIVER_DOC;
+    /** Final state snapshot of the disposed document */
+    snapshot: IDocumentData;
+}
+/**
+ * Event interface for lifecycle stage changes
+ * @interface ILifeCycleChangedEvent
+ * @augments {IEventBase}
+ */
+export interface ILifeCycleChangedEvent extends IEventBase {
+    /** Current stage of the lifecycle */
     stage: LifecycleStages;
 }
-export interface IEventBase {
-    cancel?: boolean;
+/**
+ * Event interface for command execution
+ * @interface ICommandEvent
+ * @augments {IEventBase}
+ */
+export interface ICommandEvent extends IEventBase {
+    /** Parameters passed to the command */
+    params: any;
+    /** Unique identifier of the command */
+    id: string;
+    /** Type of the command */
+    type: CommandType;
 }
-export type IUnitCreateEvent = IEventBase & (ISheetCreateParam | IDocumentCreateParam);
-export type ILifeCycleChangedEvent = IEventBase & ILifeCycleChangedParam;
 export declare class FEventName {
     static _instance: FEventName | null;
     static get(): FEventName;
     static extend(source: any): void;
     constructor();
-    get UnitCreated(): "UnitCreated";
+    /**
+     * Event fired when a document is created
+     * @see {@link IDocCreatedParam}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.event.DocCreated, (params) => {
+     *     const { unitId, type, doc, unit } = params;
+     *     console.log('doc created', params);
+     * });
+     * ```
+     */
+    get DocCreated(): "DocCreated";
+    /**
+     * Event fired when a document is disposed
+     * @see {@link IDocDisposedEvent}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.event.DocDisposed, (params) => {
+     *     const { unitId, unitType, snapshot } = params;
+     *     console.log('doc disposed', params);
+     * });
+     * ```
+     */
+    get DocDisposed(): "DocDisposed";
+    /**
+     * Event fired when life cycle is changed
+     * @see {@link ILifeCycleChangedEvent}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.event.LifeCycleChanged, (params) => {
+     *      const { stage } = params;
+     *     console.log('life cycle changed', params);
+     * });
+     * ```
+     */
     get LifeCycleChanged(): "LifeCycleChanged";
+    /**
+     * Event fired when a redo command is executed
+     * @see {@link ICommandEvent}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.event.Redo, (event) => {
+     *     const { params, id, type } = event;
+     *     console.log('command executed', event);
+     * });
+     * ```
+     */
+    get Redo(): "Redo";
+    /**
+     * Event fired when an undo command is executed
+     * @see {@link ICommandEvent}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.event.Undo, (event) => {
+     *     const { params, id, type } = event;
+     *     console.log('command executed', event);
+     * });
+     * ```
+     */
+    get Undo(): "Undo";
+    /**
+     * Event fired before a redo command is executed
+     * @see {@link ICommandEvent}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.event.BeforeRedo, (event) => {
+     *     const { params, id, type } = event;
+     *     console.log('command executed', event);
+     * });
+     * ```
+     */
+    get BeforeRedo(): "BeforeRedo";
+    /**
+     * Event fired before an undo command is executed
+     * @see {@link ICommandEvent}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.event.BeforeUndo, (event) => {
+     *     const { params, id, type } = event;
+     *     console.log('command executed', event);
+     * });
+     * ```
+     */
+    get BeforeUndo(): "BeforeUndo";
+    /**
+     * Event fired when a command is executed
+     * @see {@link ICommandEvent}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.event.CommandExecuted, (event) => {
+     *     const { params, id, type } = event;
+     *     console.log('command executed', event);
+     * });
+     * ```
+     */
+    get CommandExecuted(): "CommandExecuted";
+    /**
+     * Event fired before a command is executed
+     * @see {@link ICommandEvent}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.event.BeforeCommandExecute, (event) => {
+     *     const { params, id, type } = event;
+     *     console.log('command executed', event);
+     * });
+     * ```
+     */
+    get BeforeCommandExecute(): "BeforeCommandExecute";
 }
 export interface IEventParamConfig {
     LifeCycleChanged: ILifeCycleChangedEvent;
+    DocDisposed: IDocDisposedEvent;
+    DocCreated: IDocCreatedParam;
+    Redo: ICommandEvent;
+    Undo: ICommandEvent;
+    BeforeRedo: ICommandEvent;
+    BeforeUndo: ICommandEvent;
+    CommandExecuted: ICommandEvent;
+    BeforeCommandExecute: ICommandEvent;
 }

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

@@ -1,7 +1,10 @@
 import { IDisposable, Injector } from '../common/di';
 import { CommandListener, IExecutionOptions, ICommandService } from '../services/command/command.service';
 import { LifecycleStages } from '../services/lifecycle/lifecycle';
+import { IDocumentData, IParagraphStyle, ITextDecoration, ITextStyle } from '../types/interfaces';
 import { IEventParamConfig, FEventName } from './f-event';
+import { Registry } from '../common/registry';
+import { ParagraphStyleBuilder, ParagraphStyleValue, RichTextBuilder, RichTextValue, TextDecorationBuilder, TextStyleBuilder, TextStyleValue } from '../docs/data-model/rich-text-builder';
 import { IUniverInstanceService } from '../services/instance/instance.service';
 import { LifecycleService } from '../services/lifecycle/lifecycle.service';
 import { ColorBuilder } from '../shared';
@@ -11,6 +14,7 @@ import { FBlob } from './f-blob';
 import { FEnum } from './f-enum';
 import { FHooks } from './f-hooks';
 import { FUserManager } from './f-usermanager';
+import { FUtil } from './f-util';
 export declare class FUniver extends FBaseInitialable {
     protected readonly _injector: Injector;
     protected readonly _commandService: ICommandService;
@@ -18,38 +22,34 @@ export declare class FUniver extends FBaseInitialable {
     protected readonly _lifecycleService: LifecycleService;
     /**
      * 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;
-    private _eventRegistry;
-    private _ensureEventRegistry;
+    protected _eventRegistry: Map<string, Registry<(param: any) => void>>;
+    protected _ensureEventRegistry(event: string): Registry<(param: any) => void>;
     constructor(_injector: Injector, _commandService: ICommandService, _univerInstanceService: IUniverInstanceService, _lifecycleService: LifecycleService);
+    private _initUnitEvent;
+    protected _eventListend(key: string): Registry<(param: any) => void> | undefined;
     /**
      * 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>;
@@ -89,19 +89,9 @@ export declare class FUniver extends FBaseInitialable {
      * @returns {FHooks} FHooks instance
      */
     getHooks(): FHooks;
-    /**
-     * Create a new blob.
-     *
-     * @returns {FBlob} The new blob instance
-     * @example
-     * ```ts
-     * const blob = UniverApi.newBlob();
-     * ```
-     */
-    newBlob(): FBlob;
-    newColor(): ColorBuilder;
     get Enum(): FEnum;
     get Event(): FEventName;
+    get Util(): FUtil;
     /**
      * Add an event listener
      * @param event key of event
@@ -118,7 +108,7 @@ export declare class FUniver extends FBaseInitialable {
     /**
      * Fire an event, used in internal only.
      * @param event {string} key of event
-     * @param params {any} parmas of event
+     * @param params {any} params of event
      * @returns {boolean} should cancel
      * @example
      * ```ts
@@ -126,5 +116,90 @@ export declare class FUniver extends FBaseInitialable {
      * ```
      */
     protected fireEvent<T extends keyof IEventParamConfig>(event: T, params: IEventParamConfig[T]): boolean | undefined;
+    /**
+     * Get the callback map corresponding to the event
+     * @param event
+     * @returns {number} The number of callbacks
+     */
+    protected hasEventCallback(event: keyof IEventParamConfig): boolean;
     getUserManager(): FUserManager;
+    /**
+     * Create a new blob.
+     * @returns {FBlob} The new blob instance
+     * @example
+     * ```ts
+     * const blob = univerApi.newBlob();
+     * ```
+     */
+    newBlob(): FBlob;
+    /**
+     * Create a new color.
+     * @returns {ColorBuilder} The new color instance
+     * @example
+     * ```ts
+     * const color = univerApi.newColor();
+     * ```
+     */
+    newColor(): ColorBuilder;
+    /**
+     * Create a new rich text.
+     * @param data
+     * @returns {RichTextBuilder} The new rich text instance
+     * @example
+     * ```ts
+     * const richText = univerApi.newRichText();
+     * ```
+     */
+    newRichText(data?: IDocumentData): RichTextBuilder;
+    /**
+     * Create a new rich text value.
+     * @param data - The rich text data
+     * @returns {RichTextValue} The new rich text value instance
+     * @example
+     * ```ts
+     * const richTextValue = univerApi.newRichTextValue();
+     * ```
+     */
+    newRichTextValue(data: IDocumentData): RichTextValue;
+    /**
+     * Create a new paragraph style.
+     * @param style - The paragraph style
+     * @returns {ParagraphStyleBuilder} The new paragraph style instance
+     * @example
+     * ```ts
+     * const paragraphStyle = univerApi.newParagraphStyle();
+     * ```
+     */
+    newParagraphStyle(style?: IParagraphStyle): ParagraphStyleBuilder;
+    /**
+     * Create a new paragraph style value.
+     * @param style - The paragraph style
+     * @returns {ParagraphStyleValue} The new paragraph style value instance
+     * @example
+     * ```ts
+     * const paragraphStyleValue = univerApi.newParagraphStyleValue();
+     * ```
+     */
+    newParagraphStyleValue(style?: IParagraphStyle): ParagraphStyleValue;
+    /**
+     * Create a new text style.
+     * @param style - The text style
+     * @returns {TextStyleBuilder} The new text style instance
+     * @example
+     * ```ts
+     * const textStyle = univerApi.newTextStyle();
+     * ```
+     */
+    newTextStyle(style?: ITextStyle): TextStyleBuilder;
+    /**
+     * Create a new text style value.
+     * @param style - The text style
+     * @returns {TextStyleValue} The new text style value instance
+     * @example
+     * ```ts
+     * const textStyleValue = univerApi.newTextStyleValue();
+     * ```
+     */
+    newTextStyleValue(style?: ITextStyle): TextStyleValue;
+    newTextDecoration(decoration?: ITextDecoration): TextDecorationBuilder;
 }

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

@@ -6,10 +6,11 @@ export declare class FUserManager extends FBase {
     private readonly _userManagerService;
     constructor(_injector: Injector, _userManagerService: UserManagerService);
     /**
-     * Get current user info
+     * Get current user info.
+     * @returns {IUser} Current user info.
      * @example
-     * ```
-     * univerAPI.getUserManager().getCurrentUser()
+     * ```typescript
+     * univerAPI.getUserManager().getCurrentUser();
      * ```
      */
     getCurrentUser(): IUser;

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

@@ -1,25 +1,18 @@
-/**
- * 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.
- */
+import { Rectangle, Tools } from '../shared';
 export declare class FUtil {
-    static Range: {
-        new (): Range;
-        prototype: Range;
-        readonly START_TO_START: 0;
-        readonly START_TO_END: 1;
-        readonly END_TO_END: 2;
-        readonly END_TO_START: 3;
-    };
+    static _instance: FUtil | null;
+    static get(): FUtil;
+    static extend(source: any): void;
+    /**
+     * Rectangle utils, including range operations likes merge, subtract, split
+     */
+    get rectangle(): typeof Rectangle;
+    /**
+     * Number format utils, including parse and strigify about date, price, etc
+     */
+    get numfmt(): import('../shared/types/numfmt.type').INumfmt;
+    /**
+     * common tools
+     */
+    get tools(): typeof Tools;
 }

package/lib/types/index.d.ts

@@ -20,7 +20,8 @@ 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, 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 { ParagraphStyleBuilder, ParagraphStyleValue, RichTextBuilder, RichTextValue, TextDecorationBuilder, TextStyleBuilder, TextStyleValue } from './docs/data-model/rich-text-builder';
+export { CanceledError, CustomCommandExecutionError } from './common/error';
 export { throttle } from './common/function';
 export type { IAsyncInterceptor, ICellInterceptor, IComposeInterceptors, IInterceptor, InterceptorHandler } from './common/interceptor';
 export { AsyncInterceptorManager, composeInterceptors, createAsyncInterceptorKey, createInterceptorKey, InterceptorEffectEnum, InterceptorManager } from './common/interceptor';
@@ -33,6 +34,7 @@ export { FHooks } from './facade/f-hooks';
 export { FBlob, type IFBlobSource } from './facade/f-blob';
 export { FEventName, type IEventBase, type IEventParamConfig } from './facade/f-event';
 export { FEnum } from './facade/f-enum';
+export { FUtil } from './facade/f-util';
 export { isNumeric, isSafeNumeric } from './common/number';
 export { Registry, RegistryAsMap } from './common/registry';
 export { requestImmediateMacroTask } from './common/request-immediate-macro-task';