@worktile/theia 13.0.0-next.1 → 13.0.0

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

@@ -1,78 +1,78 @@
-import { Element } from 'slate';
-import { PluginKeys } from '../../interfaces';
-import { cloneDeep } 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
-    }
-});
+import { Element } from 'slate';
+import { PluginKeys } from '../../interfaces';
+import { cloneDeep } 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 { cloneDeep } 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

@@ -1,28 +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
-});
+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/remove-empty-nodes.mjs

@@ -1,18 +1,18 @@
-import { Node, Transforms } from 'slate';
-import { castArray } from '../../utils/cast-array';
-/**
- * Remove nodes with empty text.
- */
-export const withRemoveEmptyNodes = (options) => (editor) => {
-    const types = castArray(options.type);
-    const { normalizeNode } = editor;
-    editor.normalizeNode = ([node, path]) => {
-        if (node.type && types.includes(node.type) && Node.string(node) === '') {
-            Transforms.removeNodes(editor, { at: path });
-            return;
-        }
-        normalizeNode([node, path]);
-    };
-    return editor;
-};
+import { Node, Transforms } from 'slate';
+import { castArray } from '../../utils/cast-array';
+/**
+ * Remove nodes with empty text.
+ */
+export const withRemoveEmptyNodes = (options) => (editor) => {
+    const types = castArray(options.type);
+    const { normalizeNode } = editor;
+    editor.normalizeNode = ([node, path]) => {
+        if (node.type && types.includes(node.type) && Node.string(node) === '') {
+            Transforms.removeNodes(editor, { at: path });
+            return;
+        }
+        normalizeNode([node, path]);
+    };
+    return editor;
+};
 //# sourceMappingURL=data:application/json;base64,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

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

@@ -1,33 +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
-    }
-});
+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/paint-format/paint-format.editor.mjs

