@dwelle/excalidraw 0.5.0-ff7b5f2db → 0.5.0-ffade30

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

@@ -1,4 +1,4 @@
-import type { ExcalidrawElement, OrderedExcalidrawElement } from "./types";
+import type { ElementsMap, ExcalidrawElement, OrderedExcalidrawElement } from "./types";
 export declare class InvalidFractionalIndexError extends Error {
     code: "ELEMENT_HAS_INVALID_INDEX";
 }
@@ -42,7 +42,7 @@ export declare const orderByFractionalIndex: (elements: OrderedExcalidrawElement
  * Synchronizes invalid fractional indices of moved elements with the array order by mutating passed elements.
  * If the synchronization fails or the result is invalid, it fallbacks to `syncInvalidIndices`.
  */
-export declare const syncMovedIndices: (elements: readonly ExcalidrawElement[], movedElements: Map<string, ExcalidrawElement>) => OrderedExcalidrawElement[];
+export declare const syncMovedIndices: (elements: readonly ExcalidrawElement[], movedElements: ElementsMap) => OrderedExcalidrawElement[];
 /**
  * Synchronizes all invalid fractional indices with the array order by mutating passed elements.
  *

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

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

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

@@ -5,7 +5,6 @@ export declare const HEADING_DOWN: Heading;
 export declare const HEADING_LEFT: Heading;
 export declare const HEADING_UP: Heading;
 export type Heading = [1, 0] | [0, 1] | [-1, 0] | [0, -1];
-export declare const headingForDiamond: <Point extends GlobalPoint | LocalPoint>(a: Point, b: Point) => Heading;
 export declare const vectorToHeading: (vec: Vector) => Heading;
 export declare const headingForPoint: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => Heading;
 export declare const headingForPointIsHorizontal: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => boolean;

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

@@ -1,4 +1,4 @@
-import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted } from "./types";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ElementsMapOrArray } from "./types";
 /**
  * @deprecated unsafe, use hashElementsVersion instead
  */
@@ -6,7 +6,7 @@ export declare const getSceneVersion: (elements: readonly ExcalidrawElement[]) =
 /**
  * Hashes elements' versionNonce (using djb2 algo). Order of elements matters.
  */
-export declare const hashElementsVersion: (elements: readonly ExcalidrawElement[]) => number;
+export declare const hashElementsVersion: (elements: ElementsMapOrArray) => number;
 export declare const hashString: (s: string) => number;
 export declare const getVisibleElements: (elements: readonly ExcalidrawElement[]) => readonly NonDeletedExcalidrawElement[];
 export declare const getNonDeletedElements: <T extends ExcalidrawElement>(elements: readonly T[]) => readonly NonDeleted<T>[];
@@ -14,3 +14,46 @@ export declare const isNonDeletedElement: <T extends ExcalidrawElement>(element:
 export declare const clearElementsForDatabase: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
 export declare const clearElementsForExport: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
 export declare const clearElementsForLocalStorage: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+export * from "./align";
+export * from "./binding";
+export * from "./bounds";
+export * from "./collision";
+export * from "./comparisons";
+export * from "./containerCache";
+export * from "./cropElement";
+export * from "./delta";
+export * from "./distance";
+export * from "./distribute";
+export * from "./dragElements";
+export * from "./duplicate";
+export * from "./elbowArrow";
+export * from "./elementLink";
+export * from "./embeddable";
+export * from "./flowchart";
+export * from "./fractionalIndex";
+export * from "./frame";
+export * from "./groups";
+export * from "./heading";
+export * from "./image";
+export * from "./linearElementEditor";
+export * from "./mutateElement";
+export * from "./newElement";
+export * from "./renderElement";
+export * from "./resizeElements";
+export * from "./resizeTest";
+export * from "./Scene";
+export * from "./selection";
+export * from "./Shape";
+export * from "./ShapeCache";
+export * from "./shapes";
+export * from "./showSelectedShapeActions";
+export * from "./sizeHelpers";
+export * from "./sortElements";
+export * from "./store";
+export * from "./textElement";
+export * from "./textMeasurements";
+export * from "./textWrapping";
+export * from "./transformHandles";
+export * from "./typeChecks";
+export * from "./utils";
+export * from "./zindex";

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

@@ -1,15 +1,10 @@
 /// <reference types="react" />
 import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
-import Scene from "@excalidraw/excalidraw/scene/Scene";
-import type { Store } from "@excalidraw/excalidraw/store";
+import type { Store } from "@excalidraw/element";
 import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize, Zoom } from "@excalidraw/excalidraw/types";
+import type { Scene } from "./Scene";
 import type { Bounds } from "./bounds";
-import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, SceneElementsMap, ExcalidrawElbowArrowElement } from "./types";
-declare const editorMidPointsCache: {
-    version: number | null;
-    points: (GlobalPoint | null)[];
-    zoom: number | null;
-};
+import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, ExcalidrawElbowArrowElement, PointsPositionUpdates } from "./types";
 export declare class LinearElementEditor {
     readonly elementId: ExcalidrawElement["id"] & {
         _brand: "excalidrawLinearElementId";
@@ -43,7 +38,7 @@ export declare class LinearElementEditor {
     readonly hoverPointIndex: number;
     readonly segmentMidPointHoveredCoords: GlobalPoint | null;
     readonly elbowed: boolean;
-    constructor(element: NonDeleted<ExcalidrawLinearElement>);
+    constructor(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap);
     static POINT_HANDLE_SIZE: number;
     /**
      * @param id the `elementId` from the instance of this class (so that we can
@@ -59,8 +54,7 @@ export declare class LinearElementEditor {
         y: number;
     }[]) => void, linearElementEditor: LinearElementEditor, scene: Scene): LinearElementEditor | null;
     static handlePointerUp(event: PointerEvent, editingLinearElement: LinearElementEditor, appState: AppState, scene: Scene): LinearElementEditor;
-    static getEditorMidPoints: (element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => (typeof editorMidPointsCache)["points"];
-    static updateEditorMidPointsCache: (element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => void;
+    static getEditorMidPoints: (element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => (GlobalPoint | null)[];
     static getSegmentMidpointHitCoords: (linearElementEditor: LinearElementEditor, scenePointer: {
         x: number;
         y: number;
@@ -77,7 +71,7 @@ export declare class LinearElementEditor {
         linearElementEditor: LinearElementEditor | null;
     };
     static arePointsEqual<Point extends LocalPoint | GlobalPoint>(point1: Point | null, point2: Point | null): boolean;
-    static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, app: AppClassProperties, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): LinearElementEditor | null;
+    static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, app: AppClassProperties): LinearElementEditor | null;
     /** scene coords */
     static getPointGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, p: LocalPoint, elementsMap: ElementsMap): GlobalPoint;
     /** scene coords */
@@ -89,30 +83,25 @@ export declare class LinearElementEditor {
     static createPointAt(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, scenePointerX: number, scenePointerY: number, gridSize: NullableGridSize): LocalPoint;
     /**
      * Normalizes line points so that the start point is at [0,0]. This is
-     * expected in various parts of the codebase. Also returns new x/y to account
-     * for the potential normalization.
+     * expected in various parts of the codebase.
+     *
+     * Also returns normalized x and y coords to account for the normalization
+     * of the points.
      */
-    static getNormalizedPoints(element: ExcalidrawLinearElement): {
+    static getNormalizeElementPointsAndCoords(element: ExcalidrawLinearElement): {
         points: LocalPoint[];
         x: number;
         y: number;
     };
-    static normalizePoints(element: NonDeleted<ExcalidrawLinearElement>): void;
-    static duplicateSelectedPoints(appState: AppState, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): AppState;
-    static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[]): void;
-    static addPoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
-        point: LocalPoint;
-    }[]): void;
-    static movePoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
-        index: number;
-        point: LocalPoint;
-        isDragging?: boolean;
-    }[], otherUpdates?: {
+    static duplicateSelectedPoints(appState: AppState, scene: Scene): AppState;
+    static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, app: AppClassProperties, pointIndices: readonly number[]): void;
+    static addPoints(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene, addedPoints: LocalPoint[]): void;
+    static movePoints(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene, pointUpdates: PointsPositionUpdates, otherUpdates?: {
         startBinding?: PointBinding | null;
         endBinding?: PointBinding | null;
-    }, sceneElementsMap?: NonDeletedSceneElementsMap): void;
+    }): void;
     static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState, elementsMap: ElementsMap): boolean;
