@zsviczian/excalidraw 0.17.6-22 → 0.17.6-24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zsviczian/excalidraw",
-  "version": "0.17.6-22",
+  "version": "0.17.6-24",
   "main": "main.js",
   "types": "types/excalidraw/index.d.ts",
   "files": [

package/types/excalidraw/components/App.d.ts

@@ -249,6 +249,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private renderEmbeddables;
     private getFrameNameDOMId;
     frameNameBoundsCache: FrameNameBoundsCache;
+    private resetEditingFrame;
     private renderFrameNames;
     private toggleOverscrollBehavior;
     render(): JSX.Element;
@@ -356,7 +357,7 @@ declare class App extends React.Component<AppProps, AppState> {
     /** use when changing scrollX/scrollY/zoom based on user interaction */
     private translateCanvas;
     zoomToFit: (target?: readonly ExcalidrawElement[], maxZoom?: number, margin?: number) => void;
-    getColorAtScenePoint: ({ sceneX, sceneY }: {
+    getColorAtScenePoint: ({ sceneX, sceneY, }: {
         sceneX: number;
         sceneY: number;
     }) => string | null;

package/types/excalidraw/components/Stats/utils.d.ts

@@ -14,7 +14,6 @@ export declare const newOrigin: (x1: number, y1: number, w1: number, h1: number,
     x: number;
     y: number;
 };
-export declare const resizeElement: (nextWidth: number, nextHeight: number, keepAspectRatio: boolean, origElement: ExcalidrawElement, elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[], scene: Scene, shouldInformMutation?: boolean) => void;
 export declare const moveElement: (newTopLeftX: number, newTopLeftY: number, originalElement: ExcalidrawElement, elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[], scene: Scene, originalElementsMap: ElementsMap, shouldInformMutation?: boolean) => void;
 export declare const getAtomicUnits: (targetElements: readonly ExcalidrawElement[], appState: AppState) => AtomicUnit[];
 export declare const updateBindings: (latestElement: ExcalidrawElement, elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[], scene: Scene, options?: {
@@ -23,4 +22,5 @@ export declare const updateBindings: (latestElement: ExcalidrawElement, elements
         width: number;
         height: number;
     };
+    zoom?: AppState["zoom"];
 }) => void;

package/types/excalidraw/components/TTDDialog/MermaidToExcalidrawLib.d.ts

@@ -1,6 +1,6 @@
-import { MermaidConfig } from "@zsviczian/mermaid-to-excalidraw";
-import { ExcalidrawElement } from "../../element/types";
-import { MermaidToExcalidrawLibProps } from "./common";
+import type { MermaidConfig } from "@zsviczian/mermaid-to-excalidraw";
+import type { ExcalidrawElement } from "../../element/types";
+import type { MermaidToExcalidrawLibProps } from "./common";
 export declare const loadMermaidToExcalidrawLib: () => Promise<MermaidToExcalidrawLibProps>;
 export declare const loadMermaidLib: () => Promise<MermaidToExcalidrawLibProps>;
 export declare const mermaidToExcalidraw: (mermaidDefinition: string, opts: MermaidConfig, forceSVG?: boolean) => Promise<{

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

@@ -15,9 +15,11 @@ export type SuggestedPointBinding = [
 export declare const shouldEnableBindingForPointerEvent: (event: React.PointerEvent<HTMLElement>) => boolean;
 export declare const isBindingEnabled: (appState: AppState) => boolean;
 export declare const FIXED_BINDING_DISTANCE = 5;
+export declare const BINDING_HIGHLIGHT_THICKNESS = 10;
+export declare const BINDING_HIGHLIGHT_OFFSET = 4;
 export declare const bindOrUnbindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, startBindingElement: ExcalidrawBindableElement | null | "keep", endBindingElement: ExcalidrawBindableElement | null | "keep", elementsMap: NonDeletedSceneElementsMap, scene: Scene) => void;
-export declare const bindOrUnbindLinearElements: (selectedElements: NonDeleted<ExcalidrawLinearElement>[], elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[], scene: Scene, isBindingEnabled: boolean, draggingPoints: readonly number[] | null) => void;
-export declare const getSuggestedBindingsForArrows: (selectedElements: NonDeleted<ExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap) => SuggestedBinding[];
+export declare const bindOrUnbindLinearElements: (selectedElements: NonDeleted<ExcalidrawLinearElement>[], elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[], scene: Scene, isBindingEnabled: boolean, draggingPoints: readonly number[] | null, zoom?: AppState["zoom"]) => void;
+export declare const getSuggestedBindingsForArrows: (selectedElements: NonDeleted<ExcalidrawElement>[], elementsMap: NonDeletedSceneElementsMap, zoom: AppState["zoom"]) => SuggestedBinding[];
 export declare const maybeBindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, appState: AppState, pointerCoords: {
     x: number;
     y: number;
@@ -27,7 +29,7 @@ export declare const isLinearElementSimpleAndAlreadyBound: (linearElement: NonDe
 export declare const getHoveredElementForBinding: (pointerCoords: {
     x: number;
     y: number;
-}, elements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap, fullShape?: boolean) => NonDeleted<ExcalidrawBindableElement> | null;
+}, elements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap, zoom?: AppState["zoom"], fullShape?: boolean) => NonDeleted<ExcalidrawBindableElement> | null;
 export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, options?: {
     simultaneouslyUpdated?: readonly ExcalidrawElement[];
     newSize?: {
@@ -35,8 +37,9 @@ export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawE
         height: number;
     };
     changedElements?: Map<string, OrderedExcalidrawElement>;
+    zoom?: AppState["zoom"];
 }) => void;
-export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, elementsMap: ElementsMap, origPoint: GlobalPoint) => Heading;
+export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, elementsMap: ElementsMap, origPoint: GlobalPoint, zoom?: AppState["zoom"]) => Heading;
 export declare const bindPointToSnapToElementOutline: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined, elementsMap: ElementsMap) => GlobalPoint;
 export declare const avoidRectangularCorner: (element: ExcalidrawBindableElement, p: GlobalPoint) => GlobalPoint;
 export declare const snapToMid: (element: ExcalidrawBindableElement, p: GlobalPoint, tolerance?: number) => GlobalPoint;
@@ -48,8 +51,8 @@ export declare const fixBindingsAfterDeletion: (sceneElements: readonly Excalidr
 export declare const bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
     x: number;
     y: number;
-}, elementsMap: NonDeletedSceneElementsMap, fullShape?: boolean) => boolean;
-export declare const maxBindingGap: (element: ExcalidrawElement, elementWidth: number, elementHeight: number) => number;
+}, elementsMap: NonDeletedSceneElementsMap, zoom?: AppState["zoom"], fullShape?: boolean) => boolean;
+export declare const maxBindingGap: (element: ExcalidrawElement, elementWidth: number, elementHeight: number, zoom?: AppState["zoom"]) => number;
 export declare const distanceToBindableElement: (element: ExcalidrawBindableElement, point: GlobalPoint, elementsMap: ElementsMap) => number;
 export declare const determineFocusDistance: (element: ExcalidrawBindableElement, a: GlobalPoint, b: GlobalPoint, elementsMap: ElementsMap) => number;
 export declare const intersectElementWithLine: (element: ExcalidrawBindableElement, a: GlobalPoint, b: GlobalPoint, gap: number | undefined, elementsMap: ElementsMap) => GlobalPoint[] | undefined;

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

