@cool-office/docs-ui 0.0.0-stage → 1.2.0

package/lib/types/services/clipboard/html-to-udm/paste-plugins/plugin-word.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 type { IPastePlugin } from './type';
+declare const WordPastePlugin: IPastePlugin;
+export default WordPastePlugin;

package/lib/types/services/clipboard/html-to-udm/paste-plugins/type.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 type { IDocumentData, ITextStyle } from '@cool-office/core';
+export interface IStyleRule {
+    filter: string | string[] | ((node: HTMLElement) => boolean);
+    getStyle(node: HTMLElement): ITextStyle;
+}
+export interface IAfterProcessRule {
+    filter: string | string[] | ((node: HTMLElement) => boolean);
+    handler(doc: Partial<IDocumentData>, node: HTMLElement): void;
+}
+export interface IPastePlugin {
+    name: string;
+    checkPasteType(html: string): boolean;
+    preprocessHtml?(html: string): string;
+    stylesRules: IStyleRule[];
+    afterProcessRules: IAfterProcessRule[];
+}

package/lib/types/services/clipboard/html-to-udm/utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 type { IParagraphStyle, Nullable } from '@cool-office/core';
+export declare function getParagraphStyle(el: HTMLElement): Nullable<IParagraphStyle>;

package/lib/types/services/clipboard/internal-fragment.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 type { IDocumentBody, IDocumentData, IDocumentNote } from '@cool-office/core';
+export declare const DOC_INTERNAL_FRAGMENT_MIME = "application/x-doc-fragment+json";
+export declare const DOC_INTERNAL_FRAGMENT_COMMENT_PREFIX = "univer-doc-fragment:";
+export interface IDocInternalClipboardFragment {
+    version: 1;
+    kind: 'univer-doc-fragment';
+    doc: Partial<IDocumentData>;
+}
+export declare function createInternalClipboardFragment(doc: Partial<IDocumentData>): string;
+export declare function parseInternalClipboardFragment(value?: string): Partial<IDocumentData> | null;
+export declare function createInternalClipboardDocData(doc: IDocumentData): Partial<IDocumentData>;
+export declare function createInternalClipboardDocDataList(docs: IDocumentData[]): Partial<IDocumentData> | null;
+/** Removes reference characters through TextX so every following clipboard offset stays valid. */
+export declare function omitClipboardNotes(body: IDocumentBody): IDocumentBody;
+/** Each pasted reference owns a new rich segment, including its drawing and table identities. */
+export declare function cloneClipboardNotes(body: IDocumentBody, notes: IDocumentData['notes']): Record<string, IDocumentNote>;
+export declare function embedInternalClipboardFragment(html: string, fragmentJson: string): string;
+export declare function extractInternalClipboardFragmentFromHtml(html?: string): Partial<IDocumentData> | null;
+export declare function wrapClipboardHtml(fragmentHtml: string): string;

package/lib/types/services/clipboard/paste-options.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 type { IDocumentData, IParagraphStyle, ITextStyle } from '@cool-office/core';
+export type DocPasteMode = 'source' | 'destination' | 'text';
+export interface IDocPasteStyle {
+    textStyle: ITextStyle;
+    paragraphStyle?: IParagraphStyle;
+}
+export declare const DOC_PASTE_OPTIONS: readonly [{
+    readonly value: "source";
+    readonly label: "docs-ui.pasteOptions.source";
+}, {
+    readonly value: "destination";
+    readonly label: "docs-ui.pasteOptions.destination";
+}, {
+    readonly value: "text";
+    readonly label: "docs-ui.pasteOptions.text";
+}];
+export declare function getClipboardPlainText(doc: Partial<IDocumentData>): string;
+export declare function applyDocPasteMode(source: Partial<IDocumentData>, mode: DocPasteMode, style: IDocPasteStyle, text?: string): Partial<IDocumentData>;

package/lib/types/services/clipboard/rtf-to-plain-text.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 declare function convertClipboardRtfToPlainText(rtf: string): string;

