@zsviczian/excalidraw 0.16.1-obsidian-7 → 0.17.0-obsidian-1

package/types/components/App.d.ts

@@ -2,8 +2,9 @@ import React from "react";
 import { RoughCanvas } from "roughjs/bin/canvas";
 import { ActionManager } from "../actions/manager";
 import { EXPORT_IMAGE_TYPES } from "../constants";
+import { ExportedElements } from "../data";
 import { LinearElementEditor } from "../element/linearElementEditor";
-import { ExcalidrawElement, ExcalidrawLinearElement, NonDeleted, NonDeletedExcalidrawElement } from "../element/types";
+import { ExcalidrawElement, ExcalidrawLinearElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawFrameElement } from "../element/types";
 import History from "../history";
 import Scene from "../scene/Scene";
 import { AppClassProperties, AppProps, AppState, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, SceneData, Device, FrameNameBoundsCache, SidebarName, SidebarTabName, ToolType } from "../types";
@@ -19,11 +20,15 @@ export declare const ExcalidrawContainerContext: React.Context<{
 export declare const useApp: () => AppClassProperties;
 export declare const useAppProps: () => AppProps;
 export declare const useDevice: () => Readonly<{
-    isSmScreen: boolean;
-    isMobile: boolean;
+    viewport: {
+        isMobile: boolean;
+        isLandscape: boolean;
+    };
+    editor: {
+        isMobile: boolean;
+        canFitSidebar: boolean;
+    };
     isTouchScreen: boolean;
-    canDeviceFitSidebar: boolean;
-    isLandscape: boolean;
 }>;
 export declare const useExcalidrawContainer: () => {
     container: HTMLDivElement | null;
@@ -40,7 +45,6 @@ declare class App extends React.Component<AppProps, AppState> {
     unmounted: boolean;
     actionManager: ActionManager;
     device: Device;
-    detachIsMobileMqHandler?: () => void;
     private excalidrawContainerRef;
     static defaultProps: Partial<AppProps>;
     scene: Scene;
@@ -222,7 +226,9 @@ declare class App extends React.Component<AppProps, AppState> {
     getSceneElementsIncludingDeleted: () => readonly ExcalidrawElement[];
     getSceneElements: () => readonly NonDeletedExcalidrawElement[];
     onInsertElements: (elements: readonly ExcalidrawElement[]) => void;
-    onExportImage: (type: keyof typeof EXPORT_IMAGE_TYPES, elements: readonly NonDeletedExcalidrawElement[]) => Promise<void>;
+    onExportImage: (type: keyof typeof EXPORT_IMAGE_TYPES, elements: ExportedElements, opts: {
+        exportingFrame: ExcalidrawFrameElement | null;
+    }) => Promise<void>;
     private openEyeDropper;
     private syncActionResult;
     private onBlur;
@@ -235,7 +241,9 @@ declare class App extends React.Component<AppProps, AppState> {
      */
     private resetScene;
     private initializeScene;
-    private refreshDeviceState;
+    private isMobileBreakpoint;
+    private refreshViewportBreakpoints;
+    private refreshEditorBreakpoints;
     componentDidMount(): Promise<void>;
     componentWillUnmount(): void;
     private onResize;
@@ -246,12 +254,10 @@ declare class App extends React.Component<AppProps, AppState> {
     private onScroll;
     private onCut;
     private onCopy;
-    private cutAll;
-    private copyAll;
     private static resetTapTwice;
     private onTouchStart;
     private onTouchEnd;
-    pasteFromClipboard: (event: ClipboardEvent | null) => Promise<void>;
+    pasteFromClipboard: (event: ClipboardEvent) => Promise<void>;
     addElementsFromPasteOrLibrary: (opts: {
         elements: readonly ExcalidrawElement[];
         files: BinaryFiles | null;
@@ -273,7 +279,7 @@ declare class App extends React.Component<AppProps, AppState> {
         outline: boolean;
         clip: boolean;
     }> | ((prevState: AppState["frameRendering"]) => Partial<AppState["frameRendering"]>)) => void;
-    togglePenMode: (force?: boolean) => void;
+    togglePenMode: (force: boolean | null) => void;
     onHandToolToggle: () => void;
     /**
      * Zooms on canvas viewport center
@@ -335,6 +341,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private onKeyDown;
     private onWheel;
     private onKeyUp;
+    private isToolSupported;
     setActiveTool: (tool: (({
         type: Exclude<ToolType, "image">;
     } | {
@@ -346,6 +353,7 @@ declare class App extends React.Component<AppProps, AppState> {
     }) & {
         locked?: boolean;
     }) => void;
+    setOpenDialog: (dialogType: AppState["openDialog"]) => void;
     private setCursor;
     private resetCursor;
     /**

package/types/components/ContextMenu.d.ts

@@ -9,7 +9,8 @@ type ContextMenuProps = {
     items: ContextMenuItems;
     top: number;
     left: number;
+    onClose: (callback?: () => void) => void;
 };
 export declare const CONTEXT_MENU_SEPARATOR = "separator";
-export declare const ContextMenu: React.MemoExoticComponent<({ actionManager, items, top, left }: ContextMenuProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const ContextMenu: React.MemoExoticComponent<({ actionManager, items, top, left, onClose }: ContextMenuProps) => import("react/jsx-runtime").JSX.Element>;
 export {};

package/types/components/ImageExportDialog.d.ts

@@ -10,4 +10,4 @@ export declare const ImageExportDialog: ({ elements, appState, files, actionMana
     actionManager: ActionManager;
     onExportImage: AppClassProperties["onExportImage"];
     onCloseRequest: () => void;
-}) => import("react/jsx-runtime").JSX.Element | null;
+}) => import("react/jsx-runtime").JSX.Element;

package/types/components/LayerUI.d.ts

@@ -14,7 +14,7 @@ interface LayerUIProps {
     elements: readonly NonDeletedExcalidrawElement[];
     onLockToggle: () => void;
     onHandToolToggle: () => void;
-    onPenModeToggle: () => void;
+    onPenModeToggle: AppClassProperties["togglePenMode"];
     showExitZenModeBtn: boolean;
     langCode: Language["code"];
     renderTopRightUI?: ExcalidrawProps["renderTopRightUI"];

package/types/components/MermaidToExcalidraw.d.ts

@@ -6,7 +6,7 @@ declare const MermaidToExcalidraw: ({ selectedElements, }: {
     selectedElements: readonly NonDeletedExcalidrawElement[];
 }) => import("react/jsx-runtime").JSX.Element;
 export default MermaidToExcalidraw;
-export declare const mermaidToExcalidraw: (mermaidDefinition: string, opts?: MermaidOptions) => Promise<{
+export declare const mermaidToExcalidraw: (mermaidDefinition: string, opts?: MermaidOptions, forceSVG?: boolean) => Promise<{
     elements: ExcalidrawElement[];
     files: any;
 } | undefined>;

package/types/components/MobileMenu.d.ts

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

package/types/components/Modal.d.ts

@@ -9,5 +9,7 @@ export declare const Modal: React.FC<{
     labelledBy: string;
     theme?: AppState["theme"];
     closeOnClickOutside?: boolean;
-    style: string;
+    style: {
+        [x: string]: string;
+    };
 }>;

package/types/constants.d.ts

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

package/types/data/index.d.ts

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

package/types/data/transform.d.ts

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

package/types/element/Hyperlink.d.ts

@@ -89,7 +89,7 @@ export declare const actionLink: {
                 name: string;
                 tab?: string | undefined;
             } | null;
-            openDialog: "imageExport" | "help" | "jsonExport" | null;
+            openDialog: "mermaid" | "imageExport" | "help" | "jsonExport" | null;
             defaultSidebarDockedPreference: boolean;
             lastPointerDownWith: import("./types").PointerType;
             selectedElementIds: Readonly<{
@@ -153,7 +153,14 @@ export declare const actionLink: {
                 Regular: string;
                 MajorGridFrequency?: number | undefined;
             };
-            dynamicStyle: string;
+            dynamicStyle: {
+                [x: string]: string;
+            };
+            frameColor: {
+                stroke: string;
+                fill: string;
+                nameColor: string;
+            };
             invertBindingBehaviour: boolean;
             selectedLinearElement: import("./linearElementEditor").LinearElementEditor | null;
             snapLines: readonly import("../snapping").SnapLine[];
@@ -177,7 +184,7 @@ export declare const actionLink: {
     keyTest?: ((event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean) | undefined;
 };
 export declare const getContextMenuLabel: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState) => "labels.link.editEmbed" | "labels.link.edit" | "labels.link.createEmbed" | "labels.link.create";
-export declare const getLinkHandleFromCoords: ([x1, y1, x2, y2]: Bounds, angle: number, appState: Pick<UIAppState, "zoom">) => [x: number, y: number, width: number, height: number];
+export declare const getLinkHandleFromCoords: ([x1, y1, x2, y2]: Bounds, angle: number, appState: Pick<UIAppState, "zoom">) => Bounds;
 export declare const isPointHittingLinkIcon: (element: NonDeletedExcalidrawElement, appState: AppState, [x, y]: readonly [number, number]) => boolean;
 export declare const isPointHittingLink: (element: NonDeletedExcalidrawElement, appState: AppState, [x, y]: readonly [number, number], isMobile: boolean) => boolean;
 export declare const showHyperlinkTooltip: (element: NonDeletedExcalidrawElement, appState: AppState) => void;

package/types/element/bounds.d.ts

@@ -1,4 +1,4 @@
-import { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, NonDeleted } from "./types";
+import { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, ExcalidrawFreeDrawElement, NonDeleted } from "./types";
 import { Drawable, Op } from "roughjs/bin/core";
 import { Point } from "../types";
 export type RectangleBox = {
@@ -8,7 +8,12 @@ export type RectangleBox = {
     height: number;
     angle: number;
 };
-export type Bounds = readonly [x1: number, y1: number, x2: number, y2: number];
+export type Bounds = readonly [
+    minX: number,
+    minY: number,
+    maxX: number,
+    maxY: number
+];
 export declare class ElementBounds {
     private static boundsCache;
     static getBounds(element: ExcalidrawElement): Bounds;
@@ -25,7 +30,8 @@ export declare const getRectangleBoxAbsoluteCoords: (boxSceneCoords: RectangleBo
 export declare const pointRelativeTo: (element: ExcalidrawElement, absoluteCoords: readonly [number, number]) => readonly [number, number];
 export declare const getDiamondPoints: (element: ExcalidrawElement) => number[];
 export declare const getCurvePathOps: (shape: Drawable) => Op[];
-export declare const getMinMaxXYFromCurvePathOps: (ops: Op[], transformXY?: ((x: number, y: number) => [number, number]) | undefined) => [number, number, number, number];
+export declare const getMinMaxXYFromCurvePathOps: (ops: Op[], transformXY?: ((x: number, y: number) => [number, number]) | undefined) => Bounds;
+export declare const getBoundsFromPoints: (points: ExcalidrawFreeDrawElement["points"]) => Bounds;
 export declare const getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead) => number[] | null;
 export declare const getElementBounds: (element: ExcalidrawElement) => Bounds;
 export declare const getCommonBounds: (elements: readonly ExcalidrawElement[]) => Bounds;
@@ -33,8 +39,8 @@ export declare const getDraggedElementsBounds: (elements: ExcalidrawElement[], d
     x: number;
     y: number;
 }) => number[];
-export declare const getResizedElementAbsoluteCoords: (element: ExcalidrawElement, nextWidth: number, nextHeight: number, normalizePoints: boolean) => [number, number, number, number];
-export declare const getElementPointsCoords: (element: ExcalidrawLinearElement, points: readonly (readonly [number, number])[]) => [number, number, number, number];
+export declare const getResizedElementAbsoluteCoords: (element: ExcalidrawElement, nextWidth: number, nextHeight: number, normalizePoints: boolean) => Bounds;
+export declare const getElementPointsCoords: (element: ExcalidrawLinearElement, points: readonly (readonly [number, number])[]) => Bounds;
 export declare const getClosestElementBounds: (elements: readonly ExcalidrawElement[], from: {
     x: number;
     y: number;

package/types/element/embeddable.d.ts

@@ -14,7 +14,7 @@ type EmbeddedLink = ({
     srcdoc: (theme: Theme) => string;
 })) | null;
 export declare const getEmbedLink: (link: string | null | undefined) => EmbeddedLink;
-export declare const isEmbeddableOrFrameLabel: (element: NonDeletedExcalidrawElement) => Boolean;
+export declare const isEmbeddableOrLabel: (element: NonDeletedExcalidrawElement) => Boolean;
 export declare const createPlaceholderEmbeddableLabel: (element: ExcalidrawEmbeddableElement) => ExcalidrawElement;
 export declare const actionSetEmbeddableAsActiveTool: {
     name: "setEmbeddableAsActiveTool";
@@ -94,7 +94,7 @@ export declare const actionSetEmbeddableAsActiveTool: {
                 name: string;
                 tab?: string | undefined;
             } | null;
-            openDialog: "imageExport" | "help" | "jsonExport" | null;
+            openDialog: "mermaid" | "imageExport" | "help" | "jsonExport" | null;
             defaultSidebarDockedPreference: boolean;
             lastPointerDownWith: import("./types").PointerType;
             selectedElementIds: Readonly<{
@@ -159,7 +159,14 @@ export declare const actionSetEmbeddableAsActiveTool: {
                 Regular: string;
                 MajorGridFrequency?: number | undefined;
             };
-            dynamicStyle: string;
+            dynamicStyle: {
+                [x: string]: string;
+            };
+            frameColor: {
+                stroke: string;
+                fill: string;
+                nameColor: string;
+            };
             invertBindingBehaviour: boolean;
             selectedLinearElement: import("./linearElementEditor").LinearElementEditor | null;
             snapLines: readonly import("../snapping").SnapLine[];

package/types/element/linearElementEditor.d.ts

@@ -1,4 +1,5 @@
 import { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer } from "./types";
+import { Bounds } from "./bounds";
 import { Point, AppState, PointerCoords, InteractiveCanvasAppState } from "../types";
 import History from "../history";
 import Scene from "../scene/Scene";
@@ -191,7 +192,7 @@ export declare class LinearElementEditor {
                 name: string;
                 tab?: string | undefined;
             } | null;
-            openDialog: "imageExport" | "help" | "jsonExport" | null;
+            openDialog: "mermaid" | "imageExport" | "help" | "jsonExport" | null;
             defaultSidebarDockedPreference: boolean;
             lastPointerDownWith: import("./types").PointerType;
             selectedElementIds: Readonly<{
@@ -256,7 +257,14 @@ export declare class LinearElementEditor {
                 Regular: string;
                 MajorGridFrequency?: number | undefined;
             };
-            dynamicStyle: string;
+            dynamicStyle: {
+                [x: string]: string;
+            };
+            frameColor: {
+                stroke: string;
+                fill: string;
+                nameColor: string;
+            };
             invertBindingBehaviour: boolean;
             selectedLinearElement: LinearElementEditor | null;
             snapLines: readonly import("../snapping").SnapLine[];
@@ -290,7 +298,7 @@ export declare class LinearElementEditor {
         x: number;
         y: number;
     };
-    static getMinMaxXYWithBoundText: (element: ExcalidrawLinearElement, elementBounds: [number, number, number, number], boundTextElement: ExcalidrawTextElementWithContainer) => [number, number, number, number, number, number];
+    static getMinMaxXYWithBoundText: (element: ExcalidrawLinearElement, elementBounds: Bounds, boundTextElement: ExcalidrawTextElementWithContainer) => [number, number, number, number, number, number];
     static getElementAbsoluteCoords: (element: ExcalidrawLinearElement, includeBoundText?: boolean) => [number, number, number, number, number, number];
 }
 export {};

package/types/element/newElement.d.ts

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

package/types/element/resizeTest.d.ts

@@ -1,12 +1,13 @@
 import { ExcalidrawElement, PointerType, NonDeletedExcalidrawElement } from "./types";
 import { MaybeTransformHandleType } from "./transformHandles";
 import { AppState, Zoom } from "../types";
+import { Bounds } from "./bounds";
 export declare const resizeTest: (element: NonDeletedExcalidrawElement, appState: AppState, x: number, y: number, zoom: Zoom, pointerType: PointerType) => MaybeTransformHandleType;
 export declare const getElementWithTransformHandleType: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType) => {
     element: NonDeletedExcalidrawElement;
     transformHandleType: MaybeTransformHandleType;
 } | null;
-export declare const getTransformHandleTypeFromCoords: ([x1, y1, x2, y2]: readonly [number, number, number, number], scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType) => MaybeTransformHandleType;
+export declare const getTransformHandleTypeFromCoords: ([x1, y1, x2, y2]: Bounds, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType) => MaybeTransformHandleType;
 export declare const getCursorForResizingElement: (resizingElement: {
     element?: ExcalidrawElement;
     transformHandleType: MaybeTransformHandleType;

package/types/element/transformHandles.d.ts

@@ -1,8 +1,9 @@
 import { ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
+import { Bounds } from "./bounds";
 import { InteractiveCanvasAppState, Zoom } from "../types";
 export type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
 export type TransformHandleType = TransformHandleDirection | "rotation";
-export type TransformHandle = [number, number, number, number];
+export type TransformHandle = Bounds;
 export type TransformHandles = Partial<{
     [T in TransformHandleType]: TransformHandle;
 }>;

package/types/element/typeChecks.d.ts

@@ -16,7 +16,7 @@ export declare const isBindingElement: (element?: ExcalidrawElement | null, incl
 export declare const isBindingElementType: (elementType: AppState["activeTool"]["type"]) => boolean;
 export declare const isBindableElement: (element: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawBindableElement;
 export declare const isTextBindableContainer: (element: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawTextContainer;
-export declare const isExcalidrawElement: (element: any) => boolean;
+export declare const isExcalidrawElement: (element: any) => element is ExcalidrawElement;
 export declare const hasBoundTextElement: (element: ExcalidrawElement | null) => element is MarkNonNullable<ExcalidrawBindableElement, "boundElements">;
 export declare const isBoundToContainer: (element: ExcalidrawElement | null) => element is ExcalidrawTextElementWithContainer;
 export declare const isUsingAdaptiveRadius: (type: string) => boolean;

package/types/element/types.d.ts

@@ -83,6 +83,7 @@ export type ExcalidrawEmbeddableElement = _ExcalidrawElementBase & Readonly<{
      * may not have access to host-app supplied url validator during restore.
      */
     validated: boolean | null;
+    scale: [number, number];
 }>;
 export type ExcalidrawImageElement = _ExcalidrawElementBase & Readonly<{
     type: "image";

package/types/errors.d.ts

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

package/types/frame.d.ts

@@ -2,6 +2,7 @@ import { ExcalidrawElement, ExcalidrawFrameElement, NonDeleted, NonDeletedExcali
 import { AppClassProperties, AppState, StaticCanvasAppState } from "./types";
 import { ExcalidrawElementsIncludingDeleted } from "./scene/Scene";
 export declare const bindElementsToFramesAfterDuplication: (nextElements: ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+export declare function isElementIntersectingFrame(element: ExcalidrawElement, frame: ExcalidrawFrameElement): boolean;
 export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameElement) => ExcalidrawElement[];
 export declare const isElementContainingFrame: (elements: readonly ExcalidrawElement[], element: ExcalidrawElement, frame: ExcalidrawFrameElement) => boolean;
 export declare const getElementsIntersectingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameElement) => ExcalidrawElement[];
@@ -17,7 +18,17 @@ export declare const groupsAreCompletelyOutOfFrame: (elements: readonly NonDelet
  * Returns a map of frameId to frame elements. Includes empty frames.
  */
 export declare const groupByFrames: (elements: readonly ExcalidrawElement[]) => Map<string, ExcalidrawElement[]>;
-export declare const getFrameElements: (allElements: ExcalidrawElementsIncludingDeleted, frameId: string) => ExcalidrawElement[];
+export declare const getFrameChildren: (allElements: ExcalidrawElementsIncludingDeleted, frameId: string) => ExcalidrawElement[];
+export declare const getFrameElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawFrameElement[];
+/**
+ * Returns ExcalidrawFrameElements and non-frame-children elements.
+ *
+ * Considers children as root elements if they point to a frame parent
+ * non-existing in the elements set.
+ *
+ * Considers non-frame bound elements (container or arrow labels) as root.
+ */
+export declare const getRootElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawElement[];
 export declare const getElementsInResizingFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
 export declare const getElementsInNewFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement) => ExcalidrawElement[];
 export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap?: Map<string, ExcalidrawElement>) => ExcalidrawFrameElement | null;

package/types/hooks/useCreatePortalContainer.d.ts

@@ -1,5 +1,7 @@
 export declare const useCreatePortalContainer: (opts?: {
-    className?: string;
-    parentSelector?: string;
-    style?: string;
-}) => HTMLDivElement | null;
+    className?: string | undefined;
+    parentSelector?: string | undefined;
+    style?: {
+        [x: string]: string;
+    } | undefined;
+} | undefined) => HTMLDivElement | null;

package/types/math.d.ts

@@ -30,3 +30,4 @@ export declare const arePointsEqual: (p1: readonly [number, number], p2: readonl
 export declare const isRightAngle: (angle: number) => boolean;
 export declare const rangesOverlap: ([a0, a1]: [number, number], [b0, b1]: [number, number]) => boolean;
 export declare const rangeIntersection: (rangeA: [number, number], rangeB: [number, number]) => [number, number] | null;
+export declare const isValueInRange: (value: number, min: number, max: number) => boolean;

package/types/packages/bbox.d.ts

@@ -0,0 +1,11 @@
+import { Bounds } from "../element/bounds";
+import { Point } from "../types";
+export type LineSegment = [Point, Point];
+export declare function getBBox(line: LineSegment): Bounds;
+export declare function crossProduct(a: Point, b: Point): number;
+export declare function doBBoxesIntersect(a: Bounds, b: Bounds): boolean;
+export declare function translate(a: Point, b: Point): Point;
+export declare function isPointOnLine(l: LineSegment, p: Point): boolean;
+export declare function isPointRightOfLine(l: LineSegment, p: Point): boolean;
+export declare function isLineSegmentTouchingOrCrossingLine(a: LineSegment, b: LineSegment): boolean;
+export declare function doLineSegmentsIntersect(a: LineSegment, b: LineSegment): boolean;

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

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