@zsviczian/excalidraw 0.15.2-obsidian-10 → 0.15.2-obsidian-11

package/types/excalidraw-app/collab/Portal.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="socket.io-client" />
+/// <reference types="lodash" />
+import { SocketUpdateData, SocketUpdateDataSource } from "../data";
+import { TCollabClass } from "./Collab";
+import { ExcalidrawElement } from "../../element/types";
+import { WS_SCENE_EVENT_TYPES } from "../app_constants";
+import { UserIdleState } from "../../types";
+declare class Portal {
+    collab: TCollabClass;
+    socket: SocketIOClient.Socket | null;
+    socketInitialized: boolean;
+    roomId: string | null;
+    roomKey: string | null;
+    broadcastedElementVersions: Map<string, number>;
+    constructor(collab: TCollabClass);
+    open(socket: SocketIOClient.Socket, id: string, key: string): SocketIOClient.Socket;
+    close(): void;
+    isOpen(): boolean;
+    _broadcastSocketData(data: SocketUpdateData, volatile?: boolean): Promise<void>;
+    queueFileUpload: import("lodash").DebouncedFunc<() => Promise<void>>;
+    broadcastScene: (updateType: WS_SCENE_EVENT_TYPES.INIT | WS_SCENE_EVENT_TYPES.UPDATE, allElements: readonly ExcalidrawElement[], syncAll: boolean) => Promise<void>;
+    broadcastIdleChange: (userState: UserIdleState) => Promise<void> | undefined;
+    broadcastMouseLocation: (payload: {
+        pointer: SocketUpdateDataSource["MOUSE_LOCATION"]["payload"]["pointer"];
+        button: SocketUpdateDataSource["MOUSE_LOCATION"]["payload"]["button"];
+    }) => Promise<void> | undefined;
+}
+export default Portal;

package/types/excalidraw-app/collab/RoomDialog.d.ts

@@ -0,0 +1,13 @@
+import "./RoomDialog.scss";
+import { AppState } from "../../types";
+declare const RoomDialog: ({ handleClose, activeRoomLink, username, onUsernameChange, onRoomCreate, onRoomDestroy, setErrorMessage, theme, }: {
+    handleClose: () => void;
+    activeRoomLink: string;
+    username: string;
+    onUsernameChange: (username: string) => void;
+    onRoomCreate: () => void;
+    onRoomDestroy: () => void;
+    setErrorMessage: (message: string) => void;
+    theme: AppState["theme"];
+}) => JSX.Element;
+export default RoomDialog;

package/types/excalidraw-app/collab/reconciliation.d.ts

@@ -0,0 +1,10 @@
+import { PRECEDING_ELEMENT_KEY } from "../../constants";
+import { ExcalidrawElement } from "../../element/types";
+import { AppState } from "../../types";
+export declare type ReconciledElements = readonly ExcalidrawElement[] & {
+    _brand: "reconciledElements";
+};
+export declare type BroadcastedExcalidrawElement = ExcalidrawElement & {
+    [PRECEDING_ELEMENT_KEY]?: string;
+};
+export declare const reconcileElements: (localElements: readonly ExcalidrawElement[], remoteElements: readonly BroadcastedExcalidrawElement[], localAppState: AppState) => ReconciledElements;

package/types/excalidraw-app/components/ExportToExcalidrawPlus.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { NonDeletedExcalidrawElement } from "../../element/types";
+import { AppState, BinaryFiles } from "../../types";
+export declare const ExportToExcalidrawPlus: React.FC<{
+    elements: readonly NonDeletedExcalidrawElement[];
+    appState: AppState;
+    files: BinaryFiles;
+    onError: (error: Error) => void;
+}>;

package/types/excalidraw-app/components/LanguageList.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare const LanguageList: ({ style }: {
+    style?: React.CSSProperties | undefined;
+}) => JSX.Element;

package/types/excalidraw-app/components/icons.d.ts

@@ -0,0 +1 @@
+export declare const excalidrawPlusIcon: JSX.Element;

package/types/excalidraw-app/data/FileManager.d.ts

