@wildmio/excalidraw 0.18.0-custom-1

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

@@ -0,0 +1,8 @@
+import type { AppState } from "@excalidraw/excalidraw/types";
+import type { Scene } from "./Scene";
+import type { ExcalidrawElement } from "./types";
+export interface Alignment {
+    position: "start" | "center" | "end";
+    axis: "x" | "y";
+}
+export declare const alignElements: (selectedElements: ExcalidrawElement[], alignment: Alignment, scene: Scene, appState: Readonly<AppState>) => ExcalidrawElement[];

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

@@ -0,0 +1,124 @@
+import { type GlobalPoint } from "@excalidraw/math";
+import type { LineSegment, LocalPoint } from "@excalidraw/math";
+import type { AppState } from "@excalidraw/excalidraw/types";
+import type { Bounds } from "@excalidraw/common";
+import { type Heading } from "./heading";
+import type { Scene } from "./Scene";
+import type { ElementUpdate } from "./mutateElement";
+import type { BindMode, ElementsMap, ExcalidrawArrowElement, ExcalidrawBindableElement, ExcalidrawElbowArrowElement, ExcalidrawElement, FixedPoint, FixedPointBinding, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, Ordered, PointsPositionUpdates } from "./types";
+export type BindingStrategy = {
+    mode: BindMode;
+    element: NonDeleted<ExcalidrawBindableElement>;
+    focusPoint: GlobalPoint;
+} | {
+    mode: null;
+    element?: undefined;
+    focusPoint?: undefined;
+} | {
+    mode: undefined;
+    element?: undefined;
+    focusPoint?: undefined;
+};
+/**
+ * gaps exclude element strokeWidth
+ *
+ * IMPORTANT: currently must be > 0 (this also applies to the computed gap)
+ */
+export declare const BASE_BINDING_GAP = 10;
+export declare const BASE_BINDING_GAP_ELBOW = 5;
+export declare const getBindingGap: (bindTarget: ExcalidrawBindableElement, opts: Pick<ExcalidrawArrowElement, "elbowed">) => number;
+export declare const maxBindingDistance_simple: (zoom?: AppState["zoom"]) => number;
+export declare const shouldEnableBindingForPointerEvent: (event: React.PointerEvent<HTMLElement>) => boolean;
+export declare const isBindingEnabled: (appState: AppState) => boolean;
+export declare const bindOrUnbindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, scenePointerX: number, scenePointerY: number, scene: Scene, appState: AppState, opts?: {
+    newArrow?: boolean;
+    altKey?: boolean;
+    angleLocked?: boolean;
+    initialBinding?: boolean;
+}) => {
+    start: BindingStrategy;
+    end: BindingStrategy;
+};
+export declare const getBindingStrategyForDraggingBindingElementEndpoints: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, screenPointerX: number, screenPointerY: number, elementsMap: NonDeletedSceneElementsMap, elements: readonly Ordered<NonDeletedExcalidrawElement>[], appState: AppState, opts?: {
+    newArrow?: boolean;
+    angleLocked?: boolean;
+    altKey?: boolean;
+    finalize?: boolean;
+    initialBinding?: boolean;
+    zoom?: AppState["zoom"];
+}) => {
+    start: BindingStrategy;
+    end: BindingStrategy;
+};
+export declare const bindOrUnbindBindingElements: (selectedArrows: NonDeleted<ExcalidrawArrowElement>[], scene: Scene, appState: AppState) => void;
+export declare const bindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, hoveredElement: ExcalidrawBindableElement, mode: BindMode, startOrEnd: "start" | "end", scene: Scene, focusPoint?: GlobalPoint) => void;
+export declare const unbindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, startOrEnd: "start" | "end", scene: Scene) => ExcalidrawBindableElement["id"] | null;
+export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, scene: Scene, options?: {
+    simultaneouslyUpdated?: readonly ExcalidrawElement[];
+    changedElements?: Map<string, ExcalidrawElement>;
+}) => void;
+export declare const updateBindings: (latestElement: ExcalidrawElement, scene: Scene, appState: AppState, options?: {
+    simultaneouslyUpdated?: readonly ExcalidrawElement[];
+    newSize?: {
+        width: number;
+        height: number;
+    };
+}) => void;
+export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, origPoint: GlobalPoint, elementsMap: ElementsMap, zoom?: AppState["zoom"]) => Heading;
+export declare const bindPointToSnapToElementOutline: (arrowElement: ExcalidrawArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, customIntersector?: LineSegment<GlobalPoint>) => GlobalPoint;
+export declare const avoidRectangularCorner: (arrowElement: ExcalidrawArrowElement, bindTarget: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint) => GlobalPoint;
+export declare const updateBoundPoint: (arrow: NonDeleted<ExcalidrawArrowElement>, startOrEnd: "startBinding" | "endBinding", binding: FixedPointBinding | null | undefined, bindableElement: ExcalidrawBindableElement, elementsMap: ElementsMap, customIntersector?: LineSegment<GlobalPoint>) => LocalPoint | null;
+export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => {
+    fixedPoint: FixedPoint;
+};
+export declare const calculateFixedPointForNonElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, focusPoint?: GlobalPoint) => {
+    fixedPoint: FixedPoint;
+};
+export declare const fixDuplicatedBindingsAfterDuplication: (duplicatedElements: ExcalidrawElement[], origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicateElementsMap: NonDeletedSceneElementsMap) => void;
+export declare const fixBindingsAfterDeletion: (sceneElements: readonly ExcalidrawElement[], deletedElements: readonly ExcalidrawElement[]) => void;
+export declare const bindingProperties: Set<BindableProp | BindingProp>;
+export type BindableProp = "boundElements";
+export type BindingProp = "frameId" | "containerId" | "startBinding" | "endBinding";
+/**
+ * Bound element containing bindings to `frameId`, `containerId`, `startBinding` or `endBinding`.
+ */
+export declare class BoundElement {
+    /**
+     * Unbind the affected non deleted bindable elements (removing element from `boundElements`).
+     * - iterates non deleted bindable elements (`containerId` | `startBinding.elementId` | `endBinding.elementId`) of the current element
+     * - prepares updates to unbind each bindable element's `boundElements` from the current element
+     */
+    static unbindAffected(elements: ElementsMap, boundElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void): void;
+    /**
+     * Rebind the next affected non deleted bindable elements (adding element to `boundElements`).
+     * - iterates non deleted bindable elements (`containerId` | `startBinding.elementId` | `endBinding.elementId`) of the current element
+     * - prepares updates to rebind each bindable element's `boundElements` to the current element
+     *
+     * NOTE: rebind expects that affected elements were previously unbound with `BoundElement.unbindAffected`
+     */
+    static rebindAffected: (elements: ElementsMap, boundElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void) => void;
+}
+/**
+ * Bindable element containing bindings to `boundElements`.
+ */
+export declare class BindableElement {
+    /**
+     * Unbind the affected non deleted bound elements (resetting `containerId`, `startBinding`, `endBinding` to `null`).
+     * - iterates through non deleted `boundElements` of the current element
+     * - prepares updates to unbind each bound element from the current element
+     */
+    static unbindAffected(elements: ElementsMap, bindableElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void): void;
+    /**
+     * Rebind the affected non deleted bound elements (for now setting only `containerId`, as we cannot rebind arrows atm).
+     * - iterates through non deleted `boundElements` of the current element
+     * - prepares updates to rebind each bound element to the current element or unbind it from `boundElements` in case of conflicts
+     *
+     * NOTE: rebind expects that affected elements were previously unbound with `BindaleElement.unbindAffected`
+     */
+    static rebindAffected: (elements: ElementsMap, bindableElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void) => void;
+}
+export declare const getGlobalFixedPointForBindableElement: (fixedPointRatio: FixedPoint, element: ExcalidrawBindableElement, elementsMap: ElementsMap) => GlobalPoint;
+export declare const getGlobalFixedPoints: (arrow: ExcalidrawArrowElement, elementsMap: ElementsMap) => [GlobalPoint, GlobalPoint];
+export declare const getArrowLocalFixedPoints: (arrow: ExcalidrawElbowArrowElement, elementsMap: ElementsMap) => LocalPoint[];
+export declare const normalizeFixedPoint: <T extends FixedPoint | null>(fixedPoint: T) => T extends null ? null : FixedPoint;
+export declare const getBindingSideMidPoint: (binding: FixedPointBinding, elementsMap: ElementsMap) => GlobalPoint | LocalPoint | null;

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

