@ones-editor/editor 0.0.3-beta.1 → 0.0.3-beta.100

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

@@ -1,11 +1,14 @@
 import { OnesEditor } from '../../../../@ones-editor/core';
+import { TypedEmitter } from 'tiny-typed-emitter';
 import { OnesEditorCommentsEvents, OnesEditorCommentsProvider } from '../types';
 import CommentGroupList from './group-list';
-export default class CommentsList implements OnesEditorCommentsEvents {
+interface CommentsListEvents {
+    onSelectComment: () => void;
+}
+export default class CommentsList extends TypedEmitter<CommentsListEvents> implements OnesEditorCommentsEvents {
     private editor;
     private commentsProvider;
-    private root;
-    private header;
+    root: HTMLElement;
     private groupsContainer;
     private list;
     constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider);
@@ -14,17 +17,12 @@ export default class CommentsList implements OnesEditorCommentsEvents {
     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;
-        openButton: HTMLButtonElement;
-    };
     createList(): CommentGroupList;
-    openMiniComment: () => void;
-    hideMiniComment: () => void;
+    handleSelectionOnComment: () => void;
     updateCommentCount: () => void;
     handleActiveItemChanged: () => void;
     handleItemLayoutUpdated: () => void;
-    handleItemCountClick: () => void;
+    show(groupId?: string): void;
+    hide(): void;
 }
+export {};

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

@@ -14,7 +14,6 @@ export declare class CommentGroupItem extends TypedEmitter<CommentGroupItemEvent
     comment: CommentWithChildren;
     private groupList;
     root: HTMLDivElement;
-    private commentCountElement;
     private header;
     private mainItem;
     childrenList: CommentChildrenList;
@@ -24,18 +23,17 @@ export declare class CommentGroupItem extends TypedEmitter<CommentGroupItemEvent
     get commentCount(): number;
     private createRoot;
     private createQuickReply;
-    private createCountElement;
     private createHeader;
     private createItem;
     private createChildrenList;
     findCommentItem(commentId: string | null): CommentItem | null | undefined;
-    updateCommentItemCount: () => void;
     updateLastCommentItem: () => void;
     updateSwitchButton: () => void;
     handleCreateComment(comment: OnesEditorComment): CommentItem;
     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,8 +6,8 @@ import { CommentGroupItemHandlers } from './handler';
 export interface CommentGroupListEvents {
     activeItemChanged: (index: number) => void;
     itemLayoutUpdated: () => void;
-    itemCountClicked: () => void;
     selectionOnComment: () => void;
+    commentCountChanged: () => void;
 }
 export default class CommentGroupList extends ListBase<CommentWithChildren, CommentGroupItem, unknown, CommentGroupListEvents> {
     groupItemHandlers: CommentGroupItemHandlers;
@@ -18,7 +18,9 @@ export default class CommentGroupList extends ListBase<CommentWithChildren, Comm
     private unbindEvents;
     protected createItem(data: CommentWithChildren, reason: 'init' | 'insert'): CommentGroupItem;
     protected findInsertPos(data: CommentWithChildren): number;
-    insertItem(data: CommentWithChildren): CommentGroupItem | null;
+    insertItem(data: CommentWithChildren, options?: {
+        active: boolean;
+    }): CommentGroupItem | null;
     setActiveItem(index: number): void;
     get activeIndex(): number;
     get activeItem(): CommentGroupItem | null;
@@ -31,7 +33,7 @@ export default class CommentGroupList extends ListBase<CommentWithChildren, Comm
     handleEditorResize: () => void;
     handleDocChanged: () => void;
     handleItemResize: () => void;
+    handleScroll: (event: WheelEvent) => void;
     updateGroupItemSwitch: () => void;
-    updateAllGroupItemCount: () => void;
     private updateComments;
 }

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

