@ones-editor/editor 0.0.3-beta.4 → 0.0.3-beta.40

package/@ones-editor/block-locker/src/i18n/en-US.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    locker: {
+        lock: string;
+        unlock: string;
+        lockedBy: string;
+    };
+};
+export default _default;

package/@ones-editor/block-locker/src/i18n/index.d.ts

@@ -0,0 +1 @@
+export {};

package/@ones-editor/block-locker/src/i18n/zh-CN.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    locker: {
+        lock: string;
+        unlock: string;
+        lockedBy: string;
+    };
+};
+export default _default;

package/@ones-editor/block-locker/src/index.d.ts

@@ -1,3 +1,5 @@
 import BlockLockerHook from './hook';
 import './style.scss';
+import './i18n';
+export * from './helper';
 export { BlockLockerHook };

package/@ones-editor/block-menu/src/block-menu/index.d.ts

@@ -8,6 +8,7 @@ export default class BlockMenu {
     show(target: HTMLElement): void;
     isInMenu(eventTarget: EventTarget | null): boolean;
     handleShow: () => void;
+    handleClose: () => void;
     handleItemClick: (bar: unknown, item: CommandItem) => void;
     setBlock(block: BlockElement): void;
     close: () => void;

package/@ones-editor/block-menu/src/block-menu/items/text-styles/text-style-item.d.ts

@@ -1,8 +1,8 @@
 import { BlockElement, OnesEditor, DocBlock } from '../../../../../../@ones-editor/core';
 import { BlockMenuItem } from '../types';
-export interface BlockData extends DocBlock {
-    'style-heading'?: string;
-    'style-blockquote'?: string;
+export interface ParagraphBlockAttribute extends DocBlock {
+    'heading'?: number;
+    quoted?: boolean;
     align?: 'left' | 'center' | 'right';
     checkbox?: 'checked' | 'unchecked';
     ordered?: boolean;
@@ -11,6 +11,7 @@ export type TextStyleItemOptions = {
     onAfterStyleItemClick?: () => void;
 };
 export default class TextStyleItem implements BlockMenuItem {
+    private editor;
     private block;
     private options;
     source: string;

package/@ones-editor/comments/src/actions/add-comment-to-block.d.ts

@@ -1,3 +1,4 @@
-import { BlockElement, OnesEditor } from '../../../../@ones-editor/core';
+import { BlockElement, OnesEditor, OnesEditorComment } from '../../../../@ones-editor/core';
 import { OnesEditorCommentsProvider } from '../types';
-export declare function addCommentToBlock(editor: OnesEditor, block: BlockElement, provider: OnesEditorCommentsProvider): import("@ones-editor/core").OnesEditorComment;
+export declare function updateCommentToBlock(editor: OnesEditor, block: BlockElement, comment: OnesEditorComment): void;
+export declare function addCommentToBlock(editor: OnesEditor, block: BlockElement, provider: OnesEditorCommentsProvider): OnesEditorComment;

package/@ones-editor/comments/src/actions/add-comment-to-text-block.d.ts

@@ -1,3 +1,4 @@
-import { OnesEditor, OnesEditorComment, SelectionRange } from '../../../../@ones-editor/core';
+import { OnesEditor, OnesEditorComment, SelectedBlock, SelectionRange } from '../../../../@ones-editor/core';
 import { OnesEditorCommentsProvider } from '../types';
+export declare function addCommentToSelectedTextBlock(editor: OnesEditor, selectedBlock: SelectedBlock, comment: OnesEditorComment): void;
 export declare function addCommentToTextBlocks(editor: OnesEditor, range: SelectionRange, provider: OnesEditorCommentsProvider): OnesEditorComment;

package/@ones-editor/comments/src/actions/editor-add-comment.d.ts

@@ -0,0 +1,2 @@
+import { OnesEditor } from '../../../../@ones-editor/core';
+export declare function editorAddComment(editor: OnesEditor): void;

package/@ones-editor/comments/src/block-hook/index.d.ts

@@ -1,8 +1,10 @@
 import { BlockCommands, BlockElement, CommandItem, OnesEditor, OnesEditorBlockHook } from '../../../../@ones-editor/core';
+import type { OnesEditorComments } from '../comments';
 import { OnesEditorCommentsProvider } from '../types';
 export default class CommentBlockHook implements OnesEditorBlockHook {
     private provider;
-    constructor(provider: OnesEditorCommentsProvider);
+    private editorComments;
+    constructor(provider: OnesEditorCommentsProvider, editorComments: OnesEditorComments);
     commands(editor: OnesEditor, blockElement: BlockElement): BlockCommands;
     executeCommand: (editor: OnesEditor, block: BlockElement, item: CommandItem) => void;
 }

package/@ones-editor/comments/src/comment-editor/index.d.ts

@@ -1,14 +1,13 @@
 import type { OnesEditor, DocObject } from '../../../../@ones-editor/core';
-import { CreateCommentEditorOption, OnesEditorCommentsProvider } from '../types';
+import { OnesEditorCommentsProvider } from '../types';
 import './index.scss';
 export declare class CommentEditor {
     private mainEditor;
     private commentsProvider;
-    private createOptions;
+    private doc;
     root: HTMLDivElement;
     private components;
-    constructor(mainEditor: OnesEditor, commentsProvider: OnesEditorCommentsProvider, createOptions: CreateCommentEditorOption);
-    private get editorDoc();
+    constructor(mainEditor: OnesEditor, commentsProvider: OnesEditorCommentsProvider, doc: DocObject);
     private createEditor;
     get editor(): OnesEditor;
     private handleEditorBlur;
@@ -17,7 +16,6 @@ export declare class CommentEditor {
     private inactiveEditor;
     handleInsertImg: () => Promise<void>;
     handleReadonlyChange: (editor: OnesEditor) => void;
-    reloadDoc: () => void;
     setDoc: (doc: DocObject) => void;
     getDoc: () => DocObject;
     isEmpty: () => boolean;

package/@ones-editor/comments/src/comment-input-handler/index.d.ts

@@ -1,10 +1,2 @@
-import type { OnesEditor, OnesEditorInputHandler } from '../../../../@ones-editor/core';
-import { OnesEditorCommentsProvider, CreateCommentEditorOption } from '../types';
-export declare class OnesEditorCommentInputHandler implements OnesEditorInputHandler {
-    private commentsProvider;
-    private createCommentEditorOptions;
-    constructor(commentsProvider: OnesEditorCommentsProvider, createCommentEditorOptions: CreateCommentEditorOption);
-    private handleQuickReplyEnter;
-    private handleCommentItemEnter;
-    handleBeforeKeyDown: (editor: OnesEditor, event: KeyboardEvent) => boolean;
-}
+export { QuickReplyEditorInputHandler } from './quick-reply-input-handler';
+export { CommentEditorInputHandler } from './input-handler';

package/@ones-editor/comments/src/comment-input-handler/input-handler.d.ts

@@ -0,0 +1,11 @@
+import type { OnesEditor, OnesEditorInputHandler } from '../../../../@ones-editor/core';
+import { OnesEditorCommentsProvider } from '../types';
+import type { CommentGroupItem } from '../comments-list/group-item';
+import type { CommentItem } from '../comment-item';
+export declare class CommentEditorInputHandler implements OnesEditorInputHandler {
+    private commentsProvider;
+    private groupItem;
+    private commentItem;
+    constructor(commentsProvider: OnesEditorCommentsProvider, groupItem: CommentGroupItem, commentItem: CommentItem);
+    handleBeforeKeyDown: (editor: OnesEditor, event: KeyboardEvent) => boolean;
+}

package/@ones-editor/comments/src/comment-input-handler/quick-reply-input-handler.d.ts

@@ -0,0 +1,7 @@
+import type { OnesEditor, OnesEditorInputHandler } from '../../../../@ones-editor/core';
+import type { CommentGroupItem } from '../comments-list/group-item';
+export declare class QuickReplyEditorInputHandler implements OnesEditorInputHandler {
+    private groupItem;
+    constructor(groupItem: CommentGroupItem);
+    handleBeforeKeyDown: (editor: OnesEditor, event: KeyboardEvent) => boolean;
+}

package/@ones-editor/comments/src/comment-item/comment-item.d.ts

@@ -20,6 +20,7 @@ export declare class CommentItem {
     constructor(options: CommentItemOptions);
     private get commentOptions();
     get comment(): OnesEditorComment;
+    get doc(): import("@ones-editor/core").DocObject;
     private createRoot;
     private createMoreMenu;
     private createItem;
@@ -33,6 +34,7 @@ export declare class CommentItem {
     getCommentEditor: () => CommentEditor;
     reloadDoc(): void;
     edit(): void;
+    handleReadonlyChanged: (editor: OnesEditor) => void;
     destroy(): void;
 }
 export {};

package/@ones-editor/comments/src/comment-item/index.d.ts

@@ -1,2 +1,3 @@
 export { CommentItem } from './comment-item';
+export { MobileCommentItem } from './mobile-comment-item';
 export { MiniCommentItem } from './mini-comment-item';

package/@ones-editor/comments/src/comment-item/mobile-comment-item/index.d.ts

@@ -0,0 +1 @@
+export { MobileCommentItem } from './mobile-comment-item';

package/@ones-editor/comments/src/comment-item/mobile-comment-item/mobile-comment-item.d.ts

@@ -0,0 +1,18 @@
+import { OnesEditorComment, OnesEditor } from '../../../../../@ones-editor/core';
+import { CommentEditor } from '../../comment-editor';
+import { OnesEditorCommentsProvider } from '../../types';
+import './mobile-comment-item.scss';
+export declare class MobileCommentItem {
+    private editor;
+    private commentsProvider;
+    comment: OnesEditorComment;
+    root: HTMLDivElement;
+    private components;
+    constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider, comment: OnesEditorComment);
+    private get doc();
+    createItem(): {
+        mobileCommentEditor: CommentEditor;
+    };
+    reloadDoc: () => void;
+    destroy(): void;
+}

package/@ones-editor/comments/src/comments/comments.d.ts

@@ -1,16 +1,20 @@
 import { OnesEditor } from '../../../../@ones-editor/core';
-import CommentsList, { MiniCommentsList } from '../comments-list';
 import { OnesEditorCommentsProvider } from '../types';
 export default class OnesEditorComments {
     private editor;
     private provider;
-    private list;
-    private miniList;
+    private commentList;
+    private mobileCommentList;
+    private miniCommentList;
     constructor(editor: OnesEditor, provider: OnesEditorCommentsProvider);
+    private get commentOptions();
+    get commentProvider(): OnesEditorCommentsProvider;
+    get isMobile(): boolean;
+    private getCommentRoot;
     destroy(): void;
-    private handleCommentClose;
-    private handleMiniCommentClose;
+    private showComment;
+    showCommentList: (groupId?: string) => void;
+    private handleCommentListClose;
+    private handleOnSelectComment;
     private handleMiniCommentItemClick;
-    createCommentsList(): CommentsList;
-    createCommentMiniList(): MiniCommentsList;
 }

package/@ones-editor/comments/src/comments-button/index.d.ts

@@ -1,11 +1,13 @@
 import { BlockElement, OnesEditor } from '../../../../@ones-editor/core';
 import { OnesEditorCommentsProvider } from '../types';
+import type OnesEditorComments from '../comments/comments';
 export default class BlockCommentButton {
     private editor;
     private commentProvider;
+    private editorComments;
     private buttonElement;
     private currentBlockId;
-    constructor(editor: OnesEditor, commentProvider: OnesEditorCommentsProvider);
+    constructor(editor: OnesEditor, commentProvider: OnesEditorCommentsProvider, editorComments: OnesEditorComments);
     destroy(): void;
     handleDocumentMouseMove: (event: MouseEvent) => void;
     handleButtonClick: (event: MouseEvent) => void;

package/@ones-editor/comments/src/comments-helper/utils.d.ts

@@ -1,10 +1,11 @@
 import { OnesEditorComment, OnesEditor } from '../../../../@ones-editor/core';
 export declare function isChildComment(comment: OnesEditorComment): boolean;
 export declare function getCommentsRoot(): HTMLDivElement;
-export declare function getCommentItemCountInGroupItem(groupItemRoot: HTMLElement): number;
+export declare function getCommentItemCountInGroupItem(groupItemRoot: HTMLElement, commentItemCls?: string): number;
 export declare function getClosestCommentItemId(element: HTMLElement): string | null;
 export declare function addGroupActionToElement(element: HTMLElement, action: string): void;
 export declare function getClosestGroupItemActionElement(element: HTMLElement): HTMLElement;
 export declare function getActionFromActionElement(actionElement: HTMLElement): string;
 export declare function isDisabledActionElement(actionElement: HTMLElement): boolean;
 export declare function getBlockIdByGroupId(editor: OnesEditor, commentId: string): string | null;
+export declare function getAllCommentInCommentElement(element: HTMLElement): string[];

package/@ones-editor/comments/src/comments-list/comments-list.d.ts

@@ -3,29 +3,21 @@ import { TypedEmitter } from 'tiny-typed-emitter';
 import { OnesEditorCommentsEvents, OnesEditorCommentsProvider } from '../types';
 import CommentGroupList from './group-list';
 interface CommentsListEvents {
-    onCommentListClose: () => void;
     onSelectComment: () => void;
 }
 export default class CommentsList extends TypedEmitter<CommentsListEvents> implements OnesEditorCommentsEvents {
     private editor;
     private commentsProvider;
     private root;
-    private header;
     private groupsContainer;
     private list;
-    constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider);
+    constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider, parent: HTMLElement);
     private get commentOptions();
     destroy(): void;
     onCreateComment(commentId: string, local: boolean): void;
     onDeleteComment(commentId: string, local: boolean): void;
     onUpdateComment(commentId: string, local: boolean): void;
-    createHeader(): {
-        header: HTMLDivElement;
-        count: HTMLSpanElement;
-        closeButton: HTMLButtonElement;
-    };
     createList(): CommentGroupList;
-    handleCloseButtonClick: () => void;
     handleSelectionOnComment: () => void;
     updateCommentCount: () => void;
     handleActiveItemChanged: () => void;

package/@ones-editor/comments/src/comments-list/group-item.d.ts

@@ -33,6 +33,7 @@ export declare class CommentGroupItem extends TypedEmitter<CommentGroupItemEvent
     handleUpdateChildComment(comment: OnesEditorComment): void;
     handleUpdateMainComment(comment: OnesEditorComment): void;
     deleteMainComment(commentId: OnesEditorComment['id']): void;
+    handleReadonlyChanged: (editor: OnesEditor) => void;
     edit(): void;
     destroy(): void;
     private handleResize;

package/@ones-editor/comments/src/comments-list/group-list.d.ts

@@ -6,7 +6,6 @@ import { CommentGroupItemHandlers } from './handler';
 export interface CommentGroupListEvents {
     activeItemChanged: (index: number) => void;
     itemLayoutUpdated: () => void;
-    itemCountClicked: () => void;
     selectionOnComment: () => void;
     commentCountChanged: () => void;
 }

package/@ones-editor/comments/src/comments-list/index.d.ts

@@ -1,3 +1,4 @@
 import CommentsList from './comments-list';
+export { MobileCommentsList } from './mobile-comments-list';
 export { MiniCommentsList } from './mini-comment';
 export default CommentsList;

package/@ones-editor/comments/src/comments-list/mini-comment/mini-comments-list.d.ts

@@ -2,7 +2,6 @@ import { OnesEditor } from '../../../../../@ones-editor/core';
 import { TypedEmitter } from 'tiny-typed-emitter';
 import { OnesEditorCommentsEvents, OnesEditorCommentsProvider } from '../..';
 import { MiniGroupList } from './group-list';
-import './style.scss';
 interface MiniCommentsListEvents {
     onMiniCommentClose: () => void;
     onItemClick: (groupId: string) => void;
@@ -12,15 +11,12 @@ export declare class MiniCommentsList extends TypedEmitter<MiniCommentsListEvent
     private commentsProvider;
     list: MiniGroupList;
     root: HTMLElement;
-    header: HTMLElement;
-    constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider);
+    constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider, parent: HTMLElement);
     onCreateComment(commentId: string, local: boolean): void;
     onDeleteComment(commentId: string, local: boolean): void;
     onUpdateComment(commentId: string, local: boolean): void;
-    private createHeader;
     private createList;
     private handleListContainerClick;
-    private closeMiniComment;
     show(): void;
     hide(): void;
     destroy(): void;

package/@ones-editor/comments/src/comments-list/mobile-comments-list/children-list.d.ts

@@ -0,0 +1,17 @@
+import type { OnesEditor, OnesEditorComment } from '../../../../../@ones-editor/core';
+import { MobileCommentItem } from '../../comment-item';
+import ListBase from '../list-base';
+import { OnesEditorCommentsProvider } from '../../types';
+interface MobileCommentChildrenListOptions {
+    editor: OnesEditor;
+    commentsProvider: OnesEditorCommentsProvider;
+    parent: HTMLElement;
+    comments: OnesEditorComment[];
+}
+export declare class MobileCommentChildrenList extends ListBase<OnesEditorComment, MobileCommentItem, unknown> {
+    constructor({ editor, parent, commentsProvider, comments }: MobileCommentChildrenListOptions);
+    protected findInsertPos(): number;
+    createItem(data: OnesEditorComment): MobileCommentItem;
+    destroy(): void;
+}
+export {};

package/@ones-editor/comments/src/comments-list/mobile-comments-list/group-item.d.ts

@@ -0,0 +1,30 @@
+import { TypedEmitter } from 'tiny-typed-emitter';
+import { OnesEditor, OnesEditorComment } from '../../../../../@ones-editor/core';
+import type { CommentWithChildren, OnesEditorCommentsProvider } from '../../types';
+import { MobileCommentChildrenList } from './children-list';
+interface MobileGroupItemEvents {
+    onSwitchGroup: (groupId: CommentWithChildren['groupId'], scrollTime: number) => void;
+    onReachBottom: () => void;
+    onReachTop: () => void;
+}
+export declare class MobileGroupItem extends TypedEmitter<MobileGroupItemEvents> {
+    private editor;
+    private commentsProvider;
+    comment: CommentWithChildren;
+    root: HTMLElement;
+    childrenList: MobileCommentChildrenList;
+    private mainItem;
+    private scroller;
+    constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider, comment: CommentWithChildren);
+    createRoot: () => HTMLDivElement;
+    private createMainItem;
+    private createChildrenList;
+    get commentCount(): number;
+    private handleTouchEnd;
+    refreshScroller: () => void;
+    handleUpdateChildComment(comment: OnesEditorComment): void;
+    handleUpdateMainComment(comment: OnesEditorComment): void;
+    deleteMainComment(commentId: OnesEditorComment['id']): void;
+    destroy(): void;
+}
+export {};

package/@ones-editor/comments/src/comments-list/mobile-comments-list/group-list.d.ts

@@ -0,0 +1,29 @@
+import { OnesEditor, OnesEditorComment } from '../../../../../@ones-editor/core';
+import type { CommentWithChildren, OnesEditorCommentsProvider } from '../../types';
+import ListBase from '../list-base';
+import { MobileGroupItem } from './group-item';
+interface MobileCommentGroupListEvents {
+    onReachBottom: () => void;
+    onReachTop: () => void;
+}
+export declare class MobileGroupList extends ListBase<CommentWithChildren, MobileGroupItem, unknown, MobileCommentGroupListEvents> {
+    private scroller;
+    constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider, parent: HTMLElement, scrollElement: HTMLElement);
+    createItem(data: CommentWithChildren): MobileGroupItem;
+    insertItem(data: CommentWithChildren): MobileGroupItem | null;
+    deleteItem: (commonId: CommentWithChildren['id']) => boolean;
+    private setupGroupItem;
+    protected findInsertPos(data: CommentWithChildren): number;
+    private handleReachBottom;
+    private handleReachTop;
+    private scrollToGroup;
+    setActiveItem(groupId: CommentWithChildren['groupId']): void;
+    findGroupItem: (groupId: string) => MobileGroupItem | undefined;
+    handleCreateComment(comment: OnesEditorComment, local: boolean): void;
+    handleDeleteComment(commentId: string): void;
+    handleUpdateComment(comment: OnesEditorComment): void;
+    handleDocChanged: () => void;
+    private updateComments;
+    destroy(): void;
+}
+export {};

package/@ones-editor/comments/src/comments-list/mobile-comments-list/index.d.ts

@@ -0,0 +1 @@
+export { MobileCommentsList } from './mobile-comments-list';

package/@ones-editor/comments/src/comments-list/mobile-comments-list/mobile-comments-list.d.ts

@@ -0,0 +1,28 @@
+import { OnesEditor } from '../../../../../@ones-editor/core';
+import { TypedEmitter } from 'tiny-typed-emitter';
+import type { OnesEditorCommentsEvents, OnesEditorCommentsProvider } from '../../types';
+interface MobileCommentsListEvents {
+    onCommentListClose: () => void;
+}
+export declare class MobileCommentsList extends TypedEmitter<MobileCommentsListEvents> implements OnesEditorCommentsEvents {
+    private editor;
+    private commentsProvider;
+    private root;
+    private list;
+    private mask;
+    private pullInfoContainer;
+    constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider, parent: HTMLElement);
+    onCreateComment(commentId: string, local: boolean): void;
+    onDeleteComment(commentId: string, local: boolean): void;
+    onUpdateComment(commentId: string, local: boolean): void;
+    private handleRootClick;
+    private createPullInfo;
+    private showPullInfo;
+    private hidePullInfo;
+    private handleReachBottom;
+    private handleReachTop;
+    show: (groupId?: string) => void;
+    hide: () => void;
+    destroy(): void;
+}
+export {};

package/@ones-editor/comments/src/constant/index.d.ts

@@ -14,4 +14,4 @@ export declare enum GroupItemActions {
 export declare const GROUP_ITEM_ACTION_MARK = "group-item-action";
 export declare const LAST_COMMENT_ITEM_MARK = "last-comment-item";
 export declare const DISABLED_ACTION_CLS = "disabled";
-export declare const HIDDEN_CLS = "hidden";
+export declare const SWITCH_SCROLL_TIME = 500;

package/@ones-editor/comments/src/index.d.ts

@@ -3,9 +3,9 @@ import './style.scss';
 import './locale';
 export * from './types';
 export { OnesEditorCommentsRender } from './comments-render';
-export { OnesEditorCommentInputHandler } from './comment-input-handler';
 export { OnesEditorCommentPlaceholderHandler } from './comment-placeholder-handler';
 export { OnesEditorComments };
 export type { CommentItem } from './comment-item';
 export type { CommentGroupItem } from './comments-list/group-item';
 export { removeCommentFromBlock } from './actions/remove-comment-from-block';
+export { editorAddComment } from './actions/editor-add-comment';

package/@ones-editor/comments/src/locale/en-us.d.ts

@@ -16,6 +16,7 @@ declare const _default: {
         isFirst: string;
         isLast: string;
         more: string;
+        comment: string;
     };
 };
 export default _default;

package/@ones-editor/comments/src/locale/ja-jp.d.ts

@@ -15,6 +15,7 @@ declare const _default: {
         replyTitle: string;
         isFirst: string;
         isLast: string;
+        comment: string;
     };
 };
 export default _default;

package/@ones-editor/comments/src/locale/zh-cn.d.ts

@@ -15,6 +15,7 @@ declare const _default: {
         replyTitle: string;
         isFirst: string;
         isLast: string;
+        comment: string;
     };
 };
 export default _default;

