@excalidraw/excalidraw 0.17.1-890ed9f → 0.17.1-96eeec5

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;
@@ -13,8 +13,8 @@ export declare const actionSetEmbeddableAsActiveTool: {
     };
     target: string;
     label: string;
-    perform: (elements: readonly ExcalidrawElement[], appState: Readonly<import("../types").AppState>, _: any, app: import("../types").AppClassProperties) => {
-        elements: readonly ExcalidrawElement[];
+    perform: (elements: readonly import("./types").OrderedExcalidrawElement[], appState: Readonly<import("../types").AppState>, _: any, app: import("../types").AppClassProperties) => {
+        elements: readonly import("./types").OrderedExcalidrawElement[];
         appState: {
             activeTool: {
                 lastActiveTool: import("../types").ActiveTool | null;
@@ -146,7 +146,10 @@ export declare const actionSetEmbeddableAsActiveTool: {
                 isSpeaking?: boolean | undefined;
                 isMuted?: boolean | undefined;
             }>>;
-            showStats: boolean;
+            stats: {
+                open: boolean;
+                panels: number;
+            };
             currentChartType: import("./types").ChartType;
             pasteDialog: {
                 shown: false;
@@ -167,7 +170,7 @@ export declare const actionSetEmbeddableAsActiveTool: {
             userToFollow: import("../types").UserToFollow | null;
             followedBy: Set<import("../types").SocketId>;
         };
-        commitToHistory: false;
+        storeAction: "none";
     };
 } & {
     keyTest?: undefined;

package/dist/excalidraw/element/embeddable.js

@@ -6,6 +6,7 @@ import { newTextElement } from "./newElement";
 import { wrapText } from "./textElement";
 import { isIframeElement } from "./typeChecks";
 import { sanitizeHTMLAttribute } from "../data/url";
+import { StoreAction } from "../store";
 const embeddedLinkCache = new Map();
 const RE_YOUTUBE = /^(?:http(?:s)?:\/\/)?(?:www\.)?youtu(?:be\.com|\.be)\/(embed\/|watch\?v=|shorts\/|playlist\?list=|embed\/videoseries\?list=)?([a-zA-Z0-9_-]+)(?:\?t=|&t=|\?start=|&start=)?([a-zA-Z0-9_-]+)?[^\s]*$/;
 const RE_VIMEO = /^(?:http(?:s)?:\/\/)?(?:(?:w){3}\.)?(?:player\.)?vimeo\.com\/(?:video\/)?([^?\s]+)(?:\?.*)?$/;
@@ -248,7 +249,7 @@ export const actionSetEmbeddableAsActiveTool = register({
                     type: "embeddable",
                 }),
             },
-            commitToHistory: false,
+            storeAction: StoreAction.NONE,
         };
     },
 });

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 History from "../history";
+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)[];
@@ -62,7 +62,7 @@ export declare class LinearElementEditor {
     static isSegmentTooShort(element: NonDeleted<ExcalidrawLinearElement>, startPoint: Point, endPoint: Point, zoom: AppState["zoom"]): boolean;
     static getSegmentMidPoint(element: NonDeleted<ExcalidrawLinearElement>, startPoint: Point, endPoint: Point, endPointIndex: number, elementsMap: ElementsMap): readonly [number, number];
     static getSegmentMidPointIndex(linearElementEditor: LinearElementEditor, appState: AppState, midPoint: Point, elementsMap: ElementsMap): number;
-    static handlePointerDown(event: React.PointerEvent<HTMLElement>, appState: AppState, history: History, scenePointer: {
+    static handlePointerDown(event: React.PointerEvent<HTMLElement>, appState: AppState, store: Store, scenePointer: {
         x: number;
         y: number;
     }, linearElementEditor: LinearElementEditor, app: AppClassProperties): {
@@ -234,7 +234,7 @@ export declare class LinearElementEditor {
             offsetLeft: number;
             fileHandle: import("browser-fs-access").FileSystemHandle | null;
             collaborators: Map<import("../types").SocketId, Readonly<{
-                pointer?: import("../types").CollaboratorPointer | undefined; /** indices */
+                pointer?: import("../types").CollaboratorPointer | undefined;
                 button?: "up" | "down" | undefined;
                 selectedElementIds?: Readonly<{
                     [id: string]: true;
@@ -253,7 +253,10 @@ export declare class LinearElementEditor {
                 isSpeaking?: boolean | undefined;
                 isMuted?: boolean | undefined;
             }>>;
-            showStats: boolean;
+            stats: {
+                open: boolean;
+                panels: number;
+            };
             currentChartType: import("./types").ChartType;
             pasteDialog: {
                 shown: false;

package/dist/excalidraw/element/linearElementEditor.js

@@ -186,7 +186,7 @@ export class LinearElementEditor {
                         ]);
                     }
                     const bindingElement = isBindingEnabled(appState)
-                        ? getHoveredElementForBinding(tupleToCoors(LinearElementEditor.getPointAtIndexGlobalCoordinates(element, selectedPoint, elementsMap)), app)
+                        ? getHoveredElementForBinding(tupleToCoors(LinearElementEditor.getPointAtIndexGlobalCoordinates(element, selectedPoint, elementsMap)), elementsMap)
                         : null;
                     bindings[selectedPoint === 0 ? "startBindingElement" : "endBindingElement"] = bindingElement;
                 }
@@ -314,7 +314,7 @@ export class LinearElementEditor {
         }
         return -1;
     }
-    static handlePointerDown(event, appState, history, scenePointer, linearElementEditor, app) {
+    static handlePointerDown(event, appState, store, scenePointer, linearElementEditor, app) {
         const elementsMap = app.scene.getNonDeletedElementsMap();
         const ret = {
             didAddPoint: false,
@@ -344,7 +344,7 @@ export class LinearElementEditor {
                 });
                 ret.didAddPoint = true;
             }
-            history.resumeRecording();
+            store.shouldCaptureIncrement();
             ret.linearElementEditor = {
                 ...linearElementEditor,
                 pointerDownState: {
@@ -359,7 +359,7 @@ export class LinearElementEditor {
                 },
                 selectedPointsIndices: [element.points.length - 1],
                 lastUncommittedPoint: null,
-                endBindingElement: getHoveredElementForBinding(scenePointer, app),
+                endBindingElement: getHoveredElementForBinding(scenePointer, elementsMap),
             };
             ret.didAddPoint = true;
             return ret;
@@ -661,12 +661,15 @@ export class LinearElementEditor {
         const nextPoints = points.map((point, idx) => {
             const selectedPointData = targetPoints.find((p) => p.index === idx);
             if (selectedPointData) {
-                if (selectedOriginPoint) {
+                if (selectedPointData.index === 0) {
                     return point;
                 }
                 const deltaX = selectedPointData.point[0] - points[selectedPointData.index][0];
                 const deltaY = selectedPointData.point[1] - points[selectedPointData.index][1];
-                return [point[0] + deltaX, point[1] + deltaY];
+                return [
+                    point[0] + deltaX - offsetX,
+                    point[1] + deltaY - offsetY,
+                ];
             }
             return offsetX || offsetY
                 ? [point[0] - offsetX, point[1] - offsetY]

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

@@ -1,6 +1,6 @@
-import { ExcalidrawElement } from "./types";
-import { Mutable } from "../utility-types";
-type ElementUpdate<TElement extends ExcalidrawElement> = Omit<Partial<TElement>, "id" | "version" | "versionNonce">;
+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;
 /**
@@ -9,4 +9,3 @@ export declare const newElementWith: <TElement extends ExcalidrawElement>(elemen
  * NOTE: does not trigger re-render.
  */
 export declare const bumpVersion: <T extends Mutable<ExcalidrawElement>>(element: T, version?: ExcalidrawElement["version"]) => T;
-export {};

package/dist/excalidraw/element/mutateElement.js

@@ -71,7 +71,7 @@ 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;
 };

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

@@ -1,6 +1,6 @@
-import { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap } from "./types";
-import { AppState } from "../types";
-import { MarkOptional, Mutable } from "../utility-types";
+import type { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap } from "./types";
+import type { AppState } from "../types";
+import type { MarkOptional, Mutable } from "../utility-types";
 export type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "frameId" | "index" | "boundElements" | "seed" | "version" | "versionNonce" | "link" | "strokeStyle" | "fillStyle" | "strokeColor" | "backgroundColor" | "roughness" | "strokeWidth" | "roundness" | "locked" | "opacity" | "customData">;
 export declare const newElement: (opts: {
     type: ExcalidrawGenericElement["type"];
@@ -19,6 +19,7 @@ export declare const newMagicFrameElement: (opts: {
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawMagicFrameElement>;
 export declare const newTextElement: (opts: {
     text: string;
+    originalText?: string;
     fontSize?: number;
     fontFamily?: FontFamilyValues;
     textAlign?: TextAlign;
@@ -26,6 +27,7 @@ export declare const newTextElement: (opts: {
     containerId?: ExcalidrawTextContainer["id"] | null;
     lineHeight?: ExcalidrawTextElement["lineHeight"];
     strokeWidth?: ExcalidrawTextElement["strokeWidth"];
+    autoResize?: ExcalidrawTextElement["autoResize"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
 export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null, elementsMap: ElementsMap, text?: string) => {
     x: number;
@@ -34,11 +36,6 @@ export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement,
     height: number;
     text: string;
 } | undefined;
-export declare const updateTextElement: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null, elementsMap: ElementsMap, { text, isDeleted, originalText, }: {
-    text: string;
-    isDeleted?: boolean | undefined;
-    originalText: string;
-}) => ExcalidrawTextElement;
 export declare const newFreeDrawElement: (opts: {
     type: "freedraw";
     points?: ExcalidrawFreeDrawElement["points"];

package/dist/excalidraw/element/newElement.js

@@ -85,7 +85,7 @@ export const newTextElement = (opts) => {
     const textAlign = opts.textAlign || DEFAULT_TEXT_ALIGN;
     const verticalAlign = opts.verticalAlign || DEFAULT_VERTICAL_ALIGN;
     const offsets = getTextElementPositionOffsets({ textAlign, verticalAlign }, metrics);
-    const textElement = newElementWith({
+    const textElementProps = {
         ..._newElementBase("text", opts),
         text,
         fontSize,
@@ -97,19 +97,26 @@ export const newTextElement = (opts) => {
         width: metrics.width,
         height: metrics.height,
         containerId: opts.containerId || null,
-        originalText: text,
+        originalText: opts.originalText ?? text,
+        autoResize: opts.autoResize ?? true,
         lineHeight,
-    }, {});
+    };
+    const textElement = newElementWith(textElementProps, {});
     return textElement;
 };
 const getAdjustedDimensions = (element, elementsMap, nextText) => {
-    const { width: nextWidth, height: nextHeight } = measureText(nextText, getFontString(element), element.lineHeight);
+    let { width: nextWidth, height: nextHeight } = measureText(nextText, getFontString(element), element.lineHeight);
+    // wrapped text
+    if (!element.autoResize) {
+        nextWidth = element.width;
+    }
     const { textAlign, verticalAlign } = element;
     let x;
     let y;
     if (textAlign === "center" &&
         verticalAlign === VERTICAL_ALIGN.MIDDLE &&
-        !element.containerId) {
+        !element.containerId &&
+        element.autoResize) {
         const prevMetrics = measureText(element.text, getFontString(element), element.lineHeight);
         const offsets = getTextElementPositionOffsets(element, {
             width: nextWidth - prevMetrics.width,
@@ -142,19 +149,14 @@ export const refreshTextDimensions = (textElement, container, elementsMap, text
     if (textElement.isDeleted) {
         return;
     }
-    if (container) {
-        text = wrapText(text, getFontString(textElement), getBoundTextMaxWidth(container, textElement));
+    if (container || !textElement.autoResize) {
+        text = wrapText(text, getFontString(textElement), container
+            ? getBoundTextMaxWidth(container, textElement)
+            : textElement.width);
     }
     const dimensions = getAdjustedDimensions(textElement, elementsMap, text);
     return { text, ...dimensions };
 };
-export const updateTextElement = (textElement, container, elementsMap, { text, isDeleted, originalText, }) => {
-    return newElementWith(textElement, {
-        originalText,
-        isDeleted: isDeleted ?? textElement.isDeleted,
-        ...refreshTextDimensions(textElement, container, elementsMap, originalText),
-    });
-};
 export const newFreeDrawElement = (opts) => {
     return {
         ..._newElementBase(opts.type, opts),

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

@@ -1,9 +1,17 @@
-import { ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, ElementsMap } from "./types";
-import { MaybeTransformHandleType, TransformHandleDirection } from "./transformHandles";
-import { PointerDownState } from "../types";
+import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ElementsMap } from "./types";
+import type { MaybeTransformHandleType, TransformHandleDirection } from "./transformHandles";
+import type { PointerDownState } from "../types";
 export declare const normalizeAngle: (angle: number) => number;
 export declare const transformElements: (originalElements: PointerDownState["originalElements"], transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, 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: (readonly [number, number])[];
+} | {
+    points?: undefined;
+};
+export declare const measureFontSizeFromWidth: (element: NonDeleted<ExcalidrawTextElement>, elementsMap: ElementsMap, nextWidth: number) => {
+    size: number;
+} | null;
 export declare const resizeSingleElement: (originalElements: PointerDownState["originalElements"], shouldMaintainAspectRatio: boolean, element: NonDeletedExcalidrawElement, elementsMap: ElementsMap, transformHandleDirection: TransformHandleDirection, shouldResizeFromCenter: boolean, pointerX: number, pointerY: number) => void;
-export declare const resizeMultipleElements: (originalElements: PointerDownState["originalElements"], selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, transformHandleType: "nw" | "ne" | "sw" | "se", shouldResizeFromCenter: boolean, pointerX: number, pointerY: number) => void;
+export declare const resizeMultipleElements: (originalElements: PointerDownState["originalElements"], selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, transformHandleType: TransformHandleDirection, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number) => void;
 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";