@excalidraw/math 0.18.0-414182f → 0.18.0-43a92e6

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

@@ -0,0 +1,55 @@
+import { DrawShapeTrail } from "../drawShapeTrail";
+import type App from "./App";
+import type { PointerDownState } from "../types";
+/**
+ * Captures the App state management for the drawShape tool (free-form
+ * sketch converted into a recognized excalidraw element). Pointer events
+ * are piped here from App.
+ *
+ * The gesture is committed by `finalize()` — recognize → (maybe upgrade
+ * line to arrow) → insert → bind endpoints — which is invoked from within
+ * `actionFinalize`, the editor's single finalization funnel. Whatever
+ * triggers a finalize (the gesture's own pointerup, a mid-gesture paste
+ * switching tools, …), the pending sketch resolves there exactly once.
+ */
+export declare class AppDrawShape {
+    private app;
+    trail: DrawShapeTrail;
+    /** a pointerdown started a sketch that `finalize()` hasn't resolved yet */
+    private gestureInProgress;
+    constructor(app: App);
+    stop: () => void;
+    hasPendingGesture: () => boolean;
+    handlePointerDown: (pointerDownState: PointerDownState) => void;
+    /** returns true when the pointermove was consumed by the shape preview */
+    handlePointerMove: (pointerCoords: {
+        x: number;
+        y: number;
+    }) => boolean;
+    /**
+     * Binds both endpoints of a freshly inserted drawShape arrow to the
+     * bindable elements they hover, if any.
+     *
+     * Endpoints bind in "orbit" mode — the arrow starts/ends at the target's
+     * outline — even when the stroke was started or released inside the shape
+     * (a sketched connector aims at the shape, not at a point inside it). The
+     * exception is a sketch contained in a single shape: both ends then bind
+     * "inside" and stay where they were drawn, like the interactive
+     * inside→inside flow.
+     */
+    private bindRecognizedArrow;
+    /**
+     * A sketched line that connects a bindable element with something else —
+     * another element or blank canvas — was meant as a connector: upgrade it
+     * to an arrow (called before insertion). A line touching no shape, or
+     * contained in a single shape (an annotation, not a connector), stays a
+     * line.
+     */
+    private maybeUpgradeLineToArrow;
+    /**
+     * Commits the pending sketch, if any, and clears the trail. Invoked from
+     * within `actionFinalize` — never call directly, execute `actionFinalize`
+     * instead so element insertion flows into the action's returned elements.
+     */
+    finalize: () => void;
+}

package/dist/types/excalidraw/components/App.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.flowchart.d.ts

@@ -0,0 +1,21 @@
+import type React from "react";
+import type App from "./App";
+import type { PendingExcalidrawElements } from "../types";
+/**
+ * Captures the App state management for the flowchart functionality.
+ */
+export declare class AppFlowchart {
+    private app;
+    private creator;
+    private navigator;
+    constructor(app: App);
+    get pendingNodes(): PendingExcalidrawElements | null;
+    get isCreatingChart(): boolean;
+    /** ends any in-progress flowchart creation/navigation session */
+    clear: () => void;
+    handleKeyEvent: (event: React.KeyboardEvent | KeyboardEvent) => boolean;
+    private resolveKeyboardEventToOperation;
+    private selectAndReveal;
+    private captureUpdate;
+    private static getLinkDirectionFromKey;
+}

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

@@ -0,0 +1,38 @@
+import { Emitter } from "@excalidraw/common";
+export type HeldModifiers = Readonly<{
+    alt: boolean;
+    shift: boolean;
+    /** Ctrl, or Cmd on macOS */
+    ctrlOrCmd: boolean;
+}>;
+/**
+ * The modifier keys held over the editor, synced from the flags of its
+ * keyboard and pointer events. Kept out of appState so that pressing one
+ * re-renders only its subscribers (e.g. the hint).
+ */
+export declare class AppModifiers {
+    private held;
+    /** fires with a new snapshot whenever a modifier is pressed or released */
+    readonly onChange: Emitter<[held: Readonly<{
+        alt: boolean;
+        shift: boolean;
+        /** Ctrl, or Cmd on macOS */
+        ctrlOrCmd: boolean;
+    }>]>;
+    get: () => HeldModifiers;
+    /**
+     * A hook re-rendering on the held modifiers: all of them, or with
+     * `modifier`, only on that one being pressed or released.
+     */
+    useHeld(): HeldModifiers;
+    useHeld(modifier: keyof HeldModifiers): boolean;
+    sync: (event: {
+        altKey: boolean;
+        shiftKey: boolean;
+        ctrlKey: boolean;
+        metaKey: boolean;
+    }) => void;
+    /** releases them all — e.g. on blur, as Alt+Tab never delivers the keyup */
+    reset: () => void;
+    private set;
+}

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

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