@@ -0,0 +1,66 @@
+import { ExcalidrawElement, FileId, InitializedExcalidrawImageElement } from "../../element/types";
+import { BinaryFileData, ExcalidrawImperativeAPI, BinaryFiles } from "../../types";
+export declare class FileManager {
+    /** files being fetched */
+    private fetchingFiles;
+    /** files being saved */
+    private savingFiles;
+    private savedFiles;
+    private erroredFiles;
+    private _getFiles;
+    private _saveFiles;
+    constructor({ getFiles, saveFiles, }: {
+        getFiles: (fileIds: FileId[]) => Promise<{
+            loadedFiles: BinaryFileData[];
+            erroredFiles: Map<FileId, true>;
+        }>;
+        saveFiles: (data: {
+            addedFiles: Map<FileId, BinaryFileData>;
+        }) => Promise<{
+            savedFiles: Map<FileId, true>;
+            erroredFiles: Map<FileId, true>;
+        }>;
+    });
+    /**
+     * returns whether file is already saved or being processed
+     */
+    isFileHandled: (id: FileId) => boolean;
+    isFileSaved: (id: FileId) => boolean;
+    saveFiles: ({ elements, files, }: {
+        elements: readonly ExcalidrawElement[];
+        files: BinaryFiles;
+    }) => Promise<{
+        savedFiles: Map<FileId, true>;
+        erroredFiles: Map<FileId, true>;
+    }>;
+    getFiles: (ids: FileId[]) => Promise<{
+        loadedFiles: BinaryFileData[];
+        erroredFiles: Map<FileId, true>;
+    }>;
+    /** a file element prevents unload only if it's being saved regardless of
+     *  its `status`. This ensures that elements who for any reason haven't
+     *  beed set to `saved` status don't prevent unload in future sessions.
+     *  Technically we should prevent unload when the origin client haven't
+     *  yet saved the `status` update to storage, but that should be taken care
+     *  of during regular beforeUnload unsaved files check.
+     */
+    shouldPreventUnload: (elements: readonly ExcalidrawElement[]) => boolean;
+    /**
+     * helper to determine if image element status needs updating
+     */
+    shouldUpdateImageElementStatus: (element: ExcalidrawElement) => element is InitializedExcalidrawImageElement;
+    reset(): void;
+}
+export declare const encodeFilesForUpload: ({ files, maxBytes, encryptionKey, }: {
+    files: Map<FileId, BinaryFileData>;
+    maxBytes: number;
+    encryptionKey: string;
+}) => Promise<{
+    id: FileId;
+    buffer: Uint8Array;
+}[]>;
+export declare const updateStaleImageStatuses: (params: {
+    excalidrawAPI: ExcalidrawImperativeAPI;
+    erroredFiles: Map<FileId, true>;
+    elements: readonly ExcalidrawElement[];
+}) => void;

package/types/excalidraw-app/data/LocalData.d.ts

@@ -0,0 +1,32 @@
+/**
+ * This file deals with saving data state (appState, elements, images, ...)
+ * locally to the browser.
+ *
+ * Notes:
+ *
+ * - DataState refers to full state of the app: appState, elements, images,
+ *   though some state is saved separately (collab username, library) for one
+ *   reason or another. We also save different data to different sotrage
+ *   (localStorage, indexedDB).
+ */
+import { ExcalidrawElement, FileId } from "../../element/types";
+import { AppState, BinaryFiles } from "../../types";
+import { FileManager } from "./FileManager";
+declare class LocalFileManager extends FileManager {
+    clearObsoleteFiles: (opts: {
+        currentFileIds: FileId[];
+    }) => Promise<void>;
+}
+declare type SavingLockTypes = "collaboration";
+export declare class LocalData {
+    private static _save;
+    /** Saves DataState, including files. Bails if saving is paused */
+    static save: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles, onFilesSaved: () => void) => void;
+    static flushSave: () => void;
+    private static locker;
+    static pauseSave: (lockType: SavingLockTypes) => void;
+    static resumeSave: (lockType: SavingLockTypes) => void;
+    static isSavePaused: () => boolean;
+    static fileStorage: LocalFileManager;
+}
+export {};

package/types/excalidraw-app/data/Locker.d.ts

@@ -0,0 +1,8 @@
+export declare class Locker<T extends string> {
+    private locks;
+    lock: (lockType: T) => void;
+    /** @returns whether no locks remaining */
+    unlock: (lockType: T) => boolean;
+    /** @returns whether some (or specific) locks are present */
+    isLocked(lockType?: T): boolean;
+}

