microboard-temp 0.1.1 → 0.1.3

package/dist/types/Items/Shape/ShapeOperation.d.ts

@@ -0,0 +1,37 @@
+import { BorderStyle } from "../Path";
+import { ShapeType } from "./index";
+export type ShapeOperation = SetBackgroundColor | SetBackgroundOpacity | SetBorderColor | SetBorderOpacity | SetBorderStyle | SetBorderWidth | SetShapeType;
+interface BaseShapeOperation {
+    class: "Shape";
+    item: string[];
+}
+interface SetBackgroundColor extends BaseShapeOperation {
+    method: "setBackgroundColor";
+    backgroundColor: string;
+}
+interface SetBackgroundOpacity extends BaseShapeOperation {
+    method: "setBackgroundOpacity";
+    backgroundOpacity: number;
+}
+interface SetBorderColor extends BaseShapeOperation {
+    method: "setBorderColor";
+    borderColor: string;
+}
+interface SetBorderOpacity extends BaseShapeOperation {
+    method: "setBorderOpacity";
+    borderOpacity: number;
+}
+interface SetBorderStyle extends BaseShapeOperation {
+    method: "setBorderStyle";
+    borderStyle: BorderStyle;
+}
+export interface SetBorderWidth extends BaseShapeOperation {
+    method: "setBorderWidth";
+    borderWidth: number;
+    prevBorderWidth: number;
+}
+interface SetShapeType extends BaseShapeOperation {
+    method: "setShapeType";
+    shapeType: ShapeType;
+}
+export {};

package/dist/types/Items/Shape/getRandomRgba.d.ts

@@ -0,0 +1 @@
+export declare function getRandomRgba(min: number, max: number, alphaMin: number, alphaMax: number): string;

package/dist/types/Items/Shape/handleUpdate.d.ts

@@ -0,0 +1,7 @@
+import { TransformationOperation } from "../Transformation";
+export declare function handleUpdate(op: TransformationOperation, text: {
+    getId: () => string;
+    transformCanvas: () => void;
+    handleInshapeScale: () => void;
+    updateElement: () => void;
+}): void;

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

@@ -0,0 +1,8 @@
+import { BasicShapes } from "./Basic";
+import { BPMN } from "./BPMN";
+export { Shape, Shapes } from "./Shape";
+export { ShapeCommand } from "./ShapeCommand";
+export type { ShapeOperation } from "./ShapeOperation";
+export { DefaultShapeData } from "./ShapeData";
+export type { ShapeData } from "./ShapeData";
+export type ShapeType = keyof typeof BasicShapes | BPMN;

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

@@ -0,0 +1,73 @@
+import { Operation } from "Events";
+import { Subject } from "Subject";
+import { Line, Matrix, Mbr, Path, Paths, Point, Transformation } from "..";
+import { ResizeType } from "../../Selection/Transformer/TransformerHelpers/getResizeType.ts";
+import { DrawingContext } from "../DrawingContext";
+import { GeometricNormal } from "../GeometricNormal";
+import { Geometry } from "../Geometry";
+import { RichText } from "../RichText";
+import { StickerData, StickerOperation } from "./StickerOperation";
+import { LinkTo } from "../LinkTo/LinkTo";
+import { Board } from "Board";
+import { DocumentFactory } from "api/DocumentFactory";
+export declare const stickerColors: {
+    [color: string]: string;
+};
+export declare const StickerShape: {
+    textBounds: Mbr;
+    stickerPath: Path;
+    anchorPoints: Point[];
+    DEFAULTS: number[];
+};
+export declare class Sticker implements Geometry {
+    private board;
+    private id;
+    private backgroundColor;
+    parent: string;
+    readonly itemType = "Sticker";
+    readonly transformation: Transformation;
+    readonly linkTo: LinkTo;
+    private stickerPath;
+    private textContainer;
+    text: RichText;
+    readonly subject: Subject<Sticker>;
+    transformationRenderBlock?: boolean;
+    constructor(board: Board, id?: string, backgroundColor?: string);
+    emit(operation: StickerOperation): void;
+    saveStickerData(): void;
+    serialize(): StickerData;
+    deserialize(data: Partial<StickerData>): this;
+    private transformPath;
+    setId(id: string): this;
+    getId(): string;
+    apply(op: Operation): void;
+    getBackgroundColor(): string;
+    getWidth(): number;
+    private applyBackgroundColor;
+    setBackgroundColor(backgroundColor: string): void;
+    getIntersectionPoints(segment: Line): Point[];
+    getMbr(): Mbr;
+    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;
+    getNormal(point: Point): GeometricNormal;
+    render(context: DrawingContext): void;
+    renderHTML(documentFactory: DocumentFactory): HTMLElement;
+    renderShadow(context: DrawingContext): void;
+    getPaths(): Path | Paths;
+    isClosed(): boolean;
+    getPath(): Path | Paths;
+    getSnapAnchorPoints(): Point[];
+    applyDiagonal(line: Line): void;
+    applyTransformToCenter(pt: Point, newWidth?: number): void;
+    doResize(resizeType: ResizeType, pointer: Point, mbr: Mbr, opposite: Point, startMbr: Mbr, timeStamp: number): {
+        matrix: Matrix;
+        mbr: Mbr;
+    };
+    getRichText(): RichText;
+    getLinkTo(): string | undefined;
+}

