@excalidraw/common 0.18.0-dda3affcb-8fc71066d → 0.18.0-e9c856d

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

@@ -1,39 +1,59 @@
 import React from "react";
-import { type EXPORT_IMAGE_TYPES, Emitter } from "@excalidraw/common";
-import { LinearElementEditor, FlowChartCreator, Scene, Store, type ElementUpdate, StoreDelta } from "@excalidraw/element";
-import type { ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered, OrderedExcalidrawElement, SceneElementsMap } from "@excalidraw/element/types";
+import { AppEventBus, type EXPORT_IMAGE_TYPES, Emitter, type EditorInterface, type StylesPanelMode } from "@excalidraw/common";
+import { LinearElementEditor, Scene, Store, type ElementUpdate, StoreDelta, type ApplyToOptions } from "@excalidraw/element";
+import type { ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered, SceneElementsMap } from "@excalidraw/element/types";
 import type { Mutable } from "@excalidraw/common/utility-types";
 import { ActionManager } from "../actions/manager";
-import { AnimationFrameHandler } from "../animation-frame-handler";
 import { History } from "../history";
 import { Fonts } from "../fonts";
 import { type WritableAtom } from "../editor-jotai";
 import { Renderer } from "../scene/Renderer";
-import { LaserTrails } from "../laser-trails";
+import { type SetViewportOptions } from "../viewport";
+import { LaserTrails } from "../laserTrails";
+import { isOverScrollBars } from "../scene/scrollbars";
 import { LassoTrail } from "../lasso";
 import { EraserTrail } from "../eraser";
+import { AppFlowchart } from "./App.flowchart";
+import { CursorHints } from "./CursorHint";
+import { type OnStateChange } from "./AppStateObserver";
 import type { ExportedElements } from "../data";
-import type { FileSystemHandle } from "../data/filesystem";
-import type { AppClassProperties, AppProps, AppState, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, SceneData, Device, FrameNameBoundsCache, SidebarName, SidebarTabName, ToolType, OnUserFollowedPayload, GenerateDiagramToCode, NullableGridSize, Offsets, ApplyDeltasOptions } from "../types";
+import type { AppClassProperties, AppProps, AppState, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, SceneData, FrameNameBoundsCache, SidebarName, SidebarTabName, ToolType, OnUserFollowedPayload, ExcalidrawImperativeAPIEventMap, GenerateDiagramToCode, NullableGridSize, Offsets, ViewportOffsetsOptions } from "../types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 import type { ActionResult } from "../actions/types";
+declare const editorLifecycleEventBehavior: {
+    readonly "editor:mount": {
+        readonly cardinality: "once";
+        readonly replay: "last";
+    };
+    readonly "editor:initialize": {
+        readonly cardinality: "once";
+        readonly replay: "last";
+    };
+    readonly "editor:unmount": {
+        readonly cardinality: "once";
+        readonly replay: "last";
+    };
+};
 export declare const ExcalidrawContainerContext: React.Context<{
     container: HTMLDivElement | null;
     id: string | null;
 }>;
+export declare const ExcalidrawAPIContext: React.Context<ExcalidrawImperativeAPI | null>;
+export declare const ExcalidrawAPISetContext: React.Context<((api: ExcalidrawImperativeAPI | null) => void) | null>;
 export declare const useApp: () => AppClassProperties;
 export declare const useAppProps: () => AppProps;
