@excalidraw/element 0.18.0-d2463f87d → 0.18.0-d9e8a33

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

@@ -1,45 +1,45 @@
-/// <reference types="react" />
 import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
 import { type Store } from "@excalidraw/element";
 import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize, Zoom } from "@excalidraw/excalidraw/types";
+import type { Bounds } from "@excalidraw/common";
 import type { Scene } from "./Scene";
-import type { Bounds } from "./bounds";
-import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, ExcalidrawElbowArrowElement, PointsPositionUpdates } from "./types";
+import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, FixedPointBinding, ExcalidrawElbowArrowElement, PointsPositionUpdates } from "./types";
 export declare class LinearElementEditor {
     readonly elementId: ExcalidrawElement["id"] & {
         _brand: "excalidrawLinearElementId";
     };
     /** indices */
     readonly selectedPointsIndices: readonly number[] | null;
-    readonly pointerDownState: Readonly<{
+    readonly initialState: Readonly<{
         prevSelectedPointsIndices: readonly number[] | null;
         /** index */
         lastClickedPoint: number;
-        lastClickedIsEndPoint: boolean;
-        origin: Readonly<{
-            x: number;
-            y: number;
-        }> | null;
+        origin: Readonly<GlobalPoint> | null;
         segmentMidpoint: {
             value: GlobalPoint | null;
             index: number | null;
             added: boolean;
         };
+        arrowStartIsInside: boolean;
+        altFocusPoint: Readonly<GlobalPoint> | null;
     }>;
     /** whether you're dragging a point */
     readonly isDragging: boolean;
     readonly lastUncommittedPoint: LocalPoint | null;
+    readonly lastCommittedPoint: LocalPoint | null;
     readonly pointerOffset: Readonly<{
         x: number;
         y: number;
     }>;
-    readonly startBindingElement: ExcalidrawBindableElement | null | "keep";
-    readonly endBindingElement: ExcalidrawBindableElement | null | "keep";
     readonly hoverPointIndex: number;
     readonly segmentMidPointHoveredCoords: GlobalPoint | null;
+    readonly hoveredFocusPointBinding: "start" | "end" | null;
+    readonly draggedFocusPointBinding: "start" | "end" | null;
     readonly elbowed: boolean;
     readonly customLineAngle: number | null;
-    constructor(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap);
+    readonly isEditing: boolean;
+    readonly pointerDownState: never;
+    constructor(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, isEditing?: boolean);
     static POINT_HANDLE_SIZE: number;
     /**
      * @param id the `elementId` from the instance of this class (so that we can
@@ -47,18 +47,16 @@ export declare class LinearElementEditor {
      */
     static getElement<T extends ExcalidrawLinearElement>(id: InstanceType<typeof LinearElementEditor>["elementId"], elementsMap: ElementsMap): T | null;
     static handleBoxSelection(event: PointerEvent, appState: AppState, setState: React.Component<any, AppState>["setState"], elementsMap: NonDeletedSceneElementsMap): false | undefined;
-    /**
-     * @returns whether point was dragged
-     */
-    static handlePointDragging(event: PointerEvent, app: AppClassProperties, scenePointerX: number, scenePointerY: number, linearElementEditor: LinearElementEditor): Pick<AppState, keyof AppState> | null;
+    static handlePointerMove(event: PointerEvent, app: AppClassProperties, scenePointerX: number, scenePointerY: number, linearElementEditor: LinearElementEditor): Pick<AppState, "suggestedBinding" | "selectedLinearElement"> | null;
+    static handlePointDragging(event: PointerEvent, app: AppClassProperties, scenePointerX: number, scenePointerY: number, linearElementEditor: LinearElementEditor): Pick<AppState, "suggestedBinding" | "selectedLinearElement"> | null;
     static handlePointerUp(event: PointerEvent, editingLinearElement: LinearElementEditor, appState: AppState, scene: Scene): LinearElementEditor;
     static getEditorMidPoints: (element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => (GlobalPoint | null)[];
     static getSegmentMidpointHitCoords: (linearElementEditor: LinearElementEditor, scenePointer: {
         x: number;
         y: number;
     }, appState: AppState, elementsMap: ElementsMap) => GlobalPoint | null;
-    static isSegmentTooShort<P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, startPoint: P, endPoint: P, index: number, zoom: Zoom): boolean;
-    static getSegmentMidPoint(element: NonDeleted<ExcalidrawLinearElement>, index: number): GlobalPoint;
+    static isSegmentTooShort<P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, startPoint: P, endPoint: P, index: number, zoom: Zoom, elementsMap: ElementsMap): boolean;
+    static getSegmentMidPoint(element: NonDeleted<ExcalidrawLinearElement>, index: number, elementsMap: ElementsMap): GlobalPoint;
     static getSegmentMidPointIndex(linearElementEditor: LinearElementEditor, appState: AppState, midPoint: GlobalPoint, elementsMap: ElementsMap): number;
     static handlePointerDown(event: React.PointerEvent<HTMLElement>, app: AppClassProperties, store: Store, scenePointer: {
         x: number;
@@ -69,7 +67,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): LinearElementEditor | null;
+    static handlePointerMoveInEditMode(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 */
@@ -95,12 +93,16 @@ export declare class LinearElementEditor {
     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;
+        startBinding?: FixedPointBinding | null;
+        endBinding?: FixedPointBinding | null;
+        moveMidPointsWithElement?: boolean | null;
+    }, options?: {
+        isBindingEnabled?: boolean;
+        isMidpointSnappingEnabled?: boolean;
     }): void;
     static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState, elementsMap: ElementsMap): boolean;
     static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, scene: Scene): {
-        pointerDownState: LinearElementEditor["pointerDownState"];
+        pointerDownState: LinearElementEditor["initialState"];
         selectedPointsIndices: LinearElementEditor["selectedPointsIndices"];
     } | undefined;
     private static _updatePoints;