package/dist/types/Items/Sticker/StickerCommand.d.ts

@@ -0,0 +1,15 @@
+import { StickerOperation } from "./StickerOperation";
+import { Command } from "../../Events";
+import { Sticker } from "./index";
+export declare class StickerCommand implements Command {
+    private sticker;
+    private operation;
+    private reverse;
+    constructor(sticker: Sticker[], operation: StickerOperation);
+    apply(): void;
+    revert(): void;
+    getReverse(): {
+        item: Sticker;
+        operation: StickerOperation;
+    }[];
+}

package/dist/types/Items/Sticker/StickerOperation.d.ts

@@ -0,0 +1,19 @@
+import { LinkTo } from 'Items/LinkTo/LinkTo';
+import { DefaultRichTextData } from '../RichText/RichTextData';
+import { DefaultTransformationData } from '../Transformation/TransformationData';
+export declare class StickerData {
+    backgroundColor: string;
+    transformation: DefaultTransformationData;
+    linkTo?: (string | LinkTo) | undefined;
+    text: DefaultRichTextData;
+    readonly itemType = "Sticker";
+    constructor(backgroundColor?: string, transformation?: DefaultTransformationData, linkTo?: (string | LinkTo) | undefined, text?: DefaultRichTextData);
+}
+interface SetBackgroundColor {
+    class: 'Sticker';
+    method: 'setBackgroundColor';
+    item: string[];
+    backgroundColor: string;
+}
+export type StickerOperation = SetBackgroundColor;
+export {};

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

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

package/dist/types/Items/Transformation/Matrix.d.ts

