microboard-temp 0.1.1 → 0.1.3

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

@@ -0,0 +1,3 @@
+export { Pointer } from "./Pointer";
+export { defaultCursors as cursors } from "./Cursor";
+export type { Cursor } from "./Cursor";

package/dist/types/Presence/Events.d.ts

@@ -0,0 +1,84 @@
+import { PresenceUser } from "./Presence";
+export interface PointerMoveEvent {
+    method: "PointerMove";
+    position: {
+        x: number;
+        y: number;
+    };
+    timestamp: number;
+}
+export interface SelectionEvent {
+    method: "Selection";
+    selectedItems: string[];
+    timestamp: number;
+}
+export interface SetUserColorEvent {
+    method: "SetUserColor";
+    timestamp: number;
+    color: string;
+}
+export interface DrawSelectEvent {
+    method: "DrawSelect";
+    timestamp: number;
+    size: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    };
+}
+export interface CancelDrawSelectEvent {
+    method: "CancelDrawSelect";
+    timestamp: number;
+}
+export interface CameraEvent {
+    method: "Camera";
+    timestamp: number;
+    translateX: number;
+    translateY: number;
+    scaleX: number;
+    scaleY: number;
+    shearX: number;
+    shearY: number;
+}
+export interface PresencePingEvent {
+    method: "Ping";
+    timestamp: number;
+}
+export interface BringToMeEvent {
+    method: "BringToMe";
+    timestamp: number;
+    users: (number | string)[];
+}
+export interface StopFollowingEvent {
+    method: "StopFollowing";
+    timestamp: number;
+    users: (number | string)[];
+}
+export interface FollowEvent {
+    method: "Follow";
+    timestamp: number;
+    user: number | string;
+}
+export interface PresenceUserSnapshot {
+}
+export type PresenceEventType = PointerMoveEvent | SelectionEvent | SetUserColorEvent | DrawSelectEvent | CancelDrawSelectEvent | CameraEvent | PresencePingEvent | BringToMeEvent | StopFollowingEvent | FollowEvent;
+export interface UserJoinMsg {
+    type: "UserJoin";
+    timestamp: number;
+    userId: number;
+    boardId: string;
+    snapshots: Record<string, PresenceUser>;
+}
+export interface PresenceEventMsg<T = PresenceEventType> {
+    type: "PresenceEvent";
+    boardId: string;
+    event: T;
+    userId: string;
+    softId: string | null;
+    hardId: string | null;
+    messageId: string;
+    nickname: string;
+    color: string | null;
+    avatar: string | null;
+}

package/dist/types/Presence/Presence.d.ts

