@excalidraw/math 0.18.0-1b287a8ba → 0.18.0-214cd6e

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

@@ -0,0 +1,37 @@
+import type { AppState, UnsubscribeCallback } from "../types";
+type StateChangeSelector = keyof AppState | (keyof AppState)[] | ((appState: AppState) => unknown);
+export type OnStateChange = {
+    <K extends keyof AppState>(prop: K, callback: (value: AppState[K], appState: AppState) => void, opts?: {
+        once: boolean;
+    }): UnsubscribeCallback;
+    <K extends keyof AppState>(prop: K): Promise<AppState[K]>;
+    (prop: (keyof AppState)[], callback: (appState: AppState, appState2: AppState) => void, opts?: {
+        once: boolean;
+    }): UnsubscribeCallback;
+    (prop: (keyof AppState)[]): Promise<AppState>;
+    <T>(prop: (appState: AppState) => T, callback: (value: T, appState: AppState) => void, opts?: {
+        once: boolean;
+    }): UnsubscribeCallback;
+    <T>(prop: (appState: AppState) => T): Promise<T>;
+    (opts: {
+        predicate: (appState: AppState) => boolean;
+        callback: (appState: AppState) => void;
+        once?: boolean;
+    }): UnsubscribeCallback;
+    (opts: {
+        predicate: (appState: AppState) => boolean;
+    }): Promise<AppState>;
+    (selector: StateChangeSelector, callback: (value: any, appState: AppState) => void): any;
+};
+export declare class AppStateObserver {
+    private readonly getState;
+    private listeners;
+    constructor(getState: () => AppState);
+    private isStateChangePredicateOptions;
+    private subscribe;
+    private normalize;
+    onStateChange: OnStateChange;
+    flush(prevState: AppState): void;
+    clear(): void;
+}
+export {};

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

@@ -1,7 +1,5 @@
-/// <reference types="react" />
-import OpenColor from "open-color";
 import "./Card.scss";
 export declare const Card: React.FC<{
-    color: keyof OpenColor | "primary";
+    color: "primary" | "lime" | "pink";
     children?: React.ReactNode;
 }>;

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

@@ -1,10 +1,8 @@
 import type { ColorPickerType } from "./colorPickerUtils";
