@excalidraw/common 0.18.0-3bdaafe → 0.18.0-3c916c5

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.host.d.ts

@@ -0,0 +1,102 @@
+import type { RenderEnvironment } from "@excalidraw/element";
+import { type EyeDropperProperties } from "./EyeDropper";
+import { type HyperlinkTooltipOwner } from "./hyperlink/Hyperlink";
+import type { AppProps } from "../types";
+import type App from "./App";
+/**
+ * Owns everything that ties this editor to the document/window it renders
+ * into (cross-document runtime ownership): the render environment the
+ * canvases, images and paths are minted from, and the state that has to be
+ * re-primed whenever that environment is swapped.
+ */
+export declare class AppHost {
+    private app;
+    constructor(app: App);
+    /**
+     * Identity token for the hyperlink tooltip, which is a module-level
+     * singleton shared by every editor in the process — the owner tells it
+     * which editor the currently shown tooltip belongs to, so one editor never
+     * hides (or leaks a timer into) another's tooltip.
+     */
+    readonly hyperlinkTooltipOwner: HyperlinkTooltipOwner;
+    /**
+     * The process-wide interaction slots this editor currently owns: the
+     * pointerup handler of the interaction in flight, and the eye dropper (one
+     * atom in the editor-wide store). Both hold closures over this editor, so a
+     * teardown that leaves one set retains the editor -- and with it its owner
+     * window and document, e.g. a closed popout.
+     *
+     * @see releaseOwnedInteractionState
+     */
+    private ownedPointerUp;
+    private ownedEyeDropper;
+    /** Takes over the pointerup slot (or clears it, on `null`). */
+    setPointerUp(handler: (() => void) | null): void;
+    /**
+     * Runs the pending pointerup, whoever owns it -- pointerup does not always
+     * fire (the user tabs away), so interactions are settled manually.
+     */
+    runPendingPointerUp(): void;
+    /** Opens the eye dropper (or closes it, on `null`), taking ownership. */
+    setActiveEyeDropper(eyeDropper: EyeDropperProperties | null): void;
+    /**
+     * Drops the ownership token without touching the atom -- for callers that
+     * have just closed the eye dropper themselves.
+     */
+    releaseEyeDropperOwnership(): void;
+    /**
+     * Releases the process-wide slots this editor owns, so nothing outside it
+     * keeps it alive once it is torn down. Ownership-checked: a sibling
+     * editor's in-flight interaction must survive our teardown.
+     */
+    private releaseOwnedInteractionState;
+    /**
+     * Render environment scoped to this editor's owner window, so that the
+     * canvases, images and paths created during rendering live in the owner
+     * document. Memoized keyed on the resolved document because render caches
+     * are keyed by environment identity: the identity must not survive a
+     * document switch, or caches would mix canvases and images from two realms
+     * under one bucket.
+     */
+    private _renderEnvironment;
+    private _renderEnvironmentDocument;
+    get renderEnvironment(): RenderEnvironment;
+    /**
+     * Re-primes whatever the render environment owns. Called on mount and on
+     * every update, so an environment swap is picked up wherever it happens.
+     */
+    sync(prevProps?: AppProps): void;
+    /**
+     * Releases what this editor owns outside itself, so we don't retain the
+     * (soon detached) document/window, or leave a pending tooltip timer around.
+     */
+    destroy(): void;
+    private _destroyed;
+    /**
+     * Link icons decode asynchronously and the static scene skips an icon that
+     * is not decoded yet, so start the decode on mount rather than on the
+     * first render that happens to have a link, so the decode is settled long
+     * before there is a link element to draw an icon for.
+     *
+     * Re-run on an environment swap: the images are keyed by env identity, so
+     * a new environment starts with none.
+     *
+     * The decode landing only flips a status, which invalidates nothing, so the
+     * scene is nudged once when an icon becomes drawable -- otherwise a scene
+     * that paints before the decode settles and is then left alone (an initial
+     * scene with links, never scrolled or edited) keeps its icons missing until
+     * something unrelated repaints. Same shape as a font or an image file
+     * landing: repaint only when there is something new to draw.
+     */
+    private _linkImgDecodingEnvironment;
+    private ensureLinkImgDecoding;
+    /**
+     * Every render cache is keyed by environment identity, so a host passing an
+     * inline `renderEnvironment` literal re-mints the identity on each render
+     * and re-rasterizes everything, with no visible symptom other than being
+     * slow. Detected by the factories' source being unchanged across the swap:
+     * a genuine environment switch (e.g. a document change) reads differently.
+     */
+    private _warnedUnstableRenderEnvironment;
+    private warnOnUnstableRenderEnvironment;
+}

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" | "selectedGroupIds" | "editingGroupId">> & {
+    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" | "selectedGroupIds" | "editingGroupId">> & {
+    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" | "selectedGroupIds" | "editingGroupId">> & {
+    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 {};