package/lib/types/services/clipboard/udm-to-html/convertor.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 type { IDocumentData, ITextRun } from '@cool-office/core';
+import type { DocHtmlExportService } from './doc-html-export.service';
+export declare function covertTextRunToHtml(dataStream: string, textRun: ITextRun): string;
+export declare function getBodySliceHtml(doc: IDocumentData, startIndex: number, endIndex: number): string;
+export declare function convertBodyToHtml(doc: IDocumentData): string;
+export declare class UDMToHtmlService {
+    private readonly _docHtmlExportService?;
+    constructor(_docHtmlExportService?: Pick<DocHtmlExportService, "transformDocumentForHtmlExport"> | undefined);
+    convert(docList: IDocumentData[]): string;
+}

package/lib/types/services/clipboard/udm-to-html/doc-html-export.service.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 type { IDisposable, IDocumentData } from '@cool-office/core';
+import { Disposable } from '@cool-office/core';
+export type DocHtmlExportTransformer = (documentData: IDocumentData) => IDocumentData;
+export declare class DocHtmlExportService extends Disposable {
+    private readonly _transformers;
+    registerTransformer(transformer: DocHtmlExportTransformer): IDisposable;
+    transformDocumentForHtmlExport(documentData: IDocumentData): IDocumentData;
+}

package/lib/types/services/doc-auto-format.service.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 type { DocumentDataModel, ICommandInfo, ICustomRange, IDisposable, IParagraphRange, Nullable } from '@cool-office/core';
+import type { ITextRangeWithStyle } from '@cool-office/engine-render';
+import { Disposable, IUniverInstanceService } from '@cool-office/core';
+import { DocSelectionManagerService } from '@cool-office/docs';
+export interface IAutoFormatContext {
+    unit: DocumentDataModel;
+    selection: ITextRangeWithStyle;
+    /**
+     * is selection at doc body
+     */
+    isBody: boolean;
+    /**
+     * selection relative paragraphs
+     */
+    paragraphs: IParagraphRange[];
+    /**
+     * selection relative custom ranges
+     */
+    customRanges: ICustomRange[];
+    commandId: string;
+    commandParams: Nullable<object>;
+}
+export interface IAutoFormat {
+    id: string;
+    match: (context: IAutoFormatContext) => boolean;
+    getMutations: (context: IAutoFormatContext) => ICommandInfo[];
+    priority?: number;
+}
+/**
+ * service for auto-formatting, handle shortcut like `Space` or `Tab`.
+ */
+export declare class DocAutoFormatService extends Disposable {
+    private readonly _univerInstanceService;
+    private readonly _textSelectionManagerService;
+    private _matches;
+    constructor(_univerInstanceService: IUniverInstanceService, _textSelectionManagerService: DocSelectionManagerService);
+    registerAutoFormat(match: IAutoFormat): IDisposable;
+    onAutoFormat(id: string, params: Nullable<object>): ICommandInfo[];
+}

package/lib/types/services/doc-contextual-ribbon.service.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 { Disposable } from '@cool-office/core';
+import { IRibbonService } from '@cool-office/ui';
+/** Coordinates the document's containing table and selected content control, not global ribbon priority. */
+export declare class DocContextualRibbonService extends Disposable {
+    private readonly _ribbonService;
+    private _tableTab;
+    private _contentControlTab;
+    private _activeTab;
+    constructor(_ribbonService: IRibbonService);
+    setTableTab(tab: string, visible: boolean): void;
+    setContentControlTab(tab: string, visible: boolean): void;
+    private _setTab;
+    dispose(): void;
+}

