@ones-editor/editor 0.0.1

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

@@ -0,0 +1,21 @@
+import { OnesEditor, OnesEditorComment } from '../../../../@ones-editor/core';
+import { OnesEditorCommentsProvider } from '../types';
+import { CommentItem } from '../comment-item';
+import ListBase from './list-base';
+import type CommentGroupList from './group-list';
+import type { CommentGroupItem } from './group-item';
+interface CommentChildrenListOptions {
+    editor: OnesEditor;
+    commentsProvider: OnesEditorCommentsProvider;
+    comments: OnesEditorComment[];
+    parent: HTMLElement;
+    groupList: CommentGroupList;
+    groupItem: CommentGroupItem;
+}
+export default class CommentChildrenList extends ListBase<OnesEditorComment, CommentItem, CommentChildrenListOptions> {
+    constructor(options: CommentChildrenListOptions);
+    createItem(data: OnesEditorComment): CommentItem;
+    protected findInsertPos(): number;
+    destroy(): void;
+}
+export {};

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

@@ -0,0 +1,30 @@
+import { OnesEditor } from '../../../../@ones-editor/core';
+import { OnesEditorCommentsEvents, OnesEditorCommentsProvider } from '../types';
+import CommentGroupList from './group-list';
+export default class CommentsList implements OnesEditorCommentsEvents {
+    private editor;
+    private commentsProvider;
+    private root;
+    private header;
+    private groupsContainer;
+    private list;
+    constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider);
+    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;
+        openButton: HTMLButtonElement;
+    };
+    createList(): CommentGroupList;
+    openMiniComment: () => void;
+    hideMiniComment: () => void;
+    updateCommentCount: () => void;
+    handleActiveItemChanged: () => void;
+    handleItemLayoutUpdated: () => void;
+    handleItemCountClick: () => void;
+}

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

@@ -0,0 +1,42 @@
+import { TypedEmitter } from 'tiny-typed-emitter';
+import { OnesEditor, OnesEditorComment } from '../../../../@ones-editor/core';
+import type { CommentWithChildren, OnesEditorCommentsProvider } from '../types';
+import { CommentItem } from '../comment-item';
+import CommentChildrenList from './children-list';
+import { CommentQuickReply } from '../comment-quick-reply';
+import type CommentGroupList from './group-list';
+export interface CommentGroupItemEvents {
+    resize: () => void;
+}
+export declare class CommentGroupItem extends TypedEmitter<CommentGroupItemEvents> {
+    private editor;
+    private commentsProvider;
+    comment: CommentWithChildren;
+    private groupList;
+    root: HTMLDivElement;
+    private commentCountElement;
+    private header;
+    private mainItem;
+    childrenList: CommentChildrenList;
+    private resizeObserver;
+    quickReply: CommentQuickReply;
+    constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider, comment: CommentWithChildren, groupList: CommentGroupList);
+    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;
+    edit(): void;
+    destroy(): void;
+    private handleResize;
+}

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

@@ -0,0 +1,37 @@
+import { OnesEditor, OnesEditorComment } from '../../../../@ones-editor/core';
+import { CommentWithChildren, OnesEditorCommentsProvider } from '../types';
+import { CommentGroupItem } from './group-item';
+import ListBase from './list-base';
+import { CommentGroupItemHandlers } from './handler';
+export interface CommentGroupListEvents {
+    activeItemChanged: (index: number) => void;
+    itemLayoutUpdated: () => void;
+    itemCountClicked: () => void;
+    selectionOnComment: () => void;
+}
+export default class CommentGroupList extends ListBase<CommentWithChildren, CommentGroupItem, unknown, CommentGroupListEvents> {
+    groupItemHandlers: CommentGroupItemHandlers;
+    constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider, parent: HTMLElement);
+    destroy(): void;
+    updateItemsLayout(): void;
+    private bindEvents;
+    private unbindEvents;
+    protected createItem(data: CommentWithChildren, reason: 'init' | 'insert'): CommentGroupItem;
+    protected findInsertPos(data: CommentWithChildren): number;
+    insertItem(data: CommentWithChildren): CommentGroupItem | null;
+    setActiveItem(index: number): void;
+    get activeIndex(): number;
+    get activeItem(): CommentGroupItem | null;
+    findGroupItem: (groupId: string) => CommentGroupItem | undefined;
+    handleCreateComment(comment: OnesEditorComment, local: boolean): void;
+    handleDeleteComment(commentId: string): void;
+    handleUpdateComment(comment: OnesEditorComment): void;
+    handleContainerClick: (event: MouseEvent) => void;
+    handleSelectionChanged: () => void;
+    handleEditorResize: () => void;
+    handleDocChanged: () => void;
+    handleItemResize: () => void;
+    updateGroupItemSwitch: () => void;
+    updateAllGroupItemCount: () => void;
+    private updateComments;
+}

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

