@zsviczian/excalidraw 0.9.0-obsidian-11 → 0.9.0-obsidian-image-support-4

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

@@ -0,0 +1,92 @@
+/// <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 } from "../data";
+import Portal from "./Portal";
+import { UserIdleState } from "../../types";
+import { FileSync } from "../data/FileSync";
+interface CollabState {
+    modalIsShown: boolean;
+    errorMessage: string;
+    username: string;
+    userState: UserIdleState;
+    activeRoomLink: string;
+}
+declare type CollabInstance = InstanceType<typeof CollabWrapper>;
+export interface CollabAPI {
+    /** function so that we can access the latest value from stale callbacks */
+    isCollaborating: () => boolean;
+    username: CollabState["username"];
+    userState: CollabState["userState"];
+    onPointerUpdate: CollabInstance["onPointerUpdate"];
+    initializeSocketClient: CollabInstance["initializeSocketClient"];
+    onCollabButtonClick: CollabInstance["onCollabButtonClick"];
+    broadcastElements: CollabInstance["broadcastElements"];
+    fetchImageFilesFromFirebase: CollabInstance["fetchImageFilesFromFirebase"];
+}
+interface Props {
+    excalidrawAPI: ExcalidrawImperativeAPI;
+}
+declare const CollabContext: any, CollabContextConsumer: any;
+export { CollabContext, CollabContextConsumer };
+declare class CollabWrapper extends PureComponent<Props, CollabState> {
+    portal: Portal;
+    fileSync: FileSync;
+    excalidrawAPI: Props["excalidrawAPI"];
+    isCollaborating: boolean;
+    activeIntervalId: number | null;
+    idleTimeoutId: number | null;
+    private socketInitializationTimer?;
+    private lastBroadcastedOrReceivedSceneVersion;
+    private collaborators;
+    constructor(props: Props);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private onUnload;
+    private beforeUnload;
+    saveCollabRoomToFirebase: (syncableElements?: ExcalidrawElement[]) => Promise<void>;
+    openPortal: () => Promise<ImportedDataState | null>;
+    closePortal: () => void;
+    private destroySocketClient;
+    private fetchImageFilesFromFirebase;
+    private initializeSocketClient;
+    private initializeSocket;
+    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: (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;
+    queueBroadcastAllElements: import("lodash").DebouncedFunc<() => void>;
+    handleClose: () => void;
+    onUsernameChange: (username: string) => void;
+    onCollabButtonClick: () => void;
+    getSyncableElements: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+    /** PRIVATE. Use `this.getContextValue()` instead. */
+    private contextValue;
+    /** Getter of context value. Returned object is stable. */
+    getContextValue: () => CollabAPI;
+    render(): JSX.Element;
+}
+declare global {
+    interface Window {
+        collab: InstanceType<typeof CollabWrapper>;
+    }
+}
+export default CollabWrapper;

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 CollabWrapper from "./CollabWrapper";
+import { ExcalidrawElement } from "../../element/types";
+import { SCENE } from "../app_constants";
+import { UserIdleState } from "../../types";
+declare class Portal {
+    collab: CollabWrapper;
+    socket: SocketIOClient.Socket | null;
+    socketInitialized: boolean;
+    roomId: string | null;
+    roomKey: string | null;
+    broadcastedElementVersions: Map<string, number>;
+    constructor(collab: CollabWrapper);
+    open(socket: SocketIOClient.Socket, id: string, key: string): void;
+    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>;
+    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,14 @@
+/// <reference types="react" />
+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/data/FileSync.d.ts

@@ -0,0 +1,39 @@
+import { ExcalidrawElement, ImageId } from "../../element/types";
+import { AppState, BinaryFileData, DataURL } from "../../types";
+export declare class FileSync {
+    /** files marked for uploading or fetching, and thus neither operation should
+     *  be performed on them until finished */
+    pendingFiles: Map<ImageId | null, true>;
+    savedFiles: Map<ImageId | null, true>;
+    private _getFiles;
+    private _saveFiles;
+    constructor({ getFiles, saveFiles, }: {
+        getFiles: (imageIds: ImageId[]) => Promise<{
+            loadedFiles: BinaryFileData[];
+            erroredFiles: ImageId[];
+        }>;
+        saveFiles: (data: {
+            addedFiles: Map<ImageId, DataURL>;
+            removedFiles: Map<ImageId, true>;
+        }) => Promise<{
+            savedFiles: Map<ImageId, true>;
+            erroredFiles: Map<ImageId, true>;
+        }>;
+    });
+    saveFiles: ({ elements, appState, }: {
+        elements: readonly ExcalidrawElement[];
+        appState: Pick<AppState, "files">;
+    }) => Promise<{
+        savedFiles: Map<ImageId, true>;
+        erroredFiles: Map<ImageId, true>;
+    }>;
+    /**
+     * returns whether file is already saved or being processed
+     */
+    isFileHandled: (id: ImageId) => boolean;
+    getFiles: (ids: ImageId[]) => Promise<{
+        loadedFiles: BinaryFileData[];
+        erroredFiles: ImageId[];
+    }>;
+    destroy(): void;
+}

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

@@ -0,0 +1,22 @@
+/// <reference types="socket.io-client" />
+import { ExcalidrawElement, ImageId } from "../../element/types";
+import Portal from "../collab/Portal";
+import { BinaryFileData, DataURL } 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, decryptionKey, files, allowedTypes, maxBytes, }: {
+    prefix: string;
+    decryptionKey: string;
+    files: Map<ImageId, DataURL>;
+    allowedTypes: string[];
+    maxBytes: number;
+}) => Promise<{
+    savedFiles: Map<ImageId, true>;
+    erroredFiles: Map<ImageId, 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<{
+    loadedFiles: BinaryFileData[];
+    erroredFiles: ImageId[];
+}>;

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

@@ -0,0 +1,161 @@
+import { ImportedDataState } from "../../data/types";
+import { ExcalidrawElement } from "../../element/types";
+import { AppState, DataURL, UserIdleState } from "../../types";
+export declare const generateEncryptionKey: () => Promise<string | undefined>;
+export declare const SOCKET_SERVER: string;
+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 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;
+} | null;
+export declare const generateCollaborationLinkData: () => Promise<{
+    roomId: string;
+    roomKey: string;
+}>;
+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";
+        zoom: Readonly<{
+            value: import("../../types").NormalizedZoomValue;
+            translation: Readonly<{
+                x: number;
+                y: number;
+            }>;
+        }>;
+        scrollX: number;
+        scrollY: number;
+        files: Record<string, import("../../types").BinaryFileData>;
+        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;
+        elementType: "line" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "text" | "arrow" | "freedraw";
+        elementLocked: 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: import("../../element/types").TextAlign;
+        currentItemStrokeSharpness: import("../../element/types").StrokeSharpness;
+        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;
+        openPopup: "canvasColorPicker" | "backgroundColorPicker" | "strokeColorPicker" | null;
+        lastPointerDownWith: import("../../element/types").PointerType;
+        selectedElementIds: {
+            [id: string]: boolean;
+        };
+        previousSelectedElementIds: {
+            [id: string]: boolean;
+        };
+        shouldCacheIgnoreZoom: boolean;
+        showHelpDialog: boolean;
+        toastMessage: string | null;
+        zenModeEnabled: boolean;
+        gridSize: number | null;
+        viewModeEnabled: boolean;
+        selectedGroupIds: {
+            [groupId: string]: boolean;
+        };
+        editingGroupId: string | null;
+        isLibraryOpen: boolean;
+        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;
+        };
+        pendingImageElement: import("../../element/types").NonDeleted<import("../../element/types").ExcalidrawImageElement> | null;
+    };
+    commitToHistory: boolean;
+}>;
+export declare const exportToBackend: (elements: readonly ExcalidrawElement[], appState: AppState) => Promise<void>;
+export declare const dataURLToBlob: (dataURL: DataURL) => Blob;
+export declare const arrayBufferToDataURL: (buffer: ArrayBuffer, mimeType: string) => Promise<DataURL>;
+export declare const encryptData: (key: string, data: Blob | string) => Promise<{
+    blob: Blob;
+    iv: Uint8Array;
+}>;
+export declare const getDataURL: (file: File) => Promise<DataURL>;

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

