@excalidraw/excalidraw 0.13.0-75458c3 → 0.13.0-99fdffd

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

@@ -0,0 +1,55 @@
+import React from "react";
+import * as DefaultItems from "./DefaultItems";
+declare const MainMenu: {
+    ({ children }: {
+        children?: React.ReactNode;
+    }): JSX.Element;
+    Trigger: {
+        ({ className, children, onToggle, }: {
+            className?: string | undefined;
+            children: React.ReactNode;
+            onToggle: () => void;
+        }): JSX.Element;
+        displayName: string;
+    };
+    Item: {
+        ({ icon, onSelect, children, shortcut, className, ...rest }: {
+            icon?: JSX.Element | undefined;
+            onSelect: () => void;
+            children: React.ReactNode;
+            shortcut?: string | undefined;
+            className?: string | undefined;
+        } & React.ButtonHTMLAttributes<HTMLButtonElement>): JSX.Element;
+        displayName: string;
+    };
+    ItemLink: {
+        ({ icon, shortcut, href, children, className, ...rest }: {
+            icon?: JSX.Element | undefined;
+            children: React.ReactNode;
+            shortcut?: string | undefined;
+            className?: string | undefined;
+            href: string;
+        } & React.AnchorHTMLAttributes<HTMLAnchorElement>): JSX.Element;
+        displayName: string;
+    };
+    ItemCustom: ({ children, className, ...rest }: {
+        children: React.ReactNode;
+        className?: string | undefined;
+    } & React.HTMLAttributes<HTMLDivElement>) => JSX.Element;
+    Group: {
+        ({ children, className, style, title, }: {
+            children: React.ReactNode;
+            className?: string | undefined;
+            style?: React.CSSProperties | undefined;
+            title?: string | undefined;
+        }): JSX.Element;
+        displayName: string;
+    };
+    Separator: {
+        (): JSX.Element;
+        displayName: string;
+    };
+    DefaultItems: typeof DefaultItems;
+    displayName: string;
+};
+export default MainMenu;

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

@@ -0,0 +1,58 @@
+/// <reference types="react" />
+declare const Center: {
+    ({ children }: {
+        children?: React.ReactNode;
+    }): JSX.Element;
+    displayName: string;
+    Logo: {
+        ({ children }: {
+            children?: React.ReactNode;
+        }): JSX.Element;
+        displayName: string;
+    };
+    Heading: {
+        ({ children }: {
+            children: React.ReactNode;
+        }): JSX.Element;
+        displayName: string;
+    };
+    Menu: {
+        ({ children }: {
+            children?: React.ReactNode;
+        }): JSX.Element;
+        displayName: string;
+    };
+    MenuItem: {
+        ({ onSelect, children, icon, shortcut, className, ...props }: {
+            onSelect: () => void;
+            children: React.ReactNode;
+            icon?: JSX.Element | undefined;
+            shortcut?: string | null | undefined;
+        } & import("react").ButtonHTMLAttributes<HTMLButtonElement>): JSX.Element;
+        displayName: string;
+    };
+    MenuItemLink: {
+        ({ children, href, icon, shortcut, className, ...props }: {
+            children: React.ReactNode;
+            href: string;
+            icon?: JSX.Element | undefined;
+            shortcut?: string | null | undefined;
+        } & import("react").AnchorHTMLAttributes<HTMLAnchorElement>): JSX.Element;
+        displayName: string;
+    };
+    MenuItemHelp: {
+        (): JSX.Element;
+        displayName: string;
+    };
+    MenuItemLoadScene: {
+        (): JSX.Element | null;
+        displayName: string;
+    };
+    MenuItemLiveCollaborationTrigger: {
+        ({ onSelect, }: {
+            onSelect: () => any;
+        }): JSX.Element;
+        displayName: string;
+    };
+};
+export { Center };

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

@@ -0,0 +1,19 @@
+declare const MenuHint: {
+    ({ children }: {
+        children?: React.ReactNode;
+    }): JSX.Element;
+    displayName: string;
+};
+declare const ToolbarHint: {
+    ({ children }: {
+        children?: React.ReactNode;
+    }): JSX.Element;
+    displayName: string;
+};
+declare const HelpHint: {
+    ({ children }: {
+        children?: React.ReactNode;
+    }): JSX.Element;
+    displayName: string;
+};
+export { HelpHint, MenuHint, ToolbarHint };

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