-    static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, elementsMap: ElementsMap): {
+    static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, scene: Scene): {
         pointerDownState: LinearElementEditor["pointerDownState"];
         selectedPointsIndices: LinearElementEditor["selectedPointsIndices"];
     } | undefined;
@@ -124,7 +113,6 @@ export declare class LinearElementEditor {
     };
     static getMinMaxXYWithBoundText: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, elementBounds: Bounds, boundTextElement: ExcalidrawTextElementWithContainer) => [number, number, number, number, number, number];
     static getElementAbsoluteCoords: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, includeBoundText?: boolean) => [number, number, number, number, number, number];
-    static moveFixedSegment(linearElement: LinearElementEditor, index: number, x: number, y: number, elementsMap: ElementsMap): LinearElementEditor;
-    static deleteFixedSegment(element: ExcalidrawElbowArrowElement, index: number): void;
+    static moveFixedSegment(linearElement: LinearElementEditor, index: number, x: number, y: number, scene: Scene): LinearElementEditor;
+    static deleteFixedSegment(element: ExcalidrawElbowArrowElement, scene: Scene, index: number): void;
 }
-export {};

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

@@ -1,7 +1,15 @@
 import type { Mutable } from "@excalidraw/common/utility-types";
-import type { ExcalidrawElement } from "./types";
+import type { ElementsMap, ExcalidrawElement } from "./types";
 export type ElementUpdate<TElement extends ExcalidrawElement> = Omit<Partial<TElement>, "id" | "version" | "versionNonce" | "updated">;
