microboard-temp 0.1.1 → 0.1.3

package/dist/types/SpatialIndex/SpacialIndex.d.ts

@@ -0,0 +1,81 @@
+import { DocumentFactory } from 'api/DocumentFactory';
+import { ItemsIndexRecord } from 'BoardOperations';
+import { Camera } from 'Camera';
+import { Item, Frame, Mbr, ItemData, Point, Connector } from 'Items';
+import { DrawingContext } from 'Items/DrawingContext';
+import { Pointer } from 'Pointer';
+import { Subject } from 'Subject';
+export type ItemWoFrames = Exclude<Item, Frame>;
+export declare class SpatialIndex {
+    subject: Subject<Items>;
+    private itemsArray;
+    private framesArray;
+    private itemsIndex;
+    private framesIndex;
+    private Mbr;
+    readonly items: Items;
+    constructor(view: Camera, pointer: Pointer);
+    clear(): void;
+    insert(item: Item): void;
+    change: (item: Item) => void;
+    remove(item: Item): void;
+    copy(): (ItemData & {
+        id: string;
+    })[];
+    moveToZIndex(item: Item, zIndex: number): void;
+    moveManyToZIndex(itemsRecord: ItemsIndexRecord): void;
+    sendToBack(item: Item, shouldPublish?: boolean): void;
+    sendManyToBack(items: ItemWoFrames[]): void;
+    bringToFront(item: Item, shouldPublish?: boolean): void;
+    bringManyToFront(items: ItemWoFrames[]): void;
+    moveSecondAfterFirst(first: ItemWoFrames, second: ItemWoFrames): void;
+    moveSecondBeforeFirst(first: ItemWoFrames, second: ItemWoFrames): void;
+    getById(id: string): Item | undefined;
+    findById(id: string): Item | undefined;
+    getEnclosed(left: number, top: number, right: number, bottom: number): Item[];
+    getEnclosedOrCrossed(left: number, top: number, right: number, bottom: number): Item[];
+    getUnderPoint(point: Point, tolerace?: number): Item[];
+    getRectsEnclosedOrCrossed(left: number, top: number, right: number, bottom: number): Item[];
+    getFramesEnclosedOrCrossed(left: number, top: number, right: number, bottom: number): Frame[];
+    getItemsEnclosedOrCrossed(left: number, top: number, right: number, bottom: number): ItemWoFrames[];
+    getComments(): Comment[];
+    getMbr(): Mbr;
+    getNearestTo(point: Point, maxItems: number, filter: (item: Item) => boolean, maxDistance: number): Item[];
+    list(): ItemWoFrames[];
+    listFrames(): Frame[];
+    getZIndex(item: Item): number;
+    getLastZIndex(): number;
+    getByZIndex(index: number): Item;
+}
+export declare class Items {
+    index: SpatialIndex;
+    private view;
+    private pointer;
+    readonly subject: Subject<Items>;
+    constructor(index: SpatialIndex, view: Camera, pointer: Pointer, subject: Subject<Items>);
+    update(item: Item): void;
+    listAll(): ItemWoFrames[];
+    listFrames(): Frame[];
+    getById(id: string): Item | undefined;
+    findById(id: string): Item | undefined;
+    getEnclosed(left: number, top: number, right: number, bottom: number): Item[];
+    getEnclosedOrCrossed(left: number, top: number, right: number, bottom: number): Item[];
+    getFramesEnclosedOrCrossed(left: number, top: number, right: number, bottom: number): Frame[];
+    getUnderPoint(point: Point, tolerance?: number): Item[];
+    getMbr(): Mbr;
+    getInView(): Item[];
+    getItemsInView(): ItemWoFrames[];
+    getFramesInView(): Frame[];
+    getComments(): Comment[];
+    getUnderPointer(size?: number): Item[];
+    getNearPointer(maxDistance?: number, maxItems?: number, filter?: (item: Item) => boolean): Item[];
+    getZIndex(item: Item): number;
+    getByZIndex(index: number): Item;
+    getLastZIndex(): number;
+    getLinkedConnectorsById(id: string): Connector[];
+    getConnectorsByItemIds(startPointerItemId?: string, endPointerItemId?: string): Connector[];
+    render(context: DrawingContext): void;
+    renderHTML(documentFactory: DocumentFactory): HTMLElement;
+    getWholeHTML(documentFactory: DocumentFactory): string;
+    getHTML(documentFactory: DocumentFactory, frames: Frame[], rest: ItemWoFrames[]): string;
+}

