@excalidraw/excalidraw 0.13.0-f5379d1 → 0.14.0

package/types/element/transformHandles.d.ts

@@ -1,5 +1,4 @@
 import { ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
-import { Bounds } from "./bounds";
 import { AppState, Zoom } from "../types";
 export declare type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
 export declare type TransformHandleType = TransformHandleDirection | "rotation";
@@ -14,11 +13,11 @@ export declare const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS: {
     n: boolean;
     w: boolean;
 };
-export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2]: Bounds, angle: number, zoom: Zoom, pointerType: PointerType, omitSides?: {
-    e?: boolean | undefined;
+export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [number, number, number, number, number, number], angle: number, zoom: Zoom, pointerType: PointerType, omitSides?: {
     s?: boolean | undefined;
-    w?: boolean | undefined;
+    e?: boolean | undefined;
     n?: boolean | undefined;
+    w?: boolean | undefined;
     nw?: boolean | undefined;
     ne?: boolean | undefined;
     sw?: boolean | undefined;

package/types/element/typeChecks.d.ts

@@ -1,5 +1,5 @@
 import { AppState } from "../types";
-import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer } from "./types";
+import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, RoundnessType } from "./types";
 export declare const isGenericElement: (element: ExcalidrawElement | null) => element is ExcalidrawGenericElement;
 export declare const isInitializedImageElement: (element: ExcalidrawElement | null) => element is InitializedExcalidrawImageElement;
 export declare const isImageElement: (element: ExcalidrawElement | null) => element is ExcalidrawImageElement;
@@ -7,6 +7,7 @@ export declare const isTextElement: (element: ExcalidrawElement | null) => eleme
 export declare const isFreeDrawElement: (element?: ExcalidrawElement | null) => element is ExcalidrawFreeDrawElement;
 export declare const isFreeDrawElementType: (elementType: ExcalidrawElement["type"]) => boolean;
 export declare const isLinearElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
