@zsviczian/excalidraw 0.17.1-obsidian-46 → 0.17.1-obsidian-48

package/types/excalidraw/shapes.d.ts

@@ -1,70 +1,85 @@
-import { type GeometricShape } from "../utils/geometry/shape";
-import type { ElementsMap, ExcalidrawElement } from "./element/types";
-export declare const SHAPES: readonly [{
-    readonly icon: JSX.Element;
-    readonly value: "selection";
-    readonly key: "v";
-    readonly numericKey: "1";
-    readonly fillable: true;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "rectangle";
-    readonly key: "r";
-    readonly numericKey: "2";
-    readonly fillable: true;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "diamond";
-    readonly key: "d";
-    readonly numericKey: "3";
-    readonly fillable: true;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "ellipse";
-    readonly key: "o";
-    readonly numericKey: "4";
-    readonly fillable: true;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "arrow";
-    readonly key: "a";
-    readonly numericKey: "5";
-    readonly fillable: true;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "line";
-    readonly key: "l";
-    readonly numericKey: "6";
-    readonly fillable: true;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "freedraw";
-    readonly key: readonly ["p", "x"];
-    readonly numericKey: "7";
-    readonly fillable: false;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "text";
-    readonly key: "t";
-    readonly numericKey: "8";
-    readonly fillable: false;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "image";
-    readonly key: null;
-    readonly numericKey: "9";
-    readonly fillable: false;
-}, {
-    readonly icon: JSX.Element;
-    readonly value: "eraser";
-    readonly key: "e";
-    readonly numericKey: "0";
-    readonly fillable: false;
-}];
-export declare const findShapeByKey: (key: string) => "text" | "image" | "selection" | "rectangle" | "diamond" | "ellipse" | "arrow" | "line" | "freedraw" | "eraser" | null;
-/**
- * get the pure geometric shape of an excalidraw element
- * which is then used for hit detection
- */
-export declare const getElementShape: (element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape;
-export declare const getBoundTextShape: (element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape | null;
+import { type GlobalPoint, type LocalPoint } from "../math";
+import { type GeometricShape } from "../utils/geometry/shape";
+import type { Bounds } from "./element/bounds";
+import type { ElementsMap, ExcalidrawElement, ExcalidrawLinearElement, NonDeleted } from "./element/types";
+import type { Zoom } from "./types";
+export declare const SHAPES: readonly [{
+    readonly icon: JSX.Element;
+    readonly value: "selection";
+    readonly key: "v";
+    readonly numericKey: "1";
+    readonly fillable: true;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "rectangle";
+    readonly key: "r";
+    readonly numericKey: "2";
+    readonly fillable: true;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "diamond";
+    readonly key: "d";
+    readonly numericKey: "3";
+    readonly fillable: true;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "ellipse";
+    readonly key: "o";
+    readonly numericKey: "4";
+    readonly fillable: true;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "arrow";
+    readonly key: "a";
+    readonly numericKey: "5";
+    readonly fillable: true;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "line";
+    readonly key: "l";
+    readonly numericKey: "6";
+    readonly fillable: true;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "freedraw";
+    readonly key: readonly ["p", "x"];
+    readonly numericKey: "7";
+    readonly fillable: false;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "text";
+    readonly key: "t";
+    readonly numericKey: "8";
+    readonly fillable: false;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "image";
+    readonly key: null;
+    readonly numericKey: "9";
+    readonly fillable: false;
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "eraser";
+    readonly key: "e";
+    readonly numericKey: "0";
+    readonly fillable: false;
+}];
+export declare const findShapeByKey: (key: string) => "line" | "text" | "arrow" | "diamond" | "selection" | "rectangle" | "ellipse" | "freedraw" | "image" | "eraser" | null;
+/**
+ * get the pure geometric shape of an excalidraw element
+ * which is then used for hit detection
+ */
+export declare const getElementShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape<Point>;
+export declare const getBoundTextShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape<Point> | null;
+export declare const getControlPointsForBezierCurve: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P) => P[] | null;
+export declare const getBezierXY: <P extends GlobalPoint | LocalPoint>(p0: P, p1: P, p2: P, p3: P, t: number) => P;
+export declare const getBezierCurveLength: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P) => number;
+export declare const mapIntervalToBezierT: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P, interval: number) => number;
+/**
+ * Get the axis-aligned bounding box for a given element
+ */
+export declare const aabbForElement: (element: Readonly<ExcalidrawElement>, offset?: [number, number, number, number]) => Bounds;
+export declare const pointInsideBounds: <P extends GlobalPoint | LocalPoint>(p: P, bounds: Bounds) => boolean;
+export declare const aabbsOverlapping: (a: Bounds, b: Bounds) => boolean;
+export declare const getCornerRadius: (x: number, element: ExcalidrawElement) => number;
+export declare const isPathALoop: (points: ExcalidrawLinearElement["points"], zoomValue?: Zoom["value"]) => boolean;

