@dwelle/excalidraw 0.4.0-d8d86cf → 0.4.0-da7ef3e

package/types/types.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="react" />
-import { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, ChartType, FontFamilyValues, FileId, ExcalidrawImageElement, Theme } from "./element/types";
+import React from "react";
+import { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, ChartType, FontFamilyValues, FileId, ExcalidrawImageElement, Theme, StrokeRoundness, ExcalidrawFrameElement, ExcalidrawEmbeddableElement } from "./element/types";
 import { SHAPES } from "./shapes";
 import { Point as RoughPoint } from "roughjs/bin/geometry";
 import { LinearElementEditor } from "./element/linearElementEditor";
@@ -14,9 +14,12 @@ import { isOverScrollBars } from "./scene";
 import { MaybeTransformHandleType } from "./element/transformHandles";
 import Library from "./data/library";
 import type { FileSystemHandle } from "./data/filesystem";
-import type { ALLOWED_IMAGE_MIME_TYPES, MIME_TYPES } from "./constants";
-export declare type Point = Readonly<RoughPoint>;
-export declare type Collaborator = {
+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";
+export type Point = Readonly<RoughPoint>;
+export type Collaborator = {
     pointer?: {
         x: number;
         y: number;
@@ -32,11 +35,11 @@ export declare type Collaborator = {
     avatarUrl?: string;
     id?: string;
 };
-export declare type DataURL = string & {
+export type DataURL = string & {
     _brand: "DataURL";
 };
-export declare type BinaryFileData = {
-    mimeType: typeof ALLOWED_IMAGE_MIME_TYPES[number] | typeof MIME_TYPES.binary;
+export type BinaryFileData = {
+    mimeType: ValueOf<typeof IMAGE_MIME_TYPES> | typeof MIME_TYPES.binary;
     id: FileId;
     dataURL: DataURL;
     /**
@@ -52,19 +55,69 @@ export declare type BinaryFileData = {
      */
     lastRetrieved?: number;
 };
-export declare type BinaryFileMetadata = Omit<BinaryFileData, "dataURL">;
-export declare type BinaryFiles = Record<ExcalidrawElement["id"], BinaryFileData>;
-export declare type LastActiveToolBeforeEraser = {
-    type: typeof SHAPES[number]["value"] | "eraser";
+export type BinaryFileMetadata = Omit<BinaryFileData, "dataURL">;
+export type BinaryFiles = Record<ExcalidrawElement["id"], BinaryFileData>;
+export type LastActiveTool = {
+    type: typeof SHAPES[number]["value"] | "eraser" | "hand" | "frame" | "embeddable";
     customType: null;
 } | {
     type: "custom";
     customType: string;
 } | null;
-export declare type AppState = {
+export type SidebarName = string;
+export type SidebarTabName = string;
+type _CommonCanvasAppState = {
+    zoom: AppState["zoom"];
+    scrollX: AppState["scrollX"];
+    scrollY: AppState["scrollY"];
+    width: AppState["width"];
+    height: AppState["height"];
+    viewModeEnabled: AppState["viewModeEnabled"];
+    editingGroupId: AppState["editingGroupId"];
+    selectedElementIds: AppState["selectedElementIds"];
+    frameToHighlight: AppState["frameToHighlight"];
+    offsetLeft: AppState["offsetLeft"];
+    offsetTop: AppState["offsetTop"];
+    theme: AppState["theme"];
+    pendingImageElementId: AppState["pendingImageElementId"];
+};
+export type StaticCanvasAppState = Readonly<_CommonCanvasAppState & {
+    shouldCacheIgnoreZoom: AppState["shouldCacheIgnoreZoom"];
+    exportScale: AppState["exportScale"];
+    selectedElementsAreBeingDragged: AppState["selectedElementsAreBeingDragged"];
+    gridSize: AppState["gridSize"];
+    frameRendering: AppState["frameRendering"];
+}>;
+export type InteractiveCanvasAppState = Readonly<_CommonCanvasAppState & {
+    activeEmbeddable: AppState["activeEmbeddable"];
+    editingLinearElement: AppState["editingLinearElement"];
+    selectionElement: AppState["selectionElement"];
+    selectedGroupIds: AppState["selectedGroupIds"];
+    selectedLinearElement: AppState["selectedLinearElement"];
+    multiElement: AppState["multiElement"];
+    isBindingEnabled: AppState["isBindingEnabled"];
+    suggestedBindings: AppState["suggestedBindings"];
+    isRotating: AppState["isRotating"];
+    elementsToHighlight: AppState["elementsToHighlight"];
+    openSidebar: AppState["openSidebar"];
+    showHyperlinkPopup: AppState["showHyperlinkPopup"];
+    collaborators: AppState["collaborators"];
+    snapLines: AppState["snapLines"];
+    zenModeEnabled: AppState["zenModeEnabled"];
+}>;
+export type AppState = {
+    contextMenu: {
+        items: ContextMenuItems;
+        top: number;
+        left: number;
+    } | null;
     showWelcomeScreen: boolean;
     isLoading: boolean;
-    errorMessage: string | null;
+    errorMessage: React.ReactNode;
+    activeEmbeddable: {
+        element: NonDeletedExcalidrawElement;
+        state: "hover" | "active";
+    } | null;
     draggingElement: NonDeletedExcalidrawElement | null;
     resizingElement: NonDeletedExcalidrawElement | null;
     multiElement: NonDeleted<ExcalidrawLinearElement> | null;
@@ -72,19 +125,31 @@ export declare type AppState = {
     isBindingEnabled: boolean;
     startBoundElement: NonDeleted<ExcalidrawBindableElement> | null;
     suggestedBindings: SuggestedBinding[];
+    frameToHighlight: NonDeleted<ExcalidrawFrameElement> | null;
+    frameRendering: {
+        enabled: boolean;
+        name: boolean;
+        outline: boolean;
+        clip: boolean;
+    };
+    editingFrame: string | null;
+    elementsToHighlight: NonDeleted<ExcalidrawElement>[] | null;
     editingElement: NonDeletedExcalidrawElement | null;
     editingLinearElement: LinearElementEditor | null;
     activeTool: {
-        type: typeof SHAPES[number]["value"] | "eraser";
-        lastActiveToolBeforeEraser: LastActiveToolBeforeEraser;
+        /**
+         * indicates a previous tool we should revert back to if we deselect the
+         * currently active tool. At the moment applies to `eraser` and `hand` tool.
+         */
+        lastActiveTool: LastActiveTool;
         locked: boolean;
+    } & ({
+        type: typeof SHAPES[number]["value"] | "eraser" | "hand" | "frame" | "embeddable";
         customType: null;
     } | {
         type: "custom";
         customType: string;
-        lastActiveToolBeforeEraser: LastActiveToolBeforeEraser;
-        locked: boolean;
-    };
+    });
     penMode: boolean;
     penDetected: boolean;
     exportBackground: boolean;
@@ -101,10 +166,9 @@ export declare type AppState = {
     currentItemFontFamily: FontFamilyValues;
     currentItemFontSize: number;
     currentItemTextAlign: TextAlign;
-    currentItemStrokeSharpness: ExcalidrawElement["strokeSharpness"];
     currentItemStartArrowhead: Arrowhead | null;
     currentItemEndArrowhead: Arrowhead | null;
-    currentItemLinearStrokeSharpness: ExcalidrawElement["strokeSharpness"];
+    currentItemRoundness: StrokeRoundness;
     viewBackgroundColor: string;
     scrollX: number;
     scrollY: number;
@@ -115,17 +179,28 @@ export declare type AppState = {
     isRotating: boolean;
     zoom: Zoom;
     openMenu: "canvas" | "shape" | null;
-    openPopup: "canvasColorPicker" | "backgroundColorPicker" | "strokeColorPicker" | null;
-    openSidebar: "library" | "customSidebar" | null;
-    openDialog: "imageExport" | "help" | null;
-    isSidebarDocked: boolean;
+    openPopup: "canvasBackground" | "elementBackground" | "elementStroke" | null;
+    openSidebar: {
+        name: SidebarName;
+        tab?: SidebarTabName;
+    } | null;
+    openDialog: "imageExport" | "help" | "jsonExport" | null;
+    /**
+     * Reflects user preference for whether the default sidebar should be docked.
+     *
+     * NOTE this is only a user preference and does not reflect the actual docked
+     * state of the sidebar, because the host apps can override this through
+     * a DefaultSidebar prop, which is not reflected back to the appState.
+     */
+    defaultSidebarDockedPreference: boolean;
     lastPointerDownWith: PointerType;
-    selectedElementIds: {
-        [id: string]: boolean;
-    };
+    selectedElementIds: Readonly<{
+        [id: string]: true;
+    }>;
     previousSelectedElementIds: {
-        [id: string]: boolean;
+        [id: string]: true;
     };
+    selectedElementsAreBeingDragged: boolean;
     shouldCacheIgnoreZoom: boolean;
     toast: {
         message: string;
@@ -162,18 +237,25 @@ export declare type AppState = {
     pendingImageElementId: ExcalidrawImageElement["id"] | null;
     showHyperlinkPopup: false | "info" | "editor";
     selectedLinearElement: LinearElementEditor | null;
+    snapLines: SnapLine[];
+    originSnapOffset: {
+        x: number;
+        y: number;
+    } | null;
+    objectsSnapModeEnabled: boolean;
 };
-export declare type NormalizedZoomValue = number & {
+export type UIAppState = Omit<AppState, "suggestedBindings" | "startBoundElement" | "cursorButton" | "scrollX" | "scrollY">;
+export type NormalizedZoomValue = number & {
     _brand: "normalizedZoom";
 };
-export declare type Zoom = Readonly<{
+export type Zoom = Readonly<{
     value: NormalizedZoomValue;
 }>;
-export declare type PointerCoords = Readonly<{
+export type PointerCoords = Readonly<{
     x: number;
     y: number;
 }>;
-export declare type Gesture = {
+export type Gesture = {
     pointers: Map<number, PointerCoords>;
     lastCenter: {
         x: number;
@@ -187,11 +269,11 @@ export declare class GestureEvent extends UIEvent {
     readonly scale: number;
 }
 /** @deprecated legacy: do not use outside of migration paths */
-export declare type LibraryItem_v1 = readonly NonDeleted<ExcalidrawElement>[];
+export type LibraryItem_v1 = readonly NonDeleted<ExcalidrawElement>[];
 /** @deprecated legacy: do not use outside of migration paths */
-declare type LibraryItems_v1 = readonly LibraryItem_v1[];
+type LibraryItems_v1 = readonly LibraryItem_v1[];
 /** v2 library item */
-export declare type LibraryItem = {
+export type LibraryItem = {
     id: string;
     status: "published" | "unpublished";
     elements: readonly NonDeleted<ExcalidrawElement>[];
@@ -200,14 +282,14 @@ export declare type LibraryItem = {
     name?: string;
     error?: string;
 };
-export declare type LibraryItems = readonly LibraryItem[];
-export declare type LibraryItems_anyVersion = LibraryItems | LibraryItems_v1;
-export declare type LibraryItemsSource = ((currentLibraryItems: LibraryItems) => Blob | LibraryItems_anyVersion | Promise<LibraryItems_anyVersion | Blob>) | Blob | LibraryItems_anyVersion | Promise<LibraryItems_anyVersion | Blob>;
-export declare type ExcalidrawAPIRefValue = ExcalidrawImperativeAPI | {
+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 declare type ExcalidrawInitialDataState = Merge<ImportedDataState, {
+export type ExcalidrawInitialDataState = Merge<ImportedDataState, {
     scrollX?: number;
     scrollY?: number;
     libraryItems?: Required<ImportedDataState>["libraryItems"] | Promise<Required<ImportedDataState>["libraryItems"]>;
@@ -216,13 +298,11 @@ export interface ExcalidrawProps {
     id?: string | null;
     onChange?: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles, id?: string | null) => void;
     initialData?: ExcalidrawInitialDataState | null | Promise<ExcalidrawInitialDataState | null>;
-    onHomeButtonClick: () => void;
-    onThemeToggle: (theme: Theme) => void;
+    onHomeButtonClick?: () => void;
     user?: {
         name?: string | null;
     };
     excalidrawRef?: ForwardRef<ExcalidrawAPIRefValue>;
-    onCollabButtonClick?: () => void;
     isCollaborating?: boolean;
     onPointerUpdate?: (payload: {
         pointer: {
@@ -233,20 +313,17 @@ export interface ExcalidrawProps {
         pointersMap: Gesture["pointers"];
     }) => void;
     onPaste?: (data: ClipboardData, event: ClipboardEvent | null) => Promise<boolean> | boolean;
-    renderTopRightUI?: (isMobile: boolean, appState: AppState) => JSX.Element | null;
-    renderFooter?: (isMobile: boolean, appState: AppState) => JSX.Element | null;
+    renderTopRightUI?: (isMobile: boolean, appState: UIAppState) => JSX.Element | null;
     langCode?: Language["code"];
     viewModeEnabled?: boolean;
     zenModeEnabled?: boolean;
     gridModeEnabled?: boolean;
+    objectsSnapModeEnabled?: boolean;
     libraryReturnUrl?: string;
     theme?: Theme;
     name?: string;
-    renderCustomStats?: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState) => JSX.Element;
-    UIOptions?: {
-        dockedSidebarBreakpoint?: number;
-        canvasActions?: CanvasActions;
-    };
+    renderCustomStats?: (elements: readonly NonDeletedExcalidrawElement[], appState: UIAppState) => JSX.Element;
+    UIOptions?: Partial<UIOptions>;
     detectScroll?: boolean;
     handleKeyboardGlobally?: boolean;
     onLibraryChange?: (libraryItems: LibraryItems) => void | Promise<any>;
@@ -257,12 +334,11 @@ export interface ExcalidrawProps {
     }>) => void;
     onPointerDown?: (activeTool: AppState["activeTool"], pointerDownState: PointerDownState) => void;
     onScrollChange?: (scrollX: number, scrollY: number) => void;
-    /**
-     * Render function that renders custom <Sidebar /> component.
-     */
-    renderSidebar?: () => JSX.Element | null;
+    children?: React.ReactNode;
+    validateEmbeddable?: boolean | string[] | RegExp | RegExp[] | ((link: string) => boolean | undefined);
+    renderEmbeddable?: (element: NonDeleted<ExcalidrawEmbeddableElement>, appState: AppState) => JSX.Element | null;
 }
-export declare type SceneData = {
+export type SceneData = {
     elements?: ImportedDataState["elements"];
     appState?: ImportedDataState["appState"];
     collaborators?: Map<string, Collaborator>;
@@ -273,27 +349,32 @@ export declare enum UserIdleState {
     AWAY = "away",
     IDLE = "idle"
 }
-export declare type ExportOpts = {
+export type ExportOpts = {
     saveFileToDisk?: boolean;
-    onExportToBackend?: (exportedElements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, canvas: HTMLCanvasElement | null) => void;
-    renderCustomUI?: (exportedElements: readonly NonDeletedExcalidrawElement[], appState: AppState, files: BinaryFiles, canvas: HTMLCanvasElement | null) => JSX.Element;
+    onExportToBackend?: (exportedElements: readonly NonDeletedExcalidrawElement[], appState: UIAppState, files: BinaryFiles, canvas: HTMLCanvasElement) => void;
+    renderCustomUI?: (exportedElements: readonly NonDeletedExcalidrawElement[], appState: UIAppState, files: BinaryFiles, canvas: HTMLCanvasElement) => JSX.Element;
 };
-declare type CanvasActions = {
-    changeViewBackgroundColor?: boolean;
-    clearCanvas?: boolean;
-    export?: false | ExportOpts;
-    loadScene?: boolean;
-    saveToActiveFile?: boolean;
-    toggleTheme?: boolean | null;
-    saveAsImage?: boolean;
-};
-export declare type AppProps = Merge<ExcalidrawProps, {
-    UIOptions: {
+type CanvasActions = Partial<{
+    changeViewBackgroundColor: boolean;
+    clearCanvas: boolean;
+    export: false | ExportOpts;
+    loadScene: boolean;
+    saveToActiveFile: boolean;
+    toggleTheme: boolean | null;
+    saveAsImage: boolean;
+}>;
+type UIOptions = Partial<{
+    dockedSidebarBreakpoint: number;
+    canvasActions: CanvasActions;
+    /** @deprecated does nothing. Will be removed in 0.15 */
+    welcomeScreen?: boolean;
+}>;
+export type AppProps = Merge<ExcalidrawProps, {
+    UIOptions: Merge<UIOptions, {
         canvasActions: Required<CanvasActions> & {
             export: ExportOpts;
         };
-        dockedSidebarBreakpoint?: number;
-    };
+    }>;
     detectScroll: boolean;
     handleKeyboardGlobally: boolean;
     isCollaborating: boolean;
@@ -301,20 +382,27 @@ export declare type AppProps = Merge<ExcalidrawProps, {
 }>;
 /** A subset of App class properties that we need to use elsewhere
  * in the app, eg Manager. Factored out into a separate type to keep DRY. */
-export declare type AppClassProperties = {
+export type AppClassProperties = {
     props: AppProps;
-    canvas: HTMLCanvasElement | null;
+    interactiveCanvas: HTMLCanvasElement | null;
+    /** static canvas */
+    canvas: HTMLCanvasElement;
     focusContainer(): void;
     library: Library;
     imageCache: Map<FileId, {
         image: HTMLImageElement | Promise<HTMLImageElement>;
-        mimeType: typeof ALLOWED_IMAGE_MIME_TYPES[number];
+        mimeType: ValueOf<typeof IMAGE_MIME_TYPES>;
     }>;
     files: BinaryFiles;
     device: App["device"];
     scene: App["scene"];
+    pasteFromClipboard: App["pasteFromClipboard"];
+    id: App["id"];
+    onInsertElements: App["onInsertElements"];
+    onExportImage: App["onExportImage"];
+    lastViewportPosition: App["lastViewportPosition"];
 };
-export declare type PointerDownState = Readonly<{
+export type PointerDownState = Readonly<{
     origin: Readonly<{
         x: number;
         y: number;
@@ -373,8 +461,8 @@ export declare type PointerDownState = Readonly<{
         };
     };
 }>;
-declare type UnsubscribeCallback = () => void;
-export declare type ExcalidrawImperativeAPI = {
+type UnsubscribeCallback = () => void;
+export type ExcalidrawImperativeAPI = {
     updateScene: InstanceType<typeof App>["updateScene"];
     updateLibrary: InstanceType<typeof Library>["updateLibrary"];
     resetScene: InstanceType<typeof App>["resetScene"];
@@ -395,16 +483,43 @@ export declare type ExcalidrawImperativeAPI = {
     setActiveTool: InstanceType<typeof App>["setActiveTool"];
     setCursor: InstanceType<typeof App>["setCursor"];
     resetCursor: InstanceType<typeof App>["resetCursor"];
-    toggleMenu: InstanceType<typeof App>["toggleMenu"];
+    toggleSidebar: InstanceType<typeof App>["toggleSidebar"];
+    /**
+     * Disables rendering of frames (including element clipping), but currently
+     * the frames are still interactive in edit mode. As such, this API should be
+     * used in conjunction with view mode (props.viewModeEnabled).
+     */
+    updateFrameRendering: InstanceType<typeof App>["updateFrameRendering"];
     app: InstanceType<typeof App>;
     onChange: (callback: (elements: readonly ExcalidrawElement[], appState: AppState, files: BinaryFiles) => void) => UnsubscribeCallback;
-    onPointerDown: (callback: (activeTool: AppState["activeTool"], pointerDownState: PointerDownState, event: React.PointerEvent<HTMLCanvasElement>) => void) => UnsubscribeCallback;
+    onPointerDown: (callback: (activeTool: AppState["activeTool"], pointerDownState: PointerDownState, event: React.PointerEvent<HTMLElement>) => void) => UnsubscribeCallback;
     onPointerUp: (callback: (activeTool: AppState["activeTool"], pointerDownState: PointerDownState, event: PointerEvent) => void) => UnsubscribeCallback;
 };
-export declare type Device = Readonly<{
+export type Device = Readonly<{
     isSmScreen: boolean;
     isMobile: boolean;
     isTouchScreen: boolean;
     canDeviceFitSidebar: boolean;
+    isLandscape: boolean;
 }>;
+type FrameNameBounds = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    angle: number;
+};
+export type FrameNameBoundsCache = {
+    get: (frameElement: ExcalidrawFrameElement) => FrameNameBounds | null;
+    _cache: Map<string, FrameNameBounds & {
+        zoom: AppState["zoom"]["value"];
+        versionNonce: ExcalidrawFrameElement["versionNonce"];
+    }>;
+};
+export type KeyboardModifiersObject = {
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+};
 export {};

package/types/utility-types.d.ts

@@ -0,0 +1,24 @@
+export type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export type ValueOf<T> = T[keyof T];
+export type Merge<M, N> = Omit<M, keyof N> & N;
+/** utility type to assert that the second type is a subtype of the first type.
+ * Returns the subtype. */
+export type SubtypeOf<Supertype, Subtype extends Supertype> = Subtype;
+export type ResolutionType<T extends (...args: any) => any> = T extends (...args: any) => Promise<infer R> ? R : any;
+export type MarkOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type MarkRequired<T, RK extends keyof T> = Exclude<T, RK> & Required<Pick<T, RK>>;
+export type MarkNonNullable<T, K extends keyof T> = {
+    [P in K]-?: P extends K ? NonNullable<T[P]> : T[P];
+} & {
+    [P in keyof T]: T[P];
+};
+export type NonOptional<T> = Exclude<T, undefined>;
+export type SignatureType<T> = T extends (...args: infer R) => any ? R : never;
+export type CallableType<T extends (...args: any[]) => any> = (...args: SignatureType<T>) => ReturnType<T>;
+export type ForwardRef<T, P = any> = Parameters<CallableType<React.ForwardRefRenderFunction<T, P>>>[1];
+export type ExtractSetType<T extends Set<any>> = T extends Set<infer U> ? U : never;
+export type SameType<T, U> = T extends U ? (U extends T ? true : false) : false;
+export type Assert<T extends true> = T;
+export type NestedKeyOf<T, K = keyof T> = K extends keyof T & (string | number) ? `${K}` | (T[K] extends object ? `${K}.${NestedKeyOf<T[K]>}` : never) : never;

package/types/utils.d.ts

@@ -1,13 +1,14 @@
 import { EVENT } from "./constants";
-import { FontFamilyValues, FontString } from "./element/types";
-import { AppState, LastActiveToolBeforeEraser, Zoom } from "./types";
+import { FontFamilyValues, FontString, NonDeletedExcalidrawElement } from "./element/types";
+import { AppState, LastActiveTool, Zoom } from "./types";
 import { SHAPES } from "./shapes";
 export declare const setDateTimeForTests: (dateTime: string) => void;
 export declare const getDateTime: () => string;
 export declare const capitalizeString: (str: string) => string;
 export declare const isToolIcon: (target: Element | EventTarget | null) => target is HTMLElement;
-export declare const isInputLike: (target: Element | EventTarget | null) => target is HTMLBRElement | HTMLDivElement | HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
-export declare const isWritableElement: (target: Element | EventTarget | null) => target is HTMLBRElement | HTMLDivElement | HTMLInputElement | HTMLTextAreaElement;
+export declare const isInputLike: (target: Element | EventTarget | null) => target is HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | HTMLBRElement | HTMLDivElement;
+export declare const isInteractive: (target: Element | EventTarget | null) => boolean;
+export declare const isWritableElement: (target: Element | EventTarget | null) => target is HTMLInputElement | HTMLTextAreaElement | HTMLBRElement | HTMLDivElement;
 export declare const getFontFamilyString: ({ fontFamily, }: {
     fontFamily: FontFamilyValues;
 }) => string;
@@ -28,22 +29,71 @@ export declare const throttleRAF: <T extends any[]>(fn: (...args: T) => void, op
     flush(): void;
     cancel(): void;
 };
+/**
+ * Exponential ease-out method
+ *
+ * @param {number} k - The value to be tweened.
+ * @returns {number} The tweened value.
+ */
+export declare const easeOut: (k: number) => number;
+/**
+ * Animates values from `fromValues` to `toValues` using the requestAnimationFrame API.
+ * Executes the `onStep` callback on each step with the interpolated values.
+ * Returns a function that can be called to cancel the animation.
+ *
+ * @example
+ * // Example usage:
+ * const fromValues = { x: 0, y: 0 };
+ * const toValues = { x: 100, y: 200 };
+ * const onStep = ({x, y}) => {
+ *   setState(x, y)
+ * };
+ * const onCancel = () => {
+ *   console.log("Animation canceled");
+ * };
+ *
+ * const cancelAnimation = easeToValuesRAF({
+ *   fromValues,
+ *   toValues,
+ *   onStep,
+ *   onCancel,
+ * });
+ *
+ * // To cancel the animation:
+ * cancelAnimation();
+ */
+export declare const easeToValuesRAF: <T extends Record<keyof T, number>, K extends keyof T>({ fromValues, toValues, onStep, duration, interpolateValue, onStart, onEnd, onCancel, }: {
+    fromValues: T;
+    toValues: T;
+    /**
+     * Interpolate a single value.
+     * Return undefined to be handled by the default interpolator.
+     */
+    interpolateValue?: ((fromValue: number, toValue: number, progress: number, key: K) => number | undefined) | undefined;
+    onStep: (values: T) => void;
+    duration?: number | undefined;
+    onStart?: (() => void) | undefined;
+    onEnd?: (() => void) | undefined;
+    onCancel?: (() => void) | undefined;
+}) => () => void;
 export declare const chunk: <T extends unknown>(array: readonly T[], size: number) => T[][];
 export declare const selectNode: (node: Element) => void;
 export declare const removeSelection: () => void;
 export declare const distance: (x: number, y: number) => number;
 export declare const updateActiveTool: (appState: Pick<AppState, "activeTool">, data: ({
-    type: (typeof SHAPES)[number]["value"] | "eraser";
+    type: (typeof SHAPES)[number]["value"] | "eraser" | "hand" | "frame" | "embeddable";
+    locked?: boolean;
 } | {
     type: "custom";
     customType: string;
+    locked?: boolean;
 }) & {
-    lastActiveToolBeforeEraser?: LastActiveToolBeforeEraser;
+    lastActiveToolBeforeEraser?: LastActiveTool;
 }) => AppState["activeTool"];
-export declare const resetCursor: (canvas: HTMLCanvasElement | null) => void;
-export declare const setCursor: (canvas: HTMLCanvasElement | null, cursor: string) => void;
-export declare const setEraserCursor: (canvas: HTMLCanvasElement | null, theme: AppState["theme"]) => void;
-export declare const setCursorForShape: (canvas: HTMLCanvasElement | null, appState: AppState) => void;
+export declare const resetCursor: (interactiveCanvas: HTMLCanvasElement | null) => void;
+export declare const setCursor: (interactiveCanvas: HTMLCanvasElement | null, cursor: string) => void;
+export declare const setEraserCursor: (interactiveCanvas: HTMLCanvasElement | null, theme: AppState["theme"]) => void;
+export declare const setCursorForShape: (interactiveCanvas: HTMLCanvasElement | null, appState: Pick<AppState, "activeTool" | "theme">) => void;
 export declare const isFullScreen: () => boolean;
 export declare const allowFullScreen: () => Promise<void>;
 export declare const exitFullScreen: () => Promise<void>;
@@ -91,7 +141,7 @@ export declare const muteFSAbortError: (error?: Error) => void;
 export declare const findIndex: <T>(array: readonly T[], cb: (element: T, index: number, array: readonly T[]) => boolean, fromIndex?: number) => number;
 export declare const findLastIndex: <T>(array: readonly T[], cb: (element: T, index: number, array: readonly T[]) => boolean, fromIndex?: number) => number;
 export declare const isTransparent: (color: string) => boolean;
-export declare type ResolvablePromise<T> = Promise<T> & {
+export type ResolvablePromise<T> = Promise<T> & {
     resolve: [T] extends [undefined] ? (value?: T) => void : (value: T) => void;
     reject: (error: Error) => void;
 };
@@ -124,13 +174,29 @@ export declare const getUpdatedTimestamp: () => number;
 export declare const arrayToMap: <T extends string | {
     id: string;
 }>(items: readonly T[]) => Map<string, T>;
+export declare const arrayToMapWithIndex: <T extends {
+    id: string;
+}>(elements: readonly T[]) => Map<string, [element: T, index: number]>;
 export declare const isTestEnv: () => boolean;
-export declare const isProdEnv: () => boolean;
 export declare const wrapEvent: <T extends Event>(name: EVENT, nativeEvent: T) => CustomEvent<{
     nativeEvent: T;
 }>;
 export declare const updateObject: <T extends Record<string, any>>(obj: T, updates: Partial<T>) => T;
 export declare const isPrimitive: (val: any) => boolean;
 export declare const getFrame: () => "top" | "iframe";
+export declare const isRunningInIframe: () => boolean;
 export declare const isPromiseLike: (value: any) => value is Promise<any>;
 export declare const queryFocusableElements: (container: HTMLElement | null) => HTMLElement[];
+export declare const isShallowEqual: <T extends Record<string, any>, I extends keyof T>(objA: T, objB: T, comparators?: Record<I, (a: T[I], b: T[I]) => boolean> | undefined, debug?: boolean) => boolean;
+export declare const composeEventHandlers: <E>(originalEventHandler?: ((event: E) => void) | undefined, ourEventHandler?: ((event: E) => void) | undefined, { checkForDefaultPrevented }?: {
+    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;
+/**
+ * Memoizes on values of `opts` object (strict equality).
+ */
+export declare const memoize: <T extends Record<string, any>, R extends unknown>(func: (opts: T) => R) => ((opts: T) => R) & {
+    clear: () => void;
+};
+export declare const isRenderThrottlingEnabled: () => boolean;

package/types/zindex.d.ts

@@ -1,6 +1,6 @@
 import { ExcalidrawElement } from "./element/types";
 import { AppState } from "./types";
-export declare const moveOneLeft: (elements: readonly ExcalidrawElement[], appState: AppState) => (import("./element/types").ExcalidrawLinearElement | import("./element/types").ExcalidrawSelectionElement | import("./element/types").ExcalidrawRectangleElement | import("./element/types").ExcalidrawDiamondElement | import("./element/types").ExcalidrawEllipseElement | import("./element/types").ExcalidrawImageElement | import("./element/types").ExcalidrawTextElement | import("./element/types").ExcalidrawFreeDrawElement)[];
-export declare const moveOneRight: (elements: readonly ExcalidrawElement[], appState: AppState) => (import("./element/types").ExcalidrawLinearElement | import("./element/types").ExcalidrawSelectionElement | import("./element/types").ExcalidrawRectangleElement | import("./element/types").ExcalidrawDiamondElement | import("./element/types").ExcalidrawEllipseElement | import("./element/types").ExcalidrawImageElement | import("./element/types").ExcalidrawTextElement | import("./element/types").ExcalidrawFreeDrawElement)[];
-export declare const moveAllLeft: (elements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[];
-export declare const moveAllRight: (elements: readonly ExcalidrawElement[], appState: AppState) => readonly ExcalidrawElement[];
+export declare const moveOneLeft: (elements: readonly ExcalidrawElement[], appState: AppState, elementsToBeMoved?: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+export declare const moveOneRight: (elements: readonly ExcalidrawElement[], appState: AppState, elementsToBeMoved?: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+export declare const moveAllLeft: (elements: readonly ExcalidrawElement[], appState: AppState, elementsToBeMoved?: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+export declare const moveAllRight: (elements: readonly ExcalidrawElement[], appState: AppState, elementsToBeMoved?: readonly ExcalidrawElement[]) => ExcalidrawElement[];

package/types/components/ActiveFile.d.ts

@@ -1,7 +0,0 @@
-import "./ActiveFile.scss";
-declare type ActiveFileProps = {
-    fileName?: string;
-    onSave: () => void;
-};
-export declare const ActiveFile: ({ fileName, onSave }: ActiveFileProps) => JSX.Element;
-export {};

package/types/components/ClearCanvas.d.ts

@@ -1,4 +0,0 @@
-declare const ClearCanvas: ({ onConfirm }: {
-    onConfirm: () => void;
-}) => JSX.Element;
-export default ClearCanvas;

package/types/components/CollabButton.d.ts

@@ -1,6 +0,0 @@
-import "./CollabButton.scss";
-declare const CollabButton: ({ onClick, isInHamburgerMenu, }: {
-    onClick: () => void;
-    isInHamburgerMenu?: boolean | undefined;
-}) => JSX.Element;
-export default CollabButton;