@excalidraw/element 0.18.0-abeeaeb → 0.18.0-afa3a65

package/dist/types/excalidraw/actions/actionToggleMidpointSnapping.d.ts

@@ -62,6 +62,8 @@ export declare const actionToggleMidpointSnapping: {
             exportWithDarkMode: boolean;
             exportScale: number;
             currentItemStrokeColor: string;
+            currentItemStickynoteStrokeColor: string;
+            currentItemStickynoteBackgroundColor: string;
             currentItemBackgroundColor: string;
             currentItemFillStyle: import("@excalidraw/element/types").ExcalidrawElement["fillStyle"];
             currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
@@ -171,6 +173,8 @@ export declare const actionToggleMidpointSnapping: {
                 elementStroke: readonly string[] | null;
                 elementBackground: readonly string[] | null;
                 bucketFill: readonly string[] | null;
+                stickyNoteStroke: readonly string[] | null;
+                stickyNoteBackground: readonly string[] | null;
             };
         };
         captureUpdate: "NEVER";

package/dist/types/excalidraw/actions/actionToggleObjectsSnapMode.d.ts

@@ -65,6 +65,8 @@ export declare const actionToggleObjectsSnapMode: {
             exportWithDarkMode: boolean;
             exportScale: number;
             currentItemStrokeColor: string;
+            currentItemStickynoteStrokeColor: string;
+            currentItemStickynoteBackgroundColor: string;
             currentItemBackgroundColor: string;
             currentItemFillStyle: import("@excalidraw/element/types").ExcalidrawElement["fillStyle"];
             currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
@@ -172,6 +174,8 @@ export declare const actionToggleObjectsSnapMode: {
                 elementStroke: readonly string[] | null;
                 elementBackground: readonly string[] | null;
                 bucketFill: readonly string[] | null;
+                stickyNoteStroke: readonly string[] | null;
+                stickyNoteBackground: readonly string[] | null;
             };
         };
         captureUpdate: "EVENTUALLY";

package/dist/types/excalidraw/actions/actionToggleSearchMenu.d.ts

@@ -70,6 +70,8 @@ export declare const actionToggleSearchMenu: {
             exportWithDarkMode: boolean;
             exportScale: number;
             currentItemStrokeColor: string;
+            currentItemStickynoteStrokeColor: string;
+            currentItemStickynoteBackgroundColor: string;
             currentItemBackgroundColor: string;
             currentItemFillStyle: import("@excalidraw/element/types").ExcalidrawElement["fillStyle"];
             currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
@@ -158,6 +160,8 @@ export declare const actionToggleSearchMenu: {
                 elementStroke: readonly string[] | null;
                 elementBackground: readonly string[] | null;
                 bucketFill: readonly string[] | null;
+                stickyNoteStroke: readonly string[] | null;
+                stickyNoteBackground: readonly string[] | null;
             };
         };
         captureUpdate: "EVENTUALLY";

package/dist/types/excalidraw/actions/actionToggleStats.d.ts

@@ -67,6 +67,8 @@ export declare const actionToggleStats: {
             exportWithDarkMode: boolean;
             exportScale: number;
             currentItemStrokeColor: string;
+            currentItemStickynoteStrokeColor: string;
+            currentItemStickynoteBackgroundColor: string;
             currentItemBackgroundColor: string;
             currentItemFillStyle: import("@excalidraw/element/types").ExcalidrawElement["fillStyle"];
             currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
@@ -172,6 +174,8 @@ export declare const actionToggleStats: {
                 elementStroke: readonly string[] | null;
                 elementBackground: readonly string[] | null;
                 bucketFill: readonly string[] | null;
+                stickyNoteStroke: readonly string[] | null;
+                stickyNoteBackground: readonly string[] | null;
             };
         };
         captureUpdate: "EVENTUALLY";

package/dist/types/excalidraw/actions/actionToggleViewMode.d.ts