package/dist/types/SpatialIndex/index.d.ts

@@ -0,0 +1 @@
+export { SpatialIndex, Items } from "./SpacialIndex";

package/dist/types/Subject.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Subject class to implement the observer pattern.
+ * Observer is passed as a callback function.
+ * Observers recive published object to read its properties
+ * and call its methods to get its current state.
+ * */
+export declare class Subject<Type> {
+    observers: ((object: Type) => void)[];
+    subscribe(observer: (object: Type) => void): void;
+    unsubscribe(observer: (object: Type) => void): void;
+    publish(object: Type): void;
+}

package/dist/types/SubjectOperation.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Subject class to implement the observer pattern.
+ * Observer is passed as a callback function.
+ * Observers recive published object to read its properties
+ * and call its methods to get its current state.
+ * Observers also recive operation that was performed on the subject.
+ * */
+export declare class SubjectOperation<Subject, Operation> {
+    observers: ((subject: Subject, op: Operation) => void)[];
+    subscribe(observer: (subject: Subject, op: Operation) => void): void;
+    unsubscribe(observer: (subject: Subject, op: Operation) => void): void;
+    publish(subject: Subject, op: Operation): void;
+}

package/dist/types/Tools/AddComment/AddComment.d.ts

@@ -0,0 +1,14 @@
+import { Board } from 'Board';
+import { BoardTool } from 'Tools/BoardTool';
+export declare class AddComment extends BoardTool {
+    isDown: boolean;
+    comment: null | Comment;
+    constructor(board: Board);
+    setCursor(): void;
+    leftButtonDown(): boolean;
+    pointerMoveBy(_x: number, _y: number): boolean;
+    leftButtonUp(): boolean;
+    keyDown(key: string): boolean;
+    returnToTool: () => void;
+    onCancel(): void;
+}

package/dist/types/Tools/AddComment/index.d.ts

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

package/dist/types/Tools/AddConnector/AddConnector.d.ts

@@ -0,0 +1,35 @@
+import { Board } from 'Board';
+import { Connector, Item, Point } from 'Items';
+import { ConnectorLineStyle } from 'Items/Connector';
+import { ConnectionLineWidth } from 'Items/Connector/Connector';
+import { ConnectorSnap } from 'Items/Connector/ConnectorSnap';
+import { ConnectorPointerStyle } from 'Items/Connector/Pointers/Pointers';
+import { DrawingContext } from 'Items/DrawingContext';
+import { BorderStyle } from 'Items/Path';
+import { BoardTool } from 'Tools/BoardTool';
+export declare class AddConnector extends BoardTool {
+    private board;
+    connector: Connector | null;
+    lineStyle: ConnectorLineStyle;
+    startPointer?: ConnectorPointerStyle;
+    endPointer?: ConnectorPointerStyle;
+    lineColor?: string;
+    lineWidth?: ConnectionLineWidth;
+    strokeStyle?: BorderStyle;
+    snap: ConnectorSnap;
+    isDraggingFromFirstToSecond: boolean;
+    isDoneSecondPoint: boolean;
+    isDown: boolean;
+    isQuickAdd: boolean;
+    constructor(board: Board, itemToStart?: Item, position?: Point);
+    setCursor(): void;
+    leftButtonDown(): boolean;
+    pointerMoveBy(_x: number, _y: number): boolean;
+    leftButtonUp(): Promise<boolean>;
+    keyDown(key: string): boolean;
+    middleButtonDown(): boolean;
+    rightButtonDown(): boolean;
+    returnToTool: () => void;
+    render(context: DrawingContext): void;
+    applyLineStyle(lineStyle: ConnectorLineStyle): void;
+}

