@zsviczian/excalidraw 0.18.0-3 → 0.18.0-5

package/types/{excalidraw/element → element/src}/heading.d.ts

@@ -1,16 +1,15 @@
-import type { LocalPoint, GlobalPoint, Vector } from "@excalidraw/math";
-import type { ExcalidrawBindableElement } from "./types";
-export declare const HEADING_RIGHT: Heading;
-export declare const HEADING_DOWN: Heading;
-export declare const HEADING_LEFT: Heading;
-export declare const HEADING_UP: Heading;
-export type Heading = [1, 0] | [0, 1] | [-1, 0] | [0, -1];
-export declare const headingForDiamond: <Point extends GlobalPoint | LocalPoint>(a: Point, b: Point) => Heading;
-export declare const vectorToHeading: (vec: Vector) => Heading;
-export declare const headingForPoint: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => Heading;
-export declare const headingForPointIsHorizontal: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => boolean;
-export declare const compareHeading: (a: Heading, b: Heading) => boolean;
-export declare const headingIsHorizontal: (a: Heading) => boolean;
-export declare const headingIsVertical: (a: Heading) => boolean;
-export declare const headingForPointFromElement: <Point extends GlobalPoint | LocalPoint>(element: Readonly<ExcalidrawBindableElement>, aabb: readonly [minX: number, minY: number, maxX: number, maxY: number], p: Readonly<Point>) => Heading;
-export declare const flipHeading: (h: Heading) => Heading;
+import type { LocalPoint, GlobalPoint, Vector } from "@excalidraw/math";
+import type { ExcalidrawBindableElement } from "./types";
+export declare const HEADING_RIGHT: Heading;
+export declare const HEADING_DOWN: Heading;
+export declare const HEADING_LEFT: Heading;
+export declare const HEADING_UP: Heading;
+export type Heading = [1, 0] | [0, 1] | [-1, 0] | [0, -1];
+export declare const vectorToHeading: (vec: Vector) => Heading;
+export declare const headingForPoint: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => Heading;
+export declare const headingForPointIsHorizontal: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => boolean;
+export declare const compareHeading: (a: Heading, b: Heading) => boolean;
+export declare const headingIsHorizontal: (a: Heading) => boolean;
+export declare const headingIsVertical: (a: Heading) => boolean;
+export declare const headingForPointFromElement: <Point extends GlobalPoint>(element: Readonly<ExcalidrawBindableElement>, aabb: readonly [minX: number, minY: number, maxX: number, maxY: number], p: Readonly<Point>) => Heading;
+export declare const flipHeading: (h: Heading) => Heading;

package/types/{excalidraw/element → element/src}/image.d.ts