@@ -1,5 +1,6 @@
 import type { TransformHandleType } from "./transformHandles";
 import type { ElementsMap, ExcalidrawImageElement, ImageCrop } from "./types";
+export declare const MINIMAL_CROP_SIZE = 10;
 export declare const cropElement: (element: ExcalidrawImageElement, transformHandle: TransformHandleType, naturalWidth: number, naturalHeight: number, pointerX: number, pointerY: number, widthAspectRatio?: number) => {
     x: number;
     y: number;
@@ -12,3 +13,7 @@ export declare const getUncroppedWidthAndHeight: (element: ExcalidrawImageElemen
     width: number;
     height: number;
 };
+export declare const getFlipAdjustedCropPosition: (element: ExcalidrawImageElement, natural?: boolean) => {
+    x: number;
+    y: number;
+} | null;

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

@@ -96,10 +96,10 @@ export declare class LinearElementEditor {
     };
     static normalizePoints(element: NonDeleted<ExcalidrawLinearElement>): void;
     static duplicateSelectedPoints(appState: AppState, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): AppState;
-    static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): void;
+    static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, zoom: AppState["zoom"]): void;
     static addPoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
         point: LocalPoint;
-    }[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap): void;
+    }[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, zoom: AppState["zoom"]): void;
     static movePoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
         index: number;
         point: LocalPoint;
@@ -110,6 +110,7 @@ export declare class LinearElementEditor {
     }, options?: {
         changedElements?: Map<string, OrderedExcalidrawElement>;
         isDragging?: boolean;
+        zoom?: AppState["zoom"];
     }): void;
     static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState, elementsMap: ElementsMap): boolean;
     static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, elementsMap: ElementsMap): {

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

@@ -1,16 +1,39 @@
-import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ElementsMap, NonDeletedSceneElementsMap, SceneElementsMap } from "./types";
+import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawElement, ElementsMap, SceneElementsMap } from "./types";
+import type { BoundingBox } from "./bounds";
 import type { MaybeTransformHandleType, TransformHandleDirection } from "./transformHandles";
 import type { PointerDownState } from "../types";
-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;
+import type Scene from "../scene/Scene";
+import { type LocalPoint } from "../../math";
+export declare const transformElements: (originalElements: PointerDownState["originalElements"], transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: SceneElementsMap, scene: Scene, 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: import("../../math").LocalPoint[];
+    points: LocalPoint[];
 } | {
     points?: undefined;
 };
 export declare const measureFontSizeFromWidth: (element: NonDeleted<ExcalidrawTextElement>, elementsMap: ElementsMap, nextWidth: number) => {
     size: number;
 } | null;