@@ -0,0 +1,85 @@
+/// <reference types="react" />
+import "./WelcomeScreen.scss";
+declare const WelcomeScreen: {
+    (props: {
+        children: React.ReactNode;
+    }): null;
+    displayName: string;
+    Center: {
+        ({ children }: {
+            children?: import("react").ReactNode;
+        }): JSX.Element;
+        displayName: string;
+        Logo: {
+            ({ children }: {
+                children?: import("react").ReactNode;
+            }): JSX.Element;
+            displayName: string;
+        };
+        Heading: {
+            ({ children }: {
+                children: import("react").ReactNode;
+            }): JSX.Element;
+            displayName: string;
+        };
+        Menu: {
+            ({ children }: {
+                children?: import("react").ReactNode;
+            }): JSX.Element;
+            displayName: string;
+        };
+        MenuItem: {
+            ({ onSelect, children, icon, shortcut, className, ...props }: {
+                onSelect: () => void;
+                children: import("react").ReactNode;
+                icon?: JSX.Element | undefined;
+                shortcut?: string | null | undefined;
+            } & import("react").ButtonHTMLAttributes<HTMLButtonElement>): JSX.Element;
+            displayName: string;
+        };
+        MenuItemLink: {
+            ({ children, href, icon, shortcut, className, ...props }: {
+                children: import("react").ReactNode;
+                href: string;
+                icon?: JSX.Element | undefined;
+                shortcut?: string | null | undefined;
+            } & import("react").AnchorHTMLAttributes<HTMLAnchorElement>): JSX.Element;
+            displayName: string;
+        };
+        MenuItemHelp: {
+            (): JSX.Element;
+            displayName: string;
+        };
+        MenuItemLoadScene: {
+            (): JSX.Element | null;
+            displayName: string;
+        };
+        MenuItemLiveCollaborationTrigger: {
+            ({ onSelect, }: {
+                onSelect: () => any;
+            }): JSX.Element;
+            displayName: string;
+        };
+    };
+    Hints: {
+        MenuHint: {
+            ({ children }: {
+                children?: import("react").ReactNode;
+            }): JSX.Element;
+            displayName: string;
+        };
+        ToolbarHint: {
+            ({ children }: {
+                children?: import("react").ReactNode;
+            }): JSX.Element;
+            displayName: string;
+        };
+        HelpHint: {
+            ({ children }: {
+                children?: import("react").ReactNode;
+            }): JSX.Element;
+            displayName: string;
+        };
+    };
+};
+export default WelcomeScreen;

package/types/constants.d.ts

@@ -102,14 +102,10 @@ export declare const TITLE_TIMEOUT = 10000;
 export declare const VERSION_TIMEOUT = 30000;
 export declare const SCROLL_TIMEOUT = 100;
 export declare const ZOOM_STEP = 0.1;
+export declare const MIN_ZOOM = 0.1;
 export declare const HYPERLINK_TOOLTIP_DELAY = 300;
 export declare const IDLE_THRESHOLD = 60000;
 export declare const ACTIVE_THRESHOLD = 3000;
