@zsviczian/excalidraw 0.17.1-obsidian-47 → 0.17.1-obsidian-48

package/types/excalidraw/element/linearElementEditor.d.ts

@@ -1,11 +1,12 @@
 import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, OrderedExcalidrawElement, SceneElementsMap } from "./types";
 import type { Bounds } from "./bounds";
-import type { Point, AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize } from "../types";
+import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize } from "../types";
 import type { Store } from "../store";
 import type Scene from "../scene/Scene";
+import { type GlobalPoint, type LocalPoint } from "../../math";
 declare const editorMidPointsCache: {
     version: number | null;
-    points: (Point | null)[];
+    points: (GlobalPoint | null)[];
     zoom: number | null;
 };
 export declare class LinearElementEditor {
@@ -24,14 +25,14 @@ export declare class LinearElementEditor {
             y: number;
         }> | null;
         segmentMidpoint: {
-            value: Point | null;
+            value: GlobalPoint | null;
             index: number | null;
             added: boolean;
         };
     }>;
     /** whether you're dragging a point */
     readonly isDragging: boolean;
-    readonly lastUncommittedPoint: Point | null;
+    readonly lastUncommittedPoint: LocalPoint | null;
     readonly pointerOffset: Readonly<{
         x: number;
         y: number;
@@ -39,7 +40,7 @@ export declare class LinearElementEditor {
     readonly startBindingElement: ExcalidrawBindableElement | null | "keep";
     readonly endBindingElement: ExcalidrawBindableElement | null | "keep";
     readonly hoverPointIndex: number;
-    readonly segmentMidPointHoveredCoords: Point | null;
+    readonly segmentMidPointHoveredCoords: GlobalPoint | null;
     constructor(element: NonDeleted<ExcalidrawLinearElement>);
     static POINT_HANDLE_SIZE: number;
     /**
@@ -59,10 +60,10 @@ export declare class LinearElementEditor {
     static getSegmentMidpointHitCoords: (linearElementEditor: LinearElementEditor, scenePointer: {
         x: number;
         y: number;
-    }, appState: AppState, elementsMap: ElementsMap) => 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, elementsMap: ElementsMap): readonly [number, number];
-    static getSegmentMidPointIndex(linearElementEditor: LinearElementEditor, appState: AppState, midPoint: Point, elementsMap: ElementsMap): number;
+    }, appState: AppState, elementsMap: ElementsMap) => GlobalPoint | null;
+    static isSegmentTooShort(element: NonDeleted<ExcalidrawLinearElement>, startPoint: GlobalPoint | LocalPoint, endPoint: GlobalPoint | LocalPoint, zoom: AppState["zoom"]): boolean;
+    static getSegmentMidPoint(element: NonDeleted<ExcalidrawLinearElement>, startPoint: GlobalPoint, endPoint: GlobalPoint, endPointIndex: number, elementsMap: ElementsMap): GlobalPoint;
+    static getSegmentMidPointIndex(linearElementEditor: LinearElementEditor, appState: AppState, midPoint: GlobalPoint, elementsMap: ElementsMap): number;
     static handlePointerDown(event: React.PointerEvent<HTMLElement>, app: AppClassProperties, store: Store, scenePointer: {
         x: number;
         y: number;
@@ -71,254 +72,36 @@ export declare class LinearElementEditor {
         hitElement: NonDeleted<ExcalidrawElement> | null;
         linearElementEditor: LinearElementEditor | null;
     };
-    static arePointsEqual(point1: Point | null, point2: Point | null): boolean;
+    static arePointsEqual<Point extends LocalPoint | GlobalPoint>(point1: Point | null, point2: Point | null): boolean;
     static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, app: AppClassProperties, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): LinearElementEditor | null;
     /** scene coords */
-    static getPointGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, point: Point, elementsMap: ElementsMap): readonly [number, number];
+    static getPointGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, p: LocalPoint, elementsMap: ElementsMap): GlobalPoint;
     /** scene coords */
