@excalidraw/excalidraw 0.16.1-ceb637f → 0.16.1-d1f8eec

package/types/actions/actionToggleStats.d.ts

@@ -38,15 +38,9 @@ export declare const actionToggleStats: {
             editingElement: import("../element/types").NonDeletedExcalidrawElement | null;
             editingLinearElement: import("../element/linearElementEditor").LinearElementEditor | null;
             activeTool: {
-                lastActiveTool: import("../types").LastActiveTool;
+                lastActiveTool: import("../types").ActiveTool | null;
                 locked: boolean;
-            } & ({
-                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "eraser" | "hand";
-                customType: null;
-            } | {
-                type: "custom";
-                customType: string;
-            });
+            } & import("../types").ActiveTool;
             penMode: boolean;
             penDetected: boolean;
             exportBackground: boolean;
@@ -124,7 +118,7 @@ export declare const actionToggleStats: {
             pendingImageElementId: string | null;
             showHyperlinkPopup: false | "editor" | "info";
             selectedLinearElement: import("../element/linearElementEditor").LinearElementEditor | null;
-            snapLines: import("../snapping").SnapLine[];
+            snapLines: readonly import("../snapping").SnapLine[];
             originSnapOffset: {
                 x: number;
                 y: number;
@@ -135,7 +129,7 @@ export declare const actionToggleStats: {
     };
     checked: (appState: Readonly<import("../types").AppState>) => boolean;
     contextItemLabel: string;
-    keyTest: (event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean;
+    keyTest: (event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean;
 } & {
-    keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
+    keyTest?: ((event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean) | undefined;
 };

package/types/actions/actionToggleViewMode.d.ts

@@ -39,15 +39,9 @@ export declare const actionToggleViewMode: {
             editingElement: import("../element/types").NonDeletedExcalidrawElement | null;
             editingLinearElement: import("../element/linearElementEditor").LinearElementEditor | null;
             activeTool: {
-                lastActiveTool: import("../types").LastActiveTool;
+                lastActiveTool: import("../types").ActiveTool | null;
                 locked: boolean;
-            } & ({
-                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "eraser" | "hand";
-                customType: null;
-            } | {
-                type: "custom";
-                customType: string;
-            });
+            } & import("../types").ActiveTool;
             penMode: boolean;
             penDetected: boolean;
             exportBackground: boolean;
@@ -125,7 +119,7 @@ export declare const actionToggleViewMode: {
             pendingImageElementId: string | null;
             showHyperlinkPopup: false | "editor" | "info";
             selectedLinearElement: import("../element/linearElementEditor").LinearElementEditor | null;
-            snapLines: import("../snapping").SnapLine[];
+            snapLines: readonly import("../snapping").SnapLine[];
             originSnapOffset: {
                 x: number;
                 y: number;
@@ -137,7 +131,7 @@ export declare const actionToggleViewMode: {
     checked: (appState: Readonly<import("../types").AppState>) => boolean;
     predicate: (elements: readonly import("../element/types").ExcalidrawElement[], appState: import("../types").AppState, appProps: import("../types").ExcalidrawProps) => boolean;
     contextItemLabel: string;
-    keyTest: (event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean;
+    keyTest: (event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean;
 } & {
-    keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
+    keyTest?: ((event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean) | undefined;
 };

package/types/actions/actionToggleZenMode.d.ts

@@ -39,15 +39,9 @@ export declare const actionToggleZenMode: {
             editingElement: import("../element/types").NonDeletedExcalidrawElement | null;
             editingLinearElement: import("../element/linearElementEditor").LinearElementEditor | null;
             activeTool: {
-                lastActiveTool: import("../types").LastActiveTool;
+                lastActiveTool: import("../types").ActiveTool | null;
                 locked: boolean;
-            } & ({
-                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "eraser" | "hand";
-                customType: null;
-            } | {
-                type: "custom";
-                customType: string;
-            });
+            } & import("../types").ActiveTool;
             penMode: boolean;
             penDetected: boolean;
             exportBackground: boolean;
@@ -125,7 +119,7 @@ export declare const actionToggleZenMode: {
             pendingImageElementId: string | null;
             showHyperlinkPopup: false | "editor" | "info";
             selectedLinearElement: import("../element/linearElementEditor").LinearElementEditor | null;
-            snapLines: import("../snapping").SnapLine[];
+            snapLines: readonly import("../snapping").SnapLine[];
             originSnapOffset: {
                 x: number;
                 y: number;
@@ -137,7 +131,7 @@ export declare const actionToggleZenMode: {
     checked: (appState: Readonly<import("../types").AppState>) => boolean;
     predicate: (elements: readonly import("../element/types").ExcalidrawElement[], appState: import("../types").AppState, appProps: import("../types").ExcalidrawProps) => boolean;
     contextItemLabel: string;
-    keyTest: (event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean;
+    keyTest: (event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean;
 } & {
-    keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
+    keyTest?: ((event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean) | undefined;
 };

package/types/actions/actionZindex.d.ts

@@ -11,10 +11,10 @@ export declare const actionSendBackward: {
     };
     contextItemLabel: string;
     keyPriority: number;
-    keyTest: (event: KeyboardEvent | React.KeyboardEvent<Element>) => boolean;
+    keyTest: (event: React.KeyboardEvent<Element> | KeyboardEvent) => boolean;
     PanelComponent: ({ updateData, appState }: import("./types").PanelComponentProps) => JSX.Element;
 } & {
-    keyTest?: ((event: KeyboardEvent | React.KeyboardEvent<Element>) => boolean) | undefined;
+    keyTest?: ((event: React.KeyboardEvent<Element> | KeyboardEvent) => boolean) | undefined;
 };
 export declare const actionBringForward: {
     name: "bringForward";
@@ -28,10 +28,10 @@ export declare const actionBringForward: {
     };
     contextItemLabel: string;
     keyPriority: number;
-    keyTest: (event: KeyboardEvent | React.KeyboardEvent<Element>) => boolean;
+    keyTest: (event: React.KeyboardEvent<Element> | KeyboardEvent) => boolean;
     PanelComponent: ({ updateData, appState }: import("./types").PanelComponentProps) => JSX.Element;
 } & {
-    keyTest?: ((event: KeyboardEvent | React.KeyboardEvent<Element>) => boolean) | undefined;
+    keyTest?: ((event: React.KeyboardEvent<Element> | KeyboardEvent) => boolean) | undefined;
 };
 export declare const actionSendToBack: {
     name: "sendToBack";
@@ -39,15 +39,15 @@ export declare const actionSendToBack: {
         category: "element";
     };
     perform: (elements: readonly import("../element/types").ExcalidrawElement[], appState: Readonly<import("../types").AppState>) => {
-        elements: import("../element/types").ExcalidrawElement[];
+        elements: readonly import("../element/types").ExcalidrawElement[] | import("../element/types").ExcalidrawElement[];
         appState: Readonly<import("../types").AppState>;
         commitToHistory: true;
     };
     contextItemLabel: string;
-    keyTest: (event: KeyboardEvent | React.KeyboardEvent<Element>) => boolean;
+    keyTest: (event: React.KeyboardEvent<Element> | KeyboardEvent) => boolean;
     PanelComponent: ({ updateData, appState }: import("./types").PanelComponentProps) => JSX.Element;
 } & {
-    keyTest?: ((event: KeyboardEvent | React.KeyboardEvent<Element>) => boolean) | undefined;
+    keyTest?: ((event: React.KeyboardEvent<Element> | KeyboardEvent) => boolean) | undefined;
 };
 export declare const actionBringToFront: {
     name: "bringToFront";
@@ -55,13 +55,13 @@ export declare const actionBringToFront: {
         category: "element";
     };
     perform: (elements: readonly import("../element/types").ExcalidrawElement[], appState: Readonly<import("../types").AppState>) => {
-        elements: import("../element/types").ExcalidrawElement[];
+        elements: readonly import("../element/types").ExcalidrawElement[] | import("../element/types").ExcalidrawElement[];
         appState: Readonly<import("../types").AppState>;
         commitToHistory: true;
     };
     contextItemLabel: string;
-    keyTest: (event: KeyboardEvent | React.KeyboardEvent<Element>) => boolean;
+    keyTest: (event: React.KeyboardEvent<Element> | KeyboardEvent) => boolean;
     PanelComponent: ({ updateData, appState }: import("./types").PanelComponentProps) => JSX.Element;
 } & {
-    keyTest?: ((event: KeyboardEvent | React.KeyboardEvent<Element>) => boolean) | undefined;
+    keyTest?: ((event: React.KeyboardEvent<Element> | KeyboardEvent) => boolean) | undefined;
 };

package/types/appState.d.ts

@@ -1,20 +1,13 @@
 import { AppState, NormalizedZoomValue } from "./types";
 export declare const getDefaultAppState: () => Omit<AppState, "offsetTop" | "offsetLeft" | "width" | "height">;
 export declare const clearAppStateForLocalStorage: (appState: Partial<AppState>) => {
-    theme?: import("./element/types").Theme | undefined;
-    name?: string | undefined;
     activeTool?: ({
-        lastActiveTool: import("./types").LastActiveTool;
+        lastActiveTool: import("./types").ActiveTool | null;
         locked: boolean;
-    } & ({
-        type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "eraser" | "hand";
-        customType: null;
-    } | {
-        type: "custom";
-        customType: string;
-    })) | undefined;
-    penMode?: boolean | undefined;
+    } & import("./types").ActiveTool) | undefined;
+    name?: string | undefined;
     showWelcomeScreen?: boolean | undefined;
+    penMode?: boolean | undefined;
     penDetected?: boolean | undefined;
     exportBackground?: boolean | undefined;
     exportEmbedScene?: boolean | undefined;
@@ -56,6 +49,7 @@ export declare const clearAppStateForLocalStorage: (appState: Partial<AppState>)
     } | undefined;
     shouldCacheIgnoreZoom?: boolean | undefined;
     zenModeEnabled?: boolean | undefined;
+    theme?: import("./element/types").Theme | undefined;
     gridSize?: number | null | undefined;
     selectedGroupIds?: {
         [groupId: string]: boolean;

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,21 +1,16 @@
-import React from "react";
 import { ActionManager } from "../actions/manager";
-import { ExcalidrawElement, PointerType } from "../element/types";
-import { UIAppState, Zoom } from "../types";
+import { ExcalidrawElement } from "../element/types";
+import { AppClassProperties, UIAppState, Zoom } from "../types";
 import "./Actions.scss";
 export declare const SelectedShapeActions: ({ appState, elements, renderAction, }: {
     appState: UIAppState;
     elements: readonly ExcalidrawElement[];
     renderAction: ActionManager["renderAction"];
 }) => JSX.Element;
-export declare const ShapesSwitcher: ({ interactiveCanvas, activeTool, setAppState, onImageAction, appState, }: {
-    interactiveCanvas: HTMLCanvasElement | null;
+export declare const ShapesSwitcher: ({ activeTool, appState, app, }: {
     activeTool: UIAppState["activeTool"];
-    setAppState: React.Component<any, UIAppState>["setState"];
-    onImageAction: (data: {
-        pointerType: PointerType | null;
-    }) => void;
     appState: UIAppState;
+    app: AppClassProperties;
 }) => JSX.Element;
 export declare const ZoomActions: ({ renderAction, zoom, }: {
     renderAction: ActionManager["renderAction"];

package/types/components/App.d.ts

@@ -3,12 +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, NonDeletedExcalidrawElement } from "../element/types";
+import { ExcalidrawElement, 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 } from "../types";
+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 const ExcalidrawContainerContext: React.Context<{
     container: HTMLDivElement | null;
     id: string | null;
@@ -54,12 +56,154 @@ declare class App extends React.Component<AppProps, AppState> {
     imageCache: AppClassProperties["imageCache"];
     private iFrameRefs;
     hitLinkElement?: NonDeletedExcalidrawElement;
-    lastPointerDown: React.PointerEvent<HTMLElement> | null;
-    lastPointerUp: React.PointerEvent<HTMLElement> | PointerEvent | null;
+    lastPointerDownEvent: React.PointerEvent<HTMLElement> | null;
+    lastPointerUpEvent: React.PointerEvent<HTMLElement> | PointerEvent | null;
     lastViewportPosition: {
         x: number;
         y: number;
     };
+    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;
@@ -107,6 +251,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private onTouchEnd;
     pasteFromClipboard: (event: ClipboardEvent | null) => Promise<void>;
     private addElementsFromPasteOrLibrary;
+    private addElementsFromMixedContentPaste;
     private addTextFromPaste;
     setAppState: React.Component<any, AppState>["setState"];
     removePointer: (event: React.PointerEvent<HTMLElement> | PointerEvent) => void;
@@ -117,7 +262,7 @@ declare class App extends React.Component<AppProps, AppState> {
         outline: boolean;
         clip: boolean;
     }> | ((prevState: AppState["frameRendering"]) => Partial<AppState["frameRendering"]>)) => void;
-    togglePenMode: () => void;
+    togglePenMode: (force?: boolean) => void;
     onHandToolToggle: () => void;
     /**
      * Zooms on canvas viewport center
@@ -169,7 +314,17 @@ declare class App extends React.Component<AppProps, AppState> {
     private onKeyDown;
     private onWheel;
     private onKeyUp;
-    private setActiveTool;
+    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/LaserTool/LaserPathManager.d.ts

@@ -0,0 +1,28 @@
+import { LaserPointer } from "@excalidraw/laser-pointer";
+import App from "../App";
+declare global {
+    interface Window {
+        LPM: LaserPathManager;
+    }
+}
+export declare class LaserPathManager {
+    private app;
+    private ownState;
+    private collaboratorsState;
+    private rafId;
+    private isDrawing;
+    private container;
+    constructor(app: App);
+    destroy(): void;
+    startPath(x: number, y: number): void;
+    addPointToPath(x: number, y: number): void;
+    endPath(): void;
+    private updatePath;
+    private isRunning;
+    start(svg?: SVGSVGElement): void;
+    stop(): void;
+    loop(): void;
+    draw(path: LaserPointer): string;
+    updateCollabolatorsState(): void;
+    update(): void;
+}

package/types/components/LaserTool/LaserPointerButton.d.ts

@@ -0,0 +1,10 @@
+import "../ToolIcon.scss";
+type LaserPointerIconProps = {
+    title?: string;
+    name?: string;
+    checked: boolean;
+    onChange?(): void;
+    isMobile?: boolean;
+};
+export declare const LaserPointerButton: (props: LaserPointerIconProps) => JSX.Element;
+export {};

package/types/components/LaserTool/LaserTool.d.ts

@@ -0,0 +1,7 @@
+import { LaserPathManager } from "./LaserPathManager";
+import "./LaserToolOverlay.scss";
+type LaserToolOverlayProps = {
+    manager: LaserPathManager;
+};
+export declare const LaserToolOverlay: ({ manager }: LaserToolOverlayProps) => JSX.Element;
+export {};

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,13 +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, }: LayerUIProps) => 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) => 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) => JSX.Element;
+export declare const MobileMenu: ({ appState, elements, actionManager, setAppState, onLockToggle, onHandToolToggle, onPenModeToggle, renderTopRightUI, renderCustomStats, renderSidebars, device, renderWelcomeScreen, app, }: MobileMenuProps) => JSX.Element;
 export {};

package/types/components/Sidebar/Sidebar.d.ts

@@ -22,7 +22,7 @@ export declare const SidebarInner: React.ForwardRefExoticComponent<Pick<{
     docked?: boolean | undefined;
     className?: string | undefined;
     __fallback?: boolean | undefined;
-} & Omit<React.RefAttributes<HTMLDivElement>, "onSelect">, "className" | "name" | "children" | "key" | "onDock" | "docked" | "onStateChange" | "__fallback"> & React.RefAttributes<HTMLDivElement>>;
+} & Omit<React.RefAttributes<HTMLDivElement>, "onSelect">, "name" | "children" | "key" | "className" | "onDock" | "docked" | "onStateChange" | "__fallback"> & React.RefAttributes<HTMLDivElement>>;
 export declare const Sidebar: React.ForwardRefExoticComponent<{
     name: string;
     children: React.ReactNode;

package/types/components/Stack.d.ts

@@ -10,7 +10,7 @@ type StackProps = {
     ref: React.RefObject<HTMLDivElement>;
 };
 declare const _default: {
-    Row: React.ForwardRefExoticComponent<Pick<StackProps, "style" | "className" | "children" | "align" | "gap" | "justifyContent"> & React.RefAttributes<HTMLDivElement>>;
-    Col: React.ForwardRefExoticComponent<Pick<StackProps, "style" | "className" | "children" | "align" | "gap" | "justifyContent"> & React.RefAttributes<HTMLDivElement>>;
+    Row: React.ForwardRefExoticComponent<Pick<StackProps, "style" | "children" | "align" | "gap" | "className" | "justifyContent"> & React.RefAttributes<HTMLDivElement>>;
+    Col: React.ForwardRefExoticComponent<Pick<StackProps, "style" | "children" | "align" | "gap" | "className" | "justifyContent"> & React.RefAttributes<HTMLDivElement>>;
 };
 export default _default;

package/types/components/dropdownMenu/DropdownMenu.d.ts

@@ -25,29 +25,32 @@ declare const DropdownMenu: {
         displayName: string;
     };
     Item: {
-        ({ icon, onSelect, children, shortcut, className, ...rest }: {
+        ({ icon, onSelect, children, shortcut, className, selected, ...rest }: {
             icon?: JSX.Element | undefined;
             onSelect: (event: Event) => void;
             children: React.ReactNode;
             shortcut?: string | undefined;
+            selected?: boolean | undefined;
             className?: string | undefined;
         } & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onSelect">): JSX.Element;
         displayName: string;
     };
     ItemLink: {
-        ({ icon, shortcut, href, children, onSelect, className, ...rest }: {
+        ({ icon, shortcut, href, children, onSelect, className, selected, ...rest }: {
             href: string;
             icon?: JSX.Element | undefined;
             children: React.ReactNode;
             shortcut?: string | undefined;
             className?: string | undefined;
+            selected?: boolean | undefined;
             onSelect?: ((event: Event) => void) | undefined;
         } & React.AnchorHTMLAttributes<HTMLAnchorElement>): JSX.Element;
         displayName: string;
     };
-    ItemCustom: ({ children, className, ...rest }: {
+    ItemCustom: ({ children, className, selected, ...rest }: {
         children: React.ReactNode;
         className?: string | undefined;
+        selected?: boolean | undefined;
     } & React.HTMLAttributes<HTMLDivElement>) => JSX.Element;
     Group: {
         ({ children, className, style, title, }: {

package/types/components/dropdownMenu/DropdownMenuItem.d.ts

@@ -1,10 +1,11 @@
 import React from "react";
 declare const DropdownMenuItem: {
-    ({ icon, onSelect, children, shortcut, className, ...rest }: {
+    ({ icon, onSelect, children, shortcut, className, selected, ...rest }: {
         icon?: JSX.Element | undefined;
         onSelect: (event: Event) => void;
         children: React.ReactNode;
         shortcut?: string | undefined;
+        selected?: boolean | undefined;
         className?: string | undefined;
     } & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onSelect">): JSX.Element;
     displayName: string;

package/types/components/dropdownMenu/DropdownMenuItemCustom.d.ts

@@ -1,6 +1,7 @@
 import React from "react";
-declare const DropdownMenuItemCustom: ({ children, className, ...rest }: {
+declare const DropdownMenuItemCustom: ({ children, className, selected, ...rest }: {
     children: React.ReactNode;
     className?: string | undefined;
+    selected?: boolean | undefined;
 } & React.HTMLAttributes<HTMLDivElement>) => JSX.Element;
 export default DropdownMenuItemCustom;