@excalidraw/excalidraw 0.17.1-7500-ac247a0 → 0.17.1-b7babe5

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

@@ -1,7 +1,9 @@
 import type { RoughCanvas } from "roughjs/bin/canvas";
 import { Drawable } from "roughjs/bin/core";
-import { ExcalidrawTextElement, NonDeletedExcalidrawElement } from "../element/types";
-import { AppClassProperties, AppState, InteractiveCanvasAppState, StaticCanvasAppState } from "../types";
+import { ExcalidrawTextElement, NonDeletedElementsMap, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "../element/types";
+import { AppClassProperties, AppState, EmbedsValidationStatus, ElementsPendingErasure, InteractiveCanvasAppState, StaticCanvasAppState } from "../types";
+import { MakeBrand } from "../utility-types";
+export type RenderableElementsMap = NonDeletedElementsMap & MakeBrand<"RenderableElementsMap">;
 export type StaticCanvasRenderConfig = {
     canvasBackgroundColor: AppState["viewBackgroundColor"];
     imageCache: AppClassProperties["imageCache"];
@@ -9,6 +11,8 @@ export type StaticCanvasRenderConfig = {
     /** when exporting the behavior is slightly different (e.g. we can't use
      CSS filters), and we disable render optimizations for best output */
     isExporting: boolean;
+    embedsValidationStatus: EmbedsValidationStatus;
+    elementsPendingErasure: ElementsPendingErasure;
 };
 export type SVGRenderConfig = {
     offsetX: number;
@@ -18,6 +22,7 @@ export type SVGRenderConfig = {
     renderEmbeddables: boolean;
     frameRendering: AppState["frameRendering"];
     canvasBackgroundColor: AppState["viewBackgroundColor"];
+    embedsValidationStatus: EmbedsValidationStatus;
 };
 export type InteractiveCanvasRenderConfig = {
     remoteSelectedElementIds: {
@@ -43,13 +48,14 @@ export type InteractiveCanvasRenderConfig = {
 };
 export type RenderInteractiveSceneCallback = {
     atLeastOneVisibleElement: boolean;
-    elements: readonly NonDeletedExcalidrawElement[];
+    elementsMap: RenderableElementsMap;
     scrollBars?: ScrollBars;
 };
 export type StaticSceneRenderConfig = {
     canvas: HTMLCanvasElement;
     rc: RoughCanvas;
-    elements: readonly NonDeletedExcalidrawElement[];
+    elementsMap: RenderableElementsMap;
+    allElementsMap: NonDeletedSceneElementsMap;
     visibleElements: readonly NonDeletedExcalidrawElement[];
     scale: number;
     appState: StaticCanvasAppState;
@@ -57,7 +63,7 @@ export type StaticSceneRenderConfig = {
 };
 export type InteractiveSceneRenderConfig = {
     canvas: HTMLCanvasElement | null;
-    elements: readonly NonDeletedExcalidrawElement[];
+    elementsMap: RenderableElementsMap;
     visibleElements: readonly NonDeletedExcalidrawElement[];
     selectedElements: readonly NonDeletedExcalidrawElement[];
     scale: number;

package/dist/excalidraw/snapping.d.ts

@@ -1,6 +1,6 @@
 import { Bounds } from "./element/bounds";
 import { MaybeTransformHandleType } from "./element/transformHandles";
-import { ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
+import { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
 import { AppState, KeyboardModifiersObject, Point } from "./types";
 export declare const getSnapDistance: (zoomValue: number) => number;
 type Vector2D = {
@@ -66,17 +66,17 @@ export declare const isSnappingEnabled: ({ event, appState, selectedElements, }:
     selectedElements: NonDeletedExcalidrawElement[];
 }) => boolean;
 export declare const areRoughlyEqual: (a: number, b: number, precision?: number) => boolean;
-export declare const getElementsCorners: (elements: ExcalidrawElement[], { omitCenter, boundingBoxCorners, dragOffset, }?: {
+export declare const getElementsCorners: (elements: ExcalidrawElement[], elementsMap: ElementsMap, { omitCenter, boundingBoxCorners, dragOffset, }?: {
     omitCenter?: boolean | undefined;
     boundingBoxCorners?: boolean | undefined;
     dragOffset?: Vector2D | undefined;
 }) => Point[];
-export declare const getVisibleGaps: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState) => {
+export declare const getVisibleGaps: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => {
     horizontalGaps: Gap[];
     verticalGaps: Gap[];
 };
-export declare const getReferenceSnapPoints: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState) => (readonly [number, number])[];
-export declare const snapDraggedElements: (selectedElements: ExcalidrawElement[], dragOffset: Vector2D, appState: AppState, event: KeyboardModifiersObject) => {
+export declare const getReferenceSnapPoints: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => (readonly [number, number])[];
+export declare const snapDraggedElements: (elements: ExcalidrawElement[], dragOffset: Vector2D, appState: AppState, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
     snapOffset: {
         x: number;
         y: number;
@@ -90,14 +90,14 @@ export declare const snapResizingElements: (selectedElements: ExcalidrawElement[
     };
     snapLines: PointSnapLine[];
 };
-export declare const snapNewElement: (draggingElement: ExcalidrawElement, appState: AppState, event: KeyboardModifiersObject, origin: Vector2D, dragOffset: Vector2D) => {
+export declare const snapNewElement: (draggingElement: ExcalidrawElement, appState: AppState, event: KeyboardModifiersObject, origin: Vector2D, dragOffset: Vector2D, elementsMap: ElementsMap) => {
     snapOffset: {
         x: number;
         y: number;
     };
     snapLines: PointSnapLine[];
 };
-export declare const getSnapLinesAtPointer: (elements: readonly ExcalidrawElement[], appState: AppState, pointer: Vector2D, event: KeyboardModifiersObject) => {
+export declare const getSnapLinesAtPointer: (elements: readonly ExcalidrawElement[], appState: AppState, pointer: Vector2D, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
     originOffset: {
         x: number;
         y: number;

package/dist/excalidraw/snapping.js

@@ -4,7 +4,7 @@ import { isBoundToContainer, isFrameLikeElement } from "./element/typeChecks";
 import { getMaximumGroups } from "./groups";
 import { KEYS } from "./keys";
 import { rangeIntersection, rangesOverlap, rotatePoint } from "./math";
-import { getVisibleAndNonSelectedElements } from "./scene/selection";
+import { getSelectedElements, getVisibleAndNonSelectedElements, } from "./scene/selection";
 const SNAP_DISTANCE = 8;
 // do not comput more gaps per axis than this limit
 // TODO increase or remove once we optimize
@@ -51,14 +51,14 @@ export const isSnappingEnabled = ({ event, appState, selectedElements, }) => {
 export const areRoughlyEqual = (a, b, precision = 0.01) => {
     return Math.abs(a - b) <= precision;
 };
-export const getElementsCorners = (elements, { omitCenter, boundingBoxCorners, dragOffset, } = {
+export const getElementsCorners = (elements, elementsMap, { omitCenter, boundingBoxCorners, dragOffset, } = {
     omitCenter: false,
     boundingBoxCorners: false,
 }) => {
     let result = [];
     if (elements.length === 1) {
         const element = elements[0];
-        let [x1, y1, x2, y2, cx, cy] = getElementAbsoluteCoords(element);
+        let [x1, y1, x2, y2, cx, cy] = getElementAbsoluteCoords(element, elementsMap);
         if (dragOffset) {
             x1 += dragOffset.x;
             x2 += dragOffset.x;
@@ -106,15 +106,15 @@ export const getElementsCorners = (elements, { omitCenter, boundingBoxCorners, d
     }
     return result.map((point) => [round(point[0]), round(point[1])]);
 };
-const getReferenceElements = (elements, selectedElements, appState) => {
+const getReferenceElements = (elements, selectedElements, appState, elementsMap) => {
     const selectedFrames = selectedElements
         .filter((element) => isFrameLikeElement(element))
         .map((frame) => frame.id);
-    return getVisibleAndNonSelectedElements(elements, selectedElements, appState).filter((element) => !(element.frameId && selectedFrames.includes(element.frameId)));
+    return getVisibleAndNonSelectedElements(elements, selectedElements, appState, elementsMap).filter((element) => !(element.frameId && selectedFrames.includes(element.frameId)));
 };
-export const getVisibleGaps = (elements, selectedElements, appState) => {
-    const referenceElements = getReferenceElements(elements, selectedElements, appState);
-    const referenceBounds = getMaximumGroups(referenceElements)
+export const getVisibleGaps = (elements, selectedElements, appState, elementsMap) => {
+    const referenceElements = getReferenceElements(elements, selectedElements, appState, elementsMap);
+    const referenceBounds = getMaximumGroups(referenceElements, elementsMap)
         .filter((elementsGroup) => !(elementsGroup.length === 1 && isBoundToContainer(elementsGroup[0])))
         .map((group) => getCommonBounds(group).map((bound) => round(bound)));
     const horizontallySorted = referenceBounds.sort((a, b) => a[0] - b[0]);
@@ -317,11 +317,11 @@ const getGapSnaps = (selectedElements, dragOffset, appState, event, nearestSnaps
         }
     }
 };
-export const getReferenceSnapPoints = (elements, selectedElements, appState) => {
-    const referenceElements = getReferenceElements(elements, selectedElements, appState);
-    return getMaximumGroups(referenceElements)
+export const getReferenceSnapPoints = (elements, selectedElements, appState, elementsMap) => {
+    const referenceElements = getReferenceElements(elements, selectedElements, appState, elementsMap);
+    return getMaximumGroups(referenceElements, elementsMap)
         .filter((elementsGroup) => !(elementsGroup.length === 1 && isBoundToContainer(elementsGroup[0])))
-        .flatMap((elementGroup) => getElementsCorners(elementGroup));
+        .flatMap((elementGroup) => getElementsCorners(elementGroup, elementsMap));
 };
 const getPointSnaps = (selectedElements, selectionSnapPoints, appState, event, nearestSnapsX, nearestSnapsY, minOffset) => {
     if (!isSnappingEnabled({ appState, event, selectedElements }) ||
@@ -360,7 +360,8 @@ const getPointSnaps = (selectedElements, selectionSnapPoints, appState, event, n
         }
     }
 };
-export const snapDraggedElements = (selectedElements, dragOffset, appState, event) => {
+export const snapDraggedElements = (elements, dragOffset, appState, event, elementsMap) => {
+    const selectedElements = getSelectedElements(elements, appState);
     if (!isSnappingEnabled({ appState, event, selectedElements }) ||
         selectedElements.length === 0) {
         return {
@@ -380,7 +381,7 @@ export const snapDraggedElements = (selectedElements, dragOffset, appState, even
         x: snapDistance,
         y: snapDistance,
     };
-    const selectionPoints = getElementsCorners(selectedElements, {
+    const selectionPoints = getElementsCorners(selectedElements, elementsMap, {
         dragOffset,
     });
     // get the nearest horizontal and vertical point and gap snaps
@@ -406,7 +407,7 @@ export const snapDraggedElements = (selectedElements, dragOffset, appState, even
         x: round(dragOffset.x + snapOffset.x),
         y: round(dragOffset.y + snapOffset.y),
     };
-    getPointSnaps(selectedElements, getElementsCorners(selectedElements, {
+    getPointSnaps(selectedElements, getElementsCorners(selectedElements, elementsMap, {
         dragOffset: newDragOffset,
     }), appState, event, nearestSnapsX, nearestSnapsY, minOffset);
     getGapSnaps(selectedElements, newDragOffset, appState, event, nearestSnapsX, nearestSnapsY, minOffset);
@@ -735,7 +736,7 @@ selectedOriginalElements, appState, event, dragOffset, transformHandle) => {
         snapLines: pointSnapLines,
     };
 };
-export const snapNewElement = (draggingElement, appState, event, origin, dragOffset) => {
+export const snapNewElement = (draggingElement, appState, event, origin, dragOffset, elementsMap) => {
     if (!isSnappingEnabled({ event, selectedElements: [draggingElement], appState })) {
         return {
             snapOffset: { x: 0, y: 0 },
@@ -761,7 +762,7 @@ export const snapNewElement = (draggingElement, appState, event, origin, dragOff
     minOffset.y = 0;
     nearestSnapsX.length = 0;
     nearestSnapsY.length = 0;
-    const corners = getElementsCorners([draggingElement], {
+    const corners = getElementsCorners([draggingElement], elementsMap, {
         boundingBoxCorners: true,
         omitCenter: true,
     });
@@ -772,14 +773,14 @@ export const snapNewElement = (draggingElement, appState, event, origin, dragOff
         snapLines: pointSnapLines,
     };
 };
-export const getSnapLinesAtPointer = (elements, appState, pointer, event) => {
+export const getSnapLinesAtPointer = (elements, appState, pointer, event, elementsMap) => {
     if (!isSnappingEnabled({ event, selectedElements: [], appState })) {
         return {
             originOffset: { x: 0, y: 0 },
             snapLines: [],
         };
     }
-    const referenceElements = getVisibleAndNonSelectedElements(elements, [], appState);
+    const referenceElements = getVisibleAndNonSelectedElements(elements, [], appState, elementsMap);
     const snapDistance = getSnapDistance(appState.zoom.value);
     const minOffset = {
         x: snapDistance,
@@ -788,7 +789,7 @@ export const getSnapLinesAtPointer = (elements, appState, pointer, event) => {
     const horizontalSnapLines = [];
     const verticalSnapLines = [];
     for (const referenceElement of referenceElements) {
-        const corners = getElementsCorners([referenceElement]);
+        const corners = getElementsCorners([referenceElement], elementsMap);
         for (const corner of corners) {
             const offsetX = corner[0] - pointer.x;
             if (Math.abs(offsetX) <= Math.abs(minOffset.x)) {

package/dist/excalidraw/types.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, ChartType, FontFamilyValues, FileId, ExcalidrawImageElement, Theme, StrokeRoundness, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawFrameLikeElement, ExcalidrawElementType } from "./element/types";
+import { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, ChartType, FontFamilyValues, FileId, ExcalidrawImageElement, Theme, StrokeRoundness, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeLikeElement } from "./element/types";
 import { Action } from "./actions/types";
 import { Point as RoughPoint } from "roughjs/bin/geometry";
 import { LinearElementEditor } from "./element/linearElementEditor";
@@ -10,14 +10,14 @@ import type { throttleRAF } from "./utils";
 import { Spreadsheet } from "./charts";
 import { Language } from "./i18n";
 import { ClipboardData } from "./clipboard";
-import { isOverScrollBars } from "./scene";
+import { isOverScrollBars } from "./scene/scrollbars";
 import { MaybeTransformHandleType } from "./element/transformHandles";
 import Library from "./data/library";
 import type { FileSystemHandle } from "./data/filesystem";
 import type { IMAGE_MIME_TYPES, MIME_TYPES } from "./constants";
 import { ContextMenuItems } from "./components/ContextMenu";
 import { SnapLine } from "./snapping";
-import { Merge, ValueOf } from "./utility-types";
+import { Merge, MaybePromise, ValueOf } from "./utility-types";
 export type Point = Readonly<RoughPoint>;
 export type SocketId = string & {
     _brand: "SocketId";
@@ -181,7 +181,7 @@ export interface AppState {
     scrollY: number;
     cursorButton: "up" | "down";
     scrolledOutside: boolean;
-    name: string;
+    name: string | null;
     isResizing: boolean;
     isRotating: boolean;
     zoom: Zoom;
@@ -304,9 +304,9 @@ export type LibraryItem = {
 };
 export type LibraryItems = readonly LibraryItem[];
 export type LibraryItems_anyVersion = LibraryItems | LibraryItems_v1;
-export type LibraryItemsSource = ((currentLibraryItems: LibraryItems) => Blob | LibraryItems_anyVersion | Promise<LibraryItems_anyVersion | Blob>) | Blob | LibraryItems_anyVersion | Promise<LibraryItems_anyVersion | Blob>;
+export type LibraryItemsSource = ((currentLibraryItems: LibraryItems) => MaybePromise<LibraryItems_anyVersion | Blob>) | MaybePromise<LibraryItems_anyVersion | Blob>;
 export type ExcalidrawInitialDataState = Merge<ImportedDataState, {
-    libraryItems?: Required<ImportedDataState>["libraryItems"] | Promise<Required<ImportedDataState>["libraryItems"]>;
+    libraryItems?: MaybePromise<Required<ImportedDataState>["libraryItems"]>;
 }>;
 export type OnUserFollowedPayload = {
     userToFollow: UserToFollow;
@@ -314,7 +314,7 @@ export type OnUserFollowedPayload = {
 };
 export interface ExcalidrawProps {
     onChange?: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles) => void;
-    initialData?: ExcalidrawInitialDataState | null | Promise<ExcalidrawInitialDataState | null>;
+    initialData?: MaybePromise<ExcalidrawInitialDataState | null>;
     excalidrawAPI?: (api: ExcalidrawImperativeAPI) => void;
     isCollaborating?: boolean;
     onPointerUpdate?: (payload: {
@@ -347,6 +347,7 @@ export interface ExcalidrawProps {
         nativeEvent: MouseEvent | React.PointerEvent<HTMLCanvasElement>;
     }>) => void;
     onPointerDown?: (activeTool: AppState["activeTool"], pointerDownState: PointerDownState) => void;
+    onPointerUp?: (activeTool: AppState["activeTool"], pointerDownState: PointerDownState) => void;
     onScrollChange?: (scrollX: number, scrollY: number, zoom: Zoom) => void;
     onUserFollow?: (payload: OnUserFollowedPayload) => void;
     children?: React.ReactNode;
@@ -367,7 +368,7 @@ export declare enum UserIdleState {
 }
 export type ExportOpts = {
     saveFileToDisk?: boolean;
-    onExportToBackend?: (exportedElements: readonly NonDeletedExcalidrawElement[], appState: UIAppState, files: BinaryFiles, canvas: HTMLCanvasElement) => void;
+    onExportToBackend?: (exportedElements: readonly NonDeletedExcalidrawElement[], appState: UIAppState, files: BinaryFiles) => void;
     renderCustomUI?: (exportedElements: readonly NonDeletedExcalidrawElement[], appState: UIAppState, files: BinaryFiles, canvas: HTMLCanvasElement) => JSX.Element;
 };
 export type CanvasActions = Partial<{
@@ -429,6 +430,7 @@ export type AppClassProperties = {
     setOpenDialog: App["setOpenDialog"];
     insertEmbeddableElement: App["insertEmbeddableElement"];
     onMagicframeToolSelect: App["onMagicframeToolSelect"];
+    getName: App["getName"];
 };
 export type PointerDownState = Readonly<{
     origin: Readonly<{
@@ -482,15 +484,9 @@ export type PointerDownState = Readonly<{
     boxSelection: {
         hasOccurred: boolean;
     };
-    elementIdsToErase: {
-        [key: ExcalidrawElement["id"]]: {
-            opacity: ExcalidrawElement["opacity"];
-            erase: boolean;
-        };
-    };
 }>;
 export type UnsubscribeCallback = () => void;
-export type ExcalidrawImperativeAPI = {
+export interface ExcalidrawImperativeAPI {
     updateScene: InstanceType<typeof App>["updateScene"];
     updateLibrary: InstanceType<typeof Library>["updateLibrary"];
     resetScene: InstanceType<typeof App>["resetScene"];
@@ -498,10 +494,11 @@ export type ExcalidrawImperativeAPI = {
     history: {
         clear: InstanceType<typeof App>["resetHistory"];
     };
-    scrollToContent: InstanceType<typeof App>["scrollToContent"];
     getSceneElements: InstanceType<typeof App>["getSceneElements"];
     getAppState: () => InstanceType<typeof App>["state"];
     getFiles: () => InstanceType<typeof App>["files"];
+    getName: InstanceType<typeof App>["getName"];
+    scrollToContent: InstanceType<typeof App>["scrollToContent"];
     registerAction: (action: Action) => void;
     refresh: InstanceType<typeof App>["refresh"];
     setToast: InstanceType<typeof App>["setToast"];
@@ -522,7 +519,7 @@ export type ExcalidrawImperativeAPI = {
     onPointerUp: (callback: (activeTool: AppState["activeTool"], pointerDownState: PointerDownState, event: PointerEvent) => void) => UnsubscribeCallback;
     onScrollChange: (callback: (scrollX: number, scrollY: number, zoom: Zoom) => void) => UnsubscribeCallback;
     onUserFollow: (callback: (payload: OnUserFollowedPayload) => void) => UnsubscribeCallback;
-};
+}
 export type Device = Readonly<{
     viewport: {
         isMobile: boolean;
@@ -556,4 +553,6 @@ export type KeyboardModifiersObject = {
 };
 export type Primitive = number | string | boolean | bigint | symbol | null | undefined;
 export type JSONValue = string | number | boolean | null | object;
+export type EmbedsValidationStatus = Map<ExcalidrawIframeLikeElement["id"], boolean>;
+export type ElementsPendingErasure = Set<ExcalidrawElement["id"]>;
 export {};

package/dist/excalidraw/utility-types.d.ts

@@ -23,3 +23,10 @@ export type ExtractSetType<T extends Set<any>> = T extends Set<infer U> ? U : ne
 export type SameType<T, U> = T extends U ? (U extends T ? true : false) : false;
 export type Assert<T extends true> = T;
 export type NestedKeyOf<T, K = keyof T> = K extends keyof T & (string | number) ? `${K}` | (T[K] extends object ? `${K}.${NestedKeyOf<T[K]>}` : never) : never;
+export type SetLike<T> = Set<T> | T[];
+export type ReadonlySetLike<T> = ReadonlySet<T> | readonly T[];
+export type MakeBrand<T extends string> = {
+    [K in `~brand~${T}`]: T;
+};
+/** Maybe just promise or already fulfilled one! */
+export type MaybePromise<T> = T | Promise<T>;

package/dist/excalidraw/utils.d.ts

@@ -1,6 +1,7 @@
 import { EVENT } from "./constants";
 import { FontFamilyValues, FontString } from "./element/types";
 import { ActiveTool, AppState, ToolType, UnsubscribeCallback, Zoom } from "./types";
+import { MaybePromise } from "./utility-types";
 export declare const setDateTimeForTests: (dateTime: string) => void;
 export declare const getDateTime: () => string;
 export declare const capitalizeString: (str: string) => string;
@@ -137,23 +138,10 @@ export declare const findIndex: <T>(array: readonly T[], cb: (element: T, index:
 export declare const findLastIndex: <T>(array: readonly T[], cb: (element: T, index: number, array: readonly T[]) => boolean, fromIndex?: number) => number;
 export declare const isTransparent: (color: string) => boolean;
 export type ResolvablePromise<T> = Promise<T> & {
-    resolve: [T] extends [undefined] ? (value?: T) => void : (value: T) => void;
+    resolve: [T] extends [undefined] ? (value?: MaybePromise<Awaited<T>>) => void : (value: MaybePromise<Awaited<T>>) => void;
     reject: (error: Error) => void;
 };
 export declare const resolvablePromise: <T>() => ResolvablePromise<T>;
-/**
- * @param func handler taking at most single parameter (event).
- */
-export declare const withBatchedUpdates: <TFunction extends ((event: any) => void) | (() => void)>(func: Parameters<TFunction>["length"] extends 0 | 1 ? TFunction : never) => TFunction;
-/**
- * barches React state updates and throttles the calls to a single call per
- * animation frame
- */
-export declare const withBatchedUpdatesThrottled: <TFunction extends ((event: any) => void) | (() => void)>(func: Parameters<TFunction>["length"] extends 0 | 1 ? TFunction : never) => {
-    (...args: Parameters<TFunction>): void;
-    flush(): void;
-    cancel(): void;
-};
 export declare const nFormatter: (num: number, digits: number) => string;
 export declare const getVersion: () => string;
 export declare const supportsEmoji: () => boolean;
@@ -168,7 +156,7 @@ export declare const getUpdatedTimestamp: () => number;
  */
 export declare const arrayToMap: <T extends string | {
     id: string;
-}>(items: readonly T[]) => Map<string, T>;
+}>(items: Map<string, T> | readonly T[]) => Map<string, T>;
 export declare const arrayToMapWithIndex: <T extends {
     id: string;
 }>(elements: readonly T[]) => Map<string, [element: T, index: number]>;
@@ -205,7 +193,6 @@ export declare const assertNever: (value: never, message: string | null, softAss
 export declare const memoize: <T extends Record<string, any>, R extends unknown>(func: (opts: T) => R) => ((opts: T) => R) & {
     clear: () => void;
 };
-export declare const isRenderThrottlingEnabled: () => boolean;
 /** Checks if value is inside given collection. Useful for type-safety. */
 export declare const isMemberOf: <T extends string>(collection: Set<T> | Record<T, any> | Map<T, any> | readonly T[], value: string) => value is T;
 export declare const cloneJSON: <T>(obj: T) => T;
@@ -217,3 +204,21 @@ export declare function addEventListener<K extends keyof DocumentEventMap>(targe
 export declare function addEventListener(target: Document, type: string, listener: (this: Document, ev: Event) => any, options?: boolean | AddEventListenerOptions): UnsubscribeCallback;
 export declare function addEventListener<K extends keyof FontFaceSetEventMap>(target: FontFaceSet, type: K, listener: (this: FontFaceSet, ev: FontFaceSetEventMap[K]) => any, options?: boolean | AddEventListenerOptions): UnsubscribeCallback;
 export declare function addEventListener<K extends keyof HTMLElementEventMap>(target: Document | (Window & typeof globalThis) | HTMLElement | undefined | null | false, type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): UnsubscribeCallback;
+export declare function getSvgPathFromStroke(points: number[][], closed?: boolean): string;
+export declare const normalizeEOL: (str: string) => string;
+type HasBrand<T> = {
+    [K in keyof T]: K extends `~brand${infer _}` ? true : never;
+}[keyof T];
+type RemoveAllBrands<T> = HasBrand<T> extends true ? {
+    [K in keyof T as K extends `~brand~${infer _}` ? never : K]: T[K];
+} : never;
+type Unbrand<T> = T extends Map<infer E, infer F> ? Map<E, F> : T extends Set<infer E> ? Set<E> : T extends Array<infer E> ? Array<E> : RemoveAllBrands<T>;
+/**
+ * Makes type into a branded type, ensuring that value is assignable to
+ * the base ubranded type. Optionally you can explicitly supply current value
+ * type to combine both (useful for composite branded types. Make sure you
+ * compose branded types which are not composite themselves.)
+ */
+export declare const toBrandedType: <BrandedType, CurrentType = BrandedType>(value: Unbrand<BrandedType>) => CurrentType & BrandedType;
+export declare const promiseTry: <TValue, TArgs extends unknown[]>(fn: (...args: TArgs) => TValue | PromiseLike<TValue>, ...args: TArgs) => Promise<TValue>;
+export {};

package/dist/excalidraw/utils.js

@@ -1,7 +1,5 @@
 import { COLOR_PALETTE } from "./colors";
 import { DEFAULT_VERSION, FONT_FAMILY, isDarwin, WINDOWS_EMOJI_FALLBACK_FONT, } from "./constants";
-import { unstable_batchedUpdates } from "react-dom";
-import React from "react";
 let mockDateTime = null;
 export const setDateTimeForTests = (dateTime) => {
     mockDateTime = dateTime;
@@ -354,22 +352,6 @@ export const resolvablePromise = () => {
     promise.reject = reject;
     return promise;
 };
-/**
- * @param func handler taking at most single parameter (event).
- */
-export const withBatchedUpdates = (func) => ((event) => {
-    unstable_batchedUpdates(func, event);
-});
-/**
- * barches React state updates and throttles the calls to a single call per
- * animation frame
- */
-export const withBatchedUpdatesThrottled = (func) => {
-    // @ts-ignore
-    return throttleRAF(((event) => {
-        unstable_batchedUpdates(func, event);
-    }));
-};
 //https://stackoverflow.com/a/9462382/8418
 export const nFormatter = (num, digits) => {
     const si = [
@@ -451,6 +433,9 @@ export const getUpdatedTimestamp = () => (isTestEnv() ? 1 : Date.now());
  * or array of ids (strings), into a Map, keyd by `id`.
  */
 export const arrayToMap = (items) => {
+    if (items instanceof Map) {
+        return items;
+    }
     return items.reduce((acc, element) => {
         acc.set(typeof element === "string" ? element : element.id, element);
         return acc;
@@ -568,7 +553,7 @@ export const composeEventHandlers = (originalEventHandler, ourEventHandler, { ch
     return function handleEvent(event) {
         originalEventHandler?.(event);
         if (!checkForDefaultPrevented ||
-            !event.defaultPrevented) {
+            !event?.defaultPrevented) {
             return ourEventHandler?.(event);
         }
     };
@@ -618,32 +603,6 @@ export const memoize = (func) => {
     };
     return ret;
 };
-export const isRenderThrottlingEnabled = (() => {
-    // we don't want to throttle in react < 18 because of #5439 and it was
-    // getting more complex to maintain the fix
-    let IS_REACT_18_AND_UP;
-    try {
-        const version = React.version.split(".");
-        IS_REACT_18_AND_UP = Number(version[0]) > 17;
-    }
-    catch {
-        IS_REACT_18_AND_UP = false;
-    }
-    let hasWarned = false;
-    return () => {
-        if (window.EXCALIDRAW_THROTTLE_RENDER === true) {
-            if (!IS_REACT_18_AND_UP) {
-                if (!hasWarned) {
-                    hasWarned = true;
-                    console.warn("Excalidraw: render throttling is disabled on React versions < 18.");
-                }
-                return false;
-            }
-            return true;
-        }
-        return false;
-    };
-})();
 /** Checks if value is inside given collection. Useful for type-safety. */
 export const isMemberOf = (
 /** Set/Map/Array/Object */
@@ -681,3 +640,42 @@ target, type, listener, options) {
         target?.removeEventListener?.(type, listener, options);
     };
 }
+const average = (a, b) => (a + b) / 2;
+export function getSvgPathFromStroke(points, closed = true) {
+    const len = points.length;
+    if (len < 4) {
+        return ``;
+    }
+    let a = points[0];
+    let b = points[1];
+    const c = points[2];
+    let result = `M${a[0].toFixed(2)},${a[1].toFixed(2)} Q${b[0].toFixed(2)},${b[1].toFixed(2)} ${average(b[0], c[0]).toFixed(2)},${average(b[1], c[1]).toFixed(2)} T`;
+    for (let i = 2, max = len - 1; i < max; i++) {
+        a = points[i];
+        b = points[i + 1];
+        result += `${average(a[0], b[0]).toFixed(2)},${average(a[1], b[1]).toFixed(2)} `;
+    }
+    if (closed) {
+        result += "Z";
+    }
+    return result;
+}
+export const normalizeEOL = (str) => {
+    return str.replace(/\r?\n|\r/g, "\n");
+};
+/**
+ * Makes type into a branded type, ensuring that value is assignable to
+ * the base ubranded type. Optionally you can explicitly supply current value
+ * type to combine both (useful for composite branded types. Make sure you
+ * compose branded types which are not composite themselves.)
+ */
+export const toBrandedType = (value) => {
+    return value;
+};
+// -----------------------------------------------------------------------------
+// Promise.try, adapted from https://github.com/sindresorhus/p-try
+export const promiseTry = async (fn, ...args) => {
+    return new Promise((resolve) => {
+        resolve(fn(...args));
+    });
+};

package/dist/{dev/en-RLIAOBCI.json → prod/en-EY7E2L5O.json}

@@ -138,7 +138,9 @@
     "removeAllElementsFromFrame": "Remove all elements from frame",
     "eyeDropper": "Pick color from canvas",
     "textToDiagram": "Text to diagram",
-    "prompt": "Prompt"
+    "prompt": "Prompt",
+    "followUs": "Follow us",
+    "discordChat": "Discord chat"
   },
   "library": {
     "noItems": "No items added yet...",
@@ -212,9 +214,9 @@
     "fileTooBig": "File is too big. Maximum allowed size is {{maxSize}}.",
     "svgImageInsertError": "Couldn't insert SVG image. The SVG markup looks invalid.",
     "failedToFetchImage": "Failed to fetch image.",
-    "invalidSVGString": "Invalid SVG.",
     "cannotResolveCollabServer": "Couldn't connect to the collab server. Please reload the page and try again.",
     "importLibraryError": "Couldn't load library",
+    "saveLibraryError": "Couldn't save library to storage. Please save your library to a file locally to make sure you don't lose changes.",
     "collabSaveFailed": "Couldn't save to the backend database. If problems persist, you should save your file locally to ensure you don't lose your work.",
     "collabSaveFailed_sizeExceeded": "Couldn't save to the backend database, the canvas seems to be too big. You should save the file locally to ensure you don't lose your work.",
     "imageToolNotSupported": "Images are disabled.",
@@ -246,7 +248,7 @@
     "library": "Library",
     "lock": "Keep selected tool active after drawing",
     "penMode": "Pen mode - prevent touch",
-    "link": "Add/ Update link for a selected shape",
+    "link": "Add / Update link for a selected shape",
     "eraser": "Eraser",
     "frame": "Frame tool",
     "magicframe": "Wireframe to code",
@@ -299,9 +301,12 @@
     "openIssueMessage": "We were very cautious not to include your scene information on the error. If your scene is not private, please consider following up on our <button>bug tracker</button>. Please include information below by copying and pasting into the GitHub issue.",
     "sceneContent": "Scene content:"
   },
+  "shareDialog": {
+    "or": "Or"
+  },
   "roomDialog": {
-    "desc_intro": "You can invite people to your current scene to collaborate with you.",
-    "desc_privacy": "Don't worry, the session uses end-to-end encryption, so whatever you draw will stay private. Not even our server will be able to see what you come up with.",
+    "desc_intro": "Invite people to collaborate on your drawing.",
+    "desc_privacy": "Don't worry, the session is end-to-end encrypted, and fully private. Not even our server can see what you draw.",
     "button_startSession": "Start session",
     "button_stopSession": "Stop session",
     "desc_inProgressIntro": "Live-collaboration session is now in progress.",