@@ -15,7 +15,6 @@ export declare class CommentGroupItemHandlers {
     private handleCommentItemMore;
     private handleCommentItemOk;
     private handleCommentItemCancel;
-    private handleCommentItemCountClick;
     handleCommentItemEdit: (commentItem: CommentItem) => void;
     handleCommentItemDelete: (commentItem: CommentItem) => void;
     execute: (element: HTMLElement, groupItem: CommentGroupItem, commentId: string | null, itemIndex: number) => void;

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

@@ -1,2 +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/list-base.d.ts

@@ -1,7 +1,7 @@
 import { TypedEmitter, ListenerSignature, DefaultListener } from 'tiny-typed-emitter';
-import { OnesEditor, OnesEditorComment } from '../../../../@ones-editor/core';
+import { OnesEditor } from '../../../../@ones-editor/core';
 import { OnesEditorCommentsProvider, ItemBase } from '../types';
-export default abstract class ListBase<TData extends OnesEditorComment, TItem extends ItemBase, ListOptions = unknown, TEvents extends ListenerSignature<TEvents> = DefaultListener> extends TypedEmitter<TEvents> {
+export default abstract class ListBase<TData, TItem extends ItemBase, ListOptions = unknown, TEvents extends ListenerSignature<TEvents> = DefaultListener> extends TypedEmitter<TEvents> {
     protected editor: OnesEditor;
     protected commentsProvider: OnesEditorCommentsProvider;
     protected container: HTMLElement;
@@ -10,6 +10,7 @@ export default abstract class ListBase<TData extends OnesEditorComment, TItem ex
     constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider, container: HTMLElement, data: TData[], options: ListOptions);
     get items(): TItem[];
     private createList;
+    protected reloadList(data: TData[]): void;
     insertItem(data: TData): TItem | null;
     deleteItem(commentId: string): boolean;
     findItemIndex(commentId: string): number;

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

@@ -0,0 +1,16 @@
+import { OnesEditor, OnesEditorComment } from '../../../../../@ones-editor/core';
+import { MiniCommentGroup } from '../../types';
+export declare class MiniGroupItem {
+    private editor;
+    private commentGroup;
+    root: HTMLElement;
+    blockId: string;
+    comment: OnesEditorComment;
+    private miniCommentItem;
+    constructor(editor: OnesEditor, commentGroup: MiniCommentGroup);
+    private getBlockId;
+    private updateCommentItemCount;
+    get commentCount(): number;
+    alignToBlock(): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,16 @@
+import { OnesEditor, OnesEditorComment } from '../../../../../@ones-editor/core';
+import { MiniCommentGroup, OnesEditorCommentsProvider } from '../../types';
+import ListBase from '../list-base';
+import { MiniGroupItem } from './group-item';
+export declare class MiniGroupList extends ListBase<MiniCommentGroup, MiniGroupItem, unknown> {
+    protected editor: OnesEditor;
+    protected commentsProvider: OnesEditorCommentsProvider;
+    constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider, parent: HTMLElement);
+    protected createItem(data: MiniCommentGroup): MiniGroupItem;
+    protected findInsertPos(): number;
+    private handleDocChanged;
+    private updateMiniCommentsGroup;
+    handleCreateComment(comment: OnesEditorComment, local: boolean): void;
+    handleDeleteComment(commentId: string): void;
+    destroy(): void;
+}

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

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

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

@@ -0,0 +1,24 @@
+import { OnesEditor } from '../../../../../@ones-editor/core';
+import { TypedEmitter } from 'tiny-typed-emitter';
+import { OnesEditorCommentsEvents, OnesEditorCommentsProvider } from '../..';
+import { MiniGroupList } from './group-list';
+interface MiniCommentsListEvents {
+    onMiniCommentClose: () => void;
+    onItemClick: (groupId: string) => void;
+}
+export declare class MiniCommentsList extends TypedEmitter<MiniCommentsListEvents> implements OnesEditorCommentsEvents {
+    private editor;
+    private commentsProvider;
+    list: MiniGroupList;
+    root: HTMLElement;
+    constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider);
+    onCreateComment(commentId: string, local: boolean): void;
+    onDeleteComment(commentId: string, local: boolean): void;
+    onUpdateComment(commentId: string, local: boolean): void;
+    private createList;
+    private handleListContainerClick;
+    show(): void;
+    hide(): void;
+    destroy(): void;
+}
+export {};

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,30 @@
+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);
+    refreshScroller: () => void;
+    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,30 @@
+import { OnesEditor } from '../../../../../@ones-editor/core';
+import { TypedEmitter } from 'tiny-typed-emitter';
+import type { OnesEditorCommentsEvents, OnesEditorCommentsProvider } from '../../types';
+import { MobileGroupList } from './group-list';
+interface MobileCommentsListEvents {
+    onCommentListClose: () => void;
+}
+export declare class MobileCommentsList extends TypedEmitter<MobileCommentsListEvents> implements OnesEditorCommentsEvents {
+    private editor;
+    private commentsProvider;
+    root: HTMLDivElement;
+    list: MobileGroupList;
+    private mask;
+    private pullInfoContainer;
+    constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider);
+    onCreateComment(commentId: string, local: boolean): void;
+    onDeleteComment(commentId: string, local: boolean): void;
+    onUpdateComment(commentId: string, local: boolean): void;
+    private get commentOptions();
+    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