@@ -0,0 +1,265 @@
+import { LinearElementEditor } from "@excalidraw/element";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { Mutable } from "@excalidraw/common/utility-types";
+import type { CaptureUpdateActionType } from "@excalidraw/element";
+import type { AppClassProperties, AppState, InteractiveCanvasAppState } from "../types";
+import type App from "./App";
+export declare const selectGroupsForSelectedElements: {
+    (appState: Pick<AppState, "selectedElementIds" | "editingGroupId">, elements: readonly NonDeletedExcalidrawElement[], prevAppState: InteractiveCanvasAppState, app: AppClassProperties | null): Mutable<Pick<InteractiveCanvasAppState, "selectedGroupIds" | "editingGroupId" | "selectedElementIds">>;
+    clearCache(): void;
+};
+/**
+ * The selection of the given elements alone, with their groups (within the
+ * edited group): a frame wins over its children, bound text is left to its
+ * container, and a lone line or arrow gets its line editor.
+ *
+ * @param allElements the (non-deleted) elements the selection is in
+ * @param deep select the elements themselves rather than their groups,
+ *   editing their innermost group if they share it (and no group otherwise)
+ *   — as Ctrl+click does
+ */
+export declare const getSelectionStateForElements: (targetElements: readonly NonDeletedExcalidrawElement[], allElements: readonly NonDeletedExcalidrawElement[], appState: AppState, deep?: boolean) => Mutable<Pick<Readonly<{
+    zoom: AppState["zoom"];
+    scrollX: AppState["scrollX"];
+    scrollY: AppState["scrollY"];
+    width: AppState["width"];
+    height: AppState["height"];
+    viewModeEnabled: AppState["viewModeEnabled"];
+    openDialog: AppState["openDialog"];
+    editingGroupId: AppState["editingGroupId"];
+    selectedElementIds: AppState["selectedElementIds"];
+    frameToHighlight: AppState["frameToHighlight"];
+    offsetLeft: AppState["offsetLeft"];
+    offsetTop: AppState["offsetTop"];
+    theme: AppState["theme"];
+} & {
+    activeTool: AppState["activeTool"];
+    activeEmbeddable: AppState["activeEmbeddable"];
+    selectionElement: AppState["selectionElement"];
+    selectedGroupIds: AppState["selectedGroupIds"];
+    selectedLinearElement: AppState["selectedLinearElement"];
+    multiElement: AppState["multiElement"];
+    newElement: AppState["newElement"];
+    isBindingEnabled: AppState["isBindingEnabled"];
+    isMidpointSnappingEnabled: AppState["isMidpointSnappingEnabled"];
+    gridModeEnabled: AppState["gridModeEnabled"];
+    suggestedBinding: AppState["suggestedBinding"];
+    textToolHover: AppState["textToolHover"];
+    isRotating: AppState["isRotating"];
+    elementsToHighlight: AppState["elementsToHighlight"];
+    collaborators: AppState["collaborators"];
+    snapLines: AppState["snapLines"];
+    zenModeEnabled: AppState["zenModeEnabled"];
+    editingTextElement: AppState["editingTextElement"];
+    isCropping: AppState["isCropping"];
+    croppingElementId: AppState["croppingElementId"];
+    searchMatches: AppState["searchMatches"];
+    activeLockedId: AppState["activeLockedId"];
+    hoveredElementIds: AppState["hoveredElementIds"];
+    frameRendering: AppState["frameRendering"];
+    shouldCacheIgnoreZoom: AppState["shouldCacheIgnoreZoom"];
+    exportScale: AppState["exportScale"];
+    currentItemArrowType: AppState["currentItemArrowType"];
+}>, "selectedElementIds" | "editingGroupId" | "selectedGroupIds">> & {
+    selectedLinearElement: LinearElementEditor | null;
+};
+/**
+ * The selection with the given elements added, with their groups (within the
+ * edited group) — and the line editor of a lone selected line or arrow.
+ *
+ * A frame and its children aren't selected at the same time: an added frame
+ * deselects its children, an added child of a selected (or added) frame is
+ * left out, and adding elements grouped with frames deselects those frames'
+ * children (and leaves the added ones out). In the element link selector, the
+ * added elements replace the selection (unless one's group is selected).
+ *
+ * @param allElements the (non-deleted) elements the selection is in
+ */
+export declare const getSelectionStateAddingElements: (targetElements: readonly NonDeletedExcalidrawElement[], allElements: readonly NonDeletedExcalidrawElement[], appState: AppState) => Mutable<Pick<Readonly<{
+    zoom: AppState["zoom"];
+    scrollX: AppState["scrollX"];
+    scrollY: AppState["scrollY"];
+    width: AppState["width"];
+    height: AppState["height"];
+    viewModeEnabled: AppState["viewModeEnabled"];
+    openDialog: AppState["openDialog"];
+    editingGroupId: AppState["editingGroupId"];
+    selectedElementIds: AppState["selectedElementIds"];
+    frameToHighlight: AppState["frameToHighlight"];
+    offsetLeft: AppState["offsetLeft"];
+    offsetTop: AppState["offsetTop"];
+    theme: AppState["theme"];
+} & {
+    activeTool: AppState["activeTool"];
+    activeEmbeddable: AppState["activeEmbeddable"];
+    selectionElement: AppState["selectionElement"];
+    selectedGroupIds: AppState["selectedGroupIds"];
+    selectedLinearElement: AppState["selectedLinearElement"];
+    multiElement: AppState["multiElement"];
+    newElement: AppState["newElement"];
+    isBindingEnabled: AppState["isBindingEnabled"];
+    isMidpointSnappingEnabled: AppState["isMidpointSnappingEnabled"];
+    gridModeEnabled: AppState["gridModeEnabled"];
+    suggestedBinding: AppState["suggestedBinding"];
+    textToolHover: AppState["textToolHover"];
+    isRotating: AppState["isRotating"];
+    elementsToHighlight: AppState["elementsToHighlight"];
+    collaborators: AppState["collaborators"];
+    snapLines: AppState["snapLines"];
+    zenModeEnabled: AppState["zenModeEnabled"];
+    editingTextElement: AppState["editingTextElement"];
+    isCropping: AppState["isCropping"];
+    croppingElementId: AppState["croppingElementId"];
+    searchMatches: AppState["searchMatches"];
+    activeLockedId: AppState["activeLockedId"];
+    hoveredElementIds: AppState["hoveredElementIds"];
+    frameRendering: AppState["frameRendering"];
+    shouldCacheIgnoreZoom: AppState["shouldCacheIgnoreZoom"];
+    exportScale: AppState["exportScale"];
+    currentItemArrowType: AppState["currentItemArrowType"];
+}>, "selectedElementIds" | "editingGroupId" | "selectedGroupIds">> & {
+    selectedLinearElement: LinearElementEditor | null;
+};
+/**
+ * The selection with the given elements removed — with the group they're
+ * selected via (if any) — and a lone remaining line or arrow getting its
+ * line editor.
+ *
+ * @param allElements the (non-deleted) elements the selection is in
+ */
+export declare const getSelectionStateRemovingElements: (targetElements: readonly NonDeletedExcalidrawElement[], allElements: readonly NonDeletedExcalidrawElement[], appState: AppState) => Mutable<Pick<Readonly<{
+    zoom: AppState["zoom"];
+    scrollX: AppState["scrollX"];
+    scrollY: AppState["scrollY"];
+    width: AppState["width"];
+    height: AppState["height"];
+    viewModeEnabled: AppState["viewModeEnabled"];
+    openDialog: AppState["openDialog"];
+    editingGroupId: AppState["editingGroupId"];
+    selectedElementIds: AppState["selectedElementIds"];
+    frameToHighlight: AppState["frameToHighlight"];
+    offsetLeft: AppState["offsetLeft"];
+    offsetTop: AppState["offsetTop"];
+    theme: AppState["theme"];
+} & {
+    activeTool: AppState["activeTool"];
+    activeEmbeddable: AppState["activeEmbeddable"];
+    selectionElement: AppState["selectionElement"];
+    selectedGroupIds: AppState["selectedGroupIds"];
+    selectedLinearElement: AppState["selectedLinearElement"];
+    multiElement: AppState["multiElement"];
+    newElement: AppState["newElement"];
+    isBindingEnabled: AppState["isBindingEnabled"];
+    isMidpointSnappingEnabled: AppState["isMidpointSnappingEnabled"];
+    gridModeEnabled: AppState["gridModeEnabled"];
+    suggestedBinding: AppState["suggestedBinding"];
+    textToolHover: AppState["textToolHover"];
+    isRotating: AppState["isRotating"];
+    elementsToHighlight: AppState["elementsToHighlight"];
+    collaborators: AppState["collaborators"];
+    snapLines: AppState["snapLines"];
+    zenModeEnabled: AppState["zenModeEnabled"];
+    editingTextElement: AppState["editingTextElement"];
+    isCropping: AppState["isCropping"];
+    croppingElementId: AppState["croppingElementId"];
+    searchMatches: AppState["searchMatches"];
+    activeLockedId: AppState["activeLockedId"];
+    hoveredElementIds: AppState["hoveredElementIds"];
+    frameRendering: AppState["frameRendering"];
+    shouldCacheIgnoreZoom: AppState["shouldCacheIgnoreZoom"];
+    exportScale: AppState["exportScale"];
+    currentItemArrowType: AppState["currentItemArrowType"];
+}>, "selectedElementIds" | "editingGroupId" | "selectedGroupIds">> & {
+    selectedLinearElement: LinearElementEditor | null;
+};
+/** elements, or their ids — one or many */
+export type ElementsOrIds = ExcalidrawElement | ExcalidrawElement["id"] | readonly (ExcalidrawElement | ExcalidrawElement["id"])[];
+type SelectionChangeOptions = {
+    /**
+     * how the change is recorded for undo (see `updateScene()`) — by default,
+     * along with the next undoable change
+     */
+    captureUpdate?: CaptureUpdateActionType;
+};
+type AddOptions = SelectionChangeOptions & {
+    /**
+     * select locked elements too — e.g. for the context menu to offer unlocking
+     * them
+     */
+    includeLocked?: boolean;
+};
+type SelectOptions = AddOptions & {
+    /**
+     * select the elements themselves rather than their groups, editing their
+     * innermost group (if they share it) — as Ctrl+click does
+     */
+    deep?: boolean;
+};
+/**
+ * The selection: selecting elements, adding them to or removing them from
+ * the selection, and clearing it — keeping its rules: an element is selected
+ * with its group (but within the edited group), a frame and its children
+ * aren't selected at the same time, locked elements aren't selected, and a
+ * lone line or arrow gets its line editor (see the `getSelectionState*()`
+ * functions above).
+ *
+ * What hangs on the selection follows it: the link popup shows for a lone
+ * selected element with a link (or an embeddable), an embed stays active only
+ * while selected, cropping ends (unless the cropped image is selected again),
+ * and selecting (or adding) anything but the edited text ends text editing,
+ * submitting the text. The line editor ends once its line is deselected (see
+ * `componentDidUpdate()`).
+ *
+ * Elements are taken by id from the scene: missing and deleted ones are
+ * skipped.
+ */
+export declare class AppSelection {
+    private app;
+    constructor(app: App);
+    /**
+     * Selects the elements alone (with their groups, unless `deep`).
+     */
+    select: (elementsOrIds: ElementsOrIds, opts?: SelectOptions) => void;
+    /**
+     * Adds the elements (with their groups) to the selection.
+     */
+    add: (elementsOrIds: ElementsOrIds, opts?: AddOptions) => void;
+    /**
+     * Removes the elements from the selection — with the group they're
+     * selected via.
+     */
+    remove: (elementsOrIds: ElementsOrIds, opts?: SelectionChangeOptions) => void;
+    /**
+     * Clears the selection, leaving the edited group and ending cropping.
+     *
+     * (Doesn't end text editing: starting it clears the selection.)
+     */
+    clear: (opts?: SelectionChangeOptions) => void;
+    /**
+     * Ends what changing the selection ends — cropping (unless
+     * `keepsCroppedImage`), and text editing (unless selecting the edited text,
+     * or its container) — and records the change for undo as asked.
+     *
+     * @param elements the elements being selected (or added) — none for a
+     *   change that leaves text editing be
+     */
+    private beforeChange;
+    /**
+     * The next selection state with what follows it: the link popup — shown for
+     * a lone selected element with a link (or an embeddable), the link editor
+     * staying open if it's the same element, and hidden otherwise — and the
+     * active embed, which stays active only while selected.
+     */
+    private withFollowingState;
+    isASelectedElement(hitElement: ExcalidrawElement | null): boolean;
+    isHittingCommonBoundingBoxOfSelectedElements(point: Readonly<{
+        x: number;
+        y: number;
+    }>, selectedElements: readonly ExcalidrawElement[]): boolean;
+    /**
+     * The scene's (non-deleted) elements, by id, once each — but locked ones,
+     * unless `includeLocked`
+     */
+    private resolve;
+}
+export {};

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