-export declare const mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, informMutation?: boolean, options?: {
+/**
+ * This function tracks updates of text elements for the purposes for collaboration.
+ * The version is used to compare updates when more than one user is working in
+ * the same drawing.
+ *
+ * WARNING: this won't trigger the component to update, so if you need to trigger component update,
+ * use `scene.mutateElement` or `ExcalidrawImperativeAPI.mutateElement` instead.
+ */
+export declare const mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, elementsMap: ElementsMap, updates: ElementUpdate<TElement>, options?: {
     isDragging?: boolean;
 }) => TElement;
 export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, force?: boolean) => TElement;

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

@@ -1,5 +1,5 @@
 import type { MarkOptional } from "@excalidraw/common/utility-types";
-import type { ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap, ExcalidrawArrowElement, FixedSegment, ExcalidrawElbowArrowElement } from "./types";
+import type { ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap, ExcalidrawArrowElement, ExcalidrawElbowArrowElement, ExcalidrawLineElement } from "./types";
 export type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "frameId" | "index" | "boundElements" | "seed" | "version" | "versionNonce" | "link" | "strokeStyle" | "fillStyle" | "strokeColor" | "backgroundColor" | "roughness" | "strokeWidth" | "roundness" | "locked" | "opacity" | "customData">;
 export declare const newElement: (opts: {
     type: ExcalidrawGenericElement["type"];
@@ -43,6 +43,7 @@ export declare const newFreeDrawElement: (opts: {
 export declare const newLinearElement: (opts: {
     type: ExcalidrawLinearElement["type"];
     points?: ExcalidrawLinearElement["points"];
+    polygon?: ExcalidrawLineElement["polygon"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawLinearElement>;
 export declare const newArrowElement: <T extends boolean>(opts: {
     type: ExcalidrawArrowElement["type"];
@@ -50,8 +51,8 @@ export declare const newArrowElement: <T extends boolean>(opts: {
     endArrowhead?: Arrowhead | null | undefined;
     points?: readonly import("@excalidraw/math").LocalPoint[] | undefined;
     elbowed?: T | undefined;
-    fixedSegments?: FixedSegment[] | null | undefined;
-} & Omit<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "angle" | "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "link" | "locked" | "customData"> & Partial<Pick<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "angle" | "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "link" | "locked" | "customData">>) => T extends true ? NonDeleted<ExcalidrawElbowArrowElement> : NonDeleted<ExcalidrawArrowElement>;
+    fixedSegments?: readonly import("./types").FixedSegment[] | null | undefined;
+} & Omit<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "link" | "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "angle" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData"> & Partial<Pick<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "link" | "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "angle" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData">>) => T extends true ? NonDeleted<ExcalidrawElbowArrowElement> : NonDeleted<ExcalidrawArrowElement>;
 export declare const newImageElement: (opts: {
     type: ExcalidrawImageElement["type"];
     status?: ExcalidrawImageElement["status"];

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

@@ -1,10 +1,10 @@
 import { type LocalPoint } from "@excalidraw/math";
-import type Scene from "@excalidraw/excalidraw/scene/Scene";
 import type { PointerDownState } from "@excalidraw/excalidraw/types";
+import type { Scene } from "./Scene";
 import type { BoundingBox } from "./bounds";
 import type { MaybeTransformHandleType, TransformHandleDirection } from "./transformHandles";
-import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawElement, ElementsMap, SceneElementsMap } from "./types";
-export declare const transformElements: (originalElements: PointerDownState["originalElements"], transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: SceneElementsMap, scene: Scene, shouldRotateWithDiscreteAngle: boolean, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number) => boolean;
+import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawElement, ElementsMap } from "./types";
+export declare const transformElements: (originalElements: PointerDownState["originalElements"], transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], scene: Scene, shouldRotateWithDiscreteAngle: boolean, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number) => boolean;
 export declare const rescalePointsInElement: (element: NonDeletedExcalidrawElement, width: number, height: number, normalizePoints: boolean) => {
     points: LocalPoint[];
 } | {
@@ -15,7 +15,7 @@ export declare const measureFontSizeFromWidth: (element: NonDeleted<ExcalidrawTe
 } | null;
 export declare const getResizeOffsetXY: (transformHandleType: MaybeTransformHandleType, selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap, x: number, y: number) => [number, number];
 export declare const getResizeArrowDirection: (transformHandleType: MaybeTransformHandleType, element: NonDeleted<ExcalidrawLinearElement>) => "origin" | "end";
-export declare const resizeSingleElement: (nextWidth: number, nextHeight: number, latestElement: ExcalidrawElement, origElement: ExcalidrawElement, elementsMap: ElementsMap, originalElementsMap: ElementsMap, handleDirection: TransformHandleDirection, { shouldInformMutation, shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
+export declare const resizeSingleElement: (nextWidth: number, nextHeight: number, latestElement: ExcalidrawElement, origElement: ExcalidrawElement, originalElementsMap: ElementsMap, scene: Scene, handleDirection: TransformHandleDirection, { shouldInformMutation, shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
     shouldMaintainAspectRatio?: boolean | undefined;
     shouldResizeFromCenter?: boolean | undefined;
     shouldInformMutation?: boolean | undefined;

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

@@ -1,4 +1,5 @@
 import type { AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
+import { LinearElementEditor } from "./linearElementEditor";
 import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "./types";
 /**
  * Frames and their containing elements are not to be selected at the same time.
@@ -13,11 +14,6 @@ export declare const isSomeElementSelected: {
     (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">): boolean;
     clearCache(): void;
 };
-/**
- * Returns common attribute (picked by `getAttribute` callback) of selected
- *  elements. If elements don't share the same value, returns `null`.
- */
-export declare const getCommonAttributeOfSelectedElements: <T>(elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">, getAttribute: (element: ExcalidrawElement) => T) => T | null;
 export declare const getSelectedElements: (elements: ElementsMapOrArray, appState: Pick<InteractiveCanvasAppState, "selectedElementIds">, opts?: {
     includeBoundTextElement?: boolean;
     includeElementsInFrames?: boolean;
@@ -30,3 +26,13 @@ export declare const getTargetElements: (elements: ElementsMapOrArray, appState:
 export declare const makeNextSelectedElementIds: (nextSelectedElementIds: AppState["selectedElementIds"], prevState: Pick<AppState, "selectedElementIds">) => Readonly<{
     [id: string]: true;
 }>;
+export declare const getSelectionStateForElements: (targetElements: readonly ExcalidrawElement[], allElements: readonly NonDeletedExcalidrawElement[], appState: AppState) => {
+    selectedElementIds: Readonly<{
+        [id: string]: true;
+    }>;
+    selectedGroupIds: {
+        [groupId: string]: boolean;
+    };
+    editingGroupId: string | null;
+    selectedLinearElement: LinearElementEditor | null;
+};

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

@@ -2,7 +2,7 @@ import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
 import { type GeometricShape } from "@excalidraw/utils/shape";
 import type { Zoom } from "@excalidraw/excalidraw/types";
 import { type Bounds } from "./bounds";
-import type { ElementsMap, ExcalidrawElement, ExcalidrawLinearElement, NonDeleted } from "./types";
+import type { ElementsMap, ExcalidrawElement, ExcalidrawLinearElement, ExcalidrawLineElement, NonDeleted } from "./types";
 /**
  * get the pure geometric shape of an excalidraw elementw
  * which is then used for hit detection
@@ -21,3 +21,7 @@ export declare const pointInsideBounds: <P extends GlobalPoint | LocalPoint>(p:
 export declare const aabbsOverlapping: (a: Bounds, b: Bounds) => boolean;
 export declare const getCornerRadius: (x: number, element: ExcalidrawElement) => number;
 export declare const isPathALoop: (points: ExcalidrawLinearElement["points"], zoomValue?: Zoom["value"]) => boolean;
+export declare const toggleLinePolygonState: (element: ExcalidrawLineElement, nextPolygonState: boolean) => {
+    polygon: ExcalidrawLineElement["polygon"];
+    points: ExcalidrawLineElement["points"];
+} | null;

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

@@ -1,5 +1,6 @@
 import type { AppState, Offsets, Zoom } from "@excalidraw/excalidraw/types";
 import type { ElementsMap, ExcalidrawElement } from "./types";
+export declare const INVISIBLY_SMALL_ELEMENT_SIZE = 0.1;
 export declare const isInvisiblySmallElement: (element: ExcalidrawElement) => boolean;
 export declare const isElementInViewport: (element: ExcalidrawElement, width: number, height: number, viewTransformations: {
     zoom: Zoom;
@@ -26,7 +27,6 @@ export declare const getLockedLinearCursorAlignSize: (originX: number, originY:
     width: number;
     height: number;
 };
-export declare const resizePerfectLineForNWHandler: (element: ExcalidrawElement, x: number, y: number) => void;
 export declare const getNormalizedDimensions: (element: Pick<ExcalidrawElement, "width" | "height" | "x" | "y">) => {
     width: ExcalidrawElement["width"];
     height: ExcalidrawElement["height"];

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

@@ -0,0 +1,227 @@
+import { Emitter } from "@excalidraw/common";
+import type App from "@excalidraw/excalidraw/components/App";
+import type { DTO, ValueOf } from "@excalidraw/common/utility-types";
+import type { AppState, ObservedAppState } from "@excalidraw/excalidraw/types";
+import { ElementsDelta, AppStateDelta } from "./delta";
+import type { OrderedExcalidrawElement, SceneElementsMap } from "./types";
+export declare const CaptureUpdateAction: {
+    /**
+     * Immediately undoable.
+     *
+     * Use for updates which should be captured.
+     * Should be used for most of the local updates, except ephemerals such as dragging or resizing.
+     *
+     * These updates will _immediately_ make it to the local undo / redo stacks.
+     */
+    readonly IMMEDIATELY: "IMMEDIATELY";
+    /**
+     * Never undoable.
+     *
+     * Use for updates which should never be recorded, such as remote updates
+     * or scene initialization.
+     *
+     * These updates will _never_ make it to the local undo / redo stacks.
+     */
+    readonly NEVER: "NEVER";
+    /**
+     * Eventually undoable.
+     *
+     * Use for updates which should not be captured immediately - likely
+     * exceptions which are part of some async multi-step process. Otherwise, all
+     * such updates would end up being captured with the next
+     * `CaptureUpdateAction.IMMEDIATELY` - triggered either by the next `updateScene`
+     * or internally by the editor.
+     *
+     * These updates will _eventually_ make it to the local undo / redo stacks.
+     */
+    readonly EVENTUALLY: "EVENTUALLY";
+};
+export type CaptureUpdateActionType = ValueOf<typeof CaptureUpdateAction>;
+/**
+ * Store which captures the observed changes and emits them as `StoreIncrement` events.
+ */
+export declare class Store {
+    private readonly app;
+    readonly onDurableIncrementEmitter: Emitter<[DurableIncrement]>;
+    readonly onStoreIncrementEmitter: Emitter<[DurableIncrement | EphemeralIncrement]>;
+    private scheduledMacroActions;
+    private scheduledMicroActions;
+    private _snapshot;
+    get snapshot(): StoreSnapshot;
+    set snapshot(snapshot: StoreSnapshot);
+    constructor(app: App);
+    scheduleAction(action: CaptureUpdateActionType): void;
+    /**
+     * Use to schedule a delta calculation, which will consquentially be emitted as `DurableStoreIncrement` and pushed in the undo stack.
+     */
+    scheduleCapture(): void;
+    /**
+     * Schedule special "micro" actions, to-be executed before the next commit, before it executes a scheduled "macro" action.
+     */
+    scheduleMicroAction(params: {
+        action: CaptureUpdateActionType;
+        elements: SceneElementsMap | undefined;
+        appState: AppState | ObservedAppState | undefined;
+    } | {
+        action: typeof CaptureUpdateAction.IMMEDIATELY;
+        change: StoreChange;
+        delta: StoreDelta;
+    } | {
+        action: typeof CaptureUpdateAction.NEVER | typeof CaptureUpdateAction.EVENTUALLY;
+        change: StoreChange;
+    }): void;
+    /**
+     * Performs the incoming `CaptureUpdateAction` and emits the corresponding `StoreIncrement`.
+     * Emits `DurableStoreIncrement` when action is "capture", emits `EphemeralStoreIncrement` otherwise.
+     *
+     * @emits StoreIncrement
+     */
+    commit(elements: SceneElementsMap | undefined, appState: AppState | ObservedAppState | undefined): void;
+    /**
+     * Clears the store instance.
+     */
+    clear(): void;
+    /**
+     * Performs delta & change calculation and emits a durable increment.
+     *
+     * @emits StoreIncrement.
+     */
+    private emitDurableIncrement;
+    /**
+     * Performs change calculation and emits an ephemeral increment.
+     *
+     * @emits EphemeralStoreIncrement
+     */
+    private emitEphemeralIncrement;
+    private applyChangeToSnapshot;
+    /**
+     * Clones the snapshot if there are changes detected.
+     */
+    private maybeCloneSnapshot;
+    private flushMicroActions;
+    private processAction;
+    /**
+     * Returns the scheduled macro action.
+     */
+    private getScheduledMacroAction;
+    /**
+     * Ensures that the scheduled actions invariant is satisfied.
+     */
+    private satisfiesScheduledActionsInvariant;
+}
+/**
+ * Repsents a change to the store containing changed elements and appState.
+ */
+export declare class StoreChange {
+    readonly elements: Record<string, OrderedExcalidrawElement>;
+    readonly appState: Partial<ObservedAppState>;
+    private constructor();
+    static create(prevSnapshot: StoreSnapshot, nextSnapshot: StoreSnapshot): StoreChange;
+}
+/**
+ * Encpasulates any change to the store (durable or ephemeral).
+ */
+export declare abstract class StoreIncrement {
+    readonly type: "durable" | "ephemeral";
+    readonly change: StoreChange;
+    protected constructor(type: "durable" | "ephemeral", change: StoreChange);
+    static isDurable(increment: StoreIncrement): increment is DurableIncrement;
+    static isEphemeral(increment: StoreIncrement): increment is EphemeralIncrement;
+}
+/**
+ * Represents a durable change to the store.
+ */
+export declare class DurableIncrement extends StoreIncrement {
+    readonly change: StoreChange;
+    readonly delta: StoreDelta;
+    constructor(change: StoreChange, delta: StoreDelta);
+}
+/**
+ * Represents an ephemeral change to the store.
+ */
+export declare class EphemeralIncrement extends StoreIncrement {
+    readonly change: StoreChange;
+    constructor(change: StoreChange);
+}
+/**
+ * Represents a captured delta by the Store.
+ */
+export declare class StoreDelta {
+    readonly id: string;
+    readonly elements: ElementsDelta;
+    readonly appState: AppStateDelta;
+    protected constructor(id: string, elements: ElementsDelta, appState: AppStateDelta);
+    /**
+     * Create a new instance of `StoreDelta`.
+     */
+    static create(elements: ElementsDelta, appState: AppStateDelta, opts?: {
+        id: string;
+    }): StoreDelta;
+    /**
+     * Restore a store delta instance from a DTO.
+     */
+    static restore(storeDeltaDTO: DTO<StoreDelta>): StoreDelta;
+    /**
+     * Parse and load the delta from the remote payload.
+     */
+    static load({ id, elements: { added, removed, updated }, }: DTO<StoreDelta>): StoreDelta;
+    /**
+     * Inverse store delta, creates new instance of `StoreDelta`.
+     */
+    static inverse(delta: StoreDelta): StoreDelta;
+    /**
+     * Apply latest (remote) changes to the delta, creates new instance of `StoreDelta`.
+     */
+    static applyLatestChanges(delta: StoreDelta, elements: SceneElementsMap, modifierOptions: "deleted" | "inserted"): StoreDelta;
+    /**
+     * Apply the delta to the passed elements and appState, does not modify the snapshot.
+     */
+    static applyTo(delta: StoreDelta, elements: SceneElementsMap, appState: AppState, prevSnapshot?: StoreSnapshot): [SceneElementsMap, AppState, boolean];
+    isEmpty(): boolean;
+}
+/**
+ * Represents a snapshot of the captured or updated changes in the store,
+ * used for producing deltas and emitting `DurableStoreIncrement`s.
+ */
+export declare class StoreSnapshot {
+    readonly elements: SceneElementsMap;
+    readonly appState: ObservedAppState;
+    readonly metadata: {
+        didElementsChange: boolean;
+        didAppStateChange: boolean;
+        isEmpty?: boolean;
+    };
+    private _lastChangedElementsHash;
+    private _lastChangedAppStateHash;
+    private constructor();
+    static create(elements: SceneElementsMap, appState: AppState | ObservedAppState, metadata?: {
+        didElementsChange: boolean;
+        didAppStateChange: boolean;
+    }): StoreSnapshot;
+    static empty(): StoreSnapshot;
+    getChangedElements(prevSnapshot: StoreSnapshot): Record<string, OrderedExcalidrawElement>;
+    getChangedAppState(prevSnapshot: StoreSnapshot): Partial<ObservedAppState>;
+    isEmpty(): boolean | undefined;
+    /**
+     * Apply the change and return a new snapshot instance.
+     */
+    applyChange(change: StoreChange): StoreSnapshot;
+    /**
+     * Efficiently clone the existing snapshot, only if we detected changes.
+     *
+     * @returns same instance if there are no changes detected, new instance otherwise.
+     */
+    maybeClone(action: CaptureUpdateActionType, elements: SceneElementsMap | undefined, appState: AppState | ObservedAppState | undefined): StoreSnapshot;
+    private maybeCreateAppStateSnapshot;
+    private maybeCreateElementsSnapshot;
+    private detectChangedAppState;
+    /**
+     * Detect if there any changed elements.
+     */
+    private detectChangedElements;
+    /**
+     * Perform structural clone, deep cloning only elements that changed.
+     */
+    private createElementsSnapshot;
+}
+export declare const getObservedAppState: (appState: AppState) => ObservedAppState;

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

@@ -1,9 +1,11 @@
 import type { AppState } from "@excalidraw/excalidraw/types";
 import type { ExtractSetType } from "@excalidraw/common/utility-types";
+import type { Radians } from "@excalidraw/math";
+import type { Scene } from "./Scene";
 import type { MaybeTransformHandleType } from "./transformHandles";
 import type { ElementsMap, ExcalidrawElement, ExcalidrawElementType, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, NonDeletedExcalidrawElement } from "./types";
-export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null, elementsMap: ElementsMap, informMutation?: boolean) => void;
-export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, elementsMap: ElementsMap, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean) => void;
+export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null, scene: Scene) => void;
+export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, scene: Scene, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean) => void;
 export declare const computeBoundTextPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
     x: number;
     y: number;
@@ -19,7 +21,7 @@ export declare const getContainerCoords: (container: NonDeletedExcalidrawElement
     x: number;
     y: number;
 };
-export declare const getTextElementAngle: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null) => import("../../math/src").Radians;
+export declare const getTextElementAngle: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null) => 0 | Radians;
 export declare const getBoundTextElementPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
     x: number;
     y: number;

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

@@ -32,9 +32,9 @@ export declare const canResizeFromSides: (device: Device) => boolean;
 export declare const getOmitSidesForDevice: (device: Device) => {};
 export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [number, number, number, number, number, number], angle: Radians, zoom: Zoom, pointerType: PointerType, omitSides?: {
     s?: boolean | undefined;
-    n?: boolean | undefined;
-    w?: boolean | undefined;
     e?: boolean | undefined;
+    w?: boolean | undefined;
+    n?: boolean | undefined;
     nw?: boolean | undefined;
     ne?: boolean | undefined;
     sw?: boolean | undefined;
@@ -43,9 +43,9 @@ export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [
 }, margin?: number, spacing?: number) => TransformHandles;
 export declare const getTransformHandles: (element: ExcalidrawElement, zoom: Zoom, elementsMap: ElementsMap, pointerType?: PointerType, omitSides?: {
     s?: boolean | undefined;
-    n?: boolean | undefined;
-    w?: boolean | undefined;
     e?: boolean | undefined;
+    w?: boolean | undefined;
+    n?: boolean | undefined;
     nw?: boolean | undefined;
     ne?: boolean | undefined;
     sw?: boolean | undefined;