@myoc/excalidraw 0.18.16 → 0.18.18

package/dist/types/element/src/store.d.ts

@@ -0,0 +1,231 @@
+import { Emitter } from "@excalidraw/common";
+import type App from "@excalidraw/excalidraw/components/App";
+import type { DTO, ValueOf } from "@excalidraw/common/utility-types";
+import type { AppState, ObservedAppState } from "@excalidraw/excalidraw/types";
+import { ElementsDelta, AppStateDelta } from "./delta";
+import type { ExcalidrawElement, OrderedExcalidrawElement, SceneElementsMap } from "./types";
+export declare const CaptureUpdateAction: {
+    /**
+     * Immediately undoable.
+     *
+     * Use for updates which should be captured.
+     * Should be used for most of the local updates, except ephemerals such as dragging or resizing.
+     *
+     * These updates will _immediately_ make it to the local undo / redo stacks.
+     */
+    readonly IMMEDIATELY: "IMMEDIATELY";
+    /**
+     * Never undoable.
+     *
+     * Use for updates which should never be recorded, such as remote updates
+     * or scene initialization.
+     *
+     * These updates will _never_ make it to the local undo / redo stacks.
+     */
+    readonly NEVER: "NEVER";
+    /**
+     * Eventually undoable.
+     *
+     * Use for updates which should not be captured immediately - likely
+     * exceptions which are part of some async multi-step process. Otherwise, all
+     * such updates would end up being captured with the next
+     * `CaptureUpdateAction.IMMEDIATELY` - triggered either by the next `updateScene`
+     * or internally by the editor.
+     *
+     * These updates will _eventually_ make it to the local undo / redo stacks.
+     */
+    readonly EVENTUALLY: "EVENTUALLY";
+};
+export type CaptureUpdateActionType = ValueOf<typeof CaptureUpdateAction>;
+/**
+ * Store which captures the observed changes and emits them as `StoreIncrement` events.
+ */
+export declare class Store {
+    private readonly app;
+    readonly onDurableIncrementEmitter: Emitter<[DurableIncrement]>;
+    readonly onStoreIncrementEmitter: Emitter<[DurableIncrement | EphemeralIncrement]>;
+    private scheduledMacroActions;
+    private scheduledMicroActions;
+    private _snapshot;
+    get snapshot(): StoreSnapshot;
+    set snapshot(snapshot: StoreSnapshot);
+    constructor(app: App);
+    scheduleAction(action: CaptureUpdateActionType): void;
+    /**
+     * Use to schedule a delta calculation, which will consquentially be emitted as `DurableStoreIncrement` and pushed in the undo stack.
+     */
+    scheduleCapture(): void;
+    /**
+     * Schedule special "micro" actions, to-be executed before the next commit, before it executes a scheduled "macro" action.
+     */
+    scheduleMicroAction(params: {
+        action: CaptureUpdateActionType;
+        elements: readonly ExcalidrawElement[] | undefined;
+        appState: AppState | ObservedAppState | undefined;
+    } | {
+        action: typeof CaptureUpdateAction.IMMEDIATELY;
+        change: StoreChange;
+        delta: StoreDelta;
+    } | {
+        action: typeof CaptureUpdateAction.NEVER | typeof CaptureUpdateAction.EVENTUALLY;
+        change: StoreChange;
+    }): void;
+    /**
+     * Performs the incoming `CaptureUpdateAction` and emits the corresponding `StoreIncrement`.
+     * Emits `DurableStoreIncrement` when action is "capture", emits `EphemeralStoreIncrement` otherwise.
+     *
+     * @emits StoreIncrement
+     */
+    commit(elements: SceneElementsMap | undefined, appState: AppState | ObservedAppState | undefined): void;
+    /**
+     * Clears the store instance.
+     */
+    clear(): void;
+    /**
+     * Performs delta & change calculation and emits a durable increment.
+     *
+     * @emits StoreIncrement.
+     */
+    private emitDurableIncrement;
+    /**
+     * Performs change calculation and emits an ephemeral increment.
+     *
+     * @emits EphemeralStoreIncrement
+     */
+    private emitEphemeralIncrement;
+    private applyChangeToSnapshot;
+    /**
+     * Clones the snapshot if there are changes detected.
+     */
+    private maybeCloneSnapshot;
+    private flushMicroActions;
+    private processAction;
+    /**
+     * Returns the scheduled macro action.
+     */
+    private getScheduledMacroAction;
+    /**
+     * Ensures that the scheduled actions invariant is satisfied.
+     */
+    private satisfiesScheduledActionsInvariant;
+}
+/**
+ * Repsents a change to the store containing changed elements and appState.
+ */
+export declare class StoreChange {
+    readonly elements: Record<string, OrderedExcalidrawElement>;
+    readonly appState: Partial<ObservedAppState>;
+    private constructor();
+    static create(prevSnapshot: StoreSnapshot, nextSnapshot: StoreSnapshot): StoreChange;
+}
+/**
+ * Encpasulates any change to the store (durable or ephemeral).
+ */
+export declare abstract class StoreIncrement {
+    readonly type: "durable" | "ephemeral";
+    readonly change: StoreChange;
+    protected constructor(type: "durable" | "ephemeral", change: StoreChange);
+    static isDurable(increment: StoreIncrement): increment is DurableIncrement;
+    static isEphemeral(increment: StoreIncrement): increment is EphemeralIncrement;
+}
+/**
+ * Represents a durable change to the store.
+ */
+export declare class DurableIncrement extends StoreIncrement {
+    readonly change: StoreChange;
+    readonly delta: StoreDelta;
+    constructor(change: StoreChange, delta: StoreDelta);
+}
+/**
+ * Represents an ephemeral change to the store.
+ */
+export declare class EphemeralIncrement extends StoreIncrement {
+    readonly change: StoreChange;
+    constructor(change: StoreChange);
+}
+/**
+ * Represents a captured delta by the Store.
+ */
+export declare class StoreDelta {
+    readonly id: string;
+    readonly elements: ElementsDelta;
+    readonly appState: AppStateDelta;
+    protected constructor(id: string, elements: ElementsDelta, appState: AppStateDelta);
+    /**
+     * Create a new instance of `StoreDelta`.
+     */
+    static create(elements: ElementsDelta, appState: AppStateDelta, opts?: {
+        id: string;
+    }): StoreDelta;
+    /**
+     * Calculate the delta between the previous and next snapshot.
+     */
+    static calculate(prevSnapshot: StoreSnapshot, nextSnapshot: StoreSnapshot): StoreDelta;
+    /**
+     * Restore a store delta instance from a DTO.
+     */
+    static restore(storeDeltaDTO: DTO<StoreDelta>): StoreDelta;
+    /**
+     * Parse and load the delta from the remote payload.
+     */
+    static load({ id, elements: { added, removed, updated }, }: DTO<StoreDelta>): StoreDelta;
+    /**
+     * Inverse store delta, creates new instance of `StoreDelta`.
+     */
+    static inverse(delta: StoreDelta): StoreDelta;
+    /**
+     * Apply the delta to the passed elements and appState, does not modify the snapshot.
+     */
+    static applyTo(delta: StoreDelta, elements: SceneElementsMap, appState: AppState): [SceneElementsMap, AppState, boolean];
+    /**
+     * Apply latest (remote) changes to the delta, creates new instance of `StoreDelta`.
+     */
+    static applyLatestChanges(delta: StoreDelta, prevElements: SceneElementsMap, nextElements: SceneElementsMap, modifierOptions?: "deleted" | "inserted"): StoreDelta;
+    isEmpty(): boolean;
+}
+/**
+ * Represents a snapshot of the captured or updated changes in the store,
+ * used for producing deltas and emitting `DurableStoreIncrement`s.
+ */
+export declare class StoreSnapshot {
+    readonly elements: SceneElementsMap;
+    readonly appState: ObservedAppState;
+    readonly metadata: {
+        didElementsChange: boolean;
+        didAppStateChange: boolean;
+        isEmpty?: boolean;
+    };
+    private _lastChangedElementsHash;
+    private _lastChangedAppStateHash;
+    private constructor();
+    static create(elements: SceneElementsMap, appState: AppState | ObservedAppState, metadata?: {
+        didElementsChange: boolean;
+        didAppStateChange: boolean;
+    }): StoreSnapshot;
+    static empty(): StoreSnapshot;
+    getChangedElements(prevSnapshot: StoreSnapshot): Record<string, OrderedExcalidrawElement>;
+    getChangedAppState(prevSnapshot: StoreSnapshot): Partial<ObservedAppState>;
+    isEmpty(): boolean | undefined;
+    /**
+     * Apply the change and return a new snapshot instance.
+     */
+    applyChange(change: StoreChange): StoreSnapshot;
+    /**
+     * Efficiently clone the existing snapshot, only if we detected changes.
+     *
+     * @returns same instance if there are no changes detected, new instance otherwise.
+     */
+    maybeClone(action: CaptureUpdateActionType, elements: SceneElementsMap | undefined, appState: AppState | ObservedAppState | undefined): StoreSnapshot;
+    private maybeCreateAppStateSnapshot;
+    private maybeCreateElementsSnapshot;
+    private detectChangedAppState;
+    /**
+     * Detect if there any changed elements.
+     */
+    private detectChangedElements;
+    /**
+     * Perform structural clone, deep cloning only elements that changed.
+     */
+    private createElementsSnapshot;
+}
+export declare const getObservedAppState: (appState: AppState | ObservedAppState) => ObservedAppState;

