@zsviczian/excalidraw 0.18.0-14 → 0.18.0-16

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

@@ -1,196 +1,196 @@
-import type { ExcalidrawElement, Ordered, OrderedExcalidrawElement, SceneElementsMap } from "@excalidraw/element/types";
-import type { DTO, ValueOf } from "@excalidraw/common/utility-types";
-import type { AppState, ObservedAppState } from "@excalidraw/excalidraw/types";
-import type { ElementUpdate } from "./mutateElement";
-/**
- * Represents the difference between two objects of the same type.
- *
- * Both `deleted` and `inserted` partials represent the same set of added, removed or updated properties, where:
- * - `deleted` is a set of all the deleted values
- * - `inserted` is a set of all the inserted (added, updated) values
- *
- * Keeping it as pure object (without transient state, side-effects, etc.), so we won't have to instantiate it on load.
- */
-export declare class Delta<T> {
-    readonly deleted: Partial<T>;
-    readonly inserted: Partial<T>;
-    private constructor();
-    static create<T>(deleted: Partial<T>, inserted: Partial<T>, modifier?: (delta: Partial<T>) => Partial<T>, modifierOptions?: "deleted" | "inserted"): Delta<T>;
-    /**
-     * Calculates the delta between two objects.
-     *
-     * @param prevObject - The previous state of the object.
-     * @param nextObject - The next state of the object.
-     *
-     * @returns new delta instance.
-     */
-    static calculate<T extends {
-        [key: string]: any;
-    }>(prevObject: T, nextObject: T, modifier?: (partial: Partial<T>) => Partial<T>, postProcess?: (deleted: Partial<T>, inserted: Partial<T>) => [Partial<T>, Partial<T>]): Delta<T>;
-    static empty(): Delta<unknown>;
-    static isEmpty<T>(delta: Delta<T>): boolean;
-    /**
-     * Merges deleted and inserted object partials.
-     */
-    static mergeObjects<T extends {
-        [key: string]: unknown;
-    }>(prev: T, added: T, removed: T): T;
-    /**
-     * Merges deleted and inserted array partials.
-     */
-    static mergeArrays<T>(prev: readonly T[] | null, added: readonly T[] | null | undefined, removed: readonly T[] | null | undefined, predicate?: (value: T) => string): T[];
-    /**
-     * Diff object partials as part of the `postProcess`.
-     */
-    static diffObjects<T, K extends keyof T, V extends ValueOf<T[K]>>(deleted: Partial<T>, inserted: Partial<T>, property: K, setValue: (prevValue: V | undefined) => V): void;
-    /**
-     * Diff array partials as part of the `postProcess`.
-     */
-    static diffArrays<T, K extends keyof T, V extends T[K]>(deleted: Partial<T>, inserted: Partial<T>, property: K, groupBy: (value: V extends ArrayLike<infer T> ? T : never) => string): void;
-    /**
-     * Compares if object1 contains any different value compared to the object2.
-     */
-    static isLeftDifferent<T extends {}>(object1: T, object2: T, skipShallowCompare?: boolean): boolean;
-    /**
-     * Compares if object2 contains any different value compared to the object1.
-     */
-    static isRightDifferent<T extends {}>(object1: T, object2: T, skipShallowCompare?: boolean): boolean;
-    /**
-     * Returns sorted object1 keys that have distinct values.
-     */
-    static getLeftDifferences<T extends {}>(object1: T, object2: T, skipShallowCompare?: boolean): string[];
-    /**
-     * Returns sorted object2 keys that have distinct values.
-     */
-    static getRightDifferences<T extends {}>(object1: T, object2: T, skipShallowCompare?: boolean): string[];
-    /**
-     * Iterator comparing values of object properties based on the passed joining strategy.
-     *
-     * @yields keys of properties with different values
-     *
-     * WARN: it's based on shallow compare performed only on the first level and doesn't go deeper than that.
-     */
-    private static distinctKeysIterator;
-}
-/**
- * Encapsulates a set of application-level `Delta`s.
- */
-export interface DeltaContainer<T> {
-    /**
-     * Inverses the `Delta`s while creating a new `DeltaContainer` instance.
-     */
-    inverse(): DeltaContainer<T>;
-    /**
-     * Applies the `Delta`s to the previous object.
-     *
-     * @returns a tuple of the next object `T` with applied `Delta`s, and `boolean`, indicating whether the applied deltas resulted in a visible change.
-     */
-    applyTo(previous: T, ...options: unknown[]): [T, boolean];
-    /**
-     * Checks whether all `Delta`s are empty.
-     */
-    isEmpty(): boolean;
-}
-export declare class AppStateDelta implements DeltaContainer<AppState> {
-    readonly delta: Delta<ObservedAppState>;
-    private constructor();
-    static calculate<T extends ObservedAppState>(prevAppState: T, nextAppState: T): AppStateDelta;
-    static restore(appStateDeltaDTO: DTO<AppStateDelta>): AppStateDelta;
-    static empty(): AppStateDelta;
-    inverse(): AppStateDelta;
-    applyTo(appState: AppState, nextElements: SceneElementsMap): [AppState, boolean];
-    isEmpty(): boolean;
-    /**
-     * Mutates `nextAppState` be filtering out state related to deleted elements.
-     *
-     * @returns `true` if a visible change is found, `false` otherwise.
-     */
-    private filterInvisibleChanges;
-    private static convertToAppStateKey;
-    private static filterSelectedElements;
-    private static filterSelectedGroups;
-    private static stripElementsProps;
-    private static stripStandaloneProps;
-    /**
-     * It is necessary to post process the partials in case of reference values,
-     * for which we need to calculate the real diff between `deleted` and `inserted`.
-     */
-    private static postProcess;
-    private static orderAppStateKeys;
-}
-type ElementPartial<T extends ExcalidrawElement = ExcalidrawElement> = Omit<ElementUpdate<Ordered<T>>, "seed">;
-/**
- * Elements change is a low level primitive to capture a change between two sets of elements.
- * It does so by encapsulating forward and backward `Delta`s, allowing to time-travel in both directions.
- */
-export declare class ElementsDelta implements DeltaContainer<SceneElementsMap> {
-    readonly added: Record<string, Delta<ElementPartial>>;
-    readonly removed: Record<string, Delta<ElementPartial>>;
-    readonly updated: Record<string, Delta<ElementPartial>>;
-    private constructor();
-    static create(added: Record<string, Delta<ElementPartial>>, removed: Record<string, Delta<ElementPartial>>, updated: Record<string, Delta<ElementPartial>>, options?: {
-        shouldRedistribute: boolean;
-    }): ElementsDelta;
-    static restore(elementsDeltaDTO: DTO<ElementsDelta>): ElementsDelta;
-    private static satisfiesAddition;
-    private static satisfiesRemoval;
-    private static satisfiesUpdate;
-    private static validate;
-    /**
-     * Calculates the `Delta`s between the previous and next set of elements.
-     *
-     * @param prevElements - Map representing the previous state of elements.
-     * @param nextElements - Map representing the next state of elements.
-     *
-     * @returns `ElementsDelta` instance representing the `Delta` changes between the two sets of elements.
-     */
-    static calculate<T extends OrderedExcalidrawElement>(prevElements: Map<string, T>, nextElements: Map<string, T>): ElementsDelta;
-    static empty(): ElementsDelta;
-    inverse(): ElementsDelta;
-    isEmpty(): boolean;
-    /**
-     * Update delta/s based on the existing elements.
-     *
-     * @param elements current elements
-     * @param modifierOptions defines which of the delta (`deleted` or `inserted`) will be updated
-     * @returns new instance with modified delta/s
-     */
-    applyLatestChanges(elements: SceneElementsMap, modifierOptions: "deleted" | "inserted"): ElementsDelta;
-    applyTo(elements: SceneElementsMap, elementsSnapshot: Map<string, OrderedExcalidrawElement>): [SceneElementsMap, boolean];
-    private static createApplier;
-    private static createGetter;
-    private static applyDelta;
-    /**
-     * Check for visible changes regardless of whether they were removed, added or updated.
-     */
-    private static checkForVisibleDifference;
-    /**
-     * Resolves conflicts for all previously added, removed and updated elements.
-     * Updates the previous deltas with all the changes after conflict resolution.
-     *
-     * // TODO: revisit since some bound arrows seem to be often redrawn incorrectly
-     *
-     * @returns all elements affected by the conflict resolution
-     */
-    private resolveConflicts;
-    /**
-     * Non deleted affected elements of removed elements (before and after applying delta),
-     * should be unbound ~ bindings should not point from non deleted into the deleted element/s.
-     */
-    private static unbindAffected;
-    /**
-     * Non deleted affected elements of added or updated element/s (before and after applying delta),
-     * should be rebound (if possible) with the current element ~ bindings should be bidirectional.
-     */
-    private static rebindAffected;
-    private static redrawTextBoundingBoxes;
-    private static redrawBoundArrows;
-    private static reorderElements;
-    /**
-     * It is necessary to post process the partials in case of reference values,
-     * for which we need to calculate the real diff between `deleted` and `inserted`.
-     */
-    private static postProcess;
-    private static stripIrrelevantProps;
-}
-export {};
+import type { ExcalidrawElement, Ordered, OrderedExcalidrawElement, SceneElementsMap } from "@excalidraw/element/types";
+import type { DTO, ValueOf } from "@excalidraw/common/utility-types";
+import type { AppState, ObservedAppState } from "@excalidraw/excalidraw/types";
+import type { ElementUpdate } from "./mutateElement";
+/**
+ * Represents the difference between two objects of the same type.
+ *
+ * Both `deleted` and `inserted` partials represent the same set of added, removed or updated properties, where:
+ * - `deleted` is a set of all the deleted values
+ * - `inserted` is a set of all the inserted (added, updated) values
+ *
+ * Keeping it as pure object (without transient state, side-effects, etc.), so we won't have to instantiate it on load.
+ */
+export declare class Delta<T> {
+    readonly deleted: Partial<T>;
+    readonly inserted: Partial<T>;
+    private constructor();
+    static create<T>(deleted: Partial<T>, inserted: Partial<T>, modifier?: (delta: Partial<T>) => Partial<T>, modifierOptions?: "deleted" | "inserted"): Delta<T>;
+    /**
+     * Calculates the delta between two objects.
+     *
+     * @param prevObject - The previous state of the object.
+     * @param nextObject - The next state of the object.
+     *
+     * @returns new delta instance.
+     */
+    static calculate<T extends {
+        [key: string]: any;
+    }>(prevObject: T, nextObject: T, modifier?: (partial: Partial<T>) => Partial<T>, postProcess?: (deleted: Partial<T>, inserted: Partial<T>) => [Partial<T>, Partial<T>]): Delta<T>;
+    static empty(): Delta<unknown>;
+    static isEmpty<T>(delta: Delta<T>): boolean;
+    /**
+     * Merges deleted and inserted object partials.
+     */
+    static mergeObjects<T extends {
+        [key: string]: unknown;
+    }>(prev: T, added: T, removed: T): T;
+    /**
+     * Merges deleted and inserted array partials.
+     */
+    static mergeArrays<T>(prev: readonly T[] | null, added: readonly T[] | null | undefined, removed: readonly T[] | null | undefined, predicate?: (value: T) => string): T[];
+    /**
+     * Diff object partials as part of the `postProcess`.
+     */
+    static diffObjects<T, K extends keyof T, V extends ValueOf<T[K]>>(deleted: Partial<T>, inserted: Partial<T>, property: K, setValue: (prevValue: V | undefined) => V): void;
+    /**
+     * Diff array partials as part of the `postProcess`.
+     */
+    static diffArrays<T, K extends keyof T, V extends T[K]>(deleted: Partial<T>, inserted: Partial<T>, property: K, groupBy: (value: V extends ArrayLike<infer T> ? T : never) => string): void;
+    /**
+     * Compares if object1 contains any different value compared to the object2.
+     */
+    static isLeftDifferent<T extends {}>(object1: T, object2: T, skipShallowCompare?: boolean): boolean;
+    /**
+     * Compares if object2 contains any different value compared to the object1.
+     */
+    static isRightDifferent<T extends {}>(object1: T, object2: T, skipShallowCompare?: boolean): boolean;
+    /**
+     * Returns sorted object1 keys that have distinct values.
+     */
+    static getLeftDifferences<T extends {}>(object1: T, object2: T, skipShallowCompare?: boolean): string[];
+    /**
+     * Returns sorted object2 keys that have distinct values.
+     */
+    static getRightDifferences<T extends {}>(object1: T, object2: T, skipShallowCompare?: boolean): string[];
+    /**
+     * Iterator comparing values of object properties based on the passed joining strategy.
+     *
+     * @yields keys of properties with different values
+     *
+     * WARN: it's based on shallow compare performed only on the first level and doesn't go deeper than that.
+     */
+    private static distinctKeysIterator;
+}
+/**
+ * Encapsulates a set of application-level `Delta`s.
+ */
+export interface DeltaContainer<T> {
+    /**
+     * Inverses the `Delta`s while creating a new `DeltaContainer` instance.
+     */
+    inverse(): DeltaContainer<T>;
+    /**
+     * Applies the `Delta`s to the previous object.
+     *
+     * @returns a tuple of the next object `T` with applied `Delta`s, and `boolean`, indicating whether the applied deltas resulted in a visible change.
+     */
+    applyTo(previous: T, ...options: unknown[]): [T, boolean];
+    /**
+     * Checks whether all `Delta`s are empty.
+     */
+    isEmpty(): boolean;
+}
+export declare class AppStateDelta implements DeltaContainer<AppState> {
+    readonly delta: Delta<ObservedAppState>;
+    private constructor();
+    static calculate<T extends ObservedAppState>(prevAppState: T, nextAppState: T): AppStateDelta;
+    static restore(appStateDeltaDTO: DTO<AppStateDelta>): AppStateDelta;
+    static empty(): AppStateDelta;
+    inverse(): AppStateDelta;
+    applyTo(appState: AppState, nextElements: SceneElementsMap): [AppState, boolean];
+    isEmpty(): boolean;
+    /**
+     * Mutates `nextAppState` be filtering out state related to deleted elements.
+     *
+     * @returns `true` if a visible change is found, `false` otherwise.
+     */
+    private filterInvisibleChanges;
+    private static convertToAppStateKey;
+    private static filterSelectedElements;
+    private static filterSelectedGroups;
+    private static stripElementsProps;
+    private static stripStandaloneProps;
+    /**
+     * It is necessary to post process the partials in case of reference values,
+     * for which we need to calculate the real diff between `deleted` and `inserted`.
+     */
+    private static postProcess;
+    private static orderAppStateKeys;
+}
+type ElementPartial<T extends ExcalidrawElement = ExcalidrawElement> = Omit<ElementUpdate<Ordered<T>>, "seed">;
+/**
+ * Elements change is a low level primitive to capture a change between two sets of elements.
+ * It does so by encapsulating forward and backward `Delta`s, allowing to time-travel in both directions.
+ */
+export declare class ElementsDelta implements DeltaContainer<SceneElementsMap> {
+    readonly added: Record<string, Delta<ElementPartial>>;
+    readonly removed: Record<string, Delta<ElementPartial>>;
+    readonly updated: Record<string, Delta<ElementPartial>>;
+    private constructor();
+    static create(added: Record<string, Delta<ElementPartial>>, removed: Record<string, Delta<ElementPartial>>, updated: Record<string, Delta<ElementPartial>>, options?: {
+        shouldRedistribute: boolean;
+    }): ElementsDelta;
+    static restore(elementsDeltaDTO: DTO<ElementsDelta>): ElementsDelta;
+    private static satisfiesAddition;
+    private static satisfiesRemoval;
+    private static satisfiesUpdate;
+    private static validate;
+    /**
+     * Calculates the `Delta`s between the previous and next set of elements.
+     *
+     * @param prevElements - Map representing the previous state of elements.
+     * @param nextElements - Map representing the next state of elements.
+     *
+     * @returns `ElementsDelta` instance representing the `Delta` changes between the two sets of elements.
+     */
+    static calculate<T extends OrderedExcalidrawElement>(prevElements: Map<string, T>, nextElements: Map<string, T>): ElementsDelta;
+    static empty(): ElementsDelta;
+    inverse(): ElementsDelta;
+    isEmpty(): boolean;
+    /**
+     * Update delta/s based on the existing elements.
+     *
+     * @param elements current elements
+     * @param modifierOptions defines which of the delta (`deleted` or `inserted`) will be updated
+     * @returns new instance with modified delta/s
+     */
+    applyLatestChanges(elements: SceneElementsMap, modifierOptions: "deleted" | "inserted"): ElementsDelta;
+    applyTo(elements: SceneElementsMap, elementsSnapshot: Map<string, OrderedExcalidrawElement>): [SceneElementsMap, boolean];
+    private static createApplier;
+    private static createGetter;
+    private static applyDelta;
+    /**
+     * Check for visible changes regardless of whether they were removed, added or updated.
+     */
+    private static checkForVisibleDifference;
+    /**
+     * Resolves conflicts for all previously added, removed and updated elements.
+     * Updates the previous deltas with all the changes after conflict resolution.
+     *
+     * // TODO: revisit since some bound arrows seem to be often redrawn incorrectly
+     *
+     * @returns all elements affected by the conflict resolution
+     */
+    private resolveConflicts;
+    /**
+     * Non deleted affected elements of removed elements (before and after applying delta),
+     * should be unbound ~ bindings should not point from non deleted into the deleted element/s.
+     */
+    private static unbindAffected;
+    /**
+     * Non deleted affected elements of added or updated element/s (before and after applying delta),
+     * should be rebound (if possible) with the current element ~ bindings should be bidirectional.
+     */
+    private static rebindAffected;
+    private static redrawTextBoundingBoxes;
+    private static redrawBoundArrows;
+    private static reorderElements;
+    /**
+     * It is necessary to post process the partials in case of reference values,
+     * for which we need to calculate the real diff between `deleted` and `inserted`.
+     */
+    private static postProcess;
+    private static stripIrrelevantProps;
+}
+export {};

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