package/dist/types/Tools/AddConnector/index.d.ts

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

package/dist/types/Tools/AddDrawing/AddDrawing.d.ts

@@ -0,0 +1,29 @@
+import { Board } from 'Board';
+import { Point } from 'Items';
+import { Drawing } from 'Items/Drawing';
+import { DrawingContext } from 'Items/DrawingContext';
+import { BorderStyle } from 'Items/Path';
+import { BoardTool } from 'Tools/BoardTool';
+export declare class AddDrawing extends BoardTool {
+    drawing: Drawing | null;
+    isDown: boolean;
+    strokeWidth: number;
+    strokeColor: string;
+    strokeStyle: BorderStyle;
+    constructor(board: Board);
+    private updateSettings;
+    setStrokeWidth(strokeWidth: number): void;
+    setStrokeColor(strokeColor: string): void;
+    getStrokeWidth(): number;
+    getStrokeColor(): string;
+    renderPointerCircle(point: Point, context: DrawingContext): void;
+    setCursor(): void;
+    isHighlighter(): boolean;
+    leftButtonDown(): boolean;
+    pointerMoveBy(_x: number, _y: number): boolean;
+    leftButtonUp(): boolean;
+    middleButtonDown(): boolean;
+    rightButtonDown(): boolean;
+    returnToTool: () => void;
+    render(context: DrawingContext): void;
+}

package/dist/types/Tools/AddDrawing/AddHighlighter.d.ts

@@ -0,0 +1,11 @@
+import { Board } from 'Board';
+import { BorderStyle } from 'Items/Path';
+import { AddDrawing } from './AddDrawing';
+export declare class AddHighlighter extends AddDrawing {
+    strokeWidth: number;
+    strokeColor: string;
+    strokeStyle: BorderStyle;
+    constructor(board: Board);
+    isHighlighter(): boolean;
+    private updateSettings;
+}

package/dist/types/Tools/AddDrawing/index.d.ts

@@ -0,0 +1,2 @@
+export { AddDrawing } from "./AddDrawing";
+export { AddHighlighter } from "./AddHighlighter";

package/dist/types/Tools/AddFrame/AddFrame.d.ts

@@ -0,0 +1,33 @@
+import { Board } from 'Board';
+import { Line, Frame, Mbr, Item } from 'Items';
+import { DrawingContext } from 'Items/DrawingContext';
+import { FrameType } from 'Items/Frame/Basic';
+import { BoardTool } from 'Tools/BoardTool';
+import { NestingHighlighter } from 'Tools/NestingHighlighter';
+export declare class AddFrame extends BoardTool {
+    line: Line | undefined;
+    shape: FrameType;
+    frame: Frame;
+    mbr: Mbr;
+    isDown: boolean;
+    nestingHighlighter: NestingHighlighter;
+    constructor(board: Board);
+    setCursor(): void;
+    setShapeType(type: FrameType): void;
+    keyDown(key: string): boolean;
+    leftButtonDown(): boolean;
+    pointerMoveBy(_x: number, _y: number): boolean;
+    leftButtonUp(): boolean;
+    addNextTo(): void;
+    initTransformation(sx?: number, sy?: number): void;
+    transformToCenter(): void;
+    transformToPointerCenter(): void;
+    applyScaleTo(x: number, y: number): void;
+    applyScaleBy(x: number, y: number): void;
+    applyTranslateTo(x: number, y: number): void;
+    applyTranslateBy(x: number, y: number): void;
+    applyAddChildren(children: Item[]): void;
+    applyCanChangeRatio(canChangeRatio: boolean): void;
+    applyFrameType(shapeType: FrameType): void;
+    render(context: DrawingContext): void;
+}

package/dist/types/Tools/AddFrame/index.d.ts

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

package/dist/types/Tools/AddShape/AddShape.d.ts

