@plait/draw 0.75.0-next.7 → 0.75.0-next.9

package/fesm2022/plait-draw.mjs

@@ -1,5 +1,5 @@
-import { ACTIVE_STROKE_WIDTH, DEFAULT_COLOR, ThemeColorMode, PlaitElement, RectangleClient, getSelectedElements, idCreator, catmullRomFitting, PlaitBoard, createG, drawLinearPath, setStrokeLinecap, distanceBetweenPointAndSegments, HIT_DISTANCE_BUFFER, isPointInPolygon, isLineHitRectangle, rotatePointsByAngle, rotateAntiPointsByElement, distanceBetweenPointAndPoint, Transforms, clearSelectedElement, addSelectedElement, BoardTransforms, PlaitPointerType, depthFirstRecursion, getIsRecursionFunc, SNAPPING_STROKE_WIDTH, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, drawCircle, createDebugGenerator, Point, arrowPoints, createPath, rotate, findElements, createMask, createRect, getElementById, rotatePointsByElement, PlaitNode, hasValidAngle, toViewBoxPoint, toHostPoint, Direction, rotatePoints, getRectangleByElements, getSelectionAngle, rotatedDataPoints, isAxisChangedByAngle, isSelectionMoving, drawRectangle, getRectangleByAngle, getSnapRectangles, getTripleAxis, getMinPointDelta, SNAP_TOLERANCE, drawPointSnapLines, drawSolidLines, getNearestPointBetweenPointAndSegments, isPointInEllipse, getNearestPointBetweenPointAndEllipse, getEllipseTangentSlope, getVectorFromPointAndSlope, drawRoundRectangle, isPointInRoundRectangle, setPathStrokeLinecap, getCrossingPointsBetweenEllipseAndSegment, drawLine, Path, RgbaToHEX, SELECTION_RECTANGLE_CLASS_NAME, getHitElementByPoint, WritableClipboardOperationType, WritableClipboardType, addOrCreateClipboardContext, setAngleForG, CursorClass, temporaryDisableSelection, PRESS_AND_MOVE_BUFFER, isMainPointer, throttleRAF, getAngleBetweenPoints, normalizeAngle, degreesToRadians, rotateElements, MERGING, ROTATE_HANDLE_CLASS_NAME, isSelectedElement, isDragging } from '@plait/core';
-import { DEFAULT_FILL, Alignment, WithTextPluginKey, TextManage, getMemorizedLatest, memorizeLatest, getPointOnPolyline, buildText, Generator, getStrokeLineDash, StrokeStyle, getFirstTextEditor, sortElementsByArea, isFilled, getTextEditorsByElement, removeDuplicatePoints, generateElbowLineRoute, simplifyOrthogonalPoints, getExtendPoint, getUnitVectorByPointAndPoint, getPointByVectorComponent, RESIZE_HANDLE_DIAMETER, measureElement, DEFAULT_FONT_FAMILY, getFirstTextManage, ActiveGenerator, isSourceAndTargetIntersect, getPoints, DEFAULT_ROUTE_MARGIN, normalizeShapePoints, resetPointsAfterResize, getDirectionByVector, getRectangleResizeHandleRefs, getRotatedResizeCursorClassByAngle, ROTATE_HANDLE_DISTANCE_TO_ELEMENT, ROTATE_HANDLE_SIZE, isCornerHandle, getIndexByResizeHandle, withResize, drawHandle, getSymmetricHandleIndex, getResizeHandlePointByIndex, getDirectionFactorByDirectionComponent, buildClipboardData as buildClipboardData$1, insertClipboardData as insertClipboardData$1, getCrossingPointsBetweenPointAndSegment, isPointOnSegment, getDirectionByPointOfRectangle, getDirectionFactor, rotateVector, getOppositeDirection, rotateVectorAnti90, getSourceAndTargetOuterRectangle, getNextPoint, PRIMARY_COLOR, CommonElementFlavour, canResize, drawPrimaryHandle, drawFillPrimaryHandle, isVirtualKey, isDelete, isSpaceHotkey, isDndMode, isDrawingMode, getElementsText, acceptImageTypes, getElementOfFocusedImage, buildImage, isResizingByCondition, getRatioByPoint, getTextManages, ImageGenerator, ResizeHandle, addRotating, removeRotating, drawRotateHandle } from '@plait/common';
+import { ACTIVE_STROKE_WIDTH, DEFAULT_COLOR, ThemeColorMode, PlaitElement, RectangleClient, getSelectedElements, idCreator, catmullRomFitting, PlaitBoard, createG, drawLinearPath, setStrokeLinecap, setPathStrokeLinecap, getNearestPointBetweenPointAndArc, distanceBetweenPointAndPoint, distanceBetweenPointAndSegments, HIT_DISTANCE_BUFFER, isPointInPolygon, isLineHitRectangle, rotatePointsByAngle, createDebugGenerator, rotateAntiPointsByElement, getEllipseArcCenter, Transforms, clearSelectedElement, addSelectedElement, BoardTransforms, PlaitPointerType, depthFirstRecursion, getIsRecursionFunc, SNAPPING_STROKE_WIDTH, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, drawCircle, Point, arrowPoints, createPath, rotate, findElements, createMask, createRect, getElementById, rotatePointsByElement, PlaitNode, hasValidAngle, toViewBoxPoint, toHostPoint, Direction, rotatePoints, getRectangleByElements, getSelectionAngle, rotatedDataPoints, isAxisChangedByAngle, isSelectionMoving, drawRectangle, getRectangleByAngle, getSnapRectangles, getTripleAxis, getMinPointDelta, SNAP_TOLERANCE, drawPointSnapLines, drawSolidLines, getNearestPointBetweenPointAndSegments, isPointInEllipse, getNearestPointBetweenPointAndEllipse, getEllipseTangentSlope, getVectorFromPointAndSlope, drawRoundRectangle, isPointInRoundRectangle, getCrossingPointsBetweenEllipseAndSegment, drawLine, Path, RgbaToHEX, SELECTION_RECTANGLE_CLASS_NAME, getHitElementByPoint, WritableClipboardOperationType, WritableClipboardType, addOrCreateClipboardContext, setAngleForG, CursorClass, temporaryDisableSelection, PRESS_AND_MOVE_BUFFER, isMainPointer, throttleRAF, getAngleBetweenPoints, normalizeAngle, degreesToRadians, rotateElements, MERGING, ROTATE_HANDLE_CLASS_NAME, isSelectedElement, isDragging } from '@plait/core';
+import { DEFAULT_FILL, Alignment, WithTextPluginKey, TextManage, getMemorizedLatest, memorizeLatest, getPointOnPolyline, buildText, Generator, getStrokeLineDash, StrokeStyle, getCrossingPointsBetweenPointAndSegment, isPointOnSegment, getFirstTextEditor, sortElementsByArea, isFilled, getTextEditorsByElement, removeDuplicatePoints, generateElbowLineRoute, simplifyOrthogonalPoints, getExtendPoint, getUnitVectorByPointAndPoint, getPointByVectorComponent, RESIZE_HANDLE_DIAMETER, measureElement, DEFAULT_FONT_FAMILY, getFirstTextManage, ActiveGenerator, isSourceAndTargetIntersect, getPoints, DEFAULT_ROUTE_MARGIN, normalizeShapePoints, resetPointsAfterResize, getDirectionByVector, getRectangleResizeHandleRefs, getRotatedResizeCursorClassByAngle, ROTATE_HANDLE_DISTANCE_TO_ELEMENT, ROTATE_HANDLE_SIZE, isCornerHandle, getIndexByResizeHandle, withResize, drawHandle, getSymmetricHandleIndex, getResizeHandlePointByIndex, getDirectionFactorByDirectionComponent, buildClipboardData as buildClipboardData$1, insertClipboardData as insertClipboardData$1, getDirectionByPointOfRectangle, getDirectionFactor, rotateVector, getOppositeDirection, rotateVectorAnti90, getSourceAndTargetOuterRectangle, getNextPoint, PRIMARY_COLOR, CommonElementFlavour, hasResizeHandle, drawPrimaryHandle, drawFillPrimaryHandle, isVirtualKey, isDelete, isSpaceHotkey, isDndMode, isDrawingMode, getElementsText, acceptImageTypes, getElementOfFocusedImage, buildImage, isResizingByCondition, getRatioByPoint, getTextManages, ImageGenerator, ResizeHandle, addRotating, removeRotating, drawRotateHandle } from '@plait/common';
 import { pointsOnBezierCurves } from 'points-on-curve';
 import { TEXT_DEFAULT_HEIGHT, DEFAULT_FONT_SIZE, AlignEditor } from '@plait/text-plugins';
 import { Editor, Node } from 'slate';
