@zsviczian/excalidraw 0.11.0-obsidian-8 → 0.11.0-obsidian-9

package/types/clipboard.d.ts

@@ -16,5 +16,5 @@ export declare const copyToClipboard: (elements: readonly NonDeletedExcalidrawEl
  * Attempts to parse clipboard. Prefers system clipboard.
  */
 export declare const parseClipboard: (event: ClipboardEvent | null) => Promise<ClipboardData>;
-export declare const copyBlobToClipboardAsPng: (blob: Blob) => Promise<void>;
+export declare const copyBlobToClipboardAsPng: (blob: Blob | Promise<Blob>) => Promise<void>;
 export declare const copyTextToSystemClipboard: (text: string | null) => Promise<void>;

package/types/components/Actions.d.ts

@@ -2,15 +2,15 @@ import React from "react";
 import { ActionManager } from "../actions/manager";
 import { ExcalidrawElement, PointerType } from "../element/types";
 import { AppState, Zoom } from "../types";
-export declare const SelectedShapeActions: ({ appState, elements, renderAction, elementType, }: {
+export declare const SelectedShapeActions: ({ appState, elements, renderAction, activeTool, }: {
     appState: AppState;
     elements: readonly ExcalidrawElement[];
     renderAction: ActionManager["renderAction"];
-    elementType: AppState["elementType"];
+    activeTool: AppState["activeTool"]["type"];
 }) => JSX.Element;
-export declare const ShapesSwitcher: ({ canvas, elementType, setAppState, onImageAction, appState, }: {
+export declare const ShapesSwitcher: ({ canvas, activeTool, setAppState, onImageAction, appState, }: {
     canvas: HTMLCanvasElement | null;
-    elementType: AppState["elementType"];
+    activeTool: AppState["activeTool"];
     setAppState: React.Component<any, AppState>["setState"];
     onImageAction: (data: {
         pointerType: PointerType | null;

package/types/components/App.d.ts

@@ -77,7 +77,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private addTextFromPaste;
     setAppState: (obj: any) => void;
     removePointer: (event: React.PointerEvent<HTMLElement> | PointerEvent) => void;
-    toggleLock: () => void;
+    toggleLock: (source?: "keyboard" | "ui") => void;
     togglePenMode: () => void;
     toggleZenMode: () => void;
     toggleStats: () => void;
@@ -107,7 +107,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private updateCurrentCursorPosition;
     private onKeyDown;
     private onKeyUp;
-    private selectShapeTool;
+    private setActiveTool;
     private onGestureStart;
     private onGestureChange;
     private onGestureEnd;
@@ -149,6 +149,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private onPointerMoveFromPointerDownHandler;
     private handlePointerMoveOverScrollbars;
     private onPointerUpFromPointerDownHandler;
+    private restoreReadyToEraseElements;
     private eraseElements;
     private initializeImage;
     /**

package/types/components/ImageExportDialog.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="react" />
-import { ActionsManagerInterface } from "../actions/types";
 import { NonDeletedExcalidrawElement } from "../element/types";
 import { AppState, BinaryFiles } from "../types";
 import "./ExportDialog.scss";
+import { ActionManager } from "../actions/manager";
 export declare const ErrorCanvasPreview: () => JSX.Element;
 export declare type ExportCB = (elements: readonly NonDeletedExcalidrawElement[], scale?: number) => void;
 export declare const ImageExportDialog: ({ elements, appState, files, exportPadding, actionManager, onExportToPng, onExportToSvg, onExportToClipboard, }: {
@@ -10,7 +10,7 @@ export declare const ImageExportDialog: ({ elements, appState, files, exportPadd
     elements: readonly NonDeletedExcalidrawElement[];
     files: BinaryFiles;
     exportPadding?: number | undefined;
-    actionManager: ActionsManagerInterface;
+    actionManager: ActionManager;
     onExportToPng: ExportCB;
     onExportToSvg: ExportCB;
     onExportToClipboard: ExportCB;

package/types/components/JSONExportDialog.d.ts

@@ -1,14 +1,14 @@
 /// <reference types="react" />
-import { ActionsManagerInterface } from "../actions/types";
 import { NonDeletedExcalidrawElement } from "../element/types";
 import { AppState, ExportOpts, BinaryFiles } from "../types";
 import "./ExportDialog.scss";
+import { ActionManager } from "../actions/manager";
 export declare type ExportCB = (elements: readonly NonDeletedExcalidrawElement[], scale?: number) => void;
 export declare const JSONExportDialog: ({ elements, appState, files, actionManager, exportOpts, canvas, }: {
     elements: readonly NonDeletedExcalidrawElement[];
     appState: AppState;
     files: BinaryFiles;
-    actionManager: ActionsManagerInterface;
+    actionManager: ActionManager;
     exportOpts: ExportOpts;
     canvas: HTMLCanvasElement | null;
 }) => JSX.Element;

package/types/components/ToolButton.d.ts

@@ -38,6 +38,9 @@ declare type ToolButtonProps = (ToolButtonBaseProps & {
     onChange?(data: {
         pointerType: PointerType | null;
     }): void;
+    onPointerDown?(data: {
+        pointerType: PointerType;
+    }): void;
 });
 export declare const ToolButton: React.ForwardRefExoticComponent<ToolButtonProps & React.RefAttributes<unknown>>;
 export {};

package/types/constants.d.ts

@@ -138,3 +138,4 @@ export declare const VERTICAL_ALIGN: {
     MIDDLE: string;
     BOTTOM: string;
 };
+export declare const ELEMENT_READY_TO_ERASE_OPACITY = 20;

package/types/createInverseContext.d.ts

@@ -1 +1,20 @@
-export declare const createInverseContext: <T extends unknown = null>(initialValue: T) => any;
+import React from "react";
+export declare class InverseConsumer extends React.Component {
+    state: {
+        value: any;
+    };
+    constructor(props: any);
+    render(): JSX.Element;
+}
+export declare class InverseProvider extends React.Component<{
+    value: any;
+}> {
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    render(): JSX.Element;
+}
+export declare const createInverseContext: <T extends unknown = null>(initialValue: T) => {
+    Context: any;
+    Consumer: typeof InverseConsumer;
+    Provider: typeof InverseProvider;
+};

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

@@ -13,5 +13,6 @@ export declare const isValidExcalidrawData: (data?: {
     appState?: any;
 } | undefined) => data is ImportedDataState;
 export declare const isValidLibrary: (json: any) => any;
+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/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<AppState["elementType"], boolean>;
+export declare const AllowedExcalidrawActiveTools: Record<AppState["activeTool"]["type"], boolean>;
 export declare type RestoredDataState = {
     elements: ExcalidrawElement[];
     appState: RestoredAppState;

package/types/element/Hyperlink.d.ts

@@ -30,8 +30,11 @@ 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" | "eraser";
-            elementLocked: boolean;
+            activeTool: {
+                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | "eraser";
+                lastActiveToolBeforeEraser: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | null;
+                locked: boolean;
+            };
             penMode: boolean;
             penDetected: boolean;
             exportBackground: boolean;
@@ -109,7 +112,10 @@ export declare const actionLink: {
         };
         commitToHistory: true;
     };
-    trackEvent: (action: import("../actions/types").Action, source: "ui" | "keyboard" | "api") => void;
+    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;

package/types/element/dragElements.d.ts

@@ -2,4 +2,4 @@ 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: AppState["elementType"], 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 | undefined) => void;

package/types/element/linearElementEditor.d.ts

@@ -96,8 +96,11 @@ 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" | "eraser";
-            elementLocked: boolean;
+            activeTool: {
+                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | "eraser";
+                lastActiveToolBeforeEraser: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | null;
+                locked: boolean;
+            };
             penMode: boolean;
             penDetected: boolean;
             exportBackground: boolean;
@@ -140,7 +143,7 @@ export declare class LinearElementEditor {
             };
             shouldCacheIgnoreZoom: boolean;
             showHelpDialog: boolean;
-            toastMessage: string | null; /** @returns whether point was dragged */
+            toastMessage: string | null;
             zenModeEnabled: boolean;
             theme: string;
             gridSize: number | null;

package/types/element/sizeHelpers.d.ts

@@ -1,9 +1,10 @@
 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;
 };

package/types/element/textElement.d.ts

@@ -1,7 +1,6 @@
 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: (element: NonDeletedExcalidrawElement, transformHandleType: MaybeTransformHandleType) => void;
 export declare const measureText: (text: string, font: FontString, maxWidth?: number | null | undefined) => {

package/types/element/typeChecks.d.ts

@@ -7,11 +7,11 @@ export declare const isTextElement: (element: ExcalidrawElement | null) => eleme
 export declare const isFreeDrawElement: (element?: ExcalidrawElement | null | undefined) => 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: AppState["elementType"]) => boolean;
-export declare const isBindingElement: (element?: ExcalidrawElement | null | undefined) => element is ExcalidrawLinearElement;
-export declare const isBindingElementType: (elementType: AppState["elementType"]) => boolean;
-export declare const isBindableElement: (element: ExcalidrawElement | null) => element is ExcalidrawBindableElement;
-export declare const isTextBindableContainer: (element: ExcalidrawElement | null) => element is ExcalidrawTextContainer;
+export declare const isLinearElementType: (elementType: AppState["activeTool"]["type"]) => boolean;
+export declare const isBindingElement: (element?: ExcalidrawElement | null | undefined, 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;

package/types/element/types.d.ts

@@ -52,6 +52,7 @@ declare type _ExcalidrawElementBase = Readonly<{
     /** epoch (ms) timestamp of last element update */
     updated: number;
     link: string | null;
+    locked: boolean;
 }>;
 export declare type ExcalidrawSelectionElement = _ExcalidrawElementBase & {
     type: "selection";

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

@@ -3,8 +3,10 @@ export declare const INITIAL_SCENE_UPDATE_TIMEOUT = 5000;
 export declare const FILE_UPLOAD_TIMEOUT = 300;
 export declare const LOAD_IMAGES_TIMEOUT = 500;
 export declare const SYNC_FULL_SCENE_INTERVAL_MS = 20000;
+export declare const SYNC_BROWSER_TABS_TIMEOUT = 50;
+export declare const CURSOR_SYNC_TIMEOUT = 33;
 export declare const FILE_UPLOAD_MAX_BYTES: number;
-export declare const FILE_CACHE_MAX_AGE_SEC = 2592000;
+export declare const FILE_CACHE_MAX_AGE_SEC = 31536000;
 export declare const BROADCAST: {
     SERVER_VOLATILE: string;
     SERVER: string;
@@ -17,3 +19,13 @@ export declare const FIREBASE_STORAGE_PREFIXES: {
     shareLinkFiles: string;
     collabFiles: string;
 };
+export declare const ROOM_ID_BYTES = 10;
+export declare const STORAGE_KEYS: {
+    readonly LOCAL_STORAGE_ELEMENTS: "excalidraw";
+    readonly LOCAL_STORAGE_APP_STATE: "excalidraw-state";
+    readonly LOCAL_STORAGE_COLLAB: "excalidraw-collab";
+    readonly LOCAL_STORAGE_KEY_COLLAB_FORCE_FLAG: "collabLinkForceLoadFlag";
+    readonly LOCAL_STORAGE_LIBRARY: "excalidraw-library";
+    readonly VERSION_DATA_STATE: "version-dataState";
+    readonly VERSION_FILES: "version-files";
+};

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

@@ -7,7 +7,8 @@ import { Gesture } from "../../types";
 import { SocketUpdateDataSource } from "../data";
 import Portal from "./Portal";
 import { UserIdleState } from "../../types";
-import { FileSync } from "../data/FileSync";
+import { FileManager } from "../data/FileManager";
+import React from "react";
 interface CollabState {
     modalIsShown: boolean;
     errorMessage: string;
@@ -26,15 +27,23 @@ export interface CollabAPI {
     onCollabButtonClick: CollabInstance["onCollabButtonClick"];
     broadcastElements: CollabInstance["broadcastElements"];
     fetchImageFilesFromFirebase: CollabInstance["fetchImageFilesFromFirebase"];
+    setUsername: (username: string) => void;
 }
 interface Props {
     excalidrawAPI: ExcalidrawImperativeAPI;
+    onRoomClose?: () => void;
 }
-declare const CollabContext: any, CollabContextConsumer: any;
-export { CollabContext, CollabContextConsumer };
+declare const CollabContext: React.Context<{
+    api: CollabAPI | null;
+}> & {
+    _updateProviderValue?: ((value: {
+        api: CollabAPI | null;
+    }) => void) | undefined;
+};
+export { CollabContext };
 declare class CollabWrapper extends PureComponent<Props, CollabState> {
     portal: Portal;
-    fileSync: FileSync;
+    fileManager: FileManager;
     excalidrawAPI: Props["excalidrawAPI"];
     isCollaborating: boolean;
     activeIntervalId: number | null;
@@ -47,13 +56,14 @@ declare class CollabWrapper extends PureComponent<Props, CollabState> {
     componentWillUnmount(): void;
     private onUnload;
     private beforeUnload;
-    saveCollabRoomToFirebase: (syncableElements?: ExcalidrawElement[]) => Promise<void>;
+    saveCollabRoomToFirebase: (syncableElements?: readonly ExcalidrawElement[]) => Promise<void>;
     openPortal: () => Promise<ImportedDataState | null>;
     closePortal: () => void;
     private destroySocketClient;
     private fetchImageFilesFromFirebase;
+    private decryptPayload;
     private initializeSocketClient;
-    private initializeSocket;
+    private initializeRoom;
     private reconcileElements;
     private loadImageFiles;
     private handleRemoteSceneUpdate;
@@ -66,17 +76,19 @@ declare class CollabWrapper extends PureComponent<Props, CollabState> {
     setLastBroadcastedOrReceivedSceneVersion: (version: number) => void;
     getLastBroadcastedOrReceivedSceneVersion: () => number;
     getSceneElementsIncludingDeleted: () => readonly ExcalidrawElement[];
-    onPointerUpdate: (payload: {
+    onPointerUpdate: import("lodash").DebouncedFunc<(payload: {
         pointer: SocketUpdateDataSource["MOUSE_LOCATION"]["payload"]["pointer"];
         button: SocketUpdateDataSource["MOUSE_LOCATION"]["payload"]["button"];
         pointersMap: Gesture["pointers"];
-    }) => void;
+    }) => void>;
     onIdleStateChange: (userState: UserIdleState) => void;
     broadcastElements: (elements: readonly ExcalidrawElement[]) => void;
     queueBroadcastAllElements: import("lodash").DebouncedFunc<() => void>;
     handleClose: () => void;
+    setUsername: (username: string) => void;
     onUsernameChange: (username: string) => void;
     onCollabButtonClick: () => void;
+    isSyncableElement: (element: ExcalidrawElement) => boolean;
     getSyncableElements: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
     /** PRIVATE. Use `this.getContextValue()` instead. */
     private contextValue;

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

@@ -13,12 +13,12 @@ declare class Portal {
     roomKey: string | null;
     broadcastedElementVersions: Map<string, number>;
     constructor(collab: CollabWrapper);
-    open(socket: SocketIOClient.Socket, id: string, key: string): void;
+    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: (sceneType: SCENE.INIT | SCENE.UPDATE, syncableElements: ExcalidrawElement[], syncAll: boolean) => Promise<void>;
+    broadcastScene: (sceneType: SCENE.INIT | SCENE.UPDATE, allElements: readonly ExcalidrawElement[], syncAll: boolean) => Promise<void>;
     broadcastIdleChange: (userState: UserIdleState) => Promise<void> | undefined;
     broadcastMouseLocation: (payload: {
         pointer: SocketUpdateDataSource["MOUSE_LOCATION"]["payload"]["pointer"];

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

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

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/firebase.d.ts

@@ -1,22 +1,22 @@
 /// <reference types="socket.io-client" />
-import { ExcalidrawElement, ImageId } from "../../element/types";
+import { ExcalidrawElement, FileId } from "../../element/types";
 import Portal from "../collab/Portal";
-import { BinaryFileData, DataURL } from "../../types";
+import { BinaryFileData } from "../../types";
 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, encryptionKey, files, allowedTypes, maxBytes, }: {
+export declare const saveFilesToFirebase: ({ prefix, files, }: {
     prefix: string;
-    encryptionKey: string;
-    files: Map<ImageId, DataURL>;
-    allowedTypes: string[];
-    maxBytes: number;
+    files: {
+        id: FileId;
+        buffer: Uint8Array;
+    }[];
 }) => Promise<{
-    savedFiles: Map<ImageId, true>;
-    erroredFiles: Map<ImageId, true>;
+    savedFiles: Map<FileId, true>;
+    erroredFiles: Map<FileId, true>;
 }>;
 export declare const saveToFirebase: (portal: Portal, elements: readonly ExcalidrawElement[]) => Promise<boolean>;
 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 ImageId[]) => Promise<{
+export declare const loadFilesFromFirebase: (prefix: string, decryptionKey: string, filesIds: readonly FileId[]) => Promise<{
     loadedFiles: BinaryFileData[];
-    erroredFiles: ImageId[];
+    erroredFiles: Map<FileId, true>;
 }>;

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

@@ -1,8 +1,17 @@
 import { ImportedDataState } from "../../data/types";
 import { ExcalidrawElement } from "../../element/types";
-import { AppState, UserIdleState } from "../../types";
-export declare const generateEncryptionKey: () => Promise<string | undefined>;
-export declare const SOCKET_SERVER: string;
+import { AppState, BinaryFiles, UserIdleState } from "../../types";
+/**
+ * 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;
@@ -48,9 +57,6 @@ export declare type SocketUpdateDataIncoming = SocketUpdateDataSource[keyof Sock
 export declare type SocketUpdateData = SocketUpdateDataSource[keyof SocketUpdateDataSource] & {
     _brand: "socketUpdateData";
 };
-export declare const createIV: () => Uint8Array;
-export declare const encryptAESGEM: (data: Uint8Array, key: string) => Promise<EncryptedData>;
-export declare const decryptAESGEM: (data: ArrayBuffer, key: string, iv: Uint8Array) => Promise<SocketUpdateDataIncoming>;
 export declare const getCollaborationLinkData: (link: string) => {
     roomId: string;
     roomKey: string;
@@ -63,22 +69,19 @@ export declare const getCollaborationLink: (data: {
     roomId: string;
     roomKey: string;
 }) => string;
-export declare const getImportedKey: (key: string, usage: KeyUsage) => Promise<CryptoKey>;
-export declare const decryptImported: (iv: ArrayBuffer, encrypted: ArrayBuffer, privateKey: string) => Promise<ArrayBuffer>;
 export declare const loadScene: (id: string | null, privateKey: string | null, localDataState: ImportedDataState | undefined | null) => Promise<{
     elements: ExcalidrawElement[];
     appState: {
-        theme: "light" | "dark";
+        elementType: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | "eraser";
+        scrollX: number;
+        scrollY: number;
+        viewBackgroundColor: string;
         zoom: Readonly<{
             value: import("../../types").NormalizedZoomValue;
-            translation: Readonly<{
-                x: number;
-                y: number;
-            }>;
         }>;
-        scrollX: number;
-        scrollY: number;
-        files: Record<string, import("../../types").BinaryFileData>;
+        shouldCacheIgnoreZoom: boolean;
+        theme: string;
+        name: string;
         isLoading: boolean;
         errorMessage: string | null;
         draggingElement: import("../../element/types").NonDeletedExcalidrawElement | null;
@@ -90,8 +93,9 @@ export declare const loadScene: (id: string | null, privateKey: string | null, l
         suggestedBindings: import("../../element/binding").SuggestedBinding[];
         editingElement: import("../../element/types").NonDeletedExcalidrawElement | null;
         editingLinearElement: import("../../element/linearElementEditor").LinearElementEditor | null;
-        elementType: "line" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "text" | "arrow" | "freedraw";
         elementLocked: boolean;
+        penMode: boolean;
+        penDetected: boolean;
         exportBackground: boolean;
         exportEmbedScene: boolean;
         exportWithDarkMode: boolean;
@@ -110,10 +114,8 @@ export declare const loadScene: (id: string | null, privateKey: string | null, l
         currentItemStartArrowhead: import("../../element/types").Arrowhead | null;
         currentItemEndArrowhead: import("../../element/types").Arrowhead | null;
         currentItemLinearStrokeSharpness: import("../../element/types").StrokeSharpness;
-        viewBackgroundColor: string;
         cursorButton: "up" | "down";
         scrolledOutside: boolean;
-        name: string;
         isResizing: boolean;
         isRotating: boolean;
         openMenu: "canvas" | "shape" | null;
@@ -125,7 +127,6 @@ export declare const loadScene: (id: string | null, privateKey: string | null, l
         previousSelectedElementIds: {
             [id: string]: boolean;
         };
-        shouldCacheIgnoreZoom: boolean;
         showHelpDialog: boolean;
         toastMessage: string | null;
         zenModeEnabled: boolean;
@@ -136,7 +137,7 @@ export declare const loadScene: (id: string | null, privateKey: string | null, l
         };
         editingGroupId: string | null;
         isLibraryOpen: boolean;
-        fileHandle: import("@dwelle/browser-fs-access").FileSystemHandle | null;
+        fileHandle: import("browser-fs-access").FileSystemHandle | null;
         collaborators: Map<string, import("../../types").Collaborator>;
         showStats: boolean;
         currentChartType: import("../../element/types").ChartType;
@@ -148,12 +149,16 @@ export declare const loadScene: (id: string | null, privateKey: string | null, l
             data: import("../../charts").Spreadsheet;
         };
         pendingImageElement: import("../../element/types").NonDeleted<import("../../element/types").ExcalidrawImageElement> | null;
+        showHyperlinkPopup: false | "info" | "editor";
+        linkOpacity: number;
+        trayModeEnabled: boolean;
+        colorPalette: {
+            canvasBackground?: string[] | undefined;
+            elementBackground?: string[] | undefined;
+            elementStroke?: string[] | undefined;
+        };
     };
+    files: BinaryFiles;
     commitToHistory: boolean;
 }>;
-export declare const exportToBackend: (elements: readonly ExcalidrawElement[], appState: AppState) => Promise<void>;
-export declare const encryptData: (key: string, data: Uint8Array | Blob | File | string) => Promise<{
-    encryptedBuffer: ArrayBuffer;
-    iv: Uint8Array;
-}>;
-export declare const decryptData: (iv: ArrayBuffer, encrypted: ArrayBuffer, privateKey: string) => Promise<ArrayBuffer>;
+export declare const exportToBackend: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles) => Promise<void>;