package/lib/types/services/doc-embed-integration.service.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 type { IDisposable } from '@cool-office/core';
+import type { Observable } from 'rxjs';
+import { Subject } from 'rxjs';
+export declare const DOC_EMBED_INTERACTION_BOUNDARY_OWNER_ATTRIBUTE = "data-embed-interaction-boundary-owner";
+export declare const EMBED_INTERACTION_BOUNDARY_OWNER_ATTRIBUTE = "data-embed-interaction-boundary-owner";
+export interface IDocEmbedInteractionBoundaryService {
+    contains(embedId: string | undefined, target: EventTarget | null | undefined, event?: Event): boolean;
+    hasRecentInteraction(ownerDocument?: Document): boolean;
+    hasRecentInteractionFor?(embedId: string | undefined, ownerDocument?: Document): boolean;
+}
+export interface IDocEmbedRuntimeFocusCoordinator {
+    readonly runtimeSessionChanged$: Observable<void>;
+    isChildUnitRuntimeEvent(unitId: string | undefined, target: EventTarget | null | undefined, event?: Event): boolean;
+    isChildUnitInActiveSession(unitId: string | undefined): boolean;
+    shouldSuppressHostInteraction(unitId: string | undefined, target?: EventTarget | null, event?: Event): boolean;
+}
+export declare class EmbedInteractionBoundaryService implements IDocEmbedInteractionBoundaryService {
+    private readonly _roots;
+    registerOwnedElement(embedId: string, element: HTMLElement): IDisposable;
+    contains(embedId: string | undefined, target: EventTarget | null | undefined): boolean;
+    hasRecentInteraction(): boolean;
+    hasRecentInteractionFor(): boolean;
+}
+export declare const IDocEmbedInteractionBoundaryService: typeof EmbedInteractionBoundaryService;
+export declare class EmbedRuntimeFocusCoordinator implements IDocEmbedRuntimeFocusCoordinator {
+    private readonly _leases;
+    private readonly _elements;
+    readonly runtimeSessionChanged$: Subject<void>;
+    acquireLease(options: {
+        embedId?: string;
+        role: string;
+        owner?: string;
+        childUnitId?: string;
+        hostUnitId?: string;
+    }): IDisposable;
+    registerElement(options: {
+        embedId: string;
+        role: string;
+        element: HTMLElement;
+    }): IDisposable;
+    registerRuntimeScope(_options: {
+        embedId: string;
+        hostUnitId?: string;
+        childUnitId?: string;
+    }): IDisposable;
+    isChildUnitRuntimeEvent(_unitId: string | undefined, target: EventTarget | null | undefined): boolean;
+    isChildUnitInActiveSession(unitId: string | undefined): boolean;
+    shouldSuppressHostInteraction(unitId: string | undefined, target?: EventTarget | null): boolean;
+}
+export declare const IDocEmbedRuntimeFocusCoordinator: typeof EmbedRuntimeFocusCoordinator;

