@univerjs/docs 1.0.0-alpha.0 → 1.0.0-alpha.1

package/lib/types/facade/f-document-element.d.ts

@@ -0,0 +1,193 @@
+/**
+ * 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 { Injector } from '@univerjs/core';
+import type { FDocumentBody, IFDocumentBodyEdit } from './f-document-body';
+import { DocumentBlockType } from '@univerjs/core';
+import { FBase } from '@univerjs/core/facade';
+export interface IFDocumentElementInfo {
+    type: DocumentBlockType;
+    key: string;
+    position: number;
+    priority: number;
+}
+/**
+ * A generic top-level document body element.
+ *
+ * Use this wrapper when you need to inspect an element type first, navigate to
+ * neighboring elements, or cast the element to a more specific facade wrapper.
+ *
+ * Paragraph keys are persisted `paragraphId` values. Tables, block ranges, and
+ * custom blocks use their persisted ids.
+ *
+ * @hideconstructor
+ */
+export declare class FDocumentElement extends FBase {
+    protected readonly _body: FDocumentBody;
+    protected readonly _bodyEdit: IFDocumentBodyEdit;
+    protected readonly _info: IFDocumentElementInfo;
+    protected readonly _injector: Injector;
+    constructor(_body: FDocumentBody, _bodyEdit: IFDocumentBodyEdit, _info: IFDocumentElementInfo, _injector: Injector);
+    /**
+     * Get the document element type.
+     * @returns {DocumentBlockType} The element type, such as `paragraph`, `table`, `blockRange`, or `customBlock`.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     * console.log(element?.getType());
+     * ```
+     */
+    getType(): DocumentBlockType;
+    /**
+     * Whether this element is a paragraph.
+     * @returns {boolean} `true` if this element is a paragraph.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     * console.log(element?.isParagraph());
+     * ```
+     */
+    isParagraph(): boolean;
+    /**
+     * Whether this element is a table.
+     * @returns {boolean} `true` if this element is a table.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     * console.log(element?.isTable());
+     * ```
+     */
+    isTable(): boolean;
+    /**
+     * Whether this element is a block range, such as a callout, quote, or code block.
+     * @returns {boolean} `true` if this element is a block range.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     * console.log(element?.isBlockRange());
+     * ```
+     */
+    isBlockRange(): boolean;
+    /**
+     * Whether this element is a custom block.
+     * @returns {boolean} `true` if this element is a custom block.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     * console.log(element?.isCustomBlock());
+     * ```
+     */
+    isCustomBlock(): boolean;
+    /**
+     * Get the facade key used to resolve this element.
+     * @returns {string} The paragraph `paragraphId` or persisted table/block/custom block id.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     * console.log(element?.getKey());
+     * ```
+     */
+    getKey(): string;
+    /**
+     * Get the parent body facade that owns this element.
+     * @returns {FDocumentBody} The document body facade.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     * console.log(element?.getParent());
+     * ```
+     */
+    getParent(): FDocumentBody;
+    /**
+     * Get the resolved element info for this wrapper.
+     * @returns {IFDocumentElementInfo} The resolved element info, including type, key, position, and priority.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     * console.log(element?.getResolvedInfo());
+     * ```
+     */
+    getResolvedInfo(): IFDocumentElementInfo;
+    /**
+     * Get the next sibling element in the current body order.
+     * @returns {FDocumentElement | null} The next sibling wrapper, or `null` when this is the last child.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     * console.log(element?.getNextSibling());
+     * ```
+     */
+    getNextSibling(): FDocumentElement | null;
+    /**
+     * Get the previous sibling element in the current body order.
+     * @returns {FDocumentElement | null} The previous sibling wrapper, or `null` when this is the first child.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(1);
+     * console.log(element?.getPreviousSibling());
+     * ```
+     */
+    getPreviousSibling(): FDocumentElement | null;
+    /**
+     * Get the sibling element at a relative offset from this element.
+     * @param {number} offset The relative offset from this element. Use `1` for the next sibling, `-1` for the previous sibling, and so on.
+     * @returns {FDocumentElement | null} The sibling wrapper at the specified offset, or `null` when the offset is out of range.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     *
+     * // Get the third sibling after this element
+     * const nextThirdSibling = element?.getSibling(3);
+     * console.log(nextThirdSibling?.getType());
+     * ```
+     */
+    getSibling(offset: number): FDocumentElement | null;
+    /**
+     * Remove this element from its parent body.
+     * @returns {boolean} `true` if the element content was removed.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     * const removed = element?.remove();
+     * console.log(removed);
+     * ```
+     */
+    remove(): boolean;
+    private _createSibling;
+}

