microboard-temp 0.13.41 → 0.13.43

package/dist/types/Settings.d.ts

@@ -1,30 +1,35 @@
 import { Path2DFactory } from "./api/Path2DFactory";
+import type { Board } from "./Board";
 import { BrowserDocumentFactory } from "./api/BrowserDocumentFactory";
 import { BrowserPath2D } from "./api/BrowserPath2DFactory";
 import { MockDocumentFactory } from "./api/MockDocumentFactory";
 import { MockPath2D } from "./api/MockPath2D";
+import { TFunction } from "i18next";
 import type { BorderStyle } from "./Items/Path/Path";
 import type { Theme, ColorValue } from "./Color/ColorValue";
 export type { Theme, ColorValue };
+import type { PresenceEventType } from "./Presence/Events";
+import type { SocketMsg } from "./Events/MessageRouter/boardMessageInterface";
+import type { Editor, BasePoint } from "slate";
 export interface Connection {
     connectionId: number;
     getCurrentUser: () => string;
     connect(): Promise<void>;
-    subscribe(board: any): void;
-    unsubscribe(board: any): void;
-    publishPresenceEvent(boardId: string, event: any): void;
+    subscribe(board: Board): void;
+    unsubscribe(board: Board): void;
+    publishPresenceEvent(boardId: string, event: PresenceEventType): void;
     publishAuth(): Promise<void>;
     publishLogout(): void;
-    onMessage?: (msg: any) => void;
+    onMessage?: (msg: SocketMsg) => void;
     onAccessDenied: (boardId: string, forceUpdate?: boolean) => void;
     notifyAboutLostConnection: () => void;
     dismissNotificationAboutLostConnection: () => void;
     resetConnection: () => void;
-    send: (msg: any) => void;
+    send: (msg: SocketMsg) => void;
 }
 export interface I18NextInterface {
-    t: (key: string, options?: any) => string;
-    changeLanguage: (lng: string, callback?: (err: any, t: any) => void) => Promise<any>;
+    t: (key: string, options?: Record<string, unknown>) => string;
+    changeLanguage: (lng: string, callback?: (err: Error | null, t: TFunction) => void) => Promise<TFunction>;
 }
 export interface NotifyFunction {
     (options: {
@@ -110,8 +115,8 @@ type GetYouTubeIdFunction = (url?: string) => string | null;
 type GetDOMParser = () => {
     parseFromString: (str: string, type: DOMParserSupportedType) => Document;
 };
-type ReactEditorFocus = (editor: any) => void;
-type ReactEditorToSlatePoint = (editor: any, domNode: Node, offset: number, options: any) => any;
+type ReactEditorFocus = (editor: Editor) => void;
+type ReactEditorToSlatePoint = (editor: Editor, domNode: Node, offset: number, options?: Record<string, unknown>) => BasePoint | null;
 /**
  * Set properties before using the board.
  * @property {Path2DFactory} - The factory for creating Path2D objects.
@@ -125,9 +130,9 @@ export declare const conf: {
     measureCtx: CanvasRenderingContext2D;
     i18n: import("i18next").i18n;
     hooks: {
-        beforeMediaUpload: (...args: any[]) => Promise<boolean>;
-        beforeMediaRemove: (...args: any[]) => Promise<boolean>;
-        onUploadMediaError: (...args: any[]) => Promise<boolean>;
+        beforeMediaUpload: (...args: unknown[]) => Promise<boolean>;
+        beforeMediaRemove: (...args: unknown[]) => Promise<boolean>;
+        onUploadMediaError: (...args: unknown[]) => Promise<boolean>;
     };
     getAccessToken: GetAccessTokenFunction;
     openModal: OpenModalFunction;

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

@@ -1,6 +1,6 @@
 import { Mbr } from '../../Items/Mbr/Mbr';
 import type { Point } from '../../Items/Point/Point';
-import type { Item } from '../../Items/Item';
+import type { Item, ItemDataWithId } from '../../Items/Item';
 import { Layers } from './Layers';
 import { RTreeIndex } from '../RTreeIndex';
 export declare class Container {
@@ -20,13 +20,12 @@ export declare class LayeredIndex<T extends Item> {
     layers: Layers<RTreeIndex>;
     constructor(getZIndex: (item: T) => number);
     private isT;
-    findById(id: string): Item | undefined;
-    getEnclosed(rect: Mbr): Item[];
-    getEnclosedOrCrossedBy(rect: Mbr): Item[];
-    getUnderPoint(point: Point, tolerance?: number): Item[];
-    getRectsEnclosedOrCrossedBy(rect: Mbr): T[];
+    listEnclosedBy(rect: Mbr): Item[];
+    listEnclosedOrCrossedBy(rect: Mbr): Item[];
+    listUnderPoint(point: Point, tolerance?: number): Item[];
+    listRectsEnclosedOrCrossedBy(rect: Mbr): T[];
     isAnyEnclosedOrCrossedBy(rect: Mbr): boolean;
-    getNearestTo(point: Point, maxItems: number, filter: (item: Item) => boolean, maxDistance: number): Item[];
+    listNearestTo(point: Point, maxItems: number, filter: (item: Item) => boolean, maxDistance: number): Item[];
     private getContainersFromItems;
     insertContainer(container: Container): void;
     shiftContainerAbove(container: Container, layer: number): void;
@@ -35,7 +34,12 @@ export declare class LayeredIndex<T extends Item> {
     change(item: T): void;
     remove(item: Item): void;
     get(id: string): T | undefined;
-    list(): T[];
+    listAll(): T[];
+    getById(id: string): Item | undefined;
+    findById(id: string): Item | undefined;
+    getByZIndex(index: number): Item;
+    getLastZIndex(): number;
+    copy(): ItemDataWithId[];
     batchInsert(items: T[]): void;
     batchChange(items: T[]): void;
 }

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

@@ -1,6 +1,6 @@
 import RBush, { BBox } from 'rbush';
 import { Point, Mbr } from '../../Items';
-import { Item } from '../../Items';
+import type { Item, ItemDataWithId } from '../../Items/Item';
 import { Container } from '../LayeredIndex';
 declare class Tree extends RBush<Container> {
     toBBox(container: Container): BBox;
@@ -14,13 +14,18 @@ export declare class RTreeIndex {
     change(container: Container): void;
     get(id: string): Item | undefined;
     remove(id: string): void;
-    list(): Item[];
-    getEnclosed(rect: Mbr): Item[];
-    getEnclosedOrCrossedBy(rect: Mbr): Item[];
-    getUnderPoint(point: Point, tolerance?: number): Item[];
-    getRectsEnclosedOrCrossedBy(rect: Mbr): Item[];
+    listAll(): Item[];
+    listEnclosedBy(rect: Mbr): Item[];
+    listEnclosedOrCrossedBy(rect: Mbr): Item[];
+    listUnderPoint(point: Point, tolerance?: number): Item[];
+    listRectsEnclosedOrCrossedBy(rect: Mbr): Item[];
     isAnyEnclosedOrCrossedBy(rect: Mbr): boolean;
-    getNearestTo(point: Point, maxItems: number, filter: (item: Item) => boolean, maxDistance: number): Item[];
+    listNearestTo(point: Point, maxItems: number, filter: (item: Item) => boolean, maxDistance: number): Item[];
+    getById(id: string): Item | undefined;
+    findById(id: string): Item | undefined;
+    getByZIndex(index: number): Item;
+    getLastZIndex(): number;
+    copy(): ItemDataWithId[];
     batchInsert(batch: Container[]): void;
     batchChange(batch: Container[]): void;
 }

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

@@ -1,12 +1,13 @@
 import { Subject } from "../Subject";
-import { DrawingContext, Item, Point, Mbr } from "../Items";
+import { DrawingContext } from "../Items/DrawingContext";
+import { Item, ItemDataWithId } from "../Items/Item";
+import { Point } from "../Items/Point/Point";
+import { Mbr } from "../Items/Mbr/Mbr";
 import { Camera } from "../Camera";
 import { Pointer } from "../Pointer";
-import { BaseItem } from "../Items/BaseItem";
-import { ItemDataWithId } from "../Items/Item";
 import { ItemsIndexRecord } from "../BoardOperations";
-import { Items } from "./SpacialIndex";
-export declare class SimpleSpatialIndex {
+import { Items, ISpatialIndex } from "./SpacialIndex";
+export declare class SimpleSpatialIndex implements ISpatialIndex {
     subject: Subject<Items>;
     private itemsArray;
     private Mbr;
@@ -25,13 +26,30 @@ export declare class SimpleSpatialIndex {
     bringManyToFront(items: Item[]): void;
     moveSecondAfterFirst(first: Item, second: Item): void;
     moveSecondBeforeFirst(first: Item, second: Item): void;
-    getById(id: string): BaseItem | undefined;
+    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[];
+    listEnclosedBy(left: number | Mbr | {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }, top?: number, right?: number, bottom?: number): Item[];
+    listEnclosedOrCrossedBy(left: number | Mbr | {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }, top?: number, right?: number, bottom?: number): Item[];
+    listUnderPoint(point: Point, tolerance?: number): Item[];
+    listRectsEnclosedOrCrossedBy(left: number | Mbr | {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }, top?: number, right?: number, bottom?: number): Mbr[];
+    listNearestTo(point: Point, maxItems: number, filter: (item: Item) => boolean, maxDistance: number): Item[];
     getMbr(): Mbr;
-    list(): Item[];
+    listAll(): Item[];
     getZIndex(item: Item): number;
     getLastZIndex(): number;
     getByZIndex(index: number): Item;

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

@@ -1,13 +1,62 @@
 import { DocumentFactory } from '../api/DocumentFactory';
 import { ItemsIndexRecord } from '../BoardOperations';
 import { Camera } from '../Camera';
-import { Item, Mbr, Point, Connector, Comment } from '../Items';
+import type { Item } from "../Items/Item";
+import { Mbr } from "../Items/Mbr/Mbr";
+import { Point } from "../Items/Point/Point";
+import type { Connector } from "../Items/Connector/Connector";
+import type { Comment } from "../Items/Comment/Comment";
+import type { FrameType } from "../Items/Frame/Basic";
 import { DrawingContext } from '../Items/DrawingContext';
 import { Pointer } from '../Pointer';
 import { Subject } from '../Subject';
 import { BaseItem } from "../Items/BaseItem";
 import { ItemDataWithId } from "../Items/Item";
-export declare class SpatialIndex {
+export declare function coerceMbr(left: number | Mbr | {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}, top?: number, right?: number, bottom?: number): Mbr;
+export interface ISpatialIndex {
+    change(item: Item): void;
+    listAll(): Item[];
+    listUnderPoint(point: Point | {
+        x: number;
+        y: number;
+    }, tolerance?: number): Item[];
+    listEnclosedOrCrossedBy(rect: Mbr | {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    } | number, top?: number, right?: number, bottom?: number): Item[];
+    listEnclosedBy(rect: Mbr | {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    } | number, top?: number, right?: number, bottom?: number): Item[];
+    getZIndex(item: Item): number;
+    getById(id: string): Item | undefined;
+    findById(id: string): Item | undefined;
+    insert(item: Item): void;
+    remove(item: Item, preserveChildren?: boolean): void;
+    change(item: Item): void;
+    clear(): void;
+    getMbr(): Mbr;
+    listRectsEnclosedOrCrossedBy(rect: Mbr | {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    } | number, top?: number, right?: number, bottom?: number): Mbr[];
+    listNearestTo(point: Point, maxItems: number, filter: (item: Item) => boolean, maxDistance: number): Item[];
+    getByZIndex(index: number): Item;
+    getLastZIndex(): number;
+    copy(): ItemDataWithId[];
+}
+export declare class SpatialIndex implements ISpatialIndex {
     subject: Subject<Items>;
     private itemsArray;
     private itemsIndex;
@@ -33,27 +82,55 @@ export declare class SpatialIndex {
     moveSecondBeforeFirst(first: Item, second: Item): void;
     getById(id: string): BaseItem | 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, tolerance?: number): Item[];
-    getRectsEnclosedOrCrossed(left: number, top: number, right: number, bottom: number): Item[];
-    getItemsEnclosedOrCrossed(left: number, top: number, right: number, bottom: number): Item[];
+    listEnclosedBy(left: number | Mbr | {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }, top?: number, right?: number, bottom?: number): Item[];
+    listEnclosedOrCrossedBy(left: number | Mbr | {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }, top?: number, right?: number, bottom?: number): Item[];
+    listRectsEnclosedOrCrossedBy(left: number | Mbr | {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }, top?: number, right?: number, bottom?: number): Mbr[];
+    listUnderPoint(point: Point, tolerance?: number): Item[];
+    listNearestTo(point: Point, maxItems: number, filter: (item: Item) => boolean, maxDistance: number): Item[];
     getComments(): Comment[];
     getMbr(): Mbr;
     getNearestTo(point: Point, maxItems: number, filter: (item: Item) => boolean, maxDistance: number): Item[];
-    list(): Item[];
+    listAll(): Item[];
     getZIndex(item: Item): number;
     getLastZIndex(): number;
     getByZIndex(index: number): Item;
 }
 export declare class Items {
-    index: SpatialIndex;
+    index: ISpatialIndex;
     private view;
     private pointer;
     readonly subject: Subject<Items>;
-    constructor(index: SpatialIndex, view: Camera, pointer: Pointer, subject: Subject<Items>);
+    constructor(index: ISpatialIndex, view: Camera, pointer: Pointer, subject: Subject<Items>);
     update(item: Item): void;
     listAll(): Item[];
+    listUnderPoint(point: Point, tolerance?: number): Item[];
+    listEnclosedBy(left: number | Mbr | {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }, top?: number, right?: number, bottom?: number): Item[];
+    listEnclosedOrCrossedBy(left: number | Mbr | {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }, top?: number, right?: number, bottom?: number): Item[];
     listGroupItems(): BaseItem[];
     getById(id: string): BaseItem | undefined;
     findById(id: string): Item | undefined;
@@ -74,6 +151,8 @@ export declare class Items {
     getLastZIndex(): number;
     getLinkedConnectorsById(id: string): Connector[];
     getConnectorsByItemIds(startPointerItemId?: string, endPointerItemId?: string): Connector[];
+    setFrameType(frameType: FrameType): void;
+    getFrameType(): FrameType;
     render(context: DrawingContext): void;
     renderHTML(documentFactory: DocumentFactory): string;
     getWholeHTML(documentFactory: DocumentFactory): string;

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

@@ -1,7 +1,7 @@
 import { Board } from '../../Board';
 import { Connector, Item, Point } from '../../Items';
 import { ConnectorLineStyle } from '../../Items/Connector';
-import { ConnectionLineWidth } from '../../Items/Connector/Connector';
+import { ConnectionLineWidth } from '../../Items/Connector/ConnectorTypes';
 import { ConnectorSnap } from '../../Items/Connector/ConnectorSnap';
 import { ConnectorPointerStyle } from '../../Items/Connector/Pointers/Pointers';
 import { DrawingContext } from '../../Items/DrawingContext';

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

@@ -19,7 +19,7 @@ export declare class CustomTool extends BoardTool {
     name: string;
     private itemClass;
     item: BaseItem;
-    constructor(board: Board, name: string, itemClass: typeof BaseItem);
+    constructor(board: Board, name: string, itemClass: any);
     resetItem(): void;
 }
 export declare class ShapeTool extends CustomTool {
@@ -28,7 +28,7 @@ export declare class ShapeTool extends CustomTool {
     resizeType: ResizeType;
     bounds: Mbr;
     isDown: boolean;
-    constructor(board: Board, name: string, item: typeof BaseItem, settings?: ShapeToolSettings | undefined);
+    constructor(board: Board, name: string, item: any, settings?: ShapeToolSettings | undefined);
     setCursor(): void;
     initTransformation(sx?: number, sy?: number): void;
     pointerDown(): boolean;
@@ -39,7 +39,7 @@ export declare class ShapeTool extends CustomTool {
 }
 export declare class StickerTool extends CustomTool {
     private settings;
-    constructor(board: Board, name: string, item: typeof BaseItem, settings: StickerToolSettings);
+    constructor(board: Board, name: string, item: any, settings: StickerToolSettings);
     setCursor(): void;
     pointerDown(): boolean;
     keyDown(key: string): boolean;

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

@@ -17,7 +17,8 @@ import { ToolContext } from "./ToolContext";
 import { Subject } from "../Subject";
 import { CustomTool } from "./CustomTool";
 import { Tool } from "./Tool";
-export declare const registeredTools: Record<string, typeof CustomTool>;
+export type CustomToolConstructor = new (board: Board, name: string, ...args: any[]) => CustomTool;
+export declare const registeredTools: Record<string, CustomToolConstructor>;
 export declare class Tools extends ToolContext {
     protected board: Board;
     readonly subject: Subject<Tools>;
@@ -26,7 +27,7 @@ export declare class Tools extends ToolContext {
     addRegisteredTool(toolName: string, clearSelection?: boolean): void;
     getAddRegisteredTool(toolName: string): Tool | undefined;
     setTool(tool: BoardTool): void;
-    switchMode(mode: any): void;
+    switchMode(mode: "navigate" | "select"): void;
     navigate(): void;
     getNavigate(): Navigate | undefined;
     select(clearSelection?: boolean): void;

package/dist/types/Validators/Validators.d.ts

@@ -1,5 +1,6 @@
 import { ItemData } from "../Items";
 export type ItemsMap = Record<string, ItemData>;
-export declare function validateItemsMap(parsedObject: any): parsedObject is ItemsMap;
-export declare const itemValidators: Record<string, (data: any) => boolean>;
-export declare function validateRichTextData(richTextData: any): boolean;
+export declare function validateItemsMap(parsedObject: unknown): parsedObject is ItemsMap;
+export type ItemValidator = (data: unknown) => boolean;
+export declare const itemValidators: Record<string, ItemValidator>;
+export declare function validateRichTextData(richTextData: unknown): boolean;

package/dist/types/api/MockPath2D.d.ts

@@ -5,7 +5,7 @@ import { Path2DFactory } from "./Path2DFactory";
  * All methods are stubbed and don't perform actual path operations.
  */
 export declare class MockPath2D implements Path2DFactory {
-    nativePath: any;
+    nativePath: unknown;
     private commands;
     constructor(d?: string);
     addPath(path: Path2DFactory, transform?: DOMMatrix2DInit): void;
@@ -25,7 +25,7 @@ export declare class MockPath2D implements Path2DFactory {
      */
     getCommands(): {
         method: string;
-        args: any[];
+        args: unknown[];
     }[];
     /**
      * Clear all recorded commands
@@ -37,7 +37,7 @@ export declare class MockPath2D implements Path2DFactory {
      * @param method - The method name to check
      * @param args - Optional arguments to verify
      */
-    wasCalledWith(method: string, args?: any[]): boolean;
+    wasCalledWith(method: string, args?: unknown[]): boolean;
     /**
      * Get the number of times a specific command was called
      * @param method - The method name to count

package/dist/types/api/Path2DFactory.d.ts

@@ -1,5 +1,5 @@
 export interface Path2DFactory {
-    nativePath: any;
+    nativePath: unknown;
     /**
      * Adds the given path to the current path, optionally applying a transformation.
      * @param path - The Path2D to add.

package/dist/types/itemFactories.d.ts

@@ -1,8 +1,34 @@
 import { Board } from "./Board";
-import { ItemData, Item } from "./Items";
+import type { RichTextData } from "./Items/RichText/RichTextData";
+import type { ItemData, Item } from "./Items/Item";
+import type { ShapeData } from "./Items/Shape/ShapeData";
+import type { ConnectorData } from "./Items/Connector/ConnectorOperations";
+import type { FrameData } from "./Items/Frame/FrameData";
+import { AINodeData } from "./Items/AINode";
+import { AudioItemData } from "./Items/Audio";
+import { DrawingData } from "./Items/Drawing";
+import { GroupData } from "./Items/Group";
+import { ImageItemData } from "./Items/Image";
+import { PlaceholderData } from "./Items/Placeholder";
+import { StickerData } from "./Items/Sticker/StickerOperation";
+import { VideoItemData } from "./Items/Video";
+import { CommentData } from "./Items/Comment";
 interface ItemFactory {
     (id: string, data: ItemData, board: Board): Item;
 }
 export type ItemFactories = Record<string, ItemFactory>;
 export declare const itemFactories: ItemFactories;
+export declare function isStickerData(data: ItemData): data is StickerData;
+export declare function isCommentData(data: ItemData): data is CommentData;
+export declare function isAINodeData(data: ItemData): data is AINodeData;
+export declare function isShapeData(data: ItemData): data is ShapeData;
+export declare function isRichTextData(data: ItemData): data is RichTextData;
+export declare function isConnectorData(data: ItemData): data is ConnectorData;
+export declare function isImageItemData(data: ItemData): data is ImageItemData;
+export declare function isVideoItemData(data: ItemData): data is VideoItemData;
+export declare function isAudioItemData(data: ItemData): data is AudioItemData;
+export declare function isDrawingData(data: ItemData): data is DrawingData;
+export declare function isFrameData(data: ItemData): data is FrameData;
+export declare function isPlaceholderData(data: ItemData): data is PlaceholderData;
+export declare function isGroupData(data: ItemData): data is GroupData;
 export {};

package/dist/types/parserHTML.d.ts

@@ -1,5 +1,4 @@
-import { ItemType } from "./Items";
-import { ItemDataWithId } from "./Items/Item";
+import { ItemType, ItemDataWithId } from "./Items/Item";
 import { BaseItemData } from "./Items/BaseItem/BaseItem";
 type MapTagByType = Record<ItemType, string>;
 export declare const tagByType: MapTagByType;

package/dist/types/sha256.d.ts

@@ -1,2 +1,2 @@
-export declare function sha256(message: any): Promise<string>;
+export declare function sha256(message: string): Promise<string>;
 export declare function fileTosha256(file: File): Promise<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "microboard-temp",
-  "version": "0.13.41",
+  "version": "0.13.43",
   "description": "A flexible interactive whiteboard library",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",