@excalidraw/excalidraw 0.17.1-550a388 → 0.17.1-62228e0

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,8 +1,10 @@
 /// <reference types="react" />
-import { ExcalidrawProps } from "../types";
-import { ExcalidrawElement, ExcalidrawIframeLikeElement, IframeData } from "./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) => IframeData | null;
+export declare const getEmbedLink: (link: string | null | undefined) => IframeDataWithSandbox | null;
 export declare const createPlaceholderEmbeddableLabel: (element: ExcalidrawIframeLikeElement) => ExcalidrawElement;
 export declare const actionSetEmbeddableAsActiveTool: {
     name: "setEmbeddableAsActiveTool";
@@ -11,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;
@@ -66,6 +68,7 @@ export declare const actionSetEmbeddableAsActiveTool: {
             currentItemTextAlign: string;
             currentItemStartArrowhead: import("./types").Arrowhead | null;
             currentItemEndArrowhead: import("./types").Arrowhead | null;
+            currentHoveredFontFamily: number | null;
             currentItemRoundness: import("./types").StrokeRoundness;
             viewBackgroundColor: string;
             scrollX: number;
@@ -79,7 +82,7 @@ export declare const actionSetEmbeddableAsActiveTool: {
                 value: import("../types").NormalizedZoomValue;
             }>;
             openMenu: "canvas" | "shape" | null;
-            openPopup: "canvasBackground" | "elementBackground" | "elementStroke" | null;
+            openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
                 tab?: string | undefined;
@@ -144,7 +147,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;
@@ -165,10 +171,11 @@ export declare const actionSetEmbeddableAsActiveTool: {
             userToFollow: import("../types").UserToFollow | null;
             followedBy: Set<import("../types").SocketId>;
         };
-        commitToHistory: false;
+        storeAction: "none";
     };
 } & {
     keyTest?: undefined;
 };
 export declare const maybeParseEmbedSrc: (str: string) => string;
 export declare const embeddableURLValidator: (url: string | null | undefined, validateEmbeddable: ExcalidrawProps["validateEmbeddable"]) => boolean;
+export {};

package/dist/excalidraw/element/embeddable.js

@@ -5,16 +5,18 @@ import { setCursorForShape } from "../cursor";
 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]+)(?:\?.*)?$/;
+const RE_VIMEO = /^(?:http(?:s)?:\/\/)?(?:(?:w){3}\.)?(?:player\.)?vimeo\.com\/(?:video\/)?([^?\s]+)(?:\?.*)?$/;
 const RE_FIGMA = /^https:\/\/(?:www\.)?figma\.com/;
