@excalidraw/element 0.18.0-9ba0f5d → 0.18.0-a52cd20

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/Chat/ChatInterface.d.ts

@@ -1,5 +1,5 @@
 import type { TChat, TTTDDialog } from "../types";
-export declare const ChatInterface: ({ chatId, messages, currentPrompt, onPromptChange, onGenerate, isGenerating, rateLimits, placeholder, onAbort, onMermaidTabClick, onAiRepairClick, onDeleteMessage, onInsertMessage, onRetry, renderWarning, }: {
+export declare const ChatInterface: ({ chatId, messages, currentPrompt, onPromptChange, onGenerate, isGenerating, rateLimits, onAbort, onMermaidTabClick, onAiRepairClick, onDeleteMessage, onInsertMessage, onRetry, renderWelcomeScreen, renderWarning, }: {
     chatId: string;
     messages: TChat.ChatMessage[];
     currentPrompt: string;
@@ -12,16 +12,12 @@ export declare const ChatInterface: ({ chatId, messages, currentPrompt, onPrompt
     } | null;
     onViewAsMermaid?: () => void;
     generatedResponse?: string | null;
-    placeholder: {
-        title: string;
-        description: string;
-        hint: string;
-    };
     onAbort?: () => void;
     onMermaidTabClick?: (message: TChat.ChatMessage) => void;
     onAiRepairClick?: (message: TChat.ChatMessage) => void;
     onDeleteMessage?: (messageId: string) => void;
     onInsertMessage?: (message: TChat.ChatMessage) => void;
     onRetry?: (message: TChat.ChatMessage) => void;
+    renderWelcomeScreen?: TTTDDialog.renderWelcomeScreen;
     renderWarning?: TTTDDialog.renderWarning;
 }) => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/TTDDialog/Chat/TTDChatPanel.d.ts

@@ -1,5 +1,5 @@
 import type { SavedChat, TChat, TTTDDialog } from "../types";
-export declare const TTDChatPanel: ({ chatId, messages, currentPrompt, onPromptChange, onGenerate, isGenerating, generatedResponse, isMenuOpen, onMenuToggle, onMenuClose, onNewChat, onRestoreChat, onDeleteChat, savedChats, activeSessionId, onAbort, onMermaidTabClick, onAiRepairClick, onDeleteMessage, onInsertMessage, onRetry, onViewAsMermaid, renderWarning, }: {
+export declare const TTDChatPanel: ({ chatId, messages, currentPrompt, onPromptChange, onGenerate, isGenerating, generatedResponse, isMenuOpen, onMenuToggle, onMenuClose, onNewChat, onRestoreChat, onDeleteChat, savedChats, activeSessionId, onAbort, onMermaidTabClick, onAiRepairClick, onDeleteMessage, onInsertMessage, onRetry, onViewAsMermaid, renderWelcomeScreen, renderWarning, }: {
     chatId: string;
     messages: TChat.ChatMessage[];
     currentPrompt: string;
@@ -22,5 +22,6 @@ export declare const TTDChatPanel: ({ chatId, messages, currentPrompt, onPromptC
     onInsertMessage: (message: TChat.ChatMessage) => void;
     onRetry?: (message: TChat.ChatMessage) => void;
     onViewAsMermaid: () => void;
+    renderWelcomeScreen?: TTTDDialog.renderWelcomeScreen;
     renderWarning?: TTTDDialog.renderWarning;
 }) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,11 @@
+import type { Theme } from "@excalidraw/element/types";
+export interface CodeMirrorEditorProps {
+    value: string;
+    onChange: (value: string) => void;
+    onKeyboardSubmit?: () => void;
+    placeholder?: string;
+    theme: Theme;
+    errorLine?: number | null;
+}
+declare const CodeMirrorEditor: ({ value, onChange, onKeyboardSubmit, placeholder, theme, errorLine, }: CodeMirrorEditorProps) => import("react/jsx-runtime").JSX.Element;
+export default CodeMirrorEditor;

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/TTDDialog.d.ts

@@ -1,9 +1,13 @@
 import "./TTDDialog.scss";
 import type { TTDPersistenceAdapter, TTTDDialog } from "./types";
-export declare const TTDDialog: (props: {
-    onTextSubmit: TTTDDialog.onTextSubmit;
-    renderWarning?: TTTDDialog.renderWarning;
-    persistenceAdapter: TTDPersistenceAdapter;
-} | {
-    __fallback: true;
-}) => import("react/jsx-runtime").JSX.Element | null;
+export declare const TTDDialog: {
+    (props: {
+        onTextSubmit: TTTDDialog.onTextSubmit;
+        renderWelcomeScreen?: TTTDDialog.renderWelcomeScreen;
+        renderWarning?: TTTDDialog.renderWarning;
+        persistenceAdapter: TTDPersistenceAdapter;
+    } | {
+        __fallback: true;
+    }): import("react/jsx-runtime").JSX.Element | null;
+    WelcomeMessage: () => import("react/jsx-runtime").JSX.Element;
+};

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

@@ -1,9 +1,9 @@
-import type { ChangeEventHandler } from "react";
 interface TTDDialogInputProps {
     input: string;
     placeholder: string;
-    onChange: ChangeEventHandler<HTMLTextAreaElement>;
+    onChange: (value: string) => void;
     onKeyboardSubmit?: () => void;
+    errorLine?: number | null;
 }
-export declare const TTDDialogInput: ({ input, placeholder, onChange, onKeyboardSubmit, }: TTDDialogInputProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TTDDialogInput: ({ input, placeholder, onChange, onKeyboardSubmit, errorLine, }: TTDDialogInputProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

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

@@ -3,6 +3,9 @@ interface TTDDialogOutputProps {
     canvasRef: React.RefObject<HTMLDivElement | null>;
     loaded: boolean;
     hideErrorDetails?: boolean;
+    sourceText?: string;
+    autoFixAvailable?: boolean;
+    onApplyAutoFix?: () => void;
 }
-export declare const TTDDialogOutput: ({ error, canvasRef, loaded, hideErrorDetails, }: TTDDialogOutputProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TTDDialogOutput: ({ error, canvasRef, loaded, hideErrorDetails, sourceText, autoFixAvailable, onApplyAutoFix, }: TTDDialogOutputProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1 @@
+export declare const TTDWelcomeMessage: () => import("react/jsx-runtime").JSX.Element;

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

@@ -1,7 +1,8 @@
 import type { MermaidToExcalidrawLibProps, TTDPersistenceAdapter, TTTDDialog } from "./types";
-export declare const TextToDiagram: ({ mermaidToExcalidrawLib, onTextSubmit, renderWarning, persistenceAdapter, }: {
+export declare const TextToDiagram: ({ mermaidToExcalidrawLib, onTextSubmit, renderWelcomeScreen, renderWarning, persistenceAdapter, }: {
     mermaidToExcalidrawLib: MermaidToExcalidrawLibProps;
     onTextSubmit(props: TTTDDialog.OnTextSubmitProps): Promise<TTTDDialog.OnTextSubmitRetValue>;
+    renderWelcomeScreen?: TTTDDialog.renderWelcomeScreen;
     renderWarning?: TTTDDialog.renderWarning;
     persistenceAdapter: TTDPersistenceAdapter;
 }) => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/TTDDialog/mermaid-lang-lite.d.ts

@@ -0,0 +1,2 @@
+import { StreamLanguage } from "@codemirror/language";
+export declare function mermaidLite(): StreamLanguage<unknown>;

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

@@ -88,4 +88,8 @@ export declare namespace TTTDDialog {
      * return undefined to use default rendering
      */
     type renderWarning = (chatMessage: TChat.ChatMessage) => React.ReactNode | undefined;
+    type renderWelcomeScreen = (props: {
+        /** null if not rate limit data currently available */
+        rateLimits: RateLimits | null;
+    }) => React.ReactNode | undefined;
 }

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/TTDDialog/utils/mermaidAutoFix.d.ts

@@ -0,0 +1 @@
+export declare const getMermaidAutoFixCandidates: (sourceText: string, errorMessage: string) => string[];

package/dist/types/excalidraw/components/TTDDialog/utils/mermaidError.d.ts

@@ -0,0 +1,10 @@
+export declare const isMermaidParseSyntaxError: (message: string) => boolean;
+export declare const isMermaidAutoFixableError: (message: string) => boolean;
+export declare const isMermaidCaretLine: (line: string) => boolean;
+export declare const getMermaidInactiveParticipant: (message: string) => string | null;
+export declare const getMermaidErrorLineNumber: (message: string, sourceText?: string) => number | null;
+export declare const getMermaidSyntaxErrorGuidance: (message: string, sourceText?: string) => {
+    summary: string;
+    likelyCauses: string[];
+} | null;
+export declare const formatMermaidParseErrorMessage: (message: string) => string;

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

@@ -1,9 +1,13 @@
 import "./Toast.scss";
-import type { CSSProperties } from "react";
-export declare const Toast: ({ message, onClose, closable, duration, style, }: {
-    message: string;
+import type { CSSProperties, ReactNode } from "react";
+export declare const Toast: (({ message, onClose, closable, duration, style, }: {
+    message: ReactNode;
     onClose: () => void;
     closable?: boolean;
     duration?: number;
     style?: CSSProperties;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element) & {
+    ProgressBar: ({ progress }: {
+        progress: number;
+    }) => import("react/jsx-runtime").JSX.Element;
+};

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,151 @@
+import type { AppClassProperties, AppState, ToolType, UIAppState } from "../types";
+export type ToolConfig = {
+    icon: React.ReactNode;
+    /** letter shortcut(s) — the first one is shown in tooltips and badges */
+    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;
+    stickynote: 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" | "stickynote" | "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 StickyNoteToolButton: {
+    ({ 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/Tooltip.d.ts

@@ -7,12 +7,26 @@ export declare const updateTooltipPosition: (tooltip: HTMLDivElement, item: {
     width: number;
     height: number;
 }, position?: "bottom" | "top") => void;
+export declare const hideTooltip: () => void;
+/**
+ * Shows the tooltip for `item`. For elements that can't be wrapped
+ * in <Tooltip>. Pair with `hideTooltip()`.
+ */
+export declare const showTooltip: (item: HTMLElement, label: string, { long, delay, position, }?: {
+    long?: boolean;
+    /** show after a short delay (unless a tooltip was visible just now) */
+    delay?: boolean;
+    position?: "bottom" | "top";
+}) => void;
 type TooltipProps = {
     children: React.ReactNode;
     label: string;
     long?: boolean;
     style?: React.CSSProperties;
+    className?: string;
     disabled?: boolean;
+    /** show after a short delay (unless a tooltip was visible just now) */
+    delay?: boolean;
 };
-export declare const Tooltip: ({ children, label, long, style, disabled, }: TooltipProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const Tooltip: ({ children, label, long, style, className, disabled, delay, }: TooltipProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/types/excalidraw/components/TopPicksDnD/TopPicksContextMenu.d.ts

@@ -0,0 +1,14 @@
+import type { ReactElement } from "react";
+/**
+ * right-click context menu of a customizable top-picks strip, resetting it
+ * to its default picks. Renders the strip as-is when not customizable.
+ */
+export declare const TopPicksContextMenu: ({ children, onReset, isCustomized, resetLabel, }: {
+    /** the strip (must accept a ref — used as the menu trigger) */
+    children: ReactElement;
+    /** present when the strip is user-customizable */
+    onReset?: () => void;
+    /** whether custom picks are currently applied (enables the reset item) */
+    isCustomized: boolean;
+    resetLabel: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/TopPicksDnD/TopPicksTip.d.ts

@@ -0,0 +1,11 @@
+/**
+ * "drag to pin" hint shown in a picker popup whose top picks are
+ * customizable — with a reset link while the picks are customized
+ */
+export declare const TopPicksTip: ({ className, tip, onReset, resetTitle, }: {
+    className?: string;
+    tip: string;
+    /** present only while the top picks are customized */
+    onReset?: () => void;
+    resetTitle: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/TopPicksDnD/topPicksDnD.d.ts

@@ -0,0 +1,58 @@
+import "./TopPicksDnD.scss";
+type DragOrigin = {
+    kind: "source";
+} | {
+    kind: "pick";
+    index: number;
+};
+export type TopPicksDragState<T> = {
+    value: T;
+    origin: DragOrigin;
+    /** hovered strip slot — the slot to replace (source drags) or the final
+     * position (pick reorders). null while the pointer is outside the strip */
+    overIndex: number | null;
+    /** index of an already-pinned identical value that blocks the drop */
+    duplicateIndex: number | null;
+    /** signed distance between strip slot centers (for reorder preview) */
+    slotSpan: number;
+} | null;
+export type TopPicksGhost = {
+    /** the ghost's visual. Rendered into `document.body` — outside the
+     * editor's CSS scope, so theme-dependent styling must be resolved from the
+     * rendered DOM (computed styles) rather than CSS variables */
+    content: HTMLElement;
+    /** where the ghost spawns (its size) and flies back to on cancel */
+    rect: DOMRect;
+};
+/** called on pointerdown (the source may not stay mounted until the drag
+ * activates), for every potential drag — keep it cheap */
+export type CreateTopPicksGhost<T> = (args: {
+    value: T;
+    /** the element the drag started on */
+    sourceEl: HTMLElement;
+    /** the registered strip */
+    stripEl: HTMLElement;
+}) => TopPicksGhost;
+export type TopPicksDnD<T> = {
+    dragState: TopPicksDragState<T>;
+    startSourceDrag: (event: React.PointerEvent, value: T | null) => void;
+    startPickDrag: (event: React.PointerEvent, index: number, value: T) => void;
+    setStripEl: (el: HTMLDivElement | null) => void;
+};
+/**
+ * live preview of the reorder result — the translation (px) moving the pick
+ * at `index` to the slot it would occupy if dropped right now
+ */
+export declare const getTopPickReorderOffset: (dragState: TopPicksDragState<unknown>, index: number) => number;
+/** "marching ants" outline hinting that the strip accepts the drop — SVG
+ * because CSS dashed outlines/borders can't animate their dash offset */
+export declare const TopPicksDnDOutline: () => import("react/jsx-runtime").JSX.Element;
+export declare const useTopPicksDnD: <T>({ enabled, picks, onPicksChange, isSamePick, createGhost, }: {
+    enabled: boolean;
+    picks: readonly T[];
+    onPicksChange: (picks: T[]) => void;
+    /** value-equality — pins identical to an existing pick are refused */
+    isSamePick?: (a: T, b: T) => boolean;
+    createGhost: CreateTopPicksGhost<T>;
+}) => TopPicksDnD<T>;
+export {};

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,11 +4,14 @@ 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;
     rc: RoughCanvas;
     renderConfig: StaticCanvasRenderConfig;
+    /** CSS opacity of the whole canvas — a translucent preview of a finished element */
+    opacity?: number;
 }
 declare const NewElementCanvas: (props: NewElementCanvasProps) => import("react/jsx-runtime").JSX.Element;
 export default NewElementCanvas;