@@ -0,0 +1,27 @@
+import { Board } from "Board";
+import { Line, Mbr, Shape } from "Items";
+import { DrawingContext } from "Items/DrawingContext";
+import { ShapeType } from "Items/Shape";
+import { ResizeType } from "Selection/Transformer/TransformerHelpers/getResizeType";
+import { BoardTool } from "Tools/BoardTool";
+export declare class AddShape extends BoardTool {
+    line: Line | undefined;
+    resizeType: ResizeType;
+    bounds: Mbr;
+    type: ShapeType | "None";
+    shape: Shape;
+    isDown: boolean;
+    constructor(board: Board);
+    setCursor(): void;
+    setShapeType(type: ShapeType): void;
+    initTransformation(sx?: number, sy?: number): void;
+    leftButtonDown(): boolean;
+    pointerMoveBy(_x: number, _y: number): boolean;
+    leftButtonUp(): boolean;
+    keyDown(key: string): boolean;
+    middleButtonDown(): boolean;
+    rightButtonDown(): boolean;
+    returnToTool: () => void;
+    createShapeInCenter(shape: ShapeType): void;
+    render(context: DrawingContext): void;
+}

package/dist/types/Tools/AddShape/index.d.ts

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

package/dist/types/Tools/AddSticker/AddSticker.d.ts

@@ -0,0 +1,27 @@
+import { Board } from 'Board';
+import { Line, Mbr } from 'Items';
+import { DrawingContext } from 'Items/DrawingContext';
+import { Sticker } from 'Items/Sticker';
+import { BoardTool } from 'Tools/BoardTool';
+export declare class AddSticker extends BoardTool {
+    static MIN_SIZE: number;
+    line: Line | undefined;
+    bounds: Mbr;
+    static defaultWidth?: number;
+    sticker: Sticker;
+    isDown: boolean;
+    constructor(board: Board);
+    setCursor(color?: string): void;
+    setBackgroundColor(color: string): void;
+    getBackgroundColor(): string;
+    leftButtonDown(): boolean;
+    pointerMoveBy(_x: number, _y: number): boolean;
+    leftButtonUp(): boolean;
+    keyDown(key: string): boolean;
+    middleButtonDown(): boolean;
+    rightButtonDown(): boolean;
+    returnToTool: () => void;
+    render(context: DrawingContext): void;
+    private getLastSticker;
+    private setLastSticker;
+}

package/dist/types/Tools/AddSticker/index.d.ts

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

package/dist/types/Tools/AddText/AddText.d.ts

@@ -0,0 +1,19 @@
+import { Board } from 'Board';
+import { Line, Mbr } from 'Items';
+import { DrawingContext } from 'Items/DrawingContext';
+import { BoardTool } from 'Tools/BoardTool';
+export declare class AddText extends BoardTool {
+    private board;
+    line: Line | undefined;
+    bounds: Mbr;
+    constructor(board: Board);
+    setCursor(): void;
+    leftButtonDown(): boolean;
+    pointerMoveBy(_x: number, _y: number): boolean;
+    leftButtonUp(): Promise<boolean>;
+    keyDown(key: string): boolean;
+    middleButtonDown(): boolean;
+    rightButtonDown(): boolean;
+    returnToTool: () => void;
+    render(context: DrawingContext): void;
+}

package/dist/types/Tools/AddText/index.d.ts

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

package/dist/types/Tools/BoardTool.d.ts

@@ -0,0 +1,6 @@
+import { Board } from "Board";
+import { Tool } from "./Tool";
+export declare class BoardTool extends Tool {
+    protected board: Board;
+    constructor(board: Board);
+}

package/dist/types/Tools/BoardToolContext.d.ts

@@ -0,0 +1,8 @@
+import { Board } from "Board";
+import { ToolContext } from "./ToolContext";
+import { Tools } from "./Tools";
+export declare class BoardToolContext extends ToolContext {
+    protected boardTools: Tools;
+    protected board: Board;
+    constructor(boardTools: Tools, board: Board);
+}

