@myoc/math 0.19.521 → 0.19.523

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

@@ -1,22 +1,29 @@
 import React from "react";
 import { AppEventBus, type EXPORT_IMAGE_TYPES, Emitter, type EditorInterface, type StylesPanelMode } from "@excalidraw/common";
-import { FlowChartCreator, Scene, Store, type ElementUpdate, StoreDelta, type ApplyToOptions } from "@excalidraw/element";
-import { LinearElementEditor } from "@excalidraw/element/linearElementEditor";
-import type { ExcalidrawElement, NonDeleted, FileId, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered, SceneElementsMap } from "@excalidraw/element/types";
+import { LinearElementEditor, Scene, Store, type ElementUpdate, StoreDelta, type ApplyToOptions } from "@excalidraw/element";
+import type { LocalPoint, Radians } from "@excalidraw/math";
+import type { ExcalidrawElement, ExcalidrawTextElement, NonDeleted, FileId, NonDeletedExcalidrawElement, ExcalidrawTextContainer, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered, SceneElementsMap } from "@excalidraw/element/types";
 import type { Mutable } from "@excalidraw/common/utility-types";
 import { ActionManager } from "../actions/manager";
 import { History } from "../history";
 import { Fonts } from "../fonts";
 import { type WritableAtom } from "../editor-jotai";
 import { Renderer } from "../scene/Renderer";
-import { type ScrollToContentOptions } from "../scroll";
+import { type SetViewportOptions } from "../viewport";
 import { LaserTrails } from "../laserTrails";
 import { isOverScrollBars } from "../scene/scrollbars";
 import { LassoTrail } from "../lasso";
 import { EraserTrail } from "../eraser";
+import { AppArrowText } from "./App.arrowText";
+import { AppBucketFill } from "./App.bucketFill";
+import { AppCursor } from "./App.cursor";
+import { AppDrawShape } from "./App.drawshape";
+import { AppFlowchart } from "./App.flowchart";
+import { AppViewport } from "./App.viewport";
+import { CursorHints } from "./CursorHint";
 import { type OnStateChange } from "./AppStateObserver";
 import type { ExportedElements } from "../data";