package/dist/types/element/src/textElement.d.ts

@@ -1,10 +1,11 @@
 import type { AppState } from "@excalidraw/excalidraw/types";
 import type { ExtractSetType } from "@excalidraw/common/utility-types";
-import type { Radians } from "../../math/src";
+import type { Radians } from "@excalidraw/math";
+import type { Scene } from "./Scene";
 import type { MaybeTransformHandleType } from "./transformHandles";
 import type { ElementsMap, ExcalidrawElement, ExcalidrawElementType, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, NonDeletedExcalidrawElement } from "./types";
-export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null, elementsMap: ElementsMap, informMutation?: boolean) => void;
-export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, elementsMap: ElementsMap, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean) => void;
+export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null, scene: Scene) => void;
+export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, scene: Scene, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean) => void;
 export declare const computeBoundTextPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
     x: number;
     y: number;

package/dist/types/element/src/typeChecks.d.ts

@@ -1,7 +1,7 @@
 import type { ElementOrToolType } from "@excalidraw/excalidraw/types";
 import type { MarkNonNullable } from "@excalidraw/common/utility-types";
 import type { Bounds } from "./bounds";
-import type { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawEmbeddableElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, ExcalidrawFrameElement, RoundnessType, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeElement, ExcalidrawIframeLikeElement, ExcalidrawMagicFrameElement, ExcalidrawArrowElement, ExcalidrawElbowArrowElement, PointBinding, FixedPointBinding, ExcalidrawFlowchartNodeElement } from "./types";
+import type { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawEmbeddableElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, ExcalidrawFrameElement, RoundnessType, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeElement, ExcalidrawIframeLikeElement, ExcalidrawMagicFrameElement, ExcalidrawArrowElement, ExcalidrawElbowArrowElement, ExcalidrawLineElement, PointBinding, FixedPointBinding, ExcalidrawFlowchartNodeElement, ExcalidrawLinearElementSubType } from "./types";
 export declare const isInitializedImageElement: (element: ExcalidrawElement | null) => element is InitializedExcalidrawImageElement;
 export declare const isImageElement: (element: ExcalidrawElement | null) => element is ExcalidrawImageElement;
 export declare const isEmbeddableElement: (element: ExcalidrawElement | null | undefined) => element is ExcalidrawEmbeddableElement;
