microboard-temp 0.1.1 → 0.1.3

package/dist/types/Items/Anchor/Anchor.d.ts

@@ -0,0 +1,32 @@
+import { DrawingContext } from 'Items/DrawingContext';
+import { Mbr, Point } from '..';
+export declare const ANCHOR_BORDER_COLOR = "rgb(147, 175, 246)";
+export declare const ANCHOR_BACKGROUND_COLOR = "rgb(255, 255, 255)";
+export declare const ANCHOR_STROKE_WIDTH = 1;
+export declare const ANCHOR_RADIUS = 50;
+type Center = {
+    x: number;
+    y: number;
+};
+export declare function renderAnchor(ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, center: Center, width: number, borderColor: string, backgroundColor: string, strokeWidth: number, scale: number): void;
+export declare function renderCircleAnchor(ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, center: Center, radius: number, borderColor: string, backgroundColor: string, strokeWidth: number, scale: number): void;
+/**
+ * The minimum bounding rectangle (MBR), also known as bounding box (BBOX) or envelope.
+ * https://en.wikipedia.org/wiki/Minimum_bounding_rectangle
+ */
+export declare class Anchor extends Mbr {
+    x: number;
+    y: number;
+    radius: number;
+    borderColor: string;
+    backgroundColor: string;
+    strokeWidth: number;
+    constructor(x?: number, y?: number, radius?: number, borderColor?: string, backgroundColor?: string, strokeWidth?: number);
+    getDistanceTo(point: {
+        x: number;
+        y: number;
+    }): number;
+    getCenter(): Point;
+    render(context: DrawingContext, type?: 'rect' | 'circle', active?: boolean): void;
+}
+export {};

package/dist/types/Items/Anchor/index.d.ts

@@ -0,0 +1 @@
+export * from "./Anchor";

package/dist/types/Items/Arc/Arc.d.ts

@@ -0,0 +1,35 @@
+import { Point, Line, Mbr, Matrix } from "..";
+import { GeometricNormal } from "../GeometricNormal";
+export declare class ArcData {
+}
+export declare class Arc {
+    center: Point;
+    radiusX: number;
+    radiusY: number;
+    startAngle: number;
+    endAngle: number;
+    clockwise: boolean;
+    type: "Arc";
+    rotation: number;
+    constructor(center?: Point, radiusX?: number, radiusY?: number, startAngle?: number, endAngle?: number, clockwise?: boolean);
+    getLength(): number;
+    getNearestPointParameter(point: Point): number;
+    getPoint(parameter: number): Point;
+    getStartPoint(): Point;
+    getPointByTangent(tangent: number): Point;
+    getTangentByPoint(point: Point): number;
+    getCenterPoint(): Point;
+    getNearestPointOnArc(point: Point): Point;
+    getIntersectionPoints(segment: Line): Point[];
+    getDistance(point: Point): number;
+    getNearestEdgePointTo(point: Point): Point;
+    getMbr(): Mbr;
+    isEnclosedOrCrossedBy(rect: Mbr): boolean;
+    isUnderPoint(point: Point): boolean;
+    getNormal(point: Point): GeometricNormal;
+    moveToStart(ctx: Path2D | CanvasRenderingContext2D): void;
+    render(ctx: Path2D | CanvasRenderingContext2D): void;
+    transform(matrix: Matrix): void;
+    getTransformed(matrix: Matrix): Arc;
+    copy(): Arc;
+}

package/dist/types/Items/Arc/index.d.ts

@@ -0,0 +1 @@
+export { Arc } from "./Arc";

package/dist/types/Items/Audio/Audio.d.ts

