@zsviczian/excalidraw 0.18.0-11 → 0.18.0-12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zsviczian/excalidraw",
-  "version": "0.18.0-11",
+  "version": "0.18.0-12",
   "main": "main.js",
   "module": "./dist/prod/index.js",
   "types": "types/excalidraw/index.d.ts",

package/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/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/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,11 +38,11 @@ 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: (duplicatedElements: ExcalidrawElement[], origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicateElementsMap: NonDeletedSceneElementsMap) => void;

package/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/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/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/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/types/element/src/frame.d.ts

@@ -1,6 +1,6 @@
-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[], origElements: readonly ExcalidrawElement[], origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
 export declare function isElementIntersectingFrame(element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap): boolean;

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

@@ -1,9 +1,9 @@
 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)[];
@@ -42,7 +42,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
@@ -76,7 +76,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 */
@@ -96,22 +96,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;
@@ -123,7 +123,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/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/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,12 +15,12 @@ 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;
 }) => void;
-export declare const getNextSingleWidthAndHeightFromPointer: (latestElement: ExcalidrawElement, origElement: ExcalidrawElement, elementsMap: ElementsMap, originalElementsMap: ElementsMap, handleDirection: TransformHandleDirection, pointerX: number, pointerY: number, { shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
+export declare const getNextSingleWidthAndHeightFromPointer: (latestElement: ExcalidrawElement, origElement: ExcalidrawElement, handleDirection: TransformHandleDirection, pointerX: number, pointerY: number, { shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
     shouldMaintainAspectRatio?: boolean | undefined;
     shouldResizeFromCenter?: boolean | undefined;
 }) => {

package/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/types/element/src/textElement.d.ts

@@ -1,10 +1,11 @@
 import type { AppState } from "@excalidraw/excalidraw/types";
 import type { ExtractSetType } from "@excalidraw/common/utility-types";
-import type { Radians } from "../../math/src";
+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;

package/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/types/excalidraw/actions/actionAddToLibrary.d.ts

@@ -76,7 +76,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;
@@ -283,7 +283,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;
@@ -495,7 +495,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/types/excalidraw/actions/actionBoundText.d.ts

@@ -96,7 +96,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;
@@ -320,7 +320,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;

package/types/excalidraw/actions/actionCanvas.d.ts

@@ -65,6 +65,12 @@ export declare const actionClearCanvas: {
             allowWheelZoom: boolean | undefined;
             pinnedScripts: string[] | undefined;
             customPens: any[] | undefined;
+            name: string | null;
+            zoom: Readonly<{
+                value: import("../types").NormalizedZoomValue;
+            }>;
+            scrollX: number;
+            scrollY: number;
             viewBackgroundColor: string;
             frameRendering: {
                 enabled: boolean;
@@ -77,12 +83,6 @@ export declare const actionClearCanvas: {
                 fill: string;
                 nameColor: string;
             };
-            name: string | null;
-            zoom: Readonly<{
-                value: import("../types").NormalizedZoomValue;
-            }>;
-            scrollX: number;
-            scrollY: number;
             viewModeEnabled: boolean;
             openDialog: {
                 name: "help" | "imageExport" | "jsonExport";
@@ -160,15 +160,6 @@ export declare const actionClearCanvas: {
                     height: number;
                 }[];
             }[];
-            objectsSnapModeEnabled: boolean;
-            shouldCacheIgnoreZoom: boolean;
-            exportScale: number;
-            selectedElementsAreBeingDragged: boolean;
-            linkOpacity: number;
-            currentHoveredFontFamily: number | null;
-            hoveredElementIds: Readonly<{
-                [id: string]: true;
-            }>;
             contextMenu: {
                 items: import("../components/ContextMenu").ContextMenuItems;
                 top: number;
@@ -182,6 +173,7 @@ export declare const actionClearCanvas: {
             startBoundElement: import("@excalidraw/element/types").NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement> | null;
             editingFrame: string | null;
             exportWithDarkMode: boolean;
+            exportScale: number;
             currentItemStrokeColor: string;
             currentItemBackgroundColor: string;
             currentItemFillStyle: import("@excalidraw/element/types").FillStyle;
@@ -194,12 +186,13 @@ export declare const actionClearCanvas: {
             currentItemTextAlign: string;
             currentItemStartArrowhead: import("@excalidraw/element/types").Arrowhead | null;
             currentItemEndArrowhead: import("@excalidraw/element/types").Arrowhead | null;
+            currentHoveredFontFamily: number | null;
             currentItemRoundness: import("@excalidraw/element/types").StrokeRoundness;
             currentItemArrowType: "round" | "sharp" | "elbow";
             cursorButton: "up" | "down";
             scrolledOutside: boolean;
             isResizing: boolean;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -207,9 +200,14 @@ export declare const actionClearCanvas: {
             } | null;
             defaultSidebarDockedPreference: boolean;
             lastPointerDownWith: import("@excalidraw/element/types").PointerType;
+            hoveredElementIds: Readonly<{
+                [id: string]: true;
+            }>;
             previousSelectedElementIds: {
                 [id: string]: true;
             };
+            selectedElementsAreBeingDragged: boolean;
+            shouldCacheIgnoreZoom: boolean;
             toast: {
                 message: string;
                 closable?: boolean | undefined;
@@ -218,6 +216,7 @@ export declare const actionClearCanvas: {
             fileHandle: import("browser-fs-access").FileSystemHandle | null;
             currentChartType: import("@excalidraw/element/types").ChartType;
             showHyperlinkPopup: false | "editor" | "info";
+            linkOpacity: number;
             currentStrokeOptions?: any;
             resetCustomPen?: any;
             dynamicStyle: {
@@ -228,6 +227,7 @@ export declare const actionClearCanvas: {
                 x: number;
                 y: number;
             } | null;
+            objectsSnapModeEnabled: boolean;
             userToFollow: import("../types").UserToFollow | null;
             followedBy: Set<import("../types").SocketId>;
         };
@@ -314,7 +314,7 @@ export declare const actionZoomIn: {
             name: string | null;
             isResizing: boolean;
             isRotating: boolean;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -540,7 +540,7 @@ export declare const actionZoomOut: {
             name: string | null;
             isResizing: boolean;
             isRotating: boolean;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -766,7 +766,7 @@ export declare const actionResetZoom: {
             name: string | null;
             isResizing: boolean;
             isRotating: boolean;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -998,7 +998,7 @@ export declare const zoomToFitBounds: ({ bounds, appState, canvasOffsets, fitToV
         name: string | null;
         isResizing: boolean;
         isRotating: boolean;
-        openMenu: "shape" | "canvas" | null;
+        openMenu: "canvas" | "shape" | null;
         openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
         openSidebar: {
             name: string;
@@ -1226,7 +1226,7 @@ export declare const zoomToFit: ({ canvasOffsets, targetElements, appState, fitT
         name: string | null;
         isResizing: boolean;
         isRotating: boolean;
-        openMenu: "shape" | "canvas" | null;
+        openMenu: "canvas" | "shape" | null;
         openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
         openSidebar: {
             name: string;
@@ -1446,7 +1446,7 @@ export declare const actionZoomToFitSelectionInViewport: {
             name: string | null;
             isResizing: boolean;
             isRotating: boolean;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -1670,7 +1670,7 @@ export declare const actionZoomToFitSelection: {
             name: string | null;
             isResizing: boolean;
             isRotating: boolean;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -1895,7 +1895,7 @@ export declare const actionZoomToFit: {
             name: string | null;
             isResizing: boolean;
             isRotating: boolean;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -2122,7 +2122,7 @@ export declare const actionToggleTheme: {
             zoom: Readonly<{
                 value: import("../types").NormalizedZoomValue;
             }>;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -2344,7 +2344,7 @@ export declare const actionToggleEraserTool: {
             zoom: Readonly<{
                 value: import("../types").NormalizedZoomValue;
             }>;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -2561,7 +2561,7 @@ export declare const actionToggleLassoTool: {
             zoom: Readonly<{
                 value: import("../types").NormalizedZoomValue;
             }>;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -2778,7 +2778,7 @@ export declare const actionToggleHandTool: {
             zoom: Readonly<{
                 value: import("../types").NormalizedZoomValue;
             }>;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -2994,7 +2994,7 @@ export declare const actionToggleLaserPointer: {
             zoom: Readonly<{
                 value: import("../types").NormalizedZoomValue;
             }>;
-            openMenu: "shape" | "canvas" | null;
+            openMenu: "canvas" | "shape" | null;
             openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
@@ -3207,7 +3207,7 @@ export declare const zoomToFitElements: (elements: readonly ExcalidrawElement[],
         name: string | null;
         isResizing: boolean;
         isRotating: boolean;
-        openMenu: "shape" | "canvas" | null;
+        openMenu: "canvas" | "shape" | null;
         openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
         openSidebar: {
             name: string;