@plait/draw 0.1.0-next.10

package/esm2020/utils/line.mjs

@@ -0,0 +1,169 @@
+import { idCreator, distanceBetweenPointAndSegments, createG, getElementById, RectangleClient, findElements, drawLinearPath, createMask, createRect, ACTIVE_STROKE_WIDTH } from '@plait/core';
+import { getPoints, Direction, getRectangleByPoints, getDirectionByPoint, getPointOnPolyline, getDirectionFactor } from '@plait/common';
+import { LineMarkerType, LineShape, PlaitDrawElement, PlaitLine } from '../interfaces';
+import { getPointsByCenterPoint, getNearestPoint } from './geometry';
+import { getLineDashByElement, getStrokeColorByElement, getStrokeWidthByElement } from './style/stroke';
+import { getEngine } from './engine';
+import { drawLineArrow } from './line-arrow';
+export const createLineElement = (shape, points, source, target, options) => {
+    return {
+        id: idCreator(),
+        type: 'line',
+        shape,
+        source,
+        texts: [],
+        target,
+        opacity: 1,
+        points,
+        ...options
+    };
+};
+export const getLinePoints = (board, element) => {
+    return element.shape === LineShape.elbow ? getElbowPoints(board, element) : getStraightPoints(board, element);
+};
+export const getStraightPoints = (board, element) => {
+    return [getSourcePoint(board, element), getTargetPoint(board, element)];
+};
+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 drawLine = (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 = getLinePoints(board, element);
+    const line = drawLinearPath(points, options);
+    const id = idCreator();
+    line.setAttribute('mask', `url(#${id})`);
+    lineG.appendChild(line);
+    const { mask, maskTargetFillRect } = drawMask(board, element, id);
+    lineG.appendChild(mask);
+    line.appendChild(maskTargetFillRect);
+    const arrow = drawLineArrow(element, points, { stroke: strokeColor, strokeWidth });
+    arrow && lineG.appendChild(arrow);
+    return lineG;
+};
+function drawMask(board, element, id) {
+    const mask = createMask();
+    mask.setAttribute('id', id);
+    const points = getLinePoints(board, element);
+    let rectangle = getRectangleByPoints(points);
+    rectangle = RectangleClient.getOutlineRectangle(rectangle, -30);
+    const maskFillRect = createRect(rectangle, {
+        fill: 'white'
+    });
+    mask.appendChild(maskFillRect);
+    const texts = element.texts;
+    texts.forEach((text, index) => {
+        const textRectangle = getLineTextRectangle(board, element, index);
+        const rect = createRect(textRectangle, {
+            fill: 'black'
+        });
+        mask.appendChild(rect);
+    });
+    //撑开 line
+    const maskTargetFillRect = createRect(rectangle);
+    maskTargetFillRect.setAttribute('opacity', '0');
+    return { mask, maskTargetFillRect };
+}
+export const getSourcePoint = (board, element) => {
+    if (element.source.boundId) {
+        const strokeWidth = getStrokeWidthByElement(element);
+        const connectionOffset = PlaitLine.isSourceMark(element, LineMarkerType.none) ? 0 : strokeWidth;
+        const boundElement = getElementById(board, element.source.boundId);
+        return boundElement ? getConnectionPoint(boundElement, element.source.connection, connectionOffset) : element.points[0];
+    }
+    return element.points[0];
+};
+export const getTargetPoint = (board, element) => {
+    if (element.target.boundId) {
+        const strokeWidth = getStrokeWidthByElement(element);
+        const connectionOffset = PlaitLine.isTargetMark(element, LineMarkerType.none) ? 0 : strokeWidth;
+        const boundElement = getElementById(board, element.target.boundId);
+        return boundElement
+            ? getConnectionPoint(boundElement, element.target.connection, connectionOffset)
+            : element.points[element.points.length - 1];
+    }
+    return element.points[element.points.length - 1];
+};
+export const getConnectionPoint = (geometry, connection, offset) => {
+    const rectangle = getRectangleByPoints(geometry.points);
+    const directionFactor = getDirectionFactor(getDirectionByPoint(connection, Direction.bottom));
+    return [
+        rectangle.x + rectangle.width * connection[0] + directionFactor.x * offset,
+        rectangle.y + rectangle.height * connection[1] + directionFactor.y * offset
+    ];
+};
+export const transformPointToConnection = (board, point, hitElement) => {
+    let rectangle = getRectangleByPoints(hitElement.points);
+    rectangle = RectangleClient.inflate(rectangle, ACTIVE_STROKE_WIDTH);
+    let nearestPoint = getNearestPoint(hitElement, point, ACTIVE_STROKE_WIDTH);
+    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 = getLinePoints(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
+    };
+};
+export const getBoardLines = (board) => {
+    return findElements(board, {
+        match: (element) => PlaitDrawElement.isLine(element),
+        recursion: (element) => PlaitDrawElement.isDrawElement(element)
+    });
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"line.js","sourceRoot":"","sources":["../../../../packages/draw/src/utils/line.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Point,\n    idCreator,\n    distanceBetweenPointAndSegments,\n    PlaitBoard,\n    createG,\n    getElementById,\n    RectangleClient,\n    findElements,\n    PlaitElement,\n    drawLinearPath,\n    createMask,\n    createRect,\n    ACTIVE_STROKE_WIDTH\n} from '@plait/core';\nimport { getPoints, Direction, getRectangleByPoints, getDirectionByPoint, getPointOnPolyline, getDirectionFactor } from '@plait/common';\nimport { LineHandle, LineMarkerType, LineShape, PlaitDrawElement, PlaitGeometry, PlaitLine } from '../interfaces';\nimport { getPointsByCenterPoint, getNearestPoint } from './geometry';\nimport { getLineDashByElement, getStrokeColorByElement, getStrokeWidthByElement } from './style/stroke';\nimport { getEngine } from './engine';\nimport { drawLineArrow } from './line-arrow';\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 getLinePoints = (board: PlaitBoard, element: PlaitLine) => {\n    return element.shape === LineShape.elbow ? getElbowPoints(board, element) : getStraightPoints(board, element);\n};\n\nexport const getStraightPoints = (board: PlaitBoard, element: PlaitLine) => {\n    return [getSourcePoint(board, element), getTargetPoint(board, element)];\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 drawLine = (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 = getLinePoints(board, element);\n    const line = drawLinearPath(points, options);\n    const id = idCreator();\n    line.setAttribute('mask', `url(#${id})`);\n    lineG.appendChild(line);\n    const { mask, maskTargetFillRect } = drawMask(board, element, id);\n    lineG.appendChild(mask);\n    line.appendChild(maskTargetFillRect);\n    const arrow = drawLineArrow(element, points, { stroke: strokeColor, strokeWidth });\n    arrow && lineG.appendChild(arrow);\n    return lineG;\n};\n\nfunction drawMask(board: PlaitBoard, element: PlaitLine, id: string) {\n    const mask = createMask();\n    mask.setAttribute('id', id);\n    const points = getLinePoints(board, element);\n    let rectangle = getRectangleByPoints(points);\n    rectangle = RectangleClient.getOutlineRectangle(rectangle, -30);\n    const maskFillRect = createRect(rectangle, {\n        fill: 'white'\n    });\n    mask.appendChild(maskFillRect);\n\n    const texts = element.texts;\n    texts.forEach((text, index) => {\n        const textRectangle = getLineTextRectangle(board, element, index);\n        const rect = createRect(textRectangle, {\n            fill: 'black'\n        });\n        mask.appendChild(rect);\n    });\n    //撑开 line\n    const maskTargetFillRect = createRect(rectangle);\n    maskTargetFillRect.setAttribute('opacity', '0');\n    return { mask, maskTargetFillRect };\n}\n\nexport const getSourcePoint = (board: PlaitBoard, element: PlaitLine) => {\n    if (element.source.boundId) {\n        const strokeWidth = getStrokeWidthByElement(element);\n        const connectionOffset = PlaitLine.isSourceMark(element, LineMarkerType.none) ? 0 : strokeWidth;\n        const boundElement = getElementById<PlaitGeometry>(board, element.source.boundId);\n        return boundElement ? getConnectionPoint(boundElement, element.source.connection!, connectionOffset) : 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 strokeWidth = getStrokeWidthByElement(element);\n        const connectionOffset = PlaitLine.isTargetMark(element, LineMarkerType.none) ? 0 : strokeWidth;\n        const boundElement = getElementById<PlaitGeometry>(board, element.target.boundId);\n        return boundElement\n            ? getConnectionPoint(boundElement, element.target.connection!, connectionOffset)\n            : element.points[element.points.length - 1];\n    }\n    return element.points[element.points.length - 1];\n};\n\nexport const getConnectionPoint = (geometry: PlaitGeometry, connection: Point, offset: number): Point => {\n    const rectangle = getRectangleByPoints(geometry.points);\n    const directionFactor = getDirectionFactor(getDirectionByPoint(connection, Direction.bottom));\n    return [\n        rectangle.x + rectangle.width * connection[0] + directionFactor.x * offset,\n        rectangle.y + rectangle.height * connection[1] + directionFactor.y * offset\n    ];\n};\n\nexport const transformPointToConnection = (board: PlaitBoard, point: Point, hitElement: PlaitGeometry): Point => {\n    let rectangle = getRectangleByPoints(hitElement.points);\n    rectangle = RectangleClient.inflate(rectangle, ACTIVE_STROKE_WIDTH);\n    let nearestPoint = getNearestPoint(hitElement, point, ACTIVE_STROKE_WIDTH);\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 = getLinePoints(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\nexport const getBoardLines = (board: PlaitBoard) => {\n    return findElements(board, {\n        match: (element: PlaitElement) => PlaitDrawElement.isLine(element),\n        recursion: (element: PlaitElement) => PlaitDrawElement.isDrawElement(element)\n    }) as PlaitLine[];\n};\n"]}

