@zsviczian/excalidraw 0.16.1-obsidian-4 → 0.16.1-obsidian-6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zsviczian/excalidraw",
-  "version": "0.16.1-obsidian-4",
+  "version": "0.16.1-obsidian-6",
   "main": "main.js",
   "types": "types/packages/excalidraw/index.d.ts",
   "files": [

package/types/actions/actionCanvas.d.ts

@@ -56,12 +56,6 @@ export declare const actionClearCanvas: {
             pinnedScripts: string[] | undefined;
             customPens: any[] | undefined;
             name: string;
-            toast: {
-                message: string;
-                closable?: boolean | undefined;
-                duration?: number | undefined;
-            } | null;
-            collaborators: Map<string, import("../types").Collaborator>;
             contextMenu: {
                 items: import("../components/ContextMenu").ContextMenuItems;
                 top: number;
@@ -134,6 +128,11 @@ export declare const actionClearCanvas: {
             };
             selectedElementsAreBeingDragged: boolean;
             shouldCacheIgnoreZoom: boolean;
+            toast: {
+                message: string;
+                closable?: boolean | undefined;
+                duration?: number | undefined;
+            } | null;
             zenModeEnabled: boolean;
             previousGridSize: number | null;
             viewModeEnabled: boolean;
@@ -142,6 +141,7 @@ export declare const actionClearCanvas: {
             };
             editingGroupId: string | null;
             fileHandle: import("browser-fs-access").FileSystemHandle | null;
+            collaborators: Map<string, import("../types").Collaborator>;
             currentChartType: import("../element/types").ChartType;
             pendingImageElementId: string | null;
             showHyperlinkPopup: false | "editor" | "info";

package/types/actions/actionClipboard.d.ts

@@ -367,6 +367,7 @@ export declare const actionCut: {
             multiElement: null;
             activeEmbeddable: null;
             selectedElementIds: {};
+            selectedGroupIds: {};
             contextMenu: {
                 items: import("../components/ContextMenu").ContextMenuItems;
                 top: number;
@@ -446,9 +447,6 @@ export declare const actionCut: {
             gridSize: number | null;
             previousGridSize: number | null;
             viewModeEnabled: boolean;
-            selectedGroupIds: {
-                [groupId: string]: boolean;
-            };
             editingGroupId: string | null;
             width: number;
             height: number;

package/types/actions/actionDeleteSelected.d.ts

@@ -343,6 +343,7 @@ export declare const actionDeleteSelected: {
             multiElement: null;
             activeEmbeddable: null;
             selectedElementIds: {};
+            selectedGroupIds: {};
             contextMenu: {
                 items: import("../components/ContextMenu").ContextMenuItems;
                 top: number;
@@ -422,9 +423,6 @@ export declare const actionDeleteSelected: {
             gridSize: number | null;
             previousGridSize: number | null;
             viewModeEnabled: boolean;
-            selectedGroupIds: {
-                [groupId: string]: boolean;
-            };
             editingGroupId: string | null;
             width: number;
             height: number;

package/types/actions/actionExport.d.ts

@@ -802,7 +802,11 @@ export declare const actionSaveFileToDisk: {
     perform: (elements: readonly import("../element/types").ExcalidrawElement[], appState: Readonly<import("../types").AppState>, value: any, app: import("../types").AppClassProperties) => Promise<{
         commitToHistory: false;
         appState: {
+            openDialog: null;
             fileHandle: import("browser-fs-access").FileSystemHandle | null;
+            toast: {
+                message: string;
+            };
             contextMenu: {
                 items: import("../components/ContextMenu").ContextMenuItems;
                 top: number;
@@ -873,7 +877,6 @@ export declare const actionSaveFileToDisk: {
                 name: string;
                 tab?: string | undefined;
             } | null;
-            openDialog: "imageExport" | "help" | "jsonExport" | null;
             defaultSidebarDockedPreference: boolean;
             lastPointerDownWith: import("../element/types").PointerType;
             selectedElementIds: Readonly<{
@@ -884,11 +887,6 @@ export declare const actionSaveFileToDisk: {
             };
             selectedElementsAreBeingDragged: boolean;
             shouldCacheIgnoreZoom: boolean;
-            toast: {
-                message: string;
-                closable?: boolean | undefined;
-                duration?: number | undefined;
-            } | null;
             zenModeEnabled: boolean;
             theme: Theme;
             gridSize: number | null;
@@ -970,13 +968,6 @@ export declare const actionLoadScene: {
                 locked: boolean;
             } & import("../types").ActiveTool;
             name: string;
-            toast: {
-                message: string;
-                closable?: boolean | undefined;
-                duration?: number | undefined;
-            } | null;
-            collaborators: Map<string, import("../types").Collaborator>;
-            penMode: boolean;
             contextMenu: {
                 items: import("../components/ContextMenu").ContextMenuItems;
                 top: number;
@@ -1007,6 +998,7 @@ export declare const actionLoadScene: {
             elementsToHighlight: import("../element/types").NonDeleted<import("../element/types").ExcalidrawElement>[] | null;
             editingElement: import("../element/types").NonDeletedExcalidrawElement | null;
             editingLinearElement: import("../element/linearElementEditor").LinearElementEditor | null;
+            penMode: boolean;
             penDetected: boolean;
             exportBackground: boolean;
             exportEmbedScene: boolean;
@@ -1052,6 +1044,11 @@ export declare const actionLoadScene: {
             };
             selectedElementsAreBeingDragged: boolean;
             shouldCacheIgnoreZoom: boolean;
+            toast: {
+                message: string;
+                closable?: boolean | undefined;
+                duration?: number | undefined;
+            } | null;
             zenModeEnabled: boolean;
             theme: Theme;
             gridSize: number | null;
@@ -1062,6 +1059,7 @@ export declare const actionLoadScene: {
             };
             editingGroupId: string | null;
             fileHandle: import("browser-fs-access").FileSystemHandle | null;
+            collaborators: Map<string, import("../types").Collaborator>;
             showStats: boolean;
             currentChartType: import("../element/types").ChartType;
             pasteDialog: {

package/types/actions/actionProperties.d.ts

@@ -1,7 +1,7 @@
-import { AppState } from "../../src/types";
+import { AppState, Primitive } from "../../src/types";
 import { Arrowhead, ExcalidrawElement, ExcalidrawLinearElement } from "../element/types";
 export declare const changeProperty: (elements: readonly ExcalidrawElement[], appState: AppState, callback: (element: ExcalidrawElement) => ExcalidrawElement, includeBoundText?: boolean) => ExcalidrawElement[];
-export declare const getFormValue: <T>(elements: readonly ExcalidrawElement[], appState: AppState, getAttribute: (element: ExcalidrawElement) => T, defaultValue: T) => T;
+export declare const getFormValue: <T extends Primitive>(elements: readonly ExcalidrawElement[], appState: AppState, getAttribute: (element: ExcalidrawElement) => T, isRelevantElement: true | ((element: ExcalidrawElement) => boolean), defaultValue: T | ((isSomeElementSelected: boolean) => T)) => T;
 export declare const actionChangeStrokeColor: {
     name: "changeStrokeColor";
     trackEvent: false;

package/types/appState.d.ts

@@ -6,8 +6,8 @@ export declare const clearAppStateForLocalStorage: (appState: Partial<AppState>)
         locked: boolean;
     } & import("./types").ActiveTool) | undefined;
     name?: string | undefined;
-    penMode?: boolean | undefined;
     showWelcomeScreen?: boolean | undefined;
+    penMode?: boolean | undefined;
     penDetected?: boolean | undefined;
     exportBackground?: boolean | undefined;
     exportEmbedScene?: boolean | undefined;

package/types/clipboard.d.ts

@@ -1,11 +1,16 @@
 import { ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
 import { BinaryFiles } from "./types";
 import { Spreadsheet } from "./charts";
+export type PastedMixedContent = {
+    type: "text" | "imageUrl";
+    value: string;
+}[];
 export interface ClipboardData {
     spreadsheet?: Spreadsheet;
     elements?: readonly ExcalidrawElement[];
     files?: BinaryFiles;
     text?: string;
+    mixedContent?: PastedMixedContent;
     errorMessage?: string;
     programmaticAPI?: boolean;
 }
@@ -13,11 +18,6 @@ export declare const probablySupportsClipboardReadText: boolean;
 export declare const probablySupportsClipboardWriteText: boolean;
 export declare const probablySupportsClipboardBlob: boolean;
 export declare const copyToClipboard: (elements: readonly NonDeletedExcalidrawElement[], files: BinaryFiles | null) => Promise<string | undefined>;
-/**
- * Retrieves content from system clipboard (either from ClipboardEvent or
- *  via async clipboard API if supported)
- */
-export declare const getSystemClipboard: (event: ClipboardEvent | null) => Promise<string>;
 /**
  * Attempts to parse clipboard. Prefers system clipboard.
  */

package/types/components/Actions.d.ts

@@ -1,5 +1,5 @@
 import { ActionManager } from "../actions/manager";
-import { ExcalidrawElement, PointerType } from "../element/types";
+import { ExcalidrawElement } from "../element/types";
 import { AppClassProperties, UIAppState, Zoom } from "../types";
 import "./Actions.scss";
 export declare const SelectedShapeActions: ({ appState, elements, renderAction, }: {
@@ -7,12 +7,8 @@ export declare const SelectedShapeActions: ({ appState, elements, renderAction,
     elements: readonly ExcalidrawElement[];
     renderAction: ActionManager["renderAction"];
 }) => import("react/jsx-runtime").JSX.Element;
-export declare const ShapesSwitcher: ({ interactiveCanvas, activeTool, onImageAction, appState, app, }: {
-    interactiveCanvas: HTMLCanvasElement | null;
+export declare const ShapesSwitcher: ({ activeTool, appState, app, }: {
     activeTool: UIAppState["activeTool"];
-    onImageAction: (data: {
-        pointerType: PointerType | null;
-    }) => void;
     appState: UIAppState;
     app: AppClassProperties;
 }) => import("react/jsx-runtime").JSX.Element;

package/types/components/App.d.ts

@@ -3,13 +3,14 @@ import { RoughCanvas } from "roughjs/bin/canvas";
 import { ActionManager } from "../actions/manager";
 import { EXPORT_IMAGE_TYPES } from "../constants";
 import { LinearElementEditor } from "../element/linearElementEditor";
-import { ExcalidrawElement, ExcalidrawLinearElement, NonDeletedExcalidrawElement } from "../element/types";
+import { ExcalidrawElement, ExcalidrawLinearElement, NonDeleted, NonDeletedExcalidrawElement } from "../element/types";
 import History from "../history";
 import Scene from "../scene/Scene";
 import { AppClassProperties, AppProps, AppState, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, SceneData, Device, FrameNameBoundsCache, SidebarName, SidebarTabName, ToolType } from "../types";
 import { FileSystemHandle } from "../data/filesystem";
 import { Renderer } from "../scene/Renderer";
 import { LaserPathManager } from "./LaserTool/LaserPathManager";
+import { Emitter } from "../emitter";
 export declare let showFourthFont: boolean;
 export declare const ExcalidrawContainerContext: React.Context<{
     container: HTMLDivElement | null;
@@ -64,6 +65,147 @@ declare class App extends React.Component<AppProps, AppState> {
     };
     allowMobileMode: boolean;
     laserPathManager: LaserPathManager;
+    onChangeEmitter: Emitter<[elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles]>;
+    onPointerDownEmitter: Emitter<[activeTool: {
+        lastActiveTool: import("../types").ActiveTool | null;
+        locked: boolean;
+    } & import("../types").ActiveTool, pointerDownState: Readonly<{
+        origin: Readonly<{
+            x: number;
+            y: number;
+        }>;
+        originInGrid: Readonly<{
+            x: number;
+            y: number;
+        }>;
+        scrollbars: {
+            isOverEither: boolean;
+            isOverHorizontal: boolean;
+            isOverVertical: boolean;
+        };
+        lastCoords: {
+            x: number;
+            y: number;
+        };
+        originalElements: Map<string, NonDeleted<ExcalidrawElement>>;
+        resize: {
+            handleType: import("../element/transformHandles").MaybeTransformHandleType;
+            isResizing: boolean;
+            offset: {
+                x: number;
+                y: number;
+            };
+            arrowDirection: "end" | "origin";
+            center: {
+                x: number;
+                y: number;
+            };
+        };
+        hit: {
+            element: NonDeleted<ExcalidrawElement> | null;
+            allHitElements: NonDeleted<ExcalidrawElement>[];
+            wasAddedToSelection: boolean;
+            hasBeenDuplicated: boolean;
+            hasHitCommonBoundingBoxOfSelectedElements: boolean;
+        };
+        withCmdOrCtrl: boolean;
+        drag: {
+            hasOccurred: boolean;
+            offset: {
+                x: number;
+                y: number;
+            } | null;
+        };
+        eventListeners: {
+            onMove: {
+                (...args: any[]): void;
+                flush(): void;
+                cancel(): void;
+            } | null;
+            onUp: ((event: PointerEvent) => void) | null;
+            onKeyDown: ((event: KeyboardEvent) => void) | null;
+            onKeyUp: ((event: KeyboardEvent) => void) | null;
+        };
+        boxSelection: {
+            hasOccurred: boolean;
+        };
+        elementIdsToErase: {
+            [key: string]: {
+                opacity: number;
+                erase: boolean;
+            };
+        };
+    }>, event: React.PointerEvent<HTMLElement>]>;
+    onPointerUpEmitter: Emitter<[activeTool: {
+        lastActiveTool: import("../types").ActiveTool | null;
+        locked: boolean;
+    } & import("../types").ActiveTool, pointerDownState: Readonly<{
+        origin: Readonly<{
+            x: number;
+            y: number;
+        }>;
+        originInGrid: Readonly<{
+            x: number;
+            y: number;
+        }>;
+        scrollbars: {
+            isOverEither: boolean;
+            isOverHorizontal: boolean;
+            isOverVertical: boolean;
+        };
+        lastCoords: {
+            x: number;
+            y: number;
+        };
+        originalElements: Map<string, NonDeleted<ExcalidrawElement>>;
+        resize: {
+            handleType: import("../element/transformHandles").MaybeTransformHandleType;
+            isResizing: boolean;
+            offset: {
+                x: number;
+                y: number;
+            };
+            arrowDirection: "end" | "origin";
+            center: {
+                x: number;
+                y: number;
+            };
+        };
+        hit: {
+            element: NonDeleted<ExcalidrawElement> | null;
+            allHitElements: NonDeleted<ExcalidrawElement>[];
+            wasAddedToSelection: boolean;
+            hasBeenDuplicated: boolean;
+            hasHitCommonBoundingBoxOfSelectedElements: boolean;
+        };
+        withCmdOrCtrl: boolean;
+        drag: {
+            hasOccurred: boolean;
+            offset: {
+                x: number;
+                y: number;
+            } | null;
+        };
+        eventListeners: {
+            onMove: {
+                (...args: any[]): void;
+                flush(): void;
+                cancel(): void;
+            } | null;
+            onUp: ((event: PointerEvent) => void) | null;
+            onKeyDown: ((event: KeyboardEvent) => void) | null;
+            onKeyUp: ((event: KeyboardEvent) => void) | null;
+        };
+        boxSelection: {
+            hasOccurred: boolean;
+        };
+        elementIdsToErase: {
+            [key: string]: {
+                opacity: number;
+                erase: boolean;
+            };
+        };
+    }>, event: PointerEvent]>;
     constructor(props: AppProps);
     private onWindowMessage;
     private updateEmbeddableRef;
@@ -120,6 +262,7 @@ declare class App extends React.Component<AppProps, AppState> {
         retainSeed?: boolean;
         fitToContent?: boolean;
     }) => void;
+    private addElementsFromMixedContentPaste;
     private addTextFromPaste;
     setAppState: React.Component<any, AppState>["setState"];
     removePointer: (event: React.PointerEvent<HTMLElement> | PointerEvent) => void;
@@ -192,11 +335,16 @@ declare class App extends React.Component<AppProps, AppState> {
     private onKeyDown;
     private onWheel;
     private onKeyUp;
-    setActiveTool: (tool: {
-        type: ToolType;
+    setActiveTool: (tool: (({
+        type: Exclude<ToolType, "image">;
     } | {
+        type: Extract<ToolType, "image">;
+        insertOnCanvasDirectly?: boolean;
+    }) | {
         type: "custom";
         customType: string;
+    }) & {
+        locked?: boolean;
     }) => void;
     private setCursor;
     private resetCursor;

package/types/components/LayerUI.d.ts

@@ -10,7 +10,6 @@ interface LayerUIProps {
     appState: UIAppState;
     files: BinaryFiles;
     canvas: HTMLCanvasElement;
-    interactiveCanvas: HTMLCanvasElement | null;
     setAppState: React.Component<any, AppState>["setState"];
     elements: readonly NonDeletedExcalidrawElement[];
     onLockToggle: () => void;
@@ -21,14 +20,11 @@ interface LayerUIProps {
     renderTopRightUI?: ExcalidrawProps["renderTopRightUI"];
     renderCustomStats?: ExcalidrawProps["renderCustomStats"];
     UIOptions: AppProps["UIOptions"];
-    onImageAction: (data: {
-        insertOnCanvasDirectly: boolean;
-    }) => void;
     onExportImage: AppClassProperties["onExportImage"];
     renderWelcomeScreen: boolean;
     children?: React.ReactNode;
     app: AppClassProperties;
     isCollaborating: boolean;
 }
-declare const _default: React.MemoExoticComponent<({ actionManager, appState, files, setAppState, elements, canvas, interactiveCanvas, onLockToggle, onHandToolToggle, onPenModeToggle, showExitZenModeBtn, renderTopRightUI, renderCustomStats, UIOptions, onImageAction, onExportImage, renderWelcomeScreen, children, app, isCollaborating, }: LayerUIProps) => import("react/jsx-runtime").JSX.Element>;
+declare const _default: React.MemoExoticComponent<({ actionManager, appState, files, setAppState, elements, canvas, onLockToggle, onHandToolToggle, onPenModeToggle, showExitZenModeBtn, renderTopRightUI, renderCustomStats, UIOptions, onExportImage, renderWelcomeScreen, children, app, isCollaborating, }: LayerUIProps) => import("react/jsx-runtime").JSX.Element>;
 export default _default;

package/types/components/MobileMenu.d.ts

@@ -12,10 +12,6 @@ type MobileMenuProps = {
     onLockToggle: () => void;
     onHandToolToggle: () => void;
     onPenModeToggle: () => void;
-    interactiveCanvas: HTMLCanvasElement | null;
-    onImageAction: (data: {
-        insertOnCanvasDirectly: boolean;
-    }) => void;
     renderTopRightUI?: (isMobile: boolean, appState: UIAppState) => JSX.Element | null;
     renderCustomStats?: ExcalidrawProps["renderCustomStats"];
     renderSidebars: () => JSX.Element | null;
@@ -23,5 +19,5 @@ type MobileMenuProps = {
     renderWelcomeScreen: boolean;
     app: AppClassProperties;
 };
-export declare const MobileMenu: ({ appState, elements, actionManager, setAppState, onLockToggle, onHandToolToggle, onPenModeToggle, interactiveCanvas, onImageAction, renderTopRightUI, renderCustomStats, renderSidebars, device, renderWelcomeScreen, app, }: MobileMenuProps) => import("react/jsx-runtime").JSX.Element;
+export declare const MobileMenu: ({ appState, elements, actionManager, setAppState, onLockToggle, onHandToolToggle, onPenModeToggle, renderTopRightUI, renderCustomStats, renderSidebars, device, renderWelcomeScreen, app, }: MobileMenuProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/types/constants.d.ts

@@ -217,6 +217,16 @@ export declare const PRECEDING_ELEMENT_KEY = "__precedingElement__";
 export declare const COLOR_NAMES: {
     [key: string]: string;
 };
+export declare const ROUGHNESS: {
+    readonly architect: 0;
+    readonly artist: 1;
+    readonly cartoonist: 2;
+};
+export declare const STROKE_WIDTH: {
+    readonly thin: 1;
+    readonly bold: 2;
+    readonly extraBold: 4;
+};
 export declare const DEFAULT_ELEMENT_PROPS: {
     strokeColor: ExcalidrawElement["strokeColor"];
     backgroundColor: ExcalidrawElement["backgroundColor"];

package/types/cursor.d.ts

@@ -0,0 +1,5 @@
+import { AppState } from "./types";
+export declare const resetCursor: (interactiveCanvas: HTMLCanvasElement | null) => void;
+export declare const setCursor: (interactiveCanvas: HTMLCanvasElement | null, cursor: string) => void;
+export declare const setEraserCursor: (interactiveCanvas: HTMLCanvasElement | null, theme: AppState["theme"]) => void;
+export declare const setCursorForShape: (interactiveCanvas: HTMLCanvasElement | null, appState: Pick<AppState, "activeTool" | "theme">) => void;

package/types/data/blob.d.ts

@@ -21,7 +21,7 @@ export declare const loadSceneOrLibraryFromBlob: (blob: Blob | File, localAppSta
 export declare const loadFromBlob: (blob: Blob, localAppState: AppState | null, localElements: readonly ExcalidrawElement[] | null, fileHandle?: FileSystemHandle | null) => Promise<import("./restore").RestoredDataState>;
 export declare const parseLibraryJSON: (json: string, defaultStatus?: LibraryItem["status"]) => LibraryItem[];
 export declare const loadLibraryFromBlob: (blob: Blob, defaultStatus?: LibraryItem["status"]) => Promise<LibraryItem[]>;
-export declare const canvasToBlob: (canvas: HTMLCanvasElement) => Promise<Blob>;
+export declare const canvasToBlob: (canvas: HTMLCanvasElement | Promise<HTMLCanvasElement>) => Promise<Blob>;
 /** generates SHA-1 digest from supplied file (if not supported, falls back
     to a 40-char base64 random id) */
 export declare const generateIdFromFile: (file: File) => Promise<FileId>;
@@ -35,6 +35,7 @@ export declare const resizeImageFile: (file: File, opts: {
 export declare const SVGStringToFile: (SVGString: string, filename?: string) => File & {
     type: typeof MIME_TYPES.svg;
 };
+export declare const ImageURLToFile: (imageUrl: string, filename?: string) => Promise<File | undefined>;
 export declare const getFileFromEvent: (event: React.DragEvent<HTMLDivElement>) => Promise<{
     file: File | null;
     fileHandle: FileSystemHandle | null;

package/types/element/mutateElement.d.ts

@@ -8,5 +8,5 @@ export declare const newElementWith: <TElement extends ExcalidrawElement>(elemen
  *
  * NOTE: does not trigger re-render.
  */
-export declare const bumpVersion: (element: Mutable<ExcalidrawElement>, version?: ExcalidrawElement["version"]) => Mutable<ExcalidrawElement>;
+export declare const bumpVersion: <T extends Mutable<ExcalidrawElement>>(element: T, version?: ExcalidrawElement["version"]) => T;
 export {};

package/types/emitter.d.ts

@@ -0,0 +1,20 @@
+type Subscriber<T extends any[]> = (...payload: T) => void;
+export declare class Emitter<T extends any[] = []> {
+    subscribers: Subscriber<T>[];
+    value: T | undefined;
+    private updateOnChangeOnly;
+    constructor(opts?: {
+        initialState?: T;
+        updateOnChangeOnly?: boolean;
+    });
+    /**
+     * Attaches subscriber
+     *
+     * @returns unsubscribe function
+     */
+    on(...handlers: Subscriber<T>[] | Subscriber<T>[][]): () => void;
+    off(...handlers: Subscriber<T>[] | Subscriber<T>[][]): void;
+    trigger(...payload: T): any[];
+    destroy(): void;
+}
+export {};

package/types/frame.d.ts

@@ -21,6 +21,11 @@ export declare const getFrameElements: (allElements: ExcalidrawElementsIncluding
 export declare const getElementsInResizingFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
 export declare const getElementsInNewFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement) => ExcalidrawElement[];
 export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap?: Map<string, ExcalidrawElement>) => ExcalidrawFrameElement | null;
+/**
+ * Retains (or repairs for target frame) the ordering invriant where children
+ * elements come right before the parent frame:
+ * [el, el, child, child, frame, el]
+ */
 export declare const addElementsToFrame: (allElements: ExcalidrawElementsIncludingDeleted, elementsToAdd: NonDeletedExcalidrawElement[], frame: ExcalidrawFrameElement) => ExcalidrawElement[];
 export declare const removeElementsFromFrame: (allElements: ExcalidrawElementsIncludingDeleted, elementsToRemove: NonDeletedExcalidrawElement[], appState: AppState) => ExcalidrawElement[];
 export declare const removeAllElementsFromFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];

package/types/scene/comparisons.d.ts

@@ -4,7 +4,6 @@ export declare const hasStrokeColor: (type: string) => boolean;
 export declare const hasStrokeWidth: (type: string) => boolean;
 export declare const hasStrokeStyle: (type: string) => boolean;
 export declare const canChangeRoundness: (type: string) => boolean;
-export declare const hasText: (type: string) => boolean;
 export declare const canHaveArrowheads: (type: string) => boolean;
 export declare const getElementAtPosition: (elements: readonly NonDeletedExcalidrawElement[], isAtPositionFn: (element: NonDeletedExcalidrawElement) => boolean) => NonDeletedExcalidrawElement | null;
 export declare const getElementsAtPosition: (elements: readonly NonDeletedExcalidrawElement[], isAtPositionFn: (element: NonDeletedExcalidrawElement) => boolean) => NonDeletedExcalidrawElement[];

package/types/scene/index.d.ts

@@ -1,5 +1,5 @@
 export { isOverScrollBars } from "./scrollbars";
 export { isSomeElementSelected, getElementsWithinSelection, getCommonAttributeOfSelectedElements, getSelectedElements, getTargetElements, } from "./selection";
 export { calculateScrollCenter } from "./scroll";
-export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, getElementAtPosition, hasText, getElementsAtPosition, } from "./comparisons";
+export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, getElementAtPosition, getElementsAtPosition, } from "./comparisons";
 export { getNormalizedZoom } from "./zoom";

package/types/types.d.ts

@@ -498,6 +498,7 @@ export type PointerDownState = Readonly<{
         };
     };
 }>;
+type UnsubscribeCallback = () => void;
 export type ExcalidrawImperativeAPI = {
     updateScene: InstanceType<typeof App>["updateScene"];
     updateLibrary: InstanceType<typeof Library>["updateLibrary"];
@@ -537,6 +538,9 @@ export type ExcalidrawImperativeAPI = {
      * used in conjunction with view mode (props.viewModeEnabled).
      */
     updateFrameRendering: InstanceType<typeof App>["updateFrameRendering"];
+    onChange: (callback: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles) => void) => UnsubscribeCallback;
+    onPointerDown: (callback: (activeTool: AppState["activeTool"], pointerDownState: PointerDownState, event: React.PointerEvent<HTMLElement>) => void) => UnsubscribeCallback;
+    onPointerUp: (callback: (activeTool: AppState["activeTool"], pointerDownState: PointerDownState, event: PointerEvent) => void) => UnsubscribeCallback;
 };
 export type Device = Readonly<{
     isSmScreen: boolean;
@@ -565,4 +569,5 @@ export type KeyboardModifiersObject = {
     altKey: boolean;
     metaKey: boolean;
 };
+export type Primitive = number | string | boolean | bigint | symbol | null | undefined;
 export {};

package/types/utils.d.ts

@@ -79,18 +79,16 @@ export declare const chunk: <T extends unknown>(array: readonly T[], size: numbe
 export declare const selectNode: (node: Element) => void;
 export declare const removeSelection: () => void;
 export declare const distance: (x: number, y: number) => number;
-export declare const updateActiveTool: (appState: Pick<AppState, "activeTool">, data: ({
+export declare const updateActiveTool: (appState: Pick<AppState, "activeTool">, data: (({
     type: ToolType;
 } | {
     type: "custom";
     customType: string;
+}) & {
+    locked?: boolean;
 }) & {
     lastActiveToolBeforeEraser?: ActiveTool | null;
 }) => AppState["activeTool"];
-export declare const resetCursor: (interactiveCanvas: HTMLCanvasElement | null) => void;
-export declare const setCursor: (interactiveCanvas: HTMLCanvasElement | null, cursor: string) => void;
-export declare const setEraserCursor: (interactiveCanvas: HTMLCanvasElement | null, theme: AppState["theme"]) => void;
-export declare const setCursorForShape: (interactiveCanvas: HTMLCanvasElement | null, appState: Pick<AppState, "activeTool" | "theme">) => void;
 export declare const isFullScreen: () => boolean;
 export declare const allowFullScreen: () => Promise<void>;
 export declare const exitFullScreen: () => Promise<void>;