@@ -1,32 +1,32 @@
-import type { AppClassProperties, DataURL, BinaryFiles } from "../types";
-import type { ExcalidrawElement, FileId, InitializedExcalidrawImageElement } from "./types";
-export declare const loadHTMLImageElement: (dataURL: DataURL) => Promise<HTMLImageElement>;
-/** NOTE: updates cache even if already populated with given image. Thus,
- * you should filter out the images upstream if you want to optimize this. */
-export declare const updateImageCache: ({ fileIds, files, imageCache, }: {
-    fileIds: FileId[];
-    files: BinaryFiles;
-    imageCache: AppClassProperties["imageCache"];
-}) => Promise<{
-    imageCache: Map<FileId, {
-        image: HTMLImageElement | Promise<HTMLImageElement>;
-        mimeType: import("../utility-types").ValueOf<{
-            readonly svg: "image/svg+xml";
-            readonly png: "image/png";
-            readonly jpg: "image/jpeg";
-            readonly gif: "image/gif";
-            readonly webp: "image/webp";
-            readonly bmp: "image/bmp";
-            readonly ico: "image/x-icon";
-            readonly avif: "image/avif";
-            readonly jfif: "image/jfif";
-        }>;
-    }>;
-    /** includes errored files because they cache was updated nonetheless */
-    updatedFiles: Map<FileId, true>;
-    /** files that failed when creating HTMLImageElement */
-    erroredFiles: Map<FileId, true>;
-}>;
-export declare const getInitializedImageElements: (elements: readonly ExcalidrawElement[]) => InitializedExcalidrawImageElement[];
-export declare const isHTMLSVGElement: (node: Node | null) => node is SVGElement;
-export declare const normalizeSVG: (SVGString: string) => string;
+import type { AppClassProperties, DataURL, BinaryFiles } from "@excalidraw/excalidraw/types";
+import type { ExcalidrawElement, FileId, InitializedExcalidrawImageElement } from "./types";
+export declare const loadHTMLImageElement: (dataURL: DataURL) => Promise<HTMLImageElement>;
+/** NOTE: updates cache even if already populated with given image. Thus,
+ * you should filter out the images upstream if you want to optimize this. */
+export declare const updateImageCache: ({ fileIds, files, imageCache, }: {
+    fileIds: FileId[];
+    files: BinaryFiles;
+    imageCache: AppClassProperties["imageCache"];
+}) => Promise<{
+    imageCache: Map<FileId, {
+        image: HTMLImageElement | Promise<HTMLImageElement>;
+        mimeType: import("../../common/src/utility-types").ValueOf<{
+            readonly svg: "image/svg+xml";
+            readonly png: "image/png";
+            readonly jpg: "image/jpeg";
+            readonly gif: "image/gif";
+            readonly webp: "image/webp";
+            readonly bmp: "image/bmp";
+            readonly ico: "image/x-icon";
+            readonly avif: "image/avif";
+            readonly jfif: "image/jfif";
+        }>;
+    }>;
+    /** includes errored files because they cache was updated nonetheless */
+    updatedFiles: Map<FileId, true>;
+    /** files that failed when creating HTMLImageElement */
+    erroredFiles: Map<FileId, true>;
+}>;
+export declare const getInitializedImageElements: (elements: readonly ExcalidrawElement[]) => InitializedExcalidrawImageElement[];
+export declare const isHTMLSVGElement: (node: Node | null) => node is SVGElement;
+export declare const normalizeSVG: (SVGString: string) => string;

package/types/{excalidraw/element → element/src}/index.d.ts

@@ -1,26 +1,16 @@
-import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted } from "./types";
-export { newElement, newTextElement, refreshTextDimensions, newLinearElement, newArrowElement, newImageElement, duplicateElement, } from "./newElement";
-export { getElementAbsoluteCoords, getElementBounds, getCommonBounds, getDiamondPoints, getArrowheadPoints, getClosestElementBounds, } from "./bounds";
-export { OMIT_SIDES_FOR_MULTIPLE_ELEMENTS, getTransformHandlesFromCoords, getTransformHandles, } from "./transformHandles";
-export { resizeTest, getCursorForResizingElement, getElementWithTransformHandleType, getTransformHandleTypeFromCoords, } from "./resizeTest";
-export { transformElements, getResizeOffsetXY, getResizeArrowDirection, } from "./resizeElements";
-export { dragSelectedElements, getDragOffsetXY, dragNewElement, } from "./dragElements";
-export { isTextElement, isExcalidrawElement } from "./typeChecks";
-export { redrawTextBoundingBox, getTextFromElements } from "./textElement";
-export { getPerfectElementSize, getLockedLinearCursorAlignSize, isInvisiblySmallElement, resizePerfectLineForNWHandler, getNormalizedDimensions, } from "./sizeHelpers";
-export { showSelectedShapeActions } from "./showSelectedShapeActions";
-/**
- * @deprecated unsafe, use hashElementsVersion instead
- */
-export declare const getSceneVersion: (elements: readonly ExcalidrawElement[]) => number;
-/**
- * Hashes elements' versionNonce (using djb2 algo). Order of elements matters.
- */
-export declare const hashElementsVersion: (elements: readonly ExcalidrawElement[]) => number;
-export declare const hashString: (s: string) => number;
-export declare const getVisibleElements: (elements: readonly ExcalidrawElement[]) => readonly NonDeletedExcalidrawElement[];
-export declare const getNonDeletedElements: <T extends ExcalidrawElement>(elements: readonly T[]) => readonly NonDeleted<T>[];
-export declare const isNonDeletedElement: <T extends ExcalidrawElement>(element: T) => element is NonDeleted<T>;
-export declare const clearElementsForDatabase: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
-export declare const clearElementsForExport: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
-export declare const clearElementsForLocalStorage: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted } from "./types";
+/**
+ * @deprecated unsafe, use hashElementsVersion instead
+ */
+export declare const getSceneVersion: (elements: readonly ExcalidrawElement[]) => number;
+/**
+ * Hashes elements' versionNonce (using djb2 algo). Order of elements matters.
+ */
+export declare const hashElementsVersion: (elements: readonly ExcalidrawElement[]) => number;
+export declare const hashString: (s: string) => number;
+export declare const getVisibleElements: (elements: readonly ExcalidrawElement[]) => readonly NonDeletedExcalidrawElement[];
+export declare const getNonDeletedElements: <T extends ExcalidrawElement>(elements: readonly T[]) => readonly NonDeleted<T>[];
+export declare const isNonDeletedElement: <T extends ExcalidrawElement>(element: T) => element is NonDeleted<T>;
+export declare const clearElementsForDatabase: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+export declare const clearElementsForExport: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+export declare const clearElementsForLocalStorage: (elements: readonly ExcalidrawElement[]) => ExcalidrawElement[];

