@excalidraw/excalidraw 0.10.0 → 0.11.0-5346-59101a1

package/types/packages/excalidraw/example/initialData.d.ts

@@ -0,0 +1,172 @@
+declare namespace _default {
+    const elements: ({
+        type: string;
+        version: number;
+        versionNonce: number;
+        isDeleted: boolean;
+        id: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: never[];
+        fileId?: undefined;
+        strokeSharpness?: undefined;
+        boundElements?: undefined;
+        updated?: undefined;
+        link?: undefined;
+        status?: undefined;
+        scale?: undefined;
+    } | {
+        fileId: string;
+        type: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        angle: number;
+        strokeColor: string;
+        backgroundColor: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        groupIds: never[];
+        strokeSharpness: string;
+        seed: number;
+        version: number;
+        versionNonce: number;
+        isDeleted: boolean;
+        boundElements: null;
+        updated: number;
+        link: null;
+        status: string;
+        scale: number[];
+        id?: undefined;
+    })[];
+    namespace appState {
+        const viewBackgroundColor: string;
+        const currentItemFontFamily: number;
+    }
+    const scrollToContent: boolean;
+    const libraryItems: (({
+        type: string;
+        version: number;
+        versionNonce: number;
+        isDeleted: boolean;
+        id: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        boundElementIds: never[];
+        startBinding: null;
+        endBinding: null;
+        points: number[][];
+        lastCommittedPoint: null;
+        startArrowhead: null;
+        endArrowhead: null;
+    } | {
+        type: string;
+        version: number;
+        versionNonce: number;
+        isDeleted: boolean;
+        id: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        boundElementIds: string[];
+        startBinding?: undefined;
+        endBinding?: undefined;
+        points?: undefined;
+        lastCommittedPoint?: undefined;
+        startArrowhead?: undefined;
+        endArrowhead?: undefined;
+    })[] | ({
+        type: string;
+        version: number;
+        versionNonce: number;
+        isDeleted: boolean;
+        id: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        boundElementIds: string[];
+        points?: undefined;
+        lastCommittedPoint?: undefined;
+        startArrowhead?: undefined;
+        endArrowhead?: undefined;
+    } | {
+        type: string;
+        version: number;
+        versionNonce: number;
+        isDeleted: boolean;
+        id: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        boundElementIds: never[];
+        points: number[][];
+        lastCommittedPoint: null;
+        startArrowhead: null;
+        endArrowhead: null;
+    })[])[];
+}
+export default _default;

package/types/packages/excalidraw/example/sidebar/Sidebar.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import "./Sidebar.scss";
+export default function Sidebar({ children }: {
+    children: React.ReactNode;
+}): JSX.Element;

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

@@ -1,13 +1,15 @@
 import React from "react";
-import "./publicPath";
 import "../../css/app.scss";
 import "../../css/styles.scss";
 import { ExcalidrawAPIRefValue, ExcalidrawProps } from "../../types";
 declare type PublicExcalidrawProps = Omit<ExcalidrawProps, "forwardedRef">;
-declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<PublicExcalidrawProps & React.RefAttributes<ExcalidrawAPIRefValue>>>;
-export default _default;
-export { getSceneVersion, getElementMap, isInvisiblySmallElement, } from "../../element";
+export declare const Excalidraw: React.MemoExoticComponent<React.ForwardRefExoticComponent<PublicExcalidrawProps & React.RefAttributes<ExcalidrawAPIRefValue>>>;
+export { getSceneVersion, isInvisiblySmallElement, getNonDeletedElements, } from "../../element";
 export { defaultLang, languages } from "../../i18n";
-export { restore, restoreAppState, restoreElements } from "../../data/restore";
-export { exportToCanvas, exportToBlob, exportToSvg, serializeAsJSON, loadLibraryFromBlob, loadFromBlob, getFreeDrawSvgPath, } from "../../packages/utils";
-export { FONT_FAMILY } from "../../constants";
+export { restore, restoreAppState, restoreElements, restoreLibraryItems, } from "../../data/restore";
+export { exportToCanvas, exportToBlob, exportToSvg, serializeAsJSON, serializeLibraryAsJSON, loadLibraryFromBlob, loadFromBlob, loadSceneOrLibraryFromBlob, getFreeDrawSvgPath, exportToClipboard, mergeLibraryItems, } from "../../packages/utils";
+export { isLinearElement } from "../../element/typeChecks";
+export { FONT_FAMILY, THEME, MIME_TYPES } from "../../constants";
+export { mutateElement, newElementWith, bumpVersion, } from "../../element/mutateElement";
+export { parseLibraryTokensFromUrl, useHandleLibrary, } from "../../data/library";
+export { sceneCoordsToViewportCoords, viewportCoordsToSceneCoords, } from "../../utils";

