@excalidraw/element 0.18.0-063e025 → 0.18.0-1118751

package/dist/types/excalidraw/components/App.drawshape.d.ts

@@ -0,0 +1,55 @@
+import { DrawShapeTrail } from "../drawShapeTrail";
+import type App from "./App";
+import type { PointerDownState } from "../types";
+/**
+ * Captures the App state management for the drawShape tool (free-form
+ * sketch converted into a recognized excalidraw element). Pointer events
+ * are piped here from App.
+ *
+ * The gesture is committed by `finalize()` — recognize → (maybe upgrade
+ * line to arrow) → insert → bind endpoints — which is invoked from within
+ * `actionFinalize`, the editor's single finalization funnel. Whatever
+ * triggers a finalize (the gesture's own pointerup, a mid-gesture paste
+ * switching tools, …), the pending sketch resolves there exactly once.
+ */
+export declare class AppDrawShape {
+    private app;
+    trail: DrawShapeTrail;
+    /** a pointerdown started a sketch that `finalize()` hasn't resolved yet */
+    private gestureInProgress;
+    constructor(app: App);
+    stop: () => void;
+    hasPendingGesture: () => boolean;
+    handlePointerDown: (pointerDownState: PointerDownState) => void;
+    /** returns true when the pointermove was consumed by the shape preview */
+    handlePointerMove: (pointerCoords: {
+        x: number;
+        y: number;
+    }) => boolean;
+    /**
+     * Binds both endpoints of a freshly inserted drawShape arrow to the
+     * bindable elements they hover, if any.
+     *
+     * Endpoints bind in "orbit" mode — the arrow starts/ends at the target's
+     * outline — even when the stroke was started or released inside the shape
+     * (a sketched connector aims at the shape, not at a point inside it). The
+     * exception is a sketch contained in a single shape: both ends then bind
+     * "inside" and stay where they were drawn, like the interactive
+     * inside→inside flow.
+     */
+    private bindRecognizedArrow;
+    /**
+     * A sketched line that connects a bindable element with something else —
+     * another element or blank canvas — was meant as a connector: upgrade it
+     * to an arrow (called before insertion). A line touching no shape, or
+     * contained in a single shape (an annotation, not a connector), stays a
+     * line.
+     */
+    private maybeUpgradeLineToArrow;
+    /**
+     * Commits the pending sketch, if any, and clears the trail. Invoked from
+     * within `actionFinalize` — never call directly, execute `actionFinalize`
+     * instead so element insertion flows into the action's returned elements.
+     */
+    finalize: () => void;
+}

package/dist/types/excalidraw/components/App.duplicate.d.ts

@@ -0,0 +1,51 @@
+import { duplicateElements } from "@excalidraw/element";
+import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { PointerDownState } from "../types";
+import type App from "./App";
+type Duplication = Pick<ReturnType<typeof duplicateElements>, "duplicatedElements" | "duplicateElementsMap" | "origElementsMap" | "origIdToDuplicateId" | "duplicateIdToOrigId">;
+/**
+ * Owns the duplication paths which involve the host (`props.onDuplicate`):
+ * duplicating elements into the scene (paste, library insert etc.), and
+ * duplicating the dragged selection (alt-drag). The duplicate action shares
+ * `runOnDuplicate()`.
+ */
+export declare class AppDuplicate {
+    private app;
+    constructor(app: App);
+    /**
+     * Hands the duplication over to the host's `props.onDuplicate` (if any),
+     * and reconciles what it returned with the duplicates.
+     *
+     * @returns next elements, and the duplicates that weren't vetoed
+     */
+    runOnDuplicate: (duplication: Duplication, nextElements: ExcalidrawElement[], 
+    /** excludes the duplicated elements */
+    prevElements: readonly ExcalidrawElement[]) => {
+        elements: ExcalidrawElement[];
+        duplicatedElements: import("@excalidraw/element/types").NonDeletedExcalidrawElement[];
+    };
+    /**
+     * Duplicates elements so that they end up centered at the scene coords
+     * (and in the frame at that point, if any). Doesn't update the scene.
+     *
+     * @returns `null` if the host vetoed the duplication
+     */
+    duplicateAtSceneCoords: (elements: readonly ExcalidrawElement[], { x, y }: {
+        x: number;
+        y: number;
+    }, opts?: {
+        retainSeed?: boolean;
+        preserveFrameChildrenOrder?: boolean;
+    }) => {
+        nextElements: ExcalidrawElement[];
+        duplicatedElements: import("@excalidraw/element/types").NonDeletedExcalidrawElement[];
+    } | null;
+    /**
+     * Duplicates the selection being dragged: the originals go back to where
+     * the drag started, and the drag continues with the duplicates.
+     *
+     * If the host vetoes the duplication, the originals keep being dragged.
+     */
+    duplicateDraggedSelection: (pointerDownState: PointerDownState, event: PointerEvent) => void;
+}
+export {};

