@excalidraw/excalidraw 0.17.1-1d71f84 → 0.17.1-1ed53b1

package/dist/excalidraw/renderer/renderSnaps.js

@@ -1,3 +1,4 @@
+import { THEME } from "../constants";
 const SNAP_COLOR_LIGHT = "#ff6b6b";
 const SNAP_COLOR_DARK = "#ff0000";
 const SNAP_WIDTH = 1;
@@ -9,7 +10,7 @@ export const renderSnaps = (context, appState) => {
     // in dark mode, we need to adjust the color to account for color inversion.
     // Don't change if zen mode, because we draw only crosses, we want the
     // colors to be more visible
-    const snapColor = appState.theme === "light" || appState.zenModeEnabled
+    const snapColor = appState.theme === THEME.LIGHT || appState.zenModeEnabled
         ? SNAP_COLOR_LIGHT
         : SNAP_COLOR_DARK;
     // in zen mode make the cross more visible since we don't draw the lines

package/dist/excalidraw/renderer/staticScene.d.ts

@@ -1,4 +1,4 @@
-import { StaticSceneRenderConfig } from "../scene/types";
+import type { StaticSceneRenderConfig } from "../scene/types";
 /** throttled to animation framerate */
 export declare const renderStaticSceneThrottled: {
     (config: StaticSceneRenderConfig): void;

package/dist/excalidraw/renderer/staticScene.js

@@ -1,12 +1,13 @@
 import { FRAME_STYLE } from "../constants";
 import { getElementAbsoluteCoords } from "../element";
 import { elementOverlapsWithFrame, getTargetFrame, isElementInFrame, } from "../frame";
-import { isEmbeddableElement, isIframeLikeElement, } from "../element/typeChecks";
+import { isEmbeddableElement, isIframeLikeElement, isTextElement, } from "../element/typeChecks";
 import { renderElement } from "../renderer/renderElement";
 import { createPlaceholderEmbeddableLabel } from "../element/embeddable";
 import { EXTERNAL_LINK_IMG, getLinkHandleFromCoords, } from "../components/hyperlink/helpers";
 import { bootstrapCanvas, getNormalizedCanvasDimensions } from "./helpers";
 import { throttleRAF } from "../utils";
+import { getBoundTextElement } from "../element/textElement";
 const strokeGrid = (context, gridSize, scrollX, scrollY, zoom, width, height) => {
     const BOLD_LINE_FREQUENCY = 5;
     let GridLineColor;
@@ -121,21 +122,31 @@ const _renderStaticScene = ({ canvas, rc, elementsMap, allElementsMap, visibleEl
         .forEach((element) => {
         try {
             const frameId = element.frameId || appState.frameToHighlight?.id;
+            if (isTextElement(element) &&
+                element.containerId &&
+                elementsMap.has(element.containerId)) {
+                // will be rendered with the container
+                return;
+            }
+            context.save();
             if (frameId &&
                 appState.frameRendering.enabled &&
                 appState.frameRendering.clip) {
-                context.save();
                 const frame = getTargetFrame(element, elementsMap, appState);
                 // TODO do we need to check isElementInFrame here?
                 if (frame && isElementInFrame(element, elementsMap, appState)) {
                     frameClip(frame, context, renderConfig, appState);
                 }
                 renderElement(element, elementsMap, allElementsMap, rc, context, renderConfig, appState);
-                context.restore();
             }
             else {
                 renderElement(element, elementsMap, allElementsMap, rc, context, renderConfig, appState);
             }
+            const boundTextElement = getBoundTextElement(element, elementsMap);
+            if (boundTextElement) {
+                renderElement(boundTextElement, elementsMap, allElementsMap, rc, context, renderConfig, appState);
+            }
+            context.restore();
             if (!isExporting) {
                 renderLinkIcon(element, context, appState, elementsMap);
             }

package/dist/excalidraw/renderer/staticSvgScene.d.ts

@@ -1,5 +1,5 @@
-import { RoughSVG } from "roughjs/bin/svg";
-import { NonDeletedExcalidrawElement } from "../element/types";
-import { RenderableElementsMap, SVGRenderConfig } from "../scene/types";
-import { BinaryFiles } from "../types";
+import type { RoughSVG } from "roughjs/bin/svg";
+import type { NonDeletedExcalidrawElement } from "../element/types";
+import type { RenderableElementsMap, SVGRenderConfig } from "../scene/types";
+import type { BinaryFiles } from "../types";
 export declare const renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], elementsMap: RenderableElementsMap, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, renderConfig: SVGRenderConfig) => void;

package/dist/excalidraw/renderer/staticSvgScene.js

@@ -361,8 +361,18 @@ export const renderSceneToSvg = (elements, elementsMap, rsvg, svgRoot, files, re
         .filter((el) => !isIframeLikeElement(el))
         .forEach((element) => {
         if (!element.isDeleted) {
+            if (isTextElement(element) &&
+                element.containerId &&
+                elementsMap.has(element.containerId)) {
+                // will be rendered with the container
+                return;
+            }
             try {
                 renderElementToSvg(element, elementsMap, rsvg, svgRoot, files, element.x + renderConfig.offsetX, element.y + renderConfig.offsetY, renderConfig);
+                const boundTextElement = getBoundTextElement(element, elementsMap);
+                if (boundTextElement) {
+                    renderElementToSvg(boundTextElement, elementsMap, rsvg, svgRoot, files, boundTextElement.x + renderConfig.offsetX, boundTextElement.y + renderConfig.offsetY, renderConfig);
+                }
             }
             catch (error) {
                 console.error(error);

package/dist/excalidraw/scene/Fonts.d.ts

@@ -1,4 +1,4 @@
-import { ExcalidrawElement } from "../element/types";
+import type { ExcalidrawElement } from "../element/types";
 import type Scene from "./Scene";
 export declare class Fonts {
     private scene;

package/dist/excalidraw/scene/Renderer.d.ts

@@ -1,6 +1,6 @@
-import { NonDeletedExcalidrawElement } from "../element/types";
-import { AppState } from "../types";
-import Scene from "./Scene";
+import type { NonDeletedExcalidrawElement } from "../element/types";
+import type { AppState } from "../types";
+import type Scene from "./Scene";
 export declare class Renderer {
     private scene;
     constructor(scene: Scene);

package/dist/excalidraw/scene/Scene.d.ts

@@ -1,6 +1,6 @@
-import { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameLikeElement, ElementsMapOrArray } from "../element/types";
-import { LinearElementEditor } from "../element/linearElementEditor";
-import { AppState } from "../types";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameLikeElement, ElementsMapOrArray, OrderedExcalidrawElement, Ordered } from "../element/types";
+import type { LinearElementEditor } from "../element/linearElementEditor";
+import type { AppState } from "../types";
 type ElementIdKey = InstanceType<typeof LinearElementEditor>["elementId"];
 type ElementKey = ExcalidrawElement | ElementIdKey;
 type SceneStateCallback = () => void;
@@ -20,10 +20,10 @@ declare class Scene {
     private elementsMap;
     private selectedElementsCache;
     private versionNonce;
-    getElementsMapIncludingDeleted(): Map<string, ExcalidrawElement> & import("../utility-types").MakeBrand<"SceneElementsMap">;
-    getNonDeletedElementsMap(): Map<string, NonDeletedExcalidrawElement> & import("../utility-types").MakeBrand<"NonDeletedSceneElementsMap">;
-    getElementsIncludingDeleted(): readonly ExcalidrawElement[];
-    getNonDeletedElements(): readonly NonDeletedExcalidrawElement[];
+    getNonDeletedElementsMap(): Map<string, Ordered<NonDeletedExcalidrawElement>> & import("../utility-types").MakeBrand<"NonDeletedSceneElementsMap">;
+    getElementsIncludingDeleted(): readonly OrderedExcalidrawElement[];
+    getElementsMapIncludingDeleted(): Map<string, Ordered<ExcalidrawElement>> & import("../utility-types").MakeBrand<"SceneElementsMap">;
+    getNonDeletedElements(): readonly Ordered<NonDeletedExcalidrawElement>[];
     getFramesIncludingDeleted(): readonly ExcalidrawFrameLikeElement[];
     getSelectedElements(opts: {
         selectedElementIds: AppState["selectedElementIds"];
@@ -59,7 +59,8 @@ declare class Scene {
     destroy(): void;
     insertElementAtIndex(element: ExcalidrawElement, index: number): void;
     insertElementsAtIndex(elements: ExcalidrawElement[], index: number): void;
-    addNewElement: (element: ExcalidrawElement) => void;
+    insertElement: (element: ExcalidrawElement) => void;
+    insertElements: (elements: ExcalidrawElement[]) => void;
     getElementIndex(elementId: string): number;
     getContainerElement: (element: (ExcalidrawElement & {
         containerId: ExcalidrawElement["id"] | null;

package/dist/excalidraw/scene/Scene.js

@@ -2,7 +2,10 @@ import { isNonDeletedElement } from "../element";
 import { isFrameLikeElement } from "../element/typeChecks";
 import { getSelectedElements } from "./selection";
 import { randomInteger } from "../random";
+import { syncInvalidIndices, syncMovedIndices, validateFractionalIndices, } from "../fractionalIndex";
+import { arrayToMap } from "../utils";
 import { toBrandedType } from "../utils";
+import { ENV } from "../constants";
 const getNonDeletedElements = (allElements) => {
     const elementsMap = new Map();
     const elements = [];
@@ -59,6 +62,7 @@ class Scene {
     callbacks = new Set();
     nonDeletedElements = [];
     nonDeletedElementsMap = toBrandedType(new Map());
+    // ideally all elements within the scene should be wrapped around with `Ordered` type, but right now there is no real benefit doing so
     elements = [];
     nonDeletedFramesLikes = [];
     frames = [];
@@ -69,15 +73,15 @@ class Scene {
         cache: new Map(),
     };
     versionNonce;
-    getElementsMapIncludingDeleted() {
-        return this.elementsMap;
-    }
     getNonDeletedElementsMap() {
         return this.nonDeletedElementsMap;
     }
     getElementsIncludingDeleted() {
         return this.elements;
     }
+    getElementsMapIncludingDeleted() {
+        return this.elementsMap;
+    }
     getNonDeletedElements() {
         return this.nonDeletedElements;
     }
@@ -151,12 +155,17 @@ class Scene {
         return didChange;
     }
     replaceAllElements(nextElements) {
-        this.elements =
-            // ts doesn't like `Array.isArray` of `instanceof Map`
-            nextElements instanceof Array
-                ? nextElements
-                : Array.from(nextElements.values());
+        const _nextElements = 
+        // ts doesn't like `Array.isArray` of `instanceof Map`
+        nextElements instanceof Array
+            ? nextElements
+            : Array.from(nextElements.values());
         const nextFrameLikes = [];
+        if (import.meta.env.DEV || import.meta.env.MODE === ENV.TEST) {
+            // throw on invalid indices in test / dev to potentially detect cases were we forgot to sync moved elements
+            validateFractionalIndices(_nextElements.map((x) => x.index));
+        }
+        this.elements = syncInvalidIndices(_nextElements);
         this.elementsMap.clear();
         this.elements.forEach((element) => {
             if (isFrameLikeElement(element)) {
@@ -191,8 +200,8 @@ class Scene {
         };
     }
     destroy() {
-        this.nonDeletedElements = [];
         this.elements = [];
+        this.nonDeletedElements = [];
         this.nonDeletedFramesLikes = [];
         this.frames = [];
         this.elementsMap.clear();
@@ -217,6 +226,7 @@ class Scene {
             element,
             ...this.elements.slice(index),
         ];
+        syncMovedIndices(nextElements, arrayToMap([element]));
         this.replaceAllElements(nextElements);
     }
     insertElementsAtIndex(elements, index) {
@@ -228,15 +238,20 @@ class Scene {
             ...elements,
             ...this.elements.slice(index),
         ];
+        syncMovedIndices(nextElements, arrayToMap(elements));
         this.replaceAllElements(nextElements);
     }
-    addNewElement = (element) => {
-        if (element.frameId) {
-            this.insertElementAtIndex(element, this.getElementIndex(element.frameId));
-        }
-        else {
-            this.replaceAllElements([...this.elements, element]);
-        }
+    insertElement = (element) => {
+        const index = element.frameId
+            ? this.getElementIndex(element.frameId)
+            : this.elements.length;
+        this.insertElementAtIndex(element, index);
+    };
+    insertElements = (elements) => {
+        const index = elements[0].frameId
+            ? this.getElementIndex(elements[0].frameId)
+            : this.elements.length;
+        this.insertElementsAtIndex(elements, index);
     };
     getElementIndex(elementId) {
         return this.elements.findIndex((element) => element.id === elementId);

package/dist/excalidraw/scene/Shape.d.ts

@@ -1,7 +1,7 @@
 import type { Drawable, Options } from "roughjs/bin/core";
 import type { RoughGenerator } from "roughjs/bin/generator";
 import type { ExcalidrawElement, NonDeletedExcalidrawElement, ExcalidrawSelectionElement } from "../element/types";
-import { EmbedsValidationStatus } from "../types";
+import type { EmbedsValidationStatus } from "../types";
 export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean) => Options;
 /**
  * Generates the roughjs shape for given element.

package/dist/excalidraw/scene/ShapeCache.d.ts

@@ -1,7 +1,7 @@
-import { Drawable } from "roughjs/bin/core";
-import { ExcalidrawElement } from "../element/types";
-import { ElementShape, ElementShapes } from "./types";
-import { AppState, EmbedsValidationStatus } from "../types";
+import type { Drawable } from "roughjs/bin/core";
+import type { ExcalidrawElement } from "../element/types";
+import type { ElementShape, ElementShapes } from "./types";
+import type { AppState, EmbedsValidationStatus } from "../types";
 export declare class ShapeCache {
     private static rg;
     private static cache;

package/dist/excalidraw/scene/comparisons.d.ts

@@ -1,5 +1,5 @@
-import { NonDeletedExcalidrawElement } from "../element/types";
-import { ElementOrToolType } from "../types";
+import type { NonDeletedExcalidrawElement } from "../element/types";
+import type { ElementOrToolType } from "../types";
 export declare const hasBackground: (type: ElementOrToolType) => boolean;
 export declare const hasStrokeColor: (type: ElementOrToolType) => boolean;
 export declare const hasStrokeWidth: (type: ElementOrToolType) => boolean;

package/dist/excalidraw/scene/export.d.ts

@@ -1,5 +1,5 @@
-import { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "../element/types";
-import { AppState, BinaryFiles } from "../types";
+import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "../element/types";
+import type { AppState, BinaryFiles } from "../types";
 export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, exportingFrame, }: {
     exportBackground: boolean;
     exportPadding?: number | undefined;

package/dist/excalidraw/scene/export.js

@@ -1,8 +1,8 @@
 import rough from "roughjs/bin/rough";
-import { getCommonBounds, getElementAbsoluteCoords, } from "../element/bounds";
+import { getCommonBounds, getElementAbsoluteCoords } from "../element/bounds";
 import { renderSceneToSvg } from "../renderer/staticSvgScene";
 import { arrayToMap, distance, getFontString, toBrandedType } from "../utils";
-import { DEFAULT_EXPORT_PADDING, FONT_FAMILY, FRAME_STYLE, SVG_NS, THEME_FILTER, } from "../constants";
+import { DEFAULT_EXPORT_PADDING, FONT_FAMILY, FRAME_STYLE, SVG_NS, THEME, THEME_FILTER, } from "../constants";
 import { getDefaultAppState } from "../appState";
 import { serializeAsJSON } from "../data/json";
 import { getInitializedImageElements, updateImageCache, } from "../element/image";
@@ -10,6 +10,7 @@ import { getElementsOverlappingFrame, getFrameLikeElements, getFrameLikeTitle, g
 import { newTextElement } from "../element";
 import { newElementWith } from "../element/mutateElement";
 import { isFrameElement, isFrameLikeElement } from "../element/typeChecks";
+import { syncInvalidIndices } from "../fractionalIndex";
 import { renderStaticScene } from "../renderer/staticScene";
 const SVG_EXPORT_TAG = `<!-- svg-source:excalidraw -->`;
 const truncateText = (element, maxWidth) => {
@@ -128,7 +129,7 @@ export const exportToCanvas = async (elements, appState, files, { exportBackgrou
         canvas,
         rc: rough.canvas(canvas),
         elementsMap: toBrandedType(arrayToMap(elementsForRender)),
-        allElementsMap: toBrandedType(arrayToMap(elements)),
+        allElementsMap: toBrandedType(arrayToMap(syncInvalidIndices(elements))),
         visibleElements: elementsForRender,
         scale,
         appState: {
@@ -139,7 +140,7 @@ export const exportToCanvas = async (elements, appState, files, { exportBackgrou
             scrollY: -minY + exportPadding,
             zoom: defaultAppState.zoom,
             shouldCacheIgnoreZoom: false,
-            theme: appState.exportWithDarkMode ? "dark" : "light",
+            theme: appState.exportWithDarkMode ? THEME.DARK : THEME.LIGHT,
         },
         renderConfig: {
             canvasBackgroundColor: viewBackgroundColor,

package/dist/excalidraw/scene/scroll.d.ts

@@ -1,5 +1,5 @@
-import { AppState, PointerCoords, Zoom } from "../types";
-import { ExcalidrawElement } from "../element/types";
+import type { AppState, PointerCoords, Zoom } from "../types";
+import type { ExcalidrawElement } from "../element/types";
 export declare const centerScrollOn: ({ scenePoint, viewportDimensions, zoom, }: {
     scenePoint: PointerCoords;
     viewportDimensions: {

package/dist/excalidraw/scene/scrollbars.d.ts

@@ -1,6 +1,6 @@
-import { InteractiveCanvasAppState } from "../types";
-import { ScrollBars } from "./types";
-import { ExcalidrawElement } from "../element/types";
+import type { InteractiveCanvasAppState } from "../types";
+import type { ScrollBars } from "./types";
+import type { ExcalidrawElement } from "../element/types";
 export declare const SCROLLBAR_MARGIN = 4;
 export declare const SCROLLBAR_WIDTH = 6;
 export declare const SCROLLBAR_COLOR = "rgba(0,0,0,0.3)";

package/dist/excalidraw/scene/selection.d.ts

@@ -1,5 +1,5 @@
-import { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
-import { AppState, InteractiveCanvasAppState } from "../types";
+import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
+import type { AppState, InteractiveCanvasAppState } from "../types";
 /**
  * Frames and their containing elements are not to be selected at the same time.
  * Given an array of selected elements, if there are frames and their containing elements

package/dist/excalidraw/scene/types.d.ts

@@ -1,8 +1,8 @@
 import type { RoughCanvas } from "roughjs/bin/canvas";
-import { Drawable } from "roughjs/bin/core";
-import { ExcalidrawElement, ExcalidrawTextElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "../element/types";
-import { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, UserIdleState } from "../types";
-import { MakeBrand } from "../utility-types";
+import type { Drawable } from "roughjs/bin/core";
+import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "../element/types";
+import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, UserIdleState, Device } from "../types";
+import type { MakeBrand } from "../utility-types";
 export type RenderableElementsMap = NonDeletedElementsMap & MakeBrand<"RenderableElementsMap">;
 export type StaticCanvasRenderConfig = {
     canvasBackgroundColor: AppState["viewBackgroundColor"];
@@ -59,6 +59,7 @@ export type InteractiveSceneRenderConfig = {
     scale: number;
     appState: InteractiveCanvasAppState;
     renderConfig: InteractiveCanvasRenderConfig;
+    device: Device;
     callback: (data: RenderInteractiveSceneCallback) => void;
 };
 export type SceneScroll = {

package/dist/excalidraw/scene/zoom.d.ts

@@ -1,4 +1,4 @@
-import { AppState, NormalizedZoomValue } from "../types";
+import type { AppState, NormalizedZoomValue } from "../types";
 export declare const getNormalizedZoom: (zoom: number) => NormalizedZoomValue;
 export declare const getStateForZoom: ({ viewportX, viewportY, nextZoom, }: {
     viewportX: number;

package/dist/excalidraw/snapping.d.ts

@@ -1,7 +1,7 @@
-import { Bounds } from "./element/bounds";
-import { MaybeTransformHandleType } from "./element/transformHandles";
-import { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
-import { AppState, KeyboardModifiersObject, Point } from "./types";
+import type { Bounds } from "./element/bounds";
+import type { MaybeTransformHandleType } from "./element/transformHandles";
+import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
+import type { AppState, KeyboardModifiersObject, Point } from "./types";
 export declare const getSnapDistance: (zoomValue: number) => number;
 type Vector2D = {
     x: number;

package/dist/excalidraw/store.d.ts

@@ -0,0 +1,99 @@
+import { AppStateChange, ElementsChange } from "./change";
+import type { OrderedExcalidrawElement } from "./element/types";
+import { Emitter } from "./emitter";
+import type { AppState, ObservedAppState } from "./types";
+export declare const getObservedAppState: (appState: AppState) => ObservedAppState;
+export type StoreActionType = "capture" | "update" | "none";
+export declare const StoreAction: {
+    [K in Uppercase<StoreActionType>]: StoreActionType;
+};
+/**
+ * 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 {};