package/types/{excalidraw/element → element/src}/linearElementEditor.d.ts

@@ -1,129 +1,129 @@
-import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
-import type { Bounds } from "./bounds";
-import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, SceneElementsMap, ExcalidrawElbowArrowElement } from "./types";
-import type Scene from "../scene/Scene";
-import type { Store } from "../store";
-import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize, Zoom } from "../types";
-declare const editorMidPointsCache: {
-    version: number | null;
-    points: (GlobalPoint | null)[];
-    zoom: number | null;
-};
-export declare class LinearElementEditor {
-    readonly elementId: ExcalidrawElement["id"] & {
-        _brand: "excalidrawLinearElementId";
-    };
-    /** indices */
-    readonly selectedPointsIndices: readonly number[] | null;
-    readonly pointerDownState: Readonly<{
-        prevSelectedPointsIndices: readonly number[] | null;
-        /** index */
-        lastClickedPoint: number;
-        lastClickedIsEndPoint: boolean;
-        origin: Readonly<{
-            x: number;
-            y: number;
-        }> | null;
-        segmentMidpoint: {
-            value: GlobalPoint | null;
-            index: number | null;
-            added: boolean;
-        };
-    }>;
-    /** whether you're dragging a point */
-    readonly isDragging: boolean;
-    readonly lastUncommittedPoint: LocalPoint | null;
-    readonly pointerOffset: Readonly<{
-        x: number;
-        y: number;
-    }>;
-    readonly startBindingElement: ExcalidrawBindableElement | null | "keep";
-    readonly endBindingElement: ExcalidrawBindableElement | null | "keep";
-    readonly hoverPointIndex: number;
-    readonly segmentMidPointHoveredCoords: GlobalPoint | null;
-    readonly elbowed: boolean;
-    constructor(element: NonDeleted<ExcalidrawLinearElement>);
-    static POINT_HANDLE_SIZE: number;
-    /**
-     * @param id the `elementId` from the instance of this class (so that we can
-     *  statically guarantee this method returns an ExcalidrawLinearElement)
-     */
-    static getElement<T extends ExcalidrawLinearElement>(id: InstanceType<typeof LinearElementEditor>["elementId"], elementsMap: ElementsMap): T | null;
-    static handleBoxSelection(event: PointerEvent, appState: AppState, setState: React.Component<any, AppState>["setState"], elementsMap: NonDeletedSceneElementsMap): false | undefined;
-    /**
-     * @returns whether point was dragged
-     */
-    static handlePointDragging(event: PointerEvent, app: AppClassProperties, scenePointerX: number, scenePointerY: number, maybeSuggestBinding: (element: NonDeleted<ExcalidrawLinearElement>, pointSceneCoords: {
-        x: number;
-        y: number;
-    }[]) => void, linearElementEditor: LinearElementEditor, scene: Scene): boolean;
-    static handlePointerUp(event: PointerEvent, editingLinearElement: LinearElementEditor, appState: AppState, scene: Scene): LinearElementEditor;
-    static getEditorMidPoints: (element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => (typeof editorMidPointsCache)["points"];
-    static updateEditorMidPointsCache: (element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => void;
-    static getSegmentMidpointHitCoords: (linearElementEditor: LinearElementEditor, scenePointer: {
-        x: number;
-        y: number;
-    }, appState: AppState, elementsMap: ElementsMap) => GlobalPoint | null;
-    static isSegmentTooShort<P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, startPoint: P, endPoint: P, index: number, zoom: 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;
-    }, linearElementEditor: LinearElementEditor, scene: Scene): {
-        didAddPoint: boolean;
-        hitElement: NonDeleted<ExcalidrawElement> | null;
-        linearElementEditor: LinearElementEditor | null;
-    };
-    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>, p: LocalPoint, elementsMap: ElementsMap): GlobalPoint;
-    /** scene coords */
-    static getPointsGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap): GlobalPoint[];
-    static getPointAtIndexGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, indexMaybeFromEnd: number, // -1 for last element
-    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): 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: LocalPoint[];
-        x: number;
-        y: number;
-    };
-    static normalizePoints(element: NonDeleted<ExcalidrawLinearElement>): void;
-    static duplicateSelectedPoints(appState: AppState, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): AppState;
-    static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[]): void;
-    static addPoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
-        point: LocalPoint;
-    }[]): void;
-    static movePoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
-        index: number;
-        point: LocalPoint;
-        isDragging?: boolean;
-    }[], otherUpdates?: {
-        startBinding?: PointBinding | null;
-        endBinding?: PointBinding | null;
-    }): void;
-    static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState, elementsMap: ElementsMap): boolean;
-    static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, elementsMap: ElementsMap): {
-        pointerDownState: LinearElementEditor["pointerDownState"];
-        selectedPointsIndices: LinearElementEditor["selectedPointsIndices"];
-    } | undefined;
-    private static _updatePoints;
-    private static _getShiftLockedDelta;
-    static getBoundTextElementPosition: (element: ExcalidrawLinearElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
-        x: number;
-        y: number;
-    };
-    static getMinMaxXYWithBoundText: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, elementBounds: Bounds, boundTextElement: ExcalidrawTextElementWithContainer) => [number, number, number, number, number, number];
-    static getElementAbsoluteCoords: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, includeBoundText?: boolean) => [number, number, number, number, number, number];
-    static moveFixedSegment(linearElement: LinearElementEditor, index: number, x: number, y: number, elementsMap: ElementsMap): LinearElementEditor;
-    static deleteFixedSegment(element: ExcalidrawElbowArrowElement, index: number): void;
-}
-export {};
+import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
+import Scene from "@excalidraw/excalidraw/scene/Scene";
+import type { Store } from "@excalidraw/excalidraw/store";
+import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize, Zoom } from "@excalidraw/excalidraw/types";
+import type { Bounds } from "./bounds";
+import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, SceneElementsMap, ExcalidrawElbowArrowElement } from "./types";
+declare const editorMidPointsCache: {
+    version: number | null;
+    points: (GlobalPoint | null)[];
+    zoom: number | null;
+};
+export declare class LinearElementEditor {
+    readonly elementId: ExcalidrawElement["id"] & {
+        _brand: "excalidrawLinearElementId";
+    };
+    /** indices */
+    readonly selectedPointsIndices: readonly number[] | null;
+    readonly pointerDownState: Readonly<{
+        prevSelectedPointsIndices: readonly number[] | null;
+        /** index */
+        lastClickedPoint: number;
+        lastClickedIsEndPoint: boolean;
+        origin: Readonly<{
+            x: number;
+            y: number;
+        }> | null;
+        segmentMidpoint: {
+            value: GlobalPoint | null;
+            index: number | null;
+            added: boolean;
+        };
+    }>;
+    /** whether you're dragging a point */
+    readonly isDragging: boolean;
+    readonly lastUncommittedPoint: LocalPoint | null;
+    readonly pointerOffset: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    readonly startBindingElement: ExcalidrawBindableElement | null | "keep";
+    readonly endBindingElement: ExcalidrawBindableElement | null | "keep";
+    readonly hoverPointIndex: number;
+    readonly segmentMidPointHoveredCoords: GlobalPoint | null;
+    readonly elbowed: boolean;
+    constructor(element: NonDeleted<ExcalidrawLinearElement>);
+    static POINT_HANDLE_SIZE: number;
+    /**
+     * @param id the `elementId` from the instance of this class (so that we can
+     *  statically guarantee this method returns an ExcalidrawLinearElement)
+     */
+    static getElement<T extends ExcalidrawLinearElement>(id: InstanceType<typeof LinearElementEditor>["elementId"], elementsMap: ElementsMap): T | null;
+    static handleBoxSelection(event: PointerEvent, appState: AppState, setState: React.Component<any, AppState>["setState"], elementsMap: NonDeletedSceneElementsMap): false | undefined;
+    /**
+     * @returns whether point was dragged
+     */
+    static handlePointDragging(event: PointerEvent, app: AppClassProperties, scenePointerX: number, scenePointerY: number, maybeSuggestBinding: (element: NonDeleted<ExcalidrawLinearElement>, pointSceneCoords: {
+        x: number;
+        y: number;
+    }[]) => void, linearElementEditor: LinearElementEditor, scene: Scene): LinearElementEditor | null;
+    static handlePointerUp(event: PointerEvent, editingLinearElement: LinearElementEditor, appState: AppState, scene: Scene): LinearElementEditor;
+    static getEditorMidPoints: (element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => (typeof editorMidPointsCache)["points"];
+    static updateEditorMidPointsCache: (element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => void;
+    static getSegmentMidpointHitCoords: (linearElementEditor: LinearElementEditor, scenePointer: {
+        x: number;
+        y: number;
+    }, appState: AppState, elementsMap: ElementsMap) => GlobalPoint | null;
+    static isSegmentTooShort<P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, startPoint: P, endPoint: P, index: number, zoom: 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;
+    }, linearElementEditor: LinearElementEditor, scene: Scene): {
+        didAddPoint: boolean;
+        hitElement: NonDeleted<ExcalidrawElement> | null;
+        linearElementEditor: LinearElementEditor | null;
+    };
+    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>, p: LocalPoint, elementsMap: ElementsMap): GlobalPoint;
+    /** scene coords */
+    static getPointsGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, elementsMap: ElementsMap): GlobalPoint[];
+    static getPointAtIndexGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, indexMaybeFromEnd: number, // -1 for last element
+    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): 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: LocalPoint[];
+        x: number;
+        y: number;
+    };
+    static normalizePoints(element: NonDeleted<ExcalidrawLinearElement>): void;
+    static duplicateSelectedPoints(appState: AppState, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): AppState;
+    static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[]): void;
+    static addPoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
+        point: LocalPoint;
+    }[]): void;
+    static movePoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
+        index: number;
+        point: LocalPoint;
+        isDragging?: boolean;
+    }[], otherUpdates?: {
+        startBinding?: PointBinding | null;
+        endBinding?: PointBinding | null;
+    }, sceneElementsMap?: NonDeletedSceneElementsMap): void;
+    static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState, elementsMap: ElementsMap): boolean;
+    static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, elementsMap: ElementsMap): {
+        pointerDownState: LinearElementEditor["pointerDownState"];
+        selectedPointsIndices: LinearElementEditor["selectedPointsIndices"];
+    } | undefined;
+    private static _updatePoints;
+    private static _getShiftLockedDelta;
+    static getBoundTextElementPosition: (element: ExcalidrawLinearElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
+        x: number;
+        y: number;
+    };
+    static getMinMaxXYWithBoundText: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, elementBounds: Bounds, boundTextElement: ExcalidrawTextElementWithContainer) => [number, number, number, number, number, number];
+    static getElementAbsoluteCoords: (element: ExcalidrawLinearElement, elementsMap: ElementsMap, includeBoundText?: boolean) => [number, number, number, number, number, number];
+    static moveFixedSegment(linearElement: LinearElementEditor, index: number, x: number, y: number, elementsMap: ElementsMap): LinearElementEditor;
+    static deleteFixedSegment(element: ExcalidrawElbowArrowElement, index: number): void;
+}
+export {};

