@plait/common 0.90.1 → 0.92.0-next.0

package/index.d.ts

@@ -1,5 +1,607 @@
+import * as _plait_core from '@plait/core';
+import { PlaitElement, PlaitBoard, RectangleClient, Point, ResizeCursorClass, Path, Direction, PointOfRectangle, Vector, DirectionFactor, WithPluginOptions, PlaitElementRef, ElementFlavour, PlaitGroup, OnContextChanged, PlaitPluginElementContext } from '@plait/core';
+import * as slate from 'slate';
+import { Element as Element$1, Editor, Operation, BaseElement } from 'slate';
+
+declare const BASE = 4;
+declare const PRIMARY_COLOR = "#6698FF";
+declare const RESIZE_HANDLE_DIAMETER = 9;
+declare const WithTextPluginKey = "plait-text-plugin-key";
+declare const DEFAULT_ROUTE_MARGIN = 30;
+declare const TRANSPARENT = "transparent";
+declare const ROTATE_HANDLE_DISTANCE_TO_ELEMENT = 4;
+declare const ROTATE_HANDLE_SIZE = 18;
+declare const DEFAULT_FONT_FAMILY = "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'PingFang SC', 'Noto Sans', 'Noto Sans CJK SC', 'Microsoft Yahei', 'Hiragino Sans GB', Arial, sans-serif";
+declare const DEFAULT_FILL = "none";
+
+declare enum MediaKeys {
+    image = "image"
+}
+declare const PICTURE_ACCEPTED_UPLOAD_SIZE = 20;
+declare const acceptImageTypes: string[];
+declare const WithCommonPluginKey = "plait-common-plugin-key";
+
+declare enum ResizeHandle {
+    nw = "0",
+    n = "4",
+    ne = "1",
+    e = "5",
+    se = "2",
+    s = "6",
+    sw = "3",
+    w = "7"
+}
+
+declare enum StrokeStyle {
+    solid = "solid",
+    dashed = "dashed",
+    dotted = "dotted"
+}
+
+interface GeneratorExtraData {
+}
+interface GeneratorOptions {
+    prepend?: boolean;
+    active?: boolean;
+}
+declare abstract class Generator<T extends PlaitElement = PlaitElement, K extends GeneratorExtraData = GeneratorExtraData, V extends GeneratorOptions = GeneratorOptions, P extends PlaitBoard = PlaitBoard> {
+    protected board: P;
+    g?: SVGGElement;
+    protected options?: V;
+    constructor(board: P, options?: V);
+    processDrawing(element: T, parentG: SVGGElement, data?: K): void;
+    /**
+     * abstract function
+     */
+    protected abstract canDraw(element: T, data?: K): boolean;
+    /**
+     * abstract function
+     */
+    protected abstract draw(element: T, data?: K): SVGGElement | undefined;
+    destroy(): void;
+}
+interface AfterDraw<T extends PlaitElement = PlaitElement> {
+    afterDraw(element: T): void;
+}
+declare function hasAfterDraw(value: any): value is AfterDraw;
+
+interface ActiveGeneratorExtraData {
+    selected: boolean;
+}
+interface ActiveGeneratorOptions<T> extends GeneratorOptions {
+    getRectangle: (element: T) => RectangleClient;
+    getStrokeWidth: () => number;
+    getStrokeOpacity: () => number;
+    hasResizeHandle: () => boolean;
+    active: true;
+}
+declare const createActiveGenerator: <T extends PlaitElement = PlaitElement>(board: PlaitBoard, options: Omit<ActiveGeneratorOptions<T>, "active">) => ActiveGenerator<T>;
+declare class ActiveGenerator<T extends PlaitElement = PlaitElement> extends Generator<T, ActiveGeneratorExtraData, ActiveGeneratorOptions<T>> {
+    board: PlaitBoard;
+    options: ActiveGeneratorOptions<T>;
+    static key: string;
+    hasResizeHandle: boolean;
+    constructor(board: PlaitBoard, options: ActiveGeneratorOptions<T>);
+    canDraw(element: T, data: ActiveGeneratorExtraData): boolean;
+    draw(element: T, data: ActiveGeneratorExtraData): SVGGElement;
+}
+
+type PlaitElementOrArray = PlaitElement | PlaitElement[];
+interface ResizeOptions {
+}
+interface WithResizeOptions<T extends PlaitElementOrArray = PlaitElementOrArray, K = ResizeHandle, P = ResizeOptions> {
+    key: string;
+    canResize: () => boolean;
+    hitTest: (point: Point) => ResizeHitTestRef<T, K, P> | null;
+    onResize: (resizeRef: ResizeRef<T, K, P>, resizeState: ResizeState) => void;
+    afterResize?: (resizeRef: ResizeRef<T, K, P>) => void;
+    beforeResize?: (resizeRef: ResizeRef<T, K, P>) => void;
+}
+interface ResizeHitTestRef<T extends PlaitElementOrArray = PlaitElementOrArray, K = ResizeHandle, P = ResizeOptions> {
+    element: T;
+    rectangle?: RectangleClient;
+    handle: K;
+    handleIndex?: number;
+    cursorClass?: ResizeCursorClass;
+    options?: P;
+}
+interface ResizeState {
+    startPoint: Point;
+    endPoint: Point;
+    isShift: boolean;
+}
+interface ResizeRef<T extends PlaitElementOrArray = PlaitElementOrArray, K = ResizeHandle, P = ResizeOptions> {
+    element: T;
+    rectangle?: RectangleClient;
+    path: Path | Path[];
+    handle: K;
+    handleIndex?: number;
+    options?: P;
+}
+
+declare const getResizeHandleByIndex: (index: number) => ResizeHandle;
+declare const getIndexByResizeHandle: (resizeHandle: ResizeHandle) => number;
+declare const getSymmetricHandleIndex: (board: PlaitBoard, index: number) => number;
+declare const getRotatedResizeCursorClassByAngle: (cursor: ResizeCursorClass, angle: number) => ResizeCursorClass;
+declare const getRectangleResizeHandleRefs: (rectangle: RectangleClient, diameter: number) => {
+    rectangle: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    handle: ResizeHandle;
+    cursorClass: ResizeCursorClass;
+}[];
+declare const getResizeHandlePointByIndex: (rectangle: RectangleClient, index: number) => Point;
+declare const IS_RESIZING: WeakMap<PlaitBoard, ResizeRef<any, any, any>>;
+declare const isResizing: (board: PlaitBoard) => boolean;
+declare const isResizingByCondition: <T extends PlaitElementOrArray, K>(board: PlaitBoard, match: (resizeRef: ResizeRef<T, K>) => boolean) => boolean;
+declare const addResizing: <T extends PlaitElementOrArray, K, P>(board: PlaitBoard, resizeRef: ResizeRef<T, K, P>, key: string) => void;
+declare const removeResizing: (board: PlaitBoard, key: string) => void;
+declare const isEdgeHandle: (board: PlaitBoard, handle: ResizeHandle) => boolean;
+declare const isCornerHandle: (board: PlaitBoard, handle: ResizeHandle) => boolean;
+declare const resetPointsAfterResize: (originRectangle: RectangleClient, currentRectangle: RectangleClient, originSelectionCenterPoint: Point, currentSelectionCenterPoint: Point, angle: number) => [Point, Point];
+declare const hasMoreThanOnePoint: (element: PlaitElement) => boolean;
+declare const hasResizeHandle: (board: PlaitBoard, element: PlaitElement) => boolean;
+
+declare function getPointOnPolyline(points: Point[], ratio: number): number[];
+declare function calculatePolylineLength(points: Point[]): number;
+declare function getRatioByPoint(points: Point[], point: Point): number;
+declare const removeDuplicatePoints: (points: Point[]) => Point[];
+declare function simplifyOrthogonalPoints(points: Point[]): Point[];
+declare const getExtendPoint: (source: Point, target: Point, extendDistance: number) => Point;
+
+declare const getPoints: (source: Point, sourcePosition: Direction, target: Point, targetPosition: Direction, offset: number) => Point[];
+
+declare function isVirtualKey(e: KeyboardEvent): boolean;
+declare const isExpandHotkey: (event: KeyboardEvent) => boolean;
+declare const isTabHotkey: (event: KeyboardEvent) => boolean;
+declare const isEnterHotkey: (event: KeyboardEvent) => boolean;
+declare const isSpaceHotkey: (event: KeyboardEvent) => boolean;
+declare const isDelete: (event: KeyboardEvent) => boolean;
+
+declare enum BoardCreationMode {
+    'dnd' = "dnd",
+    'drawing' = "drawing"
+}
+declare const getCreationMode: (board: PlaitBoard) => BoardCreationMode | undefined;
+declare const setCreationMode: (board: PlaitBoard, mode: BoardCreationMode) => void;
+declare const isDndMode: (board: PlaitBoard) => boolean;
+declare const isDrawingMode: (board: PlaitBoard) => boolean;
+
+declare function getOppositeDirection(direction: Direction): Direction;
+declare function getDirectionByPointOfRectangle(point: PointOfRectangle): Direction | undefined;
 /**
- * Generated bundle index. Do not edit.
+ * this function accepts vector parameter, the vector parameter vector is based on the screen coordinate system
+ * vector[0] and vector[1] are the x and y components of the vector respectively.
+ * if the vector has only one direction, the function returns a string in that direction, such as 'right', 'top', 'bottom' or 'left'.
+ * if the vector has two directions, the function will return the string in which direction it is closer.
  */