@@ -64,6 +64,8 @@ export declare const actionToggleViewMode: {
             exportWithDarkMode: boolean;
             exportScale: number;
             currentItemStrokeColor: string;
+            currentItemStickynoteStrokeColor: string;
+            currentItemStickynoteBackgroundColor: string;
             currentItemBackgroundColor: string;
             currentItemFillStyle: import("@excalidraw/element/types").ExcalidrawElement["fillStyle"];
             currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
@@ -172,6 +174,8 @@ export declare const actionToggleViewMode: {
                 elementStroke: readonly string[] | null;
                 elementBackground: readonly string[] | null;
                 bucketFill: readonly string[] | null;
+                stickyNoteStroke: readonly string[] | null;
+                stickyNoteBackground: readonly string[] | null;
             };
         };
         captureUpdate: "EVENTUALLY";

package/dist/types/excalidraw/actions/actionToggleZenMode.d.ts

@@ -64,6 +64,8 @@ export declare const actionToggleZenMode: {
             exportWithDarkMode: boolean;
             exportScale: number;
             currentItemStrokeColor: string;
+            currentItemStickynoteStrokeColor: string;
+            currentItemStickynoteBackgroundColor: string;
             currentItemBackgroundColor: string;
             currentItemFillStyle: import("@excalidraw/element/types").ExcalidrawElement["fillStyle"];
             currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
@@ -172,6 +174,8 @@ export declare const actionToggleZenMode: {
                 elementStroke: readonly string[] | null;
                 elementBackground: readonly string[] | null;
                 bucketFill: readonly string[] | null;
+                stickyNoteStroke: readonly string[] | null;
+                stickyNoteBackground: readonly string[] | null;
             };
         };
         captureUpdate: "EVENTUALLY";

package/dist/types/excalidraw/actions/colorTargets.d.ts

@@ -0,0 +1,39 @@
+import type { ColorPaletteCustom, ColorTuple } from "@excalidraw/common";
+import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { AppState } from "../types";
+export type ColorProperty = "strokeColor" | "backgroundColor";
+/**
+ * Sticky notes are their own color domain: own defaults, own top picks, no
+ * transparent. A pick targets the regular domain, the sticky domain, or both
+ * ("mixed" selections write both defaults and use the regular picker).
+ */
+export type ColorTargetKind = "regular" | "sticky" | "mixed";
+export type ColorDefaultKey = "currentItemStrokeColor" | "currentItemBackgroundColor" | "currentItemStickynoteStrokeColor" | "currentItemStickynoteBackgroundColor";
+export type ColorTargetAppState = Pick<AppState, "selectedElementIds" | "editingTextElement" | "activeTool" | ColorDefaultKey>;
+export type ColorTarget = {
+    kind: ColorTargetKind;
+    property: ColorProperty;
+    /** the current-item defaults a pick is written to (normalized per domain) */
+    appStateKeys: readonly ColorDefaultKey[];
+    /** the default shown when no element is targeted */
+    currentValue: string;
+    palette: ColorPaletteCustom;
+    topPicks: ColorTuple;
+    customizableTopPicks: keyof AppState["colorTopPicks"];
+    excludedColors: readonly string[] | undefined;
+};
+/**
+ * Who a stroke/background pick targets. Resolve it from the state an action
+ * runs against, at execution time — never capture it in a render closure:
+ * the memoized picker keeps a stale `onChange`, and the always-visible top
+ * picks fire it without a re-render.
+ *
+ * Targets are the selected color-capable elements (for stroke incl. bound
+ * labels, since a note's visible text is its label) plus the text being
+ * edited (`handleTextWysiwyg` deselects while editing) — or, for a
+ * background pick on a note's label, the note (see `getColorTargetElement`).
+ * With no target, the active tool decides the domain.
+ */
+export declare const resolveColorTarget: (appState: ColorTargetAppState, elements: readonly ExcalidrawElement[], property: ColorProperty) => ColorTarget;
+/** the current-item default updates for a picked color */
+export declare const getColorTargetAppStateUpdates: (target: ColorTarget, color: string) => Partial<AppState>;

