@excalidraw/excalidraw 0.18.0-817d8c5 → 0.18.0-864353b

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

@@ -1,6 +1,5 @@
-import type { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap, ExcalidrawArrowElement, FixedSegment, ExcalidrawElbowArrowElement } from "./types";
-import type { AppState } from "../types";
-import type { MarkOptional, Mutable } from "../utility-types";
+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, 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"];
@@ -44,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"];
@@ -51,7 +51,7 @@ 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;
+    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"];
@@ -60,42 +60,3 @@ export declare const newImageElement: (opts: {
     scale?: ExcalidrawImageElement["scale"];
     crop?: ExcalidrawImageElement["crop"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawImageElement>;
-/**
- * Clones ExcalidrawElement data structure. Does not regenerate id, nonce, or
- * any value. The purpose is to to break object references for immutability
- * reasons, whenever we want to keep the original element, but ensure it's not
- * mutated.
- *
- * Only clones plain objects and arrays. Doesn't clone Date, RegExp, Map, Set,
- * Typed arrays and other non-null objects.
- */
-export declare const deepCopyElement: <T extends ExcalidrawElement>(val: T) => Mutable<T>;
-/**
- * Duplicate an element, often used in the alt-drag operation.
- * Note that this method has gotten a bit complicated since the
- * introduction of gruoping/ungrouping elements.
- * @param editingGroupId The current group being edited. The new
- *                       element will inherit this group and its
- *                       parents.
- * @param groupIdMapForOperation A Map that maps old group IDs to
- *                               duplicated ones. If you are duplicating
- *                               multiple elements at once, share this map
- *                               amongst all of them
- * @param element Element to duplicate
- * @param overrides Any element properties to override
- */
-export declare const duplicateElement: <TElement extends ExcalidrawElement>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, overrides?: Partial<TElement> | undefined) => Readonly<TElement>;
-/**
- * Clones elements, regenerating their ids (including bindings) and group ids.
- *
- * If bindings don't exist in the elements array, they are removed. Therefore,
- * it's advised to supply the whole elements array, or sets of elements that
- * are encapsulated (such as library items), if the purpose is to retain
- * bindings to the cloned elements intact.
- *
- * NOTE by default does not randomize or regenerate anything except the id.
- */
-export declare const duplicateElements: (elements: readonly ExcalidrawElement[], opts?: {
-    /** NOTE also updates version flags and `updated` */
-    randomizeSeed: boolean;
-}) => ExcalidrawElement[];

package/dist/types/{excalidraw/renderer → element/src}/renderElement.d.ts

@@ -1,7 +1,7 @@
-import type { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawImageElement, ExcalidrawFrameLikeElement, NonDeletedSceneElementsMap } from "../element/types";
+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 { RoughCanvas } from "roughjs/bin/canvas";
-import type { StaticCanvasRenderConfig, RenderableElementsMap, InteractiveCanvasRenderConfig } from "../scene/types";
-import type { AppState, StaticCanvasAppState, InteractiveCanvasAppState, ElementsPendingErasure, PendingExcalidrawElements } from "../types";
 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 {

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

@@ -1,10 +1,10 @@
-import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawElement, ElementsMap, SceneElementsMap } from "./types";
+import { type LocalPoint } from "@excalidraw/math";
+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 { PointerDownState } from "../types";
-import type Scene from "../scene/Scene";
-import { type LocalPoint } from "@excalidraw/math";
-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/{excalidraw/element → element/src}/resizeTest.d.ts

@@ -1,8 +1,8 @@
-import type { ExcalidrawElement, PointerType, NonDeletedExcalidrawElement, ElementsMap } from "./types";
-import type { MaybeTransformHandleType } from "./transformHandles";
-import type { AppState, Device, Zoom } from "../types";
-import type { Bounds } from "./bounds";
 import type { GlobalPoint, LocalPoint } from "@excalidraw/math";
+import type { AppState, Device, Zoom } from "@excalidraw/excalidraw/types";
+import type { Bounds } from "./bounds";
+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) => {
     element: NonDeletedExcalidrawElement;

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

@@ -1,5 +1,6 @@
-import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
-import type { AppState, InteractiveCanvasAppState } from "../types";
+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.
  * Given an array of selected elements, if there are frames and their containing elements
@@ -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

@@ -0,0 +1,27 @@
+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, ExcalidrawLineElement, NonDeleted } from "./types";
+/**
+ * get the pure geometric shape of an excalidraw elementw
+ * which is then used for hit detection
+ */
+export declare const getElementShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape<Point>;
+export declare const getBoundTextShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape<Point> | null;
+export declare const getControlPointsForBezierCurve: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P) => P[] | null;
+export declare const getBezierXY: <P extends GlobalPoint | LocalPoint>(p0: P, p1: P, p2: P, p3: P, t: number) => P;
+export declare const getBezierCurveLength: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P) => number;
+export declare const mapIntervalToBezierT: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P, interval: number) => number;
+/**
+ * Get the axis-aligned bounding box for a given element
+ */
+export declare const aabbForElement: (element: Readonly<ExcalidrawElement>, offset?: [number, number, number, number]) => Bounds;
+export declare const pointInsideBounds: <P extends GlobalPoint | LocalPoint>(p: P, bounds: Bounds) => boolean;
+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/{excalidraw/element → element/src}/showSelectedShapeActions.d.ts

