@worktile/theia 3.0.8 → 3.0.9

package/esm2015/plugins/common/block-card.plugin.js

@@ -1,287 +1,287 @@
-import { Editor, Node, Range, Path, Transforms } from 'slate';
-import { HistoryEditor } from 'slate-history';
-import { AngularEditor, hotkeys, hasBlockCard, isCardLeft, FAKE_RIGHT_BLOCK_CARD_OFFSET } from 'slate-angular';
-import { PluginKeys } from '../../interfaces';
-import { createPluginFactory } from '../../core';
-import { createEmptyParagraph } from '../../utils/create-empty-paragraph';
-import { insertParagraph } from '../../transforms/insert-paragraph';
-import * as TheTransforms from '../../transforms';
-import * as TheQueries from '../../queries';
-export const withBlockCard = (editor) => {
-    const { insertBreak, deleteBackward, onKeydown, deleteForward, insertData, insertText } = editor;
-    editor.insertBreak = () => {
-        const domSelection = window.getSelection();
-        const anchorNode = domSelection.anchorNode;
-        if (domSelection && domSelection.isCollapsed && hasBlockCard(domSelection)) {
-            const isLeftCursor = isCardLeft(anchorNode);
-            const cardEntry = AngularEditor.toSlateCardEntry(editor, anchorNode);
-            const cursorRootPath = cardEntry[1];
-            TheTransforms.insertParagraph(editor, isLeftCursor ? cursorRootPath : Path.next(cursorRootPath));
-            if (!isLeftCursor) {
-                Transforms.select(editor, Path.next(cursorRootPath));
-            }
-            return;
-        }
-        insertBreak();
-    };
-    editor.deleteBackward = unit => {
-        const domSelection = window.getSelection();
-        const anchorNode = domSelection.anchorNode;
-        if (domSelection && domSelection.isCollapsed && hasBlockCard(domSelection)) {
-            const isLeftCursor = isCardLeft(anchorNode);
-            const cardEntry = AngularEditor.toSlateCardEntry(editor, anchorNode);
-            const cursorRootPath = cardEntry[1];
-            if (isLeftCursor) {
-                const previousPath = Path.hasPrevious(cursorRootPath) && Path.previous(cursorRootPath);
-                if (!previousPath) {
-                    return;
-                }
-                if (previousPath && TheQueries.isEmptyParagraphByPath(editor, previousPath)) {
-                    Transforms.removeNodes(editor, {
-                        at: previousPath
-                    });
-                    return;
-                }
-                HistoryEditor.withoutMerging(editor, () => {
-                    Transforms.select(editor, Editor.end(editor, previousPath));
-                });
-                return;
-            }
-            else {
-                TheTransforms.insertParagraph(editor, cursorRootPath);
-                Transforms.select(editor, cursorRootPath);
-                Transforms.removeNodes(editor, { at: Path.next(cursorRootPath) });
-                return;
-            }
-        }
-        const blockCard = TheQueries.getBlockCardAbove(editor);
-        const beforePoint = Editor.before(editor, editor.selection.anchor);
-        const beforeBlockCard = TheQueries.getBlockCardAbove(editor, { at: beforePoint });
-        if (!blockCard && beforeBlockCard) {
-            if (TheQueries.isBlockAboveEmpty(editor)) {
-                const [node, path] = Editor.parent(editor, editor.selection.anchor.path);
-                HistoryEditor.withoutMerging(editor, () => {
-                    const rightCursor = { path: beforeBlockCard[1], offset: FAKE_RIGHT_BLOCK_CARD_OFFSET };
-                    Transforms.select(editor, { anchor: rightCursor, focus: rightCursor });
-                });
-                Transforms.delete(editor, { at: path });
-                return;
-            }
-            else {
-                Transforms.delete(editor, { at: beforeBlockCard[1] });
-            }
-            return;
-        }
-        deleteBackward(unit);
-    };
-    editor.deleteForward = unit => {
-        const domSelection = window.getSelection();
-        const anchorNode = domSelection.anchorNode;
-        if (domSelection && domSelection.isCollapsed && hasBlockCard(domSelection)) {
-            const isLeftCursor = isCardLeft(anchorNode);
-            const cardEntry = AngularEditor.toSlateCardEntry(editor, anchorNode);
-            const cursorRootPath = cardEntry[1];
-            if (isLeftCursor) {
-                TheTransforms.insertParagraph(editor, cursorRootPath);
-                Transforms.select(editor, cursorRootPath);
-                Transforms.removeNodes(editor, { at: Path.next(cursorRootPath) });
-                return;
-            }
-            else {
-                const nextPath = Path.next(cursorRootPath);
-                HistoryEditor.withoutMerging(editor, () => {
-                    Transforms.select(editor, Editor.start(editor, nextPath));
-                });
-                return;
-            }
-        }
-        const blockCard = TheQueries.getBlockCardAbove(editor);
-        const afterPoint = Editor.after(editor, editor.selection.anchor);
-        const afterBlockCard = TheQueries.getBlockCardAbove(editor, { at: afterPoint });
-        if (!blockCard && afterBlockCard) {
-            if (TheQueries.isBlockAboveEmpty(editor)) {
-                HistoryEditor.withoutMerging(editor, () => {
-                    const leftCursor = { path: afterBlockCard[1], offset: -1 };
-                    Transforms.select(editor, { anchor: leftCursor, focus: leftCursor });
-                });
-                Transforms.delete(editor, { at: Path.previous(afterBlockCard[1]) });
-                return;
-            }
-            return;
-        }
-        deleteForward(unit);
-    };
-    editor.onKeydown = (event) => {
-        const domSelection = window.getSelection();
-        const anchorNode = domSelection.anchorNode;
-        const nativeEvent = event;
-        const { selection } = editor;
-        const isMoveBackward = hotkeys.isMoveBackward(nativeEvent);
-        const isMoveForward = hotkeys.isMoveForward(nativeEvent);
-        const isMoveUp = hotkeys.isMoveUp(nativeEvent);
-        const isMoveDown = hotkeys.isMoveDown(nativeEvent);
-        const isCollapsed = selection && Range.isCollapsed(selection);
-        const anchorEntry = TheQueries.anchorBlockEntry(editor);
-        // block card cursor
-        if (anchorNode && hasBlockCard(domSelection)) {
-            const isCardLeftCursor = isCardLeft(anchorNode);
-            if (isMoveUp) {
-                const [, path] = AngularEditor.toSlateCardEntry(editor, anchorNode);
-                const previousPath = Path.hasPrevious(path) && Path.previous(path);
-                const previousNode = previousPath && TheQueries.getNode(editor, previousPath);
-                if (previousNode && editor.isBlockCard(previousNode)) {
-                    AngularEditor.moveBlockCard(editor, previousNode, { direction: isCardLeftCursor ? 'left' : 'right' });
-                }
-                else {
-                    const before = Editor.before(editor, path);
-                    if (before) {
-                        Transforms.select(editor, before);
-                    }
-                }
-                nativeEvent.preventDefault();
-                return;
-            }
-            if (isMoveDown) {
-                const [, path] = AngularEditor.toSlateCardEntry(editor, anchorNode);
-                const nextPath = Path.next(path);
-                const nextNode = TheQueries.getNode(editor, nextPath);
-                if (nextNode && editor.isBlockCard(nextNode)) {
-                    AngularEditor.moveBlockCard(editor, nextNode, { direction: isCardLeftCursor ? 'left' : 'right' });
-                }
-                else {
-                    const after = Editor.after(editor, path);
-                    if (after) {
-                        Transforms.select(editor, Editor.after(editor, path));
-                    }
-                }
-                nativeEvent.preventDefault();
-                return;
-            }
-            // → + right-block-card
-            if (isMoveForward && !isCardLeftCursor) {
-                nativeEvent.preventDefault();
-                const [, path] = AngularEditor.toSlateCardEntry(editor, anchorNode);
-                const nextPath = Path.next(path);
-                const nextNode = TheQueries.getNode(editor, nextPath);
-                if (nextNode && editor.isBlockCard(nextNode)) {
-                    event.preventDefault();
-                    AngularEditor.moveBlockCard(editor, nextNode, { direction: 'left' });
-                    return;
-                }
-                const after = Editor.after(editor, path);
-                if (after) {
-                    Transforms.select(editor, Editor.after(editor, path));
-                }
-                return;
-            }
-            // ← + left-block-card
-            if (isMoveBackward && isCardLeftCursor) {
-                nativeEvent.preventDefault();
-                const [, path] = AngularEditor.toSlateCardEntry(editor, anchorNode);
-                const previousPath = Path.hasPrevious(path) && Path.previous(path);
-                const previousNode = previousPath && TheQueries.getNode(editor, previousPath);
-                if (previousNode && editor.isBlockCard(previousNode)) {
-                    event.preventDefault();
-                    AngularEditor.moveBlockCard(editor, previousNode, { direction: 'right' });
-                    return;
-                }
-                const before = Editor.before(editor, path);
-                if (before) {
-                    Transforms.select(editor, before);
-                }
-                return;
-            }
-            // move to card center
-            if ((isCardLeftCursor && isMoveForward) || (!isCardLeftCursor && isMoveBackward)) {
-                nativeEvent.preventDefault();
-                const [, path] = AngularEditor.toSlateCardEntry(editor, anchorNode);
-                Transforms.select(editor, isCardLeftCursor ? Editor.start(editor, path) : Editor.end(editor, path));
-                return;
-            }
-        }
-        // block card center
-        if (isCollapsed && (isMoveUp || isMoveDown) && anchorEntry) {
-            const [block, path] = anchorEntry;
-            if (editor.isBlockCard(block)) {
-                event.preventDefault();
-                Transforms.select(editor, isMoveUp ? Editor.before(editor, path) : Editor.after(editor, path));
-                return;
-            }
-        }
-        if (isCollapsed && (isMoveBackward || isMoveForward) && anchorEntry) {
-            const [block] = anchorEntry;
-            if (editor.isBlockCard(block)) {
-                event.preventDefault();
-                AngularEditor.moveBlockCard(editor, block, { direction: isMoveBackward ? 'left' : 'right' });
-                return;
-            }
-        }
-        // move to block card cursor
-        if (isCollapsed && isMoveBackward && Editor.isStart(editor, selection.anchor, selection.anchor.path.slice(0, 1))) {
-            const currentPath = selection.anchor.path.slice(0, 1);
-            if (currentPath[0] > 0) {
-                const previousNode = Node.get(editor, Path.previous(currentPath));
-                if (previousNode && editor.isBlockCard(previousNode)) {
-                    event.preventDefault();
-                    AngularEditor.moveBlockCard(editor, previousNode, { direction: 'right' });
-                    return;
-                }
-            }
-        }
-        if (isCollapsed && isMoveForward && Editor.isEnd(editor, selection.anchor, selection.anchor.path.slice(0, 1))) {
-            const currentPath = selection.anchor.path.slice(0, 1);
-            if (currentPath[0] < editor.children.length - 1) {
-                const previousNode = Node.get(editor, Path.next(currentPath));
-                if (previousNode && editor.isBlockCard(previousNode)) {
-                    event.preventDefault();
-                    AngularEditor.moveBlockCard(editor, previousNode, { direction: 'left' });
-                    return;
-                }
-            }
-        }
-        onKeydown(event);
-    };
-    editor.insertData = (data) => {
-        const domSelection = window.getSelection();
-        const anchorNode = domSelection.anchorNode;
-        if (domSelection && domSelection.isCollapsed && hasBlockCard(domSelection)) {
-            const isLeftCursor = isCardLeft(anchorNode);
-            const cardEntry = AngularEditor.toSlateCardEntry(editor, anchorNode);
-            const cursorRootPath = cardEntry[1];
-            if (isLeftCursor) {
-                Transforms.insertNodes(editor, createEmptyParagraph(), { at: cursorRootPath });
-                Transforms.select(editor, cursorRootPath);
-            }
-            else {
-                Transforms.insertNodes(editor, createEmptyParagraph(), { at: Path.next(cursorRootPath) });
-                Transforms.select(editor, Path.next(cursorRootPath));
-            }
-        }
-        insertData(data);
-    };
-    editor.insertText = (text) => {
-        const domSelection = window.getSelection();
-        const anchorNode = domSelection === null || domSelection === void 0 ? void 0 : domSelection.anchorNode;
-        if (AngularEditor.isBlockCardLeftCursor(editor) || AngularEditor.isBlockCardRightCursor(editor)) {
-            const isLeftCursor = isCardLeft(anchorNode);
-            const cardEntry = AngularEditor.toSlateCardEntry(editor, anchorNode);
-            const cursorRootPath = cardEntry[1];
-            if (isLeftCursor) {
-                insertParagraph(editor, cursorRootPath);
-                Transforms.select(editor, cursorRootPath);
-            }
-            else {
-                const nextPath = Path.next(cursorRootPath);
-                insertParagraph(editor, nextPath);
-                Transforms.select(editor, nextPath);
-            }
-        }
-        insertText(text);
-    };
-    return editor;
-};
-export const createBlockCardPlugin = createPluginFactory({
-    key: PluginKeys.blockCard,
-    withOverrides: withBlockCard
-});
+import { Editor, Node, Range, Path, Transforms } from 'slate';
+import { HistoryEditor } from 'slate-history';
+import { AngularEditor, hotkeys, hasBlockCard, isCardLeft, FAKE_RIGHT_BLOCK_CARD_OFFSET } from 'slate-angular';
+import { PluginKeys } from '../../interfaces';
+import { createPluginFactory } from '../../core';
+import { createEmptyParagraph } from '../../utils/create-empty-paragraph';
+import { insertParagraph } from '../../transforms/insert-paragraph';
+import * as TheTransforms from '../../transforms';
+import * as TheQueries from '../../queries';
+export const withBlockCard = (editor) => {
+    const { insertBreak, deleteBackward, onKeydown, deleteForward, insertData, insertText } = editor;
+    editor.insertBreak = () => {
+        const domSelection = window.getSelection();
+        const anchorNode = domSelection.anchorNode;
+        if (domSelection && domSelection.isCollapsed && hasBlockCard(domSelection)) {
+            const isLeftCursor = isCardLeft(anchorNode);
+            const cardEntry = AngularEditor.toSlateCardEntry(editor, anchorNode);
+            const cursorRootPath = cardEntry[1];
+            TheTransforms.insertParagraph(editor, isLeftCursor ? cursorRootPath : Path.next(cursorRootPath));
+            if (!isLeftCursor) {
+                Transforms.select(editor, Path.next(cursorRootPath));
+            }
+            return;
+        }
+        insertBreak();
+    };
+    editor.deleteBackward = unit => {
+        const domSelection = window.getSelection();
+        const anchorNode = domSelection.anchorNode;
+        if (domSelection && domSelection.isCollapsed && hasBlockCard(domSelection)) {
+            const isLeftCursor = isCardLeft(anchorNode);
+            const cardEntry = AngularEditor.toSlateCardEntry(editor, anchorNode);
+            const cursorRootPath = cardEntry[1];
+            if (isLeftCursor) {
+                const previousPath = Path.hasPrevious(cursorRootPath) && Path.previous(cursorRootPath);
+                if (!previousPath) {
+                    return;
+                }
+                if (previousPath && TheQueries.isEmptyParagraphByPath(editor, previousPath)) {
+                    Transforms.removeNodes(editor, {
+                        at: previousPath
+                    });
+                    return;
+                }
+                HistoryEditor.withoutMerging(editor, () => {
+                    Transforms.select(editor, Editor.end(editor, previousPath));
+                });
+                return;
+            }
+            else {
+                TheTransforms.insertParagraph(editor, cursorRootPath);
+                Transforms.select(editor, cursorRootPath);
+                Transforms.removeNodes(editor, { at: Path.next(cursorRootPath) });
+                return;
+            }
+        }
+        const blockCard = TheQueries.getBlockCardAbove(editor);
+        const beforePoint = Editor.before(editor, editor.selection.anchor);
+        const beforeBlockCard = TheQueries.getBlockCardAbove(editor, { at: beforePoint });
+        if (!blockCard && beforeBlockCard) {
+            if (TheQueries.isBlockAboveEmpty(editor)) {
+                const [node, path] = Editor.parent(editor, editor.selection.anchor.path);
+                HistoryEditor.withoutMerging(editor, () => {
+                    const rightCursor = { path: beforeBlockCard[1], offset: FAKE_RIGHT_BLOCK_CARD_OFFSET };
+                    Transforms.select(editor, { anchor: rightCursor, focus: rightCursor });
+                });
+                Transforms.delete(editor, { at: path });
+                return;
+            }
+            else {
+                Transforms.delete(editor, { at: beforeBlockCard[1] });
+            }
+            return;
+        }
+        deleteBackward(unit);
+    };
+    editor.deleteForward = unit => {
+        const domSelection = window.getSelection();
+        const anchorNode = domSelection.anchorNode;
+        if (domSelection && domSelection.isCollapsed && hasBlockCard(domSelection)) {
+            const isLeftCursor = isCardLeft(anchorNode);
+            const cardEntry = AngularEditor.toSlateCardEntry(editor, anchorNode);
+            const cursorRootPath = cardEntry[1];
+            if (isLeftCursor) {
+                TheTransforms.insertParagraph(editor, cursorRootPath);
+                Transforms.select(editor, cursorRootPath);
+                Transforms.removeNodes(editor, { at: Path.next(cursorRootPath) });
+                return;
+            }
+            else {
+                const nextPath = Path.next(cursorRootPath);
+                HistoryEditor.withoutMerging(editor, () => {
+                    Transforms.select(editor, Editor.start(editor, nextPath));
+                });
+                return;
+            }
+        }
+        const blockCard = TheQueries.getBlockCardAbove(editor);
+        const afterPoint = Editor.after(editor, editor.selection.anchor);
+        const afterBlockCard = TheQueries.getBlockCardAbove(editor, { at: afterPoint });
+        if (!blockCard && afterBlockCard) {
+            if (TheQueries.isBlockAboveEmpty(editor)) {
+                HistoryEditor.withoutMerging(editor, () => {
+                    const leftCursor = { path: afterBlockCard[1], offset: -1 };
+                    Transforms.select(editor, { anchor: leftCursor, focus: leftCursor });
+                });
+                Transforms.delete(editor, { at: Path.previous(afterBlockCard[1]) });
+                return;
+            }
+            return;
+        }
+        deleteForward(unit);
+    };
+    editor.onKeydown = (event) => {
+        const domSelection = window.getSelection();
+        const anchorNode = domSelection.anchorNode;
+        const nativeEvent = event;
+        const { selection } = editor;
+        const isMoveBackward = hotkeys.isMoveBackward(nativeEvent);
+        const isMoveForward = hotkeys.isMoveForward(nativeEvent);
+        const isMoveUp = hotkeys.isMoveUp(nativeEvent);
+        const isMoveDown = hotkeys.isMoveDown(nativeEvent);
+        const isCollapsed = selection && Range.isCollapsed(selection);
+        const anchorEntry = TheQueries.anchorBlockEntry(editor);
+        // block card cursor
+        if (anchorNode && hasBlockCard(domSelection)) {
+            const isCardLeftCursor = isCardLeft(anchorNode);
+            if (isMoveUp) {
+                const [, path] = AngularEditor.toSlateCardEntry(editor, anchorNode);
+                const previousPath = Path.hasPrevious(path) && Path.previous(path);
+                const previousNode = previousPath && TheQueries.getNode(editor, previousPath);
+                if (previousNode && editor.isBlockCard(previousNode)) {
+                    AngularEditor.moveBlockCard(editor, previousNode, { direction: isCardLeftCursor ? 'left' : 'right' });
+                }
+                else {
+                    const before = Editor.before(editor, path);
+                    if (before) {
+                        Transforms.select(editor, before);
+                    }
+                }
+                nativeEvent.preventDefault();
+                return;
+            }
+            if (isMoveDown) {
+                const [, path] = AngularEditor.toSlateCardEntry(editor, anchorNode);
+                const nextPath = Path.next(path);
+                const nextNode = TheQueries.getNode(editor, nextPath);
+                if (nextNode && editor.isBlockCard(nextNode)) {
+                    AngularEditor.moveBlockCard(editor, nextNode, { direction: isCardLeftCursor ? 'left' : 'right' });
+                }
+                else {
+                    const after = Editor.after(editor, path);
+                    if (after) {
+                        Transforms.select(editor, Editor.after(editor, path));
+                    }
+                }
+                nativeEvent.preventDefault();
+                return;
+            }
+            // → + right-block-card
+            if (isMoveForward && !isCardLeftCursor) {
+                nativeEvent.preventDefault();
+                const [, path] = AngularEditor.toSlateCardEntry(editor, anchorNode);
+                const nextPath = Path.next(path);
+                const nextNode = TheQueries.getNode(editor, nextPath);
+                if (nextNode && editor.isBlockCard(nextNode)) {
+                    event.preventDefault();
+                    AngularEditor.moveBlockCard(editor, nextNode, { direction: 'left' });
+                    return;
+                }
+                const after = Editor.after(editor, path);
+                if (after) {
+                    Transforms.select(editor, Editor.after(editor, path));
+                }
+                return;
+            }
+            // ← + left-block-card
+            if (isMoveBackward && isCardLeftCursor) {
+                nativeEvent.preventDefault();
+                const [, path] = AngularEditor.toSlateCardEntry(editor, anchorNode);
+                const previousPath = Path.hasPrevious(path) && Path.previous(path);
+                const previousNode = previousPath && TheQueries.getNode(editor, previousPath);
+                if (previousNode && editor.isBlockCard(previousNode)) {
+                    event.preventDefault();
+                    AngularEditor.moveBlockCard(editor, previousNode, { direction: 'right' });
+                    return;
+                }
+                const before = Editor.before(editor, path);
+                if (before) {
+                    Transforms.select(editor, before);
+                }
+                return;
+            }
+            // move to card center
+            if ((isCardLeftCursor && isMoveForward) || (!isCardLeftCursor && isMoveBackward)) {
+                nativeEvent.preventDefault();
+                const [, path] = AngularEditor.toSlateCardEntry(editor, anchorNode);
+                Transforms.select(editor, isCardLeftCursor ? Editor.start(editor, path) : Editor.end(editor, path));
+                return;
+            }
+        }
+        // block card center
+        if (isCollapsed && (isMoveUp || isMoveDown) && anchorEntry) {
+            const [block, path] = anchorEntry;
+            if (editor.isBlockCard(block)) {
+                event.preventDefault();
+                Transforms.select(editor, isMoveUp ? Editor.before(editor, path) : Editor.after(editor, path));
+                return;
+            }
+        }
+        if (isCollapsed && (isMoveBackward || isMoveForward) && anchorEntry) {
+            const [block] = anchorEntry;
+            if (editor.isBlockCard(block)) {
+                event.preventDefault();
+                AngularEditor.moveBlockCard(editor, block, { direction: isMoveBackward ? 'left' : 'right' });
+                return;
+            }
+        }
+        // move to block card cursor
+        if (isCollapsed && isMoveBackward && Editor.isStart(editor, selection.anchor, selection.anchor.path.slice(0, 1))) {
+            const currentPath = selection.anchor.path.slice(0, 1);
+            if (currentPath[0] > 0) {
+                const previousNode = Node.get(editor, Path.previous(currentPath));
+                if (previousNode && editor.isBlockCard(previousNode)) {
+                    event.preventDefault();
+                    AngularEditor.moveBlockCard(editor, previousNode, { direction: 'right' });
+                    return;
+                }
+            }
+        }
+        if (isCollapsed && isMoveForward && Editor.isEnd(editor, selection.anchor, selection.anchor.path.slice(0, 1))) {
+            const currentPath = selection.anchor.path.slice(0, 1);
+            if (currentPath[0] < editor.children.length - 1) {
+                const previousNode = Node.get(editor, Path.next(currentPath));
+                if (previousNode && editor.isBlockCard(previousNode)) {
+                    event.preventDefault();
+                    AngularEditor.moveBlockCard(editor, previousNode, { direction: 'left' });
+                    return;
+                }
+            }
+        }
+        onKeydown(event);
+    };
+    editor.insertData = (data) => {
+        const domSelection = window.getSelection();
+        const anchorNode = domSelection.anchorNode;
+        if (domSelection && domSelection.isCollapsed && hasBlockCard(domSelection)) {
+            const isLeftCursor = isCardLeft(anchorNode);
+            const cardEntry = AngularEditor.toSlateCardEntry(editor, anchorNode);
+            const cursorRootPath = cardEntry[1];
+            if (isLeftCursor) {
+                Transforms.insertNodes(editor, createEmptyParagraph(), { at: cursorRootPath });
+                Transforms.select(editor, cursorRootPath);
+            }
+            else {
+                Transforms.insertNodes(editor, createEmptyParagraph(), { at: Path.next(cursorRootPath) });
+                Transforms.select(editor, Path.next(cursorRootPath));
+            }
+        }
+        insertData(data);
+    };
+    editor.insertText = (text) => {
+        const domSelection = window.getSelection();
+        const anchorNode = domSelection === null || domSelection === void 0 ? void 0 : domSelection.anchorNode;
+        if (AngularEditor.isBlockCardLeftCursor(editor) || AngularEditor.isBlockCardRightCursor(editor)) {
+            const isLeftCursor = isCardLeft(anchorNode);
+            const cardEntry = AngularEditor.toSlateCardEntry(editor, anchorNode);
+            const cursorRootPath = cardEntry[1];
+            if (isLeftCursor) {
+                insertParagraph(editor, cursorRootPath);
+                Transforms.select(editor, cursorRootPath);
+            }
+            else {
+                const nextPath = Path.next(cursorRootPath);
+                insertParagraph(editor, nextPath);
+                Transforms.select(editor, nextPath);
+            }
+        }
+        insertText(text);
+    };
+    return editor;
+};
+export const createBlockCardPlugin = createPluginFactory({
+    key: PluginKeys.blockCard,
+    withOverrides: withBlockCard
+});
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"block-card.plugin.js","sourceRoot":"","sources":["../../../../../packages/src/plugins/common/block-card.plugin.ts"],"names":[],"mappings":"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","sourcesContent":["import { Editor, Node, Range, Path, Transforms } from 'slate';\nimport { HistoryEditor } from 'slate-history';\nimport { AngularEditor, hotkeys, hasBlockCard, isCardLeft, FAKE_RIGHT_BLOCK_CARD_OFFSET } from 'slate-angular';\nimport { PluginKeys } from '../../interfaces';\nimport { createPluginFactory } from '../../core';\nimport { createEmptyParagraph } from '../../utils/create-empty-paragraph';\nimport { insertParagraph } from '../../transforms/insert-paragraph';\nimport * as TheTransforms from '../../transforms';\nimport * as TheQueries from '../../queries';\n\nexport const withBlockCard = <T extends Editor>(editor: T): T => {\n    const { insertBreak, deleteBackward, onKeydown, deleteForward, insertData, insertText } = editor;\n\n    editor.insertBreak = () => {\n        const domSelection = window.getSelection();\n        const anchorNode = domSelection.anchorNode;\n        if (domSelection && domSelection.isCollapsed && hasBlockCard(domSelection)) {\n            const isLeftCursor = isCardLeft(anchorNode);\n            const cardEntry = AngularEditor.toSlateCardEntry(editor, anchorNode);\n            const cursorRootPath = cardEntry[1];\n            TheTransforms.insertParagraph(editor, isLeftCursor ? cursorRootPath : Path.next(cursorRootPath));\n            if (!isLeftCursor) {\n                Transforms.select(editor, Path.next(cursorRootPath));\n            }\n            return;\n        }\n        insertBreak();\n    };\n\n    editor.deleteBackward = unit => {\n        const domSelection = window.getSelection();\n        const anchorNode = domSelection.anchorNode;\n        if (domSelection && domSelection.isCollapsed && hasBlockCard(domSelection)) {\n            const isLeftCursor = isCardLeft(anchorNode);\n            const cardEntry = AngularEditor.toSlateCardEntry(editor, anchorNode);\n            const cursorRootPath = cardEntry[1];\n            if (isLeftCursor) {\n                const previousPath = Path.hasPrevious(cursorRootPath) && Path.previous(cursorRootPath);\n                if (!previousPath) {\n                    return;\n                }\n                if (previousPath && TheQueries.isEmptyParagraphByPath(editor, previousPath)) {\n                    Transforms.removeNodes(editor, {\n                        at: previousPath\n                    });\n                    return;\n                }\n                HistoryEditor.withoutMerging(editor, () => {\n                    Transforms.select(editor, Editor.end(editor, previousPath));\n                });\n                return;\n            } else {\n                TheTransforms.insertParagraph(editor, cursorRootPath);\n                Transforms.select(editor, cursorRootPath);\n                Transforms.removeNodes(editor, { at: Path.next(cursorRootPath) });\n                return;\n            }\n        }\n\n        const blockCard = TheQueries.getBlockCardAbove(editor);\n        const beforePoint = Editor.before(editor, editor.selection.anchor);\n        const beforeBlockCard = TheQueries.getBlockCardAbove(editor, { at: beforePoint });\n        if (!blockCard && beforeBlockCard) {\n            if (TheQueries.isBlockAboveEmpty(editor)) {\n                const [node, path] = Editor.parent(editor, editor.selection.anchor.path);\n                HistoryEditor.withoutMerging(editor, () => {\n                    const rightCursor = { path: beforeBlockCard[1], offset: FAKE_RIGHT_BLOCK_CARD_OFFSET };\n                    Transforms.select(editor, { anchor: rightCursor, focus: rightCursor });\n                });\n                Transforms.delete(editor, { at: path });\n                return;\n            } else {\n                Transforms.delete(editor, { at: beforeBlockCard[1] });\n            }\n            return;\n        }\n\n        deleteBackward(unit);\n    };\n\n    editor.deleteForward = unit => {\n        const domSelection = window.getSelection();\n        const anchorNode = domSelection.anchorNode;\n        if (domSelection && domSelection.isCollapsed && hasBlockCard(domSelection)) {\n            const isLeftCursor = isCardLeft(anchorNode);\n            const cardEntry = AngularEditor.toSlateCardEntry(editor, anchorNode);\n            const cursorRootPath = cardEntry[1];\n            if (isLeftCursor) {\n                TheTransforms.insertParagraph(editor, cursorRootPath);\n                Transforms.select(editor, cursorRootPath);\n                Transforms.removeNodes(editor, { at: Path.next(cursorRootPath) });\n                return;\n            } else {\n                const nextPath = Path.next(cursorRootPath);\n                HistoryEditor.withoutMerging(editor, () => {\n                    Transforms.select(editor, Editor.start(editor, nextPath));\n                });\n                return;\n            }\n        }\n\n        const blockCard = TheQueries.getBlockCardAbove(editor);\n        const afterPoint = Editor.after(editor, editor.selection.anchor);\n        const afterBlockCard = TheQueries.getBlockCardAbove(editor, { at: afterPoint });\n        if (!blockCard && afterBlockCard) {\n            if (TheQueries.isBlockAboveEmpty(editor)) {\n                HistoryEditor.withoutMerging(editor, () => {\n                    const leftCursor = { path: afterBlockCard[1], offset: -1 };\n                    Transforms.select(editor, { anchor: leftCursor, focus: leftCursor });\n                });\n                Transforms.delete(editor, { at: Path.previous(afterBlockCard[1]) });\n                return;\n            }\n            return;\n        }\n\n        deleteForward(unit);\n    };\n\n    editor.onKeydown = (event: KeyboardEvent) => {\n        const domSelection = window.getSelection();\n        const anchorNode = domSelection.anchorNode;\n        const nativeEvent = event;\n        const { selection } = editor;\n\n        const isMoveBackward = hotkeys.isMoveBackward(nativeEvent);\n        const isMoveForward = hotkeys.isMoveForward(nativeEvent);\n        const isMoveUp = hotkeys.isMoveUp(nativeEvent);\n        const isMoveDown = hotkeys.isMoveDown(nativeEvent);\n        const isCollapsed = selection && Range.isCollapsed(selection);\n        const anchorEntry = TheQueries.anchorBlockEntry(editor);\n\n        // block card cursor\n        if (anchorNode && hasBlockCard(domSelection)) {\n            const isCardLeftCursor = isCardLeft(anchorNode);\n            if (isMoveUp) {\n                const [, path] = AngularEditor.toSlateCardEntry(editor, anchorNode);\n                const previousPath = Path.hasPrevious(path) && Path.previous(path);\n                const previousNode = previousPath && TheQueries.getNode(editor, previousPath);\n                if (previousNode && editor.isBlockCard(previousNode)) {\n                    AngularEditor.moveBlockCard(editor, previousNode, { direction: isCardLeftCursor ? 'left' : 'right' });\n                } else {\n                    const before = Editor.before(editor, path);\n                    if (before) {\n                        Transforms.select(editor, before);\n                    }\n                }\n                nativeEvent.preventDefault();\n                return;\n            }\n            if (isMoveDown) {\n                const [, path] = AngularEditor.toSlateCardEntry(editor, anchorNode);\n                const nextPath = Path.next(path);\n                const nextNode = TheQueries.getNode(editor, nextPath);\n                if (nextNode && editor.isBlockCard(nextNode)) {\n                    AngularEditor.moveBlockCard(editor, nextNode, { direction: isCardLeftCursor ? 'left' : 'right' });\n                } else {\n                    const after = Editor.after(editor, path);\n                    if (after) {\n                        Transforms.select(editor, Editor.after(editor, path));\n                    }\n                }\n                nativeEvent.preventDefault();\n                return;\n            }\n            // → + right-block-card\n            if (isMoveForward && !isCardLeftCursor) {\n                nativeEvent.preventDefault();\n                const [, path] = AngularEditor.toSlateCardEntry(editor, anchorNode);\n                const nextPath = Path.next(path);\n                const nextNode = TheQueries.getNode(editor, nextPath);\n                if (nextNode && editor.isBlockCard(nextNode)) {\n                    event.preventDefault();\n                    AngularEditor.moveBlockCard(editor, nextNode, { direction: 'left' });\n                    return;\n                }\n                const after = Editor.after(editor, path);\n                if (after) {\n                    Transforms.select(editor, Editor.after(editor, path));\n                }\n                return;\n            }\n            // ← + left-block-card\n            if (isMoveBackward && isCardLeftCursor) {\n                nativeEvent.preventDefault();\n                const [, path] = AngularEditor.toSlateCardEntry(editor, anchorNode);\n                const previousPath = Path.hasPrevious(path) && Path.previous(path);\n                const previousNode = previousPath && TheQueries.getNode(editor, previousPath);\n                if (previousNode && editor.isBlockCard(previousNode)) {\n                    event.preventDefault();\n                    AngularEditor.moveBlockCard(editor, previousNode, { direction: 'right' });\n                    return;\n                }\n                const before = Editor.before(editor, path);\n                if (before) {\n                    Transforms.select(editor, before);\n                }\n                return;\n            }\n            // move to card center\n            if ((isCardLeftCursor && isMoveForward) || (!isCardLeftCursor && isMoveBackward)) {\n                nativeEvent.preventDefault();\n                const [, path] = AngularEditor.toSlateCardEntry(editor, anchorNode);\n                Transforms.select(editor, isCardLeftCursor ? Editor.start(editor, path) : Editor.end(editor, path));\n                return;\n            }\n        }\n        // block card center\n        if (isCollapsed && (isMoveUp || isMoveDown) && anchorEntry) {\n            const [block, path] = anchorEntry;\n            if (editor.isBlockCard(block)) {\n                event.preventDefault();\n                Transforms.select(editor, isMoveUp ? Editor.before(editor, path) : Editor.after(editor, path));\n                return;\n            }\n        }\n        if (isCollapsed && (isMoveBackward || isMoveForward) && anchorEntry) {\n            const [block] = anchorEntry;\n            if (editor.isBlockCard(block)) {\n                event.preventDefault();\n                AngularEditor.moveBlockCard(editor, block, { direction: isMoveBackward ? 'left' : 'right' });\n                return;\n            }\n        }\n        // move to block card cursor\n        if (isCollapsed && isMoveBackward && Editor.isStart(editor, selection.anchor, selection.anchor.path.slice(0, 1))) {\n            const currentPath = selection.anchor.path.slice(0, 1);\n            if (currentPath[0] > 0) {\n                const previousNode = Node.get(editor, Path.previous(currentPath));\n                if (previousNode && editor.isBlockCard(previousNode)) {\n                    event.preventDefault();\n                    AngularEditor.moveBlockCard(editor, previousNode, { direction: 'right' });\n                    return;\n                }\n            }\n        }\n        if (isCollapsed && isMoveForward && Editor.isEnd(editor, selection.anchor, selection.anchor.path.slice(0, 1))) {\n            const currentPath = selection.anchor.path.slice(0, 1);\n            if (currentPath[0] < editor.children.length - 1) {\n                const previousNode = Node.get(editor, Path.next(currentPath));\n                if (previousNode && editor.isBlockCard(previousNode)) {\n                    event.preventDefault();\n                    AngularEditor.moveBlockCard(editor, previousNode, { direction: 'left' });\n                    return;\n                }\n            }\n        }\n\n        onKeydown(event);\n    };\n\n    editor.insertData = (data: DataTransfer) => {\n        const domSelection = window.getSelection();\n        const anchorNode = domSelection.anchorNode;\n        if (domSelection && domSelection.isCollapsed && hasBlockCard(domSelection)) {\n            const isLeftCursor = isCardLeft(anchorNode);\n            const cardEntry = AngularEditor.toSlateCardEntry(editor, anchorNode);\n            const cursorRootPath = cardEntry[1];\n            if (isLeftCursor) {\n                Transforms.insertNodes(editor, createEmptyParagraph(), { at: cursorRootPath });\n                Transforms.select(editor, cursorRootPath);\n            } else {\n                Transforms.insertNodes(editor, createEmptyParagraph(), { at: Path.next(cursorRootPath) });\n                Transforms.select(editor, Path.next(cursorRootPath));\n            }\n        }\n        insertData(data);\n    };\n\n    editor.insertText = (text: string) => {\n        const domSelection = window.getSelection();\n        const anchorNode = domSelection?.anchorNode;\n        if (AngularEditor.isBlockCardLeftCursor(editor) || AngularEditor.isBlockCardRightCursor(editor)) {\n            const isLeftCursor = isCardLeft(anchorNode);\n            const cardEntry = AngularEditor.toSlateCardEntry(editor, anchorNode);\n            const cursorRootPath = cardEntry[1];\n            if (isLeftCursor) {\n                insertParagraph(editor, cursorRootPath);\n                Transforms.select(editor, cursorRootPath);\n            } else {\n                const nextPath = Path.next(cursorRootPath);\n                insertParagraph(editor, nextPath);\n                Transforms.select(editor, nextPath);\n            }\n        }\n        insertText(text);\n    };\n\n    return editor;\n};\n\nexport const createBlockCardPlugin = createPluginFactory({\n    key: PluginKeys.blockCard,\n    withOverrides: withBlockCard\n});\n"]}