@plait/draw 0.1.0-next.8 → 0.28.0

package/generators/line-active.generator.d.ts

@@ -1,9 +1,12 @@
+import { PlaitBoard, Point } from '@plait/core';
 import { PlaitLine } from '../interfaces';
 import { Generator } from '@plait/common';
 export interface ActiveData {
     selected: boolean;
 }
 export declare class LineActiveGenerator extends Generator<PlaitLine, ActiveData> {
+    hasResizeHandle: boolean;
     canDraw(element: PlaitLine, data: ActiveData): boolean;
     baseDraw(element: PlaitLine, data: ActiveData): SVGGElement;
 }
+export declare function getMiddlePoints(board: PlaitBoard, element: PlaitLine): Point[];

package/generators/line.generator.d.ts

@@ -4,5 +4,5 @@ export interface ShapeData {
 }
 export declare class LineShapeGenerator extends Generator<PlaitLine, ShapeData> {
     canDraw(element: PlaitLine, data: ShapeData): boolean;
-    baseDraw(element: PlaitLine, data: ShapeData): SVGGElement | undefined;
+    baseDraw(element: PlaitLine, data: ShapeData): SVGGElement;
 }

package/geometry.component.d.ts

@@ -23,5 +23,5 @@ export declare class GeometryComponent extends CommonPluginElement<PlaitGeometry
     initializeTextManage(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<GeometryComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<GeometryComponent, "plait-draw-geometry", never, {}, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GeometryComponent, "plait-draw-geometry", never, {}, {}, never, never, true, never>;
 }

package/image.component.d.ts

@@ -0,0 +1,20 @@
+import { ChangeDetectorRef, OnDestroy, OnInit, ViewContainerRef } from '@angular/core';
+import { PlaitBoard, PlaitPluginElementContext, OnContextChanged } from '@plait/core';
+import { Subject } from 'rxjs';
+import { CommonPluginElement, ImageGenerator } from '@plait/common';
+import { PlaitImage } from './interfaces/image';
+import * as i0 from "@angular/core";
+export declare class ImageComponent extends CommonPluginElement<PlaitImage, PlaitBoard> implements OnInit, OnDestroy, OnContextChanged<PlaitImage, PlaitBoard> {
+    private viewContainerRef;
+    protected cdr: ChangeDetectorRef;
+    destroy$: Subject<void>;
+    get activeGenerator(): import("@plait/common").ActiveGenerator<import("@plait/core").PlaitElement>;
+    imageGenerator: ImageGenerator<PlaitImage>;
+    constructor(viewContainerRef: ViewContainerRef, cdr: ChangeDetectorRef);
+    initializeGenerator(): void;
+    ngOnInit(): void;
+    onContextChanged(value: PlaitPluginElementContext<PlaitImage, PlaitBoard>, previous: PlaitPluginElementContext<PlaitImage, PlaitBoard>): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageComponent, "plait-draw-geometry", never, {}, {}, never, never, true, never>;
+}

package/interfaces/geometry.d.ts

@@ -1,4 +1,4 @@
-import { PlaitBoard, PlaitElement, Point, RectangleClient } from '@plait/core';
+import { PlaitBoard, PlaitElement, Point, PointOfRectangle, RectangleClient, Vector } from '@plait/core';
 import { Options } from 'roughjs/bin/core';
 import { ParagraphElement } from '@plait/text';
 import { StrokeStyle } from './element';