@@ -1,123 +1,123 @@
-import { take, skip, filter } from 'rxjs/operators';
-import { Editor, Range } from 'slate';
-import { HistoryEditor } from 'slate-history';
-import { EDITOR_TO_ELEMENT } from 'slate-angular';
-import { PluginKeys, TheEditor } from '../../interfaces';
-import { TheContextService } from '../../services/context.service';
-import { MarkProps, ToolbarActionTypes } from '../../constants';
-import { createPluginFactory } from '../../core';
-import { CONTROL_KEY } from '../../utils';
-import { TableEditor } from '../table/table.editor';
-import * as TheQueries from '../../queries';
-import * as TheTransforms from '../../transforms';
-export const PaintFormatEditor = {
-    formatBrush(editor) {
-        const contextService = editor.injector.get(TheContextService);
-        const obj = {};
-        for (const key of MarkProps) {
-            const k = contextService.paintFormatStatus.marks[key];
-            obj[key] = k || null;
-        }
-        const block = TheQueries.anchorBlock(editor);
-        if (block && Range.isCollapsed(editor.selection)) {
-            // TODO:: 在撤销时有bug, 临时使用withoutSaving处理
-            HistoryEditor.withoutSaving(editor, () => {
-                const path = TheEditor.findPath(editor, block);
-                TheTransforms.setMarks(editor, obj, path);
-            });
-        }
-        else {
-            TheTransforms.setMarks(editor, obj);
-        }
-        PaintFormatEditor.cancelFormatBrushStatus(editor);
-    },
-    isActive(editor) {
-        const contextService = editor.injector.get(TheContextService);
-        const res = contextService.paintFormatStatus.isActive;
-        return res;
-    },
-    enableFormatBrush(editor) {
-        const contextService = editor.injector.get(TheContextService);
-        if (contextService.paintFormatStatus.isActive) {
-            return PaintFormatEditor.cancelFormatBrushStatus(editor);
-        }
-        contextService.paintFormatStatus = {
-            isActive: true,
-            marks: TheQueries.getSelectionMarks(editor)
-        };
-        const element = EDITOR_TO_ELEMENT.get(editor);
-        element.classList.add('pointer-paint');
-        contextService.onMouseUp$
-            .pipe(skip(1), filter(event => element.contains(event.target)), take(1))
-            .subscribe((event) => {
-            if (contextService.paintFormatStatus.isActive) {
-                PaintFormatEditor.formatBrush(editor);
-            }
-        });
-        editor.onChange();
-    },
-    cancelFormatBrushStatus(editor) {
-        const contextService = editor.injector.get(TheContextService);
-        contextService.paintFormatStatus = {
-            isActive: false,
-            marks: {}
-        };
-        const element = EDITOR_TO_ELEMENT.get(editor);
-        element.classList.remove('pointer-paint');
-        editor.onChange();
-    }
-};
-export const createPaintFormatPlugin = createPluginFactory({
-    key: PluginKeys.paintFormat,
-    toolbarItems: [
-        {
-            key: ToolbarActionTypes.undo,
-            icon: 'undo',
-            name: '撤销',
-            shortcutKey: `${CONTROL_KEY}+Z`,
-            execute: (editor) => editor.undo()
-        },
-        {
-            key: ToolbarActionTypes.redo,
-            icon: 'redo',
-            name: '重做',
-            shortcutKey: `${CONTROL_KEY}+Shift+Z`,
-            execute: (editor) => editor.redo()
-        },
-        {
-            key: ToolbarActionTypes.paintformat,
-            icon: 'paintformat',
-            name: '格式刷',
-            execute: PaintFormatEditor.enableFormatBrush,
-            active: PaintFormatEditor.isActive
-        },
-        {
-            key: ToolbarActionTypes.clean,
-            icon: 'clean',
-            name: '清除格式',
-            execute: (editor) => {
-                const { selection } = editor;
-                if (!selection) {
-                    return;
-                }
-                if (TableEditor.clearMark(editor)) {
-                    return;
-                }
-                if (Range.isCollapsed(selection)) {
-                    const marks = Editor.marks(editor);
-                    for (const key of Object.keys(marks)) {
-                        Editor.removeMark(editor, key);
-                    }
-                }
-                else {
-                    const unsetMarks = {};
-                    MarkProps.forEach(key => {
-                        unsetMarks[key] = null;
-                    });
-                    TheTransforms.setMarks(editor, unsetMarks);
-                }
-            }
-        }
-    ]
-});
+import { take, skip, filter } from 'rxjs/operators';
+import { Editor, Range } from 'slate';
+import { HistoryEditor } from 'slate-history';
+import { EDITOR_TO_ELEMENT } from 'slate-angular';
+import { PluginKeys, TheEditor } from '../../interfaces';
+import { TheContextService } from '../../services/context.service';
+import { MarkProps, ToolbarActionTypes } from '../../constants';
+import { createPluginFactory } from '../../core';
+import { CONTROL_KEY } from '../../utils';
+import { TableEditor } from '../table/table.editor';
+import * as TheQueries from '../../queries';
+import * as TheTransforms from '../../transforms';
+export const PaintFormatEditor = {
+    formatBrush(editor) {
+        const contextService = editor.injector.get(TheContextService);
+        const obj = {};
+        for (const key of MarkProps) {
+            const k = contextService.paintFormatStatus.marks[key];
+            obj[key] = k || null;
+        }
+        const block = TheQueries.anchorBlock(editor);
+        if (block && Range.isCollapsed(editor.selection)) {
+            // TODO:: 在撤销时有bug, 临时使用withoutSaving处理
+            HistoryEditor.withoutSaving(editor, () => {
+                const path = TheEditor.findPath(editor, block);
+                TheTransforms.setMarks(editor, obj, path);
+            });
+        }
+        else {
+            TheTransforms.setMarks(editor, obj);
+        }
+        PaintFormatEditor.cancelFormatBrushStatus(editor);
+    },
+    isActive(editor) {
+        const contextService = editor.injector.get(TheContextService);
+        const res = contextService.paintFormatStatus.isActive;
+        return res;
+    },
+    enableFormatBrush(editor) {
+        const contextService = editor.injector.get(TheContextService);
+        if (contextService.paintFormatStatus.isActive) {
+            return PaintFormatEditor.cancelFormatBrushStatus(editor);
+        }
+        contextService.paintFormatStatus = {
+            isActive: true,
+            marks: TheQueries.getSelectionMarks(editor)
+        };
+        const element = EDITOR_TO_ELEMENT.get(editor);
+        element.classList.add('pointer-paint');
+        contextService.onMouseUp$
+            .pipe(skip(1), filter(event => element.contains(event.target)), take(1))
+            .subscribe((event) => {
+            if (contextService.paintFormatStatus.isActive) {
+                PaintFormatEditor.formatBrush(editor);
+            }
+        });
+        editor.onChange();
+    },
+    cancelFormatBrushStatus(editor) {
+        const contextService = editor.injector.get(TheContextService);
+        contextService.paintFormatStatus = {
+            isActive: false,
+            marks: {}
+        };
+        const element = EDITOR_TO_ELEMENT.get(editor);
+        element.classList.remove('pointer-paint');
+        editor.onChange();
+    }
+};
+export const createPaintFormatPlugin = createPluginFactory({
+    key: PluginKeys.paintFormat,
+    toolbarItems: [
+        {
+            key: ToolbarActionTypes.undo,
+            icon: 'undo',
+            name: '撤销',
+            shortcutKey: `${CONTROL_KEY}+Z`,
+            execute: (editor) => editor.undo()
+        },
+        {
+            key: ToolbarActionTypes.redo,
+            icon: 'redo',
+            name: '重做',
+            shortcutKey: `${CONTROL_KEY}+Shift+Z`,
+            execute: (editor) => editor.redo()
+        },
+        {
+            key: ToolbarActionTypes.paintformat,
+            icon: 'paintformat',
+            name: '格式刷',
+            execute: PaintFormatEditor.enableFormatBrush,
+            active: PaintFormatEditor.isActive
+        },
+        {
+            key: ToolbarActionTypes.clean,
+            icon: 'clean',
+            name: '清除格式',
+            execute: (editor) => {
+                const { selection } = editor;
+                if (!selection) {
+                    return;
+                }
+                if (TableEditor.clearMark(editor)) {
+                    return;
+                }
+                if (Range.isCollapsed(selection)) {
+                    const marks = Editor.marks(editor);
+                    for (const key of Object.keys(marks)) {
+                        Editor.removeMark(editor, key);
+                    }
+                }
+                else {
+                    const unsetMarks = {};
+                    MarkProps.forEach(key => {
+                        unsetMarks[key] = null;
+                    });
+                    TheTransforms.setMarks(editor, unsetMarks);
+                }
+            }
+        }
+    ]
+});
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"paint-format.editor.js","sourceRoot":"","sources":["../../../../../packages/src/plugins/paint-format/paint-format.editor.ts"],"names":[],"mappings":"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","sourcesContent":["import { take, skip, filter } from 'rxjs/operators';\nimport { Editor, Range } from 'slate';\nimport { HistoryEditor } from 'slate-history';\nimport { EDITOR_TO_ELEMENT } from 'slate-angular';\nimport { PluginKeys, TheEditor } from '../../interfaces';\nimport { TheContextService } from '../../services/context.service';\nimport { MarkProps, MarkTypes, ToolbarActionTypes } from '../../constants';\nimport { createPluginFactory } from '../../core';\nimport { CONTROL_KEY } from '../../utils';\nimport { TableEditor } from '../table/table.editor';\nimport * as TheQueries from '../../queries';\nimport * as TheTransforms from '../../transforms';\n\nexport const PaintFormatEditor = {\n    formatBrush(editor: TheEditor) {\n        const contextService = editor.injector.get(TheContextService);\n        const obj = {};\n        for (const key of MarkProps) {\n            const k = contextService.paintFormatStatus.marks[key];\n            obj[key] = k || null;\n        }\n        const block = TheQueries.anchorBlock(editor);\n        if (block && Range.isCollapsed(editor.selection)) {\n            // TODO:: 在撤销时有bug, 临时使用withoutSaving处理\n            HistoryEditor.withoutSaving(editor, () => {\n                const path = TheEditor.findPath(editor, block);\n                TheTransforms.setMarks(editor, obj, path);\n            });\n        } else {\n            TheTransforms.setMarks(editor, obj);\n        }\n        PaintFormatEditor.cancelFormatBrushStatus(editor);\n    },\n    isActive(editor: TheEditor) {\n        const contextService = editor.injector.get(TheContextService);\n        const res = contextService.paintFormatStatus.isActive;\n        return res;\n    },\n    enableFormatBrush(editor: TheEditor) {\n        const contextService = editor.injector.get(TheContextService);\n        if (contextService.paintFormatStatus.isActive) {\n            return PaintFormatEditor.cancelFormatBrushStatus(editor);\n        }\n        contextService.paintFormatStatus = {\n            isActive: true,\n            marks: TheQueries.getSelectionMarks(editor)\n        };\n        const element = EDITOR_TO_ELEMENT.get(editor);\n        element.classList.add('pointer-paint');\n        contextService.onMouseUp$\n            .pipe(\n                skip(1),\n                filter(event => element.contains(event.target as Element)),\n                take(1)\n            )\n            .subscribe((event: MouseEvent) => {\n                if (contextService.paintFormatStatus.isActive) {\n                    PaintFormatEditor.formatBrush(editor);\n                }\n            });\n        editor.onChange();\n    },\n    cancelFormatBrushStatus(editor: TheEditor) {\n        const contextService = editor.injector.get(TheContextService);\n        contextService.paintFormatStatus = {\n            isActive: false,\n            marks: {}\n        };\n        const element = EDITOR_TO_ELEMENT.get(editor);\n        element.classList.remove('pointer-paint');\n        editor.onChange();\n    }\n};\n\nexport const createPaintFormatPlugin = createPluginFactory({\n    key: PluginKeys.paintFormat,\n    toolbarItems: [\n        {\n            key: ToolbarActionTypes.undo,\n            icon: 'undo',\n            name: '撤销',\n            shortcutKey: `${CONTROL_KEY}+Z`,\n            execute: (editor: TheEditor) => editor.undo()\n        },\n        {\n            key: ToolbarActionTypes.redo,\n            icon: 'redo',\n            name: '重做',\n            shortcutKey: `${CONTROL_KEY}+Shift+Z`,\n            execute: (editor: TheEditor) => editor.redo()\n        },\n        {\n            key: ToolbarActionTypes.paintformat,\n            icon: 'paintformat',\n            name: '格式刷',\n            execute: PaintFormatEditor.enableFormatBrush,\n            active: PaintFormatEditor.isActive\n        },\n        {\n            key: ToolbarActionTypes.clean,\n            icon: 'clean',\n            name: '清除格式',\n            execute: (editor: TheEditor) => {\n                const { selection } = editor;\n                if (!selection) {\n                    return;\n                }\n\n                if (TableEditor.clearMark(editor)) {\n                    return;\n                }\n\n                if (Range.isCollapsed(selection)) {\n                    const marks = Editor.marks(editor);\n                    for (const key of Object.keys(marks)) {\n                        Editor.removeMark(editor, key);\n                    }\n                } else {\n                    const unsetMarks: { [key in MarkTypes]?: null | string } = {};\n                    MarkProps.forEach(key => {\n                        unsetMarks[key] = null;\n                    });\n                    TheTransforms.setMarks(editor, unsetMarks);\n                }\n            }\n        }\n    ]\n});\n"]}