package/lib/types/facade/f-document-paragraph.d.ts

@@ -0,0 +1,231 @@
+/**
+ * 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 { Injector, IParagraph, IParagraphStyle } from '@univerjs/core';
+import type { FDocumentBody, IFDocumentBodyEdit, IFDocumentTextRange } from './f-document-body';
+import type { IFDocumentElementInfo } from './f-document-element';
+import { FDocumentElement } from './f-document-element';
+interface IFDocumentParagraphMixin {
+    asParagraph(): FDocumentParagraph;
+}
+/**
+ * Resolved paragraph metadata in the the document body.
+ */
+export interface IFDocumentResolvedParagraph {
+    /** The underlying paragraph snapshot object. */
+    paragraph: IParagraph;
+    /** The current paragraph index in the body paragraph list. */
+    paragraphIndex: number;
+    /** The inclusive start offset of the paragraph text. */
+    startOffset: number;
+    /** The exclusive end offset of the paragraph text, before the paragraph break. */
+    endOffset: number;
+}
+/**
+ * A paragraph facade wrapper.
+ *
+ * Paragraph identity is backed by the persisted `paragraphId`. The id is
+ * re-resolved before each method call, so insertions before this paragraph do
+ * not break the wrapper.
+ *
+ * @hideconstructor
+ */
+export declare class FDocumentParagraph extends FDocumentElement {
+    protected readonly body: FDocumentBody;
+    protected readonly bodyEdit: IFDocumentBodyEdit;
+    protected readonly info: IFDocumentElementInfo;
+    protected readonly injector: Injector;
+    constructor(body: FDocumentBody, bodyEdit: IFDocumentBodyEdit, info: IFDocumentElementInfo, injector: Injector);
+    /**
+     * Get the persisted paragraph id.
+     * @returns {string} The paragraph id.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     *
+     * if (element?.isParagraph()) {
+     *   const paragraph = element.asParagraph();
+     *   console.log(paragraph.getParagraphId());
+     * }
+     * ```
+     */
+    getParagraphId(): string;
+    /**
+     * Get the resolved paragraph info for this wrapper.
+     * @returns {IFDocumentResolvedParagraph} The resolved paragraph info, including the paragraph object, its index, and its text range.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     *
+     * if (element?.isParagraph()) {
+     *   const paragraph = element.asParagraph();
+     *   console.log(paragraph.getResolvedParagraphInfo());
+     * }
+     * ```
+     */
+    getResolvedParagraphInfo(): IFDocumentResolvedParagraph;
+    /**
+     * Get the current text range occupied by this paragraph.
+     * @returns {IFDocumentTextRange} The paragraph text range, excluding the trailing paragraph break.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     *
+     * if (element?.isParagraph()) {
+     *   const paragraph = element.asParagraph();
+     *   const range = paragraph.getRange();
+     *   fDocumentBody.setTextStyle(range, { bl: 1 });
+     * }
+     * ```
+     */
+    getRange(): IFDocumentTextRange;
+    /**
+     * Get this paragraph's plain text.
+     * @returns {string} The paragraph text without the trailing paragraph break.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     *
+     * if (element?.isParagraph()) {
+     *   const paragraph = element.asParagraph();
+     *   console.log(paragraph.getText());
+     * }
+     * ```
+     */
+    getText(): string;
+    /**
+     * Replace this paragraph's plain text.
+     * @param {string} text The replacement text. Do not include the paragraph break.
+     * @returns {boolean} `true` if the paragraph text was replaced.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     *
+     * if (element?.isParagraph()) {
+     *   const paragraph = element.asParagraph();
+     *   const success = paragraph.setText('Updated title');
+     *   console.log(success ? 'Text updated' : 'Failed to update text');
+     * }
+     * ```
+     */
+    setText(text: string): boolean;
+    /**
+     * Append plain text before this paragraph's trailing paragraph break.
+     * @param {string} text The plain text to append.
+     * @returns {boolean} `true` if the text was appended.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     *
+     * if (element?.isParagraph()) {
+     *   const paragraph = element.asParagraph();
+     *   const success = paragraph.appendText(' Appended text');
+     *   console.log(success ? 'Text appended' : 'Failed to append text');
+     * }
+     * ```
+     */
+    appendText(text: string): boolean;
+    /**
+     * Apply paragraph style to a paragraph handle or text range.
+     * @param {IParagraphStyle} style The Univer paragraph style patch.
+     * @returns {boolean} `true` if the style was applied.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     *
+     * if (element?.isParagraph()) {
+     *   const paragraph = element.asParagraph();
+     *   paragraph.setStyle({ horizontalAlign: 2 });
+     * }
+     * ```
+     */
+    setStyle(style: IParagraphStyle): boolean;
+    /**
+     * Check whether this paragraph is a bullet, ordered, or checklist item.
+     * @returns {boolean} `true` if the paragraph has list metadata.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     *
+     * if (element?.isParagraph()) {
+     *   const paragraph = element.asParagraph();
+     *   console.log(paragraph.isListItem() ? 'This is a list item' : 'This is not a list item');
+     * }
+     * ```
+     */
+    isListItem(): boolean;
+    /**
+     * Check whether this paragraph is a task/checklist item.
+     * @returns {boolean} `true` if this paragraph is an unchecked or checked task item.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     *
+     * if (element?.isParagraph()) {
+     *   const paragraph = element.asParagraph();
+     *   console.log(paragraph.isTask() ? 'This is a task item' : 'This is not a task item');
+     * }
+     * ```
+     */
+    isTask(): boolean;
+    /**
+     * Set the checked state of this task/checklist paragraph.
+     * @param {boolean} checked Whether the task item should be checked.
+     * @returns {boolean} `true` if the task state was updated, or `false` if this paragraph is not a task item.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     *
+     * if (element?.isParagraph()) {
+     *   const paragraph = element.asParagraph();
+     *
+     *   if (paragraph.isTask()) {
+     *     const success = paragraph.setTaskChecked(true);
+     *     console.log(success ? 'Task checked' : 'Failed to check task');
+     *   }
+     * }
+     * ```
+     */
+    setTaskChecked(checked: boolean): boolean;
+    private _preserveExplicitParagraphIds;
+}
+export declare class FDocumentParagraphMixin extends FDocumentElement {
+    asParagraph(): FDocumentParagraph;
+}
+declare module '@univerjs/docs/facade' {
+    interface FDocumentElement extends IFDocumentParagraphMixin {
+    }
+}
+export {};

