@worktile/theia 3.0.8 → 3.1.0-next.1

package/esm2020/plugins/mark/mark.plugin.mjs

@@ -0,0 +1,105 @@
+import { Editor, Range, Text, Transforms } from 'slate';
+import { DISABLED_OPERATE_TYPES, ElementKinds, MarkTypes } from '../../constants';
+import { PluginKeys } from '../../interfaces';
+import { createPluginFactory } from '../../core';
+import { CONTROL_KEY } from '../../utils';
+import { MarkEditor } from './mark.editor';
+export const withMark = (editor) => {
+    const e = editor;
+    e.removeMark = (key, shouldChange = true) => {
+        const { selection } = e;
+        if (selection) {
+            if (Range.isExpanded(selection)) {
+                Transforms.unsetNodes(e, key, {
+                    match: Text.isText,
+                    split: true
+                });
+            }
+            else {
+                const marks = { ...(Editor.marks(e) || {}) };
+                delete marks[key];
+                editor.marks = marks;
+                const text = Editor.string(e, selection.anchor.path);
+                if (text !== '') {
+                    Editor.setNormalizing(editor, false);
+                    e.insertText('');
+                    editor.marks = marks;
+                    Editor.setNormalizing(editor, true);
+                }
+                else {
+                    Transforms.unsetNodes(e, key, { at: selection.anchor.path });
+                }
+                if (shouldChange) {
+                    editor.onChange();
+                }
+            }
+        }
+    };
+    e.addMark = (key, value) => {
+        const { selection } = editor;
+        if (selection) {
+            if (Range.isExpanded(selection)) {
+                Transforms.setNodes(e, { [key]: value }, { match: Text.isText, split: true });
+            }
+            else {
+                const marks = {
+                    ...(Editor.marks(e) || {}),
+                    [key]: value
+                };
+                editor.marks = marks;
+                const text = Editor.string(e, selection.anchor.path);
+                if (text !== '') {
+                    Editor.setNormalizing(editor, false);
+                    e.insertText('');
+                    editor.marks = marks;
+                    Editor.setNormalizing(editor, true);
+                }
+                else {
+                    Transforms.setNodes(e, { [key]: value }, { at: selection.anchor.path });
+                }
+            }
+        }
+    };
+    return e;
+};
+export const createMarkPlugin = createPluginFactory({
+    key: PluginKeys.mark,
+    withOverrides: withMark,
+    toolbarItems: [
+        {
+            key: MarkTypes.bold,
+            icon: 'bold',
+            name: '加粗',
+            shortcutKey: `${CONTROL_KEY}+B`,
+            execute: editor => MarkEditor.toggleMark(editor, MarkTypes.bold),
+            active: editor => MarkEditor.isMarkActive(editor, MarkTypes.bold)
+        },
+        {
+            key: MarkTypes.italic,
+            icon: 'italic',
+            name: '斜体',
+            shortcutKey: `${CONTROL_KEY}+I`,
+            execute: editor => MarkEditor.toggleMark(editor, MarkTypes.italic),
+            active: editor => MarkEditor.isMarkActive(editor, MarkTypes.italic)
+        },
+        {
+            key: MarkTypes.strike,
+            icon: 'strike',
+            name: '删除线',
+            execute: editor => MarkEditor.toggleMark(editor, MarkTypes.strike),
+            active: editor => MarkEditor.isMarkActive(editor, MarkTypes.strike)
+        },
+        {
+            key: MarkTypes.underline,
+            icon: 'underline',
+            name: '下划线',
+            shortcutKey: `${CONTROL_KEY}+U`,
+            execute: editor => MarkEditor.toggleMark(editor, MarkTypes.underline),
+            active: editor => MarkEditor.isMarkActive(editor, MarkTypes.underline)
+        }
+    ],
+    options: {
+        disabledOperateTypes: [ElementKinds.image, ...DISABLED_OPERATE_TYPES]
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mark.plugin.js","sourceRoot":"","sources":["../../../../../packages/src/plugins/mark/mark.plugin.ts"],"names":[],"mappings":"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","sourcesContent":["import { Editor, Range, Text, Transforms } from 'slate';\nimport { DISABLED_OPERATE_TYPES, ElementKinds, MarkTypes } from '../../constants';\nimport { PluginKeys } from '../../interfaces';\nimport { createPluginFactory } from '../../core';\nimport { CONTROL_KEY } from '../../utils';\nimport { MarkEditor } from './mark.editor';\n\nexport const withMark = <T extends Editor & MarkEditor>(editor: T): T => {\n    const e = editor;\n\n    e.removeMark = (key: string, shouldChange = true) => {\n        const { selection } = e;\n        if (selection) {\n            if (Range.isExpanded(selection)) {\n                Transforms.unsetNodes(e, key, {\n                    match: Text.isText,\n                    split: true\n                });\n            } else {\n                const marks = { ...(Editor.marks(e) || {}) };\n                delete marks[key];\n                editor.marks = marks;\n                const text = Editor.string(e, selection.anchor.path);\n                if (text !== '') {\n                    Editor.setNormalizing(editor, false);\n                    e.insertText('');\n                    editor.marks = marks;\n                    Editor.setNormalizing(editor, true);\n                } else {\n                    Transforms.unsetNodes(e, key, { at: selection.anchor.path });\n                }\n                if (shouldChange) {\n                    editor.onChange();\n                }\n            }\n        }\n    };\n\n    e.addMark = (key: string, value: any) => {\n        const { selection } = editor;\n\n        if (selection) {\n            if (Range.isExpanded(selection)) {\n                Transforms.setNodes(e, { [key]: value }, { match: Text.isText, split: true });\n            } else {\n                const marks = {\n                    ...(Editor.marks(e) || {}),\n                    [key]: value\n                };\n                editor.marks = marks;\n                const text = Editor.string(e, selection.anchor.path);\n                if (text !== '') {\n                    Editor.setNormalizing(editor, false);\n                    e.insertText('');\n                    editor.marks = marks;\n                    Editor.setNormalizing(editor, true);\n                } else {\n                    Transforms.setNodes(e, { [key]: value }, { at: selection.anchor.path });\n                }\n            }\n        }\n    };\n\n    return e;\n};\n\nexport const createMarkPlugin = createPluginFactory({\n    key: PluginKeys.mark,\n    withOverrides: withMark,\n    toolbarItems: [\n        {\n            key: MarkTypes.bold,\n            icon: 'bold',\n            name: '加粗',\n            shortcutKey: `${CONTROL_KEY}+B`,\n            execute: editor => MarkEditor.toggleMark(editor, MarkTypes.bold),\n            active: editor => MarkEditor.isMarkActive(editor, MarkTypes.bold)\n        },\n        {\n            key: MarkTypes.italic,\n            icon: 'italic',\n            name: '斜体',\n            shortcutKey: `${CONTROL_KEY}+I`,\n            execute: editor => MarkEditor.toggleMark(editor, MarkTypes.italic),\n            active: editor => MarkEditor.isMarkActive(editor, MarkTypes.italic)\n        },\n        {\n            key: MarkTypes.strike,\n            icon: 'strike',\n            name: '删除线',\n            execute: editor => MarkEditor.toggleMark(editor, MarkTypes.strike),\n            active: editor => MarkEditor.isMarkActive(editor, MarkTypes.strike)\n        },\n        {\n            key: MarkTypes.underline,\n            icon: 'underline',\n            name: '下划线',\n            shortcutKey: `${CONTROL_KEY}+U`,\n            execute: editor => MarkEditor.toggleMark(editor, MarkTypes.underline),\n            active: editor => MarkEditor.isMarkActive(editor, MarkTypes.underline)\n        }\n    ],\n    options: {\n        disabledOperateTypes: [ElementKinds.image, ...DISABLED_OPERATE_TYPES]\n    }\n});\n"]}

package/esm2020/plugins/node-id/node-id.plugin.mjs

@@ -0,0 +1,78 @@
+import { Element } from 'slate';
+import { PluginKeys } from '../../interfaces';
+import { _ } from '../../utils/lodash';
+import { deleteElementKey } from '../../utils/fragment';
+import { createPluginFactory, getPluginOptions } from '../../core';
+import { ELEMENT_UNIQUE_ID } from '../../constants';
+import { idCreator } from '../../utils';
+import * as TheQueries from '../../queries';
+import * as TheTransforms from '../../transforms';
+export const withNodeID = (e) => {
+    const editor = e;
+    let props = { idKey: 'id', idCreator: () => Date.now(), filterText: true, filter: () => true };
+    const options = getPluginOptions(editor, PluginKeys.nodeID);
+    props = { ...props, ...options };
+    const { idKey, idCreator, filterText, filter } = props;
+    const { apply, getFragment } = editor;
+    const idPropsCreator = () => ({ [idKey]: idCreator() });
+    editor.removedIDs = new Set();
+    editor.apply = (operation) => {
+        if (operation.type === 'insert_node') {
+            const newFilter = (entry) => {
+                const [_node] = entry;
+                return filter(entry) && filterText ? Element.isElement(_node) : TheQueries.isDescendant(_node);
+            };
+            // fix can not find path by orign node
+            let node = operation.node;
+            if (!Object.isExtensible(node)) {
+                node = _.cloneDeep(node);
+            }
+            // it will not overwrite ids once it's set as it's read-only
+            TheTransforms.mergeDeepToNodes({
+                node,
+                source: idPropsCreator,
+                query: {
+                    filter: newFilter
+                }
+            });
+            return apply({
+                ...operation,
+                node
+            });
+        }
+        if (operation.type === 'split_node' && (!filterText || operation.properties.type)) {
+            let id = operation.properties[idKey];
+            if (editor.removedIDs.has(id)) {
+                editor.removedIDs.delete(id);
+            }
+            else {
+                id = idCreator();
+            }
+            return apply({
+                ...operation,
+                properties: {
+                    ...operation.properties,
+                    [idKey]: id
+                }
+            });
+        }
+        if (operation.type === 'merge_node' && (!filterText || operation.properties.type)) {
+            editor.removedIDs.add(operation.properties[idKey]);
+        }
+        return apply(operation);
+    };
+    editor.getFragment = () => {
+        const fragment = _.cloneDeep(getFragment());
+        return deleteElementKey(fragment, idKey);
+    };
+    return editor;
+};
+export const createNodeIDPlugin = createPluginFactory({
+    key: PluginKeys.nodeID,
+    withOverrides: withNodeID,
+    options: {
+        idKey: ELEMENT_UNIQUE_ID,
+        idCreator
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-id.plugin.js","sourceRoot":"","sources":["../../../../../packages/src/plugins/node-id/node-id.plugin.ts"],"names":[],"mappings":"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","sourcesContent":["import { NodeEntry, Element, Node, Editor, Operation, Descendant } from 'slate';\nimport { PluginKeys, QueryOptions } from '../../interfaces';\nimport { _ } from '../../utils/lodash';\nimport { deleteElementKey } from '../../utils/fragment';\nimport { createPluginFactory, getPluginOptions } from '../../core';\nimport { ELEMENT_UNIQUE_ID } from '../../constants';\nimport { idCreator } from '../../utils';\nimport * as TheQueries from '../../queries';\nimport * as TheTransforms from '../../transforms';\n\nexport interface WithNodeIDProps extends QueryOptions {\n    // Key used for the id. Default is `id`.\n    idKey?: string;\n    // ID factory, e.g. `uuid`\n    idCreator?: () => void;\n    // Filter `Text` nodes.\n    filterText?: boolean;\n}\n\nexport const withNodeID = <T extends Editor>(e: T): T => {\n    const editor = e as T & { removedIDs: Set<any> };\n\n    let props: WithNodeIDProps = { idKey: 'id', idCreator: () => Date.now(), filterText: true, filter: () => true };\n    const options = getPluginOptions<WithNodeIDProps>(editor, PluginKeys.nodeID);\n    props = { ...props, ...options };\n    const { idKey, idCreator, filterText, filter } = props;\n\n    const { apply, getFragment } = editor;\n\n    const idPropsCreator = () => ({ [idKey]: idCreator() });\n\n    editor.removedIDs = new Set();\n\n    editor.apply = (operation: Operation) => {\n        if (operation.type === 'insert_node') {\n            const newFilter = (entry: NodeEntry<Node>) => {\n                const [_node] = entry;\n                return filter(entry) && filterText ? Element.isElement(_node) : TheQueries.isDescendant(_node);\n            };\n\n            // fix can not find path by orign node\n            let node = operation.node;\n            if (!Object.isExtensible(node)) {\n                node = _.cloneDeep(node);\n            }\n\n            // it will not overwrite ids once it's set as it's read-only\n            TheTransforms.mergeDeepToNodes({\n                node,\n                source: idPropsCreator,\n                query: {\n                    filter: newFilter\n                }\n            });\n\n            return apply({\n                ...operation,\n                node\n            });\n        }\n\n        if (operation.type === 'split_node' && (!filterText || (operation.properties as Element).type)) {\n            let id = operation.properties[idKey];\n            if (editor.removedIDs.has(id)) {\n                editor.removedIDs.delete(id);\n            } else {\n                id = idCreator();\n            }\n\n            return apply({\n                ...operation,\n                properties: {\n                    ...operation.properties,\n                    [idKey]: id\n                }\n            });\n        }\n\n        if (operation.type === 'merge_node' && (!filterText || (operation.properties as Element).type)) {\n            editor.removedIDs.add((operation.properties as Element)[idKey]);\n        }\n\n        return apply(operation);\n    };\n\n    editor.getFragment = () => {\n        const fragment = _.cloneDeep(getFragment());\n        return deleteElementKey(fragment, idKey) as Descendant[];\n    };\n\n    return editor;\n};\n\nexport const createNodeIDPlugin = createPluginFactory<WithNodeIDProps>({\n    key: PluginKeys.nodeID,\n    withOverrides: withNodeID,\n    options: {\n        idKey: ELEMENT_UNIQUE_ID,\n        idCreator\n    }\n});\n"]}

package/esm2020/plugins/normalizers/insert-paragraph-nodes.mjs

@@ -0,0 +1,28 @@
+import { Transforms, Element, Text, Editor } from 'slate';
+import { PluginKeys } from '../../interfaces';
+import { createPluginFactory, getPluginOptions } from '../../core';
+import { createEmptyParagraph } from '../../utils/create-empty-paragraph';
+import * as TheQueries from '../../queries';
+export const withInsertParagraphNodes = (editor) => {
+    const { normalizeNode } = editor;
+    const types = getPluginOptions(editor, PluginKeys.insertParagraphNodes)?.types ?? [];
+    editor.normalizeNode = ([currentNode, currentPath]) => {
+        if (Text.isText(currentNode) && currentPath.length) {
+            const [node] = Editor.parent(editor, currentPath);
+            const containerBlocks = [...types, ...TheQueries.getContainerBlocks(editor)];
+            if (Element.isElement(node) && containerBlocks.includes(node.type)) {
+                const paragraph = createEmptyParagraph();
+                paragraph.children[0].text = currentNode.text;
+                Transforms.insertNodes(editor, paragraph, { at: currentPath });
+                return;
+            }
+        }
+        return normalizeNode([currentNode, currentPath]);
+    };
+    return editor;
+};
+export const createInsertParagraphNodesPlugin = createPluginFactory({
+    key: PluginKeys.insertParagraphNodes,
+    withOverrides: withInsertParagraphNodes
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/plugins/normalizers/trailing-node.plugin.mjs

@@ -0,0 +1,33 @@
+import { Path, Element } from 'slate';
+import { PluginKeys } from '../../interfaces';
+import { ElementKinds } from '../../constants';
+import { createPluginFactory, getPluginOptions } from '../../core';
+import * as TheQueries from '../../queries';
+export const withTrailingNode = (editor) => {
+    const { normalizeNode } = editor;
+    const options = getPluginOptions(editor, PluginKeys.trailingNode);
+    const { type, level, ...query } = options;
+    editor.normalizeNode = ([currentNode, currentPath]) => {
+        if (!currentPath.length) {
+            const entry = TheQueries.getLastNode(editor, level);
+            const [lastNode, lastPath] = entry;
+            if (Element.isElement(lastNode) && lastNode.type !== type && TheQueries.isNodeType(entry, query)) {
+                editor.insertNodes({
+                    type,
+                    children: [{ text: '' }]
+                }, { at: Path.next(lastPath) });
+            }
+        }
+        return normalizeNode([currentNode, currentPath]);
+    };
+    return editor;
+};
+export const createTrailingNodePlugin = createPluginFactory({
+    key: PluginKeys.trailingNode,
+    withOverrides: withTrailingNode,
+    options: {
+        type: ElementKinds.paragraph,
+        level: 0
+    }
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/plugins/quick-insert/components/quick-insert.component.mjs

@@ -0,0 +1,96 @@
+import { Component, ElementRef, Input, HostListener, ViewChild } from '@angular/core';
+import { Node } from 'slate';
+import { AngularEditor } from 'slate-angular';
+import { MarkTypes } from '../../../constants/node-types';
+import { isCleanEmptyParagraph } from '../../../utils/is-clean-empty-paragraph';
+import { QuickInsertEditor } from '../quick-insert.editor';
+import * as TheQueries from '../../../queries';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-tethys/icon";
+export class TheQuickInsertComponent {
+    constructor(renderer, elementRef, cdr) {
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+        this.cdr = cdr;
+        this.isVisible = false;
+        this.isHide = true;
+        this.defaultIconName = 'plus-circle-thin';
+        this.iconNameFill = 'plus-circle-thin-fill';
+        this.displayIconName = this.defaultIconName;
+    }
+    handleMousedownNativeElement(event) {
+        event.preventDefault();
+        event.stopPropagation();
+    }
+    checkStatus() {
+        const { editor } = this;
+        if (this.isVisible && isCleanEmptyParagraph(editor) && !this.hasExcludeAttribute() && !this.isRichMediaScope()) {
+            const block = Node.ancestor(editor, [editor?.selection?.anchor.path[0]]);
+            const rootNode = AngularEditor.toDOMNode(editor, block);
+            this.updatePosition(rootNode.offsetLeft, rootNode.offsetTop);
+            return;
+        }
+        this.isHide = true;
+    }
+    isRichMediaScope() {
+        const { editor } = this;
+        if (editor?.selection) {
+            const block = Node.ancestor(editor, [editor?.selection?.anchor.path[0]]);
+            const rootElement = AngularEditor.toDOMNode(editor, block);
+            const leafElement = rootElement.querySelector('[data-slate-leaf="true"]');
+            const rootElementRect = rootElement.getBoundingClientRect();
+            const leafElementRect = leafElement.getBoundingClientRect();
+            return leafElementRect?.x !== rootElementRect?.x;
+        }
+        return false;
+    }
+    hasExcludeAttribute() {
+        const marks = TheQueries.getSelectionMarks(this.editor);
+        const fontSizeMark = marks[MarkTypes.fontSize];
+        return fontSizeMark;
+    }
+    updatePosition(left, top) {
+        this.isHide = false;
+        this.renderer.setStyle(this.elementRef.nativeElement, 'top', `${top}px`);
+        this.renderer.setStyle(this.elementRef.nativeElement, 'left', `${left}px`);
+    }
+    mouseEnter(event) {
+        this.displayIconName = this.iconNameFill;
+        this.cdr.markForCheck();
+    }
+    mouseLeave(event) {
+        this.displayIconName = this.defaultIconName;
+        this.cdr.markForCheck();
+    }
+    handleClick(event) {
+        event.stopPropagation();
+        event.preventDefault();
+        if (QuickInsertEditor.isOpenedToolbar(this.editor)) {
+            QuickInsertEditor.closeQuickInsertToolbar(this.editor);
+            return;
+        }
+        QuickInsertEditor.openQuickInsertToolbar(this.editor, this.quickToolbarItems, this.iconElement.nativeElement);
+    }
+}
+TheQuickInsertComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TheQuickInsertComponent, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+TheQuickInsertComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.8", type: TheQuickInsertComponent, selector: "[theQuickInsert]", inputs: { editor: "editor", quickToolbarItems: "quickToolbarItems", isVisible: "isVisible" }, host: { listeners: { "mousedown": "handleMousedownNativeElement($event)" }, properties: { "class.hide": "isHide" }, classAttribute: "the-quick-insert" }, viewQueries: [{ propertyName: "iconElement", first: true, predicate: ["iconElement"], descendants: true, read: ElementRef }], ngImport: i0, template: "<thy-icon\n    #iconElement\n    [thyIconName]=\"displayIconName\"\n    class=\"quick-insert-icon text-desc font-size-xlg\"\n    (mouseenter)=\"mouseEnter($event)\"\n    (mouseleave)=\"mouseLeave($event)\"\n    (mousedown)=\"handleClick($event)\"\n></thy-icon>\n", components: [{ type: i1.ThyIconComponent, selector: "thy-icon", inputs: ["thyIconType", "thyTwotoneColor", "thyIconName", "thyIconRotate", "thyIconSet", "thyIconLegging", "thyIconLinearGradient"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TheQuickInsertComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[theQuickInsert]', host: {
+                        class: 'the-quick-insert',
+                        '[class.hide]': 'isHide'
+                    }, template: "<thy-icon\n    #iconElement\n    [thyIconName]=\"displayIconName\"\n    class=\"quick-insert-icon text-desc font-size-xlg\"\n    (mouseenter)=\"mouseEnter($event)\"\n    (mouseleave)=\"mouseLeave($event)\"\n    (mousedown)=\"handleClick($event)\"\n></thy-icon>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { editor: [{
+                type: Input
+            }], quickToolbarItems: [{
+                type: Input
+            }], isVisible: [{
+                type: Input
+            }], iconElement: [{
+                type: ViewChild,
+                args: ['iconElement', { read: ElementRef, static: false }]
+            }], handleMousedownNativeElement: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quick-insert.component.js","sourceRoot":"","sources":["../../../../../../packages/src/plugins/quick-insert/components/quick-insert.component.ts","../../../../../../packages/src/plugins/quick-insert/components/quick-insert.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, Input, HostListener, Renderer2, ChangeDetectorRef, ViewChild } from '@angular/core';\nimport { Editor, Node } from 'slate';\nimport { AngularEditor } from 'slate-angular';\nimport { MarkTypes } from '../../../constants/node-types';\nimport { isCleanEmptyParagraph } from '../../../utils/is-clean-empty-paragraph';\nimport { QuickInsertEditor } from '../quick-insert.editor';\nimport * as TheQueries from '../../../queries';\nimport { ToolbarItem } from '../../../interfaces/toolbar';\n\n@Component({\n    selector: '[theQuickInsert]',\n    templateUrl: './quick-insert.component.html',\n    host: {\n        class: 'the-quick-insert',\n        '[class.hide]': 'isHide'\n    }\n})\nexport class TheQuickInsertComponent {\n    @Input() editor: Editor;\n    @Input() quickToolbarItems: ToolbarItem[];\n    @Input() isVisible = false;\n\n    isHide = true;\n    defaultIconName = 'plus-circle-thin';\n    iconNameFill = 'plus-circle-thin-fill';\n    displayIconName = this.defaultIconName;\n\n    @ViewChild('iconElement', { read: ElementRef, static: false })\n    iconElement: ElementRef<any>;\n\n    @HostListener('mousedown', ['$event'])\n    handleMousedownNativeElement(event) {\n        event.preventDefault();\n        event.stopPropagation();\n    }\n\n    constructor(private renderer: Renderer2, private elementRef: ElementRef, private cdr: ChangeDetectorRef) {}\n\n    public checkStatus() {\n        const { editor } = this;\n        if (this.isVisible && isCleanEmptyParagraph(editor) && !this.hasExcludeAttribute() && !this.isRichMediaScope()) {\n            const block = Node.ancestor(editor, [editor?.selection?.anchor.path[0]]);\n            const rootNode: HTMLElement = AngularEditor.toDOMNode(editor, block);\n            this.updatePosition(rootNode.offsetLeft, rootNode.offsetTop);\n            return;\n        }\n        this.isHide = true;\n    }\n\n    private isRichMediaScope() {\n        const { editor } = this;\n        if (editor?.selection) {\n            const block = Node.ancestor(editor, [editor?.selection?.anchor.path[0]]);\n            const rootElement = AngularEditor.toDOMNode(editor, block);\n            const leafElement = rootElement.querySelector('[data-slate-leaf=\"true\"]');\n            const rootElementRect = rootElement.getBoundingClientRect();\n            const leafElementRect = leafElement.getBoundingClientRect();\n            return leafElementRect?.x !== rootElementRect?.x;\n        }\n        return false;\n    }\n\n    private hasExcludeAttribute() {\n        const marks = TheQueries.getSelectionMarks(this.editor);\n        const fontSizeMark: number = marks[MarkTypes.fontSize];\n\n        return fontSizeMark;\n    }\n\n    private updatePosition(left: number, top?: number) {\n        this.isHide = false;\n        this.renderer.setStyle(this.elementRef.nativeElement, 'top', `${top}px`);\n        this.renderer.setStyle(this.elementRef.nativeElement, 'left', `${left}px`);\n    }\n\n    mouseEnter(event: MouseEvent) {\n        this.displayIconName = this.iconNameFill;\n        this.cdr.markForCheck();\n    }\n\n    mouseLeave(event: MouseEvent) {\n        this.displayIconName = this.defaultIconName;\n        this.cdr.markForCheck();\n    }\n\n    handleClick(event: MouseEvent) {\n        event.stopPropagation();\n        event.preventDefault();\n        if (QuickInsertEditor.isOpenedToolbar(this.editor)) {\n            QuickInsertEditor.closeQuickInsertToolbar(this.editor);\n            return;\n        }\n        QuickInsertEditor.openQuickInsertToolbar(this.editor, this.quickToolbarItems, this.iconElement.nativeElement);\n    }\n}\n","<thy-icon\n    #iconElement\n    [thyIconName]=\"displayIconName\"\n    class=\"quick-insert-icon text-desc font-size-xlg\"\n    (mouseenter)=\"mouseEnter($event)\"\n    (mouseleave)=\"mouseLeave($event)\"\n    (mousedown)=\"handleClick($event)\"\n></thy-icon>\n"]}

package/esm2020/plugins/quick-insert/components/quick-toolbar/quick-toolbar.component.mjs

@@ -0,0 +1,80 @@
+import { Component, Input, HostListener } from '@angular/core';
+import { mixinUnsubscribe, MixinBase } from 'ngx-tethys/core';
+import { Editor, Node } from 'slate';
+import { AngularEditor } from 'slate-angular';
+import { getPluginOptions } from '../../../../core';
+import { PluginKeys } from '../../../../interfaces';
+import { ToolbarActionTypes, ToolbarItemMode } from '../../../../constants';
+import { QuickInsertEditor } from '../../quick-insert.editor';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-tethys/list";
+import * as i2 from "ngx-tethys/shared";
+import * as i3 from "../../../../components/toolbar-item/toolbar-item.component";
+import * as i4 from "../../../../components/nav-split-line/nav-split-line.component";
+import * as i5 from "@angular/common";
+export class TheQuickToolbarComponent extends mixinUnsubscribe(MixinBase) {
+    constructor(elementRef, cdr) {
+        super();
+        this.elementRef = elementRef;
+        this.cdr = cdr;
+        this.ToolbarItemMode = ToolbarItemMode;
+        this.ToolbarActionTypes = ToolbarActionTypes;
+    }
+    handleMouseDown(event) {
+        if (!this.elementRef.nativeElement.contains(event.target)) {
+            QuickInsertEditor.closeQuickInsertToolbar(this.editor);
+        }
+        else {
+            event.preventDefault();
+        }
+    }
+    handleEnter() {
+        QuickInsertEditor.closeQuickInsertToolbar(this.editor);
+    }
+    handleEsc() {
+        QuickInsertEditor.closeQuickInsertToolbar(this.editor);
+    }
+    ngOnInit() {
+        this.editorElement = AngularEditor.toDOMNode(this.editor, this.editor);
+    }
+    stopPropagation(event) {
+        event.preventDefault();
+    }
+    selectionChange(event) {
+        this.removeHotKey();
+        const toolbarItem = this.quickToolbarItems.find(item => item.key === event.value);
+        if (toolbarItem?.execute) {
+            toolbarItem.execute(this.editor);
+        }
+    }
+    removeHotKey() {
+        const hotkey = getPluginOptions(this.editor, PluginKeys.quickInsert)?.hotkey;
+        const node = Node.get(this.editor, this.editor.selection.anchor.path);
+        if (node && hotkey === node.text) {
+            Editor.deleteBackward(this.editor);
+        }
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+    }
+}
+TheQuickToolbarComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TheQuickToolbarComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+TheQuickToolbarComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.8", type: TheQuickToolbarComponent, selector: "the-quick-toolbar", inputs: { editor: "editor", quickToolbarItems: "quickToolbarItems" }, host: { listeners: { "document: mousedown": "handleMouseDown($event)", "document: keydown.enter": "handleEnter()", "document: keydown.escape": "handleEsc()" } }, usesInheritance: true, ngImport: i0, template: "<thy-selection-list\n    class=\"the-quick-toolbar\"\n    [thyBindKeyEventContainer]=\"editorElement\"\n    (thySelectionChange)=\"selectionChange($event)\"\n    [thyMultiple]=\"false\"\n>\n    <ng-container *ngFor=\"let item of quickToolbarItems\">\n        <ng-container *ngIf=\"item.key !== ToolbarActionTypes.split; else splitLine\">\n            <thy-list-option [thyValue]=\"item?.key\" (mousedown)=\"stopPropagation($event)\">\n                <the-toolbar-item [editor]=\"editor\" [toolbarItem]=\"item\" [itemMode]=\"ToolbarItemMode.vertical\"></the-toolbar-item>\n            </thy-list-option>\n        </ng-container>\n    </ng-container>\n</thy-selection-list>\n\n<ng-template #splitLine>\n    <nav-split-line [mode]=\"ToolbarItemMode.horizontal\"></nav-split-line>\n</ng-template>\n", components: [{ type: i1.ThySelectionListComponent, selector: "thy-selection-list,[thy-selection-list]", inputs: ["thyMultiple", "thyBindKeyEventContainer", "thyScrollContainer", "thyBeforeKeydown", "thyUniqueKey", "thyCompareWith", "thyLayout", "thyAutoActiveFirstItem", "thySize", "thySpaceKeyEnabled"], outputs: ["thySelectionChange"] }, { type: i2.ThyListOptionComponent, selector: "thy-list-option,[thy-list-option]", inputs: ["id", "thyValue", "thyDisabled"] }, { type: i3.TheToolbarItemComponent, selector: "the-toolbar-item", inputs: ["itemMode"] }, { type: i4.NavSplitLineComponent, selector: "nav-split-line", inputs: ["mode"] }], directives: [{ type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: TheQuickToolbarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'the-quick-toolbar', template: "<thy-selection-list\n    class=\"the-quick-toolbar\"\n    [thyBindKeyEventContainer]=\"editorElement\"\n    (thySelectionChange)=\"selectionChange($event)\"\n    [thyMultiple]=\"false\"\n>\n    <ng-container *ngFor=\"let item of quickToolbarItems\">\n        <ng-container *ngIf=\"item.key !== ToolbarActionTypes.split; else splitLine\">\n            <thy-list-option [thyValue]=\"item?.key\" (mousedown)=\"stopPropagation($event)\">\n                <the-toolbar-item [editor]=\"editor\" [toolbarItem]=\"item\" [itemMode]=\"ToolbarItemMode.vertical\"></the-toolbar-item>\n            </thy-list-option>\n        </ng-container>\n    </ng-container>\n</thy-selection-list>\n\n<ng-template #splitLine>\n    <nav-split-line [mode]=\"ToolbarItemMode.horizontal\"></nav-split-line>\n</ng-template>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { editor: [{
+                type: Input
+            }], quickToolbarItems: [{
+                type: Input
+            }], handleMouseDown: [{
+                type: HostListener,
+                args: ['document: mousedown', ['$event']]
+            }], handleEnter: [{
+                type: HostListener,
+                args: ['document: keydown.enter']
+            }], handleEsc: [{
+                type: HostListener,
+                args: ['document: keydown.escape']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/plugins/quick-insert/quick-insert.plugin.mjs

@@ -0,0 +1,74 @@
+import { Node } from 'slate';
+import { hotkeys } from 'slate-angular';
+import { TheEditorComponent } from '../../editor.component';
+import { THE_EDITOR_QUICK_TOOLBAR_REF, isPureEmptyParagraph } from '../../utils';
+import { createPluginFactory, getPluginOptions } from '../../core';
+import { PluginKeys } from '../../interfaces';
+import { QuickInsertEditor } from './quick-insert.editor';
+import { getBlockAbove } from '../../queries/get-block-above';
+export const withQuickInsert = (editor) => {
+    const { onKeydown, deleteBackward, onChange } = editor;
+    let presseingQuickInsertHotkey = false;
+    editor.onKeydown = (event) => {
+        const options = getPluginOptions(editor, PluginKeys.quickInsert);
+        const { hotkey, allowHotkeyInTypes } = options;
+        if (event.key === hotkey) {
+            const types = [...(allowHotkeyInTypes || [])];
+            const [block] = getBlockAbove(editor);
+            if (isPureEmptyParagraph(editor, block) && allowOpenQuickToolbar(editor, types)) {
+                presseingQuickInsertHotkey = true;
+            }
+        }
+        const quickToolbarRef = THE_EDITOR_QUICK_TOOLBAR_REF.get(editor);
+        const isMoveUp = hotkeys.isMoveUp(event);
+        const isMoveDown = hotkeys.isMoveDown(event);
+        if (quickToolbarRef && (isMoveUp || isMoveDown)) {
+            return;
+        }
+        onKeydown(event);
+    };
+    editor.deleteBackward = unit => {
+        if (QuickInsertEditor.isOpenedToolbar(editor)) {
+            QuickInsertEditor.closeQuickInsertToolbar(editor);
+        }
+        deleteBackward(unit);
+    };
+    editor.onChange = () => {
+        onChange();
+        if (editor.selection) {
+            const hotkey = getPluginOptions(editor, PluginKeys.quickInsert)?.hotkey;
+            const [block] = getBlockAbove(editor);
+            // quick insert plus
+            const editorComponent = editor.injector.get(TheEditorComponent);
+            editorComponent.quickInsertInstance?.checkStatus();
+            if (presseingQuickInsertHotkey && Node.string(block) === hotkey) {
+                QuickInsertEditor.openQuickInsertToolbar(editor, editorComponent.quickToolbarItems);
+                presseingQuickInsertHotkey = false;
+                return;
+            }
+            else {
+                presseingQuickInsertHotkey = false;
+            }
+            if (QuickInsertEditor.isOpenedToolbar(editor) && !isPureEmptyParagraph(editor, block) && Node.string(block) !== hotkey) {
+                QuickInsertEditor.closeQuickInsertToolbar(editor);
+            }
+        }
+    };
+    return editor;
+};
+export const createQuickInsertPlugin = createPluginFactory({
+    key: PluginKeys.quickInsert,
+    withOverrides: withQuickInsert,
+    options: {
+        hotkey: '/'
+    }
+});
+export const allowOpenQuickToolbar = (editor, allowTypes) => {
+    const [, path] = getBlockAbove(editor);
+    const parentNode = Node.parent(editor, path);
+    if (path.length === 1 || (parentNode && allowTypes.includes(parentNode.type))) {
+        return true;
+    }
+    return false;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quick-insert.plugin.js","sourceRoot":"","sources":["../../../../../packages/src/plugins/quick-insert/quick-insert.plugin.ts"],"names":[],"mappings":"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","sourcesContent":["import { Editor, Node } from 'slate';\nimport { hotkeys } from 'slate-angular';\nimport { TheEditorComponent } from '../../editor.component';\nimport { ElementKinds } from '../../constants';\nimport { THE_EDITOR_QUICK_TOOLBAR_REF, isPureEmptyParagraph } from '../../utils';\nimport { createPluginFactory, getPluginOptions } from '../../core';\nimport { PluginKeys } from '../../interfaces';\nimport { QuickInsertEditor } from './quick-insert.editor';\nimport { getBlockAbove } from '../../queries/get-block-above';\nimport { CustomElementKinds } from '../../custom-types';\n\nexport interface QuickInsertPluginOptions {\n    hotKey?: string;\n    allowHotkeyInTypes?: CustomElementKinds[];\n}\n\nexport const withQuickInsert = <T extends Editor>(editor: T): T => {\n    const { onKeydown, deleteBackward, onChange } = editor;\n    let presseingQuickInsertHotkey = false;\n\n    editor.onKeydown = (event: KeyboardEvent) => {\n        const options = getPluginOptions<QuickInsertPluginOptions>(editor, PluginKeys.quickInsert);\n        const { hotkey, allowHotkeyInTypes } = options;\n        if (event.key === hotkey) {\n            const types = [...(allowHotkeyInTypes || [])];\n            const [block] = getBlockAbove(editor);\n            if (isPureEmptyParagraph(editor, block) && allowOpenQuickToolbar(editor, types)) {\n                presseingQuickInsertHotkey = true;\n            }\n        }\n        const quickToolbarRef = THE_EDITOR_QUICK_TOOLBAR_REF.get(editor);\n        const isMoveUp = hotkeys.isMoveUp(event);\n        const isMoveDown = hotkeys.isMoveDown(event);\n        if (quickToolbarRef && (isMoveUp || isMoveDown)) {\n            return;\n        }\n        onKeydown(event);\n    };\n\n    editor.deleteBackward = unit => {\n        if (QuickInsertEditor.isOpenedToolbar(editor)) {\n            QuickInsertEditor.closeQuickInsertToolbar(editor);\n        }\n        deleteBackward(unit);\n    };\n\n    editor.onChange = () => {\n        onChange();\n\n        if (editor.selection) {\n            const hotkey = getPluginOptions<QuickInsertPluginOptions>(editor, PluginKeys.quickInsert)?.hotkey;\n            const [block] = getBlockAbove(editor);\n            // quick insert plus\n            const editorComponent = editor.injector.get(TheEditorComponent);\n            editorComponent.quickInsertInstance?.checkStatus();\n\n            if (presseingQuickInsertHotkey && Node.string(block) === hotkey) {\n                QuickInsertEditor.openQuickInsertToolbar(editor, editorComponent.quickToolbarItems);\n                presseingQuickInsertHotkey = false;\n                return;\n            } else {\n                presseingQuickInsertHotkey = false;\n            }\n\n            if (QuickInsertEditor.isOpenedToolbar(editor) && !isPureEmptyParagraph(editor, block) && Node.string(block) !== hotkey) {\n                QuickInsertEditor.closeQuickInsertToolbar(editor);\n            }\n        }\n    };\n\n    return editor;\n};\n\nexport const createQuickInsertPlugin = createPluginFactory<QuickInsertPluginOptions>({\n    key: PluginKeys.quickInsert,\n    withOverrides: withQuickInsert,\n    options: {\n        hotkey: '/'\n    }\n});\n\nexport const allowOpenQuickToolbar = (editor: Editor, allowTypes: ElementKinds[]) => {\n    const [, path] = getBlockAbove(editor);\n    const parentNode = Node.parent(editor, path);\n    if (path.length === 1 || (parentNode && allowTypes.includes(parentNode.type))) {\n        return true;\n    }\n    return false;\n};\n"]}