package/types/excalidraw-app/data/firebase.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="socket.io-client" />
+import { ExcalidrawElement, FileId } from "../../element/types";
+import Portal from "../collab/Portal";
+import { AppState, BinaryFileData } from "../../types";
+import { SyncableExcalidrawElement } from ".";
+export declare const loadFirebaseStorage: () => Promise<typeof import("firebase/app").default>;
+export declare const isSavedToFirebase: (portal: Portal, elements: readonly ExcalidrawElement[]) => boolean;
+export declare const saveFilesToFirebase: ({ prefix, files, }: {
+    prefix: string;
+    files: {
+        id: FileId;
+        buffer: Uint8Array;
+    }[];
+}) => Promise<{
+    savedFiles: Map<FileId, true>;
+    erroredFiles: Map<FileId, true>;
+}>;
+export declare const saveToFirebase: (portal: Portal, elements: readonly SyncableExcalidrawElement[], appState: AppState) => Promise<false | {
+    reconciledElements: SyncableExcalidrawElement[] | null;
+}>;
+export declare const loadFromFirebase: (roomId: string, roomKey: string, socket: SocketIOClient.Socket | null) => Promise<readonly ExcalidrawElement[] | null>;
+export declare const loadFilesFromFirebase: (prefix: string, decryptionKey: string, filesIds: readonly FileId[]) => Promise<{
+    loadedFiles: BinaryFileData[];
+    erroredFiles: Map<FileId, true>;
+}>;

package/types/excalidraw-app/data/index.d.ts

