@plait/common 0.51.2 → 0.51.4

package/esm2022/utils/resize.mjs

@@ -105,4 +105,4 @@ export const isEdgeHandle = (board, handle) => {
 export const isCornerHandle = (board, handle) => {
     return !isEdgeHandle(board, handle);
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resize.js","sourceRoot":"","sources":["../../../../packages/common/src/utils/resize.ts"],"names":[],"mappings":"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","sourcesContent":["import { PlaitBoard, Point, RectangleClient, ResizeCursorClass, setDragging } from '@plait/core';\nimport { ResizeHandle } from '../constants/resize';\nimport { PlaitElementOrArray, ResizeRef } from '../types/resize';\n\nexport const getResizeHandleByIndex = (index: number) => {\n    return `${index}` as ResizeHandle;\n};\n\nexport const getIndexByResizeHandle = (resizeHandle: ResizeHandle) => {\n    return Number(resizeHandle);\n};\n\nexport const getSymmetricHandleIndex = (board: PlaitBoard, index: number) => {\n    const originIndex = isEdgeHandle(board, getResizeHandleByIndex(index)) ? index - 4 : index;\n    let originSymmetricHandleIndex = originIndex + 2;\n    if (originSymmetricHandleIndex >= 4) {\n        originSymmetricHandleIndex = originSymmetricHandleIndex - 4;\n    }\n    return isEdgeHandle(board, getResizeHandleByIndex(index)) ? originSymmetricHandleIndex + 4 : originSymmetricHandleIndex;\n};\n\nconst getResizeCursorClassByIndex = (index: number) => {\n    switch (index) {\n        case 0:\n        case 2:\n            return ResizeCursorClass.nwse;\n        case 1:\n        case 3:\n            return ResizeCursorClass.nesw;\n        case 4:\n        case 6:\n            return ResizeCursorClass.ns;\n        case 5:\n        case 7:\n            return ResizeCursorClass.ew;\n        default:\n            return null;\n    }\n};\n\nexport const getRectangleResizeHandleRefs = (rectangle: RectangleClient, diameter: number) => {\n    const corners = RectangleClient.getCornerPoints(rectangle);\n    const refs = corners.map((corner, index: number) => {\n        return {\n            rectangle: {\n                x: corner[0] - diameter / 2,\n                y: corner[1] - diameter / 2,\n                width: diameter,\n                height: diameter\n            },\n            handle: getResizeHandleByIndex(index) as ResizeHandle,\n            cursorClass: getResizeCursorClassByIndex(index) as ResizeCursorClass\n        };\n    });\n    const rectangles = getResizeSideRectangles(corners, diameter / 2);\n    refs.push(\n        ...rectangles.map((rectangle, index) => {\n            return {\n                rectangle,\n                handle: getResizeHandleByIndex(index + 4) as ResizeHandle,\n                cursorClass: getResizeCursorClassByIndex(index + 4) as ResizeCursorClass\n            };\n        })\n    );\n    return refs;\n};\n\nexport const getResizeHandlePointByIndex = (rectangle: RectangleClient, index: number) => {\n    if (index <= 3) {\n        const corners = RectangleClient.getCornerPoints(rectangle);\n        return corners[index];\n    } else {\n        const edgeCenterPoints = RectangleClient.getEdgeCenterPoints(rectangle);\n        return edgeCenterPoints[index - 4];\n    }\n};\n\nconst getResizeSideRectangles = (cornerPoints: Point[], offset: number): RectangleClient[] => {\n    const result = [];\n    for (let i = 0; i < cornerPoints.length; i++) {\n        let rectangle = RectangleClient.getRectangleByPoints([cornerPoints[i], cornerPoints[(i + 1) % 4]]);\n        const arr = new Array(2).fill(0);\n        arr[(i + 1) % 2] = offset / 2;\n        rectangle = RectangleClient.expand(rectangle, arr[0], arr[1]);\n        result.push(rectangle);\n    }\n    return result;\n};\n\nexport const IS_RESIZING = new WeakMap<PlaitBoard, ResizeRef<any, any>>();\n\nexport const isResizing = (board: PlaitBoard) => {\n    return !!IS_RESIZING.get(board);\n};\n\nexport const isResizingByCondition = <T extends PlaitElementOrArray, K>(board: PlaitBoard, match: (resizeRef: ResizeRef<T, K>) => boolean) => {\n    return isResizing(board) && match(IS_RESIZING.get(board)!);\n};\n\nexport const addResizing = <T extends PlaitElementOrArray, K>(board: PlaitBoard, resizeRef: ResizeRef<T, K>, key: string) => {\n    PlaitBoard.getBoardContainer(board).classList.add(`${key}-resizing`);\n    IS_RESIZING.set(board, resizeRef);\n    setDragging(board, true);\n};\n\nexport const removeResizing = (board: PlaitBoard, key: string) => {\n    PlaitBoard.getBoardContainer(board).classList.remove(`${key}-resizing`);\n    IS_RESIZING.delete(board);\n    setDragging(board, false);\n};\n\nexport const isEdgeHandle = (board: PlaitBoard, handle: ResizeHandle) => {\n    const index = getIndexByResizeHandle(handle);\n    if (index >= 4) {\n        return true;\n    } else {\n        return false;\n    }\n};\n\nexport const isCornerHandle = (board: PlaitBoard, handle: ResizeHandle) => {\n    return !isEdgeHandle(board, handle);\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resize.js","sourceRoot":"","sources":["../../../../packages/common/src/utils/resize.ts"],"names":[],"mappings":"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","sourcesContent":["import { PlaitBoard, Point, RectangleClient, ResizeCursorClass, setDragging } from '@plait/core';\nimport { ResizeHandle } from '../constants/resize';\nimport { PlaitElementOrArray, ResizeRef } from '../types/resize';\n\nexport const getResizeHandleByIndex = (index: number) => {\n    return `${index}` as ResizeHandle;\n};\n\nexport const getIndexByResizeHandle = (resizeHandle: ResizeHandle) => {\n    return Number(resizeHandle);\n};\n\nexport const getSymmetricHandleIndex = (board: PlaitBoard, index: number) => {\n    const originIndex = isEdgeHandle(board, getResizeHandleByIndex(index)) ? index - 4 : index;\n    let originSymmetricHandleIndex = originIndex + 2;\n    if (originSymmetricHandleIndex >= 4) {\n        originSymmetricHandleIndex = originSymmetricHandleIndex - 4;\n    }\n    return isEdgeHandle(board, getResizeHandleByIndex(index)) ? originSymmetricHandleIndex + 4 : originSymmetricHandleIndex;\n};\n\nconst getResizeCursorClassByIndex = (index: number) => {\n    switch (index) {\n        case 0:\n        case 2:\n            return ResizeCursorClass.nwse;\n        case 1:\n        case 3:\n            return ResizeCursorClass.nesw;\n        case 4:\n        case 6:\n            return ResizeCursorClass.ns;\n        case 5:\n        case 7:\n            return ResizeCursorClass.ew;\n        default:\n            return null;\n    }\n};\n\nexport const getRectangleResizeHandleRefs = (rectangle: RectangleClient, diameter: number) => {\n    const corners = RectangleClient.getCornerPoints(rectangle);\n    const refs = corners.map((corner, index: number) => {\n        return {\n            rectangle: {\n                x: corner[0] - diameter / 2,\n                y: corner[1] - diameter / 2,\n                width: diameter,\n                height: diameter\n            },\n            handle: getResizeHandleByIndex(index) as ResizeHandle,\n            cursorClass: getResizeCursorClassByIndex(index) as ResizeCursorClass\n        };\n    });\n    const rectangles = getResizeSideRectangles(corners, diameter / 2);\n    refs.push(\n        ...rectangles.map((rectangle, index) => {\n            return {\n                rectangle,\n                handle: getResizeHandleByIndex(index + 4) as ResizeHandle,\n                cursorClass: getResizeCursorClassByIndex(index + 4) as ResizeCursorClass\n            };\n        })\n    );\n    return refs;\n};\n\nexport const getResizeHandlePointByIndex = (rectangle: RectangleClient, index: number) => {\n    if (index <= 3) {\n        const corners = RectangleClient.getCornerPoints(rectangle);\n        return corners[index];\n    } else {\n        const edgeCenterPoints = RectangleClient.getEdgeCenterPoints(rectangle);\n        return edgeCenterPoints[index - 4];\n    }\n};\n\nconst getResizeSideRectangles = (cornerPoints: Point[], offset: number): RectangleClient[] => {\n    const result = [];\n    for (let i = 0; i < cornerPoints.length; i++) {\n        let rectangle = RectangleClient.getRectangleByPoints([cornerPoints[i], cornerPoints[(i + 1) % 4]]);\n        const arr = new Array(2).fill(0);\n        arr[(i + 1) % 2] = offset / 2;\n        rectangle = RectangleClient.expand(rectangle, arr[0], arr[1]);\n        result.push(rectangle);\n    }\n    return result;\n};\n\nexport const IS_RESIZING = new WeakMap<PlaitBoard, ResizeRef<any, any>>();\n\nexport const isResizing = (board: PlaitBoard) => {\n    return !!IS_RESIZING.get(board);\n};\n\nexport const isResizingByCondition = <T extends PlaitElementOrArray, K>(board: PlaitBoard, match: (resizeRef: ResizeRef<T, K>) => boolean) => {\n    return isResizing(board) && match(IS_RESIZING.get(board)!);\n};\n\nexport const addResizing = <T extends PlaitElementOrArray, K>(board: PlaitBoard, resizeRef: ResizeRef<T, K>, key: string) => {\n    PlaitBoard.getBoardContainer(board).classList.add(`${key}-resizing`);\n    IS_RESIZING.set(board, resizeRef);\n    setDragging(board, true);\n};\n\nexport const removeResizing = (board: PlaitBoard, key: string) => {\n    PlaitBoard.getBoardContainer(board).classList.remove(`${key}-resizing`);\n    IS_RESIZING.delete(board);\n    setDragging(board, false);\n};\n\nexport const isEdgeHandle = (board: PlaitBoard, handle: ResizeHandle) => {\n    const index = getIndexByResizeHandle(handle);\n    if (index >= 4) {\n        return true;\n    } else {\n        return false;\n    }\n};\n\nexport const isCornerHandle = (board: PlaitBoard, handle: ResizeHandle) => {\n    return !isEdgeHandle(board, handle);\n};\n"]}

package/esm2022/utils/text.mjs

@@ -60,4 +60,4 @@ export const getElementsText = (elements) => {
         .filter(item => item)
         .join(' ');
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/vector.mjs

@@ -11,16 +11,16 @@ export function getUnitVectorByPointAndPoint(point1, point2) {
     const unitY = deltaY / distance;
     return [unitX, unitY];
 }
-export function getPointByVector(point, vector, component) {
+export function getPointByVectorComponent(point, vector, component) {
     const distance = Math.hypot(vector[0], vector[1]);
     return [point[0] + (vector[0] / distance) * component, point[1] + (vector[1] / distance) * component];
 }
-export function getPointByUnitVectorAndVectorComponent(point, unitVector, vectorComponent, isHorizontal) {
+export function getPointByVectorDirectionComponent(point, unitVector, directionComponent, isHorizontal) {
     if (isHorizontal) {
-        return [point[0] + vectorComponent, point[1] + (vectorComponent / unitVector[0]) * unitVector[1]];
+        return [point[0] + directionComponent, point[1] + (directionComponent / unitVector[0]) * unitVector[1]];
     }
     else {
-        return [point[0] + (vectorComponent / unitVector[1]) * unitVector[0], point[1] + vectorComponent];
+        return [point[0] + (directionComponent / unitVector[1]) * unitVector[0], point[1] + directionComponent];
     }
 }
 export function rotateVectorAnti90(vector) {
@@ -30,4 +30,4 @@ export function rotateVectorAnti90(vector) {
     const rotatedY = -x;
     return [rotatedX, rotatedY];
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2022/plait-common.mjs

@@ -1,4 +1,4 @@
-import { setTransformRotate, drawCircle, PlaitBoard, createG, RectangleClient, drawRectangle, createForeignObject, updateForeignObject, ResizeCursorClass, setDragging, Direction, distanceBetweenPointAndPoint, Point, hotkeys, PlaitElement, PlaitContextService, getSelectedElements, Transforms, getRectangleByElements, MERGING, PlaitPointerType, isMainPointer, toViewBoxPoint, toHostPoint, preventTouchMove, PRESS_AND_MOVE_BUFFER, isDragging, throttleRAF, handleTouchTarget, PlaitPluginElementComponent, isSelectionMoving, ACTIVE_STROKE_WIDTH } from '@plait/core';
+import { setAngleForG, RectangleClient, drawCircle, PlaitBoard, createG, drawRectangle, createForeignObject, updateForeignObject, ResizeCursorClass, setDragging, distanceBetweenPointAndPoint, Point, Direction, hotkeys, PlaitElement, PlaitContextService, getSelectedElements, Transforms, getRectangleByElements, MERGING, PlaitPointerType, isMainPointer, toViewBoxPoint, toHostPoint, preventTouchMove, PRESS_AND_MOVE_BUFFER, isDragging, throttleRAF, handleTouchTarget, PlaitPluginElementComponent, isSelectionMoving, ACTIVE_STROKE_WIDTH } from '@plait/core';
 import { isKeyHotkey } from 'is-hotkey';
 import { PlaitMarkEditor, MarkTypes, AlignEditor } from '@plait/text';
 import { Node, Transforms as Transforms$1, Editor } from 'slate';
@@ -55,7 +55,7 @@ class Generator {
                 this.g = g;
                 const rect = this.board.getRectangle(element);
                 if (rect && element.angle) {
-                    setTransformRotate(g, rect, element.angle);
+                    setAngleForG(g, RectangleClient.getCenterPoint(rect), element.angle);
                 }
             }
             else {
@@ -303,12 +303,157 @@ const isCornerHandle = (board, handle) => {
     return !isEdgeHandle(board, handle);
 };
 
+function getUnitVectorByPointAndPoint(point1, point2) {
+    const deltaX = point2[0] - point1[0];
+    const deltaY = point2[1] - point1[1];
+    const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+    // Avoid division by zero if the points are the same
+    if (distance === 0) {
+        throw new Error('Points must not be the same for a unit vector calculation.');
+    }
+    // Calculate the unit vector components
+    const unitX = deltaX / distance;
+    const unitY = deltaY / distance;
+    return [unitX, unitY];
+}
+function getPointByVectorComponent(point, vector, component) {
+    const distance = Math.hypot(vector[0], vector[1]);
+    return [point[0] + (vector[0] / distance) * component, point[1] + (vector[1] / distance) * component];
+}
+function getPointByVectorDirectionComponent(point, unitVector, directionComponent, isHorizontal) {
+    if (isHorizontal) {
+        return [point[0] + directionComponent, point[1] + (directionComponent / unitVector[0]) * unitVector[1]];
+    }
+    else {
+        return [point[0] + (directionComponent / unitVector[1]) * unitVector[0], point[1] + directionComponent];
+    }
+}
+function rotateVectorAnti90(vector) {
+    const x = vector[0];
+    const y = vector[1];
+    const rotatedX = y;
+    const rotatedY = -x;
+    return [rotatedX, rotatedY];
+}
+
+function isPointOnSegment(point, startPoint, endPoint) {
+    const distanceToStart = distanceBetweenPointAndPoint(point[0], point[1], startPoint[0], startPoint[1]);
+    const distanceToEnd = distanceBetweenPointAndPoint(point[0], point[1], endPoint[0], endPoint[1]);
+    const segmentLength = distanceBetweenPointAndPoint(startPoint[0], startPoint[1], endPoint[0], endPoint[1]);
+    return Math.abs(distanceToStart + distanceToEnd - segmentLength) < 0.1;
+}
+const getCrossingPointsBetweenPointAndSegment = (point, startPoint, endPoint) => {
+    const result = [];
+    const xRange = [Math.min(startPoint[0], endPoint[0]), Math.max(startPoint[0], endPoint[0])];
+    const yRange = [Math.min(startPoint[1], endPoint[1]), Math.max(startPoint[1], endPoint[1])];
+    const unitVector = getUnitVectorByPointAndPoint(startPoint, endPoint);
+    if (point[0] >= xRange[0] && point[0] <= xRange[1]) {
+        const crossingPoint = getPointByVectorDirectionComponent(startPoint, unitVector, point[0] - startPoint[0], true);
+        result.push(crossingPoint);
+    }
+    else if (point[1] >= yRange[0] && point[1] <= yRange[1]) {
+        const crossingPoint = getPointByVectorDirectionComponent(startPoint, unitVector, point[1] - startPoint[1], false);
+        result.push(crossingPoint);
+    }
+    return result;
+};
+
+function getPointOnPolyline(points, ratio) {
+    const totalLength = calculatePolylineLength(points);
+    const targetDistance = totalLength * ratio;
+    let accumulatedDistance = 0;
+    for (let i = 0; i < points.length - 1; i++) {
+        const [x1, y1] = points[i];
+        const [x2, y2] = points[i + 1];
+        const segmentLength = distanceBetweenPointAndPoint(x1, y1, x2, y2);
+        if (accumulatedDistance + segmentLength >= targetDistance) {
+            const remainingDistance = targetDistance - accumulatedDistance;
+            const ratioInSegment = remainingDistance / segmentLength;
+            const targetX = x1 + (x2 - x1) * ratioInSegment;
+            const targetY = y1 + (y2 - y1) * ratioInSegment;
+            return [targetX, targetY];
+        }
+        accumulatedDistance += segmentLength;
+    }
+    return points[points.length - 1];
+}
+function calculatePolylineLength(points) {
+    let length = 0;
+    for (let i = 0; i < points.length - 1; i++) {
+        const [x1, y1] = points[i];
+        const [x2, y2] = points[i + 1];
+        length += distanceBetweenPointAndPoint(x1, y1, x2, y2);
+    }
+    return length;
+}
+function getRatioByPoint(points, point) {
+    const totalLength = calculatePolylineLength(points);
+    let distance = 0;
+    for (let i = 0; i < points.length - 1; i++) {
+        const isOverlap = isPointOnSegment(point, points[i], points[i + 1]);
+        if (isOverlap) {
+            distance += distanceBetweenPointAndPoint(point[0], point[1], points[i][0], points[i][1]);
+            return distance / totalLength;
+        }
+        else {
+            distance += distanceBetweenPointAndPoint(points[i][0], points[i][1], points[i + 1][0], points[i + 1][1]);
+        }
+    }
+    throw new Error('Cannot get ratio by point');
+}
+const removeDuplicatePoints = (points) => {
+    const newArray = [];
+    points.forEach(point => {
+        const index = newArray.findIndex(otherPoint => {
+            return Point.isEquals(point, otherPoint);
+        });
+        if (index === -1)
+            newArray.push(point);
+    });
+    return newArray;
+};
+function simplifyOrthogonalPoints(points) {
+    if (points.length <= 2)
+        return points;
+    let simplifiedPoints = [points[0]];
+    for (let i = 1; i < points.length - 1; i++) {
+        const previous = points[i - 1];
+        const current = points[i];
+        const next = points[i + 1];
+        const isTurn = !(Point.isOverHorizontal([previous, current, next]) || Point.isOverVertical([previous, current, next]));
+        if (isTurn) {
+            simplifiedPoints.push(current);
+        }
+    }
+    simplifiedPoints.push(points[points.length - 1]);
+    return simplifiedPoints;
+}
+const getExtendPoint = (source, target, extendDistance) => {
+    const distance = distanceBetweenPointAndPoint(...source, ...target);
+    const isEqual = Point.isEquals(source, target);
+    const sin = isEqual ? 1 : (target[1] - source[1]) / distance;
+    const cos = isEqual ? 1 : (target[0] - source[0]) / distance;
+    return [source[0] + extendDistance * cos, source[1] + extendDistance * sin];
+};
+
 const handleDirectionFactors = {
     [Direction.left]: { x: -1, y: 0 },
     [Direction.right]: { x: 1, y: 0 },
     [Direction.top]: { x: 0, y: -1 },
     [Direction.bottom]: { x: 0, y: 1 }
 };
+function getOppositeDirection(direction) {
+    switch (direction) {
+        case Direction.left:
+            return Direction.right;
+        case Direction.right:
+            return Direction.left;
+        case Direction.top:
+            return Direction.bottom;
+        case Direction.bottom:
+            return Direction.top;
+    }
+}
 function getDirectionByPointOfRectangle(point) {
     if (point[0] === 0) {
         return Direction.left;
@@ -378,83 +523,18 @@ function getDirectionBetweenPointAndPoint(source, target) {
 function getDirectionFactor(direction) {
     return handleDirectionFactors[direction];
 }
-function getDirectionFactorByVectorComponent(vectorComponent) {
-    const directionFactor = vectorComponent === 0 ? vectorComponent : vectorComponent / Math.abs(vectorComponent);
+function getDirectionFactorByDirectionComponent(directionComponent) {
+    const directionFactor = directionComponent === 0 ? directionComponent : directionComponent / Math.abs(directionComponent);
     return directionFactor;
 }
 
-function getUnitVectorByPointAndPoint(point1, point2) {
-    const deltaX = point2[0] - point1[0];
-    const deltaY = point2[1] - point1[1];
-    const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
-    // Avoid division by zero if the points are the same
-    if (distance === 0) {
-        throw new Error('Points must not be the same for a unit vector calculation.');
-    }
-    // Calculate the unit vector components
-    const unitX = deltaX / distance;
-    const unitY = deltaY / distance;
-    return [unitX, unitY];
-}
-function getPointByVector(point, vector, component) {
-    const distance = Math.hypot(vector[0], vector[1]);
-    return [point[0] + (vector[0] / distance) * component, point[1] + (vector[1] / distance) * component];
-}
-function getPointByUnitVectorAndVectorComponent(point, unitVector, vectorComponent, isHorizontal) {
-    if (isHorizontal) {
-        return [point[0] + vectorComponent, point[1] + (vectorComponent / unitVector[0]) * unitVector[1]];
-    }
-    else {
-        return [point[0] + (vectorComponent / unitVector[1]) * unitVector[0], point[1] + vectorComponent];
-    }
-}
-function rotateVectorAnti90(vector) {
-    const x = vector[0];
-    const y = vector[1];
-    const rotatedX = y;
-    const rotatedY = -x;
-    return [rotatedX, rotatedY];
-}
-
-function isPointOnSegment(point, startPoint, endPoint) {
-    const distanceToStart = distanceBetweenPointAndPoint(point[0], point[1], startPoint[0], startPoint[1]);
-    const distanceToEnd = distanceBetweenPointAndPoint(point[0], point[1], endPoint[0], endPoint[1]);
-    const segmentLength = distanceBetweenPointAndPoint(startPoint[0], startPoint[1], endPoint[0], endPoint[1]);
-    return Math.abs(distanceToStart + distanceToEnd - segmentLength) < 0.1;
-}
-const getCrossingPointsBetweenPointAndSegment = (point, startPoint, endPoint) => {
-    const result = [];
-    const xRange = [Math.min(startPoint[0], endPoint[0]), Math.max(startPoint[0], endPoint[0])];
-    const yRange = [Math.min(startPoint[1], endPoint[1]), Math.max(startPoint[1], endPoint[1])];
-    const unitVector = getUnitVectorByPointAndPoint(startPoint, endPoint);
-    if (point[0] >= xRange[0] && point[0] <= xRange[1]) {
-        const crossingPoint = getPointByUnitVectorAndVectorComponent(startPoint, unitVector, point[0] - startPoint[0], true);
-        result.push(crossingPoint);
-    }
-    else if (point[1] >= yRange[0] && point[1] <= yRange[1]) {
-        const crossingPoint = getPointByUnitVectorAndVectorComponent(startPoint, unitVector, point[1] - startPoint[1], false);
-        result.push(crossingPoint);
-    }
-    return result;
-};
-
-function getOppositeDirection(direction) {
-    switch (direction) {
-        case Direction.left:
-            return Direction.right;
-        case Direction.right:
-            return Direction.left;
-        case Direction.top:
-            return Direction.bottom;
-        case Direction.bottom:
-            return Direction.top;
-    }
-}
+// Credits to xyflow
+// https://github.com/xyflow/xyflow/blob/main/packages/system/src/utils/edges/smoothstep-edge.ts
 const getPoints = (source, sourcePosition, target, targetPosition, offset) => {
-    const sourceDir = getDirectionFactor(sourcePosition);
-    const targetDir = getDirectionFactor(targetPosition);
-    const sourceGapped = [source[0] + sourceDir.x * offset, source[1] + sourceDir.y * offset];
-    const targetGapped = [target[0] + targetDir.x * offset, target[1] + targetDir.y * offset];
+    const sourceDirectionFactors = getDirectionFactor(sourcePosition);
+    const targetDFs = getDirectionFactor(targetPosition);
+    const sourceGapped = [source[0] + sourceDirectionFactors.x * offset, source[1] + sourceDirectionFactors.y * offset];
+    const targetGapped = [target[0] + targetDFs.x * offset, target[1] + targetDFs.y * offset];
     const dir = getDirection(sourceGapped, sourcePosition, targetGapped);
     const dirAccessor = dir.x !== 0 ? 'x' : 'y';
     const currDir = dir[dirAccessor];
@@ -467,7 +547,7 @@ const getPoints = (source, sourcePosition, target, targetPosition, offset) => {
         targetY: target[1]
     });
     // opposite handle positions, default case
-    if (sourceDir[dirAccessor] * targetDir[dirAccessor] === -1) {
+    if (sourceDirectionFactors[dirAccessor] * targetDFs[dirAccessor] === -1) {
         centerX = defaultCenterX;
         centerY = defaultCenterY;
         //    --->
@@ -484,7 +564,7 @@ const getPoints = (source, sourcePosition, target, targetPosition, offset) => {
             [sourceGapped[0], centerY],
             [targetGapped[0], centerY]
         ];
-        if (sourceDir[dirAccessor] === currDir) {
+        if (sourceDirectionFactors[dirAccessor] === currDir) {
             points = dirAccessor === 'x' ? verticalSplit : horizontalSplit;
         }
         else {
@@ -497,21 +577,21 @@ const getPoints = (source, sourcePosition, target, targetPosition, offset) => {
         const targetSource = [[targetGapped[0], sourceGapped[1]]];
         // this handles edges with same handle positions
         if (dirAccessor === 'x') {
-            points = sourceDir.x === currDir ? targetSource : sourceTarget;
+            points = sourceDirectionFactors.x === currDir ? targetSource : sourceTarget;
         }
         else {
-            points = sourceDir.y === currDir ? sourceTarget : targetSource;
+            points = sourceDirectionFactors.y === currDir ? sourceTarget : targetSource;
         }
         // these are conditions for handling mixed handle positions like right -> bottom for example
         let flipSourceTarget;
         if (sourcePosition !== targetPosition) {
             const dirAccessorOpposite = dirAccessor === 'x' ? 1 : 0;
-            const isSameDir = sourceDir[dirAccessor] === targetDir[dirAccessor === 'x' ? 'y' : 'x'];
+            const isSameDir = sourceDirectionFactors[dirAccessor] === targetDFs[dirAccessor === 'x' ? 'y' : 'x'];
             const sourceGtTarget = sourceGapped[dirAccessorOpposite] > targetGapped[dirAccessorOpposite];
             const sourceLtTarget = sourceGapped[dirAccessorOpposite] < targetGapped[dirAccessorOpposite];
             flipSourceTarget =
-                (sourceDir[dirAccessor] === 1 && ((!isSameDir && sourceGtTarget) || (isSameDir && sourceLtTarget))) ||
-                    (sourceDir[dirAccessor] !== 1 && ((!isSameDir && sourceLtTarget) || (isSameDir && sourceGtTarget)));
+                (sourceDirectionFactors[dirAccessor] === 1 && ((!isSameDir && sourceGtTarget) || (isSameDir && sourceLtTarget))) ||
+                    (sourceDirectionFactors[dirAccessor] !== 1 && ((!isSameDir && sourceLtTarget) || (isSameDir && sourceGtTarget)));
             if (flipSourceTarget) {
                 points = dirAccessor === 'x' ? sourceTarget : targetSource;
             }
@@ -532,83 +612,6 @@ function getEdgeCenter({ sourceX, sourceY, targetX, targetY }) {
     const centerY = targetY < sourceY ? targetY + yOffset : targetY - yOffset;
     return [centerX, centerY, xOffset, yOffset];
 }
-function getPointOnPolyline(points, ratio) {
-    const totalLength = calculatePolylineLength(points);
-    const targetDistance = totalLength * ratio;
-    let accumulatedDistance = 0;
-    for (let i = 0; i < points.length - 1; i++) {
-        const [x1, y1] = points[i];
-        const [x2, y2] = points[i + 1];
-        const segmentLength = distanceBetweenPointAndPoint(x1, y1, x2, y2);
-        if (accumulatedDistance + segmentLength >= targetDistance) {
-            const remainingDistance = targetDistance - accumulatedDistance;
-            const ratioInSegment = remainingDistance / segmentLength;
-            const targetX = x1 + (x2 - x1) * ratioInSegment;
-            const targetY = y1 + (y2 - y1) * ratioInSegment;
-            return [targetX, targetY];
-        }
-        accumulatedDistance += segmentLength;
-    }
-    return points[points.length - 1];
-}
-function calculatePolylineLength(points) {
-    let length = 0;
-    for (let i = 0; i < points.length - 1; i++) {
-        const [x1, y1] = points[i];
-        const [x2, y2] = points[i + 1];
-        length += distanceBetweenPointAndPoint(x1, y1, x2, y2);
-    }
-    return length;
-}
-function getRatioByPoint(points, point) {
-    const totalLength = calculatePolylineLength(points);
-    let distance = 0;
-    for (let i = 0; i < points.length - 1; i++) {
-        const isOverlap = isPointOnSegment(point, points[i], points[i + 1]);
-        if (isOverlap) {
-            distance += distanceBetweenPointAndPoint(point[0], point[1], points[i][0], points[i][1]);
-            return distance / totalLength;
-        }
-        else {
-            distance += distanceBetweenPointAndPoint(points[i][0], points[i][1], points[i + 1][0], points[i + 1][1]);
-        }
-    }
-    throw new Error('Cannot get ratio by point');
-}
-const removeDuplicatePoints = (points) => {
-    const newArray = [];
-    points.forEach(point => {
-        const index = newArray.findIndex(otherPoint => {
-            return Point.isEquals(point, otherPoint);
-        });
-        if (index === -1)
-            newArray.push(point);
-    });
-    return newArray;
-};
-function simplifyOrthogonalPoints(points) {
-    if (points.length <= 2)
-        return points;
-    let simplifiedPoints = [points[0]];
-    for (let i = 1; i < points.length - 1; i++) {
-        const previous = points[i - 1];
-        const current = points[i];
-        const next = points[i + 1];
-        const isTurn = !(Point.isOverHorizontal([previous, current, next]) || Point.isOverVertical([previous, current, next]));
-        if (isTurn) {
-            simplifiedPoints.push(current);
-        }
-    }
-    simplifiedPoints.push(points[points.length - 1]);
-    return simplifiedPoints;
-}
-const getExtendPoint = (source, target, extendDistance) => {
-    const distance = distanceBetweenPointAndPoint(...source, ...target);
-    const isEqual = Point.isEquals(source, target);
-    const sin = isEqual ? 1 : (target[1] - source[1]) / distance;
-    const cos = isEqual ? 1 : (target[0] - source[0]) / distance;
-    return [source[0] + extendDistance * cos, source[1] + extendDistance * sin];
-};
 
 function isVirtualKey(e) {
     const isMod = e.ctrlKey || e.metaKey;
@@ -1540,7 +1543,7 @@ class ImageBaseComponent {
     drawFocus() {
         if (this.initialized) {
             const activeG = PlaitBoard.getElementActiveHost(this.board);
-            this.activeGenerator.processDrawing({}, activeG, { selected: this._isFocus });
+            this.activeGenerator.processDrawing(this.element, activeG, { selected: this._isFocus });
         }
     }
     ngOnDestroy() {
@@ -1548,17 +1551,17 @@ class ImageBaseComponent {
             this.activeGenerator.destroy();
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ImageBaseComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ImageBaseComponent, inputs: { element: "element", imageItem: "imageItem", board: "board", isFocus: "isFocus", getRectangle: "getRectangle", hasResizeHandle: "hasResizeHandle" }, host: { classAttribute: "plait-image-container" }, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: ImageBaseComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.2.4", type: ImageBaseComponent, inputs: { element: "element", imageItem: "imageItem", board: "board", isFocus: "isFocus", getRectangle: "getRectangle", hasResizeHandle: "hasResizeHandle" }, host: { classAttribute: "plait-image-container" }, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ImageBaseComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: ImageBaseComponent, decorators: [{
             type: Directive,
             args: [{
                     host: {
                         class: 'plait-image-container'
                     }
                 }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { element: [{
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }], propDecorators: { element: [{
                 type: Input
             }], imageItem: [{
                 type: Input
@@ -1580,5 +1583,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { AStar, ActiveGenerator, AlignTransform, BASE, BoardCreationMode, CommonPluginElement, DEFAULT_ROUTE_MARGIN, Generator, IS_RESIZING, ImageBaseComponent, ImageGenerator, MediaKeys, PICTURE_ACCEPTED_UPLOAD_SIZE, PRIMARY_COLOR, PointGraph, PointNode, PriorityQueue, PropertyTransforms, RESIZE_HANDLE_DIAMETER, ResizeHandle, TRANSPARENT, TextTransforms, WithCommonPluginKey, WithTextPluginKey, acceptImageTypes, addElementOfFocusedImage, addResizing, alignBottom, alignHorizontalCenter, alignLeft, alignRight, alignTop, alignVerticalCenter, buildImage, calculatePolylineLength, createGraph, distributeHorizontal, distributeVertical, drawFillPrimaryHandle, drawHandle, drawPrimaryHandle, generateElbowLineRoute, getCreationMode, getCrossingPointsBetweenPointAndSegment, getDirection, getDirectionBetweenPointAndPoint, getDirectionByPointOfRectangle, getDirectionByVector, getDirectionFactor, getDirectionFactorByVectorComponent, getEdgeCenter, getElementOfFocusedImage, getElementsText, getExtendPoint, getFirstTextEditor, getFirstTextManage, getGraphPoints, getIndexByResizeHandle, getMemorizedLatest, getNextPoint, getOppositeDirection, getPointByUnitVectorAndVectorComponent, getPointByVector, getPointOnPolyline, getPoints, getRatioByPoint, getRectangleResizeHandleRefs, getResizeHandleByIndex, getResizeHandlePointByIndex, getSourceAndTargetOuterRectangle, getSymmetricHandleIndex, getTextEditors, getTextManages, getTextMarksByElement, getUnitVectorByPointAndPoint, hasAfterDraw, isCornerHandle, isDelete, isDndMode, isDrawingMode, isEdgeHandle, isEnterHotkey, isExpandHotkey, isPointOnSegment, isResizing, isResizingByCondition, isSourceAndTargetIntersect, isSpaceHotkey, isTabHotkey, isVirtualKey, memorizeLatest, normalizeShapePoints, reduceRouteMargin, removeDuplicatePoints, removeElementOfFocusedImage, removeResizing, rotateVectorAnti90, routeAdjust, selectImage, setCreationMode, setProperty, simplifyOrthogonalPoints, withResize };
+export { AStar, ActiveGenerator, AlignTransform, BASE, BoardCreationMode, CommonPluginElement, DEFAULT_ROUTE_MARGIN, Generator, IS_RESIZING, ImageBaseComponent, ImageGenerator, MediaKeys, PICTURE_ACCEPTED_UPLOAD_SIZE, PRIMARY_COLOR, PointGraph, PointNode, PriorityQueue, PropertyTransforms, RESIZE_HANDLE_DIAMETER, ResizeHandle, TRANSPARENT, TextTransforms, WithCommonPluginKey, WithTextPluginKey, acceptImageTypes, addElementOfFocusedImage, addResizing, alignBottom, alignHorizontalCenter, alignLeft, alignRight, alignTop, alignVerticalCenter, buildImage, calculatePolylineLength, createGraph, distributeHorizontal, distributeVertical, drawFillPrimaryHandle, drawHandle, drawPrimaryHandle, generateElbowLineRoute, getCreationMode, getCrossingPointsBetweenPointAndSegment, getDirectionBetweenPointAndPoint, getDirectionByPointOfRectangle, getDirectionByVector, getDirectionFactor, getDirectionFactorByDirectionComponent, getElementOfFocusedImage, getElementsText, getExtendPoint, getFirstTextEditor, getFirstTextManage, getGraphPoints, getIndexByResizeHandle, getMemorizedLatest, getNextPoint, getOppositeDirection, getPointByVectorComponent, getPointByVectorDirectionComponent, getPointOnPolyline, getPoints, getRatioByPoint, getRectangleResizeHandleRefs, getResizeHandleByIndex, getResizeHandlePointByIndex, getSourceAndTargetOuterRectangle, getSymmetricHandleIndex, getTextEditors, getTextManages, getTextMarksByElement, getUnitVectorByPointAndPoint, hasAfterDraw, isCornerHandle, isDelete, isDndMode, isDrawingMode, isEdgeHandle, isEnterHotkey, isExpandHotkey, isPointOnSegment, isResizing, isResizingByCondition, isSourceAndTargetIntersect, isSpaceHotkey, isTabHotkey, isVirtualKey, memorizeLatest, normalizeShapePoints, reduceRouteMargin, removeDuplicatePoints, removeElementOfFocusedImage, removeResizing, rotateVectorAnti90, routeAdjust, selectImage, setCreationMode, setProperty, simplifyOrthogonalPoints, withResize };
 //# sourceMappingURL=plait-common.mjs.map