@@ -111,6 +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, scene: Scene): LinearElementEditor;
+    static moveFixedSegment(linearElement: LinearElementEditor, index: number, x: number, y: number, scene: Scene): Pick<LinearElementEditor, "segmentMidPointHoveredCoords" | "initialState">;
     static deleteFixedSegment(element: ExcalidrawElbowArrowElement, scene: Scene, index: number): void;
 }

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

@@ -11,8 +11,12 @@ export type ElementUpdate<TElement extends ExcalidrawElement> = Omit<Partial<TEl
  */
 export declare const mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, elementsMap: ElementsMap, updates: ElementUpdate<TElement>, options?: {
     isDragging?: boolean;
+    isBindingEnabled?: boolean;
+    isMidpointSnappingEnabled?: boolean;
 }) => TElement;
-export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, force?: boolean) => TElement;
+export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, 
+/** pass `true` to always regenerate */
+force?: boolean) => TElement;
 /**
  * Mutates element, bumping `version`, `versionNonce`, and `updated`.
  *

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

@@ -47,12 +47,12 @@ export declare const newLinearElement: (opts: {
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawLinearElement>;
 export declare const newArrowElement: <T extends boolean>(opts: {
     type: ExcalidrawArrowElement["type"];
-    startArrowhead?: Arrowhead | null | undefined;
-    endArrowhead?: Arrowhead | null | undefined;
-    points?: readonly import("@excalidraw/math").LocalPoint[] | undefined;
-    elbowed?: T | undefined;
-    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>;
+    startArrowhead?: Arrowhead | null;
+    endArrowhead?: Arrowhead | null;
+    points?: ExcalidrawArrowElement["points"];
+    elbowed?: T;
+    fixedSegments?: ExcalidrawElbowArrowElement["fixedSegments"] | null;
+} & ElementConstructorOpts) => T extends true ? NonDeleted<ExcalidrawElbowArrowElement> : NonDeleted<ExcalidrawArrowElement>;
 export declare const newImageElement: (opts: {
     type: ExcalidrawImageElement["type"];
     status?: ExcalidrawImageElement["status"];

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

@@ -0,0 +1,2 @@
+import type { ExcalidrawElement } from "./types";
+export declare const positionElementsOnGrid: <TElement extends ExcalidrawElement>(elements: TElement[] | TElement[][], centerX: number, centerY: number, padding?: number) => TElement[];

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

@@ -1,8 +1,8 @@
+import { type GlobalPoint } from "@excalidraw/math";
 import type { AppState, StaticCanvasAppState, InteractiveCanvasAppState, ElementsPendingErasure, PendingExcalidrawElements } from "@excalidraw/excalidraw/types";
 import type { StaticCanvasRenderConfig, RenderableElementsMap, InteractiveCanvasRenderConfig } from "@excalidraw/excalidraw/scene/types";
-import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawImageElement, ExcalidrawFrameLikeElement, NonDeletedSceneElementsMap } from "./types";
+import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawImageElement, ExcalidrawFrameLikeElement, NonDeletedSceneElementsMap, ElementsMap } from "./types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
-export declare const IMAGE_INVERT_FILTER = "invert(100%) hue-rotate(180deg) saturate(1.25)";
 export declare const getRenderOpacity: (element: ExcalidrawElement, containingFrame: ExcalidrawFrameLikeElement | null, elementsPendingErasure: ElementsPendingErasure, pendingNodes: Readonly<PendingExcalidrawElements> | null, globalAlpha?: number) => number;
 export interface ExcalidrawElementWithCanvas {
     element: ExcalidrawElement | ExcalidrawTextElement;
@@ -21,8 +21,5 @@ export interface ExcalidrawElementWithCanvas {
 export declare const DEFAULT_LINK_SIZE = 14;
 export declare const elementWithCanvasCache: WeakMap<ExcalidrawElement, ExcalidrawElementWithCanvas>;
 export declare const renderSelectionElement: (element: NonDeletedExcalidrawElement, context: CanvasRenderingContext2D, appState: InteractiveCanvasAppState, selectionColor: InteractiveCanvasRenderConfig["selectionColor"]) => void;
-export declare const renderElement: (element: NonDeletedExcalidrawElement, elementsMap: RenderableElementsMap, allElementsMap: NonDeletedSceneElementsMap, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState) => void;
-export declare const pathsCache: WeakMap<ExcalidrawFreeDrawElement, Path2D>;
-export declare function generateFreeDrawShape(element: ExcalidrawFreeDrawElement): Path2D;
-export declare function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement): Path2D | undefined;
-export declare function getFreeDrawSvgPath(element: ExcalidrawFreeDrawElement): string;
+export declare const renderElement: (element: NonDeletedExcalidrawElement, elementsMap: RenderableElementsMap, allElementsMap: NonDeletedSceneElementsMap, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState | InteractiveCanvasAppState) => void;
+export declare function getFreedrawOutlineAsSegments(element: ExcalidrawFreeDrawElement, points: [number, number][], elementsMap: ElementsMap): import("@excalidraw/math").LineSegment<GlobalPoint>[];

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

@@ -17,16 +17,16 @@ export declare const resizeSingleTextElement: (origElement: NonDeleted<Excalidra
 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, originalElementsMap: ElementsMap, scene: Scene, handleDirection: TransformHandleDirection, { shouldInformMutation, shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
-    shouldMaintainAspectRatio?: boolean | undefined;
-    shouldResizeFromCenter?: boolean | undefined;
-    shouldInformMutation?: boolean | undefined;
+    shouldMaintainAspectRatio?: boolean;
+    shouldResizeFromCenter?: boolean;
+    shouldInformMutation?: boolean;
 }) => void;
 export declare const resizeMultipleElements: (selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, handleDirection: TransformHandleDirection, scene: Scene, originalElementsMap: ElementsMap, { shouldMaintainAspectRatio, shouldResizeFromCenter, flipByX, flipByY, nextHeight, nextWidth, originalBoundingBox, }?: {
-    nextWidth?: number | undefined;
-    nextHeight?: number | undefined;
-    shouldMaintainAspectRatio?: boolean | undefined;
-    shouldResizeFromCenter?: boolean | undefined;
-    flipByX?: boolean | undefined;
-    flipByY?: boolean | undefined;
-    originalBoundingBox?: BoundingBox | undefined;
+    nextWidth?: number;
+    nextHeight?: number;
+    shouldMaintainAspectRatio?: boolean;
+    shouldResizeFromCenter?: boolean;
+    flipByX?: boolean;
+    flipByY?: boolean;
+    originalBoundingBox?: BoundingBox;
 }) => void;

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

@@ -1,14 +1,15 @@
+import { type EditorInterface } from "@excalidraw/common";
 import type { GlobalPoint, LocalPoint } from "@excalidraw/math";
-import type { AppState, Device, Zoom } from "@excalidraw/excalidraw/types";
-import type { Bounds } from "./bounds";
+import type { AppState, Zoom } from "@excalidraw/excalidraw/types";
+import type { Bounds } from "@excalidraw/common";
 import type { MaybeTransformHandleType } from "./transformHandles";
 import type { ExcalidrawElement, PointerType, NonDeletedExcalidrawElement, ElementsMap } from "./types";
-export declare const resizeTest: <Point extends GlobalPoint | LocalPoint>(element: NonDeletedExcalidrawElement, elementsMap: ElementsMap, appState: AppState, x: number, y: number, zoom: Zoom, pointerType: PointerType, device: Device) => MaybeTransformHandleType;
-export declare const getElementWithTransformHandleType: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType, elementsMap: ElementsMap, device: Device) => {
+export declare const resizeTest: <Point extends GlobalPoint | LocalPoint>(element: NonDeletedExcalidrawElement, elementsMap: ElementsMap, appState: AppState, x: number, y: number, zoom: Zoom, pointerType: PointerType, editorInterface: EditorInterface) => MaybeTransformHandleType;
+export declare const getElementWithTransformHandleType: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType, elementsMap: ElementsMap, editorInterface: EditorInterface) => {
     element: NonDeletedExcalidrawElement;
     transformHandleType: MaybeTransformHandleType;
 } | null;
-export declare const getTransformHandleTypeFromCoords: <Point extends GlobalPoint | LocalPoint>([x1, y1, x2, y2]: Bounds, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType, device: Device) => MaybeTransformHandleType;
+export declare const getTransformHandleTypeFromCoords: <Point extends GlobalPoint | LocalPoint>([x1, y1, x2, y2]: Bounds, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType, editorInterface: EditorInterface) => MaybeTransformHandleType;
 export declare const getCursorForResizingElement: (resizingElement: {
     element?: ExcalidrawElement;
     transformHandleType: MaybeTransformHandleType;

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

@@ -1,6 +1,6 @@
-import type { AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
+import type { AppState, BoxSelectionMode, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
 import { LinearElementEditor } from "./linearElementEditor";
-import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "./types";
+import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement } from "./types";
 /**
  * Frames and their containing elements are not to be selected at the same time.
  * Given an array of selected elements, if there are frames and their containing elements
@@ -8,7 +8,7 @@ import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExca
  * @param selectedElements
  */
 export declare const excludeElementsInFramesFromSelection: <T extends ExcalidrawElement>(selectedElements: readonly T[]) => T[];