@@ -0,0 +1,69 @@
+import { Events, Operation } from 'Events';
+import { Subject } from 'Subject';
+import { DrawingContext } from '../DrawingContext';
+import { Mbr } from '../Mbr';
+import { Transformation } from '../Transformation';
+import { TransformationData } from '../Transformation/TransformationData';
+import { Board } from 'Board';
+import { LinkTo } from '../LinkTo/LinkTo';
+import { DocumentFactory } from 'api/DocumentFactory';
+import { Path } from '../Path';
+import { Point } from 'Items/Point/Point';
+export interface AudioItemData {
+    itemType: 'Audio';
+    url: string;
+    transformation: TransformationData;
+    isStorageUrl: boolean;
+    extension?: string;
+}
+export declare class AudioItem extends Mbr {
+    private events?;
+    private id;
+    private extension?;
+    readonly itemType = "Audio";
+    parent: string;
+    readonly transformation: Transformation;
+    readonly linkTo: LinkTo;
+    readonly subject: Subject<AudioItem>;
+    loadCallbacks: ((audio: AudioItem) => void)[];
+    beforeLoadCallbacks: ((audio: AudioItem) => void)[];
+    transformationRenderBlock?: boolean;
+    private url;
+    board: Board;
+    private isPlaying;
+    private currentTime;
+    private isStorageUrl;
+    constructor(board: Board, isStorageUrl: boolean, url?: string, events?: Events | undefined, id?: string, extension?: string | undefined);
+    setCurrentTime(time: number): void;
+    getCurrentTime(): number;
+    getIsStorageUrl(): boolean;
+    onTransform: () => void;
+    doOnceBeforeOnLoad: (callback: (audio: AudioItem) => void) => void;
+    doOnceOnLoad: (callback: (audio: AudioItem) => void) => void;
+    setIsPlaying(isPlaying: boolean): void;
+    getIsPlaying(): boolean;
+    applyUrl(url: string): void;
+    setUrl(url: string): void;
+    getStorageId(): string | undefined;
+    getUrl(): string;
+    onLoad: () => Promise<void>;
+    onError: (_error: any) => void;
+    updateMbr(): void;
+    render(context: DrawingContext): void;
+    renderHTML(documentFactory: DocumentFactory): HTMLElement;
+    serialize(): AudioItemData;
+    deserialize(data: Partial<AudioItemData>): AudioItem;
+    apply(op: Operation): void;
+    emit(operation: Operation): void;
+    setId(id: string): this;
+    getId(): string;
+    private shootLoadCallbacks;
+    private shootBeforeLoadCallbacks;
+    getPath(): Path;
+    getSnapAnchorPoints(): Point[];
+    isClosed(): boolean;
+    getRichText(): null;
+    getLinkTo(): string | undefined;
+    getExtension(): string | undefined;
+    download(): void;
+}

package/dist/types/Items/Audio/AudioCommand.d.ts

@@ -0,0 +1,9 @@
+import { Command, Operation } from 'Events';
+import { AudioItem } from './Audio';
+export declare class AudioCommand implements Command {
+    private audios;
+    private operation;
+    constructor(audios: AudioItem[], operation: Operation);
+    apply(): void;
+    revert(): void;
+}

package/dist/types/Items/Audio/AudioHelpers.d.ts

@@ -0,0 +1,6 @@
+import { Board } from 'Board';
+import { AudioItem } from 'Items/Audio/Audio';
+import { Matrix } from 'Items/Transformation/Matrix';
+export declare const uploadAudioToStorage: (hash: string, audioBlob: Blob, accessToken: string | null, boardId: string) => Promise<string>;
+export declare const prepareAudio: (file: File, accessToken: string | null, boardId: string) => Promise<string>;
+export declare const calculateAudioPosition: (board: Board, audioItem: AudioItem) => Matrix;

package/dist/types/Items/Audio/AudioOperation.d.ts

@@ -0,0 +1,10 @@
+interface AudioBaseOp {
+    class: "Audio";
+    item: string[];
+}
+interface SetUrl extends AudioBaseOp {
+    method: "setUrl";
+    url: string;
+}
+export type AudioOperation = SetUrl;
+export {};

package/dist/types/Items/Audio/index.d.ts

@@ -0,0 +1,2 @@
+export { AudioItem, AudioItemData } from './Audio.js';
+export { uploadAudio } from './uploadAudio.js';