@@ -0,0 +1,98 @@
+import { ExcalidrawElement } from "../../element/types";
+import { AppState } from "../../types";
+export declare const STORAGE_KEYS: {
+    LOCAL_STORAGE_ELEMENTS: string;
+    LOCAL_STORAGE_APP_STATE: string;
+    LOCAL_STORAGE_COLLAB: string;
+    LOCAL_STORAGE_KEY_COLLAB_FORCE_FLAG: string;
+};
+export declare const saveUsernameToLocalStorage: (username: string) => void;
+export declare const importUsernameFromLocalStorage: () => string | null;
+export declare const saveToLocalStorage: (elements: readonly ExcalidrawElement[], appState: AppState) => void;
+export declare const importFromLocalStorage: () => {
+    elements: ExcalidrawElement[];
+    appState: {
+        theme: "light" | "dark";
+        zoom: Readonly<{
+            value: import("../../types").NormalizedZoomValue;
+            translation: Readonly<{
+                x: number;
+                y: number;
+            }>;
+        }>;
+        scrollX: number;
+        scrollY: number;
+        elementType: "line" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "text" | "arrow" | "freedraw";
+        elementLocked: 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: import("../../element/types").TextAlign;
+        currentItemStrokeSharpness: import("../../element/types").StrokeSharpness;
+        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;
+        openMenu: "canvas" | "shape" | null;
+        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;
+        files: Record<string, import("../../types").BinaryFileData>;
+        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;
+        showHelpDialog: boolean;
+        toastMessage: string | null;
+        viewModeEnabled: boolean;
+        isLibraryOpen: 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;
+        };
+        pendingImageElement: import("../../element/types").NonDeleted<import("../../element/types").ExcalidrawImageElement> | null;
+    } | null;
+};
+export declare const getElementsStorageSize: () => number;
+export declare const getTotalStorageSize: () => number;