@@ -0,0 +1,123 @@
+import { Board } from 'Board';
+import { Events } from 'Events';
+import { Item } from 'Items';
+import { DrawingContext } from 'Items/DrawingContext';
+import { Subject } from 'Subject';
+import { PresenceEventType, PresenceEventMsg, UserJoinMsg, PointerMoveEvent, SelectionEvent, SetUserColorEvent, DrawSelectEvent, CancelDrawSelectEvent, CameraEvent, PresencePingEvent, BringToMeEvent, StopFollowingEvent, FollowEvent } from './Events';
+export declare const PRESENCE_CURSOR_THROTTLE: number;
+export declare const CURSORS_ANIMATION_DURATION: number;
+export declare const PRESENCE_CLEANUP_USER_TIMER = 180000;
+export declare const PRESENCE_CLEANUP_IDLE_TIMER = 60000;
+export declare const CURSORS_IDLE_CLEANUP_DELAY = 10000;
+interface Cursor {
+    x: number;
+    y: number;
+}
+export interface PresenceUser {
+    nickname: string;
+    userId: string;
+    softId: string | null;
+    hardId: string | null;
+    color: string;
+    colorChangeable: boolean;
+    lastActivity: number;
+    lastPointerActivity: number;
+    lastPing: number;
+    boardId: string;
+    selection: string[];
+    pointer: Cursor;
+    avatar: string | null;
+    select?: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    };
+    camera: {
+        translateX: number;
+        translateY: number;
+        scaleX: number;
+        scaleY: number;
+        shearX: number;
+        shearY: number;
+    } | null;
+}
+export declare class Presence {
+    readonly subject: Subject<Presence>;
+    events: Events | undefined;
+    readonly board: Board;
+    trackedUser: PresenceUser | null;
+    private cursorsEnabled;
+    private drawingContext;
+    private currentUserId;
+    users: Map<string, PresenceUser>;
+    followers: string[];
+    private svgImageCache;
+    private cursorPositionHistory;
+    private previousCursorPositions;
+    private isPointerRendering;
+    private pointerAnimationId;
+    constructor(board: Board);
+    clear(): void;
+    throttledEmit: (event: PresenceEventType) => void;
+    private sendCameraPresence;
+    private sendSelectionEvent;
+    getIsDisableTrackingNeeded(): boolean;
+    setCurrentUser(userId: string): void;
+    private updateCurrentUser;
+    cleanup(): void;
+    setupUpdateInterval(): void;
+    addEvents(events: Events): void;
+    emit(event: PresenceEventType): void;
+    push(messages: PresenceEventMsg | PresenceEventMsg[]): void;
+    ping(): void;
+    join(msg: UserJoinMsg): void;
+    getUsers(boardId: string, excludeSelf?: boolean): PresenceUser[];
+    getColors(): string[];
+    processMessage(event: PresenceEventMsg): void;
+    private updateUserMetaInfo;
+    processFollowEvent(msg: PresenceEventMsg<FollowEvent>): void;
+    processBringToMe(msg: PresenceEventMsg<BringToMeEvent>): void;
+    processStopFollowing(msg: PresenceEventMsg<StopFollowingEvent>): void;
+    processPing(msg: PresenceEventMsg<PresencePingEvent>): void;
+    processCameraEvent(msg: PresenceEventMsg<CameraEvent>): void;
+    processDrawSelect(msg: PresenceEventMsg<DrawSelectEvent>): void;
+    processCancelDrawSelect(msg: PresenceEventMsg<CancelDrawSelectEvent>): void;
+    processPointerMove(msg: PresenceEventMsg<PointerMoveEvent>): void;
+    processSelection(msg: PresenceEventMsg<SelectionEvent>): void;
+    processSetColor(msg: PresenceEventMsg<SetUserColorEvent>): void;
+    enableTracking(userId: string): void;
+    disableTracking(): void;
+    getFollowers(): PresenceUser[];
+    toggleCursorsRendering(): boolean;
+    getSelects(): {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+        color: string;
+        nickname: string;
+    }[];
+    getCursors(): {
+        x: number;
+        y: number;
+        color: string;
+        nickname: string;
+        userId: string;
+    }[];
+    getSelections(): {
+        selection: Item[];
+        color: string;
+    }[];
+    generateUserColor(shouldEmit?: boolean): string;
+    private getCursorSvg;
+    private renderItemMbr;
+    private saveImageCache;
+    private renderPointer;
+    private stopPointerRendering;
+    private renderCursorWithLabel;
+    private renderSelection;
+    private renderSelect;
+    render(context: DrawingContext): void;
+}
+export {};

package/dist/types/Presence/consts.d.ts

@@ -0,0 +1 @@
+export declare const PRESENCE_COLORS: string[];

package/dist/types/Presence/helpers.d.ts

@@ -0,0 +1,17 @@
+export declare const catmullRomInterpolate: (point0: {
+    x: number;
+    y: number;
+}, point1: {
+    x: number;
+    y: number;
+}, point2: {
+    x: number;
+    y: number;
+}, point3: {
+    x: number;
+    y: number;
+}, time: number) => {
+    x: number;
+    y: number;
+};
+export declare const rgbToRgba: (rgb: string, opacity: number) => string;

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

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

package/dist/types/Presence/throttle.d.ts

@@ -0,0 +1,2 @@
+export declare function throttle<T extends (...args: any[]) => unknown>(func: T, delay: number): (...args: Parameters<T>) => void;
+export declare function throttleWithDebounce<T extends (...args: Parameters<T>) => void>(fn: T, throttleDelay: number, debounceDelay: number): T;

package/dist/types/ReversibleOps.d.ts

