refactor: recode html2block

libs/components/editor-core/src/editor/clipboard/clipboard-parse.ts

@@ -1,134 +0,0 @@
-import { Protocol, BlockFlavorKeys } from '@toeverything/datasource/db-service';
-import { Editor } from '../editor';
-import { ClipBlockInfo } from './types';
-
-export default class ClipboardParse {
-    private editor: Editor;
-    private static block_types: BlockFlavorKeys[] = [
-        Protocol.Block.Type.page,
-        Protocol.Block.Type.reference,
-        Protocol.Block.Type.heading1,
-        Protocol.Block.Type.heading2,
-        Protocol.Block.Type.heading3,
-        Protocol.Block.Type.quote,
-        Protocol.Block.Type.todo,
-        Protocol.Block.Type.code,
-        Protocol.Block.Type.text,
-        Protocol.Block.Type.toc,
-        Protocol.Block.Type.file,
-        Protocol.Block.Type.image,
-        Protocol.Block.Type.divider,
-        Protocol.Block.Type.callout,
-        Protocol.Block.Type.youtube,
-        Protocol.Block.Type.figma,
-        Protocol.Block.Type.group,
-        Protocol.Block.Type.embedLink,
-        Protocol.Block.Type.numbered,
-        Protocol.Block.Type.bullet,
-    ];
-    private static break_flags: Set<string> = new Set([
-        'BLOCKQUOTE',
-        'BODY',
-        'CENTER',
-        'DD',
-        'DIR',
-        'DIV',
-        'DL',
-        'DT',
-        'FORM',
-        'H1',
-        'H2',
-        'H3',
-        'H4',
-        'H5',
-        'H6',
-        'HEAD',
-        'HTML',
-        'ISINDEX',
-        'MENU',
-        'NOFRAMES',
-        'P',
-        'PRE',
-        'TABLE',
-        'TD',
-        'TH',
-        'TITLE',
-        'TR',
-    ]);
-
-    constructor(editor: Editor) {
-        this.editor = editor;
-        // this.generate_html = this.generate_html.bind(this);
-        this.parse_dom = this.parse_dom.bind(this);
-    }
-    // TODO: escape
-    public text2blocks(clipData: string): ClipBlockInfo[] {
-        return (clipData || '').split('\n').map((str: string) => {
-            const block_info: ClipBlockInfo = {
-                type: 'text',
-                properties: {
-                    text: { value: [{ text: str }] },
-                },
-                children: [] as ClipBlockInfo[],
-            };
-            return block_info;
-        });
-    }
-
-    public html2blocks(clipData: string): ClipBlockInfo[] {
-        return this.common_html2blocks(clipData);
-    }
-
-    private common_html2blocks(clipData: string): ClipBlockInfo[] {
-        const html_el = document.createElement('html');
-        html_el.innerHTML = clipData;
-        return this.parse_dom(html_el);
-    }
-
-    // tTODO:odo escape
-    private parse_dom(el: Element): ClipBlockInfo[] {
-        for (let i = 0; i < ClipboardParse.block_types.length; i++) {
-            const block_utils = this.editor.getView(
-                ClipboardParse.block_types[i]
-            );
-            const blocks = block_utils?.html2block?.(el, this.parse_dom);
-
-            if (blocks) {
-                return blocks;
-            }
-        }
-        const blocks: ClipBlockInfo[] = [];
-        // blocks = DefaultBlockParse.html2block(el);
-        for (let i = 0; i < el.childNodes.length; i++) {
-            const child = el.childNodes[i];
-            const last_block_info =
-                blocks.length === 0 ? null : blocks[blocks.length - 1];
-            let blocks_info = this.parse_dom(child as Element);
-            if (
-                last_block_info &&
-                last_block_info.type === 'text' &&
-                !ClipboardParse.break_flags.has((child as Element).tagName)
-            ) {
-                const texts = last_block_info.properties?.text?.value || [];
-                let j = 0;
-                for (; j < blocks_info.length; j++) {
-                    const block = blocks_info[j];
-                    if (block.type === 'text') {
-                        const block_texts = block.properties.text.value;
-                        texts.push(...block_texts);
-                    }
-                }
-                last_block_info.properties = {
-                    text: { value: texts },
-                };
-                blocks_info = blocks_info.slice(j);
-            }
-            blocks.push(...blocks_info);
-        }
-        return blocks;
-    }
-
-    public dispose() {
-        this.editor = null;
-    }
-}

