@excalidraw/excalidraw 0.18.0-6fc8502 → 0.18.0-a18b139

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

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

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

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

package/dist/types/common/src/constants.d.ts

@@ -82,6 +82,7 @@ export declare const YOUTUBE_STATES: {
 export declare const ENV: {
     TEST: string;
     DEVELOPMENT: string;
+    PRODUCTION: string;
 };
 export declare const CLASSES: {
     SHAPE_ACTIONS_MENU: string;
@@ -224,6 +225,7 @@ export declare const DEFAULT_EXPORT_PADDING = 10;
 export declare const DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT = 1440;
 export declare const MAX_ALLOWED_FILE_BYTES: number;
 export declare const SVG_NS = "http://www.w3.org/2000/svg";
+export declare const SVG_DOCUMENT_PREAMBLE = "<?xml version=\"1.0\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n";
 export declare const ENCRYPTION_KEY_BITS = 128;
 export declare const VERSIONS: {
     readonly excalidraw: 2;

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

@@ -1,4 +1,5 @@
-import type { ExcalidrawBindableElement, FontFamilyValues, FontString } from "@excalidraw/element/types";
+import { type GlobalPoint } from "@excalidraw/math";
+import type { ExcalidrawBindableElement, FontFamilyValues, FontString, ExcalidrawElement } from "@excalidraw/element/types";
 import type { ActiveTool, AppState, ToolType, UnsubscribeCallback, Zoom } from "@excalidraw/excalidraw/types";
 import type { MaybePromise } from "./utility-types";
 import type { EVENT } from "./constants";
@@ -179,6 +180,7 @@ export type Node<T> = T & {
 export declare const arrayToList: <T>(array: readonly T[]) => Node<T>[];
 export declare const isTestEnv: () => boolean;
 export declare const isDevEnv: () => boolean;
+export declare const isProdEnv: () => boolean;
 export declare const isServerEnv: () => boolean;
 export declare const wrapEvent: <T extends Event>(name: EVENT, nativeEvent: T) => CustomEvent<{
     nativeEvent: T;
@@ -248,4 +250,8 @@ export declare const safelyParseJSON: (json: string) => Record<string, any> | nu
  */
 export declare const escapeDoubleQuotes: (str: string) => string;
 export declare const castArray: <T>(value: T | T[]) => T[];
+export declare const elementCenterPoint: (element: ExcalidrawElement, xOffset?: number, yOffset?: number) => GlobalPoint;
+/** hack for Array.isArray type guard not working with readonly value[] */
+export declare const isReadonlyArray: (value?: any) => value is readonly any[];
+export declare const sizeOf: (value: readonly number[] | Readonly<Map<any, any>> | Record<any, any>) => number;
 export {};

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

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

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

@@ -1,7 +1,7 @@
-import type Scene from "@excalidraw/excalidraw/scene/Scene";
-import type { ElementsMap, ExcalidrawElement } from "./types";
+import type Scene from "./Scene";
+import type { ExcalidrawElement } from "./types";
 export interface Alignment {
     position: "start" | "center" | "end";
     axis: "x" | "y";
 }
-export declare const alignElements: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, alignment: Alignment, scene: Scene) => ExcalidrawElement[];
+export declare const alignElements: (selectedElements: ExcalidrawElement[], alignment: Alignment, scene: Scene) => ExcalidrawElement[];

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

@@ -1,11 +1,11 @@
 import { type GlobalPoint } from "@excalidraw/math";
 import type { LocalPoint } from "@excalidraw/math";
-import type Scene from "@excalidraw/excalidraw/scene/Scene";
 import type { AppState } from "@excalidraw/excalidraw/types";
 import { type Heading } from "./heading";
+import type Scene from "./Scene";
 import type { Bounds } from "./bounds";
 import type { ElementUpdate } from "./mutateElement";
-import type { ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, ExcalidrawLinearElement, NonDeletedExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap, OrderedExcalidrawElement, ExcalidrawElbowArrowElement, FixedPoint, SceneElementsMap } from "./types";
+import type { ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, ExcalidrawLinearElement, NonDeletedExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap, OrderedExcalidrawElement, ExcalidrawElbowArrowElement, FixedPoint } from "./types";
 export type SuggestedBinding = NonDeleted<ExcalidrawBindableElement> | SuggestedPointBinding;
 export type SuggestedPointBinding = [
     NonDeleted<ExcalidrawLinearElement>,
@@ -17,20 +17,20 @@ export declare const isBindingEnabled: (appState: AppState) => boolean;
 export declare const FIXED_BINDING_DISTANCE = 5;
 export declare const BINDING_HIGHLIGHT_THICKNESS = 10;
 export declare const BINDING_HIGHLIGHT_OFFSET = 4;
-export declare const bindOrUnbindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, startBindingElement: ExcalidrawBindableElement | null | "keep", endBindingElement: ExcalidrawBindableElement | null | "keep", elementsMap: NonDeletedSceneElementsMap, scene: Scene) => void;
-export declare const bindOrUnbindLinearElements: (selectedElements: NonDeleted<ExcalidrawLinearElement>[], elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[], scene: Scene, isBindingEnabled: boolean, draggingPoints: readonly number[] | null, zoom?: AppState["zoom"]) => void;
+export declare const bindOrUnbindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, startBindingElement: ExcalidrawBindableElement | null | "keep", endBindingElement: ExcalidrawBindableElement | null | "keep", scene: Scene) => void;
+export declare const bindOrUnbindLinearElements: (selectedElements: NonDeleted<ExcalidrawLinearElement>[], isBindingEnabled: boolean, draggingPoints: readonly number[] | null, scene: Scene, zoom?: AppState["zoom"]) => void;
 export declare const getSuggestedBindingsForArrows: (selectedElements: NonDeleted<ExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, zoom: AppState["zoom"]) => SuggestedBinding[];
 export declare const maybeBindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, appState: AppState, pointerCoords: {
     x: number;
     y: number;
-}, elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[]) => void;
-export declare const bindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: NonDeletedSceneElementsMap) => void;
+}, scene: Scene) => void;
+export declare const bindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", scene: Scene) => void;
 export declare const isLinearElementSimpleAndAlreadyBound: (linearElement: NonDeleted<ExcalidrawLinearElement>, alreadyBoundToId: ExcalidrawBindableElement["id"] | undefined, bindableElement: ExcalidrawBindableElement) => boolean;
 export declare const getHoveredElementForBinding: (pointerCoords: {
     x: number;
     y: number;
 }, elements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap, zoom?: AppState["zoom"], fullShape?: boolean, considerAllElements?: boolean) => NonDeleted<ExcalidrawBindableElement> | null;
