@dwelle/excalidraw 0.4.0-e1bdbb6 → 0.4.0-e587816

package/types/snapping.d.ts

@@ -0,0 +1,108 @@
+import { Bounds } from "./element/bounds";
+import { MaybeTransformHandleType } from "./element/transformHandles";
+import { ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
+import { AppState, KeyboardModifiersObject, Point } from "./types";
+export declare const getSnapDistance: (zoomValue: number) => number;
+type Vector2D = {
+    x: number;
+    y: number;
+};
+type PointPair = [Point, Point];
+export type PointSnap = {
+    type: "point";
+    points: PointPair;
+    offset: number;
+};
+export type Gap = {
+    startBounds: Bounds;
+    endBounds: Bounds;
+    startSide: [Point, Point];
+    endSide: [Point, Point];
+    overlap: [number, number];
+    length: number;
+};
+export type GapSnap = {
+    type: "gap";
+    direction: "center_horizontal" | "center_vertical" | "side_left" | "side_right" | "side_top" | "side_bottom";
+    gap: Gap;
+    offset: number;
+};
+export type GapSnaps = GapSnap[];
+export type Snap = GapSnap | PointSnap;
+export type Snaps = Snap[];
+export type PointSnapLine = {
+    type: "points";
+    points: Point[];
+};
+export type PointerSnapLine = {
+    type: "pointer";
+    points: PointPair;
+    direction: "horizontal" | "vertical";
+};
+export type GapSnapLine = {
+    type: "gap";
+    direction: "horizontal" | "vertical";
+    points: PointPair;
+};
+export type SnapLine = PointSnapLine | GapSnapLine | PointerSnapLine;
+export declare class SnapCache {
+    private static referenceSnapPoints;
+    private static visibleGaps;
+    static setReferenceSnapPoints: (snapPoints: Point[] | null) => void;
+    static getReferenceSnapPoints: () => (readonly [number, number])[] | null;
+    static setVisibleGaps: (gaps: {
+        verticalGaps: Gap[];
+        horizontalGaps: Gap[];
+    } | null) => void;
+    static getVisibleGaps: () => {
+        verticalGaps: Gap[];
+        horizontalGaps: Gap[];
+    } | null;
+    static destroy: () => void;
+}
+export declare const isSnappingEnabled: ({ event, appState, selectedElements, }: {
+    appState: AppState;
+    event: KeyboardModifiersObject;
+    selectedElements: NonDeletedExcalidrawElement[];
+}) => boolean;
+export declare const areRoughlyEqual: (a: number, b: number, precision?: number) => boolean;
+export declare const getElementsCorners: (elements: ExcalidrawElement[], { omitCenter, boundingBoxCorners, dragOffset, }?: {
+    omitCenter?: boolean | undefined;
+    boundingBoxCorners?: boolean | undefined;
+    dragOffset?: Vector2D | undefined;
+}) => Point[];
+export declare const getVisibleGaps: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState) => {
+    horizontalGaps: Gap[];
+    verticalGaps: Gap[];
+};
+export declare const getReferenceSnapPoints: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState) => (readonly [number, number])[];
+export declare const snapDraggedElements: (selectedElements: ExcalidrawElement[], dragOffset: Vector2D, appState: AppState, event: KeyboardModifiersObject) => {
+    snapOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: (PointSnapLine | GapSnapLine)[];
+};
+export declare const snapResizingElements: (selectedElements: ExcalidrawElement[], selectedOriginalElements: ExcalidrawElement[], appState: AppState, event: KeyboardModifiersObject, dragOffset: Vector2D, transformHandle: MaybeTransformHandleType) => {
+    snapOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: PointSnapLine[];
+};
+export declare const snapNewElement: (draggingElement: ExcalidrawElement, appState: AppState, event: KeyboardModifiersObject, origin: Vector2D, dragOffset: Vector2D) => {
+    snapOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: PointSnapLine[];
+};
+export declare const getSnapLinesAtPointer: (elements: readonly ExcalidrawElement[], appState: AppState, pointer: Vector2D, event: KeyboardModifiersObject) => {
+    originOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: PointerSnapLine[];
+};
+export declare const isActiveToolNonLinearSnappable: (activeToolType: AppState["activeTool"]["type"]) => boolean;
+export {};

