@excalidraw/excalidraw 0.15.2-6546-9e6751c → 0.15.2-6546-21ca391

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

@@ -1,139 +1,144 @@
-declare namespace _default {
-    const elements: ({
+declare const _default: {
+    elements: readonly (import("../../../element/types").ExcalidrawSelectionElement | import("../../../element/types").ExcalidrawFrameElement | import("../../../element/types").ExcalidrawFreeDrawElement | import("../../../data/transform").ValidLinearElement | ({
+        type: "rectangle" | "diamond" | "ellipse";
+        id?: string | undefined;
+        label?: ({
+            text: string;
+            fontSize?: number | undefined;
+            fontFamily?: number | undefined;
+            textAlign?: string | undefined;
+            verticalAlign?: string | undefined;
+        } & Omit<import("../../../element/newElement").ElementConstructorOpts, "x" | "y"> & Partial<Pick<import("../../../element/newElement").ElementConstructorOpts, "x" | "y">>) | undefined;
+    } & Omit<Omit<import("../../../element/types").ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "link" | "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "angle" | "seed" | "version" | "versionNonce" | "groupIds" | "frameId" | "boundElements" | "locked"> & Partial<Pick<Omit<import("../../../element/types").ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "link" | "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "angle" | "seed" | "version" | "versionNonce" | "groupIds" | "frameId" | "boundElements" | "locked">>) | ({
+        type: "line";
+        x: number;
+        y: number;
+    } & Partial<import("../../../element/types").ExcalidrawLinearElement>) | ({
+        type: "text";
+        text: string;
+        x: number;
+        y: number;
+        id?: string | undefined;
+    } & Partial<import("../../../element/types").ExcalidrawTextElement>) | ({
+        type: "image";
+        x: number;
+        y: number;
+    } & Partial<import("../../../element/types").ExcalidrawImageElement>))[];
+    appState: {
+        viewBackgroundColor: string;
+        currentItemFontFamily: number;
+    };
+    scrollToContent: boolean;
+    libraryItems: ({
         type: string;
         x: number;
         y: number;
-        strokeWidth: string;
-        backgroundColor?: undefined;
-        label?: undefined;
-        start?: undefined;
-        end?: undefined;
-        fileId?: undefined;
-        width?: undefined;
-        height?: undefined;
-        angle?: undefined;
-        strokeColor?: undefined;
-        fillStyle?: undefined;
-        strokeStyle?: undefined;
-        roughness?: undefined;
-        opacity?: undefined;
-        groupIds?: undefined;
-        strokeSharpness?: undefined;
-        seed?: undefined;
-        version?: undefined;
-        versionNonce?: undefined;
-        isDeleted?: undefined;
-        boundElements?: undefined;
-        updated?: undefined;
-        link?: undefined;
-        status?: undefined;
-        scale?: undefined;
-    } | {
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        strokeSharpness: string;
+        points: number[][];
+    }[] | ({
         type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
         x: number;
         y: number;
+        strokeColor: string;
         backgroundColor: string;
-        strokeWidth: string;
-        label: {
-            text: string;
-            strokeColor: string;
-            fontSize: number;
-        };
-        start?: undefined;
-        end?: undefined;
-        fileId?: undefined;
-        width?: undefined;
-        height?: undefined;
-        angle?: undefined;
-        strokeColor?: undefined;
-        fillStyle?: undefined;
-        strokeStyle?: undefined;
+        width: number;
+        height: number;
+        groupIds: string[];
+        points: number[][];
         roughness?: undefined;
         opacity?: undefined;
-        groupIds?: undefined;
-        strokeSharpness?: undefined;
+        angle?: undefined;
         seed?: undefined;
-        version?: undefined;
-        versionNonce?: undefined;
-        isDeleted?: undefined;
-        boundElements?: undefined;
-        updated?: undefined;
-        link?: undefined;
-        status?: undefined;
-        scale?: undefined;
+        strokeSharpness?: undefined;
+        boundElementIds?: undefined;
     } | {
         type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        roughness: number;
+        opacity: number;
+        angle: number;
         x: number;
         y: number;
-        label: {
-            text: string;
-            strokeColor?: undefined;
-            fontSize?: undefined;
-        };
-        start: {
-            type: string;
-        };
-        end: {
-            type: string;
-        };
-        strokeWidth?: undefined;
-        backgroundColor?: undefined;
-        fileId?: undefined;
-        width?: undefined;
-        height?: undefined;
-        angle?: undefined;
-        strokeColor?: undefined;
-        fillStyle?: undefined;
-        strokeStyle?: undefined;
-        roughness?: undefined;
-        opacity?: undefined;
-        groupIds?: undefined;
-        strokeSharpness?: undefined;
-        seed?: undefined;
-        version?: undefined;
-        versionNonce?: undefined;
-        isDeleted?: undefined;
-        boundElements?: undefined;
-        updated?: undefined;
-        link?: undefined;
-        status?: undefined;
-        scale?: undefined;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        boundElementIds?: undefined;
     } | {
-        fileId: string;
         type: 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;
+    } | {
+        type: 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;
+        points?: undefined;
+        boundElementIds?: undefined;
+    })[] | ({
+        type: string;
         fillStyle: string;
         strokeWidth: number;
         strokeStyle: string;
         roughness: number;
         opacity: number;
-        groupIds: never[];
-        strokeSharpness: string;
+        angle: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
         seed: number;
-        version: number;
-        versionNonce: number;
-        isDeleted: boolean;
-        boundElements: null;
-        updated: number;
-        link: null;
-        status: string;
-        scale: number[];
-        label?: undefined;
-        start?: undefined;
-        end?: undefined;
-    })[];
-    namespace appState {
-        const viewBackgroundColor: string;
-        const currentItemFontFamily: number;
-    }
-    const scrollToContent: boolean;
-    const libraryItems: (({
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        version?: undefined;
+        versionNonce?: undefined;
+        isDeleted?: undefined;
+        id?: undefined;
+        boundElementIds?: undefined;
+    } | {
         type: string;
         version: number;
         versionNonce: number;
@@ -154,19 +159,10 @@ declare namespace _default {
         seed: number;
         groupIds: string[];
         strokeSharpness: string;
-        boundElementIds: never[];
-        startBinding: null;
-        endBinding: null;
         points: number[][];
-        lastCommittedPoint: null;
-        startArrowhead: null;
-        endArrowhead: null;
+        boundElementIds?: undefined;
     } | {
         type: string;
-        version: number;
-        versionNonce: number;
-        isDeleted: boolean;
-        id: string;
         fillStyle: string;
         strokeWidth: number;
         strokeStyle: string;
@@ -183,18 +179,13 @@ declare namespace _default {
         groupIds: string[];
         strokeSharpness: string;
         boundElementIds: string[];
-        startBinding?: undefined;
-        endBinding?: undefined;
         points?: undefined;
-        lastCommittedPoint?: undefined;
-        startArrowhead?: undefined;
-        endArrowhead?: undefined;
+        version?: undefined;
+        versionNonce?: undefined;
+        isDeleted?: undefined;
+        id?: undefined;
     })[] | ({
         type: string;
-        version: number;
-        versionNonce: number;
-        isDeleted: boolean;
-        id: string;
         fillStyle: string;
         strokeWidth: number;
         strokeStyle: string;
@@ -210,17 +201,9 @@ declare namespace _default {
         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;
@@ -236,11 +219,95 @@ declare namespace _default {
         seed: number;
         groupIds: string[];
         strokeSharpness: string;
-        boundElementIds: never[];
         points: number[][];
-        lastCommittedPoint: null;
-        startArrowhead: null;
-        endArrowhead: null;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        roughness?: undefined;
+        opacity?: undefined;
+        angle?: undefined;
+        seed?: undefined;
+    } | {
+        type: 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;
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        seed?: undefined;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        opacity: number;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        points: number[][];
+        roughness?: undefined;
+        angle?: undefined;
+    })[] | ({
+        type: 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;
+    } | {
+        type: string;
+        fillStyle: string;
+        strokeWidth: number;
+        strokeStyle: string;
+        x: number;
+        y: number;
+        strokeColor: string;
+        backgroundColor: string;
+        width: number;
+        height: number;
+        seed: number;
+        groupIds: string[];
+        strokeSharpness: string;
+        roughness?: undefined;
+        opacity?: undefined;
+        angle?: undefined;
     })[])[];
-}
+};
 export default _default;

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

@@ -25,3 +25,4 @@ export { useDevice } from "../../components/App";
 export { WelcomeScreen };
 export { LiveCollaborationTrigger };
 export { DefaultSidebar } from "../../components/DefaultSidebar";
+export { normalizeLink } from "../../data/url";

package/types/renderer/renderElement.d.ts

@@ -13,6 +13,7 @@ export interface ExcalidrawElementWithCanvas {
     canvasOffsetX: number;
     canvasOffsetY: number;
     boundTextElementVersion: number | null;
+    containingFrameOpacity: number;
 }
 export declare const DEFAULT_LINK_SIZE = 14;
 type ElementShape = Drawable | Drawable[] | null;
@@ -28,7 +29,7 @@ export declare const setShapeForElement: <T extends ExcalidrawElement>(element:
 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, renderConfig: RenderConfig, appState: AppState) => void;
-export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, offsetX: number, offsetY: number, exportWithDarkMode?: boolean) => void;
+export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, offsetX: number, offsetY: number, exportWithDarkMode?: boolean, exportingFrameId?: string | null) => 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,8 +1,9 @@
 import { RoughCanvas } from "roughjs/bin/canvas";
 import { RoughSVG } from "roughjs/bin/svg";
-import { AppState, BinaryFiles } from "../types";
-import { NonDeletedExcalidrawElement } from "../element/types";
+import { AppState, BinaryFiles, Zoom } from "../types";
+import { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
 import { RenderConfig } from "../scene/types";
+import "canvas-roundrect-polyfill";
 export declare const DEFAULT_SPACING = 2;
 export declare const _renderScene: ({ elements, appState, scale, rc, canvas, renderConfig, }: {
     elements: readonly NonDeletedExcalidrawElement[];
@@ -34,8 +35,16 @@ export declare const renderScene: <T extends boolean = false>(config: {
     atLeastOneVisibleElement: boolean;
     scrollBars: import("../scene/types").ScrollBars | undefined;
 };
-export declare const renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, { offsetX, offsetY, exportWithDarkMode, }?: {
+export declare const isVisibleElement: (element: ExcalidrawElement, canvasWidth: number, canvasHeight: number, viewTransformations: {
+    zoom: Zoom;
+    offsetLeft: number;
+    offsetTop: number;
+    scrollX: number;
+    scrollY: number;
+}) => boolean;
+export declare const renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, { offsetX, offsetY, exportWithDarkMode, exportingFrameId, }?: {
     offsetX?: number | undefined;
     offsetY?: number | undefined;
     exportWithDarkMode?: boolean | undefined;
+    exportingFrameId?: string | null | undefined;
 }) => void;

package/types/renderer/roundRect.d.ts

@@ -8,4 +8,4 @@
  * @param {Number} height The height of the rectangle
  * @param {Number} radius The corner radius
  */
-export declare const roundRect: (context: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, radius: number) => void;
+export declare const roundRect: (context: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, radius: number, strokeColor?: string) => void;

package/types/scene/Scene.d.ts

@@ -1,9 +1,11 @@
-import { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted } from "../element/types";
+import { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameElement } from "../element/types";
 import { LinearElementEditor } from "../element/linearElementEditor";
+import { AppState } from "../types";
 type ElementIdKey = InstanceType<typeof LinearElementEditor>["elementId"];
 type ElementKey = ExcalidrawElement | ElementIdKey;
 type SceneStateCallback = () => void;
 type SceneStateCallbackRemover = () => void;
+export type ExcalidrawElementsIncludingDeleted = readonly ExcalidrawElement[];
 declare class Scene {
     private static sceneMapByElement;
     private static sceneMapById;
@@ -12,9 +14,25 @@ declare class Scene {
     private callbacks;
     private nonDeletedElements;
     private elements;
+    private nonDeletedFrames;
+    private frames;
     private elementsMap;
+    private selectedElementsCache;
     getElementsIncludingDeleted(): readonly ExcalidrawElement[];
     getNonDeletedElements(): readonly NonDeletedExcalidrawElement[];
+    getFramesIncludingDeleted(): readonly ExcalidrawFrameElement[];
+    getSelectedElements(opts: {
+        selectedElementIds: AppState["selectedElementIds"];
+        /**
+         * for specific cases where you need to use elements not from current
+         * scene state. This in effect will likely result in cache-miss, and
+         * the cache won't be updated in this case.
+         */
+        elements?: readonly ExcalidrawElement[];
+        includeBoundTextElement?: boolean;
+        includeElementsInFrames?: boolean;
+    }): NonDeleted<ExcalidrawElement>[];
+    getNonDeletedFrames(): readonly NonDeleted<ExcalidrawFrameElement>[];
     getElement<T extends ExcalidrawElement>(id: T["id"]): T | null;
     getNonDeletedElement(id: ExcalidrawElement["id"]): NonDeleted<ExcalidrawElement> | null;
     /**
@@ -35,6 +53,8 @@ declare class Scene {
     addCallback(cb: SceneStateCallback): SceneStateCallbackRemover;
     destroy(): void;
     insertElementAtIndex(element: ExcalidrawElement, index: number): void;
+    insertElementsAtIndex(elements: ExcalidrawElement[], index: number): void;
+    addNewElement: (element: ExcalidrawElement) => void;
     getElementIndex(elementId: string): number;
 }
 export default Scene;

package/types/scene/export.d.ts

@@ -17,6 +17,7 @@ export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElemen
     viewBackgroundColor: string;
     exportWithDarkMode?: boolean;
     exportEmbedScene?: boolean;
+    renderFrame?: boolean;
 }, files: BinaryFiles | null, opts?: {
     serializeAsJSON?: () => string;
 }) => Promise<SVGSVGElement>;

package/types/scene/selection.d.ts

@@ -1,11 +1,31 @@
 import { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
 import { AppState } from "../types";
-export declare const getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement) => NonDeletedExcalidrawElement[];
-export declare const isSomeElementSelected: (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">) => boolean;
+/**
+ * Frames and their containing elements are not to be selected at the same time.
+ * Given an array of selected elements, if there are frames and their containing elements
+ * we only keep the frames.
+ * @param selectedElements
+ */
+export declare const excludeElementsInFramesFromSelection: <T extends ExcalidrawElement>(selectedElements: readonly T[]) => T[];
+export declare const getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement, excludeElementsInFrames?: boolean) => NonDeletedExcalidrawElement[];
+export declare const isSomeElementSelected: {
+    (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">): boolean;
+    clearCache(): void;
+};
 /**
  * Returns common attribute (picked by `getAttribute` callback) of selected
  *  elements. If elements don't share the same value, returns `null`.
  */
 export declare const getCommonAttributeOfSelectedElements: <T>(elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">, getAttribute: (element: ExcalidrawElement) => T) => T | null;
-export declare const getSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">, includeBoundTextElement?: boolean) => NonDeletedExcalidrawElement[];
-export declare const getTargetElements: (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds" | "editingElement">) => NonDeletedExcalidrawElement[];
+export declare const getSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">, opts?: {
+    includeBoundTextElement?: boolean;
+    includeElementsInFrames?: boolean;
+}) => ExcalidrawElement[];
+export declare const getTargetElements: (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds" | "editingElement">) => ExcalidrawElement[];
+/**
+ * returns prevState's selectedElementids if no change from previous, so as to
+ * retain reference identity for memoization
+ */
+export declare const makeNextSelectedElementIds: (nextSelectedElementIds: AppState["selectedElementIds"], prevState: Pick<AppState, "selectedElementIds">) => Readonly<{
+    [id: string]: true;
+}>;

package/types/types.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, ChartType, FontFamilyValues, FileId, ExcalidrawImageElement, Theme, StrokeRoundness } from "./element/types";
+import { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, ChartType, FontFamilyValues, FileId, ExcalidrawImageElement, Theme, StrokeRoundness, ExcalidrawFrameElement } from "./element/types";
 import { SHAPES } from "./shapes";
 import { Point as RoughPoint } from "roughjs/bin/geometry";
 import { LinearElementEditor } from "./element/linearElementEditor";
@@ -57,7 +57,7 @@ export type BinaryFileData = {
 export type BinaryFileMetadata = Omit<BinaryFileData, "dataURL">;
 export type BinaryFiles = Record<ExcalidrawElement["id"], BinaryFileData>;
 export type LastActiveTool = {
-    type: typeof SHAPES[number]["value"] | "eraser" | "hand";
+    type: typeof SHAPES[number]["value"] | "eraser" | "hand" | "frame";
     customType: null;
 } | {
     type: "custom";
@@ -81,6 +81,15 @@ export 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: {
@@ -91,7 +100,7 @@ export type AppState = {
         lastActiveTool: LastActiveTool;
         locked: boolean;
     } & ({
-        type: typeof SHAPES[number]["value"] | "eraser" | "hand";
+        type: typeof SHAPES[number]["value"] | "eraser" | "hand" | "frame";
         customType: null;
     } | {
         type: "custom";
@@ -141,12 +150,13 @@ export type 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;
@@ -411,6 +421,12 @@ export type ExcalidrawImperativeAPI = {
     setCursor: InstanceType<typeof App>["setCursor"];
     resetCursor: InstanceType<typeof App>["resetCursor"];
     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"];
 };
 export type Device = Readonly<{
     isSmScreen: boolean;
@@ -419,4 +435,18 @@ export type Device = Readonly<{
     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 {};

package/types/utility-types.d.ts

@@ -20,3 +20,5 @@ 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;