@excalidraw/element 0.18.0-9036812b6 → 0.18.0-9ba0f5d

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

@@ -27,12 +27,8 @@ 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;
 };

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,21 +12,21 @@ 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 generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean, isDarkMode?: boolean) => Options;
 export declare const generateLinearCollisionShape: (element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement) => {
     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

@@ -169,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`.
      */
@@ -182,6 +186,7 @@ export declare class StoreDelta {
      * 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";

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/{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

@@ -197,14 +197,12 @@ 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;
@@ -214,9 +212,8 @@ export type Arrowhead = "arrow" | "bar" | "dot" | "circle" | "circle_outline" |
 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 +232,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 +257,6 @@ export type ExcalidrawFreeDrawElement = _ExcalidrawElementBase & Readonly<{
     points: readonly LocalPoint[];
     pressures: readonly number[];
     simulatePressure: boolean;
-    lastCommittedPoint: LocalPoint | null;
 }>;
 export type FileId = string & {
     _brand: "FileId";

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

@@ -1,7 +1,7 @@
 import { type GlobalPoint } from "@excalidraw/math";
 import type { Curve, LineSegment } from "@excalidraw/math";
 import type { Zoom } from "@excalidraw/excalidraw/types";
-import type { ExcalidrawDiamondElement, ExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawLinearElement, ExcalidrawRectanguloidElement } from "./types";
+import type { ElementsMap, ExcalidrawArrowElement, ExcalidrawDiamondElement, ExcalidrawElement, ExcalidrawFreeDrawElement, ExcalidrawLinearElement, ExcalidrawRectanguloidElement } from "./types";
 /**
  * Returns the **rotated** components of freedraw, line or arrow elements.
  *
@@ -27,5 +27,8 @@ export declare function deconstructRectanguloidElement(element: ExcalidrawRectan
  * @returns Tuple of line **unrotated** segments (0) and curves (1)
  */
 export declare function deconstructDiamondElement(element: ExcalidrawDiamondElement, offset?: number): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]];
-export declare const isPathALoop: (points: ExcalidrawLinearElement["points"], zoomValue?: Zoom["value"]) => boolean;
+export declare const isPathALoop: (points: ExcalidrawLinearElement["points"], 
+/** supply if you want the loop detection to account for current zoom */
+zoomValue?: Zoom["value"]) => boolean;
 export declare const getCornerRadius: (x: number, element: ExcalidrawElement) => number;
+export declare const projectFixedPointOntoDiagonal: (arrow: ExcalidrawArrowElement, point: GlobalPoint, element: ExcalidrawElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => GlobalPoint | null;

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

@@ -0,0 +1,59 @@
+import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
+import { type Bounds } from "@excalidraw/common";
+import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
+import type { Curve } from "@excalidraw/math";
+import type { LineSegment } from "@excalidraw/utils";
+declare global {
+    interface Window {
+        visualDebug?: {
+            data: DebugElement[][];
+            currentFrame?: number;
+        };
+    }
+}
+export type DebugElement = {
+    color: string;
+    data: LineSegment<GlobalPoint> | Curve<GlobalPoint> | DebugPolygon;
+    permanent: boolean;
+};
+export type DebugPolygon = {
+    type: "polygon";
+    points: GlobalPoint[];
+    fill?: boolean;
+    close?: boolean;
+};
+export declare const debugDrawHitVolume: (element: ExcalidrawElement, elementsMap: ElementsMap, options?: {
+    rays?: number;
+    color?: string;
+    fill?: boolean;
+}) => void;
+export declare const debugDrawCubicBezier: (c: Curve<GlobalPoint>, opts?: {
+    color?: string;
+    permanent?: boolean;
+}) => void;
+export declare const debugDrawLine: (segment: LineSegment<GlobalPoint> | LineSegment<GlobalPoint>[], opts?: {
+    color?: string;
+    permanent?: boolean;
+}) => void;
+export declare const debugDrawPolygon: (points: GlobalPoint[], opts?: {
+    color?: string;
+    permanent?: boolean;
+    fill?: boolean;
+    close?: boolean;
+}) => void;
+export declare const debugDrawPoint: (p: GlobalPoint, opts?: {
+    color?: string;
+    permanent?: boolean;
+    fuzzy?: boolean;
+}) => void;
+export declare const debugDrawBounds: (box: Bounds | Bounds[], opts?: {
+    color?: string;
+    permanent?: boolean;
+}) => void;
+export declare const debugDrawPoints: ({ x, y, points, }: {
+    x: number;
+    y: number;
+    points: readonly LocalPoint[];
+}, options?: any) => void;
+export declare const debugCloseFrame: () => void;
+export declare const debugClear: () => void;

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

@@ -1,6 +1,12 @@
 import type { AppState } from "@excalidraw/excalidraw/types";
+import type { GlobalPoint } from "@excalidraw/math";
 import type { Scene } from "./Scene";
-import type { ExcalidrawElement } from "./types";
+import type { ExcalidrawArrowElement, ExcalidrawElement, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, Ordered, OrderedExcalidrawElement } from "./types";
+/**
+ * Moves the arrow element above any bindable elements it intersects with or
+ * hovers over.
+ */
+export declare const moveArrowAboveBindable: (point: GlobalPoint, arrow: ExcalidrawArrowElement, elements: readonly Ordered<NonDeletedExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, scene: Scene) => readonly OrderedExcalidrawElement[];
 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[];