-export declare const getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement, elementsMap: ElementsMap, excludeElementsInFrames?: boolean) => NonDeletedExcalidrawElement[];
+export declare const getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement, elementsMap: ElementsMap, excludeElementsInFrames?: boolean, boxSelectionMode?: BoxSelectionMode) => NonDeletedExcalidrawElement[];
 export declare const getVisibleAndNonSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: readonly NonDeletedExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => NonDeletedExcalidrawElement[];
 export declare const isSomeElementSelected: {
     (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">): boolean;
@@ -27,12 +27,12 @@ export declare const makeNextSelectedElementIds: (nextSelectedElementIds: AppSta
     [id: string]: true;
 }>;
 export declare const getSelectionStateForElements: (targetElements: readonly ExcalidrawElement[], allElements: readonly NonDeletedExcalidrawElement[], appState: AppState) => {
-    editingGroupId: string | null;
-    selectedElementIds: Readonly<{
-        [id: string]: true;
-    }>;
-    selectedGroupIds: {
-        [groupId: string]: boolean;
-    };
+    editingGroupId: AppState["editingGroupId"];
+    selectedElementIds: AppState["selectedElementIds"];
+    selectedGroupIds: AppState["selectedGroupIds"];
     selectedLinearElement: LinearElementEditor | null;
 };
+/**
+ * Returns editing or single-selected text element, if any.
+ */
+export declare const getActiveTextElement: (selectedElements: readonly NonDeleted<ExcalidrawElement>[], appState: Pick<AppState, "editingTextElement">) => import("./types").ExcalidrawTextElement | null;

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

@@ -3,7 +3,7 @@ import { type LocalPoint } from "@excalidraw/math";
 import type { GlobalPoint } from "@excalidraw/math";
 import type { AppState, EmbedsValidationStatus } from "@excalidraw/excalidraw/types";
 import type { ElementShape, ElementShapes } from "@excalidraw/excalidraw/scene/types";
-import type { ExcalidrawElement, ExcalidrawLinearElement, ExcalidrawFreeDrawElement, ElementsMap, ExcalidrawLineElement } from "./types";
+import type { ExcalidrawElement, ExcalidrawSelectionElement, ExcalidrawLinearElement, ExcalidrawFreeDrawElement, ElementsMap, ExcalidrawLineElement } from "./types";
 import type { Drawable, Options } from "roughjs/bin/core";
 export declare class ShapeCache {
     private static rg;
@@ -12,22 +12,22 @@ export declare class ShapeCache {
      * Retrieves shape from cache if available. Use this only if shape
      * is optional and you have a fallback in case it's not cached.
      */
-    static get: <T extends ExcalidrawElement>(element: T) => T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined;
-    static set: <T extends ExcalidrawElement>(element: T, shape: T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable) => WeakMap<ExcalidrawElement, ElementShape>;
-    static delete: (element: ExcalidrawElement) => boolean;
+    static get: <T extends ExcalidrawElement>(element: T, theme: AppState["theme"] | null) => (T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined) | undefined;
+    static delete: (element: ExcalidrawElement) => void;
     static destroy: () => void;
     /**
      * Generates & caches shape for element if not already cached, otherwise
      * returns cached shape.
      */
-    static generateElementShape: <T extends ExcalidrawLinearElement | import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawEmbeddableElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawTextElement | ExcalidrawFreeDrawElement | import("./types").ExcalidrawArrowElement>(element: T, renderConfig: {
+    static generateElementShape: <T extends Exclude<ExcalidrawElement, ExcalidrawSelectionElement>>(element: T, renderConfig: {
         isExporting: boolean;
         canvasBackgroundColor: AppState["viewBackgroundColor"];
         embedsValidationStatus: EmbedsValidationStatus;
-    } | null) => ((T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined) & ({} | null)) | (T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable | null);
+        theme: AppState["theme"];
+    } | null) => ((T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined) & {}) | (T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable | null);
 }
-export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean) => Options;
-export declare const generateLinearCollisionShape: (element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement) => {
+export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean, isDarkMode?: boolean) => Options;
+export declare const generateLinearCollisionShape: (element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement, elementsMap: ElementsMap) => {
     op: string;
     data: number[];
 }[];
@@ -40,3 +40,4 @@ export declare const toggleLinePolygonState: (element: ExcalidrawLineElement, ne
     polygon: ExcalidrawLineElement["polygon"];
     points: ExcalidrawLineElement["points"];
 } | null;
+export declare const getFreedrawOutlinePoints: (element: ExcalidrawFreeDrawElement) => [number, number][];

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

@@ -3,6 +3,7 @@ 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 { ApplyToOptions } from "./delta";
 import type { ExcalidrawElement, OrderedExcalidrawElement, SceneElementsMap } from "./types";
 export declare const CaptureUpdateAction: {
     /**
@@ -168,7 +169,11 @@ export declare class StoreDelta {
     /**
      * Parse and load the delta from the remote payload.
      */
-    static load({ id, elements: { added, removed, updated }, }: DTO<StoreDelta>): StoreDelta;
+    static load({ id, elements: { added, removed, updated }, appState: { delta: appStateDelta }, }: DTO<StoreDelta>): StoreDelta;
+    /**
+     * Squash the passed deltas into the aggregated delta instance.
+     */
+    static squash(...deltas: StoreDelta[]): StoreDelta;
     /**
      * Inverse store delta, creates new instance of `StoreDelta`.
      */
@@ -176,11 +181,12 @@ export declare class StoreDelta {
     /**
      * Apply the delta to the passed elements and appState, does not modify the snapshot.
      */
-    static applyTo(delta: StoreDelta, elements: SceneElementsMap, appState: AppState): [SceneElementsMap, AppState, boolean];
+    static applyTo(delta: StoreDelta, elements: SceneElementsMap, appState: AppState, options?: ApplyToOptions): [SceneElementsMap, AppState, boolean];
     /**
      * Apply latest (remote) changes to the delta, creates new instance of `StoreDelta`.
      */
     static applyLatestChanges(delta: StoreDelta, prevElements: SceneElementsMap, nextElements: SceneElementsMap, modifierOptions?: "deleted" | "inserted"): StoreDelta;
+    static empty(): StoreDelta;
     isEmpty(): boolean;
 }
 /**

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

@@ -1,6 +1,6 @@
+import { type Radians } from "@excalidraw/math";
 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";
@@ -31,7 +31,7 @@ export declare const suppportsHorizontalAlign: (selectedElements: NonDeletedExca
 declare const VALID_CONTAINER_TYPES: Set<string>;
 export declare const isValidTextContainer: (element: {
     type: ExcalidrawElementType;
-}) => boolean;
+}) => element is ExcalidrawTextContainer;
 export declare const computeContainerDimensionForBoundText: (dimension: number, containerType: ExtractSetType<typeof VALID_CONTAINER_TYPES>) => number;
 export declare const getBoundTextMaxWidth: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElement | null) => number;
 export declare const getBoundTextMaxHeight: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => number;

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

@@ -11,9 +11,7 @@ export declare const normalizeText: (text: string) => string;
  * To get unitless line-height (if unknown) we can calculate it by dividing
  * height-per-line by fontSize.
  */
-export declare const detectLineHeight: (textElement: ExcalidrawTextElement) => number & {
-    _brand: "unitlessLineHeight";
-};
+export declare const detectLineHeight: (textElement: ExcalidrawTextElement) => ExcalidrawTextElement["lineHeight"];
 /**
  * We calculate the line height from the font size and the unitless line height,
  * aligning with the W3C spec.

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

@@ -5,9 +5,35 @@ import type { FontString } from "./types";
 export declare const containsCJK: (text: string) => boolean;
 /**
  * Breaks the line into the tokens based on the found line break opporutnities.
+ *
+ * Note: tokenization normalizes to NFC first so decomposed graphemes are treated as
+ * their composed variants for wrapping. Any code that needs exact source offsets should
+ * keep in mind that this assumes the input text is already NFC-normalized.
  */
 export declare const parseTokens: (line: string) => string[];
 /**
  * Wraps the original text into the lines based on the given width.
+ *
+ * This is a convenience adapter over `getWrappedTextLines()` for call sites
+ * that only need the rendered wrapped string and not the source offsets.
  */
 export declare const wrapText: (text: string, font: FontString, maxWidth: number) => string;
+/**
+ * A single rendered visual line produced from the original text.
+ *
+ * `start` and `end` are end-exclusive code-unit offsets into the original text, and do
+ * not include synthetic soft line breaks inserted by this module. If trailing whitespace
+ * was trimmed away at a wrap boundary, `end` points to the last rendered character.
+ */
+export type WrappedTextLine = {
+    text: string;
+    start: number;
+    end: number;
+};
+/**
+ * Returns the rendered visual lines together with their source offsets.
+ *
+ * This is the source-of-truth wrapping pipeline for callers that need more than the
+ * final wrapped string, for example caret placement or future editor/rich-text mapping.
+ */
+export declare const getWrappedTextLines: (text: string, font: FontString, maxWidth: number) => WrappedTextLine[];

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

@@ -1,6 +1,6 @@
-import type { ElementConstructorOpts } from "@excalidraw/element";
-import type { ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawFrameElement, ExcalidrawFreeDrawElement, ExcalidrawGenericElement, ExcalidrawIframeLikeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawMagicFrameElement, ExcalidrawSelectionElement, ExcalidrawTextElement, FileId, FontFamilyValues, TextAlign, VerticalAlign } from "@excalidraw/element/types";
 import type { MarkOptional } from "@excalidraw/common/utility-types";
+import { type ElementConstructorOpts } from "./newElement";
+import type { ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawFrameElement, ExcalidrawFreeDrawElement, ExcalidrawGenericElement, ExcalidrawIframeLikeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawMagicFrameElement, ExcalidrawSelectionElement, ExcalidrawTextElement, FileId, FontFamilyValues, TextAlign, VerticalAlign } from "./types";
 export type ValidLinearElement = {
     type: "arrow" | "line";
     x: number;
@@ -78,4 +78,4 @@ export type ExcalidrawElementSkeleton = Extract<Exclude<ExcalidrawElement, Excal
 } & Partial<ExcalidrawMagicFrameElement>);
 export declare const convertToExcalidrawElements: (elementsSkeleton: ExcalidrawElementSkeleton[] | null, opts?: {
     regenerateIds: boolean;
-}) => import("@excalidraw/element/types").OrderedExcalidrawElement[];
+}) => import("./types").OrderedExcalidrawElement[];

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