package/types/keys.d.ts

@@ -42,6 +42,7 @@ export declare const KEYS: {
     readonly D: "d";
     readonly E: "e";
     readonly G: "g";
+    readonly I: "i";
     readonly L: "l";
     readonly O: "o";
     readonly P: "p";
@@ -56,6 +57,6 @@ export declare const KEYS: {
 };
 export declare type Key = keyof typeof KEYS;
 export declare const isArrowKey: (key: string) => boolean;
-export declare const getResizeCenterPointKey: (event: MouseEvent | KeyboardEvent) => boolean;
-export declare const getResizeWithSidesSameLengthKey: (event: MouseEvent | KeyboardEvent) => boolean;
-export declare const getRotateWithDiscreteAngleKey: (event: MouseEvent | KeyboardEvent) => boolean;
+export declare const shouldResizeFromCenter: (event: MouseEvent | KeyboardEvent) => boolean;
+export declare const shouldMaintainAspectRatio: (event: MouseEvent | KeyboardEvent) => boolean;
+export declare const shouldRotateWithDiscreteAngle: (event: MouseEvent | KeyboardEvent) => boolean;

package/types/packages/utils.d.ts

@@ -9,7 +9,7 @@ declare type ExportOpts = {
         scale: number;
     };
 };
-export declare const exportToCanvas: ({ elements, appState, getDimensions, }: ExportOpts) => HTMLCanvasElement;
+export declare const exportToCanvas: ({ elements, appState, getDimensions, }: ExportOpts) => Promise<HTMLCanvasElement>;
 export declare const exportToBlob: (opts: ExportOpts & {
     mimeType?: string;
     quality?: number;

package/types/renderer/renderElement.d.ts

@@ -3,10 +3,11 @@ import { RoughCanvas } from "roughjs/bin/canvas";
 import { Drawable, Options } from "roughjs/bin/core";
 import { RoughSVG } from "roughjs/bin/svg";
 import { SceneState } from "../scene/types";
-import { Zoom } from "../types";
+import { AppState, Zoom } from "../types";
 export interface ExcalidrawElementWithCanvas {
     element: ExcalidrawElement | ExcalidrawTextElement;
     canvas: HTMLCanvasElement;
+    theme: SceneState["theme"];
     canvasZoom: Zoom["value"];
     canvasOffsetX: number;
     canvasOffsetY: number;
@@ -15,7 +16,7 @@ export declare const getShapeForElement: (element: ExcalidrawElement) => Drawabl
 export declare const invalidateShapeForElement: (element: ExcalidrawElement) => boolean;
 export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean) => Options;
 export declare const renderElement: (element: NonDeletedExcalidrawElement, rc: RoughCanvas, context: CanvasRenderingContext2D, renderOptimizations: boolean, sceneState: SceneState) => void;
-export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, rsvg: RoughSVG, svgRoot: SVGElement, offsetX?: number | undefined, offsetY?: number | undefined) => void;
+export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, rsvg: RoughSVG, svgRoot: SVGElement, files: AppState["files"], offsetX?: number | undefined, offsetY?: number | undefined) => void;
 export declare const pathsCache: WeakMap<ExcalidrawFreeDrawElement, Path2D>;
 export declare function generateFreeDrawShape(element: ExcalidrawFreeDrawElement): Path2D;
 export declare function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement): Path2D | undefined;