@@ -1,3 +1,3 @@
+import type { UIAppState } from "@excalidraw/excalidraw/types";
 import type { NonDeletedExcalidrawElement } from "./types";
-import type { UIAppState } from "../types";
 export declare const showSelectedShapeActions: (appState: UIAppState, elements: readonly NonDeletedExcalidrawElement[]) => boolean;

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

@@ -1,5 +1,6 @@
+import type { AppState, Offsets, Zoom } from "@excalidraw/excalidraw/types";
 import type { ElementsMap, ExcalidrawElement } from "./types";
-import type { AppState, Offsets, Zoom } 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;
@@ -22,11 +23,10 @@ export declare const getPerfectElementSize: (elementType: AppState["activeTool"]
     width: number;
     height: number;
 };
-export declare const getLockedLinearCursorAlignSize: (originX: number, originY: number, x: number, y: number) => {
+export declare const getLockedLinearCursorAlignSize: (originX: number, originY: number, x: number, y: number, customAngle?: number) => {
     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/{excalidraw/element → element/src}/textElement.d.ts

@@ -1,10 +1,11 @@
-import type { ElementsMap, ExcalidrawElement, ExcalidrawElementType, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, NonDeletedExcalidrawElement } from "./types";
+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 { AppState } from "../types";
-import type { ExtractSetType } from "../utility-types";
-export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null, elementsMap: ElementsMap, informMutation?: boolean) => void;
-export declare const bindTextToShapeAfterDuplication: (newElements: ExcalidrawElement[], oldElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
-export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, elementsMap: ElementsMap, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean) => void;
+import type { ElementsMap, ExcalidrawElement, ExcalidrawElementType, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, NonDeletedExcalidrawElement } from "./types";
+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;
@@ -20,7 +21,7 @@ export declare const getContainerCoords: (container: NonDeletedExcalidrawElement
     x: number;
     y: number;
 };
-export declare const getTextElementAngle: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null) => import("@excalidraw/math").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/{excalidraw/element → element/src}/transformHandles.d.ts

@@ -1,7 +1,7 @@
-import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
-import type { Bounds } from "./bounds";
-import type { Device, InteractiveCanvasAppState, Zoom } from "../types";
 import type { Radians } from "@excalidraw/math";
+import type { Device, InteractiveCanvasAppState, Zoom } from "@excalidraw/excalidraw/types";
+import type { Bounds } from "./bounds";
+import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
 export type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
 export type TransformHandleType = TransformHandleDirection | "rotation";
 export type TransformHandle = Bounds;

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

@@ -1,7 +1,7 @@
-import type { ElementOrToolType } from "../types";
-import type { MarkNonNullable } from "../utility-types";
+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, PointBinding, FixedPointBinding, ExcalidrawFlowchartNodeElement } from "./types";
+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";
 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;
@@ -14,8 +14,11 @@ export declare const isFrameLikeElement: (element: ExcalidrawElement | null) =>
 export declare const isFreeDrawElement: (element?: ExcalidrawElement | null) => element is ExcalidrawFreeDrawElement;
 export declare const isFreeDrawElementType: (elementType: ExcalidrawElementType) => boolean;
 export declare const isLinearElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