-const RE_GH_GIST = /^https:\/\/gist\.github\.com/;
-const RE_GH_GIST_EMBED = /^<script[\s\S]*?\ssrc=["'](https:\/\/gist.github.com\/.*?)\.js["']/i;
+const RE_GH_GIST = /^https:\/\/gist\.github\.com\/([\w_-]+)\/([\w_-]+)/;
+const RE_GH_GIST_EMBED = /^<script[\s\S]*?\ssrc=["'](https:\/\/gist\.github\.com\/.*?)\.js["']/i;
 // not anchored to start to allow <blockquote> twitter embeds
-const RE_TWITTER = /(?:http(?:s)?:\/\/)?(?:(?:w){3}.)?(?:twitter|x).com/;
-const RE_TWITTER_EMBED = /^<blockquote[\s\S]*?\shref=["'](https:\/\/(?:twitter|x).com\/[^"']*)/i;
-const RE_VALTOWN = /^https:\/\/(?:www\.)?val.town\/(v|embed)\/[a-zA-Z_$][0-9a-zA-Z_$]+\.[a-zA-Z_$][0-9a-zA-Z_$]+/;
+const RE_TWITTER = /(?:https?:\/\/)?(?:(?:w){3}\.)?(?:twitter|x)\.com\/[^/]+\/status\/(\d+)/;
+const RE_TWITTER_EMBED = /^<blockquote[\s\S]*?\shref=["'](https?:\/\/(?:twitter|x)\.com\/[^"']*)/i;
+const RE_VALTOWN = /^https:\/\/(?:www\.)?val\.town\/(v|embed)\/[a-zA-Z_$][0-9a-zA-Z_$]+\.[a-zA-Z_$][0-9a-zA-Z_$]+/;
 const RE_GENERIC_EMBED = /^<(?:iframe|blockquote)[\s\S]*?\s(?:src|href)=["']([^"']*)["'][\s\S]*?>$/i;
 const RE_GIPHY = /giphy.com\/(?:clips|embed|gifs)\/[a-zA-Z0-9]*?-?([a-zA-Z0-9]+)(?:[^a-zA-Z0-9]|$)/;
 const ALLOWED_DOMAINS = new Set([
@@ -31,7 +33,17 @@ const ALLOWED_DOMAINS = new Set([
     "stackblitz.com",
     "val.town",
     "giphy.com",
-    "dddice.com",
+]);
+const ALLOW_SAME_ORIGIN = new Set([
+    "youtube.com",
+    "youtu.be",
+    "vimeo.com",
+    "player.vimeo.com",
+    "figma.com",
+    "twitter.com",
+    "x.com",
+    "*.simplepdf.eu",
+    "stackblitz.com",
 ]);
 export const createSrcDoc = (body) => {
     return `<html><body>${body}</body></html>`;
@@ -44,6 +56,7 @@ export const getEmbedLink = (link) => {
         return embeddedLinkCache.get(link);
     }
     const originalLink = link;
+    const allowSameOrigin = ALLOW_SAME_ORIGIN.has(matchHostname(link, ALLOW_SAME_ORIGIN) || "");
     let type = "generic";
     let aspectRatio = { w: 560, h: 840 };
     const ytLink = link.match(RE_YOUTUBE);
@@ -70,8 +83,14 @@ export const getEmbedLink = (link) => {
             link,
             intrinsicSize: aspectRatio,
             type,
+            sandbox: { allowSameOrigin },
         });
-        return { link, intrinsicSize: aspectRatio, type };
+        return {
+            link,
+            intrinsicSize: aspectRatio,
+            type,
+            sandbox: { allowSameOrigin },
+        };
     }
     const vimeoLink = link.match(RE_VIMEO);
     if (vimeoLink?.[1]) {
@@ -88,8 +107,15 @@ export const getEmbedLink = (link) => {
             link,
             intrinsicSize: aspectRatio,
             type,
+            sandbox: { allowSameOrigin },
         });
-        return { link, intrinsicSize: aspectRatio, type, error };
+        return {
+            link,
+            intrinsicSize: aspectRatio,
+            type,
+            error,
+            sandbox: { allowSameOrigin },
+        };
     }
     const figmaLink = link.match(RE_FIGMA);
     if (figmaLink) {
@@ -100,8 +126,14 @@ export const getEmbedLink = (link) => {
             link,
             intrinsicSize: aspectRatio,
             type,
+            sandbox: { allowSameOrigin },
         });
-        return { link, intrinsicSize: aspectRatio, type };
+        return {
+            link,
+            intrinsicSize: aspectRatio,
+            type,
+            sandbox: { allowSameOrigin },
+        };
     }
     const valLink = link.match(RE_VALTOWN);
     if (valLink) {
@@ -111,64 +143,62 @@ export const getEmbedLink = (link) => {
             link,
             intrinsicSize: aspectRatio,
             type,
+            sandbox: { allowSameOrigin },
         });
-        return { link, intrinsicSize: aspectRatio, type };
+        return {
+            link,
+            intrinsicSize: aspectRatio,
+            type,
+            sandbox: { allowSameOrigin },
+        };
     }
     if (RE_TWITTER.test(link)) {
-        // the embed srcdoc still supports twitter.com domain only
-        link = link.replace(/\bx.com\b/, "twitter.com");
-        let ret;
-        // assume embed code
-        if (/<blockquote/.test(link)) {
-            const srcDoc = createSrcDoc(link);
-            ret = {
-                type: "document",
-                srcdoc: () => srcDoc,
-                intrinsicSize: { w: 480, h: 480 },
-            };
-            // assume regular tweet url
-        }
-        else {
-            ret = {
-                type: "document",
-                srcdoc: (theme) => createSrcDoc(`<blockquote class="twitter-tweet" data-dnt="true" data-theme="${theme}"><a href="${link}"></a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>`),
-                intrinsicSize: { w: 480, h: 480 },
-            };
-        }
+        const postId = link.match(RE_TWITTER)[1];
+        // the embed srcdoc still supports twitter.com domain only.
+        // Note that we don't attempt to parse the username as it can consist of
+        // non-latin1 characters, and the username in the url can be set to anything
+        // without affecting the embed.
+        const safeURL = sanitizeHTMLAttribute(`https://twitter.com/x/status/${postId}`);
+        const ret = {
+            type: "document",
+            srcdoc: (theme) => createSrcDoc(`<blockquote class="twitter-tweet" data-dnt="true" data-theme="${theme}"><a href="${safeURL}"></a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>`),
+            intrinsicSize: { w: 480, h: 480 },
+            sandbox: { allowSameOrigin },
+        };
         embeddedLinkCache.set(originalLink, ret);
         return ret;
     }
     if (RE_GH_GIST.test(link)) {
-        let ret;
-        // assume embed code
-        if (/<script>/.test(link)) {
-            const srcDoc = createSrcDoc(link);
-            ret = {
-                type: "document",
-                srcdoc: () => srcDoc,
-                intrinsicSize: { w: 550, h: 720 },
-            };
-            // assume regular url
-        }
-        else {
-            ret = {
-                type: "document",
-                srcdoc: () => createSrcDoc(`
-          <script src="${link}.js"></script>
+        const [, user, gistId] = link.match(RE_GH_GIST);
+        const safeURL = sanitizeHTMLAttribute(`https://gist.github.com/${user}/${gistId}`);
+        const ret = {
+            type: "document",
+            srcdoc: () => createSrcDoc(`
+          <script src="${safeURL}.js"></script>
           <style type="text/css">
             * { margin: 0px; }
             table, .gist { height: 100%; }
             .gist .gist-file { height: calc(100vh - 2px); padding: 0px; display: grid; grid-template-rows: 1fr auto; }
           </style>
         `),
-                intrinsicSize: { w: 550, h: 720 },
-            };
-        }
+            intrinsicSize: { w: 550, h: 720 },
+            sandbox: { allowSameOrigin },
+        };
         embeddedLinkCache.set(link, ret);
         return ret;
     }
-    embeddedLinkCache.set(link, { link, intrinsicSize: aspectRatio, type });
-    return { link, intrinsicSize: aspectRatio, type };
+    embeddedLinkCache.set(link, {
+        link,
+        intrinsicSize: aspectRatio,
+        type,
+        sandbox: { allowSameOrigin },
+    });
+    return {
+        link,
+        intrinsicSize: aspectRatio,
+        type,
+        sandbox: { allowSameOrigin },
+    };
 };
 export const createPlaceholderEmbeddableLabel = (element) => {
     let text;
@@ -219,29 +249,35 @@ export const actionSetEmbeddableAsActiveTool = register({
                     type: "embeddable",
                 }),
             },
-            commitToHistory: false,
+            storeAction: StoreAction.NONE,
         };
     },
 });