package/types/packages/excalidraw/webpack.dev-server.config.d.ts

@@ -0,0 +1,19 @@
+export namespace entry {
+    const bundle: string;
+}
+export namespace devServer {
+    export const port: number;
+    export const host: string;
+    export const hot: boolean;
+    export const compress: boolean;
+    export namespace _static {
+        const directory: string;
+    }
+    export { _static as static };
+    export namespace client {
+        const progress: boolean;
+        const logging: string;
+        const overlay: boolean;
+    }
+    export const open: string[];
+}

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

@@ -11,6 +11,7 @@ export namespace output {
     const libraryTarget: string;
     const filename: string;
     const chunkFilename: string;
+    const assetModuleFilename: string;
     const publicPath: string;
 }
 export namespace resolve {
@@ -31,6 +32,7 @@ export namespace module {
                 };
             };
         })[];
+        type?: undefined;
     } | {
         test: RegExp;
         exclude: RegExp;
@@ -41,16 +43,12 @@ export namespace module {
                 configFile: string;
             };
         }[];
+        type?: undefined;
     } | {
         test: RegExp;
-        use: {
-            loader: string;
-            options: {
-                name: string;
-                outputPath: string;
-            };
-        }[];
+        type: string;
         exclude?: undefined;
+        use?: undefined;
     })[];
 }
 export namespace optimization {
@@ -64,7 +62,7 @@ export namespace optimization {
         }
     }
 }
-export const plugins: webpack.EvalSourceMapDevToolPlugin[];
+export const plugins: (webpack.EvalSourceMapDevToolPlugin | webpack.DefinePlugin)[];
 export const externals: {
     react: {
         root: string;

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

@@ -1,4 +1,5 @@
 import autoprefixer = require("autoprefixer");
+import TerserPlugin = require("terser-webpack-plugin");
 export const mode: string;
 export const entry: {
     "excalidraw.production.min": string;
@@ -9,6 +10,7 @@ export namespace output {
     const libraryTarget: string;
     const filename: string;
     const chunkFilename: string;
+    const assetModuleFilename: string;
     const publicPath: string;
 }
 export namespace resolve {
@@ -29,6 +31,7 @@ export namespace module {
                 };
             };
         })[];
+        type?: undefined;
     } | {
         test: RegExp;
         exclude: RegExp;
@@ -51,21 +54,17 @@ export namespace module {
                 configFile?: undefined;
             };
         })[];
