@excalidraw/excalidraw 0.16.1-4c35eba → 0.16.1-aaf73c8

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";
@@ -44,10 +44,10 @@ export declare const actionSendToBack: {
         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";
@@ -60,8 +60,8 @@ export declare const actionBringToFront: {
         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/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

@@ -6,9 +6,10 @@ import { LinearElementEditor } from "../element/linearElementEditor";
 import { ExcalidrawElement, 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";
 export declare const ExcalidrawContainerContext: React.Context<{
     container: HTMLDivElement | null;
     id: string | null;
@@ -54,12 +55,13 @@ 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;
     constructor(props: AppProps);
     private onWindowMessage;
     private updateEmbeddableRef;
@@ -117,7 +119,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 +171,15 @@ 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;
+    }) => 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;

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

@@ -1,11 +1,12 @@
 import React from "react";
 declare const DropdownMenuItemLink: {
-    ({ 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;

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

@@ -2,5 +2,5 @@ import React from "react";
 export declare const DropdownMenuContentPropsContext: React.Context<{
     onSelect?: ((event: Event) => void) | undefined;
 }>;
-export declare const getDropdownMenuItemClassName: (className?: string) => string;
+export declare const getDropdownMenuItemClassName: (className?: string, selected?: boolean) => string;
 export declare const useHandleDropdownMenuItemClick: (origOnClick: React.MouseEventHandler<HTMLAnchorElement | HTMLButtonElement> | undefined, onSelect: ((event: Event) => void) | undefined) => (event: React.MouseEvent<HTMLButtonElement | HTMLAnchorElement, MouseEvent>) => void;

package/types/components/icons.d.ts

@@ -1,5 +1,6 @@
 import React from "react";
 import { Theme } from "../element/types";
+export declare const iconFillColor: (theme: Theme) => string;
 type Opts = {
     width?: number;
     height?: number;
@@ -149,4 +150,5 @@ export declare const alertTriangleIcon: JSX.Element;
 export declare const eyeDropperIcon: JSX.Element;
 export declare const extraToolsIcon: JSX.Element;
 export declare const frameToolIcon: JSX.Element;
+export declare const laserPointerToolIcon: JSX.Element;
 export {};

package/types/components/main-menu/MainMenu.d.ts

@@ -19,29 +19,32 @@ declare const MainMenu: React.FC<{
         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/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/element/Hyperlink.d.ts

@@ -51,15 +51,9 @@ export declare const actionLink: {
             editingElement: NonDeletedExcalidrawElement | null;
             editingLinearElement: import("./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;
@@ -136,7 +130,7 @@ export declare const actionLink: {
             };
             pendingImageElementId: string | null;
             selectedLinearElement: import("./linearElementEditor").LinearElementEditor | null;
-            snapLines: import("../snapping").SnapLine[];
+            snapLines: readonly import("../snapping").SnapLine[];
             originSnapOffset: {
                 x: number;
                 y: number;
@@ -149,12 +143,12 @@ export declare const actionLink: {
         category: "hyperlink";
         action: string;
     };
-    keyTest: (event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean;
+    keyTest: (event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean;
     contextItemLabel: (elements: readonly import("./types").ExcalidrawElement[], appState: Readonly<AppState>) => "labels.link.editEmbed" | "labels.link.edit" | "labels.link.createEmbed" | "labels.link.create";
     predicate: (elements: readonly import("./types").ExcalidrawElement[], appState: AppState) => boolean;
     PanelComponent: ({ elements, appState, updateData }: import("../actions/types").PanelComponentProps) => JSX.Element;
 } & {
-    keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
+    keyTest?: ((event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean) | undefined;
 };
 export declare const getContextMenuLabel: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState) => "labels.link.editEmbed" | "labels.link.edit" | "labels.link.createEmbed" | "labels.link.create";
 export declare const getLinkHandleFromCoords: ([x1, y1, x2, y2]: Bounds, angle: number, appState: Pick<UIAppState, "zoom">) => [x: number, y: number, width: number, height: number];

package/types/element/embeddable.d.ts

@@ -25,15 +25,9 @@ export declare const actionSetEmbeddableAsActiveTool: {
         elements: readonly ExcalidrawElement[];
         appState: {
             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;
             contextMenu: {
                 items: import("../components/ContextMenu").ContextMenuItems;
                 top: number;
@@ -142,7 +136,7 @@ export declare const actionSetEmbeddableAsActiveTool: {
             pendingImageElementId: string | null;
             showHyperlinkPopup: false | "editor" | "info";
             selectedLinearElement: import("./linearElementEditor").LinearElementEditor | null;
-            snapLines: import("../snapping").SnapLine[];
+            snapLines: readonly import("../snapping").SnapLine[];
             originSnapOffset: {
                 x: number;
                 y: number;

package/types/element/linearElementEditor.d.ts

@@ -152,15 +152,9 @@ export declare class LinearElementEditor {
             elementsToHighlight: NonDeleted<ExcalidrawElement>[] | null;
             editingElement: import("./types").NonDeletedExcalidrawElement | 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;
@@ -239,7 +233,7 @@ export declare class LinearElementEditor {
             pendingImageElementId: string | null;
             showHyperlinkPopup: false | "editor" | "info";
             selectedLinearElement: LinearElementEditor | null;
-            snapLines: import("../snapping").SnapLine[];
+            snapLines: readonly import("../snapping").SnapLine[];
             originSnapOffset: {
                 x: number;
                 y: number;