@plait/draw 0.62.0-next.6 → 0.62.0-next.8

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

@@ -0,0 +1,13 @@
+import { Point } from '@plait/core';
+import { PlaitArrowLine } from '../interfaces';
+import { Generator } from '@plait/common';
+export interface ActiveData {
+    selected: boolean;
+    linePoints: Point[];
+}
+export declare class ArrowLineActiveGenerator extends Generator<PlaitArrowLine, ActiveData> {
+    onlySelectedCurrentLine: boolean;
+    canDraw(element: PlaitArrowLine, data: ActiveData): boolean;
+    draw(element: PlaitArrowLine, data: ActiveData): SVGGElement;
+    needUpdate(): boolean;
+}

package/generators/{line-auto-complete.generator.d.ts → arrow-line-auto-complete.generator.d.ts}

@@ -1,7 +1,7 @@
 import { PlaitBoard } from '@plait/core';
 import { PlaitGeometry, PlaitShapeElement } from '../interfaces';
 import { ActiveGeneratorExtraData, Generator } from '@plait/common';
-export declare class LineAutoCompleteGenerator<T extends PlaitShapeElement = PlaitGeometry> extends Generator<T, ActiveGeneratorExtraData> {
+export declare class ArrowLineAutoCompleteGenerator<T extends PlaitShapeElement = PlaitGeometry> extends Generator<T, ActiveGeneratorExtraData> {
     board: PlaitBoard;
     static key: string;
     autoCompleteG: SVGGElement;

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

@@ -0,0 +1,8 @@
+import { PlaitArrowLine } from '../interfaces';
+import { Generator } from '@plait/common';
+export interface ShapeData {
+}
+export declare class ArrowLineShapeGenerator extends Generator<PlaitArrowLine, ShapeData> {
+    canDraw(element: PlaitArrowLine, data: ShapeData): boolean;
+    draw(element: PlaitArrowLine, data: ShapeData): SVGGElement;
+}

package/generators/index.d.ts

@@ -1,6 +1,6 @@
 export * from './geometry-shape.generator';
-export * from './line-active.generator';
-export * from './line-auto-complete.generator';
+export * from './arrow-line-active.generator';
+export * from './arrow-line-auto-complete.generator';
 export * from './single-text.generator';
 export * from './text.generator';
 export * from './table.generator';

package/geometry.component.d.ts

@@ -2,12 +2,12 @@ import { PlaitBoard, PlaitPluginElementContext, OnContextChanged } from '@plait/
 import { PlaitCommonGeometry, PlaitMultipleTextGeometry } from './interfaces/geometry';
 import { GeometryShapeGenerator } from './generators/geometry-shape.generator';
 import { ActiveGenerator, CommonElementFlavour } from '@plait/common';
-import { LineAutoCompleteGenerator } from './generators/line-auto-complete.generator';
+import { ArrowLineAutoCompleteGenerator } from './generators/arrow-line-auto-complete.generator';
 import { TextGenerator } from './generators/text.generator';
 import { SingleTextGenerator } from './generators/single-text.generator';
 export declare class GeometryComponent extends CommonElementFlavour<PlaitCommonGeometry, PlaitBoard> implements OnContextChanged<PlaitCommonGeometry, PlaitBoard> {
     activeGenerator: ActiveGenerator<PlaitCommonGeometry>;
-    lineAutoCompleteGenerator: LineAutoCompleteGenerator;
+    lineAutoCompleteGenerator: ArrowLineAutoCompleteGenerator;
     shapeGenerator: GeometryShapeGenerator;
     textGenerator: TextGenerator<PlaitMultipleTextGeometry> | SingleTextGenerator;
     constructor();

package/image.component.d.ts

@@ -1,10 +1,10 @@
 import { PlaitBoard, PlaitPluginElementContext, OnContextChanged } from '@plait/core';
 import { CommonElementFlavour, ImageGenerator } from '@plait/common';
 import { PlaitImage } from './interfaces/image';
-import { LineAutoCompleteGenerator } from './generators/line-auto-complete.generator';
+import { ArrowLineAutoCompleteGenerator } from './generators/arrow-line-auto-complete.generator';
 export declare class ImageComponent extends CommonElementFlavour<PlaitImage, PlaitBoard> implements OnContextChanged<PlaitImage, PlaitBoard> {
     imageGenerator: ImageGenerator<PlaitImage>;
-    lineAutoCompleteGenerator: LineAutoCompleteGenerator<PlaitImage>;
+    lineAutoCompleteGenerator: ArrowLineAutoCompleteGenerator<PlaitImage>;
     constructor();
     initializeGenerator(): void;
     initialize(): void;

package/interfaces/arrow-line.d.ts

@@ -0,0 +1,75 @@
+import { Direction, PlaitBoard, PlaitElement, Point, PointOfRectangle, Vector } from '@plait/core';
+import { Element } from 'slate';
+import { StrokeStyle } from './element';
+import { PlaitShapeElement } from '.';
+export declare enum ArrowLineMarkerType {
+    arrow = "arrow",
+    none = "none",
+    openTriangle = "open-triangle",
+    solidTriangle = "solid-triangle",
+    sharpArrow = "sharp-arrow",
+    oneSideUp = "one-side-up",
+    oneSideDown = "one-side-down",
+    hollowTriangle = "hollow-triangle",
+    singleSlash = "single-slash"
+}
+export declare enum ArrowLineShape {
+    straight = "straight",
+    curve = "curve",
+    elbow = "elbow"
+}
+export declare enum ArrowLineHandleKey {
+    source = "source",
+    target = "target"
+}
+export interface ArrowLineText {
+    text: Element;
+    position: number;
+    width: number;
+    height: number;
+}
+export interface ArrowLineHandle {
+    boundId?: string;
+    connection?: PointOfRectangle;
+    marker: ArrowLineMarkerType;
+}
+export interface ArrowLineHandleRef {
+    key: ArrowLineHandleKey;
+    direction: Direction;
+    point: PointOfRectangle;
+    vector: Vector;
+    boundElement?: PlaitShapeElement;
+}
+export interface ArrowLineHandleRefPair {
+    source: ArrowLineHandleRef;
+    target: ArrowLineHandleRef;
+}
+export interface PlaitArrowLine extends PlaitElement {
+    type: 'arrow-line';
+    shape: ArrowLineShape;
+    points: Point[];
+    source: ArrowLineHandle;
+    target: ArrowLineHandle;
+    texts: ArrowLineText[];
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeStyle?: StrokeStyle;
+    opacity: number;
+}
+export interface PlaitStraightArrowLine extends PlaitArrowLine {
+    shape: ArrowLineShape.straight;
+}
+export interface PlaitCurveArrowLine extends PlaitArrowLine {
+    shape: ArrowLineShape.curve;
+}
+export interface PlaitElbowArrowLine extends PlaitArrowLine {
+    shape: ArrowLineShape.elbow;
+}
+export declare const PlaitArrowLine: {
+    isSourceMarkOrTargetMark(line: PlaitArrowLine, markType: ArrowLineMarkerType, handleKey: ArrowLineHandleKey): boolean;
+    isSourceMark(line: PlaitArrowLine, markType: ArrowLineMarkerType): boolean;
+    isTargetMark(line: PlaitArrowLine, markType: ArrowLineMarkerType): boolean;
+    isBoundElementOfSource(line: PlaitArrowLine, element: PlaitShapeElement): boolean;
+    isBoundElementOfTarget(line: PlaitArrowLine, element: PlaitShapeElement): boolean;
+    getPoints(board: PlaitBoard, line: PlaitArrowLine): Point[];
+};

package/interfaces/element.d.ts

@@ -7,6 +7,6 @@ export declare enum MemorizeKey {
     basicShape = "basicShape",
     flowchart = "flowchart",
     text = "text",
-    line = "line",
+    arrowLine = "arrow-line",
     UML = "UML"
 }

package/interfaces/index.d.ts

@@ -1,22 +1,24 @@
 import { GeometryShapes, PlaitGeometry } from './geometry';
 import { PlaitImage } from './image';
-import { PlaitLine } from './line';
+import { PlaitArrowLine } from './arrow-line';
 import { PlaitSwimlane, SwimlaneSymbols } from './swimlane';
 import { PlaitBaseTable, PlaitTable, TableSymbols } from './table';
 import { PlaitText } from './text';
-export * from './line';
+import { PlaitVectorLine } from './vector-line';
+export * from './arrow-line';
 export * from './geometry';
 export * from './text';
 export * from './element';
 export * from './engine';
 export * from './swimlane';
 export * from './table';
-export type PlaitDrawElement = PlaitGeometry | PlaitLine | PlaitImage | PlaitBaseTable | PlaitSwimlane;
+export * from './vector-line';
+export type PlaitDrawElement = PlaitGeometry | PlaitArrowLine | PlaitVectorLine | PlaitImage | PlaitBaseTable | PlaitSwimlane;
 export type PlaitShapeElement = PlaitGeometry | PlaitImage | PlaitTable | PlaitSwimlane;
 export type DrawShapes = GeometryShapes | TableSymbols | SwimlaneSymbols;
 export declare const PlaitDrawElement: {
     isGeometry: (value: any) => value is PlaitGeometry;
-    isLine: (value: any) => value is PlaitLine;
+    isArrowLine: (value: any) => value is PlaitArrowLine;
     isText: (value: any) => value is PlaitText;
     isImage: (value: any) => value is PlaitImage;
     isTable: (value: any) => value is PlaitTable;

package/interfaces/vector-line.d.ts

@@ -0,0 +1,16 @@
+import { PlaitElement, Point } from '@plait/core';
+import { StrokeStyle } from './element';
+export declare enum VectorLineShape {
+    straight = "straight",
+    curve = "curve"
+}
+export interface PlaitVectorLine extends PlaitElement {
+    type: 'vector-line';
+    shape: VectorLineShape;
+    points: Point[];
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeStyle?: StrokeStyle;
+    fill?: string;
+    opacity: number;
+}

package/package.json

@@ -1,12 +1,22 @@
 {
   "name": "@plait/draw",
-  "version": "0.62.0-next.6",
+  "version": "0.62.0-next.8",
   "peerDependencies": {
     "is-hotkey": "^0.2.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"
   },
+  "license": "MIT",
+  "repository": "https://github.com/worktile/plait",
+  "keywords": [
+    "drawing",
+    "draw",
+    "diagram",
+    "flow chart",
+    "whiteboard",
+    "open-source"
+  ],
   "module": "fesm2022/plait-draw.mjs",
   "typings": "index.d.ts",
   "exports": {

package/plugins/with-arrow-line-auto-complete-reaction.d.ts

@@ -0,0 +1,2 @@
+import { PlaitBoard } from '@plait/core';
+export declare const withArrowLineAutoCompleteReaction: (board: PlaitBoard) => PlaitBoard;

package/plugins/with-arrow-line-auto-complete.d.ts

@@ -0,0 +1,7 @@
+import { PlaitBoard } from '@plait/core';
+import { PlaitArrowLine } from '../interfaces';
+export declare const WithArrowLineAutoCompletePluginKey = "plait-arrow-line-auto-complete-plugin-key";
+export interface ArrowLineAutoCompleteOptions {
+    afterComplete: (element: PlaitArrowLine) => {};
+}
+export declare const withArrowLineAutoComplete: (board: PlaitBoard) => PlaitBoard;

package/plugins/with-arrow-line-bound-reaction.d.ts

@@ -0,0 +1,2 @@
+import { PlaitBoard } from '@plait/core';
+export declare const withArrowLineBoundReaction: (board: PlaitBoard) => PlaitBoard;

package/plugins/with-arrow-line-create.d.ts

@@ -0,0 +1,2 @@
+import { PlaitBoard } from '@plait/core';
+export declare const withArrowLineCreateByDraw: (board: PlaitBoard) => PlaitBoard;

package/plugins/with-arrow-line-resize.d.ts

@@ -0,0 +1,2 @@
+import { PlaitBoard } from '@plait/core';
+export declare const withArrowLineResize: (board: PlaitBoard) => PlaitBoard;

package/plugins/with-arrow-line-text-move.d.ts

@@ -0,0 +1,2 @@
+import { PlaitBoard } from '@plait/core';
+export declare const withArrowLineTextMove: (board: PlaitBoard) => PlaitBoard;

package/plugins/with-arrow-line-text.d.ts

@@ -0,0 +1,2 @@
+import { PlaitBoard } from '@plait/core';
+export declare const withArrowLineText: (board: PlaitBoard) => PlaitBoard;

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

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

package/plugins/with-swimlane.d.ts

@@ -1,3 +1,2 @@
-import { PlaitBoard } from '@plait/core';
 import { PlaitTableBoard } from '../interfaces/table';
-export declare const withSwimlane: (board: PlaitTableBoard) => PlaitBoard;
+export declare const withSwimlane: (board: PlaitTableBoard) => import("@plait/core").PlaitBoard;

package/public-api.d.ts

@@ -1,9 +1,9 @@
 export * from './interfaces';
 export * from './plugins/with-draw';
-export * from './plugins/with-line-auto-complete';
+export * from './plugins/with-arrow-line-auto-complete';
 export * from './constants';
 export * from './utils';
 export * from './geometry.component';
-export * from './line.component';
+export * from './arrow-line.component';
 export * from './transforms';
 export * from './generators/index';

package/table.component.d.ts

@@ -3,12 +3,12 @@ import { ActiveGenerator, CommonElementFlavour } from '@plait/common';
 import { PlaitTable, PlaitTableCell } from './interfaces/table';
 import { PlaitDrawShapeText, TextGenerator } from './generators/text.generator';
 import { TableGenerator } from './generators/table.generator';
-import { LineAutoCompleteGenerator } from './generators/line-auto-complete.generator';
+import { ArrowLineAutoCompleteGenerator } from './generators/arrow-line-auto-complete.generator';
 export declare class TableComponent<T extends PlaitTable> extends CommonElementFlavour<T, PlaitBoard> implements OnContextChanged<T, PlaitBoard> {
     activeGenerator: ActiveGenerator<T>;
     tableGenerator: TableGenerator<T>;
     textGenerator: TextGenerator<T>;
-    lineAutoCompleteGenerator: LineAutoCompleteGenerator<PlaitTable>;
+    lineAutoCompleteGenerator: ArrowLineAutoCompleteGenerator<PlaitTable>;
     constructor();
     initializeGenerator(): void;
     initialize(): void;

package/transforms/arrow-line.d.ts

@@ -0,0 +1,8 @@
+import { Path, PlaitBoard } from '@plait/core';
+import { ArrowLineHandleKey, ArrowLineMarkerType, ArrowLineText, PlaitArrowLine, PlaitShapeElement } from '../interfaces';
+export declare const resizeArrowLine: (board: PlaitBoard, options: Partial<PlaitArrowLine>, path: Path) => void;
+export declare const setArrowLineTexts: (board: PlaitBoard, element: PlaitArrowLine, texts: ArrowLineText[]) => void;
+export declare const removeArrowLineText: (board: PlaitBoard, element: PlaitArrowLine, index: number) => void;
+export declare const setArrowLineMark: (board: PlaitBoard, handleKey: ArrowLineHandleKey, marker: ArrowLineMarkerType) => void;
+export declare const setArrowLineShape: (board: PlaitBoard, newProperties: Partial<PlaitArrowLine>) => void;
+export declare const connectArrowLineToDraw: (board: PlaitBoard, lineElement: PlaitArrowLine, handle: ArrowLineHandleKey, geometryElement: PlaitShapeElement) => void;

package/transforms/common.d.ts

@@ -0,0 +1,3 @@
+import { PlaitBoard, Vector, Point } from '@plait/core';
+import { GeometryShapes, SwimlaneDrawSymbols } from '../interfaces';
+export declare const insertDrawByVector: (board: PlaitBoard, point: Point, shape: GeometryShapes | SwimlaneDrawSymbols, vector: Vector) => import("../interfaces").PlaitCommonGeometry | import("../interfaces").PlaitSwimlane | null;

package/transforms/geometry.d.ts

@@ -1,8 +1,7 @@
-import { PlaitBoard, Point, Path, Vector } from '@plait/core';
+import { PlaitBoard, Point, Path } from '@plait/core';
 import { GeometryShapes } from '../interfaces';
 import { Element } from 'slate';
 export declare const insertGeometry: (board: PlaitBoard, points: [Point, Point], shape: GeometryShapes) => import("../interfaces").PlaitCommonGeometry;
-export declare const insertGeometryByVector: (board: PlaitBoard, point: Point, shape: GeometryShapes, vector: Vector) => import("../interfaces").PlaitCommonGeometry | null;
 export declare const insertText: (board: PlaitBoard, point: Point, text: string | Element) => void;
 export declare const resizeGeometry: (board: PlaitBoard, points: [Point, Point], textHeight: number, path: Path) => void;
 export declare const switchGeometryShape: (board: PlaitBoard, shape: GeometryShapes) => void;

package/transforms/index.d.ts

@@ -5,20 +5,20 @@ export declare const DrawTransforms: {
     resizeGeometry: (board: import("@plait/core").PlaitBoard, points: [import("@plait/core").Point, import("@plait/core").Point], textHeight: number, path: import("@plait/core").Path) => void;
     insertText: (board: import("@plait/core").PlaitBoard, point: import("@plait/core").Point, text: string | import("slate").BaseElement) => void;
     setTextSize: (board: import("@plait/core").PlaitBoard, element: import("@plait/draw").PlaitGeometry, textWidth: number, textHeight: number) => void;
-    resizeLine: (board: import("@plait/core").PlaitBoard, options: Partial<import("@plait/draw").PlaitLine>, path: import("@plait/core").Path) => void;
-    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, handleKey: import("@plait/draw").LineHandleKey, marker: import("@plait/draw").LineMarkerType) => void;
-    setLineShape: (board: import("@plait/core").PlaitBoard, newProperties: Partial<import("@plait/draw").PlaitLine>) => void;
+    resizeArrowLine: (board: import("@plait/core").PlaitBoard, options: Partial<import("@plait/draw").PlaitArrowLine>, path: import("@plait/core").Path) => void;
+    setArrowLineTexts: (board: import("@plait/core").PlaitBoard, element: import("@plait/draw").PlaitArrowLine, texts: import("@plait/draw").ArrowLineText[]) => void;
+    removeArrowLineText: (board: import("@plait/core").PlaitBoard, element: import("@plait/draw").PlaitArrowLine, index: number) => void;
+    setArrowLineMark: (board: import("@plait/core").PlaitBoard, handleKey: import("@plait/draw").ArrowLineHandleKey, marker: import("@plait/draw").ArrowLineMarkerType) => void;
+    setArrowLineShape: (board: import("@plait/core").PlaitBoard, newProperties: Partial<import("@plait/draw").PlaitArrowLine>) => void;
     insertImage: (board: import("@plait/core").PlaitBoard, imageItem: import("@plait/common").CommonImageItem, startPoint?: import("@plait/core").Point | undefined) => void;
+    connectArrowLineToDraw: (board: import("@plait/core").PlaitBoard, lineElement: import("@plait/draw").PlaitArrowLine, handle: import("@plait/draw").ArrowLineHandleKey, geometryElement: import("@plait/draw").PlaitShapeElement) => void;
     switchGeometryShape: (board: import("@plait/core").PlaitBoard, shape: import("@plait/draw").GeometryShapes) => void;
-    connectLineToGeometry: (board: import("@plait/core").PlaitBoard, lineElement: import("@plait/draw").PlaitLine, handle: import("@plait/draw").LineHandleKey, geometryElement: import("@plait/draw").PlaitGeometry) => void;
-    insertGeometryByVector: (board: import("@plait/core").PlaitBoard, point: import("@plait/core").Point, shape: import("@plait/draw").GeometryShapes, vector: import("@plait/core").Vector) => import("@plait/draw").PlaitCommonGeometry | null;
-    setTableText: (board: import("@plait/core").PlaitBoard, table: import("@plait/draw").PlaitTable, cellId: string, text: import("slate").BaseElement, textWidth: number, textHeight: number) => void;
+    setTableText: (board: import("@plait/core").PlaitBoard, path: import("@plait/core").Path, cellId: string, text: import("slate").BaseElement, textHeight: number) => void;
     addSwimlaneRow: (board: import("@plait/core").PlaitBoard, swimlane: import("@plait/draw").PlaitSwimlane, index: number, count?: number) => void;
     addSwimlaneColumn: (board: import("@plait/core").PlaitBoard, swimlane: import("@plait/draw").PlaitSwimlane, index: number, count?: number) => void;
     removeSwimlaneRow: (board: import("@plait/core").PlaitBoard, swimlane: import("@plait/draw").PlaitSwimlane, index: number, count?: number) => void;
     removeSwimlaneColumn: (board: import("@plait/core").PlaitBoard, swimlane: import("@plait/draw").PlaitSwimlane, index: number, count?: number) => void;
-    setSwimlaneFill: (board: import("@plait/core").PlaitBoard, element: import("@plait/draw").PlaitBaseTable, fill: string, path: import("@plait/core").Path) => void;
     updateSwimlaneCount: (board: import("@plait/core").PlaitBoard, swimlane: import("@plait/draw").PlaitSwimlane, count: number) => void;
+    setTableFill: (board: import("@plait/core").PlaitBoard, element: import("@plait/draw").PlaitBaseTable, fill: string, path: import("@plait/core").Path) => void;
+    insertDrawByVector: (board: import("@plait/core").PlaitBoard, point: import("@plait/core").Point, shape: import("@plait/draw").GeometryShapes | import("@plait/draw").SwimlaneDrawSymbols, vector: import("@plait/core").Vector) => import("@plait/draw").PlaitCommonGeometry | import("@plait/draw").PlaitSwimlane | null;
 };

package/transforms/swimlane.d.ts

@@ -1,9 +1,7 @@
-import { Path, PlaitBoard } from '@plait/core';
+import { PlaitBoard } from '@plait/core';
 import { PlaitSwimlane } from '../interfaces';
-import { PlaitBaseTable } from '../interfaces/table';
 export declare const updateSwimlaneCount: (board: PlaitBoard, swimlane: PlaitSwimlane, count: number) => void;
 export declare const addSwimlaneRow: (board: PlaitBoard, swimlane: PlaitSwimlane, index: number, count?: number) => void;
 export declare const addSwimlaneColumn: (board: PlaitBoard, swimlane: PlaitSwimlane, index: number, count?: number) => void;
 export declare const removeSwimlaneRow: (board: PlaitBoard, swimlane: PlaitSwimlane, index: number, count?: number) => void;
 export declare const removeSwimlaneColumn: (board: PlaitBoard, swimlane: PlaitSwimlane, index: number, count?: number) => void;
-export declare const setSwimlaneFill: (board: PlaitBoard, element: PlaitBaseTable, fill: string, path: Path) => void;

package/transforms/table-text.d.ts

@@ -1,4 +1,3 @@
-import { PlaitBoard } from '@plait/core';
+import { Path, PlaitBoard } from '@plait/core';
 import { Element } from 'slate';
-import { PlaitTable } from '../interfaces/table';
-export declare const setTableText: (board: PlaitBoard, table: PlaitTable, cellId: string, text: Element, textWidth: number, textHeight: number) => void;
+export declare const setTableText: (board: PlaitBoard, path: Path, cellId: string, text: Element, textHeight: number) => void;

package/transforms/table.d.ts

@@ -0,0 +1,3 @@
+import { Path, PlaitBoard } from '@plait/core';
+import { PlaitBaseTable } from '../interfaces';
+export declare const setTableFill: (board: PlaitBoard, element: PlaitBaseTable, fill: string, path: Path) => void;

package/utils/arrow-line/arrow-line-arrow.d.ts

@@ -0,0 +1,4 @@
+import { Point } from '@plait/core';
+import { PlaitArrowLine } from '../../interfaces';
+import { Options } from 'roughjs/bin/core';
+export declare const drawArrowLineArrow: (element: PlaitArrowLine, points: Point[], options: Options) => SVGGElement | null;

package/utils/arrow-line/arrow-line-basic.d.ts

@@ -0,0 +1,13 @@
+import { Point, PlaitBoard, RectangleClient } from '@plait/core';
+import { ArrowLineHandle, ArrowLineShape, ArrowLineText, PlaitArrowLine, PlaitShapeElement } from '../../interfaces';
+export declare const createArrowLineElement: (shape: ArrowLineShape, points: [Point, Point], source: ArrowLineHandle, target: ArrowLineHandle, texts?: ArrowLineText[], options?: Pick<PlaitArrowLine, 'strokeColor' | 'strokeWidth'>) => PlaitArrowLine;
+export declare const getArrowLinePoints: (board: PlaitBoard, element: PlaitArrowLine) => Point[];
+export declare const getCurvePoints: (board: PlaitBoard, element: PlaitArrowLine) => Point[];
+export declare function getMiddlePoints(board: PlaitBoard, element: PlaitArrowLine): Point[];
+export declare const drawArrowLine: (board: PlaitBoard, element: PlaitArrowLine) => SVGGElement;
+export declare const getHitConnection: (board: PlaitBoard, point: Point, hitElement: PlaitShapeElement) => Point;
+export declare const getHitConnectorPoint: (point: Point, hitElement: PlaitShapeElement) => Point | undefined;
+export declare const getArrowLineTextRectangle: (board: PlaitBoard, element: PlaitArrowLine, index: number) => RectangleClient;
+export declare const getArrowLines: (board: PlaitBoard) => PlaitArrowLine[];
+export declare const Q2C: (points: Point[]) => Point[];
+export declare const handleArrowLineCreating: (board: PlaitBoard, lineShape: ArrowLineShape, sourcePoint: Point, movingPoint: Point, sourceElement: PlaitShapeElement | null, lineShapeG: SVGGElement) => PlaitArrowLine;

package/utils/{line/line-common.d.ts → arrow-line/arrow-line-common.d.ts}

@@ -1,9 +1,9 @@
-import { Point, PlaitBoard, RectangleClient, PointOfRectangle, Direction, Vector } from '@plait/core';
-import { LineHandleRefPair, PlaitLine, PlaitShapeElement } from '../../interfaces';
-export declare const getLineHandleRefPair: (board: PlaitBoard, element: PlaitLine) => LineHandleRefPair;
+import { Point, PlaitBoard, RectangleClient, PointOfRectangle, Direction, Vector, Path } from '@plait/core';
+import { ArrowLineHandleRefPair, PlaitArrowLine, PlaitShapeElement } from '../../interfaces';
+export declare const getArrowLineHandleRefPair: (board: PlaitBoard, element: PlaitArrowLine) => ArrowLineHandleRefPair;
 export declare const getConnectionPoint: (geometry: PlaitShapeElement, connection: Point, direction?: Direction, delta?: number) => Point;
 export declare const getVectorByConnection: (boundElement: PlaitShapeElement, connection: PointOfRectangle) => Vector;
-export declare const getElbowLineRouteOptions: (board: PlaitBoard, element: PlaitLine, handleRefPair?: LineHandleRefPair) => {
+export declare const getElbowLineRouteOptions: (board: PlaitBoard, element: PlaitArrowLine, handleRefPair?: ArrowLineHandleRefPair) => {
     sourcePoint: PointOfRectangle;
     nextSourcePoint: Point;
     sourceRectangle: RectangleClient;
@@ -23,3 +23,7 @@ export declare const getElbowLineRouteOptions: (board: PlaitBoard, element: Plai
         height: number;
     };
 };
+export declare const collectArrowLineUpdatedRefsByGeometry: (board: PlaitBoard, element: PlaitShapeElement, refs: {
+    property: Partial<PlaitArrowLine>;
+    path: Path;
+}[]) => void;

package/utils/{line/line-resize.d.ts → arrow-line/arrow-line-resize.d.ts}

@@ -1,6 +1,6 @@
 import { ElbowLineRouteOptions, ResizeState } from '@plait/common';
 import { PlaitBoard, Point } from '@plait/core';
-import { PlaitLine } from '../../interfaces';
+import { PlaitArrowLine } from '../../interfaces';
 export declare const alignPoints: (basePoint: Point, movingPoint: Point) => Point;
 export declare function getResizedPreviousAndNextPoint(nextRenderPoints: Point[], sourcePoint: Point, targetPoint: Point, handleIndex: number): {
     previous: Point | null;
@@ -10,7 +10,7 @@ export declare function alignElbowSegment(startKeyPoint: Point, endKeyPoint: Poi
     previous: Point | null;
     next: Point | null;
 }): Point[];
-export declare function getIndexAndDeleteCountByKeyPoint(board: PlaitBoard, element: PlaitLine, dataPoints: Point[], nextRenderPoints: Point[], handleIndex: number): {
+export declare function getIndexAndDeleteCountByKeyPoint(board: PlaitBoard, element: PlaitArrowLine, dataPoints: Point[], nextRenderPoints: Point[], handleIndex: number): {
     index: null;
     deleteCount: null;
 } | {
@@ -18,6 +18,6 @@ export declare function getIndexAndDeleteCountByKeyPoint(board: PlaitBoard, elem
     deleteCount: number | null;
 };
 export declare function getMirrorDataPoints(board: PlaitBoard, nextDataPoints: Point[], nextKeyPoints: Point[], params: ElbowLineRouteOptions): Point[];
-export declare function isUpdatedHandleIndex(board: PlaitBoard, element: PlaitLine, dataPoints: Point[], nextRenderPoints: Point[], handleIndex: number): boolean;
+export declare function isUpdatedHandleIndex(board: PlaitBoard, element: PlaitArrowLine, dataPoints: Point[], nextRenderPoints: Point[], handleIndex: number): boolean;
 export declare function getMidKeyPoints(simplifiedNextKeyPoints: Point[], startPoint: Point, endPoint: Point): Point[];
 export declare const hasIllegalElbowPoint: (midDataPoints: Point[]) => boolean;

package/utils/{line → arrow-line}/elbow.d.ts

@@ -1,12 +1,12 @@
 import { Point, PlaitBoard, RectangleClient } from '@plait/core';
 import { ElbowLineRouteOptions } from '@plait/common';
-import { LineHandleRefPair, PlaitLine } from '../../interfaces';
-export declare const isSelfLoop: (element: PlaitLine) => boolean | "" | undefined;
-export declare const isUseDefaultOrthogonalRoute: (element: PlaitLine, options: ElbowLineRouteOptions) => boolean;
-export declare const getElbowPoints: (board: PlaitBoard, element: PlaitLine) => Point[];
-export declare const getNextSourceAndTargetPoints: (board: PlaitBoard, element: PlaitLine) => Point[];
-export declare const getSourceAndTargetRectangle: (board: PlaitBoard, element: PlaitLine, handleRefPair: LineHandleRefPair) => {
+import { ArrowLineHandleRefPair, PlaitArrowLine } from '../../interfaces';
+export declare const isSelfLoop: (element: PlaitArrowLine) => boolean | "" | undefined;
+export declare const isUseDefaultOrthogonalRoute: (element: PlaitArrowLine, options: ElbowLineRouteOptions) => boolean;
+export declare const getElbowPoints: (board: PlaitBoard, element: PlaitArrowLine) => Point[];
+export declare const getNextSourceAndTargetPoints: (board: PlaitBoard, element: PlaitArrowLine) => Point[];
+export declare const getSourceAndTargetRectangle: (board: PlaitBoard, element: PlaitArrowLine, handleRefPair: ArrowLineHandleRefPair) => {
     sourceRectangle: RectangleClient;
     targetRectangle: RectangleClient;
 };
-export declare function getNextRenderPoints(board: PlaitBoard, element: PlaitLine, renderPoints?: Point[]): Point[];
+export declare function getNextRenderPoints(board: PlaitBoard, element: PlaitArrowLine, renderPoints?: Point[]): Point[];

package/utils/arrow-line/index.d.ts

@@ -0,0 +1,5 @@
+export * from './elbow';
+export * from './arrow-line-arrow';
+export * from './arrow-line-basic';
+export * from './arrow-line-common';
+export * from './arrow-line-resize';

package/utils/clipboard.d.ts

@@ -1,7 +1,7 @@
 import { PlaitBoard, Point } from '@plait/core';
-import { PlaitDrawElement, PlaitGeometry, PlaitLine, PlaitShapeElement } from '../interfaces';
+import { PlaitArrowLine, PlaitDrawElement, PlaitGeometry, PlaitShapeElement } from '../interfaces';
 import { PlaitTable } from '../interfaces/table';
-export declare const buildClipboardData: (board: PlaitBoard, elements: PlaitDrawElement[], startPoint: Point) => (PlaitGeometry | import("../interfaces").PlaitBaseTable | PlaitLine)[];
+export declare const buildClipboardData: (board: PlaitBoard, elements: PlaitDrawElement[], startPoint: Point) => (PlaitGeometry | import("../interfaces").PlaitBaseTable | PlaitArrowLine | import("../interfaces").PlaitVectorLine)[];
 export declare const insertClipboardData: (board: PlaitBoard, elements: PlaitDrawElement[], startPoint: Point) => void;
-export declare const insertClipboardTableData: (board: PlaitBoard, elements: PlaitTable[], startPoint: Point, lines: PlaitLine[]) => void;
-export declare const updateBoundLinesId: (element: PlaitShapeElement, lines: PlaitLine[], newId: string) => void;
+export declare const insertClipboardTableData: (board: PlaitBoard, elements: PlaitTable[], startPoint: Point, lines: PlaitArrowLine[]) => void;
+export declare const updateBoundArrowLinesId: (element: PlaitShapeElement, lines: PlaitArrowLine[], newId: string) => void;

package/utils/common.d.ts

@@ -14,6 +14,7 @@ export declare const getStrokeWidthByElement: (element: PlaitElement) => any;
 export declare const insertElement: (board: PlaitBoard, element: PlaitBaseGeometry | PlaitBaseTable) => void;
 export declare const isDrawElementIncludeText: (element: PlaitDrawElement) => boolean;
 export declare const isDrawElementsIncludeText: (elements: PlaitDrawElement[]) => boolean;
+export declare const isDrawElementClosed: (element: PlaitDrawElement) => boolean;
 export declare const getSnappingShape: (board: PlaitBoard, point: Point) => PlaitShapeElement | null;
 export declare const getSnappingRef: (board: PlaitBoard, hitElement: PlaitShapeElement, point: Point) => {
     isHitEdge: boolean;

package/utils/geometry.d.ts

@@ -122,7 +122,7 @@ export declare const getDefaultUMLProperty: (shape: UMLSymbols) => {
         align: Alignment;
     }[];
 };
-export declare const createDefaultFlowchart: (point: Point) => (PlaitGeometry | import("../interfaces").PlaitLine)[];
+export declare const createDefaultFlowchart: (point: Point) => (PlaitGeometry | import("../interfaces").PlaitArrowLine)[];
 export declare const getAutoCompletePoints: (element: PlaitShapeElement) => [Point, Point, Point, Point];
 export declare const getHitIndexOfAutoCompletePoint: (movingPoint: Point, points: Point[]) => number;
 export declare const getDrawDefaultStrokeColor: (theme: ThemeColorMode) => string;
@@ -144,3 +144,4 @@ export declare const rerenderGeometryActive: (board: PlaitBoard, element: PlaitG
 export declare const isGeometryIncludeText: (element: PlaitGeometry) => boolean;
 export declare const isSingleTextShape: (shape: GeometryShapes) => boolean;
 export declare const isSingleTextGeometry: (element: PlaitGeometry) => boolean;
+export declare const isGeometryClosed: (element: PlaitGeometry) => boolean;

package/utils/hit.d.ts

@@ -1,12 +1,15 @@
 import { PlaitElement, RectangleClient, Selection, PlaitBoard, Point } from '@plait/core';
-import { PlaitCommonGeometry, PlaitGeometry, PlaitLine, PlaitShapeElement } from '../interfaces';
+import { PlaitArrowLine, PlaitCommonGeometry, PlaitDrawElement, PlaitGeometry, PlaitShapeElement } from '../interfaces';
 export declare const isTextExceedingBounds: (geometry: PlaitGeometry) => boolean;
-export declare const isHitLineText: (board: PlaitBoard, element: PlaitLine, point: Point) => boolean;
+export declare const isHitArrowLineText: (board: PlaitBoard, element: PlaitArrowLine, point: Point) => boolean;
 export declare const isHitPolyLine: (pathPoints: Point[], point: Point) => boolean;
-export declare const isHitLine: (board: PlaitBoard, element: PlaitLine, point: Point) => boolean;
-export declare const isHitElementText: (element: PlaitCommonGeometry, point: Point) => boolean;
+export declare const isHitArrowLine: (board: PlaitBoard, element: PlaitArrowLine, point: Point) => boolean;
 export declare const isRectangleHitElementText: (element: PlaitCommonGeometry, rectangle: RectangleClient) => boolean;
+export declare const isHitElementText: (element: PlaitCommonGeometry, point: Point) => boolean;
 export declare const isRectangleHitDrawElement: (board: PlaitBoard, element: PlaitElement, selection: Selection) => boolean | null;
+export declare const getDrawHitElement: (board: PlaitBoard, elements: PlaitDrawElement[]) => PlaitElement;
+export declare const getFirstFilledDrawElement: (board: PlaitBoard, elements: PlaitDrawElement[]) => PlaitGeometry | null;
+export declare const getFirstTextOrLineElement: (elements: PlaitDrawElement[]) => PlaitGeometry | import("../interfaces").PlaitBaseTable | import("../interfaces/image").PlaitImage | PlaitArrowLine | import("../interfaces").PlaitVectorLine | null;
 export declare const isHitDrawElement: (board: PlaitBoard, element: PlaitElement, point: Point) => boolean | null;
 export declare const isHitEdgeOfShape: (board: PlaitBoard, element: PlaitShapeElement, point: Point, hitDistanceBuffer: number) => boolean;
 export declare const isInsideOfShape: (board: PlaitBoard, element: PlaitShapeElement, point: Point, hitDistanceBuffer: number) => boolean;

package/utils/index.d.ts

@@ -1,4 +1,4 @@
-export * from './line/index';
+export * from './arrow-line/index';
 export * from './geometry';
 export * from './multi-text-geometry';
 export * from './uml';

package/utils/position/arrow-line.d.ts

@@ -0,0 +1,16 @@
+import { PlaitBoard, Point } from '@plait/core';
+import { PlaitArrowLine } from '../../interfaces';
+export declare enum ArrowLineResizeHandle {
+    'source' = "source",
+    'target' = "target",
+    'addHandle' = "addHandle"
+}
+export declare const getHitArrowLineResizeHandleRef: (board: PlaitBoard, element: PlaitArrowLine, point: Point) => {
+    handle: ArrowLineResizeHandle;
+    handleIndex: number;
+} | {
+    handleIndex: number;
+    handle?: undefined;
+} | undefined;
+export declare function getHitPointIndex(points: Point[], movingPoint: Point): number;
+export declare const getHitArrowLineTextIndex: (board: PlaitBoard, element: PlaitArrowLine, point: Point) => number;

package/utils/selected.d.ts

@@ -1,9 +1,9 @@
 import { PlaitBoard, PlaitElement } from '@plait/core';
-import { PlaitDrawElement, PlaitGeometry, PlaitLine, PlaitSwimlane } from '../interfaces';
+import { PlaitArrowLine, PlaitDrawElement, PlaitGeometry, PlaitSwimlane } from '../interfaces';
 import { PlaitImage } from '../interfaces/image';
 export declare const getSelectedDrawElements: (board: PlaitBoard, elements?: PlaitElement[]) => PlaitDrawElement[];
 export declare const getSelectedGeometryElements: (board: PlaitBoard) => PlaitGeometry[];
-export declare const getSelectedLineElements: (board: PlaitBoard) => PlaitLine[];
+export declare const getSelectedArrowLineElements: (board: PlaitBoard) => PlaitArrowLine[];
 export declare const getSelectedImageElements: (board: PlaitBoard) => PlaitImage[];
 export declare const isSingleSelectSwimlane: (board: PlaitBoard) => boolean;
 export declare const getSelectedSwimlane: (board: PlaitBoard) => PlaitSwimlane;