+        type?: undefined;
     } | {
         test: RegExp;
-        use: {
-            loader: string;
-            options: {
-                name: string;
-                outputPath: string;
-            };
-        }[];
+        type: string;
         exclude?: undefined;
+        use?: undefined;
     })[];
 }
 export namespace optimization {
     const minimize: boolean;
-    const minimizer: any[];
+    const minimizer: TerserPlugin<import("terser").MinifyOptions>[];
     namespace splitChunks {
         const chunks: string;
         namespace cacheGroups {

package/types/packages/utils.d.ts

@@ -1,22 +1,32 @@
-import { AppState } from "../types";
-import { ExcalidrawElement } from "../element/types";
+import { AppState, BinaryFiles } from "../types";
+import { ExcalidrawElement, NonDeleted } from "../element/types";
+import { MIME_TYPES } from "../constants";
+export { MIME_TYPES };
 declare type ExportOpts = {
-    elements: readonly ExcalidrawElement[];
+    elements: readonly NonDeleted<ExcalidrawElement>[];
     appState?: Partial<Omit<AppState, "offsetTop" | "offsetLeft">>;
+    files: BinaryFiles | null;
+    maxWidthOrHeight?: number;
     getDimensions?: (width: number, height: number) => {
         width: number;
         height: number;
-        scale: number;
+        scale?: number;
     };
 };
-export declare const exportToCanvas: ({ elements, appState, getDimensions, }: ExportOpts) => HTMLCanvasElement;
+export declare const exportToCanvas: ({ elements, appState, files, maxWidthOrHeight, getDimensions, }: ExportOpts) => Promise<HTMLCanvasElement>;
 export declare const exportToBlob: (opts: ExportOpts & {
     mimeType?: string;
     quality?: number;
-}) => Promise<Blob | null>;
-export declare const exportToSvg: ({ elements, appState, exportPadding, }: Omit<ExportOpts, "getDimensions"> & {
+}) => Promise<Blob>;
+export declare const exportToSvg: ({ elements, appState, files, exportPadding, }: Omit<ExportOpts, "getDimensions"> & {
     exportPadding?: number | undefined;
 }) => Promise<SVGSVGElement>;
-export { serializeAsJSON } from "../data/json";
-export { loadFromBlob, loadLibraryFromBlob } from "../data/blob";
+export declare const exportToClipboard: (opts: ExportOpts & {
+    mimeType?: string;
+    quality?: number;
+    type: "png" | "svg" | "json";
+}) => Promise<void>;
+export { serializeAsJSON, serializeLibraryAsJSON } from "../data/json";
+export { loadFromBlob, loadSceneOrLibraryFromBlob, loadLibraryFromBlob, } from "../data/blob";
 export { getFreeDrawSvgPath } from "../renderer/renderElement";
+export { mergeLibraryItems } from "../data/library";

package/types/renderer/renderElement.d.ts

@@ -2,21 +2,33 @@ import { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement,
 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 { RenderConfig } from "../scene/types";
+import { BinaryFiles, Zoom } from "../types";
 export interface ExcalidrawElementWithCanvas {
     element: ExcalidrawElement | ExcalidrawTextElement;
     canvas: HTMLCanvasElement;
+    theme: RenderConfig["theme"];
     canvasZoom: Zoom["value"];
     canvasOffsetX: number;
     canvasOffsetY: number;
 }
-export declare const getShapeForElement: (element: ExcalidrawElement) => Drawable | Drawable[] | null | undefined;
+export declare const DEFAULT_LINK_SIZE = 14;
+declare type ElementShape = Drawable | Drawable[] | null;
+declare type ElementShapes = {
+    freedraw: Drawable | null;
+    arrow: Drawable[];
+    line: Drawable[];
+    text: null;
+    image: null;
+};
+export declare const getShapeForElement: <T extends ExcalidrawElement>(element: T) => T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : Drawable | null | undefined;
+export declare const setShapeForElement: <T extends ExcalidrawElement>(element: T, shape: T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable) => WeakMap<ExcalidrawElement, ElementShape>;
 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 renderElement: (element: NonDeletedExcalidrawElement, rc: RoughCanvas, context: CanvasRenderingContext2D, renderConfig: RenderConfig) => void;
+export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, offsetX?: number | undefined, offsetY?: number | undefined, exportWithDarkMode?: boolean | undefined) => void;
 export declare const pathsCache: WeakMap<ExcalidrawFreeDrawElement, Path2D>;
 export declare function generateFreeDrawShape(element: ExcalidrawFreeDrawElement): Path2D;
 export declare function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement): Path2D | undefined;
 export declare function getFreeDrawSvgPath(element: ExcalidrawFreeDrawElement): string;
+export {};

package/types/renderer/renderScene.d.ts

@@ -1,21 +1,17 @@
 import { RoughCanvas } from "roughjs/bin/canvas";
 import { RoughSVG } from "roughjs/bin/svg";
-import { AppState } from "../types";
+import { AppState, BinaryFiles } 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, }?: {
-    renderScrollbars?: boolean | undefined;
-    renderSelection?: boolean | undefined;
-    renderOptimizations?: boolean | undefined;
-    renderGrid?: boolean | undefined;
-}) => {
+import { RenderConfig } from "../scene/types";
+export declare const renderScene: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, selectionElement: NonDeletedExcalidrawElement | null, scale: number, rc: RoughCanvas, canvas: HTMLCanvasElement, renderConfig: RenderConfig) => {
     atLeastOneVisibleElement: boolean;
     scrollBars?: undefined;
 } | {
     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: BinaryFiles, { offsetX, offsetY, exportWithDarkMode, }?: {
     offsetX?: number | undefined;
     offsetY?: number | undefined;
+    exportWithDarkMode?: boolean | undefined;
 }) => void;

