@excalidraw/math 0.18.0-2b0e4c9 → 0.18.0-2b1c2a9

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

@@ -8,7 +8,7 @@ import "./Sidebar.scss";
  *
  * Since we can only render one Sidebar at a time, we can use a simple flag.
  */
-export declare const isSidebarDockedAtom: import("jotai/vanilla/atom").PrimitiveAtom<boolean> & {
+export declare const isSidebarDockedAtom: import("jotai").PrimitiveAtom<boolean> & {
     init: boolean;
 };
 export declare const SidebarInner: React.ForwardRefExoticComponent<Omit<{

package/dist/types/excalidraw/components/Stats/Angle.d.ts

@@ -1,8 +1,8 @@
-import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { Scene } from "@excalidraw/element";
 import type { AppState } from "../../types";
 interface AngleProps {
-    element: ExcalidrawElement;
+    element: NonDeletedExcalidrawElement;
     scene: Scene;
     appState: AppState;
     property: "angle";

package/dist/types/excalidraw/components/Stats/Dimension.d.ts

@@ -1,9 +1,9 @@
-import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { Scene } from "@excalidraw/element";
 import type { AppState } from "../../types";
 interface DimensionDragInputProps {
     property: "width" | "height";
-    element: ExcalidrawElement;
+    element: NonDeletedExcalidrawElement;
     scene: Scene;
     appState: AppState;
 }

package/dist/types/excalidraw/components/Stats/DragInput.d.ts

@@ -1,10 +1,10 @@
-import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
+import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { Scene } from "@excalidraw/element";
 import { useApp, useExcalidrawSetAppState } from "../App";
 import "./DragInput.scss";
 import type { StatsInputProperty } from "./utils";
 import type { AppState } from "../../types";
-export type DragInputCallbackType<P extends StatsInputProperty, E = ExcalidrawElement> = (props: {
+export type DragInputCallbackType<P extends StatsInputProperty, E = NonDeletedExcalidrawElement> = (props: {
     accumulatedChange: number;
     instantChange: number;
     originalElements: readonly E[];

package/dist/types/excalidraw/components/Stats/MultiAngle.d.ts

@@ -1,8 +1,8 @@
-import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { Scene } from "@excalidraw/element";
 import type { AppState } from "../../types";
 interface MultiAngleProps {
-    elements: readonly ExcalidrawElement[];
+    elements: readonly NonDeletedExcalidrawElement[];
     scene: Scene;
     appState: AppState;
     property: "angle";

package/dist/types/excalidraw/components/Stats/MultiDimension.d.ts

@@ -1,10 +1,10 @@
-import type { ExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import type { NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
 import type { Scene } from "@excalidraw/element";
 import type { AtomicUnit } from "./utils";
 import type { AppState } from "../../types";
 interface MultiDimensionProps {
     property: "width" | "height";
-    elements: readonly ExcalidrawElement[];
+    elements: readonly NonDeletedExcalidrawElement[];
     elementsMap: NonDeletedSceneElementsMap;
     atomicUnits: AtomicUnit[];
     scene: Scene;

package/dist/types/excalidraw/components/Stats/MultiPosition.d.ts

@@ -1,10 +1,10 @@
-import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
+import type { ElementsMap, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { Scene } from "@excalidraw/element";
 import type { AtomicUnit } from "./utils";
 import type { AppState } from "../../types";
 interface MultiPositionProps {
     property: "x" | "y";
-    elements: readonly ExcalidrawElement[];
+    elements: readonly NonDeletedExcalidrawElement[];
     elementsMap: ElementsMap;
     atomicUnits: AtomicUnit[];
     scene: Scene;

package/dist/types/excalidraw/components/Stats/Position.d.ts

@@ -1,12 +1,12 @@
-import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
+import type { ElementsMap, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { Scene } from "@excalidraw/element";
 import type { AppState } from "../../types";
 interface PositionProps {
     property: "x" | "y";
-    element: ExcalidrawElement;
+    element: NonDeletedExcalidrawElement;
     elementsMap: ElementsMap;
     scene: Scene;
     appState: AppState;
 }
-declare const Position: ({ property, element, elementsMap, scene, appState, }: PositionProps) => import("react/jsx-runtime").JSX.Element;
+declare const Position: ({ property, element, scene, appState }: PositionProps) => import("react/jsx-runtime").JSX.Element;
 export default Position;

package/dist/types/excalidraw/components/Stats/utils.d.ts

@@ -15,5 +15,5 @@ export declare const newOrigin: (x1: number, y1: number, w1: number, h1: number,
     x: number;
     y: number;
 };
-export declare const moveElement: (newTopLeftX: number, newTopLeftY: number, originalElement: ExcalidrawElement, scene: Scene, appState: AppState, originalElementsMap: ElementsMap, shouldInformMutation?: boolean) => void;
+export declare const moveElement: (newTopLeftX: number, newTopLeftY: number, originalElement: NonDeletedExcalidrawElement, scene: Scene, appState: AppState, originalElementsMap: ElementsMap, shouldInformMutation?: boolean) => void;
 export declare const getAtomicUnits: (targetElements: readonly ExcalidrawElement[], appState: AppState) => AtomicUnit[];

package/dist/types/excalidraw/components/TTDDialog/TTDContext.d.ts

@@ -1,13 +1,13 @@
 import type { RateLimits, TChat } from "./types";
-export declare const rateLimitsAtom: import("jotai/vanilla/atom").PrimitiveAtom<RateLimits | null> & {
+export declare const rateLimitsAtom: import("jotai").PrimitiveAtom<RateLimits | null> & {
     init: RateLimits | null;
 };
-export declare const showPreviewAtom: import("jotai/vanilla/atom").PrimitiveAtom<boolean> & {
+export declare const showPreviewAtom: import("jotai").PrimitiveAtom<boolean> & {
     init: boolean;
 };
-export declare const errorAtom: import("jotai/vanilla/atom").PrimitiveAtom<Error | null> & {
+export declare const errorAtom: import("jotai").PrimitiveAtom<Error | null> & {
     init: Error | null;
 };
-export declare const chatHistoryAtom: import("jotai/vanilla/atom").PrimitiveAtom<TChat.ChatHistory> & {
+export declare const chatHistoryAtom: import("jotai").PrimitiveAtom<TChat.ChatHistory> & {
     init: TChat.ChatHistory;
 };

package/dist/types/excalidraw/components/TTDDialog/useTTDChatStorage.d.ts

@@ -9,13 +9,13 @@ interface UseTTDChatStorageReturn {
     restoreChat: (chat: SavedChat) => SavedChat;
     createNewChatId: () => Promise<string>;
 }
-export declare const savedChatsAtom: import("jotai/vanilla/atom").PrimitiveAtom<SavedChats> & {
+export declare const savedChatsAtom: import("jotai").PrimitiveAtom<SavedChats> & {
     init: SavedChats;
 };
-export declare const isLoadingChatsAtom: import("jotai/vanilla/atom").PrimitiveAtom<boolean> & {
+export declare const isLoadingChatsAtom: import("jotai").PrimitiveAtom<boolean> & {
     init: boolean;
 };
-export declare const chatsLoadedAtom: import("jotai/vanilla/atom").PrimitiveAtom<boolean> & {
+export declare const chatsLoadedAtom: import("jotai").PrimitiveAtom<boolean> & {
     init: boolean;
 };
 export declare const useTTDChatStorage: ({ persistenceAdapter, }: UseTTDChatStorageProps) => UseTTDChatStorageReturn;

package/dist/types/excalidraw/components/ToolPopover.d.ts

@@ -4,7 +4,8 @@ import type { AppClassProperties } from "../types";
 type ToolOption = {
     type: string;
     icon: React.ReactNode;
-    title?: string;
+    title: string;
+    fillable?: boolean;
 };
 type ToolPopoverProps = {
     app: AppClassProperties;
@@ -13,13 +14,9 @@ type ToolPopoverProps = {
         type: string;
     };
     defaultOption: string;
-    className?: string;
-    namePrefix: string;
-    title: string;
     "data-testid": string;
     onToolChange: (type: string) => void;
     displayedOption: ToolOption;
-    fillable?: boolean;
 };
-export declare const ToolPopover: ({ app, options, activeTool, defaultOption, className, namePrefix, title, "data-testid": dataTestId, onToolChange, displayedOption, fillable, }: ToolPopoverProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ToolPopover: ({ app, options, activeTool, defaultOption, "data-testid": dataTestId, onToolChange, displayedOption, }: ToolPopoverProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/excalidraw/components/Toolbar.d.ts

@@ -0,0 +1,11 @@
+import type { AppClassProperties, AppProps, AppState, UIAppState } from "../types";
+/** the main (desktop/tablet) toolbar island */
+export declare const Toolbar: ({ app, appState, setAppState, UIOptions, onPenModeToggle, onLockToggle, heading, }: {
+    app: AppClassProperties;
+    appState: UIAppState;
+    setAppState: React.Component<any, AppState>["setState"];
+    UIOptions: AppProps["UIOptions"];
+    onPenModeToggle: AppClassProperties["togglePenMode"];
+    onLockToggle: () => void;
+    heading: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,146 @@
+import type { AppClassProperties, AppState, ToolType, UIAppState } from "../types";
+export type ToolConfig = {
+    icon: React.ReactNode;
+    /** letter shortcut(s) — the first one is shown in tooltips */
+    letterKey?: string | readonly string[];
+    /** whether `letterKey` requires Shift to be held (e.g. Shift+X) */
+    shiftKey?: boolean;
+    numericKey?: string;
+    /** whether the tool's shapes can be filled — fills the icon when active */
+    fillable?: boolean;
+    /**
+     * re-activating the tool switches back to the previously active tool
+     * (via the keyboard shortcut or ESC — see `setActiveTool`'s `toggle`
+     * option)
+     */
+    toggle?: boolean;
+};
+/**
+ * Tool data — the single source of truth for tool buttons, keyboard
+ * shortcuts (`findShapeByKey`), and the command palette. Toolbar placement
+ * is not defined here: toolbars compose the `*ToolButton` components below
+ * manually, so entries without a toolbar slot (e.g. laser) are data-only.
+ */
+export declare const TOOLS: {
+    hand: ToolConfig;
+    selection: ToolConfig;
+    rectangle: ToolConfig;
+    diamond: ToolConfig;
+    ellipse: ToolConfig;
+    arrow: ToolConfig;
+    line: ToolConfig;
+    freedraw: ToolConfig;
+    text: ToolConfig;
+    image: ToolConfig;
+    eraser: ToolConfig;
+    frame: ToolConfig;
+    autoshape: ToolConfig;
+    embeddable: ToolConfig;
+    laser: ToolConfig;
+    bucketfill: ToolConfig;
+    lasso: ToolConfig;
+};
+export type ToolbarToolType = keyof typeof TOOLS;
+/**
+ * tools that, when activated while already active, switch back to the
+ * previously active tool (see `setActiveTool`'s `toggle` option)
+ */
+export declare const TOGGLE_TOOLS: readonly (ToolType | "custom")[];
+export declare const getToolLetter: (type: ToolbarToolType) => string | undefined;
+/** human-readable shortcut hint, e.g. "R or 2", used in tooltips & aria */
+export declare const getToolShortcut: (type: ToolbarToolType) => string;
+export declare const findShapeByKey: (key: string, app: AppClassProperties, shiftKey?: boolean) => "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "lasso" | "eraser" | "hand" | "laser" | "autoshape" | "bucketfill" | null;
+/**
+ * Whether a toolbar entry activating the given tool renders disabled — true
+ * when the active tool is host-controlled (`props.activeTool`) and the entry
+ * doesn't activate the forced tool (`setActiveTool` refuses it).
+ */
+export declare const isToolButtonDisabled: (app: AppClassProperties, type: string) => boolean;
+export type ToolButtonComponentProps = {
+    app: AppClassProperties;
+    activeTool: UIAppState["activeTool"];
+    /** hide the keybinding badge rendered in the button's corner */
+    hideKeyBinding?: boolean;
+    /**
+     * hide all shortcut affordances (tooltip hint, aria-keyshortcuts, and the
+     * keybinding badge) — used on mobile where there's no keyboard
+     */
+    hideShortcut?: boolean;
+};
+export declare const HandToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const RectangleToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const DiamondToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const EllipseToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const ArrowToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const LineToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const FreedrawToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const TextToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const ImageToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const EraserToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const FrameToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+/**
+ * The selection tool button — pointer-clicking it while the selection tool
+ * is active switches to lasso.
+ */
+export declare const SelectionToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+/**
+ * Rendered in place of the selection button when lasso is the preferred
+ * selection tool; the selection shortcut activates it then.
+ */
+export declare const LassoToolButton: {
+    ({ app, activeTool, hideKeyBinding, hideShortcut, }: ToolButtonComponentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+/**
+ * The selection ⇄ lasso popover used in compact (tablet) and mobile
+ * toolbars; picking an option also makes it the preferred selection tool.
+ */
+export declare const SelectionToolPopover: ({ app, activeTool, setAppState, }: {
+    app: AppClassProperties;
+    activeTool: UIAppState["activeTool"];
+    setAppState: React.Component<any, AppState>["setState"];
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * The freedraw ⇄ draw-shape popover used in compact (tablet) and mobile
+ * toolbars. The trigger remembers and displays the most recently used option.
+ */
+export declare const FreedrawToolPopover: ({ app, activeTool, }: {
+    app: AppClassProperties;
+    activeTool: UIAppState["activeTool"];
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/UserList.d.ts

@@ -7,12 +7,13 @@ export type GoToCollaboratorComponentProps = {
     withName: boolean;
     isBeingFollowed: boolean;
 };
-type UserListUserObject = Pick<Collaborator, "avatarUrl" | "id" | "socketId" | "username" | "isInCall" | "isSpeaking" | "isMuted">;
+type UserListUserObject = Pick<Collaborator, "avatarUrl" | "id" | "socketId" | "username" | "isInCall" | "isSpeaking" | "isMuted" | "isCurrentUser">;
 type UserListProps = {
     className?: string;
     mobile?: boolean;
     collaborators: Map<SocketId, UserListUserObject>;
     userToFollow: SocketId | null;
+    currentUserControls?: React.ReactNode | ((isMobile: boolean) => React.ReactNode);
 };
-export declare const UserList: React.MemoExoticComponent<({ className, mobile, collaborators, userToFollow }: UserListProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const UserList: React.MemoExoticComponent<({ className, mobile, collaborators, userToFollow, currentUserControls, }: UserListProps) => import("react/jsx-runtime").JSX.Element>;
 export {};

package/dist/types/excalidraw/components/ViewportStatusFrame/ViewportStatusFrame.d.ts

@@ -0,0 +1,11 @@
+import "./ViewportStatusFrame.scss";
+import type { CSSProperties } from "react";
+import type { ViewportStatusFrame as ViewportStatusFrameType } from "../../types";
+export declare const ViewportStatusBorder: ({ border, style, }: {
+    border: string;
+    style?: CSSProperties;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const ViewportStatusBadge: ({ label, border, }: {
+    label: NonNullable<ViewportStatusFrameType["label"]>;
+    border?: ViewportStatusFrameType["border"];
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/canvases/InteractiveCanvas.d.ts

@@ -11,16 +11,19 @@ type InteractiveCanvasProps = {
     visibleElements: readonly NonDeletedExcalidrawElement[];
     selectedElements: readonly NonDeletedExcalidrawElement[];
     allElementsMap: NonDeletedSceneElementsMap;
-    sceneNonce: number | undefined;
+    canvasNonce: string;
     selectionNonce: number | undefined;
     scale: number;
     appState: InteractiveCanvasAppState;
     renderScrollbars: boolean;
     editorInterface: EditorInterface;
     app: AppClassProperties;
+    interactionEnabled: boolean;
+    navigationEnabled: boolean;
     renderInteractiveSceneCallback: (data: RenderInteractiveSceneCallback) => void;
     handleCanvasRef: (canvas: HTMLCanvasElement | null) => void;
     onContextMenu: Exclude<DOMAttributes<HTMLCanvasElement | HTMLDivElement>["onContextMenu"], undefined>;
+    onClick: Exclude<DOMAttributes<HTMLCanvasElement>["onClick"], undefined>;
     onPointerMove: Exclude<DOMAttributes<HTMLCanvasElement>["onPointerMove"], undefined>;
     onPointerUp: Exclude<DOMAttributes<HTMLCanvasElement>["onPointerUp"], undefined>;
     onPointerCancel: Exclude<DOMAttributes<HTMLCanvasElement>["onPointerCancel"], undefined>;

package/dist/types/excalidraw/components/canvases/NewElementCanvas.d.ts

@@ -4,6 +4,7 @@ import type { AppState } from "../../types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 interface NewElementCanvasProps {
     appState: AppState;
+    newElement: NonNullable<AppState["newElement"]>;
     elementsMap: RenderableElementsMap;
     allElementsMap: NonDeletedSceneElementsMap;
     scale: number;

package/dist/types/excalidraw/components/canvases/StaticCanvas.d.ts

@@ -9,7 +9,7 @@ type StaticCanvasProps = {
     elementsMap: RenderableElementsMap;
     allElementsMap: NonDeletedSceneElementsMap;
     visibleElements: readonly NonDeletedExcalidrawElement[];
-    sceneNonce: number | undefined;
+    canvasNonce: string;
     selectionNonce: number | undefined;
     scale: number;
     appState: StaticCanvasAppState;

package/dist/types/excalidraw/components/dropdownMenu/DropdownMenuItemContentRadio.d.ts

@@ -9,9 +9,10 @@ type Props<T> = {
     onChange: (value: T) => void;
     children: React.ReactNode;
     name: string;
+    icon?: React.ReactNode;
 };
 declare const DropdownMenuItemContentRadio: {
-    <T>({ value, shortcut, onChange, choices, children, name, }: Props<T>): import("react/jsx-runtime").JSX.Element;
+    <T>({ value, shortcut, onChange, choices, children, name, icon, }: Props<T>): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 export default DropdownMenuItemContentRadio;

package/dist/types/excalidraw/components/footer/Footer.d.ts

@@ -1,11 +1,13 @@
 import type { ActionManager } from "../../actions/manager";
 import type { UIAppState } from "../../types";
 declare const Footer: {
-    ({ appState, actionManager, showExitZenModeBtn, renderWelcomeScreen, }: {
+    ({ appState, actionManager, showExitZenModeBtn, renderWelcomeScreen, defaultUIEnabled, zoomUIEnabled, }: {
         appState: UIAppState;
         actionManager: ActionManager;
         showExitZenModeBtn: boolean;
         renderWelcomeScreen: boolean;
+        defaultUIEnabled: boolean;
+        zoomUIEnabled: boolean;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };

package/dist/types/excalidraw/components/hyperlink/helpers.d.ts

@@ -1,10 +1,10 @@
 import type { GlobalPoint, Radians } from "@excalidraw/math";
 import type { Bounds } from "@excalidraw/common";
 import type { ElementsMap, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
-import type { AppState, UIAppState } from "../../types";
+import type { AppState } from "../../types";
 export declare const DEFAULT_LINK_SIZE = 12;
 export declare const EXTERNAL_LINK_IMG: HTMLImageElement;
 export declare const ELEMENT_LINK_IMG: HTMLImageElement;
-export declare const getLinkHandleFromCoords: ([x1, y1, x2, y2]: Bounds, angle: Radians, appState: Pick<UIAppState, "zoom">) => Bounds;
+export declare const getLinkHandleFromCoords: ([x1, y1, x2, y2]: Bounds, angle: Radians, appState: Pick<AppState, "zoom">) => Bounds;
 export declare const isPointHittingLinkIcon: (element: NonDeletedExcalidrawElement, elementsMap: ElementsMap, appState: AppState, [x, y]: GlobalPoint) => boolean;
 export declare const isPointHittingLink: (element: NonDeletedExcalidrawElement, elementsMap: ElementsMap, appState: AppState, [x, y]: GlobalPoint, isMobile: boolean) => boolean;

package/dist/types/excalidraw/components/icons.d.ts

@@ -57,6 +57,7 @@ export declare const saveAs: import("react/jsx-runtime").JSX.Element;
 export declare const LoadIcon: import("react/jsx-runtime").JSX.Element;
 export declare const clipboard: import("react/jsx-runtime").JSX.Element;
 export declare const palette: import("react/jsx-runtime").JSX.Element;
+export declare const bucketFillIconSvgPaths: readonly ["M5 16l1.465 1.638a2 2 0 1 1 -3.015 .099l1.55 -1.737z", "M13.737 9.737c2.299 -2.3 3.23 -5.095 2.081 -6.245c-1.15 -1.15 -3.945 -.217 -6.244 2.082c-2.3 2.299 -3.231 5.095 -2.082 6.244c1.15 1.15 3.946 .218 6.245 -2.081z", "M7.492 11.818c.362 .362 .768 .676 1.208 .934l6.895 4.047c1.078 .557 2.255 -.075 3.692 -1.512c1.437 -1.437 2.07 -2.614 1.512 -3.692c-.372 -.718 -1.72 -3.017 -4.047 -6.895a6.015 6.015 0 0 0 -.934 -1.208"];
 export declare const bucketFillIcon: import("react/jsx-runtime").JSX.Element;
 export declare const slashIcon: import("react/jsx-runtime").JSX.Element;
 export declare const ExportImageIcon: import("react/jsx-runtime").JSX.Element;
@@ -114,6 +115,8 @@ export declare const StrokeStyleDottedIcon: import("react/jsx-runtime").JSX.Elem
 export declare const SloppinessArchitectIcon: import("react/jsx-runtime").JSX.Element;
 export declare const SloppinessArtistIcon: import("react/jsx-runtime").JSX.Element;
 export declare const SloppinessCartoonistIcon: import("react/jsx-runtime").JSX.Element;
+export declare const strokeVariabilityConstantIcon: import("react/jsx-runtime").JSX.Element;
+export declare const strokeVariabilityVariableIcon: import("react/jsx-runtime").JSX.Element;
 export declare const EdgeSharpIcon: import("react/jsx-runtime").JSX.Element;
 export declare const EdgeRoundIcon: import("react/jsx-runtime").JSX.Element;
 export declare const ArrowheadNoneIcon: React.MemoExoticComponent<({ flip }: {
@@ -194,13 +197,14 @@ export declare const playerPlayIcon: import("react/jsx-runtime").JSX.Element;
 export declare const playerStopFilledIcon: import("react/jsx-runtime").JSX.Element;
 export declare const tablerCheckIcon: import("react/jsx-runtime").JSX.Element;
 export declare const alertTriangleIcon: import("react/jsx-runtime").JSX.Element;
+export declare const eyeDropperIconSvgPaths: readonly ["M4 16l11.7 -11.7a1 1 0 0 1 1.4 0l2.6 2.6a1 1 0 0 1 0 1.4l-11.7 11.7h-4v-4z", "M11 7l6 6"];
 export declare const eyeDropperIcon: import("react/jsx-runtime").JSX.Element;
-export declare const extraToolsIcon: import("react/jsx-runtime").JSX.Element;
 export declare const frameToolIcon: import("react/jsx-runtime").JSX.Element;
 export declare const mermaidLogoIcon: import("react/jsx-runtime").JSX.Element;
 export declare const RetryIcon: import("react/jsx-runtime").JSX.Element;
 export declare const stackPushIcon: import("react/jsx-runtime").JSX.Element;
 export declare const ArrowRightIcon: import("react/jsx-runtime").JSX.Element;
+export declare const drawShapeToolIcon: import("react/jsx-runtime").JSX.Element;
 export declare const laserPointerToolIcon: import("react/jsx-runtime").JSX.Element;
 export declare const MagicIcon: import("react/jsx-runtime").JSX.Element;
 export declare const MagicIconThin: import("react/jsx-runtime").JSX.Element;
@@ -248,6 +252,7 @@ export declare const sidebarRightIcon: import("react/jsx-runtime").JSX.Element;
 export declare const messageCircleIcon: import("react/jsx-runtime").JSX.Element;
 export declare const presentationIcon: import("react/jsx-runtime").JSX.Element;
 export declare const emptyIcon: import("react/jsx-runtime").JSX.Element;
+export declare const chevronDownIcon: import("react/jsx-runtime").JSX.Element;
 export declare const chevronRight: import("react/jsx-runtime").JSX.Element;
 export declare const settingsIcon: import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/excalidraw/components/main-menu/DefaultItems.d.ts

@@ -35,11 +35,14 @@ export declare const ClearCanvas: {
 export declare const ToggleTheme: {
     (props: {
         allowSystemTheme: true;
+        /**
+         * Controls the theme of this UI component only.
+         * You should subscribe to `props.onThemeChange` and control the theme
+         * upstream.
+         */
         theme: Theme | "system";
-        onSelect: (theme: Theme | "system") => void;
     } | {
-        allowSystemTheme?: false;
-        onSelect?: (theme: Theme) => void;
+        allowSystemTheme: false;
     }): import("react/jsx-runtime").JSX.Element | null;
     displayName: string;
 };
@@ -70,12 +73,13 @@ export declare const Preferences: {
         additionalItems?: React.ReactNode;
     }): import("react/jsx-runtime").JSX.Element;
     ToggleToolLock: () => import("react/jsx-runtime").JSX.Element;
+    BoxSelectionMode: () => import("react/jsx-runtime").JSX.Element;
     ToggleSnapMode: () => import("react/jsx-runtime").JSX.Element;
     ToggleArrowBinding: () => import("react/jsx-runtime").JSX.Element;
     ToggleMidpointSnapping: () => import("react/jsx-runtime").JSX.Element;
     ToggleGridMode: () => import("react/jsx-runtime").JSX.Element;
     ToggleZenMode: () => import("react/jsx-runtime").JSX.Element;
-    ToggleViewMode: () => import("react/jsx-runtime").JSX.Element;
+    ToggleViewMode: () => import("react/jsx-runtime").JSX.Element | null;
     ToggleElementProperties: () => import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };

package/dist/types/excalidraw/components/positionElementBesideCursor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Positions an element beside a cursor within a container, flipping the
+ * element to the other side of the cursor when it would overflow the
+ * container, resolved independently on each axis.
+ *
+ * Takes the cursor in client (viewport) coordinates and returns
+ * container-local coordinates.
+ */
+export declare const positionElementBesideCursor: ({ cursor, element, container, gap, }: {
+    /** client (viewport) coordinates */
+    cursor: {
+        x: number;
+        y: number;
+    };
+    element: {
+        width: number;
+        height: number;
+    };
+    /** the container's bounding client rect */
+    container: Pick<DOMRect, "left" | "top" | "width" | "height">;
+    /** distance between the cursor and the positioned element */
+    gap: number;
+}) => {
+    left: number;
+    top: number;
+};

package/dist/types/excalidraw/components/shapeActionPredicates.d.ts

@@ -0,0 +1,39 @@
+import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import type { AppClassProperties, UIAppState } from "../types";
+export declare const canChangeStrokeColor: (appState: UIAppState, targetElements: ExcalidrawElement[]) => boolean;
+export declare const canChangeBackgroundColor: (appState: UIAppState, targetElements: ExcalidrawElement[]) => boolean;
+/**
+ * Single source of truth for "which shape-action controls are relevant right
+ * now". Each flag answers whether a given control should be shown, given the
+ * active tool and the current selection. All three styles-panel layouts
+ * (full / compact / mobile) and the compact popovers consume these flags so
+ * that visibility logic lives in one place and layout stays pure.
+ */
+export declare const getShapeActionPredicates: (appState: UIAppState, targetElements: ExcalidrawElement[], elementsMap: NonDeletedElementsMap | NonDeletedSceneElementsMap, app: AppClassProperties) => {
+    /** some element(s) selected */
+    hasSelection: boolean;
+    /** actions on selected elements (delete/duplicate/...) */
+    showExtraActions: boolean;
+    strokeColor: boolean;
+    backgroundColor: boolean;
+    fill: boolean;
+    strokeWidth: boolean;
+    freedrawMode: boolean;
+    strokeStyle: boolean;
+    sloppiness: boolean;
+    roundness: boolean;
+    arrowType: boolean;
+    arrowheads: boolean;
+    text: boolean;
+    textAlign: boolean;
+    verticalAlign: boolean;
+    opacity: boolean;
+    layers: boolean;
+    align: boolean;
+    distribute: boolean;
+    link: boolean;
+    linkSingleOnly: boolean;
+    cropEditor: boolean;
+    lineEditor: boolean;
+};
+export type ShapeActionPredicates = ReturnType<typeof getShapeActionPredicates>;