@excalidraw/element 0.18.0-4872083 → 0.18.0-4ce38fb

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

@@ -1,8 +1,8 @@
 import React from "react";
 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 { LocalPoint, Radians } from "@excalidraw/math";
-import type { ExcalidrawElement, ExcalidrawTextElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawTextContainer, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered, SceneElementsMap } from "@excalidraw/element/types";
+import type { ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered, SceneElementsMap } from "@excalidraw/element/types";
+import type { TransformHandleDirection } from "@excalidraw/element";
 import type { Mutable } from "@excalidraw/common/utility-types";
 import { ActionManager } from "../actions/manager";
 import { History } from "../history";
@@ -15,15 +15,22 @@ import { isOverScrollBars } from "../scene/scrollbars";
 import { LassoTrail } from "../lasso";
 import { EraserTrail } from "../eraser";
 import { AppArrowText } from "./App.arrowText";
+import { AppClipboard } from "./App.clipboard";
+import { AppText } from "./App.text";
+import { AppTextTool } from "./App.textTool";
 import { AppBucketFill } from "./App.bucketFill";
+import { AppToolDrag } from "./App.toolDrag";
 import { AppCursor } from "./App.cursor";
 import { AppDrawShape } from "./App.drawshape";
+import { AppDuplicate } from "./App.duplicate";
 import { AppFlowchart } from "./App.flowchart";
+import { AppPan } from "./App.pan";
 import { AppViewport } from "./App.viewport";
+import { AppWheel } from "./App.wheel";
 import { CursorHints } from "./CursorHint";
 import { type OnStateChange } from "./AppStateObserver";
 import type { ExportedElements } from "../data";