@@ -1,6 +1,7 @@
+import { type EditorInterface } from "@excalidraw/common";
 import type { Radians } from "@excalidraw/math";
-import type { Device, InteractiveCanvasAppState, Zoom } from "@excalidraw/excalidraw/types";
-import type { Bounds } from "./bounds";
+import type { InteractiveCanvasAppState, Zoom } from "@excalidraw/excalidraw/types";
+import type { Bounds } from "@excalidraw/common";
 import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
 export type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
 export type TransformHandleType = TransformHandleDirection | "rotation";
@@ -28,28 +29,8 @@ export declare const OMIT_SIDES_FOR_FRAME: {
     w: boolean;
     rotation: boolean;
 };
-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;
-    nw?: boolean | undefined;
-    ne?: boolean | undefined;
-    sw?: boolean | undefined;
-    se?: boolean | undefined;
-    rotation?: boolean | undefined;
-}, 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;
-    nw?: boolean | undefined;
-    ne?: boolean | undefined;
-    sw?: boolean | undefined;
-    se?: boolean | undefined;
-    rotation?: boolean | undefined;
-}) => TransformHandles;
-export declare const shouldShowBoundingBox: (elements: readonly NonDeletedExcalidrawElement[], appState: InteractiveCanvasAppState) => boolean;
+export declare const canResizeFromSides: (editorInterface: EditorInterface) => boolean;
+export declare const getOmitSidesForEditorInterface: (editorInterface: EditorInterface) => {};
+export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [number, number, number, number, number, number], angle: Radians, zoom: Zoom, pointerType: PointerType, omitSides?: { [T in TransformHandleType]?: boolean; }, margin?: number, spacing?: number) => TransformHandles;
+export declare const getTransformHandles: (element: ExcalidrawElement, zoom: Zoom, elementsMap: ElementsMap, pointerType?: PointerType, omitSides?: { [T in TransformHandleType]?: boolean; }) => TransformHandles;
+export declare const hasBoundingBox: (elements: readonly NonDeletedExcalidrawElement[], appState: InteractiveCanvasAppState, editorInterface: EditorInterface) => boolean;

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

