@excalidraw/excalidraw 0.16.1-6920-3a6028b → 0.16.1-7248-caa89f0

package/types/components/MobileMenu.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { AppClassProperties, AppState, Device, ExcalidrawProps, UIAppState } from "../types";
+import { AppClassProperties, AppProps, AppState, Device, ExcalidrawProps, UIAppState } from "../types";
 import { ActionManager } from "../actions/manager";
 import { NonDeletedExcalidrawElement } from "../element/types";
 type MobileMenuProps = {
@@ -11,13 +11,14 @@ type MobileMenuProps = {
     elements: readonly NonDeletedExcalidrawElement[];
     onLockToggle: () => void;
     onHandToolToggle: () => void;
-    onPenModeToggle: () => void;
+    onPenModeToggle: AppClassProperties["togglePenMode"];
     renderTopRightUI?: (isMobile: boolean, appState: UIAppState) => JSX.Element | null;
     renderCustomStats?: ExcalidrawProps["renderCustomStats"];
     renderSidebars: () => JSX.Element | null;
     device: Device;
     renderWelcomeScreen: boolean;
+    UIOptions: AppProps["UIOptions"];
     app: AppClassProperties;
 };
-export declare const MobileMenu: ({ appState, elements, actionManager, setAppState, onLockToggle, onHandToolToggle, onPenModeToggle, renderTopRightUI, renderCustomStats, renderSidebars, device, renderWelcomeScreen, app, }: MobileMenuProps) => JSX.Element;
+export declare const MobileMenu: ({ appState, elements, actionManager, setAppState, onLockToggle, onHandToolToggle, onPenModeToggle, renderTopRightUI, renderCustomStats, renderSidebars, device, renderWelcomeScreen, UIOptions, app, }: MobileMenuProps) => JSX.Element;
 export {};

package/types/constants.d.ts

@@ -84,6 +84,7 @@ export declare const FONT_FAMILY: {
     Virgil: number;
     Helvetica: number;
     Cascadia: number;
+    Assistant: number;
 };
 export declare const THEME: {
     readonly LIGHT: "light";
@@ -101,6 +102,11 @@ export declare const FRAME_STYLE: {
     } | null;
     backgroundColor: string;
     radius: number;
+    nameOffsetY: number;
+    nameColorLightTheme: string;
+    nameColorDarkTheme: string;
+    nameFontSize: number;
+    nameLineHeight: number;
 };
 export declare const WINDOWS_EMOJI_FALLBACK_FONT = "Segoe UI Emoji";
 export declare const MIN_FONT_SIZE = 1;
@@ -122,6 +128,7 @@ export declare const IMAGE_MIME_TYPES: {
     readonly avif: "image/avif";
     readonly jfif: "image/jfif";
 };
+export declare const ALLOWED_PASTE_MIME_TYPES: readonly ["text/plain", "text/html"];
 export declare const MIME_TYPES: {
     readonly svg: "image/svg+xml";
     readonly png: "image/png";
@@ -170,7 +177,6 @@ export declare const URL_HASH_KEYS: {
     readonly addLibrary: "addLibrary";
 };
 export declare const DEFAULT_UI_OPTIONS: AppProps["UIOptions"];
-export declare const MQ_SM_MAX_WIDTH = 640;
 export declare const MQ_MAX_WIDTH_PORTRAIT = 730;
 export declare const MQ_MAX_WIDTH_LANDSCAPE = 1000;
 export declare const MQ_MAX_HEIGHT_LANDSCAPE = 500;

package/types/data/index.d.ts

@@ -1,13 +1,21 @@
-import { NonDeletedExcalidrawElement } from "../element/types";
+import { ExcalidrawElement, ExcalidrawFrameElement, NonDeletedExcalidrawElement } from "../element/types";
 import { ExportType } from "../scene/types";
 import { AppState, BinaryFiles } from "../types";
 import { FileSystemHandle } from "./filesystem";
 export { loadFromBlob } from "./blob";
 export { loadFromJSON, saveAsJSON } from "./json";
-export declare const exportCanvas: (type: Omit<ExportType, "backend">, elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, name, fileHandle, }: {
+export type ExportedElements = readonly NonDeletedExcalidrawElement[] & {
+    _brand: "exportedElements";
+};
+export declare const prepareElementsForExport: (elements: readonly ExcalidrawElement[], { selectedElementIds }: Pick<AppState, "selectedElementIds">, exportSelectionOnly: boolean) => {
+    exportingFrame: ExcalidrawFrameElement | null;
+    exportedElements: ExportedElements;
+};
+export declare const exportCanvas: (type: Omit<ExportType, "backend">, elements: ExportedElements, appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, name, fileHandle, exportingFrame, }: {
     exportBackground: boolean;
     exportPadding?: number | undefined;
     viewBackgroundColor: string;
     name: string;
     fileHandle?: FileSystemHandle | null | undefined;
+    exportingFrame: ExcalidrawFrameElement | null;
 }) => Promise<FileSystemHandle | null | undefined>;

package/types/data/transform.d.ts

@@ -52,7 +52,7 @@ export type ValidContainer = {
         verticalAlign?: VerticalAlign;
     } & MarkOptional<ElementConstructorOpts, "x" | "y">;
 } & ElementConstructorOpts;
-export type ExcalidrawElementSkeleton = Extract<Exclude<ExcalidrawElement, ExcalidrawSelectionElement>, ExcalidrawEmbeddableElement | ExcalidrawFreeDrawElement | ExcalidrawFrameElement> | ({
+export type ExcalidrawElementSkeleton = Extract<Exclude<ExcalidrawElement, ExcalidrawSelectionElement>, ExcalidrawEmbeddableElement | ExcalidrawFreeDrawElement> | ({
     type: Extract<ExcalidrawLinearElement["type"], "line">;
     x: number;
     y: number;
@@ -67,7 +67,11 @@ export type ExcalidrawElementSkeleton = Extract<Exclude<ExcalidrawElement, Excal
     x: number;
     y: number;
     fileId: FileId;
-} & Partial<ExcalidrawImageElement>);
+} & Partial<ExcalidrawImageElement>) | ({
+    type: "frame";
+    children: readonly ExcalidrawElement["id"][];
+    name?: string;
+} & Partial<ExcalidrawFrameElement>);
 export declare const convertToExcalidrawElements: (elementsSkeleton: ExcalidrawElementSkeleton[] | null, opts?: {
     regenerateIds: boolean;
 }) => ExcalidrawElement[];

package/types/element/embeddable.d.ts

@@ -14,7 +14,7 @@ type EmbeddedLink = ({
     srcdoc: (theme: Theme) => string;
 })) | null;
 export declare const getEmbedLink: (link: string | null | undefined) => EmbeddedLink;