-export declare const useDevice: () => Readonly<{
-    viewport: {
-        isMobile: boolean;
-        isLandscape: boolean;
-    };
-    editor: {
-        isMobile: boolean;
-        canFitSidebar: boolean;
-    };
+export declare const useEditorInterface: () => Readonly<{
+    formFactor: "phone" | "tablet" | "desktop";
+    desktopUIMode: "compact" | "full";
+    userAgent: Readonly<{
+        isMobileDevice: boolean;
+        platform: "ios" | "android" | "other" | "unknown";
+    }>;
     isTouchScreen: boolean;
+    canFitSidebar: boolean;
+    isLandscape: boolean;
 }>;
+export declare const useStylesPanelMode: () => StylesPanelMode;
 export declare const useExcalidrawContainer: () => {
     container: HTMLDivElement | null;
     id: string | null;
@@ -42,20 +62,34 @@ export declare const useExcalidrawElements: () => readonly NonDeletedExcalidrawE
 export declare const useExcalidrawAppState: () => AppState;
 export declare const useExcalidrawSetAppState: () => <K extends keyof AppState>(state: AppState | ((prevState: Readonly<AppState>, props: Readonly<any>) => AppState | Pick<AppState, K> | null) | Pick<AppState, K> | null, callback?: (() => void) | undefined) => void;
 export declare const useExcalidrawActionManager: () => ActionManager;
+/**
+ * Requires wrapping your component in <ExcalidrawAPIContext.Provider>
+ */
+export declare const useExcalidrawAPI: () => ExcalidrawImperativeAPI | null;
 declare class App extends React.Component<AppProps, AppState> {
     canvas: AppClassProperties["canvas"];
     interactiveCanvas: AppClassProperties["interactiveCanvas"];
+    sessionExportThemeOverride: AppState["theme"] | undefined;
     rc: RoughCanvas;
     unmounted: boolean;
     actionManager: ActionManager;
-    device: Device;
+    editorInterface: EditorInterface;
+    private stylesPanelMode;
+    /**
+     * Last-measured footprints of named viewport UI surfaces
+     * (`data-viewport-ui-name`), so `getViewportOffsets` can reserve space
+     * for them while they're hidden.
+     */
+    private viewportUILastMeasured;
     private excalidrawContainerRef;
     scene: Scene;
     fonts: Fonts;
     renderer: Renderer;
     visibleElements: readonly NonDeletedExcalidrawElement[];
+    /** whether the last render had any renderable elements (excludes e.g. the
+     * in-progress `newElement` and the edited text element) */
+    private hasRenderableElements;
     private resizeObserver;
-    private nearestScrollableContainer;
     library: AppClassProperties["library"];
     libraryItemsFromStorage: LibraryItems | undefined;
     id: string;
@@ -78,26 +112,41 @@ declare class App extends React.Component<AppProps, AppState> {
     /** embeds that have been inserted to DOM (as a perf optim, we don't want to
      * insert to DOM before user initially scrolls to them) */
     private initializedEmbeds;
-    private handleToastClose;
     private elementsPendingErasure;
-    flowChartCreator: FlowChartCreator;
-    private flowChartNavigator;
+    private _initialized;
+    private readonly editorLifecycleEvents;
+    onEvent: AppEventBus<ExcalidrawImperativeAPIEventMap, typeof editorLifecycleEventBehavior>["on"];
+    private appStateObserver;
+    onStateChange: OnStateChange;
+    flowchart: AppFlowchart;
+    bindModeHandler: ReturnType<typeof setTimeout> | null;
     hitLinkElement?: NonDeletedExcalidrawElement;
     lastPointerDownEvent: React.PointerEvent<HTMLElement> | null;
     lastPointerUpEvent: React.PointerEvent<HTMLElement> | PointerEvent | null;
+    lastPointerUpIsDoubleClick: boolean;
     lastPointerMoveEvent: PointerEvent | null;
+    /** current frame pointer cords */
     lastPointerMoveCoords: {
         x: number;
         y: number;
     } | null;
+    private lastCompletedCanvasClicks;
+    /** arrowheads removed via endpoint double-click toggle, so a subsequent
+     * toggle can restore the original arrowhead (keyed by `elementId:side`) */
+    private removedArrowheads;
+    /** previous frame pointer coords */
+    previousPointerMoveCoords: {
+        x: number;
+        y: number;
+    } | null;
     lastViewportPosition: {
         x: number;
         y: number;
     };
-    animationFrameHandler: AnimationFrameHandler;
     laserTrails: LaserTrails;
     eraserTrail: EraserTrail;
     lassoTrail: LassoTrail;
+    cursorHints: CursorHints;
     onChangeEmitter: Emitter<[elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles]>;
     onPointerDownEmitter: Emitter<[activeTool: {
         lastActiveTool: import("../types").ActiveTool | null;
@@ -112,11 +161,7 @@ declare class App extends React.Component<AppProps, AppState> {
             x: number;
             y: number;
         }>;
-        scrollbars: {
-            isOverEither: boolean;
-            isOverHorizontal: boolean;
-            isOverVertical: boolean;
-        };
+        scrollbars: ReturnType<typeof isOverScrollBars>;
         lastCoords: {
             x: number;
             y: number;
@@ -129,7 +174,7 @@ declare class App extends React.Component<AppProps, AppState> {
                 x: number;
                 y: number;
             };
-            arrowDirection: "end" | "origin";
+            arrowDirection: "origin" | "end";
             center: {
                 x: number;
                 y: number;
@@ -153,16 +198,13 @@ declare class App extends React.Component<AppProps, AppState> {
                 x: number;
                 y: number;
             };
+            blockDragging: boolean;
         };
         eventListeners: {
-            onMove: {
-                (...args: any[]): void;
-                flush(): void;
-                cancel(): void;
-            } | null;
-            onUp: ((event: PointerEvent) => void) | null;
-            onKeyDown: ((event: KeyboardEvent) => void) | null;
-            onKeyUp: ((event: KeyboardEvent) => void) | null;
+            onMove: null | ReturnType<typeof import("@excalidraw/common").throttleRAF>;
+            onUp: null | ((event: PointerEvent) => void);
+            onKeyDown: null | ((event: KeyboardEvent) => void);
+            onKeyUp: null | ((event: KeyboardEvent) => void);
         };
         boxSelection: {
             hasOccurred: boolean;
@@ -181,11 +223,7 @@ declare class App extends React.Component<AppProps, AppState> {
             x: number;
             y: number;
         }>;
-        scrollbars: {
-            isOverEither: boolean;
-            isOverHorizontal: boolean;
-            isOverVertical: boolean;
-        };
+        scrollbars: ReturnType<typeof isOverScrollBars>;
         lastCoords: {
             x: number;
             y: number;
@@ -198,7 +236,7 @@ declare class App extends React.Component<AppProps, AppState> {
                 x: number;
                 y: number;
             };
-            arrowDirection: "end" | "origin";
+            arrowDirection: "origin" | "end";
             center: {
                 x: number;
                 y: number;
@@ -222,16 +260,13 @@ declare class App extends React.Component<AppProps, AppState> {
                 x: number;
                 y: number;
             };
+            blockDragging: boolean;
         };
         eventListeners: {
-            onMove: {
-                (...args: any[]): void;
-                flush(): void;
-                cancel(): void;
-            } | null;
-            onUp: ((event: PointerEvent) => void) | null;
-            onKeyDown: ((event: KeyboardEvent) => void) | null;
-            onKeyUp: ((event: KeyboardEvent) => void) | null;
+            onMove: null | ReturnType<typeof import("@excalidraw/common").throttleRAF>;
+            onUp: null | ((event: PointerEvent) => void);
+            onKeyDown: null | ((event: KeyboardEvent) => void);
+            onKeyUp: null | ((event: KeyboardEvent) => void);
         };
         boxSelection: {
             hasOccurred: boolean;
@@ -243,17 +278,27 @@ declare class App extends React.Component<AppProps, AppState> {
     }>]>;
     missingPointerEventCleanupEmitter: Emitter<[event: PointerEvent | null]>;
     onRemoveEventListenersEmitter: Emitter<[]>;
+    api: ExcalidrawImperativeAPI;
+    private createExcalidrawAPI;
     constructor(props: AppProps);
     updateEditorAtom: <Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
     private onWindowMessage;
+    private handleSkipBindMode;
+    private resetDelayedBindMode;
+    private previousHoveredBindableElement;
+    private handleDelayedBindModeChange;
     private cacheEmbeddableRef;
     /**
      * Returns gridSize taking into account `gridModeEnabled`.
      * If disabled, returns null.
      */
     getEffectiveGridSize: () => NullableGridSize;
+    private getTextCreationGridPoint;
     private getHTMLIFrameElement;
-    private handleEmbeddableCenterClick;
+    private handleIframeLikeElementHover;
+    /** @returns true if iframe-like element click handled */
+    private handleIframeLikeCenterClick;
+    private isDoubleClick;
     private isIframeLikeElementCenter;
     private updateEmbedValidationStatus;
     private updateEmbeddables;
@@ -265,12 +310,12 @@ declare class App extends React.Component<AppProps, AppState> {
     private toggleOverscrollBehavior;
     render(): import("react/jsx-runtime").JSX.Element;
     focusContainer: AppClassProperties["focusContainer"];
-    getSceneElementsIncludingDeleted: () => readonly OrderedExcalidrawElement[];
-    getSceneElementsMapIncludingDeleted: () => Map<string, Ordered<ExcalidrawElement>> & import("@excalidraw/common/utility-types").MakeBrand<"SceneElementsMap">;
+    getSceneElementsIncludingDeleted: () => readonly import("@excalidraw/element/types").OrderedExcalidrawElement[];
+    getSceneElementsMapIncludingDeleted: () => SceneElementsMap;
     getSceneElements: () => readonly Ordered<NonDeletedExcalidrawElement>[];
     onInsertElements: (elements: readonly ExcalidrawElement[]) => void;
     onExportImage: (type: keyof typeof EXPORT_IMAGE_TYPES, elements: ExportedElements, opts: {
-        exportingFrame: ExcalidrawFrameLikeElement | null;
+        exportingFrame: NonDeleted<ExcalidrawFrameLikeElement> | null;
     }) => Promise<void>;
     private magicGenerations;
     private updateMagicGeneration;
@@ -297,9 +342,11 @@ declare class App extends React.Component<AppProps, AppState> {
      */
     private resetScene;
     private initializeScene;
-    private isMobileBreakpoint;
-    private refreshViewportBreakpoints;
-    private refreshEditorBreakpoints;
+    private getFormFactor;
+    refreshEditorInterface: () => void;
+    private reconcileStylesPanelMode;
+    /** TO BE USED LATER */
+    private setDesktopUIMode;
     private clearImageShapeCache;
     componentDidMount(): Promise<void>;
     componentWillUnmount(): void;
@@ -316,6 +363,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private static resetTapTwice;
     private onTouchStart;
     private onTouchEnd;
+    private insertClipboardContent;
     pasteFromClipboard: (event: ClipboardEvent) => Promise<void>;
     addElementsFromPasteOrLibrary: (opts: {
         elements: readonly ExcalidrawElement[];
@@ -325,54 +373,57 @@ declare class App extends React.Component<AppProps, AppState> {
             clientY: number;
         } | "cursor" | "center";
         retainSeed?: boolean;
-        fitToContent?: boolean;
+        fit?: SetViewportOptions["fit"];
+        preserveFrameChildrenOrder?: boolean;
     }) => void;
     private addElementsFromMixedContentPaste;
     private addTextFromPaste;
     setAppState: React.Component<any, AppState>["setState"];
     removePointer: (event: React.PointerEvent<HTMLElement> | PointerEvent) => void;
     toggleLock: (source?: "keyboard" | "ui") => void;
-    updateFrameRendering: (opts: Partial<{
-        enabled: boolean;
-        name: boolean;
-        outline: boolean;
-        clip: boolean;
-    }> | ((prevState: AppState["frameRendering"]) => Partial<AppState["frameRendering"]>)) => void;
+    updateFrameRendering: (opts: Partial<AppState["frameRendering"]> | ((prevState: AppState["frameRendering"]) => Partial<AppState["frameRendering"]>)) => void;
     togglePenMode: (force: boolean | null) => void;
-    onHandToolToggle: () => void;
     /**
      * Zooms on canvas viewport center
      */
-    zoomCanvas: (value: number) => void;
-    private cancelInProgressAnimation;
-    scrollToContent: (target?: string | ExcalidrawElement | readonly ExcalidrawElement[], opts?: ({
-        fitToContent?: boolean;
-        fitToViewport?: never;
-        viewportZoomFactor?: number;
-        animate?: boolean;
-        duration?: number;
-    } | {
-        fitToContent?: never;
-        fitToViewport?: boolean;
-        /** when fitToViewport=true, how much screen should the content cover,
-         * between 0.1 (10%) and 1 (100%)
-         */
-        viewportZoomFactor?: number;
-        animate?: boolean;
-        duration?: number;
-    }) & {
-        minZoom?: number;
-        maxZoom?: number;
-        canvasOffsets?: Offsets;
-    }) => void;
+    zoomCanvas: (
+    /**
+     * Decimal fraction, auto-clamped between MIN_ZOOM and MAX_ZOOM.
+     * 1 = 100% zoom, 2 = 200% zoom, 0.5 = 50% zoom
+     */
+    value: number) => void;
+    /**
+     * Navigates the viewport to a target and, optionally, locks pan/zoom to it.
+     * The resolved target box drives both the navigation (pan + zoom per
+     * `fit`) and the lock: the operations chain — the viewport animates onto
+     * the target, then the lock is installed against the settled viewport.
+     *
+     * Passing `null` clears any active lock without navigating.
+     */
+    /**
+     * Resolves user-supplied viewport offsets ({@link ViewportOffsets}) into
+     * concrete per-side pixel values: static sides are used as-is, and when
+     * `ui` is set, the remaining sides are derived from the currently
+     * rendered editor UI (via `getViewportOffsets`).
+     *
+     * Must be called at the time the offsets are applied (not e.g. cached at
+     * props-definition time), so the UI-derived values reflect the actual
+     * rendered UI.
+     */
+    private resolveViewportOffsets;
+    setViewport: (opts: SetViewportOptions | null) => void;
+    revealIfHidden: (elements: NonDeletedExcalidrawElement[]) => void;
     private maybeUnfollowRemoteUser;
     /** use when changing scrollX/scrollY/zoom based on user interaction */
     private translateCanvas;
-    setToast: (toast: {
-        message: string;
-        closable?: boolean;
-        duration?: number;
-    } | null) => void;
+    /** clamps scroll/zoom back into `appState.scrollConstraints` (no-op when
+     * unconstrained). Runs as a queued update, so it sees the preceding change.
+     * `overscroll` (screen px) relaxes the bounds for rubberbanding. */
+    private constrainViewportToScrollConstraints;
+    /** animates an overscrolled viewport back inside the constraint box */
+    private snapBackToScrollConstraints;
+    private snapBackToScrollConstraintsDebounced;
+    setToast: (toast: AppState["toast"]) => void;
     restoreFileFromShare: () => Promise<void>;
     /**
      * adds supplied files to existing files in the appState.
@@ -382,7 +433,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private addMissingFiles;
     updateScene: <K extends keyof AppState>(sceneData: {
         elements?: SceneData["elements"];
-        appState?: Pick<AppState, K> | null | undefined;
+        appState?: Pick<AppState, K> | null;
         collaborators?: SceneData["collaborators"];
         /**
          *  Controls which updates should be captured by the `Store`. Captured updates are emmitted and listened to by other components, such as `History` for undo / redo purposes.
@@ -397,19 +448,31 @@ declare class App extends React.Component<AppProps, AppState> {
          */
         captureUpdate?: SceneData["captureUpdate"];
     }) => void;
-    applyDeltas: (deltas: StoreDelta[], options?: ApplyDeltasOptions) => [SceneElementsMap, AppState, boolean];
+    applyDeltas: (deltas: StoreDelta[], options?: ApplyToOptions) => [SceneElementsMap, AppState, boolean];
     mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, informMutation?: boolean) => TElement;
-    private triggerRender;
+    triggerRender: (
+    /** force always re-renders canvas even if no change */
+    force?: boolean) => void;
     /**
      * @returns whether the menu was toggled on or off
      */
     toggleSidebar: ({ name, tab, force, }: {
         name: SidebarName | null;
-        tab?: string | undefined;
-        force?: boolean | undefined;
+        tab?: SidebarTabName;
+        force?: boolean;
     }) => boolean;
     private updateCurrentCursorPosition;
-    getEditorUIOffsets: () => Offsets;
+    /**
+     * top/right/bottom/left override the final offsets for those sides.
+     *
+     * Default side offsets are measured from the currently rendered UI
+     * surfaces marked with the `data-viewport-ui` attribute (see
+     * {@link ViewportUIDock}), plus padding.
+     *
+     * See {@link ViewportOffsetsOptions} for the individual options
+     * (padding, per-side overrides, reserving space for hidden surfaces).
+     */
+    getViewportOffsets: (opts?: ViewportOffsetsOptions) => Offsets;
     private onKeyDown;
     private onKeyUp;
     private isToolSupported;
@@ -421,7 +484,17 @@ declare class App extends React.Component<AppProps, AppState> {
     }) & {
         locked?: boolean;
         fromSelection?: boolean;
-    }, keepSelection?: boolean) => void;
+    }, opts?: {
+        keepSelection?: boolean;
+        /**
+         * When `true`, re-activating an already-active toggle tool (see
+         * `TOGGLE_TOOLS`) switches back to the previously active tool.
+         * Activation is idempotent by default; toggle tools always record the
+         * previously active tool regardless (so ESC and the next `toggle`
+         * activation can switch back to it).
+         */
+        toggle?: boolean;
+    }) => void;
     setOpenDialog: (dialogType: AppState["openDialog"]) => void;
     private setCursor;
     private resetCursor;
@@ -438,7 +511,11 @@ declare class App extends React.Component<AppProps, AppState> {
     private onGestureEnd;
     private handleTextWysiwyg;
     private deselectElements;
+    private getSelectedTextElement;
+    private getSelectedTextEditingContainerAtPosition;
     private getTextElementAtPosition;
+    private isHittingTextAutoResizeHandle;
+    private handleTextAutoResizeHandlePointerDown;
     private getElementAtPosition;
     private getElementsAtPosition;
     getElementHitThreshold(element: ExcalidrawElement): number;
@@ -447,10 +524,26 @@ declare class App extends React.Component<AppProps, AppState> {
     private startTextEditing;
     private startImageCropping;
     private finishImageCropping;
+    private shouldHandleBrowserCanvasDoubleClick;
+    /**
+     * Toggles the arrowhead at the given endpoint between no arrowhead and the
+     * arrowhead it had before the last toggle (falling back to the current
+     * default arrowhead).
+     */
+    private toggleArrowheadAtEndpoint;
     private handleCanvasDoubleClick;
+    private handleCanvasClick;
     private getElementLinkAtPosition;
-    private redirectToLink;
+    private handleElementLinkClick;
+    /**
+     * finds candidate frame under cursor (when dragging frame children/elements
+     * inside frames)
+     */
     private getTopLayerFrameAtSceneCoords;
+    private updateFrameToHighlight;
+    private maybeUpdateFrameToHighlightOnPointerMove;
+    insertNewElements: (elements: readonly ExcalidrawElement[]) => void;
+    private insertNewElement;
     private handleCanvasPointerMove;
     private handleEraser;
     private handleTouchMove;
@@ -489,9 +582,10 @@ declare class App extends React.Component<AppProps, AppState> {
         sceneY: number;
         link: string;
     }) => NonDeleted<ExcalidrawEmbeddableElement> | undefined;
-    private createImageElement;
+    private newImagePlaceholder;
     private handleLinearElementOnPointerDown;
     private getCurrentItemRoundness;
+    private getCurrentItemStrokeWidth;
     private createGenericElementOnPointerDown;
     private createFrameElementOnPointerDown;
     private maybeCacheReferenceSnapPoints;
@@ -510,11 +604,7 @@ declare class App extends React.Component<AppProps, AppState> {
      * and when you don't want to loose those modifications
      */
     private getLatestInitializedImageElement;
-    /**
-     * inserts image into elements array and rerenders
-     */
-    private insertImageElement;
-    private onImageAction;
+    private onImageToolbarButtonClick;
     private getImageNaturalDimensions;
     /** updates image cache, refreshing updated elements and/or setting status
         to error for images that fail during <img> element creation */
@@ -524,12 +614,11 @@ declare class App extends React.Component<AppProps, AppState> {
     /** generally you should use `addNewImagesToImageCache()` directly if you need
      *  to render new images. This is just a failsafe  */
     private scheduleImageRefresh;
-    private updateBindingEnabledOnPointerMove;
-    private maybeSuggestBindingAtCursor;
     private clearSelection;
     private handleInteractiveCanvasRef;
+    private insertImages;
     private handleAppOnDrop;
-    loadFileToCanvas: (file: File, fileHandle: FileSystemHandle | null) => Promise<void>;
+    loadFileToCanvas: (file: File, fileHandle: FileSystemFileHandle | null) => Promise<void>;
     private handleCanvasContextMenu;
     private maybeDragNewGenericElement;
     private maybeHandleCrop;
@@ -542,6 +631,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private updateDOMRect;
     refresh: () => void;
     private getCanvasOffsets;
+    watchState: () => void;
     private updateLanguage;
 }
 declare global {
@@ -551,6 +641,7 @@ declare global {
             elements: readonly ExcalidrawElement[];
             state: AppState;
             setState: React.Component<any, AppState>["setState"];
+            watchState: (prev: any, next: any) => void | undefined;
             app: InstanceType<typeof App>;
             history: History;
             store: Store;

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

@@ -0,0 +1,19 @@
+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;
+    handleKeyEvent: (event: React.KeyboardEvent | KeyboardEvent) => boolean;
+    private resolveKeyboardEventToOperation;
+    private selectAndReveal;
+    private captureUpdate;
+    private static getLinkDirectionFromKey;
+}

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 { UIAppState } from "../../types";
 interface ColorPickerProps {
     type: ColorPickerType;
     /**
@@ -14,7 +13,7 @@ interface ColorPickerProps {
     onChange: (color: string) => void;
     label: string;
     elements: readonly ExcalidrawElement[];
-    appState: AppState;
+    appState: UIAppState;
     palette?: ColorPaletteCustom | null;
     topPicks?: ColorTuple;
     updateData: (formData?: any) => void;