microboard-temp 0.1.0 → 0.1.2

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

@@ -0,0 +1,124 @@
+import { Mbr, Line, Point, Transformation, Path, Paths, Item, RichText, Matrix } from "..";
+import { Geometry } from "../Geometry";
+import { Subject } from "Subject";
+import { DrawingContext } from "../DrawingContext";
+import { Operation } from "Events";
+import { FrameOperation } from "./FrameOperation";
+import { FrameType } from "./Basic";
+import { GeometricNormal } from "../GeometricNormal";
+import { Board } from "Board";
+import { SnapshotInfo } from "Tools/ExportSnapshot/exportBoardSnapshot";
+import { LinkTo } from "../LinkTo/LinkTo";
+import { FrameData } from "./FrameData";
+import { DocumentFactory } from "api/DocumentFactory";
+import { ResizeType } from "Selection/Transformer/TransformerHelpers/getResizeType";
+export declare class Frame implements Geometry {
+    private board;
+    private getItemById;
+    private id;
+    private name;
+    private shapeType;
+    private backgroundColor;
+    private backgroundOpacity;
+    private borderColor;
+    private borderOpacity;
+    private borderStyle;
+    private borderWidth;
+    readonly itemType = "Frame";
+    parent: string;
+    readonly transformation: Transformation;
+    readonly subject: Subject<Frame>;
+    private textContainer;
+    private path;
+    private children;
+    private mbr;
+    readonly linkTo: LinkTo;
+    readonly text: RichText;
+    private canChangeRatio;
+    newShape: FrameType | null;
+    transformationRenderBlock?: boolean;
+    constructor(board: Board, getItemById: (id: string) => Item | undefined, id?: string, name?: string, shapeType?: "Custom" | "A4" | "Letter" | "Frame16x9" | "Frame4x3" | "Frame1x1" | "Frame3x2" | "Frame9x18", backgroundColor?: string, backgroundOpacity?: number, borderColor?: string, borderOpacity?: number, borderStyle?: "solid" | "dot" | "dash" | "longDash" | "dotDash" | "tripleDotDash" | "looseDoubleDotDash", borderWidth?: number);
+    setBoard(board: Board): this;
+    /** Sets parent of child and emits add child message */
+    emitAddChild(children: Item[]): void;
+    emitRemoveChild(children: Item[] | Item): void;
+    emitNesting(children: Item[]): void;
+    /**
+     * Parent cant be child,
+     * Child cant be itself,
+     * frame cant be child
+     */
+    private addChild;
+    applyAddChild(childId: string[] | string, noWarn?: boolean): void;
+    private applyRemoveChild;
+    private removeChild;
+    getLinkTo(): string | undefined;
+    /**
+     * Returns:
+     * true - if can be child of the frame
+     * false - if outside of the frame
+     */
+    handleNesting(item: Item | Mbr, options?: {
+        onlyForOut?: boolean;
+        cancelIfChild?: boolean;
+    }): boolean;
+    private initPath;
+    getPaths(): Path | Paths;
+    getPath(): Path | Paths;
+    copyPaths(): Path | Paths;
+    isTextUnderPoint(point: Point): boolean;
+    getUnderPoint(point: Point): boolean;
+    isClosed(): boolean;
+    setId(id: string): this;
+    getId(): string;
+    getChildrenIds(): string[];
+    updateMbr(): void;
+    getMbr(): Mbr;
+    doResize(resizeType: ResizeType, pointer: Point, mbr: Mbr, opposite: Point, startMbr: Mbr, timeStamp: number): {
+        matrix: Matrix;
+        mbr: Mbr;
+    } | boolean;
+    getLastFrameScale(): {
+        x: number;
+        y: number;
+    };
+    scaleLikeLastFrame(): void;
+    setLastFrameScale(): void;
+    serialize(): FrameData;
+    deserialize(data: Partial<FrameData>): this;
+    getSavedProportionsMatrix(): Matrix;
+    private transformPath;
+    apply(op: Operation): void;
+    emit(operation: FrameOperation): void;
+    getNearestEdgePointTo(point: Point): Point;
+    getDistanceToPoint(point: Point): number;
+    isUnderPoint(point: Point): boolean;
+    isNearPoint(point: Point, distance: number): boolean;
+    isEnclosedOrCrossedBy(rect: Mbr): boolean;
+    isEnclosedBy(rect: Mbr): boolean;
+    isInView(rect: Mbr): boolean;
+    getSnapAnchorPoints(): Point[];
+    getNormal(point: Point): GeometricNormal;
+    getIntersectionPoints(segment: Line): Point[];
+    getFrameType(): FrameType;
+    private applyFrameType;
+    setFrameType(shapeType: FrameType): void;
+    getCanChangeRatio(): boolean;
+    private applyCanChangeRatio;
+    setCanChangeRatio(canChangeRatio: boolean): void;
+    getBorderColor(): string;
+    getBorderWidth(): number;
+    getBackgroundColor(): string;
+    setNewShape(type: FrameType | null): void;
+    private applyBackgroundColor;
+    setBackgroundColor(backgroundColor: string): void;
+    getExportName(): string;
+    export(board: Board, name?: string): Promise<SnapshotInfo>;
+    render(context: DrawingContext): void;
+    renderName(context: DrawingContext): void;
+    renderBorders(context: DrawingContext): void;
+    renderPath(context: DrawingContext): void;
+    renderNewShape(context: DrawingContext): void;
+    renderHTML(documentFactory: DocumentFactory): HTMLElement;
+    getRichText(): RichText;
+}

