@dwelle/excalidraw 0.5.0-da1c822 → 0.5.0-e56eec7

package/dist/excalidraw/element/typeChecks.d.ts

@@ -1,6 +1,6 @@
 import { ElementOrToolType } from "../types";
 import { MarkNonNullable } from "../utility-types";
-import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawEmbeddableElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, ExcalidrawFrameElement, RoundnessType, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeElement, ExcalidrawIframeLikeElement, ExcalidrawMagicFrameElement } from "./types";
+import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawEmbeddableElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, ExcalidrawFrameElement, RoundnessType, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeElement, ExcalidrawIframeLikeElement, ExcalidrawMagicFrameElement, ExcalidrawArrowElement } 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;
@@ -13,7 +13,7 @@ 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 isArrowElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
+export declare const isArrowElement: (element?: ExcalidrawElement | null) => 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;

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

@@ -18,6 +18,13 @@ export type StrokeStyle = "solid" | "dashed" | "dotted";
 export type TextAlign = typeof TEXT_ALIGN[keyof typeof TEXT_ALIGN];
 type VerticalAlignKeys = keyof typeof VERTICAL_ALIGN;
 export type VerticalAlign = typeof VERTICAL_ALIGN[VerticalAlignKeys];
+export type FractionalIndex = string & {
+    _brand: "franctionalIndex";
+};
+export type BoundElement = Readonly<{
+    id: ExcalidrawLinearElement["id"];
+    type: "arrow" | "text";
+}>;
 type _ExcalidrawElementBase = Readonly<{
     id: string;
     x: number;
@@ -46,16 +53,18 @@ type _ExcalidrawElementBase = Readonly<{
         Used for deterministic reconciliation of updates during collaboration,
         in case the versions (see above) are identical. */
     versionNonce: number;
+    /** String in a fractional form defined by https://github.com/rocicorp/fractional-indexing.
+        Used for ordering in multiplayer scenarios, such as during reconciliation or undo / redo.
+        Always kept in sync with the array order by `syncMovedIndices` and `syncInvalidIndices`.
+        Could be null, i.e. for new elements which were not yet assigned to the scene. */
+    index: FractionalIndex | null;
     isDeleted: boolean;
     /** List of groups the element belongs to.
         Ordered from deepest to shallowest. */
     groupIds: readonly GroupId[];
     frameId: string | null;
     /** other elements that are bound to this element */
-    boundElements: readonly Readonly<{
-        id: ExcalidrawLinearElement["id"];
-        type: "arrow" | "text";
-    }>[] | null;
+    boundElements: readonly BoundElement[] | null;
     /** epoch (ms) timestamp of last element update */
     updated: number;
     link: string | null;
@@ -128,6 +137,10 @@ export type ExcalidrawGenericElement = ExcalidrawSelectionElement | ExcalidrawRe
  * between peers and contain no state local to the peer.
  */
 export type ExcalidrawElement = ExcalidrawGenericElement | ExcalidrawTextElement | ExcalidrawLinearElement | ExcalidrawFreeDrawElement | ExcalidrawImageElement | ExcalidrawFrameElement | ExcalidrawMagicFrameElement | ExcalidrawIframeElement | ExcalidrawEmbeddableElement;
+export type Ordered<TElement extends ExcalidrawElement> = TElement & {
+    index: FractionalIndex;
+};
+export type OrderedExcalidrawElement = Ordered<ExcalidrawElement>;
 export type NonDeleted<TElement extends ExcalidrawElement> = TElement & {
     isDeleted: boolean;
 };
@@ -198,11 +211,11 @@ export type NonDeletedElementsMap = Map<ExcalidrawElement["id"], NonDeletedExcal
  * Map of all excalidraw Scene elements, including deleted.
  * Not a subset. Use this type when you need access to current Scene elements.
  */
-export type SceneElementsMap = Map<ExcalidrawElement["id"], ExcalidrawElement> & MakeBrand<"SceneElementsMap">;
+export type SceneElementsMap = Map<ExcalidrawElement["id"], Ordered<ExcalidrawElement>> & MakeBrand<"SceneElementsMap">;
 /**
  * Map of all non-deleted Scene elements.
  * Not a subset. Use this type when you need access to current Scene elements.
  */
-export type NonDeletedSceneElementsMap = Map<ExcalidrawElement["id"], NonDeletedExcalidrawElement> & MakeBrand<"NonDeletedSceneElementsMap">;
+export type NonDeletedSceneElementsMap = Map<ExcalidrawElement["id"], Ordered<NonDeletedExcalidrawElement>> & MakeBrand<"NonDeletedSceneElementsMap">;
 export type ElementsMapOrArray = readonly ExcalidrawElement[] | Readonly<ElementsMap>;
 export {};

package/dist/excalidraw/errors.d.ts

@@ -10,4 +10,7 @@ export declare class ImageSceneDataError extends Error {
     code: ImageSceneDataErrorCode;
     constructor(message?: string, code?: ImageSceneDataErrorCode);
 }
+export declare class InvalidFractionalIndexError extends Error {
+    code: "ELEMENT_HAS_INVALID_INDEX";
+}
 export {};

package/dist/excalidraw/errors.js

@@ -18,3 +18,6 @@ export class ImageSceneDataError extends Error {
         this.code = code;
     }
 }
+export class InvalidFractionalIndexError extends Error {
+    code = "ELEMENT_HAS_INVALID_INDEX";
+}

package/dist/excalidraw/fractionalIndex.d.ts

@@ -0,0 +1,40 @@
+import { ExcalidrawElement, OrderedExcalidrawElement } from "./element/types";
+/**
+ * Envisioned relation between array order and fractional indices:
+ *
+ * 1) Array (or array-like ordered data structure) should be used as a cache of elements order, hiding the internal fractional indices implementation.
+ * - it's undesirable to to perform reorder for each related operation, thefeore it's necessary to cache the order defined by fractional indices into an ordered data structure
+ * - it's easy enough to define the order of the elements from the outside (boundaries), without worrying about the underlying structure of fractional indices (especially for the host apps)
+ * - it's necessary to always keep the array support for backwards compatibility (restore) - old scenes, old libraries, supporting multiple excalidraw versions etc.
+ * - it's necessary to always keep the fractional indices in sync with the array order
+ * - elements with invalid indices should be detected and synced, without altering the already valid indices
+ *
+ * 2) Fractional indices should be used to reorder the elements, whenever the cached order is expected to be invalidated.
+ * - as the fractional indices are encoded as part of the elements, it opens up possibilties for incremental-like APIs
+ * - re-order based on fractional indices should be part of (multiplayer) operations such as reconcillitation & undo/redo
+ * - technically all the z-index actions could perform also re-order based on fractional indices,but in current state it would not bring much benefits,
+ *   as it's faster & more efficient to perform re-order based on array manipulation and later synchronisation of moved indices with the array order
+ */
+/**
+ * Ensure that all elements have valid fractional indices.
+ *
+ * @throws `InvalidFractionalIndexError` if invalid index is detected.
+ */
+export declare const validateFractionalIndices: (indices: (ExcalidrawElement["index"] | undefined)[]) => void;
+/**
+ * Order the elements based on the fractional indices.
+ * - when fractional indices are identical, break the tie based on the element id
+ * - when there is no fractional index in one of the elements, respect the order of the array
+ */
+export declare const orderByFractionalIndex: (elements: OrderedExcalidrawElement[]) => OrderedExcalidrawElement[];
+/**
+ * Synchronizes invalid fractional indices of moved elements with the array order by mutating passed elements.
+ * If the synchronization fails or the result is invalid, it fallbacks to `syncInvalidIndices`.
+ */
+export declare const syncMovedIndices: (elements: readonly ExcalidrawElement[], movedElements: Map<string, ExcalidrawElement>) => OrderedExcalidrawElement[];
+/**
+ * Synchronizes all invalid fractional indices with the array order by mutating passed elements.
+ *
+ * WARN: in edge cases it could modify the elements which were not moved, as it's impossible to guess the actually moved elements from the elements array itself.
+ */
+export declare const syncInvalidIndices: (elements: readonly ExcalidrawElement[]) => OrderedExcalidrawElement[];

package/dist/excalidraw/fractionalIndex.js

@@ -0,0 +1,241 @@
+import { generateNKeysBetween } from "fractional-indexing";
+import { mutateElement } from "./element/mutateElement";
+import { InvalidFractionalIndexError } from "./errors";
+/**
+ * Envisioned relation between array order and fractional indices:
+ *
+ * 1) Array (or array-like ordered data structure) should be used as a cache of elements order, hiding the internal fractional indices implementation.
+ * - it's undesirable to to perform reorder for each related operation, thefeore it's necessary to cache the order defined by fractional indices into an ordered data structure
+ * - it's easy enough to define the order of the elements from the outside (boundaries), without worrying about the underlying structure of fractional indices (especially for the host apps)
+ * - it's necessary to always keep the array support for backwards compatibility (restore) - old scenes, old libraries, supporting multiple excalidraw versions etc.
+ * - it's necessary to always keep the fractional indices in sync with the array order
+ * - elements with invalid indices should be detected and synced, without altering the already valid indices
+ *
+ * 2) Fractional indices should be used to reorder the elements, whenever the cached order is expected to be invalidated.
+ * - as the fractional indices are encoded as part of the elements, it opens up possibilties for incremental-like APIs
+ * - re-order based on fractional indices should be part of (multiplayer) operations such as reconcillitation & undo/redo
+ * - technically all the z-index actions could perform also re-order based on fractional indices,but in current state it would not bring much benefits,
+ *   as it's faster & more efficient to perform re-order based on array manipulation and later synchronisation of moved indices with the array order
+ */
+/**
+ * Ensure that all elements have valid fractional indices.
+ *
+ * @throws `InvalidFractionalIndexError` if invalid index is detected.
+ */
+export const validateFractionalIndices = (indices) => {
+    for (const [i, index] of indices.entries()) {
+        const predecessorIndex = indices[i - 1];
+        const successorIndex = indices[i + 1];
+        if (!isValidFractionalIndex(index, predecessorIndex, successorIndex)) {
+            throw new InvalidFractionalIndexError(`Fractional indices invariant for element has been compromised - ["${predecessorIndex}", "${index}", "${successorIndex}"] [predecessor, current, successor]`);
+        }
+    }
+};
+/**
+ * Order the elements based on the fractional indices.
+ * - when fractional indices are identical, break the tie based on the element id
+ * - when there is no fractional index in one of the elements, respect the order of the array
+ */
+export const orderByFractionalIndex = (elements) => {
+    return elements.sort((a, b) => {
+        // in case the indices are not the defined at runtime
+        if (isOrderedElement(a) && isOrderedElement(b)) {
+            if (a.index < b.index) {
+                return -1;
+            }
+            else if (a.index > b.index) {
+                return 1;
+            }
+            // break ties based on the element id
+            return a.id < b.id ? -1 : 1;
+        }
+        // defensively keep the array order
+        return 1;
+    });
+};
+/**
+ * Synchronizes invalid fractional indices of moved elements with the array order by mutating passed elements.
+ * If the synchronization fails or the result is invalid, it fallbacks to `syncInvalidIndices`.
+ */
+export const syncMovedIndices = (elements, movedElements) => {
+    try {
+        const indicesGroups = getMovedIndicesGroups(elements, movedElements);
+        // try generatating indices, throws on invalid movedElements
+        const elementsUpdates = generateIndices(elements, indicesGroups);
+        // ensure next indices are valid before mutation, throws on invalid ones
+        validateFractionalIndices(elements.map((x) => elementsUpdates.get(x)?.index || x.index));
+        // split mutation so we don't end up in an incosistent state
+        for (const [element, update] of elementsUpdates) {
+            mutateElement(element, update, false);
+        }
+    }
+    catch (e) {
+        // fallback to default sync
+        syncInvalidIndices(elements);
+    }
+    return elements;
+};
+/**
+ * Synchronizes all invalid fractional indices with the array order by mutating passed elements.
+ *
+ * WARN: in edge cases it could modify the elements which were not moved, as it's impossible to guess the actually moved elements from the elements array itself.
+ */
+export const syncInvalidIndices = (elements) => {
+    const indicesGroups = getInvalidIndicesGroups(elements);
+    const elementsUpdates = generateIndices(elements, indicesGroups);
+    for (const [element, update] of elementsUpdates) {
+        mutateElement(element, update, false);
+    }
+    return elements;
+};
+/**
+ * Get contiguous groups of indices of passed moved elements.
+ *
+ * NOTE: First and last elements within the groups are indices of lower and upper bounds.
+ */
+const getMovedIndicesGroups = (elements, movedElements) => {
+    const indicesGroups = [];
+    let i = 0;
+    while (i < elements.length) {
+        if (movedElements.has(elements[i].id) &&
+            !isValidFractionalIndex(elements[i]?.index, elements[i - 1]?.index, elements[i + 1]?.index)) {
+            const indicesGroup = [i - 1, i]; // push the lower bound index as the first item
+            while (++i < elements.length) {
+                if (!(movedElements.has(elements[i].id) &&
+                    !isValidFractionalIndex(elements[i]?.index, elements[i - 1]?.index, elements[i + 1]?.index))) {
+                    break;
+                }
+                indicesGroup.push(i);
+            }
+            indicesGroup.push(i); // push the upper bound index as the last item
+            indicesGroups.push(indicesGroup);
+        }
+        else {
+            i++;
+        }
+    }
+    return indicesGroups;
+};
+/**
+ * Gets contiguous groups of all invalid indices automatically detected inside the elements array.
+ *
+ * WARN: First and last items within the groups do NOT have to be contiguous, those are the found lower and upper bounds!
+ */
+const getInvalidIndicesGroups = (elements) => {
+    const indicesGroups = [];
+    // once we find lowerBound / upperBound, it cannot be lower than that, so we cache it for better perf.
+    let lowerBound = undefined;
+    let upperBound = undefined;
+    let lowerBoundIndex = -1;
+    let upperBoundIndex = 0;
+    /** @returns maybe valid lowerBound */
+    const getLowerBound = (index) => {
+        const lowerBound = elements[lowerBoundIndex]
+            ? elements[lowerBoundIndex].index
+            : undefined;
+        // we are already iterating left to right, therefore there is no need for additional looping
+        const candidate = elements[index - 1]?.index;
+        if ((!lowerBound && candidate) || // first lowerBound
+            (lowerBound && candidate && candidate > lowerBound) // next lowerBound
+        ) {
+            // WARN: candidate's index could be higher or same as the current element's index
+            return [candidate, index - 1];
+        }
+        // cache hit! take the last lower bound
+        return [lowerBound, lowerBoundIndex];
+    };
+    /** @returns always valid upperBound */
+    const getUpperBound = (index) => {
+        const upperBound = elements[upperBoundIndex]
+            ? elements[upperBoundIndex].index
+            : undefined;
+        // cache hit! don't let it find the upper bound again
+        if (upperBound && index < upperBoundIndex) {
+            return [upperBound, upperBoundIndex];
+        }
+        // set the current upperBoundIndex as the starting point
+        let i = upperBoundIndex;
+        while (++i < elements.length) {
+            const candidate = elements[i]?.index;
+            if ((!upperBound && candidate) || // first upperBound
+                (upperBound && candidate && candidate > upperBound) // next upperBound
+            ) {
+                return [candidate, i];
+            }
+        }
+        // we reached the end, sky is the limit
+        return [undefined, i];
+    };
+    let i = 0;
+    while (i < elements.length) {
+        const current = elements[i].index;
+        [lowerBound, lowerBoundIndex] = getLowerBound(i);
+        [upperBound, upperBoundIndex] = getUpperBound(i);
+        if (!isValidFractionalIndex(current, lowerBound, upperBound)) {
+            // push the lower bound index as the first item
+            const indicesGroup = [lowerBoundIndex, i];
+            while (++i < elements.length) {
+                const current = elements[i].index;
+                const [nextLowerBound, nextLowerBoundIndex] = getLowerBound(i);
+                const [nextUpperBound, nextUpperBoundIndex] = getUpperBound(i);
+                if (isValidFractionalIndex(current, nextLowerBound, nextUpperBound)) {
+                    break;
+                }
+                // assign bounds only for the moved elements
+                [lowerBound, lowerBoundIndex] = [nextLowerBound, nextLowerBoundIndex];
+                [upperBound, upperBoundIndex] = [nextUpperBound, nextUpperBoundIndex];
+                indicesGroup.push(i);
+            }
+            // push the upper bound index as the last item
+            indicesGroup.push(upperBoundIndex);
+            indicesGroups.push(indicesGroup);
+        }
+        else {
+            i++;
+        }
+    }
+    return indicesGroups;
+};
+const isValidFractionalIndex = (index, predecessor, successor) => {
+    if (!index) {
+        return false;
+    }
+    if (predecessor && successor) {
+        return predecessor < index && index < successor;
+    }
+    if (!predecessor && successor) {
+        // first element
+        return index < successor;
+    }
+    if (predecessor && !successor) {
+        // last element
+        return predecessor < index;
+    }
+    // only element in the array
+    return !!index;
+};
+const generateIndices = (elements, indicesGroups) => {
+    const elementsUpdates = new Map();
+    for (const indices of indicesGroups) {
+        const lowerBoundIndex = indices.shift();
+        const upperBoundIndex = indices.pop();
+        const fractionalIndices = generateNKeysBetween(elements[lowerBoundIndex]?.index, elements[upperBoundIndex]?.index, indices.length);
+        for (let i = 0; i < indices.length; i++) {
+            const element = elements[indices[i]];
+            elementsUpdates.set(element, {
+                index: fractionalIndices[i],
+            });
+        }
+    }
+    return elementsUpdates;
+};
+const isOrderedElement = (element) => {
+    // for now it's sufficient whether the index is there
+    // meaning, the element was already ordered in the past
+    // meaning, it is not a newly inserted element, not an unrestored element, etc.
+    // it does not have to mean that the index itself is valid
+    if (element.index) {
+        return true;
+    }
+    return false;
+};

package/dist/excalidraw/frame.d.ts

@@ -2,7 +2,7 @@ import { ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFrameLike
 import { AppClassProperties, AppState, StaticCanvasAppState } from "./types";
 import type { ExcalidrawElementsIncludingDeleted } from "./scene/Scene";
 import { ReadonlySetLike } from "./utility-types";
-export declare const bindElementsToFramesAfterDuplication: (nextElements: ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+export declare const bindElementsToFramesAfterDuplication: (nextElements: readonly ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
 export declare function isElementIntersectingFrame(element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap): boolean;
 export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
 export declare const isElementContainingFrame: (elements: readonly ExcalidrawElement[], element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;

package/dist/excalidraw/groups.d.ts

@@ -28,4 +28,6 @@ export declare const removeFromSelectedGroups: (groupIds: ExcalidrawElement["gro
     [groupId: string]: boolean;
 }) => string[];
 export declare const getMaximumGroups: (elements: ExcalidrawElement[], elementsMap: ElementsMap) => ExcalidrawElement[][];
+export declare const getNonDeletedGroupIds: (elements: ElementsMap) => Set<string>;
 export declare const elementsAreInSameGroup: (elements: ExcalidrawElement[]) => boolean;
+export declare const isInGroup: (element: NonDeletedExcalidrawElement) => boolean;

package/dist/excalidraw/groups.js

@@ -219,6 +219,20 @@ export const getMaximumGroups = (elements, elementsMap) => {
     });
     return Array.from(groups.values());
 };
+export const getNonDeletedGroupIds = (elements) => {
+    const nonDeletedGroupIds = new Set();
+    for (const [, element] of elements) {
+        // defensive check
+        if (element.isDeleted) {
+            continue;
+        }
+        // defensive fallback
+        for (const groupId of element.groupIds ?? []) {
+            nonDeletedGroupIds.add(groupId);
+        }
+    }
+    return nonDeletedGroupIds;
+};
 export const elementsAreInSameGroup = (elements) => {
     const allGroups = elements.flatMap((element) => element.groupIds);
     const groupCount = new Map();
@@ -231,3 +245,6 @@ export const elementsAreInSameGroup = (elements) => {
     }
     return maxGroup === elements.length;
 };
+export const isInGroup = (element) => {
+    return element.groupIds.length > 0;
+};

package/dist/excalidraw/history.d.ts

@@ -1,52 +1,40 @@
+import { AppStateChange, ElementsChange } from "./change";
+import { SceneElementsMap } from "./element/types";
+import { Emitter } from "./emitter";
+import { Snapshot } from "./store";
 import { AppState } from "./types";
-import { ExcalidrawElement } from "./element/types";
-export interface HistoryEntry {
-    appState: ReturnType<typeof clearAppStatePropertiesForHistory>;
-    elements: ExcalidrawElement[];
+export declare class HistoryChangedEvent {
+    readonly isUndoStackEmpty: boolean;
+    readonly isRedoStackEmpty: boolean;
+    constructor(isUndoStackEmpty?: boolean, isRedoStackEmpty?: boolean);
 }
-declare const clearAppStatePropertiesForHistory: (appState: AppState) => {
-    selectedElementIds: Readonly<{
-        [id: string]: true;
-    }>;
-    selectedGroupIds: {
-        [groupId: string]: boolean;
-    };
-    viewBackgroundColor: string;
-    editingLinearElement: import("./element/linearElementEditor").LinearElementEditor | null;
-    editingGroupId: string | null;
-    name: string | null;
-};
-declare class History {
-    private elementCache;
-    private recording;
-    private stateHistory;
-    private redoStack;
-    private lastEntry;
-    private hydrateHistoryEntry;
-    private dehydrateHistoryEntry;
-    getSnapshotForTest(): {
-        recording: boolean;
-        stateHistory: HistoryEntry[];
-        redoStack: HistoryEntry[];
-    };
+export declare class History {
+    readonly onHistoryChangedEmitter: Emitter<[HistoryChangedEvent]>;
+    private readonly undoStack;
+    private readonly redoStack;
+    get isUndoStackEmpty(): boolean;
+    get isRedoStackEmpty(): boolean;
     clear(): void;
-    private generateEntry;
-    shouldCreateEntry(nextEntry: HistoryEntry): boolean;
-    pushEntry(appState: AppState, elements: readonly ExcalidrawElement[]): void;
-    clearRedoStack(): void;
-    redoOnce(): HistoryEntry | null;
-    undoOnce(): HistoryEntry | null;
     /**
-     * Updates history's `lastEntry` to latest app state. This is necessary
-     *  when doing undo/redo which itself doesn't commit to history, but updates
-     *  app state in a way that would break `shouldCreateEntry` which relies on
-     *  `lastEntry` to reflect last comittable history state.
-     * We can't update `lastEntry` from within history when calling undo/redo
-     *  because the action potentially mutates appState/elements before storing
-     *  it.
+     * Record a local change which will go into the history
      */
-    setCurrentState(appState: AppState, elements: readonly ExcalidrawElement[]): void;
-    resumeRecording(): void;
-    record(state: AppState, elements: readonly ExcalidrawElement[]): void;
+    record(elementsChange: ElementsChange, appStateChange: AppStateChange): void;
+    undo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
+    redo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
+    private perform;
+    private static pop;
+    private static push;
+}
+export declare class HistoryEntry {
+    readonly appStateChange: AppStateChange;
+    readonly elementsChange: ElementsChange;
+    private constructor();
+    static create(appStateChange: AppStateChange, elementsChange: ElementsChange): HistoryEntry;
+    inverse(): HistoryEntry;
+    applyTo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): [SceneElementsMap, AppState, boolean];
+    /**
+     * Apply latest (remote) changes to the history entry, creates new instance of `HistoryEntry`.
+     */
+    applyLatestChanges(elements: SceneElementsMap): HistoryEntry;
+    isEmpty(): boolean;
 }
-export default History;