@@ -0,0 +1,23 @@
+import type { CommentGroupItem } from './group-item';
+import type CommentGroupList from './group-list';
+import type { OnesEditorCommentsProvider } from '../types';
+import type { CommentItem } from '../comment-item';
+export declare class CommentGroupItemHandlers {
+    private groupList;
+    private commentsProvider;
+    constructor(groupList: CommentGroupList, commentsProvider: OnesEditorCommentsProvider);
+    private handleSwitchUp;
+    private handleSwitchDown;
+    private handleQuickReply;
+    private handleQuickReplyOk;
+    private handleQuickReplyCancel;
+    private handleCommentItemReply;
+    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;
+    destroy(): void;
+}

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

@@ -0,0 +1,2 @@
+import CommentsList from './comments-list';
+export default CommentsList;

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

@@ -0,0 +1,20 @@
+import { TypedEmitter, ListenerSignature, DefaultListener } from 'tiny-typed-emitter';
+import { OnesEditor, OnesEditorComment } 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> {
+    protected editor: OnesEditor;
+    protected commentsProvider: OnesEditorCommentsProvider;
+    protected container: HTMLElement;
+    options: ListOptions;
+    protected _items: TItem[];
+    constructor(editor: OnesEditor, commentsProvider: OnesEditorCommentsProvider, container: HTMLElement, data: TData[], options: ListOptions);
+    get items(): TItem[];
+    private createList;
+    insertItem(data: TData): TItem | null;
+    deleteItem(commentId: string): boolean;
+    findItemIndex(commentId: string): number;
+    findItem(commentId: string): TItem | null;
+    destroy(): void;
+    protected abstract createItem(data: TData, reason: 'init' | 'insert'): TItem;
+    protected abstract findInsertPos(data: TData): number;
+}

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

@@ -0,0 +1,6 @@
+import { BlockElement, BlockPath, DocBlock, DocBlockTextAttributes, OnesEditor, OnesEditorBlockRenderer, OnesEditorBlockRenderResult } from '../../../../@ones-editor/core';
+export declare class OnesEditorCommentsRender implements OnesEditorBlockRenderer {
+    renderText(editor: OnesEditor, path: BlockPath, attributes: DocBlockTextAttributes): OnesEditorBlockRenderResult;
+    renderBlock(editor: OnesEditor, path: BlockPath, blockData: DocBlock): OnesEditorBlockRenderResult;
+    updateBlock(editor: OnesEditor, path: BlockPath, blockElement: BlockElement, blockData: DocBlock): void;
+}

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

@@ -0,0 +1,18 @@
+export declare enum GroupItemActions {
+    SwitchUp = "switch-up",
+    SwitchDown = "switch-down",
+    CommentItemReply = "comment-item-reply",
+    CommentItemMore = "comment-item-more",
+    CommentItemOk = "comment-item-ok",
+    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"
+}
+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";

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

@@ -0,0 +1,11 @@
+import { OnesEditorComments } from './comments';
+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';

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