package/dist/types/excalidraw/components/App.flowchart.d.ts

@@ -0,0 +1,21 @@
+import type React from "react";
+import type App from "./App";
+import type { PendingExcalidrawElements } from "../types";
+/**
+ * Captures the App state management for the flowchart functionality.
+ */
+export declare class AppFlowchart {
+    private app;
+    private creator;
+    private navigator;
+    constructor(app: App);
+    get pendingNodes(): PendingExcalidrawElements | null;
+    get isCreatingChart(): boolean;
+    /** ends any in-progress flowchart creation/navigation session */
+    clear: () => void;
+    handleKeyEvent: (event: React.KeyboardEvent | KeyboardEvent) => boolean;
+    private resolveKeyboardEventToOperation;
+    private selectAndReveal;
+    private captureUpdate;
+    private static getLinkDirectionFromKey;
+}

package/dist/types/excalidraw/components/App.pan.d.ts

@@ -0,0 +1,54 @@
+import type React from "react";
+import type App from "./App";
+/**
+ * The drag-pan: a pointer drag that moves the canvas — the wheel or the
+ * secondary button, the main button while space is held or the hand tool
+ * is active, or any button in view mode. One session at a time, owning its
+ * window listeners and teardown; wheel input is gated on it (see
+ * `AppWheel`).
+ *
+ * A secondary-button session is a pan only once the pointer travels past
+ * the drag threshold; released before that, it is a right-click. The
+ * platform's `contextmenu` event opens the menu for a right-click where it
+ * follows the release (Windows), as it always has; where it comes with the
+ * press (macOS, Linux) it is swallowed — a drag cannot be told from a
+ * click yet — and the session opens the menu on release instead.
+ */
+export declare class AppPan {
+    private app;
+    private dependencies;
+    /** space held down turns a main-button drag into a pan */
+    private spaceHeld;
+    private active;
+    /** the secondary-button session, while one is active */
+    private secondary;
+    /** the platform fires `contextmenu` on mouseup (Windows) or on mousedown
+     * (macOS, Linux); the one belonging to a secondary-button session is not a
+     * new click, whichever side of the session it lands on */
+    private suppressNextContextMenu;
+    /** applies the pointer move the session is holding back for its next
+     * frame, if any */
+    private pendingMoveFlush;
+    private teardown;
+    constructor(app: App, dependencies: {
+        /** pointers currently down (a two-finger gesture is not a pan) */
+        getPointerCount: () => number;
+    });
+    isActive: () => boolean;
+    isSpaceHeld: () => boolean;
+    setSpaceHeld: (held: boolean) => void;
+    /** applies the pointer move still waiting for its frame, if any */
+    flushMove: () => void;
+    /** ends the active session, if any — pointerup may never arrive (the user
+     * tabs away, a new pointerdown lands first) */
+    end: () => void;
+    /**
+     * Whether a `contextmenu` event belongs to a secondary-button session and
+     * must not open the menu: it came with the press (the session decides on
+     * release), or it follows a release that turned out to be a drag.
+     */
+    consumesContextMenuEvent: () => boolean;
+    /** starts a session for the pointerdown if it qualifies; returns whether
+     * it did */
+    start: (event: React.PointerEvent<HTMLElement> | MouseEvent) => boolean;
+}

