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

package/dist/excalidraw/element/textWysiwyg.js

@@ -2,7 +2,7 @@ import { CODES, KEYS } from "../keys";
 import { isWritableElement, getFontString, getFontFamilyString, isTestEnv, } from "../utils";
 import Scene from "../scene/Scene";
 import { isArrowElement, isBoundToContainer, isTextElement, } from "./typeChecks";
-import { CLASSES } from "../constants";
+import { CLASSES, isSafari } from "../constants";
 import { bumpVersion, mutateElement } from "./mutateElement";
 import { getBoundTextElementId, getContainerElement, getTextElementAngle, getTextWidth, normalizeText, redrawTextBoundingBox, wrapText, getBoundTextMaxHeight, getBoundTextMaxWidth, computeContainerDimensionForBoundText, computeBoundTextPosition, getBoundTextElement, } from "./textElement";
 import { actionDecreaseFontSize, actionIncreaseFontSize, } from "../actions/actionProperties";
@@ -23,7 +23,7 @@ const getTransform = (width, height, angle, appState, maxWidth, maxHeight) => {
     }
     return `translate(${translateX}px, ${translateY}px) scale(${zoom.value}) rotate(${degree}deg)`;
 };
-export const textWysiwyg = ({ id, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, }) => {
+export const textWysiwyg = ({ id, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, autoSelect = true, }) => {
     const textPropertiesUpdated = (updatedTextElement, editable) => {
         if (!editable.style.fontFamily || !editable.style.fontSize) {
             return false;
@@ -50,12 +50,12 @@ export const textWysiwyg = ({ id, onChange, onSubmit, getViewportCoords, element
             let coordX = updatedTextElement.x;
             let coordY = updatedTextElement.y;
             const container = getContainerElement(updatedTextElement, app.scene.getNonDeletedElementsMap());
+            let width = updatedTextElement.width;
+            // set to element height by default since that's
+            // what is going to be used for unbounded text
+            let height = updatedTextElement.height;
             let maxWidth = updatedTextElement.width;
             let maxHeight = updatedTextElement.height;
-            let textElementWidth = updatedTextElement.width;
-            // Set to element height by default since that's
-            // what is going to be used for unbounded text
-            const textElementHeight = updatedTextElement.height;
             if (container && updatedTextElement.containerId) {
                 if (isArrowElement(container)) {
                     const boundTextCoords = LinearElementEditor.getBoundTextElementPosition(container, updatedTextElement, elementsMap);
@@ -76,8 +76,8 @@ export const textWysiwyg = ({ id, onChange, onSubmit, getViewportCoords, element
                 maxWidth = getBoundTextMaxWidth(container, updatedTextElement);
                 maxHeight = getBoundTextMaxHeight(container, updatedTextElement);
                 // autogrow container height if text exceeds
-                if (!isArrowElement(container) && textElementHeight > maxHeight) {
-                    const targetContainerHeight = computeContainerDimensionForBoundText(textElementHeight, container.type);
+                if (!isArrowElement(container) && height > maxHeight) {
+                    const targetContainerHeight = computeContainerDimensionForBoundText(height, container.type);
                     mutateElement(container, { height: targetContainerHeight });
                     return;
                 }
@@ -86,8 +86,8 @@ export const textWysiwyg = ({ id, onChange, onSubmit, getViewportCoords, element
                 // is reached when text is removed
                 !isArrowElement(container) &&
                     container.height > originalContainerData.height &&
-                    textElementHeight < maxHeight) {
-                    const targetContainerHeight = computeContainerDimensionForBoundText(textElementHeight, container.type);
+                    height < maxHeight) {
+                    const targetContainerHeight = computeContainerDimensionForBoundText(height, container.type);
                     mutateElement(container, { height: targetContainerHeight });
                 }
                 else {
@@ -111,19 +111,30 @@ export const textWysiwyg = ({ id, onChange, onSubmit, getViewportCoords, element
             }
             if (!container) {
                 maxWidth = (appState.width - 8 - viewportX) / appState.zoom.value;
-                textElementWidth = Math.min(textElementWidth, maxWidth);
+                width = Math.min(width, maxWidth);
+            }
+            else {
+                width += 0.5;
             }
+            // add 5% buffer otherwise it causes wysiwyg to jump
+            height *= 1.05;
+            const font = getFontString(updatedTextElement);
+            // adding left and right padding buffer, so that browser does not cut the glyphs (does not work in Safari)
+            const padding = !isSafari
+                ? Math.ceil(updatedTextElement.fontSize / 2)
+                : 0;
             // Make sure text editor height doesn't go beyond viewport
             const editorMaxHeight = (appState.height - viewportY) / appState.zoom.value;
             Object.assign(editable.style, {
-                font: getFontString(updatedTextElement),
+                font,
                 // must be defined *after* font ¯\_(ツ)_/¯
                 lineHeight: updatedTextElement.lineHeight,
-                width: `${textElementWidth}px`,
-                height: `${textElementHeight}px`,
-                left: `${viewportX}px`,
+                width: `${width}px`,
+                height: `${height}px`,
+                left: `${viewportX - padding}px`,
                 top: `${viewportY}px`,
-                transform: getTransform(textElementWidth, textElementHeight, getTextElementAngle(updatedTextElement, container), appState, maxWidth, editorMaxHeight),
+                transform: getTransform(width, height, getTextElementAngle(updatedTextElement, container), appState, maxWidth, editorMaxHeight),
+                padding: `0 ${padding}px`,
                 textAlign,
                 verticalAlign,
                 color: updatedTextElement.strokeColor,
@@ -149,7 +160,7 @@ export const textWysiwyg = ({ id, onChange, onSubmit, getViewportCoords, element
     editable.classList.add("excalidraw-wysiwyg");
     let whiteSpace = "pre";
     let wordBreak = "normal";
-    if (isBoundToContainer(element)) {
+    if (isBoundToContainer(element) || !element.autoResize) {
         whiteSpace = "pre-wrap";
         wordBreak = "break-word";
     }
@@ -159,7 +170,6 @@ export const textWysiwyg = ({ id, onChange, onSubmit, getViewportCoords, element
         minHeight: "1em",
         backfaceVisibility: "hidden",
         margin: 0,
-        padding: 0,
         border: 0,
         outline: 0,
         resize: "none",
@@ -193,7 +203,7 @@ export const textWysiwyg = ({ id, onChange, onSubmit, getViewportCoords, element
             if (container) {
                 const boundTextElement = getBoundTextElement(container, app.scene.getNonDeletedElementsMap());
                 const wrappedText = wrapText(`${editable.value}${data}`, font, getBoundTextMaxWidth(container, boundTextElement));
-                const width = getTextWidth(wrappedText, font);
+                const width = getTextWidth(wrappedText, font, true);
                 editable.style.width = `${width}px`;
             }
         };
@@ -319,13 +329,20 @@ export const textWysiwyg = ({ id, onChange, onSubmit, getViewportCoords, element
             .reverse();
     };
     const stopEvent = (event) => {
-        event.preventDefault();
-        event.stopPropagation();
+        if (event.target instanceof HTMLCanvasElement) {
+            event.preventDefault();
+            event.stopPropagation();
+        }
     };
     // using a state variable instead of passing it to the handleSubmit callback
     // so that we don't need to create separate a callback for event handlers
     let submittedViaKeyboard = false;
     const handleSubmit = () => {
+        // prevent double submit
+        if (isDestroyed) {
+            return;
+        }
+        isDestroyed = true;
         // cleanup must be run before onSubmit otherwise when app blurs the wysiwyg
         // it'd get stuck in an infinite loop of blur→onSubmit after we re-focus the
         // wysiwyg on update
@@ -334,10 +351,8 @@ export const textWysiwyg = ({ id, onChange, onSubmit, getViewportCoords, element
         if (!updateElement) {
             return;
         }
-        let text = editable.value;
         const container = getContainerElement(updateElement, app.scene.getNonDeletedElementsMap());
         if (container) {
-            text = updateElement.text;
             if (editable.value.trim()) {
                 const boundTextElementId = getBoundTextElementId(container);
                 if (!boundTextElementId || boundTextElementId !== element.id) {
@@ -361,16 +376,11 @@ export const textWysiwyg = ({ id, onChange, onSubmit, getViewportCoords, element
             redrawTextBoundingBox(updateElement, container, app.scene.getNonDeletedElementsMap());
         }
         onSubmit({
-            text,
             viaKeyboard: submittedViaKeyboard,
-            originalText: editable.value,
+            nextOriginalText: editable.value,
         });
     };
     const cleanup = () => {
-        if (isDestroyed) {
-            return;
-        }
-        isDestroyed = true;
         // remove events to ensure they don't late-fire
         editable.onblur = null;
         editable.oninput = null;
@@ -394,65 +404,63 @@ export const textWysiwyg = ({ id, onChange, onSubmit, getViewportCoords, element
         // Also to handle cases such as picking a color which would trigger a blur
         // in that same tick.
         const target = event?.target;
-        const isTargetPickerTrigger = target instanceof HTMLElement &&
-            target.classList.contains("active-color");
+        const isPropertiesTrigger = target instanceof HTMLElement &&
+            target.classList.contains("properties-trigger");
         setTimeout(() => {
             editable.onblur = handleSubmit;
-            if (isTargetPickerTrigger) {
-                const callback = (mutationList, observer) => {
-                    const radixIsRemoved = mutationList.find((mutation) => mutation.removedNodes.length > 0 &&
-                        mutation.removedNodes[0].dataset
-                            ?.radixPopperContentWrapper !== undefined);
-                    if (radixIsRemoved) {
-                        // should work without this in theory
-                        // and i think it does actually but radix probably somewhere,
-                        // somehow sets the focus elsewhere
-                        setTimeout(() => {
-                            editable.focus();
-                        });
-                        observer.disconnect();
-                    }
-                };
-                const observer = new MutationObserver(callback);
-                observer.observe(document.querySelector(".excalidraw-container"), {
-                    childList: true,
-                });
-            }
             // case: clicking on the same property → no change → no update → no focus
-            if (!isTargetPickerTrigger) {
+            if (!isPropertiesTrigger) {
                 editable.focus();
             }
         });
     };
     // prevent blur when changing properties from the menu
     const onPointerDown = (event) => {
-        const isTargetPickerTrigger = event.target instanceof HTMLElement &&
-            event.target.classList.contains("active-color");
+        const target = event?.target;
+        const isPropertiesTrigger = target instanceof HTMLElement &&
+            target.classList.contains("properties-trigger");
         if (((event.target instanceof HTMLElement ||
             event.target instanceof SVGElement) &&
             event.target.closest(`.${CLASSES.SHAPE_ACTIONS_MENU}`) &&
             !isWritableElement(event.target)) ||
-            isTargetPickerTrigger) {
+            isPropertiesTrigger) {
             editable.onblur = null;
             window.addEventListener("pointerup", bindBlurEvent);
             // handle edge-case where pointerup doesn't fire e.g. due to user
             // alt-tabbing away
             window.addEventListener("blur", handleSubmit);
         }
+        else if (event.target instanceof HTMLElement &&
+            event.target instanceof HTMLCanvasElement &&
+            // Vitest simply ignores stopPropagation, capture-mode, or rAF
+            // so without introducing crazier hacks, nothing we can do
+            !isTestEnv()) {
+            // On mobile, blur event doesn't seem to always fire correctly,
+            // so we want to also submit on pointerdown outside the wysiwyg.
+            // Done in the next frame to prevent pointerdown from creating a new text
+            // immediately (if tools locked) so that users on mobile have chance
+            // to submit first (to hide virtual keyboard).
+            // Note: revisit if we want to differ this behavior on Desktop
+            requestAnimationFrame(() => {
+                handleSubmit();
+            });
+        }
     };
     // handle updates of textElement properties of editing element
-    const unbindUpdate = Scene.getScene(element).addCallback(() => {
+    const unbindUpdate = Scene.getScene(element).onUpdate(() => {
         updateWysiwygStyle();
-        const isColorPickerActive = !!document.activeElement?.closest(".color-picker-content");
-        if (!isColorPickerActive) {
+        const isPopupOpened = !!document.activeElement?.closest(".properties-content");
+        if (!isPopupOpened) {
             editable.focus();
         }
     });
     // ---------------------------------------------------------------------------
     let isDestroyed = false;
-    // select on init (focusing is done separately inside the bindBlurEvent()
-    // because we need it to happen *after* the blur event from `pointerdown`)
-    editable.select();
+    if (autoSelect) {
+        // select on init (focusing is done separately inside the bindBlurEvent()
+        // because we need it to happen *after* the blur event from `pointerdown`)
+        editable.select();
+    }
     bindBlurEvent();
     // reposition wysiwyg in case of canvas is resized. Using ResizeObserver
     // is preferred so we catch changes from host, where window may not resize.
@@ -466,7 +474,12 @@ export const textWysiwyg = ({ id, onChange, onSubmit, getViewportCoords, element
     else {
         window.addEventListener("resize", updateWysiwygStyle);
     }
-    window.addEventListener("pointerdown", onPointerDown);
+    editable.onpointerdown = (event) => event.stopPropagation();
+    // rAF (+ capture to by doubly sure) so we don't catch te pointerdown that
+    // triggered the wysiwyg
+    requestAnimationFrame(() => {
+        window.addEventListener("pointerdown", onPointerDown, { capture: true });
+    });
     window.addEventListener("wheel", stopEvent, {
         passive: false,
         capture: true,

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

@@ -1,6 +1,6 @@
-import { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
-import { Bounds } from "./bounds";
-import { InteractiveCanvasAppState, Zoom } from "../types";
+import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
+import type { Bounds } from "./bounds";
+import type { Device, InteractiveCanvasAppState, Zoom } from "../types";
 export type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
 export type TransformHandleType = TransformHandleDirection | "rotation";
 export type TransformHandle = Bounds;
@@ -8,6 +8,12 @@ export type TransformHandles = Partial<{
     [T in TransformHandleType]: TransformHandle;
 }>;
 export type MaybeTransformHandleType = TransformHandleType | false;
+export declare const DEFAULT_OMIT_SIDES: {
+    e: boolean;
+    s: boolean;
+    n: boolean;
+    w: boolean;
+};
 export declare const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS: {
     e: boolean;
     s: boolean;
@@ -21,16 +27,28 @@ export declare const OMIT_SIDES_FOR_FRAME: {
     w: boolean;
     rotation: boolean;
 };
+export declare const canResizeFromSides: (device: Device) => boolean;
+export declare const getOmitSidesForDevice: (device: Device) => {};
 export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [number, number, number, number, number, number], angle: number, zoom: Zoom, pointerType: PointerType, omitSides?: {
     s?: boolean | undefined;
-    n?: boolean | undefined;
-    w?: boolean | undefined;
     e?: boolean | undefined;
+    w?: boolean | undefined;
+    n?: boolean | undefined;
     nw?: boolean | undefined;
     ne?: boolean | undefined;
     sw?: boolean | undefined;
     se?: boolean | undefined;
     rotation?: boolean | undefined;
 }, margin?: number) => TransformHandles;
-export declare const getTransformHandles: (element: ExcalidrawElement, zoom: Zoom, elementsMap: ElementsMap, pointerType?: PointerType) => TransformHandles;
+export declare const getTransformHandles: (element: ExcalidrawElement, zoom: Zoom, elementsMap: ElementsMap, pointerType?: PointerType, omitSides?: {
+    s?: boolean | undefined;
+    e?: boolean | undefined;
+    w?: boolean | undefined;
+    n?: boolean | undefined;
+    nw?: boolean | undefined;
+    ne?: boolean | undefined;
+    sw?: boolean | undefined;
+    se?: boolean | undefined;
+    rotation?: boolean | undefined;
+}) => TransformHandles;
 export declare const shouldShowBoundingBox: (elements: readonly NonDeletedExcalidrawElement[], appState: InteractiveCanvasAppState) => boolean;

package/dist/excalidraw/element/transformHandles.js

@@ -1,32 +1,31 @@
 import { getElementAbsoluteCoords } from "./bounds";
 import { rotate } from "../math";
-import { isTextElement } from ".";
 import { isFrameLikeElement, isLinearElement } from "./typeChecks";
-import { DEFAULT_TRANSFORM_HANDLE_SPACING } from "../constants";
+import { DEFAULT_TRANSFORM_HANDLE_SPACING, isAndroid, isIOS, } from "../constants";
 const transformHandleSizes = {
     mouse: 8,
     pen: 16,
     touch: 28,
 };
 const ROTATION_RESIZE_HANDLE_GAP = 16;
-export const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS = {
+export const DEFAULT_OMIT_SIDES = {
     e: true,
     s: true,
     n: true,
     w: true,
 };
-export const OMIT_SIDES_FOR_FRAME = {
+export const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS = {
     e: true,
     s: true,
     n: true,
     w: true,
-    rotation: true,
 };
-const OMIT_SIDES_FOR_TEXT_ELEMENT = {
+export const OMIT_SIDES_FOR_FRAME = {
     e: true,
     s: true,
     n: true,
     w: true,
+    rotation: true,
 };
 const OMIT_SIDES_FOR_LINE_SLASH = {
     e: true,
@@ -46,6 +45,21 @@ const generateTransformHandle = (x, y, width, height, cx, cy, angle) => {
     const [xx, yy] = rotate(x + width / 2, y + height / 2, cx, cy, angle);
     return [xx - width / 2, yy - height / 2, width, height];
 };
+export const canResizeFromSides = (device) => {
+    if (device.viewport.isMobile) {
+        return false;
+    }
+    if (device.isTouchScreen && (isAndroid || isIOS)) {
+        return false;
+    }
+    return true;
+};
+export const getOmitSidesForDevice = (device) => {
+    if (canResizeFromSides(device)) {
+        return DEFAULT_OMIT_SIDES;
+    }
+    return {};
+};
 export const getTransformHandlesFromCoords = ([x1, y1, x2, y2, cx, cy], angle, zoom, pointerType, omitSides = {}, margin = 4) => {
     const size = transformHandleSizes[pointerType];
     const handleWidth = size / zoom.value;
@@ -98,14 +112,13 @@ export const getTransformHandlesFromCoords = ([x1, y1, x2, y2, cx, cy], angle, z
     }
     return transformHandles;
 };
-export const getTransformHandles = (element, zoom, elementsMap, pointerType = "mouse") => {
+export const getTransformHandles = (element, zoom, elementsMap, pointerType = "mouse", omitSides = DEFAULT_OMIT_SIDES) => {
     // so that when locked element is selected (especially when you toggle lock
     // via keyboard) the locked element is visually distinct, indicating
     // you can't move/resize
     if (element.locked) {
         return {};
     }
-    let omitSides = {};
     if (element.type === "freedraw" || isLinearElement(element)) {
         if (element.points.length === 2) {
             // only check the last point because starting point is always (0,0)
@@ -127,11 +140,9 @@ export const getTransformHandles = (element, zoom, elementsMap, pointerType = "m
             }
         }
     }
-    else if (isTextElement(element)) {
-        omitSides = OMIT_SIDES_FOR_TEXT_ELEMENT;
-    }
     else if (isFrameLikeElement(element)) {
         omitSides = {
+            ...omitSides,
             rotation: true,
         };
     }

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

@@ -1,6 +1,6 @@
-import { ElementOrToolType } from "../types";
-import { MarkNonNullable } from "../utility-types";
-import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawEmbeddableElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, ExcalidrawFrameElement, RoundnessType, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeElement, ExcalidrawIframeLikeElement, ExcalidrawMagicFrameElement } from "./types";
+import type { ElementOrToolType } from "../types";
+import type { MarkNonNullable } from "../utility-types";
+import type { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawEmbeddableElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, ExcalidrawFrameElement, RoundnessType, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeElement, ExcalidrawIframeLikeElement, ExcalidrawMagicFrameElement, ExcalidrawArrowElement } from "./types";
 export declare const isInitializedImageElement: (element: ExcalidrawElement | null) => element is InitializedExcalidrawImageElement;
 export declare const isImageElement: (element: ExcalidrawElement | null) => element is ExcalidrawImageElement;
 export declare const isEmbeddableElement: (element: ExcalidrawElement | null | undefined) => element is ExcalidrawEmbeddableElement;
@@ -13,11 +13,11 @@ export declare const isFrameLikeElement: (element: ExcalidrawElement | null) =>
 export declare const isFreeDrawElement: (element?: ExcalidrawElement | null) => element is ExcalidrawFreeDrawElement;
 export declare const isFreeDrawElementType: (elementType: ExcalidrawElementType) => boolean;
 export declare const isLinearElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
-export declare const isArrowElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
+export declare const isArrowElement: (element?: ExcalidrawElement | null) => element is ExcalidrawArrowElement;
 export declare const isLinearElementType: (elementType: ElementOrToolType) => boolean;
 export declare const isBindingElement: (element?: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawLinearElement;
 export declare const isBindingElementType: (elementType: ElementOrToolType) => boolean;
-export declare const isBindableElement: (element: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawBindableElement;
+export declare const isBindableElement: (element: ExcalidrawElement | null | undefined, includeLocked?: boolean) => element is ExcalidrawBindableElement;
 export declare const isTextBindableContainer: (element: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawTextContainer;
 export declare const isExcalidrawElement: (element: any) => element is ExcalidrawElement;
 export declare const hasBoundTextElement: (element: ExcalidrawElement | null) => element is MarkNonNullable<ExcalidrawBindableElement, "boundElements">;

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

@@ -1,7 +1,7 @@
-import { Point } from "../types";
-import { FONT_FAMILY, ROUNDNESS, TEXT_ALIGN, THEME, VERTICAL_ALIGN } from "../constants";
-import { MakeBrand, MarkNonNullable, ValueOf } from "../utility-types";
-import { MagicCacheData } from "../data/magic";
+import type { Point } from "../types";
+import type { FONT_FAMILY, ROUNDNESS, TEXT_ALIGN, THEME, VERTICAL_ALIGN } from "../constants";
+import type { MakeBrand, MarkNonNullable, ValueOf } from "../utility-types";
+import type { MagicCacheData } from "../data/magic";
 export type ChartType = "bar" | "line";
 export type FillStyle = "hachure" | "cross-hatch" | "solid" | "zigzag";
 export type FontFamilyKeys = keyof typeof FONT_FAMILY;
@@ -18,6 +18,13 @@ export type StrokeStyle = "solid" | "dashed" | "dotted";
 export type TextAlign = typeof TEXT_ALIGN[keyof typeof TEXT_ALIGN];
 type VerticalAlignKeys = keyof typeof VERTICAL_ALIGN;
 export type VerticalAlign = typeof VERTICAL_ALIGN[VerticalAlignKeys];
+export type FractionalIndex = string & {
+    _brand: "franctionalIndex";
+};
+export type BoundElement = Readonly<{
+    id: ExcalidrawLinearElement["id"];
+    type: "arrow" | "text";
+}>;
 type _ExcalidrawElementBase = Readonly<{
     id: string;
     x: number;
@@ -46,16 +53,18 @@ type _ExcalidrawElementBase = Readonly<{
         Used for deterministic reconciliation of updates during collaboration,
         in case the versions (see above) are identical. */
     versionNonce: number;
+    /** String in a fractional form defined by https://github.com/rocicorp/fractional-indexing.
+        Used for ordering in multiplayer scenarios, such as during reconciliation or undo / redo.
+        Always kept in sync with the array order by `syncMovedIndices` and `syncInvalidIndices`.
+        Could be null, i.e. for new elements which were not yet assigned to the scene. */
+    index: FractionalIndex | null;
     isDeleted: boolean;
     /** List of groups the element belongs to.
         Ordered from deepest to shallowest. */
     groupIds: readonly GroupId[];
     frameId: string | null;
     /** other elements that are bound to this element */
-    boundElements: readonly Readonly<{
-        id: ExcalidrawLinearElement["id"];
-        type: "arrow" | "text";
-    }>[] | null;
+    boundElements: readonly BoundElement[] | null;
     /** epoch (ms) timestamp of last element update */
     updated: number;
     link: string | null;
@@ -90,6 +99,9 @@ export type IframeData = ({
         h: number;
     };
     error?: Error;
+    sandbox?: {
+        allowSameOrigin?: boolean;
+    };
 } & ({
     type: "video" | "generic";
     link: string;
@@ -125,6 +137,10 @@ export type ExcalidrawGenericElement = ExcalidrawSelectionElement | ExcalidrawRe
  * between peers and contain no state local to the peer.
  */
 export type ExcalidrawElement = ExcalidrawGenericElement | ExcalidrawTextElement | ExcalidrawLinearElement | ExcalidrawFreeDrawElement | ExcalidrawImageElement | ExcalidrawFrameElement | ExcalidrawMagicFrameElement | ExcalidrawIframeElement | ExcalidrawEmbeddableElement;
+export type Ordered<TElement extends ExcalidrawElement> = TElement & {
+    index: FractionalIndex;
+};
+export type OrderedExcalidrawElement = Ordered<ExcalidrawElement>;
 export type NonDeleted<TElement extends ExcalidrawElement> = TElement & {
     isDeleted: boolean;
 };
@@ -138,6 +154,13 @@ export type ExcalidrawTextElement = _ExcalidrawElementBase & Readonly<{
     verticalAlign: VerticalAlign;
     containerId: ExcalidrawGenericElement["id"] | null;
     originalText: string;
+    /**
+     * If `true` the width will fit the text. If `false`, the text will
+     * wrap to fit the width.
+     *
+     * @default true
+     */
+    autoResize: boolean;
     /**
      * Unitless line height (aligned to W3C). To get line height in px, multiply
      *  with font size (using `getLineHeightInPx` helper).
@@ -195,11 +218,11 @@ export type NonDeletedElementsMap = Map<ExcalidrawElement["id"], NonDeletedExcal
  * Map of all excalidraw Scene elements, including deleted.
  * Not a subset. Use this type when you need access to current Scene elements.
  */
-export type SceneElementsMap = Map<ExcalidrawElement["id"], ExcalidrawElement> & MakeBrand<"SceneElementsMap">;
+export type SceneElementsMap = Map<ExcalidrawElement["id"], Ordered<ExcalidrawElement>> & MakeBrand<"SceneElementsMap">;
 /**
  * Map of all non-deleted Scene elements.
  * Not a subset. Use this type when you need access to current Scene elements.
  */
-export type NonDeletedSceneElementsMap = Map<ExcalidrawElement["id"], NonDeletedExcalidrawElement> & MakeBrand<"NonDeletedSceneElementsMap">;
+export type NonDeletedSceneElementsMap = Map<ExcalidrawElement["id"], Ordered<NonDeletedExcalidrawElement>> & MakeBrand<"NonDeletedSceneElementsMap">;
 export type ElementsMapOrArray = readonly ExcalidrawElement[] | Readonly<ElementsMap>;
 export {};

package/dist/excalidraw/emitter.d.ts

@@ -1,4 +1,4 @@
-import { UnsubscribeCallback } from "./types";
+import type { UnsubscribeCallback } from "./types";
 type Subscriber<T extends any[]> = (...payload: T) => void;
 export declare class Emitter<T extends any[] = []> {
     subscribers: Subscriber<T>[];

package/dist/excalidraw/errors.d.ts

@@ -10,4 +10,7 @@ export declare class ImageSceneDataError extends Error {
     code: ImageSceneDataErrorCode;
     constructor(message?: string, code?: ImageSceneDataErrorCode);
 }
+export declare class InvalidFractionalIndexError extends Error {
+    code: "ELEMENT_HAS_INVALID_INDEX";
+}
 export {};

package/dist/excalidraw/errors.js

@@ -18,3 +18,6 @@ export class ImageSceneDataError extends Error {
         this.code = code;
     }
 }
+export class InvalidFractionalIndexError extends Error {
+    code = "ELEMENT_HAS_INVALID_INDEX";
+}

package/dist/excalidraw/fonts/ExcalidrawFont.d.ts

@@ -0,0 +1,17 @@
+export interface Font {
+    url: URL;
+    fontFace: FontFace;
+    getContent(): Promise<string>;
+}
+export declare const UNPKG_PROD_URL: string;
+export declare class ExcalidrawFont implements Font {
+    readonly url: URL;
+    readonly fontFace: FontFace;
+    constructor(family: string, uri: string, descriptors?: FontFaceDescriptors);
+    /**
+     * Fetches woff2 content based on the registered url (browser).
+     *
+     * Use dataurl outside the browser environment.
+     */
+    getContent(): Promise<string>;
+}

package/dist/excalidraw/fonts/ExcalidrawFont.js

@@ -0,0 +1,50 @@
+import { stringToBase64, toByteString } from "../data/encode";
+export const UNPKG_PROD_URL = `https://unpkg.com/${import.meta.env.VITE_PKG_NAME}@${import.meta.env.PKG_VERSION}/dist/prod/`;
+export class ExcalidrawFont {
+    url;
+    fontFace;
+    constructor(family, uri, descriptors) {
+        // absolute assets paths, which are found in tests and excalidraw-app build, won't work with base url, so we are stripping initial slash away
+        const assetUrl = uri.replace(/^\/+/, "");
+        let baseUrl = undefined;
+        // fallback to unpkg to form a valid URL in case of a passed relative assetUrl
+        let baseUrlBuilder = window.EXCALIDRAW_ASSET_PATH || UNPKG_PROD_URL;
+        // in case user passed a root-relative url (~absolute path),
+        // like "/" or "/some/path", or relative (starts with "./"),
+        // prepend it with `location.origin`
+        if (/^\.?\//.test(baseUrlBuilder)) {
+            baseUrlBuilder = new URL(baseUrlBuilder.replace(/^\.?\/+/, ""), window?.location?.origin).toString();
+        }
+        // ensure there is a trailing slash, otherwise url won't be correctly concatenated
+        baseUrl = `${baseUrlBuilder.replace(/\/+$/, "")}/`;
+        this.url = new URL(assetUrl, baseUrl);
+        this.fontFace = new FontFace(family, `url(${this.url})`, {
+            display: "swap",
+            style: "normal",
+            weight: "400",
+            ...descriptors,
+        });
+    }
+    /**
+     * Fetches woff2 content based on the registered url (browser).
+     *
+     * Use dataurl outside the browser environment.
+     */
+    async getContent() {
+        if (this.url.protocol === "data:") {
+            // it's dataurl, the font is inlined as base64, no need to fetch
+            return this.url.toString();
+        }
+        const response = await fetch(this.url, {
+            headers: {
+                Accept: "font/woff2",
+            },
+        });
+        if (!response.ok) {
+            console.error(`Couldn't fetch font-family "${this.fontFace.family}" from url "${this.url}"`, response);
+        }
+        const mimeType = await response.headers.get("Content-Type");
+        const buffer = await response.arrayBuffer();
+        return `data:${mimeType};base64,${await stringToBase64(await toByteString(buffer), true)}`;
+    }
+}