@plait/core 0.24.0-next.2 → 0.24.0-next.3

package/{esm2020 → esm2022}/plait.module.mjs

@@ -6,11 +6,11 @@ import { PlaitChildrenElement } from './core/children/children.component';
 import * as i0 from "@angular/core";
 const COMPONENTS = [PlaitBoardComponent, PlaitChildrenElement, PlaitElementComponent];
 export class PlaitModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: PlaitModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.3", ngImport: i0, type: PlaitModule, declarations: [PlaitBoardComponent, PlaitChildrenElement, PlaitElementComponent], imports: [CommonModule], exports: [PlaitBoardComponent, PlaitChildrenElement, PlaitElementComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: PlaitModule, imports: [CommonModule] }); }
 }
-PlaitModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: PlaitModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-PlaitModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.5", ngImport: i0, type: PlaitModule, declarations: [PlaitBoardComponent, PlaitChildrenElement, PlaitElementComponent], imports: [CommonModule], exports: [PlaitBoardComponent, PlaitChildrenElement, PlaitElementComponent] });
-PlaitModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: PlaitModule, imports: [CommonModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: PlaitModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: PlaitModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [...COMPONENTS],
@@ -18,4 +18,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.5", ngImpor
                     exports: [...COMPONENTS]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhaXQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvcGxhaXQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzlELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQ3pFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLG9DQUFvQyxDQUFDOztBQUUxRSxNQUFNLFVBQVUsR0FBRyxDQUFDLG1CQUFtQixFQUFFLG9CQUFvQixFQUFFLHFCQUFxQixDQUFDLENBQUM7QUFPdEYsTUFBTSxPQUFPLFdBQVc7O3dHQUFYLFdBQVc7eUdBQVgsV0FBVyxpQkFQSixtQkFBbUIsRUFBRSxvQkFBb0IsRUFBRSxxQkFBcUIsYUFJdEUsWUFBWSxhQUpOLG1CQUFtQixFQUFFLG9CQUFvQixFQUFFLHFCQUFxQjt5R0FPdkUsV0FBVyxZQUhWLFlBQVk7MkZBR2IsV0FBVztrQkFMdkIsUUFBUTttQkFBQztvQkFDTixZQUFZLEVBQUUsQ0FBQyxHQUFHLFVBQVUsQ0FBQztvQkFDN0IsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixPQUFPLEVBQUUsQ0FBQyxHQUFHLFVBQVUsQ0FBQztpQkFDM0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IFBsYWl0Qm9hcmRDb21wb25lbnQgfSBmcm9tICcuL2JvYXJkL2JvYXJkLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBQbGFpdEVsZW1lbnRDb21wb25lbnQgfSBmcm9tICcuL2NvcmUvZWxlbWVudC9lbGVtZW50LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBQbGFpdENoaWxkcmVuRWxlbWVudCB9IGZyb20gJy4vY29yZS9jaGlsZHJlbi9jaGlsZHJlbi5jb21wb25lbnQnO1xuXG5jb25zdCBDT01QT05FTlRTID0gW1BsYWl0Qm9hcmRDb21wb25lbnQsIFBsYWl0Q2hpbGRyZW5FbGVtZW50LCBQbGFpdEVsZW1lbnRDb21wb25lbnRdO1xuXG5ATmdNb2R1bGUoe1xuICAgIGRlY2xhcmF0aW9uczogWy4uLkNPTVBPTkVOVFNdLFxuICAgIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICAgIGV4cG9ydHM6IFsuLi5DT01QT05FTlRTXVxufSlcbmV4cG9ydCBjbGFzcyBQbGFpdE1vZHVsZSB7fVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhaXQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvcGxhaXQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzlELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQ3pFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLG9DQUFvQyxDQUFDOztBQUUxRSxNQUFNLFVBQVUsR0FBRyxDQUFDLG1CQUFtQixFQUFFLG9CQUFvQixFQUFFLHFCQUFxQixDQUFDLENBQUM7QUFPdEYsTUFBTSxPQUFPLFdBQVc7OEdBQVgsV0FBVzsrR0FBWCxXQUFXLGlCQVBKLG1CQUFtQixFQUFFLG9CQUFvQixFQUFFLHFCQUFxQixhQUl0RSxZQUFZLGFBSk4sbUJBQW1CLEVBQUUsb0JBQW9CLEVBQUUscUJBQXFCOytHQU92RSxXQUFXLFlBSFYsWUFBWTs7MkZBR2IsV0FBVztrQkFMdkIsUUFBUTttQkFBQztvQkFDTixZQUFZLEVBQUUsQ0FBQyxHQUFHLFVBQVUsQ0FBQztvQkFDN0IsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixPQUFPLEVBQUUsQ0FBQyxHQUFHLFVBQVUsQ0FBQztpQkFDM0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IFBsYWl0Qm9hcmRDb21wb25lbnQgfSBmcm9tICcuL2JvYXJkL2JvYXJkLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBQbGFpdEVsZW1lbnRDb21wb25lbnQgfSBmcm9tICcuL2NvcmUvZWxlbWVudC9lbGVtZW50LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBQbGFpdENoaWxkcmVuRWxlbWVudCB9IGZyb20gJy4vY29yZS9jaGlsZHJlbi9jaGlsZHJlbi5jb21wb25lbnQnO1xuXG5jb25zdCBDT01QT05FTlRTID0gW1BsYWl0Qm9hcmRDb21wb25lbnQsIFBsYWl0Q2hpbGRyZW5FbGVtZW50LCBQbGFpdEVsZW1lbnRDb21wb25lbnRdO1xuXG5ATmdNb2R1bGUoe1xuICAgIGRlY2xhcmF0aW9uczogWy4uLkNPTVBPTkVOVFNdLFxuICAgIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICAgIGV4cG9ydHM6IFsuLi5DT01QT05FTlRTXVxufSlcbmV4cG9ydCBjbGFzcyBQbGFpdE1vZHVsZSB7fVxuIl19

package/esm2022/plugins/with-moving.mjs

@@ -0,0 +1,98 @@
+import { BOARD_TO_HOST } from '../utils/weak-maps';
+import { PlaitBoard } from '../interfaces/board';
+import { isInPlaitBoard, transformPoint } from '../utils/board';
+import { toPoint } from '../utils/dom/common';
+import { Transforms } from '../transforms';
+import { getHitElementOfRoot, getSelectedElements } from '../utils/selected-element';
+import { PlaitNode } from '../interfaces/node';
+import { throttleRAF } from '../utils/common';
+import { addMovingElements, removeMovingElements } from '../utils/moving-element';
+import { MERGING } from '../interfaces/history';
+import { isPreventTouchMove } from '../utils';
+export function withMoving(board) {
+    const { pointerDown, pointerMove, globalPointerUp, globalPointerMove } = board;
+    let offsetX = 0;
+    let offsetY = 0;
+    let isPreventDefault = false;
+    let startPoint;
+    let activeElements = [];
+    board.pointerDown = (event) => {
+        const host = BOARD_TO_HOST.get(board);
+        const point = transformPoint(board, toPoint(event.x, event.y, host));
+        const range = { anchor: point, focus: point };
+        let movableElements = board.children.filter(item => board.isMovable(item));
+        if (movableElements.length && !isPreventTouchMove(board)) {
+            startPoint = point;
+            const selectedRootElements = getSelectedElements(board).filter(item => movableElements.includes(item));
+            const hitElement = getHitElementOfRoot(board, movableElements, range);
+            if (hitElement && selectedRootElements.includes(hitElement)) {
+                activeElements = selectedRootElements;
+            }
+            else if (hitElement) {
+                activeElements = [hitElement];
+            }
+        }
+        pointerDown(event);
+    };
+    board.pointerMove = (event) => {
+        if (startPoint && activeElements.length && !PlaitBoard.hasBeenTextEditing(board)) {
+            if (!isPreventDefault) {
+                isPreventDefault = true;
+            }
+            const host = BOARD_TO_HOST.get(board);
+            const endPoint = transformPoint(board, toPoint(event.x, event.y, host));
+            offsetX = endPoint[0] - startPoint[0];
+            offsetY = endPoint[1] - startPoint[1];
+            const offsetBuffer = 5;
+            if (Math.abs(offsetX) > offsetBuffer || Math.abs(offsetY) > offsetBuffer) {
+                throttleRAF(() => {
+                    const currentElements = activeElements.map(activeElement => {
+                        const points = activeElement.points || [];
+                        const [x, y] = activeElement.points[0];
+                        const newPoints = points.map(p => [p[0] + offsetX, p[1] + offsetY]);
+                        const index = board.children.findIndex(item => item.id === activeElement.id);
+                        Transforms.setNode(board, {
+                            points: newPoints
+                        }, [index]);
+                        MERGING.set(board, true);
+                        return PlaitNode.get(board, [index]);
+                    });
+                    PlaitBoard.getBoardContainer(board).classList.add('element-moving');
+                    addMovingElements(board, currentElements);
+                });
+            }
+        }
+        if (isPreventDefault) {
+            // 阻止 move 过程中触发画布滚动行为
+            event.preventDefault();
+        }
+        pointerMove(event);
+    };
+    board.globalPointerMove = (event) => {
+        if (startPoint) {
+            const inPlaitBoardElement = isInPlaitBoard(board, event.x, event.y);
+            if (!inPlaitBoardElement) {
+                cancelMove(board);
+            }
+        }
+        globalPointerMove(event);
+    };
+    board.globalPointerUp = event => {
+        isPreventDefault = false;
+        if (startPoint) {
+            cancelMove(board);
+        }
+        globalPointerUp(event);
+    };
+    function cancelMove(board) {
+        startPoint = null;
+        offsetX = 0;
+        offsetY = 0;
+        activeElements = [];
+        removeMovingElements(board);
+        MERGING.set(board, false);
+        PlaitBoard.getBoardContainer(board).classList.remove('element-moving');
+    }
+    return board;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-moving.js","sourceRoot":"","sources":["../../../../packages/core/src/plugins/with-moving.ts"],"names":[],"mappings":"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","sourcesContent":["import { BOARD_TO_HOST } from '../utils/weak-maps';\nimport { PlaitBoard } from '../interfaces/board';\nimport { isInPlaitBoard, transformPoint } from '../utils/board';\nimport { toPoint } from '../utils/dom/common';\nimport { Point } from '../interfaces/point';\nimport { Transforms } from '../transforms';\nimport { PlaitElement } from '../interfaces/element';\nimport { getHitElementOfRoot, getSelectedElements } from '../utils/selected-element';\nimport { PlaitNode } from '../interfaces/node';\nimport { throttleRAF } from '../utils/common';\nimport { addMovingElements, removeMovingElements } from '../utils/moving-element';\nimport { MERGING } from '../interfaces/history';\nimport { Range } from '../interfaces';\nimport { isPreventTouchMove } from '../utils';\n\nexport function withMoving(board: PlaitBoard) {\n    const { pointerDown, pointerMove, globalPointerUp, globalPointerMove } = board;\n\n    let offsetX = 0;\n    let offsetY = 0;\n    let isPreventDefault = false;\n    let startPoint: Point | null;\n    let activeElements: PlaitElement[] = [];\n\n    board.pointerDown = (event: PointerEvent) => {\n        const host = BOARD_TO_HOST.get(board);\n        const point = transformPoint(board, toPoint(event.x, event.y, host!));\n        const range = { anchor: point, focus: point } as Range;\n        let movableElements = board.children.filter(item => board.isMovable(item));\n        if (movableElements.length && !isPreventTouchMove(board)) {\n            startPoint = point;\n            const selectedRootElements = getSelectedElements(board).filter(item => movableElements.includes(item));\n            const hitElement = getHitElementOfRoot(board, movableElements, range);\n            if (hitElement && selectedRootElements.includes(hitElement)) {\n                activeElements = selectedRootElements;\n            } else if (hitElement) {\n                activeElements = [hitElement];\n            }\n        }\n\n        pointerDown(event);\n    };\n\n    board.pointerMove = (event: PointerEvent) => {\n        if (startPoint && activeElements.length && !PlaitBoard.hasBeenTextEditing(board)) {\n            if (!isPreventDefault) {\n                isPreventDefault = true;\n            }\n            const host = BOARD_TO_HOST.get(board);\n            const endPoint = transformPoint(board, toPoint(event.x, event.y, host!));\n            offsetX = endPoint[0] - startPoint[0];\n            offsetY = endPoint[1] - startPoint[1];\n            const offsetBuffer = 5;\n            if (Math.abs(offsetX) > offsetBuffer || Math.abs(offsetY) > offsetBuffer) {\n                throttleRAF(() => {\n                    const currentElements = activeElements.map(activeElement => {\n                        const points = activeElement.points || [];\n                        const [x, y] = activeElement.points![0];\n                        const newPoints = points.map(p => [p[0] + offsetX, p[1] + offsetY]) as Point[];\n                        const index = board.children.findIndex(item => item.id === activeElement.id);\n                        Transforms.setNode(\n                            board,\n                            {\n                                points: newPoints\n                            },\n                            [index]\n                        );\n                        MERGING.set(board, true);\n                        return PlaitNode.get(board, [index]);\n                    });\n                    PlaitBoard.getBoardContainer(board).classList.add('element-moving');\n                    addMovingElements(board, currentElements as PlaitElement[]);\n                });\n            }\n        }\n        if (isPreventDefault) {\n            // 阻止 move 过程中触发画布滚动行为\n            event.preventDefault();\n        }\n        pointerMove(event);\n    };\n\n    board.globalPointerMove = (event: PointerEvent) => {\n        if (startPoint) {\n            const inPlaitBoardElement = isInPlaitBoard(board, event.x, event.y);\n            if (!inPlaitBoardElement) {\n                cancelMove(board);\n            }\n        }\n        globalPointerMove(event);\n    };\n\n    board.globalPointerUp = event => {\n        isPreventDefault = false;\n        if (startPoint) {\n            cancelMove(board);\n        }\n        globalPointerUp(event);\n    };\n\n    function cancelMove(board: PlaitBoard) {\n        startPoint = null;\n        offsetX = 0;\n        offsetY = 0;\n        activeElements = [];\n        removeMovingElements(board);\n        MERGING.set(board, false);\n        PlaitBoard.getBoardContainer(board).classList.remove('element-moving');\n    }\n\n    return board;\n}\n"]}

package/{esm2020 → esm2022}/services/image-context.service.mjs

@@ -13,10 +13,10 @@ export class PlaitContextService {
     removeUploadingFile(fileEntry) {
         this.uploadingFiles = this.uploadingFiles.filter(file => file.url !== fileEntry.url);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: PlaitContextService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: PlaitContextService }); }
 }
-PlaitContextService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: PlaitContextService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-PlaitContextService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: PlaitContextService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: PlaitContextService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: PlaitContextService, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1hZ2UtY29udGV4dC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvc2VydmljZXMvaW1hZ2UtY29udGV4dC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSTNDLE1BQU0sT0FBTyxtQkFBbUI7SUFEaEM7UUFFWSxtQkFBYyxHQUFpQixFQUFFLENBQUM7S0FhN0M7SUFYRyxnQkFBZ0IsQ0FBQyxHQUFXO1FBQ3hCLE9BQU8sSUFBSSxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsR0FBRyxLQUFLLEdBQUcsQ0FBQyxDQUFDO0lBQzlELENBQUM7SUFFRCxnQkFBZ0IsQ0FBQyxJQUFnQjtRQUM3QixPQUFPLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzFDLENBQUM7SUFFRCxtQkFBbUIsQ0FBQyxTQUFxQjtRQUNyQyxJQUFJLENBQUMsY0FBYyxHQUFHLElBQUksQ0FBQyxjQUFjLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLEdBQUcsS0FBSyxTQUFTLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDekYsQ0FBQzs7Z0hBYlEsbUJBQW1CO29IQUFuQixtQkFBbUI7MkZBQW5CLG1CQUFtQjtrQkFEL0IsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEltYWdlRW50cnkgfSBmcm9tICcuLi9pbnRlcmZhY2VzJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFBsYWl0Q29udGV4dFNlcnZpY2Uge1xuICAgIHByaXZhdGUgdXBsb2FkaW5nRmlsZXM6IEltYWdlRW50cnlbXSA9IFtdO1xuXG4gICAgZ2V0VXBsb2FkaW5nRmlsZSh1cmw6IHN0cmluZykge1xuICAgICAgICByZXR1cm4gdGhpcy51cGxvYWRpbmdGaWxlcy5maW5kKGZpbGUgPT4gZmlsZS51cmwgPT09IHVybCk7XG4gICAgfVxuXG4gICAgc2V0VXBsb2FkaW5nRmlsZShmaWxlOiBJbWFnZUVudHJ5KSB7XG4gICAgICAgIHJldHVybiB0aGlzLnVwbG9hZGluZ0ZpbGVzLnB1c2goZmlsZSk7XG4gICAgfVxuXG4gICAgcmVtb3ZlVXBsb2FkaW5nRmlsZShmaWxlRW50cnk6IEltYWdlRW50cnkpIHtcbiAgICAgICAgdGhpcy51cGxvYWRpbmdGaWxlcyA9IHRoaXMudXBsb2FkaW5nRmlsZXMuZmlsdGVyKGZpbGUgPT4gZmlsZS51cmwgIT09IGZpbGVFbnRyeS51cmwpO1xuICAgIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1hZ2UtY29udGV4dC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvc2VydmljZXMvaW1hZ2UtY29udGV4dC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSTNDLE1BQU0sT0FBTyxtQkFBbUI7SUFEaEM7UUFFWSxtQkFBYyxHQUFpQixFQUFFLENBQUM7S0FhN0M7SUFYRyxnQkFBZ0IsQ0FBQyxHQUFXO1FBQ3hCLE9BQU8sSUFBSSxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsR0FBRyxLQUFLLEdBQUcsQ0FBQyxDQUFDO0lBQzlELENBQUM7SUFFRCxnQkFBZ0IsQ0FBQyxJQUFnQjtRQUM3QixPQUFPLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzFDLENBQUM7SUFFRCxtQkFBbUIsQ0FBQyxTQUFxQjtRQUNyQyxJQUFJLENBQUMsY0FBYyxHQUFHLElBQUksQ0FBQyxjQUFjLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLEdBQUcsS0FBSyxTQUFTLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDekYsQ0FBQzs4R0FiUSxtQkFBbUI7a0hBQW5CLG1CQUFtQjs7MkZBQW5CLG1CQUFtQjtrQkFEL0IsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEltYWdlRW50cnkgfSBmcm9tICcuLi9pbnRlcmZhY2VzJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFBsYWl0Q29udGV4dFNlcnZpY2Uge1xuICAgIHByaXZhdGUgdXBsb2FkaW5nRmlsZXM6IEltYWdlRW50cnlbXSA9IFtdO1xuXG4gICAgZ2V0VXBsb2FkaW5nRmlsZSh1cmw6IHN0cmluZykge1xuICAgICAgICByZXR1cm4gdGhpcy51cGxvYWRpbmdGaWxlcy5maW5kKGZpbGUgPT4gZmlsZS51cmwgPT09IHVybCk7XG4gICAgfVxuXG4gICAgc2V0VXBsb2FkaW5nRmlsZShmaWxlOiBJbWFnZUVudHJ5KSB7XG4gICAgICAgIHJldHVybiB0aGlzLnVwbG9hZGluZ0ZpbGVzLnB1c2goZmlsZSk7XG4gICAgfVxuXG4gICAgcmVtb3ZlVXBsb2FkaW5nRmlsZShmaWxlRW50cnk6IEltYWdlRW50cnkpIHtcbiAgICAgICAgdGhpcy51cGxvYWRpbmdGaWxlcyA9IHRoaXMudXBsb2FkaW5nRmlsZXMuZmlsdGVyKGZpbGUgPT4gZmlsZS51cmwgIT09IGZpbGVFbnRyeS51cmwpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2022/utils/dom/common.mjs

@@ -0,0 +1,68 @@
+import { POINTER_BUTTON } from '../../constants';
+export const NS = 'http://www.w3.org/2000/svg';
+export function toPoint(x, y, container) {
+    const rect = container.getBoundingClientRect();
+    return [x - rect.x, y - rect.y];
+}
+export function createG() {
+    const newG = document.createElementNS(NS, 'g');
+    return newG;
+}
+export function createPath() {
+    const newG = document.createElementNS(NS, 'path');
+    return newG;
+}
+export function createRect(rectangle, options) {
+    const rect = document.createElementNS(NS, 'rect');
+    rect.setAttribute('x', `${rectangle.x}`);
+    rect.setAttribute('y', `${rectangle.y}`);
+    rect.setAttribute('width', `${rectangle.width}`);
+    rect.setAttribute('height', `${rectangle.height}`);
+    for (let key in options) {
+        const optionKey = key;
+        rect.setAttribute(key, `${options[optionKey]}`);
+    }
+    return rect;
+}
+export function createMask() {
+    return document.createElementNS(NS, 'mask');
+}
+export function createSVG() {
+    const svg = document.createElementNS(NS, 'svg');
+    return svg;
+}
+export function createText(x, y, fill, textContent) {
+    var text = document.createElementNS(NS, 'text');
+    text.setAttribute('x', `${x}`);
+    text.setAttribute('y', `${y}`);
+    text.setAttribute('fill', fill);
+    text.textContent = textContent;
+    return text;
+}
+/**
+ * Check if a DOM node is an element node.
+ */
+export const isDOMElement = (value) => {
+    return isDOMNode(value) && value.nodeType === 1;
+};
+/**
+ * Check if a value is a DOM node.
+ */
+export const isDOMNode = (value) => {
+    return value instanceof window.Node;
+};
+export const hasInputOrTextareaTarget = (target) => {
+    if (isDOMElement(target)) {
+        if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA') {
+            return true;
+        }
+    }
+    return false;
+};
+export const isSecondaryPointer = (event) => {
+    return event.button === POINTER_BUTTON.SECONDARY;
+};
+export const isMainPointer = (event) => {
+    return event.button === POINTER_BUTTON.MAIN;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/element.mjs

@@ -0,0 +1,53 @@
+import { depthFirstRecursion, getIsRecursionFunc } from './tree';
+export function getRectangleByElements(board, elements, recursion) {
+    const boundaryBox = {
+        left: Number.MAX_VALUE,
+        top: Number.MAX_VALUE,
+        right: Number.NEGATIVE_INFINITY,
+        bottom: Number.NEGATIVE_INFINITY
+    };
+    const calcRectangleClient = (node) => {
+        const nodeRectangle = board.getRectangle(node);
+        if (nodeRectangle) {
+            boundaryBox.left = Math.min(boundaryBox.left, nodeRectangle.x);
+            boundaryBox.top = Math.min(boundaryBox.top, nodeRectangle.y);
+            boundaryBox.right = Math.max(boundaryBox.right, nodeRectangle.x + nodeRectangle.width);
+            boundaryBox.bottom = Math.max(boundaryBox.bottom, nodeRectangle.y + nodeRectangle.height);
+        }
+    };
+    elements.forEach(element => {
+        if (recursion) {
+            depthFirstRecursion(element, node => calcRectangleClient(node), node => board.isRecursion(node));
+        }
+        else {
+            calcRectangleClient(element);
+        }
+    });
+    if (boundaryBox.left === Number.MAX_VALUE) {
+        return {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0
+        };
+    }
+    return {
+        x: boundaryBox.left,
+        y: boundaryBox.top,
+        width: boundaryBox.right - boundaryBox.left,
+        height: boundaryBox.bottom - boundaryBox.top
+    };
+}
+export function getBoardRectangle(board) {
+    return getRectangleByElements(board, board.children, true);
+}
+export function getElementById(board, id) {
+    let element = null;
+    depthFirstRecursion(board, node => {
+        if (id === node.id) {
+            element = node;
+        }
+    }, getIsRecursionFunc(board), true);
+    return element;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/math.mjs

@@ -0,0 +1,128 @@
+import { RectangleClient } from '../interfaces/rectangle-client';
+// https://stackoverflow.com/a/6853926/232122
+export function distanceBetweenPointAndSegment(x, y, x1, y1, x2, y2) {
+    const A = x - x1;
+    const B = y - y1;
+    const C = x2 - x1;
+    const D = y2 - y1;
+    const dot = A * C + B * D;
+    const lenSquare = C * C + D * D;
+    let param = -1;
+    if (lenSquare !== 0) {
+        // in case of 0 length line
+        param = dot / lenSquare;
+    }
+    let xx, yy;
+    if (param < 0) {
+        xx = x1;
+        yy = y1;
+    }
+    else if (param > 1) {
+        xx = x2;
+        yy = y2;
+    }
+    else {
+        xx = x1 + param * C;
+        yy = y1 + param * D;
+    }
+    const dx = x - xx;
+    const dy = y - yy;
+    return Math.hypot(dx, dy);
+}
+export function getNearestPointBetweenPointAndSegment(point, linePoints) {
+    const x = point[0], y = point[1], x1 = linePoints[0][0], y1 = linePoints[0][1], x2 = linePoints[1][0], y2 = linePoints[1][1];
+    const A = x - x1;
+    const B = y - y1;
+    const C = x2 - x1;
+    const D = y2 - y1;
+    const dot = A * C + B * D;
+    const lenSquare = C * C + D * D;
+    let param = -1;
+    if (lenSquare !== 0) {
+        // in case of 0 length line
+        param = dot / lenSquare;
+    }
+    let xx, yy;
+    if (param < 0) {
+        xx = x1;
+        yy = y1;
+    }
+    else if (param > 1) {
+        xx = x2;
+        yy = y2;
+    }
+    else {
+        xx = x1 + param * C;
+        yy = y1 + param * D;
+    }
+    return [xx, yy];
+}
+export function distanceBetweenPointAndSegments(points, point) {
+    const len = points.length;
+    let distance = Infinity;
+    for (let i = 0; i < len - 1; i++) {
+        const p = points[i];
+        const p2 = points[i + 1];
+        const currentDistance = distanceBetweenPointAndSegment(point[0], point[1], p[0], p[1], p2[0], p2[1]);
+        if (currentDistance < distance) {
+            distance = currentDistance;
+        }
+    }
+    return distance;
+}
+export function getNearestPointBetweenPointAndSegments(point, points) {
+    const len = points.length;
+    let distance = Infinity;
+    let result = point;
+    for (let i = 0; i < len; i++) {
+        const p = points[i];
+        const p2 = i === len - 1 ? points[0] : points[i + 1];
+        const currentDistance = distanceBetweenPointAndSegment(point[0], point[1], p[0], p[1], p2[0], p2[1]);
+        if (currentDistance < distance) {
+            distance = currentDistance;
+            result = getNearestPointBetweenPointAndSegment(point, [p, p2]);
+        }
+    }
+    return result;
+}
+export function rotate(x1, y1, x2, y2, angle) {
+    // 𝑎′𝑥=(𝑎𝑥−𝑐𝑥)cos𝜃−(𝑎𝑦−𝑐𝑦)sin𝜃+𝑐𝑥
+    // 𝑎′𝑦=(𝑎𝑥−𝑐𝑥)sin𝜃+(𝑎𝑦−𝑐𝑦)cos𝜃+𝑐𝑦.
+    // https://math.stackexchange.com/questions/2204520/how-do-i-rotate-a-line-segment-in-a-specific-point-on-the-line
+    return [(x1 - x2) * Math.cos(angle) - (y1 - y2) * Math.sin(angle) + x2, (x1 - x2) * Math.sin(angle) + (y1 - y2) * Math.cos(angle) + y2];
+}
+export function distanceBetweenPointAndPoint(x1, y1, x2, y2) {
+    const dx = x1 - x2;
+    const dy = y1 - y2;
+    return Math.hypot(dx, dy);
+}
+// https://stackoverflow.com/questions/5254838/calculating-distance-between-a-point-and-a-rectangular-box-nearest-point
+export function distanceBetweenPointAndRectangle(x, y, rect) {
+    var dx = Math.max(rect.x - x, 0, x - (rect.x + rect.width));
+    var dy = Math.max(rect.y - y, 0, y - (rect.y + rect.height));
+    return Math.sqrt(dx * dx + dy * dy);
+}
+export const isLineHitLine = (a, b, c, d) => {
+    const crossProduct = (v1, v2) => v1[0] * v2[1] - v1[1] * v2[0];
+    const ab = [b[0] - a[0], b[1] - a[1]];
+    const ac = [c[0] - a[0], c[1] - a[1]];
+    const ad = [d[0] - a[0], d[1] - a[1]];
+    const ca = [a[0] - c[0], a[1] - c[1]];
+    const cb = [b[0] - c[0], b[1] - c[1]];
+    const cd = [d[0] - c[0], d[1] - c[1]];
+    return crossProduct(ab, ac) * crossProduct(ab, ad) <= 0 && crossProduct(cd, ca) * crossProduct(cd, cb) <= 0;
+};
+export const isPolylineHitRectangle = (points, rectangle) => {
+    const rectanglePoints = RectangleClient.getCornerPoints(rectangle);
+    for (let i = 1; i < points.length; i++) {
+        const isIntersect = isLineHitLine(points[i], points[i - 1], rectanglePoints[0], rectanglePoints[1]) ||
+            isLineHitLine(points[i], points[i - 1], rectanglePoints[1], rectanglePoints[2]) ||
+            isLineHitLine(points[i], points[i - 1], rectanglePoints[2], rectanglePoints[3]) ||
+            isLineHitLine(points[i], points[i - 1], rectanglePoints[3], rectanglePoints[0]);
+        if (isIntersect) {
+            return true;
+        }
+    }
+    return false;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"math.js","sourceRoot":"","sources":["../../../../packages/core/src/utils/math.ts"],"names":[],"mappings":"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","sourcesContent":["import { Point } from '../interfaces';\nimport { RectangleClient } from '../interfaces/rectangle-client';\n\n// https://stackoverflow.com/a/6853926/232122\nexport function distanceBetweenPointAndSegment(x: number, y: number, x1: number, y1: number, x2: number, y2: number) {\n    const A = x - x1;\n    const B = y - y1;\n    const C = x2 - x1;\n    const D = y2 - y1;\n\n    const dot = A * C + B * D;\n    const lenSquare = C * C + D * D;\n    let param = -1;\n    if (lenSquare !== 0) {\n        // in case of 0 length line\n        param = dot / lenSquare;\n    }\n\n    let xx, yy;\n    if (param < 0) {\n        xx = x1;\n        yy = y1;\n    } else if (param > 1) {\n        xx = x2;\n        yy = y2;\n    } else {\n        xx = x1 + param * C;\n        yy = y1 + param * D;\n    }\n\n    const dx = x - xx;\n    const dy = y - yy;\n    return Math.hypot(dx, dy);\n}\n\nexport function getNearestPointBetweenPointAndSegment(point: Point, linePoints: [Point, Point]) {\n    const x = point[0],\n        y = point[1],\n        x1 = linePoints[0][0],\n        y1 = linePoints[0][1],\n        x2 = linePoints[1][0],\n        y2 = linePoints[1][1];\n    const A = x - x1;\n    const B = y - y1;\n    const C = x2 - x1;\n    const D = y2 - y1;\n\n    const dot = A * C + B * D;\n    const lenSquare = C * C + D * D;\n    let param = -1;\n    if (lenSquare !== 0) {\n        // in case of 0 length line\n        param = dot / lenSquare;\n    }\n\n    let xx, yy;\n    if (param < 0) {\n        xx = x1;\n        yy = y1;\n    } else if (param > 1) {\n        xx = x2;\n        yy = y2;\n    } else {\n        xx = x1 + param * C;\n        yy = y1 + param * D;\n    }\n\n    return [xx, yy] as Point;\n}\n\nexport function distanceBetweenPointAndSegments(points: Point[], point: Point) {\n    const len = points.length;\n    let distance = Infinity;\n    for (let i = 0; i < len - 1; i++) {\n        const p = points[i];\n        const p2 = points[i + 1];\n        const currentDistance = distanceBetweenPointAndSegment(point[0], point[1], p[0], p[1], p2[0], p2[1]);\n        if (currentDistance < distance) {\n            distance = currentDistance;\n        }\n    }\n    return distance;\n}\n\nexport function getNearestPointBetweenPointAndSegments(point: Point, points: Point[]) {\n    const len = points.length;\n    let distance = Infinity;\n    let result: Point = point;\n\n    for (let i = 0; i < len; i++) {\n        const p = points[i];\n        const p2 = i === len - 1 ? points[0] : points[i + 1];\n        const currentDistance = distanceBetweenPointAndSegment(point[0], point[1], p[0], p[1], p2[0], p2[1]);\n        if (currentDistance < distance) {\n            distance = currentDistance;\n            result = getNearestPointBetweenPointAndSegment(point, [p, p2]);\n        }\n    }\n    return result;\n}\n\nexport function rotate(x1: number, y1: number, x2: number, y2: number, angle: number) {\n    // 𝑎′𝑥=(𝑎𝑥−𝑐𝑥)cos𝜃−(𝑎𝑦−𝑐𝑦)sin𝜃+𝑐𝑥\n    // 𝑎′𝑦=(𝑎𝑥−𝑐𝑥)sin𝜃+(𝑎𝑦−𝑐𝑦)cos𝜃+𝑐𝑦.\n    // https://math.stackexchange.com/questions/2204520/how-do-i-rotate-a-line-segment-in-a-specific-point-on-the-line\n    return [(x1 - x2) * Math.cos(angle) - (y1 - y2) * Math.sin(angle) + x2, (x1 - x2) * Math.sin(angle) + (y1 - y2) * Math.cos(angle) + y2];\n}\n\nexport function distanceBetweenPointAndPoint(x1: number, y1: number, x2: number, y2: number) {\n    const dx = x1 - x2;\n    const dy = y1 - y2;\n    return Math.hypot(dx, dy);\n}\n\n// https://stackoverflow.com/questions/5254838/calculating-distance-between-a-point-and-a-rectangular-box-nearest-point\nexport function distanceBetweenPointAndRectangle(x: number, y: number, rect: RectangleClient) {\n    var dx = Math.max(rect.x - x, 0, x - (rect.x + rect.width));\n    var dy = Math.max(rect.y - y, 0, y - (rect.y + rect.height));\n    return Math.sqrt(dx * dx + dy * dy);\n}\n\nexport const isLineHitLine = (a: Point, b: Point, c: Point, d: Point): boolean => {\n    const crossProduct = (v1: Point, v2: Point) => v1[0] * v2[1] - v1[1] * v2[0];\n\n    const ab: Point = [b[0] - a[0], b[1] - a[1]];\n    const ac: Point = [c[0] - a[0], c[1] - a[1]];\n    const ad: Point = [d[0] - a[0], d[1] - a[1]];\n\n    const ca: Point = [a[0] - c[0], a[1] - c[1]];\n    const cb: Point = [b[0] - c[0], b[1] - c[1]];\n    const cd: Point = [d[0] - c[0], d[1] - c[1]];\n\n    return crossProduct(ab, ac) * crossProduct(ab, ad) <= 0 && crossProduct(cd, ca) * crossProduct(cd, cb) <= 0;\n};\n\nexport const isPolylineHitRectangle = (points: Point[], rectangle: RectangleClient) => {\n    const rectanglePoints = RectangleClient.getCornerPoints(rectangle);\n\n    for (let i = 1; i < points.length; i++) {\n        const isIntersect =\n            isLineHitLine(points[i], points[i - 1], rectanglePoints[0], rectanglePoints[1]) ||\n            isLineHitLine(points[i], points[i - 1], rectanglePoints[1], rectanglePoints[2]) ||\n            isLineHitLine(points[i], points[i - 1], rectanglePoints[2], rectanglePoints[3]) ||\n            isLineHitLine(points[i], points[i - 1], rectanglePoints[3], rectanglePoints[0]);\n        if (isIntersect) {\n            return true;\n        }\n    }\n\n    return false;\n};\n"]}