@excalidraw/excalidraw 0.18.0-817d8c5 → 0.18.0-8608d7b

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

@@ -0,0 +1,32 @@
+import type { GlobalPoint, LineSegment } from "@excalidraw/math";
+import type { FrameNameBounds } from "@excalidraw/excalidraw/types";
+import type { ElementsMap, ExcalidrawElement } from "./types";
+export declare const shouldTestInside: (element: ExcalidrawElement) => boolean;
+export type HitTestArgs = {
+    point: GlobalPoint;
+    element: ExcalidrawElement;
+    threshold: number;
+    elementsMap: ElementsMap;
+    frameNameBound?: FrameNameBounds | null;
+};
+export declare const hitElementItself: ({ point, element, threshold, elementsMap, frameNameBound, }: HitTestArgs) => boolean;
+export declare const hitElementBoundingBox: (point: GlobalPoint, element: ExcalidrawElement, elementsMap: ElementsMap, tolerance?: number) => boolean;
+export declare const hitElementBoundingBoxOnly: (hitArgs: HitTestArgs, elementsMap: ElementsMap) => boolean;
+export declare const hitElementBoundText: (point: GlobalPoint, element: ExcalidrawElement, elementsMap: ElementsMap) => boolean;
+/**
+ * Intersect a line with an element for binding test
+ *
+ * @param element
+ * @param line
+ * @param offset
+ * @returns
+ */
+export declare const intersectElementWithLineSegment: (element: ExcalidrawElement, elementsMap: ElementsMap, line: LineSegment<GlobalPoint>, offset?: number, onlyFirst?: boolean) => GlobalPoint[];
+/**
+ * Check if the given point is considered inside the element's border
+ *
+ * @param point
+ * @param element
+ * @returns
+ */
+export declare const isPointInElement: (point: GlobalPoint, element: ExcalidrawElement, elementsMap: ElementsMap) => boolean;

package/dist/types/{excalidraw/scene → element/src}/comparisons.d.ts

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

package/dist/types/{excalidraw/element → element/src}/cropElement.d.ts

@@ -1,7 +1,7 @@
 import type { TransformHandleType } from "./transformHandles";
 import type { ElementsMap, ExcalidrawImageElement, ImageCrop } from "./types";
 export declare const MINIMAL_CROP_SIZE = 10;