package/dist/types/Items/Audio/uploadAudio.d.ts

@@ -0,0 +1,3 @@
+import { Board } from 'Board';
+import { NotifyFunction } from 'shared/ui-lib/Toast/notify';
+export declare function uploadAudio(file: File, board: Board, notify: NotifyFunction, extension: string, accessToken: string | null): void;

package/dist/types/Items/BaseItem/BaseItem.d.ts

@@ -0,0 +1,24 @@
+import { Matrix } from ".";
+import { Mbr, RichText } from "..";
+import { ResizeOp } from "./BaseItemOperation";
+export declare class BaseItem extends Mbr {
+    private id;
+    matrix: any;
+    previous: any;
+    isLocked: boolean;
+    link: string | null;
+    constructor(id?: string);
+    getId(): string;
+    setId(id: string): this;
+    /** Get RichText handle if exists */
+    getRichText(): RichText | null;
+    /** Get link from this item to another item */
+    getLinkFromItem(): string | null;
+    setLinkFromItem(link: string): void;
+    /** Get link to this */
+    getLinkToItem(): string;
+    isOnlyProportionalScalingAllowed(): boolean;
+    transform(matrix: Matrix): void;
+    resize(data: ResizeOp): void;
+    setLock(isLocked: boolean): void;
+}

package/dist/types/Items/Comment/Comment.d.ts

@@ -0,0 +1,94 @@
+import { Subject } from "Subject";
+import { Events, Operation } from "Events";
+import { Point } from "../Point";
+import { Transformation, TransformationData } from "../Transformation";
+import { Mbr } from "../Mbr";
+import { Geometry } from "../Geometry";
+import { GeometricNormal } from "../GeometricNormal";
+import { RichText } from "../RichText";
+import { DrawingContext } from "../DrawingContext";
+import { Line } from "../Line";
+import { LinkTo } from "../LinkTo/LinkTo";
+import { DocumentFactory } from "api/DocumentFactory";
+export interface Commentator {
+    username: string;
+    id: number;
+    avatar?: string;
+}
+export interface Message {
+    date: Date;
+    text: string;
+    id: string;
+    commentator: Commentator;
+    readers: number[];
+}
+export interface CommentData {
+    readonly itemType: "Comment";
+    anchor: Point;
+    thread: Message[];
+    commentators: Commentator[];
+    transformation: TransformationData;
+    usersUnreadMarks: number[];
+    resolved: boolean;
+    itemToFollow?: string;
+}
+export declare class Comment implements Geometry {
+    private anchor;
+    private events?;
+    private id;
+    readonly itemType = "Comment";
+    parent: string;
+    readonly transformation: Transformation;
+    private commentators;
+    private thread;
+    private usersUnreadMarks;
+    private resolved;
+    private itemToFollow?;
+    readonly subject: Subject<Comment>;
+    readonly linkTo: LinkTo;
+    transformationRenderBlock?: boolean;
+    constructor(anchor?: Point, events?: Events | undefined, id?: string);
+    serialize(): CommentData;
+    deserialize(data: CommentData): this;
+    private emit;
+    getItemToFollow(): string | undefined;
+    setItemToFollow(itemId: string | undefined): void;
+    setId(id: string): this;
+    getId(): string;
+    getCommentators(): Commentator[];
+    apply(op: Operation): void;
+    private applyCommentOperation;
+    saveMessage(text: string, username: string, id: number, avatar?: string): void;
+    editMessage(text: string, id: string): void;
+    removeMessage(messageId: string): void;
+    setResolved(resolved: boolean): void;
+    markThreadAsUnread(userId: number): void;
+    markThreadAsRead(userId: number): void;
+    private transform;
+    getUnreadMessages(userId?: number): Message[] | null;
+    getIsThreadMarkedAsUnread(userId: number): boolean;
+    isClosed(): boolean;
+    markMessagesAsRead(messageIds: string[], userId?: number): void;
+    applyReadMessages(messageIds: string[], userId: number): void;
+    isInView(rect: Mbr): boolean;
+    getThread(): Message[];
+    getResolved(): boolean;
+    getDistanceToPoint(point: Point): number;
+    getIntersectionPoints(segment: Line): Point[];
+    getAnchorPoint(): Point;
+    getAnchorMbr(): Mbr;
+    getMbr(scale?: number): Mbr;
+    getNearestEdgePointTo(point: Point): Point;
+    getNormal(point: Point): GeometricNormal;
+    getRichText(): RichText | null;
+    isEnclosedBy(rect: Mbr): boolean;
+    isEnclosedOrCrossedBy(rect: Mbr): boolean;
+    isNearPoint(point: Point, distance: number): boolean;
+    isUnderPoint(point: Point): boolean;
+    private generateMessageId;
+    getLinkTo(): string | undefined;
+    getPath(): null;
+    getSnapAnchorPoints(): Point[] | null;
+    render(context: DrawingContext): void;
+    renderHTML(documentFactory: DocumentFactory): HTMLElement;
+}

