@plait/draw 0.1.0-next.3

package/esm2022/utils/engine/ellipse.mjs

@@ -0,0 +1,55 @@
+import { PlaitBoard, RectangleClient, isPointInEllipse } from '@plait/core';
+export const EllipseEngine = {
+    draw(board, rectangle, options) {
+        const centerPoint = [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2];
+        const rs = PlaitBoard.getRoughSVG(board);
+        return rs.ellipse(centerPoint[0], centerPoint[1], rectangle.width, rectangle.height, { ...options, fillStyle: 'solid' });
+    },
+    isHit(rectangle, point) {
+        const centerPoint = [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2];
+        return isPointInEllipse(point, centerPoint, rectangle.width / 2, rectangle.height / 2);
+    },
+    getNearestPoint(rectangle, point) {
+        const centerPoint = [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2];
+        return getNearestPointBetweenPointAndEllipse(point, centerPoint, rectangle.width / 2, rectangle.height / 2);
+    },
+    getConnectorPoints(rectangle) {
+        return RectangleClient.getEdgeCenterPoints(rectangle);
+    }
+};
+export function getNearestPointBetweenPointAndEllipse(point, center, rx, ry, rotation = 0) {
+    const rectangleClient = {
+        x: center[0] - rx,
+        y: center[1] - ry,
+        height: ry * 2,
+        width: rx * 2
+    };
+    // https://stackoverflow.com/a/46007540/232122
+    const px = Math.abs(point[0] - rectangleClient.x - rectangleClient.width / 2);
+    const py = Math.abs(point[1] - rectangleClient.y - rectangleClient.height / 2);
+    let tx = 0.707;
+    let ty = 0.707;
+    const a = Math.abs(rectangleClient.width) / 2;
+    const b = Math.abs(rectangleClient.height) / 2;
+    [0, 1, 2, 3].forEach(x => {
+        const xx = a * tx;
+        const yy = b * ty;
+        const ex = ((a * a - b * b) * tx ** 3) / a;
+        const ey = ((b * b - a * a) * ty ** 3) / b;
+        const rx = xx - ex;
+        const ry = yy - ey;
+        const qx = px - ex;
+        const qy = py - ey;
+        const r = Math.hypot(ry, rx);
+        const q = Math.hypot(qy, qx);
+        tx = Math.min(1, Math.max(0, ((qx * r) / q + ex) / a));
+        ty = Math.min(1, Math.max(0, ((qy * r) / q + ey) / b));
+        const t = Math.hypot(ty, tx);
+        tx /= t;
+        ty /= t;
+    });
+    const signX = point[0] > center[0] ? 1 : -1;
+    const signY = point[1] > center[1] ? 1 : -1;
+    return [center[0] + a * tx * signX, center[1] + b * ty * signY];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ellipse.js","sourceRoot":"","sources":["../../../../../packages/draw/src/utils/engine/ellipse.ts"],"names":[],"mappings":"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","sourcesContent":["import { PlaitBoard, Point, RectangleClient, isPointInEllipse } from '@plait/core';\nimport { ShapeEngine } from '../../interfaces';\nimport { Options } from 'roughjs/bin/core';\n\nexport const EllipseEngine: ShapeEngine = {\n    draw(board: PlaitBoard, rectangle: RectangleClient, options: Options) {\n        const centerPoint = [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2];\n        const rs = PlaitBoard.getRoughSVG(board);\n        return rs.ellipse(centerPoint[0], centerPoint[1], rectangle.width, rectangle.height, { ...options, fillStyle: 'solid' });\n    },\n    isHit(rectangle: RectangleClient, point: Point) {\n        const centerPoint: Point = [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2];\n        return isPointInEllipse(point, centerPoint, rectangle.width / 2, rectangle.height / 2);\n    },\n    getNearestPoint(rectangle: RectangleClient, point: Point) {\n        const centerPoint: Point = [rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2];\n        return getNearestPointBetweenPointAndEllipse(point, centerPoint, rectangle.width / 2, rectangle.height / 2);\n    },\n    getConnectorPoints(rectangle: RectangleClient) {\n        return RectangleClient.getEdgeCenterPoints(rectangle);\n    }\n};\n\nexport function getNearestPointBetweenPointAndEllipse(point: Point, center: Point, rx: number, ry: number, rotation: number = 0): Point {\n    const rectangleClient = {\n        x: center[0] - rx,\n        y: center[1] - ry,\n        height: ry * 2,\n        width: rx * 2\n    };\n    // https://stackoverflow.com/a/46007540/232122\n    const px = Math.abs(point[0] - rectangleClient.x - rectangleClient.width / 2);\n    const py = Math.abs(point[1] - rectangleClient.y - rectangleClient.height / 2);\n\n    let tx = 0.707;\n    let ty = 0.707;\n\n    const a = Math.abs(rectangleClient.width) / 2;\n    const b = Math.abs(rectangleClient.height) / 2;\n\n    [0, 1, 2, 3].forEach(x => {\n        const xx = a * tx;\n        const yy = b * ty;\n\n        const ex = ((a * a - b * b) * tx ** 3) / a;\n        const ey = ((b * b - a * a) * ty ** 3) / b;\n\n        const rx = xx - ex;\n        const ry = yy - ey;\n\n        const qx = px - ex;\n        const qy = py - ey;\n\n        const r = Math.hypot(ry, rx);\n        const q = Math.hypot(qy, qx);\n\n        tx = Math.min(1, Math.max(0, ((qx * r) / q + ex) / a));\n        ty = Math.min(1, Math.max(0, ((qy * r) / q + ey) / b));\n        const t = Math.hypot(ty, tx);\n        tx /= t;\n        ty /= t;\n    });\n    const signX = point[0] > center[0] ? 1 : -1;\n    const signY = point[1] > center[1] ? 1 : -1;\n\n    return [center[0] + a * tx * signX, center[1] + b * ty * signY];\n}\n"]}

package/esm2022/utils/engine/index.mjs

@@ -0,0 +1,18 @@
+import { GeometryShape } from '../../interfaces';
+import { DiamondEngine } from './diamond';
+import { EllipseEngine } from './ellipse';
+import { ParallelogramEngine } from './parallelogram';
+import { RectangleEngine } from './rectangle';
+import { RoundRectangleEngine } from './round-rectangle';
+export const ShapeEngineMap = {
+    [GeometryShape.rectangle]: RectangleEngine,
+    [GeometryShape.diamond]: DiamondEngine,
+    [GeometryShape.ellipse]: EllipseEngine,
+    [GeometryShape.parallelogram]: ParallelogramEngine,
+    [GeometryShape.roundRectangle]: RoundRectangleEngine,
+    [GeometryShape.text]: RectangleEngine
+};
+export const getEngine = (shape) => {
+    return ShapeEngineMap[shape];
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kcmF3L3NyYy91dGlscy9lbmdpbmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBZSxNQUFNLGtCQUFrQixDQUFDO0FBQzlELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFDMUMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUMxQyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUN0RCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQzlDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRXpELE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBdUM7SUFDOUQsQ0FBQyxhQUFhLENBQUMsU0FBUyxDQUFDLEVBQUUsZUFBZTtJQUMxQyxDQUFDLGFBQWEsQ0FBQyxPQUFPLENBQUMsRUFBRSxhQUFhO0lBQ3RDLENBQUMsYUFBYSxDQUFDLE9BQU8sQ0FBQyxFQUFFLGFBQWE7SUFDdEMsQ0FBQyxhQUFhLENBQUMsYUFBYSxDQUFDLEVBQUUsbUJBQW1CO0lBQ2xELENBQUMsYUFBYSxDQUFDLGNBQWMsQ0FBQyxFQUFFLG9CQUFvQjtJQUNwRCxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsRUFBRSxlQUFlO0NBQ3hDLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsQ0FBQyxLQUFvQixFQUFFLEVBQUU7SUFDOUMsT0FBTyxjQUFjLENBQUMsS0FBSyxDQUFDLENBQUM7QUFDakMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgR2VvbWV0cnlTaGFwZSwgU2hhcGVFbmdpbmUgfSBmcm9tICcuLi8uLi9pbnRlcmZhY2VzJztcbmltcG9ydCB7IERpYW1vbmRFbmdpbmUgfSBmcm9tICcuL2RpYW1vbmQnO1xuaW1wb3J0IHsgRWxsaXBzZUVuZ2luZSB9IGZyb20gJy4vZWxsaXBzZSc7XG5pbXBvcnQgeyBQYXJhbGxlbG9ncmFtRW5naW5lIH0gZnJvbSAnLi9wYXJhbGxlbG9ncmFtJztcbmltcG9ydCB7IFJlY3RhbmdsZUVuZ2luZSB9IGZyb20gJy4vcmVjdGFuZ2xlJztcbmltcG9ydCB7IFJvdW5kUmVjdGFuZ2xlRW5naW5lIH0gZnJvbSAnLi9yb3VuZC1yZWN0YW5nbGUnO1xuXG5leHBvcnQgY29uc3QgU2hhcGVFbmdpbmVNYXA6IFJlY29yZDxHZW9tZXRyeVNoYXBlLCBTaGFwZUVuZ2luZT4gPSB7XG4gICAgW0dlb21ldHJ5U2hhcGUucmVjdGFuZ2xlXTogUmVjdGFuZ2xlRW5naW5lLFxuICAgIFtHZW9tZXRyeVNoYXBlLmRpYW1vbmRdOiBEaWFtb25kRW5naW5lLFxuICAgIFtHZW9tZXRyeVNoYXBlLmVsbGlwc2VdOiBFbGxpcHNlRW5naW5lLFxuICAgIFtHZW9tZXRyeVNoYXBlLnBhcmFsbGVsb2dyYW1dOiBQYXJhbGxlbG9ncmFtRW5naW5lLFxuICAgIFtHZW9tZXRyeVNoYXBlLnJvdW5kUmVjdGFuZ2xlXTogUm91bmRSZWN0YW5nbGVFbmdpbmUsXG4gICAgW0dlb21ldHJ5U2hhcGUudGV4dF06IFJlY3RhbmdsZUVuZ2luZVxufTtcblxuZXhwb3J0IGNvbnN0IGdldEVuZ2luZSA9IChzaGFwZTogR2VvbWV0cnlTaGFwZSkgPT4ge1xuICAgIHJldHVybiBTaGFwZUVuZ2luZU1hcFtzaGFwZV07XG59O1xuIl19

package/esm2022/utils/engine/parallelogram.mjs

@@ -0,0 +1,30 @@
+import { PlaitBoard, getNearestPointBetweenPointAndSegments, isPointInPolygon } from '@plait/core';
+import { getCenterPointsOnPolygon } from '../geometry';
+export const ParallelogramEngine = {
+    draw(board, rectangle, options) {
+        const points = getParallelogramPoints(rectangle);
+        const rs = PlaitBoard.getRoughSVG(board);
+        return rs.polygon(points, { ...options, fillStyle: 'solid' });
+    },
+    isHit(rectangle, point) {
+        const parallelogramPoints = getParallelogramPoints(rectangle);
+        return isPointInPolygon(point, parallelogramPoints);
+    },
+    getNearestPoint(rectangle, point) {
+        const cornerPoints = getParallelogramPoints(rectangle);
+        return getNearestPointBetweenPointAndSegments(point, cornerPoints);
+    },
+    getConnectorPoints(rectangle) {
+        const cornerPoints = getParallelogramPoints(rectangle);
+        return getCenterPointsOnPolygon(cornerPoints);
+    }
+};
+export const getParallelogramPoints = (rectangle) => {
+    return [
+        [rectangle.x + rectangle.width / 4, rectangle.y],
+        [rectangle.x + rectangle.width, rectangle.y],
+        [rectangle.x + (rectangle.width * 3) / 4, rectangle.y + rectangle.height],
+        [rectangle.x, rectangle.y + rectangle.height]
+    ];
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/engine/rectangle.mjs

@@ -0,0 +1,18 @@
+import { RectangleClient, drawRectangle, getNearestPointBetweenPointAndSegments } from '@plait/core';
+export const RectangleEngine = {
+    draw(board, rectangle, options) {
+        return drawRectangle(board, rectangle, { ...options, fillStyle: 'solid' });
+    },
+    isHit(rectangle, point) {
+        const rangeRectangle = RectangleClient.toRectangleClient([point, point]);
+        return RectangleClient.isHit(rectangle, rangeRectangle);
+    },
+    getNearestPoint(rectangle, point) {
+        const cornerPoints = RectangleClient.getCornerPoints(rectangle);
+        return getNearestPointBetweenPointAndSegments(point, cornerPoints);
+    },
+    getConnectorPoints(rectangle) {
+        return RectangleClient.getEdgeCenterPoints(rectangle);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/engine/round-rectangle.mjs

@@ -0,0 +1,49 @@
+import { PlaitBoard, RectangleClient, drawRoundRectangle, getNearestPointBetweenPointAndSegments, isPointInRoundRectangle } from '@plait/core';
+import { getNearestPointBetweenPointAndEllipse } from './ellipse';
+export const RoundRectangleEngine = {
+    draw(board, rectangle, options) {
+        return drawRoundRectangle(PlaitBoard.getRoughSVG(board), rectangle.x, rectangle.y, rectangle.x + rectangle.width, rectangle.y + rectangle.height, { ...options, fillStyle: 'solid' }, false, getRoundRectangleRadius(rectangle));
+    },
+    isHit(rectangle, point) {
+        return isPointInRoundRectangle(point, rectangle, getRoundRectangleRadius(rectangle));
+    },
+    getNearestPoint(rectangle, point) {
+        return getNearestPointBetweenPointAndRoundRectangle(point, rectangle, getRoundRectangleRadius(rectangle));
+    },
+    getConnectorPoints(rectangle) {
+        return RectangleClient.getEdgeCenterPoints(rectangle);
+    }
+};
+export const getRoundRectangleRadius = (rectangle) => {
+    return Math.min(rectangle.width * 0.1, rectangle.height * 0.1);
+};
+export function getNearestPointBetweenPointAndRoundRectangle(point, rectangle, radius) {
+    const { x: rectX, y: rectY, width, height } = rectangle;
+    const cornerPoints = RectangleClient.getCornerPoints(rectangle);
+    let result = getNearestPointBetweenPointAndSegments(point, cornerPoints);
+    let circleCenter = null;
+    const inLeftTop = point[0] >= rectX && point[0] <= rectX + radius && point[1] >= rectY && point[1] <= rectY + radius;
+    if (inLeftTop) {
+        circleCenter = [rectX + radius, rectY + radius];
+    }
+    const inLeftBottom = point[0] >= rectX && point[0] <= rectX + radius && point[1] >= rectY + height && point[1] <= rectY + height - radius;
+    if (inLeftBottom) {
+        circleCenter = [rectX + radius, rectY + height - radius];
+    }
+    const inRightTop = point[0] >= rectX + width - radius && point[0] <= rectX + width && point[1] >= rectY && point[1] <= rectY + radius;
+    if (inRightTop) {
+        circleCenter = [rectX + width - radius, rectY + radius];
+    }
+    const inRightBottom = point[0] >= rectX + width - radius &&
+        point[0] <= rectX + width &&
+        point[1] >= rectY + height - radius &&
+        point[1] <= rectY + height;
+    if (inRightBottom) {
+        circleCenter = [rectX + width - radius, rectY + height - radius];
+    }
+    if (circleCenter) {
+        result = getNearestPointBetweenPointAndEllipse(point, circleCenter, radius, radius);
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/geometry-style/stroke.mjs

@@ -0,0 +1,17 @@
+import { DefaultGeometryStyle } from '../../constants';
+export const getStrokeWidthByElement = (element) => {
+    const strokeWidth = element.strokeWidth || DefaultGeometryStyle.strokeWidth;
+    return strokeWidth;
+};
+export const getStrokeColorByElement = (element) => {
+    const strokeColor = element.strokeColor || DefaultGeometryStyle.strokeColor;
+    return strokeColor;
+};
+export const getFillByElement = (element) => {
+    const fill = element.fill || DefaultGeometryStyle.fill;
+    return fill;
+};
+export const getLineDashByElement = (element) => {
+    return element.strokeStyle === 'dashed' ? [8, 8 + getStrokeWidthByElement(element)] : undefined;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/geometry.mjs

@@ -0,0 +1,84 @@
+import { PlaitBoard, RectangleClient, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, createG, drawCircle, idCreator } from '@plait/core';
+import { GeometryShape } from '../interfaces/geometry';
+import { Alignment, buildText } from '@plait/text';
+import { DefaultTextProperty, ShapeDefaultSpace } from '../constants';
+import { getRectangleByPoints } from '@plait/common';
+import { getStrokeWidthByElement } from './geometry-style/stroke';
+import { getEngine } from './engine';
+export const createGeometryElement = (shape, points, text, options) => {
+    let textOptions = {};
+    let alignment = Alignment.center;
+    if (shape === GeometryShape.text) {
+        textOptions = { autoSize: true };
+        alignment = undefined;
+    }
+    return {
+        id: idCreator(),
+        type: 'geometry',
+        shape,
+        angle: 0,
+        opacity: 1,
+        textHeight: DefaultTextProperty.height,
+        text: buildText(text, alignment),
+        points,
+        ...textOptions,
+        ...options
+    };
+};
+export const getPointsByCenterPoint = (point, width, height) => {
+    const leftTopPoint = [point[0] - width / 2, point[1] - height / 2];
+    const rightBottomPoint = [point[0] + width / 2, point[1] + height / 2];
+    return [leftTopPoint, rightBottomPoint];
+};
+export const getTextRectangle = (element) => {
+    const elementRectangle = getRectangleByPoints(element.points);
+    const height = element.textHeight;
+    const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2;
+    return {
+        height,
+        width: width > 0 ? width : 0,
+        x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText,
+        y: elementRectangle.y + (elementRectangle.height - height) / 2
+    };
+};
+export const drawBoundMask = (board, element) => {
+    const G = createG();
+    const rectangle = getRectangleByPoints(element.points);
+    const offset = (getStrokeWidthByElement(element) + 1) / 2 - 0.1;
+    const activeRectangle = RectangleClient.getOutlineRectangle(rectangle, -offset);
+    const maskG = drawGeometry(board, activeRectangle, element.shape, {
+        stroke: SELECTION_BORDER_COLOR,
+        strokeWidth: 1,
+        fill: SELECTION_FILL_COLOR,
+        fillStyle: 'solid'
+    });
+    G.appendChild(maskG);
+    const connectorPoints = getEngine(element.shape).getConnectorPoints(activeRectangle);
+    connectorPoints.forEach(point => {
+        const circleG = drawCircle(PlaitBoard.getRoughSVG(board), point, 6, {
+            stroke: '#999999',
+            strokeWidth: 1,
+            fill: '#FFF',
+            fillStyle: 'solid'
+        });
+        G.appendChild(circleG);
+    });
+    return G;
+};
+export const drawGeometry = (board, outerRectangle, shape, options) => {
+    return getEngine(shape).draw(board, outerRectangle, options);
+};
+export const getNearestPoint = (element, point, offset = 0) => {
+    const rectangle = getRectangleByPoints(element.points);
+    const activeRectangle = RectangleClient.getOutlineRectangle(rectangle, -offset);
+    return getEngine(element.shape).getNearestPoint(activeRectangle, point);
+};
+export const getCenterPointsOnPolygon = (points) => {
+    const centerPoint = [];
+    for (let i = 0; i < points.length; i++) {
+        let j = i == points.length - 1 ? 0 : i + 1;
+        centerPoint.push([(points[i][0] + points[j][0]) / 2, (points[i][1] + points[j][1]) / 2]);
+    }
+    return centerPoint;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geometry.js","sourceRoot":"","sources":["../../../../packages/draw/src/utils/geometry.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    PlaitBoard,\n    Point,\n    RectangleClient,\n    SELECTION_BORDER_COLOR,\n    SELECTION_FILL_COLOR,\n    createG,\n    drawCircle,\n    idCreator\n} from '@plait/core';\nimport { GeometryShape, PlaitGeometry } from '../interfaces/geometry';\nimport { Alignment, buildText } from '@plait/text';\nimport { Element } from 'slate';\nimport { DefaultTextProperty, ShapeDefaultSpace } from '../constants';\nimport { getRectangleByPoints } from '@plait/common';\nimport { getStrokeWidthByElement } from './geometry-style/stroke';\nimport { Options } from 'roughjs/bin/core';\nimport { getEngine } from './engine';\n\nexport const createGeometryElement = (\n    shape: GeometryShape,\n    points: [Point, Point],\n    text: string | Element,\n    options?: Pick<PlaitGeometry, 'fill' | 'strokeColor' | 'strokeWidth'>\n): PlaitGeometry => {\n    let textOptions = {};\n    let alignment: undefined | Alignment = Alignment.center;\n    if (shape === GeometryShape.text) {\n        textOptions = { autoSize: true };\n        alignment = undefined;\n    }\n\n    return {\n        id: idCreator(),\n        type: 'geometry',\n        shape,\n        angle: 0,\n        opacity: 1,\n        textHeight: DefaultTextProperty.height,\n        text: buildText(text, alignment),\n        points,\n        ...textOptions,\n        ...options\n    };\n};\n\nexport const getPointsByCenterPoint = (point: Point, width: number, height: number): [Point, Point] => {\n    const leftTopPoint: Point = [point[0] - width / 2, point[1] - height / 2];\n    const rightBottomPoint: Point = [point[0] + width / 2, point[1] + height / 2];\n\n    return [leftTopPoint, rightBottomPoint];\n};\n\nexport const getTextRectangle = (element: PlaitGeometry) => {\n    const elementRectangle = getRectangleByPoints(element.points!);\n    const height = element.textHeight;\n    const width = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2;\n\n    return {\n        height,\n        width: width > 0 ? width : 0,\n        x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText,\n        y: elementRectangle.y + (elementRectangle.height - height) / 2\n    };\n};\n\nexport const drawBoundMask = (board: PlaitBoard, element: PlaitGeometry) => {\n    const G = createG();\n    const rectangle = getRectangleByPoints(element.points);\n    const offset = (getStrokeWidthByElement(element) + 1) / 2 - 0.1;\n    const activeRectangle = RectangleClient.getOutlineRectangle(rectangle, -offset);\n    const maskG = drawGeometry(board, activeRectangle, element.shape, {\n        stroke: SELECTION_BORDER_COLOR,\n        strokeWidth: 1,\n        fill: SELECTION_FILL_COLOR,\n        fillStyle: 'solid'\n    });\n    G.appendChild(maskG);\n\n    const connectorPoints = getEngine(element.shape).getConnectorPoints(activeRectangle);\n    connectorPoints.forEach(point => {\n        const circleG = drawCircle(PlaitBoard.getRoughSVG(board), point, 6, {\n            stroke: '#999999',\n            strokeWidth: 1,\n            fill: '#FFF',\n            fillStyle: 'solid'\n        });\n        G.appendChild(circleG);\n    });\n\n    return G;\n};\n\nexport const drawGeometry = (board: PlaitBoard, outerRectangle: RectangleClient, shape: GeometryShape, options: Options) => {\n    return getEngine(shape).draw(board, outerRectangle, options);\n};\n\nexport const getNearestPoint = (element: PlaitGeometry, point: Point, offset = 0) => {\n    const rectangle = getRectangleByPoints(element.points);\n    const activeRectangle = RectangleClient.getOutlineRectangle(rectangle, -offset);\n    return getEngine(element.shape).getNearestPoint(activeRectangle, point);\n};\n\nexport const getCenterPointsOnPolygon = (points: Point[]) => {\n    const centerPoint: Point[] = [];\n    for (let i = 0; i < points.length; i++) {\n        let j = i == points.length - 1 ? 0 : i + 1;\n        centerPoint.push([(points[i][0] + points[j][0]) / 2, (points[i][1] + points[j][1]) / 2]);\n    }\n    return centerPoint;\n};\n"]}

package/esm2022/utils/index.mjs

@@ -0,0 +1,5 @@
+export * from './line';
+export * from './geometry';
+export * from './create-mode';
+export * from './selected';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9kcmF3L3NyYy91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFFBQVEsQ0FBQztBQUN2QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGluZSc7XG5leHBvcnQgKiBmcm9tICcuL2dlb21ldHJ5JztcbmV4cG9ydCAqIGZyb20gJy4vY3JlYXRlLW1vZGUnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWxlY3RlZCc7XG4iXX0=

package/esm2022/utils/line.mjs

@@ -0,0 +1,145 @@
+import { idCreator, distanceBetweenPointAndSegments, PlaitBoard, createG, arrowPoints, drawLinearPath, getElementById, RectangleClient } from '@plait/core';
+import { getPoints, Direction, getRectangleByPoints, getDirectionByPoint, getPointOnPolyline } from '@plait/common';
+import { LineMarkerType } from '../interfaces';
+import { getPointsByCenterPoint, getNearestPoint } from './geometry';
+import { getLineDashByElement, getStrokeColorByElement, getStrokeWidthByElement } from './geometry-style/stroke';
+import { getEngine } from './engine';
+export const createLineElement = (shape, points, source, target, options) => {
+    return {
+        id: idCreator(),
+        type: 'line',
+        shape,
+        source,
+        texts: [],
+        target,
+        opacity: 1,
+        points,
+        ...options
+    };
+};
+export const getElbowPoints = (board, element) => {
+    if (element.points.length === 2) {
+        const source = getSourcePoint(board, element);
+        const target = getTargetPoint(board, element);
+        let sourceDirection = source[0] < target[0] ? Direction.right : Direction.left;
+        let targetDirection = source[0] < target[0] ? Direction.left : Direction.right;
+        if (element.source.connection) {
+            sourceDirection = getDirectionByPoint(element.source.connection, sourceDirection);
+        }
+        if (element.target.connection) {
+            targetDirection = getDirectionByPoint(element.target.connection, targetDirection);
+        }
+        const points = getPoints(source, sourceDirection, target, targetDirection, 30);
+        return points;
+    }
+    return element.points;
+};
+export const isHitPolyLine = (pathPoints, point, strokeWidth, expand = 0) => {
+    const distance = distanceBetweenPointAndSegments(pathPoints, point);
+    return distance <= strokeWidth + expand;
+};
+export const getHitLineTextIndex = (board, element, point) => {
+    const texts = element.texts;
+    if (!texts.length)
+        return -1;
+    const points = getElbowPoints(board, element);
+    return texts.findIndex(text => {
+        const center = getPointOnPolyline(points, text.position);
+        const rectangle = {
+            x: center[0] - text.width / 2,
+            y: center[1] - text.height / 2,
+            width: text.width,
+            height: text.height
+        };
+        return RectangleClient.isHit(rectangle, RectangleClient.toRectangleClient([point, point]));
+    });
+};
+export const isHitLineText = (board, element, point) => {
+    return getHitLineTextIndex(board, element, point) !== -1;
+};
+export const drawElbowLine = (board, element) => {
+    const strokeWidth = getStrokeWidthByElement(element);
+    const strokeColor = getStrokeColorByElement(element);
+    const strokeLineDash = getLineDashByElement(element);
+    const options = { stroke: strokeColor, strokeWidth, strokeLineDash };
+    const lineG = createG();
+    const points = getElbowPoints(board, element);
+    const elbowLine = PlaitBoard.getRoughSVG(board).linearPath(points, options);
+    const path = elbowLine.querySelector('path');
+    path?.setAttribute('mask', `url(#${element.id})`);
+    lineG.appendChild(elbowLine);
+    const arrow = drawLineArrow(element, points, options);
+    arrow && lineG.appendChild(arrow);
+    return lineG;
+};
+export const drawLineArrow = (element, points, options) => {
+    const sourceMarker = element.source.marker;
+    const targetMarker = element.target.marker;
+    const arrowG = createG();
+    if (sourceMarker === LineMarkerType.none && targetMarker === LineMarkerType.none)
+        return null;
+    if (sourceMarker === LineMarkerType.arrow) {
+        const sourcePoint = points[0];
+        const { pointLeft, pointRight } = arrowPoints(points[1], sourcePoint, 10, 20);
+        const sourceArrow = drawLinearPath([pointLeft, sourcePoint, pointRight], options);
+        arrowG.appendChild(sourceArrow);
+    }
+    if (targetMarker === LineMarkerType.arrow) {
+        const endPoint = points[points.length - 1];
+        const { pointLeft, pointRight } = arrowPoints(points[points.length - 2], endPoint, 10, 20);
+        const targetArrow = drawLinearPath([pointLeft, endPoint, pointRight], options);
+        arrowG.appendChild(targetArrow);
+    }
+    return arrowG;
+};
+export const getSourcePoint = (board, element) => {
+    if (element.source.boundId) {
+        const boundElement = getElementById(board, element.source.boundId);
+        return boundElement ? normalizeConnection(boundElement, element.source.connection) : element.points[0];
+    }
+    return element.points[0];
+};
+export const getTargetPoint = (board, element) => {
+    if (element.target.boundId) {
+        const boundElement = getElementById(board, element.target.boundId);
+        return boundElement ? normalizeConnection(boundElement, element.target.connection) : element.points[element.points.length - 1];
+    }
+    return element.points[element.points.length - 1];
+};
+export const normalizeConnection = (geometry, connection) => {
+    const rectangle = getRectangleByPoints(geometry.points);
+    const strokeWidth = getStrokeWidthByElement(geometry);
+    return [
+        rectangle.x - strokeWidth / 2 + (rectangle.width + strokeWidth) * connection[0],
+        rectangle.y - strokeWidth / 2 + (rectangle.height + strokeWidth) * connection[1]
+    ];
+};
+export const transformPointToConnection = (board, point, hitElement) => {
+    const offset = (getStrokeWidthByElement(hitElement) + 1) / 2;
+    let rectangle = getRectangleByPoints(hitElement.points);
+    rectangle = RectangleClient.getOutlineRectangle(rectangle, -offset);
+    let nearestPoint = getNearestPoint(hitElement, point, offset);
+    const hitConnector = getHitConnectorPoint(nearestPoint, hitElement, rectangle);
+    nearestPoint = hitConnector ? hitConnector : nearestPoint;
+    return [(nearestPoint[0] - rectangle.x) / rectangle.width, (nearestPoint[1] - rectangle.y) / rectangle.height];
+};
+export const getHitConnectorPoint = (movingPoint, hitElement, rectangle) => {
+    const connector = getEngine(hitElement.shape).getConnectorPoints(rectangle);
+    const points = getPointsByCenterPoint(movingPoint, 5, 5);
+    const pointRectangle = getRectangleByPoints(points);
+    return connector.find(point => {
+        return RectangleClient.isHit(pointRectangle, RectangleClient.toRectangleClient([point, point]));
+    });
+};
+export const getLineTextRectangle = (board, element, index) => {
+    const text = element.texts[index];
+    const elbowPoints = getElbowPoints(board, element);
+    const point = getPointOnPolyline(elbowPoints, text.position);
+    return {
+        x: point[0] - text.width / 2,
+        y: point[1] - text.height / 2,
+        width: text.width,
+        height: text.height
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"line.js","sourceRoot":"","sources":["../../../../packages/draw/src/utils/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,SAAS,EACT,+BAA+B,EAC/B,UAAU,EACV,OAAO,EACP,WAAW,EACX,cAAc,EACd,cAAc,EACd,eAAe,EAClB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACpH,OAAO,EAAc,cAAc,EAAuC,MAAM,eAAe,CAAC;AAEhG,OAAO,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACjH,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC7B,KAAgB,EAChB,MAAsB,EACtB,MAAkB,EAClB,MAAkB,EAClB,OAAwD,EAC/C,EAAE;IACX,OAAO;QACH,EAAE,EAAE,SAAS,EAAE;QACf,IAAI,EAAE,MAAM;QACZ,KAAK;QACL,MAAM;QACN,KAAK,EAAE,EAAE;QACT,MAAM;QACN,OAAO,EAAE,CAAC;QACV,MAAM;QACN,GAAG,OAAO;KACb,CAAC;AACN,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,KAAiB,EAAE,OAAkB,EAAE,EAAE;IACpE,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QAC7B,MAAM,MAAM,GAAG,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAC9C,MAAM,MAAM,GAAG,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAC9C,IAAI,eAAe,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC;QAC/E,IAAI,eAAe,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC;QAC/E,IAAI,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE;YAC3B,eAAe,GAAG,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;SACrF;QACD,IAAI,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE;YAC3B,eAAe,GAAG,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;SACrF;QACD,MAAM,MAAM,GAAY,SAAS,CAAC,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,eAAe,EAAE,EAAE,CAAC,CAAC;QACxF,OAAO,MAAM,CAAC;KACjB;IACD,OAAO,OAAO,CAAC,MAAM,CAAC;AAC1B,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,UAAmB,EAAE,KAAY,EAAE,WAAmB,EAAE,SAAiB,CAAC,EAAE,EAAE;IACxG,MAAM,QAAQ,GAAG,+BAA+B,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IACpE,OAAO,QAAQ,IAAI,WAAW,GAAG,MAAM,CAAC;AAC5C,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,KAAiB,EAAE,OAAkB,EAAE,KAAY,EAAE,EAAE;IACvF,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;IAC5B,IAAI,CAAC,KAAK,CAAC,MAAM;QAAE,OAAO,CAAC,CAAC,CAAC;IAE7B,MAAM,MAAM,GAAG,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC9C,OAAO,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;QAC1B,MAAM,MAAM,GAAG,kBAAkB,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QACzD,MAAM,SAAS,GAAG;YACd,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAM,GAAG,CAAC;YAC9B,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,MAAO,GAAG,CAAC;YAC/B,KAAK,EAAE,IAAI,CAAC,KAAM;YAClB,MAAM,EAAE,IAAI,CAAC,MAAO;SACvB,CAAC;QACF,OAAO,eAAe,CAAC,KAAK,CAAC,SAAS,EAAE,eAAe,CAAC,iBAAiB,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IAC/F,CAAC,CAAC,CAAC;AACP,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAiB,EAAE,OAAkB,EAAE,KAAY,EAAE,EAAE;IACjF,OAAO,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;AAC7D,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAiB,EAAE,OAAkB,EAAE,EAAE;IACnE,MAAM,WAAW,GAAG,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACrD,MAAM,WAAW,GAAG,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACrD,MAAM,cAAc,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;IACrD,MAAM,OAAO,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,CAAC;IACrE,MAAM,KAAK,GAAG,OAAO,EAAE,CAAC;IACxB,MAAM,MAAM,GAAG,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC9C,MAAM,SAAS,GAAG,UAAU,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5E,MAAM,IAAI,GAAG,SAAS,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;IAC7C,IAAI,EAAE,YAAY,CAAC,MAAM,EAAE,QAAQ,OAAO,CAAC,EAAE,GAAG,CAAC,CAAC;IAClD,KAAK,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;IAC7B,MAAM,KAAK,GAAG,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACtD,KAAK,IAAI,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IAClC,OAAO,KAAK,CAAC;AACjB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,OAAkB,EAAE,MAAe,EAAE,OAAgB,EAAE,EAAE;IACnF,MAAM,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC;IAC3C,MAAM,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC;IAC3C,MAAM,MAAM,GAAG,OAAO,EAAE,CAAC;IACzB,IAAI,YAAY,KAAK,cAAc,CAAC,IAAI,IAAI,YAAY,KAAK,cAAc,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IAC9F,IAAI,YAAY,KAAK,cAAc,CAAC,KAAK,EAAE;QACvC,MAAM,WAAW,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAC9B,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QAC9E,MAAM,WAAW,GAAG,cAAc,CAAC,CAAC,SAAS,EAAE,WAAW,EAAE,UAAU,CAAC,EAAE,OAAO,CAAC,CAAC;QAClF,MAAM,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;KACnC;IACD,IAAI,YAAY,KAAK,cAAc,CAAC,KAAK,EAAE;QACvC,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC3C,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QAC3F,MAAM,WAAW,GAAG,cAAc,CAAC,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CAAC,EAAE,OAAO,CAAC,CAAC;QAC/E,MAAM,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;KACnC;IACD,OAAO,MAAM,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,KAAiB,EAAE,OAAkB,EAAE,EAAE;IACpE,IAAI,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE;QACxB,MAAM,YAAY,GAAG,cAAc,CAAgB,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAClF,OAAO,YAAY,CAAC,CAAC,CAAC,mBAAmB,CAAC,YAAY,EAAE,OAAO,CAAC,MAAM,CAAC,UAAW,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;KAC3G;IACD,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAC7B,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,KAAiB,EAAE,OAAkB,EAAE,EAAE;IACpE,IAAI,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE;QACxB,MAAM,YAAY,GAAG,cAAc,CAAgB,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAClF,OAAO,YAAY,CAAC,CAAC,CAAC,mBAAmB,CAAC,YAAY,EAAE,OAAO,CAAC,MAAM,CAAC,UAAW,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;KACnI;IACD,OAAO,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACrD,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,QAAuB,EAAE,UAAiB,EAAS,EAAE;IACrF,MAAM,SAAS,GAAG,oBAAoB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACxD,MAAM,WAAW,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAC;IACtD,OAAO;QACH,SAAS,CAAC,CAAC,GAAG,WAAW,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,KAAK,GAAG,WAAW,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;QAC/E,SAAS,CAAC,CAAC,GAAG,WAAW,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,MAAM,GAAG,WAAW,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;KACnF,CAAC;AACN,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,KAAiB,EAAE,KAAY,EAAE,UAAyB,EAAS,EAAE;IAC5G,MAAM,MAAM,GAAG,CAAC,uBAAuB,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IAC7D,IAAI,SAAS,GAAG,oBAAoB,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IACxD,SAAS,GAAG,eAAe,CAAC,mBAAmB,CAAC,SAAS,EAAE,CAAC,MAAM,CAAC,CAAC;IACpE,IAAI,YAAY,GAAG,eAAe,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IAC9D,MAAM,YAAY,GAAG,oBAAoB,CAAC,YAAY,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;IAC/E,YAAY,GAAG,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC;IAC1D,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,KAAK,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AACnH,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,WAAkB,EAAE,UAAyB,EAAE,SAA0B,EAAE,EAAE;IAC9G,MAAM,SAAS,GAAG,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAC5E,MAAM,MAAM,GAAG,sBAAsB,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACzD,MAAM,cAAc,GAAG,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACpD,OAAO,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;QAC1B,OAAO,eAAe,CAAC,KAAK,CAAC,cAAc,EAAE,eAAe,CAAC,iBAAiB,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IACpG,CAAC,CAAC,CAAC;AACP,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,KAAiB,EAAE,OAAkB,EAAE,KAAa,EAAmB,EAAE;IAC1G,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAClC,MAAM,WAAW,GAAG,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACnD,MAAM,KAAK,GAAG,kBAAkB,CAAC,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC7D,OAAO;QACH,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAM,GAAG,CAAC;QAC7B,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,MAAO,GAAG,CAAC;QAC9B,KAAK,EAAE,IAAI,CAAC,KAAM;QAClB,MAAM,EAAE,IAAI,CAAC,MAAO;KACvB,CAAC;AACN,CAAC,CAAC","sourcesContent":["import {\n    Point,\n    idCreator,\n    distanceBetweenPointAndSegments,\n    PlaitBoard,\n    createG,\n    arrowPoints,\n    drawLinearPath,\n    getElementById,\n    RectangleClient\n} from '@plait/core';\nimport { getPoints, Direction, getRectangleByPoints, getDirectionByPoint, getPointOnPolyline } from '@plait/common';\nimport { LineHandle, LineMarkerType, LineShape, PlaitGeometry, PlaitLine } from '../interfaces';\nimport { Options } from 'roughjs/bin/core';\nimport { getPointsByCenterPoint, getNearestPoint } from './geometry';\nimport { getLineDashByElement, getStrokeColorByElement, getStrokeWidthByElement } from './geometry-style/stroke';\nimport { getEngine } from './engine';\n\nexport const createLineElement = (\n    shape: LineShape,\n    points: [Point, Point],\n    source: LineHandle,\n    target: LineHandle,\n    options?: Pick<PlaitLine, 'strokeColor' | 'strokeWidth'>\n): PlaitLine => {\n    return {\n        id: idCreator(),\n        type: 'line',\n        shape,\n        source,\n        texts: [],\n        target,\n        opacity: 1,\n        points,\n        ...options\n    };\n};\n\nexport const getElbowPoints = (board: PlaitBoard, element: PlaitLine) => {\n    if (element.points.length === 2) {\n        const source = getSourcePoint(board, element);\n        const target = getTargetPoint(board, element);\n        let sourceDirection = source[0] < target[0] ? Direction.right : Direction.left;\n        let targetDirection = source[0] < target[0] ? Direction.left : Direction.right;\n        if (element.source.connection) {\n            sourceDirection = getDirectionByPoint(element.source.connection, sourceDirection);\n        }\n        if (element.target.connection) {\n            targetDirection = getDirectionByPoint(element.target.connection, targetDirection);\n        }\n        const points: Point[] = getPoints(source, sourceDirection, target, targetDirection, 30);\n        return points;\n    }\n    return element.points;\n};\n\nexport const isHitPolyLine = (pathPoints: Point[], point: Point, strokeWidth: number, expand: number = 0) => {\n    const distance = distanceBetweenPointAndSegments(pathPoints, point);\n    return distance <= strokeWidth + expand;\n};\n\nexport const getHitLineTextIndex = (board: PlaitBoard, element: PlaitLine, point: Point) => {\n    const texts = element.texts;\n    if (!texts.length) return -1;\n\n    const points = getElbowPoints(board, element);\n    return texts.findIndex(text => {\n        const center = getPointOnPolyline(points, text.position);\n        const rectangle = {\n            x: center[0] - text.width! / 2,\n            y: center[1] - text.height! / 2,\n            width: text.width!,\n            height: text.height!\n        };\n        return RectangleClient.isHit(rectangle, RectangleClient.toRectangleClient([point, point]));\n    });\n};\n\nexport const isHitLineText = (board: PlaitBoard, element: PlaitLine, point: Point) => {\n    return getHitLineTextIndex(board, element, point) !== -1;\n};\n\nexport const drawElbowLine = (board: PlaitBoard, element: PlaitLine) => {\n    const strokeWidth = getStrokeWidthByElement(element);\n    const strokeColor = getStrokeColorByElement(element);\n    const strokeLineDash = getLineDashByElement(element);\n    const options = { stroke: strokeColor, strokeWidth, strokeLineDash };\n    const lineG = createG();\n    const points = getElbowPoints(board, element);\n    const elbowLine = PlaitBoard.getRoughSVG(board).linearPath(points, options);\n    const path = elbowLine.querySelector('path');\n    path?.setAttribute('mask', `url(#${element.id})`);\n    lineG.appendChild(elbowLine);\n    const arrow = drawLineArrow(element, points, options);\n    arrow && lineG.appendChild(arrow);\n    return lineG;\n};\n\nexport const drawLineArrow = (element: PlaitLine, points: Point[], options: Options) => {\n    const sourceMarker = element.source.marker;\n    const targetMarker = element.target.marker;\n    const arrowG = createG();\n    if (sourceMarker === LineMarkerType.none && targetMarker === LineMarkerType.none) return null;\n    if (sourceMarker === LineMarkerType.arrow) {\n        const sourcePoint = points[0];\n        const { pointLeft, pointRight } = arrowPoints(points[1], sourcePoint, 10, 20);\n        const sourceArrow = drawLinearPath([pointLeft, sourcePoint, pointRight], options);\n        arrowG.appendChild(sourceArrow);\n    }\n    if (targetMarker === LineMarkerType.arrow) {\n        const endPoint = points[points.length - 1];\n        const { pointLeft, pointRight } = arrowPoints(points[points.length - 2], endPoint, 10, 20);\n        const targetArrow = drawLinearPath([pointLeft, endPoint, pointRight], options);\n        arrowG.appendChild(targetArrow);\n    }\n    return arrowG;\n};\n\nexport const getSourcePoint = (board: PlaitBoard, element: PlaitLine) => {\n    if (element.source.boundId) {\n        const boundElement = getElementById<PlaitGeometry>(board, element.source.boundId);\n        return boundElement ? normalizeConnection(boundElement, element.source.connection!) : element.points[0];\n    }\n    return element.points[0];\n};\n\nexport const getTargetPoint = (board: PlaitBoard, element: PlaitLine) => {\n    if (element.target.boundId) {\n        const boundElement = getElementById<PlaitGeometry>(board, element.target.boundId);\n        return boundElement ? normalizeConnection(boundElement, element.target.connection!) : element.points[element.points.length - 1];\n    }\n    return element.points[element.points.length - 1];\n};\n\nexport const normalizeConnection = (geometry: PlaitGeometry, connection: Point): Point => {\n    const rectangle = getRectangleByPoints(geometry.points);\n    const strokeWidth = getStrokeWidthByElement(geometry);\n    return [\n        rectangle.x - strokeWidth / 2 + (rectangle.width + strokeWidth) * connection[0],\n        rectangle.y - strokeWidth / 2 + (rectangle.height + strokeWidth) * connection[1]\n    ];\n};\n\nexport const transformPointToConnection = (board: PlaitBoard, point: Point, hitElement: PlaitGeometry): Point => {\n    const offset = (getStrokeWidthByElement(hitElement) + 1) / 2;\n    let rectangle = getRectangleByPoints(hitElement.points);\n    rectangle = RectangleClient.getOutlineRectangle(rectangle, -offset);\n    let nearestPoint = getNearestPoint(hitElement, point, offset);\n    const hitConnector = getHitConnectorPoint(nearestPoint, hitElement, rectangle);\n    nearestPoint = hitConnector ? hitConnector : nearestPoint;\n    return [(nearestPoint[0] - rectangle.x) / rectangle.width, (nearestPoint[1] - rectangle.y) / rectangle.height];\n};\n\nexport const getHitConnectorPoint = (movingPoint: Point, hitElement: PlaitGeometry, rectangle: RectangleClient) => {\n    const connector = getEngine(hitElement.shape).getConnectorPoints(rectangle);\n    const points = getPointsByCenterPoint(movingPoint, 5, 5);\n    const pointRectangle = getRectangleByPoints(points);\n    return connector.find(point => {\n        return RectangleClient.isHit(pointRectangle, RectangleClient.toRectangleClient([point, point]));\n    });\n};\n\nexport const getLineTextRectangle = (board: PlaitBoard, element: PlaitLine, index: number): RectangleClient => {\n    const text = element.texts[index];\n    const elbowPoints = getElbowPoints(board, element);\n    const point = getPointOnPolyline(elbowPoints, text.position);\n    return {\n        x: point[0] - text.width! / 2,\n        y: point[1] - text.height! / 2,\n        width: text.width!,\n        height: text.height!\n    };\n};\n"]}

package/esm2022/utils/position/geometry.mjs

@@ -0,0 +1,28 @@
+import { RectangleClient, depthFirstRecursion, getIsRecursionFunc } from '@plait/core';
+import { PlaitDrawElement } from '../../interfaces';
+import { RESIZE_HANDLE_DIAMETER, getRectangleByPoints, getRectangleResizeHandleRefs } from '@plait/common';
+import { getEngine } from '../engine';
+export const getHitGeometryResizeHandleRef = (board, element, point) => {
+    const rectangle = getRectangleByPoints(element.points);
+    const resizeHandleRefs = getRectangleResizeHandleRefs(rectangle, RESIZE_HANDLE_DIAMETER);
+    const result = resizeHandleRefs.find(resizeHandleRef => {
+        return RectangleClient.isHit(RectangleClient.toRectangleClient([point, point]), resizeHandleRef.rectangle);
+    });
+    return result;
+};
+export const getHitOutlineGeometry = (board, point, offset = 0) => {
+    let geometry = null;
+    depthFirstRecursion(board, node => {
+        if (PlaitDrawElement.isGeometry(node)) {
+            const shape = node.shape;
+            let client = getRectangleByPoints(node.points);
+            client = RectangleClient.getOutlineRectangle(client, offset);
+            const isHit = getEngine(shape).isHit(client, point);
+            if (isHit) {
+                geometry = node;
+            }
+        }
+    }, getIsRecursionFunc(board), true);
+    return geometry;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/position/line.mjs

@@ -0,0 +1,34 @@
+import { RectangleClient } from '@plait/core';
+import { RESIZE_HANDLE_DIAMETER } from '@plait/common';
+import { getSourcePoint, getTargetPoint } from '../line';
+export var LineResizeHandle;
+(function (LineResizeHandle) {
+    LineResizeHandle["source"] = "source";
+    LineResizeHandle["target"] = "target";
+})(LineResizeHandle || (LineResizeHandle = {}));
+export const getHitLineResizeHandleRef = (board, element, point) => {
+    const sourcePoint = getSourcePoint(board, element);
+    const targetPoint = getTargetPoint(board, element);
+    const sourceRectangle = {
+        x: sourcePoint[0] - RESIZE_HANDLE_DIAMETER / 2,
+        y: sourcePoint[1] - RESIZE_HANDLE_DIAMETER / 2,
+        width: RESIZE_HANDLE_DIAMETER,
+        height: RESIZE_HANDLE_DIAMETER
+    };
+    const targetRectangle = {
+        x: targetPoint[0] - RESIZE_HANDLE_DIAMETER / 2,
+        y: targetPoint[1] - RESIZE_HANDLE_DIAMETER / 2,
+        width: RESIZE_HANDLE_DIAMETER,
+        height: RESIZE_HANDLE_DIAMETER
+    };
+    const isHitSourceRectangle = RectangleClient.isHit(RectangleClient.toRectangleClient([point, point]), sourceRectangle);
+    const isHitTargetRectangle = RectangleClient.isHit(RectangleClient.toRectangleClient([point, point]), targetRectangle);
+    if (isHitSourceRectangle) {
+        return { rectangle: sourceRectangle, handle: LineResizeHandle.source };
+    }
+    if (isHitTargetRectangle) {
+        return { rectangle: targetRectangle, handle: LineResizeHandle.target };
+    }
+    return undefined;
+};
+//# sourceMappingURL=data:application/json;base64,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