@@ -1,7 +1,6 @@
 import type { ElementOrToolType } from "@excalidraw/excalidraw/types";
 import type { MarkNonNullable } from "@excalidraw/common/utility-types";
-import type { Bounds } from "./bounds";
-import type { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawEmbeddableElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, ExcalidrawFrameElement, RoundnessType, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeElement, ExcalidrawIframeLikeElement, ExcalidrawMagicFrameElement, ExcalidrawArrowElement, ExcalidrawElbowArrowElement, ExcalidrawLineElement, PointBinding, FixedPointBinding, ExcalidrawFlowchartNodeElement, ExcalidrawLinearElementSubType } from "./types";
+import type { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawEmbeddableElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, ExcalidrawFrameElement, RoundnessType, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeElement, ExcalidrawIframeLikeElement, ExcalidrawMagicFrameElement, ExcalidrawArrowElement, ExcalidrawElbowArrowElement, ExcalidrawLineElement, ExcalidrawFlowchartNodeElement, ExcalidrawLinearElementSubType } from "./types";
 export declare const isInitializedImageElement: (element: ExcalidrawElement | null) => element is InitializedExcalidrawImageElement;
 export declare const isImageElement: (element: ExcalidrawElement | null) => element is ExcalidrawImageElement;
 export declare const isEmbeddableElement: (element: ExcalidrawElement | null | undefined) => element is ExcalidrawEmbeddableElement;