package/dist/types/Items/Comment/CommentCommand.d.ts

@@ -0,0 +1,15 @@
+import { Command } from "../../Events";
+import { Comment } from "./Comment";
+import { CommentOperation } from "./CommentOperation";
+export declare class CommentCommand implements Command {
+    private comment;
+    private operation;
+    private reverse;
+    constructor(comment: Comment[], operation: CommentOperation);
+    apply(): void;
+    revert(): void;
+    getReverse(): {
+        item: Comment;
+        operation: CommentOperation;
+    }[];
+}

package/dist/types/Items/Comment/CommentOperation.d.ts

@@ -0,0 +1,40 @@
+import { Message } from "./Comment";
+interface CommentBase {
+    class: "Comment";
+    item: string[];
+}
+interface CreateMessage extends CommentBase {
+    method: "createMessage";
+    message: Message;
+}
+interface EditMessage extends CommentBase {
+    method: "editMessage";
+    message: Message;
+}
+interface RemoveMessage extends CommentBase {
+    method: "removeMessage";
+    messageId: string;
+}
+interface SetResolved extends CommentBase {
+    method: "setResolved";
+    resolved: boolean;
+}
+interface SetItemToFollow extends CommentBase {
+    method: "setItemToFollow";
+    itemId?: string;
+}
+interface MarkMessagesAsRead extends CommentBase {
+    method: "markMessagesAsRead";
+    messageIds: string[];
+    userId: number;
+}
+interface MarkThreadAsUnread extends CommentBase {
+    method: "markThreadAsUnread";
+    userId: number;
+}
+interface MarkThreadAsRead extends CommentBase {
+    method: "markThreadAsRead";
+    userId: number;
+}
+export type CommentOperation = CreateMessage | EditMessage | RemoveMessage | SetResolved | SetItemToFollow | MarkMessagesAsRead | MarkThreadAsUnread | MarkThreadAsRead;
+export {};

package/dist/types/Items/Comment/index.d.ts

@@ -0,0 +1,4 @@
+export { Comment } from "./Comment";
+export type { CommentData } from "./Comment";
+export { CommentCommand } from "./CommentCommand";
+export type { CommentOperation } from "./CommentOperation";

package/dist/types/Items/Connector/Connector.d.ts