-const validateHostname = (url, 
+const matchHostname = (url, 
 /** using a Set assumes it already contains normalized bare domains */
 allowedHostnames) => {
     try {
         const { hostname } = new URL(url);
         const bareDomain = hostname.replace(/^www\./, "");
-        const bareDomainWithFirstSubdomainWildcarded = bareDomain.replace(/^([^.]+)/, "*");
         if (allowedHostnames instanceof Set) {
-            return (ALLOWED_DOMAINS.has(bareDomain) ||
-                ALLOWED_DOMAINS.has(bareDomainWithFirstSubdomainWildcarded));
+            if (ALLOWED_DOMAINS.has(bareDomain)) {
+                return bareDomain;
+            }
+            const bareDomainWithFirstSubdomainWildcarded = bareDomain.replace(/^([^.]+)/, "*");
+            if (ALLOWED_DOMAINS.has(bareDomainWithFirstSubdomainWildcarded)) {
+                return bareDomainWithFirstSubdomainWildcarded;
+            }
+            return null;
         }
-        if (bareDomain === allowedHostnames.replace(/^www\./, "")) {
-            return true;
+        const bareAllowedHostname = allowedHostnames.replace(/^www\./, "");
+        if (bareDomain === bareAllowedHostname) {
+            return bareAllowedHostname;
         }
     }
     catch (error) {
         // ignore
     }
-    return false;
+    return null;
 };
 export const maybeParseEmbedSrc = (str) => {
     const twitterMatch = str.match(RE_TWITTER_EMBED);
@@ -286,12 +322,12 @@ export const embeddableURLValidator = (url, validateEmbeddable) => {
                         return true;
                     }
                 }
-                else if (validateHostname(url, domain)) {
+                else if (matchHostname(url, domain)) {
                     return true;
                 }
             }
             return false;
         }
     }