@@ -0,0 +1,190 @@
+import { ImportedDataState } from "../../data/types";
+import { ExcalidrawElement } from "../../element/types";
+import { AppState, BinaryFiles, UserIdleState } from "../../types";
+export declare type SyncableExcalidrawElement = ExcalidrawElement & {
+    _brand: "SyncableExcalidrawElement";
+};
+export declare const isSyncableElement: (element: ExcalidrawElement) => element is SyncableExcalidrawElement;
+export declare const getSyncableElements: (elements: readonly ExcalidrawElement[]) => SyncableExcalidrawElement[];
+/**
+ * Right now the reason why we resolve connection params (url, polling...)
+ * from upstream is to allow changing the params immediately when needed without
+ * having to wait for clients to update the SW.
+ *
+ * If REACT_APP_WS_SERVER_URL env is set, we use that instead (useful for forks)
+ */
+export declare const getCollabServer: () => Promise<{
+    url: string;
+    polling: boolean;
+}>;
+export declare type EncryptedData = {
+    data: ArrayBuffer;
+    iv: Uint8Array;
+};
+export declare type SocketUpdateDataSource = {
+    SCENE_INIT: {
+        type: "SCENE_INIT";
+        payload: {
+            elements: readonly ExcalidrawElement[];
+        };
+    };
+    SCENE_UPDATE: {
+        type: "SCENE_UPDATE";
+        payload: {
+            elements: readonly ExcalidrawElement[];
+        };
+    };
+    MOUSE_LOCATION: {
+        type: "MOUSE_LOCATION";
+        payload: {
+            socketId: string;
+            pointer: {
+                x: number;
+                y: number;
+            };
+            button: "down" | "up";
+            selectedElementIds: AppState["selectedElementIds"];
+            username: string;
+        };
+    };
+    IDLE_STATUS: {
+        type: "IDLE_STATUS";
+        payload: {
+            socketId: string;
+            userState: UserIdleState;
+            username: string;
+        };
+    };
+};
+export declare type SocketUpdateDataIncoming = SocketUpdateDataSource[keyof SocketUpdateDataSource] | {
+    type: "INVALID_RESPONSE";
+};
+export declare type SocketUpdateData = SocketUpdateDataSource[keyof SocketUpdateDataSource] & {
+    _brand: "socketUpdateData";
+};
+export declare const isCollaborationLink: (link: string) => boolean;
+export declare const getCollaborationLinkData: (link: string) => {
+    roomId: string;
+    roomKey: string;
+} | null;
+export declare const generateCollaborationLinkData: () => Promise<{
+    roomId: string;
+    roomKey: string;
+}>;
+export declare const getCollaborationLink: (data: {
+    roomId: string;
+    roomKey: string;
+}) => string;
+export declare const loadScene: (id: string | null, privateKey: string | null, localDataState: ImportedDataState | undefined | null) => Promise<{
+    elements: ExcalidrawElement[];
+    appState: {
+        theme: string;
+        name: string;
+        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;
+        };
+        contextMenu: {
+            items: import("../../components/ContextMenu").ContextMenuItems;
+            top: number;
+            left: number;
+        } | null;
+        showWelcomeScreen: boolean;
+        isLoading: boolean;
+        errorMessage: string | null;
+        draggingElement: import("../../element/types").NonDeletedExcalidrawElement | null;
+        resizingElement: import("../../element/types").NonDeletedExcalidrawElement | null;
+        multiElement: import("../../element/types").NonDeleted<import("../../element/types").ExcalidrawLinearElement> | null;
+        selectionElement: import("../../element/types").NonDeletedExcalidrawElement | null;
+        isBindingEnabled: boolean;
+        startBoundElement: import("../../element/types").NonDeleted<import("../../element/types").ExcalidrawBindableElement> | null;
+        suggestedBindings: import("../../element/binding").SuggestedBinding[];
+        editingElement: import("../../element/types").NonDeletedExcalidrawElement | null;
+        editingLinearElement: import("../../element/linearElementEditor").LinearElementEditor | null;
+        penMode: boolean;
+        penDetected: boolean;
+        exportBackground: boolean;
+        exportEmbedScene: boolean;
+        exportWithDarkMode: boolean;
+        exportScale: number;
+        currentItemStrokeColor: string;
+        currentItemBackgroundColor: string;
+        currentItemFillStyle: import("../../element/types").FillStyle;
+        currentItemStrokeWidth: number;
+        currentItemStrokeStyle: import("../../element/types").StrokeStyle;
+        currentItemRoughness: number;
+        currentItemOpacity: number;
+        currentItemFontFamily: number;
+        currentItemFontSize: number;
+        currentItemTextAlign: string;
+        currentItemStartArrowhead: import("../../element/types").Arrowhead | null;
+        currentItemEndArrowhead: import("../../element/types").Arrowhead | null;
+        currentItemRoundness: import("../../element/types").StrokeRoundness;
+        viewBackgroundColor: string;
+        scrollX: number;
+        scrollY: number;
+        cursorButton: "up" | "down";
+        scrolledOutside: boolean;
+        isResizing: boolean;
+        isRotating: boolean;
+        zoom: Readonly<{
+            value: import("../../types").NormalizedZoomValue;
+        }>;
+        openMenu: "canvas" | "shape" | null;
+        openPopup: "canvasColorPicker" | "backgroundColorPicker" | "strokeColorPicker" | null;
+        openSidebar: "library" | "customSidebar" | null;
+        openDialog: "imageExport" | "help" | null;
+        isSidebarDocked: boolean;
+        lastPointerDownWith: import("../../element/types").PointerType;
+        selectedElementIds: {
+            [id: string]: boolean;
+        };
+        previousSelectedElementIds: {
+            [id: string]: boolean;
+        };
+        shouldCacheIgnoreZoom: boolean;
+        toast: {
+            message: string;
+            closable?: boolean | undefined;
+            duration?: number | undefined;
+        } | null;
+        zenModeEnabled: boolean;
+        gridSize: number | null;
+        viewModeEnabled: boolean;
+        selectedGroupIds: {
+            [groupId: string]: boolean;
+        };
+        editingGroupId: string | null;
+        fileHandle: import("browser-fs-access").FileSystemHandle | null;
+        collaborators: Map<string, import("../../types").Collaborator>;
+        showStats: boolean;
+        currentChartType: import("../../element/types").ChartType;
+        pasteDialog: {
+            shown: false;
+            data: null;
+        } | {
+            shown: true;
+            data: import("../../charts").Spreadsheet;
+        };
+        pendingImageElementId: string | null;
+        showHyperlinkPopup: false | "info" | "editor";
+        linkOpacity: number;
+        trayModeEnabled: boolean;
+        colorPalette: {
+            canvasBackground?: string[] | undefined;
+            elementBackground?: string[] | undefined;
+            elementStroke?: string[] | undefined;
+        };
+        selectedLinearElement: import("../../element/linearElementEditor").LinearElementEditor | null;
+    };
+    files: BinaryFiles;
+    commitToHistory: boolean;
+}>;
+export declare const exportToBackend: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles) => Promise<void>;