package/types/scene/Scene.d.ts

@@ -14,10 +14,9 @@ declare class Scene {
     private elements;
     private elementsMap;
     getElementsIncludingDeleted(): readonly ExcalidrawElement[];
-    getElements(): readonly NonDeletedExcalidrawElement[];
-    getElement(id: ExcalidrawElement["id"]): ExcalidrawElement | null;
+    getNonDeletedElements(): readonly NonDeletedExcalidrawElement[];
+    getElement<T extends ExcalidrawElement>(id: T["id"]): T | null;
     getNonDeletedElement(id: ExcalidrawElement["id"]): NonDeleted<ExcalidrawElement> | null;
-    getNonDeletedElements(ids: readonly ExcalidrawElement["id"][]): NonDeleted<ExcalidrawElement>[];
     replaceAllElements(nextElements: readonly ExcalidrawElement[]): void;
     informMutation(): void;
     addCallback(cb: SceneStateCallback): SceneStateCallbackRemover;

package/types/scene/comparisons.d.ts

@@ -1,5 +1,6 @@
-import { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
+import { ExcalidrawElement, ExcalidrawTextContainer, NonDeletedExcalidrawElement } from "../element/types";
 export declare const hasBackground: (type: string) => boolean;
+export declare const hasStrokeColor: (type: string) => boolean;
 export declare const hasStrokeWidth: (type: string) => boolean;
 export declare const hasStrokeStyle: (type: string) => boolean;
 export declare const canChangeSharpness: (type: string) => boolean;
@@ -7,4 +8,4 @@ export declare const hasText: (type: string) => boolean;
 export declare const canHaveArrowheads: (type: string) => boolean;
 export declare const getElementAtPosition: (elements: readonly NonDeletedExcalidrawElement[], isAtPositionFn: (element: NonDeletedExcalidrawElement) => boolean) => NonDeletedExcalidrawElement | null;
 export declare const getElementsAtPosition: (elements: readonly NonDeletedExcalidrawElement[], isAtPositionFn: (element: NonDeletedExcalidrawElement) => boolean) => NonDeletedExcalidrawElement[];
-export declare const getElementContainingPosition: (elements: readonly ExcalidrawElement[], x: number, y: number) => ExcalidrawElement | null;
+export declare const getTextBindableContainerAtPosition: (elements: readonly ExcalidrawElement[], x: number, y: number) => ExcalidrawTextContainer | null;

package/types/scene/export.d.ts

@@ -1,14 +1,14 @@
 import { NonDeletedExcalidrawElement } from "../element/types";
-import { AppState } from "../types";
+import { AppState, BinaryFiles } from "../types";
 export declare const SVG_EXPORT_TAG = "<!-- svg-source:excalidraw -->";
-export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, { exportBackground, exportPadding, viewBackgroundColor, }: {
+export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, { exportBackground, exportPadding, viewBackgroundColor, }: {
     exportBackground: boolean;
     exportPadding?: number | undefined;
     viewBackgroundColor: string;
 }, 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,5 @@ export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElemen
     viewBackgroundColor: string;
     exportWithDarkMode?: boolean;
     exportEmbedScene?: boolean;
-}) => Promise<SVGSVGElement>;
+}, files: BinaryFiles | null) => Promise<SVGSVGElement>;
 export declare const getExportSize: (elements: readonly NonDeletedExcalidrawElement[], exportPadding: number, scale: number) => [number, number];

package/types/scene/index.d.ts

@@ -1,5 +1,5 @@
 export { isOverScrollBars } from "./scrollbars";
 export { isSomeElementSelected, getElementsWithinSelection, getCommonAttributeOfSelectedElements, getSelectedElements, getTargetElements, } from "./selection";
 export { calculateScrollCenter } from "./scroll";
-export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeSharpness, getElementAtPosition, getElementContainingPosition, hasText, getElementsAtPosition, } from "./comparisons";
-export { getNormalizedZoom, getNewZoom } from "./zoom";
+export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeSharpness, getElementAtPosition, getTextBindableContainerAtPosition, hasText, getElementsAtPosition, } from "./comparisons";
+export { getNormalizedZoom } from "./zoom";