@@ -0,0 +1,145 @@
+import { Operation as SlateOperation } from "slate";
+/**
+ * Базовый аргумент операции.
+ *
+ * @typeparam T - Тип данных для прямого и обратного действия операции.
+ */
+interface OperationArgument<T> {
+    /** Уникальный идентификатор элемента, к которому применяется операция. */
+    itemId: string;
+    /** Данные для прямого действия операции. */
+    forward: T;
+    /** Данные для обратного действия операции. */
+    reverse: T;
+}
+/**
+ * Базовый интерфейс для всех операций.
+ *
+ * @typeparam T - Тип данных для аргументов операции.
+ */
+interface Operation<T> {
+    /** Тип операции. */
+    type: string;
+    /** Массив аргументов операции. */
+    arguments: OperationArgument<T>[];
+}
+/**
+ * Операция трансформации элемента.
+ *
+ * @remarks
+ * Матрица в этой операции является афинной матрицей трансформации, состоящей из шести элементов.
+ * Порядок элементов в матрицы: [a, b, c, d, e, f], где:
+ * - a: Горизонтальное масштабирование (Horizontal scaling)
+ * - b: Горизонтальный наклон (Horizontal skew)
+ * - c: Вертикальный наклон (Vertical skew)
+ * - d: Вертикальное масштабирование (Vertical scaling)
+ * - e: Горизонтальное смещение (Horizontal translation)
+ * - f: Вертикальное смещение (Vertical translation)
+ *
+ * Этот порядок соответствует порядку, используемому в API WebCanvas.
+ *
+ * Важно отметить, что эта матрица не является финальной матрицей трансформации элемента.
+ * Она должна быть применена к предыдущей матрице трансформации элемента для получения
+ * итогового результата.
+ */
+interface TransformOperation extends Operation<{
+    matrix: number[];
+}> {
+    type: "Transform";
+}
+interface EditTextOperation extends Operation<{
+    slateOperations: SlateOperation[];
+}> {
+    type: "EditText";
+}
+interface SetFillPropertiesOperation extends Operation<{
+    color?: string;
+    opacity?: number;
+}> {
+    type: "SetFillProperties";
+}
+interface SetBorderPropertiesOperation extends Operation<{
+    color?: string;
+    opacity?: number;
+    width?: number;
+    style?: string;
+}> {
+    type: "SetBorderProperties";
+}
+interface SetConnectorPointOperation extends Operation<{
+    pointType: "start" | "end";
+    itemId: string;
+    position: {
+        x: number;
+        y: number;
+    };
+}> {
+    type: "SetConnectorPoint";
+}
+interface SetAspectRatioConstraintOperation extends Operation<{
+    constrained: boolean;
+}> {
+    type: "SetAspectRatioConstraint";
+}
+interface AddChildOperation extends Operation<{
+    parentId: string;
+    childId: string;
+}> {
+    type: "AddChild";
+}
+interface RemoveChildOperation extends Operation<{
+    parentId: string;
+    childId: string;
+}> {
+    type: "RemoveChild";
+}
+interface SetLockOperation extends Operation<{
+    locked: boolean;
+}> {
+    type: "SetLock";
+}
+/**
+ * Операция для изменения Z-индекса элемента.
+ *
+ * @remarks
+ * Новый Z-индекс (newIndex) применяется относительно массива дочерних элементов
+ * текущего родителя этого элемента. Если newIndex выходит за пределы допустимого
+ * диапазона (например, больше, чем количество элементов у родителя), то элемент
+ * будет помещен в конец списка дочерних элементов. Если newIndex отрицательный,
+ * элемент будет помещен в начало списка.
+ *
+ * Эта операция не изменяет родителя элемента. Если элемент был перемещен
+ * в другую группу или фрейм после применения этой операции, новый Z-индекс
+ * будет интерпретирован в контексте нового родителя при повторном применении операции.
+ */
+interface SetZIndexOperation extends Operation<{
+    newIndex: number;
+}> {
+    type: "SetZIndex";
+}
+interface SetShapeTypeOperation extends Operation<{
+    shapeType: string;
+}> {
+    type: "SetShapeType";
+}
+interface SetLineStyleOperation extends Operation<{
+    lineStyle: string;
+}> {
+    type: "SetLineStyle";
+}
+interface SetPointerStyleOperation extends Operation<{
+    pointerType: "start" | "end";
+    style: string;
+}> {
+    type: "SetPointerStyle";
+}
+interface AddItemOperation extends Operation<{
+    itemData: any;
+}> {
+    type: "AddItem";
+}
+interface RemoveItemOperation extends Operation<{}> {
+    type: "RemoveItem";
+}
+export type ReversibleOp = TransformOperation | EditTextOperation | SetFillPropertiesOperation | SetBorderPropertiesOperation | SetConnectorPointOperation | SetAspectRatioConstraintOperation | AddChildOperation | RemoveChildOperation | SetLockOperation | SetZIndexOperation | SetShapeTypeOperation | SetLineStyleOperation | SetPointerStyleOperation | AddItemOperation | RemoveItemOperation;
+export {};

