@plait/draw 0.57.0 → 0.58.0

package/generators/index.d.ts

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

package/generators/line-auto-complete.generator.d.ts

@@ -1,14 +1,14 @@
 import { PlaitBoard } from '@plait/core';
 import { PlaitGeometry, PlaitShapeElement } from '../interfaces';
 import { ActiveGeneratorExtraData, Generator } from '@plait/common';
-export declare class LineAutoCompleteGenerator extends Generator<PlaitShapeElement, ActiveGeneratorExtraData> {
+export declare class LineAutoCompleteGenerator<T extends PlaitShapeElement = PlaitGeometry> extends Generator<T, ActiveGeneratorExtraData> {
     board: PlaitBoard;
     static key: string;
     autoCompleteG: SVGGElement;
     hoverElement: SVGGElement | null;
     constructor(board: PlaitBoard);
     canDraw(element: PlaitShapeElement, data: ActiveGeneratorExtraData): boolean;
-    draw(element: PlaitGeometry, data: ActiveGeneratorExtraData): SVGGElement;
+    draw(element: T, data: ActiveGeneratorExtraData): SVGGElement;
     removeAutoCompleteG(index: number): void;
     recoverAutoCompleteG(): void;
 }

package/generators/single-text.generator.d.ts

@@ -0,0 +1,11 @@
+import { PlaitBoard, PlaitElement } from '@plait/core';
+import { ParagraphElement } from '@plait/text';
+import { PlaitGeometry } from '../interfaces';
+import { ViewContainerRef } from '@angular/core';
+import { PlaitDrawShapeText, TextGenerator, TextGeneratorOptions } from './text.generator';
+export declare class SingleTextGenerator<T extends PlaitElement = PlaitGeometry> extends TextGenerator<T> {
+    get textManage(): import("@plait/text").TextManage;
+    constructor(board: PlaitBoard, element: T, text: ParagraphElement, viewContainerRef: ViewContainerRef, options: TextGeneratorOptions<T>);
+    update(element: T, previousDrawShapeTexts: PlaitDrawShapeText[], currentDrawShapeTexts: PlaitDrawShapeText[], elementG: SVGElement): void;
+    update(element: T, previousText: ParagraphElement, currentText: ParagraphElement, elementG: SVGElement): void;
+}

package/generators/table.generator.d.ts

@@ -0,0 +1,9 @@
+import { Generator } from '@plait/common';
+import { PlaitElement } from '@plait/core';
+import { PlaitTable } from '../interfaces/table';
+export interface TableData {
+}
+export declare class TableGenerator<T extends PlaitElement = PlaitTable> extends Generator<T, TableData> {
+    canDraw(element: T, data: TableData): boolean;
+    draw(element: T, data: TableData): SVGGElement;
+}

package/generators/text.generator.d.ts

@@ -0,0 +1,43 @@
+import { PlaitBoard, PlaitElement, RectangleClient } from '@plait/core';
+import { TextManageRef, TextManage, ParagraphElement } from '@plait/text';
+import { DrawShapes, EngineExtraData, PlaitGeometry } from '../interfaces';
+import { ViewContainerRef } from '@angular/core';
+export interface PlaitDrawShapeText extends EngineExtraData {
+    key: string;
+    text: ParagraphElement;
+    textHeight: number;
+    board?: PlaitBoard;
+}
+export interface TextGeneratorOptions<T> {
+    onValueChangeHandle: (element: T, textChangeRef: TextManageRef, text: PlaitDrawShapeText) => void;
+    getRenderRectangle?: (element: T, text: PlaitDrawShapeText) => RectangleClient;
+    getMaxWidth?: () => number;
+}
+export declare const KEY_TO_TEXT_MANAGE: Map<string, TextManage>;
+export declare const setTextManage: (key: string, textManage: TextManage) => Map<string, TextManage>;
+export declare const getTextManage: (key: string) => TextManage | undefined;
+export declare const deleteTextManage: (key: string) => boolean;
+export declare class TextGenerator<T extends PlaitElement = PlaitGeometry> {
+    protected board: PlaitBoard;
+    protected element: T;
+    protected texts: PlaitDrawShapeText[];
+    protected viewContainerRef: ViewContainerRef;
+    protected options: TextGeneratorOptions<T>;
+    textManages: TextManage[];
+    get shape(): DrawShapes;
+    constructor(board: PlaitBoard, element: T, texts: PlaitDrawShapeText[], viewContainerRef: ViewContainerRef, options: TextGeneratorOptions<T>);
+    initialize(): void;
+    getTextKey(text: PlaitDrawShapeText): string;
+    draw(elementG: SVGElement): void;
+    update(element: T, previousDrawShapeTexts: PlaitDrawShapeText[], currentDrawShapeTexts: PlaitDrawShapeText[], elementG: SVGElement): void;
+    private createTextManage;
+    getRectangle(text: PlaitDrawShapeText): {
+        height: any;
+        width: number;
+        x: any;
+        y: number;
+    };
+    onValueChangeHandle(textManageRef: TextManageRef, text: PlaitDrawShapeText): void;
+    getMaxWidth(text: PlaitDrawShapeText): number;
+    destroy(): void;
+}

package/geometry.component.d.ts

@@ -1,26 +1,20 @@
-import { OnDestroy, OnInit } from '@angular/core';
 import { PlaitBoard, PlaitPluginElementContext, OnContextChanged } from '@plait/core';
-import { Subject } from 'rxjs';
-import { PlaitGeometry } from './interfaces/geometry';
+import { PlaitCommonGeometry, PlaitMultipleTextGeometry } from './interfaces/geometry';
 import { GeometryShapeGenerator } from './generators/geometry-shape.generator';
-import { TextManage } from '@plait/text';
-import { ActiveGenerator, CommonPluginElement } from '@plait/common';
+import { ActiveGenerator, CommonElementFlavour } from '@plait/common';
 import { LineAutoCompleteGenerator } from './generators/line-auto-complete.generator';
-import * as i0 from "@angular/core";
-export declare class GeometryComponent extends CommonPluginElement<PlaitGeometry, PlaitBoard> implements OnInit, OnDestroy, OnContextChanged<PlaitGeometry, PlaitBoard> {
-    destroy$: Subject<void>;
-    activeGenerator: ActiveGenerator<PlaitGeometry>;
+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;
     shapeGenerator: GeometryShapeGenerator;
-    get textManage(): TextManage;
+    textGenerator: TextGenerator<PlaitMultipleTextGeometry> | SingleTextGenerator;
     constructor();
     initializeGenerator(): void;
-    ngOnInit(): void;
-    onContextChanged(value: PlaitPluginElementContext<PlaitGeometry, PlaitBoard>, previous: PlaitPluginElementContext<PlaitGeometry, PlaitBoard>): void;
-    drawText(): void;
-    updateText(): void;
+    initialize(): void;
+    onContextChanged(value: PlaitPluginElementContext<PlaitCommonGeometry, PlaitBoard>, previous: PlaitPluginElementContext<PlaitCommonGeometry, PlaitBoard>): void;
+    updateText(previousElement: PlaitCommonGeometry, currentElement: PlaitCommonGeometry): void;
     initializeTextManage(): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<GeometryComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<GeometryComponent, "plait-draw-geometry", never, {}, {}, never, never, true, never>;
+    destroy(): void;
 }

package/image.component.d.ts

@@ -1,20 +1,14 @@
-import { OnDestroy, OnInit } from '@angular/core';
 import { PlaitBoard, PlaitPluginElementContext, OnContextChanged } from '@plait/core';
-import { Subject } from 'rxjs';
-import { CommonPluginElement, ImageGenerator } from '@plait/common';
+import { CommonElementFlavour, ImageGenerator } from '@plait/common';
 import { PlaitImage } from './interfaces/image';
 import { LineAutoCompleteGenerator } from './generators/line-auto-complete.generator';
-import * as i0 from "@angular/core";
-export declare class ImageComponent extends CommonPluginElement<PlaitImage, PlaitBoard> implements OnInit, OnDestroy, OnContextChanged<PlaitImage, PlaitBoard> {
-    destroy$: Subject<void>;
+export declare class ImageComponent extends CommonElementFlavour<PlaitImage, PlaitBoard> implements OnContextChanged<PlaitImage, PlaitBoard> {
     get activeGenerator(): import("@plait/common").ActiveGenerator<import("@plait/core").PlaitElement>;
     imageGenerator: ImageGenerator<PlaitImage>;
-    lineAutoCompleteGenerator: LineAutoCompleteGenerator;
+    lineAutoCompleteGenerator: LineAutoCompleteGenerator<PlaitImage>;
     constructor();
     initializeGenerator(): void;
-    ngOnInit(): void;
+    initialize(): 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>;
+    destroy(): void;
 }

package/interfaces/element.d.ts

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

package/interfaces/engine.d.ts

@@ -0,0 +1,16 @@
+import { RectangleClient, PointOfRectangle, Vector, PlaitBoard, Point, PlaitElement } from '@plait/core';
+import { Options } from 'roughjs/bin/core';
+import { PlaitGeometry } from './geometry';
+export interface EngineExtraData {
+}
+export interface ShapeEngine<T extends PlaitElement = PlaitGeometry, P extends EngineExtraData = EngineExtraData, K extends EngineExtraData = EngineExtraData> {
+    isInsidePoint: (rectangle: RectangleClient, point: Point) => boolean;
+    getNearestPoint: (rectangle: RectangleClient, point: Point) => Point;
+    getNearestCrossingPoint?: (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, roughOptions: Options, options?: P) => SVGGElement;
+    getTextRectangle?: (element: T, options?: K) => RectangleClient;
+}

package/interfaces/geometry.d.ts

@@ -1,8 +1,8 @@
-import { PlaitBoard, PlaitElement, Point, PointOfRectangle, RectangleClient, Vector } from '@plait/core';
-import { Options } from 'roughjs/bin/core';
+import { PlaitElement, Point } from '@plait/core';
 import { ParagraphElement } from '@plait/text';
 import { StrokeStyle } from './element';
 import { PlaitTable } from './table';
+import { PlaitDrawShapeText } from '../generators/text.generator';
 export declare enum BasicShapes {
     rectangle = "rectangle",
     ellipse = "ellipse",
@@ -59,13 +59,23 @@ export declare enum SwimlaneSymbols {
     swimlaneVertical = "swimlaneVertical",
     swimlaneHorizontal = "swimlaneHorizontal"
 }
-export type GeometryShapes = BasicShapes | FlowchartSymbols | SwimlaneSymbols | TableSymbols;
-export interface PlaitGeometry extends PlaitElement {
+export declare enum UMLSymbols {
+    actor = "actor",
+    useCase = "useCase",
+    container = "container",
+    package = "package",
+    combinedFragment = "combinedFragment"
+}
+export declare enum MultipleTextGeometryCommonTextKeys {
+    name = "name",
+    content = "content"
+}
+export type GeometryShapes = BasicShapes | FlowchartSymbols | SwimlaneSymbols | UMLSymbols;
+export type SwimlaneDirection = 'horizontal' | 'vertical';
+export interface PlaitCommonGeometry extends PlaitElement {
     points: [Point, Point];
     type: 'geometry';
     shape: GeometryShapes;
-    text: ParagraphElement;
-    textHeight: number;
     fill?: string;
     strokeColor?: string;
     strokeWidth?: number;
@@ -73,6 +83,13 @@ export interface PlaitGeometry extends PlaitElement {
     angle: number;
     opacity: number;
 }
+export interface PlaitMultipleTextGeometry extends PlaitCommonGeometry {
+    texts: PlaitDrawShapeText[];
+}
+export interface PlaitGeometry extends PlaitCommonGeometry {
+    text?: ParagraphElement;
+    textHeight?: number;
+}
 export interface PlaitRectangle extends PlaitGeometry {
     shape: BasicShapes.rectangle;
 }
@@ -83,7 +100,6 @@ export interface PlaitDiamond extends PlaitGeometry {
     shape: BasicShapes.diamond;
 }
 export interface PlaitSwimlane extends PlaitTable {
-    type: 'geometry';
     shape: SwimlaneSymbols;
 }
 export interface PlaitSwimlaneVertical extends PlaitSwimlane {
@@ -93,14 +109,3 @@ export interface PlaitSwimlaneHorizontal extends PlaitSwimlane {
     shape: SwimlaneSymbols.swimlaneHorizontal;
 }
 export declare const PlaitGeometry: {};
-export interface ShapeEngine {
-    isInsidePoint: (rectangle: RectangleClient, point: Point) => boolean;
-    getNearestPoint: (rectangle: RectangleClient, point: Point) => Point;
-    getNearestCrossingPoint?: (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

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

package/interfaces/index.d.ts

@@ -1,20 +1,29 @@
-import { PlaitGeometry } from './geometry';
+import { GeometryShapes, PlaitGeometry, TableSymbols } from './geometry';
 import { PlaitImage } from './image';
 import { PlaitLine } from './line';
+import { PlaitTable } from './table';
 import { PlaitText } from './text';
 export * from './line';
 export * from './geometry';
 export * from './text';
 export * from './element';
-export type PlaitDrawElement = PlaitGeometry | PlaitLine | PlaitImage;
-export type PlaitShapeElement = PlaitGeometry | PlaitImage;
+export * from './engine';
+export type PlaitDrawElement = PlaitGeometry | PlaitLine | PlaitImage | PlaitTable;
+export type PlaitShapeElement = PlaitGeometry | PlaitImage | PlaitTable;
+export type DrawShapes = GeometryShapes | TableSymbols;
 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;
+    isTable: (value: any) => value is PlaitTable;
     isDrawElement: (value: any) => value is PlaitDrawElement;
     isShapeElement: (value: any) => value is PlaitShapeElement;
     isBasicShape: (value: any) => boolean;
     isFlowchart: (value: any) => boolean;
+    isUML: (value: any) => boolean;
+    isSwimlane: (value: any) => boolean;
+    isVerticalSwimlane: (value: any) => boolean;
+    isHorizontalSwimlane: (value: any) => boolean;
+    isUMLClassOrInterface: (value: any) => boolean;
 };

package/interfaces/line.d.ts

@@ -1,8 +1,7 @@
 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';
+import { PlaitShapeElement } from '.';
 export declare enum LineMarkerType {
     arrow = "arrow",
     none = "none",
@@ -39,7 +38,7 @@ export interface LineHandleRef {
     direction: Direction;
     point: PointOfRectangle;
     vector: Vector;
-    boundElement?: PlaitGeometry;
+    boundElement?: PlaitShapeElement;
 }
 export interface LineHandleRefPair {
     source: LineHandleRef;
@@ -70,7 +69,7 @@ export declare const PlaitLine: {
     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 | PlaitImage): boolean;
-    isBoundElementOfTarget(line: PlaitLine, element: PlaitGeometry | PlaitImage): boolean;
+    isBoundElementOfSource(line: PlaitLine, element: PlaitShapeElement): boolean;
+    isBoundElementOfTarget(line: PlaitLine, element: PlaitShapeElement): boolean;
     getPoints(board: PlaitBoard, line: PlaitLine): Point[];
 };

package/interfaces/table.d.ts

@@ -1,8 +1,10 @@
 import { PlaitElement, Point } from '@plait/core';
+import { EngineExtraData } from './engine';
 import { ParagraphElement } from '@plait/text';
 export interface PlaitTable extends PlaitElement {
     id: string;
     points: Point[];
+    type: 'table';
     rows: {
         id: string;
         height?: number;
@@ -21,7 +23,18 @@ export interface PlaitTableCell {
     colspan?: number;
     rowspan?: number;
     text?: PlaitTableCellParagraph;
+    textHeight?: number;
+}
+export interface PlaitTableDrawOptions extends EngineExtraData {
+    element: PlaitTable;
+}
+export interface PlaitTableCellWithPoints extends PlaitTableCell {
+    points: [Point, Point];
 }
 export interface PlaitTableCellParagraph extends ParagraphElement {
-    writingMode: 'vertical-lr' | 'horizontal-tb';
+    direction?: 'vertical' | 'horizontal';
 }
+export declare const PlaitTableElement: {
+    isTable: (value: any) => value is PlaitTable;
+    isVerticalText: (value: PlaitTableCell) => value is PlaitTableCell;
+};

package/line.component.d.ts

@@ -1,24 +1,20 @@
-import { OnDestroy, OnInit } from '@angular/core';
 import { PlaitBoard, PlaitPluginElementContext, OnContextChanged } from '@plait/core';
-import { Subject } from 'rxjs';
 import { LineText, PlaitGeometry, PlaitLine } from './interfaces';
 import { TextManage } from '@plait/text';
 import { LineShapeGenerator } from './generators/line.generator';
 import { LineActiveGenerator } from './generators/line-active.generator';
-import { CommonPluginElement } from '@plait/common';
-import * as i0 from "@angular/core";
+import { CommonElementFlavour } from '@plait/common';
 interface BoundedElements {
     source?: PlaitGeometry;
     target?: PlaitGeometry;
 }
-export declare class LineComponent extends CommonPluginElement<PlaitLine, PlaitBoard> implements OnInit, OnDestroy, OnContextChanged<PlaitLine, PlaitBoard> {
-    destroy$: Subject<void>;
+export declare class LineComponent extends CommonElementFlavour<PlaitLine, PlaitBoard> implements OnContextChanged<PlaitLine, PlaitBoard> {
     shapeGenerator: LineShapeGenerator;
     activeGenerator: LineActiveGenerator;
     boundedElements: BoundedElements;
     constructor();
     initializeGenerator(): void;
-    ngOnInit(): void;
+    initialize(): void;
     getBoundedElements(): BoundedElements;
     onContextChanged(value: PlaitPluginElementContext<PlaitLine, PlaitBoard>, previous: PlaitPluginElementContext<PlaitLine, PlaitBoard>): void;
     initializeTextManagesByElement(): void;
@@ -26,8 +22,6 @@ export declare class LineComponent extends CommonPluginElement<PlaitLine, PlaitB
     createTextManage(text: LineText, index: number): TextManage;
     updateText(previousTexts: LineText[], currentTexts: LineText[]): void;
     updateTextRectangle(): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LineComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LineComponent, "plait-draw-line", never, {}, {}, never, never, true, never>;
+    destroy(): void;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plait/draw",
-  "version": "0.57.0",
+  "version": "0.58.0",
   "peerDependencies": {
     "@angular/common": "^17.2.4",
     "@angular/core": "^17.2.4",

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

@@ -0,0 +1,8 @@
+import { PlaitBoard } from '@plait/core';
+import { TextManage } from '@plait/text';
+export interface FakeCreateTextRef {
+    g: SVGGElement;
+    textManage: TextManage;
+}
+export declare const withSwimlaneCreateByDrag: (board: PlaitBoard) => PlaitBoard;
+export declare const withSwimlaneCreateByDrawing: (board: PlaitBoard) => PlaitBoard;

package/plugins/with-swimlane.d.ts

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

package/plugins/with-table-resize.d.ts

@@ -0,0 +1,2 @@
+import { PlaitTableBoard } from './with-table';
+export declare function withTableResize(board: PlaitTableBoard): PlaitTableBoard;

package/plugins/with-table.d.ts

@@ -1,2 +1,6 @@
+import { PlaitTable } from '../interfaces/table';
 import { PlaitBoard } from '@plait/core';
-export declare const withTable: (board: PlaitBoard) => PlaitBoard;
+export interface PlaitTableBoard extends PlaitBoard {
+    buildTable: (element: PlaitTable) => PlaitTable;
+}
+export declare const withTable: (board: PlaitBoard) => PlaitTableBoard;

package/public-api.d.ts

@@ -6,3 +6,4 @@ export * from './utils';
 export * from './geometry.component';
 export * from './line.component';
 export * from './transforms';
+export * from './generators/index';

package/table.component.d.ts

@@ -1,15 +1,21 @@
-import { OnDestroy, OnInit } from '@angular/core';
 import { PlaitBoard, PlaitPluginElementContext, OnContextChanged } from '@plait/core';
-import { ActiveGenerator, CommonPluginElement } from '@plait/common';
-import { PlaitTable } from './interfaces/table';
-import * as i0 from "@angular/core";
-export declare class TableComponent extends CommonPluginElement<PlaitTable, PlaitBoard> implements OnInit, OnDestroy, OnContextChanged<PlaitTable, PlaitBoard> {
-    activeGenerator: ActiveGenerator<PlaitTable>;
+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';
+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>;
     constructor();
     initializeGenerator(): void;
-    ngOnInit(): void;
-    onContextChanged(value: PlaitPluginElementContext<PlaitTable, PlaitBoard>, previous: PlaitPluginElementContext<PlaitTable, PlaitBoard>): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "plait-draw-table", never, {}, {}, never, never, true, never>;
+    initialize(): void;
+    draw(): void;
+    rotateVerticalText(): void;
+    getDrawShapeTexts(cells: PlaitTableCell[]): PlaitDrawShapeText[];
+    initializeTextManage(): void;
+    onContextChanged(value: PlaitPluginElementContext<T, PlaitBoard>, previous: PlaitPluginElementContext<T, PlaitBoard>): void;
+    destroy(): void;
 }

package/transforms/geometry.d.ts

@@ -1,8 +1,8 @@
 import { PlaitBoard, Point, Path, Vector } from '@plait/core';
 import { GeometryShapes } from '../interfaces';
 import { Element } from 'slate';
-export declare const insertGeometry: (board: PlaitBoard, points: [Point, Point], shape: GeometryShapes) => import("../interfaces").PlaitGeometry;
-export declare const insertGeometryByVector: (board: PlaitBoard, point: Point, shape: GeometryShapes, vector: Vector) => import("../interfaces").PlaitGeometry | null;
+export declare const insertGeometry: (board: PlaitBoard, points: [Point, Point], shape: GeometryShapes) => import("../interfaces").PlaitGeometry | import("../interfaces").PlaitMultipleTextGeometry;
+export declare const insertGeometryByVector: (board: PlaitBoard, point: Point, shape: GeometryShapes, vector: Vector) => import("../interfaces").PlaitGeometry | import("../interfaces").PlaitMultipleTextGeometry | 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

@@ -1,6 +1,7 @@
 export declare const DrawTransforms: {
     setText: (board: import("@plait/core").PlaitBoard, element: import("@plait/draw").PlaitGeometry, text: import("slate").BaseElement, width: number, textHeight: number) => void;
-    insertGeometry: (board: import("@plait/core").PlaitBoard, points: [import("@plait/core").Point, import("@plait/core").Point], shape: import("@plait/draw").GeometryShapes) => import("@plait/draw").PlaitGeometry;
+    setDrawShapeText: (board: import("@plait/core").PlaitBoard, element: import("@plait/draw").PlaitMultipleTextGeometry, text: import("@plait/draw").PlaitDrawShapeText) => void;
+    insertGeometry: (board: import("@plait/core").PlaitBoard, points: [import("@plait/core").Point, import("@plait/core").Point], shape: import("@plait/draw").GeometryShapes) => import("@plait/draw").PlaitGeometry | import("@plait/draw").PlaitMultipleTextGeometry;
     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;
@@ -12,5 +13,10 @@ export declare const DrawTransforms: {
     insertImage: (board: import("@plait/core").PlaitBoard, imageItem: import("@plait/common").CommonImageItem, startPoint?: import("@plait/core").Point | undefined) => 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").PlaitGeometry | null;
+    insertGeometryByVector: (board: import("@plait/core").PlaitBoard, point: import("@plait/core").Point, shape: import("@plait/draw").GeometryShapes, vector: import("@plait/core").Vector) => import("@plait/draw").PlaitGeometry | import("@plait/draw").PlaitMultipleTextGeometry | null;
+    setTableText: (board: import("@plait/core").PlaitBoard, table: import("../interfaces/table").PlaitTable, cellId: string, text: import("slate").BaseElement, textWidth: number, textHeight: number) => void;
+    addSwimlaneRow: (board: import("@plait/core").PlaitBoard, swimlane: import("@plait/draw").PlaitSwimlane, index: number) => void;
+    addSwimlaneColumn: (board: import("@plait/core").PlaitBoard, swimlane: import("@plait/draw").PlaitSwimlane, index: number) => void;
+    removeSwimlaneRow: (board: import("@plait/core").PlaitBoard, swimlane: import("@plait/draw").PlaitSwimlane, index: number) => void;
+    removeSwimlaneColumn: (board: import("@plait/core").PlaitBoard, swimlane: import("@plait/draw").PlaitSwimlane, index: number) => void;
 };

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

@@ -0,0 +1,4 @@
+import { PlaitBoard } from '@plait/core';
+import { PlaitMultipleTextGeometry } from '../interfaces';
+import { PlaitDrawShapeText } from '../generators/text.generator';
+export declare const setDrawShapeText: (board: PlaitBoard, element: PlaitMultipleTextGeometry, text: PlaitDrawShapeText) => void;

package/transforms/swimlane.d.ts

@@ -0,0 +1,6 @@
+import { PlaitBoard } from '@plait/core';
+import { PlaitSwimlane } from '../interfaces';
+export declare const addSwimlaneRow: (board: PlaitBoard, swimlane: PlaitSwimlane, index: number) => void;
+export declare const addSwimlaneColumn: (board: PlaitBoard, swimlane: PlaitSwimlane, index: number) => void;
+export declare const removeSwimlaneRow: (board: PlaitBoard, swimlane: PlaitSwimlane, index: number) => void;
+export declare const removeSwimlaneColumn: (board: PlaitBoard, swimlane: PlaitSwimlane, index: number) => void;

package/transforms/table-text.d.ts

@@ -0,0 +1,4 @@
+import { 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;

package/utils/clipboard.d.ts

@@ -1,4 +1,6 @@
 import { PlaitBoard, Point } from '@plait/core';
 import { PlaitDrawElement, PlaitGeometry, PlaitLine } from '../interfaces';
+import { PlaitTable } from '../interfaces/table';
 export declare const buildClipboardData: (board: PlaitBoard, elements: PlaitDrawElement[], startPoint: Point) => (PlaitGeometry | PlaitLine)[];
 export declare const insertClipboardData: (board: PlaitBoard, elements: PlaitDrawElement[], startPoint: Point) => void;
+export declare const insertClipboardTableData: (board: PlaitBoard, elements: PlaitTable[], startPoint: Point) => void;

package/utils/common.d.ts

@@ -0,0 +1,27 @@
+import { PlaitBoard, PlaitElement, Point, RectangleClient } from '@plait/core';
+import { DrawShapes, EngineExtraData, PlaitCommonGeometry, PlaitDrawElement, PlaitGeometry, PlaitShapeElement } from '../interfaces';
+import { Options } from 'roughjs/bin/core';
+import { PlaitTable } from '../interfaces/table';
+export declare const getTextRectangle: <T extends PlaitElement = PlaitGeometry>(element: T) => {
+    height: any;
+    width: number;
+    x: any;
+    y: number;
+};
+export declare const getStrokeWidthByElement: (element: PlaitElement) => any;
+export declare const insertElement: (board: PlaitBoard, element: PlaitCommonGeometry | PlaitTable) => void;
+export declare const isDrawElementsIncludeText: (elements: PlaitDrawElement[]) => boolean;
+export declare const getSnappingShape: (board: PlaitBoard, point: Point) => PlaitShapeElement | null;
+export declare const getSnappingRef: (board: PlaitBoard, hitElement: PlaitShapeElement, point: Point) => {
+    isHitEdge: boolean;
+    isHitConnector: boolean;
+    connectorPoint: Point | undefined;
+    edgePoint: Point;
+};
+export declare const getHitShape: (board: PlaitBoard, point: Point, offset?: number) => PlaitShapeElement | null;
+export declare const traverseDrawShapes: (board: PlaitBoard, callback: (element: PlaitShapeElement) => void) => void;
+export declare const drawShape: (board: PlaitBoard, outerRectangle: RectangleClient, shape: DrawShapes, roughOptions: Options, drawOptions: EngineExtraData) => SVGGElement;
+export declare const drawBoundReaction: (board: PlaitBoard, element: PlaitShapeElement, roughOptions?: {
+    hasMask: boolean;
+    hasConnector: boolean;
+}) => SVGGElement;