package/lib/types/facade/f-document-table.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 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 { ICustomTable, Injector } from '@univerjs/core';
+import type { FDocumentBody, IFDocumentBodyEdit } from './f-document-body';
+import type { IFDocumentElementInfo } from './f-document-element';
+import { FDocumentElement } from './f-document-element';
+interface IFDocumentTableMixin {
+    asTable(): FDocumentTable;
+}
+/**
+ * A facade wrapper for document top-level tables.
+ * @hideconstructor
+ */
+export declare class FDocumentTable extends FDocumentElement {
+    protected readonly body: FDocumentBody;
+    protected readonly bodyEdit: IFDocumentBodyEdit;
+    protected readonly info: IFDocumentElementInfo;
+    protected readonly injector: Injector;
+    constructor(body: FDocumentBody, bodyEdit: IFDocumentBodyEdit, info: IFDocumentElementInfo, injector: Injector);
+    /**
+     * Get the table marker.
+     * @returns {ICustomTable} The table marker.
+     * @example
+     * ```ts
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * const element = fDocumentBody.getElement(0);
+     *
+     * if (element?.isTable()) {
+     *   const table = element.asTable();
+     *   console.log(table.getTable());
+     * }
+     * ```
+     */
+    getTable(): ICustomTable;
+}
+export declare class FDocumentTableMixin extends FDocumentElement {
+    asTable(): FDocumentTable;
+}
+declare module '@univerjs/docs/facade' {
+    interface FDocumentElement extends IFDocumentTableMixin {
+    }
+}
+export {};

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