@@ -0,0 +1,141 @@
+import { RichText } from 'Items';
+import { Subject } from 'Subject';
+import { Board } from 'Board';
+import { Operation } from 'Events';
+import { DrawingContext } from '../DrawingContext';
+import { GeometricNormal } from '../GeometricNormal';
+import { Item } from '../Item';
+import { Line } from '../Line';
+import { Mbr } from '../Mbr';
+import { BorderStyle, Path, Paths } from '../Path';
+import { Point } from '../Point';
+import { Transformation } from '../Transformation';
+import { ConnectorData, ConnectorOperation } from './ConnectorOperations';
+import { BoardPoint, ControlPoint, ControlPointData, FindItemFn } from './ControlPoint';
+import { ConnectorPointerStyle, Pointer } from './Pointers/Pointers';
+import { LinkTo } from '../LinkTo/LinkTo';
+import { DocumentFactory } from 'api/DocumentFactory';
+import { ConnectorAnchorColors } from './types';
+export declare const ConnectorLineStyles: readonly ["straight", "curved", "orthogonal"];
+export type ConnectorLineStyle = (typeof ConnectorLineStyles)[number];
+export declare const ConnectionLineWidths: readonly [1, 2, 3, 4, 5, 6, 7, 8, 12];
+export type ConnectionLineWidth = (typeof ConnectionLineWidths)[number];
+export declare const CONNECTOR_COLOR = "rgb(20, 21, 26)";
+export declare const CONNECTOR_LINE_WIDTH = 1;
+export declare const CONNECTOR_BORDER_STYLE: BorderStyle;
+export declare const DEFAULT_END_POINTER = "TriangleFilled";
+export declare const DRAW_TEXT_BORDER = false;
+export declare const TEXT_BORDER_PADDING = 0;
+export declare const CONNECTOR_ANCHOR_COLOR: ConnectorAnchorColors;
+export declare const CONNECTOR_ANCHOR_TYPE = "rect";
+export declare const CONNECTOR_LINE_CAP = "round";
+export declare class Connector {
+    private board;
+    private startPoint;
+    private endPoint;
+    private lineStyle;
+    private startPointerStyle;
+    private endPointerStyle;
+    readonly itemType = "Connector";
+    parent: string;
+    private id;
+    readonly transformation: Transformation;
+    private middlePoint;
+    private lineColor;
+    readonly linkTo: LinkTo;
+    private lineWidth;
+    private borderStyle;
+    readonly subject: Subject<Connector>;
+    lines: Path;
+    startPointer: Pointer;
+    endPointer: Pointer;
+    animationFrameId?: number;
+    readonly text: RichText;
+    transformationRenderBlock?: boolean;
+    private optionalFindItemFn?;
+    constructor(board: Board, startPoint?: ControlPoint, endPoint?: ControlPoint, lineStyle?: ConnectorLineStyle, startPointerStyle?: ConnectorPointerStyle, endPointerStyle?: ConnectorPointerStyle, lineColor?: string, lineWidth?: ConnectionLineWidth, strokeStyle?: BorderStyle);
+    private initText;
+    observerStartPointItem: () => void;
+    observerEndPointItem: () => void;
+    clearObservedItems(): void;
+    private unsubscribeFromItem;
+    private subscribeToItem;
+    emit(operation: ConnectorOperation): void;
+    setId(id: string): this;
+    getId(): string;
+    apply(operation: Operation): void;
+    complete(id: string): void;
+    setStartPoint(point: ControlPoint | ControlPointData, timestamp?: number): void;
+    applyStartPoint(pointData: ControlPointData, updatePath?: boolean): void;
+    setEndPoint(point: ControlPoint | ControlPointData, timestamp?: number): void;
+    applyEndPoint(pointData: ControlPointData, updatePath?: boolean): void;
+    applyMiddlePoint(pointData: ControlPointData, updatePath?: boolean): void;
+    private applySwitchPointers;
+    addMiddlePoint(point: BoardPoint): void;
+    setMiddlePoint(point: ControlPoint | ControlPointData, timestamp?: number): void;
+    setStartPointerStyle(style: ConnectorPointerStyle): void;
+    private applyStartPointerStyle;
+    setEndPointerStyle(style: ConnectorPointerStyle): void;
+    private applyEndPointerStyle;
+    setLineColor(color: string): void;
+    private applyLineColor;
+    setLineStyle(style: ConnectorLineStyle): void;
+    private applyLineStyle;
+    private setBorderStyle;
+    private applyBorderStyle;
+    setLineWidth(width: ConnectionLineWidth): void;
+    private applyLineWidth;
+    getStartPoint(): ControlPoint;
+    getEndPoint(): ControlPoint;
+    getMiddlePoint(): ControlPoint | null;
+    calculateMiddlePoint(): {
+        x: number;
+        y: number;
+    };
+    getStartPointerStyle(): ConnectorPointerStyle;
+    getEndPointerStyle(): ConnectorPointerStyle;
+    getLineColor(): string;
+    getLineStyle(): ConnectorLineStyle;
+    getBorderStyle(): BorderStyle;
+    getLineWidth(): ConnectionLineWidth;
+    getIntersectionPoints(segment: Line): Point[];
+    getMbr(): Mbr;
+    getNearestEdgePointTo(point: Point): Point;
+    isEnclosedOrCrossedBy(bounds: Mbr): boolean;
+    isUnderPoint(point: Point): boolean;
+    isNearPoint(point: Point, distance: number): boolean;
+    isEnclosedBy(bounds: Mbr): boolean;
+    isInView(view: Mbr): boolean;
+    getNormal(point: Point): GeometricNormal;
+    isConnected(): boolean;
+    getConnectedItems(): {
+        startItem?: Item;
+        endItem?: Item;
+    };
+    isConnectedOnePoint(): boolean;
+    render(context: DrawingContext): void;
+    clipText(context: DrawingContext): void;
+    renderHTML(documentFactory: DocumentFactory): HTMLElement;
+    private renderPathHTML;
+    getPaths(): Path;
+    copyPaths(): Path;
+    isClosed(): boolean;
+    serialize(): ConnectorData;
+    deserialize(data: Partial<ConnectorData>): this;
+    getConnectorById(items: Item[], connectorId: string): Connector | undefined;
+    updateTitle(): void;
+    private scalePoints;
+    private scalePoint;
+    private translatePoints;
+    private translatePoint;
+    private updatePaths;
+    private offsetLines;
+    getPath(): Path | Paths;
+    getSnapAnchorPoints(): Point[];
+    getOptionalFindFn(): FindItemFn | undefined;
+    setOptionalFindFn(value: FindItemFn | undefined): void;
+    hasText(): boolean;
+    getRichText(): RichText;
+    getLinkTo(): string | undefined;
+}
+export declare const CONNECTOR_POINTER_TYPES: readonly ["None", "ArrowBroad", "ArrowThin", "TriangleFilled", "CircleFilled", "Angle", "TriangleEmpty", "DiamondFilled", "DiamondEmpty", "Zero", "One", "Many", "ManyMandatory", "OneMandatory", "ManyOptional", "OneOptional"];

