@excalidraw/excalidraw 0.12.0-966ca2f → 0.12.0-9929a2b

package/types/components/BackgroundPickerAndDarkModeToggle.d.ts

@@ -1,9 +1,4 @@
-import React from "react";
 import { ActionManager } from "../actions/manager";
-import { AppState } from "../types";
-export declare const BackgroundPickerAndDarkModeToggle: ({ appState, setAppState, actionManager, showThemeBtn, }: {
+export declare const BackgroundPickerAndDarkModeToggle: ({ actionManager, }: {
     actionManager: ActionManager;
-    appState: AppState;
-    setAppState: React.Component<any, AppState>["setState"];
-    showThemeBtn: boolean;
 }) => JSX.Element;

package/types/components/Footer.d.ts

@@ -0,0 +1,9 @@
+import { ActionManager } from "../actions/manager";
+import { AppState, ExcalidrawProps } from "../types";
+declare const Footer: ({ appState, actionManager, renderCustomFooter, showExitZenModeBtn, }: {
+    appState: AppState;
+    actionManager: ActionManager;
+    renderCustomFooter?: ExcalidrawProps["renderFooter"];
+    showExitZenModeBtn: boolean;
+}) => JSX.Element;
+export default Footer;

package/types/components/InitializeApp.d.ts

@@ -1,8 +1,10 @@
 import React from "react";
 import { Language } from "../i18n";
+import { Theme } from "../element/types";
 interface Props {
     langCode: Language["code"];
     children: React.ReactElement;
+    theme?: Theme;
 }
 export declare const InitializeApp: (props: Props) => JSX.Element;
 export {};

package/types/components/LayerUI.d.ts

@@ -18,7 +18,6 @@ interface LayerUIProps {
     onPenModeToggle: () => void;
     onInsertElements: (elements: readonly NonDeletedExcalidrawElement[]) => void;
     showExitZenModeBtn: boolean;
-    showThemeBtn: boolean;
     langCode: Language["code"];
     isCollaborating: boolean;
     renderTopRightUI?: ExcalidrawProps["renderTopRightUI"];
@@ -33,5 +32,5 @@ interface LayerUIProps {
         insertOnCanvasDirectly: boolean;
     }) => void;
 }
-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>;
+declare const _default: React.MemoExoticComponent<({ actionManager, appState, files, setAppState, elements, canvas, onCollabButtonClick, onLockToggle, onPenModeToggle, onInsertElements, showExitZenModeBtn, isCollaborating, renderTopRightUI, renderCustomFooter, renderCustomStats, libraryReturnUrl, UIOptions, focusContainer, library, id, onImageAction, }: LayerUIProps) => JSX.Element>;
 export default _default;

package/types/components/LibraryMenu.d.ts

@@ -1,12 +1,11 @@
 import Library from "../data/library";
 import { LibraryItems, LibraryItem, AppState, BinaryFiles, ExcalidrawProps } from "../types";
 import "./LibraryMenu.scss";
-export declare const LibraryMenu: ({ onClose, onInsertLibraryItems, pendingElements, onAddToLibrary, theme, setAppState, files, libraryReturnUrl, focusContainer, library, id, appState, }: {
+export declare const LibraryMenu: ({ onClose, onInsertLibraryItems, pendingElements, onAddToLibrary, setAppState, files, libraryReturnUrl, focusContainer, library, id, appState, }: {
     pendingElements: LibraryItem["elements"];
     onClose: () => void;
     onInsertLibraryItems: (libraryItems: LibraryItems) => void;
     onAddToLibrary: () => void;
-    theme: AppState["theme"];
     files: BinaryFiles;
     setAppState: React.Component<any, AppState>["setState"];
     libraryReturnUrl: ExcalidrawProps["libraryReturnUrl"];

package/types/components/LoadingMessage.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="react" />
+import { Theme } from "../element/types";
 export declare const LoadingMessage: React.FC<{
     delay?: number;
+    theme?: Theme;
 }>;

package/types/components/MobileMenu.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { AppState } from "../types";
+import { AppState, ExcalidrawProps } from "../types";
 import { ActionManager } from "../actions/manager";
 import { NonDeletedExcalidrawElement } from "../element/types";
 declare type MobileMenuProps = {
@@ -16,12 +16,11 @@ declare type MobileMenuProps = {
     canvas: HTMLCanvasElement | null;
     isCollaborating: boolean;
     renderCustomFooter?: (isMobile: boolean, appState: AppState) => JSX.Element | null;
-    showThemeBtn: boolean;
     onImageAction: (data: {
         insertOnCanvasDirectly: boolean;
     }) => void;
     renderTopRightUI?: (isMobile: boolean, appState: AppState) => JSX.Element | null;
-    renderStats: () => JSX.Element | null;
+    renderCustomStats?: ExcalidrawProps["renderCustomStats"];
 };
-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 declare const MobileMenu: ({ appState, elements, libraryMenu, actionManager, renderJSONExportDialog, renderImageExportDialog, setAppState, onCollabButtonClick, onLockToggle, onPenModeToggle, canvas, isCollaborating, renderCustomFooter, onImageAction, renderTopRightUI, renderCustomStats, }: MobileMenuProps) => JSX.Element;
 export {};

package/types/components/Stats.d.ts

@@ -8,4 +8,4 @@ export declare const Stats: (props: {
     elements: readonly NonDeletedExcalidrawElement[];
     onClose: () => void;
     renderCustomStats: ExcalidrawProps["renderCustomStats"];
-}) => JSX.Element | null;
+}) => JSX.Element;

package/types/data/blob.d.ts

@@ -40,7 +40,7 @@ export declare const getFileFromEvent: (event: React.DragEvent<HTMLDivElement>)
 }>;
 export declare const getFileHandle: (event: React.DragEvent<HTMLDivElement>) => Promise<FileSystemHandle | null>;
 export declare const createFile: (blob: File | Blob | ArrayBuffer, mimeType: ValueOf<typeof MIME_TYPES>, name: string | undefined) => File;
-/** attemps to detect correct mimeType if none is set, or if an image
+/** attempts to detect correct mimeType if none is set, or if an image
  * has an incorrect extension.
  * Note: doesn't handle missing .excalidraw/.excalidrawlib extension  */
 export declare const normalizeFile: (file: File) => Promise<File>;

package/types/element/Hyperlink.d.ts

@@ -4,9 +4,8 @@ import { NonDeletedExcalidrawElement } from "./types";
 import { Bounds } from "./bounds";
 import "./Hyperlink.scss";
 export declare const EXTERNAL_LINK_IMG: HTMLImageElement;
-export declare const Hyperlink: ({ element, appState, setAppState, onLinkOpen, }: {
+export declare const Hyperlink: ({ element, setAppState, onLinkOpen, }: {
     element: NonDeletedExcalidrawElement;
-    appState: AppState;
     setAppState: React.Component<any, AppState>["setState"];
     onLinkOpen: ExcalidrawProps["onLinkOpen"];
 }) => JSX.Element | null;
@@ -113,6 +112,7 @@ export declare const actionLink: {
                 data: import("../charts").Spreadsheet;
             };
             pendingImageElementId: string | null;
+            selectedLinearElement: import("./linearElementEditor").LinearElementEditor | null;
         };
         commitToHistory: true;
     };

package/types/element/bounds.d.ts

@@ -8,7 +8,7 @@ export declare const getCurvePathOps: (shape: Drawable) => Op[];
 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) => [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 getClosestElementBounds: (elements: readonly ExcalidrawElement[], from: {
     x: number;

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

@@ -3,26 +3,33 @@ import { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, E
 import { Point, AppState } from "../types";
 import History from "../history";
 import Scene from "../scene/Scene";
+declare const editorMidPointsCache: {
+    version: number | null;
+    points: (Point | null)[];
+    zoom: number | null;
+};
 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 segmentMidPointHoveredCoords: Point | null;
     constructor(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene);
     static POINT_HANDLE_SIZE: number;
     /**
@@ -32,23 +39,35 @@ 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 getEditorMidPoints: (element: NonDeleted<ExcalidrawLinearElement>, appState: AppState) => (typeof editorMidPointsCache)["points"];
+    static updateEditorMidPointsCache: (element: NonDeleted<ExcalidrawLinearElement>, appState: AppState) => void;
+    static getSegmentMidpointHitCoords: (linearElementEditor: LinearElementEditor, scenePointer: {
         x: number;
         y: number;
-    }): {
+    }, appState: AppState) => readonly [number, number] | null;
+    static isSegmentTooShort(element: NonDeleted<ExcalidrawLinearElement>, startPoint: Point, endPoint: Point, zoom: AppState["zoom"]): boolean;
+    static getSegmentMidPoint(element: NonDeleted<ExcalidrawLinearElement>, startPoint: Point, endPoint: Point, endPointIndex: number): readonly [number, number];
+    static getSegmentMidPointIndex(linearElementEditor: LinearElementEditor, appState: AppState, midPoint: Point): number;
+    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 arePointsEqual(point1: Point | null, point2: Point | null): boolean;
+    static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, appState: AppState): LinearElementEditor | null;
     /** 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 +95,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 +103,8 @@ export declare class LinearElementEditor {
                 }>;
                 startBindingElement: ExcalidrawBindableElement | "keep" | null;
                 endBindingElement: ExcalidrawBindableElement | "keep" | null;
+                hoverPointIndex: number;
+                segmentMidPointHoveredCoords: readonly [number, number] | null;
             };
             isLoading: boolean;
             errorMessage: string | null;
@@ -150,7 +170,7 @@ export declare class LinearElementEditor {
             shouldCacheIgnoreZoom: boolean;
             showHelpDialog: boolean;
             toast: {
-                message: string;
+                message: string; /** @returns whether point was dragged */
                 closable?: boolean | undefined;
                 duration?: number | undefined;
             } | null;
@@ -181,10 +201,11 @@ export declare class LinearElementEditor {
             };
             pendingImageElementId: string | null;
             showHyperlinkPopup: false | "info" | "editor";
+            selectedLinearElement: LinearElementEditor | null;
         };
     };
     static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[]): void;
-    static addPoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
+    static addPoints(element: NonDeleted<ExcalidrawLinearElement>, appState: AppState, targetPoints: {
         point: Point;
     }[]): void;
     static movePoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
@@ -196,4 +217,6 @@ export declare class LinearElementEditor {
         endBinding?: PointBinding;
     }): void;
     private static _updatePoints;
+    private static _getShiftLockedDelta;
 }