@@ -0,0 +1,45 @@
+import { Point } from '..';
+export declare class Matrix {
+    translateX: number;
+    translateY: number;
+    scaleX: number;
+    scaleY: number;
+    shearX: number;
+    shearY: number;
+    constructor(translateX?: number, translateY?: number, scaleX?: number, scaleY?: number, shearX?: number, shearY?: number);
+    translate(x: number, y: number): void;
+    scale(x: number, y: number): void;
+    multiplyByMatrix(matrix: Matrix): this;
+    multiplyByMatrixies(matrixies: Matrix[]): this;
+    multiply(value: Matrix | Matrix[]): this;
+    copy(): Matrix;
+    invert(): void;
+    getInverse(): Matrix;
+    rotateByRadian(radian: number): Matrix;
+    rotateBy(degree: number): void;
+    rotateByObjectCenter(degree: number, size: {
+        width: number;
+        height: number;
+    }, scale: {
+        x: number;
+        y: number;
+    }): void;
+    rotateByRelativeTo(degree: number, x: number, y: number): void;
+    rotateByRadianRelativeTo(radian: number, x: number, y: number): void;
+    apply(point: Point): void;
+    applyToContext(ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
+    getAffineMatrix(): {
+        a: number;
+        b: number;
+        c: number;
+        d: number;
+        e: number;
+        f: number;
+    };
+    getCssString(): string;
+    identity(): Matrix;
+    mirrorOrigin(): Matrix;
+    mirrorX(): Matrix;
+    mirrorY(): Matrix;
+    compare(matrix: Matrix): boolean;
+}

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

@@ -0,0 +1,78 @@
+import { SubjectOperation } from 'SubjectOperation';
+import { Events, Operation } from '../../Events';
+import { Point } from '../Point';
+import { Matrix } from './Matrix';
+import { TransformationData } from './TransformationData';
+import { TransformationOperation } from './TransformationOperations';
+export declare class Transformation {
+    private id;
+    private events?;
+    readonly subject: SubjectOperation<Transformation, TransformationOperation>;
+    matrix: Matrix;
+    previous: Matrix;
+    private rotate;
+    isLocked: boolean;
+    constructor(id?: string, events?: Events | undefined);
+    serialize(): TransformationData;
+    deserialize(data: TransformationData & {
+        dimension?: {
+            width: number;
+            height: number;
+        };
+    }): this;
+    copy(id?: string): Transformation;
+    emit(operation: TransformationOperation): void;
+    setId(id: string): void;
+    apply(op: Operation): void;
+    applyTranslateTo(x: number, y: number): void;
+    applyTranslateBy(x: number, y: number): void;
+    applyScaleTo(x: number, y: number): void;
+    applyScaleBy(x: number, y: number): void;
+    applyScaleByTranslateBy(scale: {
+        x: number;
+        y: number;
+    }, translate: {
+        x: number;
+        y: number;
+    }): void;
+    applyTransformMany(op: TransformationOperation): void;
+    applyScaleByRelativeTo(x: number, y: number, point: {
+        x: number;
+        y: number;
+    }): void;
+    applyScaleToRelativeTo(x: number, y: number, point: {
+        x: number;
+        y: number;
+    }): void;
+    applyRotateTo(degree: number): void;
+    applyRotateBy(degree: number): void;
+    applyLocked(locked: boolean): void;
+    applyUnlocked(locked: boolean): void;
+    getTranslation(): {
+        x: number;
+        y: number;
+    };
+    getScale(): {
+        x: number;
+        y: number;
+    };
+    getRotation(): number;
+    getInverse(): Transformation;
+    getId(): string;
+    translateTo(x: number, y: number, timeStamp?: number): void;
+    translateBy(x: number, y: number, timeStamp?: number): void;
+    scaleTo(x: number, y: number, timeStamp?: number): void;
+    scaleBy(x: number, y: number, timeStamp?: number): void;
+    scaleByTranslateBy(scale: {
+        x: number;
+        y: number;
+    }, translate: {
+        x: number;
+        y: number;
+    }, timeStamp?: number): void;
+    rotateTo(degree: number, timeStamp?: number): void;
+    rotateBy(degree: number, timeStamp?: number): void;
+    scaleToRelativeTo(x: number, y: number, point: Point, timeStamp?: number): void;
+    scaleByRelativeTo(x: number, y: number, point: Point, timeStamp?: number): void;
+    setIsLocked(isLocked: boolean, timestamp?: number): void;
+}

package/dist/types/Items/Transformation/TransformationCommand.d.ts

@@ -0,0 +1,19 @@
+import { Transformation } from "./Transformation";
+import { TransformationOperation } from "./TransformationOperations";
+import { Command } from "../../Events";
+export declare class TransformationCommand implements Command {
+    private transformation;
+    private operation;
+    reverse: {
+        item: Transformation;
+        operation: TransformationOperation;
+    }[];
+    constructor(transformation: Transformation[], operation: TransformationOperation);
+    merge(op: TransformationOperation): this;
+    apply(): void;
+    revert(): void;
+    getReverse(): {
+        item: Transformation;
+        operation: TransformationOperation;
+    }[];
+}

package/dist/types/Items/Transformation/TransformationData.d.ts

@@ -0,0 +1,17 @@
+export interface TransformationData {
+    translateX: number;
+    translateY: number;
+    scaleX: number;
+    scaleY: number;
+    rotate: number;
+    isLocked: boolean;
+}
+export declare class DefaultTransformationData implements TransformationData {
+    translateX: number;
+    translateY: number;
+    scaleX: number;
+    scaleY: number;
+    rotate: number;
+    isLocked: boolean;
+    constructor(translateX?: number, translateY?: number, scaleX?: number, scaleY?: number, rotate?: number, isLocked?: boolean);
+}

package/dist/types/Items/Transformation/TransformationOperations.d.ts

@@ -0,0 +1,69 @@
+import { TransformationData } from "./TransformationData";
+interface TransformationBase {
+    class: "Transformation";
+    item: string[];
+    timestamp?: number;
+}
+export interface TranslateOperation extends TransformationBase {
+    method: "translateTo" | "translateBy";
+    x: number;
+    y: number;
+    timeStamp?: number;
+}
+export interface ScaleOperation extends TransformationBase {
+    method: "scaleTo" | "scaleBy";
+    x: number;
+    y: number;
+    timeStamp?: number;
+}
+interface RotateOperation extends TransformationBase {
+    method: "rotateTo" | "rotateBy";
+    degree: number;
+    timeStamp?: number;
+}
+interface ScaleRelativeToOperation extends TransformationBase {
+    method: "scaleToRelativeTo" | "scaleByRelativeTo";
+    x: number;
+    y: number;
+    point: {
+        x: number;
+        y: number;
+    };
+    timeStamp?: number;
+}
+export interface ScaleByTranslateByOperation extends TransformationBase {
+    method: "scaleByTranslateBy";
+    translate: {
+        x: number;
+        y: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+    };
+    timeStamp?: number;
+}
+interface DeserializeOperation extends TransformationBase {
+    method: "deserialize";
+    data: TransformationData;
+    timeStamp?: number;
+}
+interface Locked extends TransformationBase {
+    method: "locked";
+    locked: boolean;
+}
+interface Unlocked extends TransformationBase {
+    method: "unlocked";
+    locked: boolean;
+}
+export interface TransformManyItems {
+    [key: string]: ScaleByTranslateByOperation | ScaleOperation | TranslateOperation;
+}
+export interface TransformMany {
+    class: "Transformation";
+    method: "transformMany";
+    items: TransformManyItems;
+    timeStamp?: number;
+}
+export type TransformationOperation = TranslateOperation | ScaleOperation | RotateOperation | ScaleRelativeToOperation | ScaleByTranslateByOperation | DeserializeOperation | TransformMany | Locked | Unlocked;
+export {};

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

@@ -0,0 +1,5 @@
+export { Matrix } from "./Matrix";
+export { Transformation } from "./Transformation";
+export type { TransformationOperation, TranslateOperation, ScaleByTranslateByOperation, ScaleOperation, } from "./TransformationOperations";
+export type { TransformationData } from "./TransformationData";
+export { DefaultTransformationData } from "./TransformationData";

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

@@ -0,0 +1,97 @@
+import { DocumentFactory } from 'api/DocumentFactory';
+import { Board } from 'Board';
+import { Events, Operation } from 'Events';
+import { Point } from 'Items';
+import { DrawingContext } from 'Items/DrawingContext';
+import { LinkTo } from 'Items/LinkTo/LinkTo';
+import { Mbr } from 'Items/Mbr';
+import { Path, Paths } from 'Items/Path';
+import { TransformationData, Transformation } from 'Items/Transformation';
+import { Subject } from 'Subject';
+export interface VideoItemData {
+    itemType: 'Video';
+    url?: string;
+    videoDimension: Dimension;
+    transformation: TransformationData;
+    isStorageUrl: boolean;
+    previewUrl?: string;
+    extension: string;
+}
+export interface Dimension {
+    height: number;
+    width: number;
+}
+export interface VideoConstructorData {
+    url?: string;
+    videoDimension: Dimension;
+    previewUrl?: string;
+}
+export declare const createPlaceholderImage: (width: number, height: number) => HTMLImageElement;
+export declare class VideoItem extends Mbr {
+    private events?;
+    private id;
+    private extension;
+    readonly itemType = "Video";
+    parent: string;
+    preview: HTMLImageElement;
+    readonly transformation: Transformation;
+    readonly linkTo: LinkTo;
+    readonly subject: Subject<VideoItem>;
+    loadCallbacks: ((video: VideoItem) => void)[];
+    beforeLoadCallbacks: ((video: VideoItem) => void)[];
+    transformationRenderBlock?: boolean;
+    private url;
+    private previewUrl;
+    private isStorageUrl;
+    videoDimension: Dimension;
+    board: Board;
+    private isPlaying;
+    private shouldShowControls;
+    private playBtnMbr;
+    private currentTime;
+    constructor({ url, videoDimension, previewUrl }: VideoConstructorData, board: Board, events?: Events | undefined, id?: string, extension?: string);
+    setCurrentTime(time: number): void;
+    getCurrentTime(): number;
+    onTransform: () => void;
+    doOnceBeforeOnLoad: (callback: (video: VideoItem) => void) => void;
+    doOnceOnLoad: (callback: (video: VideoItem) => void) => void;
+    getStorageId(): string | undefined;
+    getIsStorageUrl(): boolean;
+    setVideoData({ previewUrl, url }: {
+        previewUrl: string;
+        url: string;
+    }): void;
+    applyVideoData({ previewUrl, url }: {
+        previewUrl?: string;
+        url?: string;
+    }): void;
+    setIsPlaying(isPlaying: boolean): void;
+    getIsPlaying(): boolean;
+    setShouldShowControls(shouldShowControls: boolean): void;
+    getShouldShowControls(): boolean;
+    getPlayBtnMbr(): Mbr;
+    setUrl(url: string): void;
+    private setPreview;
+    setPreviewImage(image: HTMLImageElement): void;
+    getPreviewUrl(): string;
+    getUrl(): string;
+    onLoad: () => Promise<void>;
+    onError: (_error: any) => void;
+    updateMbr(): void;
+    render(context: DrawingContext): void;
+    renderHTML(documentFactory: DocumentFactory): HTMLElement;
+    serialize(): VideoItemData;
+    deserialize(data: Partial<VideoItemData>): VideoItem;
+    apply(op: Operation): void;
+    emit(operation: Operation): void;
+    setId(id: string): this;
+    getId(): string;
+    private shootLoadCallbacks;
+    private shootBeforeLoadCallbacks;
+    getPath(): Path | Paths;
+    getSnapAnchorPoints(): Point[];
+    isClosed(): boolean;
+    getRichText(): null;
+    getLinkTo(): string | undefined;
+    download(): void;
+}

package/dist/types/Items/Video/VideoCommand.d.ts

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

package/dist/types/Items/Video/VideoHelpers.d.ts

@@ -0,0 +1,15 @@
+import { Board } from 'Board';
+import { VideoConstructorData, VideoItem } from './Video';
+export declare const uploadVideoToStorage: (hash: string, videoBlob: Blob, accessToken: string | null, boardId: string) => Promise<string>;
+export declare const getVideoMetadata: (file: File) => Promise<{
+    width: number;
+    height: number;
+}>;
+export declare const createVideoItem: (board: Board, extension: "mp4" | "webm", videoData: VideoConstructorData, onLoadCb: (video: VideoItem) => void) => void;
+export declare const prepareVideo: (file: File, accessToken: string | null, boardId: string) => Promise<{
+    url: string;
+    previewUrl: string;
+}>;
+export declare const getYouTubeVideoPreview: (youtubeUrl: string) => Promise<HTMLImageElement>;
+export declare const getYouTubeThumbnail: (videoId: string, quality?: string) => string;
+export declare const captureFrame: (frameTime: number, video: HTMLVideoElement) => HTMLImageElement | null;

package/dist/types/Items/Video/VideoOperation.d.ts

@@ -0,0 +1,11 @@
+import { VideoConstructorData } from "./Video";
+interface VideoBaseOp {
+    class: "Video";
+    item: string[];
+}
+interface UpdateVideoData extends VideoBaseOp {
+    method: "updateVideoData";
+    data: VideoConstructorData;
+}
+export type VideoOperation = UpdateVideoData;
+export {};

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

@@ -0,0 +1,2 @@
+export { VideoItem, VideoItemData, VideoConstructorData } from './Video.js';
+export { uploadVideo } from './uploadVideo.js';

package/dist/types/Items/Video/uploadVideo.d.ts

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

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

@@ -0,0 +1,13 @@
+export { Point } from "./Point";
+export { Line } from "./Line";
+export { CubicBezier, QuadraticBezier } from "./Curve";
+export { Arc } from "./Arc";
+export { Path, Paths } from "./Path";
+export { Mbr } from "./Mbr";
+export { Matrix, Transformation, TransformationOperation, } from "./Transformation";
+export { Connector, ConnectorData, ConnectorOperation } from "./Connector";
+export { RichText, RichTextData, RichTextOperation } from "./RichText";
+export { Shape, ShapeData } from "./Shape";
+export { Frame, FrameData } from "./Frame";
+export { Item, ItemType, ItemData } from "./Item";
+export { Comment } from "./Comment";

package/dist/types/Keyboard/checkHotkeys.d.ts

@@ -0,0 +1,3 @@
+import { Board } from 'Board';
+import { HotkeysMap } from './types';
+export declare function checkHotkeys(hotkeyMap: HotkeysMap, event: KeyboardEvent, board: Board): boolean;

package/dist/types/Keyboard/getHotkeyLabel.d.ts

@@ -0,0 +1,2 @@
+import type { HotkeyName } from './types';
+export declare function getHotkeyLabel(hotkey: HotkeyName): string;

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

@@ -0,0 +1,16 @@
+export declare class Keyboard {
+    up: string;
+    down: string;
+    isShift: boolean;
+    isCtrl: boolean;
+    isAlt: boolean;
+    isCmd: boolean;
+    isSpacePressed: boolean;
+    activeKeys: Set<unknown>;
+    keyDown(event: KeyboardEvent): void;
+    keyUp(event: KeyboardEvent): void;
+}
+export { isHotkeyPushed } from "./isHotkeyPushed";
+export { checkHotkeys } from "./checkHotkeys";
+export { getHotkeyLabel } from "./getHotkeyLabel";
+export { isControlCharacter } from "./isControlCharacter";

package/dist/types/Keyboard/isControlCharacter.d.ts

@@ -0,0 +1 @@
+export declare function isControlCharacter(key: string): boolean;

package/dist/types/Keyboard/isHotkeyPushed.d.ts

@@ -0,0 +1,2 @@
+import type { HotkeyName } from './types';
+export declare function isHotkeyPushed(hotkey: HotkeyName, event: KeyboardEvent): boolean;

package/dist/types/Keyboard/logHotkey.d.ts

@@ -0,0 +1,5 @@
+import { SelectionContext } from 'Selection';
+import type { HotkeyCb, HotkeyConfig, HotkeyName } from './types';
+type HotkeyStatus = 'triggered' | 'canceledBySingleItemOnly' | 'canceledBySelectionContext' | 'canceledByAllItemsType';
+export declare function logHotkey(hotkeyConfig: HotkeyCb | HotkeyConfig, hotkeyName: HotkeyName, status: HotkeyStatus, context: SelectionContext): void;
+export {};

package/dist/types/Keyboard/types.d.ts

@@ -0,0 +1,24 @@
+import type { SelectionContext } from 'Selection/Selection';
+import hotkeys from 'features/hotkeys.json';
+export type Hotkey = {
+    key: {
+        button: string | string[];
+        ctrl?: boolean;
+        alt?: boolean;
+        shift?: boolean;
+    };
+    label: {
+        windows: string;
+        mac: string;
+    };
+};
+export type HotkeyName = keyof typeof hotkeys;
+export type HotkeyCb = (event?: KeyboardEvent) => void;
+export type HotkeyConfig = {
+    cb: HotkeyCb;
+    selectionContext?: SelectionContext[];
+    preventDefault?: boolean;
+    singleItemOnly?: boolean;
+    allItemsType?: string[];
+};
+export type HotkeysMap = Partial<Record<HotkeyName, HotkeyCb | HotkeyConfig>>;

package/dist/types/Pointer/Cursor.d.ts

@@ -0,0 +1,5 @@
+export declare const defaultCursors: readonly ["default", "auto", "text", "crosshair", "move", "all-scroll", "wait", "not-allowed", "pointer", "grab", "grabbing", "webkit-grab", "webkit-grabbing", "zoom-in", "zoom-out", "col-resize", "e-resize", "ew-resize", "n-resize", "ne-resize", "nesw-resize", "ns-resize", "nw-resize", "nwse-resize", "row-resize", "s-resize", "se-resize", "sw-resize", "w-resize", "alias", "cell", "context-menu", "copy", "help", "no-drop", "none", "progress", "sticker-purple", "sticker-pink", "sticker-sky-blue", "sticker-blue", "sticker-green", "sticker-light-green", "sticker-orange", "sticker-yellow", "sticker-light-gray", "sticker-gray"];
+export declare const customCursors: readonly ["pen", "eraser", "comment"];
+export type Cursor = (typeof defaultCursors)[number] | string;
+export type CursorName = (typeof defaultCursors)[number] | (typeof customCursors)[number];
+export type CursorsMap = Partial<Record<CursorName, Cursor>>;

package/dist/types/Pointer/Pointer.d.ts

@@ -0,0 +1,15 @@
+import { Point } from 'Items';
+import { Subject } from 'Subject';
+import { CursorsMap, CursorName, Cursor } from './Cursor';
+export declare const cursorsMap: CursorsMap;
+export declare class Pointer {
+    readonly point: Point;
+    readonly subject: Subject<Pointer>;
+    previous: Point;
+    delta: Point;
+    private cursor;
+    setCursor(cursor: CursorName): void;
+    getCursor(): Cursor;
+    pointTo(x: number, y: number): void;
+    moveBy(x: number, y: number): void;
+}