@excalidraw/excalidraw 0.12.0-e885057 → 0.12.0-fd946ad

package/types/components/App.d.ts

@@ -1,6 +1,7 @@
 import React from "react";
 import { RoughCanvas } from "roughjs/bin/canvas";
 import { ActionManager } from "../actions/manager";
+import { LinearElementEditor } from "../element/linearElementEditor";
 import { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
 import History from "../history";
 import Scene from "../scene/Scene";
@@ -64,11 +65,11 @@ declare class App extends React.Component<AppProps, AppState> {
     private refreshDeviceState;
     componentDidMount(): Promise<void>;
     componentWillUnmount(): void;
-    private checkIfBrowserZoomed;
     private onResize;
     private removeEventListeners;
     private addEventListeners;
     componentDidUpdate(prevProps: AppProps, prevState: AppState): void;
+    private renderScene;
     private onScroll;
     private onCut;
     private onCopy;
@@ -84,10 +85,12 @@ declare class App extends React.Component<AppProps, AppState> {
     removePointer: (event: React.PointerEvent<HTMLElement> | PointerEvent) => void;
     toggleLock: (source?: "keyboard" | "ui") => void;
     togglePenMode: () => void;
-    toggleZenMode: () => void;
     scrollToContent: (target?: ExcalidrawElement | readonly ExcalidrawElement[]) => void;
-    clearToast: () => void;
-    setToastMessage: (toastMessage: string) => void;
+    setToast: (toast: {
+        message: string;
+        closable?: boolean;
+        duration?: number;
+    } | null) => void;
     restoreFileFromShare: () => Promise<void>;
     /** adds supplied files to existing files in the appState */
     addFiles: ExcalidrawImperativeAPI["addFiles"];
@@ -127,6 +130,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private handleCanvasPointerMove;
     private handleEraser;
     private handleTouchMove;
+    handleHoverSelectedLinearElement(linearElementEditor: LinearElementEditor, scenePointerX: number, scenePointerY: number): void;
     private handleCanvasPointerDown;
     private handleCanvasPointerUp;
     private maybeOpenContextMenuAfterPointerDownOnTouchDevices;

package/types/components/ButtonIconSelect.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 export declare const ButtonIconSelect: <T extends Object>({ options, value, onChange, group, }: {
     options: {
         value: T;

package/types/components/Card.d.ts

@@ -3,4 +3,5 @@ import OpenColor from "open-color";
 import "./Card.scss";
 export declare const Card: React.FC<{
     color: keyof OpenColor | "primary";
+    children?: React.ReactNode;
 }>;

package/types/components/CheckboxItem.d.ts

@@ -4,4 +4,5 @@ export declare const CheckboxItem: React.FC<{
     checked: boolean;
     onChange: (checked: boolean, event: React.MouseEvent) => void;
     className?: string;
+    children?: React.ReactNode;
 }>;

package/types/components/ClearCanvas.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 declare const ClearCanvas: ({ onConfirm }: {
     onConfirm: () => void;
 }) => JSX.Element;

package/types/components/CollabButton.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import "./CollabButton.scss";
 declare const CollabButton: ({ isCollaborating, collaboratorCount, onClick, }: {
     isCollaborating: boolean;

package/types/components/ColorPicker.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import "./ColorPicker.scss";
 import { ExcalidrawElement } from "../element/types";
 import { AppState } from "../types";

package/types/components/ConfirmDialog.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { DialogProps } from "./Dialog";
 import "./ConfirmDialog.scss";
 interface Props extends Omit<DialogProps, "onCloseRequest"> {

package/types/components/DarkModeToggle.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import "./ToolIcon.scss";
 import { Theme } from "../element/types";
 export declare const DarkModeToggle: (props: {

package/types/components/ErrorDialog.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 export declare const ErrorDialog: ({ message, onClose, }: {
     message: string;
     onClose?: (() => void) | undefined;

package/types/components/HelpDialog.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import "./HelpDialog.scss";
 export declare const HelpDialog: ({ onClose }: {
     onClose?: (() => void) | undefined;

package/types/components/HelpIcon.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 declare type HelpIconProps = {
     title?: string;
     name?: string;

package/types/components/HintViewer.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { NonDeletedExcalidrawElement } from "../element/types";
 import "./HintViewer.scss";
 import { AppState } from "../types";

package/types/components/IconPicker.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import "./IconPicker.scss";
 export declare function IconPicker<T>({ value, label, options, onChange, group, }: {
     label: string;

package/types/components/ImageExportDialog.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { NonDeletedExcalidrawElement } from "../element/types";
 import { AppState, BinaryFiles } from "../types";
 import "./ExportDialog.scss";

package/types/components/JSONExportDialog.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { NonDeletedExcalidrawElement } from "../element/types";
 import { AppState, ExportOpts, BinaryFiles } from "../types";
 import "./ExportDialog.scss";

package/types/components/LayerUI.d.ts

@@ -17,16 +17,13 @@ interface LayerUIProps {
     onLockToggle: () => void;
     onPenModeToggle: () => void;
     onInsertElements: (elements: readonly NonDeletedExcalidrawElement[]) => void;
-    zenModeEnabled: boolean;
     showExitZenModeBtn: boolean;
     showThemeBtn: boolean;
-    toggleZenMode: () => void;
     langCode: Language["code"];
     isCollaborating: boolean;
     renderTopRightUI?: ExcalidrawProps["renderTopRightUI"];
     renderCustomFooter?: ExcalidrawProps["renderFooter"];
     renderCustomStats?: ExcalidrawProps["renderCustomStats"];
-    viewModeEnabled: boolean;
     libraryReturnUrl: ExcalidrawProps["libraryReturnUrl"];
     UIOptions: AppProps["UIOptions"];
     focusContainer: () => void;
@@ -36,5 +33,5 @@ interface LayerUIProps {
         insertOnCanvasDirectly: boolean;
     }) => void;
 }
-declare const _default: React.MemoExoticComponent<({ actionManager, appState, files, setAppState, canvas, elements, onCollabButtonClick, onLockToggle, onPenModeToggle, onInsertElements, zenModeEnabled, showExitZenModeBtn, showThemeBtn, toggleZenMode, isCollaborating, renderTopRightUI, renderCustomFooter, renderCustomStats, viewModeEnabled, libraryReturnUrl, UIOptions, focusContainer, library, id, onImageAction, }: LayerUIProps) => JSX.Element>;
+declare const _default: React.MemoExoticComponent<({ actionManager, appState, files, setAppState, canvas, elements, onCollabButtonClick, onLockToggle, onPenModeToggle, onInsertElements, showExitZenModeBtn, showThemeBtn, isCollaborating, renderTopRightUI, renderCustomFooter, renderCustomStats, libraryReturnUrl, UIOptions, focusContainer, library, id, onImageAction, }: LayerUIProps) => JSX.Element>;
 export default _default;

package/types/components/LibraryMenu.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import Library from "../data/library";
 import { LibraryItems, LibraryItem, AppState, BinaryFiles, ExcalidrawProps } from "../types";
 import "./LibraryMenu.scss";

package/types/components/LibraryUnit.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { BinaryFiles, LibraryItem } from "../types";
 import "./LibraryUnit.scss";
 export declare const LibraryUnit: ({ id, elements, files, isPending, onClick, selected, onToggle, onDrag, }: {

package/types/components/LockButton.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import "./ToolIcon.scss";
 declare type LockIconProps = {
     title?: string;

package/types/components/MobileMenu.d.ts

@@ -16,7 +16,6 @@ declare type MobileMenuProps = {
     canvas: HTMLCanvasElement | null;
     isCollaborating: boolean;
     renderCustomFooter?: (isMobile: boolean, appState: AppState) => JSX.Element | null;
-    viewModeEnabled: boolean;
     showThemeBtn: boolean;
     onImageAction: (data: {
         insertOnCanvasDirectly: boolean;
@@ -24,5 +23,5 @@ declare type MobileMenuProps = {
     renderTopRightUI?: (isMobile: boolean, appState: AppState) => JSX.Element | null;
     renderStats: () => JSX.Element | null;
 };
-export declare const MobileMenu: ({ appState, elements, libraryMenu, actionManager, renderJSONExportDialog, renderImageExportDialog, setAppState, onCollabButtonClick, onLockToggle, onPenModeToggle, canvas, isCollaborating, renderCustomFooter, viewModeEnabled, showThemeBtn, onImageAction, renderTopRightUI, renderStats, }: MobileMenuProps) => JSX.Element;
+export declare const MobileMenu: ({ appState, elements, libraryMenu, actionManager, renderJSONExportDialog, renderImageExportDialog, setAppState, onCollabButtonClick, onLockToggle, onPenModeToggle, canvas, isCollaborating, renderCustomFooter, showThemeBtn, onImageAction, renderTopRightUI, renderStats, }: MobileMenuProps) => JSX.Element;
 export {};

package/types/components/Modal.d.ts

@@ -1,7 +1,7 @@
 import "./Modal.scss";
 import React from "react";
 import { AppState } from "../types";
-export declare const Modal: (props: {
+export declare const Modal: React.FC<{
     className?: string;
     children: React.ReactNode;
     maxWidth?: number;
@@ -9,4 +9,4 @@ export declare const Modal: (props: {
     labelledBy: string;
     theme?: AppState["theme"];
     closeOnClickOutside?: boolean;
-}) => React.ReactPortal | null;
+}>;

package/types/components/PenModeButton.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import "./ToolIcon.scss";
 declare type PenModeIconProps = {
     title?: string;

package/types/components/ProjectName.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import "./TextInput.scss";
 import "./ProjectName.scss";
 declare type Props = {

package/types/components/PublishLibrary.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { AppState, LibraryItems } from "../types";
 import "./PublishLibrary.scss";
 declare const PublishLibrary: ({ onClose, libraryItems, appState, onSuccess, onError, updateItemsInStorage, onRemove, }: {

package/types/components/Section.d.ts

@@ -1,7 +1,6 @@
 import React from "react";
-interface SectionProps extends React.HTMLProps<HTMLElement> {
+export declare const Section: React.FC<{
     heading: string;
-    children: React.ReactNode | ((header: React.ReactNode) => React.ReactNode);
-}
-export declare const Section: ({ heading, children, ...props }: SectionProps) => JSX.Element;
-export {};
+    children?: React.ReactNode | ((heading: React.ReactNode) => React.ReactNode);
+    className?: string;
+}>;

package/types/components/SidebarLockButton.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import "./ToolIcon.scss";
 import "./SidebarLockButton.scss";
 declare type SidebarLockIconProps = {

package/types/components/SingleLibraryItem.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { AppState, LibraryItem } from "../types";
 import "./SingleLibraryItem.scss";
 declare const SingleLibraryItem: ({ libItem, appState, index, onChange, onRemove, }: {

package/types/components/Spinner.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import "./Spinner.scss";
 declare const Spinner: ({ size, circleWidth, }: {
     size?: string | number | undefined;

package/types/components/Toast.d.ts

@@ -1,8 +1,7 @@
-/// <reference types="react" />
 import "./Toast.scss";
-export declare const Toast: ({ message, clearToast, closable, duration, }: {
+export declare const Toast: ({ message, onClose, closable, duration, }: {
     message: string;
-    clearToast: () => void;
+    onClose: () => void;
     closable?: boolean | undefined;
     duration?: number | undefined;
 }) => JSX.Element;

package/types/data/blob.d.ts

@@ -8,16 +8,16 @@ export declare const getFileHandleType: (handle: FileSystemHandle | null) => str
 export declare const isImageFileHandleType: (type: string | null) => type is "svg" | "png";
 export declare const isImageFileHandle: (handle: FileSystemHandle | null) => boolean;
 export declare const isSupportedImageFile: (blob: Blob | null | undefined) => blob is Blob & {
-    type: typeof ALLOWED_IMAGE_MIME_TYPES[number];
+    type: (typeof ALLOWED_IMAGE_MIME_TYPES)[number];
 };
-export declare const loadSceneOrLibraryFromBlob: (blob: Blob | File, localAppState: AppState | null, localElements: readonly ExcalidrawElement[] | null, fileHandle?: FileSystemHandle | null | undefined) => Promise<{
+export declare const loadSceneOrLibraryFromBlob: (blob: Blob | File, localAppState: AppState | null, localElements: readonly ExcalidrawElement[] | null, fileHandle?: FileSystemHandle | null) => Promise<{
     type: "application/vnd.excalidraw+json";
     data: import("./restore").RestoredDataState;
 } | {
     type: "application/vnd.excalidrawlib+json";
     data: ImportedLibraryData;
 }>;
-export declare const loadFromBlob: (blob: Blob, localAppState: AppState | null, localElements: readonly ExcalidrawElement[] | null, fileHandle?: FileSystemHandle | null | undefined) => Promise<import("./restore").RestoredDataState>;
+export declare const loadFromBlob: (blob: Blob, localAppState: AppState | null, localElements: readonly ExcalidrawElement[] | null, fileHandle?: FileSystemHandle | null) => Promise<import("./restore").RestoredDataState>;
 export declare const parseLibraryJSON: (json: string, defaultStatus?: LibraryItem["status"]) => LibraryItem[];
 export declare const loadLibraryFromBlob: (blob: Blob, defaultStatus?: LibraryItem["status"]) => Promise<LibraryItem[]>;
 export declare const canvasToBlob: (canvas: HTMLCanvasElement) => Promise<Blob>;
@@ -28,7 +28,7 @@ export declare const getDataURL: (file: Blob | File) => Promise<DataURL>;
 export declare const dataURLToFile: (dataURL: DataURL, filename?: string) => File;
 export declare const resizeImageFile: (file: File, opts: {
     /** undefined indicates auto */
-    outputType?: typeof MIME_TYPES["jpg"];
+    outputType?: (typeof MIME_TYPES)["jpg"];
     maxWidthOrHeight: number;
 }) => Promise<File>;
 export declare const SVGStringToFile: (SVGString: string, filename?: string) => File & {

package/types/data/json.d.ts

@@ -10,7 +10,7 @@ export declare const isValidExcalidrawData: (data?: {
     type?: any;
     elements?: any;
     appState?: any;
-} | undefined) => data is ImportedDataState;
+}) => data is ImportedDataState;
 export declare const isValidLibrary: (json: any) => json is ImportedLibraryData;
 export declare const serializeLibraryAsJSON: (libraryItems: LibraryItems) => string;
 export declare const saveLibraryAsJSON: (libraryItems: LibraryItems) => Promise<void>;

package/types/element/Hyperlink.d.ts

@@ -82,7 +82,11 @@ export declare const actionLink: {
             };
             shouldCacheIgnoreZoom: boolean;
             showHelpDialog: boolean;
-            toastMessage: string | null;
+            toast: {
+                message: string;
+                closable?: boolean | undefined;
+                duration?: number | undefined;
+            } | null;
             zenModeEnabled: boolean;
             theme: string;
             gridSize: number | null;
@@ -109,6 +113,7 @@ export declare const actionLink: {
                 data: import("../charts").Spreadsheet;
             };
             pendingImageElementId: string | null;
+            selectedLinearElement: import("./linearElementEditor").LinearElementEditor | null;
         };
         commitToHistory: true;
     };
@@ -119,7 +124,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;
-    PanelComponent: ({ elements, appState, updateData }: import("react").PropsWithChildren<import("../actions/types").PanelComponentProps>) => JSX.Element;
+    PanelComponent: ({ elements, appState, updateData }: import("../actions/types").PanelComponentProps) => JSX.Element;
 } & {
     keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
 };

package/types/element/binding.d.ts

@@ -22,12 +22,12 @@ export declare const getHoveredElementForBinding: (pointerCoords: {
     y: number;
 }, scene: Scene) => NonDeleted<ExcalidrawBindableElement> | null;
 export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, options?: {
-    simultaneouslyUpdated?: readonly ExcalidrawElement[] | undefined;
+    simultaneouslyUpdated?: readonly ExcalidrawElement[];
     newSize?: {
         width: number;
         height: number;
-    } | undefined;
-} | undefined) => void;
+    };
+}) => void;
 export declare const getEligibleElementsForBinding: (elements: NonDeleted<ExcalidrawElement>[]) => SuggestedBinding[];
 export declare const fixBindingsAfterDuplication: (sceneElements: readonly ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicatesServeAsOld?: "duplicatesServeAsOld" | undefined) => void;
 export declare const fixBindingsAfterDeletion: (sceneElements: readonly ExcalidrawElement[], deletedElements: readonly ExcalidrawElement[]) => void;

package/types/element/dragElements.d.ts

@@ -2,4 +2,4 @@ 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;
 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 | undefined) => 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) => void;

package/types/element/index.d.ts

@@ -9,7 +9,7 @@ export { dragSelectedElements, getDragOffsetXY, dragNewElement, } from "./dragEl
 export { isTextElement, isExcalidrawElement } from "./typeChecks";
 export { textWysiwyg } from "./textWysiwyg";
 export { redrawTextBoundingBox } from "./textElement";
-export { getPerfectElementSize, isInvisiblySmallElement, resizePerfectLineForNWHandler, getNormalizedDimensions, } from "./sizeHelpers";
+export { getPerfectElementSize, getLockedLinearCursorAlignSize, isInvisiblySmallElement, resizePerfectLineForNWHandler, getNormalizedDimensions, } from "./sizeHelpers";
 export { showSelectedShapeActions } from "./showSelectedShapeActions";
 export declare const getSceneVersion: (elements: readonly ExcalidrawElement[]) => number;
 export declare const getVisibleElements: (elements: readonly ExcalidrawElement[]) => readonly NonDeletedExcalidrawElement[];

package/types/element/linearElementEditor.d.ts

@@ -4,25 +4,27 @@ import { Point, AppState } from "../types";
 import History from "../history";
 import Scene from "../scene/Scene";
 export declare class LinearElementEditor {
-    elementId: ExcalidrawElement["id"] & {
+    readonly elementId: ExcalidrawElement["id"] & {
         _brand: "excalidrawLinearElementId";
     };
     /** indices */
-    selectedPointsIndices: readonly number[] | null;
-    pointerDownState: Readonly<{
+    readonly selectedPointsIndices: readonly number[] | null;
+    readonly pointerDownState: Readonly<{
         prevSelectedPointsIndices: readonly number[] | null;
         /** index */
         lastClickedPoint: number;
     }>;
     /** whether you're dragging a point */
-    isDragging: boolean;
-    lastUncommittedPoint: Point | null;
-    pointerOffset: Readonly<{
+    readonly isDragging: boolean;
+    readonly lastUncommittedPoint: Point | null;
+    readonly pointerOffset: Readonly<{
         x: number;
         y: number;
     }>;
-    startBindingElement: ExcalidrawBindableElement | null | "keep";
-    endBindingElement: ExcalidrawBindableElement | null | "keep";
+    readonly startBindingElement: ExcalidrawBindableElement | null | "keep";
+    readonly endBindingElement: ExcalidrawBindableElement | null | "keep";
+    readonly hoverPointIndex: number;
+    readonly midPointHovered: boolean;
     constructor(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene);
     static POINT_HANDLE_SIZE: number;
     /**
@@ -32,23 +34,30 @@ export declare class LinearElementEditor {
     static getElement(id: InstanceType<typeof LinearElementEditor>["elementId"]): NonDeleted<ExcalidrawLinearElement> | null;
     static handleBoxSelection(event: PointerEvent, appState: AppState, setState: React.Component<any, AppState>["setState"]): false | undefined;
     /** @returns whether point was dragged */
-    static handlePointDragging(appState: AppState, setState: React.Component<any, AppState>["setState"], scenePointerX: number, scenePointerY: number, maybeSuggestBinding: (element: NonDeleted<ExcalidrawLinearElement>, pointSceneCoords: {
+    static handlePointDragging(event: PointerEvent, appState: AppState, scenePointerX: number, scenePointerY: number, maybeSuggestBinding: (element: NonDeleted<ExcalidrawLinearElement>, pointSceneCoords: {
         x: number;
         y: number;
-    }[]) => void): boolean;
+    }[]) => void, linearElementEditor: LinearElementEditor): boolean;
     static handlePointerUp(event: PointerEvent, editingLinearElement: LinearElementEditor, appState: AppState): LinearElementEditor;
-    static handlePointerDown(event: React.PointerEvent<HTMLCanvasElement>, appState: AppState, setState: React.Component<any, AppState>["setState"], history: History, scenePointer: {
+    static isHittingMidPoint: (linearElementEditor: LinearElementEditor, scenePointer: {
         x: number;
         y: number;
-    }): {
+    }, appState: AppState) => boolean;
+    static getMidPoint(linearElementEditor: LinearElementEditor): readonly [number, number] | null;
+    static handlePointerDown(event: React.PointerEvent<HTMLCanvasElement>, appState: AppState, history: History, scenePointer: {
+        x: number;
+        y: number;
+    }, linearElementEditor: LinearElementEditor): {
         didAddPoint: boolean;
         hitElement: NonDeleted<ExcalidrawElement> | null;
+        linearElementEditor: LinearElementEditor | null;
+        isMidPoint: boolean;
     };
-    static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, editingLinearElement: LinearElementEditor, gridSize: number | null): LinearElementEditor;
+    static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, linearElementEditor: LinearElementEditor, gridSize: number | null): LinearElementEditor;
     /** scene coords */
     static getPointGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, point: Point): readonly [number, number];
     /** scene coords */
-    static getPointsGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>): number[][];
+    static getPointsGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>): Point[];
     static getPointAtIndexGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, indexMaybeFromEnd: number): Point;
     static pointFromAbsoluteCoords(element: NonDeleted<ExcalidrawLinearElement>, absoluteCoords: Point): Point;
     static getPointIndexUnderCursor(element: NonDeleted<ExcalidrawLinearElement>, zoom: AppState["zoom"], x: number, y: number): number;
@@ -76,7 +85,6 @@ export declare class LinearElementEditor {
                     /** index */
                     lastClickedPoint: number;
                 }>;
-                /** whether you're dragging a point */
                 isDragging: boolean;
                 lastUncommittedPoint: readonly [number, number] | null;
                 pointerOffset: Readonly<{
@@ -85,6 +93,8 @@ export declare class LinearElementEditor {
                 }>;
                 startBindingElement: ExcalidrawBindableElement | "keep" | null;
                 endBindingElement: ExcalidrawBindableElement | "keep" | null;
+                hoverPointIndex: number;
+                midPointHovered: boolean;
             };
             isLoading: boolean;
             errorMessage: string | null;
@@ -149,7 +159,11 @@ export declare class LinearElementEditor {
             };
             shouldCacheIgnoreZoom: boolean;
             showHelpDialog: boolean;
-            toastMessage: string | null;
+            toast: {
+                message: string;
+                closable?: boolean | undefined;
+                duration?: number | undefined;
+            } | null;
             zenModeEnabled: boolean;
             theme: string;
             gridSize: number | null;
@@ -177,6 +191,7 @@ export declare class LinearElementEditor {
             };
             pendingImageElementId: string | null;
             showHyperlinkPopup: false | "info" | "editor";
+            selectedLinearElement: LinearElementEditor | null;
         };
     };
     static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[]): void;
@@ -192,4 +207,5 @@ export declare class LinearElementEditor {
         endBinding?: PointBinding;
     }): void;
     private static _updatePoints;
+    private static _getShiftLockedDelta;
 }

package/types/element/mutateElement.d.ts

@@ -7,5 +7,5 @@ export declare const newElementWith: <TElement extends ExcalidrawElement>(elemen
  *
  * NOTE: does not trigger re-render.
  */
-export declare const bumpVersion: (element: Mutable<ExcalidrawElement>, version?: number | undefined) => Mutable<ExcalidrawElement>;
+export declare const bumpVersion: (element: Mutable<ExcalidrawElement>, version?: ExcalidrawElement["version"]) => Mutable<ExcalidrawElement>;
 export {};

package/types/element/sizeHelpers.d.ts

@@ -8,6 +8,10 @@ export declare const getPerfectElementSize: (elementType: AppState["activeTool"]
     width: number;
     height: number;
 };
+export declare const getLockedLinearCursorAlignSize: (originX: number, originY: number, x: number, y: number) => {
+    width: number;
+    height: number;
+};
 export declare const resizePerfectLineForNWHandler: (element: ExcalidrawElement, x: number, y: number) => void;
 export declare const getNormalizedDimensions: (element: Pick<ExcalidrawElement, "width" | "height" | "x" | "y">) => {
     width: ExcalidrawElement["width"];

package/types/element/textElement.d.ts

@@ -3,7 +3,7 @@ import { MaybeTransformHandleType } from "./transformHandles";
 export declare const redrawTextBoundingBox: (element: 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 measureText: (text: string, font: FontString, maxWidth?: number | null | undefined) => {
+export declare const measureText: (text: string, font: FontString, maxWidth?: number | null) => {
     width: number;
     height: number;
     baseline: number;

package/types/element/transformHandles.d.ts

@@ -1,4 +1,4 @@
-import { ExcalidrawElement, PointerType } from "./types";
+import { ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
 import { Bounds } from "./bounds";
 import { Zoom } from "../types";
 export declare type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
@@ -17,12 +17,13 @@ export declare const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS: {
 export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2]: Bounds, angle: number, zoom: Zoom, pointerType: PointerType, omitSides?: {
     e?: boolean | undefined;
     s?: boolean | undefined;
-    n?: boolean | undefined;
     w?: boolean | undefined;
+    n?: boolean | undefined;
     nw?: boolean | undefined;
     ne?: boolean | undefined;
     sw?: boolean | undefined;
     se?: boolean | undefined;
     rotation?: boolean | undefined;
-}) => TransformHandles;
+}, margin?: number) => TransformHandles;
 export declare const getTransformHandles: (element: ExcalidrawElement, zoom: Zoom, pointerType?: PointerType) => TransformHandles;
+export declare const shouldShowBoundingBox: (elements: NonDeletedExcalidrawElement[]) => boolean;

package/types/element/typeChecks.d.ts

@@ -4,11 +4,11 @@ export declare const isGenericElement: (element: ExcalidrawElement | null) => el
 export declare const isInitializedImageElement: (element: ExcalidrawElement | null) => element is InitializedExcalidrawImageElement;
 export declare const isImageElement: (element: ExcalidrawElement | null) => element is ExcalidrawImageElement;
 export declare const isTextElement: (element: ExcalidrawElement | null) => element is ExcalidrawTextElement;
-export declare const isFreeDrawElement: (element?: ExcalidrawElement | null | undefined) => element is ExcalidrawFreeDrawElement;
+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 | undefined) => element is ExcalidrawLinearElement;
+export declare const isLinearElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
 export declare const isLinearElementType: (elementType: AppState["activeTool"]["type"]) => boolean;
-export declare const isBindingElement: (element?: ExcalidrawElement | null | undefined, includeLocked?: boolean) => element is ExcalidrawLinearElement;
+export declare const isBindingElement: (element?: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawLinearElement;
 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;

package/types/keys.d.ts

@@ -65,4 +65,4 @@ export declare type Key = keyof typeof KEYS;
 export declare const isArrowKey: (key: string) => boolean;
 export declare const shouldResizeFromCenter: (event: MouseEvent | KeyboardEvent) => boolean;
 export declare const shouldMaintainAspectRatio: (event: MouseEvent | KeyboardEvent) => boolean;
-export declare const shouldRotateWithDiscreteAngle: (event: MouseEvent | KeyboardEvent) => boolean;
+export declare const shouldRotateWithDiscreteAngle: (event: MouseEvent | KeyboardEvent | React.PointerEvent<HTMLCanvasElement>) => boolean;