+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/transformHandles.d.ts

@@ -1,6 +1,6 @@
-import { ExcalidrawElement, PointerType } from "./types";
+import { ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
 import { Bounds } from "./bounds";
-import { Zoom } from "../types";
+import { AppState, Zoom } from "../types";
 export declare type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
 export declare type TransformHandleType = TransformHandleDirection | "rotation";
 export declare type TransformHandle = [number, number, number, number];
@@ -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[], appState: AppState) => boolean;

package/types/element/types.d.ts

@@ -53,6 +53,7 @@ declare type _ExcalidrawElementBase = Readonly<{
     updated: number;
     link: string | null;
     locked: boolean;
+    customData?: Record<string, any>;
 }>;
 export declare type ExcalidrawSelectionElement = _ExcalidrawElementBase & {
     type: "selection";

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;

package/types/math.d.ts

@@ -1,5 +1,5 @@
 import { Point, Zoom } from "./types";
-import { ExcalidrawLinearElement } from "./element/types";
+import { ExcalidrawLinearElement, NonDeleted } from "./element/types";
 export declare const rotate: (x1: number, y1: number, x2: number, y2: number, angle: number) => [number, number];
 export declare const rotatePoint: (point: readonly [number, number], center: readonly [number, number], angle: number) => [number, number];
 export declare const adjustXYWithRotation: (sides: {
@@ -18,3 +18,10 @@ export declare const centerPoint: (a: readonly [number, number], b: readonly [nu
 export declare const isPathALoop: (points: ExcalidrawLinearElement["points"], zoomValue?: Zoom["value"]) => boolean;
 export declare const isPointInPolygon: (points: Point[], x: number, y: number) => boolean;
 export declare const getGridPoint: (x: number, y: number, gridSize: number | null) => [number, number];
+export declare const getControlPointsForBezierCurve: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number]) => [number, number][] | null;
+export declare const getBezierXY: (p0: readonly [number, number], p1: readonly [number, number], p2: readonly [number, number], p3: readonly [number, number], t: number) => number[];
+export declare const getPointsInBezierCurve: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number]) => [number, number][];
+export declare const getBezierCurveArcLengths: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number]) => number[];
+export declare const getBezierCurveLength: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number]) => number;
+export declare const mapIntervalToBezierT: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number], interval: number) => number;
+export declare const arePointsEqual: (p1: readonly [number, number], p2: readonly [number, number]) => boolean;