package/dist/types/Items/Connector/ConnectorCommand.d.ts

@@ -0,0 +1,18 @@
+import { Connector } from ".";
+import { Command } from "../../Events";
+import { ConnectorOperation } from "./ConnectorOperations";
+type ReverseOperation = {
+    item: Connector;
+    operation: ConnectorOperation;
+}[];
+export declare class ConnectorCommand implements Command {
+    private connector;
+    private operation;
+    reverse: ReverseOperation;
+    constructor(connector: Connector[], operation: ConnectorOperation);
+    merge(op: ConnectorOperation): this;
+    apply(): void;
+    revert(): void;
+    getReverse(): ReverseOperation;
+}
+export {};

package/dist/types/Items/Connector/ConnectorOperations.d.ts

@@ -0,0 +1,87 @@
+import { ControlPointData, FindItemFn } from "./ControlPoint";
+import { ConnectionLineWidth, ConnectorLineStyle } from "./Connector";
+import { ConnectorPointerStyle } from "./Pointers/Pointers";
+import { DefaultRichTextData } from "../RichText/RichTextData";
+import { DefaultTransformationData } from "../Transformation/TransformationData";
+import { LinkTo } from "../LinkTo/LinkTo";
+import { BorderStyle } from "../Path";
+export declare class ConnectorData {
+    readonly itemType = "Connector";
+    startPoint: ControlPointData;
+    endPoint: ControlPointData;
+    middlePoint: ControlPointData | null;
+    startPointerStyle: ConnectorPointerStyle;
+    endPointerStyle: ConnectorPointerStyle;
+    lineStyle: ConnectorLineStyle;
+    lineColor: string;
+    linkTo?: string | LinkTo;
+    lineWidth: ConnectionLineWidth;
+    borderStyle: BorderStyle;
+    transformation: DefaultTransformationData;
+    text: DefaultRichTextData;
+    optionalFindItemFn?: FindItemFn;
+}
+interface SetStartPoint {
+    class: "Connector";
+    method: "setStartPoint";
+    item: string[];
+    startPointData: ControlPointData;
+    timestamp?: number;
+}
+interface SetEndPoint {
+    class: "Connector";
+    method: "setEndPoint";
+    item: string[];
+    endPointData: ControlPointData;
+    timestamp?: number;
+}
+interface SetMiddlePoint {
+    class: "Connector";
+    method: "setMiddlePoint";
+    item: string[];
+    middlePointData: ControlPointData;
+    timestamp?: number;
+}
+interface SetStartPointerStyle {
+    class: "Connector";
+    method: "setStartPointerStyle";
+    item: string[];
+    startPointerStyle: ConnectorPointerStyle;
+}
+interface SetEndPointerStyle {
+    class: "Connector";
+    method: "setEndPointerStyle";
+    item: string[];
+    endPointerStyle: ConnectorPointerStyle;
+}
+interface SetLineStyle {
+    class: "Connector";
+    method: "setLineStyle";
+    item: string[];
+    lineStyle: ConnectorLineStyle;
+}
+interface SetBorderStyle {
+    class: "Connector";
+    method: "setBorderStyle";
+    item: string[];
+    borderStyle: BorderStyle;
+}
+interface SetLineColor {
+    class: "Connector";
+    method: "setLineColor";
+    item: string[];
+    lineColor: string;
+}
+interface SetLineWidth {
+    class: "Connector";
+    method: "setLineWidth";
+    item: string[];
+    lineWidth: ConnectionLineWidth;
+}
+interface SwitchPointers {
+    class: "Connector";
+    method: "switchPointers";
+    item: string[];
+}
+export type ConnectorOperation = SetStartPoint | SetEndPoint | SetMiddlePoint | SetStartPointerStyle | SetEndPointerStyle | SetLineStyle | SetLineColor | SetLineWidth | SwitchPointers | SetBorderStyle;
+export {};