@@ -0,0 +1,81 @@
+import { type Bounds } from "@excalidraw/common";
+import type { Degrees, GlobalPoint, LineSegment, LocalPoint } from "@excalidraw/math";
+import type { AppState } from "@excalidraw/excalidraw/types";
+import type { Drawable, Op } from "roughjs/bin/core";
+import type { Arrowhead, ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawLinearElement, NonDeleted } from "./types";
+export type RectangleBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    angle: number;
+};
+export type SceneBounds = readonly [
+    sceneX: number,
+    sceneY: number,
+    sceneX2: number,
+    sceneY2: number
+];
+export declare class ElementBounds {
+    private static boundsCache;
+    private static nonRotatedBoundsCache;
+    static getBounds(element: ExcalidrawElement, elementsMap: ElementsMap, nonRotated?: boolean): Bounds;
+    private static calculateBounds;
+}
+export declare const getElementAbsoluteCoords: (element: ExcalidrawElement, elementsMap: ElementsMap, includeBoundText?: boolean) => [number, number, number, number, number, number];
+/**
+ * Given an element, return the line segments that make up the element.
+ *
+ * Uses helpers from /math
+ */
+export declare const getElementLineSegments: (element: ExcalidrawElement, elementsMap: ElementsMap) => LineSegment<GlobalPoint>[];
+/**
+ * Scene -> Scene coords, but in x1,x2,y1,y2 format.
+ *
+ * Rectangle here means any rectangular frame, not an excalidraw element.
+ */
+export declare const getRectangleBoxAbsoluteCoords: (boxSceneCoords: RectangleBox) => number[];
+export declare const getDiamondPoints: (element: ExcalidrawElement) => number[];
+export declare const getCubicBezierCurveBound: (p0: GlobalPoint, p1: GlobalPoint, p2: GlobalPoint, p3: GlobalPoint) => Bounds;
+export declare const getMinMaxXYFromCurvePathOps: (ops: Op[], transformXY?: (p: GlobalPoint) => GlobalPoint) => Bounds;
+export declare const getBoundsFromPoints: (points: ExcalidrawFreeDrawElement["points"]) => Bounds;
+/** @returns number in pixels */
+export declare const getArrowheadSize: (arrowhead: Arrowhead) => number;
+/** @returns number in degrees */
+export declare const getArrowheadAngle: (arrowhead: Arrowhead) => Degrees;
+export declare const getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead) => number[] | null;
+export declare const getElementBounds: (element: ExcalidrawElement, elementsMap: ElementsMap, nonRotated?: boolean) => Bounds;
+export declare const getCommonBounds: (elements: ElementsMapOrArray, elementsMap?: ElementsMap) => Bounds;
+export declare const getDraggedElementsBounds: (elements: ExcalidrawElement[], dragOffset: {
+    x: number;
+    y: number;
+}) => number[];
+export declare const getResizedElementAbsoluteCoords: (element: ExcalidrawElement, nextWidth: number, nextHeight: number, normalizePoints: boolean) => Bounds;
+export declare const getElementPointsCoords: (element: ExcalidrawLinearElement, points: readonly (readonly [number, number])[]) => Bounds;
+export declare const getClosestElementBounds: (elements: readonly ExcalidrawElement[], from: {
+    x: number;
+    y: number;
+}) => Bounds;
+export interface BoundingBox {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    midX: number;
+    midY: number;
+    width: number;
+    height: number;
+}
+export declare const getCommonBoundingBox: (elements: readonly ExcalidrawElement[] | readonly NonDeleted<ExcalidrawElement>[]) => BoundingBox;
+/**
+ * returns scene coords of user's editor viewport (visible canvas area) bounds
+ */
+export declare const getVisibleSceneBounds: ({ scrollX, scrollY, width, height, zoom, }: AppState) => SceneBounds;
+export declare const getCenterForBounds: (bounds: Bounds) => GlobalPoint;
+/**
+ * Get the axis-aligned bounding box for a given element
+ */
+export declare const aabbForElement: (element: Readonly<ExcalidrawElement>, elementsMap: ElementsMap, offset?: [number, number, number, number]) => Bounds;
+export declare const pointInsideBounds: <P extends GlobalPoint | LocalPoint>(p: P, bounds: Bounds) => boolean;
+export declare const doBoundsIntersect: (bounds1: Bounds | null, bounds2: Bounds | null) => boolean;
+export declare const elementCenterPoint: (element: ExcalidrawElement, elementsMap: ElementsMap, xOffset?: number, yOffset?: number) => GlobalPoint;

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

