@excalidraw/excalidraw 0.10.0 → 0.11.0-5346-59101a1

package/types/constants.d.ts

@@ -17,10 +17,10 @@ export declare const CURSOR_TYPE: {
     AUTO: string;
 };
 export declare const POINTER_BUTTON: {
-    MAIN: number;
-    WHEEL: number;
-    SECONDARY: number;
-    TOUCH: number;
+    readonly MAIN: 0;
+    readonly WHEEL: 1;
+    readonly SECONDARY: 2;
+    readonly TOUCH: -1;
 };
 export declare enum EVENT {
     COPY = "copy",
@@ -47,7 +47,8 @@ export declare enum EVENT {
     TOUCH_END = "touchend",
     HASHCHANGE = "hashchange",
     VISIBILITY_CHANGE = "visibilitychange",
-    SCROLL = "scroll"
+    SCROLL = "scroll",
+    EXCALIDRAW_LINK = "excalidraw-link"
 }
 export declare const ENV: {
     TEST: string;
@@ -61,6 +62,10 @@ export declare const FONT_FAMILY: {
     Helvetica: number;
     Cascadia: number;
 };
+export declare const THEME: {
+    LIGHT: string;
+    DARK: string;
+};
 export declare const WINDOWS_EMOJI_FALLBACK_FONT = "Segoe UI Emoji";
 export declare const DEFAULT_FONT_SIZE = 20;
 export declare const DEFAULT_FONT_FAMILY: FontFamilyValues;
@@ -72,6 +77,14 @@ export declare const GRID_SIZE = 20;
 export declare const MIME_TYPES: {
     readonly excalidraw: "application/vnd.excalidraw+json";
     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";
 };
 export declare const EXPORT_DATA_TYPES: {
     readonly excalidraw: "excalidraw";
@@ -79,9 +92,7 @@ export declare const EXPORT_DATA_TYPES: {
     readonly excalidrawLibrary: "excalidrawlib";
 };
 export declare const EXPORT_SOURCE: string;
-export declare const STORAGE_KEYS: {
-    readonly LOCAL_STORAGE_LIBRARY: "excalidraw-library";
-};
+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;
@@ -89,6 +100,7 @@ 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;
+export declare const HYPERLINK_TOOLTIP_DELAY = 300;
 export declare const IDLE_THRESHOLD = 60000;
 export declare const ACTIVE_THRESHOLD = 3000;
 export declare const MODES: {
@@ -104,9 +116,31 @@ 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;
+export declare const DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT = 1440;
+export declare const ALLOWED_IMAGE_MIME_TYPES: readonly ["image/png", "image/jpeg", "image/svg+xml", "image/gif"];
+export declare const MAX_ALLOWED_FILE_BYTES: number;
+export declare const SVG_NS = "http://www.w3.org/2000/svg";
+export declare const ENCRYPTION_KEY_BITS = 128;
+export declare const VERSIONS: {
+    readonly excalidraw: 2;
+    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,11 +1,47 @@
-import { ExcalidrawElement } from "../element/types";
-import { AppState } from "../types";
+import { ALLOWED_IMAGE_MIME_TYPES, MIME_TYPES } from "../constants";
+import { ExcalidrawElement, FileId } from "../element/types";
+import { AppState, DataURL, LibraryItem } from "../types";
 import { FileSystemHandle } from "./filesystem";
 import { ImportedLibraryData } from "./types";
 export declare const getMimeType: (blob: Blob | string) => string;
 export declare const getFileHandleType: (handle: FileSystemHandle | null) => string | null;
 export declare const isImageFileHandleType: (type: string | null) => type is "svg" | "png";
 export declare const isImageFileHandle: (handle: FileSystemHandle | null) => boolean;
-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 isSupportedImageFile: (blob: Blob | null | undefined) => blob is Blob & {
+    type: typeof ALLOWED_IMAGE_MIME_TYPES[number];
+};
+export declare const loadSceneOrLibraryFromBlob: (blob: Blob | File, localAppState: AppState | null, localElements: readonly ExcalidrawElement[] | null, fileHandle?: FileSystemHandle | null | undefined) => 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 | undefined) => 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) */
+export declare const generateIdFromFile: (file: File) => Promise<FileId>;
+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"];
+    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/encode.d.ts

@@ -1,4 +1,4 @@
-export declare const toByteString: (data: string | Uint8Array) => Promise<string>;
+export declare const toByteString: (data: string | Uint8Array | ArrayBuffer) => Promise<string>;
 /**
  * @param isByteString set to true if already byte string to prevent bloat
  *  due to reencoding
@@ -22,4 +22,32 @@ export declare const encode: ({ text, compress, }: {
     compress?: boolean | undefined;
 }) => Promise<EncodedData>;
 export declare const decode: (data: EncodedData) => Promise<string>;
+/**
+ * The returned buffer has following format:
+ * `[]` refers to a buffers wrapper (see `concatBuffers`)
+ *
+ * [
+ *   encodingMetadataBuffer,
+ *   iv,
+ *   [
+ *      contentsMetadataBuffer
+ *      contentsBuffer
+ *   ]
+ * ]
+ */
+export declare const compressData: <T extends Record<string, any> = never>(dataBuffer: Uint8Array, options: {
+    encryptionKey: string;
+} & ([T] extends [never] ? {
+    metadata?: T | undefined;
+} : {
+    metadata: T;
+})) => Promise<Uint8Array>;
+export declare const decompressData: <T extends Record<string, any>>(bufferView: Uint8Array, options: {
+    decryptionKey: string;
+}) => Promise<{
+    /** metadata source is always JSON so we can decode it here */
+    metadata: T;
+    /** data can be anything so the caller must decode it */
+    data: Uint8Array;
+}>;
 export {};

package/types/data/encryption.d.ts

@@ -0,0 +1,9 @@
+export declare const IV_LENGTH_BYTES = 12;
+export declare const createIV: () => Uint8Array;
+export declare const generateEncryptionKey: <T extends "string" | "cryptoKey" = "string">(returnAs?: T | undefined) => Promise<T extends "cryptoKey" ? CryptoKey : string>;
+export declare const getCryptoKey: (key: string, usage: KeyUsage) => Promise<CryptoKey>;
+export declare const encryptData: (key: string | CryptoKey, data: Uint8Array | ArrayBuffer | Blob | File | string) => Promise<{
+    encryptedBuffer: ArrayBuffer;
+    iv: Uint8Array;
+}>;
+export declare const decryptData: (iv: Uint8Array, encrypted: Uint8Array | ArrayBuffer, privateKey: string) => Promise<ArrayBuffer>;

package/types/data/filesystem.d.ts

@@ -1,16 +1,16 @@
-import { FileWithHandle, FileSystemHandle, supported as nativeFileSystemSupported } from "@dwelle/browser-fs-access";
-declare type FILE_EXTENSION = "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 | 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;
     /** file extension */
     extension: FILE_EXTENSION;
-    description?: string;
+    description: string;
     /** existing FileSystemHandle */
     fileHandle?: FileSystemHandle | null;
 }) => Promise<FileSystemHandle | null>;

package/types/data/index.d.ts

@@ -1,10 +1,10 @@
 import { NonDeletedExcalidrawElement } from "../element/types";
 import { ExportType } from "../scene/types";
-import { AppState } from "../types";
+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, { 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,10 +1,9 @@
 import { ExcalidrawElement } from "../element/types";
-import { AppState } from "../types";
-import { ImportedDataState } from "./types";
-import Library from "./library";
-export declare const serializeAsJSON: (elements: readonly ExcalidrawElement[], appState: Partial<AppState>) => string;
-export declare const saveAsJSON: (elements: readonly ExcalidrawElement[], appState: AppState) => Promise<{
-    fileHandle: import("@dwelle/browser-fs-access").FileSystemHandle | null;
+import { AppState, BinaryFiles, LibraryItems } from "../types";
+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;
 }>;
 export declare const loadFromJSON: (localAppState: AppState, localElements: readonly ExcalidrawElement[] | null) => Promise<import("./restore").RestoredDataState>;
 export declare const isValidExcalidrawData: (data?: {
@@ -12,6 +11,6 @@ export declare const isValidExcalidrawData: (data?: {
     elements?: any;
     appState?: any;
 } | undefined) => data is ImportedDataState;
-export declare const isValidLibrary: (json: any) => any;
-export declare const saveLibraryAsJSON: (library: Library) => Promise<void>;
-export declare const importLibraryFromJSON: (library: Library) => Promise<void>;
+export declare const isValidLibrary: (json: any) => json is ImportedLibraryData;
+export declare const serializeLibraryAsJSON: (libraryItems: LibraryItems) => string;
+export declare const saveLibraryAsJSON: (libraryItems: LibraryItems) => 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): 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/resave.d.ts

@@ -1,5 +1,5 @@
 import { ExcalidrawElement } from "../element/types";
-import { AppState } from "../types";
-export declare const resaveAsImageWithScene: (elements: readonly ExcalidrawElement[], appState: AppState) => Promise<{
-    fileHandle: import("@dwelle/browser-fs-access").FileSystemHandle;
+import { AppState, BinaryFiles } from "../types";
+export declare const resaveAsImageWithScene: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles) => Promise<{
+    fileHandle: import("browser-fs-access").FileSystemHandle;
 }>;

package/types/data/restore.d.ts

@@ -1,13 +1,15 @@
 import { ExcalidrawElement } from "../element/types";
-import { AppState } from "../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;
+    files: BinaryFiles;
 };
 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 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,12 +1,14 @@
 import { ExcalidrawElement } from "../element/types";
-import { AppState, LibraryItems } from "../types";
+import { AppState, BinaryFiles, LibraryItems, LibraryItems_anyVersion } from "../types";
 import type { cleanAppStateForExport } from "../appState";
+import { VERSIONS } from "../constants";
 export interface ExportedDataState {
     type: string;
     version: number;
     source: string;
     elements: readonly ExcalidrawElement[];
     appState: ReturnType<typeof cleanAppStateForExport>;
+    files: BinaryFiles | undefined;
 }
 export interface ImportedDataState {
     type?: string;
@@ -15,13 +17,16 @@ export interface ImportedDataState {
     elements?: readonly ExcalidrawElement[] | null;
     appState?: Readonly<Partial<AppState>> | null;
     scrollToContent?: boolean;
-    libraryItems?: LibraryItems;
+    libraryItems?: LibraryItems_anyVersion;
+    files?: BinaryFiles;
 }
 export interface ExportedLibraryData {
     type: string;
-    version: number;
+    version: typeof VERSIONS.excalidrawLibrary;
     source: string;
-    library: LibraryItems;
+    libraryItems: LibraryItems;
 }
 export interface ImportedLibraryData extends Partial<ExportedLibraryData> {
+    /** @deprecated v1 */
+    library?: LibraryItems;
 }

package/types/{disitrubte.d.ts → distribute.d.ts}

@@ -4,4 +4,3 @@ export interface Distribution {
     axis: "x" | "y";
 }
 export declare const distributeElements: (selectedElements: ExcalidrawElement[], distribution: Distribution) => ExcalidrawElement[];
-export declare const getMaximumGroups: (elements: ExcalidrawElement[]) => ExcalidrawElement[][];

package/types/element/Hyperlink.d.ts

@@ -0,0 +1,131 @@
+/// <reference types="react" />
+import { AppState, ExcalidrawProps } from "../types";
+import { NonDeletedExcalidrawElement } from "./types";
+import { Bounds } from "./bounds";
+import "./Hyperlink.scss";
+export declare const EXTERNAL_LINK_IMG: HTMLImageElement;
+export declare const Hyperlink: ({ element, appState, setAppState, onLinkOpen, }: {
+    element: NonDeletedExcalidrawElement;
+    appState: AppState;
+    setAppState: React.Component<any, AppState>["setState"];
+    onLinkOpen: ExcalidrawProps["onLinkOpen"];
+}) => JSX.Element | null;
+export declare const normalizeLink: (link: string) => string;
+export declare const isLocalLink: (link: string | null) => boolean;
+export declare const actionLink: {
+    name: "hyperlink";
+    perform: (elements: readonly import("./types").ExcalidrawElement[], appState: Readonly<AppState>) => false | {
+        elements: readonly import("./types").ExcalidrawElement[];
+        appState: {
+            showHyperlinkPopup: "editor";
+            openMenu: null;
+            isLoading: boolean;
+            errorMessage: string | null;
+            draggingElement: NonDeletedExcalidrawElement | null;
+            resizingElement: NonDeletedExcalidrawElement | null;
+            multiElement: import("./types").NonDeleted<import("./types").ExcalidrawLinearElement> | null;
+            selectionElement: NonDeletedExcalidrawElement | null;
+            isBindingEnabled: boolean;
+            startBoundElement: import("./types").NonDeleted<import("./types").ExcalidrawBindableElement> | null;
+            suggestedBindings: import("./binding").SuggestedBinding[];
+            editingElement: NonDeletedExcalidrawElement | null;
+            editingLinearElement: import("./linearElementEditor").LinearElementEditor | null;
+            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;
+            exportEmbedScene: boolean;
+            exportWithDarkMode: boolean;
+            exportScale: number;
+            currentItemStrokeColor: string;
+            currentItemBackgroundColor: string;
+            currentItemFillStyle: import("./types").FillStyle;
+            currentItemStrokeWidth: number;
+            currentItemStrokeStyle: import("./types").StrokeStyle;
+            currentItemRoughness: number;
+            currentItemOpacity: number;
+            currentItemFontFamily: number;
+            currentItemFontSize: number;
+            currentItemTextAlign: import("./types").TextAlign;
+            currentItemStrokeSharpness: import("./types").StrokeSharpness;
+            currentItemStartArrowhead: import("./types").Arrowhead | null;
+            currentItemEndArrowhead: import("./types").Arrowhead | null;
+            currentItemLinearStrokeSharpness: import("./types").StrokeSharpness;
+            viewBackgroundColor: string;
+            scrollX: number;
+            scrollY: number;
+            cursorButton: "up" | "down";
+            scrolledOutside: boolean;
+            name: string;
+            isResizing: boolean;
+            isRotating: boolean;
+            zoom: Readonly<{
+                value: import("../types").NormalizedZoomValue;
+            }>;
+            openPopup: "canvasColorPicker" | "backgroundColorPicker" | "strokeColorPicker" | null;
+            lastPointerDownWith: import("./types").PointerType;
+            selectedElementIds: {
+                [id: string]: boolean;
+            };
+            previousSelectedElementIds: {
+                [id: string]: boolean;
+            };
+            shouldCacheIgnoreZoom: boolean;
+            showHelpDialog: boolean;
+            toastMessage: string | null;
+            zenModeEnabled: boolean;
+            theme: string;
+            gridSize: number | null;
+            viewModeEnabled: boolean;
+            selectedGroupIds: {
+                [groupId: string]: boolean;
+            };
+            editingGroupId: string | null;
+            width: number;
+            height: number;
+            offsetTop: number;
+            offsetLeft: number;
+            isLibraryOpen: boolean;
+            isLibraryMenuDocked: boolean;
+            fileHandle: import("browser-fs-access").FileSystemHandle | null;
+            collaborators: Map<string, import("../types").Collaborator>;
+            showStats: boolean;
+            currentChartType: import("./types").ChartType;
+            pasteDialog: {
+                shown: false;
+                data: null;
+            } | {
+                shown: true;
+                data: import("../charts").Spreadsheet;
+            };
+            pendingImageElementId: string | 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;
+} & {
+    keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
+};
+export declare const getContextMenuLabel: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState) => "labels.link.edit" | "labels.link.create";
+export declare const getLinkHandleFromCoords: ([x1, y1, x2, y2]: Bounds, angle: number, appState: AppState) => [x: number, y: number, width: number, height: number];
+export declare const isPointHittingLinkIcon: (element: NonDeletedExcalidrawElement, appState: AppState, [x, y]: readonly [number, number], isMobile: boolean) => boolean;
+export declare const showHyperlinkTooltip: (element: NonDeletedExcalidrawElement, appState: AppState) => void;
+export declare const hideHyperlinkToolip: () => void;
+export declare const shouldHideLinkPopup: (element: NonDeletedExcalidrawElement, appState: AppState, [clientX, clientY]: readonly [number, number]) => Boolean;

package/types/element/bounds.d.ts

@@ -1,4 +1,4 @@
-import { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead } from "./types";
+import { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, NonDeleted } from "./types";
 import { Drawable, Op } from "roughjs/bin/core";
 export declare type Bounds = readonly [number, number, number, number];
 export declare const getElementAbsoluteCoords: (element: ExcalidrawElement) => Bounds;
@@ -14,3 +14,14 @@ export declare const getClosestElementBounds: (elements: readonly ExcalidrawElem
     x: number;
     y: number;
 }) => [number, number, number, number];
+export interface Box {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    midX: number;
+    midY: number;
+    width: number;
+    height: number;
+}
+export declare const getCommonBoundingBox: (elements: ExcalidrawElement[] | readonly NonDeleted<ExcalidrawElement>[]) => Box;

package/types/element/collision.d.ts

@@ -1,9 +1,11 @@
 import * as GA from "../ga";
-import { NonDeletedExcalidrawElement, ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawRectangleElement, ExcalidrawDiamondElement, ExcalidrawTextElement, ExcalidrawEllipseElement, NonDeleted } from "./types";
+import { NonDeletedExcalidrawElement, ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawRectangleElement, ExcalidrawDiamondElement, ExcalidrawTextElement, ExcalidrawEllipseElement, NonDeleted, ExcalidrawImageElement } from "./types";
 import { Point } from "../types";
 import { AppState } from "../types";
 export declare const hitTest: (element: NonDeletedExcalidrawElement, appState: AppState, x: number, y: number) => boolean;
 export declare const isHittingElementBoundingBoxWithoutHittingElement: (element: NonDeletedExcalidrawElement, appState: AppState, x: number, y: number) => boolean;
+export declare const isHittingElementNotConsideringBoundingBox: (element: NonDeletedExcalidrawElement, appState: AppState, point: readonly [number, number]) => boolean;
+export declare const isPointHittingElementBoundingBox: (element: NonDeleted<ExcalidrawElement>, [x, y]: readonly [number, number], threshold: number) => boolean;
 export declare const bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
     x: number;
     y: number;
@@ -16,4 +18,4 @@ export declare const determineFocusPoint: (element: ExcalidrawBindableElement, f
 export declare const intersectElementWithLine: (element: ExcalidrawBindableElement, a: readonly [number, number], b: readonly [number, number], gap?: number) => Point[];
 export declare const getCircleIntersections: (center: readonly [number, number, number, number, number, number, number, number], radius: number, line: readonly [number, number, number, number, number, number, number, number]) => GA.Point[];
 export declare const findFocusPointForEllipse: (ellipse: ExcalidrawEllipseElement, relativeDistance: number, point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
-export declare const findFocusPointForRectangulars: (element: ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawTextElement, relativeDistance: number, point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const findFocusPointForRectangulars: (element: ExcalidrawRectangleElement | ExcalidrawImageElement | ExcalidrawDiamondElement | ExcalidrawTextElement, relativeDistance: number, point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];

package/types/element/dragElements.d.ts

@@ -1,7 +1,5 @@
-import { SHAPES } from "../shapes";
-import Scene from "../scene/Scene";
 import { NonDeletedExcalidrawElement } from "./types";
-import { PointerDownState } from "../types";
-export declare const dragSelectedElements: (pointerDownState: PointerDownState, selectedElements: NonDeletedExcalidrawElement[], pointerX: number, pointerY: number, scene: Scene, lockDirection?: boolean, distanceX?: number, distanceY?: number) => void;
+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, isResizeWithSidesSameLength: boolean, isResizeCenterPoint: boolean) => 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 | undefined) => void;