@excalidraw/excalidraw 0.18.0-432a46e → 0.18.0-4e471c107

package/dist/prod/locales/{en-B4ZKOASM.js → en-TYY6KWIJ.js}

@@ -1 +1 @@
-import{A,B,C,D,E,F,G,H,I,J,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z}from"../chunk-6U3AYISY.js";import"../chunk-SRAX5OIU.js";export{f as alerts,e as buttons,l as canvasError,s as clearCanvasDialog,C as colorPicker,A as colors,I as commandPalette,v as confirmDialog,J as default,i as element,b as elementLink,x as encrypted,p as errorDialog,m as errorSplash,g as errors,q as exportDialog,G as fontList,j as headings,r as helpDialog,k as hints,w as imageExportDialog,a as labels,c as library,E as mermaid,D as overwriteConfirm,t as publishDialog,u as publishSuccessDialog,F as quickSearch,o as roomDialog,d as search,n as shareDialog,y as stats,z as toast,h as toolBar,H as userList,B as welcomeScreen};
+import{A,B,C,D,E,F,G,H,I,J,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z}from"../chunk-I4UNSFV6.js";import"../chunk-SRAX5OIU.js";export{f as alerts,e as buttons,l as canvasError,s as clearCanvasDialog,C as colorPicker,A as colors,I as commandPalette,v as confirmDialog,J as default,i as element,b as elementLink,x as encrypted,p as errorDialog,m as errorSplash,g as errors,q as exportDialog,G as fontList,j as headings,r as helpDialog,k as hints,w as imageExportDialog,a as labels,c as library,E as mermaid,D as overwriteConfirm,t as publishDialog,u as publishSuccessDialog,F as quickSearch,o as roomDialog,d as search,n as shareDialog,y as stats,z as toast,h as toolBar,H as userList,B as welcomeScreen};

package/dist/prod/subset-shared.chunk.js

@@ -1 +1 @@
-import{a,b,c,d}from"./chunk-LS7FJGPW.js";import"./chunk-U24AOZ3B.js";import"./chunk-SRAX5OIU.js";export{a as Commands,b as subsetToBase64,c as subsetToBinary,d as toBase64};
+import{a,b,c,d}from"./chunk-LS7FJGPW.js";import"./chunk-A66AFZZU.js";import"./chunk-SRAX5OIU.js";export{a as Commands,b as subsetToBase64,c as subsetToBinary,d as toBase64};

package/dist/prod/subset-worker.chunk.js

@@ -1 +1 @@
-import{a as r,c as t}from"./chunk-LS7FJGPW.js";import"./chunk-U24AOZ3B.js";import"./chunk-SRAX5OIU.js";var s=import.meta.url?new URL(import.meta.url):void 0;typeof window>"u"&&typeof self<"u"&&(self.onmessage=async e=>{switch(e.data.command){case r.Subset:let a=await t(e.data.arrayBuffer,e.data.codePoints);self.postMessage(a,{transfer:[a]});break}});export{s as WorkerUrl};
+import{a as r,c as t}from"./chunk-LS7FJGPW.js";import"./chunk-A66AFZZU.js";import"./chunk-SRAX5OIU.js";var s=import.meta.url?new URL(import.meta.url):void 0;typeof window>"u"&&typeof self<"u"&&(self.onmessage=async e=>{switch(e.data.command){case r.Subset:let a=await t(e.data.arrayBuffer,e.data.codePoints);self.postMessage(a,{transfer:[a]});break}});export{s as WorkerUrl};

package/dist/types/{packages/common → common}/src/colors.d.ts

@@ -1,5 +1,6 @@
 import oc from "open-color";
 import type { Merge } from "./utility-types";