package/types/types.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="react" />
-import { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, ChartType, FontFamilyValues, FileId, ExcalidrawImageElement, Theme } from "./element/types";
-import { SHAPES } from "./shapes";
+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 { Point as RoughPoint } from "roughjs/bin/geometry";
 import { LinearElementEditor } from "./element/linearElementEditor";
 import { SuggestedBinding } from "./element/binding";
@@ -14,13 +13,13 @@ 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 = {
-    pointer?: {
-        x: number;
-        y: number;
-    };
+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?: CollaboratorPointer;
     button?: "up" | "down";
     selectedElementIds?: AppState["selectedElementIds"];
     username?: string | null;
@@ -32,11 +31,29 @@ export declare type Collaborator = {
     avatarUrl?: string;
     id?: string;
 };
-export declare type DataURL = string & {
+export type CollaboratorPointer = {
+    x: number;
+    y: number;
+    tool: "pointer" | "laser";
+    /**
+     * Whether to render cursor + username. Useful when you only want to render
+     * laser trail.
+     *
+     * @default true
+     */
+    renderCursor?: boolean;
+    /**
+     * Explicit laser color.
+     *
+     * @default string collaborator's cursor color
+     */
+    laserColor?: 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 +69,70 @@ 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 ToolType = "selection" | "rectangle" | "diamond" | "ellipse" | "arrow" | "line" | "freedraw" | "text" | "image" | "eraser" | "hand" | "frame" | "embeddable" | "laser";
+export type ActiveTool = {
+    type: ToolType;
     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 +140,25 @@ 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;
-        locked: boolean;
-        customType: null;
-    } | {
-        type: "custom";
-        customType: string;
-        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: ActiveTool | null;
         locked: boolean;
-    };
+    } & ActiveTool;
     penMode: boolean;
     penDetected: boolean;
     exportBackground: boolean;
@@ -101,10 +175,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 +188,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 +246,25 @@ export declare type AppState = {
     pendingImageElementId: ExcalidrawImageElement["id"] | null;
     showHyperlinkPopup: false | "info" | "editor";
     selectedLinearElement: LinearElementEditor | null;
+    snapLines: readonly 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 +278,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 +291,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,37 +307,33 @@ 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: {
             x: number;
             y: number;
+            tool: "pointer" | "laser";
         };
         button: "down" | "up";
         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 +344,19 @@ 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;
+    interactive?: boolean;
+    ui?: boolean;
+    activeTool?: {
+        type: ToolType;
+    } | {
+        type: "custom";
+        customType: string;
+    };
 }
-export declare type SceneData = {
+export type SceneData = {
     elements?: ImportedDataState["elements"];
     appState?: ImportedDataState["appState"];
     collaborators?: Map<string, Collaborator>;
@@ -273,27 +367,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;
-};
-declare type CanvasActions = {
-    changeViewBackgroundColor?: boolean;
-    clearCanvas?: boolean;
-    export?: false | ExportOpts;
-    loadScene?: boolean;
-    saveToActiveFile?: boolean;
-    toggleTheme?: boolean | null;
-    saveAsImage?: boolean;
+    onExportToBackend?: (exportedElements: readonly NonDeletedExcalidrawElement[], appState: UIAppState, files: BinaryFiles, canvas: HTMLCanvasElement) => void;
+    renderCustomUI?: (exportedElements: readonly NonDeletedExcalidrawElement[], appState: UIAppState, files: BinaryFiles, canvas: HTMLCanvasElement) => JSX.Element;
 };
-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 +400,29 @@ 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"];
+    togglePenMode: App["togglePenMode"];
+    setActiveTool: App["setActiveTool"];
 };
-export declare type PointerDownState = Readonly<{
+export type PointerDownState = Readonly<{
     origin: Readonly<{
         x: number;
         y: number;
@@ -373,8 +481,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 +503,44 @@ 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 type Primitive = number | string | boolean | bigint | symbol | null | undefined;
 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;