package/types/{excalidraw/element → element/src}/mutateElement.d.ts

@@ -1,13 +1,13 @@
-import type { ExcalidrawElement } from "./types";
-import type { Mutable } from "../utility-types";
-export type ElementUpdate<TElement extends ExcalidrawElement> = Omit<Partial<TElement>, "id" | "version" | "versionNonce" | "updated">;
-export declare const mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, informMutation?: boolean, options?: {
-    isDragging?: boolean;
-}) => TElement;
-export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, force?: boolean) => TElement;
-/**
- * Mutates element, bumping `version`, `versionNonce`, and `updated`.
- *
- * NOTE: does not trigger re-render.
- */
-export declare const bumpVersion: <T extends Mutable<ExcalidrawElement>>(element: T, version?: ExcalidrawElement["version"]) => T;
+import type { Mutable } from "@excalidraw/common/utility-types";
+import type { ExcalidrawElement } from "./types";
+export type ElementUpdate<TElement extends ExcalidrawElement> = Omit<Partial<TElement>, "id" | "version" | "versionNonce" | "updated">;
+export declare const mutateElement: <TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, informMutation?: boolean, options?: {
+    isDragging?: boolean;
+}) => TElement;
+export declare const newElementWith: <TElement extends ExcalidrawElement>(element: TElement, updates: ElementUpdate<TElement>, force?: boolean) => TElement;
+/**
+ * Mutates element, bumping `version`, `versionNonce`, and `updated`.
+ *
+ * NOTE: does not trigger re-render.
+ */
+export declare const bumpVersion: <T extends Mutable<ExcalidrawElement>>(element: T, version?: ExcalidrawElement["version"]) => T;