@@ -16,13 +16,7 @@
 import type { DocumentDataModel, IDocumentData } from '@univerjs/core';
 import { ICommandService, Injector, IResourceLoaderService, IUniverInstanceService } from '@univerjs/core';
 import { FBaseInitialable } from '@univerjs/core/facade';
-import { FDocBody } from './f-doc-body';
-export interface IDocumentInsertTextFacadeOptions {
-    startOffset?: number;
-    endOffset?: number;
-    segmentId?: string;
-    cursorOffset?: number;
-}
+import { FDocumentBody } from './f-document-body';
 /**
  * Facade API object bounded to a document. It provides a set of methods to interact with the document.
  * @hideconstructor
@@ -34,7 +28,6 @@ export declare class FDocument extends FBaseInitialable {
     protected readonly _resourceLoaderService: IResourceLoaderService;
     private readonly _commandService;
     readonly id: string;
-    private readonly _docElementRegistry;
     constructor(_documentDataModel: DocumentDataModel, _injector: Injector, _univerInstanceService: IUniverInstanceService, _resourceLoaderService: IResourceLoaderService, _commandService: ICommandService);
     /**
      * Get the document data model of the document.
@@ -55,18 +48,22 @@ export declare class FDocument extends FBaseInitialable {
      * use their persisted `paragraphId` values. Persisted elements, such as tables
      * and custom blocks, use their existing ids.
      *
-     * @returns {FDocBody} The document body API instance.
+     * @returns {FDocumentBody} The document body API instance.
      * @example
      * ```typescript
-     * const doc = univerAPI.getActiveDocument();
-     * if (!doc) throw new Error('No active document');
+     * const fDocument = univerAPI.getActiveDocument();
+     * const fDocumentBody = fDocument.getBody();
+     * console.log(fDocumentBody.getBody());
      *
-     * const body = doc.getBody();
-     * const paragraph = body.getChild(0).asParagraph();
-     * paragraph.appendText(' updated');
+     * const element = fDocumentBody.getElement(0);
+     * if (element.isParagraph()) {
+     *   const paragraph = element.asParagraph();
+     *   paragraph.appendText(' updated');
+     *   console.log(paragraph.getText());
+     * }
      * ```
      */
-    getBody(): FDocBody;
+    getBody(): FDocumentBody;
     dispose(): void;
     /**
      * Get the document id.
@@ -123,83 +120,4 @@ export declare class FDocument extends FBaseInitialable {
      * ```
      */
     redo(): boolean;
-    /**
-     * Adds the specified text to the end of this text region.
-     * @param {string} text - The text to be added to the end of this text region.
-     * @return {boolean} `true` if the text was successfully appended, or `false` if it failed.
-     * @example
-     * ```typescript
-     * const fDocument = univerAPI.getActiveDocument();
-     * const success = fDocument.appendText('Hello, world!');
-     * console.log(success);
-     * ```
-     */
-    appendText(text: string): boolean;
-    /**
-     * Inserts text at the provided document range. Defaults to appending before the final section break.
-     * @param {string} text - The text to insert.
-     * @param {IDocumentInsertTextFacadeOptions} options - Optional target range, segment id, and cursor offset.
-     * @returns {boolean} `true` if the text was successfully inserted, or `false` if it failed.
-     * @example
-     *
-     * // Insert text at a specific range in the document body
-     * ```typescript
-     * const fDocument = univerAPI.getActiveDocument();
-     * const success = fDocument.insertText('Hello, world!', {
-     *   startOffset: 5,
-     *   endOffset: 5,
-     *   segmentId: '',
-     *   cursorOffset: 13,
-     * });
-     * console.log(success);
-     * ```
-     *
-     * // Insert text at the beginning of a header or footer segment
-     * ```typescript
-     * const fDocument = univerAPI.getActiveDocument();
-     * const snapshot = fDocument.save();
-     * const { headers, footers } = snapshot;
-     *
-     * if (headers) {
-     *   for (const headerId in headers) {
-     *     if (headerId === 'target-header-id') {
-     *       fDocument.insertText('Hello, header!', {
-     *         startOffset: 0,
-     *         endOffset: 0,
-     *         segmentId: headerId,
-     *       });
-     *     }
-     *   }
-     * }
-     *
-     * if (footers) {
-     *   for (const footerId in footers) {
-     *     if (footerId === 'target-footer-id') {
-     *       fDocument.insertText('Hello, footer!', {
-     *         startOffset: 0,
-     *         endOffset: 0,
-     *         segmentId: footerId,
-     *       });
-     *     }
-     *   }
-     * }
-     * ```
-     */
-    insertText(text: string, options?: IDocumentInsertTextFacadeOptions): boolean;
-    /**
-     * Inserts one or more plain-text paragraphs at the provided document range.
-     * @param {string} text - The paragraph text to insert. Newlines are normalized to document paragraph separators.
-     * @param {IDocumentInsertTextFacadeOptions} options - Optional target range, segment id, and cursor offset.
-     * @returns {boolean} `true` if the paragraphs were successfully inserted, or `false` if it failed.
-     * @example
-     * ```typescript
-     * const fDocument = univerAPI.getActiveDocument();
-     * const success = fDocument.insertParagraph('Hello, world! This is a new paragraph.', {
-     *   startOffset: 5,
-     *   endOffset: 5,
-     * });
-     * console.log(success);
-     * ```
-     */
-    insertParagraph(text?: string, options?: IDocumentInsertTextFacadeOptions): boolean;
 }

