@dwelle/excalidraw 0.4.0-9db4535 → 0.4.0-9fa56da

package/types/components/canvases/StaticCanvas.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import { RoughCanvas } from "roughjs/bin/canvas";
+import type { StaticCanvasAppState } from "../../types";
+import type { StaticCanvasRenderConfig } from "../../scene/types";
+import type { NonDeletedExcalidrawElement } from "../../element/types";
+type StaticCanvasProps = {
+    canvas: HTMLCanvasElement;
+    rc: RoughCanvas;
+    elements: readonly NonDeletedExcalidrawElement[];
+    visibleElements: readonly NonDeletedExcalidrawElement[];
+    versionNonce: number | undefined;
+    selectionNonce: number | undefined;
+    scale: number;
+    appState: StaticCanvasAppState;
+    renderConfig: StaticCanvasRenderConfig;
+};
+declare const _default: React.MemoExoticComponent<(props: StaticCanvasProps) => JSX.Element>;
+export default _default;

package/types/components/canvases/index.d.ts

@@ -0,0 +1,3 @@
+import InteractiveCanvas from "./InteractiveCanvas";
+import StaticCanvas from "./StaticCanvas";
+export { InteractiveCanvas, StaticCanvas };

package/types/components/dropdownMenu/DropdownMenu.d.ts