package/types/excalidraw/snapping.d.ts

@@ -1,109 +1,112 @@
-import type { Bounds } from "./element/bounds";
-import type { MaybeTransformHandleType } from "./element/transformHandles";
-import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
-import type { AppClassProperties, AppState, KeyboardModifiersObject, Point } from "./types";
-export declare const getSnapDistance: (zoomValue: number) => number;
-type Vector2D = {
-    x: number;
-    y: number;
-};
-type PointPair = [Point, Point];
-export type PointSnap = {
-    type: "point";
-    points: PointPair;
-    offset: number;
-};
-export type Gap = {
-    startBounds: Bounds;
-    endBounds: Bounds;
-    startSide: [Point, Point];
-    endSide: [Point, Point];
-    overlap: [number, number];
-    length: number;
-};
-export type GapSnap = {
-    type: "gap";
-    direction: "center_horizontal" | "center_vertical" | "side_left" | "side_right" | "side_top" | "side_bottom";
-    gap: Gap;
-    offset: number;
-};
-export type GapSnaps = GapSnap[];
-export type Snap = GapSnap | PointSnap;
-export type Snaps = Snap[];
-export type PointSnapLine = {
-    type: "points";
-    points: Point[];
-};
-export type PointerSnapLine = {
-    type: "pointer";
-    points: PointPair;
-    direction: "horizontal" | "vertical";
-};
-export type GapSnapLine = {
-    type: "gap";
-    direction: "horizontal" | "vertical";
-    points: PointPair;
-};
-export type SnapLine = PointSnapLine | GapSnapLine | PointerSnapLine;
-export declare class SnapCache {
-    private static referenceSnapPoints;
-    private static visibleGaps;
-    static setReferenceSnapPoints: (snapPoints: Point[] | null) => void;
-    static getReferenceSnapPoints: () => (readonly [number, number])[] | null;
-    static setVisibleGaps: (gaps: {
-        verticalGaps: Gap[];
-        horizontalGaps: Gap[];
-    } | null) => void;
-    static getVisibleGaps: () => {
-        verticalGaps: Gap[];
-        horizontalGaps: Gap[];
-    } | null;
-    static destroy: () => void;
-}
-export declare const isGridModeEnabled: (app: AppClassProperties) => boolean;
-export declare const isSnappingEnabled: ({ event, app, selectedElements, }: {
-    app: AppClassProperties;
-    event: KeyboardModifiersObject;
-    selectedElements: NonDeletedExcalidrawElement[];
-}) => boolean;
-export declare const areRoughlyEqual: (a: number, b: number, precision?: number) => boolean;
-export declare const getElementsCorners: (elements: ExcalidrawElement[], elementsMap: ElementsMap, { omitCenter, boundingBoxCorners, dragOffset, }?: {
-    omitCenter?: boolean | undefined;
-    boundingBoxCorners?: boolean | undefined;
-    dragOffset?: Vector2D | undefined;
-}) => Point[];
-export declare const getVisibleGaps: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => {
-    horizontalGaps: Gap[];
-    verticalGaps: Gap[];
-};
-export declare const getReferenceSnapPoints: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => (readonly [number, number])[];
-export declare const snapDraggedElements: (elements: ExcalidrawElement[], dragOffset: Vector2D, app: AppClassProperties, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
-    snapOffset: {
-        x: number;
-        y: number;
-    };
-    snapLines: (PointSnapLine | GapSnapLine)[];
-};
-export declare const snapResizingElements: (selectedElements: ExcalidrawElement[], selectedOriginalElements: ExcalidrawElement[], app: AppClassProperties, event: KeyboardModifiersObject, dragOffset: Vector2D, transformHandle: MaybeTransformHandleType) => {
-    snapOffset: {
-        x: number;
-        y: number;
-    };
-    snapLines: PointSnapLine[];
-};
-export declare const snapNewElement: (newElement: ExcalidrawElement, app: AppClassProperties, event: KeyboardModifiersObject, origin: Vector2D, dragOffset: Vector2D, elementsMap: ElementsMap) => {
-    snapOffset: {
-        x: number;
-        y: number;
-    };
-    snapLines: PointSnapLine[];
-};
-export declare const getSnapLinesAtPointer: (elements: readonly ExcalidrawElement[], app: AppClassProperties, pointer: Vector2D, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
-    originOffset: {
-        x: number;
-        y: number;
-    };
-    snapLines: PointerSnapLine[];
-};
-export declare const isActiveToolNonLinearSnappable: (activeToolType: AppState["activeTool"]["type"]) => boolean;
-export {};
+import type { InclusiveRange } from "../math";
+import { type GlobalPoint } from "../math";
+import type { Bounds } from "./element/bounds";
+import type { MaybeTransformHandleType } from "./element/transformHandles";
+import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
+import type { AppClassProperties, AppState, KeyboardModifiersObject, NullableGridSize } from "./types";
+export declare const getSnapDistance: (zoomValue: number) => number;
+type Vector2D = {
+    x: number;
+    y: number;
+};
+type PointPair = [GlobalPoint, GlobalPoint];
+export type PointSnap = {
+    type: "point";
+    points: PointPair;
+    offset: number;
+};
+export type Gap = {
+    startBounds: Bounds;
+    endBounds: Bounds;
+    startSide: [GlobalPoint, GlobalPoint];
+    endSide: [GlobalPoint, GlobalPoint];
+    overlap: InclusiveRange;
+    length: number;
+};
+export type GapSnap = {
+    type: "gap";
+    direction: "center_horizontal" | "center_vertical" | "side_left" | "side_right" | "side_top" | "side_bottom";
+    gap: Gap;
+    offset: number;
+};
+export type GapSnaps = GapSnap[];
+export type Snap = GapSnap | PointSnap;
+export type Snaps = Snap[];
+export type PointSnapLine = {
+    type: "points";
+    points: GlobalPoint[];
+};
+export type PointerSnapLine = {
+    type: "pointer";
+    points: PointPair;
+    direction: "horizontal" | "vertical";
+};
+export type GapSnapLine = {
+    type: "gap";
+    direction: "horizontal" | "vertical";
+    points: PointPair;
+};
+export type SnapLine = PointSnapLine | GapSnapLine | PointerSnapLine;
+export declare class SnapCache {
+    private static referenceSnapPoints;
+    private static visibleGaps;
+    static setReferenceSnapPoints: (snapPoints: GlobalPoint[] | null) => void;
+    static getReferenceSnapPoints: () => GlobalPoint[] | null;
+    static setVisibleGaps: (gaps: {
+        verticalGaps: Gap[];
+        horizontalGaps: Gap[];
+    } | null) => void;
+    static getVisibleGaps: () => {
+        verticalGaps: Gap[];
+        horizontalGaps: Gap[];
+    } | null;
+    static destroy: () => void;
+}
+export declare const isGridModeEnabled: (app: AppClassProperties) => boolean;
+export declare const isSnappingEnabled: ({ event, app, selectedElements, }: {
+    app: AppClassProperties;
+    event: KeyboardModifiersObject;
+    selectedElements: NonDeletedExcalidrawElement[];
+}) => boolean;
+export declare const areRoughlyEqual: (a: number, b: number, precision?: number) => boolean;
+export declare const getElementsCorners: (elements: ExcalidrawElement[], elementsMap: ElementsMap, { omitCenter, boundingBoxCorners, dragOffset, }?: {
+    omitCenter?: boolean | undefined;
+    boundingBoxCorners?: boolean | undefined;
+    dragOffset?: Vector2D | undefined;
+}) => GlobalPoint[];
+export declare const getVisibleGaps: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => {
+    horizontalGaps: Gap[];
+    verticalGaps: Gap[];
+};
+export declare const getReferenceSnapPoints: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => GlobalPoint[];
+export declare const snapDraggedElements: (elements: ExcalidrawElement[], dragOffset: Vector2D, app: AppClassProperties, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
+    snapOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: (PointSnapLine | GapSnapLine)[];
+};
+export declare const snapResizingElements: (selectedElements: ExcalidrawElement[], selectedOriginalElements: ExcalidrawElement[], app: AppClassProperties, event: KeyboardModifiersObject, dragOffset: Vector2D, transformHandle: MaybeTransformHandleType) => {
+    snapOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: PointSnapLine[];
+};
+export declare const snapNewElement: (newElement: ExcalidrawElement, app: AppClassProperties, event: KeyboardModifiersObject, origin: Vector2D, dragOffset: Vector2D, elementsMap: ElementsMap) => {
+    snapOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: PointSnapLine[];
+};
+export declare const getSnapLinesAtPointer: (elements: readonly ExcalidrawElement[], app: AppClassProperties, pointer: Vector2D, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
+    originOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: PointerSnapLine[];
+};
+export declare const isActiveToolNonLinearSnappable: (activeToolType: AppState["activeTool"]["type"]) => boolean;
+export declare const getGridPoint: (x: number, y: number, gridSize: NullableGridSize) => [number, number];
+export {};