-    static getPointsGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap): Point[];
+    static getPointsGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap): GlobalPoint[];
     static getPointAtIndexGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, indexMaybeFromEnd: number, // -1 for last element
-    elementsMap: ElementsMap): Point;
-    static pointFromAbsoluteCoords(element: NonDeleted<ExcalidrawLinearElement>, absoluteCoords: Point, elementsMap: ElementsMap): Point;
+    elementsMap: ElementsMap): GlobalPoint;
+    static pointFromAbsoluteCoords(element: NonDeleted<ExcalidrawLinearElement>, absoluteCoords: GlobalPoint, elementsMap: ElementsMap): LocalPoint;
     static getPointIndexUnderCursor(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, zoom: AppState["zoom"], x: number, y: number): number;
-    static createPointAt(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, scenePointerX: number, scenePointerY: number, gridSize: NullableGridSize): Point;
+    static createPointAt(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, scenePointerX: number, scenePointerY: number, gridSize: NullableGridSize): LocalPoint;
     /**
      * Normalizes line points so that the start point is at [0,0]. This is
      * expected in various parts of the codebase. Also returns new x/y to account
      * for the potential normalization.
      */
     static getNormalizedPoints(element: ExcalidrawLinearElement): {
-        points: (readonly [number, number])[];
+        points: LocalPoint[];
         x: number;
         y: number;
     };
     static normalizePoints(element: NonDeleted<ExcalidrawLinearElement>): void;