package/dist/types/Items/Frame/FrameCommand.d.ts

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

package/dist/types/Items/Frame/FrameData.d.ts

@@ -0,0 +1,67 @@
+import { DefaultTransformationData, TransformationData } from '../Transformation/TransformationData';
+import { RichTextData } from '../RichText';
+import { BorderStyle, BorderWidth } from '../Path';
+import { FrameType } from './Basic';
+export declare const FRAME_BORDER_COLOR = "rgba(10, 15, 41, 0.08)";
+export declare const FRAME_HIGHLIGHTER_BORDER_COLOR = "#93AFF6";
+export declare const FRAME_CHILDREN_HIGHLIGHTER_COLOR = "rgb(10, 15, 41, .08)";
+export declare const FRAME_CHILDREN_HIGHLIGHTER_BORDER_COLOR = "#4778F5";
+export declare const FRAME_TITLE_COLOR = "rgb(107, 110, 120)";
+export declare const FRAME_TYPES: readonly [{
+    readonly id: "Custom";
+    readonly label: "Custom";
+}, {
+    readonly id: "Frame16x9";
+    readonly label: "16:9";
+}, {
+    readonly id: "Frame3x2";
+    readonly label: "3:2";
+}, {
+    readonly id: "Frame4x3";
+    readonly label: "4:3";
+}, {
+    readonly id: "A4";
+    readonly label: "A4";
+}, {
+    readonly id: "Letter";
+    readonly label: "Letter";
+}, {
+    readonly id: "Frame9x18";
+    readonly label: "9:18";
+}, {
+    readonly id: "Frame1x1";
+    readonly label: "1:1";
+}];
+export declare const FRAME_FILL_COLORS: string[];
+export declare const FRAME_FILL_COLOR: string;
+export interface FrameData {
+    readonly itemType: 'Frame';
+    shapeType: FrameType;
+    backgroundColor: string;
+    backgroundOpacity: number;
+    borderColor: string;
+    borderOpacity: number;
+    borderStyle: BorderStyle;
+    borderWidth: BorderWidth;
+    children: string[];
+    transformation?: TransformationData;
+    text?: RichTextData;
+    canChangeRatio?: boolean;
+    linkTo?: string;
+}
+export declare class DefaultFrameData implements FrameData {
+    shapeType: FrameType;
+    backgroundColor: string;
+    backgroundOpacity: number;
+    borderColor: string;
+    borderOpacity: number;
+    borderStyle: BorderStyle;
+    borderWidth: BorderWidth;
+    transformation: DefaultTransformationData;
+    children: string[];
+    text: RichTextData;
+    canChangeRatio: boolean;
+    linkTo?: string | undefined;
+    readonly itemType = "Frame";
+    constructor(shapeType?: FrameType, backgroundColor?: string, backgroundOpacity?: number, borderColor?: string, borderOpacity?: number, borderStyle?: BorderStyle, borderWidth?: BorderWidth, transformation?: DefaultTransformationData, children?: string[], text?: RichTextData, canChangeRatio?: boolean, linkTo?: string | undefined);
+}