@@ -0,0 +1,21 @@
+declare const _default: {
+    comment: {
+        count: string;
+        hide: string;
+        show: string;
+        reply: string;
+        quicklyReply: string;
+        send: string;
+        placeholder: string;
+        replyPlaceholder: string;
+        edit: string;
+        delete: string;
+        image: string;
+        sendTitle: string;
+        replyTitle: string;
+        isFirst: string;
+        isLast: string;
+        more: string;
+    };
+};
+export default _default;

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

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

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

@@ -0,0 +1,20 @@
+declare const _default: {
+    comment: {
+        count: string;
+        hide: string;
+        show: string;
+        reply: string;
+        quicklyReply: string;
+        send: string;
+        placeholder: string;
+        replyPlaceholder: string;
+        edit: string;
+        delete: string;
+        image: string;
+        sendTitle: string;
+        replyTitle: string;
+        isFirst: string;
+        isLast: string;
+    };
+};
+export default _default;

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

@@ -0,0 +1,20 @@
+declare const _default: {
+    comment: {
+        count: string;
+        hide: string;
+        show: string;
+        reply: string;
+        quicklyReply: string;
+        send: string;
+        placeholder: string;
+        replyPlaceholder: string;
+        edit: string;
+        delete: string;
+        image: string;
+        sendTitle: string;
+        replyTitle: string;
+        isFirst: string;
+        isLast: string;
+    };
+};
+export default _default;

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

