@zsviczian/excalidraw 0.17.6-26 → 0.17.6-28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zsviczian/excalidraw",
-  "version": "0.17.6-26",
+  "version": "0.17.6-28",
   "main": "main.js",
   "types": "types/excalidraw/index.d.ts",
   "files": [
@@ -58,7 +58,8 @@
     "fractional-indexing": "3.2.0",
     "fuzzy": "0.1.3",
     "image-blob-reduce": "3.0.1",
-    "jotai": "1.13.1",
+    "jotai": "2.11.0",
+    "jotai-scope": "0.7.2",
     "lodash.throttle": "4.1.1",
     "nanoid": "3.3.3",
     "open-color": "1.9.1",
@@ -104,6 +105,7 @@
     "fonteditor-core": "2.4.1",
     "harfbuzzjs": "0.3.6",
     "import-meta-loader": "1.1.0",
+    "jest-diff": "29.7.0",
     "mini-css-extract-plugin": "2.6.1",
     "postcss-loader": "7.0.1",
     "sass-loader": "13.0.2",

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

@@ -1,4 +1,4 @@
-export declare const activeConfirmDialogAtom: import("jotai").PrimitiveAtom<"clearCanvas" | null> & {
+export declare const activeConfirmDialogAtom: import("jotai/vanilla/atom").PrimitiveAtom<"clearCanvas" | null> & {
     init: "clearCanvas" | null;
 };
 export declare const ActiveConfirmDialog: () => JSX.Element | null;

package/types/excalidraw/components/ColorPicker/colorPickerUtils.d.ts

@@ -14,7 +14,7 @@ export declare const isCustomColor: ({ color, palette, }: {
 }) => boolean;
 export declare const getMostUsedCustomColors: (elements: readonly ExcalidrawElement[], type: "elementBackground" | "elementStroke", palette: ColorPaletteCustom) => string[];
 export type ActiveColorPickerSectionAtomType = "custom" | "baseColors" | "shades" | "hex" | null;
-export declare const activeColorPickerSectionAtom: import("jotai").PrimitiveAtom<ActiveColorPickerSectionAtomType> & {
+export declare const activeColorPickerSectionAtom: import("jotai/vanilla/atom").PrimitiveAtom<ActiveColorPickerSectionAtomType> & {
     init: ActiveColorPickerSectionAtomType;
 };
 export declare const getContrastYIQ: (bgHex: string, isCustomColor: boolean) => "white" | "black";

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

@@ -13,7 +13,7 @@ export type EyeDropperProperties = {
      **/
     colorPickerType: ColorPickerType;
 };
-export declare const activeEyeDropperAtom: import("jotai").PrimitiveAtom<EyeDropperProperties | null> & {
+export declare const activeEyeDropperAtom: import("jotai/vanilla/atom").PrimitiveAtom<EyeDropperProperties | null> & {
     init: EyeDropperProperties | null;
 };
 export declare const EyeDropper: React.FC<{

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

@@ -2,7 +2,7 @@ import React from "react";
 import type Library from "../data/library";
 import type { LibraryItems, LibraryItem, ExcalidrawProps, UIAppState } from "../types";
 import "./LibraryMenu.scss";
-export declare const isLibraryMenuOpenAtom: import("jotai").PrimitiveAtom<boolean> & {
+export declare const isLibraryMenuOpenAtom: import("jotai/vanilla/atom").PrimitiveAtom<boolean> & {
     init: boolean;
 };
 export declare const LibraryMenuContent: ({ onInsertLibraryItems, pendingElements, onAddToLibrary, setAppState, libraryReturnUrl, library, id, theme, selectedItems, onSelectItems, }: {

package/types/excalidraw/components/OverwriteConfirm/OverwriteConfirmState.d.ts

@@ -11,7 +11,7 @@ export type OverwriteConfirmState = {
 } | {
     active: false;
 };
-export declare const overwriteConfirmStateAtom: import("jotai").PrimitiveAtom<OverwriteConfirmState> & {
+export declare const overwriteConfirmStateAtom: import("jotai/vanilla/atom").PrimitiveAtom<OverwriteConfirmState> & {
     init: OverwriteConfirmState;
 };
 export declare function openConfirmModal({ title, description, actionLabel, color, }: {

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

@@ -1,5 +1,5 @@
 import "./SearchMenu.scss";
-export declare const searchItemInFocusAtom: import("jotai").PrimitiveAtom<number | null> & {
+export declare const searchItemInFocusAtom: import("jotai/vanilla/atom").PrimitiveAtom<number | null> & {
     init: number | null;
 };
 export declare const SearchMenu: () => JSX.Element;

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

@@ -8,7 +8,7 @@ import "./Sidebar.scss";
  *
  * Since we can only render one Sidebar at a time, we can use a simple flag.
  */
-export declare const isSidebarDockedAtom: import("jotai").PrimitiveAtom<boolean> & {
+export declare const isSidebarDockedAtom: import("jotai/vanilla/atom").PrimitiveAtom<boolean> & {
     init: boolean;
 };
 export declare const SidebarInner: React.ForwardRefExoticComponent<Omit<{

package/types/excalidraw/context/tunnels.d.ts

@@ -1,5 +1,6 @@
 import React from "react";
 import tunnel from "tunnel-rat";
+import { createIsolation } from "jotai-scope";
 export type Tunnel = ReturnType<typeof tunnel>;
 type TunnelsContextValue = {
     MainMenuTunnel: Tunnel;
@@ -12,7 +13,7 @@ type TunnelsContextValue = {
     DefaultSidebarTabTriggersTunnel: Tunnel;
     OverwriteConfirmDialogTunnel: Tunnel;
     TTDDialogTriggerTunnel: Tunnel;
-    jotaiScope: symbol;
+    tunnelsJotai: ReturnType<typeof createIsolation>;
 };
 export declare const TunnelsContext: React.Context<TunnelsContextValue>;
 export declare const useTunnels: () => TunnelsContextValue;

package/types/excalidraw/data/library.d.ts

@@ -37,7 +37,7 @@ export interface LibraryMigrationAdapter {
     /** clears entire storage afterwards */
     clear(): MaybePromise<void>;
 }
-export declare const libraryItemsAtom: import("jotai").PrimitiveAtom<{
+export declare const libraryItemsAtom: import("jotai/vanilla/atom").PrimitiveAtom<{
     status: "loading" | "loaded";
     /** indicates whether library is initialized with library items (has gone
      * through at least one update). Used in UI. Specific to this atom only. */
@@ -83,7 +83,7 @@ declare class Library {
 }
 export default Library;
 export declare const distributeLibraryItemsOnSquareGrid: (libraryItems: LibraryItems) => ExcalidrawElement[];
-declare const validateLibraryUrl: (libraryUrl: string, validator?: ((libraryUrl: string) => boolean) | undefined) => boolean;
+export declare const validateLibraryUrl: (libraryUrl: string, validator?: string[] | ((libraryUrl: string) => boolean)) => true;
 export declare const parseLibraryTokensFromUrl: () => {
     libraryUrl: string;
     idToken: string | null;

package/types/excalidraw/editor-jotai.d.ts

@@ -0,0 +1,56 @@
+import { atom, createStore, type PrimitiveAtom } from "jotai";
+import { createIsolation } from "jotai-scope";
+export { atom, PrimitiveAtom };
+export declare const useAtom: typeof import("jotai").useAtom, useSetAtom: typeof import("jotai").useSetAtom, useAtomValue: typeof import("jotai").useAtomValue, useStore: (options?: {
+    store?: {
+        get: <Value>(atom: import("jotai").Atom<Value>) => Value;
+        set: <Value_1, Args extends unknown[], Result>(atom: import("jotai").WritableAtom<Value_1, Args, Result>, ...args: Args) => Result;
+        sub: (atom: import("jotai").Atom<unknown>, listener: () => void) => () => void;
+    } | ({
+        get: <Value_2>(atom: import("jotai").Atom<Value_2>) => Value_2;
+        set: <Value_1_1, Args_1 extends unknown[], Result_1>(atom: import("jotai").WritableAtom<Value_1_1, Args_1, Result_1>, ...args: Args_1) => Result_1;
+        sub: (atom: import("jotai").Atom<unknown>, listener: () => void) => () => void;
+    } & {
+        dev4_get_internal_weak_map: () => WeakMap<import("jotai").Atom<unknown>, {
+            readonly d: Map<import("jotai").Atom<unknown>, number>;
+            readonly p: Set<import("jotai").Atom<unknown>>;
+            n: number;
+            m?: {
+                readonly l: Set<() => void>;
+                readonly d: Set<import("jotai").Atom<unknown>>;
+                readonly t: Set<import("jotai").Atom<unknown>>;
+                u?: (() => void) | undefined;
+            } | undefined;
+            v?: unknown;
+            e?: unknown;
+        }>;
+        dev4_get_mounted_atoms: () => Set<import("jotai").Atom<unknown>>;
+        dev4_restore_atoms: (values: Iterable<readonly [import("jotai").Atom<unknown>, unknown]>) => void;
+    }) | undefined;
+} | undefined) => {
+    get: <Value_3>(atom: import("jotai").Atom<Value_3>) => Value_3;
+    set: <Value_1_2, Args_2 extends unknown[], Result_2>(atom: import("jotai").WritableAtom<Value_1_2, Args_2, Result_2>, ...args: Args_2) => Result_2;
+    sub: (atom: import("jotai").Atom<unknown>, listener: () => void) => () => void;
+} | ({
+    get: <Value_4>(atom: import("jotai").Atom<Value_4>) => Value_4;
+    set: <Value_1_3, Args_3 extends unknown[], Result_3>(atom: import("jotai").WritableAtom<Value_1_3, Args_3, Result_3>, ...args: Args_3) => Result_3;
+    sub: (atom: import("jotai").Atom<unknown>, listener: () => void) => () => void;
+} & {
+    dev4_get_internal_weak_map: () => WeakMap<import("jotai").Atom<unknown>, {
+        readonly d: Map<import("jotai").Atom<unknown>, number>;
+        readonly p: Set<import("jotai").Atom<unknown>>;
+        n: number;
+        m?: {
+            readonly l: Set<() => void>;
+            readonly d: Set<import("jotai").Atom<unknown>>;
+            readonly t: Set<import("jotai").Atom<unknown>>;
+            u?: (() => void) | undefined;
+        } | undefined;
+        v?: unknown;
+        e?: unknown;
+    }>;
+    dev4_get_mounted_atoms: () => Set<import("jotai").Atom<unknown>>;
+    dev4_restore_atoms: (values: Iterable<readonly [import("jotai").Atom<unknown>, unknown]>) => void;
+});
+export declare const EditorJotaiProvider: ReturnType<typeof createIsolation>["Provider"];
+export declare const editorJotaiStore: ReturnType<typeof createStore>;

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

@@ -37,7 +37,6 @@ 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, zoom?: AppState["zoom"]) => Heading;
 export declare const bindPointToSnapToElementOutline: (p: Readonly<GlobalPoint>, otherPoint: Readonly<GlobalPoint>, bindableElement: ExcalidrawBindableElement | undefined, elementsMap: ElementsMap) => GlobalPoint;
@@ -98,5 +97,6 @@ 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 getArrowLocalFixedPoints: (arrow: ExcalidrawElbowArrowElement, elementsMap: ElementsMap) => LocalPoint[];
 export declare const normalizeFixedPoint: <T extends FixedPoint | null>(fixedPoint: T) => T extends null ? null : FixedPoint;

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

@@ -0,0 +1,14 @@
+import { type LocalPoint } from "../../math";
+import { type ElementUpdate } from "./mutateElement";
+import { type ExcalidrawElbowArrowElement, type NonDeletedSceneElementsMap, type SceneElementsMap } from "./types";
+import type { FixedSegment } from "./types";
+export declare const BASE_PADDING = 40;
+/**
+ *
+ */
+export declare const updateElbowArrowPoints: (arrow: Readonly<ExcalidrawElbowArrowElement>, elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, updates: {
+    points?: readonly LocalPoint[];
+    fixedSegments?: FixedSegment[] | null;
+}, options?: {
+    isDragging?: boolean;
+}) => ElementUpdate<ExcalidrawElbowArrowElement>;

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

@@ -7,6 +7,10 @@ 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 headingForPointFromElement: <Point extends GlobalPoint | LocalPoint>(element: Readonly<ExcalidrawBindableElement>, aabb: readonly [minX: number, minY: number, maxX: number, maxY: number], p: Readonly<LocalPoint | GlobalPoint>) => Heading;
+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;

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

@@ -1,6 +1,6 @@
-import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, OrderedExcalidrawElement, SceneElementsMap } from "./types";
+import type { NonDeleted, ExcalidrawLinearElement, ExcalidrawElement, PointBinding, ExcalidrawBindableElement, ExcalidrawTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, SceneElementsMap, ExcalidrawElbowArrowElement } from "./types";
 import type { Bounds } from "./bounds";
-import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize } from "../types";
+import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize, Zoom } from "../types";
 import type { Store } from "../store";
 import type Scene from "../scene/Scene";
 import { type GlobalPoint, type LocalPoint } from "../../math";
@@ -48,7 +48,7 @@ export declare class LinearElementEditor {
      * @param id the `elementId` from the instance of this class (so that we can
      *  statically guarantee this method returns an ExcalidrawLinearElement)
      */
-    static getElement(id: InstanceType<typeof LinearElementEditor>["elementId"], elementsMap: ElementsMap): NonDeleted<ExcalidrawLinearElement> | null;
+    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: {
@@ -62,7 +62,7 @@ export declare class LinearElementEditor {
         x: number;
         y: number;
     }, appState: AppState, elementsMap: ElementsMap) => GlobalPoint | null;
-    static isSegmentTooShort(element: NonDeleted<ExcalidrawLinearElement>, startPoint: GlobalPoint | LocalPoint, endPoint: GlobalPoint | LocalPoint, zoom: AppState["zoom"]): boolean;
+    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: {
@@ -96,21 +96,17 @@ 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, zoom: AppState["zoom"]): void;
+    static deletePoints(element: NonDeleted<ExcalidrawLinearElement>, pointIndices: readonly number[]): void;
     static addPoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
         point: LocalPoint;
-    }[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, zoom: AppState["zoom"]): void;
+    }[]): void;
     static movePoints(element: NonDeleted<ExcalidrawLinearElement>, targetPoints: {
         index: number;
         point: LocalPoint;
         isDragging?: boolean;
-    }[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, otherUpdates?: {
+    }[], otherUpdates?: {
         startBinding?: PointBinding | null;
         endBinding?: PointBinding | null;
-    }, 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): {
@@ -125,5 +121,7 @@ export declare class LinearElementEditor {
     };
     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/mutateElement.d.ts

@@ -1,7 +1,9 @@
 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) => TElement;
+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`.

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

@@ -1,4 +1,4 @@
-import type { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap, ExcalidrawArrowElement } from "./types";
+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">;
@@ -46,13 +46,14 @@ export declare const newLinearElement: (opts: {
     type: ExcalidrawLinearElement["type"];
     points?: ExcalidrawLinearElement["points"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawLinearElement>;
-export declare const newArrowElement: (opts: {
+export declare const newArrowElement: <T extends boolean>(opts: {
     type: ExcalidrawArrowElement["type"];
-    startArrowhead?: Arrowhead | null;
-    endArrowhead?: Arrowhead | null;
-    points?: ExcalidrawArrowElement["points"];
-    elbowed?: boolean;
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawArrowElement>;
+    startArrowhead?: Arrowhead | null | undefined;
+    endArrowhead?: Arrowhead | null | undefined;
+    points?: readonly import("../../math").LocalPoint[] | undefined;
+    elbowed?: T | undefined;
+    fixedSegments?: FixedSegment[] | null | undefined;
+} & Omit<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "angle" | "link" | "width" | "height" | "backgroundColor" | "strokeColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData"> & Partial<Pick<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "angle" | "link" | "width" | "height" | "backgroundColor" | "strokeColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "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"];

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

@@ -27,13 +27,12 @@ export declare const getNextSingleWidthAndHeightFromPointer: (latestElement: Exc
     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, }?: {
+export declare const resizeMultipleElements: (selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, handleDirection: TransformHandleDirection, scene: Scene, originalElementsMap: ElementsMap, { shouldMaintainAspectRatio, shouldResizeFromCenter, flipByX, flipByY, nextHeight, nextWidth, 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/types.d.ts

@@ -218,6 +218,11 @@ export type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<{
     startArrowhead: Arrowhead | null;
     endArrowhead: Arrowhead | null;
 }>;
+export type FixedSegment = {
+    start: LocalPoint;
+    end: LocalPoint;
+    index: number;
+};
 export type ExcalidrawArrowElement = ExcalidrawLinearElement & Readonly<{
     type: "arrow";
     elbowed: boolean;
@@ -226,6 +231,23 @@ export type ExcalidrawElbowArrowElement = Merge<ExcalidrawArrowElement, {
     elbowed: true;
     startBinding: FixedPointBinding | null;
     endBinding: FixedPointBinding | null;
+    fixedSegments: FixedSegment[] | null;
+    /**
+     * Marks that the 3rd point should be used as the 2nd point of the arrow in
+     * order to temporarily hide the first segment of the arrow without losing
+     * the data from the points array. It allows creating the expected arrow
+     * path when the arrow with fixed segments is bound on a horizontal side and
+     * moved to a vertical and vica versa.
+     */
+    startIsSpecial: boolean | null;
+    /**
+     * Marks that the 3rd point backwards from the end should be used as the 2nd
+     * point of the arrow in order to temporarily hide the last segment of the
+     * arrow without losing the data from the points array. It allows creating
+     * the expected arrow path when the arrow with fixed segments is bound on a
+     * horizontal side and moved to a vertical and vica versa.
+     */
+    endIsSpecial: boolean | null;
 }>;
 export type ExcalidrawFreeDrawElement = _ExcalidrawElementBase & Readonly<{
     type: "freedraw";

package/types/excalidraw/frame.d.ts

@@ -5,7 +5,7 @@ import type { ReadonlySetLike } from "./utility-types";
 export declare const bindElementsToFramesAfterDuplication: (nextElements: readonly ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
 export declare function isElementIntersectingFrame(element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap): boolean;
 export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
-export declare const isElementContainingFrame: (elements: readonly ExcalidrawElement[], element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
+export declare const isElementContainingFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
 export declare const getElementsIntersectingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
 export declare const elementsAreInFrameBounds: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
 export declare const elementOverlapsWithFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
@@ -31,7 +31,8 @@ export declare const getFrameLikeElements: (allElements: ExcalidrawElementsInclu
  */
 export declare const getRootElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawElement[];
 export declare const getElementsInResizingFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, appState: AppState, elementsMap: ElementsMap) => ExcalidrawElement[];
-export declare const getElementsInNewFrame: (elements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
+export declare const getElementsInNewFrame: (elements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => (import("./element/types").ExcalidrawSelectionElement | import("./element/types").ExcalidrawRectangleElement | import("./element/types").ExcalidrawDiamondElement | import("./element/types").ExcalidrawEllipseElement | import("./element/types").ExcalidrawTextElement | import("./element/types").ExcalidrawLinearElement | import("./element/types").ExcalidrawFreeDrawElement | import("./element/types").ExcalidrawImageElement | import("./element/types").ExcalidrawFrameElement | import("./element/types").ExcalidrawMagicFrameElement | import("./element/types").ExcalidrawIframeElement | import("./element/types").ExcalidrawEmbeddableElement)[];
+export declare const omitPartialGroups: (elements: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, allElementsMap: ElementsMap) => (import("./element/types").ExcalidrawSelectionElement | import("./element/types").ExcalidrawRectangleElement | import("./element/types").ExcalidrawDiamondElement | import("./element/types").ExcalidrawEllipseElement | import("./element/types").ExcalidrawTextElement | import("./element/types").ExcalidrawLinearElement | import("./element/types").ExcalidrawFreeDrawElement | import("./element/types").ExcalidrawImageElement | import("./element/types").ExcalidrawFrameElement | import("./element/types").ExcalidrawMagicFrameElement | import("./element/types").ExcalidrawIframeElement | import("./element/types").ExcalidrawEmbeddableElement)[];
 export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap: ElementsMap) => ExcalidrawFrameLikeElement | null;
 /** */
 export declare const filterElementsEligibleAsFrameChildren: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
@@ -58,6 +59,10 @@ export declare const omitGroupsContainingFrameLikes: (allElements: ElementsMapOr
  * is going to be added to or remove from
  */
 export declare const getTargetFrame: (element: ExcalidrawElement, elementsMap: ElementsMap, appState: StaticCanvasAppState) => import("./element/types").ExcalidrawFrameElement | import("./element/types").ExcalidrawMagicFrameElement | null;
-export declare const isElementInFrame: (element: ExcalidrawElement, allElementsMap: ElementsMap, appState: StaticCanvasAppState) => boolean;
+export declare const isElementInFrame: (element: ExcalidrawElement, allElementsMap: ElementsMap, appState: StaticCanvasAppState, opts?: {
+    targetFrame?: ExcalidrawFrameLikeElement;
+    checkedGroups?: Map<string, boolean>;
+}) => boolean;
+export declare const shouldApplyFrameClip: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, appState: StaticCanvasAppState, elementsMap: ElementsMap, checkedGroups?: Map<string, boolean>) => boolean;
 export declare const getFrameLikeTitle: (element: ExcalidrawFrameLikeElement) => string;
 export declare const getElementsOverlappingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => NonDeletedExcalidrawElement[];

package/types/excalidraw/hooks/useLibraryItemSvg.d.ts

@@ -1,6 +1,6 @@
 import type { LibraryItem } from "../types";
 export type SvgCache = Map<LibraryItem["id"], SVGSVGElement>;
-export declare const libraryItemSvgsCache: import("jotai").PrimitiveAtom<SvgCache> & {
+export declare const libraryItemSvgsCache: import("jotai/vanilla/atom").PrimitiveAtom<SvgCache> & {
     init: SvgCache;
 };
 export declare const useLibraryItemSvg: (id: LibraryItem["id"] | null, elements: LibraryItem["elements"] | undefined, svgCache: SvgCache) => SVGSVGElement | undefined;

package/types/excalidraw/visualdebug.d.ts

@@ -1,4 +1,4 @@
-import { type GlobalPoint } from "../math";
+import { type GlobalPoint, type LocalPoint } from "../math";
 import type { LineSegment } from "../utils";
 import type { BoundingBox, Bounds } from "./element/bounds";
 declare global {
@@ -7,6 +7,8 @@ declare global {
             data: DebugElement[][];
             currentFrame?: number;
         };
+        debugDrawPoint: typeof debugDrawPoint;
+        debugDrawLine: typeof debugDrawLine;
     }
 }
 export type DebugElement = {
@@ -31,5 +33,10 @@ export declare const debugDrawBounds: (box: Bounds | Bounds[], opts?: {
     color?: string;
     permanent?: boolean;
 }) => void;
+export declare const debugDrawPoints: ({ x, y, points, }: {
+    x: number;
+    y: number;
+    points: LocalPoint[];
+}, options?: any) => void;
 export declare const debugCloseFrame: () => void;
 export declare const debugClear: () => void;

package/types/math/line.d.ts

@@ -23,4 +23,23 @@ export declare function lineFromPointPair<P extends GlobalPoint | LocalPoint>([a
  * @returns
  */
 export declare function lineFromPointArray<P extends GlobalPoint | LocalPoint>(pointArray: P[]): Line<P> | undefined;
+/**
+ * Return the coordinates resulting from rotating the given line about an
+ * origin by an angle in degrees note that when the origin is not given,
+ * the midpoint of the given line is used as the origin
+ *
+ * @param l
+ * @param angle
+ * @param origin
+ * @returns
+ */
 export declare const lineRotate: <Point extends GlobalPoint | LocalPoint>(l: Line<Point>, angle: Radians, origin?: Point | undefined) => Line<Point>;
+/**
+ * Determines the intersection point (unless the lines are parallel) of two
+ * lines
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare const linesIntersectAt: <Point extends GlobalPoint | LocalPoint>(a: Line<Point>, b: Line<Point>) => Point | null;

package/types/math/point.d.ts

@@ -28,6 +28,16 @@ export declare function pointFromPair<Point extends GlobalPoint | LocalPoint>(pa
  * @returns The point the vector points at with origin 0,0
  */
 export declare function pointFromVector<P extends GlobalPoint | LocalPoint>(v: Vector): P;
+/**
+ * Convert the coordiante object to a point.
+ *
+ * @param coords The coordinate object with x and y properties
+ * @returns
+ */
+export declare function pointFromCoords<Point extends GlobalPoint | LocalPoint>({ x, y, }: {
+    x: number;
+    y: number;
+}): Point;
 /**
  * Checks if the provided value has the shape of a Point.
  *