package/dist/types/Items/Frame/FrameOperation.d.ts

@@ -0,0 +1,34 @@
+import { FrameType } from "./Basic";
+interface SetBackgroundColor {
+    class: "Frame";
+    method: "setBackgroundColor";
+    item: string[];
+    backgroundColor: string;
+}
+interface SetCanChangeRatio {
+    class: "Frame";
+    method: "setCanChangeRatio";
+    item: string[];
+    canChangeRatio: boolean;
+}
+interface SetFrameType {
+    class: "Frame";
+    method: "setFrameType";
+    item: string[];
+    shapeType: FrameType;
+    prevShapeType: FrameType;
+}
+interface AddChild {
+    class: "Frame";
+    method: "addChild";
+    item: string[];
+    childId: string[];
+}
+interface RemoveChild {
+    class: "Frame";
+    method: "removeChild";
+    item: string[];
+    childId: string[];
+}
+export type FrameOperation = SetBackgroundColor | SetCanChangeRatio | SetFrameType | AddChild | RemoveChild;
+export {};

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

@@ -0,0 +1,4 @@
+export { Frame } from "./Frame";
+export type { FrameOperation } from "./FrameOperation";
+export { FrameCommand } from "./FrameCommand";
+export type { FrameData } from "./FrameData";

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

@@ -0,0 +1,13 @@
+import { Point } from "./Point";
+export declare class GeometricNormal {
+    readonly point: Point;
+    readonly projectionPoint: Point;
+    readonly normalPoint: Point;
+    private distanceValue;
+    private angleRadiansValue;
+    private angelRadiansNormalValue;
+    constructor(point: Point, projectionPoint: Point, normalPoint: Point);
+    getDistance(): number;
+    getAngleRadians(): number;
+    getAngleRadiansNormal(): number;
+}

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

@@ -0,0 +1,35 @@
+import { Mbr } from "./Mbr";
+import { Point } from "./Point";
+import { Line } from "./Line";
+import { DrawingContext } from "./DrawingContext";
+import { GeometricNormal } from "./GeometricNormal";
+import { RichText } from "./RichText";
+/**
+ * Methods that define the geometry of an item.
+ */
+export interface Geometry {
+    /** Compute all points on the borders of the item that a segment of a line intersects. */
+    getIntersectionPoints(segment: Line): Point[];
+    /** Compute a bounding rectangle of the item.  */
+    getMbr(): Mbr;
+    /** Compute the nearest point on the edge of the item to a point. */
+    getNearestEdgePointTo(point: Point): Point;
+    /** Compute the distance from the item to a point. */
+    getDistanceToPoint(point: Point): number;
+    /** Find if item is under a point. */
+    isUnderPoint(point: Point): boolean;
+    /** Find if item is not futher away from a point that a distance. */
+    isNearPoint(point: Point, distance: number): boolean;
+    /** Find if item is enclosed or crossed by a bounding rectangle. */
+    isEnclosedOrCrossedBy(rect: Mbr): boolean;
+    /** Find if item is enclosed by a bounding rectangle. */
+    isEnclosedBy(rect: Mbr): boolean;
+    /** Find if item can possibly be seen inside of a bounding rectangle. */
+    isInView(rect: Mbr): boolean;
+    /** Find normal vector that point outside of the item from a point on the edge of the item nearest to a point. */
+    getNormal(point: Point): GeometricNormal;
+    /** Render the item on a Drawing Context */
+    render(context: DrawingContext): void;
+    /** Get RichText handle if exists */
+    getRichText(): RichText | null;
+}

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