@@ -14,8 +14,15 @@ export declare const isFrameLikeElement: (element: ExcalidrawElement | null) =>
 export declare const isFreeDrawElement: (element?: ExcalidrawElement | null) => element is ExcalidrawFreeDrawElement;
 export declare const isFreeDrawElementType: (elementType: ExcalidrawElementType) => boolean;
 export declare const isLinearElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
+export declare const isLineElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLineElement;
 export declare const isArrowElement: (element?: ExcalidrawElement | null) => element is ExcalidrawArrowElement;
 export declare const isElbowArrow: (element?: ExcalidrawElement) => element is ExcalidrawElbowArrowElement;
+/**
+ * sharp or curved arrow, but not elbow
+ */
+export declare const isSimpleArrow: (element?: ExcalidrawElement) => element is ExcalidrawArrowElement;
+export declare const isSharpArrow: (element?: ExcalidrawElement) => element is ExcalidrawArrowElement;
+export declare const isCurvedArrow: (element?: ExcalidrawElement) => element is ExcalidrawArrowElement;
 export declare const isLinearElementType: (elementType: ElementOrToolType) => boolean;
 export declare const isBindingElement: (element?: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawLinearElement;
 export declare const isBindingElementType: (elementType: ElementOrToolType) => boolean;
@@ -27,6 +34,7 @@ export declare const isExcalidrawElement: (element: any) => element is Excalidra
 export declare const isFlowchartNodeElement: (element: ExcalidrawElement) => element is ExcalidrawFlowchartNodeElement;
 export declare const hasBoundTextElement: (element: ExcalidrawElement | null) => element is MarkNonNullable<ExcalidrawBindableElement, "boundElements">;
 export declare const isBoundToContainer: (element: ExcalidrawElement | null) => element is ExcalidrawTextElementWithContainer;
+export declare const isArrowBoundToElement: (element: ExcalidrawArrowElement) => boolean;
 export declare const isUsingAdaptiveRadius: (type: string) => boolean;
 export declare const isUsingProportionalRadius: (type: string) => boolean;
 export declare const canApplyRoundnessTypeToElement: (roundnessType: RoundnessType, element: ExcalidrawElement) => boolean;
@@ -37,3 +45,13 @@ export declare const getDefaultRoundnessTypeForElement: (element: ExcalidrawElem
 } | null;
 export declare const isFixedPointBinding: (binding: PointBinding | FixedPointBinding) => binding is FixedPointBinding;
 export declare const isBounds: (box: unknown) => box is Bounds;
+export declare const getLinearElementSubType: (element: ExcalidrawLinearElement) => ExcalidrawLinearElementSubType;
+/**
+ * Checks if current element points meet all the conditions for polygon=true
+ * (this isn't a element type check, for that use isLineElement).
+ *
+ * If you want to check if points *can* be turned into a polygon, use
+ *  canBecomePolygon(points).
+ */
+export declare const isValidPolygon: (points: ExcalidrawLineElement["points"]) => boolean;
+export declare const canBecomePolygon: (points: ExcalidrawLineElement["points"]) => boolean;

package/dist/types/element/src/types.d.ts

@@ -151,7 +151,7 @@ export type ExcalidrawFrameLikeElement = ExcalidrawFrameElement | ExcalidrawMagi
  */
 export type ExcalidrawGenericElement = ExcalidrawSelectionElement | ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement;
 export type ExcalidrawFlowchartNodeElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement;
-export type ExcalidrawRectanguloidElement = ExcalidrawRectangleElement | ExcalidrawImageElement | ExcalidrawTextElement | ExcalidrawFreeDrawElement | ExcalidrawIframeLikeElement | ExcalidrawFrameLikeElement | ExcalidrawEmbeddableElement;
+export type ExcalidrawRectanguloidElement = ExcalidrawRectangleElement | ExcalidrawImageElement | ExcalidrawTextElement | ExcalidrawFreeDrawElement | ExcalidrawIframeLikeElement | ExcalidrawFrameLikeElement | ExcalidrawEmbeddableElement | ExcalidrawSelectionElement;
 /**
  * ExcalidrawElement should be JSON serializable and (eventually) contain
  * no computed data. The list of all ExcalidrawElements should be shareable
@@ -205,6 +205,11 @@ export type PointBinding = {
 export type FixedPointBinding = Merge<PointBinding, {
     fixedPoint: FixedPoint;
 }>;
+type Index = number;
+export type PointsPositionUpdates = Map<Index, {
+    point: LocalPoint;
+    isDragging?: boolean;
+}>;
 export type Arrowhead = "arrow" | "bar" | "dot" | "circle" | "circle_outline" | "triangle" | "triangle_outline" | "diamond" | "diamond_outline" | "crowfoot_one" | "crowfoot_many" | "crowfoot_one_or_many";
 export type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<{
     type: "line" | "arrow";
@@ -215,10 +220,14 @@ export type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<{
     startArrowhead: Arrowhead | null;
     endArrowhead: Arrowhead | null;
 }>;
+export type ExcalidrawLineElement = ExcalidrawLinearElement & Readonly<{
+    type: "line";
+    polygon: boolean;
+}>;
 export type FixedSegment = {
     start: LocalPoint;
     end: LocalPoint;
-    index: number;
+    index: Index;
 };
 export type ExcalidrawArrowElement = ExcalidrawLinearElement & Readonly<{
     type: "arrow";
@@ -280,4 +289,8 @@ export type SceneElementsMap = Map<ExcalidrawElement["id"], Ordered<ExcalidrawEl
 export type NonDeletedSceneElementsMap = Map<ExcalidrawElement["id"], Ordered<NonDeletedExcalidrawElement>> & MakeBrand<"NonDeletedSceneElementsMap">;
 export type ElementsMapOrArray = readonly ExcalidrawElement[] | Readonly<ElementsMap>;
 export type ArrangeAlgorithms = "bin-packing";
+export type ExcalidrawLinearElementSubType = "line" | "sharpArrow" | "curvedArrow" | "elbowArrow";
+export type ConvertibleGenericTypes = "rectangle" | "diamond" | "ellipse";
+export type ConvertibleLinearTypes = ExcalidrawLinearElementSubType;
+export type ConvertibleTypes = ConvertibleGenericTypes | ConvertibleLinearTypes;
 export {};

package/dist/types/element/src/utils.d.ts

@@ -1,6 +1,8 @@
 import { type GlobalPoint } from "@excalidraw/math";
 import type { Curve, LineSegment } from "@excalidraw/math";
-import type { ExcalidrawDiamondElement, ExcalidrawRectanguloidElement } from "./types";
+import type { Zoom } from "@excalidraw/excalidraw/types";
+import type { ExcalidrawDiamondElement, ExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawLinearElement, ExcalidrawRectanguloidElement } from "./types";
+export declare function deconstructLinearOrFreeDrawElement(element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]];
 /**
  * Get the building components of a rectanguloid element in the form of
  * line segments and curves.
@@ -19,3 +21,5 @@ export declare function deconstructRectanguloidElement(element: ExcalidrawRectan
  * @returns Tuple of line segments (0) and curves (1)
  */
 export declare function deconstructDiamondElement(element: ExcalidrawDiamondElement, offset?: number): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]];
