@plait/draw 0.57.0 → 0.58.0

package/utils/geometry.d.ts

@@ -1,27 +1,20 @@
 import { PlaitBoard, Point, RectangleClient, ThemeColorMode } from '@plait/core';
-import { GeometryShapes, BasicShapes, PlaitGeometry, FlowchartSymbols } from '../interfaces/geometry';
+import { GeometryShapes, BasicShapes, PlaitGeometry, FlowchartSymbols, UMLSymbols } from '../interfaces/geometry';
 import { Alignment, CustomText } from '@plait/text';
 import { Element } from 'slate';
 import { DrawPointerType } from '../constants';
 import { Options } from 'roughjs/bin/core';
 import { PlaitShapeElement } from '../interfaces';
+import { PlaitDrawShapeText } from '../generators/text.generator';
 export type GeometryStyleOptions = Pick<PlaitGeometry, 'fill' | 'strokeColor' | 'strokeWidth'>;
 export type TextProperties = Partial<CustomText> & {
     align?: Alignment;
     textHeight?: number;
 };
 export declare const createGeometryElement: (shape: GeometryShapes, points: [Point, Point], text: string | Element, options?: GeometryStyleOptions, textProperties?: TextProperties) => PlaitGeometry;
-export declare const getTextRectangle: (element: PlaitGeometry) => {
-    height: number;
-    width: number;
-    x: number;
-    y: number;
-};
-export declare const drawBoundReaction: (board: PlaitBoard, element: PlaitGeometry, options?: {
-    hasMask: boolean;
-    hasConnector: boolean;
-}) => SVGGElement;
-export declare const drawGeometry: (board: PlaitBoard, outerRectangle: RectangleClient, shape: GeometryShapes, options: Options) => SVGGElement;
+export declare const createGeometryElementWithText: (shape: GeometryShapes, points: [Point, Point], text: string | Element, options?: GeometryStyleOptions, textProperties?: TextProperties) => PlaitGeometry;
+export declare const createGeometryElementWithoutText: (shape: GeometryShapes, points: [Point, Point], options?: GeometryStyleOptions) => PlaitGeometry;
+export declare const drawGeometry: (board: PlaitBoard, outerRectangle: RectangleClient, shape: GeometryShapes, roughOptions: Options) => SVGGElement;
 export declare const getNearestPoint: (element: PlaitShapeElement, point: Point) => Point;
 export declare const getCenterPointsOnPolygon: (points: Point[]) => Point[];
 export declare const getDefaultFlowchartProperty: (symbol: FlowchartSymbols) => {
@@ -62,6 +55,32 @@ export declare const getDefaultBasicShapeProperty: (shape: BasicShapes) => {
     width: number;
     height: number;
 };
+export declare const getDefaultUMLProperty: (shape: UMLSymbols) => {
+    width: number;
+    height: number;
+} | {
+    width: number;
+    height: number;
+} | {
+    width: number;
+    height: number;
+} | {
+    width: number;
+    height: number;
+    texts: {
+        key: import("../interfaces").MultipleTextGeometryCommonTextKeys;
+        text: string;
+        align: Alignment;
+    }[];
+} | {
+    width: number;
+    height: number;
+    texts: {
+        key: import("../interfaces").MultipleTextGeometryCommonTextKeys;
+        text: string;
+        align: Alignment;
+    }[];
+};
 export declare const createDefaultFlowchart: (point: Point) => (PlaitGeometry | import("../interfaces").PlaitLine)[];
 export declare const getAutoCompletePoints: (element: PlaitShapeElement) => [Point, Point, Point, Point];
 export declare const getHitIndexOfAutoCompletePoint: (movingPoint: Point, points: Point[]) => number;
@@ -77,8 +96,8 @@ export declare const getDefaultGeometryProperty: (pointer: DrawPointerType) => {
     height: number;
 };
 export declare const getDefaultTextPoints: (board: PlaitBoard, centerPoint: Point, fontSize?: number | string) => [Point, Point];
-export declare const insertElement: (board: PlaitBoard, element: PlaitGeometry) => void;
 export declare const createTextElement: (board: PlaitBoard, points: [Point, Point], text?: string | Element, textHeight?: number) => PlaitGeometry;
-export declare const createDefaultGeometry: (board: PlaitBoard, points: [Point, Point], shape: GeometryShapes) => PlaitGeometry;
-export declare const editText: (board: PlaitBoard, element: PlaitGeometry) => void;
+export declare const createDefaultGeometry: (board: PlaitBoard, points: [Point, Point], shape: GeometryShapes) => PlaitGeometry | import("../interfaces").PlaitMultipleTextGeometry;
+export declare const editText: (board: PlaitBoard, element: PlaitGeometry, text?: PlaitDrawShapeText) => void;
 export declare const rerenderGeometryActive: (board: PlaitBoard, element: PlaitGeometry) => void;
+export declare const isGeometryIncludeText: (element: PlaitGeometry) => boolean | 0 | undefined;

package/utils/hit.d.ts

@@ -1,9 +1,11 @@
-import { PlaitElement, Selection, PlaitBoard, Point } from '@plait/core';
-import { PlaitGeometry, PlaitLine, PlaitShapeElement } from '../interfaces';
+import { PlaitElement, RectangleClient, Selection, PlaitBoard, Point } from '@plait/core';
+import { PlaitCommonGeometry, PlaitGeometry, PlaitLine, PlaitShapeElement } from '../interfaces';
 export declare const isTextExceedingBounds: (geometry: PlaitGeometry) => boolean;
 export declare const isHitLineText: (board: PlaitBoard, element: PlaitLine, 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 isRectangleHitElementText: (element: PlaitCommonGeometry, rectangle: RectangleClient) => boolean;
 export declare const isRectangleHitDrawElement: (board: PlaitBoard, element: PlaitElement, selection: Selection) => boolean | 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;

package/utils/index.d.ts

@@ -1,6 +1,9 @@
 export * from './line/index';
 export * from './geometry';
+export * from './multi-text-geometry';
 export * from './selected';
 export * from './style';
 export * from './hit';
 export * from './memorize';
+export * from './common';
+export * from './snap-resizing';

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

@@ -1,8 +1,8 @@
 import { Point, PlaitBoard, RectangleClient, PointOfRectangle, Direction, Vector } from '@plait/core';
-import { LineHandleRefPair, PlaitGeometry, PlaitLine } from '../../interfaces';
+import { LineHandleRefPair, PlaitLine, PlaitShapeElement } from '../../interfaces';
 export declare const getLineHandleRefPair: (board: PlaitBoard, element: PlaitLine) => LineHandleRefPair;
-export declare const getConnectionPoint: (geometry: PlaitGeometry, connection: Point, direction?: Direction, delta?: number) => Point;
-export declare const getVectorByConnection: (boundElement: PlaitGeometry, connection: PointOfRectangle) => Vector;
+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) => {
     sourcePoint: PointOfRectangle;
     nextSourcePoint: Point;

package/utils/memorize.d.ts

@@ -10,6 +10,7 @@ export declare const getLineMemorizedLatest: () => {
     points?: import("@plait/core").Point[] | undefined;
     type?: string | undefined;
     groupId?: string | undefined;
+    angle?: number | undefined;
 };
 export declare const getMemorizedLatestByPointer: (pointer: DrawPointerType) => {
     textProperties: any;
@@ -20,8 +21,9 @@ export declare const getMemorizedLatestByPointer: (pointer: DrawPointerType) =>
         points?: import("@plait/core").Point[] | undefined;
         type?: string | undefined;
         groupId?: string | undefined;
+        angle?: number | undefined;
     };
 };
-export declare const memorizeLatestText: (element: PlaitDrawElement, operations: BaseOperation[]) => void;
+export declare const memorizeLatestText: <T extends PlaitElement = PlaitDrawElement>(element: T, operations: BaseOperation[]) => void;
 export declare const memorizeLatestShape: (board: PlaitBoard, shape: GeometryShapes) => void;
 export declare const getMemorizedLatestShape: (board: PlaitBoard) => GeometryShapes[] | undefined;

package/utils/multi-text-geometry.d.ts

@@ -0,0 +1,14 @@
+import { Point } from '@plait/core';
+import { GeometryShapes, PlaitMultipleTextGeometry, PlaitCommonGeometry } from '../interfaces/geometry';
+import { PlaitDrawShapeText } from '../generators/text.generator';
+import { GeometryStyleOptions } from './geometry';
+export declare const isMultipleTextShape: (shape: GeometryShapes) => boolean;
+export declare const isMultipleTextGeometry: (geometry: PlaitCommonGeometry) => geometry is PlaitMultipleTextGeometry;
+export declare const getMultipleTextGeometryTextKeys: (shape: GeometryShapes) => string[] | undefined;
+export declare const createMultipleTextGeometryElement: (shape: GeometryShapes, points: [Point, Point], options?: GeometryStyleOptions) => PlaitMultipleTextGeometry;
+export declare const buildDefaultTextsByShape: (shape: GeometryShapes, elementId: string) => {
+    key: string;
+    text: import("slate").BaseElement;
+    textHeight: any;
+}[];
+export declare const getHitText: (element: PlaitMultipleTextGeometry, point: Point) => PlaitDrawShapeText | undefined;

package/utils/position/geometry.d.ts

@@ -1,24 +1,11 @@
-import { PlaitBoard, Point, RectangleClient } from '@plait/core';
-import { PlaitGeometry, PlaitShapeElement } from '../../interfaces';
-export declare const getHitRectangleResizeHandleRef: (board: PlaitBoard, rectangle: RectangleClient, point: Point, angle?: number) => {
-    rectangle: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    handle: import("@plait/common").ResizeHandle;
-    cursorClass: import("@plait/core").ResizeCursorClass;
-} | undefined;
-export declare const getSnappingGeometry: (board: PlaitBoard, point: Point) => PlaitGeometry | null;
-export declare const getSnappingRef: (board: PlaitBoard, hitElement: PlaitShapeElement, point: Point) => {
-    isHitEdge: boolean;
-    isHitConnector: boolean;
-    connectorPoint: Point | undefined;
-    edgePoint: Point;
-};
-export declare const getHitGeometry: (board: PlaitBoard, point: Point, offset?: number) => PlaitGeometry | null;
-export declare const traverseDrawShapes: (board: PlaitBoard, callback: (element: PlaitShapeElement) => void) => void;
+import { PlaitBoard, Point, RectangleClient, ResizeCursorClass } from '@plait/core';
+import { ResizeHandle } from '@plait/common';
+export interface ResizeHandleRef {
+    rectangle: RectangleClient;
+    handle: ResizeHandle;
+    cursorClass: ResizeCursorClass;
+}
+export declare const getHitRectangleResizeHandleRef: (board: PlaitBoard, rectangle: RectangleClient, point: Point, angle?: number) => ResizeHandleRef | undefined;
 export declare const getRotateHandleRectangle: (rectangle: RectangleClient) => {
     x: number;
     y: number;

package/utils/selected.d.ts

@@ -1,7 +1,11 @@
 import { PlaitBoard, PlaitElement } from '@plait/core';
 import { PlaitDrawElement, PlaitGeometry, PlaitLine } from '../interfaces';
 import { PlaitImage } from '../interfaces/image';
+import { PlaitTable } from '../interfaces/table';
 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 getSelectedImageElements: (board: PlaitBoard) => PlaitImage[];
+export declare const isSingleSelectSwimlane: (board: PlaitBoard) => boolean;
+export declare const isSingleSelectTable: (board: PlaitBoard) => boolean;
+export declare const getSelectedTableElements: (board: PlaitBoard, elements?: PlaitElement[]) => PlaitTable[];

package/utils/shape.d.ts

@@ -1,2 +1,2 @@
-import { PlaitShapeElement } from '../interfaces';
-export declare const getElementShape: (value: PlaitShapeElement) => import("../interfaces").GeometryShapes;
+import { PlaitShapeElement, TableSymbols } from '../interfaces';
+export declare const getElementShape: (value: PlaitShapeElement) => import("../interfaces").GeometryShapes | TableSymbols.table;

package/utils/style/stroke.d.ts

@@ -1,7 +1,6 @@
-import { PlaitGeometry, PlaitLine, StrokeStyle } from '../../interfaces';
-import { PlaitBoard } from '@plait/core';
-export declare const getStrokeWidthByElement: (element: PlaitGeometry | PlaitLine) => number;
+import { PlaitGeometry, PlaitLine } from '../../interfaces';
+import { PlaitBoard, PlaitElement } from '@plait/core';
 export declare const getStrokeColorByElement: (board: PlaitBoard, element: PlaitGeometry | PlaitLine) => string;
 export declare const getFillByElement: (board: PlaitBoard, element: PlaitGeometry | PlaitLine) => any;
-export declare const getLineDashByElement: (element: PlaitGeometry | PlaitLine) => number[] | undefined;
-export declare const getStrokeStyleByElement: (element: PlaitGeometry | PlaitLine) => StrokeStyle;
+export declare const getLineDashByElement: (element: PlaitGeometry | PlaitLine) => any[] | undefined;
+export declare const getStrokeStyleByElement: (element: PlaitElement) => any;

package/utils/swimlane.d.ts

@@ -0,0 +1,52 @@
+import { Point } from '@plait/core';
+import { DrawPointerType } from '../constants';
+import { PlaitSwimlane, SwimlaneSymbols } from '../interfaces';
+export declare function buildSwimlaneTable(element: PlaitSwimlane): {
+    [x: string]: any;
+    shape: SwimlaneSymbols;
+    id: string;
+    points: Point[];
+    type: "table";
+    rows: {
+        id: string;
+        height?: number | undefined;
+    }[];
+    columns: {
+        id: string;
+        width?: number | undefined;
+    }[];
+    cells: import("../interfaces/table").PlaitTableCell[];
+    groupId?: string | undefined;
+    children?: import("@plait/core").PlaitElement[] | undefined;
+    angle?: number | undefined;
+};
+export declare const getDefaultSWimlanePoints: (pointer: DrawPointerType, centerPoint: Point) => [Point, Point];
+export declare const createDefaultSwimlane: (shape: SwimlaneSymbols, points: [Point, Point]) => {
+    [x: string]: any;
+    shape: SwimlaneSymbols;
+    id: string;
+    points: Point[];
+    type: "table";
+    rows: {
+        id: string;
+        height?: number | undefined;
+    }[];
+    columns: {
+        id: string;
+        width?: number | undefined;
+    }[];
+    cells: import("../interfaces/table").PlaitTableCell[];
+    groupId?: string | undefined;
+    children?: import("@plait/core").PlaitElement[] | undefined;
+    angle?: number | undefined;
+};
+export declare const createDefaultRowsOrColumns: (shape: SwimlaneSymbols, type: 'row' | 'column') => {
+    id: string;
+}[];
+export declare const createDefaultCells: (shape: SwimlaneSymbols, rows: {
+    id: string;
+    height?: number;
+}[], columns: {
+    id: string;
+    width?: number;
+}[]) => any[];

package/utils/table.d.ts

@@ -0,0 +1,26 @@
+import { PlaitBoard, Point } from '@plait/core';
+import { PlaitTable, PlaitTableCell, PlaitTableCellWithPoints } from '../interfaces/table';
+import { PlaitTableBoard } from '../plugins/with-table';
+export declare function getCellsWithPoints(board: PlaitBoard, element: PlaitTable): PlaitTableCellWithPoints[];
+export declare function getCellWithPoints(board: PlaitBoard, table: PlaitTable, cellId: string): PlaitTableCellWithPoints;
+export declare function getHitCell(board: PlaitTableBoard, element: PlaitTable, point: Point): PlaitTableCell | null | undefined;
+export declare function editCell(cell: PlaitTableCell): void;
+export declare function getTextManageByCell(cell: PlaitTableCell): import("@plait/text").TextManage | undefined;
+export declare const updateColumns: (table: PlaitTable, columnId: string, width: number, offset: number) => {
+    columns: {
+        id: string;
+        width?: number | undefined;
+    }[];
+    points: Point[];
+};
+export declare const updateRows: (table: PlaitTable, rowId: string, height: number, offset: number) => {
+    rows: {
+        id: string;
+        height?: number | undefined;
+    }[];
+    points: Point[];
+};
+export declare function updateCellIdsByRowOrColumn(cells: PlaitTableCell[], oldId: string, newId: string, type: 'row' | 'column'): void;
+export declare function updateRowOrColumnIds(element: PlaitTable, type: 'row' | 'column'): void;
+export declare function updateCellIds(cells: PlaitTableCell[]): void;
+export declare function isCellIncludeText(cell: PlaitTableCell): number | undefined;