@excalidraw/excalidraw 0.11.0 → 0.12.0-08ce7c7

package/types/components/UserList.d.ts

@@ -1,9 +1,10 @@
 import "./UserList.scss";
 import React from "react";
-declare type UserListProps = {
-    children: React.ReactNode;
+import { AppState } from "../types";
+import { ActionManager } from "../actions/manager";
+export declare const UserList: React.FC<{
     className?: string;
     mobile?: boolean;
-};
-export declare const UserList: ({ children, className, mobile }: UserListProps) => JSX.Element;
-export {};
+    collaborators: AppState["collaborators"];
+    actionManager: ActionManager;
+}>;

package/types/components/icons.d.ts

@@ -164,6 +164,16 @@ export declare const TextAlignCenterIcon: React.MemoExoticComponent<({ theme }:
 export declare const TextAlignRightIcon: React.MemoExoticComponent<({ theme }: {
     theme: Theme;
 }) => JSX.Element>;
+export declare const TextAlignTopIcon: React.MemoExoticComponent<({ theme }: {
+    theme: Theme;
+}) => JSX.Element>;
+export declare const TextAlignBottomIcon: React.MemoExoticComponent<({ theme }: {
+    theme: Theme;
+}) => JSX.Element>;
+export declare const TextAlignMiddleIcon: React.MemoExoticComponent<({ theme }: {
+    theme: Theme;
+}) => JSX.Element>;
 export declare const publishIcon: JSX.Element;
 export declare const editIcon: JSX.Element;
+export declare const eraser: JSX.Element;
 export {};

package/types/constants.d.ts

@@ -79,7 +79,9 @@ export declare const MIME_TYPES: {
     readonly excalidrawlib: "application/vnd.excalidrawlib+json";
     readonly json: "application/json";
     readonly svg: "image/svg+xml";
+    readonly "excalidraw.svg": "image/svg+xml";
     readonly png: "image/png";
+    readonly "excalidraw.png": "image/png";
     readonly jpg: "image/jpeg";
     readonly gif: "image/gif";
     readonly binary: "application/octet-stream";
@@ -94,7 +96,6 @@ export declare const IMAGE_RENDER_TIMEOUT = 500;
 export declare const TAP_TWICE_TIMEOUT = 300;
 export declare const TOUCH_CTX_MENU_TIMEOUT = 500;
 export declare const TITLE_TIMEOUT = 10000;
-export declare const TOAST_TIMEOUT = 5000;
 export declare const VERSION_TIMEOUT = 30000;
 export declare const SCROLL_TIMEOUT = 100;
 export declare const ZOOM_STEP = 0.1;
@@ -114,9 +115,12 @@ export declare const URL_HASH_KEYS: {
     readonly addLibrary: "addLibrary";
 };
 export declare const DEFAULT_UI_OPTIONS: AppProps["UIOptions"];
+export declare const MQ_SM_MAX_WIDTH = 640;
 export declare const MQ_MAX_WIDTH_PORTRAIT = 730;
 export declare const MQ_MAX_WIDTH_LANDSCAPE = 1000;
 export declare const MQ_MAX_HEIGHT_LANDSCAPE = 500;
+export declare const MQ_RIGHT_SIDEBAR_MIN_WIDTH = 1229;
+export declare const LIBRARY_SIDEBAR_WIDTH: number;
 export declare const MAX_DECIMALS_FOR_SVG_EXPORT = 2;
 export declare const EXPORT_SCALES: number[];
 export declare const DEFAULT_EXPORT_PADDING = 10;
@@ -130,3 +134,12 @@ export declare const VERSIONS: {
     readonly excalidrawLibrary: 2;
 };
 export declare const BOUND_TEXT_PADDING = 5;
+export declare const VERTICAL_ALIGN: {
+    TOP: string;
+    MIDDLE: string;
+    BOTTOM: string;
+};
+export declare const ELEMENT_READY_TO_ERASE_OPACITY = 20;
+export declare const COOKIES: {
+    readonly AUTH_STATE_COOKIE: "excplus-auth";
+};

package/types/data/blob.d.ts

@@ -1,6 +1,6 @@
 import { ALLOWED_IMAGE_MIME_TYPES, MIME_TYPES } from "../constants";
 import { ExcalidrawElement, FileId } from "../element/types";
-import { AppState, DataURL } from "../types";
+import { AppState, DataURL, LibraryItem } from "../types";
 import { FileSystemHandle } from "./filesystem";
 import { ImportedLibraryData } from "./types";
 export declare const getMimeType: (blob: Blob | string) => string;
@@ -8,10 +8,18 @@ export declare const getFileHandleType: (handle: FileSystemHandle | null) => str
 export declare const isImageFileHandleType: (type: string | null) => type is "svg" | "png";
 export declare const isImageFileHandle: (handle: FileSystemHandle | null) => boolean;
 export declare const isSupportedImageFile: (blob: Blob | null | undefined) => blob is Blob & {
-    type: typeof ALLOWED_IMAGE_MIME_TYPES[number];
+    type: (typeof ALLOWED_IMAGE_MIME_TYPES)[number];
 };
-export declare const loadFromBlob: (blob: Blob, localAppState: AppState | null, localElements: readonly ExcalidrawElement[] | null) => Promise<import("./restore").RestoredDataState>;
-export declare const loadLibraryFromBlob: (blob: Blob) => Promise<ImportedLibraryData>;
+export declare const loadSceneOrLibraryFromBlob: (blob: Blob | File, localAppState: AppState | null, localElements: readonly ExcalidrawElement[] | null, fileHandle?: FileSystemHandle | null) => Promise<{
+    type: "application/vnd.excalidraw+json";
+    data: import("./restore").RestoredDataState;
+} | {
+    type: "application/vnd.excalidrawlib+json";
+    data: ImportedLibraryData;
+}>;
+export declare const loadFromBlob: (blob: Blob, localAppState: AppState | null, localElements: readonly ExcalidrawElement[] | null, fileHandle?: FileSystemHandle | null) => Promise<import("./restore").RestoredDataState>;
+export declare const parseLibraryJSON: (json: string, defaultStatus?: LibraryItem["status"]) => LibraryItem[];
+export declare const loadLibraryFromBlob: (blob: Blob, defaultStatus?: LibraryItem["status"]) => Promise<LibraryItem[]>;
 export declare const canvasToBlob: (canvas: HTMLCanvasElement) => Promise<Blob>;
 /** generates SHA-1 digest from supplied file (if not supported, falls back
     to a 40-char base64 random id) */
@@ -20,9 +28,20 @@ export declare const getDataURL: (file: Blob | File) => Promise<DataURL>;
 export declare const dataURLToFile: (dataURL: DataURL, filename?: string) => File;
 export declare const resizeImageFile: (file: File, opts: {
     /** undefined indicates auto */
-    outputType?: typeof MIME_TYPES["jpg"];
+    outputType?: (typeof MIME_TYPES)["jpg"];
     maxWidthOrHeight: number;
 }) => Promise<File>;
 export declare const SVGStringToFile: (SVGString: string, filename?: string) => File & {
     type: typeof MIME_TYPES.svg;
 };
+export declare const getFileFromEvent: (event: React.DragEvent<HTMLDivElement>) => Promise<{
+    file: File | null;
+    fileHandle: FileSystemHandle | null;
+}>;
+export declare const getFileHandle: (event: React.DragEvent<HTMLDivElement>) => Promise<FileSystemHandle | null>;
+export declare const createFile: (blob: File | Blob | ArrayBuffer, mimeType: ValueOf<typeof MIME_TYPES>, name: string | undefined) => File;
+/** attemps to detect correct mimeType if none is set, or if an image
+ * has an incorrect extension.
+ * Note: doesn't handle missing .excalidraw/.excalidrawlib extension  */
+export declare const normalizeFile: (file: File) => Promise<File>;
+export declare const blobToArrayBuffer: (blob: Blob) => Promise<ArrayBuffer>;

package/types/data/filesystem.d.ts

@@ -1,10 +1,10 @@
-import { FileWithHandle, FileSystemHandle, supported as nativeFileSystemSupported } from "browser-fs-access";
-declare type FILE_EXTENSION = "gif" | "jpg" | "png" | "svg" | "json" | "excalidraw" | "excalidrawlib";
+import { FileSystemHandle, supported as nativeFileSystemSupported } from "browser-fs-access";
+declare type FILE_EXTENSION = "gif" | "jpg" | "png" | "excalidraw.png" | "svg" | "excalidraw.svg" | "json" | "excalidraw" | "excalidrawlib";
 export declare const fileOpen: <M extends boolean | undefined = false>(opts: {
     extensions?: FILE_EXTENSION[] | undefined;
     description: string;
     multiple?: M | undefined;
-}) => Promise<M extends false | undefined ? FileWithHandle : FileWithHandle[]>;
+}) => Promise<M extends false | undefined ? File : File[]>;
 export declare const fileSave: (blob: Blob, opts: {
     /** supply without the extension */
     name: string;

package/types/data/index.d.ts

@@ -4,7 +4,7 @@ import { AppState, BinaryFiles } from "../types";
 import { FileSystemHandle } from "./filesystem";
 export { loadFromBlob } from "./blob";
 export { loadFromJSON, saveAsJSON } from "./json";
-export declare const exportCanvas: (type: ExportType, elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, name, fileHandle, }: {
+export declare const exportCanvas: (type: Omit<ExportType, "backend">, elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, name, fileHandle, }: {
     exportBackground: boolean;
     exportPadding?: number | undefined;
     viewBackgroundColor: string;

package/types/data/json.d.ts

@@ -1,7 +1,6 @@
 import { ExcalidrawElement } from "../element/types";
 import { AppState, BinaryFiles, LibraryItems } from "../types";
-import { ImportedDataState } from "./types";
-import Library from "./library";
+import { ImportedDataState, ImportedLibraryData } from "./types";
 export declare const serializeAsJSON: (elements: readonly ExcalidrawElement[], appState: Partial<AppState>, files: BinaryFiles, type: "local" | "database") => string;
 export declare const saveAsJSON: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles) => Promise<{
     fileHandle: import("browser-fs-access").FileSystemHandle | null;
@@ -11,7 +10,7 @@ export declare const isValidExcalidrawData: (data?: {
     type?: any;
     elements?: any;
     appState?: any;
-} | undefined) => data is ImportedDataState;
-export declare const isValidLibrary: (json: any) => any;
+}) => data is ImportedDataState;
+export declare const isValidLibrary: (json: any) => json is ImportedLibraryData;
+export declare const serializeLibraryAsJSON: (libraryItems: LibraryItems) => string;
 export declare const saveLibraryAsJSON: (libraryItems: LibraryItems) => Promise<void>;
-export declare const importLibraryFromJSON: (library: Library) => Promise<void>;

package/types/data/library.d.ts

@@ -1,14 +1,96 @@
-import { LibraryItems, LibraryItem } from "../types";
+import { LibraryItems, ExcalidrawImperativeAPI, LibraryItemsSource } from "../types";
 import type App from "../components/App";
+import { ExcalidrawElement } from "../element/types";
+export declare const libraryItemsAtom: import("jotai").Atom<{
+    status: "loading" | "loaded";
+    isInitialized: boolean;
+    libraryItems: LibraryItems;
+}> & {
+    write: (get: {
+        <Value>(atom: import("jotai").Atom<Value | Promise<Value>>): Value;
+        <Value_1>(atom: import("jotai").Atom<Promise<Value_1>>): Value_1;
+        <Value_2>(atom: import("jotai").Atom<Value_2>): Value_2 extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2;
+    } & {
+        <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>, options: {
+            unstable_promise: true;
+        }): Value_3 | Promise<Value_3>;
+        <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>, options: {
+            unstable_promise: true;
+        }): Value_4 | Promise<Value_4>;
+        <Value_5>(atom: import("jotai").Atom<Value_5>, options: {
+            unstable_promise: true;
+        }): (Value_5 extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? any : V : V : V : V : V : V : V : V : V : V : Value_5) | Promise<Value_5 extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? any : V : V : V : V : V : V : V : V : V : V : Value_5>;
+    }, set: {
+        <Value_6, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_6, undefined, Result>): Result;
+        <Value_7, Update, Result_1 extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1;
+    }, update: {
+        status: "loading" | "loaded";
+        isInitialized: boolean;
+        libraryItems: LibraryItems;
+    } | ((prev: {
+        status: "loading" | "loaded";
+        isInitialized: boolean;
+        libraryItems: LibraryItems;
+    }) => {
+        status: "loading" | "loaded";
+        isInitialized: boolean;
+        libraryItems: LibraryItems;
+    })) => void;
+    onMount?: (<S extends (update: {
+        status: "loading" | "loaded";
+        isInitialized: boolean;
+        libraryItems: LibraryItems;
+    } | ((prev: {
+        status: "loading" | "loaded";
+        isInitialized: boolean;
+        libraryItems: LibraryItems;
+    }) => {
+        status: "loading" | "loaded";
+        isInitialized: boolean;
+        libraryItems: LibraryItems;
+    })) => void>(setAtom: S) => void | (() => void)) | undefined;
+} & {
+    init: {
+        status: "loading" | "loaded";
+        isInitialized: boolean;
+        libraryItems: LibraryItems;
+    };
+};
+/** Merges otherItems into localItems. Unique items in otherItems array are
+    sorted first. */
+export declare const mergeLibraryItems: (localItems: LibraryItems, otherItems: LibraryItems) => LibraryItems;
 declare class Library {
-    private libraryCache;
+    /** latest libraryItems */
+    private lastLibraryItems;
+    /** indicates whether library is initialized with library items (has gone
+     * though at least one update) */
+    private isInitialized;
     private app;
     constructor(app: App);
-    resetLibrary: () => Promise<void>;
-    restoreLibraryItem: (libraryItem: LibraryItem) => LibraryItem | null;
-    /** imports library (currently merges, removing duplicates) */
-    importLibrary(blob: Blob, defaultStatus?: string): Promise<void>;
-    loadLibrary: () => Promise<LibraryItems>;
-    saveLibrary: (items: LibraryItems) => Promise<void>;
+    private updateQueue;
+    private getLastUpdateTask;
+    private notifyListeners;
+    resetLibrary: () => Promise<LibraryItems>;
+    /**
+     * @returns latest cloned libraryItems. Awaits all in-progress updates first.
+     */
+    getLatestLibrary: () => Promise<LibraryItems>;
+    updateLibrary: ({ libraryItems, prompt, merge, openLibraryMenu, defaultStatus, }: {
+        libraryItems: LibraryItemsSource;
+        merge?: boolean | undefined;
+        prompt?: boolean | undefined;
+        openLibraryMenu?: boolean | undefined;
+        defaultStatus?: "published" | "unpublished" | undefined;
+    }) => Promise<LibraryItems>;
+    setLibrary: (libraryItems: LibraryItems | Promise<LibraryItems> | ((latestLibraryItems: LibraryItems) => LibraryItems | Promise<LibraryItems>)) => Promise<LibraryItems>;
 }
 export default Library;