@@ -0,0 +1,49 @@
+import { Subject } from 'Subject';
+import { DrawingContext } from '../DrawingContext';
+import { TransformationData } from '../Transformation/TransformationData';
+import { GroupOperation } from './GroupOperation';
+import { Events, Operation } from 'Events';
+import { Mbr, Line, Point, Transformation, Item } from '..';
+import { Board } from 'Board';
+import { LinkTo } from '../LinkTo/LinkTo';
+export interface GroupData {
+    readonly itemType: 'Group';
+    children: string[];
+    transformation: TransformationData;
+}
+export declare class Group extends Mbr {
+    private board;
+    private events?;
+    private children;
+    private id;
+    readonly linkTo: LinkTo;
+    readonly itemType = "Group";
+    parent: string;
+    readonly transformation: Transformation;
+    readonly subject: Subject<Group>;
+    private mbr;
+    transformationRenderBlock?: boolean;
+    constructor(board: Board, events?: Events | undefined, children?: string[], id?: string);
+    getRichText(): null;
+    addChild(childId: string): void;
+    private applyAddChild;
+    private applyRemoveChild;
+    removeChild(childId: string): void;
+    emitRemoveChild(child: Item): void;
+    apply(op: Operation): void;
+    emit(operation: GroupOperation): void;
+    setId(id: string): this;
+    serialize(): GroupData;
+    deserialize(data: GroupData): this;
+    getId(): string;
+    getIntersectionPoints(segment: Line): Point[];
+    getMbr(): Mbr;
+    getChildrenIds(): string[];
+    getChildren(): Item[];
+    updateMbr(): void;
+    setBoard(board: Board): void;
+    setChildren(items: string[]): void;
+    removeChildren(): void;
+    getLinkTo(): string | undefined;
+    render(context: DrawingContext): void;
+}

package/dist/types/Items/Group/GroupCommand.d.ts

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

package/dist/types/Items/Group/GroupOperation.d.ts

@@ -0,0 +1,14 @@
+interface AddChild {
+    class: "Group";
+    method: "addChild";
+    item: string[];
+    childId: string;
+}
+interface RemoveChild {
+    class: "Group";
+    method: "removeChild";
+    item: string[];
+    childId: string;
+}
+export type GroupOperation = AddChild | RemoveChild;
+export {};

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

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

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

@@ -0,0 +1,73 @@
+import { Events, Operation } from 'Events';
+import { Subject } from 'Subject';
+import { DrawingContext } from '../DrawingContext';
+import { Mbr } from '../Mbr';
+import { Path, Paths } from '../Path';
+import { Point } from '../Point';
+import { Transformation } from '../Transformation';
+import { TransformationData } from '../Transformation/TransformationData';
+import { Board } from 'Board';
+import { LinkTo } from '../LinkTo/LinkTo';
+import { ImageOperation } from './ImageOperation';
+import { DocumentFactory } from 'api/DocumentFactory';
+export interface ImageItemData {
+    itemType: 'Image';
+    storageLink: string;
+    imageDimension: Dimension;
+    transformation: TransformationData;
+    linkTo?: string;
+}
+export interface Dimension {
+    height: number;
+    width: number;
+}
+export declare function getPlaceholderImage(board: Board, imageDimension?: Dimension): HTMLImageElement;
+export interface ImageConstructorData {
+    base64?: string;
+    storageLink: string;
+    imageDimension: Dimension;
+}
+export declare class ImageItem extends Mbr {
+    private events?;
+    private id;
+    readonly itemType = "Image";
+    parent: string;
+    image: HTMLImageElement;
+    readonly transformation: Transformation;
+    readonly linkTo: LinkTo;
+    readonly subject: Subject<ImageItem>;
+    loadCallbacks: ((image: ImageItem) => void)[];
+    beforeLoadCallbacks: ((image: ImageItem) => void)[];
+    transformationRenderBlock?: boolean;
+    private storageLink;
+    imageDimension: Dimension;
+    board: Board;
+    constructor({ base64, storageLink, imageDimension }: ImageConstructorData, board: Board, events?: Events | undefined, id?: string);
+    setStorageLink(link: string): void;
+    getStorageId(): string | undefined;
+    handleError: () => void;
+    onLoad: () => Promise<void>;
+    onError: (_error: any) => void;
+    onTransform: () => void;
+    updateMbr(): void;
+    doOnceBeforeOnLoad: (callback: (image: ImageItem) => void) => void;
+    doOnceOnLoad: (callback: (image: ImageItem) => void) => void;
+    setId(id: string): this;
+    getId(): string;
+    serialize(): ImageItemData;
+    private setCoordinates;
+    private shootBeforeLoadCallbacks;
+    private shootLoadCallbacks;
+    deserialize(data: Partial<ImageItemData>): ImageItem;
+    emit(operation: ImageOperation): void;
+    setDimensions(dim: Dimension): void;
+    apply(op: Operation): void;
+    render(context: DrawingContext): void;
+    renderHTML(documentFactory: DocumentFactory): HTMLElement;
+    getPath(): Path | Paths;
+    getSnapAnchorPoints(): Point[];
+    isClosed(): boolean;
+    getRichText(): null;
+    getLinkTo(): string | undefined;
+    download(): void;
+}

