@plait/mind 0.2.0-next.0

package/esm2020/plait-mind.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhaXQtbWluZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3BhY2thZ2VzL21pbmQvc3JjL3BsYWl0LW1pbmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/plugins/emoji/emoji-base.component.mjs

@@ -0,0 +1,21 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MindEmojiBaseComponent {
+    get nativeElement() {
+        return this.elementRef.nativeElement;
+    }
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this.fontSize = 14;
+    }
+}
+MindEmojiBaseComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: MindEmojiBaseComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+MindEmojiBaseComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.5", type: MindEmojiBaseComponent, inputs: { fontSize: "fontSize", emojiItem: "emojiItem" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: MindEmojiBaseComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { fontSize: [{
+                type: Input
+            }], emojiItem: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1vamktYmFzZS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9taW5kL3NyYy9wbHVnaW5zL2Vtb2ppL2Vtb2ppLWJhc2UuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQWMsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUk3RCxNQUFNLE9BQU8sc0JBQXNCO0lBTy9CLElBQUksYUFBYTtRQUNiLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxhQUFhLENBQUM7SUFDekMsQ0FBQztJQUVELFlBQXNCLFVBQW1DO1FBQW5DLGVBQVUsR0FBVixVQUFVLENBQXlCO1FBVHpELGFBQVEsR0FBVyxFQUFFLENBQUM7SUFTc0MsQ0FBQzs7bUhBWHBELHNCQUFzQjt1R0FBdEIsc0JBQXNCOzJGQUF0QixzQkFBc0I7a0JBRGxDLFNBQVM7aUdBR04sUUFBUTtzQkFEUCxLQUFLO2dCQUlOLFNBQVM7c0JBRFIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgRWxlbWVudFJlZiwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEVtb2ppSXRlbSB9IGZyb20gJy4uLy4uL2ludGVyZmFjZXMvZWxlbWVudC1kYXRhJztcblxuQERpcmVjdGl2ZSgpXG5leHBvcnQgY2xhc3MgTWluZEVtb2ppQmFzZUNvbXBvbmVudCB7XG4gICAgQElucHV0KClcbiAgICBmb250U2l6ZTogbnVtYmVyID0gMTQ7XG5cbiAgICBASW5wdXQoKVxuICAgIGVtb2ppSXRlbSE6IEVtb2ppSXRlbTtcblxuICAgIGdldCBuYXRpdmVFbGVtZW50KCkge1xuICAgICAgICByZXR1cm4gdGhpcy5lbGVtZW50UmVmLm5hdGl2ZUVsZW1lbnQ7XG4gICAgfVxuXG4gICAgY29uc3RydWN0b3IocHJvdGVjdGVkIGVsZW1lbnRSZWY6IEVsZW1lbnRSZWY8SFRNTEVsZW1lbnQ+KSB7fVxufVxuIl19

package/esm2020/plugins/emoji/emoji.drawer.mjs