-import type { AppClassProperties, AppProps, AppState, ExcalidrawImperativeAPI, BinaryFiles, SceneData, FrameNameBoundsCache, SidebarName, SidebarTabName, ToolType, OnUserFollowedPayload, ExcalidrawImperativeAPIEventMap, GenerateDiagramToCode, NullableGridSize, Offsets } from "../types";
+import type { AppClassProperties, AppProps, AppState, ExcalidrawImperativeAPI, BinaryFiles, SceneData, FrameNameBoundsCache, SidebarName, SidebarTabName, ToolType, OnUserFollowedPayload, ExcalidrawImperativeAPIEventMap, NullableGridSize, UIConfig, ImageStatus } from "../types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 import type { ActionResult } from "../actions/types";
 declare const editorLifecycleEventBehavior: {
@@ -79,6 +86,9 @@ declare class App extends React.Component<AppProps, AppState> {
     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;
     id: string;
     private store;
@@ -91,8 +101,9 @@ declare class App extends React.Component<AppProps, AppState> {
     imageCache: AppClassProperties["imageCache"];
     imageLoadingProgress: Map<FileId, number>;
     imageLoadingProgressEmitter: Emitter<[]>;
+    imageStatus: Map<FileId, ImageStatus>;
+    imageStatusEmitter: Emitter<[]>;
     imagePlaceholderUpdateEmitter: Emitter<[]>;
-    private imageTransitionPlaceholders;
     private iFrameRefs;
     /**
      * Indicates whether the embeddable's url has been validated for rendering.
@@ -110,9 +121,17 @@ declare class App extends React.Component<AppProps, AppState> {
     onEvent: AppEventBus<ExcalidrawImperativeAPIEventMap, typeof editorLifecycleEventBehavior>["on"];
     private appStateObserver;
     onStateChange: OnStateChange;
-    flowChartCreator: FlowChartCreator;
-    private flowChartNavigator;
+    bucketFill: AppBucketFill;
+    flowchart: AppFlowchart;
+    cursor: AppCursor;
+    arrowText: AppArrowText;
+    viewport: AppViewport;
+    get lastViewportPosition(): {
+        x: number;
+        y: number;
+    };
     bindModeHandler: ReturnType<typeof setTimeout> | null;
+    private textWysiwygSubmitHandler;
     hitLinkElement?: NonDeletedExcalidrawElement;
     lastPointerDownEvent: React.PointerEvent<HTMLElement> | null;
     lastPointerUpEvent: React.PointerEvent<HTMLElement> | PointerEvent | null;
@@ -129,13 +148,11 @@ declare class App extends React.Component<AppProps, AppState> {
         x: number;
         y: number;
     } | null;
-    lastViewportPosition: {
-        x: number;
-        y: number;
-    };
+    drawShape: AppDrawShape;
     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;
@@ -268,9 +285,77 @@ declare class App extends React.Component<AppProps, AppState> {
     missingPointerEventCleanupEmitter: Emitter<[event: PointerEvent | null]>;
     onRemoveEventListenersEmitter: Emitter<[]>;
     api: ExcalidrawImperativeAPI;
-    addImageElementsToScene: ExcalidrawImperativeAPI["addImageElementsToScene"];
     private createExcalidrawAPI;
     constructor(props: AppProps);
+    /**
+     * Whether the editor accepts user input (pointer, keyboard, wheel, touch,
+     * clipboard, drag&drop). When `false`, the editor is fully inert for the
+     * user, but remains controllable through the imperative API.
+     *
+     * All user-input entry points must consult this getter (directly or by
+     * not being attached/rendered at all).
+     */
+    isInteractionEnabled(props?: Pick<AppProps, "interaction">): boolean;
+    /**
+     * Whether element links render their link icon and are clickable.
+     * True when fully interactive, or when `interaction: { enabled: { links:
+     * true } }`
+     * (in which case clicking anywhere on a linked element opens the link,
+     * same as in view mode).
+     */
+    isLinksEnabled(props?: Pick<AppProps, "interaction">): boolean;
+    /**
+     * Whether canvas navigation — panning & zooming, view-mode style — is
+     * enabled. True when fully interactive, or when `interaction: { enabled:
+     * { navigation: true } }`. Respects `appState.scrollConstraints`.
+     */
+    isNavigationEnabled(props?: Pick<AppProps, "interaction">): boolean;
+    /**
+     * Whether embeddable & iframe elements are interactive (hover & click to
+     * activate, view-mode style). True when fully interactive, or when
+     * allowed via `interaction.enabled.embeds` / `.interactiveContent`.
+     */
+    isEmbedsEnabled(props?: Pick<AppProps, "interaction">): boolean;
+    /**
+     * Whether the browser's own zoom (ctrl/cmd + wheel, pinch, keyboard
+     * shortcuts) stays available over the non-interactive editor.
+     * Prevented by default.
+     */
+    isBrowserZoomEnabled(props?: Pick<AppProps, "interaction">): boolean;
+    /**
+     * Whether the tool can be activated & driven by user input. False when
+     * disabled via `UIOptions.tools`, or when the editor is non-interactive
+     * and the tool isn't kept user-driven via `interaction.enabled.tools`.
+     *
+     * (Once UI tool availability is split from input availability — e.g.
+     * `props.ui.tools` vs `interaction.disabled.tools` — the UI axis moves
+     * out into its own predicate.)
+     *
+     * We purposely widen the `tool` type so this helper can be called with
+     * any tool without having to type check it.
+     */
+    isToolSupported: <T extends ToolType | "custom">(tool: T, props?: Pick<AppProps, "interaction" | "UIOptions">) => boolean;
+    /**
+     * Whether the active tool is locked in place — via the tool lock
+     * (padlock / Q) or by being host-forced (`props.activeTool`). A locked
+     * tool doesn't revert to the selection tool after use, and elements drawn
+     * with it aren't selected. Forcing deliberately does not mutate
+     * `activeTool.locked`, which is the user's persisted padlock preference.
+     */
+    isToolLocked(): boolean;
+    /**
+     * Whether the active tool captures the primary pointer instead of the
+     * view-mode drag-to-pan — the laser and host-implemented custom tools do;
+     * while non-interactive, any tool allowed via
+     * `interaction.enabled.tools` does. (Editing tools capture the pointer
+     * trivially since view mode implies they're not active; this predicate only
+     * matters where view-mode gates apply.)
+     */
+    isActiveToolPointerCapturing(): boolean;
+    /** Whether Excalidraw's full default UI is rendered. */
+    isDefaultUIEnabled(props?: Pick<AppProps, "ui">): boolean;
+    /** Whether an individual default UI control is rendered. */
+    isUIControlEnabled(control: keyof UIConfig["enabled"], props?: Pick<AppProps, "ui">): boolean;
     updateEditorAtom: <Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
     private onWindowMessage;
     private handleSkipBindMode;
@@ -305,25 +390,42 @@ declare class App extends React.Component<AppProps, AppState> {
     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;
-    plugins: {
-        diagramToCode?: {
-            generate: GenerateDiagramToCode;
-        };
-    };
-    setPlugins(plugins: Partial<App["plugins"]>): void;
-    private onMagicFrameGenerate;
-    private onIframeSrcCopy;
-    onMagicframeToolSelect: () => void;
-    private openEyeDropper;
+    openEyeDropper: ({ type, swapPreviewOnAlt, }: {
+        type: "stroke" | "background";
+        swapPreviewOnAlt?: boolean;
+    }) => void;
     dismissLinearEditor: () => void;
     syncActionResult: (actionResult: ActionResult) => void;
+    scheduleCapture: () => void;
     private onBlur;
     private onUnload;
     private disableEvent;
+    private preventBrowserZoomWheel;
+    private handleNavigationModeKeyDown;
+    /**
+     * PageUp/PageDown scroll the canvas by a page — vertically, or
+     * horizontally with shift. Respects `appState.scrollConstraints`
+     * (via `viewport.translate`).
+     */
+    private maybeHandlePageScrollKeyDown;
+    private preventBrowserZoomKeyDown;
+    /** Ends active input sessions before switching to a view-mode/non-interactive
+     *  mode. */
+    private terminateActiveInteraction;
+    private handleInteractionStateChange;
+    /** whether the two values reference the same tool (incl. custom subtype) */
+    private isSameForcedTool;
+    /**
+     * Keeps `state.activeTool` synced to the host-controlled
+     * `props.activeTool`. `setActiveTool` refuses non-matching activations
+     * while forced (user input, API); this backstop covers the writers that
+     * bypass the funnel (`actionFinalize`/`actionDeselect`, `restore()` on
+     * scene load, ...) and re-applies the tool once it becomes activatable
+     * (e.g. `interaction` config changes).
+     */
+    private handleForcedToolChange;
     private resetHistory;
     private resetStore;
     /**
@@ -355,6 +457,17 @@ declare class App extends React.Component<AppProps, AppState> {
     private onTouchEnd;
     private insertClipboardContent;
     pasteFromClipboard: (event: ClipboardEvent) => Promise<void>;
+    addElementsFromPasteOrLibrary: (opts: {
+        elements: readonly ExcalidrawElement[];
+        files: BinaryFiles | null;
+        position: {
+            clientX: number;
+            clientY: number;
+        } | "cursor" | "center";
+        retainSeed?: boolean;
+        fit?: SetViewportOptions["fit"];
+        preserveFrameChildrenOrder?: boolean;
+    }) => void;
     addElementsFromPaste: (opts: {
         elements: readonly ExcalidrawElement[];
         files: BinaryFiles | null;
@@ -373,39 +486,41 @@ declare class App extends React.Component<AppProps, AppState> {
     toggleLock: (source?: "keyboard" | "ui") => 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: (
-    /**
-     * Decimal fraction, auto-clamped between MIN_ZOOM and MAX_ZOOM.
-     * 1 = 100% zoom, 2 = 200% zoom, 0.5 = 50% zoom
-     */
-    value: number) => void;
-    private cancelInProgressAnimation;
+    revealIfHidden: (elements: NonDeletedExcalidrawElement[]) => void;
     scrollToViewport: (target: {
         scrollX: number;
         scrollY: number;
         zoom: number;
-    }, opts?: {
+    }, _opts?: {
         animate?: boolean;
         duration?: number;
     }) => void;
-    scrollToContent: (target?: string | ExcalidrawElement | readonly NonDeletedExcalidrawElement[], opts?: ScrollToContentOptions) => void;
-    private maybeUnfollowRemoteUser;
-    /** use when changing scrollX/scrollY/zoom based on user interaction */
-    private translateCanvas;
+    scrollToContent: (target?: SetViewportOptions["target"], opts?: {
+        animate?: boolean;
+        duration?: number;
+        fitToViewport?: boolean;
+    }) => void;
+    /** emits a follow/unfollow intent to the host (which owns the
+     *  `userToFollow` state) via both the `onUserFollow` prop and the
+     *  imperative API emitter */
+    emitUserFollowIntent: (payload: OnUserFollowedPayload) => void;
+    /** emits an UNFOLLOW intent if currently following someone — use on
+     *  user-initiated viewport changes which should break follow mode */
+    requestUnfollow: () => void;
     setToast: (toast: AppState["toast"]) => void;
-    private handleToastClose;
     restoreFileFromShare: () => Promise<void>;
     /**
      * adds supplied files to existing files in the appState.
      * NOTE if file already exists in editor state, the file data is not updated
      * */
     addFiles: ExcalidrawImperativeAPI["addFiles"];
+    addImageElementsToScene: ExcalidrawImperativeAPI["addImageElementsToScene"];
     addImagePlaceholder: ExcalidrawImperativeAPI["addImagePlaceholder"];
-    setImageLoadingProgress: ExcalidrawImperativeAPI["setImageLoadingProgress"];
+    setDownloadProgress: ExcalidrawImperativeAPI["setDownloadProgress"];
+    setDownloadError: ExcalidrawImperativeAPI["setDownloadError"];
+    setUploadProgress: ExcalidrawImperativeAPI["setUploadProgress"];
+    private updateImageStatus;
+    private areImageStatusesEqual;
     private clearImageLoadingProgress;
     private clearImageShapeCacheForFileId;
     private addMissingFiles;
@@ -428,7 +543,9 @@ declare class App extends React.Component<AppProps, AppState> {
     }) => void;
     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
      */
@@ -438,10 +555,8 @@ declare class App extends React.Component<AppProps, AppState> {
         force?: boolean;
     }) => boolean;
     private updateCurrentCursorPosition;
-    getEditorUIOffsets: () => Offsets;
     private onKeyDown;
     private onKeyUp;
-    private isToolSupported;
     setActiveTool: (tool: ({
         type: ToolType;
     } | {
@@ -450,10 +565,18 @@ 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;
     /**
      * returns whether user is making a gesture with >= 2 fingers (points)
      * on o touch screen (not on a trackpad). Currently only relates to Darwin
@@ -469,32 +592,229 @@ declare class App extends React.Component<AppProps, AppState> {
     private deselectElements;
     private getSelectedTextElement;
     private getSelectedTextEditingContainerAtPosition;
-    private getTextElementAtPosition;
+    getTextElementAtPosition(x: number, y: number): NonDeleted<ExcalidrawTextElement> | null;
     private isHittingTextAutoResizeHandle;
     private handleTextAutoResizeHandlePointerDown;
-    private getElementAtPosition;
+    getElementAtPosition(x: number, y: number, opts?: ({
+        includeBoundTextElement?: boolean;
+        includeLockedElements?: boolean;
+    } | {
+        allHitElements: NonDeleted<ExcalidrawElement>[];
+    }) & {
+        preferSelected?: boolean;
+    }): NonDeleted<ExcalidrawElement> | null;
     private getElementsAtPosition;
     getElementHitThreshold(element: ExcalidrawElement): number;
     private hitElement;
-    private getTextBindableContainerAtPosition;
+    getTextBindableContainerAtPosition(x: number, y: number): (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;
+        link: string | null;
+        locked: boolean;
+        customData?: Record<string, any>;
+    }> & {
+        type: "rectangle";
+    } & {
+        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;
+        link: string | null;
+        locked: boolean;
+        customData?: Record<string, any>;
+    }> & {
+        type: "diamond";
+    } & {
+        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;
+        link: string | null;
+        locked: boolean;
+        customData?: Record<string, any>;
+    }> & {
+        type: "ellipse";
+    } & {
+        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;
+        link: string | null;
+        locked: boolean;
+        customData?: Record<string, any>;
+    }> & Readonly<{
+        type: "line" | "arrow";
+        points: readonly LocalPoint[];
+        startBinding: import("@excalidraw/element/types").FixedPointBinding | null;
+        endBinding: import("@excalidraw/element/types").FixedPointBinding | null;
+        startArrowhead: import("@excalidraw/element/types").Arrowhead | null;
+        endArrowhead: import("@excalidraw/element/types").Arrowhead | null;
+    }> & Readonly<{
+        type: "arrow";
+        elbowed: boolean;
+    }> & {
+        isDeleted: false;
+    }) | null;
+    /**
+     * Whether a text element's content is still being authored.
+     *
+     * Creating a text reverts the tool to selection during pointerdown, so the
+     * pointerup that follows looks like an ordinary canvas click and would
+     * capture the still-empty element as a history entry of its own. Undo would
+     * then rewind only the typing, restoring an invisible, zero-content element
+     * (and, for an endpoint label, leaving the arrow bound to it) rather than
+     * removing it. The editor's own submit captures the finished text instead,
+     * so the whole create-and-type lands in a single entry.
+     */
+    private isEditingTextContent;
     private startTextEditing;
     private startImageCropping;
     private finishImageCropping;
     private shouldHandleBrowserCanvasDoubleClick;
     private handleCanvasDoubleClick;
     private handleCanvasClick;
+    private getImageStatusActionAtPosition;
+    private isPointInsideImageStatusOverlay;
     private getElementLinkAtPosition;
     private handleElementLinkClick;
-    private openElementLink;
+    /**
+     * Applies (or clears) the element-link hover affordances — pointer cursor
+     * and tooltip — based on the current `hitLinkElement`. Returns whether a
+     * link is being hovered.
+     */
+    private applyElementLinkHoverAffordance;
+    /**
+     * On touchscreens (where no hover precedes the tap) re-derives
+     * `hitLinkElement`, then opens the hit element link, if any.
+     * Returns whether a link click was handled.
+     */
+    private maybeHandleElementLinkClick;
+    /**
+     * Restricted pointer handling for the non-interactive editor with links
+     * and/or embeds allowed (`interaction.enabled.links` / `.embeds` /
+     * `.interactiveContent`) — runs only the element-link & embed concerns
+     * (shared with the full pointer handlers above) so they behave like in
+     * view mode without the rest of the canvas pointer machinery.
+     */
+    private handleInteractiveContentPointerMove;
+    private handleInteractiveContentPointerUp;
     /**
      * finds candidate frame under cursor (when dragging frame children/elements
      * inside frames)
      */
-    private getTopLayerFrameAtSceneCoords;
+    getTopLayerFrameAtSceneCoords: (
+    /**
+     * should be already grid aligned (basically should be what the call site
+     * sets the element's coords to, if applicable)
+     */
+    sceneCoords: {
+        x: number;
+        y: number;
+    }, opts?: {
+        /** to exclude selected elements when dragging, etc. */
+        excludeElementIds?: AppState["selectedElementIds"];
+        currentFrameId?: ExcalidrawElement["frameId"];
+    }) => NonDeleted<ExcalidrawFrameLikeElement> | null;
     private updateFrameToHighlight;
     private maybeUpdateFrameToHighlightOnPointerMove;
-    private insertNewElements;
-    private insertNewElement;
+    insertNewElements: (elements: readonly ExcalidrawElement[]) => void;
+    insertNewElement: (element: ExcalidrawElement) => void;
     private handleCanvasPointerMove;
     private handleEraser;
     private handleTouchMove;
@@ -509,10 +829,13 @@ declare class App extends React.Component<AppProps, AppState> {
      * pointerup handlers manually
      */
     private maybeCleanupAfterMissingPointerUp;
-    private handleCanvasZoomUsingZDrag;
-    private restoreCursorAfterZoomKey;
     handleCanvasPanUsingWheelOrSpaceDrag: (event: React.PointerEvent<HTMLElement> | MouseEvent) => boolean;
     private updateGestureOnPointerDown;
+    /**
+     * Tracks the pointer within the ongoing multi-touch gesture and applies
+     * the two-finger pinch zoom/pan, if any.
+     */
+    private updateMultiTouchGesture;
     private initialPointerDownState;
     private handleDraggingScrollBar;
     private clearSelectionIfNotUsingSelection;
@@ -576,10 +899,15 @@ declare class App extends React.Component<AppProps, AppState> {
     private maybeDragNewGenericElement;
     private maybeHandleCrop;
     private maybeHandleResize;
-    private getContextMenuItems;
     private getImageContextMenuItems;
+    private getContextMenuItems;
     private handleWheel;
-    private getTextWysiwygSnappedToCenterPosition;
+    getTextWysiwygSnappedToCenterPosition(x: number, y: number, appState: AppState, container?: ExcalidrawTextContainer | null): {
+        viewportX: number;
+        viewportY: number;
+        elementCenterX: number;
+        elementCenterY: number;
+    } | undefined;
     private savePointer;
     private resetShouldCacheIgnoreZoomDebounced;
     private updateDOMRect;

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;
+}