-    return validateHostname(url, ALLOWED_DOMAINS);
+    return !!matchHostname(url, ALLOWED_DOMAINS);
 };

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,8 +1,7 @@
-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 { hitTest, isHittingElementBoundingBoxWithoutHittingElement, } from "./collision";
 export { resizeTest, getCursorForResizingElement, getElementWithTransformHandleType, getTransformHandleTypeFromCoords, } from "./resizeTest";
 export { transformElements, getResizeOffsetXY, getResizeArrowDirection, } from "./resizeElements";
 export { dragSelectedElements, getDragOffsetXY, dragNewElement, } from "./dragElements";

package/dist/excalidraw/element/index.js

@@ -1,9 +1,8 @@
 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 { hitTest, isHittingElementBoundingBoxWithoutHittingElement, } from "./collision";
 export { resizeTest, getCursorForResizingElement, getElementWithTransformHandleType, getTransformHandleTypeFromCoords, } from "./resizeTest";
 export { transformElements, getResizeOffsetXY, getResizeArrowDirection, } from "./resizeElements";
 export { dragSelectedElements, getDragOffsetXY, dragNewElement, } from "./dragElements";

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

@@ -1,8 +1,8 @@
 /// <reference types="react" />
-import { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "./types";
-import { Bounds } from "./bounds";
-import { Point, AppState, PointerCoords, InteractiveCanvasAppState } 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)[];
@@ -52,7 +52,7 @@ export declare class LinearElementEditor {
         x: number;
         y: number;
     }[]) => void, linearElementEditor: LinearElementEditor, elementsMap: NonDeletedSceneElementsMap): boolean;