package/lib/types/services/doc-event-manager.service.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 type { DocumentDataModel, ICustomRange, IParagraph, Nullable } from '@cool-office/core';
+import type { Documents, DocumentSkeleton, IBoundRectNoAngle, IDocsTableRenderViewport, IDocumentSkeletonGlyph, IRenderContext, IRenderModule } from '@cool-office/engine-render';
+import { Disposable } from '@cool-office/core';
+import { DocSkeletonManagerService } from '@cool-office/docs';
+export interface ICustomRangeBound {
+    customRange: ICustomRange;
+    rects: IBoundRectNoAngle[];
+    segmentId?: string;
+    segmentPageIndex: number;
+}
+export interface IBulletBound {
+    rect: IBoundRectNoAngle;
+    segmentId?: string;
+    segmentPageIndex: number;
+    paragraph: IParagraph;
+}
+export declare const calcDocGlyphPosition: (glyph: IDocumentSkeletonGlyph, documents: Documents, skeleton: DocumentSkeleton, pageIndex?: number) => IBoundRectNoAngle | undefined;
+export declare function getListMarkerFallbackHit(paragraphBound: Pick<IMutiPageParagraphBound, 'firstLine' | 'pageIndex' | 'rect' | 'segmentId'>, paragraph: Pick<IParagraph, 'bullet' | 'startIndex'> | undefined, point: {
+    x: number;
+    y: number;
+}): IBulletBound | null;
+export declare function getListParagraphContextMenuHit(paragraphBound: Pick<IMutiPageParagraphBound, 'firstLine' | 'pageIndex' | 'rect' | 'segmentId'>, paragraph: Pick<IParagraph, 'bullet' | 'startIndex'> | undefined, point: {
+    x: number;
+    y: number;
+}): IBulletBound | null;
+export declare function isChecklistListType(listType?: string): boolean;
+export declare function getListMarkerFallbackBound(paragraphBound: Pick<IMutiPageParagraphBound, 'firstLine' | 'pageIndex' | 'rect' | 'segmentId'>, paragraph: Pick<IParagraph, 'bullet' | 'startIndex'> | undefined): IBulletBound | null;
+interface ICustomRangeActive {
+    range: ICustomRange;
+    segmentId?: string;
+    segmentPageIndex: number;
+    rects: IBoundRectNoAngle[];
+}
+interface ICustomRangeClickEvent extends ICustomRangeActive {
+    ctrlKey: boolean;
+    metaKey: boolean;
+}
+interface IBulletActive {
+    paragraph: IParagraph;
+    segmentId?: string;
+    segmentPageIndex: number;
+    rect: IBoundRectNoAngle;
+}
+export interface IMutiPageParagraphBound {
+    rect: IBoundRectNoAngle;
+    paragraphStart: number;
+    paragraphEnd: number;
+    startIndex: number;
+    rects: IBoundRectNoAngle[];
+    pageIndex: number;
+    segmentId?: string;
+    firstLine: IBoundRectNoAngle;
+}
+export interface ITableParagraphBound {
+    rect: IBoundRectNoAngle;
+    paragraphStart: number;
+    paragraphEnd: number;
+    startIndex: number;
+    pageIndex: number;
+    segmentId?: string;
+    rowIndex: number;
+    colIndex: number;
+    firstLine: IBoundRectNoAngle;
+    tableId: string;
+}
+export interface ITableBound {
+    rect: IBoundRectNoAngle;
+    pageIndex: number;
+    tableId: string;
+}
+export interface ITableCellBound {
+    rect: IBoundRectNoAngle;
+    pageIndex: number;
+    rowIndex: number;
+    colIndex: number;
+    tableId: string;
+}
+export declare function getTableBlockMenuHoverRect(tableRect: IBoundRectNoAngle): IBoundRectNoAngle;
+export declare function getTableHorizontalViewportGeometry(tableLeft: number, tableWidth: number, viewport: Nullable<IDocsTableRenderViewport>): {
+    scrollLeft: number;
+    visibleLeft: number;
+    visibleRight: number;
+};
+export declare class DocEventManagerService extends Disposable implements IRenderModule {
+    private _context;
+    private readonly _docSkeletonManagerService;
+    private readonly _hoverCustomRanges$;
+    readonly hoverCustomRanges$: import("rxjs").Observable<ICustomRangeActive[]>;
+    private readonly _clickCustomRanges$;
+    readonly clickCustomRanges$: import("rxjs").Observable<ICustomRangeClickEvent>;
+    private readonly _pointerDownCustomRanges$;
+    readonly pointerDownCustomRanges$: import("rxjs").Observable<ICustomRangeActive[]>;
+    private readonly _hoverBullet$;
+    readonly hoverBullet$: import("rxjs").Observable<Nullable<IBulletActive>>;
+    private readonly _clickBullet$;
+    readonly clickBullets$: import("rxjs").Observable<IBulletActive>;
+    private readonly _contextMenuBullet$;
+    readonly contextMenuBullets$: import("rxjs").Observable<IBulletActive & {
+        x: number;
+        y: number;
+    }>;
+    private readonly _hoverParagraph$;
+    readonly hoverParagraph$: import("rxjs").Observable<Nullable<IMutiPageParagraphBound>>;
+    readonly hoverParagraphRealTime$: import("rxjs").Observable<Nullable<IMutiPageParagraphBound>>;
+    get hoverParagraph(): Nullable<IMutiPageParagraphBound>;
+    private readonly _hoverParagraphLeft$;
+    readonly hoverParagraphLeft$: import("rxjs").Observable<Nullable<IMutiPageParagraphBound>>;
+    readonly hoverParagraphLeftRealTime$: import("rxjs").Observable<Nullable<IMutiPageParagraphBound>>;
+    get hoverParagraphLeft(): Nullable<IMutiPageParagraphBound>;
+    private readonly _hoverTableCell$;
+    readonly hoverTableCell$: import("rxjs").Observable<Nullable<ITableCellBound>>;
+    readonly hoverTableCellRealTime$: import("rxjs").Observable<Nullable<ITableCellBound>>;
+    private readonly _hoverTable$;
+    readonly hoverTable$: import("rxjs").Observable<Nullable<ITableBound>>;
+    readonly hoverTableRealTime$: import("rxjs").Observable<Nullable<ITableBound>>;
+    private _customRangeDirty;
+    private _customRangeCount;
+    private _customRangeSkeletonSignature;
+    private _bulletDirty;
+    private _paragraphDirty;
+    private _tableBoundsDirty;
+    /**
+     * cache the bounding of custom ranges,
+     * it will be updated when the doc-skeleton is recalculated
+     */
+    private _customRangeBounds;
+    /**
+     * cache the bounding of bullets,
+     * it will be updated when the doc-skeleton is recalculated
+     */
+    private _bulletBounds;
+    /**
+     * cache the bounding of paragraphs,
+     * it will be updated when the doc-skeleton is recalculated
+     */
+    private _paragraphBounds;
+    private _paragraphLeftBounds;
+    private _tableParagraphBounds;
+    private _tableParagraphBoundsByIndex;
+    private _segmentParagraphBounds;
+    private _tableViewportSignature;
+    private _tableCellBounds;
+    private _tableCellGeometries;
+    private _tableCellPages;
+    private _tableBounds;
+    private get _skeleton();
+    private get _documents();
+    constructor(_context: IRenderContext<DocumentDataModel>, _docSkeletonManagerService: DocSkeletonManagerService);
+    dispose(): void;
+    private _initPointer;
+    private _initResetDirty;
+    private _initEvents;
+    isPointerOnBullet(offsetX: number, offsetY: number): boolean;
+    isPointerOnInteractiveRange(offsetX: number, offsetY: number): boolean;
+    isPointerOnNonChecklistBullet(offsetX: number, offsetY: number): boolean;
+    getBulletBounds(): IBulletBound[];
+    getCustomRangeBounds(): ICustomRangeBound[];
+    getListContextMenuBulletByOffset(offsetX: number, offsetY: number): Nullable<IBulletBound>;
+    private _buildCustomRangeBoundsBySegment;
+    private _buildCustomRangeBounds;
+    private _calcActiveRanges;
+    private _buildBulletBoundsBySegment;
+    private _buildBulletBounds;
+    private _calcActiveBullet;
+    private _calcActiveListParagraph;
+    private _getParagraphByStartIndex;
+    private _buildParagraphBoundsBySegment;
+    private _buildParagraphBounds;
+    private _buildTableBounds;
+    private _buildTableCellsForPage;
+    private _buildTableCellsForDocumentRange;
+    private _getTableParagraphBoundsForCell;
+    contextMenuParagraph: {
+        unitId: string;
+        segmentId: string;
+        paragraphId: string;
+    } | null;
+    getParagraphByOffset(offsetX: number, offsetY: number): Nullable<IMutiPageParagraphBound>;
+    private _calcActiveParagraph;
+    private _calcActiveParagraphLeft;
+    get paragraphBounds(): Map<number, IMutiPageParagraphBound>;
+    get tableBounds(): Map<string, ITableBound>;
+    findTableCellBound(tableId: string, rowIndex: number, colIndex: number, pageIndex?: number): ITableCellBound | undefined;
+    findParagraphBoundByIndex(index: number): IMutiPageParagraphBound | ITableParagraphBound | undefined;
+    findParagraphBoundsInRange(startIndex: number, endIndex: number): IMutiPageParagraphBound[];
+    private _getTableViewportSignature;
+}
+export declare function getPreferredParagraphBoundsInRange(bodyBounds: IMutiPageParagraphBound[], tableBounds: IMutiPageParagraphBound[], startIndex: number, endIndex: number): IMutiPageParagraphBound[];
+export {};