package/esm2020/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/esm2020/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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

package/esm2020/utils/selected.mjs

@@ -0,0 +1,15 @@
+import { getSelectedElements } from '@plait/core';
+import { PlaitDrawElement } from '../interfaces';
+export const getSelectedDrawElements = (board) => {
+    const selectedElements = getSelectedElements(board).filter(value => PlaitDrawElement.isDrawElement(value));
+    return selectedElements;
+};
+export const getSelectedGeometryElements = (board) => {
+    const selectedElements = getSelectedElements(board).filter(value => PlaitDrawElement.isGeometry(value));
+    return selectedElements;
+};
+export const getSelectedLineElements = (board) => {
+    const selectedElements = getSelectedElements(board).filter(value => PlaitDrawElement.isLine(value));
+    return selectedElements;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/style/index.mjs

@@ -0,0 +1,2 @@
+export * from './stroke';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kcmF3L3NyYy91dGlscy9zdHlsZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFVBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc3Ryb2tlJztcbiJdfQ==

package/esm2020/utils/style/stroke.mjs

@@ -0,0 +1,24 @@
+import { PlaitDrawElement, StrokeStyle } from '../../interfaces';
+import { DefaultGeometryStyle } from '../../constants';
+export const getStrokeWidthByElement = (element) => {
+    if (PlaitDrawElement.isText(element)) {
+        return 0;
+    }
+    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;
+};
+export const getStrokeStyleByElement = (element) => {
+    return element.strokeStyle || StrokeStyle.solid;
+};
+//# sourceMappingURL=data:application/json;base64,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