-export declare const cropElement: (element: ExcalidrawImageElement, transformHandle: TransformHandleType, naturalWidth: number, naturalHeight: number, pointerX: number, pointerY: number, widthAspectRatio?: number) => {
+export declare const cropElement: (element: ExcalidrawImageElement, elementsMap: ElementsMap, transformHandle: TransformHandleType, naturalWidth: number, naturalHeight: number, pointerX: number, pointerY: number, widthAspectRatio?: number) => {
     x: number;
     y: number;
     width: number;

package/dist/types/{excalidraw/change.d.ts → element/src/delta.d.ts}

@@ -1,7 +1,7 @@
-import type { ElementUpdate } from "./element/mutateElement";
-import type { ExcalidrawElement, Ordered, OrderedExcalidrawElement, SceneElementsMap } from "./element/types";
-import type { AppState, ObservedAppState } from "./types";
-import type { ValueOf } from "./utility-types";
+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 { StoreSnapshot } from "./store";
 /**
  * Represents the difference between two objects of the same type.
  *
@@ -11,11 +11,11 @@ import type { ValueOf } from "./utility-types";
  *
  * Keeping it as pure object (without transient state, side-effects, etc.), so we won't have to instantiate it on load.
  */
-declare class Delta<T> {
+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>;
+    static create<T>(deleted: Partial<T>, inserted: Partial<T>, modifier?: (delta: Partial<T>, partialType: "deleted" | "inserted") => Partial<T>, modifierOptions?: "deleted" | "inserted" | "both"): Delta<T>;
     /**
      * Calculates the delta between two objects.
      *
@@ -29,12 +29,16 @@ declare class Delta<T> {
     }>(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 two deltas into a new one.
+     */
+    static merge<T>(delta1: Delta<T>, delta2: Delta<T>, delta3?: Delta<T>): Delta<T>;
     /**
      * Merges deleted and inserted object partials.
      */
     static mergeObjects<T extends {
         [key: string]: unknown;
-    }>(prev: T, added: T, removed: T): T;
+    }>(prev: T, added: T, removed?: T): T;
     /**
      * Merges deleted and inserted array partials.
      */
@@ -56,13 +60,29 @@ declare class Delta<T> {
      */
     static isRightDifferent<T extends {}>(object1: T, object2: T, skipShallowCompare?: boolean): boolean;
     /**
-     * Returns all the object1 keys that have distinct values.
+     * Compares if shared properties of object1 and object2 contain any different value (aka inner join).
+     */
+    static isInnerDifferent<T extends {}>(object1: T, object2: T, skipShallowCompare?: boolean): boolean;
+    /**
+     * Compares if any properties of object1 and object2 contain any different value (aka full join).
+     */
+    static isDifferent<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 all the object2 keys that have distinct values.
+     * Returns sorted object2 keys that have distinct values.
      */
     static getRightDifferences<T extends {}>(object1: T, object2: T, skipShallowCompare?: boolean): string[];
+    /**
+     * Returns sorted keys of shared object1 and object2 properties that have distinct values (aka inner join).
+     */
+    static getInnerDifferences<T extends {}>(object1: T, object2: T, skipShallowCompare?: boolean): string[];
+    /**
+     * Returns sorted keys that have distinct values between object1 and object2 (aka full join).
+     */
+    static getDifferences<T extends {}>(object1: T, object2: T, skipShallowCompare?: boolean): string[];
     /**
      * Iterator comparing values of object properties based on the passed joining strategy.
      *
@@ -73,65 +93,78 @@ declare class Delta<T> {
     private static distinctKeysIterator;
 }
 /**
- * Encapsulates the modifications captured as `Delta`/s.
+ * Encapsulates a set of application-level `Delta`s.
  */
-interface Change<T> {
+export interface DeltaContainer<T> {
     /**
-     * Inverses the `Delta`s inside while creating a new `Change`.
+     * Inverses the `Delta`s while creating a new `DeltaContainer` instance.
      */
-    inverse(): Change<T>;
+    inverse(): DeltaContainer<T>;
     /**
-     * Applies the `Change` to the previous object.
+     * Applies the `Delta`s to the previous object.
      *
-     * @returns a tuple of the next object `T` with applied change, and `boolean`, indicating whether the applied change resulted in a visible change.
+     * @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 there are actually `Delta`s.
+     * Squashes the current delta with the given one.
+     */
+    squash(delta: DeltaContainer<T>): this;
+    /**
+     * Checks whether all `Delta`s are empty.
      */
     isEmpty(): boolean;
 }
-export declare class AppStateChange implements Change<AppState> {
-    private readonly delta;
+export declare class AppStateDelta implements DeltaContainer<AppState> {
+    delta: Delta<ObservedAppState>;
     private constructor();
-    static calculate<T extends ObservedAppState>(prevAppState: T, nextAppState: T): AppStateChange;
-    static empty(): AppStateChange;
-    inverse(): AppStateChange;
+    static create(delta: Delta<ObservedAppState>): AppStateDelta;
+    static calculate<T extends ObservedAppState>(prevAppState: T, nextAppState: T): AppStateDelta;
+    static restore(appStateDeltaDTO: DTO<AppStateDelta>): AppStateDelta;
+    static empty(): AppStateDelta;
+    inverse(): AppStateDelta;
+    squash(delta: AppStateDelta): this;
     applyTo(appState: AppState, nextElements: SceneElementsMap): [AppState, boolean];
     isEmpty(): boolean;
-    /**
-     * 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;
     /**
      * 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">;
+type ElementPartial<TElement extends ExcalidrawElement = ExcalidrawElement> = Omit<Partial<Ordered<TElement>>, "id" | "updated" | "seed">;
+export type ApplyToOptions = {
+    excludedProperties?: Set<keyof ElementPartial>;
+};
 /**
  * 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 ElementsChange implements Change<SceneElementsMap> {
-    private readonly added;
-    private readonly removed;
-    private readonly updated;
+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: Map<string, Delta<ElementPartial>>, removed: Map<string, Delta<ElementPartial>>, updated: Map<string, Delta<ElementPartial>>, options?: {
+    static create(added: Record<string, Delta<ElementPartial>>, removed: Record<string, Delta<ElementPartial>>, updated: Record<string, Delta<ElementPartial>>, options?: {
         shouldRedistribute: boolean;
-    }): ElementsChange;
+    }): ElementsDelta;
+    static restore(elementsDeltaDTO: DTO<ElementsDelta>): ElementsDelta;
     private static satisfiesAddition;
     private static satisfiesRemoval;
     private static satisfiesUpdate;
+    private static satisfiesCommmonInvariants;
+    private static satisfiesUniqueInvariants;
     private static validate;
     /**
      * Calculates the `Delta`s between the previous and next set of elements.
@@ -139,21 +172,22 @@ export declare class ElementsChange implements Change<SceneElementsMap> {
      * @param prevElements - Map representing the previous state of elements.
      * @param nextElements - Map representing the next state of elements.
      *
-     * @returns `ElementsChange` instance representing the `Delta` changes between the two sets 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>): ElementsChange;
-    static empty(): ElementsChange;
-    inverse(): ElementsChange;
+    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 nextElements 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): ElementsChange;
-    applyTo(elements: SceneElementsMap, snapshot: Map<string, OrderedExcalidrawElement>): [SceneElementsMap, boolean];
+    applyLatestChanges(prevElements: SceneElementsMap, nextElements: SceneElementsMap, modifierOptions?: "deleted" | "inserted"): ElementsDelta;
+    applyTo(elements: SceneElementsMap, snapshot?: StoreSnapshot["elements"], options?: ApplyToOptions): [SceneElementsMap, boolean];
+    squash(delta: ElementsDelta): this;
     private static createApplier;
     private static createGetter;
     private static applyDelta;
@@ -165,6 +199,8 @@ export declare class ElementsChange implements Change<SceneElementsMap> {
      * 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;
@@ -178,6 +214,7 @@ export declare class ElementsChange implements Change<SceneElementsMap> {
      * should be rebound (if possible) with the current element ~ bindings should be bidirectional.
      */
     private static rebindAffected;
+    static redrawElements(nextElements: SceneElementsMap, changedElements: Map<string, OrderedExcalidrawElement>): SceneElementsMap;
     private static redrawTextBoundingBoxes;
     private static redrawBoundArrows;
     private static reorderElements;

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

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

package/dist/types/{excalidraw → element/src}/distribute.d.ts

@@ -1,6 +1,7 @@
-import type { ElementsMap, ExcalidrawElement } from "./element/types";
+import type { AppState } from "@excalidraw/excalidraw/types";
+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[];
+export declare const distributeElements: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, distribution: Distribution, appState: Readonly<AppState>) => ExcalidrawElement[];

package/dist/types/{excalidraw/element → element/src}/dragElements.d.ts

@@ -1,6 +1,6 @@
-import type { NonDeletedExcalidrawElement } from "./types";
-import type { AppState, NormalizedZoomValue, NullableGridSize, PointerDownState } from "../types";
-import type Scene from "../scene/Scene";
+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;
@@ -9,7 +9,7 @@ export declare const dragSelectedElements: (pointerDownState: PointerDownState,
     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, widthAspectRatio, originOffset, informMutation, }: {
+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;
@@ -21,6 +21,7 @@ export declare const dragNewElement: ({ newElement, elementType, originX, origin
     shouldMaintainAspectRatio: boolean;
     shouldResizeFromCenter: boolean;
     zoom: NormalizedZoomValue;
+    scene: Scene;
     /** whether to keep given aspect ratio when `isResizeWithSidesSameLength` is
         true */
     widthAspectRatio?: number | null | undefined;

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

@@ -0,0 +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>;

package/dist/types/{excalidraw/element → element/src}/elbowArrow.d.ts

@@ -8,7 +8,7 @@ export declare const BASE_PADDING = 40;
  */
 export declare const updateElbowArrowPoints: (arrow: Readonly<ExcalidrawElbowArrowElement>, elementsMap: NonDeletedSceneElementsMap, updates: {
     points?: readonly LocalPoint[];
-    fixedSegments?: FixedSegment[] | null;
+    fixedSegments?: readonly FixedSegment[] | null;
     startBinding?: FixedPointBinding | null;
     endBinding?: FixedPointBinding | null;
 }, options?: {

package/dist/types/{excalidraw/element → element/src}/elementLink.d.ts

@@ -1,7 +1,7 @@
 /**
  * Create and link between shapes.
  */
-import type { AppProps, AppState } from "../types";
+import type { AppProps, AppState } from "@excalidraw/excalidraw/types";
 import type { ExcalidrawElement } from "./types";
 export declare const defaultGetElementLinkFromSelection: Exclude<AppProps["generateLinkForSelection"], undefined>;
 export declare const getLinkIdAndTypeFromSelection: (selectedElements: ExcalidrawElement[], appState: AppState) => {

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

@@ -0,0 +1,10 @@
+import type { ExcalidrawProps } from "@excalidraw/excalidraw/types";
+import type { MarkRequired } from "@excalidraw/common/utility-types";
+import type { ExcalidrawElement, ExcalidrawIframeLikeElement, IframeData } from "./types";
+type IframeDataWithSandbox = MarkRequired<IframeData, "sandbox">;
+export declare const createSrcDoc: (body: string) => string;
+export declare const getEmbedLink: (link: string | null | undefined) => IframeDataWithSandbox | null;
+export declare const createPlaceholderEmbeddableLabel: (element: ExcalidrawIframeLikeElement) => ExcalidrawElement;
+export declare const maybeParseEmbedSrc: (str: string) => string;
+export declare const embeddableURLValidator: (url: string | null | undefined, validateEmbeddable: ExcalidrawProps["validateEmbeddable"]) => boolean;
+export {};

package/dist/types/{excalidraw/element → element/src}/flowchart.d.ts

@@ -1,9 +1,10 @@
+import type { AppState, PendingExcalidrawElements } from "@excalidraw/excalidraw/types";
 import { type ElementsMap, type ExcalidrawBindableElement, type ExcalidrawElement, type ExcalidrawFlowchartNodeElement } from "./types";
-import type { AppState, PendingExcalidrawElements } from "../types";
+import type { Scene } from "./Scene";
 type LinkDirection = "up" | "right" | "down" | "left";
 export declare const getLinkDirectionFromKey: (key: string) => LinkDirection;
 export declare const getPredecessors: (node: ExcalidrawBindableElement, elementsMap: ElementsMap, direction: LinkDirection) => ExcalidrawBindableElement[];
-export declare const addNewNodes: (startNode: ExcalidrawFlowchartNodeElement, elementsMap: ElementsMap, appState: AppState, direction: LinkDirection, numberOfNodes: number) => ExcalidrawElement[];
+export declare const addNewNodes: (startNode: ExcalidrawFlowchartNodeElement, appState: AppState, direction: LinkDirection, scene: Scene, numberOfNodes: number) => ExcalidrawElement[];
 export declare class FlowChartNavigator {
     isExploring: boolean;
     private sameLevelNodes;
@@ -18,7 +19,7 @@ export declare class FlowChartCreator {
     private numberOfNodes;
     private direction;
     pendingNodes: PendingExcalidrawElements | null;
-    createNodes(startNode: ExcalidrawFlowchartNodeElement, elementsMap: ElementsMap, appState: AppState, direction: LinkDirection): void;
+    createNodes(startNode: ExcalidrawFlowchartNodeElement, appState: AppState, direction: LinkDirection, scene: Scene): void;
     clear(): void;
 }
 export declare const isNodeInFlowchart: (element: ExcalidrawFlowchartNodeElement, elementsMap: ElementsMap) => boolean;

package/dist/types/{excalidraw → element/src}/fractionalIndex.d.ts

@@ -1,4 +1,7 @@
-import type { ExcalidrawElement, OrderedExcalidrawElement } from "./element/types";
+import type { ElementsMap, ExcalidrawElement, OrderedExcalidrawElement, SceneElementsMap } from "./types";
+export declare class InvalidFractionalIndexError extends Error {
+    code: "ELEMENT_HAS_INVALID_INDEX";
+}
 /**
  * Envisioned relation between array order and fractional indices:
  *
@@ -39,10 +42,16 @@ export declare const orderByFractionalIndex: (elements: 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[];
+export declare const syncMovedIndices: (elements: readonly ExcalidrawElement[], movedElements: ElementsMap) => OrderedExcalidrawElement[];
 /**
- * Synchronizes all invalid fractional indices with the array order by mutating passed elements.
+ * Synchronizes all invalid fractional indices within the array order by mutating elements in the passed array.
  *
  * 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[];
+/**
+ * Synchronizes all invalid fractional indices within the array order by creating new instances of elements with corrected indices.
+ *
+ * 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 syncInvalidIndicesImmutable: (elements: readonly ExcalidrawElement[]) => SceneElementsMap | undefined;

package/dist/types/{excalidraw → element/src}/frame.d.ts

@@ -1,8 +1,8 @@
-import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "./element/types";
-import type { AppClassProperties, AppState, StaticCanvasAppState } from "./types";
-import type { ExcalidrawElementsIncludingDeleted } from "./scene/Scene";
-import type { ReadonlySetLike } from "./utility-types";
-export declare const bindElementsToFramesAfterDuplication: (nextElements: readonly ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+import type { AppClassProperties, AppState, StaticCanvasAppState } from "@excalidraw/excalidraw/types";
+import type { ReadonlySetLike } from "@excalidraw/common/utility-types";
+import type { ExcalidrawElementsIncludingDeleted } from "./Scene";
+import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "./types";
+export declare const bindElementsToFramesAfterDuplication: (nextElements: readonly ExcalidrawElement[], origElements: readonly ExcalidrawElement[], origIdToDuplicateId: 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: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
@@ -31,8 +31,8 @@ export declare const getFrameLikeElements: (allElements: ExcalidrawElementsInclu
  */
 export declare const getRootElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawElement[];
 export declare const getElementsInResizingFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, appState: AppState, elementsMap: ElementsMap) => ExcalidrawElement[];
-export declare const getElementsInNewFrame: (elements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => (import("./element/types").ExcalidrawSelectionElement | import("./element/types").ExcalidrawRectangleElement | import("./element/types").ExcalidrawDiamondElement | import("./element/types").ExcalidrawEllipseElement | import("./element/types").ExcalidrawTextElement | import("./element/types").ExcalidrawLinearElement | import("./element/types").ExcalidrawFreeDrawElement | import("./element/types").ExcalidrawImageElement | import("./element/types").ExcalidrawFrameElement | import("./element/types").ExcalidrawMagicFrameElement | import("./element/types").ExcalidrawIframeElement | import("./element/types").ExcalidrawEmbeddableElement)[];
-export declare const omitPartialGroups: (elements: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, allElementsMap: ElementsMap) => (import("./element/types").ExcalidrawSelectionElement | import("./element/types").ExcalidrawRectangleElement | import("./element/types").ExcalidrawDiamondElement | import("./element/types").ExcalidrawEllipseElement | import("./element/types").ExcalidrawTextElement | import("./element/types").ExcalidrawLinearElement | import("./element/types").ExcalidrawFreeDrawElement | import("./element/types").ExcalidrawImageElement | import("./element/types").ExcalidrawFrameElement | import("./element/types").ExcalidrawMagicFrameElement | import("./element/types").ExcalidrawIframeElement | import("./element/types").ExcalidrawEmbeddableElement)[];
+export declare const getElementsInNewFrame: (elements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => (import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawSelectionElement | import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawEmbeddableElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawTextElement | import("./types").ExcalidrawFreeDrawElement)[];
+export declare const omitPartialGroups: (elements: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, allElementsMap: ElementsMap) => (import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawSelectionElement | import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawEmbeddableElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawTextElement | import("./types").ExcalidrawFreeDrawElement)[];
 export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap: ElementsMap) => ExcalidrawFrameLikeElement | null;
 /** */
 export declare const filterElementsEligibleAsFrameChildren: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
@@ -64,6 +64,7 @@ export declare const isElementInFrame: (element: ExcalidrawElement, allElementsM
     checkedGroups?: Map<string, boolean>;
 }) => boolean;
 export declare const shouldApplyFrameClip: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, appState: StaticCanvasAppState, elementsMap: ElementsMap, checkedGroups?: Map<string, boolean>) => boolean;
+export declare const getDefaultFrameName: (element: ExcalidrawFrameLikeElement) => "Frame" | "AI Frame";
 export declare const getFrameLikeTitle: (element: ExcalidrawFrameLikeElement) => string;
 export declare const getElementsOverlappingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => NonDeletedExcalidrawElement[];
 export declare const frameAndChildrenSelectedTogether: (selectedElements: readonly ExcalidrawElement[]) => boolean;

package/dist/types/{excalidraw → element/src}/groups.d.ts

@@ -1,6 +1,6 @@
-import type { GroupId, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ElementsMapOrArray, ElementsMap } from "./element/types";
-import type { AppClassProperties, AppState, InteractiveCanvasAppState } from "./types";
-import type { Mutable } from "./utility-types";
+import type { AppClassProperties, AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
+import type { Mutable } from "@excalidraw/common/utility-types";
+import type { GroupId, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ElementsMapOrArray, ElementsMap } from "./types";
 export declare const selectGroup: (groupId: GroupId, appState: InteractiveCanvasAppState, elements: readonly NonDeleted<ExcalidrawElement>[]) => Pick<InteractiveCanvasAppState, "selectedGroupIds" | "selectedElementIds" | "editingGroupId">;
 export declare const selectGroupsForSelectedElements: {
     (appState: Pick<AppState, "selectedElementIds" | "editingGroupId">, elements: readonly NonDeletedExcalidrawElement[], prevAppState: InteractiveCanvasAppState, app: AppClassProperties | null): Mutable<Pick<InteractiveCanvasAppState, "selectedGroupIds" | "editingGroupId" | "selectedElementIds">>;
@@ -11,7 +11,7 @@ export declare const selectGroupsForSelectedElements: {
  * selection border around it.
  */
 export declare const isSelectedViaGroup: (appState: InteractiveCanvasAppState, element: ExcalidrawElement) => boolean;
-export declare const getSelectedGroupForElement: (appState: InteractiveCanvasAppState, element: ExcalidrawElement) => string | undefined;
+export declare const getSelectedGroupForElement: (appState: Pick<InteractiveCanvasAppState, "editingGroupId" | "selectedGroupIds">, element: ExcalidrawElement) => string | undefined;
 export declare const getSelectedGroupIds: (appState: InteractiveCanvasAppState) => GroupId[];
 export declare const selectGroupsFromGivenElements: (elements: readonly NonDeleted<ExcalidrawElement>[], appState: InteractiveCanvasAppState) => {
     [groupId: string]: boolean;
@@ -22,7 +22,6 @@ export declare const getElementsInGroup: (elements: ElementsMapOrArray, groupId:
 export declare const getSelectedGroupIdForElement: (element: ExcalidrawElement, selectedGroupIds: {
     [groupId: string]: boolean;
 }) => string | undefined;
-export declare const getNewGroupIdsForDuplication: (groupIds: ExcalidrawElement["groupIds"], editingGroupId: AppState["editingGroupId"], mapper: (groupId: GroupId) => GroupId) => string[];
 export declare const addToGroup: (prevGroupIds: ExcalidrawElement["groupIds"], newGroupId: GroupId, editingGroupId: AppState["editingGroupId"]) => string[];
 export declare const removeFromSelectedGroups: (groupIds: ExcalidrawElement["groupIds"], selectedGroupIds: {
     [groupId: string]: boolean;
@@ -31,3 +30,5 @@ export declare const getMaximumGroups: (elements: ExcalidrawElement[], elementsM
 export declare const getNonDeletedGroupIds: (elements: ElementsMap) => Set<string>;
 export declare const elementsAreInSameGroup: (elements: readonly ExcalidrawElement[]) => boolean;
 export declare const isInGroup: (element: NonDeletedExcalidrawElement) => boolean;
+export declare const getNewGroupIdsForDuplication: (groupIds: ExcalidrawElement["groupIds"], editingGroupId: AppState["editingGroupId"], mapper: (groupId: GroupId) => GroupId) => string[];
+export declare const getSelectedElementsByGroup: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, appState: Readonly<AppState>) => ExcalidrawElement[][];

package/dist/types/{excalidraw/element → element/src}/heading.d.ts

@@ -5,12 +5,11 @@ export declare const HEADING_DOWN: Heading;
 export declare const HEADING_LEFT: Heading;
 export declare const HEADING_UP: Heading;
 export type Heading = [1, 0] | [0, 1] | [-1, 0] | [0, -1];
-export declare const headingForDiamond: <Point extends GlobalPoint | LocalPoint>(a: Point, b: Point) => Heading;
 export declare const vectorToHeading: (vec: Vector) => Heading;
 export declare const headingForPoint: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => Heading;
 export declare const headingForPointIsHorizontal: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => boolean;
 export declare const compareHeading: (a: Heading, b: Heading) => boolean;
 export declare const headingIsHorizontal: (a: Heading) => boolean;
 export declare const headingIsVertical: (a: Heading) => boolean;
-export declare const headingForPointFromElement: <Point extends GlobalPoint | LocalPoint>(element: Readonly<ExcalidrawBindableElement>, aabb: readonly [minX: number, minY: number, maxX: number, maxY: number], p: Readonly<Point>) => Heading;
+export declare const headingForPointFromElement: <Point extends GlobalPoint>(element: Readonly<ExcalidrawBindableElement>, aabb: readonly [minX: number, minY: number, maxX: number, maxY: number], p: Readonly<Point>) => Heading;
 export declare const flipHeading: (h: Heading) => Heading;

package/dist/types/{excalidraw/element → element/src}/image.d.ts

@@ -1,4 +1,4 @@
-import type { AppClassProperties, DataURL, BinaryFiles } from "../types";
+import type { AppClassProperties, DataURL, BinaryFiles } from "@excalidraw/excalidraw/types";
 import type { ExcalidrawElement, FileId, InitializedExcalidrawImageElement } from "./types";
 export declare const loadHTMLImageElement: (dataURL: DataURL) => Promise<HTMLImageElement>;
 /** NOTE: updates cache even if already populated with given image. Thus,
@@ -10,7 +10,7 @@ export declare const updateImageCache: ({ fileIds, files, imageCache, }: {
 }) => Promise<{
     imageCache: Map<FileId, {
         image: HTMLImageElement | Promise<HTMLImageElement>;
-        mimeType: import("../utility-types").ValueOf<{
+        mimeType: import("../../common/src/utility-types").ValueOf<{
             readonly svg: "image/svg+xml";
             readonly png: "image/png";
             readonly jpg: "image/jpeg";