package/dist/types/Items/Image/ImageCommand.d.ts

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

package/dist/types/Items/Image/ImageHelpers.d.ts

@@ -0,0 +1,21 @@
+import { ImageConstructorData } from './Image';
+import { Account } from 'entities/account/Account';
+export declare const catchErrorResponse: (response: Response, mediaType: "image" | "video" | "audio") => Promise<never>;
+export declare const catchDuplicateErrorResponse: (response: Response) => Promise<never>;
+export declare const validateMediaFile: (file: File, account: Account) => boolean;
+export declare const deleteMedia: (mediaIds: string[], boardId: string) => Promise<void>;
+export declare const updateMediaUsage: (mediaIds: string[], boardId: string) => Promise<boolean>;
+export declare const uploadToTheStorage: (hash: string, dataURL: string, accessToken: string | null, boardId: string) => Promise<string>;
+export declare const resizeAndConvertToPng: (inp: string | ArrayBuffer | null | undefined) => Promise<{
+    dataURL: string;
+    width: number;
+    height: number;
+    hash: string;
+}>;
+/** Resizes if needed and converts image to png and uploads the image to the storage, doesnt throw on unsuccess
+ * @param inp - The input image data
+ * @param accessToken
+ * @param boardId
+ * @returns An object containing prepared image information on success, err otherwise
+ */
+export declare const prepareImage: (inp: string | ArrayBuffer | null | undefined, accessToken: string | null, boardId: string) => Promise<ImageConstructorData>;

package/dist/types/Items/Image/ImageOperation.d.ts

@@ -0,0 +1,11 @@
+import { ImageConstructorData } from "./Image";
+interface ImageBaseOp {
+    class: "Image";
+    item: string[];
+}
+interface UpdateImageData extends ImageBaseOp {
+    method: "updateImageData";
+    data: ImageConstructorData;
+}
+export type ImageOperation = UpdateImageData;
+export {};

package/dist/types/Items/Image/calculatePosition.d.ts

@@ -0,0 +1,9 @@
+import type { Board } from 'Board';
+import type { ImageItem } from './Image';
+import { VideoItem } from 'Items/Video/Video';
+export declare function calculatePosition(boardImage: ImageItem | VideoItem, board: Board): {
+    scaleX: number;
+    scaleY: number;
+    translateX: number;
+    translateY: number;
+};

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

@@ -0,0 +1,2 @@
+export * from "./Image";
+export * from "./ImageOperation";

package/dist/types/Items/Image/uploadImage.d.ts

@@ -0,0 +1,2 @@
+import { Board } from 'Board';
+export declare function uploadImage(file: File, board: Board, accessToken: string | null): void;

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