package/types/{excalidraw/element → element/src}/newElement.d.ts

@@ -1,102 +1,62 @@
-import type { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap, ExcalidrawArrowElement, FixedSegment, ExcalidrawElbowArrowElement } from "./types";
-import type { AppState } from "../types";
-import type { MarkOptional, Mutable } from "../utility-types";
-export type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "frameId" | "index" | "boundElements" | "seed" | "version" | "versionNonce" | "link" | "strokeStyle" | "fillStyle" | "strokeColor" | "backgroundColor" | "roughness" | "strokeWidth" | "roundness" | "locked" | "opacity" | "customData">;
-export declare const newElement: (opts: {
-    type: ExcalidrawGenericElement["type"];
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawGenericElement>;
-export declare const newEmbeddableElement: (opts: {
-    type: "embeddable";
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawEmbeddableElement>;
-export declare const newIframeElement: (opts: {
-    type: "iframe";
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawIframeElement>;
-export declare const newFrameElement: (opts: {
-    name?: string;
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawFrameElement>;
-export declare const newMagicFrameElement: (opts: {
-    name?: string;
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawMagicFrameElement>;
-export declare const newTextElement: (opts: {
-    text: string;
-    rawText: string;
-    originalText?: string;
-    fontSize?: number;
-    fontFamily?: FontFamilyValues;
-    textAlign?: TextAlign;
-    verticalAlign?: VerticalAlign;
-    containerId?: ExcalidrawTextContainer["id"] | null;
-    lineHeight?: ExcalidrawTextElement["lineHeight"];
-    autoResize?: ExcalidrawTextElement["autoResize"];
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
-export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null, elementsMap: ElementsMap, text?: string) => {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    text: string;
-} | undefined;
-export declare const newFreeDrawElement: (opts: {
-    type: "freedraw";
-    points?: ExcalidrawFreeDrawElement["points"];
-    simulatePressure: boolean;
-    pressures?: ExcalidrawFreeDrawElement["pressures"];
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawFreeDrawElement>;
-export declare const newLinearElement: (opts: {
-    type: ExcalidrawLinearElement["type"];
-    points?: ExcalidrawLinearElement["points"];
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawLinearElement>;
-export declare const newArrowElement: <T extends boolean>(opts: {
-    type: ExcalidrawArrowElement["type"];
-    startArrowhead?: Arrowhead | null | undefined;
-    endArrowhead?: Arrowhead | null | undefined;
-    points?: readonly import("@excalidraw/math").LocalPoint[] | undefined;
-    elbowed?: T | undefined;
-    fixedSegments?: FixedSegment[] | null | undefined;
-} & Omit<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "link" | "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "angle" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData"> & Partial<Pick<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "link" | "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "angle" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData">>) => T extends true ? NonDeleted<ExcalidrawElbowArrowElement> : NonDeleted<ExcalidrawArrowElement>;
-export declare const newImageElement: (opts: {
-    type: ExcalidrawImageElement["type"];
-    status?: ExcalidrawImageElement["status"];
-    fileId?: ExcalidrawImageElement["fileId"];
-    scale?: ExcalidrawImageElement["scale"];
-    crop?: ExcalidrawImageElement["crop"];
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawImageElement>;
-/**
- * Clones ExcalidrawElement data structure. Does not regenerate id, nonce, or
- * any value. The purpose is to to break object references for immutability
- * reasons, whenever we want to keep the original element, but ensure it's not
- * mutated.
- *
- * Only clones plain objects and arrays. Doesn't clone Date, RegExp, Map, Set,
- * Typed arrays and other non-null objects.
- */
-export declare const deepCopyElement: <T extends ExcalidrawElement>(val: T) => Mutable<T>;
-/**
- * Duplicate an element, often used in the alt-drag operation.
- * Note that this method has gotten a bit complicated since the
- * introduction of gruoping/ungrouping elements.
- * @param editingGroupId The current group being edited. The new
- *                       element will inherit this group and its
- *                       parents.
- * @param groupIdMapForOperation A Map that maps old group IDs to
- *                               duplicated ones. If you are duplicating
- *                               multiple elements at once, share this map
- *                               amongst all of them
- * @param element Element to duplicate
- * @param overrides Any element properties to override
- */
-export declare const duplicateElement: <TElement extends ExcalidrawElement>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, overrides?: Partial<TElement> | undefined) => Readonly<TElement>;
-/**
- * Clones elements, regenerating their ids (including bindings) and group ids.
- *
- * If bindings don't exist in the elements array, they are removed. Therefore,
- * it's advised to supply the whole elements array, or sets of elements that
- * are encapsulated (such as library items), if the purpose is to retain
- * bindings to the cloned elements intact.
- *
- * NOTE by default does not randomize or regenerate anything except the id.
- */
-export declare const duplicateElements: (elements: readonly ExcalidrawElement[], opts?: {
-    /** NOTE also updates version flags and `updated` */
-    randomizeSeed: boolean;
-}) => ExcalidrawElement[];
+import type { MarkOptional } from "@excalidraw/common/utility-types";
+import type { ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap, ExcalidrawArrowElement, FixedSegment, ExcalidrawElbowArrowElement } from "./types";
+export type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "frameId" | "index" | "boundElements" | "seed" | "version" | "versionNonce" | "link" | "strokeStyle" | "fillStyle" | "strokeColor" | "backgroundColor" | "roughness" | "strokeWidth" | "roundness" | "locked" | "opacity" | "customData">;
+export declare const newElement: (opts: {
+    type: ExcalidrawGenericElement["type"];
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawGenericElement>;
+export declare const newEmbeddableElement: (opts: {
+    type: "embeddable";
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawEmbeddableElement>;
+export declare const newIframeElement: (opts: {
+    type: "iframe";
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawIframeElement>;
+export declare const newFrameElement: (opts: {
+    name?: string;
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawFrameElement>;
+export declare const newMagicFrameElement: (opts: {
+    name?: string;
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawMagicFrameElement>;
+export declare const newTextElement: (opts: {
+    text: string;
+    rawText: string;
+    originalText?: string;
+    fontSize?: number;
+    fontFamily?: FontFamilyValues;
+    textAlign?: TextAlign;
+    verticalAlign?: VerticalAlign;
+    containerId?: ExcalidrawTextContainer["id"] | null;
+    lineHeight?: ExcalidrawTextElement["lineHeight"];
+    autoResize?: ExcalidrawTextElement["autoResize"];
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
+export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null, elementsMap: ElementsMap, text?: string) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text: string;
+} | undefined;
+export declare const newFreeDrawElement: (opts: {
+    type: "freedraw";
+    points?: ExcalidrawFreeDrawElement["points"];
+    simulatePressure: boolean;
+    pressures?: ExcalidrawFreeDrawElement["pressures"];
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawFreeDrawElement>;
+export declare const newLinearElement: (opts: {
+    type: ExcalidrawLinearElement["type"];
+    points?: ExcalidrawLinearElement["points"];
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawLinearElement>;
+export declare const newArrowElement: <T extends boolean>(opts: {
+    type: ExcalidrawArrowElement["type"];
+    startArrowhead?: Arrowhead | null | undefined;
+    endArrowhead?: Arrowhead | null | undefined;
+    points?: readonly import("@excalidraw/math").LocalPoint[] | undefined;
+    elbowed?: T | undefined;
+    fixedSegments?: FixedSegment[] | null | undefined;
+} & Omit<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "link" | "angle" | "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData"> & Partial<Pick<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "link" | "angle" | "strokeColor" | "backgroundColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "width" | "height" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData">>) => T extends true ? NonDeleted<ExcalidrawElbowArrowElement> : NonDeleted<ExcalidrawArrowElement>;
+export declare const newImageElement: (opts: {
+    type: ExcalidrawImageElement["type"];
+    status?: ExcalidrawImageElement["status"];
+    fileId?: ExcalidrawImageElement["fileId"];
+    scale?: ExcalidrawImageElement["scale"];
+    crop?: ExcalidrawImageElement["crop"];
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawImageElement>;