package/types/excalidraw-app/data/localStorage.d.ts

@@ -0,0 +1,116 @@
+import { ExcalidrawElement } from "../../element/types";
+export declare const saveUsernameToLocalStorage: (username: string) => void;
+export declare const importUsernameFromLocalStorage: () => string | null;
+export declare const importFromLocalStorage: () => {
+    elements: ExcalidrawElement[];
+    appState: {
+        theme: string;
+        name: string;
+        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;
+        };
+        showWelcomeScreen: boolean;
+        penMode: boolean;
+        penDetected: boolean;
+        exportBackground: boolean;
+        exportEmbedScene: boolean;
+        exportWithDarkMode: boolean;
+        exportScale: number;
+        currentItemStrokeColor: string;
+        currentItemBackgroundColor: string;
+        currentItemFillStyle: import("../../element/types").FillStyle;
+        currentItemStrokeWidth: number;
+        currentItemStrokeStyle: import("../../element/types").StrokeStyle;
+        currentItemRoughness: number;
+        currentItemOpacity: number;
+        currentItemFontFamily: number;
+        currentItemFontSize: number;
+        currentItemTextAlign: string;
+        currentItemStartArrowhead: import("../../element/types").Arrowhead | null;
+        currentItemEndArrowhead: import("../../element/types").Arrowhead | null;
+        currentItemRoundness: import("../../element/types").StrokeRoundness;
+        viewBackgroundColor: string;
+        scrollX: number;
+        scrollY: number;
+        cursorButton: "up" | "down";
+        scrolledOutside: boolean;
+        zoom: Readonly<{
+            value: import("../../types").NormalizedZoomValue;
+        }>;
+        openMenu: "canvas" | "shape" | null;
+        openSidebar: "library" | "customSidebar" | null;
+        isSidebarDocked: boolean;
+        lastPointerDownWith: import("../../element/types").PointerType;
+        selectedElementIds: {
+            [id: string]: boolean;
+        };
+        previousSelectedElementIds: {
+            [id: string]: boolean;
+        };
+        shouldCacheIgnoreZoom: boolean;
+        zenModeEnabled: boolean;
+        gridSize: number | null;
+        selectedGroupIds: {
+            [groupId: string]: boolean;
+        };
+        editingGroupId: string | null;
+        showStats: boolean;
+        currentChartType: import("../../element/types").ChartType;
+        selectedLinearElement: import("../../element/linearElementEditor").LinearElementEditor | null;
+        contextMenu: {
+            items: import("../../components/ContextMenu").ContextMenuItems;
+            top: number;
+            left: number;
+        } | null;
+        isLoading: boolean;
+        errorMessage: string | null;
+        draggingElement: import("../../element/types").NonDeletedExcalidrawElement | null;
+        resizingElement: import("../../element/types").NonDeletedExcalidrawElement | null;
+        multiElement: import("../../element/types").NonDeleted<import("../../element/types").ExcalidrawLinearElement> | null;
+        selectionElement: import("../../element/types").NonDeletedExcalidrawElement | null;
+        isBindingEnabled: boolean;
+        startBoundElement: import("../../element/types").NonDeleted<import("../../element/types").ExcalidrawBindableElement> | null;
+        suggestedBindings: import("../../element/binding").SuggestedBinding[];
+        editingElement: import("../../element/types").NonDeletedExcalidrawElement | null;
+        editingLinearElement: import("../../element/linearElementEditor").LinearElementEditor | null;
+        isResizing: boolean;
+        isRotating: boolean;
+        openPopup: "canvasColorPicker" | "backgroundColorPicker" | "strokeColorPicker" | null;
+        openDialog: "imageExport" | "help" | null;
+        toast: {
+            message: string;
+            closable?: boolean | undefined;
+            duration?: number | undefined;
+        } | null;
+        viewModeEnabled: boolean;
+        fileHandle: import("browser-fs-access").FileSystemHandle | null;
+        collaborators: Map<string, import("../../types").Collaborator>;
+        pasteDialog: {
+            shown: false;
+            data: null;
+        } | {
+            shown: true;
+            data: import("../../charts").Spreadsheet;
+        };
+        pendingImageElementId: string | null;
+        showHyperlinkPopup: false | "info" | "editor";
+        linkOpacity: number;
+        trayModeEnabled: boolean;
+        colorPalette: {
+            canvasBackground?: string[] | undefined;
+            elementBackground?: string[] | undefined;
+            elementStroke?: string[] | undefined;
+        };
+    } | null;
+};
+export declare const getElementsStorageSize: () => number;
+export declare const getTotalStorageSize: () => number;
+export declare const getLibraryItemsFromStorage: () => import("../../types").LibraryItems_anyVersion;