-export declare const isEmbeddableOrFrameLabel: (element: NonDeletedExcalidrawElement) => Boolean;
+export declare const isEmbeddableOrLabel: (element: NonDeletedExcalidrawElement) => Boolean;
 export declare const createPlaceholderEmbeddableLabel: (element: ExcalidrawEmbeddableElement) => ExcalidrawElement;
 export declare const actionSetEmbeddableAsActiveTool: {
     name: "setEmbeddableAsActiveTool";

package/types/element/newElement.d.ts

@@ -9,7 +9,9 @@ export declare const newEmbeddableElement: (opts: {
     type: "embeddable";
     validated: ExcalidrawEmbeddableElement["validated"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawEmbeddableElement>;
-export declare const newFrameElement: (opts: ElementConstructorOpts) => NonDeleted<ExcalidrawFrameElement>;
+export declare const newFrameElement: (opts: {
+    name?: string;
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawFrameElement>;
 export declare const newTextElement: (opts: {
     text: string;
     fontSize?: number;

package/types/element/typeChecks.d.ts

@@ -16,7 +16,7 @@ export declare const isBindingElement: (element?: ExcalidrawElement | null, incl
 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 isExcalidrawElement: (element: any) => element is ExcalidrawElement;
 export declare const hasBoundTextElement: (element: ExcalidrawElement | null) => element is MarkNonNullable<ExcalidrawBindableElement, "boundElements">;
 export declare const isBoundToContainer: (element: ExcalidrawElement | null) => element is ExcalidrawTextElementWithContainer;
 export declare const isUsingAdaptiveRadius: (type: string) => boolean;

package/types/errors.d.ts

@@ -5,4 +5,9 @@ export declare class CanvasError extends Error {
 export declare class AbortError extends DOMException {
     constructor(message?: string);
 }
+type ImageSceneDataErrorCode = "IMAGE_NOT_CONTAINS_SCENE_DATA" | "IMAGE_SCENE_DATA_ERROR";
+export declare class ImageSceneDataError extends Error {
+    code: ImageSceneDataErrorCode;
+    constructor(message?: string, code?: ImageSceneDataErrorCode);
+}
 export {};

package/types/frame.d.ts

@@ -18,7 +18,17 @@ export declare const groupsAreCompletelyOutOfFrame: (elements: readonly NonDelet
  * 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 getFrameChildren: (allElements: ExcalidrawElementsIncludingDeleted, frameId: string) => ExcalidrawElement[];
+export declare const getFrameElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawFrameElement[];
+/**
+ * Returns ExcalidrawFrameElements and non-frame-children elements.
+ *
+ * Considers children as root elements if they point to a frame parent
+ * non-existing in the elements set.
+ *
+ * Considers non-frame bound elements (container or arrow labels) as root.
+ */
+export declare const getRootElements: (allElements: ExcalidrawElementsIncludingDeleted) => 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;

package/types/packages/excalidraw/dist/excalidraw-with-preact.development.d.ts

@@ -0,0 +1,2 @@
+export = __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime__;
+export = __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime__;

package/types/packages/excalidraw/dist/excalidraw-with-preact.production.min.d.ts

@@ -0,0 +1 @@
+export const ExcalidrawLib: {};

package/types/packages/excalidraw/dist/excalidraw.development.d.ts

@@ -1,2 +1,2 @@
-export = __WEBPACK_EXTERNAL_MODULE_react_dom__;
-export = __WEBPACK_EXTERNAL_MODULE_react_dom__;
+export = __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime__;
+export = __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime__;

package/types/packages/excalidraw/index.d.ts

@@ -1,13 +1,12 @@
 import React from "react";
 import "../../css/app.scss";
 import "../../css/styles.scss";
-import { ExcalidrawAPIRefValue, ExcalidrawProps } from "../../types";
+import { ExcalidrawProps } from "../../types";
 import Footer from "../../components/footer/FooterCenter";
 import MainMenu from "../../components/main-menu/MainMenu";
 import WelcomeScreen from "../../components/welcome-screen/WelcomeScreen";
 import LiveCollaborationTrigger from "../../components/live-collaboration/LiveCollaborationTrigger";
-type PublicExcalidrawProps = Omit<ExcalidrawProps, "forwardedRef">;
-export declare const Excalidraw: React.MemoExoticComponent<React.ForwardRefExoticComponent<PublicExcalidrawProps & React.RefAttributes<ExcalidrawAPIRefValue>>>;
+export declare const Excalidraw: React.MemoExoticComponent<(props: ExcalidrawProps) => JSX.Element>;
 export { getSceneVersion, isInvisiblySmallElement, getNonDeletedElements, } from "../../element";
 export { defaultLang, useI18n, languages } from "../../i18n";
 export { restore, restoreAppState, restoreElements, restoreLibraryItems, } from "../../data/restore";
@@ -27,4 +26,5 @@ export { LiveCollaborationTrigger };
 export { DefaultSidebar } from "../../components/DefaultSidebar";
 export { normalizeLink } from "../../data/url";
 export { convertToExcalidrawElements } from "../../data/transform";
+export { getCommonBounds } from "../../element/bounds";
 export { elementsOverlappingBBox, isElementInsideBBox, elementPartiallyOverlapsWithOrContainsBBox, } from "../withinBounds";

package/types/packages/excalidraw/webpack.preact.config.d.ts

@@ -0,0 +1,171 @@
+declare const _exports: {
+    mode: string;
+    devtool: boolean;
+    entry: {
+        "excalidraw.development": string;
+    };
+    output: {
+        path: string;
+        library: string;
+        libraryTarget: string;
+        filename: string;
+        chunkFilename: string;
+        assetModuleFilename: string;
+        publicPath: string;
+    };
+    resolve: {
+        extensions: string[];
+    };
+    module: {
+        rules: ({
+            test: RegExp;
+            exclude: RegExp;
+            use: (string | {
+                loader: string;
+            } | {
+                loader: string;
+                options: {
+                    postcssOptions: {
+                        plugins: (import("postcss").Plugin & import("autoprefixer").ExportedAPI)[];
+                    };
+                };
+            })[];
+        } | {
+            test: RegExp;
+            resolve: {
+                fullySpecified: boolean;
+            };
+        } | {
+            test: RegExp;
+            exclude: RegExp;
+            use: ({
+                loader: string;
+            } | {
+                loader: string;
+                options: {
+                    transpileOnly: boolean;
+                    configFile: string;
+                };
+            })[];
+        } | {
+            test: RegExp;
+            type: string;
+        })[];
+    };
+    optimization: {
+        splitChunks: {
+            chunks: string;
+            cacheGroups: {
+                vendors: {
+                    test: RegExp;
+                    name: string;
+                };
+            };
+        };
+    };
+    plugins: (import("webpack").EvalSourceMapDevToolPlugin | import("webpack").DefinePlugin)[];
+    externals: {
+        react: {
+            root: string;
+            commonjs2: string;
+            commonjs: string;
+            amd: string;
+        };
+        "react-dom": {
+            root: string;
+            commonjs2: string;
+            commonjs: string;
+            amd: string;
+        };
+    };
+} | {
+    mode: string;
+    entry: {
+        "excalidraw.production.min": string;
+    };
+    output: {
+        path: string;
+        library: string;
+        libraryTarget: string;
+        filename: string;
+        chunkFilename: string;
+        assetModuleFilename: string;
+        publicPath: string;
+    };
+    resolve: {
+        extensions: string[];
+    };
+    module: {
+        rules: ({
+            test: RegExp;
+            exclude: RegExp;
+            use: (string | {
+                loader: string;
+            } | {
+                loader: string;
+                options: {
+                    postcssOptions: {
+                        plugins: (import("postcss").Plugin & import("autoprefixer").ExportedAPI)[];
+                    };
+                };
+            })[];
+        } | {
+            test: RegExp;
+            resolve: {
+                fullySpecified: boolean;
+            };
+        } | {
+            test: RegExp;
+            exclude: RegExp;
+            use: ({
+                loader: string;
+            } | {
+                loader: string;
+                options: {
+                    transpileOnly: boolean;
+                    configFile: string;
+                };
+            } | {
+                loader: string;
+                options: {
+                    presets: (string | (string | {
+                        runtime: string;
+                    })[])[];
+                    plugins: string[];
+                };
+            })[];
+        } | {
+            test: RegExp;
+            type: string;
+        })[];
+    };
+    optimization: {
+        minimize: boolean;
+        minimizer: import("terser-webpack-plugin")<import("terser").MinifyOptions>[];
+        splitChunks: {
+            chunks: string;
+            cacheGroups: {
+                vendors: {
+                    test: RegExp;
+                    name: string;
+                };
+            };
+        };
+    };
+    plugins: any[];
+    externals: {
+        react: {
+            root: string;
+            commonjs2: string;
+            commonjs: string;
+            amd: string;
+        };
+        "react-dom": {
+            root: string;
+            commonjs2: string;
+            commonjs: string;
+            amd: string;
+        };
+    };
+};
+export = _exports;

package/types/packages/utils.d.ts

@@ -1,5 +1,5 @@
 import { AppState, BinaryFiles } from "../types";
-import { ExcalidrawElement, NonDeleted } from "../element/types";
+import { ExcalidrawElement, ExcalidrawFrameElement, NonDeleted } from "../element/types";
 import { MIME_TYPES } from "../constants";
 export { MIME_TYPES };
 type ExportOpts = {
@@ -7,13 +7,14 @@ type ExportOpts = {
     appState?: Partial<Omit<AppState, "offsetTop" | "offsetLeft">>;
     files: BinaryFiles | null;
     maxWidthOrHeight?: number;
+    exportingFrame?: ExcalidrawFrameElement | null;
     getDimensions?: (width: number, height: number) => {
         width: number;
         height: number;
         scale?: number;
     };
 };
-export declare const exportToCanvas: ({ elements, appState, files, maxWidthOrHeight, getDimensions, exportPadding, }: ExportOpts & {
+export declare const exportToCanvas: ({ elements, appState, files, maxWidthOrHeight, getDimensions, exportPadding, exportingFrame, }: ExportOpts & {
     exportPadding?: number | undefined;
 }) => Promise<HTMLCanvasElement>;
 export declare const exportToBlob: (opts: ExportOpts & {
@@ -21,7 +22,7 @@ export declare const exportToBlob: (opts: ExportOpts & {
     quality?: number;
     exportPadding?: number;
 }) => Promise<Blob>;
-export declare const exportToSvg: ({ elements, appState, files, exportPadding, renderEmbeddables, }: Omit<ExportOpts, "getDimensions"> & {
+export declare const exportToSvg: ({ elements, appState, files, exportPadding, renderEmbeddables, exportingFrame, }: Omit<ExportOpts, "getDimensions"> & {
     exportPadding?: number | undefined;
     renderEmbeddables?: boolean | undefined;
 }) => Promise<SVGSVGElement>;

package/types/packages/withinBounds.d.ts

@@ -1,4 +1,4 @@
-import type { NonDeletedExcalidrawElement } from "../element/types";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
 import { Bounds } from "../element/bounds";
 type Element = NonDeletedExcalidrawElement;
 type Elements = readonly NonDeletedExcalidrawElement[];
@@ -6,7 +6,7 @@ export declare const isElementInsideBBox: (element: Element, bbox: Bounds, eithe
 export declare const elementPartiallyOverlapsWithOrContainsBBox: (element: Element, bbox: Bounds) => boolean;
 export declare const elementsOverlappingBBox: ({ elements, bounds, type, errorMargin, }: {
     elements: Elements;
-    bounds: Bounds;
+    bounds: Bounds | ExcalidrawElement;
     /** safety offset. Defaults to 0. */
     errorMargin?: number | undefined;
     /**

package/types/renderer/renderElement.d.ts

@@ -18,7 +18,11 @@ export declare const DEFAULT_LINK_SIZE = 14;
 export declare const elementWithCanvasCache: WeakMap<ExcalidrawElement, ExcalidrawElementWithCanvas>;
 export declare const renderSelectionElement: (element: NonDeletedExcalidrawElement, context: CanvasRenderingContext2D, appState: InteractiveCanvasAppState) => void;
 export declare const renderElement: (element: NonDeletedExcalidrawElement, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: StaticCanvasRenderConfig, appState: StaticCanvasAppState) => void;
-export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, offsetX: number, offsetY: number, exportWithDarkMode?: boolean, exportingFrameId?: string | null, renderEmbeddables?: boolean) => void;
+export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, offsetX: number, offsetY: number, renderConfig: {
+    exportWithDarkMode: boolean;
+    renderEmbeddables: boolean;
+    frameRendering: AppState["frameRendering"];
+}) => 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

@@ -1,5 +1,5 @@
 import { RoughSVG } from "roughjs/bin/svg";
-import { BinaryFiles } from "../types";
+import { BinaryFiles, AppState } from "../types";
 import { NonDeletedExcalidrawElement } from "../element/types";
 import { InteractiveSceneRenderConfig, StaticSceneRenderConfig } from "../scene/types";
 import "canvas-roundrect-polyfill";
@@ -22,10 +22,10 @@ export declare const renderInteractiveScene: <U extends ({ canvas, elements, vis
  */
 export declare const renderStaticScene: (renderConfig: StaticSceneRenderConfig, throttle?: boolean) => void;
 export declare const cancelRender: () => void;
-export declare const renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, { offsetX, offsetY, exportWithDarkMode, exportingFrameId, renderEmbeddables, }?: {
+export declare const renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, { offsetX, offsetY, exportWithDarkMode, renderEmbeddables, frameRendering, }: {
     offsetX?: number | undefined;
     offsetY?: number | undefined;
-    exportWithDarkMode?: boolean | undefined;
-    exportingFrameId?: string | null | undefined;
-    renderEmbeddables?: boolean | undefined;
+    exportWithDarkMode: boolean;
+    renderEmbeddables: boolean;
+    frameRendering: AppState["frameRendering"];
 }) => void;

package/types/scene/Scene.d.ts

@@ -9,7 +9,12 @@ export type ExcalidrawElementsIncludingDeleted = readonly ExcalidrawElement[];
 declare class Scene {
     private static sceneMapByElement;
     private static sceneMapById;
-    static mapElementToScene(elementKey: ElementKey, scene: Scene): void;
+    static mapElementToScene(elementKey: ElementKey, scene: Scene, 
+    /**
+     * needed because of frame exporting hack.
+     * elementId:Scene mapping will be removed completely, soon.
+     */
+    mapElementIds?: boolean): void;
     static getScene(elementKey: ElementKey): Scene | null;
     private callbacks;
     private nonDeletedElements;
@@ -50,7 +55,7 @@ declare class Scene {
      * @returns whether a change was made
      */
     mapElements(iteratee: (element: ExcalidrawElement) => ExcalidrawElement): boolean;
-    replaceAllElements(nextElements: readonly ExcalidrawElement[]): void;
+    replaceAllElements(nextElements: readonly ExcalidrawElement[], mapElementIds?: boolean): void;
     informMutation(): void;
     addCallback(cb: SceneStateCallback): SceneStateCallbackRemover;
     destroy(): void;

package/types/scene/export.d.ts

@@ -1,11 +1,10 @@
-import { NonDeletedExcalidrawElement } from "../element/types";
+import { ExcalidrawFrameElement, NonDeletedExcalidrawElement } from "../element/types";
 import { AppState, BinaryFiles } from "../types";
-import { serializeAsJSON } from "../data/json";
-export declare const SVG_EXPORT_TAG = "<!-- svg-source:excalidraw -->";
-export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, }: {
+export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, exportingFrame, }: {
     exportBackground: boolean;
     exportPadding?: number | undefined;
     viewBackgroundColor: string;
+    exportingFrame?: ExcalidrawFrameElement | null | undefined;
 }, createCanvas?: (width: number, height: number) => {
     canvas: HTMLCanvasElement;
     scale: number;
@@ -17,9 +16,9 @@ export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElemen
     viewBackgroundColor: string;
     exportWithDarkMode?: boolean;
     exportEmbedScene?: boolean;
-    renderFrame?: boolean;
+    frameRendering?: AppState["frameRendering"];
 }, files: BinaryFiles | null, opts?: {
-    serializeAsJSON?: () => string;
     renderEmbeddables?: boolean;
+    exportingFrame?: ExcalidrawFrameElement | null;
 }) => Promise<SVGSVGElement>;
 export declare const getExportSize: (elements: readonly NonDeletedExcalidrawElement[], exportPadding: number, scale: number) => [number, number];

package/types/types.d.ts

@@ -5,7 +5,7 @@ import { LinearElementEditor } from "./element/linearElementEditor";
 import { SuggestedBinding } from "./element/binding";
 import { ImportedDataState } from "./data/types";
 import type App from "./components/App";
-import type { ResolvablePromise, throttleRAF } from "./utils";
+import type { throttleRAF } from "./utils";
 import { Spreadsheet } from "./charts";
 import { Language } from "./i18n";
 import { ClipboardData } from "./clipboard";
@@ -16,7 +16,7 @@ import type { FileSystemHandle } from "./data/filesystem";
 import type { IMAGE_MIME_TYPES, MIME_TYPES } from "./constants";
 import { ContextMenuItems } from "./components/ContextMenu";
 import { SnapLine } from "./snapping";
-import { Merge, ForwardRef, ValueOf } from "./utility-types";
+import { Merge, ValueOf } from "./utility-types";
 export type Point = Readonly<RoughPoint>;
 export type Collaborator = {
     pointer?: CollaboratorPointer;
@@ -283,17 +283,13 @@ export type LibraryItem = {
 export type LibraryItems = readonly LibraryItem[];
 export type LibraryItems_anyVersion = LibraryItems | LibraryItems_v1;
 export type LibraryItemsSource = ((currentLibraryItems: LibraryItems) => Blob | LibraryItems_anyVersion | Promise<LibraryItems_anyVersion | Blob>) | Blob | LibraryItems_anyVersion | Promise<LibraryItems_anyVersion | Blob>;
-export type ExcalidrawAPIRefValue = ExcalidrawImperativeAPI | {
-    readyPromise?: ResolvablePromise<ExcalidrawImperativeAPI>;
-    ready?: false;
-};
 export type ExcalidrawInitialDataState = Merge<ImportedDataState, {
     libraryItems?: Required<ImportedDataState>["libraryItems"] | Promise<Required<ImportedDataState>["libraryItems"]>;
 }>;
 export interface ExcalidrawProps {
     onChange?: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles) => void;
     initialData?: ExcalidrawInitialDataState | null | Promise<ExcalidrawInitialDataState | null>;
-    excalidrawRef?: ForwardRef<ExcalidrawAPIRefValue>;
+    excalidrawAPI?: (api: ExcalidrawImperativeAPI) => void;
     isCollaborating?: boolean;
     onPointerUpdate?: (payload: {
         pointer: {
@@ -346,7 +342,7 @@ export type ExportOpts = {
     onExportToBackend?: (exportedElements: readonly NonDeletedExcalidrawElement[], appState: UIAppState, files: BinaryFiles, canvas: HTMLCanvasElement) => void;
     renderCustomUI?: (exportedElements: readonly NonDeletedExcalidrawElement[], appState: UIAppState, files: BinaryFiles, canvas: HTMLCanvasElement) => JSX.Element;
 };
-type CanvasActions = Partial<{
+export type CanvasActions = Partial<{
     changeViewBackgroundColor: boolean;
     clearCanvas: boolean;
     export: false | ExportOpts;
@@ -355,9 +351,12 @@ type CanvasActions = Partial<{
     toggleTheme: boolean | null;
     saveAsImage: boolean;
 }>;
-type UIOptions = Partial<{
+export type UIOptions = Partial<{
     dockedSidebarBreakpoint: number;
     canvasActions: CanvasActions;
+    tools: {
+        image: boolean;
+    };
     /** @deprecated does nothing. Will be removed in 0.15 */
     welcomeScreen?: boolean;
 }>;
@@ -395,7 +394,6 @@ export type AppClassProperties = {
     lastViewportPosition: App["lastViewportPosition"];
     scrollToContent: App["scrollToContent"];
     addFiles: App["addFiles"];
-    setSelection: App["setSelection"];
     addElementsFromPasteOrLibrary: App["addElementsFromPasteOrLibrary"];
     togglePenMode: App["togglePenMode"];
     setActiveTool: App["setActiveTool"];
@@ -476,8 +474,6 @@ export type ExcalidrawImperativeAPI = {
     refresh: InstanceType<typeof App>["refresh"];
     setToast: InstanceType<typeof App>["setToast"];
     addFiles: (data: BinaryFileData[]) => void;
-    readyPromise: ResolvablePromise<ExcalidrawImperativeAPI>;
-    ready: true;
     id: string;
     setActiveTool: InstanceType<typeof App>["setActiveTool"];
     setCursor: InstanceType<typeof App>["setCursor"];
@@ -494,11 +490,15 @@ export type ExcalidrawImperativeAPI = {
     onPointerUp: (callback: (activeTool: AppState["activeTool"], pointerDownState: PointerDownState, event: PointerEvent) => void) => UnsubscribeCallback;
 };
 export type Device = Readonly<{
-    isSmScreen: boolean;
-    isMobile: boolean;
+    viewport: {
+        isMobile: boolean;
+        isLandscape: boolean;
+    };
+    editor: {
+        isMobile: boolean;
+        canFitSidebar: boolean;
+    };
     isTouchScreen: boolean;
-    canDeviceFitSidebar: boolean;
-    isLandscape: boolean;
 }>;
 type FrameNameBounds = {
     x: number;

package/types/utils.d.ts

@@ -187,7 +187,11 @@ export declare const composeEventHandlers: <E>(originalEventHandler?: ((event: E
     checkForDefaultPrevented?: boolean | undefined;
 }) => (event: E) => void;
 export declare const isOnlyExportingSingleFrame: (elements: readonly NonDeletedExcalidrawElement[]) => boolean;
-export declare const assertNever: (value: never, message: string, softAssert?: boolean) => never;
+/**
+ * supply `null` as message if non-never value is valid, you just need to
+ * typecheck against it
+ */
+export declare const assertNever: (value: never, message: string | null, softAssert?: boolean) => never;
 /**
  * Memoizes on values of `opts` object (strict equality).
  */
@@ -195,3 +199,6 @@ export declare const memoize: <T extends Record<string, any>, R extends unknown>
     clear: () => void;
 };
 export declare const isRenderThrottlingEnabled: () => boolean;
+/** Checks if value is inside given collection. Useful for type-safety. */
+export declare const isMemberOf: <T extends string>(collection: Set<T> | Record<T, any> | Map<T, any> | readonly T[], value: string) => value is T;
+export declare const cloneJSON: <T>(obj: T) => T;