@@ -0,0 +1,17 @@
+import { AINode, AINodeData } from "./AINode";
+import { AudioItem, AudioItemData } from "./Audio";
+import { Comment, CommentData } from "./Comment";
+import { Connector, ConnectorData } from "./Connector";
+import { Drawing, DrawingData } from "./Drawing";
+import { Frame, FrameData } from "./Frame";
+import { Group, GroupData } from "./Group";
+import { ImageItem, ImageItemData } from "./Image";
+import { Placeholder, PlaceholderData } from "./Placeholder";
+import { RichText, RichTextData } from "./RichText";
+import { Shape, ShapeData } from "./Shape";
+import { Sticker } from "./Sticker";
+import { StickerData } from "./Sticker/StickerOperation";
+import { VideoItem, VideoItemData } from "./Video";
+export type Item = RichText | Shape | Connector | ImageItem | Drawing | Sticker | Frame | Placeholder | Comment | Group | AINode | VideoItem | AudioItem | Comment;
+export type ItemType = Item["itemType"];
+export type ItemData = ShapeData | RichTextData | ConnectorData | ImageItemData | DrawingData | StickerData | FrameData | PlaceholderData | CommentData | GroupData | AINodeData | VideoItemData | AudioItemData;

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

@@ -0,0 +1,8 @@
+import { Item } from "./Item";
+export declare function reverMapOf<Itm extends Item, T>(item: Itm | Itm[], getCallback: (item: Itm) => T | null | false | undefined): {
+    [key: string]: T;
+};
+export declare function mapItemsByOperation<Item, O>(item: Item | Item[], getCallback: (item: Item) => O): {
+    item: Item;
+    operation: O;
+}[];

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

@@ -0,0 +1,56 @@
+import { Point } from '../Point';
+import { Mbr } from '../Mbr';
+import { Matrix } from '../Transformation';
+import { GeometricNormal } from '../GeometricNormal';
+interface RelationBase {
+    lineA: Line;
+    lineB: Line;
+    denominator: number;
+    parameterA: number;
+    parameterB: number;
+}
+interface NonIntersectingLines extends RelationBase {
+    type: 'NonIntersecting';
+}
+interface IntersectingLines extends RelationBase {
+    type: 'Intersecting';
+}
+interface ParallelLines extends RelationBase {
+    type: 'Parallel';
+}
+interface ColenearLines extends RelationBase {
+    type: 'Colenear';
+}
+export type LinesRelation = NonIntersectingLines | IntersectingLines | ParallelLines | ColenearLines;
+export declare function getLinesRelationType(lineA: Line, lineB: Line): LinesRelation;
+export declare function getIntersectionPointFromIntersectingLines(relation: IntersectingLines): Point;
+export declare class Line {
+    start: Point;
+    end: Point;
+    type: "Line";
+    isCenter: boolean;
+    constructor(start?: Point, end?: Point, isCenter?: boolean);
+    getStartPoint(): Point;
+    getLength(): number;
+    getNearestPointParameter(point: Point): number;
+    getPoint(parameter: number): Point;
+    getPointByTangent(tangent: number): Point;
+    getTangentByPoint(point: Point): number;
+    getCenterPoint(): Point;
+    getNearestPointOnLineSegment(point: Point): Point;
+    getDistance(point: Point): number;
+    getIntersectionPoints(segment: Line): Point[];
+    hasIntersectionPoint(segment: Line): boolean;
+    getNearestEdgePointTo(point: Point): Point;
+    getAngle(line: Line): number;
+    getMbr(): Mbr;
+    isEnclosedOrCrossedBy(rect: Mbr): boolean;
+    getNormal(point: Point): GeometricNormal;
+    moveToStart(ctx: Path2D | CanvasRenderingContext2D): void;
+    render(ctx: Path2D | CanvasRenderingContext2D): void;
+    transform(matrix: Matrix): void;
+    getTransformed(matrix: Matrix): Line;
+    copy(): Line;
+    getParameter(point: Point): number;
+}
+export {};

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

@@ -0,0 +1 @@
+export { Line, getIntersectionPointFromIntersectingLines, getLinesRelationType, } from "./Line";

package/dist/types/Items/LinkTo/LinkToCommand.d.ts

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

package/dist/types/Items/LinkTo/LinkToOperation.d.ts

@@ -0,0 +1,10 @@
+interface LinkToBase {
+    class: "LinkTo";
+    item: string[];
+}
+interface SetLinkTo extends LinkToBase {
+    method: "setLinkTo";
+    link: string | undefined;
+}
+export type LinkToOperation = SetLinkTo;
+export {};