@@ -1,3 +1,3 @@
-import type { GlobalPoint } from "@excalidraw/math";
-import type { ExcalidrawBindableElement } from "./types";
-export declare const distanceToBindableElement: (element: ExcalidrawBindableElement, p: GlobalPoint) => number;
+import type { GlobalPoint } from "@excalidraw/math";
+import type { ExcalidrawBindableElement } from "./types";
+export declare const distanceToBindableElement: (element: ExcalidrawBindableElement, p: GlobalPoint) => number;

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

@@ -1,6 +1,6 @@
-import type { ElementsMap, ExcalidrawElement } from "./types";
-export interface Distribution {
-    space: "between";
-    axis: "x" | "y";
-}
-export declare const distributeElements: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, distribution: Distribution) => ExcalidrawElement[];
+import type { ElementsMap, ExcalidrawElement } from "./types";
+export interface Distribution {
+    space: "between";
+    axis: "x" | "y";
+}
+export declare const distributeElements: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, distribution: Distribution) => ExcalidrawElement[];

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

@@ -1,33 +1,33 @@
-import type { AppState, NormalizedZoomValue, NullableGridSize, PointerDownState } from "@excalidraw/excalidraw/types";
-import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
-import type Scene from "./Scene";
-export declare const dragSelectedElements: (pointerDownState: PointerDownState, _selectedElements: NonDeletedExcalidrawElement[], offset: {
-    x: number;
-    y: number;
-}, scene: Scene, snapOffset: {
-    x: number;
-    y: number;
-}, gridSize: NullableGridSize) => void;
-export declare const getDragOffsetXY: (selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
-export declare const dragNewElement: ({ newElement, elementType, originX, originY, x, y, width, height, shouldMaintainAspectRatio, shouldResizeFromCenter, zoom, scene, widthAspectRatio, originOffset, informMutation, }: {
-    newElement: NonDeletedExcalidrawElement;
-    elementType: AppState["activeTool"]["type"];
-    originX: number;
-    originY: number;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    shouldMaintainAspectRatio: boolean;
-    shouldResizeFromCenter: boolean;
-    zoom: NormalizedZoomValue;
-    scene: Scene;
-    /** whether to keep given aspect ratio when `isResizeWithSidesSameLength` is
-        true */
-    widthAspectRatio?: number | null | undefined;
-    originOffset?: {
-        x: number;
-        y: number;
-    } | null | undefined;
-    informMutation?: boolean | undefined;
-}) => void;
+import type { AppState, NormalizedZoomValue, NullableGridSize, PointerDownState } from "@excalidraw/excalidraw/types";
+import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type { Scene } from "./Scene";
+export declare const dragSelectedElements: (pointerDownState: PointerDownState, _selectedElements: NonDeletedExcalidrawElement[], offset: {
+    x: number;
+    y: number;
+}, scene: Scene, snapOffset: {
+    x: number;
+    y: number;
+}, gridSize: NullableGridSize) => void;
+export declare const getDragOffsetXY: (selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
+export declare const dragNewElement: ({ newElement, elementType, originX, originY, x, y, width, height, shouldMaintainAspectRatio, shouldResizeFromCenter, zoom, scene, widthAspectRatio, originOffset, informMutation, }: {
+    newElement: NonDeletedExcalidrawElement;
+    elementType: AppState["activeTool"]["type"];
+    originX: number;
+    originY: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    shouldMaintainAspectRatio: boolean;
+    shouldResizeFromCenter: boolean;
+    zoom: NormalizedZoomValue;
+    scene: Scene;
+    /** whether to keep given aspect ratio when `isResizeWithSidesSameLength` is
+        true */
+    widthAspectRatio?: number | null | undefined;
+    originOffset?: {
+        x: number;
+        y: number;
+    } | null | undefined;
+    informMutation?: boolean | undefined;
+}) => void;

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

@@ -1,63 +1,63 @@
-import type { Mutable } from "@excalidraw/common/utility-types";
-import type { AppState } from "@excalidraw/excalidraw/types";
-import type { ExcalidrawElement, GroupId } from "./types";
-/**
- * Duplicate an element, often used in the alt-drag operation.
- * Note that this method has gotten a bit complicated since the
- * introduction of gruoping/ungrouping elements.
- * @param editingGroupId The current group being edited. The new
- *                       element will inherit this group and its
- *                       parents.
- * @param groupIdMapForOperation A Map that maps old group IDs to
- *                               duplicated ones. If you are duplicating
- *                               multiple elements at once, share this map
- *                               amongst all of them
- * @param element Element to duplicate
- */
-export declare const duplicateElement: <TElement extends ExcalidrawElement>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, randomizeSeed?: boolean) => Readonly<TElement>;
-export declare const duplicateElements: (opts: {
-    elements: readonly ExcalidrawElement[];
-    randomizeSeed?: boolean | undefined;
-    overrides?: ((data: {
-        duplicateElement: ExcalidrawElement;
-        origElement: ExcalidrawElement;
-        origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>;
-    }) => Partial<ExcalidrawElement>) | undefined;
-} & ({
-    /**
-     * Duplicates all elements in array.
-     *
-     * Use this when programmaticaly duplicating elements, without direct
-     * user interaction.
-     */
-    type: "everything";
-} | {
-    /**
-     * Duplicates specified elements and inserts them back into the array
-     * in specified order.
-     *
-     * Use this when duplicating Scene elements, during user interaction
-     * such as alt-drag or on duplicate action.
-     */
-    type: "in-place";
-    idsOfElementsToDuplicate: Map<ExcalidrawElement["id"], ExcalidrawElement>;
-    appState: {
-        editingGroupId: AppState["editingGroupId"];
-        selectedGroupIds: AppState["selectedGroupIds"];
-    };
-})) => {
-    duplicatedElements: ExcalidrawElement[];
-    duplicateElementsMap: Map<string, ExcalidrawElement>;
-    elementsWithDuplicates: ExcalidrawElement[];
-    origIdToDuplicateId: Map<string, string>;
-};
-/**
- * Clones ExcalidrawElement data structure. Does not regenerate id, nonce, or
- * any value. The purpose is to to break object references for immutability
- * reasons, whenever we want to keep the original element, but ensure it's not
- * mutated.
- *
- * Only clones plain objects and arrays. Doesn't clone Date, RegExp, Map, Set,
- * Typed arrays and other non-null objects.
- */
-export declare const deepCopyElement: <T extends ExcalidrawElement>(val: T) => Mutable<T>;
+import type { Mutable } from "@excalidraw/common/utility-types";
+import type { AppState } from "@excalidraw/excalidraw/types";
+import type { ExcalidrawElement, GroupId } from "./types";
+/**
+ * Duplicate an element, often used in the alt-drag operation.
+ * Note that this method has gotten a bit complicated since the
+ * introduction of gruoping/ungrouping elements.
+ * @param editingGroupId The current group being edited. The new
+ *                       element will inherit this group and its
+ *                       parents.
+ * @param groupIdMapForOperation A Map that maps old group IDs to
+ *                               duplicated ones. If you are duplicating
+ *                               multiple elements at once, share this map
+ *                               amongst all of them
+ * @param element Element to duplicate
+ */
+export declare const duplicateElement: <TElement extends ExcalidrawElement>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, randomizeSeed?: boolean) => Readonly<TElement>;
+export declare const duplicateElements: (opts: {
+    elements: readonly ExcalidrawElement[];
+    randomizeSeed?: boolean | undefined;
+    overrides?: ((data: {
+        duplicateElement: ExcalidrawElement;
+        origElement: ExcalidrawElement;
+        origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>;
+    }) => Partial<ExcalidrawElement>) | undefined;
+} & ({
+    /**
+     * Duplicates all elements in array.
+     *
+     * Use this when programmaticaly duplicating elements, without direct
+     * user interaction.
+     */
+    type: "everything";
+} | {
+    /**
+     * Duplicates specified elements and inserts them back into the array
+     * in specified order.
+     *
+     * Use this when duplicating Scene elements, during user interaction
+     * such as alt-drag or on duplicate action.
+     */
+    type: "in-place";
+    idsOfElementsToDuplicate: Map<ExcalidrawElement["id"], ExcalidrawElement>;
+    appState: {
+        editingGroupId: AppState["editingGroupId"];
+        selectedGroupIds: AppState["selectedGroupIds"];
+    };
+})) => {
+    duplicatedElements: ExcalidrawElement[];
+    duplicateElementsMap: Map<string, ExcalidrawElement>;
+    elementsWithDuplicates: ExcalidrawElement[];
+    origIdToDuplicateId: Map<string, string>;
+};
+/**
+ * Clones ExcalidrawElement data structure. Does not regenerate id, nonce, or
+ * any value. The purpose is to to break object references for immutability
+ * reasons, whenever we want to keep the original element, but ensure it's not
+ * mutated.
+ *
+ * Only clones plain objects and arrays. Doesn't clone Date, RegExp, Map, Set,
+ * Typed arrays and other non-null objects.
+ */
+export declare const deepCopyElement: <T extends ExcalidrawElement>(val: T) => Mutable<T>;

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

@@ -1,6 +1,6 @@
-type EasingFunction = (progress: number) => number;
-interface EasingDictionary {
-    [easing: string]: EasingFunction;
-}
-declare const easingsFunctions: EasingDictionary;
-export default easingsFunctions;
+type EasingFunction = (progress: number) => number;
+interface EasingDictionary {
+    [easing: string]: EasingFunction;
+}
+declare const easingsFunctions: EasingDictionary;
+export default easingsFunctions;