@@ -24,7 +23,7 @@ export declare const isSimpleArrow: (element?: ExcalidrawElement) => element is
 export declare const isSharpArrow: (element?: ExcalidrawElement) => element is ExcalidrawArrowElement;
 export declare const isCurvedArrow: (element?: ExcalidrawElement) => element is ExcalidrawArrowElement;
 export declare const isLinearElementType: (elementType: ElementOrToolType) => boolean;
-export declare const isBindingElement: (element?: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawLinearElement;
+export declare const isBindingElement: (element?: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawArrowElement;
 export declare const isBindingElementType: (elementType: ElementOrToolType) => boolean;
 export declare const isBindableElement: (element: ExcalidrawElement | null | undefined, includeLocked?: boolean) => element is ExcalidrawBindableElement;
 export declare const isRectanguloidElement: (element?: ExcalidrawElement | null) => element is ExcalidrawBindableElement;
@@ -35,16 +34,14 @@ export declare const isFlowchartNodeElement: (element: ExcalidrawElement) => ele
 export declare const hasBoundTextElement: (element: ExcalidrawElement | null) => element is MarkNonNullable<ExcalidrawBindableElement, "boundElements">;
 export declare const isBoundToContainer: (element: ExcalidrawElement | null) => element is ExcalidrawTextElementWithContainer;
 export declare const isArrowBoundToElement: (element: ExcalidrawArrowElement) => boolean;
-export declare const isUsingAdaptiveRadius: (type: string) => boolean;
-export declare const isUsingProportionalRadius: (type: string) => boolean;
+export declare const isUsingAdaptiveRadius: (type: string) => type is "rectangle" | "embeddable" | "iframe" | "image";
+export declare const isUsingProportionalRadius: (type: string) => type is "line" | "arrow" | "diamond";
 export declare const canApplyRoundnessTypeToElement: (roundnessType: RoundnessType, element: ExcalidrawElement) => boolean;
 export declare const getDefaultRoundnessTypeForElement: (element: ExcalidrawElement) => {
     type: 2;
 } | {
     type: 3;
 } | null;
-export declare const isFixedPointBinding: (binding: PointBinding | FixedPointBinding) => binding is FixedPointBinding;
-export declare const isBounds: (box: unknown) => box is Bounds;
 export declare const getLinearElementSubType: (element: ExcalidrawLinearElement) => ExcalidrawLinearElementSubType;
 /**
  * Checks if current element points meet all the conditions for polygon=true

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

@@ -1,7 +1,7 @@
 import type { LocalPoint, Radians } from "@excalidraw/math";
 import type { FONT_FAMILY, ROUNDNESS, TEXT_ALIGN, THEME, VERTICAL_ALIGN } from "@excalidraw/common";
 import type { MakeBrand, MarkNonNullable, Merge, ValueOf } from "@excalidraw/common/utility-types";
-export type ChartType = "bar" | "line";
+export type ChartType = "bar" | "line" | "radar";
 export type FillStyle = "hachure" | "cross-hatch" | "solid" | "zigzag";
 export type FontFamilyKeys = keyof typeof FONT_FAMILY;
 export type FontFamilyValues = typeof FONT_FAMILY[FontFamilyKeys];
@@ -197,26 +197,26 @@ export type ExcalidrawTextElementWithContainer = {
     containerId: ExcalidrawTextContainer["id"];
 } & ExcalidrawTextElement;
 export type FixedPoint = [number, number];
-export type PointBinding = {
+export type BindMode = "inside" | "orbit" | "skip";
+export type FixedPointBinding = {
     elementId: ExcalidrawBindableElement["id"];
-    focus: number;
-    gap: number;
-};
-export type FixedPointBinding = Merge<PointBinding, {
     fixedPoint: FixedPoint;
-}>;
+    mode: BindMode;
+};
 type Index = number;
 export type PointsPositionUpdates = Map<Index, {
     point: LocalPoint;
     isDragging?: boolean;
 }>;
-export type Arrowhead = "arrow" | "bar" | "dot" | "circle" | "circle_outline" | "triangle" | "triangle_outline" | "diamond" | "diamond_outline" | "crowfoot_one" | "crowfoot_many" | "crowfoot_one_or_many";
+export type CardinalityArrowhead = "cardinality_one" | "cardinality_many" | "cardinality_one_or_many" | "cardinality_exactly_one" | "cardinality_zero_or_one" | "cardinality_zero_or_many";
+export type ArrowheadLegacy = "dot" | "crowfoot_one" | "crowfoot_many" | "crowfoot_one_or_many";
+export type Arrowhead = "arrow" | "bar" | "circle" | "circle_outline" | "triangle" | "triangle_outline" | "diamond" | "diamond_outline" | CardinalityArrowhead;
+export type AnyArrowhead = Arrowhead | ArrowheadLegacy;
 export type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<{
     type: "line" | "arrow";
     points: readonly LocalPoint[];
-    lastCommittedPoint: LocalPoint | null;
-    startBinding: PointBinding | null;
-    endBinding: PointBinding | null;
+    startBinding: FixedPointBinding | null;
+    endBinding: FixedPointBinding | null;
     startArrowhead: Arrowhead | null;
     endArrowhead: Arrowhead | null;
 }>;
@@ -235,9 +235,9 @@ export type ExcalidrawArrowElement = ExcalidrawLinearElement & Readonly<{
 }>;
 export type ExcalidrawElbowArrowElement = Merge<ExcalidrawArrowElement, {
     elbowed: true;
+    fixedSegments: readonly FixedSegment[] | null;
     startBinding: FixedPointBinding | null;
     endBinding: FixedPointBinding | null;
-    fixedSegments: readonly FixedSegment[] | null;
     /**
      * Marks that the 3rd point should be used as the 2nd point of the arrow in
      * order to temporarily hide the first segment of the arrow without losing
@@ -260,7 +260,6 @@ export type ExcalidrawFreeDrawElement = _ExcalidrawElementBase & Readonly<{
     points: readonly LocalPoint[];
     pressures: readonly number[];
     simulatePressure: boolean;
-    lastCommittedPoint: LocalPoint | null;
 }>;
 export type FileId = string & {
     _brand: "FileId";