@excalidraw/excalidraw 0.17.1-88812e0 → 0.17.1-96eeec5

package/dist/excalidraw/renderer/renderElement.js

@@ -24,7 +24,7 @@ const shouldResetImageFilter = (element, renderConfig, appState) => {
         !isPendingImageElement(element, renderConfig) &&
         renderConfig.imageCache.get(element.fileId)?.mimeType !== MIME_TYPES.svg);
 };
-const getCanvasPadding = (element) => element.type === "freedraw" ? element.strokeWidth * 12 : 20;
+const getCanvasPadding = (element) => element.type === "freedraw" ? element.strokeWidth * 12 : 200;
 export const getRenderOpacity = (element, containingFrame, elementsPendingErasure) => {
     // multiplying frame opacity with element opacity to combine them
     // (e.g. frame 50% and element 50% opacity should result in 25% opacity)
@@ -119,7 +119,7 @@ const IMAGE_PLACEHOLDER_IMG = document.createElement("img");
 IMAGE_PLACEHOLDER_IMG.src = `data:${MIME_TYPES.svg},${encodeURIComponent(`<svg aria-hidden="true" focusable="false" data-prefix="fas" data-icon="image" class="svg-inline--fa fa-image fa-w-16" role="img" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><path fill="#888" d="M464 448H48c-26.51 0-48-21.49-48-48V112c0-26.51 21.49-48 48-48h416c26.51 0 48 21.49 48 48v288c0 26.51-21.49 48-48 48zM112 120c-30.928 0-56 25.072-56 56s25.072 56 56 56 56-25.072 56-56-25.072-56-56-56zM64 384h384V272l-87.515-87.515c-4.686-4.686-12.284-4.686-16.971 0L208 320l-55.515-55.515c-4.686-4.686-12.284-4.686-16.971 0L64 336v48z"></path></svg>`)}`;
 const IMAGE_ERROR_PLACEHOLDER_IMG = document.createElement("img");
 IMAGE_ERROR_PLACEHOLDER_IMG.src = `data:${MIME_TYPES.svg},${encodeURIComponent(`<svg viewBox="0 0 668 668" xmlns="http://www.w3.org/2000/svg" xml:space="preserve" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2"><path d="M464 448H48c-26.51 0-48-21.49-48-48V112c0-26.51 21.49-48 48-48h416c26.51 0 48 21.49 48 48v288c0 26.51-21.49 48-48 48ZM112 120c-30.928 0-56 25.072-56 56s25.072 56 56 56 56-25.072 56-56-25.072-56-56-56ZM64 384h384V272l-87.515-87.515c-4.686-4.686-12.284-4.686-16.971 0L208 320l-55.515-55.515c-4.686-4.686-12.284-4.686-16.971 0L64 336v48Z" style="fill:#888;fill-rule:nonzero" transform="matrix(.81709 0 0 .81709 124.825 145.825)"/><path d="M256 8C119.034 8 8 119.033 8 256c0 136.967 111.034 248 248 248s248-111.034 248-248S392.967 8 256 8Zm130.108 117.892c65.448 65.448 70 165.481 20.677 235.637L150.47 105.216c70.204-49.356 170.226-44.735 235.638 20.676ZM125.892 386.108c-65.448-65.448-70-165.481-20.677-235.637L361.53 406.784c-70.203 49.356-170.226 44.736-235.638-20.676Z" style="fill:#888;fill-rule:nonzero" transform="matrix(.30366 0 0 .30366 506.822 60.065)"/></svg>`)}`;
-const drawImagePlaceholder = (element, context, zoomValue) => {
+const drawImagePlaceholder = (element, context) => {
     context.fillStyle = "#E7E7E7";
     context.fillRect(0, 0, element.width, element.height);
     const imageMinWidthOrHeight = Math.min(element.width, element.height);
@@ -176,7 +176,7 @@ const drawElementOnCanvas = (element, rc, context, renderConfig, appState) => {
                 context.drawImage(img, 0 /* hardcoded for the selection box*/, 0, element.width, element.height);
             }
             else {
-                drawImagePlaceholder(element, context, appState.zoom.value);
+                drawImagePlaceholder(element, context);
             }
             break;
         }
@@ -323,7 +323,7 @@ const drawElementFromCanvas = (elementWithCanvas, context, renderConfig, appStat
     context.restore();
     // Clear the nested element we appended to the DOM
 };
-export const renderSelectionElement = (element, context, appState) => {
+export const renderSelectionElement = (element, context, appState, selectionColor) => {
     context.save();
     context.translate(element.x + appState.scrollX, element.y + appState.scrollY);
     context.fillStyle = "rgba(0, 0, 200, 0.04)";
@@ -334,7 +334,7 @@ export const renderSelectionElement = (element, context, appState) => {
     const offset = 0.5 / appState.zoom.value;
     context.fillRect(offset, offset, element.width, element.height);
     context.lineWidth = 1 / appState.zoom.value;
-    context.strokeStyle = " rgb(105, 101, 219)";
+    context.strokeStyle = selectionColor;
     context.strokeRect(offset, offset, element.width, element.height);
     context.restore();
 };

package/dist/excalidraw/renderer/renderSnaps.d.ts

@@ -1,2 +1,2 @@
-import { InteractiveCanvasAppState } from "../types";
+import type { InteractiveCanvasAppState } from "../types";
 export declare const renderSnaps: (context: CanvasRenderingContext2D, appState: InteractiveCanvasAppState) => void;

package/dist/excalidraw/renderer/staticScene.d.ts

@@ -1,4 +1,4 @@
-import { StaticSceneRenderConfig } from "../scene/types";
+import type { StaticSceneRenderConfig } from "../scene/types";
 /** throttled to animation framerate */
 export declare const renderStaticSceneThrottled: {
     (config: StaticSceneRenderConfig): void;

package/dist/excalidraw/renderer/staticSvgScene.d.ts

@@ -1,5 +1,5 @@
-import { RoughSVG } from "roughjs/bin/svg";
-import { NonDeletedExcalidrawElement } from "../element/types";
-import { RenderableElementsMap, SVGRenderConfig } from "../scene/types";
-import { BinaryFiles } from "../types";
+import type { RoughSVG } from "roughjs/bin/svg";
+import type { NonDeletedExcalidrawElement } from "../element/types";
+import type { RenderableElementsMap, SVGRenderConfig } from "../scene/types";
+import type { BinaryFiles } from "../types";
 export declare const renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], elementsMap: RenderableElementsMap, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, renderConfig: SVGRenderConfig) => void;

package/dist/excalidraw/scene/Fonts.d.ts

@@ -1,11 +1,9 @@
-import { ExcalidrawElement } from "../element/types";
+import type { ExcalidrawElement } from "../element/types";
 import type Scene from "./Scene";
 export declare class Fonts {
     private scene;
-    private onSceneUpdated;
-    constructor({ scene, onSceneUpdated, }: {
+    constructor({ scene }: {
         scene: Scene;
-        onSceneUpdated: () => void;
     });
     private static loadedFontFaces;
     /**

package/dist/excalidraw/scene/Fonts.js

@@ -1,15 +1,11 @@
-import { isTextElement, refreshTextDimensions } from "../element";
-import { newElementWith } from "../element/mutateElement";
+import { isTextElement } from "../element";
 import { getContainerElement } from "../element/textElement";
-import { isBoundToContainer } from "../element/typeChecks";
 import { getFontString } from "../utils";
 import { ShapeCache } from "./ShapeCache";
 export class Fonts {
     scene;
-    onSceneUpdated;
-    constructor({ scene, onSceneUpdated, }) {
+    constructor({ scene }) {
         this.scene = scene;
-        this.onSceneUpdated = onSceneUpdated;
     }
     // it's ok to track fonts across multiple instances only once, so let's use
     // a static member to reduce memory footprint
@@ -38,18 +34,19 @@ export class Fonts {
             return false;
         }
         let didUpdate = false;
-        this.scene.mapElements((element) => {
-            if (isTextElement(element) && !isBoundToContainer(element)) {
-                ShapeCache.delete(element);
+        const elementsMap = this.scene.getNonDeletedElementsMap();
+        for (const element of this.scene.getNonDeletedElements()) {
+            if (isTextElement(element)) {
                 didUpdate = true;
-                return newElementWith(element, {
-                    ...refreshTextDimensions(element, getContainerElement(element, this.scene.getNonDeletedElementsMap()), this.scene.getNonDeletedElementsMap()),
-                });
+                ShapeCache.delete(element);
+                const container = getContainerElement(element, elementsMap);
+                if (container) {
+                    ShapeCache.delete(container);
+                }
             }
-            return element;
-        });
+        }
         if (didUpdate) {
-            this.onSceneUpdated();
+            this.scene.triggerUpdate();
         }
     };
     loadFontsForElements = async (elements) => {

package/dist/excalidraw/scene/Renderer.d.ts

@@ -1,6 +1,6 @@
-import { NonDeletedExcalidrawElement } from "../element/types";
-import { AppState } from "../types";
-import Scene from "./Scene";
+import type { NonDeletedExcalidrawElement } from "../element/types";
+import type { AppState } from "../types";
+import type Scene from "./Scene";
 export declare class Renderer {
     private scene;
     constructor(scene: Scene);
@@ -14,7 +14,7 @@ export declare class Renderer {
         width: AppState["width"];
         editingElement: AppState["editingElement"];
         pendingImageElementId: AppState["pendingImageElementId"];
-        versionNonce: ReturnType<InstanceType<typeof Scene>["getVersionNonce"]>;
+        sceneNonce: ReturnType<InstanceType<typeof Scene>["getSceneNonce"]>;
     }) => {
         elementsMap: Map<string, NonDeletedExcalidrawElement> & import("../utility-types").MakeBrand<"NonDeletedElementsMap"> & import("../utility-types").MakeBrand<"RenderableElementsMap">;
         visibleElements: readonly NonDeletedExcalidrawElement[];

package/dist/excalidraw/scene/Renderer.js

@@ -45,9 +45,8 @@ export class Renderer {
             return elementsMap;
         };
         return memoize(({ zoom, offsetLeft, offsetTop, scrollX, scrollY, height, width, editingElement, pendingImageElementId, 
-        // unused but serves we cache on it to invalidate elements if they
-        // get mutated
-        versionNonce: _versionNonce, }) => {
+        // cache-invalidation nonce
+        sceneNonce: _sceneNonce, }) => {
             const elements = this.scene.getNonDeletedElements();
             const elementsMap = getRenderableElements({
                 elements,

package/dist/excalidraw/scene/Scene.d.ts

@@ -1,6 +1,6 @@
-import { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameLikeElement, ElementsMapOrArray, OrderedExcalidrawElement, Ordered } from "../element/types";
-import { LinearElementEditor } from "../element/linearElementEditor";
-import { AppState } from "../types";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameLikeElement, ElementsMapOrArray, OrderedExcalidrawElement, Ordered } from "../element/types";
+import type { LinearElementEditor } from "../element/linearElementEditor";
+import type { AppState } from "../types";
 type ElementIdKey = InstanceType<typeof LinearElementEditor>["elementId"];
 type ElementKey = ExcalidrawElement | ElementIdKey;
 type SceneStateCallback = () => void;
@@ -10,6 +10,9 @@ declare class Scene {
     private static sceneMapByElement;
     private static sceneMapById;
     static mapElementToScene(elementKey: ElementKey, scene: Scene): void;
+    /**
+     * @deprecated pass down `app.scene` and use it directly
+     */
     static getScene(elementKey: ElementKey): Scene | null;
     private callbacks;
     private nonDeletedElements;
@@ -19,7 +22,14 @@ declare class Scene {
     private frames;
     private elementsMap;
     private selectedElementsCache;
-    private versionNonce;
+    /**
+     * Random integer regenerated each scene update.
+     *
+     * Does not relate to elements versions, it's only a renderer
+     * cache-invalidation nonce at the moment.
+     */
+    private sceneNonce;
+    getSceneNonce(): number | undefined;
     getNonDeletedElementsMap(): Map<string, Ordered<NonDeletedExcalidrawElement>> & import("../utility-types").MakeBrand<"NonDeletedSceneElementsMap">;
     getElementsIncludingDeleted(): readonly OrderedExcalidrawElement[];
     getElementsMapIncludingDeleted(): Map<string, Ordered<ExcalidrawElement>> & import("../utility-types").MakeBrand<"SceneElementsMap">;
@@ -38,7 +48,6 @@ declare class Scene {
     }): NonDeleted<ExcalidrawElement>[];
     getNonDeletedFramesLikes(): readonly NonDeleted<ExcalidrawFrameLikeElement>[];
     getElement<T extends ExcalidrawElement>(id: T["id"]): T | null;
-    getVersionNonce(): number | undefined;
     getNonDeletedElement(id: ExcalidrawElement["id"]): NonDeleted<ExcalidrawElement> | null;
     /**
      * A utility method to help with updating all scene elements, with the added
@@ -54,8 +63,8 @@ declare class Scene {
      */
     mapElements(iteratee: (element: ExcalidrawElement) => ExcalidrawElement): boolean;
     replaceAllElements(nextElements: ElementsMapOrArray): void;
-    informMutation(): void;
-    addCallback(cb: SceneStateCallback): SceneStateCallbackRemover;
+    triggerUpdate(): void;
+    onUpdate(cb: SceneStateCallback): SceneStateCallbackRemover;
     destroy(): void;
     insertElementAtIndex(element: ExcalidrawElement, index: number): void;
     insertElementsAtIndex(elements: ExcalidrawElement[], index: number): void;

package/dist/excalidraw/scene/Scene.js

@@ -50,6 +50,9 @@ class Scene {
             this.sceneMapById.set(elementKey.id, scene);
         }
     }
+    /**
+     * @deprecated pass down `app.scene` and use it directly
+     */
     static getScene(elementKey) {
         if (isIdKey(elementKey)) {
             return this.sceneMapById.get(elementKey) || null;
@@ -72,7 +75,16 @@ class Scene {
         elements: null,
         cache: new Map(),
     };
-    versionNonce;
+    /**
+     * Random integer regenerated each scene update.
+     *
+     * Does not relate to elements versions, it's only a renderer
+     * cache-invalidation nonce at the moment.
+     */
+    sceneNonce;
+    getSceneNonce() {
+        return this.sceneNonce;
+    }
     getNonDeletedElementsMap() {
         return this.nonDeletedElementsMap;
     }
@@ -118,9 +130,6 @@ class Scene {
     getElement(id) {
         return this.elementsMap.get(id) || null;
     }
-    getVersionNonce() {
-        return this.versionNonce;
-    }
     getNonDeletedElement(id) {
         const element = this.getElement(id);
         if (element && isNonDeletedElement(element)) {
@@ -179,15 +188,15 @@ class Scene {
         this.nonDeletedElementsMap = nonDeletedElements.elementsMap;
         this.frames = nextFrameLikes;
         this.nonDeletedFramesLikes = getNonDeletedElements(this.frames).elements;
-        this.informMutation();
+        this.triggerUpdate();
     }
-    informMutation() {
-        this.versionNonce = randomInteger();
+    triggerUpdate() {
+        this.sceneNonce = randomInteger();
         for (const callback of Array.from(this.callbacks)) {
             callback();
         }
     }
-    addCallback(cb) {
+    onUpdate(cb) {
         if (this.callbacks.has(cb)) {
             throw new Error();
         }

package/dist/excalidraw/scene/Shape.d.ts

@@ -1,7 +1,7 @@
 import type { Drawable, Options } from "roughjs/bin/core";
 import type { RoughGenerator } from "roughjs/bin/generator";
 import type { ExcalidrawElement, NonDeletedExcalidrawElement, ExcalidrawSelectionElement } from "../element/types";
-import { EmbedsValidationStatus } from "../types";
+import type { EmbedsValidationStatus } from "../types";
 export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean) => Options;
 /**
  * Generates the roughjs shape for given element.

package/dist/excalidraw/scene/ShapeCache.d.ts

@@ -1,7 +1,7 @@
-import { Drawable } from "roughjs/bin/core";
-import { ExcalidrawElement } from "../element/types";
-import { ElementShape, ElementShapes } from "./types";
-import { AppState, EmbedsValidationStatus } from "../types";
+import type { Drawable } from "roughjs/bin/core";
+import type { ExcalidrawElement } from "../element/types";
+import type { ElementShape, ElementShapes } from "./types";
+import type { AppState, EmbedsValidationStatus } from "../types";
 export declare class ShapeCache {
     private static rg;
     private static cache;

package/dist/excalidraw/scene/comparisons.d.ts

@@ -1,5 +1,5 @@
-import { NonDeletedExcalidrawElement } from "../element/types";
-import { ElementOrToolType } from "../types";
+import type { NonDeletedExcalidrawElement } from "../element/types";
+import type { ElementOrToolType } from "../types";
 export declare const hasBackground: (type: ElementOrToolType) => boolean;
 export declare const hasStrokeColor: (type: ElementOrToolType) => boolean;
 export declare const hasStrokeWidth: (type: ElementOrToolType) => boolean;

package/dist/excalidraw/scene/export.d.ts

@@ -1,5 +1,5 @@
-import { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "../element/types";
-import { AppState, BinaryFiles } from "../types";
+import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "../element/types";
+import type { AppState, BinaryFiles } from "../types";
 export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, exportingFrame, }: {
     exportBackground: boolean;
     exportPadding?: number | undefined;

package/dist/excalidraw/scene/export.js

@@ -1,5 +1,5 @@
 import rough from "roughjs/bin/rough";
-import { getCommonBounds, getElementAbsoluteCoords, } from "../element/bounds";
+import { getCommonBounds, getElementAbsoluteCoords } from "../element/bounds";
 import { renderSceneToSvg } from "../renderer/staticSvgScene";
 import { arrayToMap, distance, getFontString, toBrandedType } from "../utils";
 import { DEFAULT_EXPORT_PADDING, FONT_FAMILY, FRAME_STYLE, SVG_NS, THEME, THEME_FILTER, } from "../constants";
@@ -200,7 +200,7 @@ export const exportToSvg = async (elements, appState, files, opts) => {
     if (import.meta.env.VITE_IS_EXCALIDRAW_NPM_PACKAGE) {
         assetPath =
             window.EXCALIDRAW_ASSET_PATH ||
-                `https://unpkg.com/${import.meta.env.VITE_PKG_NAME}@${import.meta.env.PKG_VERSION}`;
+                `https://unpkg.com/${import.meta.env.VITE_PKG_NAME}@${import.meta.env.VITE_PKG_VERSION}`;
         if (assetPath?.startsWith("/")) {
             assetPath = assetPath.replace("/", `${window.location.origin}/`);
         }

package/dist/excalidraw/scene/scroll.d.ts

@@ -1,5 +1,5 @@
-import { AppState, PointerCoords, Zoom } from "../types";
-import { ExcalidrawElement } from "../element/types";
+import type { AppState, PointerCoords, Zoom } from "../types";
+import type { ExcalidrawElement } from "../element/types";
 export declare const centerScrollOn: ({ scenePoint, viewportDimensions, zoom, }: {
     scenePoint: PointerCoords;
     viewportDimensions: {

package/dist/excalidraw/scene/scrollbars.d.ts

@@ -1,6 +1,6 @@
-import { InteractiveCanvasAppState } from "../types";
-import { ScrollBars } from "./types";
-import { ExcalidrawElement } from "../element/types";
+import type { InteractiveCanvasAppState } from "../types";
+import type { ScrollBars } from "./types";
+import type { ExcalidrawElement } from "../element/types";
 export declare const SCROLLBAR_MARGIN = 4;
 export declare const SCROLLBAR_WIDTH = 6;
 export declare const SCROLLBAR_COLOR = "rgba(0,0,0,0.3)";

package/dist/excalidraw/scene/selection.d.ts

@@ -1,5 +1,5 @@
-import { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
-import { AppState, InteractiveCanvasAppState } from "../types";
+import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
+import type { AppState, InteractiveCanvasAppState } from "../types";
 /**
  * Frames and their containing elements are not to be selected at the same time.
  * Given an array of selected elements, if there are frames and their containing elements

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

@@ -1,8 +1,8 @@
 import type { RoughCanvas } from "roughjs/bin/canvas";
-import { Drawable } from "roughjs/bin/core";
-import { ExcalidrawElement, ExcalidrawTextElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "../element/types";
-import { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, UserIdleState, Device } from "../types";
-import { MakeBrand } from "../utility-types";
+import type { Drawable } from "roughjs/bin/core";
+import type { ExcalidrawElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "../element/types";
+import type { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState, SocketId, UserIdleState, Device } from "../types";
+import type { MakeBrand } from "../utility-types";
 export type RenderableElementsMap = NonDeletedElementsMap & MakeBrand<"RenderableElementsMap">;
 export type StaticCanvasRenderConfig = {
     canvasBackgroundColor: AppState["viewBackgroundColor"];
@@ -33,7 +33,7 @@ export type InteractiveCanvasRenderConfig = {
     remotePointerUserStates: Map<SocketId, UserIdleState>;
     remotePointerUsernames: Map<SocketId, string>;
     remotePointerButton: Map<SocketId, string | undefined>;
-    selectionColor?: string;
+    selectionColor: string;
     renderScrollbars?: boolean;
 };
 export type RenderInteractiveSceneCallback = {
@@ -56,6 +56,7 @@ export type InteractiveSceneRenderConfig = {
     elementsMap: RenderableElementsMap;
     visibleElements: readonly NonDeletedExcalidrawElement[];
     selectedElements: readonly NonDeletedExcalidrawElement[];
+    allElementsMap: NonDeletedSceneElementsMap;
     scale: number;
     appState: InteractiveCanvasAppState;
     renderConfig: InteractiveCanvasRenderConfig;
@@ -66,9 +67,6 @@ export type SceneScroll = {
     scrollX: number;
     scrollY: number;
 };
-export interface Scene {
-    elements: ExcalidrawTextElement[];
-}
 export type ExportType = "png" | "clipboard" | "clipboard-svg" | "backend" | "svg";
 export type ScrollBars = {
     horizontal: {

package/dist/excalidraw/scene/zoom.d.ts

@@ -1,4 +1,4 @@
-import { AppState, NormalizedZoomValue } from "../types";
+import type { AppState, NormalizedZoomValue } from "../types";
 export declare const getNormalizedZoom: (zoom: number) => NormalizedZoomValue;
 export declare const getStateForZoom: ({ viewportX, viewportY, nextZoom, }: {
     viewportX: number;

package/dist/excalidraw/shapes.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="react" />
+import { type GeometricShape } from "../utils/geometry/shape";
+import type { ElementsMap, ExcalidrawElement } from "./element/types";
 export declare const SHAPES: readonly [{
     readonly icon: JSX.Element;
     readonly value: "selection";
@@ -61,3 +63,8 @@ export declare const SHAPES: readonly [{
     readonly fillable: false;
 }];
 export declare const findShapeByKey: (key: string) => "text" | "image" | "selection" | "rectangle" | "diamond" | "ellipse" | "arrow" | "line" | "freedraw" | "eraser" | null;
+/**
+ * get the pure geometric shape of an excalidraw element
+ * which is then used for hit detection
+ */
+export declare const getElementShape: (element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape;

package/dist/excalidraw/shapes.js

@@ -1,5 +1,9 @@
+import { getClosedCurveShape, getCurveShape, getEllipseShape, getFreedrawShape, getPolygonShape, } from "../utils/geometry/shape";
 import { ArrowIcon, DiamondIcon, EllipseIcon, EraserIcon, FreedrawIcon, ImageIcon, LineIcon, RectangleIcon, SelectionIcon, TextIcon, } from "./components/icons";
+import { getElementAbsoluteCoords } from "./element";
+import { shouldTestInside } from "./element/collision";
 import { KEYS } from "./keys";
+import { ShapeCache } from "./scene/ShapeCache";
 export const SHAPES = [
     {
         icon: SelectionIcon,
@@ -82,3 +86,39 @@ export const findShapeByKey = (key) => {
     });
     return shape?.value || null;
 };
+/**
+ * get the pure geometric shape of an excalidraw element
+ * which is then used for hit detection
+ */
+export const getElementShape = (element, elementsMap) => {
+    switch (element.type) {
+        case "rectangle":
+        case "diamond":
+        case "frame":
+        case "magicframe":
+        case "embeddable":
+        case "image":
+        case "iframe":
+        case "text":
+        case "selection":
+            return getPolygonShape(element);
+        case "arrow":
+        case "line": {
+            const roughShape = ShapeCache.get(element)?.[0] ??
+                ShapeCache.generateElementShape(element, null)[0];
+            const [, , , , cx, cy] = getElementAbsoluteCoords(element, elementsMap);
+            return shouldTestInside(element)
+                ? getClosedCurveShape(element, roughShape, [element.x, element.y], element.angle, [cx, cy])
+                : getCurveShape(roughShape, [element.x, element.y], element.angle, [
+                    cx,
+                    cy,
+                ]);
+        }
+        case "ellipse":
+            return getEllipseShape(element);
+        case "freedraw": {
+            const [, , , , cx, cy] = getElementAbsoluteCoords(element, elementsMap);
+            return getFreedrawShape(element, [cx, cy], shouldTestInside(element));
+        }
+    }
+};

package/dist/excalidraw/snapping.d.ts

@@ -1,7 +1,7 @@
-import { Bounds } from "./element/bounds";
-import { MaybeTransformHandleType } from "./element/transformHandles";
-import { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
-import { AppState, KeyboardModifiersObject, Point } from "./types";
+import type { Bounds } from "./element/bounds";
+import type { MaybeTransformHandleType } from "./element/transformHandles";
+import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
+import type { AppState, KeyboardModifiersObject, Point } from "./types";
 export declare const getSnapDistance: (zoomValue: number) => number;
 type Vector2D = {
     x: number;

package/dist/excalidraw/snapping.js

@@ -835,5 +835,6 @@ export const isActiveToolNonLinearSnappable = (activeToolType) => {
         activeToolType === TOOL_TYPE.diamond ||
         activeToolType === TOOL_TYPE.frame ||
         activeToolType === TOOL_TYPE.magicframe ||
-        activeToolType === TOOL_TYPE.image);
+        activeToolType === TOOL_TYPE.image ||
+        activeToolType === TOOL_TYPE.text);
 };

package/dist/excalidraw/store.d.ts

@@ -1,12 +1,42 @@
 import { AppStateChange, ElementsChange } from "./change";
-import { OrderedExcalidrawElement } from "./element/types";
+import type { OrderedExcalidrawElement } from "./element/types";
 import { Emitter } from "./emitter";
-import { AppState, ObservedAppState } from "./types";
+import type { AppState, ObservedAppState } from "./types";
+import type { ValueOf } from "./utility-types";
 export declare const getObservedAppState: (appState: AppState) => ObservedAppState;
-export type StoreActionType = "capture" | "update" | "none";
 export declare const StoreAction: {
-    [K in Uppercase<StoreActionType>]: StoreActionType;
+    /**
+     * Immediately undoable.
+     *
+     * Use for updates which should be captured.
+     * Should be used for most of the local updates.
+     *
+     * These updates will _immediately_ make it to the local undo / redo stacks.
+     */
+    readonly CAPTURE: "capture";
+    /**
+     * Never undoable.
+     *
+     * Use for updates which should never be recorded, such as remote updates
+     * or scene initialization.
+     *
+     * These updates will _never_ make it to the local undo / redo stacks.
+     */
+    readonly UPDATE: "update";
+    /**
+     * Eventually undoable.
+     *
+     * Use for updates which should not be captured immediately - likely
+     * exceptions which are part of some async multi-step process. Otherwise, all
+     * such updates would end up being captured with the next
+     * `StoreAction.CAPTURE` - triggered either by the next `updateScene`
+     * or internally by the editor.
+     *
+     * These updates will _eventually_ make it to the local undo / redo stacks.
+     */
+    readonly NONE: "none";
 };
+export type StoreActionType = ValueOf<typeof StoreAction>;
 /**
  * Represent an increment to the Store.
  */

package/dist/excalidraw/store.js

@@ -25,8 +25,35 @@ export const getObservedAppState = (appState) => {
 };
 const isObservedAppState = (appState) => !!Reflect.get(appState, hiddenObservedAppStateProp);
 export const StoreAction = {
+    /**
+     * Immediately undoable.
+     *
+     * Use for updates which should be captured.
+     * Should be used for most of the local updates.
+     *
+     * These updates will _immediately_ make it to the local undo / redo stacks.
+     */
     CAPTURE: "capture",
+    /**
+     * Never undoable.
+     *
+     * Use for updates which should never be recorded, such as remote updates
+     * or scene initialization.
+     *
+     * These updates will _never_ make it to the local undo / redo stacks.
+     */
     UPDATE: "update",
+    /**
+     * Eventually undoable.
+     *
+     * Use for updates which should not be captured immediately - likely
+     * exceptions which are part of some async multi-step process. Otherwise, all
+     * such updates would end up being captured with the next
+     * `StoreAction.CAPTURE` - triggered either by the next `updateScene`
+     * or internally by the editor.
+     *
+     * These updates will _eventually_ make it to the local undo / redo stacks.
+     */
     NONE: "none",
 };
 /**