-import type { AppClassProperties, AppProps, AppState, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, SceneData, FrameNameBoundsCache, SidebarName, SidebarTabName, ToolType, OnUserFollowedPayload, ExcalidrawImperativeAPIEventMap, GenerateDiagramToCode, NullableGridSize, UIConfig } from "../types";
+import type { AppClassProperties, AppProps, AppState, ElementRenderOverrides, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, PointerDownState, SceneData, FrameNameBoundsCache, SidebarName, SidebarTabName, KeyboardModifiersObject, ToolType, OnUserFollowedPayload, ExcalidrawImperativeAPIEventMap, GenerateDiagramToCode, NullableGridSize, UIConfig } from "../types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 import type { ActionResult } from "../actions/types";
 declare const editorLifecycleEventBehavior: {
@@ -82,6 +89,9 @@ declare class App extends React.Component<AppProps, AppState> {
     editorInterface: EditorInterface;
     private stylesPanelMode;
     private excalidrawContainerRef;
+    private zenModeTransitionTimer;
+    get ownerDocument(): Document;
+    get ownerWindow(): Window & typeof globalThis;
     scene: Scene;
     fonts: Fonts;
     renderer: Renderer;
@@ -93,7 +103,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,14 +129,27 @@ declare class App extends React.Component<AppProps, AppState> {
     private appStateObserver;
     onStateChange: OnStateChange;
     bucketFill: AppBucketFill;
+    duplicate: AppDuplicate;
+    toolDrag: AppToolDrag;
     flowchart: AppFlowchart;
     cursor: AppCursor;
     arrowText: AppArrowText;
+    pan: AppPan;
+    textTool: AppTextTool;
+    clipboard: AppClipboard;
+    text: AppText;
     viewport: AppViewport;
+    wheel: AppWheel;
     bindModeHandler: ReturnType<typeof setTimeout> | null;
-    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;
@@ -184,7 +207,10 @@ declare class App extends React.Component<AppProps, AppState> {
             allHitElements: NonDeleted<ExcalidrawElement>[];
             wasAddedToSelection: boolean;
             hasBeenDuplicated: boolean;
+            advancedListMarkers: readonly import("@excalidraw/element").ListMarkerAdvance[];
+            editedTextId: import("@excalidraw/element/types").ExcalidrawTextElement["id"] | null;
             hasHitCommonBoundingBoxOfSelectedElements: boolean;
+            arrowLabel: boolean;
         };
         withCmdOrCtrl: boolean;
         drag: {
@@ -246,7 +272,10 @@ declare class App extends React.Component<AppProps, AppState> {
             allHitElements: NonDeleted<ExcalidrawElement>[];
             wasAddedToSelection: boolean;
             hasBeenDuplicated: boolean;
+            advancedListMarkers: readonly import("@excalidraw/element").ListMarkerAdvance[];
+            editedTextId: import("@excalidraw/element/types").ExcalidrawTextElement["id"] | null;
             hasHitCommonBoundingBoxOfSelectedElements: boolean;
+            arrowLabel: boolean;
         };
         withCmdOrCtrl: boolean;
         drag: {
@@ -278,6 +307,12 @@ declare class App extends React.Component<AppProps, AppState> {
     missingPointerEventCleanupEmitter: Emitter<[event: PointerEvent | null]>;
     onRemoveEventListenersEmitter: Emitter<[]>;
     api: ExcalidrawImperativeAPI;
+    private elementRenderOverrides;
+    /** offsets of `elementRenderOverrides`; keeps its identity while they don't change */
+    private elementRenderOffsets;
+    private renderOverridesUpdatePending;
+    private getRenderOverrideConfig;
+    private getElementRenderState;
     private createExcalidrawAPI;
     constructor(props: AppProps);
     /**
@@ -361,8 +396,12 @@ declare class App extends React.Component<AppProps, AppState> {
      * If disabled, returns null.
      */
     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;
@@ -403,7 +442,8 @@ declare class App extends React.Component<AppProps, AppState> {
     private onBlur;
     private onUnload;
     private disableEvent;
-    private preventBrowserZoomWheel;
+    private isFileDropEnabled;
+    private onDragOver;
     private handleNavigationModeKeyDown;
     /**
      * PageUp/PageDown scroll the canvas by a page — vertically, or
@@ -448,16 +488,20 @@ declare class App extends React.Component<AppProps, AppState> {
     private onFullscreenChange;
     private removeEventListeners;
     private addEventListeners;
+    getSnapshotBeforeUpdate(prevProps: AppProps, prevState: AppState): null;
+    /**
+     * Flags the container while toggling zen mode so that UI chrome
+     * (backgrounds etc.) animates only then, and hover transitions stay
+     * instant. A data attribute so that React doesn't reset it on re-render.
+     */
+    private markZenModeTransition;
+    private unmarkZenModeTransition;
     componentDidUpdate(prevProps: AppProps, prevState: AppState): void;
     private renderInteractiveSceneCallback;
     private onScroll;
-    private onCut;
-    private onCopy;
     private static resetTapTwice;
     private onTouchStart;
     private onTouchEnd;
-    private insertClipboardContent;
-    pasteFromClipboard: (event: ClipboardEvent) => Promise<void>;
     addElementsFromPasteOrLibrary: (opts: {
         elements: readonly ExcalidrawElement[];
         files: BinaryFiles | null;
@@ -469,8 +513,6 @@ declare class App extends React.Component<AppProps, AppState> {
         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;
@@ -482,9 +524,11 @@ declare class App extends React.Component<AppProps, AppState> {
      *  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 */
+     *  viewport changes that take the view over from the followed user (user
+     *  pans and zooms, `setViewport` navigation) */
     requestUnfollow: () => void;
     setToast: (toast: AppState["toast"]) => void;
+    private showSceneReplacedToast;
     restoreFileFromShare: () => Promise<void>;
     /**
      * adds supplied files to existing files in the appState.
@@ -509,6 +553,10 @@ declare class App extends React.Component<AppProps, AppState> {
          */
         captureUpdate?: SceneData["captureUpdate"];
     }) => void;
+    /**
+     * see {@link ExcalidrawImperativeAPI.setElementRenderOverrides} for details
+     */
+    setElementRenderOverrides: (overrides: ElementRenderOverrides | null) => void;
     applyDeltas: (deltas: StoreDelta[], options?: ApplyToOptions) => [SceneElementsMap, AppState, boolean];
     mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, informMutation?: boolean) => TElement;
     triggerRender: (
@@ -556,13 +604,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private onGestureStart;
     private onGestureChange;
     private onGestureEnd;
-    private handleTextWysiwyg;
-    private deselectElements;
-    private getSelectedTextElement;
-    private getSelectedTextEditingContainerAtPosition;
-    getTextElementAtPosition(x: number, y: number): NonDeleted<ExcalidrawTextElement> | null;
-    private isHittingTextAutoResizeHandle;
-    private handleTextAutoResizeHandlePointerDown;
+    deselectElements(): void;
     getElementAtPosition(x: number, y: number, opts?: ({
         includeBoundTextElement?: boolean;
         includeLockedElements?: boolean;
@@ -571,167 +613,17 @@ declare class App extends React.Component<AppProps, AppState> {
     }) & {
         preferSelected?: boolean;
     }): NonDeleted<ExcalidrawElement> | null;
-    private getElementsAtPosition;
-    getElementHitThreshold(element: ExcalidrawElement): number;
-    private hitElement;
-    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.
+    getElementsAtPosition(x: number, y: number, opts?: {
+        includeBoundTextElement?: boolean;
+        includeLockedElements?: boolean;
+    }): NonDeleted<ExcalidrawElement>[];
+    /**
+     * Whether the element's frame clips it away at the position — hitting a
+     * frame's element from outside the frame is not considered a hit.
      */
-    private isEditingTextContent;
-    private startTextEditing;
+    isClippedByFrameAt(x: number, y: number, element: ExcalidrawElement): boolean;
+    getElementHitThreshold(element: ExcalidrawElement): number;
+    hitElement(x: number, y: number, element: NonDeletedExcalidrawElement, considerBoundingBox?: boolean): boolean;
     private startImageCropping;
     private finishImageCropping;
     private shouldHandleBrowserCanvasDoubleClick;
@@ -784,8 +676,19 @@ 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;
+    /**
+     * The browser took the pointer over (scroll, pinch, palm rejection): no
+     * pointerup will follow, so the gesture is torn down here and now — the
+     * same cleanup a lost pointerup gets at the next press, only not left
+     * lying in wait for it, where its replay would tangle with that press.
+     */
+    private handleCanvasPointerCancel;
     private handleCanvasPointerUp;
     private maybeOpenContextMenuAfterPointerDownOnTouchDevices;
     private resetContextMenuTimer;
@@ -795,7 +698,6 @@ declare class App extends React.Component<AppProps, AppState> {
      * pointerup handlers manually
      */
     private maybeCleanupAfterMissingPointerUp;
-    handleCanvasPanUsingWheelOrSpaceDrag: (event: React.PointerEvent<HTMLElement> | MouseEvent) => boolean;
     private updateGestureOnPointerDown;
     /**
      * Tracks the pointer within the ongoing multi-touch gesture and applies
@@ -811,7 +713,6 @@ declare class App extends React.Component<AppProps, AppState> {
     private handleSelectionOnPointerDown;
     private isASelectedElement;
     private isHittingCommonBoundingBoxOfSelectedElements;
-    private handleTextOnPointerDown;
     private handleFreeDrawElementOnPointerDown;
     insertIframeElement: ({ sceneX, sceneY, width, height, }: {
         sceneX: number;
@@ -826,12 +727,14 @@ 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;
-    private maybeCacheVisibleGaps;
+    maybeCacheReferenceSnapPoints(event: KeyboardModifiersObject, selectedElements: readonly NonDeletedExcalidrawElement[], recomputeAnyways?: boolean): void;
+    maybeCacheVisibleGaps(event: KeyboardModifiersObject, selectedElements: readonly NonDeletedExcalidrawElement[], recomputeAnyways?: boolean): void;
     private onKeyDownFromPointerDownHandler;
     private onKeyUpFromPointerDownHandler;
     private onPointerMoveFromPointerDownHandler;
@@ -858,23 +761,31 @@ declare class App extends React.Component<AppProps, AppState> {
     private scheduleImageRefresh;
     private clearSelection;
     private handleInteractiveCanvasRef;
-    private insertImages;
+    insertImages: (imageFiles: File[], sceneX: number, sceneY: number) => Promise<void>;
     private handleAppOnDrop;
-    loadFileToCanvas: (file: File, fileHandle: FileSystemFileHandle | null) => Promise<void>;
+    /** @returns true if the file replaced the scene */
+    loadFileToCanvas: (file: File, fileHandle: FileSystemFileHandle | null, insertPosition?: {
+        clientX: number;
+        clientY: number;
+    }) => Promise<true | undefined>;
     private handleCanvasContextMenu;
-    private maybeDragNewGenericElement;
+    /** opens the context menu for the element under the pointer, or the canvas */
+    openContextMenu: (pointer: {
+        clientX: number;
+        clientY: number;
+        button?: number;
+        pointerType?: string;
+    }) => void;
+    maybeDragNewGenericElement: (pointerDownState: PointerDownState, event: MouseEvent | KeyboardEvent, informMutation?: boolean) => void;
     private maybeHandleCrop;
     private maybeHandleResize;
     private getContextMenuItems;
-    private handleWheel;
-    getTextWysiwygSnappedToCenterPosition(x: number, y: number, appState: AppState, container?: ExcalidrawTextContainer | null): {
-        viewportX: number;
-        viewportY: number;
-        elementCenterX: number;
-        elementCenterY: number;
-    } | undefined;
-    private savePointer;
-    private resetShouldCacheIgnoreZoomDebounced;
+    savePointer: (x: number, y: number, button: "up" | "down") => void;
+    resetShouldCacheIgnoreZoomDebounced: {
+        (): void;
+        flush(): void;
+        cancel(): void;
+    };
     private updateDOMRect;
     refresh: () => void;
     private getCanvasOffsets;

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

@@ -0,0 +1,101 @@
+import { duplicateElements } from "@excalidraw/element";
+import type { ExcalidrawElement, ExcalidrawTextElement } from "@excalidraw/element/types";
+import type { PointerDownState } from "../types";
+import type App from "./App";
+type Duplication = Pick<ReturnType<typeof duplicateElements>, "duplicatedElements" | "duplicateElementsMap" | "origElementsMap" | "origIdToDuplicateId" | "duplicateIdToOrigId">;
+/**
+ * Owns the duplication paths which involve the host (`props.onDuplicate`):
+ * duplicating elements into the scene (paste, library insert etc.), and
+ * duplicating the dragged selection (alt-drag). The duplicate action shares
+ * `runOnDuplicate()`.
+ */
+export declare class AppDuplicate {
+    private app;
+    private dependencies;
+    constructor(app: App, dependencies: {
+        /** pointers currently down */
+        getPointerCount: () => number;
+    });
+    /**
+     * Hands the duplication over to the host's `props.onDuplicate` (if any),
+     * and reconciles what it returned with the duplicates.
+     *
+     * @returns next elements, and the duplicates that weren't vetoed
+     */
+    runOnDuplicate: (duplication: Duplication, nextElements: ExcalidrawElement[], 
+    /** excludes the duplicated elements */
+    prevElements: readonly ExcalidrawElement[]) => {
+        elements: ExcalidrawElement[];
+        duplicatedElements: import("@excalidraw/element/types").NonDeletedExcalidrawElement[];
+    };
+    /**
+     * Runs `update` once what's pending is committed, capturing what it changes
+     * (if it returns `true`) as a separate undo step.
+     */
+    private afterCommit;
+    /**
+     * Advances the list markers of the duplicated texts (`1.` -> `2.`) once
+     * the duplication is committed, as a separate undo step, so that undo
+     * reverts the markers first.
+     */
+    advanceListMarkers: (duplicatedElements: readonly ExcalidrawElement[]) => void;
+    /**
+     * The text whose editing an alt-press on it ended, while the press is
+     * handed over to the canvas (see `handOverTextEditorPress()`).
+     */
+    handedOverTextId: ExcalidrawTextElement["id"] | null;
+    /**
+     * An alt-press on the text being edited, once it ended the editing, is
+     * handed over to the canvas, for the text to be alt-dragged (duplicated) as
+     * on the canvas — its duplicate is then edited on drop.
+     */
+    handOverTextEditorPress: (event: PointerEvent, textElementId: ExcalidrawTextElement["id"]) => void;
+    /**
+     * The pointer down a handed-over press is replayed as (see
+     * `handOverTextEditorPress()`) moves what was edited — the text, or its
+     * container — and nothing beneath the editor, which reaches past the text:
+     * no resize handle, nor an arrow's point, midpoint or label.
+     *
+     * @returns `false` if the pointer down isn't a handed-over press
+     */
+    hitEditedElement: (pointerDownState: PointerDownState) => boolean;
+    /**
+     * On alt-drag drop: the list markers advanced along with the drag go back,
+     * for the drag to be committed as is, and forth again once it is, as
+     * a separate undo step (before the browser gets to paint either).
+     *
+     * A duplicate is then edited (once the drop is committed): a single list
+     * item with text after its marker, with that text selected (`1. |foo|`),
+     * as it's likely to differ from the original's — or else the duplicate of
+     * the text the drag ended the editing of, with all of it selected.
+     */
+    commitDraggedDuplicates: ({ hit }: PointerDownState, { editText, }: {
+        /** `false` if the drag didn't end with a genuine pointerup */
+        editText: boolean;
+    }) => void;
+    private editDuplicatedText;
+    /**
+     * Duplicates elements so that they end up centered at the scene coords
+     * (and in the frame at that point, if any). Doesn't update the scene.
+     *
+     * @returns `null` if the host vetoed the duplication
+     */
+    duplicateAtSceneCoords: (elements: readonly ExcalidrawElement[], { x, y }: {
+        x: number;
+        y: number;
+    }, opts?: {
+        retainSeed?: boolean;
+        preserveFrameChildrenOrder?: boolean;
+    }) => {
+        nextElements: ExcalidrawElement[];
+        duplicatedElements: import("@excalidraw/element/types").NonDeletedExcalidrawElement[];
+    } | null;
+    /**
+     * Duplicates the selection being dragged: the originals go back to where
+     * the drag started, and the drag continues with the duplicates.
+     *
+     * If the host vetoes the duplication, the originals keep being dragged.
+     */
+    duplicateDraggedSelection: (pointerDownState: PointerDownState, event: PointerEvent) => void;
+}
+export {};

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

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