package/dist/types/excalidraw/components/App.toolDrag.d.ts

@@ -0,0 +1,63 @@
+import type { ExcalidrawNonSelectionElement, NonDeleted } from "@excalidraw/element/types";
+import type App from "./App";
+import type { ToolType } from "../types";
+type ScenePoint = {
+    x: number;
+    y: number;
+};
+/** what a drag places: any element the new-element canvas can preview */
+type DraggedElement = NonDeleted<ExcalidrawNonSelectionElement>;
+/**
+ * A tool the user can drag out of the toolbar to drop a default-sized element
+ * where the pointer is released.
+ */
+type DraggableTool = {
+    /** the element the drop creates, centered on the pointer */
+    createElement: (app: App, center: ScenePoint) => DraggedElement;
+    /** what the tool does once its element is on the canvas (e.g. start editing) */
+    onDrop?: (app: App, element: DraggedElement) => void;
+};
+/**
+ * The tools that can be dragged out of the toolbar. Add an entry to make a
+ * tool's button draggable — the gesture, preview and drop are shared.
+ */
+export declare const DRAGGABLE_TOOLS: Partial<Record<ToolType, DraggableTool>>;
+/** CSS opacity of the preview canvas while dragging */
+export declare const TOOL_DRAG_PREVIEW_OPACITY = 0.5;
+/**
+ * Dragging a tool out of the toolbar. The preview element exists only here
+ * until the drop — it is not in the scene, the store or the history, so
+ * collaborators never see it and an aborted drag leaves nothing behind. It
+ * is painted by the `NewElementCanvas`, drawn exactly as it will land, with
+ * the canvas itself made translucent.
+ *
+ * The button arms on pointerdown; the drag starts once the pointer has
+ * moved `DRAGGING_THRESHOLD`, so a plain click still selects the tool. The
+ * gesture lives on the owner window (the pointer leaves the button at once),
+ * like the other pointer gestures in `App`.
+ */
+export declare class AppToolDrag {
+    private app;
+    constructor(app: App);
+    /** the element under the pointer while dragging, `null` otherwise */
+    preview: DraggedElement | null;
+    private armed;
+    private tool;
+    private type;
+    static isDraggable: (type: ToolType) => boolean;
+    isDragging: () => boolean;
+    /**
+     * Arm a drag from a tool button's pointerdown. Returns whether the tool is
+     * draggable (the caller lets a non-draggable press fall through).
+     */
+    handleButtonPointerDown: (type: ToolType, event: PointerEvent) => boolean;
+    private onPointerMove;
+    private onPointerUp;
+    private onKeyDown;
+    /** drop the gesture without a trace */
+    cancel: () => void;
+    private isOverCanvas;
+    private addListeners;
+    private removeListeners;
+}
+export {};

package/dist/types/excalidraw/components/App.viewport.d.ts

