@wildmio/excalidraw 0.18.0-custom.1 → 0.18.0-custom.3

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

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

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

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

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

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

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

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

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

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

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

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

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

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