@zsviczian/excalidraw 0.12.0-obsidian-4 → 0.12.0-obsidian-5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zsviczian/excalidraw",
-  "version": "0.12.0-obsidian-4",
+  "version": "0.12.0-obsidian-5",
   "main": "main.js",
   "types": "types/packages/excalidraw/index.d.ts",
   "files": [

package/types/actions/actionClipboard.d.ts

@@ -147,6 +147,7 @@ export declare const actionCut: {
                     y: number;
                 }>;
                 hoverPointIndex: number;
+                midPointHovered: boolean;
             };
             isLoading: boolean;
             errorMessage: string | null;

package/types/actions/actionDeleteSelected.d.ts

@@ -138,6 +138,7 @@ export declare const actionDeleteSelected: {
                     y: number;
                 }>;
                 hoverPointIndex: number;
+                midPointHovered: boolean;
             };
             isLoading: boolean;
             errorMessage: string | null;

package/types/element/linearElementEditor.d.ts

@@ -4,26 +4,27 @@ import { Point, AppState } from "../types";
 import History from "../history";
 import Scene from "../scene/Scene";
 export declare class LinearElementEditor {
-    elementId: ExcalidrawElement["id"] & {
+    readonly elementId: ExcalidrawElement["id"] & {
         _brand: "excalidrawLinearElementId";
     };
     /** indices */
-    selectedPointsIndices: readonly number[] | null;
-    pointerDownState: Readonly<{
+    readonly selectedPointsIndices: readonly number[] | null;
+    readonly pointerDownState: Readonly<{
         prevSelectedPointsIndices: readonly number[] | null;
         /** index */
         lastClickedPoint: number;
     }>;
     /** whether you're dragging a point */
-    isDragging: boolean;
-    lastUncommittedPoint: Point | null;
-    pointerOffset: Readonly<{
+    readonly isDragging: boolean;
+    readonly lastUncommittedPoint: Point | null;
+    readonly pointerOffset: Readonly<{
         x: number;
         y: number;
     }>;
-    startBindingElement: ExcalidrawBindableElement | null | "keep";
-    endBindingElement: ExcalidrawBindableElement | null | "keep";
-    hoverPointIndex: number;
+    readonly startBindingElement: ExcalidrawBindableElement | null | "keep";
+    readonly endBindingElement: ExcalidrawBindableElement | null | "keep";
+    readonly hoverPointIndex: number;
+    readonly midPointHovered: boolean;
     constructor(element: NonDeleted<ExcalidrawLinearElement>, scene: Scene);
     static POINT_HANDLE_SIZE: number;
     /**
@@ -33,11 +34,16 @@ 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, 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, linearElementEditor: LinearElementEditor): boolean;
     static handlePointerUp(event: PointerEvent, editingLinearElement: LinearElementEditor, appState: AppState): LinearElementEditor;
+    static isHittingMidPoint: (linearElementEditor: LinearElementEditor, scenePointer: {
+        x: number;
+        y: number;
+    }, appState: AppState) => boolean;
+    static getMidPoint(linearElementEditor: LinearElementEditor): readonly [number, number] | null;
     static handlePointerDown(event: React.PointerEvent<HTMLCanvasElement>, appState: AppState, history: History, scenePointer: {
         x: number;
         y: number;
@@ -45,12 +51,13 @@ export declare class LinearElementEditor {
         didAddPoint: boolean;
         hitElement: NonDeleted<ExcalidrawElement> | null;
         linearElementEditor: LinearElementEditor | null;
+        isMidPoint: boolean;
     };
     static handlePointerMove(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, linearElementEditor: LinearElementEditor, gridSize: number | null): LinearElementEditor;
     /** scene coords */
     static getPointGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, point: Point): readonly [number, number];
     /** scene coords */
-    static getPointsGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>): number[][];
+    static getPointsGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>): Point[];
     static getPointAtIndexGlobalCoordinates(element: NonDeleted<ExcalidrawLinearElement>, indexMaybeFromEnd: number): Point;
     static pointFromAbsoluteCoords(element: NonDeleted<ExcalidrawLinearElement>, absoluteCoords: Point): Point;
     static getPointIndexUnderCursor(element: NonDeleted<ExcalidrawLinearElement>, zoom: AppState["zoom"], x: number, y: number): number;
@@ -78,7 +85,6 @@ export declare class LinearElementEditor {
                     /** index */
                     lastClickedPoint: number;
                 }>;
-                /** whether you're dragging a point */
                 isDragging: boolean;
                 lastUncommittedPoint: readonly [number, number] | null;
                 pointerOffset: Readonly<{
@@ -88,6 +94,7 @@ export declare class LinearElementEditor {
                 startBindingElement: ExcalidrawBindableElement | "keep" | null;
                 endBindingElement: ExcalidrawBindableElement | "keep" | null;
                 hoverPointIndex: number;
+                midPointHovered: boolean;
             };
             isLoading: boolean;
             errorMessage: string | null;
@@ -207,4 +214,5 @@ export declare class LinearElementEditor {
         endBinding?: PointBinding;
     }): void;
     private static _updatePoints;
+    private static _getShiftLockedDelta;
 }

package/types/element/transformHandles.d.ts

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

package/types/polyfill.d.ts

@@ -0,0 +1,2 @@
+declare const polyfill: () => void;
+export default polyfill;

package/types/renderer/renderScene.d.ts

@@ -3,6 +3,7 @@ import { RoughSVG } from "roughjs/bin/svg";
 import { AppState, BinaryFiles } from "../types";
 import { NonDeletedExcalidrawElement } from "../element/types";
 import { RenderConfig } from "../scene/types";
+export declare const DEFAULT_SPACING = 4;
 export declare const _renderScene: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, selectionElement: NonDeletedExcalidrawElement | null, scale: number, rc: RoughCanvas, canvas: HTMLCanvasElement, renderConfig: RenderConfig) => {
     atLeastOneVisibleElement: boolean;
     scrollBars?: undefined;