package/lib/types/facade/index.d.ts

@@ -14,12 +14,10 @@
  * limitations under the License.
  */
 import './f-univer';
-export { DocElementRegistry, DocElementStaleError, type FDocElementType } from './doc-element-registry';
-export { FDocBlockRange } from './f-doc-block-range';
-export { FDocBody, type IFDocElementHandle, type IFDocResolvedParagraph, type IFDocRichTextLike, type IFDocTextRange } from './f-doc-body';
-export { FDocCustomBlock } from './f-doc-custom-block';
-export { FDocElement } from './f-doc-element';
-export { FDocParagraph } from './f-doc-paragraph';
-export { FDocTable } from './f-doc-table';
 export { FDocument } from './f-document';
-export type * from './f-univer';
+export { FDocumentBlockRange } from './f-document-block-range';
+export { FDocumentBody, type IFDocumentTextRange } from './f-document-body';
+export { FDocumentCustomBlock } from './f-document-custom-block';
+export { FDocumentElement } from './f-document-element';
+export { FDocumentParagraph } from './f-document-paragraph';
+export { FDocumentTable } from './f-document-table';

package/lib/types/facade/utils.d.ts

@@ -13,14 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { IDocumentBody } from '@univerjs/core';
-type IParagraphStyle = NonNullable<IDocumentBody['paragraphs']>[number]['paragraphStyle'];
+import type { IDocumentBody, IParagraphStyle } from '@univerjs/core';
 export interface IBuildPlainTextInsertBodyOptions {
     paragraphStyle?: IParagraphStyle;
     removeLeadingParagraphBreak?: boolean;
 }
 export declare function getRemovedLeadingParagraphBreakLength(dataStream: string, removeLeadingParagraphBreak?: boolean): number;
 export declare function getNormalizedPlainTextCursorOffset(dataStream: string, cursorOffset: number, removeLeadingParagraphBreak?: boolean): number;
-export declare function getParagraphStyleAtOffset(body: IDocumentBody, offset: number): IParagraphStyle;
+export declare function getParagraphStyleAtOffset(body: IDocumentBody, offset: number): IParagraphStyle | undefined;
 export declare function buildPlainTextInsertBody(dataStream: string, options?: IBuildPlainTextInsertBodyOptions): IDocumentBody;
-export {};

package/lib/types/index.d.ts

@@ -21,6 +21,8 @@ export { SetTextSelectionsOperation } from './commands/operations/text-selection
 export type { ISetTextSelectionsOperationParams } from './commands/operations/text-selection.operation';
 export type { IUniverDocsConfig } from './config/config';
 export { UniverDocsPlugin } from './plugin';
+export { DocBlockMoveValidatorService } from './services/doc-block-move-validator.service';
+export type { DocBlockMoveTransformer, DocBlockMoveValidator, IDocBlockMoveResult, IDocBlockMoveTransformContext, IDocBlockMoveValidationContext } from './services/doc-block-move-validator.service';
 export { DocContentInsertService } from './services/doc-content-insert.service';
 export type { IDocContentInsertRange } from './services/doc-content-insert.service';
 export { DocInterceptorService } from './services/doc-interceptor/doc-interceptor.service';