package/dist/types/excalidraw/appState.d.ts

@@ -44,6 +44,8 @@ export declare const clearAppStateForLocalStorage: (appState: Partial<AppState>)
     exportEmbedScene?: boolean | undefined;
     exportWithDarkMode?: boolean | undefined;
     currentItemStrokeColor?: string | undefined;
+    currentItemStickynoteStrokeColor?: string | undefined;
+    currentItemStickynoteBackgroundColor?: string | undefined;
     currentItemBackgroundColor?: string | undefined;
     currentItemFillStyle?: import("@excalidraw/element/types").FillStyle | undefined;
     currentItemStrokeWidthKey?: import("@excalidraw/common").StrokeWidthKey | undefined;
@@ -82,6 +84,8 @@ export declare const clearAppStateForLocalStorage: (appState: Partial<AppState>)
         elementStroke: readonly string[] | null;
         elementBackground: readonly string[] | null;
         bucketFill: readonly string[] | null;
+        stickyNoteStroke: readonly string[] | null;
+        stickyNoteBackground: readonly string[] | null;
     } | undefined;
 };
 export declare const cleanAppStateForExport: (appState: Partial<AppState>) => {

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

@@ -1,15 +1,23 @@
+import { LinearElementEditor } from "@excalidraw/element";
 import type { ArrowEndpoint } from "@excalidraw/element";
-import type { ExcalidrawElement, ExcalidrawTextElement, FixedPoint, NonDeleted } from "@excalidraw/element/types";
+import type { ExcalidrawElement, ExcalidrawTextElement, FixedPoint, NonDeleted, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type App from "./App";
-import type { AppState } from "../types";
+import type { AppState, PointerDownState } from "../types";
 /**
- * The text tool's interaction with arrows: the hover affordance showing where
- * a click would attach text to an arrow — a free endpoint (binds the arrow to
- * a new text element positioned against that endpoint) or the arrow's midpoint
- * (adds a label bound to the arrow) — and the endpoint-bound flavor of
- * drag-sizing a new text.
+ * Text ↔ arrow interactions.
  *
- * The scene-level logic lives in `@excalidraw/element`'s `arrowEndpointText.ts`.
+ * With the text tool: the hover affordance showing where a click would attach
+ * text to an arrow — a free endpoint (binds the arrow to a new text element
+ * positioned against that endpoint) or the arrow's midpoint (adds a label
+ * bound to the arrow) — and the endpoint-bound flavor of drag-sizing a new
+ * text.
+ *
+ * With the selection tool: dragging an arrow's existing label along the arrow
+ * — the grab affordance, the drag itself, and where a double-click starts
+ * editing a label the drag has moved.
+ *
+ * The scene-level logic lives in `@excalidraw/element`'s
+ * `arrowEndpointText.ts` and `linearElementEditor.ts`.
  */
 export declare class AppArrowText {
     private app;
@@ -69,4 +77,28 @@ export declare class AppArrowText {
         x: number;
         y: number;
     }): boolean;
+    /**
+     * Whether the arrow's label is what a grab at this position would pick up:
+     * the pointer is over the label, and no element stacked above the arrow
+     * owns the hit instead.
+     */
+    isBoundTextGrabbable(element: NonDeletedExcalidrawElement, x: number, y: number): boolean;
+    /**
+     * The pointer-move half of dragging a label along its arrow. Owns the move
+     * whenever the gesture started on the label (`pointerDownState.hit.arrowLabel`),
+     * dragging only once past the threshold. Returns whether it owned it.
+     */
+    maybeDragLabel(linearElementEditor: LinearElementEditor, pointerDownState: PointerDownState, pointerCoords: {
+        x: number;
+        y: number;
+    }): boolean;
+    /**
+     * Where a double-click on a labeled arrow should start text editing: the
+     * center of the label itself, which a label drag may have moved away from
+     * the arrow's midpoint. Null when the element is not a labeled arrow.
+     */
+    getLabelCenter(element: ExcalidrawElement): {
+        x: number;
+        y: number;
+    } | null;
 }

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

@@ -24,6 +24,14 @@ export declare class AppCursor {
     reset: () => void;
     /** applies the given tool's cursor (defaults to the active tool) */
     applyForTool: (activeTool?: AppState["activeTool"]) => void;
+    /**
+     * Re-runs the hover cursor logic at the last known pointer position by
+     * re-dispatching a synthetic pointermove — for state changes that alter
+     * what hovering means without the pointer moving (e.g. the tool reverting
+     * to selection after an element is created). Mouse only: touch and pen
+     * have no resting hover to restore.
+     */
+    refreshHover: () => void;
     /** clears the inline cursor so the environment default (CSS) applies */
     private clear;
     private applyEraser;

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

@@ -3,6 +3,7 @@ import { AppEventBus, type EXPORT_IMAGE_TYPES, Emitter, type EditorInterface, ty
 import { LinearElementEditor, Scene, Store, type ElementUpdate, StoreDelta, type ApplyToOptions } from "@excalidraw/element";
 import type { LocalPoint, Radians } from "@excalidraw/math";
 import type { ExcalidrawElement, ExcalidrawTextElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawTextContainer, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered, SceneElementsMap } from "@excalidraw/element/types";
+import type { ArrowEndpoint, TransformHandleDirection } from "@excalidraw/element";
 import type { Mutable } from "@excalidraw/common/utility-types";
 import { ActionManager } from "../actions/manager";
 import { History } from "../history";
@@ -16,6 +17,7 @@ import { LassoTrail } from "../lasso";
 import { EraserTrail } from "../eraser";
 import { AppArrowText } from "./App.arrowText";
 import { AppBucketFill } from "./App.bucketFill";
+import { AppToolDrag } from "./App.toolDrag";
 import { AppCursor } from "./App.cursor";
 import { AppDrawShape } from "./App.drawshape";
 import { AppFlowchart } from "./App.flowchart";
@@ -82,6 +84,8 @@ declare class App extends React.Component<AppProps, AppState> {
     editorInterface: EditorInterface;
     private stylesPanelMode;
     private excalidrawContainerRef;
+    get ownerDocument(): Document;
+    get ownerWindow(): Window & typeof globalThis;
     scene: Scene;
     fonts: Fonts;
     renderer: Renderer;
@@ -93,7 +97,7 @@ declare class App extends React.Component<AppProps, AppState> {
     library: AppClassProperties["library"];
     libraryItemsFromStorage: LibraryItems | undefined;
     id: string;
-    private store;
+    store: Store;
     private history;
     excalidrawContainerValue: {
         container: HTMLDivElement | null;
@@ -119,6 +123,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private appStateObserver;
     onStateChange: OnStateChange;
     bucketFill: AppBucketFill;
+    toolDrag: AppToolDrag;
     flowchart: AppFlowchart;
     cursor: AppCursor;
     arrowText: AppArrowText;
@@ -127,6 +132,13 @@ declare class App extends React.Component<AppProps, AppState> {
     private textWysiwygSubmitHandler;
     hitLinkElement?: NonDeletedExcalidrawElement;
     lastPointerDownEvent: React.PointerEvent<HTMLElement> | null;
+    /**
+     * the handle of the resize in progress while `state.isResizing` — for UI
+     * that words itself by handle (a sticky note's corners resize
+     * proportionally, its edges freely); not app state, so it costs no
+     * re-render of its own
+     */
+    activeResizeHandle: TransformHandleDirection | null;
     lastPointerUpEvent: React.PointerEvent<HTMLElement> | PointerEvent | null;
     lastPointerUpIsDoubleClick: boolean;
     lastPointerMoveEvent: PointerEvent | null;
@@ -185,6 +197,7 @@ declare class App extends React.Component<AppProps, AppState> {
             wasAddedToSelection: boolean;
             hasBeenDuplicated: boolean;
             hasHitCommonBoundingBoxOfSelectedElements: boolean;
+            arrowLabel: boolean;
         };
         withCmdOrCtrl: boolean;
         drag: {
@@ -247,6 +260,7 @@ declare class App extends React.Component<AppProps, AppState> {
             wasAddedToSelection: boolean;
             hasBeenDuplicated: boolean;
             hasHitCommonBoundingBoxOfSelectedElements: boolean;
+            arrowLabel: boolean;
         };
         withCmdOrCtrl: boolean;
         drag: {
@@ -363,6 +377,11 @@ declare class App extends React.Component<AppProps, AppState> {
     getEffectiveGridSize: () => NullableGridSize;
     private getTextCreationGridPoint;
     private getHTMLIFrameElement;
+    /**
+     * AI-generated iframe elements aren't interactive while their generation
+     * is still in progress (the partial content is render-only).
+     */
+    private isIframeLikeInteractive;
     private handleIframeLikeElementHover;
     /** @returns true if iframe-like element click handled */
     private handleIframeLikeCenterClick;
@@ -571,9 +590,12 @@ declare class App extends React.Component<AppProps, AppState> {
     }) & {
         preferSelected?: boolean;
     }): NonDeleted<ExcalidrawElement> | null;
-    private getElementsAtPosition;
+    getElementsAtPosition(x: number, y: number, opts?: {
+        includeBoundTextElement?: boolean;
+        includeLockedElements?: boolean;
+    }): NonDeleted<ExcalidrawElement>[];
     getElementHitThreshold(element: ExcalidrawElement): number;
-    private hitElement;
+    hitElement(x: number, y: number, element: NonDeletedExcalidrawElement, considerBoundingBox?: boolean): boolean;
     getTextBindableContainerAtPosition(x: number, y: number): (Readonly<{
         id: string;
         x: number;
@@ -601,6 +623,7 @@ declare class App extends React.Component<AppProps, AppState> {
         frameId: string | null;
         boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
         updated: number;
+        created: number | null;
         link: string | null;
         locked: boolean;
         customData?: Record<string, any>;
@@ -635,6 +658,43 @@ declare class App extends React.Component<AppProps, AppState> {
         frameId: string | null;
         boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
         updated: number;
+        created: number | null;
+        link: string | null;
+        locked: boolean;
+        customData?: Record<string, any>;
+    }> & Readonly<{
+        type: "stickynote";
+        baseHeight: number;
+    }> & {
+        isDeleted: false;
+    }) | (Readonly<{
+        id: string;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        fillStyle: import("@excalidraw/element/types").FillStyle;
+        strokeWidth: number;
+        strokeStyle: import("@excalidraw/element/types").StrokeStyle;
+        roundness: null | {
+            type: import("@excalidraw/element/types").RoundnessType;
+            value?: number;
+        };
+        roughness: number;
+        opacity: number;
+        width: number;
+        height: number;
+        angle: Radians;
+        seed: number;
+        version: number;
+        versionNonce: number;
+        index: import("@excalidraw/element/types").FractionalIndex | null;
+        isDeleted: boolean;
+        groupIds: readonly import("@excalidraw/element/types").GroupId[];
+        frameId: string | null;
+        boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
+        updated: number;
+        created: number | null;
         link: string | null;
         locked: boolean;
         customData?: Record<string, any>;
@@ -669,6 +729,7 @@ declare class App extends React.Component<AppProps, AppState> {
         frameId: string | null;
         boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
         updated: number;
+        created: number | null;
         link: string | null;
         locked: boolean;
         customData?: Record<string, any>;
@@ -703,6 +764,7 @@ declare class App extends React.Component<AppProps, AppState> {
         frameId: string | null;
         boundElements: readonly import("@excalidraw/element/types").BoundElement[] | null;
         updated: number;
+        created: number | null;
         link: string | null;
         locked: boolean;
         customData?: Record<string, any>;
@@ -731,7 +793,25 @@ declare class App extends React.Component<AppProps, AppState> {
      * so the whole create-and-type lands in a single entry.
      */
     private isEditingTextContent;
-    private startTextEditing;
+    startTextEditing: ({ sceneX, sceneY, insertAtParentCenter, container, autoEdit, initialCaretSceneCoords, arrowEndpoint, }: {
+        /** X position to insert text at */
+        sceneX: number;
+        /** Y position to insert text at */
+        sceneY: number;
+        /** whether to attempt to insert at element center if applicable */
+        insertAtParentCenter?: boolean;
+        container?: ExcalidrawTextContainer | null;
+        autoEdit?: boolean;
+        initialCaretSceneCoords?: {
+            x: number;
+            y: number;
+        };
+        /**
+         * creates the text as a label for this arrow endpoint: the binding then
+         * dictates the text's position and alignment, overriding (sceneX, sceneY)
+         */
+        arrowEndpoint?: ArrowEndpoint | null;
+    }) => void;
     private startImageCropping;
     private finishImageCropping;
     private shouldHandleBrowserCanvasDoubleClick;
@@ -784,6 +864,10 @@ declare class App extends React.Component<AppProps, AppState> {
     private handleCanvasPointerMove;
     private handleEraser;
     private handleTouchMove;
+    /**
+     * Applies the hover affordances of a selected linear element: the cursor,
+     * plus the hovered-handle state that renders them highlighted.
+     */
     handleHoverSelectedLinearElement(linearElementEditor: LinearElementEditor, scenePointerX: number, scenePointerY: number): void;
     private handleCanvasPointerDown;
     private handleCanvasPointerUp;
@@ -826,8 +910,10 @@ declare class App extends React.Component<AppProps, AppState> {
     }) => NonDeleted<ExcalidrawEmbeddableElement> | undefined;
     private newImagePlaceholder;
     private handleLinearElementOnPointerDown;
-    private getCurrentItemRoundness;
-    private getCurrentItemStrokeWidth;
+    getCurrentItemRoundness(elementType: "selection" | "rectangle" | "stickynote" | "diamond" | "ellipse" | "iframe" | "embeddable"): {
+        type: 2 | 3;
+    } | null;
+    getCurrentItemStrokeWidth(elementType: ExcalidrawElement["type"]): number;
     private createGenericElementOnPointerDown;
     private createFrameElementOnPointerDown;
     private maybeCacheReferenceSnapPoints;

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

@@ -41,6 +41,8 @@ type IconButtonProps = (IconButtonBaseProps & {
     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/Tools.d.ts

@@ -1,7 +1,7 @@
 import type { AppClassProperties, AppState, ToolType, UIAppState } from "../types";
 export type ToolConfig = {
     icon: React.ReactNode;
-    /** letter shortcut(s) — the first one is shown in tooltips */
+    /** 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;
@@ -31,6 +31,7 @@ export declare const TOOLS: {
     line: ToolConfig;
     freedraw: ToolConfig;
     text: ToolConfig;
+    stickynote: ToolConfig;
     image: ToolConfig;
     eraser: ToolConfig;
     frame: ToolConfig;
@@ -49,7 +50,7 @@ export declare const TOGGLE_TOOLS: readonly (ToolType | "custom")[];
 export declare const getToolLetter: (type: ToolbarToolType) => string | undefined;
 /** human-readable shortcut hint, e.g. "R or 2", used in tooltips & aria */
 export declare const getToolShortcut: (type: ToolbarToolType) => string;
-export declare const findShapeByKey: (key: string, app: AppClassProperties, shiftKey?: boolean) => "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "lasso" | "eraser" | "hand" | "laser" | "autoshape" | "bucketfill" | null;
+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
@@ -99,6 +100,10 @@ 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;

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

@@ -10,6 +10,8 @@ interface NewElementCanvasProps {
     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;

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

@@ -200,6 +200,7 @@ export declare const alertTriangleIcon: import("react/jsx-runtime").JSX.Element;
 export declare const eyeDropperIconSvgPaths: readonly ["M4 16l11.7 -11.7a1 1 0 0 1 1.4 0l2.6 2.6a1 1 0 0 1 0 1.4l-11.7 11.7h-4v-4z", "M11 7l6 6"];
 export declare const eyeDropperIcon: import("react/jsx-runtime").JSX.Element;
 export declare const frameToolIcon: import("react/jsx-runtime").JSX.Element;
+export declare const stickyNoteToolIcon: import("react/jsx-runtime").JSX.Element;
 export declare const mermaidLogoIcon: import("react/jsx-runtime").JSX.Element;
 export declare const RetryIcon: import("react/jsx-runtime").JSX.Element;
 export declare const stackPushIcon: import("react/jsx-runtime").JSX.Element;

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

@@ -1,7 +1,7 @@
-import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import type { ElementsMap, ExcalidrawElement, NonDeletedElementsMap, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
 import type { AppClassProperties, UIAppState } from "../types";
 export declare const canChangeStrokeColor: (appState: UIAppState, targetElements: ExcalidrawElement[]) => boolean;
-export declare const canChangeBackgroundColor: (appState: UIAppState, targetElements: ExcalidrawElement[]) => boolean;
+export declare const canChangeBackgroundColor: (appState: UIAppState, targetElements: ExcalidrawElement[], elementsMap: ElementsMap) => boolean;
 /**
  * Single source of truth for "which shape-action controls are relevant right
  * now". Each flag answers whether a given control should be shown, given the

package/dist/types/excalidraw/data/blob.d.ts

@@ -125,6 +125,8 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
             exportEmbedScene: boolean;
             exportWithDarkMode: boolean;
             currentItemStrokeColor: string;
+            currentItemStickynoteStrokeColor: string;
+            currentItemStickynoteBackgroundColor: string;
             currentItemBackgroundColor: string;
             currentItemFillStyle: ExcalidrawElement["fillStyle"];
             currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
@@ -179,6 +181,8 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
                 elementStroke: readonly string[] | null;
                 elementBackground: readonly string[] | null;
                 bucketFill: readonly string[] | null;
+                stickyNoteStroke: readonly string[] | null;
+                stickyNoteBackground: readonly string[] | null;
             };
         };
         files: import("../types").BinaryFiles;
@@ -299,6 +303,8 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
         exportEmbedScene: boolean;
         exportWithDarkMode: boolean;
         currentItemStrokeColor: string;
+        currentItemStickynoteStrokeColor: string;
+        currentItemStickynoteBackgroundColor: string;
         currentItemBackgroundColor: string;
         currentItemFillStyle: ExcalidrawElement["fillStyle"];
         currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
@@ -353,6 +359,8 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
             elementStroke: readonly string[] | null;
             elementBackground: readonly string[] | null;
             bucketFill: readonly string[] | null;
+            stickyNoteStroke: readonly string[] | null;
+            stickyNoteBackground: readonly string[] | null;
         };
     };
     files: import("../types").BinaryFiles;

package/dist/types/excalidraw/data/json.d.ts

@@ -123,6 +123,8 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
         exportEmbedScene: boolean;
         exportWithDarkMode: boolean;
         currentItemStrokeColor: string;
+        currentItemStickynoteStrokeColor: string;
+        currentItemStickynoteBackgroundColor: string;
         currentItemBackgroundColor: string;
         currentItemFillStyle: ExcalidrawElement["fillStyle"];
         currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
@@ -177,6 +179,8 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
             elementStroke: readonly string[] | null;
             elementBackground: readonly string[] | null;
             bucketFill: readonly string[] | null;
+            stickyNoteStroke: readonly string[] | null;
+            stickyNoteBackground: readonly string[] | null;
         };
     };
     files: BinaryFiles;