-/// <amd-module name="@plait/common" />
-export * from './public-api';
+declare function getDirectionByVector(vector: Vector): Direction | null;
+declare function getDirectionBetweenPointAndPoint(source: Point, target: Point): Direction;
+declare function getDirectionFactor(direction: Direction): {
+    x: number;
+    y: number;
+} | {
+    x: number;
+    y: number;
+} | {
+    x: number;
+    y: number;
+} | {
+    x: number;
+    y: number;
+};
+declare function getDirectionFactorByDirectionComponent(directionComponent: number): DirectionFactor;
+
+interface RenderComponentRef<T> {
+    destroy: () => void;
+    update: (props: Partial<T>) => void;
+}
+
+interface PlaitTextBoard {
+    renderText: (container: Element | DocumentFragment, props: TextProps) => TextComponentRef;
+}
+declare const withText: <T extends PlaitBoard = PlaitBoard>(board: T) => T & PlaitTextBoard;
+type TextComponentRef = RenderComponentRef<TextProps>;
+interface TextProps {
+    board: PlaitBoard;
+    text: Element$1;
+    textPlugins?: TextPlugin[];
+    readonly?: boolean;
+    onChange?: (data: TextChangeData) => void;
+    afterInit?: (data: Editor) => void;
+    onComposition?: (data: CompositionEvent) => void;
+}
+type TextChangeData = {
+    newText: Element$1;
+    operations: Operation[];
+};
+interface WithTextPluginOptions extends WithPluginOptions {
+    textPlugins?: TextPlugin[];
+}
+type TextPlugin = (editor: Editor) => Editor;
+
+interface TextManageChangeData {
+    newText?: Element$1;
+    operations?: Operation[];
+    width: number;
+    height: number;
+}
+declare class TextManage {
+    private board;
+    private options;
+    isEditing: boolean;
+    editor: Editor;
+    g: SVGGElement;
+    foreignObject: SVGForeignObjectElement;
+    textComponentRef: TextComponentRef;
+    exitCallback?: () => void;
+    constructor(board: PlaitBoard, options: {
+        getRectangle: () => RectangleClient;
+        onChange?: (data: TextManageChangeData) => void;
+        getRenderRectangle?: () => RectangleClient;
+        getMaxWidth?: () => number;
+        textPlugins?: TextPlugin[];
+    });
+    draw(text: Element$1): void;
+    updateRectangleWidth(width: number): void;
+    updateAngle(centerPoint: Point, angle?: number): void;
+    updateRectangle(rectangle?: RectangleClient): void;
+    updateText(newText: Element$1): void;
+    edit(callback?: () => void, exitEdit?: (event: Event) => boolean): () => void;
+    getSize: (element?: Element$1, maxWidth?: number) => {
+        width: number;
+        height: number;
+    };
+    getText: () => slate.Descendant;
+    destroy(): void;
+}
+declare const buildCompositionData: (editor: Editor, data: string) => {
+    children: any[];
+} | null;
+
+type ElementSize = {
+    width: number;
+    height: number;
+};
+declare enum Alignment {
+    left = "left",
+    center = "center",
+    right = "right"
+}
+type CustomText = {
+    bold?: boolean;
+    italic?: boolean;
+    strike?: boolean;
+    code?: boolean;
+    text: string;
+    underlined?: boolean;
+    color?: string;
+    [`font-size`]?: string;
+};
+interface LinkElement extends BaseElement {
+    type: 'link';
+    url: string;
+}
+interface ParagraphElement extends BaseElement {
+    align?: Alignment;
+}
+type CustomElement = ParagraphElement | LinkElement;
+
+interface TextInterface {
+    getTextEditors: (board: PlaitBoard, elements?: PlaitElement[]) => Editor[] | undefined;
+    findFirstTextEditor: (board: PlaitBoard) => null;
+    getFirstTextEditor: (element: PlaitElement) => Editor;
+    getTextEditorsByElement: (element: PlaitElement) => Editor[];
+    getEditingTextEditor: (board: PlaitBoard, elements?: PlaitElement[]) => Editor | undefined;
+}
+declare const getTextManages: (element: PlaitElement) => TextManage[];
+declare const getFirstTextManage: (element: PlaitElement) => TextManage;
+declare const getTextEditorsByElement: TextInterface['getTextEditorsByElement'];
+declare const getFirstTextEditor: TextInterface['getFirstTextEditor'];
+declare const findFirstTextEditor: TextInterface['findFirstTextEditor'];
+declare const getElementsText: (elements: PlaitElement[]) => string;
+declare const getTextEditors: TextInterface['getTextEditors'];
+declare const getEditingTextEditor: TextInterface['getEditingTextEditor'];
+declare const buildText: (text: string | Element$1, align?: Alignment, properties?: Partial<CustomText>) => slate.BaseElement | {
+    children: {
+        bold?: boolean | undefined;
+        italic?: boolean | undefined;
+        strike?: boolean | undefined;
+        code?: boolean | undefined;
+        text: string;
+        underlined?: boolean | undefined;
+        color?: string | undefined;
+        "font-size"?: string | undefined;
+    }[];
+    type: string;
+};
+declare const getLineHeightByFontSize: (fontSize: number) => number;
+
+interface CommonImageItem {
+    url: string;
+    width: number;
+    height: number;
+}
+declare const selectImage: (board: PlaitBoard, defaultImageWidth: number, handle: (commonImage: CommonImageItem) => void, acceptImageTypes?: string[]) => void;
+declare const buildImage: (board: PlaitBoard, imageFile: File, defaultImageWidth: number, handle: (commonImage: CommonImageItem) => void) => Promise<void>;
+declare const getElementOfFocusedImage: (board: PlaitBoard) => PlaitElement | undefined;
+declare const addElementOfFocusedImage: (board: PlaitBoard, element: PlaitElement) => void;
+declare const removeElementOfFocusedImage: (board: PlaitBoard) => void;
+
+declare class PointNode {
+    data: Point;
+    distance: number;
+    adjacentNodes: PointNode[];
+    constructor(data: Point);
+}
+declare class PointGraph {
+    private index;
+    add(p: Point): void;
+    connect(a: Point, b: Point): void;
+    has(p: Point): boolean;
+    get(p: Point): PointNode | null;
+}
+
+declare class AStar {
+    private graph;
+    cameFrom: Map<PointNode, PointNode>;
+    constructor(graph: PointGraph);
+    heuristic(a: Point, b: Point): number;
+    search(start: Point, end: Point, previousStart: Point): void;
+    getRoute(start: Point, end: Point): Point[];
+}
+
+declare class PriorityQueue {
+    list: {
+        node: PointNode;
+        priority: number;
+    }[];
+    constructor();
+    enqueue(item: {
+        node: PointNode;
+        priority: number;
+    }): void;
+    dequeue(): {
+        node: PointNode;
+        priority: number;
+    } | undefined;
+}
+
+interface ElbowLineRouteOptions {
+    sourcePoint: Point;
+    nextSourcePoint: Point;
+    sourceRectangle: RectangleClient;
+    sourceOuterRectangle: RectangleClient;
+    targetPoint: Point;
+    nextTargetPoint: Point;
+    targetOuterRectangle: RectangleClient;
+    targetRectangle: RectangleClient;
+}
+interface RouteAdjustOptions {
+    centerX?: number;
+    centerY?: number;
+    sourceRectangle: RectangleClient;
+    targetRectangle: RectangleClient;
+}
+interface AdjustOptions {
+    parallelPaths: [Point, Point][];
+    pointOfHit: Point;
+    sourceRectangle: RectangleClient;
+    targetRectangle: RectangleClient;
+}
+declare const generateElbowLineRoute: (options: ElbowLineRouteOptions, board?: PlaitBoard) => Point[];
+declare const routeAdjust: (path: Point[], options: RouteAdjustOptions, board?: PlaitBoard) => Point[];
+declare const getGraphPoints: (options: ElbowLineRouteOptions) => Point[];
+declare const createGraph: (points: Point[]) => PointGraph;
+declare const reduceRouteMargin: (sourceRectangle: RectangleClient, targetRectangle: RectangleClient) => {
+    sourceOffset: number[];
+    targetOffset: number[];
+};
+declare const getNextPoint: (point: Point, outerRectangle: RectangleClient, direction: Direction) => Point;
+declare const getSourceAndTargetOuterRectangle: (sourceRectangle: RectangleClient, targetRectangle: RectangleClient) => {
+    sourceOuterRectangle: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    targetOuterRectangle: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};
+declare const isSourceAndTargetIntersect: (options: ElbowLineRouteOptions) => boolean;
+
+declare const memorizeLatest: <T extends PlaitElement = PlaitElement>(memorizedKey: string, propertyKey: keyof T, propertyValue: T[keyof T]) => void;
+declare const getMemorizedLatest: <T extends PlaitElement = PlaitElement>(memorizedKey: string) => T;
+
+declare function getUnitVectorByPointAndPoint(point1: Point, point2: Point): Point;
+declare function getPointByVectorComponent(point: Point, vector: Vector, component: number): Point;
+declare function getPointByVectorDirectionComponent(point: Point, unitVector: Vector, directionComponent: number, isHorizontal: boolean): Point;
+declare function rotateVectorAnti90(vector: Vector): Vector;
+declare function rotateVector(vector: Vector, angle: number): Vector;
+
+declare function isPointOnSegment(point: Point, startPoint: Point, endPoint: Point): boolean;
+declare const getCrossingPointsBetweenPointAndSegment: (point: Point, startPoint: Point, endPoint: Point) => Point[];
+
+declare const drawHandle: (board: PlaitBoard, centerPoint: Point) => SVGGElement;
+declare function drawFillPrimaryHandle(board: PlaitBoard, point: Point): SVGGElement;
+declare function drawPrimaryHandle(board: PlaitBoard, point: Point): SVGGElement;
+
+declare const drawRotateHandle: (board: PlaitBoard, rectangle: RectangleClient) => SVGGElement;
+
+interface RotateRef<T extends PlaitElement = PlaitElement> {
+    elements: T[];
+    startPoint: Point;
+    angle?: number;
+}
+
+declare const IS_ROTATING: WeakMap<PlaitBoard, RotateRef<_plait_core.PlaitElement>>;
+declare const isRotating: (board: PlaitBoard) => boolean;
+declare const addRotating: (board: PlaitBoard, rotateRef: RotateRef) => void;
+declare const removeRotating: (board: PlaitBoard) => void;
+
+declare const getElementArea: (board: PlaitBoard, element: PlaitElement) => number;
+declare const sortElementsByArea: (board: PlaitBoard, elements: PlaitElement[], direction?: "desc" | "asc") => PlaitElement[];
+declare const isFilled: (fill: string) => boolean | "";
+
+type AnimateOption = {
+    stop: () => void;
+    start: () => void;
+};
+declare function animate(tween: (t: number) => void, duration: number, ease: Function, callback: Function): AnimateOption;
+declare function getTimestamp(): number;
+declare function linear(t: number): number;
+
+declare const getStrokeLineDash: (strokeStyle: StrokeStyle, strokeWidth: number) => number[] | undefined;
+
+declare const buildClipboardData: (board: PlaitBoard, elements: PlaitElement[], startPoint: Point, elementBuilder?: (element: PlaitElement) => PlaitElement | undefined) => (PlaitElement | {
+    points: number[][];
+    id: string;
+    children?: PlaitElement[];
+    type?: string;
+    groupId?: string;
+    angle?: number;
+})[];
+declare const insertClipboardData: (board: PlaitBoard, elements: PlaitElement[], startPoint: Point, elementHandler?: (element: PlaitElement, idsMap: Record<string, string>) => void) => void;
+
+declare const moveXOfPoint: (point: Point, distance: number, direction?: Direction) => Point;
+declare const moveYOfPoint: (point: Point, distance: number, direction?: Direction) => Point;
+declare const getDirectionByIndex: (index: number) => Direction;
+declare const getXDistanceBetweenPoint: (point1: Point, point2: Point, isHorizontal: boolean) => number;
+
+interface PlaitImageBoard {
+    renderImage: (container: Element | DocumentFragment, props: ImageProps) => ImageComponentRef;
+}
+declare const withImage: <T extends PlaitBoard = PlaitBoard>(board: T) => T & PlaitImageBoard;
+type ImageComponentRef = RenderComponentRef<ImageProps>;
+interface ImageProps {
+    board: PlaitBoard;
+    imageItem: CommonImageItem;
+    element: PlaitElement;
+    isFocus?: boolean;
+    getRectangle: () => RectangleClient;
+}
+
+declare const FOREIGN_OBJECT_IMAGE_CLASS_NAME = "foreign-object-image";
+interface ImageGeneratorOptions<T> {
+    getRectangle: (element: T) => RectangleClient;
+    getImageItem: (element: T) => CommonImageItem;
+}
+declare class ImageGenerator<T extends PlaitElement = PlaitElement> extends Generator<T, GeneratorExtraData, ImageGeneratorOptions<T> & GeneratorOptions> {
+    board: PlaitBoard;
+    options: ImageGeneratorOptions<T>;
+    static key: string;
+    foreignObject: SVGForeignObjectElement;
+    imageComponentRef: ImageComponentRef;
+    activeGenerator: ActiveGenerator;
+    isFocus: boolean;
+    element: T;
+    constructor(board: PlaitBoard, options: ImageGeneratorOptions<T>);
+    canDraw(element: T): boolean;
+    draw(element: T): SVGGElement;
+    updateImage(nodeG: SVGGElement, previous: T, current: T): void;
+    setFocus(element: PlaitElement, isFocus: boolean): void;
+    destroy(): void;
+}
+
+interface SetOptions<T extends PlaitElement = PlaitElement> {
+    callback?: (element: T, path: Path) => void;
+    getMemorizeKey?: (element: T) => string;
+    match?: (element: T) => boolean;
+}
+declare const setProperty: <T extends PlaitElement = PlaitElement>(board: PlaitBoard, properties: Partial<T>, options?: SetOptions<T>) => void;
+declare const PropertyTransforms: {
+    setFillColor: (board: PlaitBoard, fill: string | null, options: SetOptions) => void;
+    setStrokeStyle: (board: PlaitBoard, strokeStyle: string, options: SetOptions) => void;
+    setProperty: <T extends PlaitElement = PlaitElement>(board: PlaitBoard, properties: Partial<T>, options?: SetOptions<T>) => void;
+    setStrokeWidth: (board: PlaitBoard, strokeWidth: number, options: SetOptions) => void;
+    setStrokeColor: (board: PlaitBoard, strokeColor: string | null, options: SetOptions) => void;
+};
+
+declare const alignTop: (board: PlaitBoard) => void;
+declare const alignBottom: (board: PlaitBoard) => void;
+declare const alignLeft: (board: PlaitBoard) => void;
+declare const alignHorizontalCenter: (board: PlaitBoard) => void;
+declare const alignVerticalCenter: (board: PlaitBoard) => void;
+declare const alignRight: (board: PlaitBoard) => void;
+declare const distributeHorizontal: (board: PlaitBoard) => void;
+declare const distributeVertical: (board: PlaitBoard) => void;
+interface AlignTransform {
+    alignTop: (board: PlaitBoard) => void;
+    alignHorizontalCenter: (board: PlaitBoard) => void;
+    alignBottom: (board: PlaitBoard) => void;
+    alignLeft: (board: PlaitBoard) => void;
+    alignVerticalCenter: (board: PlaitBoard) => void;
+    alignRight: (board: PlaitBoard) => void;
+    distributeHorizontal: (board: PlaitBoard) => void;
+    distributeVertical: (board: PlaitBoard) => void;
+}
+declare const AlignTransform: AlignTransform;
+
+declare const normalizeShapePoints: (points: [Point, Point], shift?: boolean) => [Point, Point];
+
+declare const withResize: <T extends PlaitElementOrArray = PlaitElementOrArray, K = ResizeHandle, P = ResizeOptions>(board: PlaitBoard, options: WithResizeOptions<T, K, P>) => PlaitBoard;
+
+declare function withGroup(board: PlaitBoard): PlaitBoard;
+
+declare abstract class ImageBaseComponent {
+    _isFocus: boolean;
+    element: PlaitElement;
+    board: PlaitBoard;
+    set isFocus(value: boolean);
+    get isFocus(): boolean;
+    abstract nativeElement(): HTMLElement;
+}
+
+declare const getElementSize: (board: PlaitBoard | null, element: ParagraphElement, options: {
+    fontSize: number;
+    fontFamily: string;
+}, containerMaxWidth?: number) => ElementSize;
+declare const updateElementSizeCache: (board: PlaitBoard | null, element: ParagraphElement, size: ElementSize) => void;
+declare const clearElementSizeCache: (board: PlaitBoard | null, element: ParagraphElement) => void;
+declare function measureElement(board: PlaitBoard | null, element: ParagraphElement, options: {
+    fontSize: number;
+    fontFamily: string;
+}, containerMaxWidth?: number): {
+    width: number;
+    height: number;
+};
+
+declare class PlaitCommonElementRef implements PlaitElementRef {
+    private textManages;
+    private generatorMap;
+    addGenerator<T extends Object = Generator>(key: string, generator: T): void;
+    getGenerator<T extends Object = Generator>(key: string): T;
+    initializeTextManage(textManage: TextManage | TextManage[]): void;
+    getTextManages(): TextManage[];
+    updateActiveSection: () => void;
+    destroyTextManage(): void;
+}
+
+declare class CommonElementFlavour<T extends PlaitElement = PlaitElement, K extends PlaitBoard = PlaitBoard, R extends PlaitCommonElementRef = PlaitCommonElementRef> extends ElementFlavour<T, K, R> {
+    constructor(elementRef?: PlaitCommonElementRef);
+}
+
+declare class GroupGenerator extends Generator<PlaitGroup> {
+    static key: string;
+    canDraw(element: PlaitGroup): boolean;
+    draw(element: PlaitGroup, partialSelected: boolean): SVGGElement;
+}
+
+declare class GroupComponent extends CommonElementFlavour<PlaitGroup, PlaitBoard> implements OnContextChanged<PlaitGroup, PlaitBoard> {
+    constructor();
+    activeGenerator: ActiveGenerator<PlaitGroup>;
+    groupGenerator: GroupGenerator;
+    initializeGenerator(): void;
+    initialize(): void;
+    onContextChanged(value: PlaitPluginElementContext<PlaitGroup, PlaitBoard>, previous: PlaitPluginElementContext<PlaitGroup, PlaitBoard>): void;
+}
+
+export { AStar, ActiveGenerator, AlignTransform, Alignment, BASE, BoardCreationMode, CommonElementFlavour, DEFAULT_FILL, DEFAULT_FONT_FAMILY, DEFAULT_ROUTE_MARGIN, FOREIGN_OBJECT_IMAGE_CLASS_NAME, Generator, GroupComponent, IS_RESIZING, IS_ROTATING, ImageBaseComponent, ImageGenerator, MediaKeys, PICTURE_ACCEPTED_UPLOAD_SIZE, PRIMARY_COLOR, PlaitCommonElementRef, PointGraph, PointNode, PriorityQueue, PropertyTransforms, RESIZE_HANDLE_DIAMETER, ROTATE_HANDLE_DISTANCE_TO_ELEMENT, ROTATE_HANDLE_SIZE, ResizeHandle, StrokeStyle, TRANSPARENT, TextManage, WithCommonPluginKey, WithTextPluginKey, acceptImageTypes, addElementOfFocusedImage, addResizing, addRotating, alignBottom, alignHorizontalCenter, alignLeft, alignRight, alignTop, alignVerticalCenter, animate, buildClipboardData, buildCompositionData, buildImage, buildText, calculatePolylineLength, clearElementSizeCache, createActiveGenerator, createGraph, distributeHorizontal, distributeVertical, drawFillPrimaryHandle, drawHandle, drawPrimaryHandle, drawRotateHandle, findFirstTextEditor, generateElbowLineRoute, getCreationMode, getCrossingPointsBetweenPointAndSegment, getDirectionBetweenPointAndPoint, getDirectionByIndex, getDirectionByPointOfRectangle, getDirectionByVector, getDirectionFactor, getDirectionFactorByDirectionComponent, getEditingTextEditor, getElementArea, getElementOfFocusedImage, getElementSize, getElementsText, getExtendPoint, getFirstTextEditor, getFirstTextManage, getGraphPoints, getIndexByResizeHandle, getLineHeightByFontSize, getMemorizedLatest, getNextPoint, getOppositeDirection, getPointByVectorComponent, getPointByVectorDirectionComponent, getPointOnPolyline, getPoints, getRatioByPoint, getRectangleResizeHandleRefs, getResizeHandleByIndex, getResizeHandlePointByIndex, getRotatedResizeCursorClassByAngle, getSourceAndTargetOuterRectangle, getStrokeLineDash, getSymmetricHandleIndex, getTextEditors, getTextEditorsByElement, getTextManages, getTimestamp, getUnitVectorByPointAndPoint, getXDistanceBetweenPoint, hasAfterDraw, hasMoreThanOnePoint, hasResizeHandle, insertClipboardData, isCornerHandle, isDelete, isDndMode, isDrawingMode, isEdgeHandle, isEnterHotkey, isExpandHotkey, isFilled, isPointOnSegment, isResizing, isResizingByCondition, isRotating, isSourceAndTargetIntersect, isSpaceHotkey, isTabHotkey, isVirtualKey, linear, measureElement, memorizeLatest, moveXOfPoint, moveYOfPoint, normalizeShapePoints, reduceRouteMargin, removeDuplicatePoints, removeElementOfFocusedImage, removeResizing, removeRotating, resetPointsAfterResize, rotateVector, rotateVectorAnti90, routeAdjust, selectImage, setCreationMode, setProperty, simplifyOrthogonalPoints, sortElementsByArea, updateElementSizeCache, withGroup, withImage, withResize, withText };
+export type { ActiveGeneratorExtraData, ActiveGeneratorOptions, AdjustOptions, AfterDraw, AnimateOption, CommonImageItem, CustomElement, CustomText, ElbowLineRouteOptions, ElementSize, GeneratorExtraData, GeneratorOptions, ImageComponentRef, ImageGeneratorOptions, ImageProps, LinkElement, ParagraphElement, PlaitElementOrArray, PlaitImageBoard, PlaitTextBoard, RenderComponentRef, ResizeHitTestRef, ResizeOptions, ResizeRef, ResizeState, RotateRef, RouteAdjustOptions, SetOptions, TextChangeData, TextComponentRef, TextInterface, TextManageChangeData, TextPlugin, TextProps, WithResizeOptions, WithTextPluginOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plait/common",
-  "version": "0.90.1",
+  "version": "0.92.0-next.0",
   "peerDependencies": {},
   "dependencies": {
     "tslib": "^2.3.0"

package/algorithms/a-star.d.ts

@@ -1,10 +0,0 @@
-import { Point } from '@plait/core';
-import { PointGraph, PointNode } from './data-structures/graph';
-export declare class AStar {
-    private graph;
-    cameFrom: Map<PointNode, PointNode>;
-    constructor(graph: PointGraph);
-    heuristic(a: Point, b: Point): number;
-    search(start: Point, end: Point, previousStart: Point): void;
-    getRoute(start: Point, end: Point): Point[];
-}

package/algorithms/data-structures/graph.d.ts

@@ -1,14 +0,0 @@
-import { Point } from '@plait/core';
-export declare class PointNode {
-    data: Point;
-    distance: number;
-    adjacentNodes: PointNode[];
-    constructor(data: Point);
-}
-export declare class PointGraph {
-    private index;
-    add(p: Point): void;
-    connect(a: Point, b: Point): void;
-    has(p: Point): boolean;
-    get(p: Point): PointNode | null;
-}

package/algorithms/data-structures/index.d.ts

@@ -1,2 +0,0 @@
-export * from './graph';
-export * from './priority-queue';

package/algorithms/data-structures/priority-queue.d.ts

@@ -1,16 +0,0 @@
-import { PointNode } from './graph';
-export declare class PriorityQueue {
-    list: {
-        node: PointNode;
-        priority: number;
-    }[];
-    constructor();
-    enqueue(item: {
-        node: PointNode;
-        priority: number;
-    }): void;
-    dequeue(): {
-        node: PointNode;
-        priority: number;
-    } | undefined;
-}

package/algorithms/index.d.ts

@@ -1,2 +0,0 @@
-export * from './a-star';
-export * from './data-structures';

package/constants/default.d.ts

@@ -1,10 +0,0 @@
-export declare const BASE = 4;
-export declare const PRIMARY_COLOR = "#6698FF";
-export declare const RESIZE_HANDLE_DIAMETER = 9;
-export declare const WithTextPluginKey = "plait-text-plugin-key";
-export declare const DEFAULT_ROUTE_MARGIN = 30;
-export declare const TRANSPARENT = "transparent";
-export declare const ROTATE_HANDLE_DISTANCE_TO_ELEMENT = 4;
-export declare const ROTATE_HANDLE_SIZE = 18;
-export declare const DEFAULT_FONT_FAMILY = "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'PingFang SC', 'Noto Sans', 'Noto Sans CJK SC', 'Microsoft Yahei', 'Hiragino Sans GB', Arial, sans-serif";
-export declare const DEFAULT_FILL = "none";