@@ -8,7 +8,21 @@ export declare enum GeometryShape {
     diamond = "diamond",
     roundRectangle = "roundRectangle",
     parallelogram = "parallelogram",
-    text = "text"
+    text = "text",
+    triangle = "triangle",
+    leftArrow = "leftArrow",
+    trapezoid = "trapezoid",
+    rightArrow = "rightArrow",
+    cross = "cross",
+    star = "star",
+    pentagon = "pentagon",
+    hexagon = "hexagon",
+    octagon = "octagon",
+    pentagonArrow = "pentagonArrow",
+    processArrow = "processArrow",
+    twoWayArrow = "twoWayArrow",
+    comment = "comment",
+    roundComment = "roundComment"
 }
 export interface PlaitGeometry extends PlaitElement {
     points: [Point, Point];
@@ -40,5 +54,9 @@ export interface ShapeEngine {
     isHit: (rectangle: RectangleClient, point: Point) => boolean;
     getNearestPoint: (rectangle: RectangleClient, point: Point) => Point;
     getConnectorPoints: (rectangle: RectangleClient) => Point[];
+    getCornerPoints: (rectangle: RectangleClient) => Point[];
+    getEdgeByConnectionPoint?: (rectangle: RectangleClient, point: PointOfRectangle) => [Point, Point] | null;
+    getTangentVectorByConnectionPoint?: (rectangle: RectangleClient, point: PointOfRectangle) => Vector | null;
     draw: (board: PlaitBoard, rectangle: RectangleClient, options: Options) => SVGGElement;
+    getTextRectangle?: (element: PlaitGeometry) => RectangleClient;
 }

package/interfaces/image.d.ts

@@ -0,0 +1,7 @@
+import { PlaitElement, Point } from '@plait/core';
+export interface PlaitImage extends PlaitElement {
+    points: [Point, Point];
+    type: 'image';
+    url: string;
+    angle: number;
+}

package/interfaces/index.d.ts

@@ -1,14 +1,18 @@
 import { PlaitGeometry } from './geometry';
+import { PlaitImage } from './image';
 import { PlaitLine } from './line';
 import { PlaitText } from './text';
 export * from './line';
 export * from './geometry';
 export * from './text';
 export * from './element';
-export type PlaitDrawElement = PlaitGeometry | PlaitLine;
+export type PlaitDrawElement = PlaitGeometry | PlaitLine | PlaitImage;
+export type PlaitShape = PlaitGeometry | PlaitImage;
 export declare const PlaitDrawElement: {
     isGeometry: (value: any) => value is PlaitGeometry;
     isLine: (value: any) => value is PlaitLine;
     isText: (value: any) => value is PlaitText;
+    isImage: (value: any) => value is PlaitImage;
     isDrawElement: (value: any) => value is PlaitDrawElement;
+    isShape: (value: any) => boolean;
 };

package/interfaces/line.d.ts

@@ -1,13 +1,18 @@
-import { PlaitElement, Point } from '@plait/core';
+import { Direction, PlaitBoard, PlaitElement, Point, PointOfRectangle, Vector } from '@plait/core';
 import { Element } from 'slate';
 import { PlaitGeometry } from './geometry';
 import { StrokeStyle } from './element';
+import { PlaitImage } from '../interfaces/image';
 export declare enum LineMarkerType {
     arrow = "arrow",
     none = "none",
     openTriangle = "open-triangle",
     solidTriangle = "solid-triangle",
-    sharpArrow = "sharp-arrow"
+    sharpArrow = "sharp-arrow",
+    oneSideUp = "one-side-up",
+    oneSideDown = "one-side-down",
+    hollowTriangle = "hollow-triangle",
+    singleSlash = "single-slash"
 }
 export declare enum LineShape {
     straight = "straight",
@@ -26,9 +31,16 @@ export interface LineText {
 }
 export interface LineHandle {
     boundId?: string;
-    connection?: Point;
+    connection?: PointOfRectangle;
     marker: LineMarkerType;
 }
+export interface LineHandleRef {
+    key: LineHandleKey;
+    direction: Direction;
+    point: PointOfRectangle;
+    vector: Vector;
+    boundElement?: PlaitGeometry;
+}
 export interface PlaitLine extends PlaitElement {
     type: 'line';
     shape: LineShape;
@@ -52,8 +64,10 @@ export interface PlaitElbowLine extends PlaitLine {
 }
 export declare const PlaitLine: {
     getTextEditors(element: PlaitLine): (import("slate").BaseEditor & import("slate-angular").AngularEditor & import("slate-history").HistoryEditor)[];
+    isSourceMarkOrTargetMark(line: PlaitLine, markType: LineMarkerType, handleKey: LineHandleKey): boolean;
     isSourceMark(line: PlaitLine, markType: LineMarkerType): boolean;
     isTargetMark(line: PlaitLine, markType: LineMarkerType): boolean;
-    isBoundElementOfSource(line: PlaitLine, element: PlaitGeometry): boolean;
-    isBoundElementOfTarget(line: PlaitLine, element: PlaitGeometry): boolean;
+    isBoundElementOfSource(line: PlaitLine, element: PlaitGeometry | PlaitImage): boolean;
+    isBoundElementOfTarget(line: PlaitLine, element: PlaitGeometry | PlaitImage): boolean;
+    getPoints(board: PlaitBoard, line: PlaitLine): Point[];
 };

package/line.component.d.ts

@@ -23,6 +23,7 @@ export declare class LineComponent extends PlaitPluginElementComponent<PlaitLine
     ngOnInit(): void;
     getBoundedElements(): BoundedElements;
     onContextChanged(value: PlaitPluginElementContext<PlaitLine, PlaitBoard>, previous: PlaitPluginElementContext<PlaitLine, PlaitBoard>): void;
+    hasResizeHandle(): boolean;
     initializeTextManages(): void;
     destroyTextManages(): void;
     drawText(): void;
@@ -31,6 +32,6 @@ export declare class LineComponent extends PlaitPluginElementComponent<PlaitLine
     updateTextRectangle(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<LineComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LineComponent, "plait-draw-line", never, {}, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LineComponent, "plait-draw-line", never, {}, {}, never, never, true, never>;
 }
 export {};

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@plait/draw",
-  "version": "0.1.0-next.8",
+  "version": "0.28.0",
   "peerDependencies": {
     "@angular/common": "^16.0.0",
-    "@angular/core": "^16.0.0"
+    "@angular/core": "^16.0.0",
+    "is-hotkey": "^0.2.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"

package/plugins/with-draw-fragment.d.ts

@@ -1,2 +1,4 @@
 import { PlaitBoard } from '@plait/core';
+import { PlaitLine, PlaitShape } from '../interfaces';
 export declare const withDrawFragment: (baseBoard: PlaitBoard) => PlaitBoard;
+export declare const getBoundedLineElements: (board: PlaitBoard, plaitShapes: PlaitShape[]) => PlaitLine[];

package/plugins/with-geometry-create.d.ts

@@ -1,3 +1,3 @@
 import { PlaitBoard } from '@plait/core';
 export declare const withGeometryCreateByDrag: (board: PlaitBoard) => PlaitBoard;
-export declare const withGeometryCreateByDraw: (board: PlaitBoard) => PlaitBoard;
+export declare const withGeometryCreateByDrawing: (board: PlaitBoard) => PlaitBoard;

package/styles/styles.scss

@@ -4,8 +4,8 @@
             cursor: default;
         }
     }
-    &.pointer-rectangle,
-    &.pointer-line {
+    &:not(.pointer-text):not(.pointer-selection):not(.pointer-hand)
+     {
         .board-host-svg {
             cursor: crosshair;
         }

package/transforms/image.d.ts

@@ -0,0 +1,3 @@
+import { CommonImageItem } from '@plait/common';
+import { PlaitBoard, Point } from '@plait/core';
+export declare const insertImage: (board: PlaitBoard, imageItem: CommonImageItem, startPoint?: Point) => void;

package/transforms/index.d.ts

@@ -8,4 +8,5 @@ export declare const DrawTransforms: {
     setLineTexts: (board: import("@plait/core").PlaitBoard, element: import("@plait/draw").PlaitLine, texts: import("@plait/draw").LineText[]) => void;
     removeLineText: (board: import("@plait/core").PlaitBoard, element: import("@plait/draw").PlaitLine, index: number) => void;
     setLineMark: (board: import("@plait/core").PlaitBoard, element: import("@plait/draw").PlaitLine, handleKey: import("@plait/draw").LineHandleKey, marker: import("@plait/draw").LineMarkerType) => void;
+    insertImage: (board: import("@plait/core").PlaitBoard, imageItem: import("@plait/common").CommonImageItem, startPoint?: import("@plait/core").Point | undefined) => void;
 };

package/utils/geometry.d.ts

@@ -14,3 +14,4 @@ export declare const drawBoundMask: (board: PlaitBoard, element: PlaitGeometry)
 export declare const drawGeometry: (board: PlaitBoard, outerRectangle: RectangleClient, shape: GeometryShape, options: Options) => SVGGElement;
 export declare const getNearestPoint: (element: PlaitGeometry, point: Point, inflateDelta?: number) => Point;
 export declare const getCenterPointsOnPolygon: (points: Point[]) => Point[];
+export declare const getEdgeOnPolygonByPoint: (corners: Point[], point: Point) => [Point, Point] | null;

package/utils/line.d.ts

@@ -1,17 +1,25 @@
-import { Point, PlaitBoard, RectangleClient } from '@plait/core';
-import { LineHandle, LineShape, PlaitGeometry, PlaitLine } from '../interfaces';
+import { Point, PlaitBoard, RectangleClient, PointOfRectangle, Direction, Vector } from '@plait/core';
+import { LineHandle, LineHandleRef, LineShape, PlaitGeometry, PlaitLine } from '../interfaces';
+import { Op } from 'roughjs/bin/core';
 export declare const createLineElement: (shape: LineShape, points: [Point, Point], source: LineHandle, target: LineHandle, options?: Pick<PlaitLine, 'strokeColor' | 'strokeWidth'>) => PlaitLine;
 export declare const getLinePoints: (board: PlaitBoard, element: PlaitLine) => Point[];
-export declare const getStraightPoints: (board: PlaitBoard, element: PlaitLine) => Point[];
+export declare const getLineHandleRefPair: (board: PlaitBoard, element: PlaitLine) => {
+    source: LineHandleRef;
+    target: LineHandleRef;
+};
 export declare const getElbowPoints: (board: PlaitBoard, element: PlaitLine) => Point[];
+export declare const getCurvePoints: (board: PlaitBoard, element: PlaitLine) => Point[];
+export declare const transformOpsToPoints: (ops: Op[]) => number[][];
 export declare const isHitPolyLine: (pathPoints: Point[], point: Point, strokeWidth: number, expand?: number) => boolean;
 export declare const getHitLineTextIndex: (board: PlaitBoard, element: PlaitLine, point: Point) => number;
 export declare const isHitLineText: (board: PlaitBoard, element: PlaitLine, point: Point) => boolean;
 export declare const drawLine: (board: PlaitBoard, element: PlaitLine) => SVGGElement;
-export declare const getSourcePoint: (board: PlaitBoard, element: PlaitLine) => Point;
-export declare const getTargetPoint: (board: PlaitBoard, element: PlaitLine) => Point;
-export declare const getConnectionPoint: (geometry: PlaitGeometry, connection: Point, offset: number) => Point;
+export declare const getConnectionPoint: (geometry: PlaitGeometry, connection: Point, direction?: Direction, delta?: number) => Point;
 export declare const transformPointToConnection: (board: PlaitBoard, point: Point, hitElement: PlaitGeometry) => Point;
 export declare const getHitConnectorPoint: (movingPoint: Point, hitElement: PlaitGeometry, rectangle: RectangleClient) => Point | undefined;
 export declare const getLineTextRectangle: (board: PlaitBoard, element: PlaitLine, index: number) => RectangleClient;
 export declare const getBoardLines: (board: PlaitBoard) => PlaitLine[];
+export declare const removeDuplicatePoints: (points: Point[]) => Point[];
+export declare const getExtendPoint: (source: Point, target: Point, extendDistance: number) => Point;
+export declare const Q2C: (points: Point[]) => Point[];
+export declare const getVectorByConnection: (boundElement: PlaitGeometry, connection: PointOfRectangle) => Vector;

package/utils/position/geometry.d.ts

@@ -1,6 +1,7 @@
 import { PlaitBoard, Point } from '@plait/core';
 import { PlaitGeometry } from '../../interfaces';
-export declare const getHitGeometryResizeHandleRef: (board: PlaitBoard, element: PlaitGeometry, point: Point) => {
+import { PlaitImage } from '../../interfaces/image';
+export declare const getHitGeometryResizeHandleRef: (board: PlaitBoard, element: PlaitGeometry | PlaitImage, point: Point) => {
     rectangle: {
         x: number;
         y: number;

package/utils/position/line.d.ts

@@ -1,10 +1,14 @@
-import { PlaitBoard, Point, RectangleClient } from '@plait/core';
+import { PlaitBoard, Point } from '@plait/core';
 import { PlaitLine } from '../../interfaces';
 export declare enum LineResizeHandle {
     'source' = "source",
-    'target' = "target"
+    'target' = "target",
+    'addHandle' = "addHandle"
 }
 export declare const getHitLineResizeHandleRef: (board: PlaitBoard, element: PlaitLine, point: Point) => {
-    rectangle: RectangleClient;
     handle: LineResizeHandle;
+    index: number;
+} | {
+    index: number;
+    handle?: undefined;
 } | undefined;

package/utils/selected.d.ts

@@ -1,5 +1,7 @@
 import { PlaitBoard } from '@plait/core';
 import { PlaitDrawElement, PlaitGeometry, PlaitLine } from '../interfaces';
+import { PlaitImage } from '../interfaces/image';
 export declare const getSelectedDrawElements: (board: PlaitBoard) => PlaitDrawElement[];
 export declare const getSelectedGeometryElements: (board: PlaitBoard) => PlaitGeometry[];
 export declare const getSelectedLineElements: (board: PlaitBoard) => PlaitLine[];
+export declare const getSelectedImageElements: (board: PlaitBoard) => PlaitImage[];

package/utils/shape.d.ts

@@ -0,0 +1,2 @@
+import { GeometryShape, PlaitShape } from '../interfaces';
+export declare const getShape: (value: PlaitShape) => GeometryShape;

package/esm2022/utils/engine/diamond.mjs

@@ -1,22 +0,0 @@
-import { PlaitBoard, RectangleClient, getNearestPointBetweenPointAndSegments, isPointInPolygon, setStrokeLinecap } from '@plait/core';
-export const DiamondEngine = {
-    draw(board, rectangle, options) {
-        const points = RectangleClient.getEdgeCenterPoints(rectangle);
-        const rs = PlaitBoard.getRoughSVG(board);
-        const polygon = rs.polygon(points, { ...options, fillStyle: 'solid' });
-        setStrokeLinecap(polygon, 'round');
-        return polygon;
-    },
-    isHit(rectangle, point) {
-        const controlPoints = RectangleClient.getEdgeCenterPoints(rectangle);
-        return isPointInPolygon(point, controlPoints);
-    },
-    getNearestPoint(rectangle, point) {
-        const connectorPoints = RectangleClient.getEdgeCenterPoints(rectangle);
-        return getNearestPointBetweenPointAndSegments(point, connectorPoints);
-    },
-    getConnectorPoints(rectangle) {
-        return RectangleClient.getEdgeCenterPoints(rectangle);
-    }
-};
-//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/engine/ellipse.mjs

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

package/esm2022/utils/engine/index.mjs

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

package/esm2022/utils/engine/parallelogram.mjs

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

package/esm2022/utils/engine/rectangle.mjs

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

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

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

package/utils/engine/parallelogram.d.ts

@@ -1,4 +0,0 @@
-import { Point, RectangleClient } from '@plait/core';
-import { ShapeEngine } from '../../interfaces';
-export declare const ParallelogramEngine: ShapeEngine;
-export declare const getParallelogramPoints: (rectangle: RectangleClient) => Point[];