package/dist/types/Tools/DebounceUpdater/DebounceUpdater.d.ts

@@ -0,0 +1,6 @@
+export default function createDebounceUpdater(): {
+    shouldUpd: () => boolean;
+    setTimeoutUpdate: (ms: number) => void;
+    setFalse: () => void;
+};
+export type DebounceUpdater = ReturnType<typeof createDebounceUpdater>;

package/dist/types/Tools/DebounceUpdater/index.d.ts

@@ -0,0 +1 @@
+export { default as createDebounceUpdater } from "./DebounceUpdater";

package/dist/types/Tools/Eraser/Eraser.d.ts

@@ -0,0 +1,22 @@
+import { Board } from 'Board';
+import { Drawing } from 'Items/Drawing';
+import { DrawingContext } from 'Items/DrawingContext';
+import { BorderStyle } from 'Items/Path';
+import { BoardTool } from 'Tools/BoardTool';
+export declare class Eraser extends BoardTool {
+    itemType: string;
+    isDown: boolean;
+    strokeWidth: number;
+    strokeColor: string;
+    strokeStyle: BorderStyle;
+    drawing: Drawing;
+    maxPointsInLine: number;
+    constructor(board: Board);
+    setCursor(): void;
+    leftButtonDown(): boolean;
+    removeUnderPointOrLine(): void;
+    pointerMoveBy(_x: number, _y: number): boolean;
+    leftButtonUp(): boolean;
+    rightButtonDown(): boolean;
+    render(context: DrawingContext): void;
+}

package/dist/types/Tools/Eraser/index.d.ts

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

package/dist/types/Tools/ExportSnapshot/ExportSnapshot.d.ts

@@ -0,0 +1,30 @@
+import { Path2DFactory } from "api/Path2DFactory";
+import { Board } from "Board";
+import { Mbr, Transformation, Point } from "Items";
+import { DrawingContext } from "Items/DrawingContext";
+import { ResizeType } from "Selection/Transformer/TransformerHelpers/getResizeType";
+import { Tool } from "Tools/Tool";
+import { SnapshotInfo } from "./exportBoardSnapshot";
+export declare class ExportSnapshot extends Tool {
+    private board;
+    mbr: Mbr;
+    transformation: Transformation;
+    isDown: boolean;
+    isDragging: boolean;
+    resizeType: null | ResizeType;
+    oppositePoint: null | Point;
+    tempCanvas: HTMLCanvasElement;
+    tempCtx: CanvasRenderingContext2D;
+    tempDrawingContext: DrawingContext;
+    constructor(board: Board);
+    rectMoveTo(x: number, y: number): void;
+    resize(): void;
+    updateCursor(): void;
+    pointerMoveBy(x: number, y: number): boolean;
+    leftButtonDown(): boolean;
+    leftButtonUp(): boolean;
+    takeSnapshot(): Promise<SnapshotInfo>;
+    renderDecoration(context: DrawingContext, path: Path2DFactory, translateX: number, translateY: number, color: string, lineWidth: number): void;
+    onCancel(): void;
+    render(context: DrawingContext): void;
+}

package/dist/types/Tools/ExportSnapshot/exportBoardSnapshot.d.ts

@@ -0,0 +1,16 @@
+import { Board } from 'Board';
+import { Mbr } from 'Items';
+export interface SnapshotInfo {
+    dataUrl: string;
+    nameToExport: string;
+}
+type Args = {
+    board: Board;
+    bgColor?: string;
+    selection: Mbr;
+    nameToExport?: string;
+    upscaleTo?: number;
+    upscaleBy?: number;
+};
+export declare function exportBoardSnapshot({ board, bgColor, selection, nameToExport, upscaleTo, upscaleBy, }: Args): Promise<SnapshotInfo>;
+export {};

package/dist/types/Tools/ExportSnapshot/getDecorationResizeType.d.ts