package/types/excalidraw-app/data/tabSync.d.ts

@@ -0,0 +1,9 @@
+declare const LOCAL_STATE_VERSIONS: {
+    "version-dataState": number;
+    "version-files": number;
+};
+declare type BrowserStateTypes = keyof typeof LOCAL_STATE_VERSIONS;
+export declare const isBrowserStorageStateNewer: (type: BrowserStateTypes) => boolean;
+export declare const updateBrowserStateVersion: (type: BrowserStateTypes) => void;
+export declare const resetBrowserStateVersions: () => void;
+export {};

package/types/excalidraw-app/index.d.ts

@@ -0,0 +1,26 @@
+import "./index.scss";
+export declare const langCodeAtom: import("jotai").Atom<string> & {
+    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: string | ((prev: string) => string)) => void;
+    onMount?: (<S extends (update: string | ((prev: string) => string)) => void>(setAtom: S) => void | (() => void)) | undefined;
+} & {
+    init: string;
+};
+declare const ExcalidrawApp: () => JSX.Element;
+export default ExcalidrawApp;

package/types/frame.d.ts

@@ -1,40 +1,40 @@
-import { ExcalidrawElement, ExcalidrawFrameElement, NonDeleted, NonDeletedExcalidrawElement } from "./element/types";
-import { AppClassProperties, AppState } from "./types";
-import { ExcalidrawElementsIncludingDeleted } from "./scene/Scene";
-export declare const bindElementsToFramesAfterDuplication: (nextElements: ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
-export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameElement) => ExcalidrawElement[];
-export declare const isElementContainingFrame: (elements: readonly ExcalidrawElement[], element: ExcalidrawElement, frame: ExcalidrawFrameElement) => boolean;
-export declare const getElementsIntersectingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameElement) => ExcalidrawElement[];
-export declare const elementsAreInFrameBounds: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameElement) => boolean;
-export declare const elementOverlapsWithFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameElement) => boolean;
-export declare const isCursorInFrame: (cursorCoords: {
-    x: number;
-    y: number;
-}, frame: NonDeleted<ExcalidrawFrameElement>) => boolean;
-export declare const groupsAreAtLeastIntersectingTheFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameElement) => boolean;
-export declare const groupsAreCompletelyOutOfFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameElement) => boolean;
-/**
- * Returns a map of frameId to frame elements. Includes empty frames.
- */
-export declare const groupByFrames: (elements: readonly ExcalidrawElement[]) => Map<string, ExcalidrawElement[]>;
-export declare const getFrameElements: (allElements: ExcalidrawElementsIncludingDeleted, frameId: string) => ExcalidrawElement[];
-export declare const getElementsInResizingFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
-export declare const getElementsInNewFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement) => ExcalidrawElement[];
-export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap?: Map<string, ExcalidrawElement>) => ExcalidrawFrameElement | null;
-export declare const addElementsToFrame: (allElements: ExcalidrawElementsIncludingDeleted, elementsToAdd: NonDeletedExcalidrawElement[], frame: ExcalidrawFrameElement) => ExcalidrawElement[];
-export declare const removeElementsFromFrame: (allElements: ExcalidrawElementsIncludingDeleted, elementsToRemove: NonDeletedExcalidrawElement[], appState: AppState) => ExcalidrawElement[];
-export declare const removeAllElementsFromFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
-export declare const replaceAllElementsInFrame: (allElements: ExcalidrawElementsIncludingDeleted, nextElementsInFrame: ExcalidrawElement[], frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
-/** does not mutate elements, but return new ones */
-export declare const updateFrameMembershipOfSelectedElements: (allElements: ExcalidrawElementsIncludingDeleted, appState: AppState, app: AppClassProperties) => ExcalidrawElementsIncludingDeleted;
-/**
- * filters out elements that are inside groups that contain a frame element
- * anywhere in the group tree
- */
-export declare const omitGroupsContainingFrames: (allElements: ExcalidrawElementsIncludingDeleted, selectedElements?: readonly ExcalidrawElement[]) => ExcalidrawElement[];
-/**
- * depending on the appState, return target frame, which is the frame the given element
- * is going to be added to or remove from
- */
-export declare const getTargetFrame: (element: ExcalidrawElement, appState: AppState) => ExcalidrawFrameElement | null;
-export declare const isElementInFrame: (element: ExcalidrawElement, allElements: ExcalidrawElementsIncludingDeleted, appState: AppState) => boolean;
+import { ExcalidrawElement, ExcalidrawFrameElement, NonDeleted, NonDeletedExcalidrawElement } from "./element/types";
+import { AppClassProperties, AppState } from "./types";
+import { ExcalidrawElementsIncludingDeleted } from "./scene/Scene";
+export declare const bindElementsToFramesAfterDuplication: (nextElements: ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameElement) => ExcalidrawElement[];
+export declare const isElementContainingFrame: (elements: readonly ExcalidrawElement[], element: ExcalidrawElement, frame: ExcalidrawFrameElement) => boolean;
+export declare const getElementsIntersectingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameElement) => ExcalidrawElement[];
+export declare const elementsAreInFrameBounds: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameElement) => boolean;
+export declare const elementOverlapsWithFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameElement) => boolean;
+export declare const isCursorInFrame: (cursorCoords: {
+    x: number;
+    y: number;
+}, frame: NonDeleted<ExcalidrawFrameElement>) => boolean;
+export declare const groupsAreAtLeastIntersectingTheFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameElement) => boolean;
+export declare const groupsAreCompletelyOutOfFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameElement) => boolean;
+/**
+ * Returns a map of frameId to frame elements. Includes empty frames.
+ */
+export declare const groupByFrames: (elements: readonly ExcalidrawElement[]) => Map<string, ExcalidrawElement[]>;
+export declare const getFrameElements: (allElements: ExcalidrawElementsIncludingDeleted, frameId: string) => ExcalidrawElement[];
+export declare const getElementsInResizingFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
+export declare const getElementsInNewFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement) => ExcalidrawElement[];
+export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap?: Map<string, ExcalidrawElement>) => ExcalidrawFrameElement | null;
+export declare const addElementsToFrame: (allElements: ExcalidrawElementsIncludingDeleted, elementsToAdd: NonDeletedExcalidrawElement[], frame: ExcalidrawFrameElement) => ExcalidrawElement[];
+export declare const removeElementsFromFrame: (allElements: ExcalidrawElementsIncludingDeleted, elementsToRemove: NonDeletedExcalidrawElement[], appState: AppState) => ExcalidrawElement[];
+export declare const removeAllElementsFromFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
+export declare const replaceAllElementsInFrame: (allElements: ExcalidrawElementsIncludingDeleted, nextElementsInFrame: ExcalidrawElement[], frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
+/** does not mutate elements, but return new ones */
+export declare const updateFrameMembershipOfSelectedElements: (allElements: ExcalidrawElementsIncludingDeleted, appState: AppState, app: AppClassProperties) => ExcalidrawElementsIncludingDeleted;
+/**
+ * filters out elements that are inside groups that contain a frame element
+ * anywhere in the group tree
+ */
+export declare const omitGroupsContainingFrames: (allElements: ExcalidrawElementsIncludingDeleted, selectedElements?: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+/**
+ * depending on the appState, return target frame, which is the frame the given element
+ * is going to be added to or remove from
+ */
+export declare const getTargetFrame: (element: ExcalidrawElement, appState: AppState) => ExcalidrawFrameElement | null;
+export declare const isElementInFrame: (element: ExcalidrawElement, allElements: ExcalidrawElementsIncludingDeleted, appState: AppState) => boolean;