@@ -7,7 +7,6 @@ export declare enum GroupItemActions {
     CommentItemCancel = "comment-item-cancel",
     CommentItemDelete = "comment-item-delete",
     CommentItemEdit = "comment-item-edit",
-    CommentItemCountClick = "comment-item-count-click",
     QuickReply = "quick-reply",
     QuickReplyOk = "quick-reply-ok",
     QuickReplyCancel = "quick-reply-cancel"
@@ -15,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,9 @@ declare const _default: {
         isFirst: string;
         isLast: string;
         more: string;
+        comment: string;
+        command: string;
+        quickMenuCommand: 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,9 @@ declare const _default: {
         replyTitle: string;
         isFirst: string;
         isLast: string;
+        comment: string;
+        command: string;
+        quickMenuCommand: 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,30 @@
 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 CommentRoot = {
+    container?: HTMLElement;
+    miniContainer?: HTMLElement;
+    mobileContainer?: HTMLElement;
+};
 export interface OnesEditorCommentOptions {
-    hideHeader?: boolean;
+    controller: OnesEditorCommentController;
     disableReply?: boolean;
     disableEdit?: boolean;
+    pullThreshold?: number;
     onUpdateLayout?: (editor: OnesEditor, data: CommentData) => void;
+    onCommentCountChange?: (count: number) => void;
+    onCommentEditorClick?: (editor: OnesEditor, event: MouseEvent) => 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 +33,8 @@ 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;
+    allowEdit: (comment: OnesEditorComment) => boolean;
 }
 export interface CommentWithChildren extends OnesEditorComment {
     children: OnesEditorComment[];
@@ -47,3 +44,15 @@ export interface ItemBase {
     comment: OnesEditorComment;
     destroy: () => void;
 }
+export type BlockId = string;
+export type CommentIds = Set<string>;
+export type MiniCommentGroupsMap = Map<BlockId, {
+    firstComment: OnesEditorComment;
+    commentIds: CommentIds;
+}>;
+export interface MiniCommentGroup {
+    blockId: BlockId;
+    firstComment: OnesEditorComment;
+    commentIds: CommentIds;
+}
+export type MiniCommentGroups = MiniCommentGroup[];

package/@ones-editor/core/src/common/index.d.ts

@@ -1,6 +1,6 @@
 import genId from '../utils/gen-id';
 import SimpleCache from '../utils/simple-cache';
-import { getLogger, chalk } from '../utils/logger';
+import { getLogger } from '../utils/logger';
 export { genId };
 export { SimpleCache };
-export { getLogger, chalk };
+export { getLogger };

package/@ones-editor/core/src/core/blocks/block-anchor/create-block-anchor.d.ts

@@ -1,3 +1,4 @@
 import { BlockElement, OnesEditor } from '../../types';
 import './anchor.scss';
 export declare function createBlockAnchor(editor: OnesEditor, block: BlockElement, id: string, refClientRect?: DOMRect): HTMLElement;
+export declare function createBlockCaretAnchor(editor: OnesEditor, block: BlockElement, offset: number, id: string): HTMLElement;

package/@ones-editor/core/src/core/blocks/common/block-dom.d.ts

@@ -1,12 +1,14 @@
 import { DocBlock, DocBox } from '../../doc';
 import { BlockBackgroundElement, BlockContentElement, BlockElement, BlockPath, BlockToolsElement, BoxContentElement, BoxElement, ContainerElement, InsertionContentElement, InsertionElement, OnesEditor } from '../../types';
 export declare function isBlock(node: Node): node is BlockElement;
+export declare function isBlockTools(node: Node): boolean;
 export declare function hideBlock(block: BlockElement): void;
 export declare function showBlock(block: BlockElement): void;
 export declare function isVisibleBlock(block: BlockElement): boolean;
 export declare function getBlockId(block: BlockElement): string;
 export declare function getBlockType(block: BlockElement): string;
 export declare function getParentBlock(node: Node): BlockElement | null;
+export declare function getParentBlockExcludeSelf(node: Node): BlockElement | null;
 export declare function getParentContainer(block: BlockElement): ContainerElement;
 export declare function getBlockContent(block: BlockElement): BlockContentElement;
 export declare function getBlockTools(block: BlockElement): BlockToolsElement;

package/@ones-editor/core/src/core/blocks/common/block-properties.d.ts

@@ -1,4 +1,10 @@
 import { BlockCommands, BlockElement, OnesEditor } from '../../types';
 export declare function getBlockProperties(editor: OnesEditor, block: BlockElement): import("../../types").BlockProperties | undefined;
 export declare function getBlockCommandsWithHook(editor: OnesEditor, block: BlockElement): Record<string, BlockCommands>;
-export declare function getSpecialBlockCommands(editor: OnesEditor, block: BlockElement, group: string): import("../../types").CommandItem[];
+export declare function getSpecialBlockCommands(editor: OnesEditor, blockElement: BlockElement, group: string): {
+    element: import("../../types").BlockContentElement;
+    commands: import("../../types").CommandItem[];
+} | {
+    element: null;
+    commands: never[];
+};

package/@ones-editor/core/src/core/blocks/complex-blocks/complex-block-helper.d.ts

@@ -1,9 +1,9 @@
-import { OnesEditor, BlockElement, BlockPosition, ContainerElement, ComplexBlockPosition } from '../../types';
-export declare function complexBlockGetAllChildContainers(editor: OnesEditor, block: BlockElement): ContainerElement[];
+import { OnesEditor, BlockElement, BlockPosition, ContainerElement, ComplexBlockPosition, GetChildContainerOptions } from '../../types';
+export declare function complexBlockGetAllChildContainers(editor: OnesEditor, block: BlockElement, options?: GetChildContainerOptions): ContainerElement[];
 export declare function complexBlockGetSelectedContainers(editor: OnesEditor, block: BlockElement, start: BlockPosition, end: BlockPosition): ContainerElement[];
 export declare function isFirstChildBlockInComplexBlock(editor: OnesEditor, childBlock: BlockElement): boolean;
-export declare function complexBlockGeFirstSimpleChild(editor: OnesEditor, complexBlock: BlockElement): BlockElement | null;
-export declare function complexBlockGetLastSimpleChild(editor: OnesEditor, complexBlock: BlockElement): BlockElement | null;
+export declare function complexBlockGeFirstSimpleChild(editor: OnesEditor, complexBlock: BlockElement, options?: GetChildContainerOptions): BlockElement | null;
+export declare function complexBlockGetLastSimpleChild(editor: OnesEditor, complexBlock: BlockElement, options?: GetChildContainerOptions): BlockElement | null;
 export declare function findPrevSimpleBlockBeforeChildContainer(editor: OnesEditor, childContainer: ContainerElement): BlockElement | null;
 export declare function complexBlockGetTopChildContainers(editor: OnesEditor, complexBlock: BlockElement): ContainerElement[];
 export declare function complexBlockGetBottomChildContainers(editor: OnesEditor, complexBlock: BlockElement): ContainerElement[];

package/@ones-editor/core/src/core/blocks/text-blocks/index.d.ts

@@ -1,4 +1,5 @@
 import TextBlock, { updateTextBlockContent } from './text-block';
 export * from './base/child';
 export * from './base/text-offset';
+export * from './base/block-text';
 export { TextBlock, updateTextBlockContent, };

package/@ones-editor/core/src/core/blocks/text-blocks/text-block/to-markdown.d.ts

@@ -0,0 +1,3 @@
+import { DocBlock, DocObject } from '../../../doc';
+import { OnesEditor } from '../../../types';
+export declare function textBlockToMarkdown(editor: OnesEditor, blockData: DocBlock, doc: DocObject): string;

package/@ones-editor/core/src/core/blocks/text-blocks/text-block/to-plain-html.d.ts

@@ -0,0 +1,3 @@
+import { DocBlockText, DocObject } from '../../../doc';
+import { OnesEditor } from '../../../types';
+export declare function textBlockToHtml(editor: OnesEditor, ops: DocBlockText, doc: DocObject): string;

package/@ones-editor/core/src/core/blocks/text-blocks/text-block/to-plain-text.d.ts

@@ -0,0 +1,3 @@
+import { DocBlockText, DocObject } from '../../../doc';
+import { OnesEditor } from '../../../types';
+export declare function textBlockToText(editor: OnesEditor, ops: DocBlockText, doc: DocObject): string;

package/@ones-editor/core/src/core/composition/clipboard/copy.d.ts

@@ -1,7 +1,8 @@
 import { DocObject } from '../../doc';
 import { BlockElement, OnesEditor } from '../../types';
-export declare function docToPlainText(editor: OnesEditor, doc: DocObject): string;
+export declare function injectDocToHtmlFragment(htmlFragment: string, doc: DocObject): string;
 export declare function addMetaToDoc(editor: OnesEditor, doc: DocObject): void;
-export declare function editorCopy(editor: OnesEditor, event: ClipboardEvent): void;
+export type BeforeCopyCallback = (editor: OnesEditor, event: ClipboardEvent, doc: DocObject) => DocObject | boolean | undefined;
+export declare function editorCopy(editor: OnesEditor, event: ClipboardEvent, beforeCopy?: BeforeCopyCallback): void;
 export declare function editorCopyWithoutEvent(editor: OnesEditor): void;
 export declare function editorCopyBlock(editor: OnesEditor, block: BlockElement): Promise<boolean>;

package/@ones-editor/core/src/core/composition/clipboard/cut.d.ts

@@ -1,2 +1,2 @@
 import { OnesEditor } from '../../types';
-export declare function editorCut(editor: OnesEditor): boolean;
+export declare function editorCut(editor: OnesEditor, event: ClipboardEvent): boolean;

package/@ones-editor/core/src/core/composition/clipboard/paste.d.ts

@@ -1,4 +1,4 @@
-import { OnesEditor, OnesEditorDocs } from '../../types';
+import { CloneBlockResultInfo, OnesEditor, OnesEditorDocs } from '../../types';
 import { DocObject } from '../../doc';
-export declare function editorInsertDocWithResources(editor: OnesEditor, doc: DocObject): Promise<void>;
+export declare function editorInsertDocWithResources(editor: OnesEditor, doc: DocObject, cloneDocResult?: CloneBlockResultInfo): Promise<void>;
 export declare function getDocFromDocs(docs: OnesEditorDocs): DocObject | null;

package/@ones-editor/core/src/core/composition/editor-input.d.ts

@@ -10,6 +10,9 @@ export interface EditorInputCallbacks {
     onFocus: () => void;
     onBlur: () => void;
     onPaste: (event: ClipboardEvent) => void;
+    onPasteText: (text: string) => void;
+    onCopy: (event: ClipboardEvent) => void;
+    onCut: (event: ClipboardEvent) => void;
     addHandler: (handler: OnesEditorInputHandler) => void;
     removeHandler: (handler: OnesEditorInputHandler) => void;
     defaultInsertText: (editor: OnesEditor, containerId: string, blockIndex: number, offset: number, text: string) => void;
@@ -36,6 +39,7 @@ export declare class EditorInput implements OnesEditorInput {
     handleCopy: (event: ClipboardEvent) => void;
     handleCut: (event: ClipboardEvent) => void;
     handlePaste: (event: ClipboardEvent) => void;
+    handlePasteText: (text: string) => void;
     handleChanged(action: OnesEditorUndoAction): void;
     handleRemoteChanged(type: RemoteChangeType): void;
     addHandler(handler: OnesEditorInputHandler): void;

package/@ones-editor/core/src/core/composition/index.d.ts

@@ -1 +1 @@
-export { editorCopyBlock } from './clipboard/copy';
+export { editorCopyBlock, addMetaToDoc, injectDocToHtmlFragment } from './clipboard/copy';

package/@ones-editor/core/src/core/containers/root-container.d.ts

@@ -1,4 +1,4 @@
-import { OnesEditor, ContainerElement } from '../types';
+import { OnesEditor, ContainerElement, BlockElement } from '../types';
 export declare class RootContainer {
     private editor;
     rootContainer: ContainerElement;
@@ -10,6 +10,7 @@ export declare class RootContainer {
     handleContextMenu: (event: Event) => void;
     handleResize: () => void;
     handleClick: (event: MouseEvent) => void;
+    handleBlockClick: (event: MouseEvent, block: BlockElement, elem: Element) => void;
     handleDblClick: (event: MouseEvent) => void;
     handleMouseDown: (event: MouseEvent) => void;
     handleMouseMove: (event: MouseEvent) => void;

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

@@ -1,3 +1,3 @@
 import { DocBlock, DocObject } from '../doc';
-import { OnesEditor } from '../types';
-export declare function blockToHtml(editor: OnesEditor, blockData: DocBlock, doc: DocObject): string;
+import { BlockPath, OnesEditor } from '../types';
+export declare function blockToHtml(editor: OnesEditor, blockData: DocBlock, doc: DocObject, path: BlockPath): string;

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

@@ -1,3 +1,3 @@
 import { DocBlock, DocObject } from '../doc';
-import { OnesEditor } from '../types';
-export declare function blockToMarkdown(editor: OnesEditor, blockData: DocBlock, doc: DocObject): string;
+import { BlockPath, OnesEditor } from '../types';
+export declare function blockToMarkdown(editor: OnesEditor, blockData: DocBlock, doc: DocObject, path: BlockPath): string;

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

@@ -1,3 +1,3 @@
 import { DocBlock, DocObject } from '../doc';
-import { OnesEditor } from '../types';
-export declare function blockToText(editor: OnesEditor, blockData: DocBlock, doc: DocObject): string;
+import { BlockPath, OnesEditor } from '../types';
+export declare function blockToText(editor: OnesEditor, blockData: DocBlock, doc: DocObject, path: BlockPath): string;