@@ -0,0 +1,3 @@
+import { Point, Mbr } from "Items";
+import { ResizeType } from "Selection/Transformer/TransformerHelpers/getResizeType";
+export declare function getDecorationResizeType(point: Point, mbr: Mbr, tolerance?: number): ResizeType | undefined;

package/dist/types/Tools/Navigate/Navigate.d.ts

@@ -0,0 +1,19 @@
+import { Board } from 'Board';
+import { BoardTool } from 'Tools/BoardTool';
+export declare class Navigate extends BoardTool {
+    isDown: boolean;
+    isDraggingBoard: boolean;
+    constructor(board: Board);
+    returnToTool: () => void;
+    pointerMoveBy(x: number, y: number): boolean;
+    private down;
+    leftButtonDown(): boolean;
+    middleButtonDown(): boolean;
+    rightButtonDown(): boolean;
+    private up;
+    leftButtonUp(): boolean;
+    middleButtonUp(): boolean;
+    rightButtonUp(): boolean;
+    leftButtonDouble(): boolean;
+    keyDown(key: string): boolean;
+}

package/dist/types/Tools/Navigate/index.d.ts

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

package/dist/types/Tools/NestingHighlighter/NestingHighlighter.d.ts

@@ -0,0 +1,18 @@
+import { Frame, Item } from 'Items';
+import { DrawingContext } from 'Items/DrawingContext';
+import { Tool } from 'Tools/Tool';
+interface HighlightGroup {
+    frame?: Frame;
+    children: Item[];
+}
+export declare class NestingHighlighter extends Tool {
+    private toHighlight;
+    clear(): void;
+    listAll(): HighlightGroup[];
+    add(frame: Frame, children: Item | Item[]): void;
+    addSingleItem(item: Item): void;
+    /** Remvoe children only, frames would be cleaned when empty */
+    remove(item: Item): void;
+    render(context: DrawingContext): void;
+}
+export {};

package/dist/types/Tools/NestingHighlighter/index.d.ts

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

package/dist/types/Tools/RelativeAlignment/RelativeAlignment.d.ts

@@ -0,0 +1,45 @@
+import { Board } from "Board";
+import { CanvasDrawer } from "drawMbrOnCanvas";
+import { Item, Mbr, Line, Point } from "Items";
+import { DrawingContext } from "Items/DrawingContext";
+import { ResizeType } from "Selection/Transformer/TransformerHelpers/getResizeType";
+import { SpatialIndex } from "SpatialIndex";
+import { DebounceUpdater } from "Tools/DebounceUpdater/DebounceUpdater";
+export declare const RELATIVE_ALIGNMENT_COLOR = "#4778F5";
+export declare class AlignmentHelper {
+    private spatialIndex;
+    private canvasDrawer;
+    private debounceUpd;
+    private alignThreshold;
+    private snapMemory;
+    board: Board;
+    snapThreshold: number;
+    constructor(board: Board, spatialIndex: SpatialIndex, canvasDrawer: CanvasDrawer, debounceUpd: DebounceUpdater);
+    calculateLineThickness(zoom: number): number;
+    combineMBRs(items: Item[]): Mbr;
+    checkAlignment(movingItem: Item | Item[], excludeItems?: Item[]): {
+        verticalLines: Line[];
+        horizontalLines: Line[];
+    };
+    generateGuidelines(center: Point): {
+        lines: Line[];
+    };
+    snapToClosestLine(draggingItem: Item | Item[], snapLines: {
+        verticalLines: Line[];
+        horizontalLines: Line[];
+    }, beginTimeStamp: number, cursorPosition: Point): boolean;
+    snapCanvasToClosestLine(snapLines: {
+        verticalLines: Line[];
+        horizontalLines: Line[];
+    }, beginTimeStamp: number, cursorPosition: Point): boolean;
+    snapToSide(draggingItem: Item | Item[], snapLines: {
+        verticalLines: Line[];
+        horizontalLines: Line[];
+    }, beginTimeStamp: number, side: ResizeType): boolean;
+    translateItems(item: Item | Item[], x: number, y: number, timeStamp: number): void;
+    translateCanvas(x: number, y: number, timeStamp: number): void;
+    renderSnapLines(context: DrawingContext, snapLines: {
+        verticalLines: Line[];
+        horizontalLines: Line[];
+    }, scale: number): void;
+}