package/types/excalidraw/store.d.ts

@@ -1,129 +1,129 @@
-import { AppStateChange, ElementsChange } from "./change";
-import type { OrderedExcalidrawElement } from "./element/types";
-import { Emitter } from "./emitter";
-import type { AppState, ObservedAppState } from "./types";
-import type { ValueOf } from "./utility-types";
-export declare const getObservedAppState: (appState: AppState) => ObservedAppState;
-export declare const StoreAction: {
-    /**
-     * Immediately undoable.
-     *
-     * Use for updates which should be captured.
-     * Should be used for most of the local updates.
-     *
-     * These updates will _immediately_ make it to the local undo / redo stacks.
-     */
-    readonly CAPTURE: "capture";
-    /**
-     * 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 UPDATE: "update";
-    /**
-     * 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
-     * `StoreAction.CAPTURE` - triggered either by the next `updateScene`
-     * or internally by the editor.
-     *
-     * These updates will _eventually_ make it to the local undo / redo stacks.
-     */
-    readonly NONE: "none";
-};
-export type StoreActionType = ValueOf<typeof StoreAction>;
-/**
- * Represent an increment to the Store.
- */
-declare class StoreIncrementEvent {
-    readonly elementsChange: ElementsChange;
-    readonly appStateChange: AppStateChange;
-    constructor(elementsChange: ElementsChange, appStateChange: AppStateChange);
-}
-/**
- * Store which captures the observed changes and emits them as `StoreIncrementEvent` events.
- *
- * @experimental this interface is experimental and subject to change.
- */
-export interface IStore {
-    onStoreIncrementEmitter: Emitter<[StoreIncrementEvent]>;
-    get snapshot(): Snapshot;
-    set snapshot(snapshot: Snapshot);
-    /**
-     * Use to schedule update of the snapshot, useful on updates for which we don't need to calculate increments (i.e. remote updates).
-     */
-    shouldUpdateSnapshot(): void;
-    /**
-     * Use to schedule calculation of a store increment.
-     */
-    shouldCaptureIncrement(): void;
-    /**
-     * Based on the scheduled operation, either only updates store snapshot or also calculates increment and emits the result as a `StoreIncrementEvent`.
-     *
-     * @emits StoreIncrementEvent when increment is calculated.
-     */
-    commit(elements: Map<string, OrderedExcalidrawElement> | undefined, appState: AppState | ObservedAppState | undefined): void;
-    /**
-     * Clears the store instance.
-     */
-    clear(): void;
-    /**
-     * Filters out yet uncomitted elements from `nextElements`, which are part of in-progress local async actions (ephemerals) and thus were not yet commited to the snapshot.
-     *
-     * This is necessary in updates in which we receive reconciled elements, already containing elements which were not yet captured by the local store (i.e. collab).
-     */
-    filterUncomittedElements(prevElements: Map<string, OrderedExcalidrawElement>, nextElements: Map<string, OrderedExcalidrawElement>): Map<string, OrderedExcalidrawElement>;
-}
-export declare class Store implements IStore {
-    readonly onStoreIncrementEmitter: Emitter<[StoreIncrementEvent]>;
-    private scheduledActions;
-    private _snapshot;
-    get snapshot(): Snapshot;
-    set snapshot(snapshot: Snapshot);
-    shouldCaptureIncrement: () => void;
-    shouldUpdateSnapshot: () => void;
-    private scheduleAction;
-    commit: (elements: Map<string, OrderedExcalidrawElement> | undefined, appState: AppState | ObservedAppState | undefined) => void;
-    captureIncrement: (elements: Map<string, OrderedExcalidrawElement> | undefined, appState: AppState | ObservedAppState | undefined) => void;
-    updateSnapshot: (elements: Map<string, OrderedExcalidrawElement> | undefined, appState: AppState | ObservedAppState | undefined) => void;
-    filterUncomittedElements: (prevElements: Map<string, OrderedExcalidrawElement>, nextElements: Map<string, OrderedExcalidrawElement>) => Map<string, OrderedExcalidrawElement>;
-    clear: () => void;
-    private satisfiesScheduledActionsInvariant;
-}
-export declare class Snapshot {
-    readonly elements: Map<string, OrderedExcalidrawElement>;
-    readonly appState: ObservedAppState;
-    readonly meta: {
-        didElementsChange: boolean;
-        didAppStateChange: boolean;
-        isEmpty?: boolean;
-    };
-    private constructor();
-    static empty(): Snapshot;
-    isEmpty(): boolean | undefined;
-    /**
-     * Efficiently clone the existing snapshot, only if we detected changes.
-     *
-     * @returns same instance if there are no changes detected, new instance otherwise.
-     */
-    maybeClone(elements: Map<string, OrderedExcalidrawElement> | undefined, appState: AppState | ObservedAppState | undefined): Snapshot;
-    private maybeCreateAppStateSnapshot;
-    private detectChangedAppState;
-    private maybeCreateElementsSnapshot;
-    /**
-     * Detect if there any changed elements.
-     *
-     * NOTE: we shouldn't just use `sceneVersionNonce` instead, as we need to call this before the scene updates.
-     */
-    private detectChangedElements;
-    /**
-     * Perform structural clone, cloning only elements that changed.
-     */
-    private createElementsSnapshot;
-}
-export {};
+import { AppStateChange, ElementsChange } from "./change";
+import type { OrderedExcalidrawElement } from "./element/types";
+import { Emitter } from "./emitter";
+import type { AppState, ObservedAppState } from "./types";
+import type { ValueOf } from "./utility-types";
+export declare const getObservedAppState: (appState: AppState) => ObservedAppState;
+export declare const StoreAction: {
+    /**
+     * Immediately undoable.
+     *
+     * Use for updates which should be captured.
+     * Should be used for most of the local updates.
+     *
+     * These updates will _immediately_ make it to the local undo / redo stacks.
+     */
+    readonly CAPTURE: "capture";
+    /**
+     * 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 UPDATE: "update";
+    /**
+     * 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
+     * `StoreAction.CAPTURE` - triggered either by the next `updateScene`
+     * or internally by the editor.
+     *
+     * These updates will _eventually_ make it to the local undo / redo stacks.
+     */
+    readonly NONE: "none";
+};
+export type StoreActionType = ValueOf<typeof StoreAction>;
+/**
+ * Represent an increment to the Store.
+ */
+declare class StoreIncrementEvent {
+    readonly elementsChange: ElementsChange;
+    readonly appStateChange: AppStateChange;
+    constructor(elementsChange: ElementsChange, appStateChange: AppStateChange);
+}
+/**
+ * Store which captures the observed changes and emits them as `StoreIncrementEvent` events.
+ *
+ * @experimental this interface is experimental and subject to change.
+ */
+export interface IStore {
+    onStoreIncrementEmitter: Emitter<[StoreIncrementEvent]>;
+    get snapshot(): Snapshot;
+    set snapshot(snapshot: Snapshot);
+    /**
+     * Use to schedule update of the snapshot, useful on updates for which we don't need to calculate increments (i.e. remote updates).
+     */
+    shouldUpdateSnapshot(): void;
+    /**
+     * Use to schedule calculation of a store increment.
+     */
+    shouldCaptureIncrement(): void;
+    /**
+     * Based on the scheduled operation, either only updates store snapshot or also calculates increment and emits the result as a `StoreIncrementEvent`.
+     *
+     * @emits StoreIncrementEvent when increment is calculated.
+     */
+    commit(elements: Map<string, OrderedExcalidrawElement> | undefined, appState: AppState | ObservedAppState | undefined): void;
+    /**
+     * Clears the store instance.
+     */
+    clear(): void;
+    /**
+     * Filters out yet uncomitted elements from `nextElements`, which are part of in-progress local async actions (ephemerals) and thus were not yet commited to the snapshot.
+     *
+     * This is necessary in updates in which we receive reconciled elements, already containing elements which were not yet captured by the local store (i.e. collab).
+     */
+    filterUncomittedElements(prevElements: Map<string, OrderedExcalidrawElement>, nextElements: Map<string, OrderedExcalidrawElement>): Map<string, OrderedExcalidrawElement>;
+}
+export declare class Store implements IStore {
+    readonly onStoreIncrementEmitter: Emitter<[StoreIncrementEvent]>;
+    private scheduledActions;
+    private _snapshot;
+    get snapshot(): Snapshot;
+    set snapshot(snapshot: Snapshot);
+    shouldCaptureIncrement: () => void;
+    shouldUpdateSnapshot: () => void;
+    private scheduleAction;
+    commit: (elements: Map<string, OrderedExcalidrawElement> | undefined, appState: AppState | ObservedAppState | undefined) => void;
+    captureIncrement: (elements: Map<string, OrderedExcalidrawElement> | undefined, appState: AppState | ObservedAppState | undefined) => void;
+    updateSnapshot: (elements: Map<string, OrderedExcalidrawElement> | undefined, appState: AppState | ObservedAppState | undefined) => void;
+    filterUncomittedElements: (prevElements: Map<string, OrderedExcalidrawElement>, nextElements: Map<string, OrderedExcalidrawElement>) => Map<string, OrderedExcalidrawElement>;
+    clear: () => void;
+    private satisfiesScheduledActionsInvariant;
+}
+export declare class Snapshot {
+    readonly elements: Map<string, OrderedExcalidrawElement>;
+    readonly appState: ObservedAppState;
+    readonly meta: {
+        didElementsChange: boolean;
+        didAppStateChange: boolean;
+        isEmpty?: boolean;
+    };
+    private constructor();
+    static empty(): Snapshot;
+    isEmpty(): boolean | undefined;
+    /**
+     * Efficiently clone the existing snapshot, only if we detected changes.
+     *
+     * @returns same instance if there are no changes detected, new instance otherwise.
+     */
+    maybeClone(elements: Map<string, OrderedExcalidrawElement> | undefined, appState: AppState | ObservedAppState | undefined): Snapshot;
+    private maybeCreateAppStateSnapshot;
+    private detectChangedAppState;
+    private maybeCreateElementsSnapshot;
+    /**
+     * Detect if there any changed elements.
+     *
+     * NOTE: we shouldn't just use `sceneVersionNonce` instead, as we need to call this before the scene updates.
+     */
+    private detectChangedElements;
+    /**
+     * Perform structural clone, cloning only elements that changed.
+     */
+    private createElementsSnapshot;
+}
+export {};