+export declare const isPathALoop: (points: ExcalidrawLinearElement["points"], zoomValue?: Zoom["value"]) => boolean;
+export declare const getCornerRadius: (x: number, element: ExcalidrawElement) => number;

package/dist/types/element/src/zindex.d.ts

@@ -1,5 +1,5 @@
 import type { AppState } from "@excalidraw/excalidraw/types";
-import type Scene from "@excalidraw/excalidraw/scene/Scene";
+import type { Scene } from "./Scene";
 import type { ExcalidrawElement } from "./types";
 export declare const moveOneLeft: (allElements: readonly ExcalidrawElement[], appState: AppState, scene: Scene) => readonly ExcalidrawElement[];
 export declare const moveOneRight: (allElements: readonly ExcalidrawElement[], appState: AppState, scene: Scene) => readonly ExcalidrawElement[];

package/dist/types/excalidraw/actions/actionAddToLibrary.d.ts

@@ -36,7 +36,7 @@ export declare const actionAddToLibrary: {
             selectionElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
             isBindingEnabled: boolean;
             startBoundElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement> | null;
-            suggestedBindings: import("@excalidraw/element/binding").SuggestedBinding[];
+            suggestedBindings: import("@excalidraw/element").SuggestedBinding[];
             frameToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
             frameRendering: {
                 enabled: boolean;
@@ -47,7 +47,7 @@ export declare const actionAddToLibrary: {
             editingFrame: string | null;
             elementsToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawElement>[] | null;
             editingTextElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
-            editingLinearElement: import("@excalidraw/element/linearElementEditor").LinearElementEditor | null;
+            editingLinearElement: import("@excalidraw/element").LinearElementEditor | null;
             activeTool: {
                 lastActiveTool: import("../types").ActiveTool | null;
                 locked: boolean;
@@ -73,7 +73,7 @@ export declare const actionAddToLibrary: {
             currentItemEndArrowhead: import("@excalidraw/element/types").Arrowhead | null;
             currentHoveredFontFamily: number | null;
             currentItemRoundness: import("@excalidraw/element/types").StrokeRoundness;
-            currentItemArrowType: "round" | "sharp" | "elbow";
+            currentItemArrowType: "sharp" | "round" | "elbow";
             viewBackgroundColor: string;
             scrollX: number;
             scrollY: number;
@@ -85,7 +85,7 @@ export declare const actionAddToLibrary: {
             zoom: Readonly<{
                 value: import("../types").NormalizedZoomValue;
             }>;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -162,9 +162,8 @@ export declare const actionAddToLibrary: {
                 shown: true;
                 data: import("../charts").Spreadsheet;
             };
-            pendingImageElementId: string | null;
-            showHyperlinkPopup: false | "editor" | "info";
-            selectedLinearElement: import("@excalidraw/element/linearElementEditor").LinearElementEditor | null;
+            showHyperlinkPopup: false | "info" | "editor";
+            selectedLinearElement: import("@excalidraw/element").LinearElementEditor | null;
             snapLines: readonly import("../snapping").SnapLine[];
             originSnapOffset: {
                 x: number;
@@ -175,16 +174,14 @@ export declare const actionAddToLibrary: {
             followedBy: Set<import("../types").SocketId>;
             isCropping: boolean;
             croppingElementId: string | null;
-            searchMatches: readonly {
-                id: string;
-                focus: boolean;
-                matchedLines: {
-                    offsetX: number;
-                    offsetY: number;
-                    width: number;
-                    height: number;
-                }[];
-            }[];
+            searchMatches: Readonly<{
+                focusedId: string | null;
+                matches: readonly import("../types").SearchMatch[];
+            }> | null;
+            activeLockedId: string | null;
+            lockedMultiSelections: {
+                [groupId: string]: true;
+            };
         };
     } | {
         captureUpdate: "EVENTUALLY";
@@ -215,7 +212,7 @@ export declare const actionAddToLibrary: {
             selectionElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
             isBindingEnabled: boolean;
             startBoundElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement> | null;
-            suggestedBindings: import("@excalidraw/element/binding").SuggestedBinding[];
+            suggestedBindings: import("@excalidraw/element").SuggestedBinding[];
             frameToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
             frameRendering: {
                 enabled: boolean;
@@ -226,7 +223,7 @@ export declare const actionAddToLibrary: {
             editingFrame: string | null;
             elementsToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawElement>[] | null;
             editingTextElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
-            editingLinearElement: import("@excalidraw/element/linearElementEditor").LinearElementEditor | null;
+            editingLinearElement: import("@excalidraw/element").LinearElementEditor | null;
             activeTool: {
                 lastActiveTool: import("../types").ActiveTool | null;
                 locked: boolean;
@@ -252,7 +249,7 @@ export declare const actionAddToLibrary: {
             currentItemEndArrowhead: import("@excalidraw/element/types").Arrowhead | null;
             currentHoveredFontFamily: number | null;
             currentItemRoundness: import("@excalidraw/element/types").StrokeRoundness;
-            currentItemArrowType: "round" | "sharp" | "elbow";
+            currentItemArrowType: "sharp" | "round" | "elbow";
             viewBackgroundColor: string;
             scrollX: number;
             scrollY: number;
@@ -264,7 +261,7 @@ export declare const actionAddToLibrary: {
             zoom: Readonly<{
                 value: import("../types").NormalizedZoomValue;
             }>;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -346,9 +343,8 @@ export declare const actionAddToLibrary: {
                 shown: true;
                 data: import("../charts").Spreadsheet;
             };
-            pendingImageElementId: string | null;
-            showHyperlinkPopup: false | "editor" | "info";
-            selectedLinearElement: import("@excalidraw/element/linearElementEditor").LinearElementEditor | null;
+            showHyperlinkPopup: false | "info" | "editor";
+            selectedLinearElement: import("@excalidraw/element").LinearElementEditor | null;
             snapLines: readonly import("../snapping").SnapLine[];
             originSnapOffset: {
                 x: number;
@@ -359,16 +355,14 @@ export declare const actionAddToLibrary: {
             followedBy: Set<import("../types").SocketId>;
             isCropping: boolean;
             croppingElementId: string | null;
-            searchMatches: readonly {
-                id: string;
-                focus: boolean;
-                matchedLines: {
-                    offsetX: number;
-                    offsetY: number;
-                    width: number;
-                    height: number;
-                }[];
-            }[];
+            searchMatches: Readonly<{
+                focusedId: string | null;
+                matches: readonly import("../types").SearchMatch[];
+            }> | null;
+            activeLockedId: string | null;
+            lockedMultiSelections: {
+                [groupId: string]: true;
+            };
         };
     }> | {
         captureUpdate: "EVENTUALLY";
@@ -399,7 +393,7 @@ export declare const actionAddToLibrary: {
             selectionElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
             isBindingEnabled: boolean;
             startBoundElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement> | null;
-            suggestedBindings: import("@excalidraw/element/binding").SuggestedBinding[];
+            suggestedBindings: import("@excalidraw/element").SuggestedBinding[];
             frameToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
             frameRendering: {
                 enabled: boolean;
@@ -410,7 +404,7 @@ export declare const actionAddToLibrary: {
             editingFrame: string | null;
             elementsToHighlight: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawElement>[] | null;
             editingTextElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
-            editingLinearElement: import("@excalidraw/element/linearElementEditor").LinearElementEditor | null;
+            editingLinearElement: import("@excalidraw/element").LinearElementEditor | null;
             activeTool: {
                 lastActiveTool: import("../types").ActiveTool | null;
                 locked: boolean;
@@ -436,7 +430,7 @@ export declare const actionAddToLibrary: {
             currentItemEndArrowhead: import("@excalidraw/element/types").Arrowhead | null;
             currentHoveredFontFamily: number | null;
             currentItemRoundness: import("@excalidraw/element/types").StrokeRoundness;
-            currentItemArrowType: "round" | "sharp" | "elbow";
+            currentItemArrowType: "sharp" | "round" | "elbow";
             viewBackgroundColor: string;
             scrollX: number;
             scrollY: number;
@@ -448,7 +442,7 @@ export declare const actionAddToLibrary: {
             zoom: Readonly<{
                 value: import("../types").NormalizedZoomValue;
             }>;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -530,9 +524,8 @@ export declare const actionAddToLibrary: {
                 shown: true;
                 data: import("../charts").Spreadsheet;
             };
-            pendingImageElementId: string | null;
-            showHyperlinkPopup: false | "editor" | "info";
-            selectedLinearElement: import("@excalidraw/element/linearElementEditor").LinearElementEditor | null;
+            showHyperlinkPopup: false | "info" | "editor";
+            selectedLinearElement: import("@excalidraw/element").LinearElementEditor | null;
             snapLines: readonly import("../snapping").SnapLine[];
             originSnapOffset: {
                 x: number;
@@ -543,16 +536,14 @@ export declare const actionAddToLibrary: {
             followedBy: Set<import("../types").SocketId>;
             isCropping: boolean;
             croppingElementId: string | null;
-            searchMatches: readonly {
-                id: string;
-                focus: boolean;
-                matchedLines: {
-                    offsetX: number;
-                    offsetY: number;
-                    width: number;
-                    height: number;
-                }[];
-            }[];
+            searchMatches: Readonly<{
+                focusedId: string | null;
+                matches: readonly import("../types").SearchMatch[];
+            }> | null;
+            activeLockedId: string | null;
+            lockedMultiSelections: {
+                [groupId: string]: true;
+            };
         };
     };
     label: string;

package/dist/types/excalidraw/actions/actionAlign.d.ts

@@ -15,10 +15,10 @@ export declare const actionAlignTop: {
         elements: ExcalidrawElement[];
         captureUpdate: "IMMEDIATELY";
     };
-    keyTest: (event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean;
+    keyTest: (event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean;
     PanelComponent: ({ elements, appState, updateData, app }: import("./types").PanelComponentProps) => import("react/jsx-runtime").JSX.Element;
 } & {
-    keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
+    keyTest?: ((event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean) | undefined;
 };
 export declare const actionAlignBottom: {
     name: "alignBottom";
@@ -33,10 +33,10 @@ export declare const actionAlignBottom: {
         elements: ExcalidrawElement[];
         captureUpdate: "IMMEDIATELY";
     };
-    keyTest: (event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean;
+    keyTest: (event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean;
     PanelComponent: ({ elements, appState, updateData, app }: import("./types").PanelComponentProps) => import("react/jsx-runtime").JSX.Element;
 } & {
-    keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
+    keyTest?: ((event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean) | undefined;
 };
 export declare const actionAlignLeft: {
     name: "alignLeft";
@@ -51,10 +51,10 @@ export declare const actionAlignLeft: {
         elements: ExcalidrawElement[];
         captureUpdate: "IMMEDIATELY";
     };
-    keyTest: (event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean;
+    keyTest: (event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean;
     PanelComponent: ({ elements, appState, updateData, app }: import("./types").PanelComponentProps) => import("react/jsx-runtime").JSX.Element;
 } & {
-    keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
+    keyTest?: ((event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean) | undefined;
 };
 export declare const actionAlignRight: {
     name: "alignRight";
@@ -69,10 +69,10 @@ export declare const actionAlignRight: {
         elements: ExcalidrawElement[];
         captureUpdate: "IMMEDIATELY";
     };
-    keyTest: (event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean;
+    keyTest: (event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean;
     PanelComponent: ({ elements, appState, updateData, app }: import("./types").PanelComponentProps) => import("react/jsx-runtime").JSX.Element;
 } & {
-    keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
+    keyTest?: ((event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean) | undefined;
 };
 export declare const actionAlignVerticallyCentered: {
     name: "alignVerticallyCentered";

package/dist/types/excalidraw/actions/actionArrange.d.ts

@@ -23,8 +23,8 @@ export declare const actionArrangeElements: {
         elements: ExcalidrawElement[];
         captureUpdate: "IMMEDIATELY";
     };
-    keyTest: (event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean;
+    keyTest: (event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean;
     PanelComponent: ({ updateData }: import("./types").PanelComponentProps) => import("react/jsx-runtime").JSX.Element;
 } & {
-    keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
+    keyTest?: ((event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean) | undefined;
 };