package/dist/types/Items/Connector/ConnectorSnap.d.ts

@@ -0,0 +1,50 @@
+import { Board } from "../../Board";
+import { ControlPoint } from "./ControlPoint";
+import { Point } from "../Point";
+import { Item } from "../Item";
+import { DrawingContext } from "../DrawingContext";
+import { Anchor } from "../Anchor";
+import { Path, Paths } from "../Path";
+import { Connector } from "./Connector";
+export declare class ConnectorSnap {
+    private board;
+    distance: {
+        neighbor: number;
+        border: number;
+        anchor: number;
+    };
+    maxNeighbors: number;
+    timeout: number;
+    connectorAttachLimit: {
+        start: number;
+        end: number;
+    };
+    color: import("./types").ConnectorAnchorColors;
+    snap: {
+        item: Item | null;
+        path: Path | Paths | null;
+        anchors: Anchor[];
+        anchor: Anchor | null;
+        point: Anchor | null;
+    };
+    hover: {
+        item: Item | null;
+        timeout: NodeJS.Timeout | null;
+        isTimeoutElapsed: boolean;
+    };
+    controlPoint: ControlPoint | null;
+    connector: Connector | null;
+    constructor(board: Board);
+    getControlPoint(): ControlPoint;
+    pointerMove(): void;
+    setHover(): void;
+    getNearest(): Item | null;
+    getClosestPointOnItem(item: Item, position: Point): ControlPoint;
+    isNearBorder(item: Item | null): boolean;
+    setSnap(): void;
+    setAnchors(item: Item): void;
+    setNearestAnchor(): void;
+    setPoint(): void;
+    clear(): void;
+    render(context: DrawingContext): void;
+}