+export declare const isArrowElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
 export declare const isLinearElementType: (elementType: AppState["activeTool"]["type"]) => boolean;
 export declare const isBindingElement: (element?: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawLinearElement;
 export declare const isBindingElementType: (elementType: AppState["activeTool"]["type"]) => boolean;
@@ -15,3 +16,11 @@ export declare const isTextBindableContainer: (element: ExcalidrawElement | null
 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;
+export declare const isUsingAdaptiveRadius: (type: string) => boolean;
+export declare const isUsingProportionalRadius: (type: string) => boolean;
+export declare const canApplyRoundnessTypeToElement: (roundnessType: RoundnessType, element: ExcalidrawElement) => boolean;
+export declare const getDefaultRoundnessTypeForElement: (element: ExcalidrawElement) => {
+    type: 2;
+} | {
+    type: 3;
+} | null;

package/types/element/types.d.ts

@@ -1,5 +1,5 @@
 import { Point } from "../types";
-import { FONT_FAMILY, TEXT_ALIGN, THEME, VERTICAL_ALIGN } from "../constants";
+import { FONT_FAMILY, ROUNDNESS, TEXT_ALIGN, THEME, VERTICAL_ALIGN } from "../constants";
 export declare type ChartType = "bar" | "line";
 export declare type FillStyle = "hachure" | "cross-hatch" | "solid";
 export declare type FontFamilyKeys = keyof typeof FONT_FAMILY;
@@ -10,7 +10,8 @@ export declare type FontString = string & {
 };
 export declare type GroupId = string;
 export declare type PointerType = "mouse" | "pen" | "touch";
-export declare type StrokeSharpness = "round" | "sharp";
+export declare type StrokeRoundness = "round" | "sharp";
+export declare type RoundnessType = ValueOf<typeof ROUNDNESS>;
 export declare type StrokeStyle = "solid" | "dashed" | "dotted";
 export declare type TextAlign = typeof TEXT_ALIGN[keyof typeof TEXT_ALIGN];
 declare type VerticalAlignKeys = keyof typeof VERTICAL_ALIGN;
@@ -24,7 +25,10 @@ declare type _ExcalidrawElementBase = Readonly<{
     fillStyle: FillStyle;
     strokeWidth: number;
     strokeStyle: StrokeStyle;
-    strokeSharpness: StrokeSharpness;
+    roundness: null | {
+        type: RoundnessType;
+        value?: number;
+    };
     roughness: number;
     opacity: number;
     width: number;
@@ -102,7 +106,7 @@ export declare type ExcalidrawTextElement = _ExcalidrawElementBase & Readonly<{
     originalText: string;
 }>;
 export declare type ExcalidrawBindableElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawTextElement | ExcalidrawImageElement;
-export declare type ExcalidrawTextContainer = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawImageElement;
+export declare type ExcalidrawTextContainer = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawImageElement | ExcalidrawArrowElement;
 export declare type ExcalidrawTextElementWithContainer = {
     containerId: ExcalidrawTextContainer["id"];
 } & ExcalidrawTextElement;
@@ -121,6 +125,9 @@ export declare type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<
     startArrowhead: Arrowhead | null;
     endArrowhead: Arrowhead | null;
 }>;
+export declare type ExcalidrawArrowElement = ExcalidrawLinearElement & Readonly<{
+    type: "arrow";
+}>;
 export declare type ExcalidrawFreeDrawElement = _ExcalidrawElementBase & Readonly<{
     type: "freedraw";
     points: readonly Point[];

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

@@ -0,0 +1,9 @@
+import { AppState } from "../types";
+import { NonDeletedExcalidrawElement } from "../element/types";
+declare type Props = {
+    setToast: (message: string) => void;
+    elements: readonly NonDeletedExcalidrawElement[];
+    appState: AppState;
+};
+declare const CustomStats: (props: Props) => JSX.Element;
+export default CustomStats;

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

@@ -0,0 +1,32 @@
+export declare const SAVE_TO_LOCAL_STORAGE_TIMEOUT = 300;
+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 DELETED_ELEMENT_TIMEOUT: number;
+export declare const FILE_UPLOAD_MAX_BYTES: number;
+export declare const FILE_CACHE_MAX_AGE_SEC = 31536000;
+export declare const WS_EVENTS: {
+    SERVER_VOLATILE: string;
+    SERVER: string;
+};
+export declare enum WS_SCENE_EVENT_TYPES {
+    INIT = "SCENE_INIT",
+    UPDATE = "SCENE_UPDATE"
+}
+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_LIBRARY: "excalidraw-library";
+    readonly LOCAL_STORAGE_THEME: "excalidraw-theme";
+    readonly VERSION_DATA_STATE: "version-dataState";
+    readonly VERSION_FILES: "version-files";
+};

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

@@ -0,0 +1,163 @@
+/// <reference types="lodash" />
+import { PureComponent } from "react";
+import { ExcalidrawImperativeAPI } from "../../types";
+import { ImportedDataState } from "../../data/types";
+import { ExcalidrawElement } from "../../element/types";
+import { Gesture } from "../../types";
+import { SocketUpdateDataSource, SyncableExcalidrawElement } from "../data";
+import Portal from "./Portal";
+import { UserIdleState } from "../../types";
+import { FileManager } from "../data/FileManager";
+export declare const collabAPIAtom: import("jotai").Atom<CollabAPI | null> & {
+    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: CollabAPI | ((prev: CollabAPI | null) => CollabAPI | null) | null) => void;
+    onMount?: (<S extends (update: CollabAPI | ((prev: CollabAPI | null) => CollabAPI | null) | null) => void>(setAtom: S) => void | (() => void)) | undefined;
+} & {
+    init: CollabAPI | null;
+};
+export declare const collabDialogShownAtom: import("jotai").Atom<boolean> & {
+    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: boolean | ((prev: boolean) => boolean)) => void;
+    onMount?: (<S extends (update: boolean | ((prev: boolean) => boolean)) => void>(setAtom: S) => void | (() => void)) | undefined;
+} & {
+    init: boolean;
+};
+export declare const isCollaboratingAtom: import("jotai").Atom<boolean> & {
+    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: boolean | ((prev: boolean) => boolean)) => void;
+    onMount?: (<S extends (update: boolean | ((prev: boolean) => boolean)) => void>(setAtom: S) => void | (() => void)) | undefined;
+} & {
+    init: boolean;
+};
+interface CollabState {
+    errorMessage: string;
+    username: string;
+    activeRoomLink: string;
+}
+declare type CollabInstance = InstanceType<typeof Collab>;
+export interface CollabAPI {
+    /** function so that we can access the latest value from stale callbacks */
+    isCollaborating: () => boolean;
+    onPointerUpdate: CollabInstance["onPointerUpdate"];
+    startCollaboration: CollabInstance["startCollaboration"];
+    stopCollaboration: CollabInstance["stopCollaboration"];
+    syncElements: CollabInstance["syncElements"];
+    fetchImageFilesFromFirebase: CollabInstance["fetchImageFilesFromFirebase"];
+    setUsername: (username: string) => void;
+}
+interface PublicProps {
+    excalidrawAPI: ExcalidrawImperativeAPI;
+}
+declare type Props = PublicProps & {
+    modalIsShown: boolean;
+};
+declare class Collab extends PureComponent<Props, CollabState> {
+    portal: Portal;
+    fileManager: FileManager;
+    excalidrawAPI: Props["excalidrawAPI"];
+    activeIntervalId: number | null;
+    idleTimeoutId: number | null;
+    private socketInitializationTimer?;
+    private lastBroadcastedOrReceivedSceneVersion;
+    private collaborators;
+    constructor(props: Props);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    isCollaborating: () => boolean;
+    private setIsCollaborating;
+    private onUnload;
+    private beforeUnload;
+    saveCollabRoomToFirebase: (syncableElements: readonly SyncableExcalidrawElement[]) => Promise<void>;
+    stopCollaboration: (keepRemoteState?: boolean) => void;
+    private destroySocketClient;
+    private fetchImageFilesFromFirebase;
+    private decryptPayload;
+    private fallbackInitializationHandler;
+    startCollaboration: (existingRoomLinkData: null | {
+        roomId: string;
+        roomKey: string;
+    }) => Promise<ImportedDataState | null>;
+    private initializeRoom;
+    private reconcileElements;
+    private loadImageFiles;
+    private handleRemoteSceneUpdate;
+    private onPointerMove;
+    private onVisibilityChange;
+    private reportIdle;
+    private reportActive;
+    private initializeIdleDetector;
+    setCollaborators(sockets: string[]): void;
+    setLastBroadcastedOrReceivedSceneVersion: (version: number) => void;
+    getLastBroadcastedOrReceivedSceneVersion: () => number;
+    getSceneElementsIncludingDeleted: () => readonly ExcalidrawElement[];
+    onPointerUpdate: import("lodash").DebouncedFunc<(payload: {
+        pointer: SocketUpdateDataSource["MOUSE_LOCATION"]["payload"]["pointer"];
+        button: SocketUpdateDataSource["MOUSE_LOCATION"]["payload"]["button"];
+        pointersMap: Gesture["pointers"];
+    }) => void>;
+    onIdleStateChange: (userState: UserIdleState) => void;
+    broadcastElements: (elements: readonly ExcalidrawElement[]) => void;
+    syncElements: (elements: readonly ExcalidrawElement[]) => void;
+    queueBroadcastAllElements: import("lodash").DebouncedFunc<() => void>;
+    queueSaveToFirebase: import("lodash").DebouncedFunc<() => void>;
+    handleClose: () => void;
+    setUsername: (username: string) => void;
+    onUsernameChange: (username: string) => void;
+    render(): JSX.Element;
+}
+declare global {
+    interface Window {
+        collab: InstanceType<typeof Collab>;
+    }
+}
+declare const _Collab: React.FC<PublicProps>;
+export default _Collab;
+export declare type TCollabClass = Collab;

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

@@ -0,0 +1 @@
+export declare const EncryptedIcon: () => JSX.Element;

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

@@ -0,0 +1 @@
+export declare const ExcalidrawPlusAppLink: () => JSX.Element | null;

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>;
+}>;