+export declare const distributeLibraryItemsOnSquareGrid: (libraryItems: LibraryItems) => ExcalidrawElement[];
+export declare const parseLibraryTokensFromUrl: () => {
+    libraryUrl: string;
+    idToken: string | null;
+} | null;
+export declare const useHandleLibrary: ({ excalidrawAPI, getInitialLibraryItems, }: {
+    excalidrawAPI: ExcalidrawImperativeAPI | null;
+    getInitialLibraryItems?: (() => LibraryItemsSource) | undefined;
+}) => void;

package/types/data/restore.d.ts

@@ -2,7 +2,7 @@ import { ExcalidrawElement } from "../element/types";
 import { AppState, BinaryFiles, LibraryItem } from "../types";
 import { ImportedDataState } from "./types";
 declare type RestoredAppState = Omit<AppState, "offsetTop" | "offsetLeft" | "width" | "height">;
-export declare const AllowedExcalidrawElementTypes: Record<ExcalidrawElement["type"], true>;
+export declare const AllowedExcalidrawActiveTools: Record<AppState["activeTool"]["type"], boolean>;
 export declare type RestoredDataState = {
     elements: ExcalidrawElement[];
     appState: RestoredAppState;
@@ -10,6 +10,6 @@ export declare type RestoredDataState = {
 };
 export declare const restoreElements: (elements: ImportedDataState["elements"], localElements: readonly ExcalidrawElement[] | null | undefined) => ExcalidrawElement[];
 export declare const restoreAppState: (appState: ImportedDataState["appState"], localAppState: Partial<AppState> | null | undefined) => RestoredAppState;
-export declare const restore: (data: ImportedDataState | null, localAppState: Partial<AppState> | null | undefined, localElements: readonly ExcalidrawElement[] | null | undefined) => RestoredDataState;
-export declare const restoreLibraryItems: (libraryItems: NonOptional<ImportedDataState["libraryItems"]>, defaultStatus: LibraryItem["status"]) => LibraryItem[];
+export declare const restore: (data: Pick<ImportedDataState, "appState" | "elements" | "files"> | null, localAppState: Partial<AppState> | null | undefined, localElements: readonly ExcalidrawElement[] | null | undefined) => RestoredDataState;
+export declare const restoreLibraryItems: (libraryItems: ImportedDataState["libraryItems"], defaultStatus: LibraryItem["status"]) => LibraryItem[];
 export {};

package/types/data/types.d.ts

@@ -1,5 +1,5 @@
 import { ExcalidrawElement } from "../element/types";
-import { AppState, BinaryFiles, LibraryItems, LibraryItems_v1 } from "../types";
+import { AppState, BinaryFiles, LibraryItems, LibraryItems_anyVersion } from "../types";
 import type { cleanAppStateForExport } from "../appState";
 import { VERSIONS } from "../constants";
 export interface ExportedDataState {
@@ -17,7 +17,7 @@ export interface ImportedDataState {
     elements?: readonly ExcalidrawElement[] | null;
     appState?: Readonly<Partial<AppState>> | null;
     scrollToContent?: boolean;
-    libraryItems?: LibraryItems | LibraryItems_v1;
+    libraryItems?: LibraryItems_anyVersion;
     files?: BinaryFiles;
 }
 export interface ExportedLibraryData {

package/types/element/Hyperlink.d.ts

@@ -13,7 +13,7 @@ export declare const Hyperlink: ({ element, appState, setAppState, onLinkOpen, }
 export declare const normalizeLink: (link: string) => string;
 export declare const isLocalLink: (link: string | null) => boolean;
 export declare const actionLink: {
-    name: "link";
+    name: "hyperlink";
     perform: (elements: readonly import("./types").ExcalidrawElement[], appState: Readonly<AppState>) => false | {
         elements: readonly import("./types").ExcalidrawElement[];
         appState: {
@@ -30,8 +30,17 @@ export declare const actionLink: {
             suggestedBindings: import("./binding").SuggestedBinding[];
             editingElement: NonDeletedExcalidrawElement | null;
             editingLinearElement: import("./linearElementEditor").LinearElementEditor | null;
-            elementType: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw";
-            elementLocked: boolean;
+            activeTool: {
+                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | "eraser";
+                lastActiveToolBeforeEraser: import("../types").LastActiveToolBeforeEraser;
+                locked: boolean;
+                customType: null;
+            } | {
+                type: "custom";
+                customType: string;
+                lastActiveToolBeforeEraser: import("../types").LastActiveToolBeforeEraser;
+                locked: boolean;
+            };
             penMode: boolean;
             penDetected: boolean;
             exportBackground: boolean;
@@ -73,7 +82,11 @@ export declare const actionLink: {
             };
             shouldCacheIgnoreZoom: boolean;
             showHelpDialog: boolean;
-            toastMessage: string | null;
+            toast: {
+                message: string;
+                closable?: boolean | undefined;
+                duration?: number | undefined;
+            } | null;
             zenModeEnabled: boolean;
             theme: string;
             gridSize: number | null;
@@ -87,6 +100,7 @@ export declare const actionLink: {
             offsetTop: number;
             offsetLeft: number;
             isLibraryOpen: boolean;
+            isLibraryMenuDocked: boolean;
             fileHandle: import("browser-fs-access").FileSystemHandle | null;
             collaborators: Map<string, import("../types").Collaborator>;
             showStats: boolean;
@@ -98,14 +112,19 @@ export declare const actionLink: {
                 shown: true;
                 data: import("../charts").Spreadsheet;
             };
-            pendingImageElement: import("./types").NonDeleted<import("./types").ExcalidrawImageElement> | null;
+            pendingImageElementId: string | null;
+            selectedLinearElement: import("./linearElementEditor").LinearElementEditor | null;
         };
         commitToHistory: true;
     };
+    trackEvent: {
+        category: "hyperlink";
+        action: string;
+    };
     keyTest: (event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean;
     contextItemLabel: (elements: readonly import("./types").ExcalidrawElement[], appState: Readonly<AppState>) => "labels.link.edit" | "labels.link.create";
     contextItemPredicate: (elements: readonly import("./types").ExcalidrawElement[], appState: AppState) => boolean;
-    PanelComponent: ({ elements, appState, updateData }: import("react").PropsWithChildren<import("../actions/types").PanelComponentProps>) => JSX.Element;
+    PanelComponent: ({ elements, appState, updateData }: import("../actions/types").PanelComponentProps) => JSX.Element;
 } & {
     keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
 };

package/types/element/binding.d.ts

@@ -22,12 +22,12 @@ export declare const getHoveredElementForBinding: (pointerCoords: {
     y: number;
 }, scene: Scene) => NonDeleted<ExcalidrawBindableElement> | null;
 export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, options?: {
-    simultaneouslyUpdated?: readonly ExcalidrawElement[] | undefined;
+    simultaneouslyUpdated?: readonly ExcalidrawElement[];
     newSize?: {
         width: number;
         height: number;
-    } | undefined;
-} | undefined) => void;
+    };
+}) => void;
 export declare const getEligibleElementsForBinding: (elements: NonDeleted<ExcalidrawElement>[]) => SuggestedBinding[];
 export declare const fixBindingsAfterDuplication: (sceneElements: readonly ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicatesServeAsOld?: "duplicatesServeAsOld" | undefined) => void;
 export declare const fixBindingsAfterDeletion: (sceneElements: readonly ExcalidrawElement[], deletedElements: readonly ExcalidrawElement[]) => void;

package/types/element/dragElements.d.ts

@@ -1,6 +1,5 @@
-import { SHAPES } from "../shapes";
 import { NonDeletedExcalidrawElement } from "./types";
 import { AppState, PointerDownState } from "../types";
 export declare const dragSelectedElements: (pointerDownState: PointerDownState, selectedElements: NonDeletedExcalidrawElement[], pointerX: number, pointerY: number, lockDirection: boolean | undefined, distanceX: number | undefined, distanceY: number | undefined, appState: AppState) => void;
 export declare const getDragOffsetXY: (selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
-export declare const dragNewElement: (draggingElement: NonDeletedExcalidrawElement, elementType: typeof SHAPES[number]["value"], originX: number, originY: number, x: number, y: number, width: number, height: number, shouldMaintainAspectRatio: boolean, shouldResizeFromCenter: boolean, widthAspectRatio?: number | null | undefined) => void;
+export declare const dragNewElement: (draggingElement: NonDeletedExcalidrawElement, elementType: AppState["activeTool"]["type"], originX: number, originY: number, x: number, y: number, width: number, height: number, shouldMaintainAspectRatio: boolean, shouldResizeFromCenter: boolean, widthAspectRatio?: number | null) => void;

package/types/element/index.d.ts

@@ -9,7 +9,7 @@ export { dragSelectedElements, getDragOffsetXY, dragNewElement, } from "./dragEl
 export { isTextElement, isExcalidrawElement } from "./typeChecks";
 export { textWysiwyg } from "./textWysiwyg";
 export { redrawTextBoundingBox } from "./textElement";
-export { getPerfectElementSize, isInvisiblySmallElement, resizePerfectLineForNWHandler, getNormalizedDimensions, } from "./sizeHelpers";
+export { getPerfectElementSize, getLockedLinearCursorAlignSize, isInvisiblySmallElement, resizePerfectLineForNWHandler, getNormalizedDimensions, } from "./sizeHelpers";
 export { showSelectedShapeActions } from "./showSelectedShapeActions";
 export declare const getSceneVersion: (elements: readonly ExcalidrawElement[]) => number;
 export declare const getVisibleElements: (elements: readonly ExcalidrawElement[]) => readonly NonDeletedExcalidrawElement[];

package/types/element/linearElementEditor.d.ts

@@ -23,6 +23,7 @@ export declare class LinearElementEditor {
     }>;
     startBindingElement: ExcalidrawBindableElement | null | "keep";
     endBindingElement: ExcalidrawBindableElement | null | "keep";
+    hoverPointIndex: number;
     constructor(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene);
     static POINT_HANDLE_SIZE: number;
     /**
@@ -32,19 +33,20 @@ export declare class LinearElementEditor {
     static getElement(id: InstanceType<typeof LinearElementEditor>["elementId"]): NonDeleted<ExcalidrawLinearElement> | null;
     static handleBoxSelection(event: PointerEvent, appState: AppState, setState: React.Component<any, AppState>["setState"]): false | undefined;
     /** @returns whether point was dragged */
-    static handlePointDragging(appState: AppState, setState: React.Component<any, AppState>["setState"], scenePointerX: number, scenePointerY: number, maybeSuggestBinding: (element: NonDeleted<ExcalidrawLinearElement>, pointSceneCoords: {
+    static handlePointDragging(appState: AppState, scenePointerX: number, scenePointerY: number, maybeSuggestBinding: (element: NonDeleted<ExcalidrawLinearElement>, pointSceneCoords: {
         x: number;
         y: number;
-    }[]) => void): boolean;
+    }[]) => void, linearElementEditor: LinearElementEditor): boolean;
     static handlePointerUp(event: PointerEvent, editingLinearElement: LinearElementEditor, appState: AppState): LinearElementEditor;
-    static handlePointerDown(event: React.PointerEvent<HTMLCanvasElement>, appState: AppState, setState: React.Component<any, AppState>["setState"], history: History, scenePointer: {
+    static handlePointerDown(event: React.PointerEvent<HTMLCanvasElement>, appState: AppState, history: History, scenePointer: {
         x: number;
         y: number;
-    }): {
+    }, linearElementEditor: LinearElementEditor): {
         didAddPoint: boolean;
         hitElement: NonDeleted<ExcalidrawElement> | null;
+        linearElementEditor: LinearElementEditor | null;
     };
-    static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, editingLinearElement: LinearElementEditor, gridSize: number | null): LinearElementEditor;
+    static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, linearElementEditor: LinearElementEditor, gridSize: number | null): LinearElementEditor;
     /** scene coords */
     static getPointGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, point: Point): readonly [number, number];
     /** scene coords */
@@ -85,6 +87,7 @@ export declare class LinearElementEditor {
                 }>;
                 startBindingElement: ExcalidrawBindableElement | "keep" | null;
                 endBindingElement: ExcalidrawBindableElement | "keep" | null;
+                hoverPointIndex: number;
             };
             isLoading: boolean;
             errorMessage: string | null;
@@ -96,8 +99,17 @@ export declare class LinearElementEditor {
             startBoundElement: NonDeleted<ExcalidrawBindableElement> | null;
             suggestedBindings: import("./binding").SuggestedBinding[];
             editingElement: import("./types").NonDeletedExcalidrawElement | null;
-            elementType: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw";
-            elementLocked: boolean;
+            activeTool: {
+                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | "eraser";
+                lastActiveToolBeforeEraser: import("../types").LastActiveToolBeforeEraser;
+                locked: boolean;
+                customType: null;
+            } | {
+                type: "custom";
+                customType: string;
+                lastActiveToolBeforeEraser: import("../types").LastActiveToolBeforeEraser;
+                locked: boolean;
+            };
             penMode: boolean;
             penDetected: boolean;
             exportBackground: boolean;
@@ -140,7 +152,11 @@ export declare class LinearElementEditor {
             };
             shouldCacheIgnoreZoom: boolean;
             showHelpDialog: boolean;
-            toastMessage: string | null;
+            toast: {
+                message: string;
+                closable?: boolean | undefined;
+                duration?: number | undefined;
+            } | null;
             zenModeEnabled: boolean;
             theme: string;
             gridSize: number | null;
@@ -154,6 +170,7 @@ export declare class LinearElementEditor {
             offsetTop: number;
             offsetLeft: number;
             isLibraryOpen: boolean;
+            isLibraryMenuDocked: boolean;
             fileHandle: import("browser-fs-access").FileSystemHandle | null;
             collaborators: Map<string, import("../types").Collaborator>;
             showStats: boolean;
@@ -165,8 +182,9 @@ export declare class LinearElementEditor {
                 shown: true;
                 data: import("../charts").Spreadsheet;
             };
-            pendingImageElement: NonDeleted<import("./types").ExcalidrawImageElement> | null;
+            pendingImageElementId: string | null;
             showHyperlinkPopup: false | "info" | "editor";
+            selectedLinearElement: LinearElementEditor | null;
         };
     };
     static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[]): void;