@@ -6,11 +6,12 @@ declare const DropdownMenu: {
         open: boolean;
     }): JSX.Element;
     Trigger: {
-        ({ className, children, onToggle, }: {
+        ({ className, children, onToggle, title, ...rest }: {
             className?: string | undefined;
             children: React.ReactNode;
             onToggle: () => void;
-        }): JSX.Element;
+            title?: string | undefined;
+        } & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onSelect">): JSX.Element;
         displayName: string;
     };
     Content: {
@@ -24,29 +25,32 @@ declare const DropdownMenu: {
         displayName: string;
     };
     Item: {
-        ({ icon, onSelect, children, shortcut, className, ...rest }: {
+        ({ icon, onSelect, children, shortcut, className, selected, ...rest }: {
             icon?: JSX.Element | undefined;
             onSelect: (event: Event) => void;
             children: React.ReactNode;
             shortcut?: string | undefined;
+            selected?: boolean | undefined;
             className?: string | undefined;
         } & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onSelect">): JSX.Element;
         displayName: string;
     };
     ItemLink: {
-        ({ icon, shortcut, href, children, onSelect, className, ...rest }: {
+        ({ icon, shortcut, href, children, onSelect, className, selected, ...rest }: {
             href: string;
             icon?: JSX.Element | undefined;
             children: React.ReactNode;
             shortcut?: string | undefined;
             className?: string | undefined;
+            selected?: boolean | undefined;
             onSelect?: ((event: Event) => void) | undefined;
         } & React.AnchorHTMLAttributes<HTMLAnchorElement>): JSX.Element;
         displayName: string;
     };
-    ItemCustom: ({ children, className, ...rest }: {
+    ItemCustom: ({ children, className, selected, ...rest }: {
         children: React.ReactNode;
         className?: string | undefined;
+        selected?: boolean | undefined;
     } & React.HTMLAttributes<HTMLDivElement>) => JSX.Element;
     Group: {
         ({ children, className, style, title, }: {

package/types/components/dropdownMenu/DropdownMenuItem.d.ts

@@ -1,10 +1,11 @@
 import React from "react";
 declare const DropdownMenuItem: {
-    ({ icon, onSelect, children, shortcut, className, ...rest }: {
+    ({ icon, onSelect, children, shortcut, className, selected, ...rest }: {
         icon?: JSX.Element | undefined;
         onSelect: (event: Event) => void;
         children: React.ReactNode;
         shortcut?: string | undefined;
+        selected?: boolean | undefined;
         className?: string | undefined;
     } & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onSelect">): JSX.Element;
     displayName: string;

package/types/components/dropdownMenu/DropdownMenuItemCustom.d.ts

@@ -1,6 +1,7 @@
 import React from "react";
-declare const DropdownMenuItemCustom: ({ children, className, ...rest }: {
+declare const DropdownMenuItemCustom: ({ children, className, selected, ...rest }: {
     children: React.ReactNode;
     className?: string | undefined;
+    selected?: boolean | undefined;
 } & React.HTMLAttributes<HTMLDivElement>) => JSX.Element;
 export default DropdownMenuItemCustom;

package/types/components/dropdownMenu/DropdownMenuItemLink.d.ts

@@ -1,11 +1,12 @@
 import React from "react";
 declare const DropdownMenuItemLink: {
-    ({ icon, shortcut, href, children, onSelect, className, ...rest }: {
+    ({ icon, shortcut, href, children, onSelect, className, selected, ...rest }: {
         href: string;
         icon?: JSX.Element | undefined;
         children: React.ReactNode;
         shortcut?: string | undefined;
         className?: string | undefined;
+        selected?: boolean | undefined;
         onSelect?: ((event: Event) => void) | undefined;
     } & React.AnchorHTMLAttributes<HTMLAnchorElement>): JSX.Element;
     displayName: string;

package/types/components/dropdownMenu/DropdownMenuTrigger.d.ts

@@ -1,9 +1,10 @@
 declare const MenuTrigger: {
-    ({ className, children, onToggle, }: {
+    ({ className, children, onToggle, title, ...rest }: {
         className?: string | undefined;
         children: React.ReactNode;
         onToggle: () => void;
-    }): JSX.Element;
+        title?: string | undefined;
+    } & Omit<import("react").ButtonHTMLAttributes<HTMLButtonElement>, "onSelect">): JSX.Element;
     displayName: string;
 };
 export default MenuTrigger;

package/types/components/dropdownMenu/common.d.ts

@@ -2,5 +2,5 @@ import React from "react";
 export declare const DropdownMenuContentPropsContext: React.Context<{
     onSelect?: ((event: Event) => void) | undefined;
 }>;
-export declare const getDropdownMenuItemClassName: (className?: string) => string;
+export declare const getDropdownMenuItemClassName: (className?: string, selected?: boolean) => string;
 export declare const useHandleDropdownMenuItemClick: (origOnClick: React.MouseEventHandler<HTMLAnchorElement | HTMLButtonElement> | undefined, onSelect: ((event: Event) => void) | undefined) => (event: React.MouseEvent<HTMLButtonElement | HTMLAnchorElement, MouseEvent>) => void;

package/types/components/icons.d.ts

@@ -1,5 +1,6 @@
 import React from "react";
 import { Theme } from "../element/types";
+export declare const iconFillColor: (theme: Theme) => string;
 type Opts = {
     width?: number;
     height?: number;
@@ -31,6 +32,7 @@ export declare const EraserIcon: JSX.Element;
 export declare const ZoomInIcon: JSX.Element;
 export declare const ZoomOutIcon: JSX.Element;
 export declare const TrashIcon: JSX.Element;
+export declare const EmbedIcon: JSX.Element;
 export declare const DuplicateIcon: JSX.Element;
 export declare const MoonIcon: JSX.Element;
 export declare const SunIcon: JSX.Element;
@@ -144,5 +146,9 @@ export declare const helpIcon: JSX.Element;
 export declare const playerPlayIcon: JSX.Element;
 export declare const playerStopFilledIcon: JSX.Element;
 export declare const tablerCheckIcon: JSX.Element;
+export declare const alertTriangleIcon: JSX.Element;
 export declare const eyeDropperIcon: JSX.Element;
+export declare const extraToolsIcon: JSX.Element;
+export declare const frameToolIcon: JSX.Element;
+export declare const laserPointerToolIcon: JSX.Element;
 export {};

package/types/components/live-collaboration/LiveCollaborationTrigger.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import "./LiveCollaborationTrigger.scss";
 declare const LiveCollaborationTrigger: {
     ({ isCollaborating, onSelect, ...rest }: {

package/types/components/main-menu/MainMenu.d.ts

@@ -10,37 +10,41 @@ declare const MainMenu: React.FC<{
     __fallback?: boolean | undefined;
 }> & {
     Trigger: {
-        ({ className, children, onToggle, }: {
+        ({ className, children, onToggle, title, ...rest }: {
             className?: string | undefined;
             children: React.ReactNode;
             onToggle: () => void;
-        }): JSX.Element;
+            title?: string | undefined;
+        } & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onSelect">): JSX.Element;
         displayName: string;
     };
     Item: {
-        ({ icon, onSelect, children, shortcut, className, ...rest }: {
+        ({ icon, onSelect, children, shortcut, className, selected, ...rest }: {
             icon?: JSX.Element | undefined;
             onSelect: (event: Event) => void;
             children: React.ReactNode;
             shortcut?: string | undefined;
+            selected?: boolean | undefined;
             className?: string | undefined;
         } & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onSelect">): JSX.Element;
         displayName: string;
     };
     ItemLink: {
-        ({ icon, shortcut, href, children, onSelect, className, ...rest }: {
+        ({ icon, shortcut, href, children, onSelect, className, selected, ...rest }: {
             href: string;
             icon?: JSX.Element | undefined;
             children: React.ReactNode;
             shortcut?: string | undefined;
             className?: string | undefined;
+            selected?: boolean | undefined;
             onSelect?: ((event: Event) => void) | undefined;
         } & React.AnchorHTMLAttributes<HTMLAnchorElement>): JSX.Element;
         displayName: string;
     };
-    ItemCustom: ({ children, className, ...rest }: {
+    ItemCustom: ({ children, className, selected, ...rest }: {
         children: React.ReactNode;
         className?: string | undefined;
+        selected?: boolean | undefined;
     } & React.HTMLAttributes<HTMLDivElement>) => JSX.Element;
     Group: {
         ({ children, className, style, title, }: {

package/types/components/welcome-screen/WelcomeScreen.Center.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 declare const Center: {
     ({ children }: {
         children?: React.ReactNode;

package/types/components/welcome-screen/WelcomeScreen.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import "./WelcomeScreen.scss";
 declare const WelcomeScreen: {
     (props: {

package/types/constants.d.ts

@@ -29,6 +29,11 @@ export declare const POINTER_BUTTON: {
     readonly SECONDARY: 2;
     readonly TOUCH: -1;
 };
+export declare const POINTER_EVENTS: {
+    readonly enabled: "all";
+    readonly disabled: "none";
+    readonly inheritFromUI: any;
+};
 export declare enum EVENT {
     COPY = "copy",
     PASTE = "paste",
@@ -57,8 +62,17 @@ export declare enum EVENT {
     VISIBILITY_CHANGE = "visibilitychange",
     SCROLL = "scroll",
     EXCALIDRAW_LINK = "excalidraw-link",
-    MENU_ITEM_SELECT = "menu.itemSelect"
+    MENU_ITEM_SELECT = "menu.itemSelect",
+    MESSAGE = "message"
 }
+export declare const YOUTUBE_STATES: {
+    readonly UNSTARTED: -1;
+    readonly ENDED: 0;
+    readonly PLAYING: 1;
+    readonly PAUSED: 2;
+    readonly BUFFERING: 3;
+    readonly CUED: 5;
+};
 export declare const ENV: {
     TEST: string;
     DEVELOPMENT: string;
@@ -73,10 +87,24 @@ export declare const FONT_FAMILY: {
     Cascadia: number;
 };
 export declare const THEME: {
-    LIGHT: string;
-    DARK: string;
+    readonly LIGHT: "light";
+    readonly DARK: "dark";
+};
+export declare const FRAME_STYLE: {
+    strokeColor: string;
+    strokeWidth: number;
+    strokeStyle: import("./element/types").StrokeStyle;
+    fillStyle: import("./element/types").FillStyle;
+    roughness: number;
+    roundness: {
+        type: import("./element/types").RoundnessType;
+        value?: number | undefined;
+    } | null;
+    backgroundColor: string;
+    radius: number;
 };
 export declare const WINDOWS_EMOJI_FALLBACK_FONT = "Segoe UI Emoji";
+export declare const MIN_FONT_SIZE = 1;
 export declare const DEFAULT_FONT_SIZE = 20;
 export declare const DEFAULT_FONT_FAMILY: FontFamilyValues;
 export declare const DEFAULT_TEXT_ALIGN = "left";
@@ -124,6 +152,7 @@ export declare const EXPORT_DATA_TYPES: {
     readonly excalidraw: "excalidraw";
     readonly excalidrawClipboard: "excalidraw/clipboard";
     readonly excalidrawLibrary: "excalidrawlib";
+    readonly excalidrawClipboardWithAPI: "excalidraw-api/clipboard";
 };
 export declare const EXPORT_SOURCE: string;
 export declare const IMAGE_RENDER_TIMEOUT = 500;
@@ -163,6 +192,8 @@ export declare const VERSIONS: {
     readonly excalidrawLibrary: 2;
 };
 export declare const BOUND_TEXT_PADDING = 5;
+export declare const ARROW_LABEL_WIDTH_FRACTION = 0.7;
+export declare const ARROW_LABEL_FONT_SIZE_TO_MIN_WIDTH_RATIO = 11;
 export declare const VERTICAL_ALIGN: {
     TOP: string;
     MIDDLE: string;
@@ -199,3 +230,4 @@ export declare const DEFAULT_SIDEBAR: {
     readonly name: "default";
     readonly defaultTab: "library";
 };
+export declare const LIBRARY_DISABLED_TYPES: Set<"embeddable" | "image">;

package/types/context/tunnels.d.ts

@@ -10,6 +10,7 @@ type TunnelsContextValue = {
     FooterCenterTunnel: Tunnel;
     DefaultSidebarTriggerTunnel: Tunnel;
     DefaultSidebarTabTriggersTunnel: Tunnel;
+    OverwriteConfirmDialogTunnel: Tunnel;
     jotaiScope: symbol;
 };
 export declare const TunnelsContext: React.Context<TunnelsContextValue>;

package/types/data/transform.d.ts

@@ -0,0 +1,71 @@
+import { ElementConstructorOpts } from "../element/newElement";
+import { ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawEmbeddableElement, ExcalidrawFrameElement, ExcalidrawFreeDrawElement, ExcalidrawGenericElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawSelectionElement, ExcalidrawTextElement, FileId, FontFamilyValues, TextAlign, VerticalAlign } from "../element/types";
+import { MarkOptional } from "../utility-types";
+export type ValidLinearElement = {
+    type: "arrow" | "line";
+    x: number;
+    y: number;
+    label?: {
+        text: string;
+        fontSize?: number;
+        fontFamily?: FontFamilyValues;
+        textAlign?: TextAlign;
+        verticalAlign?: VerticalAlign;
+    } & MarkOptional<ElementConstructorOpts, "x" | "y">;
+    end?: (({
+        type: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "embeddable">;
+        id?: ExcalidrawGenericElement["id"];
+    } | {
+        id: ExcalidrawGenericElement["id"];
+        type?: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "embeddable">;
+    }) | (({
+        type: "text";
+        text: string;
+    } | {
+        type?: "text";
+        id: ExcalidrawTextElement["id"];
+        text: string;
+    }) & Partial<ExcalidrawTextElement>)) & MarkOptional<ElementConstructorOpts, "x" | "y">;
+    start?: (({
+        type: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "embeddable">;
+        id?: ExcalidrawGenericElement["id"];
+    } | {
+        id: ExcalidrawGenericElement["id"];
+        type?: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "embeddable">;
+    }) | (({
+        type: "text";
+        text: string;
+    } | {
+        type?: "text";
+        id: ExcalidrawTextElement["id"];
+        text: string;
+    }) & Partial<ExcalidrawTextElement>)) & MarkOptional<ElementConstructorOpts, "x" | "y">;
+} & Partial<ExcalidrawLinearElement>;
+export type ValidContainer = {
+    type: Exclude<ExcalidrawGenericElement["type"], "selection">;
+    id?: ExcalidrawGenericElement["id"];
+    label?: {
+        text: string;
+        fontSize?: number;
+        fontFamily?: FontFamilyValues;
+        textAlign?: TextAlign;
+        verticalAlign?: VerticalAlign;
+    } & MarkOptional<ElementConstructorOpts, "x" | "y">;
+} & ElementConstructorOpts;
+export type ExcalidrawElementSkeleton = Extract<Exclude<ExcalidrawElement, ExcalidrawSelectionElement>, ExcalidrawEmbeddableElement | ExcalidrawFreeDrawElement | ExcalidrawFrameElement> | ({
+    type: Extract<ExcalidrawLinearElement["type"], "line">;
+    x: number;
+    y: number;
+} & Partial<ExcalidrawLinearElement>) | ValidContainer | ValidLinearElement | ({
+    type: "text";
+    text: string;
+    x: number;
+    y: number;
+    id?: ExcalidrawTextElement["id"];
+} & Partial<ExcalidrawTextElement>) | ({
+    type: Extract<ExcalidrawImageElement["type"], "image">;
+    x: number;
+    y: number;
+    fileId: FileId;
+} & Partial<ExcalidrawImageElement>);
+export declare const convertToExcalidrawElements: (elements: ExcalidrawElementSkeleton[] | null) => ExcalidrawElement[];

package/types/data/url.d.ts

@@ -0,0 +1,7 @@
+export declare const normalizeLink: (link: string) => string;
+export declare const isLocalLink: (link: string | null) => boolean;
+/**
+ * Returns URL sanitized and safe for usage in places such as
+ * iframe's src attribute or <a> href attributes.
+ */
+export declare const toValidURL: (link: string) => string;

package/types/element/Hyperlink.d.ts

@@ -1,16 +1,18 @@
-/// <reference types="react" />
 import { AppState, ExcalidrawProps, UIAppState } from "../types";
 import { NonDeletedExcalidrawElement } from "./types";
 import { Bounds } from "./bounds";
 import "./Hyperlink.scss";
 export declare const EXTERNAL_LINK_IMG: HTMLImageElement;
-export declare const Hyperlink: ({ element, setAppState, onLinkOpen, }: {
+export declare const Hyperlink: ({ element, setAppState, onLinkOpen, setToast, }: {
     element: NonDeletedExcalidrawElement;
     setAppState: React.Component<any, AppState>["setState"];
     onLinkOpen: ExcalidrawProps["onLinkOpen"];
+    setToast: (toast: {
+        message: string;
+        closable?: boolean;
+        duration?: number;
+    } | null) => void;
 }) => JSX.Element | null;
-export declare const normalizeLink: (link: string) => string;
-export declare const isLocalLink: (link: string | null) => boolean;
 export declare const actionLink: {
     name: "hyperlink";
     perform: (elements: readonly import("./types").ExcalidrawElement[], appState: Readonly<AppState>) => false | {
@@ -26,6 +28,10 @@ export declare const actionLink: {
             showWelcomeScreen: boolean;
             isLoading: boolean;
             errorMessage: import("react").ReactNode;
+            activeEmbeddable: {
+                element: NonDeletedExcalidrawElement;
+                state: "active" | "hover";
+            } | null;
             draggingElement: NonDeletedExcalidrawElement | null;
             resizingElement: NonDeletedExcalidrawElement | null;
             multiElement: import("./types").NonDeleted<import("./types").ExcalidrawLinearElement> | null;
@@ -33,18 +39,21 @@ export declare const actionLink: {
             isBindingEnabled: boolean;
             startBoundElement: import("./types").NonDeleted<import("./types").ExcalidrawBindableElement> | null;
             suggestedBindings: import("./binding").SuggestedBinding[];
+            frameToHighlight: import("./types").NonDeleted<import("./types").ExcalidrawFrameElement> | null;
+            frameRendering: {
+                enabled: boolean;
+                name: boolean;
+                outline: boolean;
+                clip: boolean;
+            };
+            editingFrame: string | null;
+            elementsToHighlight: import("./types").NonDeleted<import("./types").ExcalidrawElement>[] | null;
             editingElement: NonDeletedExcalidrawElement | null;
             editingLinearElement: import("./linearElementEditor").LinearElementEditor | null;
             activeTool: {
-                lastActiveTool: import("../types").LastActiveTool;
+                lastActiveTool: import("../types").ActiveTool | null;
                 locked: boolean;
-            } & ({
-                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | "eraser" | "hand";
-                customType: null;
-            } | {
-                type: "custom";
-                customType: string;
-            });
+            } & import("../types").ActiveTool;
             penMode: boolean;
             penDetected: boolean;
             exportBackground: boolean;
@@ -83,12 +92,13 @@ export declare const actionLink: {
             openDialog: "imageExport" | "help" | "jsonExport" | null;
             defaultSidebarDockedPreference: boolean;
             lastPointerDownWith: import("./types").PointerType;
-            selectedElementIds: {
-                [id: string]: boolean;
-            };
+            selectedElementIds: Readonly<{
+                [id: string]: true;
+            }>;
             previousSelectedElementIds: {
-                [id: string]: boolean;
+                [id: string]: true;
             };
+            selectedElementsAreBeingDragged: boolean;
             shouldCacheIgnoreZoom: boolean;
             toast: {
                 message: string;
@@ -96,7 +106,7 @@ export declare const actionLink: {
                 duration?: number | undefined;
             } | null;
             zenModeEnabled: boolean;
-            theme: string;
+            theme: import("./types").Theme;
             gridSize: number | null;
             viewModeEnabled: boolean;
             selectedGroupIds: {
@@ -120,6 +130,12 @@ export declare const actionLink: {
             };
             pendingImageElementId: string | null;
             selectedLinearElement: import("./linearElementEditor").LinearElementEditor | null;
+            snapLines: readonly import("../snapping").SnapLine[];
+            originSnapOffset: {
+                x: number;
+                y: number;
+            } | null;
+            objectsSnapModeEnabled: boolean;
         };
         commitToHistory: true;
     };
@@ -127,16 +143,17 @@ export declare const actionLink: {
         category: "hyperlink";
         action: string;
     };
-    keyTest: (event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean;
-    contextItemLabel: (elements: readonly import("./types").ExcalidrawElement[], appState: Readonly<AppState>) => "labels.link.edit" | "labels.link.create";
+    keyTest: (event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean;
+    contextItemLabel: (elements: readonly import("./types").ExcalidrawElement[], appState: Readonly<AppState>) => "labels.link.editEmbed" | "labels.link.edit" | "labels.link.createEmbed" | "labels.link.create";
     predicate: (elements: readonly import("./types").ExcalidrawElement[], appState: AppState) => boolean;
     PanelComponent: ({ elements, appState, updateData }: import("../actions/types").PanelComponentProps) => JSX.Element;
 } & {
-    keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
+    keyTest?: ((event: import("react").KeyboardEvent<Element> | KeyboardEvent) => boolean) | undefined;
 };
-export declare const getContextMenuLabel: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState) => "labels.link.edit" | "labels.link.create";
-export declare const getLinkHandleFromCoords: ([x1, y1, x2, y2]: Bounds, angle: number, appState: UIAppState) => [x: number, y: number, width: number, height: number];
-export declare const isPointHittingLinkIcon: (element: NonDeletedExcalidrawElement, appState: AppState, [x, y]: readonly [number, number], isMobile: boolean) => boolean;
+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 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;
 export declare const hideHyperlinkToolip: () => void;
 export declare const shouldHideLinkPopup: (element: NonDeletedExcalidrawElement, appState: AppState, [clientX, clientY]: readonly [number, number]) => Boolean;

package/types/element/binding.d.ts

@@ -7,7 +7,7 @@ export type SuggestedPointBinding = [
     "start" | "end" | "both",
     NonDeleted<ExcalidrawBindableElement>
 ];
-export declare const shouldEnableBindingForPointerEvent: (event: React.PointerEvent<HTMLCanvasElement>) => boolean;
+export declare const shouldEnableBindingForPointerEvent: (event: React.PointerEvent<HTMLElement>) => boolean;
 export declare const isBindingEnabled: (appState: AppState) => boolean;
 export declare const bindOrUnbindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, startBindingElement: ExcalidrawBindableElement | null | "keep", endBindingElement: ExcalidrawBindableElement | null | "keep") => void;
 export declare const bindOrUnbindSelectedElements: (elements: NonDeleted<ExcalidrawElement>[]) => void;
@@ -15,6 +15,7 @@ export declare const maybeBindLinearElement: (linearElement: NonDeleted<Excalidr
     x: number;
     y: number;
 }) => void;
+export declare const bindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end") => void;
 export declare const isLinearElementSimpleAndAlreadyBound: (linearElement: NonDeleted<ExcalidrawLinearElement>, alreadyBoundToId: ExcalidrawBindableElement["id"] | undefined, bindableElement: ExcalidrawBindableElement) => boolean;
 export declare const unbindLinearElements: (elements: NonDeleted<ExcalidrawElement>[]) => void;
 export declare const getHoveredElementForBinding: (pointerCoords: {

package/types/element/bounds.d.ts

@@ -1,21 +1,45 @@
 import { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, NonDeleted } from "./types";
 import { Drawable, Op } from "roughjs/bin/core";
-export type Bounds = readonly [number, number, number, number];
+import { Point } from "../types";
+export type RectangleBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    angle: number;
+};
+export type Bounds = readonly [x1: number, y1: number, x2: number, y2: number];
+export declare class ElementBounds {
+    private static boundsCache;
+    static getBounds(element: ExcalidrawElement): Bounds;
+    private static calculateBounds;
+}
 export declare const getElementAbsoluteCoords: (element: ExcalidrawElement, includeBoundText?: boolean) => [number, number, number, number, number, number];
+export declare const getElementLineSegments: (element: ExcalidrawElement) => [Point, Point][];
+/**
+ * Scene -> Scene coords, but in x1,x2,y1,y2 format.
+ *
+ * Rectangle here means any rectangular frame, not an excalidraw element.
+ */
+export declare const getRectangleBoxAbsoluteCoords: (boxSceneCoords: RectangleBox) => number[];
 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 getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead) => number[] | null;
-export declare const getElementBounds: (element: ExcalidrawElement) => [number, number, number, number];
-export declare const getCommonBounds: (elements: readonly ExcalidrawElement[]) => [number, number, number, number];
+export declare const getElementBounds: (element: ExcalidrawElement) => Bounds;
+export declare const getCommonBounds: (elements: readonly ExcalidrawElement[]) => Bounds;
+export declare const getDraggedElementsBounds: (elements: ExcalidrawElement[], dragOffset: {
+    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 getClosestElementBounds: (elements: readonly ExcalidrawElement[], from: {
     x: number;
     y: number;
-}) => [number, number, number, number];
-export interface Box {
+}) => Bounds;
+export interface BoundingBox {
     minX: number;
     minY: number;
     maxX: number;
@@ -25,4 +49,4 @@ export interface Box {
     width: number;
     height: number;
 }
-export declare const getCommonBoundingBox: (elements: ExcalidrawElement[] | readonly NonDeleted<ExcalidrawElement>[]) => Box;
+export declare const getCommonBoundingBox: (elements: ExcalidrawElement[] | readonly NonDeleted<ExcalidrawElement>[]) => BoundingBox;

package/types/element/collision.d.ts

@@ -1,11 +1,11 @@
 import * as GA from "../ga";
-import { NonDeletedExcalidrawElement, ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawRectangleElement, ExcalidrawDiamondElement, ExcalidrawTextElement, ExcalidrawEllipseElement, NonDeleted, ExcalidrawImageElement } from "./types";
-import { Point } from "../types";
+import { NonDeletedExcalidrawElement, ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawRectangleElement, ExcalidrawEmbeddableElement, ExcalidrawDiamondElement, ExcalidrawTextElement, ExcalidrawEllipseElement, NonDeleted, ExcalidrawImageElement, ExcalidrawFrameElement } from "./types";
+import { FrameNameBoundsCache, Point } from "../types";
 import { AppState } from "../types";
-export declare const hitTest: (element: NonDeletedExcalidrawElement, appState: AppState, x: number, y: number) => boolean;
-export declare const isHittingElementBoundingBoxWithoutHittingElement: (element: NonDeletedExcalidrawElement, appState: AppState, x: number, y: number) => boolean;
-export declare const isHittingElementNotConsideringBoundingBox: (element: NonDeletedExcalidrawElement, appState: AppState, point: readonly [number, number]) => boolean;
-export declare const isPointHittingElementBoundingBox: (element: NonDeleted<ExcalidrawElement>, [x, y]: readonly [number, number], threshold: number) => boolean;
+export declare const hitTest: (element: NonDeletedExcalidrawElement, appState: AppState, frameNameBoundsCache: FrameNameBoundsCache, x: number, y: number) => boolean;
+export declare const isHittingElementBoundingBoxWithoutHittingElement: (element: NonDeletedExcalidrawElement, appState: AppState, frameNameBoundsCache: FrameNameBoundsCache, x: number, y: number) => boolean;
+export declare const isHittingElementNotConsideringBoundingBox: (element: NonDeletedExcalidrawElement, appState: AppState, frameNameBoundsCache: FrameNameBoundsCache | null, point: readonly [number, number]) => boolean;
+export declare const isPointHittingElementBoundingBox: (element: NonDeleted<ExcalidrawElement>, [x, y]: readonly [number, number], threshold: number, frameNameBoundsCache: FrameNameBoundsCache | null) => boolean;
 export declare const bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
     x: number;
     y: number;
@@ -18,4 +18,4 @@ export declare const determineFocusPoint: (element: ExcalidrawBindableElement, f
 export declare const intersectElementWithLine: (element: ExcalidrawBindableElement, a: readonly [number, number], b: readonly [number, number], gap?: number) => Point[];
 export declare const getCircleIntersections: (center: readonly [number, number, number, number, number, number, number, number], radius: number, line: readonly [number, number, number, number, number, number, number, number]) => GA.Point[];
 export declare const findFocusPointForEllipse: (ellipse: ExcalidrawEllipseElement, relativeDistance: number, point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
-export declare const findFocusPointForRectangulars: (element: ExcalidrawRectangleElement | ExcalidrawImageElement | ExcalidrawDiamondElement | ExcalidrawTextElement, relativeDistance: number, point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const findFocusPointForRectangulars: (element: ExcalidrawRectangleElement | ExcalidrawImageElement | ExcalidrawDiamondElement | ExcalidrawTextElement | ExcalidrawEmbeddableElement | ExcalidrawFrameElement, relativeDistance: number, point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];

package/types/element/dragElements.d.ts

@@ -1,5 +1,15 @@
 import { NonDeletedExcalidrawElement } from "./types";
 import { AppState, PointerDownState } from "../types";
-export declare const dragSelectedElements: (pointerDownState: PointerDownState, selectedElements: NonDeletedExcalidrawElement[], pointerX: number, pointerY: number, lockDirection: boolean | undefined, distanceX: number | undefined, distanceY: number | undefined, appState: AppState) => void;
+import Scene from "../scene/Scene";
+export declare const dragSelectedElements: (pointerDownState: PointerDownState, selectedElements: NonDeletedExcalidrawElement[], offset: {
+    x: number;
+    y: number;
+}, appState: AppState, scene: Scene, snapOffset: {
+    x: number;
+    y: number;
+}, gridSize: AppState["gridSize"]) => void;
 export declare const getDragOffsetXY: (selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
-export declare const dragNewElement: (draggingElement: NonDeletedExcalidrawElement, elementType: AppState["activeTool"]["type"], originX: number, originY: number, x: number, y: number, width: number, height: number, shouldMaintainAspectRatio: boolean, shouldResizeFromCenter: boolean, widthAspectRatio?: number | null) => void;
+export declare const dragNewElement: (draggingElement: NonDeletedExcalidrawElement, elementType: AppState["activeTool"]["type"], originX: number, originY: number, x: number, y: number, width: number, height: number, shouldMaintainAspectRatio: boolean, shouldResizeFromCenter: boolean, widthAspectRatio?: number | null, originOffset?: {
+    x: number;
+    y: number;
+} | null) => void;