@plait/draw 0.1.0-next.10

package/esm2020/line.component.mjs

@@ -0,0 +1,152 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { PlaitBoard, PlaitPluginElementComponent, getElementById } from '@plait/core';
+import { Subject } from 'rxjs';
+import { TextManage } from '@plait/text';
+import { LineShapeGenerator } from './generators/line.generator';
+import { LineActiveGenerator } from './generators/line-active.generator';
+import { getLineTextRectangle } from './utils';
+import { DrawTransforms } from './transforms';
+import { GeometryThreshold } from './constants';
+import * as i0 from "@angular/core";
+export class LineComponent extends PlaitPluginElementComponent {
+    constructor(viewContainerRef, cdr) {
+        super(cdr);
+        this.viewContainerRef = viewContainerRef;
+        this.cdr = cdr;
+        this.destroy$ = new Subject();
+        this.textManages = [];
+        this.boundedElements = {};
+    }
+    initializeGenerator() {
+        this.shapeGenerator = new LineShapeGenerator(this.board);
+        this.activeGenerator = new LineActiveGenerator(this.board);
+        this.initializeTextManages();
+    }
+    ngOnInit() {
+        this.initializeGenerator();
+        this.shapeGenerator.draw(this.element, this.g);
+        this.activeGenerator.draw(this.element, PlaitBoard.getElementActiveHost(this.board), { selected: this.selected });
+        super.ngOnInit();
+        this.boundedElements = this.getBoundedElements();
+        this.drawText();
+    }
+    getBoundedElements() {
+        const boundedElements = {};
+        if (this.element.source.boundId) {
+            const boundElement = getElementById(this.board, this.element.source.boundId);
+            if (boundElement) {
+                boundedElements.source = boundElement;
+            }
+        }
+        if (this.element.target.boundId) {
+            const boundElement = getElementById(this.board, this.element.target.boundId);
+            if (boundElement) {
+                boundedElements.target = boundElement;
+            }
+        }
+        return boundedElements;
+    }
+    onContextChanged(value, previous) {
+        const boundedElements = this.getBoundedElements();
+        const isBoundedElementsChanged = boundedElements.source !== this.boundedElements.source || boundedElements.target !== this.boundedElements.target;
+        this.boundedElements = boundedElements;
+        if (value.element !== previous.element) {
+            this.shapeGenerator.draw(this.element, this.g);
+            this.activeGenerator.draw(this.element, PlaitBoard.getElementActiveHost(this.board), { selected: this.selected });
+            this.updateText(previous.element.texts, value.element.texts);
+            this.updateTextRectangle();
+        }
+        if (isBoundedElementsChanged) {
+            this.shapeGenerator.draw(this.element, this.g);
+            this.activeGenerator.draw(this.element, PlaitBoard.getElementActiveHost(this.board), { selected: this.selected });
+            this.updateTextRectangle();
+            return;
+        }
+        const hasSameSelected = value.selected === previous.selected;
+        if (!hasSameSelected) {
+            this.activeGenerator.draw(this.element, PlaitBoard.getElementActiveHost(this.board), { selected: this.selected });
+        }
+    }
+    initializeTextManages() {
+        if (this.element.texts?.length) {
+            this.element.texts.forEach((text, index) => {
+                const manage = this.createTextManage(text, index);
+                this.textManages.push(manage);
+            });
+        }
+    }
+    destroyTextManages() {
+        this.textManages.forEach(manage => {
+            manage.destroy();
+        });
+    }
+    drawText() {
+        if (this.element.texts?.length) {
+            this.textManages.forEach((manage, index) => {
+                manage.draw(this.element.texts[index].text);
+                this.g.append(manage.g);
+            });
+        }
+    }
+    createTextManage(text, index) {
+        return new TextManage(this.board, this.viewContainerRef, {
+            getRectangle: () => {
+                return getLineTextRectangle(this.board, this.element, index);
+            },
+            onValueChangeHandle: (textManageRef) => {
+                const height = textManageRef.height / this.board.viewport.zoom;
+                const width = textManageRef.width / this.board.viewport.zoom;
+                const texts = [...this.element.texts];
+                texts.splice(index, 1, {
+                    text: textManageRef.newValue ? textManageRef.newValue : this.element.texts[index].text,
+                    position: this.element.texts[index].position,
+                    width,
+                    height
+                });
+                DrawTransforms.setLineTexts(this.board, this.element, texts);
+            },
+            getMaxWidth: () => GeometryThreshold.defaultTextMaxWidth
+        });
+    }
+    updateText(previousTexts, currentTexts) {
+        if (previousTexts === currentTexts)
+            return;
+        const previousTextsLength = previousTexts.length;
+        const currentTextsLength = currentTexts.length;
+        if (currentTextsLength === previousTextsLength) {
+            for (let i = 0; i < previousTextsLength; i++) {
+                if (previousTexts[i].text !== currentTexts[i].text) {
+                    this.textManages[i].updateText(currentTexts[i].text);
+                }
+            }
+        }
+        else {
+            this.destroyTextManages();
+            this.textManages = [];
+            this.initializeTextManages();
+            this.drawText();
+        }
+    }
+    updateTextRectangle() {
+        this.textManages.forEach(manage => {
+            manage.updateRectangle();
+        });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.activeGenerator.destroy();
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+LineComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: LineComponent, deps: [{ token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+LineComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.2", type: LineComponent, selector: "plait-draw-line", usesInheritance: true, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: LineComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'plait-draw-line',
+                    template: ``,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.ChangeDetectorRef }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"line.component.js","sourceRoot":"","sources":["../../../packages/draw/src/line.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, OnDestroy, OnInit, ViewContainerRef } from '@angular/core';\nimport { PlaitBoard, PlaitPluginElementComponent, PlaitPluginElementContext, OnContextChanged, getElementById } from '@plait/core';\nimport { Subject } from 'rxjs';\nimport { LineText, PlaitGeometry, PlaitLine } from './interfaces';\nimport { TextManage, TextManageRef, buildText } from '@plait/text';\nimport { LineShapeGenerator } from './generators/line.generator';\nimport { LineActiveGenerator } from './generators/line-active.generator';\nimport { getLineTextRectangle } from './utils';\nimport { DrawTransforms } from './transforms';\nimport { GeometryThreshold } from './constants';\n\ninterface BoundedElements {\n    source?: PlaitGeometry;\n    target?: PlaitGeometry;\n}\n\n@Component({\n    selector: 'plait-draw-line',\n    template: ``,\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class LineComponent extends PlaitPluginElementComponent<PlaitLine, PlaitBoard>\n    implements OnInit, OnDestroy, OnContextChanged<PlaitLine, PlaitBoard> {\n    destroy$ = new Subject<void>();\n\n    shapeGenerator!: LineShapeGenerator;\n\n    activeGenerator!: LineActiveGenerator;\n\n    textManages: TextManage[] = [];\n\n    boundedElements: BoundedElements = {};\n\n    constructor(private viewContainerRef: ViewContainerRef, protected cdr: ChangeDetectorRef) {\n        super(cdr);\n    }\n\n    initializeGenerator() {\n        this.shapeGenerator = new LineShapeGenerator(this.board);\n        this.activeGenerator = new LineActiveGenerator(this.board);\n        this.initializeTextManages();\n    }\n\n    ngOnInit(): void {\n        this.initializeGenerator();\n        this.shapeGenerator.draw(this.element, this.g);\n        this.activeGenerator.draw(this.element, PlaitBoard.getElementActiveHost(this.board), { selected: this.selected });\n        super.ngOnInit();\n        this.boundedElements = this.getBoundedElements();\n        this.drawText();\n    }\n\n    getBoundedElements() {\n        const boundedElements: BoundedElements = {};\n        if (this.element.source.boundId) {\n            const boundElement = getElementById<PlaitGeometry>(this.board, this.element.source.boundId);\n            if (boundElement) {\n                boundedElements.source = boundElement;\n            }\n        }\n        if (this.element.target.boundId) {\n            const boundElement = getElementById<PlaitGeometry>(this.board, this.element.target.boundId);\n            if (boundElement) {\n                boundedElements.target = boundElement;\n            }\n        }\n        return boundedElements;\n    }\n\n    onContextChanged(value: PlaitPluginElementContext<PlaitLine, PlaitBoard>, previous: PlaitPluginElementContext<PlaitLine, PlaitBoard>) {\n        const boundedElements = this.getBoundedElements();\n        const isBoundedElementsChanged =\n            boundedElements.source !== this.boundedElements.source || boundedElements.target !== this.boundedElements.target;\n        this.boundedElements = boundedElements;\n\n        if (value.element !== previous.element) {\n            this.shapeGenerator.draw(this.element, this.g);\n            this.activeGenerator.draw(this.element, PlaitBoard.getElementActiveHost(this.board), { selected: this.selected });\n            this.updateText(previous.element.texts, value.element.texts);\n            this.updateTextRectangle();\n        }\n\n        if (isBoundedElementsChanged) {\n            this.shapeGenerator.draw(this.element, this.g);\n            this.activeGenerator.draw(this.element, PlaitBoard.getElementActiveHost(this.board), { selected: this.selected });\n            this.updateTextRectangle();\n            return;\n        }\n\n        const hasSameSelected = value.selected === previous.selected;\n        if (!hasSameSelected) {\n            this.activeGenerator.draw(this.element, PlaitBoard.getElementActiveHost(this.board), { selected: this.selected });\n        }\n    }\n\n    initializeTextManages() {\n        if (this.element.texts?.length) {\n            this.element.texts.forEach((text, index) => {\n                const manage = this.createTextManage(text, index);\n                this.textManages.push(manage);\n            });\n        }\n    }\n\n    destroyTextManages() {\n        this.textManages.forEach(manage => {\n            manage.destroy();\n        });\n    }\n\n    drawText() {\n        if (this.element.texts?.length) {\n            this.textManages.forEach((manage, index) => {\n                manage.draw(this.element.texts![index].text);\n                this.g.append(manage.g);\n            });\n        }\n    }\n\n    createTextManage(text: LineText, index: number) {\n        return new TextManage(this.board, this.viewContainerRef, {\n            getRectangle: () => {\n                return getLineTextRectangle(this.board, this.element, index);\n            },\n            onValueChangeHandle: (textManageRef: TextManageRef) => {\n                const height = textManageRef.height / this.board.viewport.zoom;\n                const width = textManageRef.width / this.board.viewport.zoom;\n                const texts = [...this.element.texts];\n                texts.splice(index, 1, {\n                    text: textManageRef.newValue ? textManageRef.newValue : this.element.texts[index].text,\n                    position: this.element.texts[index].position,\n                    width,\n                    height\n                });\n                DrawTransforms.setLineTexts(this.board, this.element, texts);\n            },\n            getMaxWidth: () => GeometryThreshold.defaultTextMaxWidth\n        });\n    }\n\n    updateText(previousTexts: LineText[], currentTexts: LineText[]) {\n        if (previousTexts === currentTexts) return;\n        const previousTextsLength = previousTexts.length;\n        const currentTextsLength = currentTexts.length;\n        if (currentTextsLength === previousTextsLength) {\n            for (let i = 0; i < previousTextsLength; i++) {\n                if (previousTexts[i].text !== currentTexts[i].text) {\n                    this.textManages[i].updateText(currentTexts[i].text);\n                }\n            }\n        } else {\n            this.destroyTextManages();\n            this.textManages = [];\n            this.initializeTextManages();\n            this.drawText();\n        }\n    }\n\n    updateTextRectangle() {\n        this.textManages.forEach(manage => {\n            manage.updateRectangle();\n        });\n    }\n\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this.activeGenerator.destroy();\n        this.destroy$.next();\n        this.destroy$.complete();\n    }\n}\n"]}

package/esm2020/plait-draw.mjs

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

package/esm2020/plugins/with-draw-fragment.mjs

@@ -0,0 +1,52 @@
+import { getDataFromClipboard, getSelectedElements, setClipboardData } from '@plait/core';
+import { getSelectedDrawElements } from '../utils/selected';
+import { PlaitDrawElement, PlaitLine } from '../interfaces';
+import { getTextFromClipboard, getTextSize } from '@plait/text';
+import { buildClipboardData, insertClipboardData } from '../utils/clipboard';
+import { DrawTransforms } from '../transforms';
+import { getBoardLines } from '../utils/line';
+export const withDrawFragment = (baseBoard) => {
+    const board = baseBoard;
+    const { getDeletedFragment, setFragment, insertFragment } = board;
+    board.getDeletedFragment = (data) => {
+        const drawElements = getSelectedDrawElements(board);
+        if (drawElements.length) {
+            const lines = getBoardLines(board);
+            const geometryElements = drawElements.filter(value => PlaitDrawElement.isGeometry(value));
+            const lineElements = drawElements.filter(value => PlaitDrawElement.isLine(value));
+            const boundLineElements = lines.filter(line => geometryElements.find(geometry => PlaitLine.isBoundElementOfSource(line, geometry) || PlaitLine.isBoundElementOfTarget(line, geometry)));
+            data.push(...[...geometryElements, ...lineElements, ...boundLineElements.filter(line => !lineElements.includes(line))]);
+        }
+        return getDeletedFragment(data);
+    };
+    board.setFragment = (data, rectangle) => {
+        const targetDrawElements = getSelectedDrawElements(board);
+        if (targetDrawElements.length) {
+            const elements = buildClipboardData(board, targetDrawElements, rectangle ? [rectangle.x, rectangle.y] : [0, 0]);
+            setClipboardData(data, elements);
+        }
+        setFragment(data, rectangle);
+    };
+    board.insertFragment = (data, targetPoint) => {
+        const elements = getDataFromClipboard(data);
+        const drawElements = elements.filter(value => PlaitDrawElement.isDrawElement(value));
+        if (elements.length > 0 && drawElements.length > 0) {
+            insertClipboardData(board, drawElements, targetPoint);
+        }
+        else if (elements.length === 0) {
+            const text = getTextFromClipboard(data);
+            const selectedElements = getSelectedElements(board);
+            // (*￣︶￣)
+            const insertAsChildren = selectedElements.length === 1 && selectedElements[0].children;
+            const insertAsFreeText = !insertAsChildren;
+            if (text && insertAsFreeText) {
+                const { width, height } = getTextSize(board, text);
+                DrawTransforms.insertText(board, [targetPoint, [targetPoint[0] + width, targetPoint[1] + height]], text);
+                return;
+            }
+        }
+        insertFragment(data, targetPoint);
+    };
+    return board;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-draw-fragment.js","sourceRoot":"","sources":["../../../../packages/draw/src/plugins/with-draw-fragment.ts"],"names":[],"mappings":"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","sourcesContent":["import { PlaitBoard, PlaitElement, Point, RectangleClient, getDataFromClipboard, getSelectedElements, setClipboardData } from '@plait/core';\nimport { getSelectedDrawElements } from '../utils/selected';\nimport { PlaitDrawElement, PlaitGeometry, PlaitLine } from '../interfaces';\nimport { getTextFromClipboard, getTextSize } from '@plait/text';\nimport { buildClipboardData, insertClipboardData } from '../utils/clipboard';\nimport { DrawTransforms } from '../transforms';\nimport { getBoardLines } from '../utils/line';\n\nexport const withDrawFragment = (baseBoard: PlaitBoard) => {\n    const board = baseBoard as PlaitBoard;\n    const { getDeletedFragment, setFragment, insertFragment } = board;\n\n    board.getDeletedFragment = (data: PlaitElement[]) => {\n        const drawElements = getSelectedDrawElements(board);\n        if (drawElements.length) {\n            const lines = getBoardLines(board);\n            const geometryElements = drawElements.filter(value => PlaitDrawElement.isGeometry(value)) as PlaitGeometry[];\n            const lineElements = drawElements.filter(value => PlaitDrawElement.isLine(value)) as PlaitLine[];\n            const boundLineElements = lines.filter(line =>\n                geometryElements.find(\n                    geometry => PlaitLine.isBoundElementOfSource(line, geometry) || PlaitLine.isBoundElementOfTarget(line, geometry)\n                )\n            );\n            data.push(...[...geometryElements, ...lineElements, ...boundLineElements.filter(line => !lineElements.includes(line))]);\n        }\n        return getDeletedFragment(data);\n    };\n\n    board.setFragment = (data: DataTransfer | null, rectangle: RectangleClient | null) => {\n        const targetDrawElements = getSelectedDrawElements(board);\n        if (targetDrawElements.length) {\n            const elements = buildClipboardData(board, targetDrawElements, rectangle ? [rectangle.x, rectangle.y] : [0, 0]);\n            setClipboardData(data, elements);\n        }\n        setFragment(data, rectangle);\n    };\n\n    board.insertFragment = (data: DataTransfer | null, targetPoint: Point) => {\n        const elements = getDataFromClipboard(data);\n        const drawElements = elements.filter(value => PlaitDrawElement.isDrawElement(value)) as PlaitDrawElement[];\n        if (elements.length > 0 && drawElements.length > 0) {\n            insertClipboardData(board, drawElements, targetPoint);\n        } else if (elements.length === 0) {\n            const text = getTextFromClipboard(data);\n            const selectedElements = getSelectedElements(board);\n            // (*￣︶￣)\n            const insertAsChildren = selectedElements.length === 1 && selectedElements[0].children;\n            const insertAsFreeText = !insertAsChildren;\n            if (text && insertAsFreeText) {\n                const { width, height } = getTextSize(board, text);\n                DrawTransforms.insertText(board, [targetPoint, [targetPoint[0] + width, targetPoint[1] + height]], text);\n                return;\n            }\n        }\n        insertFragment(data, targetPoint);\n    };\n\n    return board;\n};\n"]}

package/esm2020/plugins/with-draw-hotkey.mjs

@@ -0,0 +1,33 @@
+import { PlaitElement, getSelectedElements } from '@plait/core';
+import { isVirtualKey, isSpaceHotkey, isDelete } from '@plait/common';
+import { PlaitDrawElement } from '../interfaces';
+import { getSelectedGeometryElements } from '../utils';
+export const withDrawHotkey = (board) => {
+    const { keydown, dblclick } = board;
+    board.keydown = (event) => {
+        const selectedElements = getSelectedElements(board);
+        const isSingleSelection = selectedElements.length === 1;
+        const targetElement = selectedElements[0];
+        if (!isVirtualKey(event) &&
+            !isDelete(event) &&
+            !isSpaceHotkey(event) &&
+            isSingleSelection &&
+            PlaitDrawElement.isGeometry(targetElement)) {
+            event.preventDefault();
+            PlaitElement.getComponent(targetElement).editText();
+            return;
+        }
+        keydown(event);
+    };
+    board.dblclick = (event) => {
+        event.preventDefault();
+        const geometries = getSelectedGeometryElements(board);
+        if (geometries.length === 1) {
+            const component = PlaitElement.getComponent(geometries[0]);
+            component.editText();
+        }
+        dblclick(event);
+    };
+    return board;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/plugins/with-draw.mjs

@@ -0,0 +1,73 @@
+import { RectangleClient, isPolylineHitRectangle } from '@plait/core';
+import { GeometryComponent } from '../geometry.component';
+import { LineComponent } from '../line.component';
+import { PlaitDrawElement } from '../interfaces';
+import { getRectangleByPoints } from '@plait/common';
+import { withDrawHotkey } from './with-draw-hotkey';
+import { withGeometryCreateByDraw, withGeometryCreateByDrag } from './with-geometry-create';
+import { withDrawFragment } from './with-draw-fragment';
+import { getTextRectangle, isHitPolyLine, isHitLineText, getTargetPoint, getSourcePoint, getLinePoints } from '../utils';
+import { getStrokeWidthByElement } from '../utils/style/stroke';
+import { withLineCreateByDraw } from './with-line-create';
+import { withGeometryResize } from './with-geometry-resize';
+import { withLineResize } from './with-line-resize';
+import { withLineBoundReaction } from './with-line-bound-reaction';
+import { withLineText } from './with-line-text';
+export const withDraw = (board) => {
+    const { drawElement, getRectangle, isHitSelection, isMovable, dblclick } = board;
+    board.drawElement = (context) => {
+        if (PlaitDrawElement.isGeometry(context.element)) {
+            return GeometryComponent;
+        }
+        else if (PlaitDrawElement.isLine(context.element)) {
+            return LineComponent;
+        }
+        return drawElement(context);
+    };
+    board.getRectangle = (element) => {
+        if (PlaitDrawElement.isGeometry(element)) {
+            return getRectangleByPoints(element.points);
+        }
+        if (PlaitDrawElement.isLine(element)) {
+            const source = getSourcePoint(board, element);
+            const target = getTargetPoint(board, element);
+            return getRectangleByPoints([source, target]);
+        }
+        return getRectangle(element);
+    };
+    board.isHitSelection = (element, range) => {
+        if (PlaitDrawElement.isGeometry(element)) {
+            const client = getRectangleByPoints(element.points);
+            const rangeRectangle = RectangleClient.toRectangleClient([range.anchor, range.focus]);
+            if (element.textHeight > client.height) {
+                const textClient = getTextRectangle(element);
+                return RectangleClient.isHit(rangeRectangle, client) || RectangleClient.isHit(rangeRectangle, textClient);
+            }
+            return RectangleClient.isHit(rangeRectangle, client);
+        }
+        if (PlaitDrawElement.isLine(element)) {
+            const points = getLinePoints(board, element);
+            const strokeWidth = getStrokeWidthByElement(element);
+            const isHitText = isHitLineText(board, element, range.focus);
+            const isHit = isHitPolyLine(points, range.focus, strokeWidth, 3) || isHitText;
+            const rangeRectangle = RectangleClient.toRectangleClient([range.anchor, range.focus]);
+            const isContainPolyLinePoint = points.some(point => {
+                return RectangleClient.isHit(rangeRectangle, RectangleClient.toRectangleClient([point, point]));
+            });
+            const isIntersect = range.anchor === range.focus ? isHit : isPolylineHitRectangle(points, rangeRectangle);
+            return isContainPolyLinePoint || isIntersect;
+        }
+        return isHitSelection(element, range);
+    };
+    board.isMovable = (element) => {
+        if (PlaitDrawElement.isGeometry(element)) {
+            return true;
+        }
+        if (PlaitDrawElement.isLine(element)) {
+            return !element.source.boundId && !element.target.boundId;
+        }
+        return isMovable(element);
+    };
+    return withLineText(withLineBoundReaction(withLineResize(withGeometryResize(withLineCreateByDraw(withGeometryCreateByDrag(withGeometryCreateByDraw(withDrawFragment(withDrawHotkey(board)))))))));
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-draw.js","sourceRoot":"","sources":["../../../../packages/draw/src/plugins/with-draw.ts"],"names":[],"mappings":"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","sourcesContent":["import { PlaitBoard, PlaitElement, PlaitPluginElementContext, Range, RectangleClient, isPolylineHitRectangle } from '@plait/core';\nimport { GeometryComponent } from '../geometry.component';\nimport { LineComponent } from '../line.component';\nimport { PlaitDrawElement } from '../interfaces';\nimport { getRectangleByPoints } from '@plait/common';\nimport { withDrawHotkey } from './with-draw-hotkey';\nimport { withGeometryCreateByDraw, withGeometryCreateByDrag } from './with-geometry-create';\nimport { withDrawFragment } from './with-draw-fragment';\nimport { getTextRectangle, isHitPolyLine, isHitLineText, getTargetPoint, getSourcePoint, getLinePoints } from '../utils';\nimport { getStrokeWidthByElement } from '../utils/style/stroke';\nimport { withLineCreateByDraw } from './with-line-create';\nimport { withGeometryResize } from './with-geometry-resize';\nimport { withLineResize } from './with-line-resize';\nimport { withLineBoundReaction } from './with-line-bound-reaction';\nimport { withLineText } from './with-line-text';\n\nexport const withDraw = (board: PlaitBoard) => {\n    const { drawElement, getRectangle, isHitSelection, isMovable, dblclick } = board;\n\n    board.drawElement = (context: PlaitPluginElementContext) => {\n        if (PlaitDrawElement.isGeometry(context.element)) {\n            return GeometryComponent;\n        } else if (PlaitDrawElement.isLine(context.element)) {\n            return LineComponent;\n        }\n        return drawElement(context);\n    };\n\n    board.getRectangle = (element: PlaitElement) => {\n        if (PlaitDrawElement.isGeometry(element)) {\n            return getRectangleByPoints(element.points);\n        }\n        if (PlaitDrawElement.isLine(element)) {\n            const source = getSourcePoint(board, element);\n            const target = getTargetPoint(board, element);\n            return getRectangleByPoints([source, target]);\n        }\n        return getRectangle(element);\n    };\n\n    board.isHitSelection = (element: PlaitElement, range: Range) => {\n        if (PlaitDrawElement.isGeometry(element)) {\n            const client = getRectangleByPoints(element.points);\n            const rangeRectangle = RectangleClient.toRectangleClient([range.anchor, range.focus]);\n            if (element.textHeight > client.height) {\n                const textClient = getTextRectangle(element);\n                return RectangleClient.isHit(rangeRectangle, client) || RectangleClient.isHit(rangeRectangle, textClient);\n            }\n            return RectangleClient.isHit(rangeRectangle, client);\n        }\n        if (PlaitDrawElement.isLine(element)) {\n            const points = getLinePoints(board, element);\n            const strokeWidth = getStrokeWidthByElement(element);\n            const isHitText = isHitLineText(board, element, range.focus);\n            const isHit = isHitPolyLine(points, range.focus, strokeWidth, 3) || isHitText;\n            const rangeRectangle = RectangleClient.toRectangleClient([range.anchor, range.focus]);\n            const isContainPolyLinePoint = points.some(point => {\n                return RectangleClient.isHit(rangeRectangle, RectangleClient.toRectangleClient([point, point]));\n            });\n            const isIntersect = range.anchor === range.focus ? isHit : isPolylineHitRectangle(points, rangeRectangle);\n            return isContainPolyLinePoint || isIntersect;\n        }\n\n        return isHitSelection(element, range);\n    };\n\n    board.isMovable = (element: PlaitElement) => {\n        if (PlaitDrawElement.isGeometry(element)) {\n            return true;\n        }\n        if (PlaitDrawElement.isLine(element)) {\n            return !element.source.boundId && !element.target.boundId;\n        }\n        return isMovable(element);\n    };\n\n    return withLineText(\n        withLineBoundReaction(\n            withLineResize(\n                withGeometryResize(\n                    withLineCreateByDraw(withGeometryCreateByDrag(withGeometryCreateByDraw(withDrawFragment(withDrawHotkey(board)))))\n                )\n            )\n        )\n    );\n};\n"]}

package/esm2020/plugins/with-geometry-create.mjs

@@ -0,0 +1,160 @@
+import { BoardTransforms, PlaitBoard, PlaitPointerType, RectangleClient, Transforms, addSelectedElement, clearSelectedElement, createForeignObject, createG, preventTouchMove, toPoint, transformPoint } from '@plait/core';
+import { GeometryShape } from '../interfaces';
+import { GeometryShapeGenerator } from '../generators/geometry-shape.generator';
+import { createGeometryElement, getPointsByCenterPoint } from '../utils';
+import { DefaultGeometryProperty, DefaultTextProperty, DrawPointerType, GeometryPointer, ShapeDefaultSpace } from '../constants';
+import { normalizeShapePoints, isDndMode, isDrawingMode } from '@plait/common';
+import { DrawTransforms } from '../transforms';
+import { DEFAULT_FONT_SIZE } from '@plait/text';
+import { isKeyHotkey } from 'is-hotkey';
+export const withGeometryCreateByDrag = (board) => {
+    const { pointerMove, pointerUp } = board;
+    let geometryShapeG = null;
+    board.pointerMove = (event) => {
+        geometryShapeG?.remove();
+        geometryShapeG = createG();
+        const geometryGenerator = new GeometryShapeGenerator(board);
+        const isGeometryPointer = PlaitBoard.isInPointer(board, GeometryPointer);
+        const dragMode = isGeometryPointer && isDndMode(board);
+        const movingPoint = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));
+        const pointer = PlaitBoard.getPointer(board);
+        if (dragMode) {
+            const points = getDefaultGeometryPoints(pointer, movingPoint);
+            if (pointer === DrawPointerType.text) {
+                const textG = getTemporaryTextG(movingPoint);
+                geometryShapeG.appendChild(textG);
+                PlaitBoard.getElementActiveHost(board).append(geometryShapeG);
+            }
+            else {
+                const temporaryElement = createGeometryElement(pointer, points, '', {
+                    strokeColor: DefaultGeometryProperty.strokeColor,
+                    strokeWidth: DefaultGeometryProperty.strokeWidth
+                });
+                geometryGenerator.draw(temporaryElement, geometryShapeG);
+                PlaitBoard.getElementActiveHost(board).append(geometryShapeG);
+            }
+        }
+        pointerMove(event);
+    };
+    board.pointerUp = (event) => {
+        const pointer = PlaitBoard.getPointer(board);
+        const isGeometryPointer = PlaitBoard.isInPointer(board, GeometryPointer);
+        const dragMode = isGeometryPointer && isDndMode(board);
+        if (dragMode) {
+            const targetPoint = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));
+            const points = getDefaultGeometryPoints(pointer, targetPoint);
+            if (pointer === DrawPointerType.text) {
+                DrawTransforms.insertText(board, points);
+            }
+            else {
+                DrawTransforms.insertGeometry(board, points, pointer);
+            }
+            BoardTransforms.updatePointerType(board, PlaitPointerType.selection);
+        }
+        geometryShapeG?.remove();
+        geometryShapeG = null;
+        preventTouchMove(board, event, false);
+        pointerUp(event);
+    };
+    return board;
+};
+export const withGeometryCreateByDraw = (board) => {
+    const { pointerDown, pointerMove, pointerUp, keydown, keyup } = board;
+    let start = null;
+    let geometryShapeG = null;
+    let temporaryElement = null;
+    let isShift = false;
+    board.keydown = (event) => {
+        isShift = isKeyHotkey('shift', event);
+        keydown(event);
+    };
+    board.keyup = (event) => {
+        isShift = false;
+        keyup(event);
+    };
+    board.pointerDown = (event) => {
+        const isGeometryPointer = PlaitBoard.isInPointer(board, GeometryPointer);
+        if (isGeometryPointer && isDrawingMode(board)) {
+            const point = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));
+            start = point;
+            const pointer = PlaitBoard.getPointer(board);
+            preventTouchMove(board, event, true);
+            if (pointer === DrawPointerType.text) {
+                const points = getDefaultGeometryPoints(pointer, point);
+                const textElement = createGeometryElement(GeometryShape.text, points, DefaultTextProperty.text);
+                Transforms.insertNode(board, textElement, [board.children.length]);
+                clearSelectedElement(board);
+                addSelectedElement(board, textElement);
+                BoardTransforms.updatePointerType(board, PlaitPointerType.selection);
+                start = null;
+            }
+        }
+        pointerDown(event);
+    };
+    board.pointerMove = (event) => {
+        geometryShapeG?.remove();
+        geometryShapeG = createG();
+        const geometryGenerator = new GeometryShapeGenerator(board);
+        const drawMode = !!start;
+        const movingPoint = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));
+        const pointer = PlaitBoard.getPointer(board);
+        if (drawMode && pointer !== DrawPointerType.text) {
+            const points = normalizeShapePoints([start, movingPoint], isShift);
+            temporaryElement = createGeometryElement(pointer, points, '', {
+                strokeColor: DefaultGeometryProperty.strokeColor,
+                strokeWidth: DefaultGeometryProperty.strokeWidth
+            });
+            geometryGenerator.draw(temporaryElement, geometryShapeG);
+            PlaitBoard.getElementActiveHost(board).append(geometryShapeG);
+        }
+        pointerMove(event);
+    };
+    board.pointerUp = (event) => {
+        const isDrawMode = !!start;
+        if (isDrawMode) {
+            const targetPoint = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));
+            const { width, height } = RectangleClient.toRectangleClient([start, targetPoint]);
+            if (Math.hypot(width, height) === 0) {
+                const pointer = PlaitBoard.getPointer(board);
+                const points = getDefaultGeometryPoints(pointer, targetPoint);
+                if (pointer !== DrawPointerType.text) {
+                    temporaryElement = createGeometryElement(pointer, points, '', {
+                        strokeColor: DefaultGeometryProperty.strokeColor,
+                        strokeWidth: DefaultGeometryProperty.strokeWidth
+                    });
+                }
+            }
+        }
+        if (temporaryElement) {
+            Transforms.insertNode(board, temporaryElement, [board.children.length]);
+            clearSelectedElement(board);
+            addSelectedElement(board, temporaryElement);
+            BoardTransforms.updatePointerType(board, PlaitPointerType.selection);
+        }
+        geometryShapeG?.remove();
+        geometryShapeG = null;
+        start = null;
+        temporaryElement = null;
+        preventTouchMove(board, event, false);
+        pointerUp(event);
+    };
+    return board;
+};
+const getDefaultGeometryPoints = (pointer, targetPoint) => {
+    return pointer === DrawPointerType.text
+        ? getPointsByCenterPoint(targetPoint, DefaultTextProperty.width, DefaultTextProperty.height)
+        : getPointsByCenterPoint(targetPoint, DefaultGeometryProperty.width, DefaultGeometryProperty.height);
+};
+const getTemporaryTextG = (movingPoint) => {
+    const textG = createG();
+    const width = DefaultTextProperty.width - ShapeDefaultSpace.rectangleAndText * 2;
+    const foreignObject = createForeignObject(movingPoint[0] - width / 2, movingPoint[1] - DefaultTextProperty.height / 2, width, DefaultTextProperty.height);
+    const richtext = document.createElement('div');
+    richtext.textContent = DefaultTextProperty.text;
+    richtext.style.fontSize = `${DEFAULT_FONT_SIZE}px`;
+    richtext.style.cursor = 'default';
+    foreignObject.appendChild(richtext);
+    textG.appendChild(foreignObject);
+    return textG;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-geometry-create.js","sourceRoot":"","sources":["../../../../packages/draw/src/plugins/with-geometry-create.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    BoardTransforms,\n    PlaitBoard,\n    PlaitPointerType,\n    Point,\n    RectangleClient,\n    Transforms,\n    addSelectedElement,\n    clearSelectedElement,\n    createForeignObject,\n    createG,\n    preventTouchMove,\n    toPoint,\n    transformPoint\n} from '@plait/core';\nimport { GeometryShape, PlaitGeometry } from '../interfaces';\nimport { GeometryShapeGenerator } from '../generators/geometry-shape.generator';\nimport { createGeometryElement, getPointsByCenterPoint } from '../utils';\nimport { DefaultGeometryProperty, DefaultTextProperty, DrawPointerType, GeometryPointer, ShapeDefaultSpace } from '../constants';\nimport { normalizeShapePoints, isDndMode, isDrawingMode } from '@plait/common';\nimport { DrawTransforms } from '../transforms';\nimport { DEFAULT_FONT_SIZE } from '@plait/text';\nimport { isKeyHotkey } from 'is-hotkey';\n\nexport const withGeometryCreateByDrag = (board: PlaitBoard) => {\n    const { pointerMove, pointerUp } = board;\n\n    let geometryShapeG: SVGGElement | null = null;\n\n    board.pointerMove = (event: PointerEvent) => {\n        geometryShapeG?.remove();\n        geometryShapeG = createG();\n\n        const geometryGenerator = new GeometryShapeGenerator(board);\n        const isGeometryPointer = PlaitBoard.isInPointer(board, GeometryPointer);\n        const dragMode = isGeometryPointer && isDndMode(board);\n        const movingPoint = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));\n        const pointer = PlaitBoard.getPointer(board) as DrawPointerType;\n\n        if (dragMode) {\n            const points = getDefaultGeometryPoints(pointer, movingPoint);\n            if (pointer === DrawPointerType.text) {\n                const textG = getTemporaryTextG(movingPoint);\n                geometryShapeG.appendChild(textG);\n                PlaitBoard.getElementActiveHost(board).append(geometryShapeG);\n            } else {\n                const temporaryElement = createGeometryElement((pointer as unknown) as GeometryShape, points, '', {\n                    strokeColor: DefaultGeometryProperty.strokeColor,\n                    strokeWidth: DefaultGeometryProperty.strokeWidth\n                });\n                geometryGenerator.draw(temporaryElement, geometryShapeG);\n                PlaitBoard.getElementActiveHost(board).append(geometryShapeG);\n            }\n        }\n\n        pointerMove(event);\n    };\n\n    board.pointerUp = (event: PointerEvent) => {\n        const pointer = PlaitBoard.getPointer(board) as DrawPointerType;\n        const isGeometryPointer = PlaitBoard.isInPointer(board, GeometryPointer);\n        const dragMode = isGeometryPointer && isDndMode(board);\n\n        if (dragMode) {\n            const targetPoint = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));\n            const points = getDefaultGeometryPoints(pointer, targetPoint);\n            if (pointer === DrawPointerType.text) {\n                DrawTransforms.insertText(board, points);\n            } else {\n                DrawTransforms.insertGeometry(board, points, (pointer as unknown) as GeometryShape);\n            }\n            BoardTransforms.updatePointerType(board, PlaitPointerType.selection);\n        }\n\n        geometryShapeG?.remove();\n        geometryShapeG = null;\n        preventTouchMove(board, event, false);\n\n        pointerUp(event);\n    };\n\n    return board;\n};\n\nexport const withGeometryCreateByDraw = (board: PlaitBoard) => {\n    const { pointerDown, pointerMove, pointerUp, keydown, keyup } = board;\n    let start: Point | null = null;\n\n    let geometryShapeG: SVGGElement | null = null;\n\n    let temporaryElement: PlaitGeometry | null = null;\n\n    let isShift = false;\n\n    board.keydown = (event: KeyboardEvent) => {\n        isShift = isKeyHotkey('shift', event);\n        keydown(event);\n    };\n\n    board.keyup = (event: KeyboardEvent) => {\n        isShift = false;\n        keyup(event);\n    };\n\n    board.pointerDown = (event: PointerEvent) => {\n        const isGeometryPointer = PlaitBoard.isInPointer(board, GeometryPointer);\n        if (isGeometryPointer && isDrawingMode(board)) {\n            const point = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));\n            start = point;\n            const pointer = PlaitBoard.getPointer(board) as DrawPointerType;\n            preventTouchMove(board, event, true);\n            if (pointer === DrawPointerType.text) {\n                const points = getDefaultGeometryPoints(pointer, point);\n                const textElement = createGeometryElement(GeometryShape.text, points, DefaultTextProperty.text);\n                Transforms.insertNode(board, textElement, [board.children.length]);\n                clearSelectedElement(board);\n                addSelectedElement(board, textElement);\n                BoardTransforms.updatePointerType(board, PlaitPointerType.selection);\n                start = null;\n            }\n        }\n        pointerDown(event);\n    };\n\n    board.pointerMove = (event: PointerEvent) => {\n        geometryShapeG?.remove();\n        geometryShapeG = createG();\n        const geometryGenerator = new GeometryShapeGenerator(board);\n        const drawMode = !!start;\n        const movingPoint = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));\n        const pointer = PlaitBoard.getPointer(board) as DrawPointerType;\n        if (drawMode && pointer !== DrawPointerType.text) {\n            const points = normalizeShapePoints([start!, movingPoint], isShift);\n            temporaryElement = createGeometryElement((pointer as unknown) as GeometryShape, points, '', {\n                strokeColor: DefaultGeometryProperty.strokeColor,\n                strokeWidth: DefaultGeometryProperty.strokeWidth\n            });\n            geometryGenerator.draw(temporaryElement, geometryShapeG);\n            PlaitBoard.getElementActiveHost(board).append(geometryShapeG);\n        }\n\n        pointerMove(event);\n    };\n\n    board.pointerUp = (event: PointerEvent) => {\n        const isDrawMode = !!start;\n        if (isDrawMode) {\n            const targetPoint = transformPoint(board, toPoint(event.x, event.y, PlaitBoard.getHost(board)));\n            const { width, height } = RectangleClient.toRectangleClient([start!, targetPoint]);\n            if (Math.hypot(width, height) === 0) {\n                const pointer = PlaitBoard.getPointer(board) as DrawPointerType;\n                const points = getDefaultGeometryPoints(pointer, targetPoint);\n                if (pointer !== DrawPointerType.text) {\n                    temporaryElement = createGeometryElement((pointer as unknown) as GeometryShape, points, '', {\n                        strokeColor: DefaultGeometryProperty.strokeColor,\n                        strokeWidth: DefaultGeometryProperty.strokeWidth\n                    });\n                }\n            }\n        }\n        if (temporaryElement) {\n            Transforms.insertNode(board, temporaryElement, [board.children.length]);\n            clearSelectedElement(board);\n            addSelectedElement(board, temporaryElement);\n            BoardTransforms.updatePointerType(board, PlaitPointerType.selection);\n        }\n\n        geometryShapeG?.remove();\n        geometryShapeG = null;\n        start = null;\n        temporaryElement = null;\n        preventTouchMove(board, event, false);\n\n        pointerUp(event);\n    };\n\n    return board;\n};\n\nconst getDefaultGeometryPoints = (pointer: DrawPointerType, targetPoint: Point) => {\n    return pointer === DrawPointerType.text\n        ? getPointsByCenterPoint(targetPoint, DefaultTextProperty.width, DefaultTextProperty.height)\n        : getPointsByCenterPoint(targetPoint, DefaultGeometryProperty.width, DefaultGeometryProperty.height);\n};\n\nconst getTemporaryTextG = (movingPoint: Point) => {\n    const textG = createG();\n    const width = DefaultTextProperty.width - ShapeDefaultSpace.rectangleAndText * 2;\n    const foreignObject = createForeignObject(\n        movingPoint[0] - width / 2,\n        movingPoint[1] - DefaultTextProperty.height / 2,\n        width,\n        DefaultTextProperty.height\n    );\n\n    const richtext = document.createElement('div');\n    richtext.textContent = DefaultTextProperty.text;\n    richtext.style.fontSize = `${DEFAULT_FONT_SIZE}px`;\n    richtext.style.cursor = 'default';\n    foreignObject.appendChild(richtext);\n    textG.appendChild(foreignObject);\n\n    return textG;\n};\n"]}