package/@ones-editor/comments/src/text-comments/comments-command-provider.d.ts

@@ -1,9 +1,11 @@
 import { BlockCommandItem, BlockCommandItemWithSource, BlockElement, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
 import { OnesEditorCommentsProvider } from '../types';
+import type { OnesEditorComments } from '../comments';
 export default class CommentsCommandProvider implements OnesEditorCommandProvider {
     private provider;
+    private editorComments;
     id: string;
-    constructor(provider: OnesEditorCommentsProvider);
+    constructor(provider: OnesEditorCommentsProvider, editorComments: OnesEditorComments);
     getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange): BlockCommandItem[];
     executeRangeCommand(editor: OnesEditor, range: SelectionRange, command: BlockCommandItemWithSource, params: CommandParams, result: CommandResult): boolean;
 }

package/@ones-editor/comments/src/types.d.ts

@@ -1,34 +1,28 @@
 import { DocObject, LocalDoc, OnesEditor, OnesEditorComment } from '../../../@ones-editor/core';
-import { AuthMessage } from '../../../@ones-editor/sharedb-doc';
-import type { CommentGroupItem } from './comments-list/group-item';
-import type { CommentItem } from './comment-item';
 export type CommentData = {
     [p in string]: unknown;
 };
+export interface OnesEditorCommentController {
+    showCommentList: () => void;
+}
+export type CommentRootType = keyof Pick<OnesEditorCommentOptions, 'container' | 'miniContainer' | 'mobileContainer'>;
 export interface OnesEditorCommentOptions {
-    hideHeader?: boolean;
+    controller: OnesEditorCommentController;
+    container?: HTMLElement;
+    miniContainer?: HTMLElement;
+    mobileContainer?: HTMLElement;
     disableReply?: boolean;
     disableEdit?: boolean;
+    pullThreshold?: number;
     onUpdateLayout?: (editor: OnesEditor, data: CommentData) => void;
+    onCommentCountChange?: (count: number) => void;
 }
 export interface OnesEditorCommentsEvents {
     onCreateComment: (commentId: string, local: boolean) => void;
     onDeleteComment: (commentId: string, local: boolean) => void;
     onUpdateComment: (commentId: string, local: boolean) => void;
 }