@@ -0,0 +1,73 @@
+import { type StylesPanelMode } from "@excalidraw/common";
+import type { NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import { type SetViewportOptions } from "../viewport";
+import type { AppProps, AppState, Offsets, ScrollConstraints, ViewportOffsets, ViewportOffsetsOptions, ViewportUIName } from "../types";
+import type App from "./App";
+export declare const SCROLL_TO_CONTENT_ANIMATION_KEY = "animateScrollToContent";
+export declare const SCROLL_CONSTRAINTS_SNAP_BACK_ANIMATION_KEY = "animateScrollConstraintsSnapBack";
+/** single source of truth for the `--right-sidebar-width` CSS variable */
+export declare const RIGHT_SIDEBAR_WIDTH = 302;
+type Viewport = Pick<AppState, "scrollX" | "scrollY" | "zoom">;
+type AppViewportDependencies = {
+    getContainer: () => HTMLDivElement | null;
+    getStylesPanelMode: () => StylesPanelMode;
+    isGestureActive: () => boolean;
+};
+/**
+ * Rubberband snap-back: animates the viewport from its current (possibly
+ * overscrolled) position back inside the lock box via the shared
+ * AnimationController. No-op when already within the hard bounds (or when
+ * there is no lock).
+ */
+export declare const snapBackToConstraints: (state: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "width" | "height" | "scrollConstraints">, onFrame: (updater: (state: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "width" | "height" | "scrollConstraints">) => Viewport | null) => void, duration?: number) => void;
+/**
+ * Owns viewport state transitions and App-bound viewport concerns. Pure
+ * viewport geometry remains in `viewport.ts` so actions and public helpers can
+ * calculate state without an App instance.
+ */
+export declare class AppViewport {
+    private app;
+    private dependencies;
+    lastPosition: {
+        x: number;
+        y: number;
+    };
+    private activeTransition;
+    private uiLastMeasured;
+    constructor(app: App, dependencies: AppViewportDependencies);
+    get isAnimating(): boolean;
+    /** Whether a programmatic transition into a locked viewport currently owns
+     * user pan/zoom input. */
+    get isLockedTransitionPending(): boolean;
+    invalidateUIOffset: (name: ViewportUIName) => void;
+    /**
+     * Resolves user-supplied viewport offsets into concrete per-side pixel
+     * values. Static sides take precedence over UI-derived sides.
+     */
+    resolveOffsets: (offsets: ViewportOffsets | undefined) => Offsets | undefined;
+    /**
+     * Measures the currently rendered editor UI and returns the usable viewport
+     * offsets, including optional padding and reserved hidden surfaces.
+     */
+    getOffsets: (opts?: ViewportOffsetsOptions) => Offsets;
+    /** Resolves the host-supplied initial viewport against restored scene data. */
+    resolveInitialViewport: (opts: Omit<SetViewportOptions, "animation">, elementsMap: NonDeletedSceneElementsMap, appState: AppState) => (Viewport & {
+        scrollConstraints: ScrollConstraints | null;
+    }) | null;
+    /** Navigates to a target and optionally installs scroll/zoom constraints. */
+    setViewport: (opts: SetViewportOptions | null) => void;
+    /** Use when changing scrollX/scrollY/zoom based on user interaction. */
+    translate: <K extends keyof AppState>(state: AppState | Pick<AppState, K> | null | ((prevState: Readonly<AppState>, props: Readonly<AppProps>) => AppState | Pick<AppState, K> | null), opts?: {
+        zoomPreConstrained?: boolean;
+        preserveScrollConstraintsSnapBack?: boolean;
+    }) => boolean;
+    /** Clamps the viewport into the active scroll constraints. */
+    constrain: (overscroll?: number) => void;
+    /** Releases a held rubberband overscroll. */
+    releaseOverscroll: () => void;
+    private snapBack;
+    private snapBackDebounced;
+    private cancelTransition;
+    destroy: () => void;
+}
+export {};

package/dist/types/excalidraw/components/App.wheel.d.ts

@@ -0,0 +1,26 @@
+import type App from "./App";
+/**
+ * Wheel input over the editor: pans the canvas, or zooms it around the
+ * pointer (`viewport.lastPosition`) — on ctrl/cmd+wheel (which is also how
+ * a trackpad pinch is delivered), while the wheel button itself is held
+ * down, or on a plain wheel when the input device is a mouse
+ * (`appState.inputDevice`). Shift+wheel pans horizontally;
+ * ctrl/cmd+shift+wheel pans vertically.
+ */
+export declare class AppWheel {
+    private app;
+    constructor(app: App);
+    /** the editor surfaces whose wheel input the editor consumes; everywhere
+     * else (menus, sidebars, …) the DOM keeps scrolling. The frame-name labels
+     * are DOM, but sit inside the container this listener is attached to */
+    private isOverEditorSurface;
+    handle: (event: WheelEvent) => void;
+    /**
+     * Prevents the browser's own zoom over the non-interactive editor while
+     * letting regular scroll through (trackpad pinch is delivered as
+     * ctrl+wheel).
+     */
+    preventBrowserZoom: (event: WheelEvent) => void;
+    /** zooms around the pointer by a wheel delta (positive = zoom out) */
+    private zoomBy;
+}

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

@@ -2,7 +2,7 @@ import type { ColorTuple, ColorPaletteCustom } from "@excalidraw/common";
 import type { ExcalidrawElement } from "@excalidraw/element/types";
 import "./ColorPicker.scss";
 import type { ColorPickerType } from "./colorPickerUtils";
-import type { UIAppState } from "../../types";
+import type { AppState, UIAppState } from "../../types";
 interface ColorPickerProps {
     type: ColorPickerType;
     /**
@@ -17,6 +17,12 @@ interface ColorPickerProps {
     palette?: ColorPaletteCustom | null;
     topPicks?: ColorTuple;
     updateData: (formData?: any) => void;
+    /** palette colors to hide from the popup, keeping hotkey positions */
+    excludedColors?: readonly string[];
+    /** allow users to customize the top picks strip by drag & dropping colors
+     * from the picker popup onto it. The value names the
+     * `appState.colorTopPicks` slot the customization is stored in */
+    customizableTopPicks?: keyof AppState["colorTopPicks"];
 }
-export declare const ColorPicker: ({ type, color, onChange, label, elements, palette, topPicks, updateData, appState, }: ColorPickerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ColorPicker: import("react").MemoExoticComponent<({ type, color, onChange, label, elements, palette, topPicks, updateData, appState, excludedColors, customizableTopPicks, }: ColorPickerProps) => import("react/jsx-runtime").JSX.Element>;
 export {};

package/dist/types/excalidraw/components/ColorPicker/CustomColorList.d.ts

@@ -1,8 +1,10 @@
+import type { Theme } from "@excalidraw/element/types";
 interface CustomColorListProps {
+    theme: Theme;
     colors: string[];
     color: string | null;
     onChange: (color: string) => void;
     label: string;
 }
-export declare const CustomColorList: ({ colors, color, onChange, label, }: CustomColorListProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CustomColorList: ({ theme, colors, color, onChange, label, }: CustomColorListProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/excalidraw/components/ColorPicker/Picker.d.ts

@@ -1,8 +1,9 @@
 import React from "react";
-import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { ExcalidrawElement, Theme } from "@excalidraw/element/types";
 import type { ColorPaletteCustom } from "@excalidraw/common";
 import type { ColorPickerType } from "./colorPickerUtils";
 interface PickerProps {
+    theme: Theme;
     color: string | null;
     onChange: (color: string) => void;
     type: ColorPickerType;
@@ -14,6 +15,9 @@ interface PickerProps {
     onEyeDropperToggle: (force?: boolean) => void;
     onEscape: (event: React.KeyboardEvent | KeyboardEvent) => void;
     showHotKey?: boolean;
+    excludedColors?: readonly string[];
+    /** present only while the top picks are customized */
+    onResetTopPicks?: () => void;
 }
 export declare const Picker: React.ForwardRefExoticComponent<PickerProps & React.RefAttributes<unknown>>;
 export {};

package/dist/types/excalidraw/components/ColorPicker/PickerColorList.d.ts

@@ -1,10 +1,17 @@
-import type { ColorPaletteCustom } from "@excalidraw/common";
+import { type ColorPaletteCustom } from "@excalidraw/common";
+import type { Theme } from "@excalidraw/element/types";
 interface PickerColorListProps {
+    theme: Theme;
     palette: ColorPaletteCustom;
     color: string | null;
     onChange: (color: string) => void;
     activeShade: number;
     showHotKey?: boolean;
+    /**
+     * palette colors to hide. Hidden entries keep their position in the hotkey
+     * order (their hotkey goes dead instead of remapping the colors after them).
+     */
+    excludedColors?: readonly string[];
 }
-declare const PickerColorList: ({ palette, color, onChange, activeShade, showHotKey, }: PickerColorListProps) => import("react/jsx-runtime").JSX.Element;
+declare const PickerColorList: ({ theme, palette, color, onChange, activeShade, showHotKey, excludedColors, }: PickerColorListProps) => import("react/jsx-runtime").JSX.Element;
 export default PickerColorList;

package/dist/types/excalidraw/components/ColorPicker/ShadeList.d.ts

@@ -1,9 +1,11 @@
-import type { ColorPaletteCustom } from "@excalidraw/common";
+import { type ColorPaletteCustom } from "@excalidraw/common";
+import type { Theme } from "@excalidraw/element/types";
 interface ShadeListProps {
+    theme: Theme;
     color: string | null;
     onChange: (color: string) => void;
     palette: ColorPaletteCustom;
     showHotKey?: boolean;
 }
-export declare const ShadeList: ({ color, onChange, palette, showHotKey, }: ShadeListProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ShadeList: ({ theme, color, onChange, palette, showHotKey, }: ShadeListProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/excalidraw/components/ColorPicker/TopPicks.d.ts

@@ -1,9 +1,16 @@
+import type { Theme } from "@excalidraw/element/types";
 import type { ColorPickerType } from "./colorPickerUtils";
 interface TopPicksProps {
+    theme: Theme;
     onChange: (color: string) => void;
     type: ColorPickerType;
     activeColor: string | null;
     topPicks?: readonly string[];
+    /** present when the strip is user-customizable — enables the right-click
+     * context menu resetting the strip to its default picks */
+    onReset?: () => void;
+    /** whether custom picks are currently applied (enables the reset item) */
+    isCustomized?: boolean;
 }
-export declare const TopPicks: ({ onChange, type, activeColor, topPicks, }: TopPicksProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const TopPicks: ({ theme, onChange, type, activeColor, topPicks, onReset, isCustomized, }: TopPicksProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/types/excalidraw/components/ColorPicker/colorTopPicksDnD.d.ts

@@ -0,0 +1,11 @@
+import type { TopPicksDnD } from "../TopPicksDnD/topPicksDnD";
+export type ColorPickerDnD = TopPicksDnD<string>;
+export declare const ColorPickerDnDContext: import("react").Context<ColorPickerDnD | null>;
+export declare const useColorPickerDnD: () => ColorPickerDnD | null;
+/** pinning colors from the picker popup (palette/shades/custom) or the
+ * active-color trigger to the top-picks strip, and reordering the strip */
+export declare const useColorTopPicksDnD: ({ enabled, picks, onPicksChange, }: {
+    enabled: boolean;
+    picks: readonly string[];
+    onPicksChange: (picks: string[]) => void;
+}) => ColorPickerDnD;

package/dist/types/excalidraw/components/ColorPicker/keyboardNavHandlers.d.ts

@@ -12,9 +12,10 @@ interface ColorPickerKeyNavHandlerProps {
     activeShade: number;
     onEyeDropperToggle: (force?: boolean) => void;
     onEscape: (event: React.KeyboardEvent | KeyboardEvent) => void;
+    excludedColors?: readonly string[];
 }
 /**
  * @returns true if the event was handled
  */
-export declare const colorPickerKeyNavHandler: ({ event, activeColorPickerSection, palette, color, onChange, customColors, setActiveColorPickerSection, updateData, activeShade, onEyeDropperToggle, onEscape, }: ColorPickerKeyNavHandlerProps) => boolean;
+export declare const colorPickerKeyNavHandler: ({ event, activeColorPickerSection, palette, color, onChange, customColors, setActiveColorPickerSection, updateData, activeShade, onEyeDropperToggle, onEscape, excludedColors, }: ColorPickerKeyNavHandlerProps) => boolean;
 export {};

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

@@ -12,11 +12,14 @@ interface FontPickerProps {
     isOpened: boolean;
     selectedFontFamily: FontFamilyValues | null;
     hoveredFontFamily: FontFamilyValues | null;
+    /** user-customized top picks (`appState.fontTopPicks`) */
+    topPicks: readonly FontFamilyValues[] | null;
     onSelect: (fontFamily: FontFamilyValues) => void;
+    onTopPicksChange: (fontTopPicks: FontFamilyValues[] | null) => void;
     onHover: (fontFamily: FontFamilyValues) => void;
     onLeave: () => void;
     onPopupChange: (open: boolean) => void;
     compactMode?: boolean;
 }
-export declare const FontPicker: React.MemoExoticComponent<({ isOpened, selectedFontFamily, hoveredFontFamily, onSelect, onHover, onLeave, onPopupChange, compactMode, }: FontPickerProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const FontPicker: React.MemoExoticComponent<({ isOpened, selectedFontFamily, hoveredFontFamily, topPicks, onSelect, onTopPicksChange, onHover, onLeave, onPopupChange, compactMode, }: FontPickerProps) => import("react/jsx-runtime").JSX.Element>;
 export {};

package/dist/types/excalidraw/components/FontPicker/FontPickerList.d.ts

@@ -3,6 +3,7 @@ import { type FontFamilyValues } from "@excalidraw/element/types";
 import type { ValueOf } from "@excalidraw/common/utility-types";
 import { DropDownMenuItemBadgeType } from "../dropdownMenu/DropdownMenuItem";
 import type { JSX } from "react";
+import type { ExcalidrawFontFace } from "../../fonts/ExcalidrawFontFace";
 export interface FontDescriptor {
     value: number;
     icon: JSX.Element;
@@ -21,6 +22,10 @@ interface FontPickerListProps {
     onLeave: () => void;
     onOpen: () => void;
     onClose: () => void;
+    /** present only while the top picks are customized */
+    onResetTopPicks?: () => void;
 }
-export declare const FontPickerList: React.MemoExoticComponent<({ selectedFontFamily, hoveredFontFamily, onSelect, onHover, onLeave, onOpen, onClose, }: FontPickerListProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const getFontFamilyIcon: (fontFamily: FontFamilyValues) => JSX.Element;
+export declare const getFontFamilyLabel: (fontFamily: FontFamilyValues, fontFaces: ExcalidrawFontFace[]) => string;
+export declare const FontPickerList: React.MemoExoticComponent<({ selectedFontFamily, hoveredFontFamily, onSelect, onHover, onLeave, onOpen, onClose, onResetTopPicks, }: FontPickerListProps) => import("react/jsx-runtime").JSX.Element>;
 export {};

package/dist/types/excalidraw/components/FontPicker/fontTopPicksDnD.d.ts

@@ -0,0 +1,12 @@
+import type { FontFamilyValues } from "@excalidraw/element/types";
+import type { TopPicksDnD } from "../TopPicksDnD/topPicksDnD";
+export type FontPickerDnD = TopPicksDnD<FontFamilyValues>;
+export declare const FontPickerDnDContext: import("react").Context<FontPickerDnD | null>;
+export declare const useFontPickerDnD: () => FontPickerDnD | null;
+/** pinning fonts from the font picker list to the top-picks strip, and
+ * reordering the strip */
+export declare const useFontTopPicksDnD: ({ enabled, picks, onPicksChange, }: {
+    enabled: boolean;
+    picks: readonly FontFamilyValues[];
+    onPicksChange: (picks: FontFamilyValues[]) => void;
+}) => FontPickerDnD;

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

@@ -0,0 +1,48 @@
+import React from "react";
+import type { PointerType } from "@excalidraw/element/types";
+import "./ToolIcon.scss";
+import type { CSSProperties } from "react";
+export type IconButtonSize = "small" | "medium";
+type IconButtonBaseProps = {
+    icon?: React.ReactNode;
+    "aria-label": string;
+    "aria-keyshortcuts"?: string;
+    "data-testid"?: string;
+    label?: string;
+    title?: string;
+    size?: IconButtonSize;
+    keyBindingLabel?: string | null;
+    showAriaLabel?: boolean;
+    hidden?: boolean;
+    visible?: boolean;
+    disabled?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    isLoading?: boolean;
+};
+type IconButtonProps = (IconButtonBaseProps & {
+    type: "button";
+    children?: React.ReactNode;
+    onClick?(event: React.MouseEvent): void;
+}) | (IconButtonBaseProps & {
+    type: "icon";
+    children?: React.ReactNode;
+    onClick?(): void;
+}) | (IconButtonBaseProps & {
+    type: "toggle";
+    checked: boolean;
+    /**
+     * Fired on activation — a completed pointer gesture (via `click`, so a
+     * press canceled by sliding off the button doesn't select) or
+     * keyboard/AT activation, in which case pointerType is null.
+     * pointerType is captured on pointer-down, where it's reliable
+     * (unlike the click event's own pointerType on iOS).
+     */
+    onSelect?(data: {
+        pointerType: PointerType | null;
+    }): void;
+    /** the press that may become a click — e.g. to arm a drag out of the toolbar */
+    onPointerDown?(event: React.PointerEvent<HTMLButtonElement>): void;
+});
+export declare const IconButton: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<unknown>>;
+export {};

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

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

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

@@ -13,7 +13,6 @@ interface LayerUIProps {
     setAppState: React.Component<any, AppState>["setState"];
     elements: readonly NonDeletedExcalidrawElement[];
     onLockToggle: () => void;
-    onHandToolToggle: () => void;
     onPenModeToggle: AppClassProperties["togglePenMode"];
     showExitZenModeBtn: boolean;
     langCode: Language["code"];
@@ -25,8 +24,12 @@ interface LayerUIProps {
     renderWelcomeScreen: boolean;
     children?: React.ReactNode;
     app: AppClassProperties;
+    defaultUIEnabled: boolean;
+    zoomUIEnabled: boolean;
+    scrollBackToContentUIEnabled: boolean;
     isCollaborating: boolean;
     generateLinkForSelection?: AppProps["generateLinkForSelection"];
+    currentUserControls?: ExcalidrawProps["currentUserControls"];
 }
-declare const _default: React.MemoExoticComponent<({ actionManager, appState, files, setAppState, elements, canvas, onLockToggle, onHandToolToggle, onPenModeToggle, showExitZenModeBtn, renderTopLeftUI, renderTopRightUI, renderCustomStats, UIOptions, onExportImage, renderWelcomeScreen, children, app, isCollaborating, generateLinkForSelection, }: LayerUIProps) => import("react/jsx-runtime").JSX.Element>;
+declare const _default: React.MemoExoticComponent<({ actionManager, appState, files, setAppState, elements, canvas, onLockToggle, onPenModeToggle, showExitZenModeBtn, renderTopLeftUI, renderTopRightUI, renderCustomStats, UIOptions, onExportImage, renderWelcomeScreen, children, app, defaultUIEnabled, zoomUIEnabled, scrollBackToContentUIEnabled, isCollaborating, generateLinkForSelection, currentUserControls, }: LayerUIProps) => import("react/jsx-runtime").JSX.Element>;
 export default _default;

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

@@ -1,10 +1,9 @@
-import "./ToolIcon.scss";
-type LockIconProps = {
+type LockButtonProps = {
     title?: string;
-    name?: string;
     checked: boolean;
     onChange?(): void;
     isMobile?: boolean;
+    disabled?: boolean;
 };
-export declare const LockButton: (props: LockIconProps) => import("react/jsx-runtime").JSX.Element;
+export declare const LockButton: (props: LockButtonProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,9 +1,7 @@
-import "./ToolIcon.scss";
 import type { JSX } from "react";
 export declare const ElementCanvasButton: (props: {
     title?: string;
     icon: JSX.Element;
-    name?: string;
     checked: boolean;
     onChange?(): void;
     isMobile?: boolean;