-export declare const MODES: {
-    VIEW: string;
-    ZEN: string;
-    GRID: string;
-};
 export declare const THEME_FILTER: any;
 export declare const URL_QUERY_KEYS: {
     readonly addLibrary: "addLibrary";
@@ -148,8 +144,12 @@ export declare const TEXT_ALIGN: {
     RIGHT: string;
 };
 export declare const ELEMENT_READY_TO_ERASE_OPACITY = 20;
-export declare const COOKIES: {
-    readonly AUTH_STATE_COOKIE: "excplus-auth";
+export declare const DEFAULT_PROPORTIONAL_RADIUS = 0.25;
+export declare const DEFAULT_ADAPTIVE_RADIUS = 32;
+export declare const ROUNDNESS: {
+    readonly LEGACY: 1;
+    readonly PROPORTIONAL_RADIUS: 2;
+    readonly ADAPTIVE_RADIUS: 3;
 };
 /** key containt id of precedeing elemnt id we use in reconciliation during
  * collaboration */

package/types/data/restore.d.ts

@@ -8,7 +8,7 @@ export declare type RestoredDataState = {
     appState: RestoredAppState;
     files: BinaryFiles;
 };
-export declare const restoreElements: (elements: ImportedDataState["elements"], localElements: readonly ExcalidrawElement[] | null | undefined) => ExcalidrawElement[];
+export declare const restoreElements: (elements: ImportedDataState["elements"], localElements: readonly ExcalidrawElement[] | null | undefined, refreshDimensions?: boolean) => ExcalidrawElement[];
 export declare const restoreAppState: (appState: ImportedDataState["appState"], localAppState: Partial<AppState> | null | undefined) => RestoredAppState;
 export declare const restore: (data: Pick<ImportedDataState, "appState" | "elements" | "files"> | null, localAppState: Partial<AppState> | null | undefined, localElements: readonly ExcalidrawElement[] | null | undefined) => RestoredDataState;
 export declare const restoreLibraryItems: (libraryItems: ImportedDataState["libraryItems"], defaultStatus: LibraryItem["status"]) => LibraryItem[];

package/types/element/Hyperlink.d.ts

@@ -18,6 +18,12 @@ export declare const actionLink: {
         appState: {
             showHyperlinkPopup: "editor";
             openMenu: null;
+            contextMenu: {
+                items: import("../components/ContextMenu").ContextMenuItems;
+                top: number;
+                left: number;
+            } | null;
+            showWelcomeScreen: boolean;
             isLoading: boolean;
             errorMessage: string | null;
             draggingElement: NonDeletedExcalidrawElement | null;
@@ -56,10 +62,9 @@ export declare const actionLink: {
             currentItemFontFamily: number;
             currentItemFontSize: number;
             currentItemTextAlign: string;
-            currentItemStrokeSharpness: import("./types").StrokeSharpness;
             currentItemStartArrowhead: import("./types").Arrowhead | null;
             currentItemEndArrowhead: import("./types").Arrowhead | null;
-            currentItemLinearStrokeSharpness: import("./types").StrokeSharpness;
+            currentItemRoundness: import("./types").StrokeRoundness;
             viewBackgroundColor: string;
             scrollX: number;
             scrollY: number;
@@ -73,6 +78,7 @@ export declare const actionLink: {
             }>;
             openPopup: "canvasColorPicker" | "backgroundColorPicker" | "strokeColorPicker" | null;
             openSidebar: "library" | "customSidebar" | null;
+            openDialog: "imageExport" | "help" | "jsonExport" | null;
             isSidebarDocked: boolean;
             lastPointerDownWith: import("./types").PointerType;
             selectedElementIds: {
@@ -82,7 +88,6 @@ export declare const actionLink: {
                 [id: string]: boolean;
             };
             shouldCacheIgnoreZoom: boolean;
-            showHelpDialog: boolean;
             toast: {
                 message: string;
                 closable?: boolean | undefined;
@@ -122,7 +127,7 @@ export declare const actionLink: {
     };
     keyTest: (event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean;
     contextItemLabel: (elements: readonly import("./types").ExcalidrawElement[], appState: Readonly<AppState>) => "labels.link.edit" | "labels.link.create";
-    contextItemPredicate: (elements: readonly import("./types").ExcalidrawElement[], appState: AppState) => boolean;
+    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;

package/types/element/bounds.d.ts

@@ -1,15 +1,16 @@
 import { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, NonDeleted } from "./types";
 import { Drawable, Op } from "roughjs/bin/core";
 export declare type Bounds = readonly [number, number, number, number];
-export declare const getElementAbsoluteCoords: (element: ExcalidrawElement) => Bounds;
+export declare const getElementAbsoluteCoords: (element: ExcalidrawElement, includeBoundText?: boolean) => [number, number, number, number, number, 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 getResizedElementAbsoluteCoords: (element: ExcalidrawElement, nextWidth: number, nextHeight: number, normalizePoints: boolean) => [number, number, number, number];
-export declare const getElementPointsCoords: (element: ExcalidrawLinearElement, points: readonly (readonly [number, number])[], sharpness: ExcalidrawElement["strokeSharpness"]) => [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;

package/types/element/index.d.ts

@@ -1,5 +1,5 @@
 import { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted } from "./types";
-export { newElement, newTextElement, updateTextElement, newLinearElement, newImageElement, duplicateElement, } from "./newElement";
+export { newElement, newTextElement, updateTextElement, refreshTextDimensions, newLinearElement, newImageElement, duplicateElement, } from "./newElement";
 export { getElementAbsoluteCoords, getElementBounds, getCommonBounds, getDiamondPoints, getArrowheadPoints, getClosestElementBounds, } from "./bounds";
 export { OMIT_SIDES_FOR_MULTIPLE_ELEMENTS, getTransformHandlesFromCoords, getTransformHandles, } from "./transformHandles";
 export { hitTest, isHittingElementBoundingBoxWithoutHittingElement, } from "./collision";

package/types/element/linearElementEditor.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
-import { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement } from "./types";
-import { Point, AppState } from "../types";
+import { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer } from "./types";
+import { Point, AppState, PointerCoords } from "../types";
 import History from "../history";
 import Scene from "../scene/Scene";
 declare const editorMidPointsCache: {
@@ -18,6 +18,15 @@ export declare class LinearElementEditor {
         prevSelectedPointsIndices: readonly number[] | null;
         /** index */
         lastClickedPoint: number;
+        origin: Readonly<{
+            x: number;
+            y: number;
+        }> | null;
+        segmentMidpoint: {
+            value: Point | null;
+            index: number | null;
+            added: boolean;
+        };
     }>;
     /** whether you're dragging a point */
     readonly isDragging: boolean;
@@ -60,7 +69,6 @@ export declare class LinearElementEditor {
         didAddPoint: boolean;
         hitElement: NonDeleted<ExcalidrawElement> | null;
         linearElementEditor: LinearElementEditor | null;
-        isMidPoint: boolean;
     };
     static arePointsEqual(point1: Point | null, point2: Point | null): boolean;
     static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, appState: AppState): LinearElementEditor | null;
@@ -94,6 +102,15 @@ export declare class LinearElementEditor {
                     prevSelectedPointsIndices: readonly number[] | null;
                     /** index */
                     lastClickedPoint: number;
+                    origin: Readonly<{
+                        x: number;
+                        y: number;
+                    }> | null;
+                    segmentMidpoint: {
+                        value: readonly [number, number] | null;
+                        index: number | null;
+                        added: boolean;
+                    };
                 }>;
                 isDragging: boolean;
                 lastUncommittedPoint: readonly [number, number] | null;
@@ -106,6 +123,12 @@ export declare class LinearElementEditor {
                 hoverPointIndex: number;
                 segmentMidPointHoveredCoords: readonly [number, number] | null;
             };
+            contextMenu: {
+                items: import("../components/ContextMenu").ContextMenuItems;
+                top: number;
+                left: number;
+            } | null;
+            showWelcomeScreen: boolean;
             isLoading: boolean;
             errorMessage: string | null;
             draggingElement: import("./types").NonDeletedExcalidrawElement | null;
@@ -143,10 +166,9 @@ export declare class LinearElementEditor {
             currentItemFontFamily: number;
             currentItemFontSize: number;
             currentItemTextAlign: string;
-            currentItemStrokeSharpness: import("./types").StrokeSharpness;
             currentItemStartArrowhead: import("./types").Arrowhead | null;
             currentItemEndArrowhead: import("./types").Arrowhead | null;
-            currentItemLinearStrokeSharpness: import("./types").StrokeSharpness;
+            currentItemRoundness: import("./types").StrokeRoundness;
             viewBackgroundColor: string;
             scrollX: number;
             scrollY: number;
@@ -161,6 +183,7 @@ export declare class LinearElementEditor {
             openMenu: "canvas" | "shape" | null;
             openPopup: "canvasColorPicker" | "backgroundColorPicker" | "strokeColorPicker" | null;
             openSidebar: "library" | "customSidebar" | null;
+            openDialog: "imageExport" | "help" | "jsonExport" | null;
             isSidebarDocked: boolean;
             lastPointerDownWith: import("./types").PointerType;
             selectedElementIds: {
@@ -170,11 +193,10 @@ export declare class LinearElementEditor {
                 [id: string]: boolean;
             };
             shouldCacheIgnoreZoom: boolean;
-            showHelpDialog: boolean;
             toast: {
                 message: string;
                 closable?: boolean | undefined;
-                duration?: number | undefined;
+                duration?: number | undefined; /** @returns whether point was dragged */
             } | null;
             zenModeEnabled: boolean;
             theme: string;
@@ -216,7 +238,18 @@ export declare class LinearElementEditor {
         startBinding?: PointBinding;
         endBinding?: PointBinding;
     }): void;
+    static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState): boolean;
+    static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState): {
+        pointerDownState: LinearElementEditor["pointerDownState"];
+        selectedPointsIndices: LinearElementEditor["selectedPointsIndices"];
+    } | undefined;
     private static _updatePoints;
     private static _getShiftLockedDelta;
+    static getBoundTextElementPosition: (element: ExcalidrawLinearElement, boundTextElement: ExcalidrawTextElementWithContainer) => {
+        x: number;
+        y: number;
+    };
+    static getMinMaxXYWithBoundText: (element: ExcalidrawLinearElement, elementBounds: [number, number, number, number], 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

@@ -1,4 +1,4 @@
-import { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawRectangleElement } from "../element/types";
+import { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer } from "../element/types";
 import { AppState } from "../types";
 declare type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "boundElements" | "seed" | "version" | "versionNonce" | "link">;
 export declare const newElement: (opts: {
@@ -10,8 +10,16 @@ export declare const newTextElement: (opts: {
     fontFamily: FontFamilyValues;
     textAlign: TextAlign;
     verticalAlign: VerticalAlign;
-    containerId?: ExcalidrawRectangleElement["id"];
+    containerId?: ExcalidrawTextContainer["id"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
+export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement, text?: string) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    baseline: number;
+    text: string;
+};
 export declare const getMaxContainerWidth: (container: ExcalidrawElement) => number;
 export declare const getMaxContainerHeight: (container: ExcalidrawElement) => number;
 export declare const updateTextElement: (textElement: ExcalidrawTextElement, { text, isDeleted, originalText, }: {

package/types/element/resizeElements.d.ts

@@ -3,7 +3,6 @@ import { MaybeTransformHandleType, TransformHandleDirection } from "./transformH
 import { PointerDownState } from "../types";
 export declare const normalizeAngle: (angle: number) => number;
 export declare const transformElements: (pointerDownState: PointerDownState, transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], resizeArrowDirection: "origin" | "end", shouldRotateWithDiscreteAngle: boolean, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number) => boolean;
-export declare const reshapeSingleTwoPointElement: (element: NonDeleted<ExcalidrawLinearElement>, resizeArrowDirection: "origin" | "end", shouldRotateWithDiscreteAngle: boolean, pointerX: number, pointerY: number) => void;
 export declare const resizeSingleElement: (originalElements: PointerDownState["originalElements"], shouldMaintainAspectRatio: boolean, element: NonDeletedExcalidrawElement, transformHandleDirection: TransformHandleDirection, shouldResizeFromCenter: boolean, pointerX: number, pointerY: number) => void;
 export declare const getResizeOffsetXY: (transformHandleType: MaybeTransformHandleType, selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
 export declare const getResizeArrowDirection: (transformHandleType: MaybeTransformHandleType, element: NonDeleted<ExcalidrawLinearElement>) => "origin" | "end";

package/types/element/textElement.d.ts

@@ -1,14 +1,23 @@
-import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, FontString, NonDeletedExcalidrawElement } from "./types";
+import { ExcalidrawElement, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, FontString, NonDeletedExcalidrawElement } from "./types";
 import { MaybeTransformHandleType } from "./transformHandles";
+import { AppState } from "../types";
+export declare const normalizeText: (text: string) => string;
 export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null) => void;
 export declare const bindTextToShapeAfterDuplication: (sceneElements: ExcalidrawElement[], oldElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
-export declare const handleBindTextResize: (element: NonDeletedExcalidrawElement, transformHandleType: MaybeTransformHandleType) => void;
+export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, transformHandleType: MaybeTransformHandleType) => void;
 export declare const measureText: (text: string, font: FontString, maxWidth?: number | null) => {
     width: number;
     height: number;
     baseline: number;
+    container: HTMLDivElement;
+} | {
+    width: number;
+    height: number;
+    baseline: number;
+    container?: undefined;
 };
 export declare const getApproxLineHeight: (font: FontString) => number;
+export declare const getTextWidth: (text: string, font: FontString) => number;
 export declare const wrapText: (text: string, font: FontString, maxWidth: number) => string;
 export declare const charWidth: {
     calculate: (char: string, font: FontString) => number;
@@ -28,3 +37,16 @@ export declare const getContainerDims: (element: ExcalidrawElement) => {
     width: number;
     height: number;
 };
+export declare const getContainerCenter: (container: ExcalidrawElement, appState: AppState) => {
+    x: number;
+    y: number;
+};
+export declare const getTextElementAngle: (textElement: ExcalidrawTextElement) => number;
+export declare const getBoundTextElementOffset: (boundTextElement: ExcalidrawTextElement | null) => number;
+export declare const getBoundTextElementPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => {
+    x: number;
+    y: number;
+} | undefined;
+export declare const shouldAllowVerticalAlign: (selectedElements: NonDeletedExcalidrawElement[]) => boolean;
+export declare const getTextBindableContainerAtPosition: (elements: readonly ExcalidrawElement[], appState: AppState, x: number, y: number) => ExcalidrawTextContainer | null;
+export declare const isValidTextContainer: (element: ExcalidrawElement) => boolean;

package/types/element/textWysiwyg.d.ts

@@ -1,5 +1,10 @@
-import { ExcalidrawElement, ExcalidrawTextElement } from "./types";
+import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawTextContainer } from "./types";
 import App from "../components/App";
+export declare const updateOriginalContainerCache: (id: ExcalidrawTextContainer["id"], height: ExcalidrawTextContainer["height"]) => {
+    height: ExcalidrawTextContainer["height"];
+};
+export declare const resetOriginalContainerCache: (id: ExcalidrawTextContainer["id"]) => void;
+export declare const getOriginalContainerHeightFromCache: (id: ExcalidrawTextContainer["id"]) => number | null;
 export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, }: {
     id: ExcalidrawElement["id"];
     onChange?: ((text: string) => void) | undefined;

package/types/element/transformHandles.d.ts

@@ -1,5 +1,4 @@
 import { ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
-import { Bounds } from "./bounds";
 import { AppState, Zoom } from "../types";
 export declare type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
 export declare type TransformHandleType = TransformHandleDirection | "rotation";
@@ -14,11 +13,11 @@ export declare const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS: {
     n: boolean;
     w: boolean;
 };
-export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2]: Bounds, angle: number, zoom: Zoom, pointerType: PointerType, omitSides?: {
-    e?: boolean | undefined;
+export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [number, number, number, number, number, number], angle: number, zoom: Zoom, pointerType: PointerType, omitSides?: {
     s?: boolean | undefined;
-    w?: boolean | undefined;
+    e?: boolean | undefined;
     n?: boolean | undefined;
+    w?: boolean | undefined;
     nw?: boolean | undefined;
     ne?: boolean | undefined;
     sw?: boolean | undefined;

package/types/element/typeChecks.d.ts

@@ -1,5 +1,5 @@
 import { AppState } from "../types";
-import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer } from "./types";
+import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, RoundnessType } from "./types";
 export declare const isGenericElement: (element: ExcalidrawElement | null) => element is ExcalidrawGenericElement;
 export declare const isInitializedImageElement: (element: ExcalidrawElement | null) => element is InitializedExcalidrawImageElement;
 export declare const isImageElement: (element: ExcalidrawElement | null) => element is ExcalidrawImageElement;
@@ -7,6 +7,7 @@ export declare const isTextElement: (element: ExcalidrawElement | null) => eleme
 export declare const isFreeDrawElement: (element?: ExcalidrawElement | null) => element is ExcalidrawFreeDrawElement;
 export declare const isFreeDrawElementType: (elementType: ExcalidrawElement["type"]) => boolean;
 export declare const isLinearElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
+export declare const isArrowElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
 export declare const isLinearElementType: (elementType: AppState["activeTool"]["type"]) => boolean;
 export declare const isBindingElement: (element?: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawLinearElement;
 export declare const isBindingElementType: (elementType: AppState["activeTool"]["type"]) => boolean;
@@ -15,3 +16,11 @@ export declare const isTextBindableContainer: (element: ExcalidrawElement | null
 export declare const isExcalidrawElement: (element: any) => boolean;
 export declare const hasBoundTextElement: (element: ExcalidrawElement | null) => element is ExcalidrawBindableElement;
 export declare const isBoundToContainer: (element: ExcalidrawElement | null) => element is ExcalidrawTextElementWithContainer;
+export declare const isUsingAdaptiveRadius: (type: string) => boolean;
+export declare const isUsingProportionalRadius: (type: string) => boolean;
+export declare const canApplyRoundnessTypeToElement: (roundnessType: RoundnessType, element: ExcalidrawElement) => boolean;
+export declare const getDefaultRoundnessTypeForElement: (element: ExcalidrawElement) => {
+    type: 2;
+} | {
+    type: 3;
+} | null;

package/types/element/types.d.ts

@@ -1,5 +1,5 @@
 import { Point } from "../types";
-import { FONT_FAMILY, TEXT_ALIGN, THEME, VERTICAL_ALIGN } from "../constants";
+import { FONT_FAMILY, ROUNDNESS, TEXT_ALIGN, THEME, VERTICAL_ALIGN } from "../constants";
 export declare type ChartType = "bar" | "line";
 export declare type FillStyle = "hachure" | "cross-hatch" | "solid";
 export declare type FontFamilyKeys = keyof typeof FONT_FAMILY;
@@ -10,7 +10,8 @@ export declare type FontString = string & {
 };
 export declare type GroupId = string;
 export declare type PointerType = "mouse" | "pen" | "touch";
-export declare type StrokeSharpness = "round" | "sharp";
+export declare type StrokeRoundness = "round" | "sharp";
+export declare type RoundnessType = ValueOf<typeof ROUNDNESS>;
 export declare type StrokeStyle = "solid" | "dashed" | "dotted";
 export declare type TextAlign = typeof TEXT_ALIGN[keyof typeof TEXT_ALIGN];
 declare type VerticalAlignKeys = keyof typeof VERTICAL_ALIGN;
@@ -24,7 +25,10 @@ declare type _ExcalidrawElementBase = Readonly<{
     fillStyle: FillStyle;
     strokeWidth: number;
     strokeStyle: StrokeStyle;
-    strokeSharpness: StrokeSharpness;
+    roundness: null | {
+        type: RoundnessType;
+        value?: number;
+    };
     roughness: number;
     opacity: number;
     width: number;
@@ -102,7 +106,7 @@ export declare type ExcalidrawTextElement = _ExcalidrawElementBase & Readonly<{
     originalText: string;
 }>;
 export declare type ExcalidrawBindableElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawTextElement | ExcalidrawImageElement;
-export declare type ExcalidrawTextContainer = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawImageElement;
+export declare type ExcalidrawTextContainer = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawImageElement | ExcalidrawArrowElement;
 export declare type ExcalidrawTextElementWithContainer = {
     containerId: ExcalidrawTextContainer["id"];
 } & ExcalidrawTextElement;
@@ -121,6 +125,9 @@ export declare type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<
     startArrowhead: Arrowhead | null;
     endArrowhead: Arrowhead | null;
 }>;
+export declare type ExcalidrawArrowElement = ExcalidrawLinearElement & Readonly<{
+    type: "arrow";
+}>;
 export declare type ExcalidrawFreeDrawElement = _ExcalidrawElementBase & Readonly<{
     type: "freedraw";
     points: readonly Point[];

package/types/hooks/useOutsideClick.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const useOutsideClickHook: (handler: (event: Event) => void) => import("react").MutableRefObject<null>;