+export declare const COLOR_OUTLINE_CONTRAST_THRESHOLD = 240;
 export type ColorPickerColor = Exclude<keyof oc, "indigo" | "lime"> | "transparent" | "bronze";
 export type ColorTuple = readonly [string, string, string, string, string];
 export type ColorPalette = Merge<Record<ColorPickerColor, ColorTuple>, {

package/dist/types/{packages/common → common}/src/constants.d.ts

@@ -82,11 +82,13 @@ export declare const YOUTUBE_STATES: {
 export declare const ENV: {
     TEST: string;
     DEVELOPMENT: string;
+    PRODUCTION: string;
 };
 export declare const CLASSES: {
     SHAPE_ACTIONS_MENU: string;
     ZOOM_ACTIONS: string;
     SEARCH_MENU_INPUT_WRAPPER: string;
+    CONVERT_ELEMENT_TYPE_POPUP: string;
 };
 export declare const CJK_HAND_DRAWN_FALLBACK_FONT = "Xiaolai";
 export declare const WINDOWS_EMOJI_FALLBACK_FONT = "Segoe UI Emoji";
@@ -107,11 +109,21 @@ export declare const FONT_FAMILY: {
     "Lilita One": number;
     "Comic Shanns": number;
     "Liberation Sans": number;
+    Assistant: number;
+};
+export declare const SANS_SERIF_GENERIC_FONT = "sans-serif";
+export declare const MONOSPACE_GENERIC_FONT = "monospace";
+export declare const FONT_FAMILY_GENERIC_FALLBACKS: {
+    "sans-serif": number;
+    monospace: number;
 };
 export declare const FONT_FAMILY_FALLBACKS: {
-    Xiaolai: number;
     "Segoe UI Emoji": number;
+    "sans-serif": number;
+    monospace: number;
+    Xiaolai: number;
 };
+export declare function getGenericFontFamilyFallback(fontFamily: number): keyof typeof FONT_FAMILY_GENERIC_FALLBACKS;
 export declare const getFontFamilyFallbacks: (fontFamily: number) => Array<keyof typeof FONT_FAMILY_FALLBACKS>;
 export declare const THEME: {
     readonly LIGHT: "light";
@@ -193,7 +205,7 @@ export declare const EXPORT_DATA_TYPES: {
     readonly excalidrawLibrary: "excalidrawlib";
     readonly excalidrawClipboardWithAPI: "excalidraw-api/clipboard";
 };
-export declare const EXPORT_SOURCE: string;
+export declare const getExportSource: () => string;
 export declare const IMAGE_RENDER_TIMEOUT = 500;
 export declare const TAP_TWICE_TIMEOUT = 300;
 export declare const TOUCH_CTX_MENU_TIMEOUT = 500;
@@ -224,6 +236,7 @@ export declare const DEFAULT_EXPORT_PADDING = 10;
 export declare const DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT = 1440;
 export declare const MAX_ALLOWED_FILE_BYTES: number;
 export declare const SVG_NS = "http://www.w3.org/2000/svg";
+export declare const SVG_DOCUMENT_PREAMBLE = "<?xml version=\"1.0\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n";
 export declare const ENCRYPTION_KEY_BITS = 128;
 export declare const VERSIONS: {
     readonly excalidraw: 2;
@@ -276,9 +289,10 @@ export declare const DEFAULT_SIDEBAR: {
     readonly name: "default";
     readonly defaultTab: "library";
 };
-export declare const LIBRARY_DISABLED_TYPES: Set<"embeddable" | "image" | "iframe">;
+export declare const LIBRARY_DISABLED_TYPES: Set<"embeddable" | "iframe" | "image">;
 export declare const TOOL_TYPE: {
     readonly selection: "selection";
+    readonly lasso: "lasso";
     readonly rectangle: "rectangle";
     readonly diamond: "diamond";
     readonly ellipse: "ellipse";
@@ -321,3 +335,9 @@ export declare enum UserIdleState {
     AWAY = "away",
     IDLE = "idle"
 }
+/**
+ * distance at which we merge points instead of adding a new merge-point
+ * when converting a line to a polygon (merge currently means overlaping
+ * the start and end points)
+ */
+export declare const LINE_POLYGON_POINT_MERGE_DISTANCE = 20;

package/dist/types/{packages/excalidraw → common/src}/emitter.d.ts

@@ -1,4 +1,4 @@
-import type { UnsubscribeCallback } from "./types";
+import type { UnsubscribeCallback } from "@excalidraw/excalidraw/types";
 type Subscriber<T extends any[]> = (...payload: T) => void;
 export declare class Emitter<T extends any[] = []> {
     subscribers: Subscriber<T>[];

package/dist/types/{packages/common → common}/src/font-metadata.d.ts

@@ -16,8 +16,10 @@ export interface FontMetadata {
     };
     /** flag to indicate a deprecated font */
     deprecated?: true;
-    /** flag to indicate a server-side only font */
-    serverSide?: true;
+    /**
+     * whether this is a font that users can use (= shown in font picker)
+     */
+    private?: true;
     /** flag to indiccate a local-only font */
     local?: true;
     /** flag to indicate a fallback font */

package/dist/types/{packages/common → common}/src/index.d.ts

@@ -9,3 +9,4 @@ export * from "./promise-pool";
 export * from "./random";
 export * from "./url";
 export * from "./utils";
+export * from "./emitter";

package/dist/types/{packages/common → common}/src/utility-types.d.ts

@@ -31,3 +31,8 @@ export type MakeBrand<T extends string> = {
 /** Maybe just promise or already fulfilled one! */
 export type MaybePromise<T> = T | Promise<T>;
 export type AllPossibleKeys<T> = T extends any ? keyof T : never;
+/** Strip all the methods or functions from a type */
+export type DTO<T> = {
+    [K in keyof T as T[K] extends Function ? never : K]: T[K];
+};
+export type MapEntry<M extends Map<any, any>> = M extends Map<infer K, infer V> ? [K, V] : never;

package/dist/types/{packages/common → common}/src/utils.d.ts

@@ -87,6 +87,7 @@ export declare const updateActiveTool: (appState: Pick<AppState, "activeTool">,
     customType: string;
 }) & {
     locked?: boolean;
+    fromSelection?: boolean;
 }) & {
     lastActiveToolBeforeEraser?: ActiveTool | null;
 }) => AppState["activeTool"];
@@ -136,6 +137,8 @@ export declare const tupleToCoors: (xyTuple: readonly [number, number]) => {
 export declare const muteFSAbortError: (error?: Error) => void;
 export declare const findIndex: <T>(array: readonly T[], cb: (element: T, index: number, array: readonly T[]) => boolean, fromIndex?: number) => number;
 export declare const findLastIndex: <T>(array: readonly T[], cb: (element: T, index: number, array: readonly T[]) => boolean, fromIndex?: number) => number;
+/** returns the first non-null mapped value */
+export declare const mapFind: <T, K>(collection: readonly T[], iteratee: (value: T, index: number) => K | null | undefined) => K | undefined;
 export declare const isTransparent: (color: string) => boolean;
 export declare const isBindingFallthroughEnabled: (el: ExcalidrawBindableElement) => boolean;
 export type ResolvablePromise<T> = Promise<T> & {
@@ -176,15 +179,25 @@ export type Node<T> = T & {
  * Creates a circular doubly linked list by adding `prev` and `next` props to the existing array nodes.
  */
 export declare const arrayToList: <T>(array: readonly T[]) => Node<T>[];
+/**
+ * Converts a readonly array or map into an iterable.
+ * Useful for avoiding entry allocations when iterating object / map on each iteration.
+ */
+export declare const toIterable: <T>(values: ReadonlyMap<string, T> | readonly T[]) => Iterable<T>;
+/**
+ * Converts a readonly array or map into an array.
+ */
+export declare const toArray: <T>(values: ReadonlyMap<string, T> | readonly T[]) => T[];
 export declare const isTestEnv: () => boolean;
 export declare const isDevEnv: () => boolean;
+export declare const isProdEnv: () => boolean;
 export declare const isServerEnv: () => boolean;
 export declare const wrapEvent: <T extends Event>(name: EVENT, nativeEvent: T) => CustomEvent<{
     nativeEvent: T;
 }>;
 export declare const updateObject: <T extends Record<string, any>>(obj: T, updates: Partial<T>) => T;
 export declare const isPrimitive: (val: any) => boolean;
-export declare const getFrame: () => "iframe" | "top";
+export declare const getFrame: () => "top" | "iframe";
 export declare const isRunningInIframe: () => boolean;
 export declare const isPromiseLike: (value: any) => value is Promise<any>;
 export declare const queryFocusableElements: (container: HTMLElement | null) => HTMLElement[];
@@ -247,4 +260,8 @@ export declare const safelyParseJSON: (json: string) => Record<string, any> | nu
  */
 export declare const escapeDoubleQuotes: (str: string) => string;
 export declare const castArray: <T>(value: T | T[]) => T[];
+/** hack for Array.isArray type guard not working with readonly value[] */
+export declare const isReadonlyArray: (value?: any) => value is readonly any[];
+export declare const sizeOf: (value: readonly unknown[] | Readonly<Map<string, unknown>> | Readonly<Record<string, unknown>> | ReadonlySet<unknown>) => number;
+export declare const reduceToCommonValue: <T, R = T>(collection: ReadonlySet<T> | readonly T[], getValue?: ((item: T) => R) | undefined) => R | null;
 export {};

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

@@ -1,19 +1,11 @@
-import type { LinearElementEditor } from "@excalidraw/element/linearElementEditor";
+import { type ElementUpdate } from "@excalidraw/element";
 import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameLikeElement, ElementsMapOrArray, OrderedExcalidrawElement, Ordered } from "@excalidraw/element/types";
-import type { AppState } from "../types";
-type ElementIdKey = InstanceType<typeof LinearElementEditor>["elementId"];
-type ElementKey = ExcalidrawElement | ElementIdKey;
+import type { Mutable } from "@excalidraw/common/utility-types";
+import type { AppState } from "../../excalidraw/types";
 type SceneStateCallback = () => void;
 type SceneStateCallbackRemover = () => void;
 export type ExcalidrawElementsIncludingDeleted = readonly ExcalidrawElement[];
-declare class Scene {
-    private static sceneMapByElement;
-    private static sceneMapById;
-    static mapElementToScene(elementKey: ElementKey, scene: Scene): void;
-    /**
-     * @deprecated pass down `app.scene` and use it directly
-     */
-    static getScene(elementKey: ElementKey): Scene | null;
+export declare class Scene {
     private callbacks;
     private nonDeletedElements;
     private nonDeletedElementsMap;
@@ -35,6 +27,7 @@ declare class Scene {
     getElementsMapIncludingDeleted(): Map<string, Ordered<ExcalidrawElement>> & import("@excalidraw/common/utility-types").MakeBrand<"SceneElementsMap">;
     getNonDeletedElements(): readonly Ordered<NonDeletedExcalidrawElement>[];
     getFramesIncludingDeleted(): readonly ExcalidrawFrameLikeElement[];
+    constructor(elements?: ElementsMapOrArray | null);
     getSelectedElements(opts: {
         selectedElementIds: AppState["selectedElementIds"];
         /**
@@ -73,7 +66,11 @@ declare class Scene {
     getElementIndex(elementId: string): number;
     getContainerElement: (element: (ExcalidrawElement & {
         containerId: ExcalidrawElement["id"] | null;
-    }) | null) => import("@excalidraw/element/types").ExcalidrawRectangleElement | import("@excalidraw/element/types").ExcalidrawDiamondElement | import("@excalidraw/element/types").ExcalidrawFrameElement | import("@excalidraw/element/types").ExcalidrawMagicFrameElement | import("@excalidraw/element/types").ExcalidrawEmbeddableElement | import("@excalidraw/element/types").ExcalidrawImageElement | import("@excalidraw/element/types").ExcalidrawIframeElement | import("@excalidraw/element/types").ExcalidrawTextElement | import("@excalidraw/element/types").ExcalidrawSelectionElement | import("@excalidraw/element/types").ExcalidrawEllipseElement | import("@excalidraw/element/types").ExcalidrawLinearElement | import("@excalidraw/element/types").ExcalidrawFreeDrawElement | null;
+    }) | null) => import("@excalidraw/element/types").ExcalidrawLinearElement | import("@excalidraw/element/types").ExcalidrawSelectionElement | import("@excalidraw/element/types").ExcalidrawRectangleElement | import("@excalidraw/element/types").ExcalidrawDiamondElement | import("@excalidraw/element/types").ExcalidrawEllipseElement | import("@excalidraw/element/types").ExcalidrawEmbeddableElement | import("@excalidraw/element/types").ExcalidrawIframeElement | import("@excalidraw/element/types").ExcalidrawImageElement | import("@excalidraw/element/types").ExcalidrawFrameElement | import("@excalidraw/element/types").ExcalidrawMagicFrameElement | import("@excalidraw/element/types").ExcalidrawTextElement | import("@excalidraw/element/types").ExcalidrawFreeDrawElement | null;
     getElementsFromId: (id: string) => ExcalidrawElement[];
+    mutateElement<TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, options?: {
+        informMutation: boolean;
+        isDragging: boolean;
+    }): TElement;
 }
-export default Scene;
+export {};

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

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

package/dist/types/{packages/element → element}/src/binding.d.ts

@@ -1,11 +1,11 @@
 import { type GlobalPoint } from "@excalidraw/math";
 import type { LocalPoint } from "@excalidraw/math";
-import type Scene from "@excalidraw/excalidraw/scene/Scene";
 import type { AppState } from "@excalidraw/excalidraw/types";
 import { type Heading } from "./heading";
+import type { Scene } from "./Scene";
 import type { Bounds } from "./bounds";
 import type { ElementUpdate } from "./mutateElement";
-import type { ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, ExcalidrawLinearElement, NonDeletedExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap, OrderedExcalidrawElement, ExcalidrawElbowArrowElement, FixedPoint, SceneElementsMap } from "./types";
+import type { ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, ExcalidrawLinearElement, NonDeletedExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap, ExcalidrawElbowArrowElement, FixedPoint } from "./types";
 export type SuggestedBinding = NonDeleted<ExcalidrawBindableElement> | SuggestedPointBinding;
 export type SuggestedPointBinding = [
     NonDeleted<ExcalidrawLinearElement>,
@@ -16,36 +16,47 @@ export declare const shouldEnableBindingForPointerEvent: (event: React.PointerEv
 export declare const isBindingEnabled: (appState: AppState) => boolean;
 export declare const FIXED_BINDING_DISTANCE = 5;
 export declare const BINDING_HIGHLIGHT_THICKNESS = 10;
-export declare const BINDING_HIGHLIGHT_OFFSET = 4;
-export declare const bindOrUnbindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, startBindingElement: ExcalidrawBindableElement | null | "keep", endBindingElement: ExcalidrawBindableElement | null | "keep", elementsMap: NonDeletedSceneElementsMap, scene: Scene) => void;
-export declare const bindOrUnbindLinearElements: (selectedElements: NonDeleted<ExcalidrawLinearElement>[], elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[], scene: Scene, isBindingEnabled: boolean, draggingPoints: readonly number[] | null, zoom?: AppState["zoom"]) => void;
+export declare const bindOrUnbindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, startBindingElement: ExcalidrawBindableElement | null | "keep", endBindingElement: ExcalidrawBindableElement | null | "keep", scene: Scene) => void;
+export declare const bindOrUnbindLinearElements: (selectedElements: NonDeleted<ExcalidrawLinearElement>[], isBindingEnabled: boolean, draggingPoints: readonly number[] | null, scene: Scene, zoom?: AppState["zoom"]) => void;
 export declare const getSuggestedBindingsForArrows: (selectedElements: NonDeleted<ExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, zoom: AppState["zoom"]) => SuggestedBinding[];
+export declare const maybeSuggestBindingsForLinearElementAtCoords: (linearElement: NonDeleted<ExcalidrawLinearElement>, pointerCoords: {
+    x: number;
+    y: number;
+}[], scene: Scene, zoom: AppState["zoom"], oppositeBindingBoundElement?: ExcalidrawBindableElement | null) => ExcalidrawBindableElement[];
 export declare const maybeBindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, appState: AppState, pointerCoords: {
     x: number;
     y: number;
-}, elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[]) => void;
-export declare const bindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: NonDeletedSceneElementsMap) => void;
+}, scene: Scene) => void;
+export declare const bindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", scene: Scene) => void;
 export declare const isLinearElementSimpleAndAlreadyBound: (linearElement: NonDeleted<ExcalidrawLinearElement>, alreadyBoundToId: ExcalidrawBindableElement["id"] | undefined, bindableElement: ExcalidrawBindableElement) => boolean;
 export declare const getHoveredElementForBinding: (pointerCoords: {
     x: number;
     y: number;
 }, elements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap, zoom?: AppState["zoom"], fullShape?: boolean, considerAllElements?: boolean) => NonDeleted<ExcalidrawBindableElement> | null;
-export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, options?: {
+export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, scene: Scene, options?: {
+    simultaneouslyUpdated?: readonly ExcalidrawElement[];
+    newSize?: {
+        width: number;
+        height: number;
+    };
+    changedElements?: Map<string, ExcalidrawElement>;
+}) => void;
+export declare const updateBindings: (latestElement: ExcalidrawElement, scene: Scene, options?: {
     simultaneouslyUpdated?: readonly ExcalidrawElement[];
     newSize?: {
         width: number;
         height: number;
     };
-    changedElements?: Map<string, OrderedExcalidrawElement>;
+    zoom?: AppState["zoom"];
 }) => void;
-export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, elementsMap: ElementsMap, origPoint: GlobalPoint, zoom?: AppState["zoom"]) => Heading;
-export declare const bindPointToSnapToElementOutline: (arrow: ExcalidrawElbowArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end") => GlobalPoint;
-export declare const avoidRectangularCorner: (element: ExcalidrawBindableElement, p: GlobalPoint) => GlobalPoint;
-export declare const snapToMid: (element: ExcalidrawBindableElement, p: GlobalPoint, tolerance?: number) => GlobalPoint;
+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: (arrow: ExcalidrawElbowArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => GlobalPoint;
+export declare const avoidRectangularCorner: (element: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint) => GlobalPoint;
+export declare const snapToMid: (element: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint, tolerance?: number) => GlobalPoint;
 export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => {
     fixedPoint: FixedPoint;
 };
-export declare const fixBindingsAfterDuplication: (newElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicatedElementsMap: NonDeletedSceneElementsMap) => void;
+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 bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
     x: number;
@@ -93,7 +104,7 @@ export declare class BindableElement {
      */
     static rebindAffected: (elements: ElementsMap, bindableElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void) => void;
 }
-export declare const getGlobalFixedPointForBindableElement: (fixedPointRatio: [number, number], element: ExcalidrawBindableElement) => GlobalPoint;
+export declare const getGlobalFixedPointForBindableElement: (fixedPointRatio: [number, number], element: ExcalidrawBindableElement, elementsMap: ElementsMap) => GlobalPoint;
 export declare const getGlobalFixedPoints: (arrow: ExcalidrawElbowArrowElement, 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;

package/dist/types/{packages/element → element}/src/bounds.d.ts

@@ -1,7 +1,7 @@
-import type { Degrees, GlobalPoint, LineSegment } from "@excalidraw/math";
+import type { Degrees, GlobalPoint, LineSegment, LocalPoint } from "@excalidraw/math";
 import type { AppState } from "@excalidraw/excalidraw/types";
-import type { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, ExcalidrawFreeDrawElement, NonDeleted, ElementsMap } from "./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;
@@ -26,10 +26,16 @@ export type SceneBounds = readonly [
 ];
 export declare class ElementBounds {
     private static boundsCache;
-    static getBounds(element: ExcalidrawElement, elementsMap: ElementsMap): Bounds;
+    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.
@@ -38,6 +44,7 @@ export declare const getElementLineSegments: (element: ExcalidrawElement, elemen
  */
 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) | undefined) => Bounds;
 export declare const getBoundsFromPoints: (points: ExcalidrawFreeDrawElement["points"]) => Bounds;
 /** @returns number in pixels */
@@ -45,8 +52,8 @@ 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) => Bounds;
-export declare const getCommonBounds: (elements: readonly ExcalidrawElement[], elementsMap?: ElementsMap) => Bounds;
+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;
@@ -73,4 +80,10 @@ export declare const getCommonBoundingBox: (elements: ExcalidrawElement[] | read
  */
 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,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/{packages/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/{packages/excalidraw/change.d.ts → element/src/delta.d.ts}

@@ -1,7 +1,7 @@
-import type { ElementUpdate } from "@excalidraw/element/mutateElement";
 import type { ExcalidrawElement, Ordered, OrderedExcalidrawElement, SceneElementsMap } from "@excalidraw/element/types";
-import type { ValueOf } from "@excalidraw/common/utility-types";
-import type { AppState, ObservedAppState } from "./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 { AppState, ObservedAppState } from "./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.
      *
@@ -56,13 +56,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,37 +89,33 @@ 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.
+     * 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> {
+    readonly delta: Delta<ObservedAppState>;
     private constructor();
-    static calculate<T extends ObservedAppState>(prevAppState: T, nextAppState: T): AppStateChange;
-    static empty(): AppStateChange;
-    inverse(): AppStateChange;
+    static calculate<T extends ObservedAppState>(prevAppState: T, nextAppState: T): AppStateDelta;
+    static restore(appStateDeltaDTO: DTO<AppStateDelta>): AppStateDelta;
+    static empty(): AppStateDelta;
+    inverse(): AppStateDelta;
     applyTo(appState: AppState, nextElements: SceneElementsMap): [AppState, boolean];
     isEmpty(): boolean;
-    /**
-     * 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.
      *
@@ -115,23 +127,34 @@ export declare class AppStateChange implements Change<AppState> {
     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 validate;
     /**
      * Calculates the `Delta`s between the previous and next set of elements.
@@ -139,21 +162,21 @@ 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];
     private static createApplier;
     private static createGetter;
     private static applyDelta;
@@ -165,6 +188,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;

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;