@plait/mind 0.85.0 → 0.86.0

package/fesm2022/plait-mind.mjs

@@ -478,7 +478,7 @@ const getFillByElement = (board, element) => {
         return element.fill;
     }
     const defaultRootFill = getMindThemeColor(board).rootFill;
-    return element.isRoot ? defaultRootFill : DefaultNodeStyle.shape.fill;
+    return PlaitMind.isMind(element) ? defaultRootFill : DefaultNodeStyle.shape.fill;
 };
 const getShapeByElement = (board, element) => {
     const shape = getAvailableProperty(board, element, 'shape');
@@ -602,7 +602,7 @@ const getRootLayout = (root) => {
 
 const getLayoutOptions = (board) => {
     function getMainAxle(element, parent) {
-        if (element.isRoot) {
+        if (PlaitMind.isMind(element)) {
             return BASE * 12;
         }
         if (parent && parent.isRoot()) {
@@ -611,7 +611,7 @@ const getLayoutOptions = (board) => {
         return BASE * 3;
     }
     function getSecondAxle(element, parent) {
-        if (element.isRoot) {
+        if (PlaitMind.isMind(element)) {
             return BASE * 12;
         }
         return BASE * 8.5;
@@ -676,7 +676,6 @@ const getAbstractNodeText = (board) => {
 const createEmptyMind = (board, point) => {
     const text = getDefaultMindNameText(board);
     const element = createMindElement(text, { layout: MindLayoutType.right });
-    element.isRoot = true;
     element.type = 'mind';
     const width = NodeSpace.getNodeWidth(board, element);
     const height = NodeSpace.getNodeHeight(board, element);
@@ -761,7 +760,7 @@ const copyNewNode = (node) => {
 };
 const insertMindElement = (board, inheritNode, path) => {
     const newNode = {};
-    if (!inheritNode.isRoot) {
+    if (!PlaitMind.isMind(inheritNode)) {
         INHERIT_ATTRIBUTE_KEYS.forEach((attr) => {
             newNode[attr] = inheritNode[attr];
         });
@@ -1051,7 +1050,6 @@ const getHitImageResizeHandleDirection = (board, element, point) => {
 
 const adjustRootToNode = (board, node) => {
     const newNode = { ...node };
-    delete newNode.isRoot;
     delete newNode.rightNodeCount;
     newNode.type = 'mind_child';
     if (newNode.layout === MindLayoutType.standard) {
@@ -1078,7 +1076,6 @@ const adjustNodeToRoot = (board, node) => {
     return {
         ...newElement,
         layout: newElement.layout ?? MindLayoutType.right,
-        isRoot: true,
         type: 'mind'
     };
 };
@@ -1165,10 +1162,10 @@ const isDropStandardRight = (parent, dropTarget) => {
 };
 
 const directionCorrector = (board, node, detectResults) => {
-    if (!node.origin.isRoot && !AbstractNode.isAbstract(node.origin)) {
+    if (!PlaitMind.isMind(node.origin) && !AbstractNode.isAbstract(node.origin)) {
         const parentLayout = MindQueries.getCorrectLayoutByElement(board, node?.parent.origin);
         if (isStandardLayout(parentLayout)) {
-            const idx = node.parent.children.findIndex(x => x === node);
+            const idx = node.parent.children.findIndex((x) => x === node);
             const isLeft = idx >= (node.parent.origin.rightNodeCount || 0);
             return getAllowedDirection(detectResults, [isLeft ? 'right' : 'left']);
         }
@@ -1207,8 +1204,8 @@ const directionCorrector = (board, node, detectResults) => {
 };
 const getAllowedDirection = (detectResults, illegalDirections) => {
     const directions = detectResults;
-    illegalDirections.forEach(item => {
-        const bottomDirectionIndex = directions.findIndex(direction => direction === item);
+    illegalDirections.forEach((item) => {
+        const bottomDirectionIndex = directions.findIndex((direction) => direction === item);
         if (bottomDirectionIndex !== -1) {
             directions.splice(bottomDirectionIndex, 1);
         }
@@ -1217,7 +1214,7 @@ const getAllowedDirection = (detectResults, illegalDirections) => {
 };
 const detectDropTarget = (board, detectPoint, dropTarget, activeElements) => {
     let detectResult = null;
-    depthFirstRecursion(board, element => {
+    depthFirstRecursion(board, (element) => {
         if (!MindElement.isMindElement(board, element) || detectResult) {
             return;
         }
@@ -1227,7 +1224,7 @@ const detectDropTarget = (board, detectPoint, dropTarget, activeElements) => {
             detectResult = directionCorrector(board, node, directions);
         }
         dropTarget = null;
-        const isValid = activeElements.every(element => isValidTarget(element, node.origin));
+        const isValid = activeElements.every((element) => isValidTarget(element, node.origin));
         if (detectResult && isValid) {
             dropTarget = { target: node.origin, detectResult: detectResult[0] };
         }
@@ -1489,7 +1486,7 @@ function drawLogicLink(board, parent, node, isHorizontal, defaultStrokeColor = n
     const branchColor = defaultStrokeColor || getBranchColorByMindElement(board, node.origin);
     const branchWidth = defaultStrokeWidth || getBranchWidthByMindElement(board, node.origin);
     const strokeStyle = defaultStrokeStyle || getStrokeStyleByElement(board, node.origin);
-    const hasStraightLine = branchShape === BranchShape.polyline ? true : !parent.origin.isRoot;
+    const hasStraightLine = branchShape === BranchShape.polyline ? true : !PlaitMind.isMind(parent.origin);
     const parentShape = getShapeByElement(board, parent.origin);
     const shape = getShapeByElement(board, node.origin);
     const hasUnderlineShape = shape === MindElementShape.underline;
@@ -1504,7 +1501,7 @@ function drawLogicLink(board, parent, node, isHorizontal, defaultStrokeColor = n
     transformPlacement(beginPlacement, linkDirection);
     transformPlacement(endPlacement, linkDirection);
     // underline shape and horizontal
-    if (isHorizontal && hasUnderlineShapeOfParent && !parent.origin.isRoot) {
+    if (isHorizontal && hasUnderlineShapeOfParent && !PlaitMind.isMind(parent.origin)) {
         beginPlacement[1] = VerticalPlacement.bottom;
     }
     if (isHorizontal && hasUnderlineShape) {
@@ -2113,8 +2110,8 @@ function handleTouchedAbstract(board, touchedAbstract, endPoint) {
 const isInRightBranchOfStandardLayout = (selectedElement) => {
     const parentElement = MindElement.findParent(selectedElement);
     if (parentElement) {
-        const nodeIndex = parentElement.children.findIndex(item => item.id === selectedElement.id);
-        if (parentElement.isRoot &&
+        const nodeIndex = parentElement.children.findIndex((item) => item.id === selectedElement.id);
+        if (PlaitMind.isMind(parentElement) &&
             getRootLayout(parentElement) === MindLayoutType.standard &&
             parentElement.rightNodeCount &&
             nodeIndex <= parentElement.rightNodeCount - 1) {
@@ -2124,7 +2121,7 @@ const isInRightBranchOfStandardLayout = (selectedElement) => {
     return false;
 };
 const insertElementHandleRightNodeCount = (board, path, insertCount, effectedRightNodeCount = []) => {
-    let index = effectedRightNodeCount.findIndex(ref => Path.equals(ref.path, path));
+    let index = effectedRightNodeCount.findIndex((ref) => Path.equals(ref.path, path));
     const mind = PlaitNode.get(board, path);
     if (index === -1) {
         effectedRightNodeCount.push({ path, rightNodeCount: mind.rightNodeCount + insertCount });
@@ -2135,11 +2132,11 @@ const insertElementHandleRightNodeCount = (board, path, insertCount, effectedRig
     return effectedRightNodeCount;
 };
 const deleteElementsHandleRightNodeCount = (board, deletableElements, effectedRightNodeCount = []) => {
-    deletableElements.forEach(element => {
+    deletableElements.forEach((element) => {
         if (isInRightBranchOfStandardLayout(element)) {
             const mind = MindElement.getParent(element);
             const path = PlaitBoard.findPath(board, mind);
-            let index = effectedRightNodeCount.findIndex(ref => Path.equals(ref.path, path));
+            let index = effectedRightNodeCount.findIndex((ref) => Path.equals(ref.path, path));
             if (index === -1) {
                 effectedRightNodeCount.push({ path, rightNodeCount: mind.rightNodeCount - 1 });
             }
@@ -2854,7 +2851,7 @@ const getMoreStartAndEnd = (board, element, linkLineDirection) => {
     // underline shape and horizontal
     const layout = MindQueries.getLayoutByElement(element);
     const isHorizontal = isHorizontalLayout(layout);
-    if (isHorizontal && isUnderlineShape && !element.isRoot) {
+    if (isHorizontal && isUnderlineShape && !PlaitMind.isMind(element)) {
         placement[1] = VerticalPlacement.bottom;
     }
     let startPoint = getPointByPlacement(nodeClient, placement);
@@ -3074,7 +3071,7 @@ const withNodeDnd = (board) => {
             MindElement.isMindElement(board, hitElement) &&
             !PlaitMind.isMind(hitElement) &&
             !AbstractNode.isAbstract(hitElement)) {
-            const targetElements = selectedElements.filter(element => MindElement.isMindElement(board, element) && !element.isRoot && !AbstractNode.isAbstract(element));
+            const targetElements = selectedElements.filter((element) => MindElement.isMindElement(board, element) && !PlaitMind.isMind(element) && !AbstractNode.isAbstract(element));
             const isMultipleSelection = selectedElements.length > 0 && selectedElements.includes(hitElement);
             if (isMultipleSelection) {
                 activeElements = targetElements;
@@ -3110,10 +3107,10 @@ const withNodeDnd = (board) => {
             const offsetY = endPoint[1] - startPoint[1];
             dragFakeNodeG?.remove();
             dragFakeNodeG = createG();
-            [...activeElements, ...correspondingElements].forEach(element => {
+            [...activeElements, ...correspondingElements].forEach((element) => {
                 addActiveOnDragOrigin(element);
             });
-            activeElements.forEach(element => {
+            activeElements.forEach((element) => {
                 const nodeG = drawFakeDragNode(board, element, offsetX, offsetY);
                 dragFakeNodeG?.appendChild(nodeG);
             });
@@ -3127,7 +3124,7 @@ const withNodeDnd = (board) => {
         if (!board.options.readonly && firstLevelElements.length) {
             firstLevelElements.push(...correspondingElements);
             if (isDragging(board)) {
-                firstLevelElements.forEach(element => {
+                firstLevelElements.forEach((element) => {
                     removeActiveOnDragOrigin(element);
                 });
             }
@@ -3137,8 +3134,8 @@ const withNodeDnd = (board) => {
                 const targetElementPathRef = board.pathRef(PlaitBoard.findPath(board, dropTarget.target));
                 let abstractRefs = getValidAbstractRefs(board, firstLevelElements);
                 const normalElements = firstLevelElements
-                    .filter(element => !abstractRefs.some(refs => refs.abstract === element))
-                    .map(element => {
+                    .filter((element) => !abstractRefs.some((refs) => refs.abstract === element))
+                    .map((element) => {
                     if (AbstractNode.isAbstract(element)) {
                         return adjustAbstractToNode(element);
                     }
@@ -3150,7 +3147,7 @@ const withNodeDnd = (board) => {
                     const correspondingAbstract = getCorrespondingAbstract(previousElement);
                     const targetHasCorrespondAbstract = correspondingAbstract && correspondingAbstract.end !== targetPath[targetPath.length - 1] - 1;
                     if (targetHasCorrespondAbstract) {
-                        const adjustedNode = abstractRefs.map(ref => {
+                        const adjustedNode = abstractRefs.map((ref) => {
                             return adjustAbstractToNode(ref.abstract);
                         });
                         normalElements.push(...adjustedNode);
@@ -3195,8 +3192,8 @@ const withNodeDnd = (board) => {
                 targetElementPathRef.unref();
                 targetPathRef.unref();
                 let setActiveElements = [];
-                depthFirstRecursion(board, node => {
-                    const isSelected = activeElements.some(element => element.id === node.id);
+                depthFirstRecursion(board, (node) => {
+                    const isSelected = activeElements.some((element) => element.id === node.id);
                     if (isSelected) {
                         setActiveElements.push(node);
                     }
@@ -3891,7 +3888,7 @@ const insertClipboardData = (board, elements, targetPoint, operationType) => {
     elements.forEach((item, index) => {
         newElement = copyNewNode(item);
         if (hasTargetParent && operationType !== WritableClipboardOperationType.duplicate) {
-            if (item.isRoot) {
+            if (PlaitMind.isMind(item)) {
                 newElement = adjustRootToNode(board, newElement);
             }
             // handle abstract start and end
@@ -3907,7 +3904,7 @@ const insertClipboardData = (board, elements, targetPoint, operationType) => {
             if (AbstractNode.isAbstract(item)) {
                 newElement = adjustAbstractToNode(newElement);
             }
-            if (!item.isRoot) {
+            if (!PlaitMind.isMind(item)) {
                 newElement = adjustNodeToRoot(board, newElement);
             }
             path = [board.children.length];
@@ -4088,13 +4085,13 @@ const withMind = (baseBoard) => {
         return getRectangle(element);
     };
     board.canAddToGroup = (element) => {
-        if (MindElement.isMindElement(board, element) && !element.isRoot) {
+        if (MindElement.isMindElement(board, element) && !PlaitMind.isMind(element)) {
             return false;
         }
         return canAddToGroup(element);
     };
     board.canSetZIndex = (element) => {
-        if (MindElement.isMindElement(board, element) && !element.isRoot) {
+        if (MindElement.isMindElement(board, element) && !PlaitMind.isMind(element)) {
             return false;
         }
         return canSetZIndex(element);
@@ -4129,7 +4126,7 @@ const withMind = (baseBoard) => {
         return getOneHitElement(elements);
     };
     board.isMovable = (element) => {
-        if (PlaitMind.isMind(element) && element.isRoot) {
+        if (PlaitMind.isMind(element)) {
             return true;
         }
         return isMovable(element);
@@ -4141,7 +4138,7 @@ const withMind = (baseBoard) => {
         return isImageBindingAllowed(element);
     };
     board.isAlign = (element) => {
-        if (PlaitMind.isMind(element) && element.isRoot) {
+        if (PlaitMind.isMind(element)) {
             return true;
         }
         return isAlign(element);