@@ -0,0 +1,93 @@
+import type { TransformHandleType } from "@excalidraw/element";
+import type { ExcalidrawElement, ExcalidrawImageElement, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, PointerType } from "@excalidraw/element/types";
+import type React from "react";
+import type { PointerDownState } from "../types";
+import type App from "./App";
+/**
+ * The selection tool's (and the lasso's) selection: what a pointer down
+ * selects, what a click (a pointer up without a drag) does to the selection —
+ * including alt-click cycling through the overlapping elements — and the
+ * selection's transform handles (resizing, rotating, cropping).
+ */
+export declare class AppSelectionTool {
+    private app;
+    constructor(app: App);
+    clearSelectionIfNotUsingSelection: () => void;
+    /**
+     * @returns whether the pointer event has been completely handled
+     */
+    handleSelectionOnPointerDown: (event: React.PointerEvent<HTMLElement>, pointerDownState: PointerDownState) => boolean;
+    maybeHandleCrop: (pointerDownState: PointerDownState, event: MouseEvent | KeyboardEvent) => boolean;
+    /**
+     * In the crop editor, a double-click on a handle uncrops its side (a
+     * corner's two), and mirrored, the opposite side(s) too.
+     *
+     * @returns whether the double-click has been handled
+     */
+    maybeUncropSides: (image: NonDeleted<ExcalidrawImageElement>, sceneX: number, sceneY: number, mirrored: boolean) => boolean;
+    maybeHandleResize: (pointerDownState: PointerDownState, event: MouseEvent | KeyboardEvent) => boolean;
+    /**
+     * Drags the selection (or, in the crop editor, the image within its crop) —
+     * duplicating it on an alt-drag past the drag threshold.
+     *
+     * @returns whether the pointer event has been completely handled
+     */
+    handleSelectionDragOnPointerMove: (event: PointerEvent, pointerDownState: PointerDownState, pointerCoords: {
+        x: number;
+        y: number;
+    }, elementsMap: NonDeletedSceneElementsMap) => boolean;
+    /**
+     * Box-selects with the selection tool — the line editor's points, while
+     * editing a line.
+     */
+    handleBoxSelectionOnPointerMove: (event: PointerEvent, pointerDownState: PointerDownState) => void;
+    /**
+     * After dragging the selection: the dragged elements join the frame they're
+     * dropped in, or leave theirs (and the edited group, if they leave it).
+     */
+    handleSelectionDragOnPointerUp: (childEvent: PointerEvent) => void;
+    /**
+     * The selection's transform handle at the scene point, if any — with its
+     * element, for a lone selected element.
+     *
+     * A lone selected element has none while the line editor is open or one of
+     * its line points is hovered, nor does an elbow arrow, a two-point line or
+     * arrow, or (on mobile devices) any line or arrow. The selection has none in
+     * the element link selector.
+     */
+    getTransformHandleAt(selectedElements: readonly NonDeletedExcalidrawElement[], sceneX: number, sceneY: number, pointerType: PointerType): {
+        element?: NonDeletedExcalidrawElement;
+        transformHandleType: TransformHandleType;
+    } | null;
+    /**
+     * Updates the selection on a click (no drag): the element below the
+     * selected one on an alt-click, the clicked element added to or removed
+     * from the selection with shift, or selected, and the selection cleared
+     * by a click hitting only a bounding box.
+     *
+     * @returns whether the pointer event has been completely handled
+     */
+    handleSelectionOnPointerUp: (childEvent: PointerEvent, pointerDownState: PointerDownState, elementsMap: NonDeletedSceneElementsMap) => boolean;
+    clearSelection(hitElement: ExcalidrawElement | null): void;
+    /** whether an alt-click on the selection (over other elements) cycles it */
+    canCycleSelection: () => boolean;
+    /**
+     * The selectable unit (an element, or the group a click would select) an
+     * element belongs to. Inside an edited group, its elements are units of
+     * their own.
+     */
+    private getSelectableUnit;
+    /**
+     * The selected unit, if an alt-click can cycle away from it: exactly one
+     * is selected, and neither the linear nor the crop editor is open.
+     */
+    private getCyclableSelectedUnit;
+    /**
+     * The element an alt-click selects: the selectable unit below the selected
+     * one among the hit elements, wrapping around to the topmost — or `null`
+     * unless it's an alt-click, the selection can cycle, and it's under the
+     * pointer. Inside an edited group, it cycles through the group's elements
+     * only, never leaving the group.
+     */
+    private getSelectionCycleTarget;
+}