package/lib/types/services/doc-heading-collapse.service.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 type { DocumentDataModel } from '@cool-office/core';
+import type { IRenderContext, IRenderModule } from '@cool-office/engine-render';
+import { Disposable, ICommandService, LocaleService, ThemeService } from '@cool-office/core';
+import { DocSelectionManagerService, DocSkeletonManagerService } from '@cool-office/docs';
+import { ILayoutService } from '@cool-office/ui';
+import { DocEventManagerService } from './doc-event-manager.service';
+export declare class DocHeadingCollapseService extends Disposable implements IRenderModule {
+    private readonly _context;
+    private readonly _skeletonManager;
+    private readonly _eventManager;
+    private readonly _selections;
+    private readonly _commandService;
+    private readonly _layoutService;
+    private readonly _buttons;
+    private _colors;
+    private _expandLabel;
+    private _collapseLabel;
+    constructor(_context: IRenderContext<DocumentDataModel>, _skeletonManager: DocSkeletonManagerService, _eventManager: DocEventManagerService, _selections: DocSelectionManagerService, _commandService: ICommandService, _layoutService: ILayoutService, themeService: ThemeService, localeService: LocaleService);
+    private _getColors;
+    private _normalizeSelection;
+    private _update;
+    dispose(): void;
+}

package/lib/types/services/doc-ime-input-manager.service.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 type { DocumentDataModel, Nullable } from '@cool-office/core';
+import type { IRichTextEditingMutationParams } from '@cool-office/docs';
+import type { IRenderContext, IRenderModule, ITextRangeWithStyle } from '@cool-office/engine-render';
+import { RxDisposable } from '@cool-office/core';
+interface ICacheParams {
+    undoCache: IRichTextEditingMutationParams[];
+    redoCache: IRichTextEditingMutationParams[];
+}
+export declare class DocIMEInputManagerService extends RxDisposable implements IRenderModule {
+    private readonly _context;
+    private _previousActiveRange;
+    private _previousDocRanges;
+    private _compositionRange;
+    private _previousSelectionOptions;
+    private _undoMutationParamsCache;
+    private _redoMutationParamsCache;
+    constructor(_context: IRenderContext<DocumentDataModel>);
+    clearUndoRedoMutationParamsCache(): void;
+    getUndoRedoMutationParamsCache(): {
+        undoCache: IRichTextEditingMutationParams[];
+        redoCache: IRichTextEditingMutationParams[];
+    };
+    setUndoRedoMutationParamsCache({ undoCache, redoCache }: ICacheParams): void;
+    getActiveRange(): Nullable<ITextRangeWithStyle>;
+    setActiveRange(range: Nullable<ITextRangeWithStyle>): void;
+    getCompositionRange(): Nullable<ITextRangeWithStyle>;
+    setCompositionRange(range: Nullable<ITextRangeWithStyle>): void;
+    getPreviousDocRanges(): ITextRangeWithStyle[];
+    setPreviousDocRanges(ranges: ITextRangeWithStyle[]): void;
+    getPreviousSelectionOptions(): Nullable<{
+        [key: string]: boolean;
+    }>;
+    setPreviousSelectionOptions(options: Nullable<{
+        [key: string]: boolean;
+    }>): void;
+    pushUndoRedoMutationParams(undoParams: IRichTextEditingMutationParams, redoParams: IRichTextEditingMutationParams): void;
+    fetchComposedUndoRedoMutationParams(): {
+        redoMutationParams: IRichTextEditingMutationParams;
+        undoMutationParams: IRichTextEditingMutationParams;
+        previousActiveRange: ITextRangeWithStyle;
+        previousDocRanges: ITextRangeWithStyle[];
+        previousSelectionOptions: Nullable<{
+            [key: string]: boolean;
+        }>;
+    } | null;
+    dispose(): void;
+}
+export {};