-    static duplicateSelectedPoints(appState: AppState, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): false | {
-        appState: {
-            editingLinearElement: {
-                selectedPointsIndices: number[];
-                elementId: string & {
-                    _brand: "excalidrawLinearElementId";
-                };
-                pointerDownState: Readonly<{
-                    prevSelectedPointsIndices: readonly number[] | null;
-                    /** index */
-                    lastClickedPoint: number;
-                    lastClickedIsEndPoint: boolean;
-                    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;
-                pointerOffset: Readonly<{
-                    x: number;
-                    y: number;
-                }>;
-                startBindingElement: ExcalidrawBindableElement | "keep" | null;
-                endBindingElement: ExcalidrawBindableElement | "keep" | null;
-                hoverPointIndex: number;
-                segmentMidPointHoveredCoords: readonly [number, number] | null;
-            };
-            contextMenu: {
-                items: import("../components/ContextMenu").ContextMenuItems;
-                top: number;
-                left: number;
-            } | null;
-            showWelcomeScreen: boolean;
-            isLoading: boolean;
-            errorMessage: import("react").ReactNode;
-            activeEmbeddable: {
-                element: import("./types").NonDeletedExcalidrawElement;
-                state: "active" | "hover";
-            } | null;
-            newElement: NonDeleted<import("./types").ExcalidrawNonSelectionElement> | null;
-            resizingElement: import("./types").NonDeletedExcalidrawElement | null;
-            multiElement: NonDeleted<ExcalidrawLinearElement> | null;
-            selectionElement: import("./types").NonDeletedExcalidrawElement | null;
-            isBindingEnabled: boolean;
-            startBoundElement: NonDeleted<ExcalidrawBindableElement> | null;
-            suggestedBindings: import("./binding").SuggestedBinding[];
-            frameToHighlight: NonDeleted<import("./types").ExcalidrawFrameLikeElement> | null;
-            frameRendering: {
-                enabled: boolean;
-                name: boolean;
-                outline: boolean;
-                clip: boolean;
-            };
-            editingFrame: string | null;
-            elementsToHighlight: NonDeleted<ExcalidrawElement>[] | null;
-            editingTextElement: import("./types").NonDeletedExcalidrawElement | null;
-            activeTool: {
-                lastActiveTool: import("../types").ActiveTool | null;
-                locked: boolean;
-            } & import("../types").ActiveTool;
-            penMode: boolean;
-            penDetected: boolean;
-            exportBackground: boolean;
-            exportEmbedScene: boolean;
-            exportWithDarkMode: boolean;
-            exportScale: number;
-            currentItemStrokeColor: string;
-            currentItemBackgroundColor: string;
-            currentItemFillStyle: import("./types").FillStyle;
-            currentItemStrokeWidth: number;
-            currentItemStrokeStyle: import("./types").StrokeStyle;
-            currentItemRoughness: number;
-            currentItemOpacity: number;
-            currentItemFontFamily: number;
-            currentItemFontSize: number;
-            currentItemTextAlign: string;
-            currentItemStartArrowhead: import("./types").Arrowhead | null;
-            currentItemEndArrowhead: import("./types").Arrowhead | null;
-            currentHoveredFontFamily: number | null;
-            currentItemRoundness: import("./types").StrokeRoundness;
-            currentItemArrowType: "sharp" | "round" | "elbow";
-            viewBackgroundColor: string;
-            scrollX: number;
-            scrollY: number;
-            cursorButton: "up" | "down";
-            scrolledOutside: boolean;
-            name: string | null;
-            isResizing: boolean;
-            isRotating: boolean;
-            zoom: Readonly<{
-                value: import("../types").NormalizedZoomValue;
-            }>;
-            openMenu: "canvas" | "shape" | null;
-            openPopup: "fontFamily" | "canvasBackground" | "elementBackground" | "elementStroke" | null;
-            openSidebar: {
-                name: string;
-                tab?: string | undefined;
-            } | null;
-            openDialog: {
-                name: "imageExport" | "help" | "jsonExport";
-            } | {
-                name: "ttd";
-                tab: "mermaid" | "text-to-diagram";
-            } | {
-                name: "commandPalette";
-            } | null;
-            defaultSidebarDockedPreference: boolean;
-            lastPointerDownWith: import("./types").PointerType;
-            selectedElementIds: Readonly<{
-                [id: string]: true;
-            }>;
-            previousSelectedElementIds: {
-                [id: string]: true;
-            };
-            selectedElementsAreBeingDragged: boolean;
-            shouldCacheIgnoreZoom: boolean;
-            toast: {
-                message: string;
-                closable?: boolean | undefined;
-                duration?: number | undefined;
-            } | null;
-            zenModeEnabled: boolean;
-            theme: import("./types").Theme;
-            gridSize: number;
-            gridStep: number;
-            gridModeEnabled: boolean;
-            viewModeEnabled: boolean;
-            selectedGroupIds: {
-                [groupId: string]: boolean;
-            };
-            editingGroupId: string | null;
-            width: number;
-            height: number;
-            offsetTop: number;
-            offsetLeft: number;
-            fileHandle: import("browser-fs-access").FileSystemHandle | null;
-            collaborators: Map<import("../types").SocketId, Readonly<{
-                pointer?: import("../types").CollaboratorPointer | undefined;
-                button?: "up" | "down" | undefined;
-                selectedElementIds?: Readonly<{
-                    [id: string]: true;
-                }> | undefined;
-                username?: string | null | undefined;
-                userState?: import("../types").UserIdleState | undefined;
-                color?: {
-                    background: string;
-                    stroke: string;
-                } | undefined;
-                avatarUrl?: string | undefined;
-                id?: string | undefined;
-                socketId?: import("../types").SocketId | undefined;
-                isCurrentUser?: boolean | undefined; /** whether you're dragging a point */
-                isInCall?: boolean | undefined;
-                isSpeaking?: boolean | undefined;
-                isMuted?: boolean | undefined;
-            }>>;
-            stats: {
-                open: boolean;
-                panels: number;
-            };
-            currentChartType: import("./types").ChartType;
-            pasteDialog: {
-                shown: false;
-                data: null;
-            } | {
-                shown: true;
-                data: import("../charts").Spreadsheet;
-            };
-            pendingImageElementId: string | null;
-            showHyperlinkPopup: false | "info" | "editor";
-            linkOpacity: number;
-            trayModeEnabled: boolean;
-            colorPalette?: {
-                canvasBackground: import("../colors").ColorPaletteCustom;
-                elementBackground: import("../colors").ColorPaletteCustom;
-                elementStroke: import("../colors").ColorPaletteCustom;
-                topPicks: {
-                    canvasBackground: [string, string, string, string, string];
-                    elementStroke: [string, string, string, string, string];
-                    elementBackground: [string, string, string, string, string];
-                };
-            } | undefined;
-            allowWheelZoom?: boolean | undefined;
-            allowPinchZoom?: boolean | undefined;
-            pinnedScripts?: string[] | undefined;
-            customPens?: any[] | undefined;
-            currentStrokeOptions?: any;
-            resetCustomPen?: any;
-            gridColor: {
-                Bold: string;
-                Regular: string;
-            };
-            highlightSearchResult: boolean;
-            dynamicStyle: {
-                [x: string]: string;
-            };
-            frameColor: {
-                stroke: string;
-                fill: string;
-                nameColor: string;
-            };
-            invertBindingBehaviour: boolean;
-            selectedLinearElement: LinearElementEditor | null;
-            snapLines: readonly import("../snapping").SnapLine[];
-            originSnapOffset: {
-                x: number;
-                y: number;
-            } | null;
-            objectsSnapModeEnabled: boolean;
-            userToFollow: import("../types").UserToFollow | null;
-            followedBy: Set<import("../types").SocketId>;
-        };
-    };
+    static duplicateSelectedPoints(appState: AppState, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): AppState;
     static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): void;
     static addPoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
