@dwelle/excalidraw 0.5.0-3bc80da → 0.5.0-3f1f8dd

package/dist/excalidraw/data/transform.d.ts

@@ -1,6 +1,6 @@
-import { ElementConstructorOpts } from "../element/newElement";
-import { ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawFrameElement, ExcalidrawFreeDrawElement, ExcalidrawGenericElement, ExcalidrawIframeLikeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawMagicFrameElement, ExcalidrawSelectionElement, ExcalidrawTextElement, FileId, FontFamilyValues, TextAlign, VerticalAlign } from "../element/types";
-import { MarkOptional } from "../utility-types";
+import type { ElementConstructorOpts } from "../element/newElement";
+import type { ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawFrameElement, ExcalidrawFreeDrawElement, ExcalidrawGenericElement, ExcalidrawIframeLikeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawMagicFrameElement, ExcalidrawSelectionElement, ExcalidrawTextElement, FileId, FontFamilyValues, TextAlign, VerticalAlign } from "../element/types";
+import type { MarkOptional } from "../utility-types";
 export type ValidLinearElement = {
     type: "arrow" | "line";
     x: number;

package/dist/excalidraw/data/types.d.ts

@@ -1,7 +1,7 @@
-import { ExcalidrawElement } from "../element/types";
-import { AppState, BinaryFiles, LibraryItems, LibraryItems_anyVersion } from "../types";
+import type { ExcalidrawElement } from "../element/types";
+import type { AppState, BinaryFiles, LibraryItems, LibraryItems_anyVersion } from "../types";
 import type { cleanAppStateForExport } from "../appState";
-import { VERSIONS } from "../constants";
+import type { VERSIONS } from "../constants";
 export interface ExportedDataState {
     type: string;
     version: number;

package/dist/excalidraw/element/ElementCanvasButtons.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { ElementsMap, NonDeletedExcalidrawElement } from "./types";
+import type { ElementsMap, NonDeletedExcalidrawElement } from "./types";
 import "./ElementCanvasButtons.scss";
 export declare const ElementCanvasButtons: ({ children, element, elementsMap, }: {
     children: React.ReactNode;

package/dist/excalidraw/element/binding.d.ts

@@ -1,7 +1,6 @@
-import * as GA from "../ga";
-import { ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawRectangleElement, ExcalidrawDiamondElement, ExcalidrawEllipseElement, ExcalidrawImageElement, ExcalidrawFrameLikeElement, ExcalidrawIframeLikeElement, NonDeleted, ExcalidrawLinearElement, NonDeletedExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap, ExcalidrawTextElement } from "./types";
-import { AppClassProperties, AppState, Point } from "../types";
-import { ElementUpdate } from "./mutateElement";
+import type { ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, ExcalidrawLinearElement, NonDeletedExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap } from "./types";
+import type { AppClassProperties, AppState } from "../types";
+import type { ElementUpdate } from "./mutateElement";
 export type SuggestedBinding = NonDeleted<ExcalidrawBindableElement> | SuggestedPointBinding;
 export type SuggestedPointBinding = [
     NonDeleted<ExcalidrawLinearElement>,
@@ -11,14 +10,14 @@ export type SuggestedPointBinding = [
 export declare const shouldEnableBindingForPointerEvent: (event: React.PointerEvent<HTMLElement>) => boolean;
 export declare const isBindingEnabled: (appState: AppState) => boolean;
 export declare const bindOrUnbindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, startBindingElement: ExcalidrawBindableElement | null | "keep", endBindingElement: ExcalidrawBindableElement | null | "keep", elementsMap: NonDeletedSceneElementsMap) => void;
-export declare const bindOrUnbindSelectedElements: (selectedElements: NonDeleted<ExcalidrawElement>[], app: AppClassProperties) => void;
+export declare const bindOrUnbindLinearElements: (selectedElements: NonDeleted<ExcalidrawLinearElement>[], app: AppClassProperties, isBindingEnabled: boolean, draggingPoints: readonly number[] | null) => void;
+export declare const getSuggestedBindingsForArrows: (selectedElements: NonDeleted<ExcalidrawElement>[], app: AppClassProperties) => SuggestedBinding[];
 export declare const maybeBindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, appState: AppState, pointerCoords: {
     x: number;
     y: number;
 }, app: AppClassProperties) => void;
 export declare const bindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: NonDeletedSceneElementsMap) => void;
 export declare const isLinearElementSimpleAndAlreadyBound: (linearElement: NonDeleted<ExcalidrawLinearElement>, alreadyBoundToId: ExcalidrawBindableElement["id"] | undefined, bindableElement: ExcalidrawBindableElement) => boolean;
-export declare const unbindLinearElements: (elements: readonly NonDeleted<ExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap) => void;
 export declare const getHoveredElementForBinding: (pointerCoords: {
     x: number;
     y: number;
@@ -30,22 +29,9 @@ export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawE
         height: number;
     };
 }) => void;
-export declare const getEligibleElementsForBinding: (selectedElements: NonDeleted<ExcalidrawElement>[], app: AppClassProperties) => SuggestedBinding[];
 export declare const fixBindingsAfterDuplication: (sceneElements: readonly ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicatesServeAsOld?: "duplicatesServeAsOld" | undefined) => void;
 export declare const fixBindingsAfterDeletion: (sceneElements: readonly ExcalidrawElement[], deletedElements: readonly ExcalidrawElement[]) => void;
-export declare const bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
-    x: number;
-    y: number;
-}, app: AppClassProperties) => boolean;
 export declare const maxBindingGap: (element: ExcalidrawElement, elementWidth: number, elementHeight: number) => number;