libs/components/editor-core/src/editor/clipboard/clipboard.ts

@@ -3,29 +3,21 @@ import { HookType } from '@toeverything/components/editor-core';
 import { Editor } from '../editor';
 import { Copy } from './copy';
 import { Paste } from './paste';
-import ClipboardParse from './clipboard-parse';
-import { MarkdownParser } from './markdown-parse';
+
 import { ClipboardUtils } from './clipboardUtils';
 
 export class Clipboard {
     private _clipboardEventDispatcher: ClipboardEventDispatcher;
     private _copy: Copy;
     private _paste: Paste;
-    private _clipboardParse: ClipboardParse;
-    private _markdownParse: MarkdownParser;
+    private readonly _supportMarkdownPaste = true;
     public clipboardUtils: ClipboardUtils;
 
     constructor(editor: Editor, clipboardTarget: HTMLElement) {
-        this._clipboardParse = new ClipboardParse(editor);
-        this._markdownParse = new MarkdownParser();
         this.clipboardUtils = new ClipboardUtils(editor);
         this._copy = new Copy(editor);
 
-        this._paste = new Paste(
-            editor,
-            this._clipboardParse,
-            this._markdownParse
-        );
+        this._paste = new Paste(editor, this._supportMarkdownPaste);
 
         this._clipboardEventDispatcher = new ClipboardEventDispatcher(
             editor,

libs/components/editor-core/src/editor/clipboard/clipboardUtils.ts

@@ -6,6 +6,7 @@ import {
 } from '@toeverything/components/editor-core';
 import { ClipBlockInfo, OFFICE_CLIPBOARD_MIMETYPE } from './types';
 import { Clip } from './clip';
+import { commonHTML2Block, commonHTML2Text } from './utils';
 
 export class ClipboardUtils {
     private _editor: Editor;
@@ -146,6 +147,65 @@ export class ClipboardUtils {
         ).join('');
     }
 
+    async convertHTMLString2Blocks(html: string) {
+        const htmlEl = document.createElement('html');
+        htmlEl.innerHTML = html;
+        htmlEl.querySelector('head')?.remove();
+
+        return this.convertHtml2Block(htmlEl);
+    }
+    async convertHtml2Block(element: Element): Promise<ClipBlockInfo[]> {
+        const editableViews = this._editor.getEditableViews();
+        // 如果block能够捕捉htmlElement则返回block的html2block
+        const [clipBlockInfos] = (
+            await Promise.all(
+                editableViews.map(editableView => {
+                    return editableView?.html2block2?.({
+                        editor: this._editor,
+                        element: element,
+                    });
+                })
+            )
+        ).filter(v => v && v.length);
+
+        if (clipBlockInfos) {
+            return clipBlockInfos;
+        }
+        return (
+            await Promise.all(
+                Array.from(element.children).map(async childElement => {
+                    const clipBlockInfos = await this.convertHtml2Block(
+                        childElement
+                    );
+
+                    if (clipBlockInfos && clipBlockInfos.length) {
+                        return clipBlockInfos;
+                    }
+
+                    return this.commonHTML2Block(childElement);
+                })
+            )
+        )
+            .flat()
+            .filter(v => v);
+    }
+
+    commonHTML2Block = commonHTML2Block;
+
+    commonHTML2Text = commonHTML2Text;
+
+    textToBlock = (clipData: string = ''): ClipBlockInfo[] => {
+        return clipData.split('\n').map((str: string) => {
+            return {
+                type: 'text',
+                properties: {
+                    text: { value: [{ text: str }] },
+                },
+                children: [],
+            };
+        });
+    };
+
     async page2html() {
         const rootBlockId = this._editor.getRootBlockId();
         if (!rootBlockId) {

libs/components/editor-core/src/editor/clipboard/copy.ts

@@ -2,15 +2,12 @@ import { Editor } from '../editor';
 import { SelectInfo } from '../selection';
 import { OFFICE_CLIPBOARD_MIMETYPE } from './types';
 import { Clip } from './clip';
-import ClipboardParse from './clipboard-parse';
 import { ClipboardUtils } from './clipboardUtils';
 class Copy {
     private _editor: Editor;
-    private _clipboardParse: ClipboardParse;
     private _utils: ClipboardUtils;
     constructor(editor: Editor) {
         this._editor = editor;
-        this._clipboardParse = new ClipboardParse(editor);
         this._utils = new ClipboardUtils(editor);
         this.handleCopy = this.handleCopy.bind(this);
     }
@@ -53,9 +50,6 @@ class Copy {
         const htmlClip = await this._getHtmlClip();
 
         clips.push(htmlClip);
-        // const htmlClip = await this._clipboardParse.generateHtml();
-        // htmlClip &&
-        //     clips.push(new Clip(OFFICE_CLIPBOARD_MIMETYPE.HTML, htmlClip));
 
         return clips;
     }

libs/components/editor-core/src/editor/clipboard/paste.ts

@@ -6,16 +6,11 @@ import {
 } from './types';
 import { Editor } from '../editor';
 import { AsyncBlock } from '../block';
-import ClipboardParse from './clipboard-parse';
-import { SelectInfo } from '../selection';
-import {
-    Protocol,
-    BlockFlavorKeys,
-    services,
-} from '@toeverything/datasource/db-service';
+import { services } from '@toeverything/datasource/db-service';
 import { MarkdownParser } from './markdown-parse';
-const SUPPORT_MARKDOWN_PASTE = true;
-
+import { escape } from 'html-escaper';
+import { marked } from 'marked';
+import { ClipboardUtils } from './clipboardUtils';
 type TextValueItem = {
     text: string;
     [key: string]: any;
@@ -24,22 +19,24 @@ type TextValueItem = {
 export class Paste {
     private _editor: Editor;
     private _markdownParse: MarkdownParser;
-    private _clipboardParse: ClipboardParse;
-    constructor(
-        editor: Editor,
-        clipboardParse: ClipboardParse,
-        markdownParse: MarkdownParser
-    ) {
-        this._markdownParse = markdownParse;
-        this._clipboardParse = clipboardParse;
+    private readonly _supportMarkdownPaste: boolean = true;
+    private _utils: ClipboardUtils;
+    constructor(editor: Editor, supportMarkdownPaste?: boolean) {
+        this._markdownParse = new MarkdownParser();
         this._editor = editor;
+        this._supportMarkdownPaste =
+            supportMarkdownPaste ?? this._supportMarkdownPaste;
+
+        this._utils = new ClipboardUtils(editor);
         this.handlePaste = this.handlePaste.bind(this);
     }
-    private static _optimalMimeType: string[] = [
+    // The event handler will get the most needed clipboard data based on this array order
+    private static _optimalMimeTypes: string[] = [
         OFFICE_CLIPBOARD_MIMETYPE.DOCS_DOCUMENT_SLICE_CLIP_WRAPPED,
         OFFICE_CLIPBOARD_MIMETYPE.HTML,
         OFFICE_CLIPBOARD_MIMETYPE.TEXT,
     ];
+
     public handlePaste(e: ClipboardEvent) {
         e.stopPropagation();
 
@@ -52,60 +49,59 @@ export class Paste {
             this._pasteContent(clipboardData);
         }
     }
-    public getOptimalClip(clipboardData: any) {
-        const mimeTypeArr = Paste._optimalMimeType;
-
-        for (let i = 0; i < mimeTypeArr.length; i++) {
-            const data =
-                clipboardData[mimeTypeArr[i]] ||
-                clipboardData.getData(mimeTypeArr[i]);
+    // Get the most needed clipboard data based on `_optimalMimeTypes` order
+    public getOptimalClip(clipboardData: ClipboardEvent['clipboardData']) {
+        for (let i = 0; i < Paste._optimalMimeTypes.length; i++) {
+            const mimeType = Paste._optimalMimeTypes[i];
+            const data = clipboardData.getData(mimeType);
 
             if (data) {
                 return {
-                    type: mimeTypeArr[i],
+                    type: mimeType,
                     data: data,
                 };
             }
         }
 
-        return '';
+        return null;
     }
 
-    private _pasteContent(clipboardData: any) {
-        const originClip: { data: any; type: any } = this.getOptimalClip(
-            clipboardData
-        ) as { data: any; type: any };
+    private _pasteContent(clipboardData: ClipboardEvent['clipboardData']) {
+        const optimalClip = this.getOptimalClip(clipboardData);
+        if (
+            optimalClip?.type ===
+            OFFICE_CLIPBOARD_MIMETYPE.DOCS_DOCUMENT_SLICE_CLIP_WRAPPED
+        ) {
+            return this._firePasteEditAction(optimalClip.data);
+        }
 
-        const originTextClipData = clipboardData.getData(
-            OFFICE_CLIPBOARD_MIMETYPE.TEXT
+        const textClipData = escape(
+            clipboardData.getData(OFFICE_CLIPBOARD_MIMETYPE.TEXT)
         );
+        const shouldConvertMarkdown =
+            this._supportMarkdownPaste &&
+            this._markdownParse.checkIfTextContainsMd(textClipData);
 
-        let clipData = originClip['data'];
-
-        if (originClip['type'] === OFFICE_CLIPBOARD_MIMETYPE.TEXT) {
-            clipData = Paste._excapeHtml(clipData);
+        if (
+            optimalClip?.type === OFFICE_CLIPBOARD_MIMETYPE.HTML &&
+            !shouldConvertMarkdown
+        ) {
+            return this._pasteHtml(optimalClip.data);
         }
 
-        switch (originClip['type']) {
-            /** Protocol paste */
-            case OFFICE_CLIPBOARD_MIMETYPE.DOCS_DOCUMENT_SLICE_CLIP_WRAPPED:
-                this._firePasteEditAction(clipData);
-                break;
-            case OFFICE_CLIPBOARD_MIMETYPE.HTML:
-                this._pasteHtml(clipData, originTextClipData);
-                break;
-            case OFFICE_CLIPBOARD_MIMETYPE.TEXT:
-                this._pasteText(clipData, originTextClipData);
-                break;
-
-            default:
-                break;
+        if (shouldConvertMarkdown) {
+            const md2html = marked.parse(textClipData);
+            return this._pasteHtml(md2html);
         }
+
+        return this._pasteText(textClipData);
     }
-    private async _firePasteEditAction(clipboardData: any) {
+
+    private async _firePasteEditAction(clipboardData: string) {
         const clipInfo: InnerClipInfo = JSON.parse(clipboardData);
-        clipInfo && this._insertBlocks(clipInfo.data, clipInfo.select);
+        clipInfo && this._insertBlocks(clipInfo.data);
     }
+
     private async _pasteFile(clipboardData: any) {
         const file = Paste._getImageFile(clipboardData);
         if (file) {
@@ -139,26 +135,7 @@ export class Paste {
         );
     }
 
-    private static _isTextEditBlock(type: BlockFlavorKeys) {
-        return (
-            type === Protocol.Block.Type.page ||
-            type === Protocol.Block.Type.text ||
-            type === Protocol.Block.Type.heading1 ||
-            type === Protocol.Block.Type.heading2 ||
-            type === Protocol.Block.Type.heading3 ||
-            type === Protocol.Block.Type.quote ||
-            type === Protocol.Block.Type.todo ||
-            type === Protocol.Block.Type.code ||
-            type === Protocol.Block.Type.callout ||
-            type === Protocol.Block.Type.numbered ||
-            type === Protocol.Block.Type.bullet
-        );
-    }
-
-    private async _insertBlocks(
-        blocks: ClipBlockInfo[],
-        pasteSelect?: SelectInfo
-    ) {
+    private async _insertBlocks(blocks: ClipBlockInfo[]) {
         if (blocks.length === 0) {
             return;
         }
@@ -172,15 +149,16 @@ export class Paste {
             const selectedBlock = await this._editor.getBlockById(
                 currentSelectInfo.blocks[0].blockId
             );
-            const isSelectedBlockCanEdit = Paste._isTextEditBlock(
-                selectedBlock.type
+            const isSelectedBlockCanEdit = this._editor.isEditableView(
+                selectedBlock?.type
             );
+
             const blockView = this._editor.getView(selectedBlock.type);
             const isSelectedBlockEmpty = blockView.isEmpty(selectedBlock);
             if (isSelectedBlockCanEdit && !isSelectedBlockEmpty) {
                 const shouldSplitBlock =
                     blocks.length > 1 ||
-                    !Paste._isTextEditBlock(blocks[0].type);
+                    !this._editor.isEditableView(blocks[0].type);
                 const pureText = !shouldSplitBlock
                     ? blocks[0].properties.text.value
                     : [{ text: '' }];
@@ -400,7 +378,7 @@ export class Paste {
     }
     private async _setEndSelectToBlock(blockId: string) {
         const block = await this._editor.getBlockById(blockId);
-        const isBlockCanEdit = Paste._isTextEditBlock(block.type);
+        const isBlockCanEdit = this._editor.isEditableView(block.type);
         if (!isBlockCanEdit) {
             return;
         }
@@ -445,31 +423,13 @@ export class Paste {
         );
     }
 
-    private async _pasteHtml(clipData: any, originTextClipData: any) {
-        if (SUPPORT_MARKDOWN_PASTE) {
-            const hasMarkdown =
-                this._markdownParse.checkIfTextContainsMd(originTextClipData);
-            if (hasMarkdown) {
-                try {
-                    const convertedDataObj =
-                        this._markdownParse.md2Html(originTextClipData);
-                    if (convertedDataObj.isConverted) {
-                        clipData = convertedDataObj.text;
-                    }
-                } catch (e) {
-                    console.error(e);
-                    clipData = originTextClipData;
-                }
-            }
-        }
-
-        const blocks = this._clipboardParse.html2blocks(clipData);
-
-        await this._insertBlocks(blocks);
+    private async _pasteHtml(clipData: string) {
+        const block2 = await this._utils.convertHTMLString2Blocks(clipData);
+        await this._insertBlocks(block2);
     }
 
-    private async _pasteText(clipData: any, originTextClipData: any) {
-        const blocks = this._clipboardParse.text2blocks(clipData);
+    private async _pasteText(clipData: string) {
+        const blocks = this._utils.textToBlock(clipData);
         await this._insertBlocks(blocks);
     }
 
@@ -480,16 +440,4 @@ export class Paste {
         }
         return;
     }
-
-    private static _excapeHtml(data: any, onlySpace?: any) {
-        if (!onlySpace) {
-            // TODO:
-            // data = string.htmlEscape(data);
-            // data = data.replace(/\n/g, '<br>');
-        }
-
-        // data = data.replace(/ /g, '&nbsp;');
-        // data = data.replace(/\t/g, '&nbsp;&nbsp;&nbsp;&nbsp;');
-        return data;
-    }
 }

libs/components/editor-core/src/editor/clipboard/types.ts

@@ -1,9 +1,13 @@
 import {
     BlockFlavorKeys,
     DefaultColumnsValue,
+    ReturnEditorBlock,
 } from '@toeverything/datasource/db-service';
 import { SelectInfo } from '../selection';
 
+// export type ClipBlockInfo = Partial<ReturnEditorBlock> & {
+//     children?: ClipBlockInfo[];
+// };
 export const OFFICE_CLIPBOARD_MIMETYPE = {
     DOCS_DOCUMENT_SLICE_CLIP_WRAPPED: 'affine/x-c+w',
     HTML: 'text/html',
@@ -20,8 +24,9 @@ export const OFFICE_CLIPBOARD_MIMETYPE = {
 export interface ClipBlockInfo {
     type: BlockFlavorKeys;
     properties?: Partial<DefaultColumnsValue>;
-    children: ClipBlockInfo[];
+    children?: ClipBlockInfo[];
 }
+export type HTML2BlockResult = ClipBlockInfo[] | null;
 
 export interface InnerClipInfo {
     select: SelectInfo;

libs/components/editor-core/src/editor/clipboard/utils.ts

@@ -0,0 +1,150 @@
+import { getRandomString } from '@toeverything/components/common';
+import { ClipBlockInfo } from '@toeverything/components/editor-core';
+import { BlockFlavorKeys, Protocol } from '@toeverything/datasource/db-service';
+
+const getIsLink = (htmlElement: HTMLElement) => {
+    return ['A', 'IMG'].includes(htmlElement.tagName);
+};
+const getTextStyle = (htmlElement: HTMLElement) => {
+    const tagName = htmlElement.tagName;
+    const textStyle: { [key: string]: any } = {};
+
+    const style = (htmlElement.getAttribute('style') || '')
+        .split(';')
+        .reduce((style: { [key: string]: any }, styleString) => {
+            const [key, value] = styleString.split(':');
+            if (key && value) {
+                style[key] = value;
+            }
+            return style;
+        }, {});
+
+    if (
+        style['font-weight'] === 'bold' ||
+        Number(style['font-weight']) > 400 ||
+        ['STRONG', 'B', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6'].includes(
+            htmlElement.tagName
+        )
+    ) {
+        textStyle['bold'] = true;
+    }
+    if (getIsLink(htmlElement)) {
+        textStyle['type'] = 'link';
+        textStyle['url'] =
+            htmlElement.getAttribute('href') || htmlElement.getAttribute('src');
+        textStyle['id'] = getRandomString('link');
+    }
+
+    if (tagName === 'EM' || style['fontStyle'] === 'italic') {
+        textStyle['italic'] = true;
+    }
+    if (
+        tagName === 'U' ||
+        (style['text-decoration'] &&
+            style['text-decoration'].indexOf('underline') !== -1) ||
+        style['border-bottom']
+    ) {
+        textStyle['underline'] = true;
+    }
+    if (tagName === 'CODE') {
+        textStyle['inlinecode'] = true;
+    }
+    if (
+        tagName === 'S' ||
+        tagName === 'DEL' ||
+        (style['text-decoration'] &&
+            style['text-decoration'].indexOf('line-through') !== -1)
+    ) {
+        textStyle['strikethrough'] = true;
+    }
+
+    return textStyle;
+};
+
+export const commonHTML2Block = (
+    element: HTMLElement | Node,
+    type: BlockFlavorKeys = Protocol.Block.Type.text,
+    ignoreEmptyElement = true
+): ClipBlockInfo => {
+    const textValue = commonHTML2Text(element, {}, ignoreEmptyElement);
+    if (!textValue.length && ignoreEmptyElement) {
+        return null;
+    }
+    return {
+        type,
+        properties: {
+            text: { value: textValue },
+        },
+        children: [],
+    };
+};
+
+const getSingleLabelHTMLElementContent = (htmlElement: HTMLElement) => {
+    if (htmlElement.tagName === 'IMG') {
+        return (
+            htmlElement.getAttribute('alt') || htmlElement.getAttribute('src')
+        );
+    }
+    return '';
+};
+export const commonHTML2Text = (
+    element: HTMLElement | Node,
+    textStyle: { [key: string]: any } = {},
+    ignoreEmptyText = true
+) => {
+    if (element instanceof Text) {
+        return element.textContent.split('\n').map(text => {
+            return { text: text, ...textStyle };
+        });
+    }
+    const htmlElement = element as HTMLElement;
+    const childNodes = Array.from(htmlElement.childNodes);
+
+    const isLink = getIsLink(htmlElement);
+    const currentTextStyle = getTextStyle(htmlElement);
+
+    if (!childNodes.length) {
+        const singleLabelContent =
+            getSingleLabelHTMLElementContent(htmlElement);
+        if (isLink && singleLabelContent) {
+            return [
+                {
+                    children: [
+                        {
+                            text: singleLabelContent,
+                        },
+                    ],
+                    ...currentTextStyle,
+                },
+            ];
+        }
+        return ignoreEmptyText ? [] : [{ text: '', ...currentTextStyle }];
+    }
+
+    const childTexts = childNodes
+        .reduce((result, childNode) => {
+            const textBlocks = commonHTML2Text(
+                childNode,
+                isLink
+                    ? textStyle
+                    : {
+                          ...textStyle,
+                          ...currentTextStyle,
+                      },
+                ignoreEmptyText
+            );
+            result.push(...textBlocks);
+            return result;
+        }, [])
+        .filter(v => v);
+
+    if (isLink && childTexts.length) {
+        return [
+            {
+                children: childTexts,
+                ...currentTextStyle,
+            },
+        ];
+    }
+    return childTexts;
+};

libs/components/editor-core/src/editor/editor.ts

@@ -255,6 +255,14 @@ export class Editor implements Virgo {
     getView(type: string) {
         return this.views[type];
     }
+    getEditableViews() {
+        return Object.values(this.views)
+            .map(view => (view.activatable ? view : null))
+            .filter(v => v);
+    }
+    isEditableView(type: string) {
+        return this.views[type].activatable;
+    }
 
     private async _initBlock(
         blockData: ReturnEditorBlock

libs/components/editor-core/src/editor/index.ts

@@ -1,7 +1,4 @@
-import ClipboardParseInner from './clipboard/clipboard-parse';
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export const ClipboardParse = ClipboardParseInner;
-
+export { HTML2BlockResult, ClipBlockInfo } from './clipboard/types';
 export { AsyncBlock } from './block';
 export * from './commands/types';
 export { Editor as BlockEditor } from './editor';

libs/components/editor-core/src/editor/views/base-view.ts

@@ -1,20 +1,15 @@
 import { ComponentType, ReactElement } from 'react';
-
-import type {
-    Column,
-    DefaultColumnsValue,
-} from '@toeverything/datasource/db-service';
+import type { Column } from '@toeverything/datasource/db-service';
 import {
     ArrayOperation,
     BlockDecoration,
     MapOperation,
 } from '@toeverything/datasource/jwt';
-import { cloneDeep } from '@toeverything/utils';
 import type { EventData } from '../block';
 import { AsyncBlock } from '../block';
 import type { Editor } from '../editor';
 import { SelectBlock } from '../selection';
-
+import { HTML2BlockResult } from '../clipboard/types';
 export interface CreateView {
     block: AsyncBlock;
     editor: Editor;
@@ -135,6 +130,13 @@ export abstract class BaseView {
         return null;
     }
 
+    async html2block2(props: {
+        element: HTMLElement | Node;
+        editor: Editor;
+    }): Promise<HTML2BlockResult> {
+        return null;
+    }
+
     async block2Text(
         block: AsyncBlock,
         // The selectInfo parameter is not passed when the block is selected in ful, the selectInfo.type is Range