package/dist/types/Selection/ConnectorTransformer/ConnectorTransformer.d.ts

@@ -0,0 +1,26 @@
+import { Board } from 'Board';
+import { DrawingContext } from 'Items/DrawingContext';
+import { SelectionItems } from 'Selection/SelectionItems';
+import { Tool } from 'Tools/Tool';
+export declare class ConnectorTransformer extends Tool {
+    private board;
+    private selection;
+    private startPointerAnchor;
+    private endPointerAnchor;
+    private middlePointerAnchor;
+    private statePointer;
+    private state;
+    private snap;
+    private connector;
+    beginTimeStamp: number;
+    constructor(board: Board, selection: Selection);
+    handleSelectionUpdate(items: SelectionItems): void;
+    private getConnector;
+    leftButtonDown(): boolean;
+    leftButtonUp(): boolean;
+    pointerMoveBy(_x: number, _y: number): boolean;
+    render(context: DrawingContext): void;
+    private updateConnectorPoints;
+    private isHoveringAnchor;
+    private calculateAnchors;
+}

package/dist/types/Selection/ConnectorTransformer/index.d.ts

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

package/dist/types/Selection/QuickAddButtons/QuickAddButtons.d.ts

@@ -0,0 +1,19 @@
+import { Board } from 'Board';
+import { Item, ConnectorData, Point } from 'Items';
+import { DrawingContext } from 'Items/DrawingContext';
+export interface QuickAddButtons {
+    clear: () => void;
+    render: (context: DrawingContext) => void;
+}
+export interface QuickAddItems {
+    newItem: Item;
+    connectorData: ConnectorData;
+    connectorStartPoint: Point;
+    connectorEndPoint: Point;
+    placeholderItem?: Item;
+}
+export interface HTMLQuickAddButton extends HTMLButtonElement {
+    isMouseDown: boolean;
+    resetState: () => void;
+}
+export declare function getQuickAddButtons(selection: Selection, board: Board): QuickAddButtons;

package/dist/types/Selection/QuickAddButtons/index.d.ts

@@ -0,0 +1,3 @@
+export type { QuickAddButtons, QuickAddItems } from './QuickAddButtons';
+export { getQuickAddButtons } from './QuickAddButtons';
+export { quickAddItem, getControlPointData } from './quickAddHelpers';

package/dist/types/Selection/QuickAddButtons/quickAddHelpers.d.ts

@@ -0,0 +1,10 @@
+import { Board } from 'Board';
+import { Item, Connector, RichText } from 'Items';
+import { AINode } from 'Items/AINode';
+import { ControlPointData } from 'Items/Connector/ControlPoint';
+import { ShapeType } from 'Items/Shape';
+/** index represents the number of connection - left, right, top, bottom */
+export declare function getControlPointData(item: Item, index: number, isRichText?: boolean): ControlPointData;
+export declare function quickAddItem(board: Board, type: ShapeType | 'AINode' | 'Sticker' | 'RichText', connector: Connector): void;
+export declare function createAINode(board: Board, parentNodeId: string, directionIndex: number): AINode;
+export declare function createRichText(board: Board): RichText;

package/dist/types/Selection/Selection.d.ts