@@ -0,0 +1,9 @@
+import { BlockCommandItem, BlockCommandItemWithSource, BlockElement, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+import { OnesEditorCommentsProvider } from '../types';
+export default class CommentsCommandProvider implements OnesEditorCommandProvider {
+    private provider;
+    id: string;
+    constructor(provider: OnesEditorCommentsProvider);
+    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

@@ -0,0 +1,49 @@
+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 OnesEditorCommentOptions {
+    hideHeader?: boolean;
+    disableReply?: boolean;
+    disableEdit?: boolean;
+    onUpdateLayout?: (editor: OnesEditor, data: CommentData) => 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;
+    localCreateComment: (comment: OnesEditorComment, doc: DocObject) => void;
+    localDeleteComment: (commentId: string) => void;
+    localUpdateComment: (comment: OnesEditorComment, doc: DocObject) => void;
+    addListener: (callback: OnesEditorCommentsEvents) => void;
+    removeListener: (callback: OnesEditorCommentsEvents) => void;
+    createCommentEditor: (parent: HTMLElement, doc: LocalDoc, op: CreateCommentEditorOption) => OnesEditor;
+}
+export interface CommentWithChildren extends OnesEditorComment {
+    children: OnesEditorComment[];
+}
+export interface ItemBase {
+    root: HTMLElement;
+    comment: OnesEditorComment;
+    destroy: () => void;
+}

package/@ones-editor/core/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@ones-editor/core",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "main": "./src/index.ts",
+  "devDependencies": {
+    "@types/events": "^3.0.0",
+    "@types/js-base64": "*",
+    "@types/lodash.clonedeep": "^4.5.6",
+    "@types/lodash.intersection": "^4.4.0",
+    "@types/lodash.isequal": "^4.5.5",
+    "@types/lodash.merge": "^4.6.7",
+    "@types/string-template": "^1.0.0"
+  },
+  "types": "src/index.d.ts"
+}

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

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

package/@ones-editor/core/src/core/block-renderers/block-renderers.d.ts

@@ -0,0 +1,11 @@
+import { DocBlock, DocBlockTextAttributes } from '../doc';
+import { BlockPath, OnesEditor, OnesEditorBlockRenderer, OnesEditorBlockRenderResult, OnesEditorBlockRenderers, BlockElement } from '../types';
+export declare class EditorBlockRenderers implements OnesEditorBlockRenderers {
+    private editor;
+    private renders;
+    constructor(editor: OnesEditor);
+    registerRender(render: OnesEditorBlockRenderer): void;
+    renderText(path: BlockPath, attributes: DocBlockTextAttributes): OnesEditorBlockRenderResult;
+    renderBlock(editor: OnesEditor, path: BlockPath, blockData: DocBlock): OnesEditorBlockRenderResult;
+    updateBlock(editor: OnesEditor, path: BlockPath, blockElement: BlockElement, blockData: DocBlock): void;
+}

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

@@ -0,0 +1,2 @@
+export { EditorBlockRenderers } from './block-renderers';
+export { StandardBlockRenderer } from './standard-block-render';

package/@ones-editor/core/src/core/block-renderers/standard-block-render.d.ts

@@ -0,0 +1,8 @@
+import AttributeMap from 'quill-delta/dist/AttributeMap';
+import { DocBlock } from '../doc';
+import { BlockElement, BlockPath, OnesEditor, OnesEditorBlockRenderer, OnesEditorBlockRenderResult } from '../types';
+export declare class StandardBlockRenderer implements OnesEditorBlockRenderer {
+    renderText(editor: OnesEditor, path: BlockPath, attributes: AttributeMap): OnesEditorBlockRenderResult;
+    renderBlock(editor: OnesEditor, path: BlockPath, blockData: DocBlock): OnesEditorBlockRenderResult;
+    updateBlock(editor: OnesEditor, path: BlockPath, blockElement: BlockElement, blockData: DocBlock): void;
+}

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

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

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

@@ -0,0 +1 @@
+export * from './create-block-anchor';

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

@@ -0,0 +1,2 @@
+import { BlockElement, OnesEditor, SimpleBlockPosition } from '../../types';
+export declare function getBlockCaretRect(editor: OnesEditor, block: BlockElement, pos: SimpleBlockPosition): DOMRect;

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

@@ -0,0 +1,5 @@
+import { BlockElement, ComplexKindBlock, OnesEditor, TextKindBlock } from '../../types';
+export declare function getBlockClass(editor: OnesEditor, block: BlockElement): import("../../types").Block;
+export declare function getTextBlockClass(editor: OnesEditor, block: BlockElement): TextKindBlock;
+export declare function getComplexBlockClass(editor: OnesEditor, block: BlockElement): ComplexKindBlock;
+export declare function getBlockClassByType(editor: OnesEditor, type: string): import("../../types").Block;

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

@@ -0,0 +1,34 @@
+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 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 getParentContainer(block: BlockElement): ContainerElement;
+export declare function getBlockContent(block: BlockElement): BlockContentElement;
+export declare function getBlockTools(block: BlockElement): BlockToolsElement;
+export declare function getExistsBlockTools(block: BlockElement): BlockToolsElement | null;
+export declare function getBlockBackground(block: BlockElement): BlockBackgroundElement;
+export declare function createBlockElement(editor: OnesEditor, path: BlockPath, data: DocBlock): BlockElement;
+export declare function createBlockContentElement<K extends keyof HTMLElementTagNameMap>(block: BlockElement | null, tagName: K): BlockContentElement;
+export declare function createBoxElement(data: DocBox): BoxElement;
+export declare function getBoxTypeFromElement(box: BoxElement): string;
+export declare function isBox(node: Node): boolean;
+export declare function getBoxId(box: BoxElement): string;
+export declare function getParentBox(node: Node): BoxElement | null;
+export declare function createBoxContentElement(boxElement: BoxElement): BoxContentElement;
+export declare function getBoxContent(box: BoxElement): BoxContentElement;
+export declare function createInsertionElement(type: string, id: string): InsertionElement;
+export declare function findInsertionById(editor: OnesEditor, id: string): InsertionElement | null;
+export declare function createInsertionContentElement(insertionElement: InsertionElement): InsertionContentElement;
+export declare function getInsertionContent(insertion: InsertionElement): InsertionContentElement;
+export declare function getPrevBlock(block: BlockElement): BlockElement | null;
+export declare function getNextBlock(block: BlockElement): BlockElement | null;
+export declare function getPrevVisibleBlock(block: BlockElement): BlockElement | null;
+export declare function getNextVisibleBlock(block: BlockElement): BlockElement | null;
+export declare function getBlockIndex(block: BlockElement): number;
+export declare function isInBlock(target: EventTarget | null): boolean;
+export declare function isInBlockTools(target: EventTarget | null): boolean;

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

@@ -0,0 +1,2 @@
+import { BlockElement, OnesEditor } from '../../types';
+export declare function getBlockOptions(editor: OnesEditor, block: BlockElement): import("../../types").BlockOptions;

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

@@ -0,0 +1,2 @@
+import { BlockElement, BlockPath } from '../../types';
+export declare function getBlockPath(block: BlockElement): BlockPath;

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

@@ -0,0 +1,4 @@
+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[];

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

@@ -0,0 +1,2 @@
+import { BlockElement, OnesEditor } from '../../types';
+export declare function isEmptyTextBlock(editor: OnesEditor, block: BlockElement): boolean;

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

@@ -0,0 +1,6 @@
+import { BlockElement, BlockKind, OnesEditor } from '../../types';
+export declare function isTextKindBlock(editor: OnesEditor, block: BlockElement): boolean;
+export declare function isTextKindBlockType(editor: OnesEditor, type: string): boolean;
+export declare function isComplexKindBlock(editor: OnesEditor, block: BlockElement): boolean;
+export declare function isSimpleBlock(editor: OnesEditor, block: BlockElement): boolean;
+export declare function getBlockKind(editor: OnesEditor, block: BlockElement): BlockKind;

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

@@ -0,0 +1,14 @@
+import { OnesEditor, BlockElement, BlockPosition, ConvertBlockResult, SelectionRange, BlockStyles } from '../../types';
+import { DocBlock, DocBlockAttributes } from '../../doc';
+export declare function getBlockTextLength(editor: OnesEditor, block: BlockElement): number;
+export declare function clearAllSelection(editor: OnesEditor): void;
+export declare function updateBlockSelection(editor: OnesEditor, block: BlockElement, from: BlockPosition, to: BlockPosition): void;
+export declare function getRootBlock(block: BlockElement): BlockElement;
+export declare function getBlockMinWidth(editor: OnesEditor, block: BlockElement): number | undefined;
+export declare function handleBlockElementUpdated(editor: OnesEditor, block: BlockElement, data: DocBlock): void;
+export declare function convertBlockFrom(editor: OnesEditor, block: BlockElement, type: string, options: {
+    offset: number;
+    data?: DocBlockAttributes;
+}): ConvertBlockResult | null;
+export declare function getBlockClientRects(editor: OnesEditor, block: BlockElement, range: SelectionRange): DOMRect[];
+export declare function getBlockStyles(editor: OnesEditor, block: BlockElement): BlockStyles;

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

@@ -0,0 +1,3 @@
+import { BlockElement, CommandItem, OnesEditor } from '../../types';
+export declare function executeEmbedBlockCommand(editor: OnesEditor, block: BlockElement, commandGroup: string, item: CommandItem): unknown;
+export declare function executeBlockCommand(editor: OnesEditor, block: BlockElement, commandGroup: string, item: CommandItem): unknown;

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

@@ -0,0 +1,11 @@
+export * from './block-caret';
+export * from './block-dom';
+export * from './block-type';
+export * from './block-text';
+export * from './block-class';
+export * from './block-wrapper';
+export * from './block-path';
+export * from './block-options';
+export * from './block-properties';
+export * from './insert-empty-block';
+export * from './execute-block-command';

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

@@ -0,0 +1,3 @@
+import { OnesEditor } from '../../types';
+export declare function insertEmptyEmbedBlock(editor: OnesEditor, embedType: string, containerId: string, blockIndex: number, data?: Record<string, unknown>): Promise<import("../../types").BlockElement | null>;
+export declare function insertEmptyBlock(editor: OnesEditor, type: string, containerId: string, blockIndex: number, data?: Record<string, unknown>): Promise<import("../../types").BlockElement | null> | null;

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

@@ -0,0 +1,6 @@
+import { BlockElement, OnesEditor, SelectedBlock } from '../../types';
+export type GetAllChildBlocksOptions = {
+    simpleBlockOnly?: boolean;
+};
+export declare function getAllChildBlocks(editor: OnesEditor, options?: GetAllChildBlocksOptions): BlockElement[];
+export declare function getAllSelectedBlocks(editor: OnesEditor, options?: GetAllChildBlocksOptions): SelectedBlock[];

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

@@ -0,0 +1,14 @@
+import { OnesEditor, BlockElement, BlockPosition, ContainerElement, ComplexBlockPosition } from '../../types';
+export declare function complexBlockGetAllChildContainers(editor: OnesEditor, block: BlockElement): 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 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[];
+export declare function complexBlockFindNearestChildBlock(editor: OnesEditor, complexBlock: BlockElement, x: number, y: number): BlockElement;
+export declare function complexBlockAdjustSelectionPos(editor: OnesEditor, complexBlock: BlockElement, anchor: ComplexBlockPosition, focus: ComplexBlockPosition): {
+    anchor: ComplexBlockPosition;
+    focus: ComplexBlockPosition;
+};

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

@@ -0,0 +1,2 @@
+export * from './complex-block-helper';
+export * from './child-blocks';

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

@@ -0,0 +1,13 @@
+import { DocBlock } from '../doc/doc';
+import { OnesEditor, Block, ContainerElement, BlockPath } from '../types';
+export default class EditorBlocks {
+    private editor;
+    private blocks;
+    constructor(editor: OnesEditor);
+    registerBlockClass(blockClass: Block): void;
+    getBlockClass(type: string): Block;
+    hasBlock(type: string): boolean;
+    createBlock(path: BlockPath, container: ContainerElement, block: DocBlock): import("../types").BlockElement;
+    forEach(callback: (blockClass: Block) => void): void;
+    private registerUnknownBlock;
+}

package/@ones-editor/core/src/core/blocks/embed-blocks/editor-embeds.d.ts

@@ -0,0 +1,10 @@
+import { BlockElement, Embed, OnesEditor } from '../../types';
+export default class EditorEmbeds {
+    private editor;
+    private objects;
+    constructor(editor: OnesEditor);
+    registerEmbedClass(embedClass: Embed): void;
+    getEmbedClass(type: string): Embed;
+    getEmbedClassFromBlock(block: BlockElement): Embed;
+    forEach(callback: (embedClass: Embed) => void): void;
+}

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

@@ -0,0 +1,3 @@
+import { BlockElement } from '../../../types';
+export declare function isEmbedBlock(block: BlockElement): boolean;
+export declare function getEmbedType(block: BlockElement): string;

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

@@ -0,0 +1,3 @@
+import { Block } from '../../../types';
+declare const EmbedBlock: Block;
+export default EmbedBlock;

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

@@ -0,0 +1,3 @@
+import { BlockElement, Embed, OnesEditor } from '../../../types';
+export declare function getEmbedClassFromBlock(editor: OnesEditor, block: BlockElement): Embed;
+export declare function getEmbedClassByType(editor: OnesEditor, type: string): Embed;

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

@@ -0,0 +1,3 @@
+import EmbedBlock from './embed-block';
+export * from './common';
+export { EmbedBlock };

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

@@ -0,0 +1,3 @@
+import EditorEmbeds from './editor-embeds';
+export * from './embed-block';
+export { EditorEmbeds };

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

@@ -0,0 +1,7 @@
+import EditorBlocks from './editor-blocks';
+export * from './common';
+export * from './embed-blocks';
+export * from './complex-blocks';
+export * from './block-anchor';
+export * from './text-blocks';
+export { EditorBlocks };