package/types/renderer/renderScene.d.ts

@@ -3,11 +3,12 @@ import { RoughSVG } from "roughjs/bin/svg";
 import { AppState } from "../types";
 import { NonDeletedExcalidrawElement } from "../element/types";
 import { SceneState } from "../scene/types";
-export declare const renderScene: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, selectionElement: NonDeletedExcalidrawElement | null, scale: number, rc: RoughCanvas, canvas: HTMLCanvasElement, sceneState: SceneState, { renderScrollbars, renderSelection, renderOptimizations, renderGrid, }?: {
+export declare const renderScene: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, selectionElement: NonDeletedExcalidrawElement | null, scale: number, rc: RoughCanvas, canvas: HTMLCanvasElement, sceneState: SceneState, { renderScrollbars, renderSelection, renderOptimizations, renderGrid, isExport, }?: {
     renderScrollbars?: boolean | undefined;
     renderSelection?: boolean | undefined;
     renderOptimizations?: boolean | undefined;
     renderGrid?: boolean | undefined;
+    isExport?: boolean | undefined;
 }) => {
     atLeastOneVisibleElement: boolean;
     scrollBars?: undefined;
@@ -15,7 +16,7 @@ export declare const renderScene: (elements: readonly NonDeletedExcalidrawElemen
     atLeastOneVisibleElement: boolean;
     scrollBars: import("../scene/types").ScrollBars | undefined;
 };
-export declare const renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], rsvg: RoughSVG, svgRoot: SVGElement, { offsetX, offsetY, }?: {
+export declare const renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], rsvg: RoughSVG, svgRoot: SVGElement, files: AppState["files"], { offsetX, offsetY, }?: {
     offsetX?: number | undefined;
     offsetY?: number | undefined;
 }) => void;

package/types/scene/export.d.ts

@@ -8,7 +8,7 @@ export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawEle
 }, createCanvas?: (width: number, height: number) => {
     canvas: HTMLCanvasElement;
     scale: number;
-}) => HTMLCanvasElement;
+}) => Promise<HTMLCanvasElement>;
 export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElement[], appState: {
     exportBackground: boolean;
     exportPadding?: number;
@@ -16,5 +16,6 @@ export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElemen
     viewBackgroundColor: string;
     exportWithDarkMode?: boolean;
     exportEmbedScene?: boolean;
+    files: AppState["files"];
 }) => Promise<SVGSVGElement>;
 export declare const getExportSize: (elements: readonly NonDeletedExcalidrawElement[], exportPadding: number, scale: number) => [number, number];

package/types/scene/types.d.ts

@@ -1,10 +1,9 @@
-import { ExcalidrawTextElement } from "../element/types";
-import { Zoom } from "../types";
+import { ExcalidrawTextElement, ImageId } from "../element/types";
+import { AppState, Zoom } from "../types";
 export declare type SceneState = {
     scrollX: number;
     scrollY: number;
     viewBackgroundColor: string | null;
-    exportWithDarkMode?: boolean;
     zoom: Zoom;
     shouldCacheIgnoreZoom: boolean;
     remotePointerViewportCoords: {
@@ -25,6 +24,8 @@ export declare type SceneState = {
     remotePointerUserStates: {
         [id: string]: string;
     };
+    theme: AppState["theme"];
+    imageCache: Map<ImageId, HTMLImageElement>;
 };
 export declare type SceneScroll = {
     scrollX: number;

package/types/shapes.d.ts

@@ -31,5 +31,9 @@ export declare const SHAPES: readonly [{
     readonly icon: JSX.Element;
     readonly value: "text";
     readonly key: "t";
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "image";
+    readonly key: "i";
 }];
-export declare const findShapeByKey: (key: string) => "line" | "selection" | "rectangle" | "diamond" | "ellipse" | "text" | "arrow" | "freedraw" | null;
+export declare const findShapeByKey: (key: string) => "line" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "text" | "arrow" | "freedraw" | null;