package/types/scene/selection.d.ts

@@ -7,5 +7,5 @@ export declare const isSomeElementSelected: (elements: readonly NonDeletedExcali
  *  elements. If elements don't share the same value, returns `null`.
  */
 export declare const getCommonAttributeOfSelectedElements: <T>(elements: readonly NonDeletedExcalidrawElement[], appState: AppState, getAttribute: (element: ExcalidrawElement) => T) => T | null;
-export declare const getSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState) => NonDeletedExcalidrawElement[];
+export declare const getSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, includeBoundTextElement?: boolean) => NonDeletedExcalidrawElement[];
 export declare const getTargetElements: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState) => NonDeletedExcalidrawElement[];

package/types/scene/types.d.ts

@@ -1,12 +1,13 @@
 import { ExcalidrawTextElement } from "../element/types";
-import { Zoom } from "../types";
-export declare type SceneState = {
-    scrollX: number;
-    scrollY: number;
-    viewBackgroundColor: string | null;
-    exportWithDarkMode?: boolean;
-    zoom: Zoom;
-    shouldCacheIgnoreZoom: boolean;
+import { AppClassProperties, AppState } from "../types";
+export declare type RenderConfig = {
+    scrollX: AppState["scrollX"];
+    scrollY: AppState["scrollY"];
+    /** null indicates transparent bg */
+    viewBackgroundColor: AppState["viewBackgroundColor"] | null;
+    zoom: AppState["zoom"];
+    shouldCacheIgnoreZoom: AppState["shouldCacheIgnoreZoom"];
+    theme: AppState["theme"];
     remotePointerViewportCoords: {
         [id: string]: {
             x: number;
@@ -25,6 +26,13 @@ export declare type SceneState = {
     remotePointerUserStates: {
         [id: string]: string;
     };
+    imageCache: AppClassProperties["imageCache"];
+    renderScrollbars?: boolean;
+    renderSelection?: boolean;
+    renderGrid?: boolean;
+    /** when exporting the behavior is slightly different (e.g. we can't use
+      CSS filters), and we disable render optimizations for best output */
+    isExporting: boolean;
 };
 export declare type SceneScroll = {
     scrollX: number;

package/types/scene/zoom.d.ts

@@ -1,6 +1,13 @@
-import { NormalizedZoomValue, PointerCoords, Zoom } from "../types";
-export declare const getNewZoom: (newZoomValue: NormalizedZoomValue, prevZoom: Zoom, canvasOffset: {
-    left: number;
-    top: number;
-}, zoomOnViewportPoint?: PointerCoords) => Zoom;
+import { AppState, NormalizedZoomValue } from "../types";
 export declare const getNormalizedZoom: (zoom: number) => NormalizedZoomValue;
+export declare const getStateForZoom: ({ viewportX, viewportY, nextZoom, }: {
+    viewportX: number;
+    viewportY: number;
+    nextZoom: NormalizedZoomValue;
+}, appState: AppState) => {
+    scrollX: number;
+    scrollY: number;
+    zoom: {
+        value: NormalizedZoomValue;
+    };
+};

package/types/shapes.d.ts

@@ -14,7 +14,7 @@ export declare const SHAPES: readonly [{
 }, {
     readonly icon: JSX.Element;
     readonly value: "ellipse";
-    readonly key: "e";
+    readonly key: "o";
 }, {
     readonly icon: JSX.Element;
     readonly value: "arrow";
@@ -26,10 +26,14 @@ export declare const SHAPES: readonly [{
 }, {
     readonly icon: JSX.Element;
     readonly value: "freedraw";
-    readonly key: "x";
+    readonly key: readonly ["x", string];
 }, {
     readonly icon: JSX.Element;
     readonly value: "text";
     readonly key: "t";
+}, {
+    readonly icon: JSX.Element;
+    readonly value: "image";
+    readonly key: null;
 }];
-export declare const findShapeByKey: (key: string) => "line" | "selection" | "rectangle" | "diamond" | "ellipse" | "text" | "arrow" | "freedraw" | null;
+export declare const findShapeByKey: (key: string) => "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | null;