-interface ColorInputProps {
+export declare const ColorInput: ({ color, onChange, label, colorPickerType, placeholder, }: {
     color: string;
     onChange: (color: string) => void;
     label: string;
     colorPickerType: ColorPickerType;
     placeholder?: string;
-}
-export declare const ColorInput: ({ color, onChange, label, colorPickerType, placeholder, }: ColorInputProps) => import("react/jsx-runtime").JSX.Element;
-export {};
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -2,8 +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 { AppState } from "../../types";
-export declare const getColor: (color: string) => string | null;
+import type { AppState, UIAppState } from "../../types";
 interface ColorPickerProps {
     type: ColorPickerType;
     /**
@@ -14,10 +13,16 @@ interface ColorPickerProps {
     onChange: (color: string) => void;
     label: string;
     elements: readonly ExcalidrawElement[];
-    appState: AppState;
+    appState: UIAppState;
     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;
@@ -10,8 +11,11 @@ interface PickerProps {
     palette: ColorPaletteCustom;
     updateData: (formData?: any) => void;
     children?: React.ReactNode;
+    showTitle?: boolean;
     onEyeDropperToggle: (force?: boolean) => void;
     onEscape: (event: React.KeyboardEvent | KeyboardEvent) => void;
+    showHotKey?: boolean;
+    excludedColors?: readonly string[];
 }
 export declare const Picker: React.ForwardRefExoticComponent<PickerProps & React.RefAttributes<unknown>>;
 export {};

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

@@ -1,9 +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, }: 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,8 +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 }: 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/colorPickerUtils.d.ts

@@ -14,8 +14,7 @@ export declare const isCustomColor: ({ color, palette, }: {
 }) => boolean;
 export declare const getMostUsedCustomColors: (elements: readonly ExcalidrawElement[], type: "elementBackground" | "elementStroke", palette: ColorPaletteCustom) => string[];
 export type ActiveColorPickerSectionAtomType = "custom" | "baseColors" | "shades" | "hex" | null;
-export declare const activeColorPickerSectionAtom: import("jotai/vanilla/atom").PrimitiveAtom<ActiveColorPickerSectionAtomType> & {
+export declare const activeColorPickerSectionAtom: import("jotai").PrimitiveAtom<ActiveColorPickerSectionAtomType> & {
     init: ActiveColorPickerSectionAtomType;
 };
-export declare const isColorDark: (color: string, threshold?: number) => boolean;
 export type ColorPickerType = "canvasBackground" | "elementBackground" | "elementStroke";

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import type { ColorPaletteCustom } from "@excalidraw/common";
 import type { ActiveColorPickerSectionAtomType } from "./colorPickerUtils";
 interface ColorPickerKeyNavHandlerProps {
@@ -13,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/ColorPicker/topPicksDnD.d.ts

@@ -0,0 +1,31 @@
+type DragOrigin = {
+    kind: "swatch";
+} | {
+    kind: "pick";
+    index: number;
+};
+export type TopPicksDragState = {
+    color: string;
+    origin: DragOrigin;
+    /** hovered strip slot — the slot to replace (swatch drags) or the final
+     * position (pick reorders). null while the pointer is outside the strip */
+    overIndex: number | null;
+    /** index of an already-pinned identical color that blocks the drop */
+    duplicateIndex: number | null;
+    /** signed distance between strip slot centers (for reorder preview) */
+    slotSpan: number;
+} | null;
+export type ColorPickerDnD = {
+    dragState: TopPicksDragState;
+    startSwatchDrag: (event: React.PointerEvent, color: string | null) => void;
+    startPickDrag: (event: React.PointerEvent, index: number, color: string) => void;
+    setStripEl: (el: HTMLDivElement | null) => void;
+};
+export declare const ColorPickerDnDContext: import("react").Context<ColorPickerDnD | null>;
+export declare const useColorPickerDnD: () => ColorPickerDnD | null;
+export declare const useTopPicksDnD: ({ enabled, picks, onPicksChange, }: {
+    enabled: boolean;
+    picks: readonly string[];
+    onPicksChange: (picks: string[]) => void;
+}) => ColorPickerDnD;
+export {};

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

@@ -8,6 +8,7 @@ export declare const DEFAULT_CATEGORIES: {
     editor: string;
     elements: string;
     links: string;
+    library: string;
 };
 type CommandPaletteProps = {
     customCommandPaletteItems?: CommandPaletteItem[];

package/dist/types/excalidraw/components/CommandPalette/defaultCommandPaletteItems.d.ts

@@ -1,2 +1 @@
-import type { CommandPaletteItem } from "./types";
-export declare const toggleTheme: CommandPaletteItem;
+export {};

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

@@ -1,7 +1,5 @@
-/// <reference types="react" />
 import type { ActionManager } from "../../actions/manager";
 import type { Action } from "../../actions/types";
-import type { UIAppState } from "../../types";
 export type CommandPaletteItem = {
     label: string;
     /** additional keywords to match against
@@ -12,11 +10,11 @@ export type CommandPaletteItem = {
      * (deburred name + keywords)
      */
     haystack?: string;
-    icon?: React.ReactNode | ((appState: UIAppState) => React.ReactNode);
+    icon?: Action["icon"];
     category: string;
     order?: number;
     predicate?: boolean | Action["predicate"];
-    shortcut?: string;
+    shortcut?: string | null;
     /** if false, command will not show while in view mode */
     viewMode?: boolean;
     perform: (data: {

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

@@ -2,7 +2,7 @@ import type { ConvertibleTypes, ExcalidrawElement, ExcalidrawTextContainer, Exca
 import type { Scene } from "@excalidraw/element";
 import "./ConvertElementTypePopup.scss";
 import type App from "./App";
-export declare const convertElementTypePopupAtom: import("jotai/vanilla/atom").PrimitiveAtom<{
+export declare const convertElementTypePopupAtom: import("jotai").PrimitiveAtom<{
     type: "panel";
 } | null> & {
     init: {
@@ -16,8 +16,8 @@ export declare const adjustBoundTextSize: (container: ExcalidrawTextContainer, b
 type ConversionType = "generic" | "linear" | null;
 export declare const convertElementTypes: (app: App, { conversionType, nextType, direction, }: {
     conversionType: ConversionType;
-    nextType?: ConvertibleTypes | undefined;
-    direction?: "left" | "right" | undefined;
+    nextType?: ConvertibleTypes;
+    direction?: "left" | "right";
 }) => boolean;
-export declare const getConversionTypeFromElements: (elements: ExcalidrawElement[]) => ConversionType;
+export declare const getConversionTypeFromElements: (elements: readonly ExcalidrawElement[]) => ConversionType;
 export default ConvertElementTypePopup;

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

@@ -0,0 +1,46 @@
+import "./CursorHint.scss";
+import type { AppClassProperties, AppState } from "../types";
+/**
+ * While a recently shown hint is still fresh in memory, tool-switch hints
+ * are suppressed (repeatedly re-picking a tool you just used doesn't need
+ * the reminder). Cycling arrow types and numeric shortcuts bypass this.
+ */
+export declare const CURSOR_HINT_COOLDOWN: number;
+export declare const cursorHintAtom: import("jotai").PrimitiveAtom<{
+    content: React.ReactNode;
+    /** unique per trigger so a re-trigger restarts the hide timer */
+    nonce: number;
+} | null> & {
+    init: {
+        content: React.ReactNode;
+        /** unique per trigger so a re-trigger restarts the hide timer */
+        nonce: number;
+    } | null;
+};
+/**
+ * Owns the cursor-hint policy. App reports semantic interaction events
+ * (what the user did); all decisions about whether and what to show —
+ * cooldown, bypasses, hint content — are made here.
+ */
+export declare class CursorHints {
+    private app;
+    private lastShownAt;
+    constructor(app: AppClassProperties);
+    /**
+     * Shows a transient tooltip next to the cursor, hidden automatically
+     * after a short delay. Repeated calls replace the content and restart
+     * the timer.
+     */
+    show: (content: React.ReactNode) => void;
+    private isOnCooldown;
+    /** arrow type cycled via shortcut (arrow tool already active) */
+    onArrowTypeCycled: (arrowType: AppState["currentItemArrowType"]) => void;
+    /** arrow/line tool picked via keyboard shortcut */
+    onToolShortcut: (tool: "arrow" | "line", source: "letter" | "digit") => void;
+}
+/**
+ * Transient tooltip shown next to the cursor for added affordance after
+ * actions that have no other visual feedback near the pointer (e.g. cycling
+ * arrow types via shortcut). Trigger via `app.cursorHints`.
+ */
+export declare const CursorHint: () => import("react/jsx-runtime").JSX.Element | null;

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

@@ -3,5 +3,5 @@ import "./ToolIcon.scss";
 export declare const DarkModeToggle: (props: {
     value: Theme;
     onChange: (value: Theme) => void;
-    title?: string | undefined;
+    title?: string;
 }) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,26 +1,22 @@
-/// <reference types="react" />
 import type { MarkOptional } from "@excalidraw/common/utility-types";
 import "../components/dropdownMenu/DropdownMenu.scss";
 import type { SidebarProps, SidebarTriggerProps } from "./Sidebar/common";
 export declare const DefaultSidebar: import("react").FC<Omit<MarkOptional<Omit<{
-    name: string;
-    children: import("react").ReactNode;
-    onStateChange?: ((state: {
-        name: string;
-        tab?: string | undefined;
-    } | null) => void) | undefined;
-    onDock?: ((docked: boolean) => void) | undefined;
-    docked?: boolean | undefined;
-    className?: string | undefined;
-    __fallback?: boolean | undefined;
+    name: import("../types").SidebarName;
+    children: React.ReactNode;
+    onStateChange?: (state: import("../types").AppState["openSidebar"]) => void;
+    onDock?: (docked: boolean) => void;
+    docked?: boolean;
+    className?: string;
+    __fallback?: boolean;
 }, "name">, "children">, "onDock"> & {
     /** pass `false` to disable docking */
     onDock?: SidebarProps["onDock"] | false;
 } & {
-    __fallback?: boolean | undefined;
+    __fallback?: boolean;
 }> & {
     Trigger: import("react").FC<Omit<SidebarTriggerProps, "name"> & import("react").HTMLAttributes<HTMLDivElement> & {
-        __fallback?: boolean | undefined;
+        __fallback?: boolean;
     }>;
     TabTriggers: {
         ({ children }: {

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

@@ -6,7 +6,7 @@ declare const ElementLinkDialog: ({ sourceElementId, onClose, appState, scene, g
     sourceElementId: ExcalidrawElement["id"];
     appState: UIAppState;
     scene: Scene;
-    onClose?: (() => void) | undefined;
+    onClose?: () => void;
     generateLinkForSelection: AppProps["generateLinkForSelection"];
 }) => import("react/jsx-runtime").JSX.Element;
 export default ElementLinkDialog;

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 export declare const Ellipsify: ({ children, ...rest }: {
     children: React.ReactNode;
-} & import("react").HTMLAttributes<HTMLSpanElement>) => import("react/jsx-runtime").JSX.Element;
+} & React.HTMLAttributes<HTMLSpanElement>) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,5 +1,5 @@
 import React from "react";
 export declare const ErrorDialog: ({ children, onClose, }: {
     children?: React.ReactNode;
-    onClose?: (() => void) | undefined;
+    onClose?: () => void;
 }) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import type { ExcalidrawElement } from "@excalidraw/element/types";
 import "./EyeDropper.scss";
 import type { ColorPickerType } from "./ColorPicker/colorPickerUtils";
@@ -14,7 +13,7 @@ export type EyeDropperProperties = {
      **/
     colorPickerType: ColorPickerType;
 };
-export declare const activeEyeDropperAtom: import("jotai/vanilla/atom").PrimitiveAtom<EyeDropperProperties | null> & {
+export declare const activeEyeDropperAtom: import("jotai").PrimitiveAtom<EyeDropperProperties | null> & {
     init: EyeDropperProperties | null;
 };
 export declare const EyeDropper: React.FC<{

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

@@ -4,7 +4,7 @@ export type ButtonVariant = "filled" | "outlined" | "icon";
 export type ButtonColor = "primary" | "danger" | "warning" | "muted" | "success";
 export type ButtonSize = "medium" | "large";
 export type FilledButtonProps = {
-    label: string;
+    label?: string;
     children?: React.ReactNode;
     onClick?: (event: React.MouseEvent) => void;
     status?: null | "loading" | "success";
@@ -14,5 +14,6 @@ export type FilledButtonProps = {
     className?: string;
     fullWidth?: boolean;
     icon?: React.ReactNode;
+    disabled?: boolean;
 };
 export declare const FilledButton: React.ForwardRefExoticComponent<FilledButtonProps & React.RefAttributes<HTMLButtonElement>>;

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

@@ -16,6 +16,7 @@ interface FontPickerProps {
     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, }: FontPickerProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const FontPicker: React.MemoExoticComponent<({ isOpened, selectedFontFamily, hoveredFontFamily, onSelect, onHover, onLeave, onPopupChange, compactMode, }: FontPickerProps) => import("react/jsx-runtime").JSX.Element>;
 export {};

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

@@ -1,6 +1,8 @@
 import type { FontFamilyValues } from "@excalidraw/element/types";
 interface FontPickerTriggerProps {
     selectedFontFamily: FontFamilyValues | null;
+    isOpened?: boolean;
+    compactMode?: boolean;
 }
-export declare const FontPickerTrigger: ({ selectedFontFamily, }: FontPickerTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FontPickerTrigger: ({ selectedFontFamily, isOpened, compactMode, }: FontPickerTriggerProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import type { Node } from "@excalidraw/common";
 import { type FontDescriptor } from "./FontPickerList";
 interface FontPickerKeyNavHandlerProps {

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

@@ -1,4 +1,4 @@
 import "./HelpDialog.scss";
 export declare const HelpDialog: ({ onClose }: {
-    onClose?: (() => void) | undefined;
+    onClose?: () => void;
 }) => import("react/jsx-runtime").JSX.Element;