-export declare const resizeSingleElement: (originalElements: PointerDownState["originalElements"], shouldMaintainAspectRatio: boolean, element: NonDeletedExcalidrawElement, elementsMap: SceneElementsMap, transformHandleDirection: TransformHandleDirection, shouldResizeFromCenter: boolean, pointerX: number, pointerY: number) => void;
-export declare const resizeMultipleElements: (originalElements: PointerDownState["originalElements"], selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, transformHandleType: TransformHandleDirection, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number) => void;
 export declare const getResizeOffsetXY: (transformHandleType: MaybeTransformHandleType, selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap, x: number, y: number) => [number, number];
 export declare const getResizeArrowDirection: (transformHandleType: MaybeTransformHandleType, element: NonDeleted<ExcalidrawLinearElement>) => "origin" | "end";
+export declare const resizeSingleElement: (nextWidth: number, nextHeight: number, latestElement: ExcalidrawElement, origElement: ExcalidrawElement, elementsMap: ElementsMap, originalElementsMap: ElementsMap, handleDirection: TransformHandleDirection, { shouldInformMutation, shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
+    shouldMaintainAspectRatio?: boolean | undefined;
+    shouldResizeFromCenter?: boolean | undefined;
+    shouldInformMutation?: boolean | undefined;
+}) => void;
+export declare const getNextSingleWidthAndHeightFromPointer: (latestElement: ExcalidrawElement, origElement: ExcalidrawElement, elementsMap: ElementsMap, originalElementsMap: ElementsMap, handleDirection: TransformHandleDirection, pointerX: number, pointerY: number, { shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
+    shouldMaintainAspectRatio?: boolean | undefined;
+    shouldResizeFromCenter?: boolean | undefined;
+}) => {
+    nextWidth: number;
+    nextHeight: number;
+};
+export declare const resizeMultipleElements: (selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, handleDirection: TransformHandleDirection, scene: Scene, { shouldMaintainAspectRatio, shouldResizeFromCenter, flipByX, flipByY, nextHeight, nextWidth, originalElementsMap, originalBoundingBox, }?: {
+    nextWidth?: number | undefined;
+    nextHeight?: number | undefined;
+    shouldMaintainAspectRatio?: boolean | undefined;
+    shouldResizeFromCenter?: boolean | undefined;
+    flipByX?: boolean | undefined;
+    flipByY?: boolean | undefined;
+    originalElementsMap?: ElementsMap | undefined;
+    originalBoundingBox?: BoundingBox | undefined;
+}) => void;

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

@@ -1,12 +1,15 @@
 import { type LocalPoint, type Vector } from "../../math";
+import type { AppState } from "../types";
 import type { ElementUpdate } from "./mutateElement";
 import type { ExcalidrawElbowArrowElement, NonDeletedSceneElementsMap, SceneElementsMap } from "./types";
 export declare const mutateElbowArrow: (arrow: ExcalidrawElbowArrowElement, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, nextPoints: readonly LocalPoint[], offset?: Vector, otherUpdates?: Omit<ElementUpdate<ExcalidrawElbowArrowElement>, "angle" | "x" | "y" | "width" | "height" | "elbowed" | "points">, options?: {
     isDragging?: boolean;
     informMutation?: boolean;
+    zoom?: AppState["zoom"];
 }) => void;
 export declare const updateElbowArrow: (arrow: ExcalidrawElbowArrowElement, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, nextPoints: readonly LocalPoint[], offset?: Vector, options?: {
     isDragging?: boolean;
     disableBinding?: boolean;
     informMutation?: boolean;
+    zoom?: AppState["zoom"];
 }) => ElementUpdate<ExcalidrawElbowArrowElement> | null;

package/types/excalidraw/fonts/Fonts.d.ts

@@ -67,8 +67,7 @@ export declare class Fonts {
      * @param metadata font metadata
      * @param fontFacesDecriptors font faces descriptors
      */
-    static register(//zsviczian made public
-    this: Fonts | {
+    static register(this: Fonts | {
         registered: Map<number, {
             metadata: FontMetadata;
             fontFaces: ExcalidrawFontFace[];

package/types/excalidraw/obsidianUtils.d.ts

@@ -1,7 +1,7 @@
-import { MermaidToExcalidrawLibProps } from "./components/TTDDialog/common";
-import { NonDeletedExcalidrawElement } from "./element/types";
+import type { MermaidToExcalidrawLibProps } from "./components/TTDDialog/common";
+import type { NonDeletedExcalidrawElement } from "./element/types";
 import type { FontMetadata } from "./fonts/FontMetadata";
-import { AppState } from "./types";
+import type { AppState } from "./types";
 export declare let hostPlugin: any;
 export declare function destroyObsidianUtils(): void;
 export declare function initializeObsidianUtils(): void;