-export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, options?: {
+export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, scene: Scene, options?: {
     simultaneouslyUpdated?: readonly ExcalidrawElement[];
     newSize?: {
         width: number;
@@ -38,15 +38,14 @@ export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawE
     };
     changedElements?: Map<string, OrderedExcalidrawElement>;
 }) => void;
-export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, elementsMap: ElementsMap, origPoint: GlobalPoint, zoom?: AppState["zoom"]) => Heading;
+export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, origPoint: GlobalPoint, zoom?: AppState["zoom"]) => Heading;
 export declare const bindPointToSnapToElementOutline: (arrow: ExcalidrawElbowArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end") => GlobalPoint;
 export declare const avoidRectangularCorner: (element: ExcalidrawBindableElement, p: GlobalPoint) => GlobalPoint;
 export declare const snapToMid: (element: ExcalidrawBindableElement, p: GlobalPoint, tolerance?: number) => GlobalPoint;
-export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => {
+export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end") => {
     fixedPoint: FixedPoint;
 };
-export declare const fixDuplicatedBindingsAfterDuplication: (newElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicatedElementsMap: NonDeletedSceneElementsMap) => void;
-export declare const fixReversedBindings: (originalElements: Map<string, ExcalidrawElement>, elementsWithClones: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+export declare const fixDuplicatedBindingsAfterDuplication: (duplicatedElements: ExcalidrawElement[], origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicateElementsMap: NonDeletedSceneElementsMap) => void;
 export declare const fixBindingsAfterDeletion: (sceneElements: readonly ExcalidrawElement[], deletedElements: readonly ExcalidrawElement[]) => void;
 export declare const bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
     x: number;

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

@@ -1,6 +1,6 @@
 import type { Degrees, GlobalPoint, LineSegment } from "@excalidraw/math";
 import type { AppState } from "@excalidraw/excalidraw/types";
-import type { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, ExcalidrawFreeDrawElement, NonDeleted, ElementsMap } from "./types";
+import type { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, ExcalidrawFreeDrawElement, NonDeleted, ElementsMap, ElementsMapOrArray } from "./types";
 import type { Drawable, Op } from "roughjs/bin/core";
 export type RectangleBox = {
     x: number;
@@ -51,7 +51,7 @@ export declare const getArrowheadSize: (arrowhead: Arrowhead) => number;
 export declare const getArrowheadAngle: (arrowhead: Arrowhead) => Degrees;
 export declare const getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead) => number[] | null;
 export declare const getElementBounds: (element: ExcalidrawElement, elementsMap: ElementsMap) => Bounds;
-export declare const getCommonBounds: (elements: readonly ExcalidrawElement[], elementsMap?: ElementsMap) => Bounds;
+export declare const getCommonBounds: (elements: ElementsMapOrArray, elementsMap?: ElementsMap) => Bounds;
 export declare const getDraggedElementsBounds: (elements: ExcalidrawElement[], dragOffset: {
     x: number;
     y: number;

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

@@ -1,5 +1,5 @@
+import { type GeometricShape } from "@excalidraw/utils/shape";
 import type { GlobalPoint, LineSegment, LocalPoint } from "@excalidraw/math";
-import type { GeometricShape } from "@excalidraw/utils/shape";
 import type { FrameNameBounds } from "@excalidraw/excalidraw/types";
 import type { ElementsMap, ExcalidrawElement } from "./types";
 export declare const shouldTestInside: (element: ExcalidrawElement) => boolean;

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

@@ -1,6 +1,6 @@
 import type { AppState, NormalizedZoomValue, NullableGridSize, PointerDownState } from "@excalidraw/excalidraw/types";
-import type Scene from "@excalidraw/excalidraw/scene/Scene";
 import type { NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+import type Scene from "./Scene";
 export declare const dragSelectedElements: (pointerDownState: PointerDownState, _selectedElements: NonDeletedExcalidrawElement[], offset: {
     x: number;
     y: number;
@@ -9,7 +9,7 @@ export declare const dragSelectedElements: (pointerDownState: PointerDownState,
     y: number;
 }, gridSize: NullableGridSize) => void;
 export declare const getDragOffsetXY: (selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
-export declare const dragNewElement: ({ newElement, elementType, originX, originY, x, y, width, height, shouldMaintainAspectRatio, shouldResizeFromCenter, zoom, widthAspectRatio, originOffset, informMutation, }: {
+export declare const dragNewElement: ({ newElement, elementType, originX, originY, x, y, width, height, shouldMaintainAspectRatio, shouldResizeFromCenter, zoom, scene, widthAspectRatio, originOffset, informMutation, }: {
     newElement: NonDeletedExcalidrawElement;
     elementType: AppState["activeTool"]["type"];
     originX: number;
@@ -21,6 +21,7 @@ export declare const dragNewElement: ({ newElement, elementType, originX, origin
     shouldMaintainAspectRatio: boolean;
     shouldResizeFromCenter: boolean;
     zoom: NormalizedZoomValue;
+    scene: Scene;
     /** whether to keep given aspect ratio when `isResizeWithSidesSameLength` is
         true */
     widthAspectRatio?: number | null | undefined;

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

@@ -13,13 +13,16 @@ import type { ExcalidrawElement, GroupId } from "./types";
  *                               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, randomizeSeed?: boolean) => Readonly<TElement>;
+export declare const duplicateElement: <TElement extends ExcalidrawElement>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, randomizeSeed?: boolean) => Readonly<TElement>;
 export declare const duplicateElements: (opts: {
     elements: readonly ExcalidrawElement[];
     randomizeSeed?: boolean | undefined;
-    overrides?: ((originalElement: ExcalidrawElement) => Partial<ExcalidrawElement>) | undefined;
+    overrides?: ((data: {
+        duplicateElement: ExcalidrawElement;
+        origElement: ExcalidrawElement;
+        origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>;
+    }) => Partial<ExcalidrawElement>) | undefined;
 } & ({
     /**
      * Duplicates all elements in array.
@@ -42,17 +45,11 @@ export declare const duplicateElements: (opts: {
         editingGroupId: AppState["editingGroupId"];
         selectedGroupIds: AppState["selectedGroupIds"];
     };
-    /**
-     * If true, duplicated elements are inserted _before_ specified
-     * elements. Case: alt-dragging elements to duplicate them.
-     *
-     * TODO: remove this once (if) we stop replacing the original element
-     * with the duplicated one in the scene array.
-     */
-    reverseOrder: boolean;
 })) => {
-    newElements: ExcalidrawElement[];
-    elementsWithClones: ExcalidrawElement[];
+    duplicatedElements: ExcalidrawElement[];
+    duplicateElementsMap: Map<string, ExcalidrawElement>;
+    elementsWithDuplicates: ExcalidrawElement[];
+    origIdToDuplicateId: Map<string, string>;
 };
 /**
  * Clones ExcalidrawElement data structure. Does not regenerate id, nonce, or

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

@@ -8,7 +8,7 @@ export declare const BASE_PADDING = 40;
  */
 export declare const updateElbowArrowPoints: (arrow: Readonly<ExcalidrawElbowArrowElement>, elementsMap: NonDeletedSceneElementsMap, updates: {
     points?: readonly LocalPoint[];
-    fixedSegments?: FixedSegment[] | null;
+    fixedSegments?: readonly FixedSegment[] | null;
     startBinding?: FixedPointBinding | null;
     endBinding?: FixedPointBinding | null;
 }, options?: {

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

@@ -1,9 +1,10 @@
 import type { AppState, PendingExcalidrawElements } from "@excalidraw/excalidraw/types";
 import { type ElementsMap, type ExcalidrawBindableElement, type ExcalidrawElement, type ExcalidrawFlowchartNodeElement } from "./types";
+import type Scene from "./Scene";
 type LinkDirection = "up" | "right" | "down" | "left";
 export declare const getLinkDirectionFromKey: (key: string) => LinkDirection;
 export declare const getPredecessors: (node: ExcalidrawBindableElement, elementsMap: ElementsMap, direction: LinkDirection) => ExcalidrawBindableElement[];
-export declare const addNewNodes: (startNode: ExcalidrawFlowchartNodeElement, elementsMap: ElementsMap, appState: AppState, direction: LinkDirection, numberOfNodes: number) => ExcalidrawElement[];
+export declare const addNewNodes: (startNode: ExcalidrawFlowchartNodeElement, appState: AppState, direction: LinkDirection, scene: Scene, numberOfNodes: number) => ExcalidrawElement[];
 export declare class FlowChartNavigator {
     isExploring: boolean;
     private sameLevelNodes;
@@ -18,7 +19,7 @@ export declare class FlowChartCreator {
     private numberOfNodes;
     private direction;
     pendingNodes: PendingExcalidrawElements | null;
-    createNodes(startNode: ExcalidrawFlowchartNodeElement, elementsMap: ElementsMap, appState: AppState, direction: LinkDirection): void;
+    createNodes(startNode: ExcalidrawFlowchartNodeElement, appState: AppState, direction: LinkDirection, scene: Scene): void;
     clear(): void;
 }
 export declare const isNodeInFlowchart: (element: ExcalidrawFlowchartNodeElement, elementsMap: ElementsMap) => boolean;

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

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

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

@@ -1,8 +1,8 @@
-import type { ExcalidrawElementsIncludingDeleted } from "@excalidraw/excalidraw/scene/Scene";
 import type { AppClassProperties, AppState, StaticCanvasAppState } from "@excalidraw/excalidraw/types";
 import type { ReadonlySetLike } from "@excalidraw/common/utility-types";
+import type { ExcalidrawElementsIncludingDeleted } from "./Scene";
 import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "./types";
-export declare const bindElementsToFramesAfterDuplication: (nextElements: readonly ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+export declare const bindElementsToFramesAfterDuplication: (nextElements: readonly ExcalidrawElement[], origElements: readonly ExcalidrawElement[], origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
 export declare function isElementIntersectingFrame(element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap): boolean;
 export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
 export declare const isElementContainingFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;

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

@@ -1,10 +1,10 @@
 /// <reference types="react" />
 import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
-import Scene from "@excalidraw/excalidraw/scene/Scene";
 import type { Store } from "@excalidraw/excalidraw/store";
 import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize, Zoom } from "@excalidraw/excalidraw/types";
+import type Scene from "./Scene";
 import type { Bounds } from "./bounds";
-import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, SceneElementsMap, ExcalidrawElbowArrowElement } from "./types";
+import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, ExcalidrawElbowArrowElement } from "./types";
 declare const editorMidPointsCache: {
     version: number | null;
     points: (GlobalPoint | null)[];
@@ -43,7 +43,7 @@ export declare class LinearElementEditor {
     readonly hoverPointIndex: number;
     readonly segmentMidPointHoveredCoords: GlobalPoint | null;
     readonly elbowed: boolean;
-    constructor(element: NonDeleted<ExcalidrawLinearElement>);
+    constructor(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap);
     static POINT_HANDLE_SIZE: number;
     /**
      * @param id the `elementId` from the instance of this class (so that we can
@@ -77,7 +77,7 @@ export declare class LinearElementEditor {
         linearElementEditor: LinearElementEditor | null;
     };
     static arePointsEqual<Point extends LocalPoint | GlobalPoint>(point1: Point | null, point2: Point | null): boolean;
-    static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, app: AppClassProperties, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): LinearElementEditor | null;
+    static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, app: AppClassProperties): LinearElementEditor | null;
     /** scene coords */
     static getPointGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, p: LocalPoint, elementsMap: ElementsMap): GlobalPoint;
     /** scene coords */
@@ -97,22 +97,22 @@ export declare class LinearElementEditor {
         x: number;
         y: number;
     };
-    static normalizePoints(element: NonDeleted<ExcalidrawLinearElement>): void;
-    static duplicateSelectedPoints(appState: AppState, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): AppState;
-    static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[]): void;
-    static addPoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
+    static normalizePoints(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap): void;
+    static duplicateSelectedPoints(appState: AppState, scene: Scene): AppState;
+    static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene, pointIndices: readonly number[]): void;
+    static addPoints(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene, targetPoints: {
         point: LocalPoint;
     }[]): void;
-    static movePoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
+    static movePoints(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene, targetPoints: {
         index: number;
         point: LocalPoint;
         isDragging?: boolean;
     }[], otherUpdates?: {
         startBinding?: PointBinding | null;
         endBinding?: PointBinding | null;
-    }, sceneElementsMap?: NonDeletedSceneElementsMap): void;
+    }): void;
     static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState, elementsMap: ElementsMap): boolean;
-    static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, elementsMap: ElementsMap): {
+    static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, scene: Scene): {
         pointerDownState: LinearElementEditor["pointerDownState"];
         selectedPointsIndices: LinearElementEditor["selectedPointsIndices"];
     } | undefined;
@@ -124,7 +124,7 @@ export declare class LinearElementEditor {
     };
     static getMinMaxXYWithBoundText: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, elementBounds: Bounds, boundTextElement: ExcalidrawTextElementWithContainer) => [number, number, number, number, number, number];
     static getElementAbsoluteCoords: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, includeBoundText?: boolean) => [number, number, number, number, number, number];
-    static moveFixedSegment(linearElement: LinearElementEditor, index: number, x: number, y: number, elementsMap: ElementsMap): LinearElementEditor;
-    static deleteFixedSegment(element: ExcalidrawElbowArrowElement, index: number): void;
+    static moveFixedSegment(linearElement: LinearElementEditor, index: number, x: number, y: number, scene: Scene): LinearElementEditor;
+    static deleteFixedSegment(element: ExcalidrawElbowArrowElement, scene: Scene, index: number): void;
 }
 export {};

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

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

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

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

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

@@ -1,4 +1,5 @@
 import type { AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
+import { LinearElementEditor } from "./linearElementEditor";
 import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "./types";
 /**
  * Frames and their containing elements are not to be selected at the same time.
@@ -30,3 +31,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) => {
+    editingGroupId: string | null;
+    selectedElementIds: Readonly<{
+        [id: string]: true;
+    }>;
+    selectedGroupIds: {
+        [groupId: string]: boolean;
+    };
+    selectedLinearElement: LinearElementEditor | null;
+};

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

@@ -26,7 +26,6 @@ export declare const getLockedLinearCursorAlignSize: (originX: number, originY:
     width: number;
     height: number;
 };
-export declare const resizePerfectLineForNWHandler: (element: ExcalidrawElement, x: number, y: number) => void;
 export declare const getNormalizedDimensions: (element: Pick<ExcalidrawElement, "width" | "height" | "x" | "y">) => {
     width: ExcalidrawElement["width"];
     height: ExcalidrawElement["height"];

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

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

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

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

package/dist/types/excalidraw/actions/actionAddToLibrary.d.ts

@@ -77,7 +77,7 @@ export declare const actionAddToLibrary: {
             zoom: Readonly<{
                 value: import("../types").NormalizedZoomValue;
             }>;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -248,7 +248,7 @@ export declare const actionAddToLibrary: {
             zoom: Readonly<{
                 value: import("../types").NormalizedZoomValue;
             }>;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -424,7 +424,7 @@ export declare const actionAddToLibrary: {
             zoom: Readonly<{
                 value: import("../types").NormalizedZoomValue;
             }>;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;

package/dist/types/excalidraw/actions/actionBoundText.d.ts

@@ -97,7 +97,7 @@ export declare const actionBindText: {
             zoom: Readonly<{
                 value: import("../types").NormalizedZoomValue;
             }>;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -285,7 +285,7 @@ export declare const actionWrapTextInContainer: {
             zoom: Readonly<{
                 value: import("../types").NormalizedZoomValue;
             }>;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;