@@ -0,0 +1,36 @@
+import type { GlobalPoint, LineSegment } from "@excalidraw/math";
+import type { FrameNameBounds } from "@excalidraw/excalidraw/types";
+import type { ElementsMap, ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, Ordered } from "./types";
+export declare const shouldTestInside: (element: ExcalidrawElement) => boolean;
+export type HitTestArgs = {
+    point: GlobalPoint;
+    element: ExcalidrawElement;
+    threshold: number;
+    elementsMap: ElementsMap;
+    frameNameBound?: FrameNameBounds | null;
+    overrideShouldTestInside?: boolean;
+};
+export declare const hitElementItself: ({ point, element, threshold, elementsMap, frameNameBound, overrideShouldTestInside, }: 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;
+export declare const getAllHoveredElementAtPoint: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, toleranceFn?: (element: ExcalidrawBindableElement) => number) => NonDeleted<ExcalidrawBindableElement>[];
+export declare const getHoveredElementForBinding: (point: Readonly<GlobalPoint>, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, toleranceFn?: (element: ExcalidrawBindableElement) => number) => NonDeleted<ExcalidrawBindableElement> | null;
+/**
+ * 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;
+export declare const isBindableElementInsideOtherBindable: (innerElement: ExcalidrawBindableElement, outerElement: ExcalidrawBindableElement, elementsMap: ElementsMap) => boolean;

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

@@ -0,0 +1,8 @@
+import type { ElementOrToolType } from "@excalidraw/excalidraw/types";
+export declare const hasBackground: (type: ElementOrToolType) => type is "line" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "iframe" | "freedraw";
+export declare const hasStrokeColor: (type: ElementOrToolType) => type is "line" | "arrow" | "text" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "freedraw";
+export declare const hasStrokeWidth: (type: ElementOrToolType) => type is "line" | "arrow" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "iframe" | "freedraw";
+export declare const hasStrokeStyle: (type: ElementOrToolType) => type is "line" | "arrow" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "iframe";
+export declare const canChangeRoundness: (type: ElementOrToolType) => type is "line" | "rectangle" | "diamond" | "embeddable" | "iframe" | "image";
+export declare const toolIsArrow: (type: ElementOrToolType) => type is "arrow";
+export declare const canHaveArrowheads: (type: ElementOrToolType) => type is "arrow";

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

@@ -0,0 +1,11 @@
+import type { ExcalidrawTextContainer } from "./types";
+export declare const originalContainerCache: {
+    [id: ExcalidrawTextContainer["id"]]: {
+        height: ExcalidrawTextContainer["height"];
+    } | undefined;
+};
+export declare const updateOriginalContainerCache: (id: ExcalidrawTextContainer["id"], height: ExcalidrawTextContainer["height"]) => {
+    height: ExcalidrawTextContainer["height"];
+};
+export declare const resetOriginalContainerCache: (id: ExcalidrawTextContainer["id"]) => void;
+export declare const getOriginalContainerHeightFromCache: (id: ExcalidrawTextContainer["id"]) => number | null;

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

@@ -0,0 +1,19 @@
+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, elementsMap: ElementsMap, transformHandle: TransformHandleType, naturalWidth: number, naturalHeight: number, pointerX: number, pointerY: number, widthAspectRatio?: number) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    crop: ImageCrop | null;
+};
+export declare const getUncroppedImageElement: (element: ExcalidrawImageElement, elementsMap: ElementsMap) => ExcalidrawImageElement;
+export declare const getUncroppedWidthAndHeight: (element: ExcalidrawImageElement) => {
+    width: number;
+    height: number;
+};
+export declare const getFlipAdjustedCropPosition: (element: ExcalidrawImageElement, natural?: boolean) => {
+    x: number;
+    y: number;
+} | null;

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

@@ -0,0 +1,228 @@
+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.
+ *
+ * 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>, partialType: "deleted" | "inserted") => Partial<T>, modifierOptions?: "deleted" | "inserted" | "both"): 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 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;
+    /**
+     * 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;
+    /**
+     * 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 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.
+     *
+     * @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];
+    /**
+     * 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 AppStateDelta implements DeltaContainer<AppState> {
+    delta: Delta<ObservedAppState>;
+    private constructor();
+    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;
+    /**
+     * Mutates `nextAppState` be filtering out state related to deleted elements.
+     *
+     * @returns `true` if a visible change is found, `false` otherwise.
+     */
+    private filterInvisibleChanges;
+    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<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 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 satisfiesCommmonInvariants;
+    private static satisfiesUniqueInvariants;
+    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 nextElements current elements
+     * @param modifierOptions defines which of the delta (`deleted` or `inserted`) will be updated
+     * @returns new instance with modified delta/s
+     */
+    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;
+    /**
+     * 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;
+    static redrawElements(nextElements: SceneElementsMap, changedElements: Map<string, OrderedExcalidrawElement>): SceneElementsMap;
+    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/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/element/src/distribute.d.ts

@@ -0,0 +1,7 @@
+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, appState: Readonly<AppState>) => ExcalidrawElement[];

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

@@ -0,0 +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;
+    originOffset?: {
+        x: number;
+        y: number;
+    } | null;
+    informMutation?: boolean;
+}) => void;

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;
+    overrides?: (data: {
+        duplicateElement: ExcalidrawElement;
+        origElement: ExcalidrawElement;
+        origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>;
+    }) => Partial<ExcalidrawElement>;
+} & ({
+    /**
+     * 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/element/src/elbowArrow.d.ts

@@ -0,0 +1,17 @@
+import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
+import { type ElementUpdate } from "./mutateElement";
+import { type ExcalidrawElbowArrowElement, type NonDeletedSceneElementsMap } from "./types";
+import type { FixedPointBinding, FixedSegment } from "./types";
+export declare const BASE_PADDING = 40;
+/**
+ *
+ */
+export declare const updateElbowArrowPoints: (arrow: Readonly<ExcalidrawElbowArrowElement>, elementsMap: NonDeletedSceneElementsMap, updates: {
+    points?: readonly LocalPoint[];
+    fixedSegments?: readonly FixedSegment[] | null;
+    startBinding?: FixedPointBinding | null;
+    endBinding?: FixedPointBinding | null;
+}, options?: {
+    isDragging?: boolean;
+}) => ElementUpdate<ExcalidrawElbowArrowElement>;
+export declare const validateElbowPoints: <P extends GlobalPoint | LocalPoint>(points: readonly P[], tolerance?: number) => boolean;