@zsviczian/excalidraw 0.15.3-obsidian-1 → 0.16.1-obsidian-2

package/types/data/transform.d.ts

@@ -68,4 +68,6 @@ export type ExcalidrawElementSkeleton = Extract<Exclude<ExcalidrawElement, Excal
     y: number;
     fileId: FileId;
 } & Partial<ExcalidrawImageElement>);
-export declare const convertToExcalidrawElements: (elements: ExcalidrawElementSkeleton[] | null) => ExcalidrawElement[];
+export declare const convertToExcalidrawElements: (elements: ExcalidrawElementSkeleton[] | null, opts?: {
+    regenerateIds: boolean;
+}) => ExcalidrawElement[];

package/types/element/Hyperlink.d.ts

@@ -12,7 +12,7 @@ export declare const Hyperlink: ({ element, setAppState, onLinkOpen, setToast, }
         closable?: boolean;
         duration?: number;
     } | null) => void;
-}) => JSX.Element | null;
+}) => import("react/jsx-runtime").JSX.Element | null;
 export declare const actionLink: {
     name: "hyperlink";
     perform: (elements: readonly import("./types").ExcalidrawElement[], appState: Readonly<AppState>) => false | {
@@ -54,7 +54,7 @@ export declare const actionLink: {
                 lastActiveTool: import("../types").LastActiveTool;
                 locked: boolean;
             } & ({
-                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "eraser" | "hand";
+                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "eraser" | "hand" | "mermaid";
                 customType: null;
             } | {
                 type: "custom";
@@ -162,6 +162,12 @@ export declare const actionLink: {
             dynamicStyle: string;
             invertBindingBehaviour: boolean;
             selectedLinearElement: import("./linearElementEditor").LinearElementEditor | null;
+            snapLines: import("../snapping").SnapLine[];
+            originSnapOffset: {
+                x: number;
+                y: number;
+            } | null;
+            objectsSnapModeEnabled: boolean;
         };
         commitToHistory: true;
     };
@@ -172,7 +178,7 @@ export declare const actionLink: {
     keyTest: (event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean;
     contextItemLabel: (elements: readonly import("./types").ExcalidrawElement[], appState: Readonly<AppState>) => "labels.link.editEmbed" | "labels.link.edit" | "labels.link.createEmbed" | "labels.link.create";
     predicate: (elements: readonly import("./types").ExcalidrawElement[], appState: AppState) => boolean;
-    PanelComponent: ({ elements, appState, updateData }: import("../actions/types").PanelComponentProps) => JSX.Element;
+    PanelComponent: ({ elements, appState, updateData }: import("../actions/types").PanelComponentProps) => import("react/jsx-runtime").JSX.Element;
 } & {
     keyTest?: ((event: KeyboardEvent | import("react").KeyboardEvent<Element>) => boolean) | undefined;
 };

package/types/element/bounds.d.ts

@@ -15,11 +15,6 @@ export declare class ElementBounds {
     private static calculateBounds;
 }
 export declare const getElementAbsoluteCoords: (element: ExcalidrawElement, includeBoundText?: boolean) => [number, number, number, number, number, number];
-/**
- * for a given element, `getElementLineSegments` returns line segments
- * that can be used for visual collision detection (useful for frames)
- * as opposed to bounding box collision detection
- */
 export declare const getElementLineSegments: (element: ExcalidrawElement) => [Point, Point][];
 /**
  * Scene -> Scene coords, but in x1,x2,y1,y2 format.
@@ -34,6 +29,10 @@ export declare const getMinMaxXYFromCurvePathOps: (ops: Op[], transformXY?: ((x:
 export declare const getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead) => number[] | null;
 export declare const getElementBounds: (element: ExcalidrawElement) => Bounds;
 export declare const getCommonBounds: (elements: readonly ExcalidrawElement[]) => Bounds;
+export declare const getDraggedElementsBounds: (elements: ExcalidrawElement[], dragOffset: {
+    x: number;
+    y: number;
+}) => number[];
 export declare const getResizedElementAbsoluteCoords: (element: ExcalidrawElement, nextWidth: number, nextHeight: number, normalizePoints: boolean) => [number, number, number, number];
 export declare const getElementPointsCoords: (element: ExcalidrawLinearElement, points: readonly (readonly [number, number])[]) => [number, number, number, number];
 export declare const getClosestElementBounds: (elements: readonly ExcalidrawElement[], from: {

package/types/element/dragElements.d.ts

@@ -1,6 +1,15 @@
 import { NonDeletedExcalidrawElement } from "./types";
 import { AppState, PointerDownState } from "../types";
 import Scene from "../scene/Scene";
-export declare const dragSelectedElements: (pointerDownState: PointerDownState, selectedElements: NonDeletedExcalidrawElement[], pointerX: number, pointerY: number, lockDirection: boolean | undefined, distanceX: number | undefined, distanceY: number | undefined, appState: AppState, scene: Scene) => void;
+export declare const dragSelectedElements: (pointerDownState: PointerDownState, selectedElements: NonDeletedExcalidrawElement[], offset: {
+    x: number;
+    y: number;
+}, appState: AppState, scene: Scene, snapOffset: {
+    x: number;
+    y: number;
+}, gridSize: AppState["gridSize"]) => void;
 export declare const getDragOffsetXY: (selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
-export declare const dragNewElement: (draggingElement: NonDeletedExcalidrawElement, elementType: AppState["activeTool"]["type"], originX: number, originY: number, x: number, y: number, width: number, height: number, shouldMaintainAspectRatio: boolean, shouldResizeFromCenter: boolean, widthAspectRatio?: number | null) => void;
+export declare const dragNewElement: (draggingElement: NonDeletedExcalidrawElement, elementType: AppState["activeTool"]["type"], originX: number, originY: number, x: number, y: number, width: number, height: number, shouldMaintainAspectRatio: boolean, shouldResizeFromCenter: boolean, widthAspectRatio?: number | null, originOffset?: {
+    x: number;
+    y: number;
+} | null) => void;

package/types/element/embeddable.d.ts

@@ -28,7 +28,7 @@ export declare const actionSetEmbeddableAsActiveTool: {
                 lastActiveTool: import("../types").LastActiveTool;
                 locked: boolean;
             } & ({
-                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "eraser" | "hand";
+                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "eraser" | "hand" | "mermaid";
                 customType: null;
             } | {
                 type: "custom";
@@ -168,6 +168,12 @@ export declare const actionSetEmbeddableAsActiveTool: {
             dynamicStyle: string;
             invertBindingBehaviour: boolean;
             selectedLinearElement: import("./linearElementEditor").LinearElementEditor | null;
+            snapLines: import("../snapping").SnapLine[];
+            originSnapOffset: {
+                x: number;
+                y: number;
+            } | null;
+            objectsSnapModeEnabled: boolean;
         };
         commitToHistory: false;
     };

package/types/element/linearElementEditor.d.ts

@@ -155,7 +155,7 @@ export declare class LinearElementEditor {
                 lastActiveTool: import("../types").LastActiveTool;
                 locked: boolean;
             } & ({
-                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "eraser" | "hand";
+                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "embeddable" | "image" | "frame" | "freedraw" | "eraser" | "hand" | "mermaid";
                 customType: null;
             } | {
                 type: "custom";
@@ -265,6 +265,12 @@ export declare class LinearElementEditor {
             dynamicStyle: string;
             invertBindingBehaviour: boolean;
             selectedLinearElement: LinearElementEditor | null;
+            snapLines: import("../snapping").SnapLine[];
+            originSnapOffset: {
+                x: number;
+                y: number;
+            } | null;
+            objectsSnapModeEnabled: boolean;
         };
     };
     static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[]): void;
@@ -280,7 +286,7 @@ export declare class LinearElementEditor {
         endBinding?: PointBinding;
     }): void;
     static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState): boolean;
-    static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState): {
+    static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState, snapToGrid: boolean): {
         pointerDownState: LinearElementEditor["pointerDownState"];
         selectedPointsIndices: LinearElementEditor["selectedPointsIndices"];
     } | undefined;

package/types/element/resizeElements.d.ts

@@ -1,8 +1,8 @@
 import { ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted } from "./types";
 import { MaybeTransformHandleType, TransformHandleDirection } from "./transformHandles";
-import { PointerDownState } from "../types";
+import { AppState, PointerDownState } from "../types";
 export declare const normalizeAngle: (angle: number) => number;
-export declare const transformElements: (pointerDownState: PointerDownState, transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], resizeArrowDirection: "origin" | "end", shouldRotateWithDiscreteAngle: boolean, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number) => boolean;
+export declare const transformElements: (pointerDownState: PointerDownState, transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], resizeArrowDirection: "origin" | "end", shouldRotateWithDiscreteAngle: boolean, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number, appState: AppState) => boolean;
 export declare const resizeSingleElement: (originalElements: PointerDownState["originalElements"], shouldMaintainAspectRatio: boolean, element: NonDeletedExcalidrawElement, transformHandleDirection: TransformHandleDirection, shouldResizeFromCenter: boolean, pointerX: number, pointerY: number) => void;
 export declare const resizeMultipleElements: (pointerDownState: PointerDownState, selectedElements: readonly NonDeletedExcalidrawElement[], transformHandleType: "nw" | "ne" | "sw" | "se", shouldResizeFromCenter: boolean, pointerX: number, pointerY: number) => void;
 export declare const getResizeOffsetXY: (transformHandleType: MaybeTransformHandleType, selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];

package/types/frame.d.ts

@@ -25,7 +25,7 @@ export declare const addElementsToFrame: (allElements: ExcalidrawElementsIncludi
 export declare const removeElementsFromFrame: (allElements: ExcalidrawElementsIncludingDeleted, elementsToRemove: NonDeletedExcalidrawElement[], appState: AppState) => ExcalidrawElement[];
 export declare const removeAllElementsFromFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
 export declare const replaceAllElementsInFrame: (allElements: ExcalidrawElementsIncludingDeleted, nextElementsInFrame: ExcalidrawElement[], frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
-/** does not mutate elements, but return new ones */
+/** does not mutate elements, but returns new ones */
 export declare const updateFrameMembershipOfSelectedElements: (allElements: ExcalidrawElementsIncludingDeleted, appState: AppState, app: AppClassProperties) => ExcalidrawElementsIncludingDeleted;
 /**
  * filters out elements that are inside groups that contain a frame element

package/types/hooks/useStable.d.ts

@@ -0,0 +1 @@
+export declare const useStable: <T extends Record<string, any>>(value: T) => T;

package/types/keys.d.ts

@@ -19,6 +19,7 @@ export declare const CODES: {
     readonly V: "KeyV";
     readonly Z: "KeyZ";
     readonly R: "KeyR";
+    readonly S: "KeyS";
 };
 export declare const KEYS: {
     readonly ARROW_DOWN: "ArrowDown";

package/types/math.d.ts

@@ -28,3 +28,5 @@ export declare const getBezierCurveLength: (element: NonDeleted<ExcalidrawLinear
 export declare const mapIntervalToBezierT: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number], interval: number) => number;
 export declare const arePointsEqual: (p1: readonly [number, number], p2: readonly [number, number]) => boolean;
 export declare const isRightAngle: (angle: number) => boolean;
+export declare const rangesOverlap: ([a0, a1]: [number, number], [b0, b1]: [number, number]) => boolean;
+export declare const rangeIntersection: (rangeA: [number, number], rangeB: [number, number]) => [number, number] | null;

package/types/packages/excalidraw/example/App.d.ts

@@ -11,4 +11,4 @@ export interface AppProps {
     useCustom: (api: ExcalidrawImperativeAPI | null, customArgs?: any[]) => void;
     customArgs?: any[];
 }
-export default function App({ appTitle, useCustom, customArgs }: AppProps): JSX.Element;
+export default function App({ appTitle, useCustom, customArgs }: AppProps): import("react/jsx-runtime").JSX.Element;

package/types/packages/excalidraw/example/CustomFooter.d.ts

@@ -1,5 +1,5 @@
 import { ExcalidrawImperativeAPI } from "../../../types";
 declare const CustomFooter: ({ excalidrawAPI, }: {
     excalidrawAPI: ExcalidrawImperativeAPI;
-}) => JSX.Element;
+}) => import("react/jsx-runtime").JSX.Element;
 export default CustomFooter;

package/types/packages/excalidraw/example/MobileFooter.d.ts

@@ -1,5 +1,5 @@
 import { ExcalidrawImperativeAPI } from "../../../types";
 declare const MobileFooter: ({ excalidrawAPI, }: {
     excalidrawAPI: ExcalidrawImperativeAPI;
-}) => JSX.Element | null;
+}) => import("react/jsx-runtime").JSX.Element | null;
 export default MobileFooter;

package/types/packages/excalidraw/example/sidebar/ExampleSidebar.d.ts

@@ -2,4 +2,4 @@ import React from "react";
 import "./ExampleSidebar.scss";
 export default function Sidebar({ children }: {
     children: React.ReactNode;
-}): JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;

package/types/packages/excalidraw/index.d.ts

@@ -20,7 +20,7 @@ getDefaultLineHeight, //zsviczian
 wrapText, //zsviczian
 getFontString, //zsviczian
 getBoundTextMaxWidth, //zsviczian
-exportToClipboard, mergeLibraryItems, } from "../../packages/utils";
+exportToClipboard, mergeLibraryItems, mermaidToExcalidraw, } from "../../packages/utils";
 export { isLinearElement } from "../../element/typeChecks";
 export { FONT_FAMILY, THEME, MIME_TYPES } from "../../constants";
 export { mutateElement, newElementWith, bumpVersion, } from "../../element/mutateElement";

package/types/packages/excalidraw/webpack.dev.config.d.ts

@@ -30,6 +30,15 @@ export namespace module {
                 };
             };
         })[];
+        resolve?: undefined;
+        type?: undefined;
+    } | {
+        test: RegExp;
+        resolve: {
+            fullySpecified: boolean;
+        };
+        exclude?: undefined;
+        use?: undefined;
         type?: undefined;
     } | {
         test: RegExp;
@@ -44,12 +53,14 @@ export namespace module {
                 configFile: string;
             };
         })[];
+        resolve?: undefined;
         type?: undefined;
     } | {
         test: RegExp;
         type: string;
         exclude?: undefined;
         use?: undefined;
+        resolve?: undefined;
     })[];
 }
 export namespace optimization {

package/types/packages/excalidraw/webpack.prod.config.d.ts

@@ -31,6 +31,15 @@ export namespace module {
                 };
             };
         })[];
+        resolve?: undefined;
+        type?: undefined;
+    } | {
+        test: RegExp;
+        resolve: {
+            fullySpecified: boolean;
+        };
+        exclude?: undefined;
+        use?: undefined;
         type?: undefined;
     } | {
         test: RegExp;
@@ -57,12 +66,14 @@ export namespace module {
                 configFile?: undefined;
             };
         })[];
+        resolve?: undefined;
         type?: undefined;
     } | {
         test: RegExp;
         type: string;
         exclude?: undefined;
         use?: undefined;
+        resolve?: undefined;
     })[];
 }
 export namespace optimization {

package/types/packages/utils.d.ts

@@ -41,3 +41,4 @@ export { measureText, wrapText, getDefaultLineHeight, } from "../element/textEle
 export { getFontString } from "../utils";
 export { getBoundTextMaxWidth } from "../element/textElement";
 export { mergeLibraryItems } from "../data/library";
+export { mermaidToExcalidraw } from "../components/MermaidToExcalidraw";

package/types/renderer/renderSnaps.d.ts

@@ -0,0 +1,2 @@
+import { InteractiveCanvasAppState } from "../types";
+export declare const renderSnaps: (context: CanvasRenderingContext2D, appState: InteractiveCanvasAppState) => void;

package/types/scene/selection.d.ts

@@ -8,6 +8,7 @@ import { AppState, InteractiveCanvasAppState } from "../types";
  */
 export declare const excludeElementsInFramesFromSelection: <T extends ExcalidrawElement>(selectedElements: readonly T[]) => T[];
 export declare const getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement, excludeElementsInFrames?: boolean) => NonDeletedExcalidrawElement[];
+export declare const getVisibleAndNonSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: readonly NonDeletedExcalidrawElement[], appState: AppState) => NonDeletedExcalidrawElement[];
 export declare const isSomeElementSelected: {
     (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">): boolean;
     clearCache(): void;

package/types/shapes.d.ts

@@ -1,59 +1,59 @@
 export declare const SHAPES: readonly [{
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "selection";
     readonly key: "v";
     readonly numericKey: "1";
     readonly fillable: true;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "rectangle";
     readonly key: "r";
     readonly numericKey: "2";
     readonly fillable: true;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "diamond";
     readonly key: "d";
     readonly numericKey: "3";
     readonly fillable: true;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "ellipse";
     readonly key: "o";
     readonly numericKey: "4";
     readonly fillable: true;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "arrow";
     readonly key: "a";
     readonly numericKey: "5";
     readonly fillable: true;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "line";
     readonly key: "l";
     readonly numericKey: "6";
     readonly fillable: true;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "freedraw";
     readonly key: readonly ["p", "x"];
     readonly numericKey: "7";
     readonly fillable: false;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "text";
     readonly key: "t";
     readonly numericKey: "8";
     readonly fillable: false;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "image";
     readonly key: null;
     readonly numericKey: "9";
     readonly fillable: false;
 }, {
-    readonly icon: JSX.Element;
+    readonly icon: import("react/jsx-runtime").JSX.Element;
     readonly value: "eraser";
     readonly key: "e";
     readonly numericKey: "0";

package/types/snapping.d.ts

@@ -0,0 +1,108 @@
+import { Bounds } from "./element/bounds";
+import { MaybeTransformHandleType } from "./element/transformHandles";
+import { ExcalidrawElement, NonDeletedExcalidrawElement } from "./element/types";
+import { AppState, KeyboardModifiersObject, Point } from "./types";
+export declare const getSnapDistance: (zoomValue: number) => number;
+type Vector2D = {
+    x: number;
+    y: number;
+};
+type PointPair = [Point, Point];
+export type PointSnap = {
+    type: "point";
+    points: PointPair;
+    offset: number;
+};
+export type Gap = {
+    startBounds: Bounds;
+    endBounds: Bounds;
+    startSide: [Point, Point];
+    endSide: [Point, Point];
+    overlap: [number, number];
+    length: number;
+};
+export type GapSnap = {
+    type: "gap";
+    direction: "center_horizontal" | "center_vertical" | "side_left" | "side_right" | "side_top" | "side_bottom";
+    gap: Gap;
+    offset: number;
+};
+export type GapSnaps = GapSnap[];
+export type Snap = GapSnap | PointSnap;
+export type Snaps = Snap[];
+export type PointSnapLine = {
+    type: "points";
+    points: Point[];
+};
+export type PointerSnapLine = {
+    type: "pointer";
+    points: PointPair;
+    direction: "horizontal" | "vertical";
+};
+export type GapSnapLine = {
+    type: "gap";
+    direction: "horizontal" | "vertical";
+    points: PointPair;
+};
+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 setVisibleGaps: (gaps: {
+        verticalGaps: Gap[];
+        horizontalGaps: Gap[];
+    } | null) => void;
+    static getVisibleGaps: () => {
+        verticalGaps: Gap[];
+        horizontalGaps: Gap[];
+    } | null;
+    static destroy: () => void;
+}
+export declare const isSnappingEnabled: ({ event, appState, selectedElements, }: {
+    appState: AppState;
+    event: KeyboardModifiersObject;
+    selectedElements: NonDeletedExcalidrawElement[];
+}) => boolean;
+export declare const areRoughlyEqual: (a: number, b: number, precision?: number) => boolean;
+export declare const getElementsCorners: (elements: ExcalidrawElement[], { omitCenter, boundingBoxCorners, dragOffset, }?: {
+    omitCenter?: boolean | undefined;
+    boundingBoxCorners?: boolean | undefined;
+    dragOffset?: Vector2D | undefined;
+}) => Point[];
+export declare const getVisibleGaps: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState) => {
+    horizontalGaps: Gap[];
+    verticalGaps: Gap[];
+};
+export declare const getReferenceSnapPoints: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: ExcalidrawElement[], appState: AppState) => (readonly [number, number])[];
+export declare const snapDraggedElements: (selectedElements: ExcalidrawElement[], dragOffset: Vector2D, appState: AppState, event: KeyboardModifiersObject) => {
+    snapOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: (PointSnapLine | GapSnapLine)[];
+};
+export declare const snapResizingElements: (selectedElements: ExcalidrawElement[], selectedOriginalElements: ExcalidrawElement[], appState: AppState, event: KeyboardModifiersObject, dragOffset: Vector2D, transformHandle: MaybeTransformHandleType) => {
+    snapOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: PointSnapLine[];
+};
+export declare const snapNewElement: (draggingElement: ExcalidrawElement, appState: AppState, event: KeyboardModifiersObject, origin: Vector2D, dragOffset: Vector2D) => {
+    snapOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: PointSnapLine[];
+};
+export declare const getSnapLinesAtPointer: (elements: readonly ExcalidrawElement[], appState: AppState, pointer: Vector2D, event: KeyboardModifiersObject) => {
+    originOffset: {
+        x: number;
+        y: number;
+    };
+    snapLines: PointerSnapLine[];
+};
+export declare const isActiveToolNonLinearSnappable: (activeToolType: AppState["activeTool"]["type"]) => boolean;
+export {};

package/types/types.d.ts

@@ -16,6 +16,7 @@ import Library from "./data/library";
 import type { FileSystemHandle } from "./data/filesystem";
 import type { IMAGE_MIME_TYPES, MIME_TYPES } from "./constants";
 import { ContextMenuItems } from "./components/ContextMenu";
+import { SnapLine } from "./snapping";
 import { Merge, ForwardRef, ValueOf } from "./utility-types";
 import { ColorPaletteCustom } from "./colors";
 export type Point = Readonly<RoughPoint>;
@@ -58,7 +59,7 @@ export type BinaryFileData = {
 export type BinaryFileMetadata = Omit<BinaryFileData, "dataURL">;
 export type BinaryFiles = Record<ExcalidrawElement["id"], BinaryFileData>;
 export type LastActiveTool = {
-    type: typeof SHAPES[number]["value"] | "eraser" | "hand" | "frame" | "embeddable";
+    type: typeof SHAPES[number]["value"] | "eraser" | "hand" | "frame" | "embeddable" | "mermaid";
     customType: null;
 } | {
     type: "custom";
@@ -106,6 +107,8 @@ export type InteractiveCanvasAppState = Readonly<_CommonCanvasAppState & {
     openSidebar: AppState["openSidebar"];
     showHyperlinkPopup: AppState["showHyperlinkPopup"];
     collaborators: AppState["collaborators"];
+    snapLines: AppState["snapLines"];
+    zenModeEnabled: AppState["zenModeEnabled"];
 }>;
 export type AppState = {
     contextMenu: {
@@ -146,7 +149,7 @@ export type AppState = {
         lastActiveTool: LastActiveTool;
         locked: boolean;
     } & ({
-        type: typeof SHAPES[number]["value"] | "eraser" | "hand" | "frame" | "embeddable";
+        type: typeof SHAPES[number]["value"] | "eraser" | "hand" | "frame" | "embeddable" | "mermaid";
         customType: null;
     } | {
         type: "custom";
@@ -265,6 +268,12 @@ export type AppState = {
     dynamicStyle: string;
     invertBindingBehaviour: boolean;
     selectedLinearElement: LinearElementEditor | null;
+    snapLines: SnapLine[];
+    originSnapOffset: {
+        x: number;
+        y: number;
+    } | null;
+    objectsSnapModeEnabled: boolean;
 };
 export type UIAppState = Omit<AppState, "suggestedBindings" | "startBoundElement" | "cursorButton" | "scrollX" | "scrollY">;
 export type NormalizedZoomValue = number & {
@@ -334,6 +343,7 @@ export interface ExcalidrawProps {
     viewModeEnabled?: boolean;
     zenModeEnabled?: boolean;
     gridModeEnabled?: boolean;
+    objectsSnapModeEnabled?: boolean;
     libraryReturnUrl?: string;
     initState?: AppState;
     theme?: Theme;
@@ -360,6 +370,7 @@ export interface ExcalidrawProps {
     renderEmbeddable?: (element: NonDeleted<ExcalidrawEmbeddableElement>, appState: AppState) => JSX.Element | null;
     renderWebview?: boolean;
     renderEmbeddableMenu?: (appState: AppState) => JSX.Element | null;
+    renderMermaid?: boolean;
 }
 export type SceneData = {
     elements?: ImportedDataState["elements"];
@@ -407,8 +418,9 @@ export type AppProps = Merge<ExcalidrawProps, {
  * in the app, eg Manager. Factored out into a separate type to keep DRY. */
 export type AppClassProperties = {
     props: AppProps;
-    canvas: HTMLCanvasElement;
     interactiveCanvas: HTMLCanvasElement | null;
+    /** static canvas */
+    canvas: HTMLCanvasElement;
     focusContainer(): void;
     library: Library;
     imageCache: Map<FileId, {
@@ -423,6 +435,11 @@ export type AppClassProperties = {
     onInsertElements: App["onInsertElements"];
     onExportImage: App["onExportImage"];
     lastViewportPosition: App["lastViewportPosition"];
+    scrollToContent: App["scrollToContent"];
+    addFiles: App["addFiles"];
+    setSelection: App["setSelection"];
+    addElementsFromPasteOrLibrary: App["addElementsFromPasteOrLibrary"];
+    setActiveTool: App["setActiveTool"];
 };
 export type PointerDownState = Readonly<{
     origin: Readonly<{
@@ -544,4 +561,10 @@ export type FrameNameBoundsCache = {
         versionNonce: ExcalidrawFrameElement["versionNonce"];
     }>;
 };
+export type KeyboardModifiersObject = {
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+};
 export {};

package/types/utils.d.ts

@@ -81,7 +81,7 @@ export declare const selectNode: (node: Element) => void;
 export declare const removeSelection: () => void;
 export declare const distance: (x: number, y: number) => number;
 export declare const updateActiveTool: (appState: Pick<AppState, "activeTool">, data: ({
-    type: (typeof SHAPES)[number]["value"] | "eraser" | "hand" | "frame" | "embeddable";
+    type: (typeof SHAPES)[number]["value"] | "eraser" | "hand" | "frame" | "embeddable" | "mermaid";
 } | {
     type: "custom";
     customType: string;