@plait/draw 0.51.2 → 0.51.3

package/esm2022/utils/hit.mjs

@@ -1,6 +1,6 @@
-import { RectangleClient, isPolylineHitRectangle, distanceBetweenPointAndSegments, distanceBetweenPointAndPoint, HIT_DISTANCE_BUFFER } from '@plait/core';
+import { RectangleClient, isPolylineHitRectangle, distanceBetweenPointAndSegments, distanceBetweenPointAndPoint, HIT_DISTANCE_BUFFER, rotate } from '@plait/core';
 import { PlaitDrawElement } from '../interfaces';
-import { TRANSPARENT } from '@plait/common';
+import { TRANSPARENT, rotatePoints } from '@plait/common';
 import { getTextRectangle } from './geometry';
 import { getLinePoints } from './line/line-basic';
 import { getFillByElement } from './style/stroke';
@@ -31,15 +31,18 @@ export const isRectangleHitDrawElement = (board, element, selection) => {
     const rangeRectangle = RectangleClient.getRectangleByPoints([selection.anchor, selection.focus]);
     if (PlaitDrawElement.isGeometry(element)) {
         const client = RectangleClient.getRectangleByPoints(element.points);
+        const centerPoint = RectangleClient.getCenterPoint(client);
+        let rotatedCornerPoints = rotatePoints(RectangleClient.getCornerPoints(client), centerPoint, element.angle);
         if (isTextExceedingBounds(element)) {
             const textClient = getTextRectangle(element);
-            return RectangleClient.isHit(rangeRectangle, client) || RectangleClient.isHit(rangeRectangle, textClient);
+            rotatedCornerPoints = rotatePoints(RectangleClient.getCornerPoints(textClient), centerPoint, element.angle);
         }
-        return RectangleClient.isHit(rangeRectangle, client);
+        return isPolylineHitRectangle(rotatedCornerPoints, rangeRectangle);
     }
     if (PlaitDrawElement.isImage(element)) {
         const client = RectangleClient.getRectangleByPoints(element.points);
-        return RectangleClient.isHit(rangeRectangle, client);
+        const rotatedCornerPoints = rotatePoints(RectangleClient.getCornerPoints(client), RectangleClient.getCenterPoint(client), element.angle);
+        return isPolylineHitRectangle(rotatedCornerPoints, client);
     }
     if (PlaitDrawElement.isLine(element)) {
         const points = getLinePoints(board, element);
@@ -48,10 +51,14 @@ export const isRectangleHitDrawElement = (board, element, selection) => {
     return null;
 };
 export const isHitDrawElement = (board, element, point) => {
+    const rectangle = board.getRectangle(element);
+    const centerPoint = RectangleClient.getCenterPoint(rectangle);
+    if (element.angle) {
+        point = rotate(point[0], point[1], centerPoint[0], centerPoint[1], -element.angle);
+    }
     if (PlaitDrawElement.isGeometry(element)) {
         const fill = getFillByElement(board, element);
         const engine = getEngine(getShape(element));
-        const rectangle = board.getRectangle(element);
         const nearestPoint = engine.getNearestPoint(rectangle, point);
         const distance = distanceBetweenPointAndPoint(nearestPoint[0], nearestPoint[1], point[0], point[1]);
         const isHitEdge = distance <= HIT_DISTANCE_BUFFER;
@@ -89,9 +96,13 @@ export const isHitDrawElement = (board, element, point) => {
     return null;
 };
 export const isHitElementInside = (board, element, point) => {
+    const rectangle = board.getRectangle(element);
+    const centerPoint = RectangleClient.getCenterPoint(rectangle);
+    if (element.angle) {
+        point = rotate(point[0], point[1], centerPoint[0], centerPoint[1], -element.angle);
+    }
     if (PlaitDrawElement.isGeometry(element)) {
         const engine = getEngine(getShape(element));
-        const rectangle = board.getRectangle(element);
         const isHitInside = engine.isInsidePoint(rectangle, point);
         if (isHitInside) {
             return isHitInside;
@@ -112,4 +123,4 @@ export const isHitElementInside = (board, element, point) => {
     }
     return null;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hit.js","sourceRoot":"","sources":["../../../../packages/draw/src/utils/hit.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    PlaitElement,\n    RectangleClient,\n    Selection,\n    PlaitBoard,\n    isPolylineHitRectangle,\n    Point,\n    distanceBetweenPointAndSegments,\n    distanceBetweenPointAndPoint,\n    HIT_DISTANCE_BUFFER\n} from '@plait/core';\nimport { PlaitDrawElement, PlaitGeometry, PlaitLine } from '../interfaces';\nimport { TRANSPARENT } from '@plait/common';\nimport { getTextRectangle } from './geometry';\nimport { getLinePoints } from './line/line-basic';\nimport { getFillByElement } from './style/stroke';\nimport { DefaultGeometryStyle } from '../constants/geometry';\nimport { getEngine } from '../engines';\nimport { getShape } from './shape';\nimport { getHitLineTextIndex } from './position/line';\n\nexport const isTextExceedingBounds = (geometry: PlaitGeometry) => {\n    const client = RectangleClient.getRectangleByPoints(geometry.points);\n    if (geometry.textHeight > client.height) {\n        return true;\n    }\n    return false;\n};\n\nexport const isHitLineText = (board: PlaitBoard, element: PlaitLine, point: Point) => {\n    return getHitLineTextIndex(board, element, point) !== -1;\n};\n\nexport const isHitPolyLine = (pathPoints: Point[], point: Point) => {\n    const distance = distanceBetweenPointAndSegments(pathPoints, point);\n    return distance <= HIT_DISTANCE_BUFFER;\n};\n\nexport const isHitLine = (board: PlaitBoard, element: PlaitLine, point: Point) => {\n    const points = getLinePoints(board, element);\n    const isHitText = isHitLineText(board, element, point);\n    return isHitText || isHitPolyLine(points, point);\n};\n\nexport const isRectangleHitDrawElement = (board: PlaitBoard, element: PlaitElement, selection: Selection) => {\n    const rangeRectangle = RectangleClient.getRectangleByPoints([selection.anchor, selection.focus]);\n    if (PlaitDrawElement.isGeometry(element)) {\n        const client = RectangleClient.getRectangleByPoints(element.points);\n        if (isTextExceedingBounds(element)) {\n            const textClient = getTextRectangle(element);\n            return RectangleClient.isHit(rangeRectangle, client) || RectangleClient.isHit(rangeRectangle, textClient);\n        }\n        return RectangleClient.isHit(rangeRectangle, client);\n    }\n    if (PlaitDrawElement.isImage(element)) {\n        const client = RectangleClient.getRectangleByPoints(element.points);\n        return RectangleClient.isHit(rangeRectangle, client);\n    }\n    if (PlaitDrawElement.isLine(element)) {\n        const points = getLinePoints(board, element);\n        return isPolylineHitRectangle(points, rangeRectangle);\n    }\n    return null;\n};\n\nexport const isHitDrawElement = (board: PlaitBoard, element: PlaitElement, point: Point) => {\n    if (PlaitDrawElement.isGeometry(element)) {\n        const fill = getFillByElement(board, element);\n        const engine = getEngine(getShape(element));\n        const rectangle = board.getRectangle(element);\n        const nearestPoint = engine.getNearestPoint(rectangle!, point);\n        const distance = distanceBetweenPointAndPoint(nearestPoint[0], nearestPoint[1], point[0], point[1]);\n        const isHitEdge = distance <= HIT_DISTANCE_BUFFER;\n        if (isHitEdge) {\n            return isHitEdge;\n        }\n        // when shape equals text, fill is not allowed\n        if (fill !== DefaultGeometryStyle.fill && fill !== TRANSPARENT && !PlaitDrawElement.isText(element)) {\n            const isHitInside = engine.isInsidePoint(rectangle!, point);\n            if (isHitInside) {\n                return isHitInside;\n            }\n        } else {\n            // if shape equals text, only check text rectangle\n            if (PlaitDrawElement.isText(element)) {\n                const textClient = getTextRectangle(element);\n                let isHitText = RectangleClient.isPointInRectangle(textClient, point);\n                return isHitText;\n            }\n\n            // check textRectangle of element\n            const textClient = engine.getTextRectangle ? engine.getTextRectangle(element) : getTextRectangle(element);\n            const isHitTextRectangle = RectangleClient.isPointInRectangle(textClient, point);\n            if (isHitTextRectangle) {\n                return isHitTextRectangle;\n            }\n        }\n    }\n    if (PlaitDrawElement.isImage(element)) {\n        return isRectangleHitDrawElement(board, element, { anchor: point, focus: point });\n    }\n\n    if (PlaitDrawElement.isLine(element)) {\n        return isHitLine(board, element, point);\n    }\n    return null;\n};\n\nexport const isHitElementInside = (board: PlaitBoard, element: PlaitElement, point: Point) => {\n    if (PlaitDrawElement.isGeometry(element)) {\n        const engine = getEngine(getShape(element));\n        const rectangle = board.getRectangle(element);\n        const isHitInside = engine.isInsidePoint(rectangle!, point);\n        if (isHitInside) {\n            return isHitInside;\n        }\n\n        if (engine.getTextRectangle) {\n            const textClient = engine.getTextRectangle(element);\n            const isHitTextRectangle = RectangleClient.isPointInRectangle(textClient, point);\n            if (isHitTextRectangle) {\n                return isHitTextRectangle;\n            }\n        }\n    }\n    if (PlaitDrawElement.isImage(element)) {\n        return isRectangleHitDrawElement(board, element, { anchor: point, focus: point });\n    }\n\n    if (PlaitDrawElement.isLine(element)) {\n        return isHitLine(board, element, point);\n    }\n\n    return null;\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hit.js","sourceRoot":"","sources":["../../../../packages/draw/src/utils/hit.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    PlaitElement,\n    RectangleClient,\n    Selection,\n    PlaitBoard,\n    isPolylineHitRectangle,\n    Point,\n    distanceBetweenPointAndSegments,\n    distanceBetweenPointAndPoint,\n    HIT_DISTANCE_BUFFER,\n    rotate\n} from '@plait/core';\nimport { PlaitDrawElement, PlaitGeometry, PlaitLine } from '../interfaces';\nimport { TRANSPARENT, rotatePoints } from '@plait/common';\nimport { getTextRectangle } from './geometry';\nimport { getLinePoints } from './line/line-basic';\nimport { getFillByElement } from './style/stroke';\nimport { DefaultGeometryStyle } from '../constants/geometry';\nimport { getEngine } from '../engines';\nimport { getShape } from './shape';\nimport { getHitLineTextIndex } from './position/line';\n\nexport const isTextExceedingBounds = (geometry: PlaitGeometry) => {\n    const client = RectangleClient.getRectangleByPoints(geometry.points);\n    if (geometry.textHeight > client.height) {\n        return true;\n    }\n    return false;\n};\n\nexport const isHitLineText = (board: PlaitBoard, element: PlaitLine, point: Point) => {\n    return getHitLineTextIndex(board, element, point) !== -1;\n};\n\nexport const isHitPolyLine = (pathPoints: Point[], point: Point) => {\n    const distance = distanceBetweenPointAndSegments(pathPoints, point);\n    return distance <= HIT_DISTANCE_BUFFER;\n};\n\nexport const isHitLine = (board: PlaitBoard, element: PlaitLine, point: Point) => {\n    const points = getLinePoints(board, element);\n    const isHitText = isHitLineText(board, element, point);\n    return isHitText || isHitPolyLine(points, point);\n};\n\nexport const isRectangleHitDrawElement = (board: PlaitBoard, element: PlaitElement, selection: Selection) => {\n    const rangeRectangle = RectangleClient.getRectangleByPoints([selection.anchor, selection.focus]);\n    if (PlaitDrawElement.isGeometry(element)) {\n        const client = RectangleClient.getRectangleByPoints(element.points);\n        const centerPoint = RectangleClient.getCenterPoint(client);\n        let rotatedCornerPoints = rotatePoints(RectangleClient.getCornerPoints(client), centerPoint, element.angle);\n        if (isTextExceedingBounds(element)) {\n            const textClient = getTextRectangle(element);\n            rotatedCornerPoints = rotatePoints(RectangleClient.getCornerPoints(textClient), centerPoint, element.angle);\n        }\n        return isPolylineHitRectangle(rotatedCornerPoints, rangeRectangle);\n    }\n\n    if (PlaitDrawElement.isImage(element)) {\n        const client = RectangleClient.getRectangleByPoints(element.points);\n        const rotatedCornerPoints = rotatePoints(\n            RectangleClient.getCornerPoints(client),\n            RectangleClient.getCenterPoint(client),\n            element.angle\n        );\n        return isPolylineHitRectangle(rotatedCornerPoints, client);\n    }\n\n    if (PlaitDrawElement.isLine(element)) {\n        const points = getLinePoints(board, element);\n        return isPolylineHitRectangle(points, rangeRectangle);\n    }\n   return null;\n};\n\nexport const isHitDrawElement = (board: PlaitBoard, element: PlaitElement, point: Point) => {\n    const rectangle = board.getRectangle(element);\n    const centerPoint = RectangleClient.getCenterPoint(rectangle!);\n    if (element.angle) {\n        point = rotate(point[0], point[1], centerPoint[0], centerPoint[1], -element.angle) as Point;\n    }\n    if (PlaitDrawElement.isGeometry(element)) {\n        const fill = getFillByElement(board, element);\n        const engine = getEngine(getShape(element));\n        const nearestPoint = engine.getNearestPoint(rectangle!, point);\n        const distance = distanceBetweenPointAndPoint(nearestPoint[0], nearestPoint[1], point[0], point[1]);\n        const isHitEdge = distance <= HIT_DISTANCE_BUFFER;\n        if (isHitEdge) {\n            return isHitEdge;\n        }\n        // when shape equals text, fill is not allowed\n        if (fill !== DefaultGeometryStyle.fill && fill !== TRANSPARENT && !PlaitDrawElement.isText(element)) {\n            const isHitInside = engine.isInsidePoint(rectangle!, point);\n            if (isHitInside) {\n                return isHitInside;\n            }\n        } else {\n            // if shape equals text, only check text rectangle\n            if (PlaitDrawElement.isText(element)) {\n                const textClient = getTextRectangle(element);\n                let isHitText = RectangleClient.isPointInRectangle(textClient, point);\n                return isHitText;\n            }\n\n            // check textRectangle of element\n            const textClient = engine.getTextRectangle ? engine.getTextRectangle(element) : getTextRectangle(element);\n            const isHitTextRectangle = RectangleClient.isPointInRectangle(textClient, point);\n            if (isHitTextRectangle) {\n                return isHitTextRectangle;\n            }\n        }\n    }\n    if (PlaitDrawElement.isImage(element)) {\n        return isRectangleHitDrawElement(board, element, { anchor: point, focus: point });\n    }\n\n    if (PlaitDrawElement.isLine(element)) {\n        return isHitLine(board, element, point);\n    }\n    return null;\n};\n\nexport const isHitElementInside = (board: PlaitBoard, element: PlaitElement, point: Point) => {\n    const rectangle = board.getRectangle(element);\n    const centerPoint = RectangleClient.getCenterPoint(rectangle!);\n    if (element.angle) {\n        point = rotate(point[0], point[1], centerPoint[0], centerPoint[1], -element.angle) as Point;\n    }\n    if (PlaitDrawElement.isGeometry(element)) {\n        const engine = getEngine(getShape(element));\n        const isHitInside = engine.isInsidePoint(rectangle!, point);\n        if (isHitInside) {\n            return isHitInside;\n        }\n\n        if (engine.getTextRectangle) {\n            const textClient = engine.getTextRectangle(element);\n            const isHitTextRectangle = RectangleClient.isPointInRectangle(textClient, point);\n            if (isHitTextRectangle) {\n                return isHitTextRectangle;\n            }\n        }\n    }\n    if (PlaitDrawElement.isImage(element)) {\n        return isRectangleHitDrawElement(board, element, { anchor: point, focus: point });\n    }\n\n    if (PlaitDrawElement.isLine(element)) {\n        return isHitLine(board, element, point);\n    }\n\n    return null;\n};\n"]}

package/esm2022/utils/resize-align.mjs

@@ -1,6 +1,6 @@
 import { RectangleClient, getRectangleByElements } from '@plait/core';
 import { getResizeZoom, movePointByZoomAndOriginPoint } from '../plugins/with-draw-resize';
-import { getDirectionFactorByVectorComponent, getUnitVectorByPointAndPoint } from '@plait/common';
+import { getDirectionFactorByDirectionComponent, getUnitVectorByPointAndPoint } from '@plait/common';
 import { ResizeAlignReaction } from './resize-align-reaction';
 export function getResizeAlignRef(board, resizeRef, resizeState, resizeOriginPointAndHandlePoint, isAspectRatio, isFromCorner) {
     const { originPoint, handlePoint } = resizeOriginPointAndHandlePoint;
@@ -29,9 +29,9 @@ export function getResizeAlignRef(board, resizeRef, resizeState, resizeOriginPoi
         activeRectangle,
         originPoint,
         handlePoint,
-        directionFactors: [getDirectionFactorByVectorComponent(x), getDirectionFactorByVectorComponent(y)],
+        directionFactors: [getDirectionFactorByDirectionComponent(x), getDirectionFactorByDirectionComponent(y)],
         isAspectRatio,
         isFromCorner
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2022/plait-draw.mjs

@@ -1,5 +1,5 @@
-import { ACTIVE_STROKE_WIDTH, ThemeColorMode, Point, RectangleClient, getElementById, createG, arrowPoints, createPath, distanceBetweenPointAndPoint, drawLinearPath, rotate, depthFirstRecursion, getIsRecursionFunc, idCreator, catmullRomFitting, PlaitBoard, findElements, createMask, createRect, getSelectedElements, distanceBetweenPointAndSegments, HIT_DISTANCE_BUFFER, isPolylineHitRectangle, setStrokeLinecap, isPointInPolygon, getNearestPointBetweenPointAndSegments, isPointInEllipse, getEllipseTangentSlope, getVectorFromPointAndSlope, drawRectangle, drawRoundRectangle, isPointInRoundRectangle, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, drawCircle, Transforms, clearSelectedElement, addSelectedElement, BoardTransforms, PlaitPointerType, Direction, Path, PlaitNode, toViewBoxPoint, toHostPoint, isSelectionMoving, RgbaToHEX, PlaitElement, preventTouchMove, createClipboardContext, WritableClipboardType, addClipboardContext, getRectangleByElements, getHitElementByPoint, CursorClass, temporaryDisableSelection, PRESS_AND_MOVE_BUFFER } from '@plait/core';
-import { removeDuplicatePoints, generateElbowLineRoute, simplifyOrthogonalPoints, isSourceAndTargetIntersect, getPoints, getPointByVector, getExtendPoint, getUnitVectorByPointAndPoint, Generator, getRectangleResizeHandleRefs, RESIZE_HANDLE_DIAMETER, getMemorizedLatest, memorizeLatest, getPointOnPolyline, TRANSPARENT, getCrossingPointsBetweenPointAndSegment, isPointOnSegment, getDirectionByVector, getOppositeDirection, getDirectionFactor, getDirectionByPointOfRectangle, rotateVectorAnti90, getSourceAndTargetOuterRectangle, getNextPoint, normalizeShapePoints, getFirstTextEditor, PRIMARY_COLOR, CommonPluginElement, ActiveGenerator, WithTextPluginKey, drawPrimaryHandle, drawFillPrimaryHandle, isVirtualKey, isDelete, isSpaceHotkey, isDndMode, isDrawingMode, getElementsText, acceptImageTypes, getElementOfFocusedImage, buildImage, getDirectionFactorByVectorComponent, isCornerHandle, getFirstTextManage, withResize, drawHandle, getIndexByResizeHandle, getSymmetricHandleIndex, getResizeHandlePointByIndex, isResizingByCondition, getRatioByPoint, ImageGenerator, ResizeHandle } from '@plait/common';
+import { ACTIVE_STROKE_WIDTH, ThemeColorMode, Point, RectangleClient, getElementById, createG, arrowPoints, createPath, distanceBetweenPointAndPoint, drawLinearPath, rotate, depthFirstRecursion, getIsRecursionFunc, idCreator, catmullRomFitting, PlaitBoard, findElements, createMask, createRect, getSelectedElements, distanceBetweenPointAndSegments, HIT_DISTANCE_BUFFER, isPolylineHitRectangle, setStrokeLinecap, isPointInPolygon, getNearestPointBetweenPointAndSegments, isPointInEllipse, getEllipseTangentSlope, getVectorFromPointAndSlope, drawRectangle, drawRoundRectangle, isPointInRoundRectangle, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, drawCircle, Transforms, clearSelectedElement, addSelectedElement, BoardTransforms, PlaitPointerType, Direction, Path, PlaitNode, toViewBoxPoint, toHostPoint, isSelectionMoving, RgbaToHEX, PlaitElement, preventTouchMove, createClipboardContext, WritableClipboardType, addClipboardContext, getRectangleByElements, getHitElementByPoint, CursorClass, temporaryDisableSelection, PRESS_AND_MOVE_BUFFER, getRectangleByGroup, getElementsInGroup, isSelectedElementOrGroup, PlaitGroupElement } from '@plait/core';
+import { removeDuplicatePoints, generateElbowLineRoute, simplifyOrthogonalPoints, isSourceAndTargetIntersect, getPoints, getPointByVector, getExtendPoint, getUnitVectorByPointAndPoint, Generator, getRectangleResizeHandleRefs, RESIZE_HANDLE_DIAMETER, getMemorizedLatest, memorizeLatest, getPointOnPolyline, rotatePoints, TRANSPARENT, getCrossingPointsBetweenPointAndSegment, isPointOnSegment, getDirectionByVector, getOppositeDirection, getDirectionFactor, getDirectionByPointOfRectangle, rotateVectorAnti90, getSourceAndTargetOuterRectangle, getNextPoint, normalizeShapePoints, getFirstTextEditor, PRIMARY_COLOR, CommonPluginElement, ActiveGenerator, WithTextPluginKey, drawPrimaryHandle, drawFillPrimaryHandle, isVirtualKey, isDelete, isSpaceHotkey, isDndMode, isDrawingMode, getElementsText, acceptImageTypes, getElementOfFocusedImage, buildImage, getDirectionFactorByDirectionComponent, isCornerHandle, getFirstTextManage, withResize, drawHandle, getIndexByResizeHandle, getSymmetricHandleIndex, getResizeHandlePointByIndex, isResizingByCondition, getRatioByPoint, ImageGenerator, ResizeHandle } from '@plait/common';
 import { Alignment, buildText, DEFAULT_FONT_SIZE, getTextSize, AlignEditor, TextManage } from '@plait/text';
 import { pointsOnBezierCurves } from 'points-on-curve';
 import * as i0 from '@angular/core';
@@ -1146,15 +1146,18 @@ const isRectangleHitDrawElement = (board, element, selection) => {
     const rangeRectangle = RectangleClient.getRectangleByPoints([selection.anchor, selection.focus]);
     if (PlaitDrawElement.isGeometry(element)) {
         const client = RectangleClient.getRectangleByPoints(element.points);
+        const centerPoint = RectangleClient.getCenterPoint(client);
+        let rotatedCornerPoints = rotatePoints(RectangleClient.getCornerPoints(client), centerPoint, element.angle);
         if (isTextExceedingBounds(element)) {
             const textClient = getTextRectangle(element);
-            return RectangleClient.isHit(rangeRectangle, client) || RectangleClient.isHit(rangeRectangle, textClient);
+            rotatedCornerPoints = rotatePoints(RectangleClient.getCornerPoints(textClient), centerPoint, element.angle);
         }
-        return RectangleClient.isHit(rangeRectangle, client);
+        return isPolylineHitRectangle(rotatedCornerPoints, rangeRectangle);
     }
     if (PlaitDrawElement.isImage(element)) {
         const client = RectangleClient.getRectangleByPoints(element.points);
-        return RectangleClient.isHit(rangeRectangle, client);
+        const rotatedCornerPoints = rotatePoints(RectangleClient.getCornerPoints(client), RectangleClient.getCenterPoint(client), element.angle);
+        return isPolylineHitRectangle(rotatedCornerPoints, client);
     }
     if (PlaitDrawElement.isLine(element)) {
         const points = getLinePoints(board, element);
@@ -1163,10 +1166,14 @@ const isRectangleHitDrawElement = (board, element, selection) => {
     return null;
 };
 const isHitDrawElement = (board, element, point) => {
+    const rectangle = board.getRectangle(element);
+    const centerPoint = RectangleClient.getCenterPoint(rectangle);
+    if (element.angle) {
+        point = rotate(point[0], point[1], centerPoint[0], centerPoint[1], -element.angle);
+    }
     if (PlaitDrawElement.isGeometry(element)) {
         const fill = getFillByElement(board, element);
         const engine = getEngine(getShape(element));
-        const rectangle = board.getRectangle(element);
         const nearestPoint = engine.getNearestPoint(rectangle, point);
         const distance = distanceBetweenPointAndPoint(nearestPoint[0], nearestPoint[1], point[0], point[1]);
         const isHitEdge = distance <= HIT_DISTANCE_BUFFER;
@@ -1204,9 +1211,13 @@ const isHitDrawElement = (board, element, point) => {
     return null;
 };
 const isHitElementInside = (board, element, point) => {
+    const rectangle = board.getRectangle(element);
+    const centerPoint = RectangleClient.getCenterPoint(rectangle);
+    if (element.angle) {
+        point = rotate(point[0], point[1], centerPoint[0], centerPoint[1], -element.angle);
+    }
     if (PlaitDrawElement.isGeometry(element)) {
         const engine = getEngine(getShape(element));
-        const rectangle = board.getRectangle(element);
         const isHitInside = engine.isInsidePoint(rectangle, point);
         if (isHitInside) {
             return isHitInside;
@@ -3090,10 +3101,14 @@ class GeometryComponent extends CommonPluginElement {
     drawText() {
         this.textManage.draw(this.element.text);
         this.g.append(this.textManage.g);
+        const centerPoint = RectangleClient.getCenterPoint(this.board.getRectangle(this.element));
+        this.textManage.updateAngle(centerPoint, this.element.angle);
     }
     updateText() {
         this.textManage.updateText(this.element.text);
         this.textManage.updateRectangle();
+        const centerPoint = RectangleClient.getCenterPoint(this.board.getRectangle(this.element));
+        this.textManage.updateAngle(centerPoint, this.element.angle);
     }
     initializeTextManage() {
         const plugins = (this.board.getPluginOptions(WithTextPluginKey) || {}).textPlugins;
@@ -3136,10 +3151,10 @@ class GeometryComponent extends CommonPluginElement {
         this.activeGenerator.destroy();
         this.lineAutoCompleteGenerator.destroy();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GeometryComponent, deps: [{ token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: GeometryComponent, isStandalone: true, selector: "plait-draw-geometry", usesInheritance: true, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.8", ngImport: i0, type: GeometryComponent, deps: [{ token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.8", type: GeometryComponent, isStandalone: true, selector: "plait-draw-geometry", usesInheritance: true, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GeometryComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.8", ngImport: i0, type: GeometryComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'plait-draw-geometry',
@@ -3381,10 +3396,10 @@ class LineComponent extends CommonPluginElement {
         this.destroy$.complete();
         this.destroyTextManages();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LineComponent, deps: [{ token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: LineComponent, isStandalone: true, selector: "plait-draw-line", usesInheritance: true, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.8", ngImport: i0, type: LineComponent, deps: [{ token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.8", type: LineComponent, isStandalone: true, selector: "plait-draw-line", usesInheritance: true, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LineComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.8", ngImport: i0, type: LineComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'plait-draw-line',
@@ -4101,7 +4116,7 @@ function getResizeAlignRef(board, resizeRef, resizeState, resizeOriginPointAndHa
         activeRectangle,
         originPoint,
         handlePoint,
-        directionFactors: [getDirectionFactorByVectorComponent(x), getDirectionFactorByVectorComponent(y)],
+        directionFactors: [getDirectionFactorByDirectionComponent(x), getDirectionFactorByDirectionComponent(y)],
         isAspectRatio,
         isFromCorner
     });
@@ -4615,10 +4630,10 @@ class ImageComponent extends CommonPluginElement {
         this.imageGenerator.destroy();
         this.lineAutoCompleteGenerator.destroy();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ImageComponent, deps: [{ token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: ImageComponent, isStandalone: true, selector: "plait-draw-geometry", usesInheritance: true, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.8", ngImport: i0, type: ImageComponent, deps: [{ token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.8", type: ImageComponent, isStandalone: true, selector: "plait-draw-geometry", usesInheritance: true, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ImageComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.8", ngImport: i0, type: ImageComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'plait-draw-geometry',
@@ -4772,6 +4787,66 @@ const withLineTextMove = (board) => {
     return board;
 };
 
+class GroupGenerator extends Generator {
+    canDraw(element) {
+        return true;
+    }
+    draw(element, partialSelected) {
+        const options = {
+            stroke: '',
+            strokeWidth: ACTIVE_STROKE_WIDTH,
+            strokeLineDash: [5]
+        };
+        if (partialSelected) {
+            options.stroke = '#999';
+        }
+        const rectangle = getRectangleByGroup(this.board, element, true);
+        return drawRectangle(this.board, rectangle, options);
+    }
+}
+
+class GroupComponent extends CommonPluginElement {
+    constructor(viewContainerRef, cdr) {
+        super(cdr);
+        this.viewContainerRef = viewContainerRef;
+        this.cdr = cdr;
+    }
+    initializeGenerator() {
+        this.activeGenerator = new ActiveGenerator(this.board, {
+            getRectangle: (element) => {
+                return getRectangleByGroup(this.board, element);
+            },
+            getStrokeWidth: () => 0,
+            getStrokeOpacity: () => 0,
+            hasResizeHandle: () => {
+                return !isSelectionMoving(this.board);
+            }
+        });
+        this.groupGenerator = new GroupGenerator(this.board);
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.initializeGenerator();
+    }
+    onContextChanged(value, previous) {
+        const elementsInGroup = getElementsInGroup(this.board, value.element, false, true);
+        const isPartialSelectGroup = elementsInGroup.some(item => isSelectedElementOrGroup(this.board, item)) &&
+            !elementsInGroup.every(item => isSelectedElementOrGroup(this.board, item));
+        this.groupGenerator.processDrawing(value.element, this.g, isPartialSelectGroup);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.8", ngImport: i0, type: GroupComponent, deps: [{ token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.8", type: GroupComponent, isStandalone: true, selector: "plait-group", usesInheritance: true, ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.8", ngImport: i0, type: GroupComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'plait-group',
+                    template: ``,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.ChangeDetectorRef }]; } });
+
 const withDraw = (board) => {
     const { drawElement, getRectangle, isRectangleHit, isHit, isInsidePoint, isMovable, isAlign, getRelatedFragment } = board;
     board.drawElement = (context) => {
@@ -4784,6 +4859,9 @@ const withDraw = (board) => {
         else if (PlaitDrawElement.isImage(context.element)) {
             return ImageComponent;
         }
+        else if (PlaitGroupElement.isGroup(context.element)) {
+            return GroupComponent;
+        }
         return drawElement(context);
     };
     board.getRectangle = (element) => {
@@ -4802,6 +4880,9 @@ const withDraw = (board) => {
         if (PlaitDrawElement.isImage(element)) {
             return RectangleClient.getRectangleByPoints(element.points);
         }
+        if (PlaitGroupElement.isGroup(element)) {
+            return getRectangleByGroup(board, element);
+        }
         return getRectangle(element);
     };
     board.isRectangleHit = (element, selection) => {