package/types/element/mutateElement.d.ts

@@ -7,5 +7,5 @@ export declare const newElementWith: <TElement extends ExcalidrawElement>(elemen
  *
  * NOTE: does not trigger re-render.
  */
-export declare const bumpVersion: (element: Mutable<ExcalidrawElement>, version?: number | undefined) => Mutable<ExcalidrawElement>;
+export declare const bumpVersion: (element: Mutable<ExcalidrawElement>, version?: ExcalidrawElement["version"]) => Mutable<ExcalidrawElement>;
 export {};

package/types/element/resizeElements.d.ts

@@ -4,6 +4,6 @@ import { PointerDownState } from "../types";
 export declare const normalizeAngle: (angle: number) => number;
 export declare const transformElements: (pointerDownState: PointerDownState, transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], resizeArrowDirection: "origin" | "end", shouldRotateWithDiscreteAngle: boolean, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number) => boolean;
 export declare const reshapeSingleTwoPointElement: (element: NonDeleted<ExcalidrawLinearElement>, resizeArrowDirection: "origin" | "end", shouldRotateWithDiscreteAngle: boolean, pointerX: number, pointerY: number) => void;
-export declare const resizeSingleElement: (stateAtResizeStart: NonDeletedExcalidrawElement, shouldMaintainAspectRatio: boolean, element: NonDeletedExcalidrawElement, transformHandleDirection: TransformHandleDirection, shouldResizeFromCenter: boolean, pointerX: number, pointerY: number) => void;
+export declare const resizeSingleElement: (originalElements: PointerDownState["originalElements"], shouldMaintainAspectRatio: boolean, element: NonDeletedExcalidrawElement, transformHandleDirection: TransformHandleDirection, shouldResizeFromCenter: boolean, pointerX: number, pointerY: number) => void;
 export declare const getResizeOffsetXY: (transformHandleType: MaybeTransformHandleType, selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
 export declare const getResizeArrowDirection: (transformHandleType: MaybeTransformHandleType, element: NonDeleted<ExcalidrawLinearElement>) => "origin" | "end";

package/types/element/sizeHelpers.d.ts

@@ -1,9 +1,14 @@
 import { ExcalidrawElement } from "./types";
+import { AppState } from "../types";
 export declare const isInvisiblySmallElement: (element: ExcalidrawElement) => boolean;
 /**
  * Makes a perfect shape or diagonal/horizontal/vertical line
  */
-export declare const getPerfectElementSize: (elementType: string, width: number, height: number) => {
+export declare const getPerfectElementSize: (elementType: AppState["activeTool"]["type"], width: number, height: number) => {
+    width: number;
+    height: number;
+};
+export declare const getLockedLinearCursorAlignSize: (originX: number, originY: number, x: number, y: number) => {
     width: number;
     height: number;
 };

package/types/element/textElement.d.ts

@@ -1,10 +1,9 @@
 import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, FontString, NonDeletedExcalidrawElement } from "./types";
 import { MaybeTransformHandleType } from "./transformHandles";
-import { AppState } from "../types";
-export declare const redrawTextBoundingBox: (element: ExcalidrawTextElement, container: ExcalidrawElement | null, appState: AppState) => void;
+export declare const redrawTextBoundingBox: (element: ExcalidrawTextElement, container: ExcalidrawElement | null) => void;
 export declare const bindTextToShapeAfterDuplication: (sceneElements: ExcalidrawElement[], oldElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
-export declare const handleBindTextResize: (elements: readonly NonDeletedExcalidrawElement[], transformHandleType: MaybeTransformHandleType) => void;
-export declare const measureText: (text: string, font: FontString, maxWidth?: number | null | undefined) => {
+export declare const handleBindTextResize: (element: NonDeletedExcalidrawElement, transformHandleType: MaybeTransformHandleType) => void;
+export declare const measureText: (text: string, font: FontString, maxWidth?: number | null) => {
     width: number;
     height: number;
     baseline: number;
@@ -18,8 +17,9 @@ export declare const charWidth: {
 export declare const getApproxMinLineWidth: (font: FontString) => number;
 export declare const getApproxMinLineHeight: (font: FontString) => number;
 export declare const getMinCharWidth: (font: FontString) => number;
+export declare const getMaxCharWidth: (font: FontString) => number;
 export declare const getApproxCharsToFitInWidth: (font: FontString, width: number) => number;
-export declare const getBoundTextElementId: (container: ExcalidrawElement | null) => string | undefined;
+export declare const getBoundTextElementId: (container: ExcalidrawElement | null) => string | null;
 export declare const getBoundTextElement: (element: ExcalidrawElement | null) => ExcalidrawTextElementWithContainer | null;
 export declare const getContainerElement: (element: (ExcalidrawElement & {
     containerId: ExcalidrawElement["id"] | null;

package/types/element/typeChecks.d.ts

@@ -1,16 +1,17 @@
-import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer } from "./types";
+import { AppState } from "../types";
+import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer } from "./types";
 export declare const isGenericElement: (element: ExcalidrawElement | null) => element is ExcalidrawGenericElement;
 export declare const isInitializedImageElement: (element: ExcalidrawElement | null) => element is InitializedExcalidrawImageElement;
 export declare const isImageElement: (element: ExcalidrawElement | null) => element is ExcalidrawImageElement;
 export declare const isTextElement: (element: ExcalidrawElement | null) => element is ExcalidrawTextElement;
-export declare const isFreeDrawElement: (element?: ExcalidrawElement | null | undefined) => element is ExcalidrawFreeDrawElement;
+export declare const isFreeDrawElement: (element?: ExcalidrawElement | null) => element is ExcalidrawFreeDrawElement;
 export declare const isFreeDrawElementType: (elementType: ExcalidrawElement["type"]) => boolean;
-export declare const isLinearElement: (element?: ExcalidrawElement | null | undefined) => element is ExcalidrawLinearElement;
-export declare const isLinearElementType: (elementType: ExcalidrawElement["type"]) => boolean;
-export declare const isBindingElement: (element?: ExcalidrawElement | null | undefined) => element is ExcalidrawLinearElement;
-export declare const isBindingElementType: (elementType: ExcalidrawElement["type"]) => boolean;
-export declare const isBindableElement: (element: ExcalidrawElement | null) => element is ExcalidrawBindableElement;
-export declare const isTextBindableContainer: (element: ExcalidrawElement | null) => boolean;
+export declare const isLinearElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
+export declare const isLinearElementType: (elementType: AppState["activeTool"]["type"]) => boolean;
+export declare const isBindingElement: (element?: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawLinearElement;
+export declare const isBindingElementType: (elementType: AppState["activeTool"]["type"]) => boolean;
+export declare const isBindableElement: (element: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawBindableElement;
+export declare const isTextBindableContainer: (element: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawTextContainer;
 export declare const isExcalidrawElement: (element: any) => boolean;
 export declare const hasBoundTextElement: (element: ExcalidrawElement | null) => element is ExcalidrawBindableElement;
 export declare const isBoundToContainer: (element: ExcalidrawElement | null) => element is ExcalidrawTextElementWithContainer;