@zsviczian/excalidraw 0.18.0-6 → 0.18.0-60

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@zsviczian/excalidraw",
-  "version": "0.18.0-6",
+  "version": "0.18.0-60",
   "main": "main.js",
   "module": "./dist/prod/index.js",
+  "source": "./index.tsx",
   "types": "types/excalidraw/index.d.ts",
   "exports": {
     "./common/*": {
@@ -67,6 +68,13 @@
       "last 1 safari version"
     ]
   },
+  "repository": "https://github.com/excalidraw/excalidraw",
+  "bugs": "https://github.com/excalidraw/excalidraw/issues",
+  "homepage": "https://github.com/excalidraw/excalidraw/tree/master/packages/excalidraw",
+  "scripts": {
+    "gen:types": "rimraf types && tsc",
+    "build:esm": "rimraf dist && node ../../scripts/buildPackage.js && yarn gen:types"
+  },
   "peerDependencies": {
     "react": "^17.0.2 || ^18.2.0 || ^19.0.0",
     "react-dom": "^17.0.2 || ^18.2.0 || ^19.0.0"
@@ -74,7 +82,7 @@
   "dependencies": {
     "@braintree/sanitize-url": "6.0.2",
     "@zsviczian/laser-pointer": "1.3.1",
-    "@zsviczian/mermaid-to-excalidraw": "1.1.2",
+    "@zsviczian/mermaid-to-excalidraw": "1.1.3",
     "@excalidraw/random-username": "1.1.0",
     "@radix-ui/react-popover": "1.1.6",
     "@radix-ui/react-tabs": "1.1.3",
@@ -87,8 +95,8 @@
     "image-blob-reduce": "3.0.1",
     "jotai": "2.11.0",
     "jotai-scope": "0.7.2",
-    "lodash.throttle": "4.1.1",
     "lodash.debounce": "4.0.8",
+    "lodash.throttle": "4.1.1",
     "nanoid": "3.3.3",
     "open-color": "1.9.1",
     "pako": "2.0.3",
@@ -153,7 +161,10 @@
     "css-loader": "^7.1.2",
     "esbuild-plugin-external-global": "^1.0.1"
   },
-  "repository": "https://github.com/excalidraw/excalidraw",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zsviczian/excalidraw.git"
+  },
   "bugs": "https://github.com/excalidraw/excalidraw/issues",
   "homepage": "https://github.com/excalidraw/excalidraw/tree/master/packages/excalidraw",
   "scripts": {

package/types/common/src/commonObsidianUtils.d.ts

@@ -0,0 +1,20 @@
+export type ObsidianDeviceType = {
+    isDesktop: boolean;
+    isPhone: boolean;
+    isTablet: boolean;
+    isMobile: boolean;
+    isLinux: boolean;
+    isMacOS: boolean;
+    isWindows: boolean;
+    isIOS: boolean;
+    isAndroid: boolean;
+};
+export declare let hostPlugin: any;
+export declare function destroyObsidianUtils(): void;
+export declare function initializeObsidianUtils(): void;
+export declare function getHostPlugin(): any;
+export declare const getObsidianDeviceInfo: () => ObsidianDeviceType | null;
+export declare const getDesktopUIMode: () => any;
+export declare function getAreaLimit(): any;
+export declare function getWidthHeightLimit(): any;
+export declare function getHighlightColor(sceneBgColor: string, opacity?: number): string;

package/types/common/src/constants.d.ts

@@ -1,17 +1,10 @@
 import type { ExcalidrawElement, FontFamilyValues } from "@excalidraw/element/types";
 import type { AppProps, AppState } from "@excalidraw/excalidraw/types";
-export declare const isDarwin: boolean;
-export declare const isWindows: boolean;
-export declare const isAndroid: boolean;
-export declare const isFirefox: boolean;
-export declare const isChrome: boolean;
-export declare const isSafari: boolean;
-export declare const isIOS: boolean;
-export declare const isBrave: () => boolean;
 export declare const supportsResizeObserver: boolean;
 export declare const APP_NAME = "Excalidraw";
 export declare const TEXT_AUTOWRAP_THRESHOLD = 36;
 export declare const DRAGGING_THRESHOLD = 10;
+export declare const MINIMUM_ARROW_SIZE = 20;
 export declare const LINE_CONFIRM_THRESHOLD = 8;
 export declare const ELEMENT_SHIFT_TRANSLATE_AMOUNT = 5;
 export declare const ELEMENT_TRANSLATE_AMOUNT = 1;
@@ -85,11 +78,16 @@ export declare const ENV: {
     PRODUCTION: string;
 };
 export declare const CLASSES: {
+    SIDEBAR: string;
     SHAPE_ACTIONS_MENU: string;
     SHAPE_ACTIONS_MOBILE_MENU: string;
+    SHAPE_ACTIONS_TRAY_MENU: string;
     MOBILE_TOOLBAR: string;
     ZOOM_ACTIONS: string;
     SEARCH_MENU_INPUT_WRAPPER: string;
+    CONVERT_ELEMENT_TYPE_POPUP: string;
+    SHAPE_ACTIONS_THEME_SCOPE: string;
+    FRAME_NAME: string;
 };
 export declare const CJK_HAND_DRAWN_FALLBACK_FONT = "Xiaolai";
 export declare const WINDOWS_EMOJI_FALLBACK_FONT = "Segoe UI Emoji";
@@ -111,11 +109,21 @@ export declare const FONT_FAMILY: {
     "Lilita One": number;
     "Comic Shanns": number;
     "Liberation Sans": number;
+    Assistant: number;
+};
+export declare const SANS_SERIF_GENERIC_FONT = "sans-serif";
+export declare const MONOSPACE_GENERIC_FONT = "monospace";
+export declare const FONT_FAMILY_GENERIC_FALLBACKS: {
+    "sans-serif": number;
+    monospace: number;
 };
 export declare const FONT_FAMILY_FALLBACKS: {
-    Xiaolai: number;
     "Segoe UI Emoji": number;
+    "sans-serif": number;
+    monospace: number;
+    Xiaolai: number;
 };
+export declare function getGenericFontFamilyFallback(fontFamily: number): keyof typeof FONT_FAMILY_GENERIC_FALLBACKS;
 export declare const getFontFamilyFallbacks: (fontFamily: number) => Array<keyof typeof FONT_FAMILY_FALLBACKS>;
 export declare const THEME: {
     readonly LIGHT: "light";
@@ -166,6 +174,14 @@ export declare const IMAGE_MIME_TYPES: {
     readonly avif: "image/avif";
     readonly jfif: "image/jfif";
 };
+export declare const STRING_MIME_TYPES: {
+    readonly text: "text/plain";
+    readonly html: "text/html";
+    readonly json: "application/json";
+    readonly excalidraw: "application/vnd.excalidraw+json";
+    readonly excalidrawlib: "application/vnd.excalidrawlib+json";
+    readonly excalidrawlibIds: "application/vnd.excalidrawlib.ids+json";
+};
 export declare const MIME_TYPES: {
     readonly svg: "image/svg+xml";
     readonly png: "image/png";
@@ -176,14 +192,15 @@ export declare const MIME_TYPES: {
     readonly ico: "image/x-icon";
     readonly avif: "image/avif";
     readonly jfif: "image/jfif";
+    readonly "excalidraw.svg": "image/svg+xml";
+    readonly "excalidraw.png": "image/png";
+    readonly binary: "application/octet-stream";
     readonly text: "text/plain";
     readonly html: "text/html";
     readonly json: "application/json";
     readonly excalidraw: "application/vnd.excalidraw+json";
     readonly excalidrawlib: "application/vnd.excalidrawlib+json";
-    readonly "excalidraw.svg": "image/svg+xml";
-    readonly "excalidraw.png": "image/png";
-    readonly binary: "application/octet-stream";
+    readonly excalidrawlibIds: "application/vnd.excalidrawlib.ids+json";
 };
 export declare const ALLOWED_PASTE_MIME_TYPES: readonly ["text/plain", "text/html", ...("image/svg+xml" | "image/png" | "image/jpeg" | "image/gif" | "image/webp" | "image/bmp" | "image/x-icon" | "image/avif" | "image/jfif")[]];
 export declare const EXPORT_IMAGE_TYPES: {
@@ -197,7 +214,7 @@ export declare const EXPORT_DATA_TYPES: {
     readonly excalidrawLibrary: "excalidrawlib";
     readonly excalidrawClipboardWithAPI: "excalidraw-api/clipboard";
 };
-export declare const EXPORT_SOURCE: string;
+export declare const getExportSource: () => string;
 export declare const IMAGE_RENDER_TIMEOUT = 500;
 export declare const TAP_TWICE_TIMEOUT = 300;
 export declare const TOUCH_CTX_MENU_TIMEOUT = 500;
@@ -218,10 +235,6 @@ export declare const URL_HASH_KEYS: {
     readonly addLibrary: "addLibrary";
 };
 export declare const DEFAULT_UI_OPTIONS: AppProps["UIOptions"];
-export declare const MQ_MAX_WIDTH_PORTRAIT = 730;
-export declare const MQ_MAX_WIDTH_LANDSCAPE = 1000;
-export declare const MQ_MAX_HEIGHT_LANDSCAPE = 500;
-export declare const MQ_RIGHT_SIDEBAR_MIN_WIDTH = 1229;
 export declare const MAX_DECIMALS_FOR_SVG_EXPORT = 2;
 export declare const EXPORT_SCALES: number[];
 export declare const DEFAULT_EXPORT_PADDING = 10;
@@ -288,7 +301,7 @@ export declare const DEFAULT_SIDEBAR: {
     readonly name: "default";
     readonly defaultTab: "library";
 };
-export declare const LIBRARY_DISABLED_TYPES: Set<"embeddable" | "image" | "iframe">;
+export declare const LIBRARY_DISABLED_TYPES: Set<"embeddable" | "iframe" | "image">;
 export declare const TOOL_TYPE: {
     readonly selection: "selection";
     readonly lasso: "lasso";
@@ -334,3 +347,14 @@ export declare enum UserIdleState {
     AWAY = "away",
     IDLE = "idle"
 }
+/**
+ * distance at which we merge points instead of adding a new merge-point
+ * when converting a line to a polygon (merge currently means overlaping
+ * the start and end points)
+ */
+export declare const LINE_POLYGON_POINT_MERGE_DISTANCE = 20;
+export declare const DOUBLE_TAP_POSITION_THRESHOLD = 35;
+export declare const BIND_MODE_TIMEOUT = 700;
+export declare const MOBILE_ACTION_BUTTON_BG: {
+    readonly background: "var(--mobile-action-button-bg)";
+};

package/types/common/src/editorInterface.d.ts

@@ -0,0 +1,35 @@
+export type StylesPanelMode = "compact" | "full" | "mobile" | "tray";
+export type EditorInterface = Readonly<{
+    formFactor: "phone" | "tablet" | "desktop";
+    desktopUIMode: "compact" | "full" | "tray";
+    userAgent: Readonly<{
+        isMobileDevice: boolean;
+        platform: "ios" | "android" | "other" | "unknown";
+    }>;
+    isTouchScreen: boolean;
+    canFitSidebar: boolean;
+    isLandscape: boolean;
+    preferTrayMode: boolean;
+}>;
+export declare const MQ_MAX_MOBILE = 599;
+export declare const MQ_MAX_WIDTH_LANDSCAPE = 1000;
+export declare const MQ_MAX_HEIGHT_LANDSCAPE = 500;
+export declare const MQ_MIN_TABLET: number;
+export declare const MQ_MAX_TABLET = 1400;
+export declare const MQ_MIN_WIDTH_DESKTOP = 1440;
+export declare const MQ_RIGHT_SIDEBAR_MIN_WIDTH = 800;
+export declare const isDarwin: boolean;
+export declare const isWindows: boolean;
+export declare const isAndroid: boolean;
+export declare const isFirefox: boolean;
+export declare const isChrome: boolean;
+export declare const isSafari: boolean;
+export declare const isIOS: boolean;
+export declare const isBrave: () => boolean;
+export declare const isMobileBreakpoint: (width: number, height: number, allowMobile: boolean) => boolean;
+export declare const isTabletBreakpoint: (editorWidth: number, editorHeight: number) => boolean;
+export declare const getFormFactor: (editorWidth: number, editorHeight: number, allowMobile: boolean) => EditorInterface["formFactor"];
+export declare const deriveStylesPanelMode: (editorInterface: EditorInterface) => StylesPanelMode;
+export declare const createUserAgentDescriptor: (userAgentString: string) => EditorInterface["userAgent"];
+export declare const loadDesktopUIModePreference: () => any;
+export declare const setDesktopUIMode: (mode: EditorInterface["desktopUIMode"]) => "tray" | "full" | "compact" | undefined;

package/types/{excalidraw → common/src}/emitter.d.ts

@@ -1,4 +1,4 @@
-import type { UnsubscribeCallback } from "./types";
+import type { UnsubscribeCallback } from "@excalidraw/excalidraw/types";
 type Subscriber<T extends any[]> = (...payload: T) => void;
 export declare class Emitter<T extends any[] = []> {
     subscribers: Subscriber<T>[];

package/types/common/src/font-metadata.d.ts

@@ -16,8 +16,10 @@ export interface FontMetadata {
     };
     /** flag to indicate a deprecated font */
     deprecated?: true;
-    /** flag to indicate a server-side only font */
-    serverSide?: true;
+    /**
+     * whether this is a font that users can use (= shown in font picker)
+     */
+    private?: true;
     /** flag to indiccate a local-only font */
     local?: true;
     /** flag to indicate a fallback font */

package/types/common/src/index.d.ts

@@ -9,3 +9,7 @@ export * from "./promise-pool";
 export * from "./random";
 export * from "./url";
 export * from "./utils";
+export * from "./emitter";
+export * from "./visualdebug";
+export * from "./editorInterface";
+export * from "./commonObsidianUtils";

package/types/common/src/utility-types.d.ts

@@ -30,3 +30,8 @@ export type MakeBrand<T extends string> = {
 /** Maybe just promise or already fulfilled one! */
 export type MaybePromise<T> = T | Promise<T>;
 export type AllPossibleKeys<T> = T extends any ? keyof T : never;
+/** Strip all the methods or functions from a type */
+export type DTO<T> = {
+    [K in keyof T as T[K] extends Function ? never : K]: T[K];
+};
+export type MapEntry<M extends Map<any, any>> = M extends Map<infer K, infer V> ? [K, V] : never;

package/types/common/src/utils.d.ts

@@ -1,5 +1,4 @@
-import { type GlobalPoint } from "@excalidraw/math";
-import type { ExcalidrawBindableElement, FontFamilyValues, FontString, ExcalidrawElement } from "@excalidraw/element/types";
+import type { FontFamilyValues, FontString } from "@excalidraw/element/types";
 import type { ActiveTool, AppState, ToolType, UnsubscribeCallback, Zoom } from "@excalidraw/excalidraw/types";
 import type { MaybePromise } from "./utility-types";
 import type { EVENT } from "./constants";
@@ -18,6 +17,8 @@ export declare const getFontString: ({ fontSize, fontFamily, }: {
     fontSize: number;
     fontFamily: FontFamilyValues;
 }) => FontString;
+/** executes callback in the frame that's after the current one */
+export declare const nextAnimationFrame: (cb: () => any) => Promise<void>;
 export declare const debounce: <T extends any[]>(fn: (...args: T) => void, timeout: number) => {
     (...args: T): void;
     flush(): void;
@@ -81,6 +82,7 @@ export declare const chunk: <T extends unknown>(array: readonly T[], size: numbe
 export declare const selectNode: (node: Element) => void;
 export declare const removeSelection: () => void;
 export declare const distance: (x: number, y: number) => number;
+export declare const isSelectionLikeTool: (type: ToolType | "custom") => boolean;
 export declare const updateActiveTool: (appState: Pick<AppState, "activeTool">, data: (({
     type: ToolType;
 } | {
@@ -95,7 +97,6 @@ export declare const updateActiveTool: (appState: Pick<AppState, "activeTool">,
 export declare const isFullScreen: () => boolean;
 export declare const allowFullScreen: () => Promise<void>;
 export declare const exitFullScreen: () => Promise<void>;
-export declare const getShortcutKey: (shortcut: string) => string;
 export declare const viewportCoordsToSceneCoords: ({ clientX, clientY }: {
     clientX: number;
     clientY: number;
@@ -138,8 +139,9 @@ export declare const tupleToCoors: (xyTuple: readonly [number, number]) => {
 export declare const muteFSAbortError: (error?: Error) => void;
 export declare const findIndex: <T>(array: readonly T[], cb: (element: T, index: number, array: readonly T[]) => boolean, fromIndex?: number) => number;
 export declare const findLastIndex: <T>(array: readonly T[], cb: (element: T, index: number, array: readonly T[]) => boolean, fromIndex?: number) => number;
+/** returns the first non-null mapped value */
+export declare const mapFind: <T, K>(collection: readonly T[], iteratee: (value: T, index: number) => K | null | undefined) => K | undefined;
 export declare const isTransparent: (color: string) => boolean;
-export declare const isBindingFallthroughEnabled: (el: ExcalidrawBindableElement) => boolean;
 export type ResolvablePromise<T> = Promise<T> & {
     resolve: [T] extends [undefined] ? (value?: MaybePromise<Awaited<T>>) => void : (value: MaybePromise<Awaited<T>>) => void;
     reject: (error: Error) => void;
@@ -178,6 +180,15 @@ export type Node<T> = T & {
  * Creates a circular doubly linked list by adding `prev` and `next` props to the existing array nodes.
  */
 export declare const arrayToList: <T>(array: readonly T[]) => Node<T>[];
+/**
+ * Converts a readonly array or map into an iterable.
+ * Useful for avoiding entry allocations when iterating object / map on each iteration.
+ */
+export declare const toIterable: <T>(values: ReadonlyMap<string, T> | readonly T[]) => Iterable<T>;
+/**
+ * Converts a readonly array or map into an array.
+ */
+export declare const toArray: <T>(values: ReadonlyMap<string, T> | readonly T[]) => T[];
 export declare const isTestEnv: () => boolean;
 export declare const isDevEnv: () => boolean;
 export declare const isProdEnv: () => boolean;
@@ -187,7 +198,7 @@ export declare const wrapEvent: <T extends Event>(name: EVENT, nativeEvent: T) =
 }>;
 export declare const updateObject: <T extends Record<string, any>>(obj: T, updates: Partial<T>) => T;
 export declare const isPrimitive: (val: any) => boolean;
-export declare const getFrame: () => "iframe" | "top";
+export declare const getFrame: () => "top" | "iframe";
 export declare const isRunningInIframe: () => boolean;
 export declare const isPromiseLike: (value: any) => value is Promise<any>;
 export declare const queryFocusableElements: (container: HTMLElement | null) => HTMLElement[];
@@ -250,5 +261,13 @@ export declare const safelyParseJSON: (json: string) => Record<string, any> | nu
  */
 export declare const escapeDoubleQuotes: (str: string) => string;
 export declare const castArray: <T>(value: T | T[]) => T[];
-export declare const elementCenterPoint: (element: ExcalidrawElement, xOffset?: number, yOffset?: number) => GlobalPoint;
+/** hack for Array.isArray type guard not working with readonly value[] */
+export declare const isReadonlyArray: (value?: any) => value is readonly any[];
+export declare const sizeOf: (value: readonly unknown[] | Readonly<Map<string, unknown>> | Readonly<Record<string, unknown>> | ReadonlySet<unknown>) => number;
+export declare const reduceToCommonValue: <T, R = T>(collection: ReadonlySet<T> | readonly T[], getValue?: ((item: T) => R) | undefined) => R | null;
+type FEATURE_FLAGS = {
+    COMPLEX_BINDINGS: boolean;
+};
+export declare const getFeatureFlag: <F extends "COMPLEX_BINDINGS">(flag: F) => FEATURE_FLAGS[F];
+export declare const setFeatureFlag: <F extends "COMPLEX_BINDINGS">(flag: F, value: FEATURE_FLAGS[F]) => void;
 export {};

package/types/{excalidraw → common/src}/visualdebug.d.ts

@@ -1,7 +1,7 @@
 import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
 import type { Curve } from "@excalidraw/math";
 import type { LineSegment } from "@excalidraw/utils";
-import type { Bounds } from "@excalidraw/element/bounds";
+import type { Bounds } from "@excalidraw/element";
 declare global {
     interface Window {
         visualDebug?: {
@@ -35,7 +35,7 @@ export declare const debugDrawBounds: (box: Bounds | Bounds[], opts?: {
 export declare const debugDrawPoints: ({ x, y, points, }: {
     x: number;
     y: number;
-    points: LocalPoint[];
+    points: readonly LocalPoint[];
 }, options?: any) => void;
 export declare const debugCloseFrame: () => void;
 export declare const debugClear: () => void;

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

@@ -1,19 +1,11 @@
-import type { LinearElementEditor } from "@excalidraw/element/linearElementEditor";
+import { type ElementUpdate } from "@excalidraw/element";
 import type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawFrameLikeElement, ElementsMapOrArray, OrderedExcalidrawElement, Ordered } from "@excalidraw/element/types";
-import type { AppState } from "../types";
-type ElementIdKey = InstanceType<typeof LinearElementEditor>["elementId"];
-type ElementKey = ExcalidrawElement | ElementIdKey;
+import type { Mutable } from "@excalidraw/common/utility-types";
+import type { AppState } from "../../excalidraw/types";
 type SceneStateCallback = () => void;
 type SceneStateCallbackRemover = () => void;
 export type ExcalidrawElementsIncludingDeleted = readonly ExcalidrawElement[];
-declare class Scene {
-    private static sceneMapByElement;
-    private static sceneMapById;
-    static mapElementToScene(elementKey: ElementKey, scene: Scene): void;
-    /**
-     * @deprecated pass down `app.scene` and use it directly
-     */
-    static getScene(elementKey: ElementKey): Scene | null;
+export declare class Scene {
     private callbacks;
     private nonDeletedElements;
     private nonDeletedElementsMap;
@@ -35,6 +27,9 @@ declare class Scene {
     getElementsMapIncludingDeleted(): Map<string, Ordered<ExcalidrawElement>> & import("@excalidraw/common/utility-types").MakeBrand<"SceneElementsMap">;
     getNonDeletedElements(): readonly Ordered<NonDeletedExcalidrawElement>[];
     getFramesIncludingDeleted(): readonly ExcalidrawFrameLikeElement[];
+    constructor(elements?: ElementsMapOrArray | null, options?: {
+        skipValidation?: true;
+    });
     getSelectedElements(opts: {
         selectedElementIds: AppState["selectedElementIds"];
         /**
@@ -62,7 +57,9 @@ declare class Scene {
      * @returns whether a change was made
      */
     mapElements(iteratee: (element: ExcalidrawElement) => ExcalidrawElement): boolean;
-    replaceAllElements(nextElements: ElementsMapOrArray): void;
+    replaceAllElements(nextElements: ElementsMapOrArray, options?: {
+        skipValidation?: true;
+    }): void;
     triggerUpdate(): void;
     onUpdate(cb: SceneStateCallback): SceneStateCallbackRemover;
     destroy(): void;
@@ -73,7 +70,11 @@ declare class Scene {
     getElementIndex(elementId: string): number;
     getContainerElement: (element: (ExcalidrawElement & {
         containerId: ExcalidrawElement["id"] | null;
-    }) | null) => import("@excalidraw/element/types").ExcalidrawRectangleElement | import("@excalidraw/element/types").ExcalidrawDiamondElement | import("@excalidraw/element/types").ExcalidrawFrameElement | import("@excalidraw/element/types").ExcalidrawMagicFrameElement | import("@excalidraw/element/types").ExcalidrawEmbeddableElement | import("@excalidraw/element/types").ExcalidrawImageElement | import("@excalidraw/element/types").ExcalidrawIframeElement | import("@excalidraw/element/types").ExcalidrawTextElement | import("@excalidraw/element/types").ExcalidrawSelectionElement | import("@excalidraw/element/types").ExcalidrawEllipseElement | import("@excalidraw/element/types").ExcalidrawLinearElement | import("@excalidraw/element/types").ExcalidrawFreeDrawElement | null;
+    }) | null) => import("@excalidraw/element/types").ExcalidrawLinearElement | import("@excalidraw/element/types").ExcalidrawSelectionElement | import("@excalidraw/element/types").ExcalidrawRectangleElement | import("@excalidraw/element/types").ExcalidrawDiamondElement | import("@excalidraw/element/types").ExcalidrawEllipseElement | import("@excalidraw/element/types").ExcalidrawEmbeddableElement | import("@excalidraw/element/types").ExcalidrawIframeElement | import("@excalidraw/element/types").ExcalidrawImageElement | import("@excalidraw/element/types").ExcalidrawFrameElement | import("@excalidraw/element/types").ExcalidrawMagicFrameElement | import("@excalidraw/element/types").ExcalidrawTextElement | import("@excalidraw/element/types").ExcalidrawFreeDrawElement | null;
     getElementsFromId: (id: string) => ExcalidrawElement[];
+    mutateElement<TElement extends Mutable<ExcalidrawElement>>(element: TElement, updates: ElementUpdate<TElement>, options?: {
+        informMutation: boolean;
+        isDragging: boolean;
+    }): TElement;
 }
-export default Scene;
+export {};

package/types/element/src/align.d.ts

@@ -1,7 +1,8 @@
-import type Scene from "@excalidraw/excalidraw/scene/Scene";
-import type { ElementsMap, ExcalidrawElement } from "./types";
+import type { AppState } from "@excalidraw/excalidraw/types";
+import type { Scene } from "./Scene";
+import type { ExcalidrawElement } from "./types";
 export interface Alignment {
     position: "start" | "center" | "end";
     axis: "x" | "y";
 }
-export declare const alignElements: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, alignment: Alignment, scene: Scene) => ExcalidrawElement[];
+export declare const alignElements: (selectedElements: ExcalidrawElement[], alignment: Alignment, scene: Scene, appState: Readonly<AppState>) => ExcalidrawElement[];

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

@@ -1,59 +1,80 @@
 import { type GlobalPoint } from "@excalidraw/math";
-import type { LocalPoint } from "@excalidraw/math";
-import type Scene from "@excalidraw/excalidraw/scene/Scene";
+import type { LineSegment, LocalPoint } from "@excalidraw/math";
 import type { AppState } from "@excalidraw/excalidraw/types";
 import { type Heading } from "./heading";
+import type { Scene } from "./Scene";
 import type { Bounds } from "./bounds";
 import type { ElementUpdate } from "./mutateElement";
-import type { ExcalidrawBindableElement, ExcalidrawElement, NonDeleted, ExcalidrawLinearElement, NonDeletedExcalidrawElement, ElementsMap, NonDeletedSceneElementsMap, OrderedExcalidrawElement, ExcalidrawElbowArrowElement, FixedPoint, SceneElementsMap } from "./types";
-export type SuggestedBinding = NonDeleted<ExcalidrawBindableElement> | SuggestedPointBinding;
-export type SuggestedPointBinding = [
-    NonDeleted<ExcalidrawLinearElement>,
-    "start" | "end" | "both",
-    NonDeleted<ExcalidrawBindableElement>
-];
+import type { BindMode, ElementsMap, ExcalidrawArrowElement, ExcalidrawBindableElement, ExcalidrawElbowArrowElement, ExcalidrawElement, FixedPoint, FixedPointBinding, NonDeleted, NonDeletedExcalidrawElement, NonDeletedSceneElementsMap, Ordered, PointsPositionUpdates } from "./types";
+export type BindingStrategy = {
+    mode: BindMode;
+    element: NonDeleted<ExcalidrawBindableElement>;
+    focusPoint: GlobalPoint;
+} | {
+    mode: null;
+    element?: undefined;
+    focusPoint?: undefined;
+} | {
+    mode: undefined;
+    element?: undefined;
+    focusPoint?: undefined;
+};
+/**
+ * gaps exclude element strokeWidth
+ *
+ * IMPORTANT: currently must be > 0 (this also applies to the computed gap)
+ */
+export declare const BASE_BINDING_GAP = 10;
+export declare const BASE_BINDING_GAP_ELBOW = 5;
+export declare const getBindingGap: (bindTarget: ExcalidrawBindableElement, opts: Pick<ExcalidrawArrowElement, "elbowed">) => number;
+export declare const maxBindingDistance_simple: (zoom?: AppState["zoom"]) => number;
 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, 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;
-}, elementsMap: NonDeletedSceneElementsMap, elements: readonly NonDeletedExcalidrawElement[]) => void;
-export declare const bindLinearElement: (linearElement: NonDeleted<ExcalidrawLinearElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: NonDeletedSceneElementsMap) => void;
-export declare const isLinearElementSimpleAndAlreadyBound: (linearElement: NonDeleted<ExcalidrawLinearElement>, alreadyBoundToId: ExcalidrawBindableElement["id"] | undefined, bindableElement: ExcalidrawBindableElement) => boolean;
-export declare const getHoveredElementForBinding: (pointerCoords: {
-    x: number;
-    y: number;
-}, elements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap, zoom?: AppState["zoom"], fullShape?: boolean, considerAllElements?: boolean) => NonDeleted<ExcalidrawBindableElement> | null;
-export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, options?: {
+export declare const bindOrUnbindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, scene: Scene, appState: AppState, opts?: {
+    newArrow?: boolean;
+    altKey?: boolean;
+    initialBinding?: boolean;
+}) => {
+    start: BindingStrategy;
+    end: BindingStrategy;
+};
+export declare const getBindingStrategyForDraggingBindingElementEndpoints: (arrow: NonDeleted<ExcalidrawArrowElement>, draggingPoints: PointsPositionUpdates, elementsMap: NonDeletedSceneElementsMap, elements: readonly Ordered<NonDeletedExcalidrawElement>[], appState: AppState, opts?: {
+    newArrow?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    finalize?: boolean;
+    initialBinding?: boolean;
+    zoom?: AppState["zoom"];
+}) => {
+    start: BindingStrategy;
+    end: BindingStrategy;
+};
+export declare const bindOrUnbindBindingElements: (selectedArrows: NonDeleted<ExcalidrawArrowElement>[], scene: Scene, appState: AppState) => void;
+export declare const bindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, hoveredElement: ExcalidrawBindableElement, mode: BindMode, startOrEnd: "start" | "end", scene: Scene, focusPoint?: GlobalPoint) => void;
+export declare const unbindBindingElement: (arrow: NonDeleted<ExcalidrawArrowElement>, startOrEnd: "start" | "end", scene: Scene) => ExcalidrawBindableElement["id"] | null;
+export declare const updateBoundElements: (changedElement: NonDeletedExcalidrawElement, scene: Scene, options?: {
+    simultaneouslyUpdated?: readonly ExcalidrawElement[];
+    changedElements?: Map<string, ExcalidrawElement>;
+}) => void;
+export declare const updateBindings: (latestElement: ExcalidrawElement, scene: Scene, appState: AppState, options?: {
     simultaneouslyUpdated?: readonly ExcalidrawElement[];
     newSize?: {
         width: number;
         height: number;
     };
-    changedElements?: Map<string, OrderedExcalidrawElement>;
 }) => void;
-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: (arrow: ExcalidrawElbowArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end") => GlobalPoint;
-export declare const avoidRectangularCorner: (element: ExcalidrawBindableElement, p: GlobalPoint) => GlobalPoint;
-export declare const snapToMid: (element: ExcalidrawBindableElement, p: GlobalPoint, tolerance?: number) => GlobalPoint;
+export declare const getHeadingForElbowArrowSnap: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined | null, aabb: Bounds | undefined | null, origPoint: GlobalPoint, elementsMap: ElementsMap, zoom?: AppState["zoom"]) => Heading;
+export declare const bindPointToSnapToElementOutline: (arrowElement: ExcalidrawArrowElement, bindableElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, customIntersector?: LineSegment<GlobalPoint>) => GlobalPoint;
+export declare const avoidRectangularCorner: (arrowElement: ExcalidrawArrowElement, bindTarget: ExcalidrawBindableElement, elementsMap: ElementsMap, p: GlobalPoint) => GlobalPoint;
+export declare const updateBoundPoint: (arrow: NonDeleted<ExcalidrawArrowElement>, startOrEnd: "startBinding" | "endBinding", binding: FixedPointBinding | null | undefined, bindableElement: ExcalidrawBindableElement, elementsMap: ElementsMap, customIntersector?: LineSegment<GlobalPoint>) => LocalPoint | null;
 export declare const calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => {
     fixedPoint: FixedPoint;
 };
-export declare const fixDuplicatedBindingsAfterDuplication: (newElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicatedElementsMap: NonDeletedSceneElementsMap) => void;
-export declare const fixReversedBindings: (originalElements: Map<string, ExcalidrawElement>, elementsWithClones: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+export declare const calculateFixedPointForNonElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap, focusPoint?: GlobalPoint) => {
+    fixedPoint: FixedPoint;
+};
+export declare const fixDuplicatedBindingsAfterDuplication: (duplicatedElements: ExcalidrawElement[], origIdToDuplicateId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicateElementsMap: NonDeletedSceneElementsMap) => void;
 export declare const fixBindingsAfterDeletion: (sceneElements: readonly ExcalidrawElement[], deletedElements: readonly ExcalidrawElement[]) => void;
-export declare const bindingBorderTest: (element: NonDeleted<ExcalidrawBindableElement>, { x, y }: {
-    x: number;
-    y: 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 determineFocusDistance: (element: ExcalidrawBindableElement, a: GlobalPoint, b: GlobalPoint) => number;
 export declare const bindingProperties: Set<BindableProp | BindingProp>;
 export type BindableProp = "boundElements";
 export type BindingProp = "frameId" | "containerId" | "startBinding" | "endBinding";
@@ -95,7 +116,7 @@ export declare class BindableElement {
      */
     static rebindAffected: (elements: ElementsMap, bindableElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void) => void;
 }
-export declare const getGlobalFixedPointForBindableElement: (fixedPointRatio: [number, number], element: ExcalidrawBindableElement) => GlobalPoint;
-export declare const getGlobalFixedPoints: (arrow: ExcalidrawElbowArrowElement, elementsMap: ElementsMap) => [GlobalPoint, GlobalPoint];
+export declare const getGlobalFixedPointForBindableElement: (fixedPointRatio: FixedPoint, element: ExcalidrawBindableElement, elementsMap: ElementsMap) => GlobalPoint;
+export declare const getGlobalFixedPoints: (arrow: ExcalidrawArrowElement, elementsMap: ElementsMap) => [GlobalPoint, GlobalPoint];
 export declare const getArrowLocalFixedPoints: (arrow: ExcalidrawElbowArrowElement, elementsMap: ElementsMap) => LocalPoint[];
 export declare const normalizeFixedPoint: <T extends FixedPoint | null>(fixedPoint: T) => T extends null ? null : FixedPoint;