-export type CreateQuickReplyEditorOption = {
-    type: 'quick-reply';
-    groupItem: CommentGroupItem;
-};
-export type CreateCommentItemEditorOption = {
-    type: 'comment-item';
-    commentItem: CommentItem;
-    groupItem: CommentGroupItem;
-    comment: OnesEditorComment;
-};
-export type CreateCommentEditorOption = CreateQuickReplyEditorOption | CreateCommentItemEditorOption;
 export interface OnesEditorCommentsProvider {
-    getAuth: () => AuthMessage;
     getComments: () => OnesEditorComment[];
     getComment: (id: string) => OnesEditorComment;
     getCommentDoc: (commentId: string) => DocObject;
@@ -37,7 +31,7 @@ export interface OnesEditorCommentsProvider {
     localUpdateComment: (comment: OnesEditorComment, doc: DocObject) => void;
     addListener: (callback: OnesEditorCommentsEvents) => void;
     removeListener: (callback: OnesEditorCommentsEvents) => void;
-    createCommentEditor: (parent: HTMLElement, doc: LocalDoc, op: CreateCommentEditorOption) => OnesEditor;
+    createCommentEditor: (parent: HTMLElement, doc: LocalDoc) => OnesEditor;
 }
 export interface CommentWithChildren extends OnesEditorComment {
     children: OnesEditorComment[];

package/@ones-editor/core/src/core/converter/block-to-doc.d.ts

@@ -1,3 +1,3 @@
 import { DocObject } from '../doc';
 import { BlockElement, OnesEditor } from '../types';
-export declare function blockToDoc(editor: OnesEditor, block: BlockElement): DocObject;
+export declare function blockToDoc(editor: OnesEditor, block: BlockElement, ignoreLockInfo?: boolean): DocObject;

package/@ones-editor/core/src/core/converter/selected-block-to-doc.d.ts

@@ -1,3 +1,5 @@
 import { DocObject } from '../doc';
 import { OnesEditor, SelectedBlock } from '../types';
-export declare function selectedBlockToDoc(editor: OnesEditor, selectedBlock: SelectedBlock): DocObject;
+export declare function selectedBlockToDoc(editor: OnesEditor, selectedBlock: SelectedBlock, options?: {
+    ignoreLockInfo: boolean;
+}): DocObject;

package/@ones-editor/core/src/core/doc/doc.d.ts

@@ -179,15 +179,19 @@ export interface RecognizeLinkResult {
     providerName?: string;
     url: string;
 }
+export interface InsertBlockOptions {
+    noScroll?: boolean;
+}
+export type UpdateBlockOptions = InsertBlockOptions;
 export interface OnesEditorDoc {
     registerCallback: (callbacks: OnesEditorDocCallbacks) => void;
     unregisterCallback: (callbacks: OnesEditorDocCallbacks) => void;
     toJSON: () => DocObject;
     getContainerBlocks: (containerId: string) => DocBlock[];
     getBlockData: (containerId: string, blockIndex: number) => DocBlock;
-    localUpdateBlockText: (containerId: string, blockIndex: number, actions: DocBlockTextActions) => DocBlockText;
+    localUpdateBlockText: (containerId: string, blockIndex: number, actions: DocBlockTextActions, options?: UpdateBlockOptions) => DocBlockText;
     localUpdateBlockData: (containerId: string, blockIndex: number, delta: DocBlockDelta, newRange: OnesEditorDocRange) => DocBlock;
-    localInsertBlock: (containerId: string, blockIndex: number, data: DocBlock, newRange: OnesEditorDocRange) => DocBlock;
+    localInsertBlock: (containerId: string, blockIndex: number, data: DocBlock, newRange: OnesEditorDocRange, options?: InsertBlockOptions) => DocBlock;
     localDeleteBlock: (containerId: string, blockIndex: number, newRange: OnesEditorDocRange) => DocBlock;
     localInsertChildContainer: (containerId: string, blocks: DocBlock[]) => void;
     localDeleteChildContainers: (containerIds: string[]) => void;

package/@ones-editor/core/src/core/doc/rich-text/insert-text.d.ts

@@ -1,3 +1,4 @@
-import { DocBlockText, DocBlockTextActions, DocBlockTextAttributes } from '../doc';
+import { DocBlockText, DocBlockTextActions, DocBlockTextAttributes, DocBox, DocBlockTextOp } from '../doc';
 export declare function insertText(richText: DocBlockText, offset: number, text: string | DocBlockText, attributes: DocBlockTextAttributes | null): DocBlockText;
+export declare function createBoxOp(boxData: DocBox): DocBlockTextOp;
 export declare function createInsertOps(offset: number, text: string | DocBlockText, attributes: DocBlockTextAttributes | null): DocBlockTextActions;

package/@ones-editor/core/src/core/editor/actions/auto-insert-block.d.ts

@@ -1,3 +1,3 @@
-import { DocBlock, OnesEditorDocRange } from '../../doc';
+import { InsertBlockOptions, DocBlock, OnesEditorDocRange } from '../../doc';
 import { OnesEditor } from '../../types';
-export declare function editorAutoInsertBlock(editor: OnesEditor, blockData: DocBlock, containerId?: string, blockIndex?: number, newRange?: OnesEditorDocRange): import("../../types").BlockElement;
+export declare function editorAutoInsertBlock(editor: OnesEditor, blockData: DocBlock, containerId?: string, blockIndex?: number, newRange?: OnesEditorDocRange, insertBlockOptions?: InsertBlockOptions): import("../../types").BlockElement;

package/@ones-editor/core/src/core/editor/actions/break-text-block.d.ts

@@ -1,6 +1,8 @@
 import { BlockElement, BreakTextOptions, OnesEditor } from '../../types';
+import { DocBlockAttributes } from '../../doc';
 export interface BreakTextBlockResult {
     block: BlockElement;
     newBlock: BlockElement;
 }
+export declare function copyBlockAttributes(editor: OnesEditor, block: BlockElement): DocBlockAttributes;
 export declare function editorBreakTextBlock(editor: OnesEditor, block: BlockElement, offset: number, options?: BreakTextOptions): BreakTextBlockResult;