package/dist/types/Tools/RelativeAlignment/index.d.ts

@@ -0,0 +1,2 @@
+import { AlignmentHelper } from "./RelativeAlignment";
+export default AlignmentHelper;

package/dist/types/Tools/Select/Select.d.ts

@@ -0,0 +1,68 @@
+import { Board } from 'Board';
+import { CanvasDrawer } from 'drawMbrOnCanvas';
+import { Line, Mbr, Item } from 'Items';
+import { DrawingContext } from 'Items/DrawingContext';
+import { NestingHighlighter } from 'Tools/NestingHighlighter';
+import { Tool } from 'Tools/Tool';
+export declare class Select extends Tool {
+    private board;
+    line: null | Line;
+    rect: null | Mbr;
+    downOnItem: null | Item;
+    isHoverUnselectedItem: boolean;
+    isDrawingRectangle: boolean;
+    isCameraPan: boolean;
+    isDraggingSelection: boolean;
+    isDraggingUnselectedItem: boolean;
+    isDownOnSelection: boolean;
+    isDownOnBoard: boolean;
+    isDownOnUnselectedItem: boolean;
+    isLeftDown: boolean;
+    isRightDown: boolean;
+    isMiddleDown: boolean;
+    isMovedAfterDown: boolean;
+    isCtrl: boolean;
+    lastPointerMoveEventTime: number;
+    nestingHighlighter: NestingHighlighter;
+    beginTimeStamp: number;
+    canvasDrawer: CanvasDrawer;
+    debounceUpd: {
+        shouldUpd: () => boolean;
+        setTimeoutUpdate: (ms: number) => void;
+        setFalse: () => void;
+    };
+    private alignmentHelper;
+    private snapLines;
+    private isSnapped;
+    private snapCursorPos;
+    private originalCenter;
+    private initialCursorPos;
+    private guidelines;
+    private mainLine;
+    private snapLine;
+    initialSnap: boolean;
+    constructor(board: Board);
+    clear(): void;
+    private handleSnapping;
+    private handleCanvasSnapping;
+    private calculateLineLength;
+    private calculateAngle;
+    private handleShiftGuidelines;
+    private clearGuidelines;
+    leftButtonDown(hoveredItem?: Item): boolean;
+    rightButtonDown(): boolean;
+    middleButtonDown(): boolean;
+    pointerMoveBy(x: number, y: number): boolean;
+    private updateMovementFlag;
+    private updateGuidelines;
+    private updateFramesNesting;
+    private updateSnapLines;
+    private getAlignmentItem;
+    leftButtonUp(): boolean;
+    rightButtonUp(): boolean;
+    middleButtonUp(): boolean;
+    leftButtonDouble(): boolean;
+    onCancel(): void;
+    onConfirm(): void;
+    render(context: DrawingContext): void;
+}

package/dist/types/Tools/Select/index.d.ts

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

package/dist/types/Tools/Tool.d.ts

@@ -0,0 +1,18 @@
+import { DrawingContext } from 'Items/DrawingContext';
+export declare class Tool {
+    leftButtonDown(): boolean;
+    leftButtonUp(): boolean;
+    leftButtonDouble(): boolean;
+    rightButtonDown(): boolean;
+    rightButtonUp(): boolean;
+    rightButtonDouble(): boolean;
+    middleButtonDown(): boolean;
+    middleButtonUp(): boolean;
+    middleButtonDouble(): boolean;
+    keyDown(_key: string): boolean;
+    keyUp(_key: string): boolean;
+    pointerMoveBy(_x: number, _y: number): boolean;
+    onCancel(): void;
+    onConfirm(): void;
+    render(_context: DrawingContext): void;
+}