@@ -0,0 +1,79 @@
+import { MindElement, PlaitMind } from '../../interfaces';
+import { createForeignObject } from '@plait/richtext';
+import { createG } from '@plait/core';
+import { getRectangleByNode } from '../../utils/graph';
+import { getEmojiFontSize, getEmojisRectangle } from './emoji';
+import { NodeSpace } from '../../utils/node-space';
+export class EmojiDrawer {
+    constructor(board, viewContainerRef) {
+        this.board = board;
+        this.viewContainerRef = viewContainerRef;
+        this.componentRef = null;
+    }
+    draw(emoji, element) {
+        this.destroy();
+        const componentType = this.board.drawEmoji(emoji, element);
+        this.componentRef = this.viewContainerRef.createComponent(componentType);
+        this.componentRef.instance.emojiItem = emoji;
+        const fontSize = PlaitMind.isMind(element) ? 18 : 14;
+        this.componentRef.instance.fontSize = fontSize;
+    }
+    get nativeElement() {
+        if (this.componentRef) {
+            return this.componentRef.instance.nativeElement;
+        }
+        else {
+            return null;
+        }
+    }
+    destroy() {
+        if (this.componentRef) {
+            this.componentRef.destroy();
+            this.componentRef = null;
+        }
+    }
+}
+export class EmojisDrawer {
+    constructor(board, viewContainerRef) {
+        this.board = board;
+        this.viewContainerRef = viewContainerRef;
+        this.emojiDrawers = [];
+    }
+    drawEmojis(element) {
+        this.destroy();
+        if (MindElement.hasEmojis(element)) {
+            const node = MindElement.getNode(element);
+            this.g = createG();
+            this.g.classList.add('emojis');
+            let { x, y } = getRectangleByNode(MindElement.getNode(element));
+            x = x + NodeSpace.getEmojiHorizontalSpace(element);
+            y = y + NodeSpace.getEmojiVerticalSpace(element);
+            const { width, height } = getEmojisRectangle(element);
+            const fontSize = getEmojiFontSize(element);
+            const foreignObject = createForeignObject(x, y, width, height);
+            this.g.append(foreignObject);
+            const container = document.createElement('div');
+            container.classList.add('node-emojis-container');
+            container.classList.add(`emoji-font-size-${fontSize}`);
+            foreignObject.append(container);
+            this.emojiDrawers = element.data.emojis.map(emojiItem => {
+                const drawer = new EmojiDrawer(this.board, this.viewContainerRef);
+                drawer.draw(emojiItem, element);
+                return drawer;
+            });
+            this.emojiDrawers.forEach(drawer => {
+                container.append(drawer.nativeElement);
+            });
+            return this.g;
+        }
+        return undefined;
+    }
+    destroy() {
+        if (this.g) {
+            this.g.remove();
+        }
+        this.emojiDrawers.forEach(drawer => drawer.destroy());
+        this.emojiDrawers = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"emoji.drawer.js","sourceRoot":"","sources":["../../../../../packages/mind/src/plugins/emoji/emoji.drawer.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef, ViewContainerRef } from '@angular/core';\nimport { EmojiItem, MindElement, PlaitMind } from '../../interfaces';\nimport { MindEmojiBaseComponent } from './emoji-base.component';\nimport { PlaitMindEmojiBoard } from './with-mind-emoji';\nimport { createForeignObject } from '@plait/richtext';\nimport { createG } from '@plait/core';\nimport { getRectangleByNode } from '../../utils/graph';\nimport { getEmojiFontSize, getEmojisRectangle } from './emoji';\nimport { NodeSpace } from '../../utils/node-space';\n\nexport class EmojiDrawer {\n    componentRef: ComponentRef<MindEmojiBaseComponent> | null = null;\n\n    constructor(private board: PlaitMindEmojiBoard, private viewContainerRef: ViewContainerRef) {}\n\n    draw(emoji: EmojiItem, element: MindElement) {\n        this.destroy();\n        const componentType = this.board.drawEmoji(emoji, element);\n        this.componentRef = this.viewContainerRef.createComponent(componentType);\n        this.componentRef.instance.emojiItem = emoji;\n        const fontSize = PlaitMind.isMind(element) ? 18 : 14;\n        this.componentRef.instance.fontSize = fontSize;\n    }\n\n    get nativeElement() {\n        if (this.componentRef) {\n            return this.componentRef.instance.nativeElement;\n        } else {\n            return null;\n        }\n    }\n\n    destroy() {\n        if (this.componentRef) {\n            this.componentRef.destroy();\n            this.componentRef = null;\n        }\n    }\n}\n\nexport class EmojisDrawer {\n    emojiDrawers: EmojiDrawer[] = [];\n\n    g?: SVGGElement;\n\n    constructor(private board: PlaitMindEmojiBoard, private viewContainerRef: ViewContainerRef) {}\n\n    drawEmojis(element: MindElement) {\n        this.destroy();\n        if (MindElement.hasEmojis(element)) {\n            const node = MindElement.getNode(element);\n            this.g = createG();\n            this.g.classList.add('emojis');\n            let { x, y } = getRectangleByNode(MindElement.getNode(element));\n            x = x + NodeSpace.getEmojiHorizontalSpace(element);\n            y = y + NodeSpace.getEmojiVerticalSpace(element);\n            const { width, height } = getEmojisRectangle(element);\n            const fontSize = getEmojiFontSize(element);\n            const foreignObject = createForeignObject(x, y, width, height);\n            this.g.append(foreignObject);\n            const container = document.createElement('div');\n            container.classList.add('node-emojis-container');\n            container.classList.add(`emoji-font-size-${fontSize}`);\n            foreignObject.append(container);\n            this.emojiDrawers = element.data.emojis.map(emojiItem => {\n                const drawer = new EmojiDrawer(this.board, this.viewContainerRef);\n                drawer.draw(emojiItem, element);\n                return drawer;\n            });\n            this.emojiDrawers.forEach(drawer => {\n                container.append(drawer.nativeElement!);\n            });\n            return this.g;\n        }\n        return undefined;\n    }\n\n    destroy() {\n        if (this.g) {\n            this.g.remove();\n        }\n        this.emojiDrawers.forEach(drawer => drawer.destroy());\n        this.emojiDrawers = [];\n    }\n}\n"]}

package/esm2020/plugins/emoji/emoji.mjs

@@ -0,0 +1,15 @@
+import { PlaitMind } from '../../interfaces';
+export function getEmojisRectangle(element) {
+    const count = element.data.emojis.length;
+    const fontSize = getEmojiFontSize(element);
+    return { width: fontSize * count, height: fontSize * 1.5 };
+}
+export function getEmojiFontSize(element) {
+    if (PlaitMind.isMind(element)) {
+        return 18;
+    }
+    else {
+        return 14;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1vamkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9taW5kL3NyYy9wbHVnaW5zL2Vtb2ppL2Vtb2ppLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBMEIsU0FBUyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFckUsTUFBTSxVQUFVLGtCQUFrQixDQUFDLE9BQStCO0lBQzlELE1BQU0sS0FBSyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUN6QyxNQUFNLFFBQVEsR0FBRyxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUMzQyxPQUFPLEVBQUUsS0FBSyxFQUFFLFFBQVEsR0FBRyxLQUFLLEVBQUUsTUFBTSxFQUFFLFFBQVEsR0FBRyxHQUFHLEVBQUUsQ0FBQztBQUMvRCxDQUFDO0FBRUQsTUFBTSxVQUFVLGdCQUFnQixDQUFDLE9BQStCO0lBQzVELElBQUksU0FBUyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsRUFBRTtRQUMzQixPQUFPLEVBQUUsQ0FBQztLQUNiO1NBQU07UUFDSCxPQUFPLEVBQUUsQ0FBQztLQUNiO0FBQ0wsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVtb2ppRGF0YSwgTWluZEVsZW1lbnQsIFBsYWl0TWluZCB9IGZyb20gJy4uLy4uL2ludGVyZmFjZXMnO1xuXG5leHBvcnQgZnVuY3Rpb24gZ2V0RW1vamlzUmVjdGFuZ2xlKGVsZW1lbnQ6IE1pbmRFbGVtZW50PEVtb2ppRGF0YT4pIHtcbiAgICBjb25zdCBjb3VudCA9IGVsZW1lbnQuZGF0YS5lbW9qaXMubGVuZ3RoO1xuICAgIGNvbnN0IGZvbnRTaXplID0gZ2V0RW1vamlGb250U2l6ZShlbGVtZW50KTtcbiAgICByZXR1cm4geyB3aWR0aDogZm9udFNpemUgKiBjb3VudCwgaGVpZ2h0OiBmb250U2l6ZSAqIDEuNSB9O1xufVxuXG5leHBvcnQgZnVuY3Rpb24gZ2V0RW1vamlGb250U2l6ZShlbGVtZW50OiBNaW5kRWxlbWVudDxFbW9qaURhdGE+KSB7XG4gICAgaWYgKFBsYWl0TWluZC5pc01pbmQoZWxlbWVudCkpIHtcbiAgICAgICAgcmV0dXJuIDE4O1xuICAgIH0gZWxzZSB7XG4gICAgICAgIHJldHVybiAxNDtcbiAgICB9XG59XG4iXX0=

package/esm2020/plugins/emoji/index.mjs

@@ -0,0 +1,4 @@
+export * from './with-mind-emoji';
+export * from './emoji';
+export * from './emoji-base.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9taW5kL3NyYy9wbHVnaW5zL2Vtb2ppL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vd2l0aC1taW5kLWVtb2ppJztcbmV4cG9ydCAqIGZyb20gJy4vZW1vamknO1xuZXhwb3J0ICogZnJvbSAnLi9lbW9qaS1iYXNlLmNvbXBvbmVudCc7Il19

package/esm2020/plugins/emoji/with-mind-emoji.mjs

@@ -0,0 +1,8 @@
+export const withEmoji = (board) => {
+    const newBoard = board;
+    newBoard.drawEmoji = (emoji, element) => {
+        throw new Error('Not implement drawEmoji method error.');
+    };
+    return newBoard;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1taW5kLWVtb2ppLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbWluZC9zcmMvcGx1Z2lucy9lbW9qaS93aXRoLW1pbmQtZW1vamkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0EsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLENBQUMsS0FBaUIsRUFBRSxFQUFFO0lBQzNDLE1BQU0sUUFBUSxHQUFHLEtBQXlDLENBQUM7SUFFM0QsUUFBUSxDQUFDLFNBQVMsR0FBRyxDQUFDLEtBQWdCLEVBQUUsT0FBb0IsRUFBRSxFQUFFO1FBQzVELE1BQU0sSUFBSSxLQUFLLENBQUMsdUNBQXVDLENBQUMsQ0FBQztJQUM3RCxDQUFDLENBQUE7SUFFRCxPQUFPLFFBQVEsQ0FBQztBQUNwQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnRUeXBlLCBQbGFpdEJvYXJkLCBQbGFpdFBsdWdpbiB9IGZyb20gJ0BwbGFpdC9jb3JlJztcbmltcG9ydCB7IE1pbmRFbGVtZW50IH0gZnJvbSAnLi4vLi4vaW50ZXJmYWNlcy9lbGVtZW50JztcbmltcG9ydCB7IEVtb2ppSXRlbSB9IGZyb20gJy4uLy4uL2ludGVyZmFjZXMvZWxlbWVudC1kYXRhJztcbmltcG9ydCB7IE1pbmRFbW9qaUJhc2VDb21wb25lbnQgfSBmcm9tICcuL2Vtb2ppLWJhc2UuY29tcG9uZW50JztcblxuZXhwb3J0IGludGVyZmFjZSBQbGFpdE1pbmRFbW9qaUJvYXJkIGV4dGVuZHMgUGxhaXRCb2FyZCB7XG4gICAgZHJhd0Vtb2ppOiAoZW1vamk6IEVtb2ppSXRlbSwgZWxlbWVudDogTWluZEVsZW1lbnQpID0+IENvbXBvbmVudFR5cGU8TWluZEVtb2ppQmFzZUNvbXBvbmVudD47XG59XG5cbmV4cG9ydCBjb25zdCB3aXRoRW1vamkgPSAoYm9hcmQ6IFBsYWl0Qm9hcmQpID0+IHtcbiAgICBjb25zdCBuZXdCb2FyZCA9IGJvYXJkIGFzIFBsYWl0Qm9hcmQgJiBQbGFpdE1pbmRFbW9qaUJvYXJkO1xuXG4gICAgbmV3Qm9hcmQuZHJhd0Vtb2ppID0gKGVtb2ppOiBFbW9qaUl0ZW0sIGVsZW1lbnQ6IE1pbmRFbGVtZW50KSA9PiB7XG4gICAgICAgIHRocm93IG5ldyBFcnJvcignTm90IGltcGxlbWVudCBkcmF3RW1vamkgbWV0aG9kIGVycm9yLicpO1xuICAgIH1cblxuICAgIHJldHVybiBuZXdCb2FyZDtcbn07Il19

package/esm2020/plugins/with-abstract.mjs

@@ -0,0 +1,92 @@
+import { BOARD_TO_HOST, PlaitBoard, PlaitElement, Transforms, getSelectedElements, toPoint, transformPoint } from '@plait/core';
+import { AbstractNode, isHorizontalLayout, isStandardLayout } from '@plait/layouts';
+import { AbstractHandlePosition, MindElement } from '../interfaces';
+import { MindmapQueries } from '../public-api';
+import { findLocationLeftIndex, getHitAbstractHandle, getLocationScope } from '../utils/abstract/resize';
+import { separateChildren } from '../utils/abstract/common';
+export const withAbstract = (board) => {
+    const { mousedown, mousemove, mouseup } = board;
+    let activeAbstractElement;
+    let abstractHandlePosition;
+    let startPoint;
+    let newProperty;
+    board.mousedown = (event) => {
+        const activeAbstractElements = getSelectedElements(board).filter(element => AbstractNode.isAbstract(element));
+        const host = BOARD_TO_HOST.get(board);
+        const point = transformPoint(board, toPoint(event.x, event.y, host));
+        activeAbstractElement = activeAbstractElements.find(element => {
+            abstractHandlePosition = getHitAbstractHandle(board, element, point);
+            return abstractHandlePosition;
+        });
+        if (activeAbstractElement) {
+            startPoint = point;
+            return;
+        }
+        mousedown(event);
+    };
+    board.mousemove = (event) => {
+        getSelectedElements(board);
+        const host = BOARD_TO_HOST.get(board);
+        const endPoint = transformPoint(board, toPoint(event.x, event.y, host));
+        if (abstractHandlePosition && activeAbstractElement) {
+            const abstractComponent = PlaitElement.getComponent(activeAbstractElement);
+            const element = abstractComponent.element;
+            const nodeLayout = MindmapQueries.getCorrectLayoutByElement(activeAbstractElement);
+            const isHorizontal = isHorizontalLayout(nodeLayout);
+            const parentElement = MindElement.getParent(element);
+            let children = parentElement.children;
+            const parentLayout = MindmapQueries.getLayoutByElement(parentElement);
+            if (isStandardLayout(parentLayout)) {
+                const rightNodeCount = parentElement.rightNodeCount;
+                const { leftChildren, rightChildren } = separateChildren(parentElement);
+                if (activeAbstractElement.end < rightNodeCount) {
+                    children = rightChildren;
+                }
+                if (activeAbstractElement.start >= rightNodeCount) {
+                    children = leftChildren;
+                }
+            }
+            const resizingLocation = isHorizontal ? endPoint[1] : endPoint[0];
+            const parent = MindElement.getNode(parentElement);
+            const scope = getLocationScope(board, abstractHandlePosition, children, element, parent, isHorizontal);
+            const location = Math.min(scope.max, Math.max(scope.min, resizingLocation));
+            let locationIndex = findLocationLeftIndex(board, children, location, isHorizontal);
+            const isPropertyUnchanged = (abstractHandlePosition === AbstractHandlePosition.start &&
+                locationIndex + 1 === activeAbstractElement.start) ||
+                (abstractHandlePosition === AbstractHandlePosition.end && locationIndex === activeAbstractElement.end);
+            if (isPropertyUnchanged) {
+                newProperty = undefined;
+            }
+            else {
+                if (isStandardLayout(parent.layout)) {
+                    const rightNodeCount = parent.origin.rightNodeCount;
+                    let start = element.start;
+                    if (start >= rightNodeCount) {
+                        locationIndex += rightNodeCount;
+                    }
+                }
+                newProperty =
+                    abstractHandlePosition === AbstractHandlePosition.start ? { start: locationIndex + 1 } : { end: locationIndex };
+            }
+            abstractComponent.updateAbstractIncludedOutline(location, abstractHandlePosition);
+        }
+        mousemove(event);
+    };
+    board.mouseup = (event) => {
+        startPoint = undefined;
+        abstractHandlePosition = null;
+        if (activeAbstractElement) {
+            if (newProperty) {
+                const path = PlaitBoard.findPath(board, activeAbstractElement);
+                Transforms.setNode(board, newProperty, path);
+            }
+            else {
+                const abstractComponent = PlaitElement.getComponent(activeAbstractElement);
+                abstractComponent.updateAbstractIncludedOutline();
+            }
+        }
+        mouseup(event);
+    };
+    return board;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-abstract.js","sourceRoot":"","sources":["../../../../packages/mind/src/plugins/with-abstract.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    BOARD_TO_HOST,\n    PlaitBoard,\n    PlaitElement,\n    PlaitPlugin,\n    Point,\n    Transforms,\n    getSelectedElements,\n    toPoint,\n    transformPoint\n} from '@plait/core';\nimport { AbstractNode, LayoutNode, MindmapLayoutType, isHorizontalLayout, isStandardLayout } from '@plait/layouts';\nimport { AbstractHandlePosition, MindElement } from '../interfaces';\nimport { MindNodeComponent, MindmapQueries } from '../public-api';\nimport { findLocationLeftIndex, getHitAbstractHandle, getLocationScope } from '../utils/abstract/resize';\nimport { separateChildren } from '../utils/abstract/common';\n\nexport const withAbstract: PlaitPlugin = (board: PlaitBoard) => {\n    const { mousedown, mousemove, mouseup } = board;\n    let activeAbstractElement: PlaitElement | undefined;\n    let abstractHandlePosition: AbstractHandlePosition | null;\n    let startPoint: Point | undefined;\n    let newProperty: { end: number } | { start: number } | undefined;\n\n    board.mousedown = (event: MouseEvent) => {\n        const activeAbstractElements = getSelectedElements(board).filter(element => AbstractNode.isAbstract(element));\n        const host = BOARD_TO_HOST.get(board);\n        const point = transformPoint(board, toPoint(event.x, event.y, host!));\n\n        activeAbstractElement = activeAbstractElements.find(element => {\n            abstractHandlePosition = getHitAbstractHandle(board, element as MindElement, point);\n            return abstractHandlePosition;\n        });\n\n        if (activeAbstractElement) {\n            startPoint = point;\n            return;\n        }\n\n        mousedown(event);\n    };\n\n    board.mousemove = (event: MouseEvent) => {\n        getSelectedElements(board);\n        const host = BOARD_TO_HOST.get(board);\n        const endPoint = transformPoint(board, toPoint(event.x, event.y, host!));\n\n        if (abstractHandlePosition && activeAbstractElement) {\n            const abstractComponent = PlaitElement.getComponent(activeAbstractElement) as MindNodeComponent;\n            const element = abstractComponent.element;\n            const nodeLayout = MindmapQueries.getCorrectLayoutByElement(activeAbstractElement as MindElement) as MindmapLayoutType;\n            const isHorizontal = isHorizontalLayout(nodeLayout);\n            const parentElement = MindElement.getParent(element);\n\n            let children = parentElement.children;\n\n            const parentLayout = MindmapQueries.getLayoutByElement(parentElement);\n            if (isStandardLayout(parentLayout)) {\n                const rightNodeCount = parentElement.rightNodeCount!;\n                const { leftChildren, rightChildren } = separateChildren(parentElement);\n                if ((activeAbstractElement as MindElement).end! < rightNodeCount) {\n                    children = rightChildren;\n                }\n                if ((activeAbstractElement as MindElement).start! >= rightNodeCount) {\n                    children = leftChildren;\n                }\n            }\n\n            const resizingLocation = isHorizontal ? endPoint[1] : endPoint[0];\n            const parent = (MindElement.getNode(parentElement) as unknown) as LayoutNode;\n            const scope = getLocationScope(board, abstractHandlePosition, children, element, parent, isHorizontal);\n            const location = Math.min(scope.max, Math.max(scope.min, resizingLocation));\n\n            let locationIndex = findLocationLeftIndex(board, children, location, isHorizontal);\n\n            const isPropertyUnchanged =\n                (abstractHandlePosition === AbstractHandlePosition.start &&\n                    locationIndex + 1 === (activeAbstractElement as MindElement).start!) ||\n                (abstractHandlePosition === AbstractHandlePosition.end && locationIndex === (activeAbstractElement as MindElement).end!);\n\n            if (isPropertyUnchanged) {\n                newProperty = undefined;\n            } else {\n                if (isStandardLayout(parent.layout)) {\n                    const rightNodeCount = parent.origin.rightNodeCount;\n                    let start = element.start!;\n                    if (start >= rightNodeCount) {\n                        locationIndex += rightNodeCount;\n                    }\n                }\n\n                newProperty =\n                    abstractHandlePosition === AbstractHandlePosition.start ? { start: locationIndex + 1 } : { end: locationIndex };\n            }\n\n            abstractComponent!.updateAbstractIncludedOutline(location, abstractHandlePosition);\n        }\n        mousemove(event);\n    };\n\n    board.mouseup = (event: MouseEvent) => {\n        startPoint = undefined;\n        abstractHandlePosition = null;\n        if (activeAbstractElement) {\n            if (newProperty) {\n                const path = PlaitBoard.findPath(board, activeAbstractElement);\n                Transforms.setNode(board, newProperty, path);\n            } else {\n                const abstractComponent = PlaitElement.getComponent(activeAbstractElement) as MindNodeComponent;\n                abstractComponent!.updateAbstractIncludedOutline();\n            }\n        }\n        mouseup(event);\n    };\n    return board;\n};\n"]}

package/esm2020/plugins/with-dnd.mjs

@@ -0,0 +1,276 @@
+import { createG, distanceBetweenPointAndPoint, IS_TEXT_EDITABLE, Path, PlaitBoard, toPoint, transformPoint, Transforms, ELEMENT_TO_COMPONENT, getSelectedElements } from '@plait/core';
+import { isBottomLayout, isHorizontalLogicLayout, isIndentedLayout, isLeftLayout, isRightLayout, isStandardLayout, isTopLayout, isVerticalLogicLayout } from '@plait/layouts';
+import { updateForeignObject } from '@plait/richtext';
+import { BASE } from '../constants';
+import { getRichtextRectangleByNode } from '../draw/richtext';
+import { drawRectangleNode } from '../draw/shape';
+import { PlaitMind } from '../interfaces/element';
+import { directionCorrector, directionDetector, drawPlaceholderDropNodeG, findUpElement, isChildElement, readjustmentDropTarget } from '../utils';
+import { getRectangleByNode, hitMindmapElement } from '../utils/graph';
+import { MINDMAP_ELEMENT_TO_COMPONENT } from '../utils/weak-maps';
+import { MindmapQueries } from '../queries';
+const DRAG_MOVE_BUFFER = 5;
+export const withDnd = (board) => {
+    const { mousedown, mousemove, globalMouseup, keydown } = board;
+    let activeElement;
+    let startPoint;
+    let fakeDragNodeG;
+    let fakeDropNodeG;
+    let dropTarget = null;
+    board.mousedown = (event) => {
+        if (board.options.readonly || IS_TEXT_EDITABLE.get(board) || event.button === 2) {
+            mousedown(event);
+            return;
+        }
+        // 确认是否 hit 节点
+        const point = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));
+        const selectedElements = getSelectedElements(board);
+        board.children.forEach((value) => {
+            if (activeElement) {
+                return;
+            }
+            if (PlaitMind.isMind(value)) {
+                const mindmapComponent = ELEMENT_TO_COMPONENT.get(value);
+                const root = mindmapComponent?.root;
+                root.eachNode((node) => {
+                    if (activeElement) {
+                        return;
+                    }
+                    if (hitMindmapElement(board, point, node.origin) && !node.origin.isRoot && selectedElements.length <= 1) {
+                        activeElement = node.origin;
+                        startPoint = point;
+                    }
+                });
+            }
+        });
+        if (activeElement) {
+            event.preventDefault();
+        }
+        mousedown(event);
+    };
+    board.mousemove = (event) => {
+        if (!board.options.readonly && activeElement && startPoint) {
+            const endPoint = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));
+            const distance = distanceBetweenPointAndPoint(startPoint[0], startPoint[1], endPoint[0], endPoint[1]);
+            if (distance < DRAG_MOVE_BUFFER) {
+                return;
+            }
+            if (!isDragging(board)) {
+                setIsDragging(board, true);
+                fakeDragNodeG = createG();
+                fakeDragNodeG.classList.add('dragging', 'fake-node', 'plait-board-attached');
+                fakeDropNodeG = createG();
+                addActiveOnDragOrigin(activeElement);
+                PlaitBoard.getHost(board).appendChild(fakeDropNodeG);
+                PlaitBoard.getHost(board).appendChild(fakeDragNodeG);
+            }
+            else {
+                fakeDragNodeG?.childNodes.forEach(node => {
+                    node.remove();
+                });
+                fakeDropNodeG?.childNodes.forEach(node => {
+                    node.remove();
+                });
+            }
+            // fake dragging origin node
+            const offsetX = endPoint[0] - startPoint[0];
+            const offsetY = endPoint[1] - startPoint[1];
+            const activeComponent = MINDMAP_ELEMENT_TO_COMPONENT.get(activeElement);
+            const roughSVG = PlaitBoard.getRoughSVG(board);
+            const fakeDraggingNode = {
+                ...activeComponent.node,
+                children: [],
+                x: activeComponent.node.x + offsetX,
+                y: activeComponent.node.y + offsetY
+            };
+            const textRectangle = getRichtextRectangleByNode(activeComponent.node);
+            const fakeNodeG = drawRectangleNode(board, fakeDraggingNode);
+            const richtextG = activeComponent.richtextG?.cloneNode(true);
+            updateForeignObject(richtextG, textRectangle.width + BASE * 10, textRectangle.height, textRectangle.x + offsetX, textRectangle.y + offsetY);
+            fakeDragNodeG?.append(fakeNodeG);
+            fakeDragNodeG?.append(richtextG);
+            // drop position detect
+            const { x, y } = getRectangleByNode(fakeDraggingNode);
+            const detectCenterPoint = [x + textRectangle.width / 2, y + textRectangle.height / 2];
+            let detectResult = null;
+            board.children.forEach((value) => {
+                if (detectResult) {
+                    return;
+                }
+                if (PlaitMind.isMind(value)) {
+                    const mindmapComponent = ELEMENT_TO_COMPONENT.get(value);
+                    const root = mindmapComponent?.root;
+                    root.eachNode((node) => {
+                        if (detectResult) {
+                            return;
+                        }
+                        const directions = directionDetector(node, detectCenterPoint);
+                        if (directions) {
+                            detectResult = directionCorrector(node, directions);
+                        }
+                        dropTarget = null;
+                        if (detectResult && isValidTarget(activeComponent.node.origin, node.origin)) {
+                            dropTarget = { target: node.origin, detectResult: detectResult[0] };
+                        }
+                    });
+                }
+            });
+            if (dropTarget?.target) {
+                dropTarget = readjustmentDropTarget(dropTarget);
+                drawPlaceholderDropNodeG(dropTarget, roughSVG, fakeDropNodeG);
+            }
+        }
+        mousemove(event);
+    };
+    board.globalMouseup = (event) => {
+        if (!board.options.readonly && activeElement) {
+            if (dropTarget?.target) {
+                const activeComponent = MINDMAP_ELEMENT_TO_COMPONENT.get(activeElement);
+                const targetComponent = MINDMAP_ELEMENT_TO_COMPONENT.get(dropTarget.target);
+                let targetPath = PlaitBoard.findPath(board, targetComponent.element);
+                const mindmapElement = findUpElement(dropTarget.target).root;
+                const mindmapComponent = ELEMENT_TO_COMPONENT.get(mindmapElement);
+                const layout = MindmapQueries.getCorrectLayoutByElement(mindmapComponent?.root.origin);
+                targetPath = updatePathByLayoutAndDropTarget(targetPath, layout, dropTarget);
+                const originPath = PlaitBoard.findPath(board, activeComponent.element);
+                let newElement = { isCollapsed: false }, rightTargetPath = PlaitBoard.findPath(board, targetComponent.element);
+                if (isStandardLayout(layout)) {
+                    updateRightNodeCount(board, activeComponent, targetComponent, dropTarget.detectResult);
+                }
+                if (dropTarget.detectResult === 'right') {
+                    if (targetComponent.node.origin.isRoot) {
+                        targetPath = PlaitBoard.findPath(board, targetComponent.element);
+                        targetPath.push(0);
+                        const rightNodeCount = targetComponent.node.origin.rightNodeCount + 1;
+                        newElement = { isCollapsed: false, rightNodeCount };
+                    }
+                    Transforms.setNode(board, newElement, rightTargetPath);
+                }
+                Transforms.moveNode(board, originPath, targetPath);
+            }
+            if (isDragging(board)) {
+                removeActiveOnDragOrigin(activeElement);
+            }
+            setIsDragging(board, false);
+            activeElement = null;
+            fakeDragNodeG?.remove();
+            fakeDragNodeG = undefined;
+            fakeDropNodeG?.remove();
+            fakeDropNodeG = undefined;
+            dropTarget = null;
+        }
+        globalMouseup(event);
+    };
+    board.keydown = (event) => {
+        keydown(event);
+    };
+    return board;
+};
+export const isValidTarget = (origin, target) => {
+    return origin !== target && !isChildElement(origin, target);
+};
+export const addActiveOnDragOrigin = (activeElement, isOrigin = true) => {
+    const activeComponent = MINDMAP_ELEMENT_TO_COMPONENT.get(activeElement);
+    if (isOrigin) {
+        activeComponent.g.classList.add('dragging-origin');
+    }
+    else {
+        activeComponent.g.classList.add('dragging-child');
+    }
+    !activeElement.isCollapsed &&
+        activeElement.children.forEach(child => {
+            addActiveOnDragOrigin(child, false);
+        });
+};
+export const removeActiveOnDragOrigin = (activeElement, isOrigin = true) => {
+    const activeComponent = MINDMAP_ELEMENT_TO_COMPONENT.get(activeElement);
+    if (isOrigin) {
+        activeComponent.g.classList.remove('dragging-origin');
+    }
+    else {
+        activeComponent.g.classList.remove('dragging-child');
+    }
+    !activeElement.isCollapsed &&
+        activeElement.children.forEach(child => {
+            removeActiveOnDragOrigin(child, false);
+        });
+};
+const updatePathByLayoutAndDropTarget = (targetPath, layout, dropTarget) => {
+    // 上下布局：左右是兄弟节点，上下是子节点
+    if (isVerticalLogicLayout(layout)) {
+        if (isTopLayout(layout) && dropTarget.detectResult === 'top') {
+            targetPath.push(dropTarget.target.children.length);
+        }
+        if (isBottomLayout(layout) && dropTarget.detectResult === 'bottom') {
+            targetPath.push(dropTarget.target.children.length);
+        }
+        // 如果是左，位置不变，右则插入到下一个兄弟节点
+        if (dropTarget.detectResult === 'right') {
+            targetPath = Path.next(targetPath);
+        }
+    }
+    // 水平布局/标准布局：上下是兄弟节点，左右是子节点
+    if (isHorizontalLogicLayout(layout)) {
+        if (dropTarget.detectResult === 'right') {
+            targetPath.push(dropTarget.target.children.length);
+        }
+        if (dropTarget.detectResult === 'left') {
+            targetPath.push(dropTarget.target.children.length);
+        }
+        // 如果是上，位置不变，下插入到下一个兄弟节点
+        if (dropTarget.detectResult === 'bottom') {
+            targetPath = Path.next(targetPath);
+        }
+    }
+    // 缩进布局：上下是兄弟节点，左右是子节点，但上（左上/右上），探测到上是子节点，下则位置不变，反之同理。
+    if (isIndentedLayout(layout)) {
+        if (isTopLayout(layout) && dropTarget.detectResult === 'top') {
+            targetPath = Path.next(targetPath);
+        }
+        if (isBottomLayout(layout) && dropTarget.detectResult === 'bottom') {
+            targetPath = Path.next(targetPath);
+        }
+        if (isLeftLayout(layout) && dropTarget.detectResult === 'left') {
+            targetPath.push(dropTarget.target.children.length);
+        }
+        if (isRightLayout(layout) && dropTarget.detectResult === 'right') {
+            targetPath.push(dropTarget.target.children.length);
+        }
+    }
+    return targetPath;
+};
+export const updateRightNodeCount = (board, activeComponent, targetComponent, detectResult) => {
+    let rightNodeCount;
+    const mindmapElement = findUpElement(targetComponent.node.origin).root;
+    const mindmapComponent = ELEMENT_TO_COMPONENT.get(mindmapElement);
+    const activeIndex = mindmapComponent?.root.children.indexOf(activeComponent.node);
+    const targetIndex = mindmapComponent?.root.children.indexOf(targetComponent.node);
+    const isActiveOnRight = activeIndex !== -1 && activeIndex <= activeComponent.parent.origin.rightNodeCount - 1;
+    const isTargetOnRight = targetComponent.parent && targetIndex !== -1 && targetIndex <= targetComponent.parent.origin.rightNodeCount - 1;
+    const isBothOnRight = isActiveOnRight && isTargetOnRight;
+    const rootChildCount = mindmapComponent.root.children?.length;
+    const rootRightNodeCount = mindmapComponent?.root.origin.rightNodeCount;
+    if (!isBothOnRight) {
+        if (isActiveOnRight) {
+            rightNodeCount = rootChildCount < rootRightNodeCount ? rootChildCount - 1 : rootRightNodeCount - 1;
+            Transforms.setNode(board, { rightNodeCount }, PlaitBoard.findPath(board, activeComponent.parent.origin));
+        }
+        if (isTargetOnRight && detectResult !== 'right') {
+            rightNodeCount = rootChildCount < rootRightNodeCount ? rootRightNodeCount : rootRightNodeCount + 1;
+            Transforms.setNode(board, { rightNodeCount }, PlaitBoard.findPath(board, targetComponent.parent.origin));
+        }
+        //二级子节点拖动到根节点左侧
+        if (targetComponent.node.origin.isRoot && detectResult === 'left' && activeIndex === -1) {
+            rightNodeCount = rootChildCount;
+            Transforms.setNode(board, { rightNodeCount }, PlaitBoard.findPath(board, targetComponent.element));
+        }
+    }
+};
+const IS_DRAGGING = new WeakMap();
+export const isDragging = (board) => {
+    return !!IS_DRAGGING.get(board);
+};
+export const setIsDragging = (board, state) => {
+    IS_DRAGGING.set(board, state);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-dnd.js","sourceRoot":"","sources":["../../../../packages/mind/src/plugins/with-dnd.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    createG,\n    distanceBetweenPointAndPoint,\n    IS_TEXT_EDITABLE,\n    Path,\n    PlaitBoard,\n    PlaitElement,\n    PlaitPlugin,\n    Point,\n    toPoint,\n    transformPoint,\n    Transforms,\n    ELEMENT_TO_COMPONENT,\n    getSelectedElements\n} from '@plait/core';\nimport {\n    isBottomLayout,\n    isHorizontalLogicLayout,\n    isIndentedLayout,\n    isLeftLayout,\n    isRightLayout,\n    isStandardLayout,\n    isTopLayout,\n    isVerticalLogicLayout,\n    MindmapLayoutType\n} from '@plait/layouts';\nimport { updateForeignObject } from '@plait/richtext';\nimport { RoughSVG } from 'roughjs/bin/svg';\nimport { BASE } from '../constants';\nimport { getRichtextRectangleByNode } from '../draw/richtext';\nimport { drawRectangleNode } from '../draw/shape';\nimport { MindElement, PlaitMind } from '../interfaces/element';\nimport { DetectResult, MindmapNode } from '../interfaces/node';\nimport { MindNodeComponent } from '../node.component';\nimport {\n    directionCorrector,\n    directionDetector,\n    drawPlaceholderDropNodeG,\n    findUpElement,\n    isChildElement,\n    readjustmentDropTarget\n} from '../utils';\nimport { getRectangleByNode, hitMindmapElement } from '../utils/graph';\nimport { MINDMAP_ELEMENT_TO_COMPONENT } from '../utils/weak-maps';\nimport { MindmapQueries } from '../queries';\nimport { PlaitMindComponent } from '../mind.component';\n\nconst DRAG_MOVE_BUFFER = 5;\n\nexport const withDnd = (board: PlaitBoard) => {\n    const { mousedown, mousemove, globalMouseup, keydown } = board;\n\n    let activeElement: MindElement | null;\n    let startPoint: Point;\n    let fakeDragNodeG: SVGGElement | undefined;\n    let fakeDropNodeG: SVGGElement | undefined;\n    let dropTarget: { target: MindElement; detectResult: DetectResult } | null = null;\n\n    board.mousedown = (event: MouseEvent) => {\n        if (board.options.readonly || IS_TEXT_EDITABLE.get(board) || event.button === 2) {\n            mousedown(event);\n            return;\n        }\n\n        // 确认是否 hit 节点\n        const point = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));\n        const selectedElements = getSelectedElements(board);\n        board.children.forEach((value: PlaitElement) => {\n            if (activeElement) {\n                return;\n            }\n            if (PlaitMind.isMind(value)) {\n                const mindmapComponent = ELEMENT_TO_COMPONENT.get(value) as PlaitMindComponent;\n                const root = mindmapComponent?.root;\n                (root as any).eachNode((node: MindmapNode) => {\n                    if (activeElement) {\n                        return;\n                    }\n                    if (hitMindmapElement(board, point, node.origin) && !node.origin.isRoot && selectedElements.length <= 1) {\n                        activeElement = node.origin;\n                        startPoint = point;\n                    }\n                });\n            }\n        });\n\n        if (activeElement) {\n            event.preventDefault();\n        }\n\n        mousedown(event);\n    };\n\n    board.mousemove = (event: MouseEvent) => {\n        if (!board.options.readonly && activeElement && startPoint) {\n            const endPoint = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));\n            const distance = distanceBetweenPointAndPoint(startPoint[0], startPoint[1], endPoint[0], endPoint[1]);\n            if (distance < DRAG_MOVE_BUFFER) {\n                return;\n            }\n\n            if (!isDragging(board)) {\n                setIsDragging(board, true);\n                fakeDragNodeG = createG();\n                fakeDragNodeG.classList.add('dragging', 'fake-node', 'plait-board-attached');\n                fakeDropNodeG = createG();\n                addActiveOnDragOrigin(activeElement);\n                PlaitBoard.getHost(board).appendChild(fakeDropNodeG);\n                PlaitBoard.getHost(board).appendChild(fakeDragNodeG);\n            } else {\n                fakeDragNodeG?.childNodes.forEach(node => {\n                    node.remove();\n                });\n                fakeDropNodeG?.childNodes.forEach(node => {\n                    node.remove();\n                });\n            }\n\n            // fake dragging origin node\n            const offsetX = endPoint[0] - startPoint[0];\n            const offsetY = endPoint[1] - startPoint[1];\n            const activeComponent = MINDMAP_ELEMENT_TO_COMPONENT.get(activeElement) as MindNodeComponent;\n            const roughSVG = PlaitBoard.getRoughSVG(board);\n            const fakeDraggingNode: MindmapNode = {\n                ...activeComponent.node,\n                children: [],\n                x: activeComponent.node.x + offsetX,\n                y: activeComponent.node.y + offsetY\n            };\n            const textRectangle = getRichtextRectangleByNode(activeComponent.node);\n            const fakeNodeG = drawRectangleNode(board, fakeDraggingNode);\n            const richtextG = activeComponent.richtextG?.cloneNode(true) as SVGGElement;\n            updateForeignObject(richtextG, textRectangle.width + BASE * 10, textRectangle.height, textRectangle.x + offsetX, textRectangle.y + offsetY);\n            fakeDragNodeG?.append(fakeNodeG);\n            fakeDragNodeG?.append(richtextG);\n\n            // drop position detect\n            const { x, y } = getRectangleByNode(fakeDraggingNode);\n            const detectCenterPoint = [x + textRectangle.width / 2, y + textRectangle.height / 2] as Point;\n\n            let detectResult: DetectResult[] | null = null;\n            board.children.forEach((value: PlaitElement) => {\n                if (detectResult) {\n                    return;\n                }\n                if (PlaitMind.isMind(value)) {\n                    const mindmapComponent = ELEMENT_TO_COMPONENT.get(value) as PlaitMindComponent;\n                    const root = mindmapComponent?.root;\n\n                    (root as any).eachNode((node: MindmapNode) => {\n                        if (detectResult) {\n                            return;\n                        }\n                        const directions = directionDetector(node, detectCenterPoint);\n                        if (directions) {\n                            detectResult = directionCorrector(node, directions);\n                        }\n                        dropTarget = null;\n                        if (detectResult && isValidTarget(activeComponent.node.origin, node.origin)) {\n                            dropTarget = { target: node.origin, detectResult: detectResult[0] };\n                        }\n                    });\n                }\n            });\n\n            if (dropTarget?.target) {\n                dropTarget = readjustmentDropTarget(dropTarget);\n                drawPlaceholderDropNodeG(dropTarget, roughSVG, fakeDropNodeG);\n            }\n        }\n\n        mousemove(event);\n    };\n\n    board.globalMouseup = (event: MouseEvent) => {\n        if (!board.options.readonly && activeElement) {\n            if (dropTarget?.target) {\n                const activeComponent = MINDMAP_ELEMENT_TO_COMPONENT.get(activeElement) as MindNodeComponent;\n                const targetComponent = MINDMAP_ELEMENT_TO_COMPONENT.get(dropTarget.target) as MindNodeComponent;\n                let targetPath = PlaitBoard.findPath(board, targetComponent.element);\n                const mindmapElement = findUpElement(dropTarget.target).root;\n                const mindmapComponent = ELEMENT_TO_COMPONENT.get(mindmapElement as PlaitMind) as PlaitMindComponent;\n                const layout = MindmapQueries.getCorrectLayoutByElement(mindmapComponent?.root.origin as MindElement);\n                targetPath = updatePathByLayoutAndDropTarget(targetPath, layout, dropTarget);\n                const originPath = PlaitBoard.findPath(board, activeComponent.element);\n                let newElement: Partial<MindElement> = { isCollapsed: false },\n                    rightTargetPath = PlaitBoard.findPath(board, targetComponent.element);\n\n                if (isStandardLayout(layout)) {\n                    updateRightNodeCount(board, activeComponent, targetComponent, dropTarget.detectResult);\n                }\n\n                if (dropTarget.detectResult === 'right') {\n                    if (targetComponent.node.origin.isRoot) {\n                        targetPath = PlaitBoard.findPath(board, targetComponent.element);\n                        targetPath.push(0);\n                        const rightNodeCount = (targetComponent.node.origin.rightNodeCount as number) + 1;\n                        newElement = { isCollapsed: false, rightNodeCount };\n                    }\n                    Transforms.setNode(board, newElement, rightTargetPath as Path);\n                }\n\n                Transforms.moveNode(board, originPath, targetPath);\n            }\n\n            if (isDragging(board)) {\n                removeActiveOnDragOrigin(activeElement);\n            }\n            setIsDragging(board, false);\n            activeElement = null;\n            fakeDragNodeG?.remove();\n            fakeDragNodeG = undefined;\n            fakeDropNodeG?.remove();\n            fakeDropNodeG = undefined;\n            dropTarget = null;\n        }\n        globalMouseup(event);\n    };\n\n    board.keydown = (event: KeyboardEvent) => {\n        keydown(event);\n    };\n\n    return board;\n};\n\nexport const isValidTarget = (origin: MindElement, target: MindElement) => {\n    return origin !== target && !isChildElement(origin, target);\n};\n\nexport const addActiveOnDragOrigin = (activeElement: MindElement, isOrigin = true) => {\n    const activeComponent = MINDMAP_ELEMENT_TO_COMPONENT.get(activeElement) as MindNodeComponent;\n    if (isOrigin) {\n        activeComponent.g.classList.add('dragging-origin');\n    } else {\n        activeComponent.g.classList.add('dragging-child');\n    }\n    !activeElement.isCollapsed &&\n        activeElement.children.forEach(child => {\n            addActiveOnDragOrigin(child, false);\n        });\n};\n\nexport const removeActiveOnDragOrigin = (activeElement: MindElement, isOrigin = true) => {\n    const activeComponent = MINDMAP_ELEMENT_TO_COMPONENT.get(activeElement) as MindNodeComponent;\n    if (isOrigin) {\n        activeComponent.g.classList.remove('dragging-origin');\n    } else {\n        activeComponent.g.classList.remove('dragging-child');\n    }\n    !activeElement.isCollapsed &&\n        activeElement.children.forEach(child => {\n            removeActiveOnDragOrigin(child, false);\n        });\n};\n\nconst updatePathByLayoutAndDropTarget = (\n    targetPath: Path,\n    layout: MindmapLayoutType,\n    dropTarget: { target: MindElement; detectResult: DetectResult }\n) => {\n    // 上下布局：左右是兄弟节点，上下是子节点\n    if (isVerticalLogicLayout(layout)) {\n        if (isTopLayout(layout) && dropTarget.detectResult === 'top') {\n            targetPath.push(dropTarget.target.children.length);\n        }\n        if (isBottomLayout(layout) && dropTarget.detectResult === 'bottom') {\n            targetPath.push(dropTarget.target.children.length);\n        }\n        // 如果是左，位置不变，右则插入到下一个兄弟节点\n        if (dropTarget.detectResult === 'right') {\n            targetPath = Path.next(targetPath);\n        }\n    }\n    // 水平布局/标准布局：上下是兄弟节点，左右是子节点\n    if (isHorizontalLogicLayout(layout)) {\n        if (dropTarget.detectResult === 'right') {\n            targetPath.push(dropTarget.target.children.length);\n        }\n        if (dropTarget.detectResult === 'left') {\n            targetPath.push(dropTarget.target.children.length);\n        }\n        // 如果是上，位置不变，下插入到下一个兄弟节点\n        if (dropTarget.detectResult === 'bottom') {\n            targetPath = Path.next(targetPath);\n        }\n    }\n    // 缩进布局：上下是兄弟节点，左右是子节点，但上（左上/右上），探测到上是子节点，下则位置不变，反之同理。\n    if (isIndentedLayout(layout)) {\n        if (isTopLayout(layout) && dropTarget.detectResult === 'top') {\n            targetPath = Path.next(targetPath);\n        }\n        if (isBottomLayout(layout) && dropTarget.detectResult === 'bottom') {\n            targetPath = Path.next(targetPath);\n        }\n        if (isLeftLayout(layout) && dropTarget.detectResult === 'left') {\n            targetPath.push(dropTarget.target.children.length);\n        }\n        if (isRightLayout(layout) && dropTarget.detectResult === 'right') {\n            targetPath.push(dropTarget.target.children.length);\n        }\n    }\n    return targetPath;\n};\n\nexport const updateRightNodeCount = (\n    board: PlaitBoard,\n    activeComponent: MindNodeComponent,\n    targetComponent: MindNodeComponent,\n    detectResult: DetectResult\n) => {\n    let rightNodeCount;\n    const mindmapElement = findUpElement(targetComponent.node.origin).root;\n    const mindmapComponent = ELEMENT_TO_COMPONENT.get(mindmapElement as PlaitMind) as PlaitMindComponent;\n    const activeIndex = mindmapComponent?.root.children.indexOf(activeComponent.node) as number;\n    const targetIndex = mindmapComponent?.root.children.indexOf(targetComponent.node) as number;\n    const isActiveOnRight = activeIndex !== -1 && activeIndex <= (activeComponent.parent.origin.rightNodeCount as number) - 1;\n    const isTargetOnRight =\n        targetComponent.parent && targetIndex !== -1 && targetIndex <= (targetComponent.parent.origin.rightNodeCount as number) - 1;\n    const isBothOnRight = isActiveOnRight && isTargetOnRight;\n    const rootChildCount = mindmapComponent.root.children?.length as number;\n    const rootRightNodeCount = mindmapComponent?.root.origin.rightNodeCount as number;\n\n    if (!isBothOnRight) {\n        if (isActiveOnRight) {\n            rightNodeCount = rootChildCount < rootRightNodeCount ? rootChildCount - 1 : rootRightNodeCount - 1;\n            Transforms.setNode(board, { rightNodeCount }, PlaitBoard.findPath(board, activeComponent.parent.origin));\n        }\n\n        if (isTargetOnRight && detectResult !== 'right') {\n            rightNodeCount = rootChildCount < rootRightNodeCount ? rootRightNodeCount : rootRightNodeCount + 1;\n            Transforms.setNode(board, { rightNodeCount }, PlaitBoard.findPath(board, targetComponent.parent.origin));\n        }\n\n        //二级子节点拖动到根节点左侧\n        if (targetComponent.node.origin.isRoot && detectResult === 'left' && activeIndex === -1) {\n            rightNodeCount = rootChildCount;\n            Transforms.setNode(board, { rightNodeCount }, PlaitBoard.findPath(board, targetComponent.element));\n        }\n    }\n};\n\nconst IS_DRAGGING = new WeakMap<PlaitBoard, boolean>();\n\nexport const isDragging = (board: PlaitBoard) => {\n    return !!IS_DRAGGING.get(board);\n};\n\nexport const setIsDragging = (board: PlaitBoard, state: boolean) => {\n    IS_DRAGGING.set(board, state);\n};\n"]}