@@ -1034,6 +1034,177 @@ const drawVectorLine = (board, element) => {
     return lineG;
 };
 
+const getCenterPointsOnPolygon$1 = (points) => {
+    const centerPoints = [];
+    for (let i = 0; i < points.length; i++) {
+        let j = i == points.length - 1 ? 0 : i + 1;
+        centerPoints.push([(points[i][0] + points[j][0]) / 2, (points[i][1] + points[j][1]) / 2]);
+    }
+    return centerPoints;
+};
+const getCrossingPointBetweenPointAndPolygon = (corners, point) => {
+    const result = [];
+    for (let index = 1; index <= corners.length; index++) {
+        let start = corners[index - 1];
+        let end = index === corners.length ? corners[0] : corners[index];
+        const crossingPoint = getCrossingPointsBetweenPointAndSegment(point, start, end);
+        result.push(...crossingPoint);
+    }
+    return result;
+};
+const getPolygonEdgeByConnectionPoint = (corners, point) => {
+    for (let index = 1; index <= corners.length; index++) {
+        let start = corners[index - 1];
+        let end = index === corners.length ? corners[0] : corners[index];
+        if (isPointOnSegment(point, start, end)) {
+            return [start, end];
+        }
+    }
+    return null;
+};
+
+function generateCloudPath(rectangle) {
+    const divisionWidth = rectangle.width / 7;
+    const divisionHeight = rectangle.height / 3.2;
+    const xRadius = divisionWidth / 8.5;
+    const yRadius = divisionHeight / 20;
+    const startPoint = [rectangle.x + divisionWidth, rectangle.y + divisionHeight];
+    const arcs = [
+        {
+            rx: xRadius,
+            ry: yRadius * 1.2,
+            xAxisRotation: 0,
+            largeArcFlag: 1,
+            sweepFlag: 1,
+            endX: rectangle.x + divisionWidth * 2,
+            endY: rectangle.y + divisionHeight / 2
+        },
+        {
+            rx: xRadius,
+            ry: yRadius,
+            xAxisRotation: 0,
+            largeArcFlag: 1,
+            sweepFlag: 1,
+            endX: rectangle.x + divisionWidth * 4.2,
+            endY: rectangle.y + divisionHeight / 2.2
+        },
+        {
+            rx: xRadius,
+            ry: yRadius,
+            xAxisRotation: 0,
+            largeArcFlag: 1,
+            sweepFlag: 1,
+            endX: rectangle.x + divisionWidth * 5.8,
+            endY: rectangle.y + divisionHeight
+        },
+        {
+            rx: xRadius,
+            ry: yRadius * 1.3,
+            xAxisRotation: 0,
+            largeArcFlag: 1,
+            sweepFlag: 1,
+            endX: rectangle.x + divisionWidth * 6,
+            endY: rectangle.y + divisionHeight * 2.2
+        },
+        {
+            rx: xRadius,
+            ry: yRadius * 1.2,
+            xAxisRotation: 0,
+            largeArcFlag: 1,
+            sweepFlag: 1,
+            endX: rectangle.x + divisionWidth * 5,
+            endY: rectangle.y + divisionHeight * 2.8
+        },
+        {
+            rx: xRadius,
+            ry: yRadius / 1.2,
+            xAxisRotation: 0,
+            largeArcFlag: 1,
+            sweepFlag: 1,
+            endX: rectangle.x + divisionWidth * 2.8,
+            endY: rectangle.y + divisionHeight * 2.8
+        },
+        {
+            rx: xRadius,
+            ry: yRadius,
+            xAxisRotation: 0,
+            largeArcFlag: 1,
+            sweepFlag: 1,
+            endX: rectangle.x + divisionWidth,
+            endY: rectangle.y + divisionHeight * 2.2
+        },
+        {
+            rx: xRadius,
+            ry: yRadius * 1.42,
+            xAxisRotation: 0,
+            largeArcFlag: 1,
+            sweepFlag: 1,
+            endX: rectangle.x + divisionWidth,
+            endY: rectangle.y + divisionHeight
+        }
+    ];
+    return { startPoint, arcs };
+}
+const CloudEngine = {
+    draw(board, rectangle, options) {
+        const rs = PlaitBoard.getRoughSVG(board);
+        const { startPoint, arcs } = generateCloudPath(rectangle);
+        const pathData = `M ${startPoint[0]} ${startPoint[1]} ` +
+            arcs
+                .map((arc) => `A ${arc.rx} ${arc.ry} ${arc.xAxisRotation} ${arc.largeArcFlag} ${arc.sweepFlag} ${arc.endX} ${arc.endY}`)
+                .join('\n') +
+            ' Z';
+        const svgElement = rs.path(pathData, { ...options, fillStyle: 'solid' });
+        setPathStrokeLinecap(svgElement, 'round');
+        return svgElement;
+    },
+    isInsidePoint(rectangle, point) {
+        const rangeRectangle = RectangleClient.getRectangleByPoints([point, point]);
+        return RectangleClient.isHit(rectangle, rangeRectangle);
+    },
+    getCornerPoints(rectangle) {
+        return RectangleClient.getCornerPoints(rectangle);
+    },
+    getNearestPoint(rectangle, point) {
+        const { startPoint, arcs } = generateCloudPath(rectangle);
+        let minDistance = Infinity;
+        let nearestPoint = point;
+        // 检查每个弧段
+        let currentStart = startPoint;
+        for (const arc of arcs) {
+            const arcNearestPoint = getNearestPointBetweenPointAndArc(point, currentStart, arc);
+            const distance = distanceBetweenPointAndPoint(point[0], point[1], arcNearestPoint[0], arcNearestPoint[1]);
+            if (distance < minDistance) {
+                minDistance = distance;
+                nearestPoint = arcNearestPoint;
+            }
+            currentStart = [arc.endX, arc.endY];
+        }
+        return nearestPoint;
+    },
+    getEdgeByConnectionPoint(rectangle, pointOfRectangle) {
+        const corners = CloudEngine.getCornerPoints(rectangle);
+        const point = RectangleClient.getConnectionPoint(rectangle, pointOfRectangle);
+        return getPolygonEdgeByConnectionPoint(corners, point);
+    },
+    getConnectorPoints(rectangle) {
+        return RectangleClient.getEdgeCenterPoints(rectangle);
+    },
+    getTextRectangle(element) {
+        const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
+        const strokeWidth = getStrokeWidthByElement(element);
+        const height = element.textHeight;
+        const originWidth = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
+        const width = originWidth / 1.5;
+        return {
+            height,
+            width: width > 0 ? width : 0,
+            x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth + originWidth / 6,
+            y: elementRectangle.y + elementRectangle.height / 6 + ((elementRectangle.height * 4) / 6 - height) / 2
+        };
+    }
+};
+
 const isTextExceedingBounds = (geometry) => {
     const client = RectangleClient.getRectangleByPoints(geometry.points);
     if (geometry.textHeight && geometry.textHeight > client.height) {
@@ -1169,10 +1340,35 @@ const getFirstTextOrLineElement = (elements) => {
     }
     return null;
 };
+const debugKey$4 = 'debug:plait:hit:shape:edge:sample-points';
+const debugGenerator$4 = createDebugGenerator(debugKey$4);
+const shapes = [BasicShapes.cloud];
 const isHitDrawElement = (board, element, point, isStrict = true) => {
     const rectangle = board.getRectangle(element);
     point = rotateAntiPointsByElement(point, element) || point;
-    if (PlaitDrawElement.isGeometry(element)) {
+    if (PlaitDrawElement.isGeometry(element) && rectangle) {
+        if (debugGenerator$4.isDebug() && shapes.includes(element.shape)) {
+            debugGenerator$4.clear();
+            const { startPoint, arcs } = generateCloudPath(rectangle);
+            const points = [startPoint, ...arcs.map((arc) => [arc.endX, arc.endY])];
+            debugGenerator$4.drawCircles(board, points, 5, false);
+            let minDistance = Infinity;
+            let nearestPoint = point;
+            let currentStart = startPoint;
+            for (const arc of arcs) {
+                const arcNearestPoint = getNearestPointBetweenPointAndArc(point, currentStart, arc);
+                const distance = distanceBetweenPointAndPoint(point[0], point[1], arcNearestPoint[0], arcNearestPoint[1]);
+                const { center } = getEllipseArcCenter(currentStart, arc);
+                debugGenerator$4.drawCircles(board, [center], 8, false, { fill: 'yellow' });
+                if (distance < minDistance) {
+                    minDistance = distance;
+                    nearestPoint = arcNearestPoint;
+                }
+                currentStart = [arc.endX, arc.endY];
+            }
+            debugGenerator$4.drawCircles(board, [point], 12, false, { fill: 'black', stroke: 'black' });
+            debugGenerator$4.drawCircles(board, [nearestPoint], 12, false, { fill: 'green', stroke: 'green' });
+        }
         if (isHitEdgeOfShape(board, element, point, HIT_DISTANCE_BUFFER)) {
             return true;
         }
@@ -2182,7 +2378,7 @@ const getNearestPoint = (element, point) => {
     const shape = getElementShape(element);
     return getEngine(shape).getNearestPoint(rectangle, point);
 };
-const getCenterPointsOnPolygon$1 = (points) => {
+const getCenterPointsOnPolygon = (points) => {
     const centerPoint = [];
     for (let i = 0; i < points.length; i++) {
         let j = i == points.length - 1 ? 0 : i + 1;
@@ -3147,7 +3343,7 @@ function withDrawResize(board) {
     const canResize = () => {
         const elements = getSelectedElements(board);
         return (elements.length >= 1 &&
-            elements.every(el => (PlaitDrawElement.isDrawElement(el) || PlaitDrawElement.isCustomGeometryElement(board, el)) &&
+            elements.every((el) => (PlaitDrawElement.isDrawElement(el) || (PlaitDrawElement.isCustomGeometryElement(board, el) && el.points.length > 1)) &&
                 !isSingleSelectLine(board) &&
                 !isSingleSelectSwimlane(board)));
     };
@@ -3200,7 +3396,7 @@ function withDrawResize(board) {
             PlaitBoard.getElementActiveHost(board).append(snapG);
             if (bulkRotationRef) {
                 const boundingBoxCornerPoints = RectangleClient.getPoints(resizeRef.rectangle);
-                const resizedBoundingBoxCornerPoints = boundingBoxCornerPoints.map(p => {
+                const resizedBoundingBoxCornerPoints = boundingBoxCornerPoints.map((p) => {
                     return movePointByZoomAndOriginPoint(p, originPoint, resizeSnapRef.xZoom, resizeSnapRef.yZoom);
                 });
                 const newBoundingBox = RectangleClient.getRectangleByPoints(resizedBoundingBoxCornerPoints);
@@ -3215,7 +3411,7 @@ function withDrawResize(board) {
                 });
                 debugGenerator$2.isDebug() && debugGenerator$2.drawRectangle(board, adjustedNewBoundingBoxPoints);
             }
-            resizeRef.element.forEach(target => {
+            resizeRef.element.forEach((target) => {
                 const path = PlaitBoard.findPath(board, target);
                 let points;
                 if (bulkRotationRef) {
@@ -3223,7 +3419,7 @@ function withDrawResize(board) {
                     points = reversedPoints.map((p) => {
                         return movePointByZoomAndOriginPoint(p, originPoint, resizeSnapRef.xZoom, resizeSnapRef.yZoom);
                     });
-                    const adjustTargetPoints = points.map(p => [
+                    const adjustTargetPoints = points.map((p) => [
                         p[0] + bulkRotationRef.offsetX,
                         p[1] + bulkRotationRef.offsetY
                     ]);
@@ -3237,7 +3433,7 @@ function withDrawResize(board) {
                         points = getResizePointsByOtherwiseAxis(board, target.points, originPoint, resizeSnapRef.xZoom, resizeSnapRef.yZoom);
                     }
                     else {
-                        points = target.points.map(p => {
+                        points = target.points.map((p) => {
                             return movePointByZoomAndOriginPoint(p, originPoint, resizeSnapRef.xZoom, resizeSnapRef.yZoom);
                         });
                     }
@@ -3302,7 +3498,7 @@ function withDrawResize(board) {
                 const centerPoint = RectangleClient.getCenterPoint(boundingRectangle);
                 corners = rotatePoints(corners, centerPoint, angle);
             }
-            corners.forEach(corner => {
+            corners.forEach((corner) => {
                 const g = drawHandle(board, corner);
                 handleG && handleG.append(g);
             });
@@ -3383,7 +3579,7 @@ const getResizePointsByOtherwiseAxis = (board, points, resizeOriginPoint, xZoom,
     let resultPoints = points;
     resultPoints = rotatePoints(resultPoints, RectangleClient.getCenterPoint(currentRectangle), (1 / 2) * Math.PI);
     debugGenerator$2.isDebug() && debugGenerator$2.drawRectangle(board, resultPoints, { stroke: 'blue' });
-    resultPoints = resultPoints.map(p => {
+    resultPoints = resultPoints.map((p) => {
         return movePointByZoomAndOriginPoint(p, resizeOriginPoint, xZoom, yZoom);
     });
     debugGenerator$2.isDebug() && debugGenerator$2.drawRectangle(board, resultPoints);
@@ -3683,35 +3879,6 @@ const insertClipboardData = (board, elements, startPoint) => {
     });
 };
 
-const getCenterPointsOnPolygon = (points) => {
-    const centerPoints = [];
-    for (let i = 0; i < points.length; i++) {
-        let j = i == points.length - 1 ? 0 : i + 1;
-        centerPoints.push([(points[i][0] + points[j][0]) / 2, (points[i][1] + points[j][1]) / 2]);
-    }
-    return centerPoints;
-};
-const getCrossingPointBetweenPointAndPolygon = (corners, point) => {
-    const result = [];
-    for (let index = 1; index <= corners.length; index++) {
-        let start = corners[index - 1];
-        let end = index === corners.length ? corners[0] : corners[index];
-        const crossingPoint = getCrossingPointsBetweenPointAndSegment(point, start, end);
-        result.push(...crossingPoint);
-    }
-    return result;
-};
-const getPolygonEdgeByConnectionPoint = (corners, point) => {
-    for (let index = 1; index <= corners.length; index++) {
-        let start = corners[index - 1];
-        let end = index === corners.length ? corners[0] : corners[index];
-        if (isPointOnSegment(point, start, end)) {
-            return [start, end];
-        }
-    }
-    return null;
-};
-
 const heightRatio$1 = 3 / 4;
 const CommentEngine = {
     draw(board, rectangle, options) {
@@ -4002,7 +4169,7 @@ const ParallelogramEngine = createPolygonEngine({
     getPolygonPoints: getParallelogramPoints,
     getConnectorPoints: (rectangle) => {
         const cornerPoints = getParallelogramPoints(rectangle);
-        return getCenterPointsOnPolygon(cornerPoints);
+        return getCenterPointsOnPolygon$1(cornerPoints);
     },
     getTextRectangle(element) {
         const rectangle = getTextRectangle(element);
@@ -4280,7 +4447,7 @@ const TrapezoidEngine = createPolygonEngine({
     getPolygonPoints: getTrapezoidPoints,
     getConnectorPoints(rectangle) {
         const points = getTrapezoidPoints(rectangle);
-        return getCenterPointsOnPolygon(points);
+        return getCenterPointsOnPolygon$1(points);
     },
     getTextRectangle(element) {
         const rectangle = getTextRectangle(element);
@@ -4302,7 +4469,7 @@ const TriangleEngine = createPolygonEngine({
     getPolygonPoints: getTrianglePoints,
     getConnectorPoints(rectangle) {
         const cornerPoints = getTrianglePoints(rectangle);
-        const lineCenterPoints = getCenterPointsOnPolygon(cornerPoints);
+        const lineCenterPoints = getCenterPointsOnPolygon$1(cornerPoints);
         return [...lineCenterPoints, ...cornerPoints];
     },
     getTextRectangle(element) {
@@ -4458,7 +4625,7 @@ const ManualInputEngine = createPolygonEngine({
     getPolygonPoints: getManualInputPoints,
     getConnectorPoints: (rectangle) => {
         const cornerPoints = getManualInputPoints(rectangle);
-        return getCenterPointsOnPolygon(cornerPoints);
+        return getCenterPointsOnPolygon$1(cornerPoints);
     },
     getTextRectangle: (element) => {
         const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
@@ -4510,7 +4677,7 @@ const ManualLoopEngine = createPolygonEngine({
     getPolygonPoints: getManualLoopPoints,
     getConnectorPoints: (rectangle) => {
         const cornerPoints = getManualLoopPoints(rectangle);
-        return getCenterPointsOnPolygon(cornerPoints);
+        return getCenterPointsOnPolygon$1(cornerPoints);
     },
     getTextRectangle(element) {
         const rectangle = getTextRectangle(element);
@@ -4532,7 +4699,7 @@ const MergeEngine = createPolygonEngine({
     getPolygonPoints: getMergePoints,
     getConnectorPoints: (rectangle) => {
         const cornerPoints = getMergePoints(rectangle);
-        const lineCenterPoints = getCenterPointsOnPolygon(cornerPoints);
+        const lineCenterPoints = getCenterPointsOnPolygon$1(cornerPoints);
         return [...lineCenterPoints, ...cornerPoints];
     },
     getTextRectangle(element) {
@@ -4738,59 +4905,6 @@ const OffPageEngine = createPolygonEngine({
     }
 });
 
-const CloudEngine = {
-    draw(board, rectangle, options) {
-        const rs = PlaitBoard.getRoughSVG(board);
-        const divisionWidth = rectangle.width / 7;
-        const divisionHeight = rectangle.height / 3.2;
-        const xRadius = divisionWidth / 8.5;
-        const yRadius = divisionHeight / 20;
-        const svgElement = rs.path(`M ${rectangle.x + divisionWidth} ${rectangle.y + divisionHeight}
-             A ${xRadius} ${yRadius * 1.2} 0 1 1 ${rectangle.x + divisionWidth * 2} ${rectangle.y + divisionHeight / 2}
-             A ${xRadius} ${yRadius} 0 1 1 ${rectangle.x + divisionWidth * 4.2} ${rectangle.y + divisionHeight / 2.2}
-             A ${xRadius} ${yRadius} 0 1 1 ${rectangle.x + divisionWidth * 5.8} ${rectangle.y + divisionHeight}
-             A ${xRadius} ${yRadius * 1.3} 0 1 1 ${rectangle.x + divisionWidth * 6} ${rectangle.y + divisionHeight * 2.2}
-             A ${xRadius} ${yRadius * 1.2} 0 1 1 ${rectangle.x + divisionWidth * 5} ${rectangle.y + divisionHeight * 2.8}
-             A ${xRadius} ${yRadius / 1.2} 0 1 1 ${rectangle.x + divisionWidth * 2.8} ${rectangle.y + divisionHeight * 2.8}
-             A ${xRadius} ${yRadius} 0 1 1 ${rectangle.x + divisionWidth} ${rectangle.y + divisionHeight * 2.2}
-             A ${xRadius} ${yRadius * 1.42} 0 1 1 ${rectangle.x + divisionWidth} ${rectangle.y + divisionHeight}
-            Z`, { ...options, fillStyle: 'solid' });
-        setPathStrokeLinecap(svgElement, 'round');
-        return svgElement;
-    },
-    isInsidePoint(rectangle, point) {
-        const rangeRectangle = RectangleClient.getRectangleByPoints([point, point]);
-        return RectangleClient.isHit(rectangle, rangeRectangle);
-    },
-    getCornerPoints(rectangle) {
-        return RectangleClient.getCornerPoints(rectangle);
-    },
-    getNearestPoint(rectangle, point) {
-        return getNearestPointBetweenPointAndSegments(point, CloudEngine.getCornerPoints(rectangle));
-    },
-    getEdgeByConnectionPoint(rectangle, pointOfRectangle) {
-        const corners = CloudEngine.getCornerPoints(rectangle);
-        const point = RectangleClient.getConnectionPoint(rectangle, pointOfRectangle);
-        return getPolygonEdgeByConnectionPoint(corners, point);
-    },
-    getConnectorPoints(rectangle) {
-        return RectangleClient.getEdgeCenterPoints(rectangle);
-    },
-    getTextRectangle(element) {
-        const elementRectangle = RectangleClient.getRectangleByPoints(element.points);
-        const strokeWidth = getStrokeWidthByElement(element);
-        const height = element.textHeight;
-        const originWidth = elementRectangle.width - ShapeDefaultSpace.rectangleAndText * 2 - strokeWidth * 2;
-        const width = originWidth / 1.5;
-        return {
-            height,
-            width: width > 0 ? width : 0,
-            x: elementRectangle.x + ShapeDefaultSpace.rectangleAndText + strokeWidth + originWidth / 6,
-            y: elementRectangle.y + elementRectangle.height / 6 + ((elementRectangle.height * 4) / 6 - height) / 2
-        };
-    }
-};
-
 const OrEngine = createEllipseEngine({
     draw(board, rectangle, options) {
         const rs = PlaitBoard.getRoughSVG(board);
@@ -6751,7 +6865,7 @@ class GeometryComponent extends CommonElementFlavour {
                 return RectangleClient.getRectangleByPoints(element.points);
             },
             hasResizeHandle: () => {
-                return canResize(this.board, this.element);
+                return hasResizeHandle(this.board, this.element);
             }
         });
         this.lineAutoCompleteGenerator = new ArrowLineAutoCompleteGenerator(this.board);
@@ -7913,6 +8027,7 @@ const withArrowLineAutoComplete = (board) => {
                 // source point must be click point
                 const rotatedSourcePoint = rotatePointsByElement(sourcePoint, sourceElement) || sourcePoint;
                 temporaryElement = handleArrowLineCreating(board, ArrowLineShape.elbow, rotatedSourcePoint, movingPoint, sourceElement, lineShapeG);
+                Transforms.addSelectionWithTemporaryElements(board, []);
             }
         }
         pointerMove(event);
@@ -8132,7 +8247,7 @@ class TableComponent extends CommonElementFlavour {
                 if (cells?.length) {
                     return false;
                 }
-                return canResize(this.board, this.element);
+                return hasResizeHandle(this.board, this.element);
             }
         });
         this.tableGenerator = new TableGenerator(this.board);
@@ -8865,5 +8980,5 @@ const withDraw = (board) => {
  * Generated bundle index. Do not edit.
  */
 
-export { ArrowLineAutoCompleteGenerator, ArrowLineComponent, ArrowLineHandleKey, ArrowLineMarkerType, ArrowLineShape, BasicShapes, DEFAULT_IMAGE_WIDTH, DefaultActivationProperty, DefaultActorProperty, DefaultArrowProperty, DefaultAssemblyProperty, DefaultBasicShapeProperty, DefaultBasicShapePropertyMap, DefaultClassProperty, DefaultCloudProperty, DefaultCombinedFragmentProperty, DefaultComponentBoxProperty, DefaultConnectorProperty, DefaultContainerProperty, DefaultDataBaseProperty, DefaultDataProperty, DefaultDecisionProperty, DefaultDeletionProperty, DefaultDocumentProperty, DefaultDrawActiveStyle, DefaultDrawStyle, DefaultFlowchartProperty, DefaultFlowchartPropertyMap, DefaultInterfaceProperty, DefaultInternalStorageProperty, DefaultManualInputProperty, DefaultMergeProperty, DefaultMultiDocumentProperty, DefaultNoteProperty, DefaultObjectProperty, DefaultPackageProperty, DefaultPentagonArrowProperty, DefaultPortProperty, DefaultProvidedInterfaceProperty, DefaultRequiredInterfaceProperty, DefaultSwimlaneHorizontalProperty, DefaultSwimlaneHorizontalWithHeaderProperty, DefaultSwimlanePropertyMap, DefaultSwimlaneVerticalProperty, DefaultSwimlaneVerticalWithHeaderProperty, DefaultTextProperty, DefaultTwoWayArrowProperty, DefaultUMLPropertyMap, DrawThemeColors, DrawTransforms, FlowchartSymbols, GEOMETRY_NOT_CLOSED, GEOMETRY_WITHOUT_TEXT, GEOMETRY_WITH_MULTIPLE_TEXT, GeometryCommonTextKeys, GeometryComponent, GeometryShapeGenerator, GeometryThreshold, KEY_TO_TEXT_MANAGE, LINE_HIT_GEOMETRY_BUFFER, LINE_SNAPPING_BUFFER, LINE_SNAPPING_CONNECTOR_BUFFER, LineActiveGenerator, MIN_TEXT_WIDTH, MemorizeKey, MultipleTextGeometryTextKeys, PlaitArrowLine, PlaitDrawElement, PlaitGeometry, PlaitTableElement, Q2C, SELECTED_CELLS, SWIMLANE_HEADER_SIZE, ShapeDefaultSpace, SingleTextGenerator, SwimlaneDrawSymbols, SwimlaneSymbols, TableGenerator, TableSymbols, TextGenerator, UMLSymbols, VectorLineComponent, VectorLinePointerType, VectorLineShape, WithArrowLineAutoCompletePluginKey, WithDrawPluginKey, adjustSwimlaneShape, alignElbowSegment, alignPoints, buildClipboardData, buildDefaultTextsByShape, buildSwimlaneTable, clearSelectedCells, collectArrowLineUpdatedRefsByGeometry, createArrowLineElement, createCell, createDefaultCells, createDefaultFlowchart, createDefaultGeometry, createDefaultRowsOrColumns, createDefaultSwimlane, createGeometryElement, createGeometryElementWithText, createGeometryElementWithoutText, createMultipleTextGeometryElement, createTextElement, createUMLClassOrInterfaceGeometryElement, createVectorLineElement, debugGenerator$1 as debugGenerator, deleteTextManage, drawArrowLine, drawArrowLineArrow, drawBoundReaction, drawGeometry, drawShape, drawVectorLine, editCell, editText, getArrowLineHandleRefPair, getArrowLinePointers, getArrowLinePoints, getArrowLineTextRectangle, getArrowLines, getAutoCompletePoints, getBasicPointers, getCellWithPoints, getCellsRectangle, getCellsWithPoints, getCenterPointsOnPolygon$1 as getCenterPointsOnPolygon, getConnectionPoint, getCurvePoints, getDefaultBasicShapeProperty, getDefaultFlowchartProperty, getDefaultGeometryPoints, getDefaultGeometryProperty, getDefaultSwimlanePoints, getDefaultTextPoints, getDefaultUMLProperty, getDrawDefaultStrokeColor, getElbowLineRouteOptions, getElbowPoints, getFillByElement, getFirstFilledDrawElement, getFirstTextOrLineElement, getFlowchartDefaultFill, getFlowchartPointers, getGeometryAlign, getGeometryPointers, getHitCell, getHitConnection, getHitConnectorPoint, getHitDrawElement, getHitIndexOfAutoCompletePoint, getHitMultipleGeometryText, getHitShape, getIndexAndDeleteCountByKeyPoint, getLineMemorizedLatest, getMemorizeKey, getMemorizedLatestByPointer, getMemorizedLatestShape, getMidKeyPoints, getMiddlePoints, getMirrorDataPoints, getMultipleTextGeometryTextKeys, getNearestPoint, getNextRenderPoints, getNextSourceAndTargetPoints, getResizedPreviousAndNextPoint, getSelectedArrowLineElements, getSelectedCells, getSelectedCustomGeometryElements, getSelectedDrawElements, getSelectedGeometryElements, getSelectedImageElements, getSelectedSwimlane, getSelectedTableCellsEditor, getSelectedTableElements, getSelectedVectorLineElements, getSnapResizingRef, getSnapResizingRefOptions, getSnappingRef, getSnappingShape, getSourceAndTargetRectangle, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getSwimlaneCount, getSwimlanePointers, getTextKey, getTextManage, getTextManageByCell, getTextRectangle, getTextShapeProperty, getUMLPointers, getVectorByConnection, getVectorLinePointers, getVectorLinePoints, handleArrowLineCreating, hasIllegalElbowPoint, insertClipboardData, insertElement, isCellIncludeText, isClosedCustomGeometry, isClosedDrawElement, isClosedPoints, isDrawElementIncludeText, isDrawElementsIncludeText, isEmptyTextElement, isFilledDrawElement, isGeometryClosed, isGeometryIncludeText, isHitArrowLine, isHitArrowLineText, isHitDrawElement, isHitEdgeOfShape, isHitElementInside, isHitElementText, isHitPolyLine, isHitVectorLine, isInsideOfShape, isMultipleTextGeometry, isMultipleTextShape, isRectangleHitDrawElement, isRectangleHitElementText, isRectangleHitRotatedElement, isRectangleHitRotatedPoints, isSelfLoop, isSingleSelectElementByTable, isSingleSelectLine, isSingleSelectSwimlane, isSingleSelectTable, isSingleTextGeometry, isSingleTextShape, isSwimlanePointers, isSwimlaneWithHeader, isTextExceedingBounds, isUpdatedHandleIndex, isUseDefaultOrthogonalRoute, memorizeLatestShape, memorizeLatestText, rerenderGeometryActive, setSelectedCells, setTextManage, traverseDrawShapes, updateCellIds, updateCellIdsByRowOrColumn, updateColumns, updateRowOrColumnIds, updateRows, vectorLineCreating, withArrowLineAutoComplete, withDraw };
+export { ArrowLineAutoCompleteGenerator, ArrowLineComponent, ArrowLineHandleKey, ArrowLineMarkerType, ArrowLineShape, BasicShapes, DEFAULT_IMAGE_WIDTH, DefaultActivationProperty, DefaultActorProperty, DefaultArrowProperty, DefaultAssemblyProperty, DefaultBasicShapeProperty, DefaultBasicShapePropertyMap, DefaultClassProperty, DefaultCloudProperty, DefaultCombinedFragmentProperty, DefaultComponentBoxProperty, DefaultConnectorProperty, DefaultContainerProperty, DefaultDataBaseProperty, DefaultDataProperty, DefaultDecisionProperty, DefaultDeletionProperty, DefaultDocumentProperty, DefaultDrawActiveStyle, DefaultDrawStyle, DefaultFlowchartProperty, DefaultFlowchartPropertyMap, DefaultInterfaceProperty, DefaultInternalStorageProperty, DefaultManualInputProperty, DefaultMergeProperty, DefaultMultiDocumentProperty, DefaultNoteProperty, DefaultObjectProperty, DefaultPackageProperty, DefaultPentagonArrowProperty, DefaultPortProperty, DefaultProvidedInterfaceProperty, DefaultRequiredInterfaceProperty, DefaultSwimlaneHorizontalProperty, DefaultSwimlaneHorizontalWithHeaderProperty, DefaultSwimlanePropertyMap, DefaultSwimlaneVerticalProperty, DefaultSwimlaneVerticalWithHeaderProperty, DefaultTextProperty, DefaultTwoWayArrowProperty, DefaultUMLPropertyMap, DrawThemeColors, DrawTransforms, FlowchartSymbols, GEOMETRY_NOT_CLOSED, GEOMETRY_WITHOUT_TEXT, GEOMETRY_WITH_MULTIPLE_TEXT, GeometryCommonTextKeys, GeometryComponent, GeometryShapeGenerator, GeometryThreshold, KEY_TO_TEXT_MANAGE, LINE_HIT_GEOMETRY_BUFFER, LINE_SNAPPING_BUFFER, LINE_SNAPPING_CONNECTOR_BUFFER, LineActiveGenerator, MIN_TEXT_WIDTH, MemorizeKey, MultipleTextGeometryTextKeys, PlaitArrowLine, PlaitDrawElement, PlaitGeometry, PlaitTableElement, Q2C, SELECTED_CELLS, SWIMLANE_HEADER_SIZE, ShapeDefaultSpace, SingleTextGenerator, SwimlaneDrawSymbols, SwimlaneSymbols, TableGenerator, TableSymbols, TextGenerator, UMLSymbols, VectorLineComponent, VectorLinePointerType, VectorLineShape, WithArrowLineAutoCompletePluginKey, WithDrawPluginKey, adjustSwimlaneShape, alignElbowSegment, alignPoints, buildClipboardData, buildDefaultTextsByShape, buildSwimlaneTable, clearSelectedCells, collectArrowLineUpdatedRefsByGeometry, createArrowLineElement, createCell, createDefaultCells, createDefaultFlowchart, createDefaultGeometry, createDefaultRowsOrColumns, createDefaultSwimlane, createGeometryElement, createGeometryElementWithText, createGeometryElementWithoutText, createMultipleTextGeometryElement, createTextElement, createUMLClassOrInterfaceGeometryElement, createVectorLineElement, debugGenerator$1 as debugGenerator, deleteTextManage, drawArrowLine, drawArrowLineArrow, drawBoundReaction, drawGeometry, drawShape, drawVectorLine, editCell, editText, getArrowLineHandleRefPair, getArrowLinePointers, getArrowLinePoints, getArrowLineTextRectangle, getArrowLines, getAutoCompletePoints, getBasicPointers, getCellWithPoints, getCellsRectangle, getCellsWithPoints, getCenterPointsOnPolygon, getConnectionPoint, getCurvePoints, getDefaultBasicShapeProperty, getDefaultFlowchartProperty, getDefaultGeometryPoints, getDefaultGeometryProperty, getDefaultSwimlanePoints, getDefaultTextPoints, getDefaultUMLProperty, getDrawDefaultStrokeColor, getElbowLineRouteOptions, getElbowPoints, getFillByElement, getFirstFilledDrawElement, getFirstTextOrLineElement, getFlowchartDefaultFill, getFlowchartPointers, getGeometryAlign, getGeometryPointers, getHitCell, getHitConnection, getHitConnectorPoint, getHitDrawElement, getHitIndexOfAutoCompletePoint, getHitMultipleGeometryText, getHitShape, getIndexAndDeleteCountByKeyPoint, getLineMemorizedLatest, getMemorizeKey, getMemorizedLatestByPointer, getMemorizedLatestShape, getMidKeyPoints, getMiddlePoints, getMirrorDataPoints, getMultipleTextGeometryTextKeys, getNearestPoint, getNextRenderPoints, getNextSourceAndTargetPoints, getResizedPreviousAndNextPoint, getSelectedArrowLineElements, getSelectedCells, getSelectedCustomGeometryElements, getSelectedDrawElements, getSelectedGeometryElements, getSelectedImageElements, getSelectedSwimlane, getSelectedTableCellsEditor, getSelectedTableElements, getSelectedVectorLineElements, getSnapResizingRef, getSnapResizingRefOptions, getSnappingRef, getSnappingShape, getSourceAndTargetRectangle, getStrokeColorByElement, getStrokeStyleByElement, getStrokeWidthByElement, getSwimlaneCount, getSwimlanePointers, getTextKey, getTextManage, getTextManageByCell, getTextRectangle, getTextShapeProperty, getUMLPointers, getVectorByConnection, getVectorLinePointers, getVectorLinePoints, handleArrowLineCreating, hasIllegalElbowPoint, insertClipboardData, insertElement, isCellIncludeText, isClosedCustomGeometry, isClosedDrawElement, isClosedPoints, isDrawElementIncludeText, isDrawElementsIncludeText, isEmptyTextElement, isFilledDrawElement, isGeometryClosed, isGeometryIncludeText, isHitArrowLine, isHitArrowLineText, isHitDrawElement, isHitEdgeOfShape, isHitElementInside, isHitElementText, isHitPolyLine, isHitVectorLine, isInsideOfShape, isMultipleTextGeometry, isMultipleTextShape, isRectangleHitDrawElement, isRectangleHitElementText, isRectangleHitRotatedElement, isRectangleHitRotatedPoints, isSelfLoop, isSingleSelectElementByTable, isSingleSelectLine, isSingleSelectSwimlane, isSingleSelectTable, isSingleTextGeometry, isSingleTextShape, isSwimlanePointers, isSwimlaneWithHeader, isTextExceedingBounds, isUpdatedHandleIndex, isUseDefaultOrthogonalRoute, memorizeLatestShape, memorizeLatestText, rerenderGeometryActive, setSelectedCells, setTextManage, traverseDrawShapes, updateCellIds, updateCellIdsByRowOrColumn, updateColumns, updateRowOrColumnIds, updateRows, vectorLineCreating, withArrowLineAutoComplete, withDraw };
 //# sourceMappingURL=plait-draw.mjs.map