+export declare const isLineElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLineElement;
 export declare const isArrowElement: (element?: ExcalidrawElement | null) => element is ExcalidrawArrowElement;
 export declare const isElbowArrow: (element?: ExcalidrawElement) => element is ExcalidrawElbowArrowElement;
+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 isBindingElementType: (elementType: ElementOrToolType) => boolean;
@@ -27,6 +30,7 @@ export declare const isExcalidrawElement: (element: any) => element is Excalidra
 export declare const isFlowchartNodeElement: (element: ExcalidrawElement) => element is ExcalidrawFlowchartNodeElement;
 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 canApplyRoundnessTypeToElement: (roundnessType: RoundnessType, element: ExcalidrawElement) => boolean;
@@ -37,3 +41,13 @@ export declare const getDefaultRoundnessTypeForElement: (element: ExcalidrawElem
 } | 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
+ * (this isn't a element type check, for that use isLineElement).
+ *
+ * If you want to check if points *can* be turned into a polygon, use
+ *  canBecomePolygon(points).
+ */
+export declare const isValidPolygon: (points: ExcalidrawLineElement["points"]) => boolean;
+export declare const canBecomePolygon: (points: ExcalidrawLineElement["points"]) => boolean;

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

@@ -1,6 +1,6 @@
 import type { LocalPoint, Radians } from "@excalidraw/math";
-import type { FONT_FAMILY, ROUNDNESS, TEXT_ALIGN, THEME, VERTICAL_ALIGN } from "../constants";
-import type { MakeBrand, MarkNonNullable, Merge, ValueOf } from "../utility-types";
+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 FillStyle = "hachure" | "cross-hatch" | "solid" | "zigzag";
 export type FontFamilyKeys = keyof typeof FONT_FAMILY;
@@ -205,6 +205,11 @@ export type PointBinding = {
 export type FixedPointBinding = Merge<PointBinding, {
     fixedPoint: FixedPoint;
 }>;
+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 ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<{
     type: "line" | "arrow";
@@ -215,10 +220,14 @@ export type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<{
     startArrowhead: Arrowhead | null;
     endArrowhead: Arrowhead | null;
 }>;
+export type ExcalidrawLineElement = ExcalidrawLinearElement & Readonly<{
+    type: "line";
+    polygon: boolean;
+}>;
 export type FixedSegment = {
     start: LocalPoint;
     end: LocalPoint;
-    index: number;
+    index: Index;
 };
 export type ExcalidrawArrowElement = ExcalidrawLinearElement & Readonly<{
     type: "arrow";
@@ -279,4 +288,8 @@ export type SceneElementsMap = Map<ExcalidrawElement["id"], Ordered<ExcalidrawEl
  */
 export type NonDeletedSceneElementsMap = Map<ExcalidrawElement["id"], Ordered<NonDeletedExcalidrawElement>> & MakeBrand<"NonDeletedSceneElementsMap">;
 export type ElementsMapOrArray = readonly ExcalidrawElement[] | Readonly<ElementsMap>;
+export type ExcalidrawLinearElementSubType = "line" | "sharpArrow" | "curvedArrow" | "elbowArrow";
+export type ConvertibleGenericTypes = "rectangle" | "diamond" | "ellipse";
+export type ConvertibleLinearTypes = ExcalidrawLinearElementSubType;
+export type ConvertibleTypes = ConvertibleGenericTypes | ConvertibleLinearTypes;
 export {};

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

@@ -1,6 +1,7 @@
-import type { ExcalidrawElement } from "./element/types";
-import type { AppState } from "./types";
-export declare const moveOneLeft: (allElements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[];
-export declare const moveOneRight: (allElements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[];
+import type { AppState } from "@excalidraw/excalidraw/types";
+import type { Scene } from "./Scene";
+import type { ExcalidrawElement } from "./types";
+export declare const moveOneLeft: (allElements: readonly ExcalidrawElement[], appState: AppState, scene: Scene) => readonly ExcalidrawElement[];
+export declare const moveOneRight: (allElements: readonly ExcalidrawElement[], appState: AppState, scene: Scene) => readonly ExcalidrawElement[];
 export declare const moveAllLeft: (allElements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[] | ExcalidrawElement[];
 export declare const moveAllRight: (allElements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[] | ExcalidrawElement[];