@plait/mind 0.12.2 → 0.13.0

package/fesm2015/plait-mind.mjs

@@ -280,7 +280,10 @@ const isHitEmojis = (board, element, point) => {
 
 function getTopicRectangleByNode(board, node) {
     let nodeRectangle = getRectangleByNode(node);
-    return getTopicRectangleByElement(board, nodeRectangle, node.origin);
+    const result = getTopicRectangleByElement(board, nodeRectangle, node.origin);
+    // add buffer width to avoid unexpected text breaks in different scene
+    result.width = result.width + 4;
+    return result;
 }
 function getTopicRectangleByElement(board, nodeRectangle, element) {
     const x = nodeRectangle.x + NodeSpace.getTextLeftSpace(board, element);
@@ -294,7 +297,7 @@ const NODE_MIN_WIDTH = 18;
 
 function editTopic(element) {
     const component = PlaitElement.getComponent(element);
-    component.editTopic();
+    component === null || component === void 0 ? void 0 : component.editTopic();
 }
 
 const TOPIC_COLOR = '#333';
@@ -441,7 +444,6 @@ const extractNodesText = (node) => {
     }
     return str;
 };
-// layoutLevel 用来表示插入兄弟节点还是子节点
 const insertMindElement = (board, inheritNode, path) => {
     const newNode = {};
     if (!inheritNode.isRoot) {
@@ -2584,7 +2586,6 @@ class MindNodeComponent extends PlaitPluginElementComponent {
         const plugins = this.board.getMindOptions().textPlugins;
         this.textManage = new TextManage(this.board, this.viewContainerRef, () => {
             const rect = getTopicRectangleByNode(this.board, this.node);
-            rect.width = rect.width + WIDTH_BUFFER;
             return rect;
         }, (point) => {
             return isHitMindElement(this.board, point, this.element);
@@ -3361,27 +3362,104 @@ const withCreateMind = (board) => {
 
 const withMindHotkey = (board) => {
     const { keydown } = board;
-    board.keydown = (keyboardEvent) => {
-        if (!PlaitBoard.getMovingPoint(board)) {
-            return;
+    board.keydown = (event) => {
+        const selectedElements = getSelectedElements(board);
+        const isSingleSelection = selectedElements.length === 1;
+        const isSingleMindElement = selectedElements.length === 1 && MindElement.isMindElement(board, selectedElements[0]);
+        const targetElement = selectedElements[0];
+        if (isExpandHotkey(event) && isSingleMindElement && !PlaitMind.isMind(targetElement)) {
+            if (targetElement.children && targetElement.children.length > 0) {
+                Transforms.setNode(board, { isCollapsed: targetElement.isCollapsed ? false : true }, PlaitBoard.findPath(board, targetElement));
+                return;
+            }
         }
-        if (isExpandHotkey(keyboardEvent)) {
-            const selectedMindElements = getSelectedElements(board).filter(element => MindElement.isMindElement(board, element));
-            if (selectedMindElements.length === 1 &&
-                !PlaitMind.isMind(selectedMindElements[0]) &&
-                selectedMindElements[0].children &&
-                selectedMindElements[0].children.length > 0) {
-                const element = selectedMindElements[0];
-                Transforms.setNode(board, { isCollapsed: element.isCollapsed ? false : true }, PlaitBoard.findPath(board, element));
+        if (!PlaitBoard.isReadonly(board)) {
+            if (isTabHotkey(event) && isSingleMindElement) {
+                event.preventDefault();
+                removeSelectedElement(board, targetElement);
+                const targetElementPath = PlaitBoard.findPath(board, targetElement);
+                if (targetElement.isCollapsed) {
+                    const newElement = { isCollapsed: false };
+                    PlaitHistoryBoard.withoutSaving(board, () => {
+                        Transforms.setNode(board, newElement, targetElementPath);
+                    });
+                }
+                insertMindElement(board, targetElement, findNewChildNodePath(board, targetElement));
+                return;
+            }
+            if (isEnterHotkey(event) &&
+                isSingleMindElement &&
+                !PlaitMind.isMind(targetElement) &&
+                !AbstractNode.isAbstract(targetElement)) {
+                const targetElementPath = PlaitBoard.findPath(board, targetElement);
+                if (isInRightBranchOfStandardLayout(targetElement)) {
+                    const refs = insertElementHandleRightNodeCount(board, targetElementPath.slice(0, 1), 1);
+                    MindTransforms.setRightNodeCountByRefs(board, refs);
+                }
+                const abstractRefs = insertElementHandleAbstract(board, Path.next(targetElementPath));
+                MindTransforms.setAbstractsByRefs(board, abstractRefs);
+                insertMindElement(board, targetElement, findNewSiblingNodePath(board, targetElement));
+                return;
+            }
+            if (selectedElements.length > 0 && (hotkeys.isDeleteBackward(event) || hotkeys.isDeleteForward(event))) {
+                event.preventDefault();
+                const targetMindElements = selectedElements.filter(el => MindElement.isMindElement(board, el));
+                const firstLevelElements = getFirstLevelElement(targetMindElements);
+                const deletableElements = firstLevelElements.reverse();
+                const abstractRefs = deleteElementHandleAbstract(board, deletableElements);
+                MindTransforms.setAbstractsByRefs(board, abstractRefs);
+                const refs = deleteElementsHandleRightNodeCount(board, targetMindElements);
+                MindTransforms.setRightNodeCountByRefs(board, refs);
+                MindTransforms.removeElements(board, targetMindElements);
+                let activeElement;
+                if (AbstractNode.isAbstract(firstLevelElements[0])) {
+                    const parent = MindElement.getParent(firstLevelElements[0]);
+                    activeElement = parent.children[firstLevelElements[0].start];
+                }
+                const firstElement = firstLevelElements[0];
+                const firstElementParent = MindElement.findParent(firstElement);
+                const hasSameParent = firstLevelElements.every(element => {
+                    return MindElement.findParent(element) === firstElementParent;
+                });
+                if (firstElementParent && hasSameParent && !activeElement) {
+                    const firstElementIndex = firstElementParent.children.indexOf(firstElement);
+                    const childrenCount = firstElementParent.children.length;
+                    // active parent element
+                    if (childrenCount === firstLevelElements.length) {
+                        activeElement = firstElementParent;
+                    }
+                    else {
+                        if (firstElementIndex > 0) {
+                            activeElement = firstElementParent.children[firstElementIndex - 1];
+                        }
+                    }
+                }
+                if (activeElement) {
+                    addSelectedElement(board, activeElement);
+                }
+                return;
+            }
+            if (!isVirtualKey(event) && !isSpaceHotkey(event) && isSingleSelection) {
+                event.preventDefault();
+                editTopic(targetElement);
                 return;
             }
         }
-        keydown(keyboardEvent);
+        keydown(event);
     };
     return board;
 };
-const isExpandHotkey = (keyboardEvent) => {
-    return isKeyHotkey('mod+/', keyboardEvent);
+const isExpandHotkey = (event) => {
+    return isKeyHotkey('mod+/', event);
+};
+const isTabHotkey = (event) => {
+    return event.key === 'Tab';
+};
+const isEnterHotkey = (event) => {
+    return event.key === 'Enter';
+};
+const isSpaceHotkey = (event) => {
+    return event.code === 'Space';
 };
 
 const withNodeHover = (board) => {
@@ -3497,92 +3575,6 @@ const withMind = (board) => {
         }
         return isMovable(element);
     };
-    board.keydown = (event) => {
-        if (PlaitBoard.isReadonly(board)) {
-            keydown(event);
-            return;
-        }
-        const selectedElements = getSelectedElements(board);
-        if (selectedElements.length) {
-            if (selectedElements.length === 1 &&
-                (event.key === 'Tab' ||
-                    (event.key === 'Enter' && !selectedElements[0].isRoot && !AbstractNode.isAbstract(selectedElements[0])))) {
-                event.preventDefault();
-                const selectedElement = selectedElements[0];
-                removeSelectedElement(board, selectedElement);
-                const selectedElementPath = PlaitBoard.findPath(board, selectedElement);
-                if (event.key === 'Tab') {
-                    if (selectedElement.isCollapsed) {
-                        const newElement = { isCollapsed: false };
-                        PlaitHistoryBoard.withoutSaving(board, () => {
-                            Transforms.setNode(board, newElement, selectedElementPath);
-                        });
-                    }
-                    insertMindElement(board, selectedElement, findNewChildNodePath(board, selectedElement));
-                }
-                else {
-                    if (isInRightBranchOfStandardLayout(selectedElement)) {
-                        const refs = insertElementHandleRightNodeCount(board, selectedElementPath.slice(0, 1), 1);
-                        MindTransforms.setRightNodeCountByRefs(board, refs);
-                    }
-                    const abstractRefs = insertElementHandleAbstract(board, Path.next(selectedElementPath));
-                    MindTransforms.setAbstractsByRefs(board, abstractRefs);
-                    insertMindElement(board, selectedElement, findNewSiblingNodePath(board, selectedElement));
-                }
-                return;
-            }
-            if (hotkeys.isDeleteBackward(event) || hotkeys.isDeleteForward(event)) {
-                event.preventDefault();
-                const deletableElements = getFirstLevelElement(selectedElements).reverse();
-                const abstractRefs = deleteElementHandleAbstract(board, deletableElements);
-                MindTransforms.setAbstractsByRefs(board, abstractRefs);
-                const refs = deleteElementsHandleRightNodeCount(board, selectedElements);
-                MindTransforms.setRightNodeCountByRefs(board, refs);
-                MindTransforms.removeElements(board, selectedElements);
-                let activeElement;
-                const firstLevelElements = getFirstLevelElement(selectedElements);
-                if (AbstractNode.isAbstract(firstLevelElements[0])) {
-                    const parent = MindElement.getParent(firstLevelElements[0]);
-                    activeElement = parent.children[firstLevelElements[0].start];
-                }
-                const firstElement = firstLevelElements[0];
-                const firstElementParent = MindElement.findParent(firstElement);
-                const hasSameParent = firstLevelElements.every(element => {
-                    return MindElement.findParent(element) === firstElementParent;
-                });
-                if (firstElementParent && hasSameParent && !activeElement) {
-                    const firstElementIndex = firstElementParent.children.indexOf(firstElement);
-                    const childrenCount = firstElementParent.children.length;
-                    // active parent element
-                    if (childrenCount === firstLevelElements.length) {
-                        activeElement = firstElementParent;
-                    }
-                    else {
-                        if (firstElementIndex > 0) {
-                            activeElement = firstElementParent.children[firstElementIndex - 1];
-                        }
-                    }
-                }
-                if (activeElement) {
-                    addSelectedElement(board, activeElement);
-                }
-                return;
-            }
-            // auto enter edit status
-            if (!isVirtualKey(event)) {
-                event.preventDefault();
-                const selectedElement = selectedElements[0];
-                editTopic(selectedElement);
-                return;
-            }
-        }
-        if (board.selection && event.code === 'Space') {
-            if (selectedElements === null || selectedElements === void 0 ? void 0 : selectedElements.length) {
-                return;
-            }
-        }
-        keydown(event);
-    };
     board.dblclick = (event) => {
         if (PlaitBoard.isReadonly(board)) {
             dblclick(event);