-export declare const distanceToBindableElement: (element: ExcalidrawBindableElement, point: readonly [number, number], elementsMap: ElementsMap) => number;
-export declare const distanceToEllipse: (element: ExcalidrawEllipseElement, point: readonly [number, number], elementsMap: ElementsMap) => number;
-export declare const determineFocusDistance: (element: ExcalidrawBindableElement, a: readonly [number, number], b: readonly [number, number], elementsMap: ElementsMap) => number;
-export declare const determineFocusPoint: (element: ExcalidrawBindableElement, focus: number, adjecentPoint: readonly [number, number], elementsMap: ElementsMap) => readonly [number, number];
-export declare const intersectElementWithLine: (element: ExcalidrawBindableElement, a: readonly [number, number], b: readonly [number, number], gap: number | undefined, elementsMap: ElementsMap) => Point[];
-export declare const getCircleIntersections: (center: readonly [number, number, number, number, number, number, number, number], radius: number, line: readonly [number, number, number, number, number, number, number, number]) => GA.Point[];
-export declare const findFocusPointForEllipse: (ellipse: ExcalidrawEllipseElement, relativeDistance: number, point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
-export declare const findFocusPointForRectangulars: (element: ExcalidrawRectangleElement | ExcalidrawImageElement | ExcalidrawDiamondElement | ExcalidrawTextElement | ExcalidrawIframeLikeElement | ExcalidrawFrameLikeElement, relativeDistance: number, point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
 export declare const bindingProperties: Set<BindableProp | BindingProp>;
 export type BindableProp = "boundElements";
 export type BindingProp = "frameId" | "containerId" | "startBinding" | "endBinding";

package/dist/excalidraw/element/binding.js

@@ -46,39 +46,110 @@ const bindOrUnbindLinearElementEdge = (linearElement, bindableElement, otherEdge
 boundToElementIds, 
 // Is mutated
 unboundFromElementIds, elementsMap) => {
-    if (bindableElement !== "keep") {
-        if (bindableElement != null) {
-            // Don't bind if we're trying to bind or are already bound to the same
-            // element on the other edge already ("start" edge takes precedence).
-            if (otherEdgeBindableElement == null ||
-                (otherEdgeBindableElement === "keep"
-                    ? !isLinearElementSimpleAndAlreadyBoundOnOppositeEdge(linearElement, bindableElement, startOrEnd)
-                    : startOrEnd === "start" ||
-                        otherEdgeBindableElement.id !== bindableElement.id)) {
-                bindLinearElement(linearElement, bindableElement, startOrEnd, elementsMap);
-                boundToElementIds.add(bindableElement.id);
-            }
+    // "keep" is for method chaining convenience, a "no-op", so just bail out
+    if (bindableElement === "keep") {
+        return;
+    }
+    // null means break the bind, so nothing to consider here
+    if (bindableElement === null) {
+        const unbound = unbindLinearElement(linearElement, startOrEnd);
+        if (unbound != null) {
+            unboundFromElementIds.add(unbound);
         }
-        else {
-            const unbound = unbindLinearElement(linearElement, startOrEnd);
-            if (unbound != null) {
-                unboundFromElementIds.add(unbound);
-            }
+        return;
+    }
+    // While complext arrows can do anything, simple arrow with both ends trying
+    // to bind to the same bindable should not be allowed, start binding takes
+    // precedence
+    if (isLinearElementSimple(linearElement)) {
+        if (otherEdgeBindableElement == null ||
+            (otherEdgeBindableElement === "keep"
+                ? // TODO: Refactor - Needlessly complex
+                    !isLinearElementSimpleAndAlreadyBoundOnOppositeEdge(linearElement, bindableElement, startOrEnd)
+                : startOrEnd === "start" ||
+                    otherEdgeBindableElement.id !== bindableElement.id)) {
+            bindLinearElement(linearElement, bindableElement, startOrEnd, elementsMap);
+            boundToElementIds.add(bindableElement.id);
         }
     }
+    else {
+        bindLinearElement(linearElement, bindableElement, startOrEnd, elementsMap);
+        boundToElementIds.add(bindableElement.id);
+    }
 };
-export const bindOrUnbindSelectedElements = (selectedElements, app) => {
-    selectedElements.forEach((selectedElement) => {
-        if (isBindingElement(selectedElement)) {
-            bindOrUnbindLinearElement(selectedElement, getElligibleElementForBindingElement(selectedElement, "start", app), getElligibleElementForBindingElement(selectedElement, "end", app), app.scene.getNonDeletedElementsMap());
-        }
-        else if (isBindableElement(selectedElement)) {
-            maybeBindBindableElement(selectedElement, app.scene.getNonDeletedElementsMap(), app);
+const getOriginalBindingIfStillCloseOfLinearElementEdge = (linearElement, edge, app) => {
+    const elementsMap = app.scene.getNonDeletedElementsMap();
+    const coors = getLinearElementEdgeCoors(linearElement, edge, elementsMap);
+    const elementId = edge === "start"
+        ? linearElement.startBinding?.elementId
+        : linearElement.endBinding?.elementId;
+    if (elementId) {
+        const element = elementsMap.get(elementId);
+        if (bindingBorderTest(element, coors, app)) {
+            return element;
         }
+    }
+    return null;
+};
+const getOriginalBindingsIfStillCloseToArrowEnds = (linearElement, app) => ["start", "end"].map((edge) => getOriginalBindingIfStillCloseOfLinearElementEdge(linearElement, edge, app));
+const getBindingStrategyForDraggingArrowEndpoints = (selectedElement, isBindingEnabled, draggingPoints, app) => {
+    const startIdx = 0;
+    const endIdx = selectedElement.points.length - 1;
+    const startDragged = draggingPoints.findIndex((i) => i === startIdx) > -1;
+    const endDragged = draggingPoints.findIndex((i) => i === endIdx) > -1;
+    const start = startDragged
+        ? isBindingEnabled
+            ? getElligibleElementForBindingElement(selectedElement, "start", app)
+            : null // If binding is disabled and start is dragged, break all binds
+        : // We have to update the focus and gap of the binding, so let's rebind
+            getElligibleElementForBindingElement(selectedElement, "start", app);
+    const end = endDragged
+        ? isBindingEnabled
+            ? getElligibleElementForBindingElement(selectedElement, "end", app)
+            : null // If binding is disabled and end is dragged, break all binds
+        : // We have to update the focus and gap of the binding, so let's rebind
+            getElligibleElementForBindingElement(selectedElement, "end", app);
+    return [start, end];
+};
+const getBindingStrategyForDraggingArrowOrJoints = (selectedElement, app, isBindingEnabled) => {
+    const [startIsClose, endIsClose] = getOriginalBindingsIfStillCloseToArrowEnds(selectedElement, app);
+    const start = startIsClose
+        ? isBindingEnabled
+            ? getElligibleElementForBindingElement(selectedElement, "start", app)
+            : null
+        : null;
+    const end = endIsClose
+        ? isBindingEnabled
+            ? getElligibleElementForBindingElement(selectedElement, "end", app)
+            : null
+        : null;
+    return [start, end];
+};
+export const bindOrUnbindLinearElements = (selectedElements, app, isBindingEnabled, draggingPoints) => {
+    selectedElements.forEach((selectedElement) => {
+        const [start, end] = draggingPoints?.length
+            ? // The arrow edge points are dragged (i.e. start, end)
+                getBindingStrategyForDraggingArrowEndpoints(selectedElement, isBindingEnabled, draggingPoints ?? [], app)
+            : // The arrow itself (the shaft) or the inner joins are dragged
+                getBindingStrategyForDraggingArrowOrJoints(selectedElement, app, isBindingEnabled);
+        bindOrUnbindLinearElement(selectedElement, start, end, app.scene.getNonDeletedElementsMap());
     });
 };
-const maybeBindBindableElement = (bindableElement, elementsMap, app) => {
-    getElligibleElementsForBindableElementAndWhere(bindableElement, app).forEach(([linearElement, where]) => bindOrUnbindLinearElement(linearElement, where === "end" ? "keep" : bindableElement, where === "start" ? "keep" : bindableElement, elementsMap));
+export const getSuggestedBindingsForArrows = (selectedElements, app) => {
+    // HOT PATH: Bail out if selected elements list is too large
+    if (selectedElements.length > 50) {
+        return [];
+    }
+    return (selectedElements
+        .filter(isLinearElement)
+        .flatMap((element) => getOriginalBindingsIfStillCloseToArrowEnds(element, app))
+        .filter((element) => element !== null)
+        // Filter out bind candidates which are in the
+        // same selection / group with the arrow
+        //
+        // TODO: Is it worth turning the list into a set to avoid dupes?
+        .filter((element) => selectedElements.filter((selected) => selected.id === element?.id)
+        .length === 0));
 };
 export const maybeBindLinearElement = (linearElement, appState, pointerCoords, app) => {
     if (appState.startBoundElement != null) {
@@ -113,20 +184,10 @@ const isLinearElementSimpleAndAlreadyBoundOnOppositeEdge = (linearElement, binda
     return isLinearElementSimpleAndAlreadyBound(linearElement, otherBinding?.elementId, bindableElement);
 };
 export const isLinearElementSimpleAndAlreadyBound = (linearElement, alreadyBoundToId, bindableElement) => {
-    return (alreadyBoundToId === bindableElement.id && linearElement.points.length < 3);
-};
-export const unbindLinearElements = (elements, elementsMap) => {
-    elements.forEach((element) => {
-        if (isBindingElement(element)) {
-            if (element.startBinding !== null && element.endBinding !== null) {
-                bindOrUnbindLinearElement(element, null, null, elementsMap);
-            }
-            else {
-                bindOrUnbindLinearElement(element, element.startBinding ? "keep" : null, element.endBinding ? "keep" : null, elementsMap);
-            }
-        }
-    });
+    return (alreadyBoundToId === bindableElement.id &&
+        isLinearElementSimple(linearElement));
 };
+const isLinearElementSimple = (linearElement) => linearElement.points.length < 3;
 const unbindLinearElement = (linearElement, startOrEnd) => {
     const field = startOrEnd === "start" ? "startBinding" : "endBinding";
     const binding = linearElement[field];
@@ -247,21 +308,6 @@ const maybeCalculateNewGapWhenScaling = (changedElement, currentBinding, newSize
     const newGap = Math.max(1, Math.min(maxBindingGap(changedElement, newWidth, newHeight), gap * (newWidth < newHeight ? newWidth / width : newHeight / height)));
     return { elementId, gap: newGap, focus };
 };
-// TODO: this is a bottleneck, optimise
-export const getEligibleElementsForBinding = (selectedElements, app) => {
-    const includedElementIds = new Set(selectedElements.map(({ id }) => id));
-    return selectedElements.flatMap((selectedElement) => isBindingElement(selectedElement, false)
-        ? getElligibleElementsForBindingElement(selectedElement, app).filter((element) => !includedElementIds.has(element.id))
-        : isBindableElement(selectedElement, false)
-            ? getElligibleElementsForBindableElementAndWhere(selectedElement, app).filter((binding) => !includedElementIds.has(binding[0].id))
-            : []);
-};
-const getElligibleElementsForBindingElement = (linearElement, app) => {
-    return [
-        getElligibleElementForBindingElement(linearElement, "start", app),
-        getElligibleElementForBindingElement(linearElement, "end", app),
-    ].filter((element) => element != null);
-};
 const getElligibleElementForBindingElement = (linearElement, startOrEnd, app) => {
     return getHoveredElementForBinding(getLinearElementEdgeCoors(linearElement, startOrEnd, app.scene.getNonDeletedElementsMap()), app);
 };
@@ -269,33 +315,6 @@ const getLinearElementEdgeCoors = (linearElement, startOrEnd, elementsMap) => {
     const index = startOrEnd === "start" ? 0 : -1;
     return tupleToCoors(LinearElementEditor.getPointAtIndexGlobalCoordinates(linearElement, index, elementsMap));
 };
-const getElligibleElementsForBindableElementAndWhere = (bindableElement, app) => {
-    const scene = Scene.getScene(bindableElement);
-    return scene
-        .getNonDeletedElements()
-        .map((element) => {
-        if (!isBindingElement(element, false)) {
-            return null;
-        }
-        const canBindStart = isLinearElementEligibleForNewBindingByBindable(element, "start", bindableElement, scene.getNonDeletedElementsMap(), app);
-        const canBindEnd = isLinearElementEligibleForNewBindingByBindable(element, "end", bindableElement, scene.getNonDeletedElementsMap(), app);
-        if (!canBindStart && !canBindEnd) {
-            return null;
-        }
-        return [
-            element,
-            canBindStart && canBindEnd ? "both" : canBindStart ? "start" : "end",
-            bindableElement,
-        ];
-    })
-        .filter((maybeElement) => maybeElement != null);
-};
-const isLinearElementEligibleForNewBindingByBindable = (linearElement, startOrEnd, bindableElement, elementsMap, app) => {
-    const existingBinding = linearElement[startOrEnd === "start" ? "startBinding" : "endBinding"];
-    return (existingBinding == null &&
-        !isLinearElementSimpleAndAlreadyBoundOnOppositeEdge(linearElement, bindableElement, startOrEnd) &&
-        bindingBorderTest(bindableElement, getLinearElementEdgeCoors(linearElement, startOrEnd, elementsMap), app));
-};
 // We need to:
 // 1: Update elements not selected to point to duplicated elements
 // 2: Update duplicated elements to point to other duplicated elements
@@ -389,7 +408,7 @@ const newBoundElements = (boundElements, idsToRemove, elementsToAdd = []) => {
     nextBoundElements.push(...elementsToAdd.map((x) => ({ id: x.id, type: x.type })));
     return nextBoundElements;
 };
-export const bindingBorderTest = (element, { x, y }, app) => {
+const bindingBorderTest = (element, { x, y }, app) => {
     const threshold = maxBindingGap(element, element.width, element.height);
     const shape = app.getElementShape(element);
     return isPointOnShape([x, y], shape, threshold);
@@ -401,7 +420,7 @@ export const maxBindingGap = (element, elementWidth, elementHeight) => {
     // We make the bindable boundary bigger for bigger elements
     return Math.max(16, Math.min(0.25 * smallerDimension, 32));
 };
-export const distanceToBindableElement = (element, point, elementsMap) => {
+const distanceToBindableElement = (element, point, elementsMap) => {
     switch (element.type) {
         case "rectangle":
         case "image":
@@ -426,7 +445,7 @@ const distanceToDiamond = (element, point, elementsMap) => {
     const side = GALine.equation(hheight, hwidth, -hheight * hwidth);
     return GAPoint.distanceToLine(pointRel, side);
 };
-export const distanceToEllipse = (element, point, elementsMap) => {
+const distanceToEllipse = (element, point, elementsMap) => {
     const [pointRel, tangent] = ellipseParamsForTest(element, point, elementsMap);
     return -GALine.sign(tangent) * GAPoint.distanceToLine(pointRel, tangent);
 };
@@ -504,7 +523,7 @@ const coordsCenter = (x1, y1, x2, y2) => {
 // all focus points lie, so it's a number between -1 and 1.
 // The line going through `a` and `b` is a tangent to the "focus image"
 // of the element.
-export const determineFocusDistance = (element, 
+const determineFocusDistance = (element, 
 // Point on the line, in absolute coordinates
 a, 
 // Another point on the line, in absolute coordinates (closer to element)
@@ -541,7 +560,7 @@ b, elementsMap) => {
     }
     return ret || 0;
 };
-export const determineFocusPoint = (element, 
+const determineFocusPoint = (element, 
 // The oriented, relative distance from the center of `element` of the
 // returned focusPoint
 focus, adjecentPoint, elementsMap) => {
@@ -573,7 +592,7 @@ focus, adjecentPoint, elementsMap) => {
 };
 // Returns 2 or 0 intersection points between line going through `a` and `b`
 // and the `element`, in ascending order of distance from `a`.
-export const intersectElementWithLine = (element, 
+const intersectElementWithLine = (element, 
 // Point on the line, in absolute coordinates
 a, 
 // Another point on the line, in absolute coordinates
@@ -688,7 +707,7 @@ const getEllipseIntersections = (element, gap, line) => {
         GA.point((xn - a * b * n * discrRoot) / squares, (yn + a * b * m * discrRoot) / squares),
     ];
 };
-export const getCircleIntersections = (center, radius, line) => {
+const getCircleIntersections = (center, radius, line) => {
     if (radius === 0) {
         return GAPoint.distanceToLine(line, center) === 0 ? [center] : [];
     }
@@ -712,7 +731,7 @@ export const getCircleIntersections = (center, radius, line) => {
 };
 // The focus point is the tangent point of the "focus image" of the
 // `element`, where the tangent goes through `point`.
-export const findFocusPointForEllipse = (ellipse, 
+const findFocusPointForEllipse = (ellipse, 
 // Between -1 and 1 (not 0) the relative size of the "focus image" of
 // the element on which the focus point lies
 relativeDistance, 
@@ -739,7 +758,7 @@ point) => {
     const x = -(a ** 2 * m) / (n ** 2 * b ** 2 + m ** 2 * a ** 2);
     return GA.point(x, (-m * x - 1) / n);
 };
-export const findFocusPointForRectangulars = (element, 
+const findFocusPointForRectangulars = (element, 
 // Between -1 and 1 for how far away should the focus point be relative
 // to the size of the element. Sign determines orientation.
 relativeDistance, 

package/dist/excalidraw/element/bounds.d.ts

@@ -1,6 +1,6 @@
-import { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, ExcalidrawFreeDrawElement, NonDeleted, ElementsMap } from "./types";
-import { Drawable, Op } from "roughjs/bin/core";
-import { AppState, Point } from "../types";
+import type { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, ExcalidrawFreeDrawElement, NonDeleted, ElementsMap } from "./types";
+import type { Drawable, Op } from "roughjs/bin/core";
+import type { AppState, Point } from "../types";
 export type RectangleBox = {
     x: number;
     y: number;

package/dist/excalidraw/element/collision.d.ts

@@ -1,6 +1,6 @@
-import { ElementsMap, ExcalidrawElement } from "./types";
-import { FrameNameBounds } from "../types";
-import { GeometricShape } from "../../utils/geometry/shape";
+import type { ElementsMap, ExcalidrawElement } from "./types";
+import type { FrameNameBounds } from "../types";
+import type { GeometricShape } from "../../utils/geometry/shape";
 export declare const shouldTestInside: (element: ExcalidrawElement) => boolean;
 export type HitTestArgs = {
     x: number;

package/dist/excalidraw/element/collision.js

@@ -1,6 +1,6 @@
 import { isPathALoop, isPointWithinBounds } from "../math";
 import { getElementBounds } from "./bounds";
-import { getPolygonShape, } from "../../utils/geometry/shape";
+import { getPolygonShape } from "../../utils/geometry/shape";
 import { isPointInShape, isPointOnShape } from "../../utils/collision";
 import { isTransparent } from "../utils";
 import { hasBoundTextElement, isIframeLikeElement, isImageElement, isTextElement, } from "./typeChecks";

package/dist/excalidraw/element/containerCache.d.ts

@@ -1,4 +1,4 @@
-import { ExcalidrawTextContainer } from "./types";
+import type { ExcalidrawTextContainer } from "./types";
 export declare const originalContainerCache: {
     [id: ExcalidrawTextContainer["id"]]: {
         height: ExcalidrawTextContainer["height"];

package/dist/excalidraw/element/dragElements.d.ts

@@ -1,6 +1,6 @@
-import { NonDeletedExcalidrawElement } from "./types";
-import { AppState, PointerDownState } from "../types";
-import Scene from "../scene/Scene";
+import type { NonDeletedExcalidrawElement } from "./types";
+import type { AppState, NormalizedZoomValue, PointerDownState } from "../types";
+import type Scene from "../scene/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: AppState["gridSize"]) => void;
 export declare const getDragOffsetXY: (selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
-export declare const dragNewElement: (draggingElement: NonDeletedExcalidrawElement, elementType: AppState["activeTool"]["type"], originX: number, originY: number, x: number, y: number, width: number, height: number, shouldMaintainAspectRatio: boolean, shouldResizeFromCenter: boolean, widthAspectRatio?: number | null, originOffset?: {
+export declare const dragNewElement: (draggingElement: NonDeletedExcalidrawElement, elementType: AppState["activeTool"]["type"], originX: number, originY: number, x: number, y: number, width: number, height: number, shouldMaintainAspectRatio: boolean, shouldResizeFromCenter: boolean, zoom: NormalizedZoomValue, widthAspectRatio?: number | null, originOffset?: {
     x: number;
     y: number;
 } | null) => void;

package/dist/excalidraw/element/dragElements.js

@@ -2,9 +2,11 @@ import { updateBoundElements } from "./binding";
 import { getCommonBounds } from "./bounds";
 import { mutateElement } from "./mutateElement";
 import { getPerfectElementSize } from "./sizeHelpers";
-import { getBoundTextElement } from "./textElement";
+import { getBoundTextElement, getMinTextElementWidth } from "./textElement";
 import { getGridPoint } from "../math";
-import { isArrowElement, isFrameLikeElement } from "./typeChecks";
+import { isArrowElement, isFrameLikeElement, isTextElement, } from "./typeChecks";
+import { getFontString } from "../utils";
+import { TEXT_AUTOWRAP_THRESHOLD } from "../constants";
 export const dragSelectedElements = (pointerDownState, selectedElements, offset, appState, scene, snapOffset, gridSize) => {
     // we do not want a frame and its elements to be selected at the same time
     // but when it happens (due to some bug), we want to avoid updating element
@@ -68,7 +70,7 @@ export const getDragOffsetXY = (selectedElements, x, y) => {
     const [x1, y1] = getCommonBounds(selectedElements);
     return [x - x1, y - y1];
 };
-export const dragNewElement = (draggingElement, elementType, originX, originY, x, y, width, height, shouldMaintainAspectRatio, shouldResizeFromCenter, 
+export const dragNewElement = (draggingElement, elementType, originX, originY, x, y, width, height, shouldMaintainAspectRatio, shouldResizeFromCenter, zoom, 
 /** whether to keep given aspect ratio when `isResizeWithSidesSameLength` is
     true */
 widthAspectRatio, originOffset = null) => {
@@ -99,12 +101,34 @@ widthAspectRatio, originOffset = null) => {
         newX = originX - width / 2;
         newY = originY - height / 2;
     }
+    let textAutoResize = null;
+    // NOTE this should apply only to creating text elements, not existing
+    // (once we rewrite appState.draggingElement to actually mean dragging
+    // elements)
+    if (isTextElement(draggingElement)) {
+        height = draggingElement.height;
+        const minWidth = getMinTextElementWidth(getFontString({
+            fontSize: draggingElement.fontSize,
+            fontFamily: draggingElement.fontFamily,
+        }), draggingElement.lineHeight);
+        width = Math.max(width, minWidth);
+        if (Math.abs(x - originX) > TEXT_AUTOWRAP_THRESHOLD / zoom) {
+            textAutoResize = {
+                autoResize: false,
+            };
+        }
+        newY = originY;
+        if (shouldResizeFromCenter) {
+            newX = originX - width / 2;
+        }
+    }
     if (width !== 0 && height !== 0) {
         mutateElement(draggingElement, {
             x: newX + (originOffset?.x ?? 0),
             y: newY + (originOffset?.y ?? 0),
             width,
             height,
+            ...textAutoResize,
         });
     }
 };

package/dist/excalidraw/element/embeddable.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="react" />
-import { ExcalidrawProps } from "../types";
-import { ExcalidrawElement, ExcalidrawIframeLikeElement, IframeData } from "./types";
-import { MarkRequired } from "../utility-types";
+import type { ExcalidrawProps } from "../types";
+import type { ExcalidrawElement, ExcalidrawIframeLikeElement, IframeData } from "./types";
+import type { MarkRequired } from "../utility-types";
 type IframeDataWithSandbox = MarkRequired<IframeData, "sandbox">;
 export declare const createSrcDoc: (body: string) => string;
 export declare const getEmbedLink: (link: string | null | undefined) => IframeDataWithSandbox | null;
@@ -167,7 +167,7 @@ export declare const actionSetEmbeddableAsActiveTool: {
             userToFollow: import("../types").UserToFollow | null;
             followedBy: Set<import("../types").SocketId>;
         };
-        storeAction: import("../store").StoreActionType;
+        storeAction: "none";
     };
 } & {
     keyTest?: undefined;

package/dist/excalidraw/element/image.d.ts

@@ -1,5 +1,5 @@
-import { AppClassProperties, DataURL, BinaryFiles } from "../types";
-import { ExcalidrawElement, FileId, InitializedExcalidrawImageElement } from "./types";
+import type { AppClassProperties, DataURL, BinaryFiles } from "../types";
+import type { ExcalidrawElement, FileId, InitializedExcalidrawImageElement } from "./types";
 export declare const loadHTMLImageElement: (dataURL: DataURL) => Promise<HTMLImageElement>;
 /** NOTE: updates cache even if already populated with given image. Thus,
  * you should filter out the images upstream if you want to optimize this. */

package/dist/excalidraw/element/index.d.ts

@@ -1,5 +1,5 @@
-import { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted } from "./types";
-export { newElement, newTextElement, updateTextElement, refreshTextDimensions, newLinearElement, newImageElement, duplicateElement, } from "./newElement";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted } from "./types";
+export { newElement, newTextElement, refreshTextDimensions, newLinearElement, newImageElement, duplicateElement, } from "./newElement";
 export { getElementAbsoluteCoords, getElementBounds, getCommonBounds, getDiamondPoints, getArrowheadPoints, getClosestElementBounds, } from "./bounds";
 export { OMIT_SIDES_FOR_MULTIPLE_ELEMENTS, getTransformHandlesFromCoords, getTransformHandles, } from "./transformHandles";
 export { resizeTest, getCursorForResizingElement, getElementWithTransformHandleType, getTransformHandleTypeFromCoords, } from "./resizeTest";

package/dist/excalidraw/element/index.js

@@ -1,6 +1,6 @@
 import { isInvisiblySmallElement } from "./sizeHelpers";
 import { isLinearElementType } from "./typeChecks";
-export { newElement, newTextElement, updateTextElement, refreshTextDimensions, newLinearElement, newImageElement, duplicateElement, } from "./newElement";
+export { newElement, newTextElement, refreshTextDimensions, newLinearElement, newImageElement, duplicateElement, } from "./newElement";
 export { getElementAbsoluteCoords, getElementBounds, getCommonBounds, getDiamondPoints, getArrowheadPoints, getClosestElementBounds, } from "./bounds";
 export { OMIT_SIDES_FOR_MULTIPLE_ELEMENTS, getTransformHandlesFromCoords, getTransformHandles, } from "./transformHandles";
 export { resizeTest, getCursorForResizingElement, getElementWithTransformHandleType, getTransformHandleTypeFromCoords, } from "./resizeTest";

package/dist/excalidraw/element/linearElementEditor.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="react" />
-import { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap } from "./types";
-import { Bounds } from "./bounds";
-import { Point, AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties } from "../types";
-import { Store } from "../store";
+import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap } from "./types";
+import type { Bounds } from "./bounds";
+import type { Point, AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties } from "../types";
+import type { Store } from "../store";
 declare const editorMidPointsCache: {
     version: number | null;
     points: (Point | null)[];

package/dist/excalidraw/element/mutateElement.d.ts

@@ -1,8 +1,8 @@
-import { ExcalidrawElement } from "./types";
-import { Mutable } from "../utility-types";
+import type { ExcalidrawElement } from "./types";
+import type { Mutable } from "../utility-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) => TElement;
-export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>) => TElement;
+export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, force?: boolean) => TElement;
 /**
  * Mutates element, bumping `version`, `versionNonce`, and `updated`.
  *

package/dist/excalidraw/element/mutateElement.js

@@ -71,11 +71,13 @@ export const mutateElement = (element, updates, informMutation = true) => {
     element.versionNonce = randomInteger();
     element.updated = getUpdatedTimestamp();
     if (informMutation) {
-        Scene.getScene(element)?.informMutation();
+        Scene.getScene(element)?.triggerUpdate();
     }
     return element;
 };
-export const newElementWith = (element, updates) => {
+export const newElementWith = (element, updates, 
+/** pass `true` to always regenerate */
+force = false) => {
     let didChange = false;
     for (const key in updates) {
         const value = updates[key];
@@ -88,7 +90,7 @@ export const newElementWith = (element, updates) => {
             didChange = true;
         }
     }
-    if (!didChange) {
+    if (!didChange && !force) {
         return element;
     }
     return {