@@ -0,0 +1,151 @@
+import { Board } from "Board";
+import { Events } from "Events";
+import { Item, RichText, Mbr, ItemData } from "Items";
+import { AINode } from "Items/AINode";
+import { HorisontalAlignment, VerticalAlignment } from "Items/Alignment";
+import { ConnectorLineStyle } from "Items/Connector";
+import { ConnectorPointerStyle } from "Items/Connector/Pointers/Pointers";
+import { DrawingContext } from "Items/DrawingContext";
+import { FrameType } from "Items/Frame/Basic";
+import { BorderStyle } from "Items/Path";
+import { TextStyle } from "Items/RichText";
+import { ShapeType } from "Items/Shape";
+import { TransformManyItems } from "Items/Transformation/TransformationOperations";
+import { Subject } from "Subject";
+import { Tool } from "Tools/Tool";
+import { QuickAddButtons } from "./QuickAddButtons";
+import { SelectionItems } from "./SelectionItems";
+import { BaseSelection, BaseRange } from "slate";
+export type SelectionContext = "SelectUnderPointer" | "HoverUnderPointer" | "EditUnderPointer" | "EditTextUnderPointer" | "SelectByRect" | "None";
+type SelectionSnapshot = {
+    selectedItems: string;
+    context: SelectionContext;
+    focus: {
+        selection: BaseSelection;
+        textToEdit: string;
+    } | null;
+};
+export declare class Selection {
+    private board;
+    events?: Events | undefined;
+    readonly subject: Subject<Selection>;
+    readonly itemSubject: Subject<Item>;
+    readonly itemsSubject: Subject<Item[]>;
+    isOn: boolean;
+    private context;
+    readonly items: SelectionItems;
+    shouldPublish: boolean;
+    readonly tool: Tool;
+    textToEdit: RichText | undefined;
+    transformationRenderBlock?: boolean;
+    shouldRenderItemsMbr: boolean;
+    quickAddButtons: QuickAddButtons;
+    showQuickAddPanel: boolean;
+    memorySnapshot: SelectionSnapshot | null;
+    constructor(board: Board, events?: Events | undefined);
+    serialize(): string;
+    deserialize(serializedData: string): void;
+    private getEditingFocus;
+    memoize(): SelectionSnapshot;
+    applyMemoized(): SelectionSnapshot | null;
+    applyMemoizedCaretOrRange(): void;
+    private emit;
+    private emitApplied;
+    private emitCommand;
+    updateQueue: Set<() => void>;
+    decorateObserverToScheduleUpdate<T extends (...args: any[]) => void>(observer: T): T;
+    updateScheduledObservers: () => void;
+    private itemObserver;
+    decoratedItemObserver: (item: Item) => void;
+    add(value: Item | Item[]): void;
+    addAll(): void;
+    remove(value: Item | Item[]): void;
+    removeAll(): void;
+    getContext(): SelectionContext;
+    timeoutID: NodeJS.Timeout | null;
+    on: () => void;
+    off: () => void;
+    disable(): void;
+    setContext(context: SelectionContext): void;
+    getMbr(): Mbr | undefined;
+    selectUnderPointer(): void;
+    editSelected(): void;
+    editText(shouldReplace?: string, moveCursorToEnd?: boolean, shouldSelect?: boolean): void;
+    editUnderPointer(): void;
+    setTextToEdit(item: Item | undefined): void;
+    editTextUnderPointer(): void;
+    selectEnclosedBy(rect: Mbr): void;
+    selectEnclosedOrCrossedBy(rect: Mbr): void;
+    list(): Item[];
+    canChangeText(): boolean;
+    private handleItemCopy;
+    copy(skipImageBlobCopy?: boolean): {
+        [key: string]: ItemData;
+    } | {
+        imageElement: HTMLImageElement;
+        imageData: {
+            [key: string]: ItemData;
+        };
+    };
+    cut(): {
+        [key: string]: ItemData;
+    };
+    getText(biggestFontSize?: boolean): RichText | null;
+    isTextEmpty(): boolean;
+    getAutosize(): boolean;
+    getFontSize(biggest?: boolean): number;
+    getFontHighlight(): string;
+    getFontColor(): string;
+    getFillColor(): string;
+    getBorderStyle(): string;
+    getStrokeColor(): string;
+    getStrokeWidth(): number;
+    getConnectorLineWidth(): number;
+    getConnectorLineColor(): string;
+    getStartPointerStyle(): ConnectorPointerStyle;
+    getEndPointerStyle(): ConnectorPointerStyle;
+    setStartPointerStyle(style: ConnectorPointerStyle): void;
+    setEndPointerStyle(style: ConnectorPointerStyle): void;
+    switchPointers(): void;
+    setConnectorLineStyle(style: ConnectorLineStyle): void;
+    getConnectorLineStyle(): string;
+    getTextToEdit(): RichText | undefined;
+    nestSelectedItems(unselectedItem?: Item | null, checkFrames?: boolean): void;
+    /** Emits transformManyItems */
+    transformMany(items: TransformManyItems, timeStamp?: number): void;
+    /** transforms selected items with frames' children */
+    getManyItemsTranslation(x: number, y: number, unselectedItem?: Item): TransformManyItems;
+    setStrokeStyle(borderStyle: BorderStyle): void;
+    setStrokeColor(borderColor: string): void;
+    setStrokeWidth(width: number): void;
+    setFillColor(backgroundColor: string): void;
+    setCanChangeRatio(canChangeRatio: boolean): void;
+    getCanChangeRatio(): boolean;
+    setFrameType(frameType: FrameType): void;
+    getFrameType(): FrameType;
+    setShapeType(shapeType: ShapeType): void;
+    setFontSize(size: number | "auto"): void;
+    setFontStyle(fontStyle: TextStyle): void;
+    setFontColor(fontColor: string): void;
+    setHyperLink(link: string | undefined, selection: BaseRange | null): void;
+    setFontHighlight(fontHighlight: string): void;
+    setHorisontalAlignment(horisontalAlignment: HorisontalAlignment): void;
+    setVerticalAlignment(verticalAlignment: VerticalAlignment): void;
+    getMediaStorageIds(): string[];
+    removeFromBoard(): void;
+    getIsLockedSelection(): boolean;
+    isLocked(): boolean;
+    lock(): void;
+    unlock(): void;
+    bringToFront(): void;
+    sendToBack(): void;
+    duplicate(): Promise<void>;
+    getMostNestedAINodeWithParents(): {
+        node: AINode;
+        parents: AINode[];
+        lastAssistantMessageId: string | undefined;
+    } | null;
+    renderItemMbr(context: DrawingContext, item: Item, customScale?: number): void;
+    render(context: DrawingContext): void;
+}
+export {};