-        point: Point;
+        point: LocalPoint;
     }[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): void;
     static movePoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
         index: number;
-        point: Point;
+        point: LocalPoint;
         isDragging?: boolean;
     }[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, otherUpdates?: {
         startBinding?: PointBinding | null;

package/types/excalidraw/element/resizeElements.d.ts

@@ -1,10 +1,9 @@
 import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ElementsMap, NonDeletedSceneElementsMap, SceneElementsMap } from "./types";
 import type { MaybeTransformHandleType, TransformHandleDirection } from "./transformHandles";
 import type { PointerDownState } from "../types";
-export declare const normalizeAngle: (angle: number) => number;
 export declare const transformElements: (originalElements: PointerDownState["originalElements"], transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: SceneElementsMap, shouldRotateWithDiscreteAngle: boolean, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number) => boolean;
 export declare const rescalePointsInElement: (element: NonDeletedExcalidrawElement, width: number, height: number, normalizePoints: boolean) => {
-    points: (readonly [number, number])[];
+    points: import("../../math").LocalPoint[];
 } | {
     points?: undefined;
 };

package/types/excalidraw/element/resizeTest.d.ts

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

package/types/excalidraw/element/routing.d.ts

@@ -1,6 +1,6 @@
-import type { Point } from "../types";
+import { type LocalPoint, type Vector } from "../../math";
 import type { ExcalidrawElbowArrowElement, FixedPointBinding, NonDeletedSceneElementsMap, SceneElementsMap } from "./types";
-export declare const mutateElbowArrow: (arrow: ExcalidrawElbowArrowElement, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, nextPoints: readonly Point[], offset?: Point, otherUpdates?: {
+export declare const mutateElbowArrow: (arrow: ExcalidrawElbowArrowElement, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, nextPoints: readonly LocalPoint[], offset?: Vector, otherUpdates?: {
     startBinding?: FixedPointBinding | null;
     endBinding?: FixedPointBinding | null;
 }, options?: {

package/types/excalidraw/element/textElement.d.ts

@@ -49,7 +49,7 @@ export declare const getContainerCoords: (container: NonDeletedExcalidrawElement
     x: number;
     y: number;
 };
-export declare const getTextElementAngle: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null) => number;
+export declare const getTextElementAngle: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null) => import("../../math").Radians;
 export declare const getBoundTextElementPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
     x: number;
     y: number;

package/types/excalidraw/element/transformHandles.d.ts

@@ -1,6 +1,7 @@
 import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
 import type { Bounds } from "./bounds";
 import type { Device, InteractiveCanvasAppState, Zoom } from "../types";
+import type { Radians } from "../../math";
 export type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
 export type TransformHandleType = TransformHandleDirection | "rotation";
 export type TransformHandle = Bounds;
@@ -29,9 +30,9 @@ export declare const OMIT_SIDES_FOR_FRAME: {
 };
 export declare const canResizeFromSides: (device: Device) => boolean;
 export declare const getOmitSidesForDevice: (device: Device) => {};
-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;
+export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [number, number, number, number, number, number], angle: Radians, zoom: Zoom, pointerType: PointerType, omitSides?: {
     e?: boolean | undefined;
+    s?: boolean | undefined;
     w?: boolean | undefined;
     n?: boolean | undefined;
     nw?: boolean | undefined;
@@ -41,8 +42,8 @@ export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [
     rotation?: boolean | undefined;
 }, margin?: number) => TransformHandles;
 export declare const getTransformHandles: (element: ExcalidrawElement, zoom: Zoom, elementsMap: ElementsMap, pointerType?: PointerType, omitSides?: {
-    s?: boolean | undefined;
     e?: boolean | undefined;
+    s?: boolean | undefined;
     w?: boolean | undefined;
     n?: boolean | undefined;
     nw?: boolean | undefined;

package/types/excalidraw/element/typeChecks.d.ts

@@ -1,4 +1,3 @@
-import type { LineSegment } from "../../utils";
 import type { ElementOrToolType } from "../types";
 import type { MarkNonNullable } from "../utility-types";
 import type { Bounds } from "./bounds";
@@ -37,6 +36,4 @@ export declare const getDefaultRoundnessTypeForElement: (element: ExcalidrawElem
     type: 3;
 } | null;
 export declare const isFixedPointBinding: (binding: PointBinding) => binding is FixedPointBinding;
-export declare const isPoint: (point: unknown) => point is readonly [number, number];
 export declare const isBounds: (box: unknown) => box is Bounds;
-export declare const isLineSegment: (segment: unknown) => segment is LineSegment;

package/types/excalidraw/element/types.d.ts

@@ -1,4 +1,4 @@
-import type { Point } from "../types";
+import type { LocalPoint, Radians } from "../../math";
 import type { FONT_FAMILY, ROUNDNESS, TEXT_ALIGN, THEME, VERTICAL_ALIGN } from "../constants";
 import type { MakeBrand, MarkNonNullable, Merge, ValueOf } from "../utility-types";
 export type ChartType = "bar" | "line";
@@ -41,7 +41,7 @@ type _ExcalidrawElementBase = Readonly<{
     opacity: number;
     width: number;
     height: number;
-    angle: number;
+    angle: Radians;
     /** Random integer used to seed shape generation so that the roughjs shape
         doesn't differ across renders. */
     seed: number;
@@ -143,6 +143,7 @@ export type ExcalidrawFrameLikeElement = ExcalidrawFrameElement | ExcalidrawMagi
  */
 export type ExcalidrawGenericElement = ExcalidrawSelectionElement | ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement;
 export type ExcalidrawFlowchartNodeElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement;
+export type ExcalidrawRectanguloidElement = ExcalidrawRectangleElement | ExcalidrawImageElement | ExcalidrawTextElement | ExcalidrawFreeDrawElement | ExcalidrawIframeLikeElement | ExcalidrawFrameLikeElement | ExcalidrawEmbeddableElement;
 /**
  * ExcalidrawElement should be JSON serializable and (eventually) contain
  * no computed data. The list of all ExcalidrawElements should be shareable
@@ -201,8 +202,8 @@ export type FixedPointBinding = Merge<PointBinding, {
 export type Arrowhead = "arrow" | "bar" | "dot" | "circle" | "circle_outline" | "triangle" | "triangle_outline" | "diamond" | "diamond_outline";
 export type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<{
     type: "line" | "arrow";
-    points: readonly Point[];
-    lastCommittedPoint: Point | null;
+    points: readonly LocalPoint[];
+    lastCommittedPoint: LocalPoint | null;
     startBinding: PointBinding | null;
     endBinding: PointBinding | null;
     startArrowhead: Arrowhead | null;
@@ -219,10 +220,10 @@ export type ExcalidrawElbowArrowElement = Merge<ExcalidrawArrowElement, {
 }>;
 export type ExcalidrawFreeDrawElement = _ExcalidrawElementBase & Readonly<{
     type: "freedraw";
-    points: readonly Point[];
+    points: readonly LocalPoint[];
     pressures: readonly number[];
     simulatePressure: boolean;
-    lastCommittedPoint: Point | null;
+    lastCommittedPoint: LocalPoint | null;
 }>;
 export type FileId = string & {
     _brand: "FileId";

package/types/excalidraw/obsidianUtils.d.ts

@@ -15,3 +15,4 @@ export declare function registerLocalFont(fontMetrics: FontMetadata & {
 export declare function getFontFamilies(): string[];
 export declare function registerFontsInCSS(): Promise<void>;
 export declare function getCSSFontDefinition(fontFamily: number): Promise<string>;
+export declare function getArrayBufferFromBase64(url: string): ArrayBuffer;

package/types/excalidraw/points.d.ts

@@ -1,7 +1,7 @@
-import type { Point } from "./types";
-export declare const getSizeFromPoints: (points: readonly Point[]) => {
+import { type GlobalPoint, type LocalPoint } from "../math";
+export declare const getSizeFromPoints: (points: readonly (GlobalPoint | LocalPoint)[]) => {
     width: number;
     height: number;
 };
 /** @arg dimension, 0 for rescaling only x, 1 for y */
-export declare const rescalePoints: (dimension: 0 | 1, newSize: number, points: readonly Point[], normalize: boolean) => Point[];
+export declare const rescalePoints: <Point extends GlobalPoint | LocalPoint>(dimension: 0 | 1, newSize: number, points: readonly Point[], normalize: boolean) => Point[];

package/types/excalidraw/shapes.d.ts

@@ -1,5 +1,8 @@
+import { type GlobalPoint, type LocalPoint } from "../math";
 import { type GeometricShape } from "../utils/geometry/shape";
-import type { ElementsMap, ExcalidrawElement } from "./element/types";
+import type { Bounds } from "./element/bounds";
+import type { ElementsMap, ExcalidrawElement, ExcalidrawLinearElement, NonDeleted } from "./element/types";
+import type { Zoom } from "./types";
 export declare const SHAPES: readonly [{
     readonly icon: JSX.Element;
     readonly value: "selection";
@@ -61,10 +64,22 @@ export declare const SHAPES: readonly [{
     readonly numericKey: "0";
     readonly fillable: false;
 }];
-export declare const findShapeByKey: (key: string) => "text" | "image" | "selection" | "rectangle" | "diamond" | "ellipse" | "arrow" | "line" | "freedraw" | "eraser" | null;
+export declare const findShapeByKey: (key: string) => "line" | "text" | "arrow" | "diamond" | "selection" | "rectangle" | "ellipse" | "freedraw" | "image" | "eraser" | null;
 /**
  * get the pure geometric shape of an excalidraw element
  * which is then used for hit detection
  */
-export declare const getElementShape: (element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape;
-export declare const getBoundTextShape: (element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape | null;
+export declare const getElementShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape<Point>;
+export declare const getBoundTextShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape<Point> | null;
+export declare const getControlPointsForBezierCurve: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P) => P[] | null;
+export declare const getBezierXY: <P extends GlobalPoint | LocalPoint>(p0: P, p1: P, p2: P, p3: P, t: number) => P;
+export declare const getBezierCurveLength: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P) => number;
+export declare const mapIntervalToBezierT: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P, interval: number) => number;
+/**
+ * Get the axis-aligned bounding box for a given element
+ */
+export declare const aabbForElement: (element: Readonly<ExcalidrawElement>, offset?: [number, number, number, number]) => Bounds;
+export declare const pointInsideBounds: <P extends GlobalPoint | LocalPoint>(p: P, bounds: Bounds) => boolean;
+export declare const aabbsOverlapping: (a: Bounds, b: Bounds) => boolean;
+export declare const getCornerRadius: (x: number, element: ExcalidrawElement) => number;
+export declare const isPathALoop: (points: ExcalidrawLinearElement["points"], zoomValue?: Zoom["value"]) => boolean;

package/types/excalidraw/snapping.d.ts

@@ -1,13 +1,15 @@
+import type { InclusiveRange } from "../math";
+import { type GlobalPoint } from "../math";
 import type { Bounds } from "./element/bounds";
 import type { MaybeTransformHandleType } from "./element/transformHandles";
 import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
-import type { AppClassProperties, AppState, KeyboardModifiersObject, Point } from "./types";
+import type { AppClassProperties, AppState, KeyboardModifiersObject, NullableGridSize } from "./types";
 export declare const getSnapDistance: (zoomValue: number) => number;
 type Vector2D = {
     x: number;
     y: number;
 };
-type PointPair = [Point, Point];
+type PointPair = [GlobalPoint, GlobalPoint];
 export type PointSnap = {
     type: "point";
     points: PointPair;
@@ -16,9 +18,9 @@ export type PointSnap = {
 export type Gap = {
     startBounds: Bounds;
     endBounds: Bounds;
-    startSide: [Point, Point];
-    endSide: [Point, Point];
-    overlap: [number, number];
+    startSide: [GlobalPoint, GlobalPoint];
+    endSide: [GlobalPoint, GlobalPoint];
+    overlap: InclusiveRange;
     length: number;
 };
 export type GapSnap = {
@@ -32,7 +34,7 @@ export type Snap = GapSnap | PointSnap;
 export type Snaps = Snap[];
 export type PointSnapLine = {
     type: "points";
-    points: Point[];
+    points: GlobalPoint[];
 };
 export type PointerSnapLine = {
     type: "pointer";
@@ -48,8 +50,8 @@ export type SnapLine = PointSnapLine | GapSnapLine | PointerSnapLine;
 export declare class SnapCache {
     private static referenceSnapPoints;
     private static visibleGaps;
-    static setReferenceSnapPoints: (snapPoints: Point[] | null) => void;
-    static getReferenceSnapPoints: () => (readonly [number, number])[] | null;
+    static setReferenceSnapPoints: (snapPoints: GlobalPoint[] | null) => void;
+    static getReferenceSnapPoints: () => GlobalPoint[] | null;
     static setVisibleGaps: (gaps: {
         verticalGaps: Gap[];
         horizontalGaps: Gap[];
@@ -71,12 +73,12 @@ export declare const getElementsCorners: (elements: ExcalidrawElement[], element
     omitCenter?: boolean | undefined;
     boundingBoxCorners?: boolean | undefined;
     dragOffset?: Vector2D | undefined;
-}) => Point[];
+}) => GlobalPoint[];
 export declare const getVisibleGaps: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => {
     horizontalGaps: Gap[];
     verticalGaps: Gap[];
 };
-export declare const getReferenceSnapPoints: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => (readonly [number, number])[];
+export declare const getReferenceSnapPoints: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => GlobalPoint[];
 export declare const snapDraggedElements: (elements: ExcalidrawElement[], dragOffset: Vector2D, app: AppClassProperties, event: KeyboardModifiersObject, elementsMap: ElementsMap) => {
     snapOffset: {
         x: number;
@@ -106,4 +108,5 @@ export declare const getSnapLinesAtPointer: (elements: readonly ExcalidrawElemen
     snapLines: PointerSnapLine[];
 };
 export declare const isActiveToolNonLinearSnappable: (activeToolType: AppState["activeTool"]["type"]) => boolean;
+export declare const getGridPoint: (x: number, y: number, gridSize: NullableGridSize) => [number, number];
 export {};

package/types/excalidraw/types.d.ts

@@ -1,7 +1,6 @@
 import type React from "react";
 import type { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, ChartType, FontFamilyValues, ExcalidrawTextElement, FileId, ExcalidrawImageElement, Theme, StrokeRoundness, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeLikeElement, OrderedExcalidrawElement, ExcalidrawNonSelectionElement } from "./element/types";
 import type { Action } from "./actions/types";
-import type { Point as RoughPoint } from "roughjs/bin/geometry";
 import type { LinearElementEditor } from "./element/linearElementEditor";
 import type { SuggestedBinding } from "./element/binding";
 import type { ImportedDataState } from "./data/types";
@@ -20,7 +19,6 @@ import type { SnapLine } from "./snapping";
 import type { Merge, MaybePromise, ValueOf, MakeBrand } from "./utility-types";
 import type { ColorPaletteCustom } from "./colors";
 import type { StoreActionType } from "./store";
-export type Point = Readonly<RoughPoint>;
 export type SocketId = string & {
     _brand: "SocketId";
 };

package/types/excalidraw/utils.d.ts

@@ -6,9 +6,9 @@ export declare const setDateTimeForTests: (dateTime: string) => void;
 export declare const getDateTime: () => string;
 export declare const capitalizeString: (str: string) => string;
 export declare const isToolIcon: (target: Element | EventTarget | null) => target is HTMLElement;
-export declare const isInputLike: (target: Element | EventTarget | null) => target is HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | HTMLBRElement | HTMLDivElement;
+export declare const isInputLike: (target: Element | EventTarget | null) => target is HTMLBRElement | HTMLDivElement | HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
 export declare const isInteractive: (target: Element | EventTarget | null) => boolean;
-export declare const isWritableElement: (target: Element | EventTarget | null) => target is HTMLInputElement | HTMLTextAreaElement | HTMLBRElement | HTMLDivElement;
+export declare const isWritableElement: (target: Element | EventTarget | null) => target is HTMLBRElement | HTMLDivElement | HTMLInputElement | HTMLTextAreaElement;
 export declare const getFontFamilyString: ({ fontFamily, }: {
     fontFamily: FontFamilyValues;
 }) => string;
@@ -182,7 +182,7 @@ export declare const wrapEvent: <T extends Event>(name: EVENT, nativeEvent: T) =
 }>;
 export declare const updateObject: <T extends Record<string, any>>(obj: T, updates: Partial<T>) => T;
 export declare const isPrimitive: (val: any) => boolean;
-export declare const getFrame: () => "top" | "iframe";
+export declare const getFrame: () => "iframe" | "top";
 export declare const isRunningInIframe: () => boolean;
 export declare const isPromiseLike: (value: any) => value is Promise<any>;
 export declare const queryFocusableElements: (container: HTMLElement | null) => HTMLElement[];
@@ -213,7 +213,6 @@ export declare const memoize: <T extends Record<string, any>, R extends unknown>
 /** Checks if value is inside given collection. Useful for type-safety. */
 export declare const isMemberOf: <T extends string>(collection: Set<T> | Record<T, any> | Map<T, any> | readonly T[], value: string) => value is T;
 export declare const cloneJSON: <T>(obj: T) => T;
-export declare const isFiniteNumber: (value: any) => value is number;
 export declare const updateStable: <T extends any[] | Record<string, any>>(prevValue: T, nextValue: T) => T;
 export declare function addEventListener<K extends keyof WindowEventMap>(target: Window & typeof globalThis, type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): UnsubscribeCallback;
 export declare function addEventListener(target: Window & typeof globalThis, type: string, listener: (this: Window, ev: Event) => any, options?: boolean | AddEventListenerOptions): UnsubscribeCallback;