-    static handlePointerUp(event: PointerEvent, editingLinearElement: LinearElementEditor, appState: AppState, elements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap): LinearElementEditor;
+    static handlePointerUp(event: PointerEvent, editingLinearElement: LinearElementEditor, appState: AppState, app: AppClassProperties): LinearElementEditor;
     static getEditorMidPoints: (element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => (typeof editorMidPointsCache)["points"];
     static updateEditorMidPointsCache: (element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => void;
     static getSegmentMidpointHitCoords: (linearElementEditor: LinearElementEditor, scenePointer: {
@@ -62,10 +62,10 @@ 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, elements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap): {
+    }, linearElementEditor: LinearElementEditor, app: AppClassProperties): {
         didAddPoint: boolean;
         hitElement: NonDeleted<ExcalidrawElement> | null;
         linearElementEditor: LinearElementEditor | null;
@@ -133,13 +133,13 @@ export declare class LinearElementEditor {
             isLoading: boolean;
             errorMessage: import("react").ReactNode;
             activeEmbeddable: {
-                element: NonDeletedExcalidrawElement;
+                element: import("./types").NonDeletedExcalidrawElement;
                 state: "hover" | "active";
             } | null;
-            draggingElement: NonDeletedExcalidrawElement | null;
-            resizingElement: NonDeletedExcalidrawElement | null;
+            draggingElement: import("./types").NonDeletedExcalidrawElement | null;
+            resizingElement: import("./types").NonDeletedExcalidrawElement | null;
             multiElement: NonDeleted<ExcalidrawLinearElement> | null;
-            selectionElement: NonDeletedExcalidrawElement | null;
+            selectionElement: import("./types").NonDeletedExcalidrawElement | null;
             isBindingEnabled: boolean;
             startBoundElement: NonDeleted<ExcalidrawBindableElement> | null;
             suggestedBindings: import("./binding").SuggestedBinding[];
@@ -152,7 +152,7 @@ export declare class LinearElementEditor {
             };
             editingFrame: string | null;
             elementsToHighlight: NonDeleted<ExcalidrawElement>[] | null;
-            editingElement: NonDeletedExcalidrawElement | null;
+            editingElement: import("./types").NonDeletedExcalidrawElement | null;
             activeTool: {
                 lastActiveTool: import("../types").ActiveTool | null;
                 locked: boolean;
@@ -175,6 +175,7 @@ export declare class LinearElementEditor {
             currentItemTextAlign: string;
             currentItemStartArrowhead: import("./types").Arrowhead | null;
             currentItemEndArrowhead: import("./types").Arrowhead | null;
+            currentHoveredFontFamily: number | null;
             currentItemRoundness: import("./types").StrokeRoundness;
             viewBackgroundColor: string;
             scrollX: number;
@@ -188,7 +189,7 @@ export declare class LinearElementEditor {
                 value: import("../types").NormalizedZoomValue;
             }>;
             openMenu: "canvas" | "shape" | null;
-            openPopup: "canvasBackground" | "elementBackground" | "elementStroke" | null;
+            openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
             openSidebar: {
                 name: string;
                 tab?: string | undefined;
@@ -253,7 +254,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

@@ -163,7 +163,8 @@ export class LinearElementEditor {
         }
         return false;
     }
-    static handlePointerUp(event, editingLinearElement, appState, elements, elementsMap) {
+    static handlePointerUp(event, editingLinearElement, appState, app) {
+        const elementsMap = app.scene.getNonDeletedElementsMap();
         const { elementId, selectedPointsIndices, isDragging, pointerDownState } = editingLinearElement;
         const element = LinearElementEditor.getElement(elementId, elementsMap);
         if (!element) {
@@ -185,7 +186,7 @@ export class LinearElementEditor {
                         ]);
                     }
                     const bindingElement = isBindingEnabled(appState)
-                        ? getHoveredElementForBinding(tupleToCoors(LinearElementEditor.getPointAtIndexGlobalCoordinates(element, selectedPoint, elementsMap)), elements, elementsMap)
+                        ? getHoveredElementForBinding(tupleToCoors(LinearElementEditor.getPointAtIndexGlobalCoordinates(element, selectedPoint, elementsMap)), elementsMap)
                         : null;
                     bindings[selectedPoint === 0 ? "startBindingElement" : "endBindingElement"] = bindingElement;
                 }
@@ -313,7 +314,8 @@ export class LinearElementEditor {
         }
         return -1;
     }
-    static handlePointerDown(event, appState, history, scenePointer, linearElementEditor, elements, elementsMap) {
+    static handlePointerDown(event, appState, store, scenePointer, linearElementEditor, app) {
+        const elementsMap = app.scene.getNonDeletedElementsMap();
         const ret = {
             didAddPoint: false,
             hitElement: null,
@@ -342,7 +344,7 @@ export class LinearElementEditor {
                 });
                 ret.didAddPoint = true;
             }
-            history.resumeRecording();
+            store.shouldCaptureIncrement();
             ret.linearElementEditor = {
                 ...linearElementEditor,
                 pointerDownState: {
@@ -357,7 +359,7 @@ export class LinearElementEditor {
                 },
                 selectedPointsIndices: [element.points.length - 1],
                 lastUncommittedPoint: null,
-                endBindingElement: getHoveredElementForBinding(scenePointer, elements, elementsMap),
+                endBindingElement: getHoveredElementForBinding(scenePointer, elementsMap),
             };
             ret.didAddPoint = true;
             return ret;
@@ -659,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,12 +1,11 @@
-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;
+export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, force?: boolean) => TElement;
 /**
  * Mutates element, bumping `version`, `versionNonce`, and `updated`.
  *
  * 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,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 {