package/dist/types/Selection/SelectionItems.d.ts

@@ -0,0 +1,25 @@
+import { Item, ItemType, Mbr } from 'Items';
+export declare class SelectionItems {
+    private items;
+    add(value: Item | Item[]): void;
+    remove(value: Item | Item[]): void;
+    removeAll(): void;
+    findById(itemId: string): Item | null;
+    list(): Item[];
+    isEmpty(): boolean;
+    isSingle(): boolean;
+    values(): IterableIterator<Item>;
+    getSize(): number;
+    isTexts(): boolean;
+    isAllItemsType(itemType: ItemType): boolean;
+    isItemTypes(itemTypes: ItemType[]): boolean;
+    getItemTypes(): ItemType[];
+    getItemsByItemTypes<T extends ItemType>(itemTypes: T[]): Extract<Item, {
+        itemType: T;
+    }>[];
+    getIdsByItemTypes(itemTypes: string[]): string[];
+    getSingle(): Item | null;
+    listByIds(itemIdList: string[]): Item[];
+    ids(): string[];
+    getMbr(): Mbr | undefined;
+}

package/dist/types/Selection/SelectionTransformer.d.ts

@@ -0,0 +1,30 @@
+import { Board } from 'Board';
+import { DrawingContext } from 'Items/DrawingContext';
+import { Tool } from 'Tools/Tool';
+import { ConnectorTransformer } from './ConnectorTransformer';
+import { SelectionItems } from './SelectionItems';
+import { Transformer } from './Transformer';
+export declare class SelectionTransformer extends Tool {
+    private board;
+    private selection;
+    private readonly defaultTransformerTool;
+    private readonly connectorTransformerTool;
+    private tool;
+    constructor(board: Board, selection: Selection);
+    handleSelectionUpdate(items: SelectionItems): void;
+    updateTool(): void;
+    getTool(): Transformer | ConnectorTransformer;
+    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;
+    render(context: DrawingContext): void;
+}

package/dist/types/Selection/Transformer/TextTransformer/getTextResizeType.d.ts

@@ -0,0 +1,8 @@
+import { Point, Mbr } from "Items";
+import { ResizeType } from "../TransformerHelpers/getResizeType.ts";
+/**
+ * A funciton to get the resize type of a text item.
+ * A text item does not have top and bottom anchors.
+ * Unlike other items its top and bottom anchors are split into left and right parts.
+ */
+export declare function getTextResizeType(cursorPoint: Point, cameraScale: number, mbr?: Mbr, anchorDistance?: number): ResizeType | undefined;

package/dist/types/Selection/Transformer/TextTransformer/index.d.ts

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