@zsviczian/excalidraw 0.18.0-3 → 0.18.0-5

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

@@ -1,25 +1,25 @@
-import type { ExcalidrawElement } from "../element/types";
-import type { AppState, EmbedsValidationStatus } from "../types";
-import type { ElementShape, ElementShapes } from "./types";
-import type { Drawable } from "roughjs/bin/core";
-export declare class ShapeCache {
-    private static rg;
-    private static cache;
-    /**
-     * Retrieves shape from cache if available. Use this only if shape
-     * is optional and you have a fallback in case it's not cached.
-     */
-    static get: <T extends ExcalidrawElement>(element: T) => T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined;
-    static set: <T extends ExcalidrawElement>(element: T, shape: T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable) => WeakMap<ExcalidrawElement, ElementShape>;
-    static delete: (element: ExcalidrawElement) => boolean;
-    static destroy: () => void;
-    /**
-     * Generates & caches shape for element if not already cached, otherwise
-     * returns cached shape.
-     */
-    static generateElementShape: <T extends import("../element/types").ExcalidrawLinearElement | import("../element/types").ExcalidrawRectangleElement | import("../element/types").ExcalidrawDiamondElement | import("../element/types").ExcalidrawEllipseElement | import("../element/types").ExcalidrawEmbeddableElement | import("../element/types").ExcalidrawIframeElement | import("../element/types").ExcalidrawImageElement | import("../element/types").ExcalidrawFrameElement | import("../element/types").ExcalidrawMagicFrameElement | import("../element/types").ExcalidrawTextElement | import("../element/types").ExcalidrawFreeDrawElement | import("../element/types").ExcalidrawArrowElement>(element: T, renderConfig: {
-        isExporting: boolean;
-        canvasBackgroundColor: AppState["viewBackgroundColor"];
-        embedsValidationStatus: EmbedsValidationStatus;
-    } | null) => ((T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined) & ({} | null)) | (T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable | null);
-}
+import type { AppState, EmbedsValidationStatus } from "@excalidraw/excalidraw/types";
+import type { ElementShape, ElementShapes } from "@excalidraw/excalidraw/scene/types";
+import type { ExcalidrawElement } from "./types";
+import type { Drawable } from "roughjs/bin/core";
+export declare class ShapeCache {
+    private static rg;
+    private static cache;
+    /**
+     * Retrieves shape from cache if available. Use this only if shape
+     * is optional and you have a fallback in case it's not cached.
+     */
+    static get: <T extends ExcalidrawElement>(element: T) => T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined;
+    static set: <T extends ExcalidrawElement>(element: T, shape: T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable) => WeakMap<ExcalidrawElement, ElementShape>;
+    static delete: (element: ExcalidrawElement) => boolean;
+    static destroy: () => void;
+    /**
+     * Generates & caches shape for element if not already cached, otherwise
+     * returns cached shape.
+     */
+    static generateElementShape: <T extends import("./types").ExcalidrawRectangleElement | import("./types").ExcalidrawDiamondElement | import("./types").ExcalidrawFrameElement | import("./types").ExcalidrawMagicFrameElement | import("./types").ExcalidrawEmbeddableElement | import("./types").ExcalidrawImageElement | import("./types").ExcalidrawIframeElement | import("./types").ExcalidrawTextElement | import("./types").ExcalidrawEllipseElement | import("./types").ExcalidrawLinearElement | import("./types").ExcalidrawArrowElement | import("./types").ExcalidrawFreeDrawElement>(element: T, renderConfig: {
+        isExporting: boolean;
+        canvasBackgroundColor: AppState["viewBackgroundColor"];
+        embedsValidationStatus: EmbedsValidationStatus;
+    } | null) => ((T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined) & ({} | null)) | (T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable | null);
+}

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

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

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

@@ -1,100 +1,101 @@
-import { type GlobalPoint } from "@excalidraw/math";
-import type { LocalPoint } from "@excalidraw/math";
-import { type Heading } from "./heading";
-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";
-import type Scene from "../scene/Scene";
-import type { AppState } from "../types";
-export type SuggestedBinding = NonDeleted<ExcalidrawBindableElement> | SuggestedPointBinding;
-export type SuggestedPointBinding = [
-    NonDeleted<ExcalidrawLinearElement>,
-    "start" | "end" | "both",
-    NonDeleted<ExcalidrawBindableElement>
-];
-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?: {
-    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 | undefined, 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 calculateFixedPointForElbowArrowBinding: (linearElement: NonDeleted<ExcalidrawElbowArrowElement>, hoveredElement: ExcalidrawBindableElement, startOrEnd: "start" | "end", elementsMap: ElementsMap) => {
-    fixedPoint: FixedPoint;
-};
-export declare const fixBindingsAfterDuplication: (sceneElements: readonly ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>, duplicatesServeAsOld?: "duplicatesServeAsOld" | undefined) => 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";
-/**
- * Bound element containing bindings to `frameId`, `containerId`, `startBinding` or `endBinding`.
- */
-export declare class BoundElement {
-    /**
-     * Unbind the affected non deleted bindable elements (removing element from `boundElements`).
-     * - iterates non deleted bindable elements (`containerId` | `startBinding.elementId` | `endBinding.elementId`) of the current element
-     * - prepares updates to unbind each bindable element's `boundElements` from the current element
-     */
-    static unbindAffected(elements: ElementsMap, boundElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void): void;
-    /**
-     * Rebind the next affected non deleted bindable elements (adding element to `boundElements`).
-     * - iterates non deleted bindable elements (`containerId` | `startBinding.elementId` | `endBinding.elementId`) of the current element
-     * - prepares updates to rebind each bindable element's `boundElements` to the current element
-     *
-     * NOTE: rebind expects that affected elements were previously unbound with `BoundElement.unbindAffected`
-     */
-    static rebindAffected: (elements: ElementsMap, boundElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void) => void;
-}
-/**
- * Bindable element containing bindings to `boundElements`.
- */
-export declare class BindableElement {
-    /**
-     * Unbind the affected non deleted bound elements (resetting `containerId`, `startBinding`, `endBinding` to `null`).
-     * - iterates through non deleted `boundElements` of the current element
-     * - prepares updates to unbind each bound element from the current element
-     */
-    static unbindAffected(elements: ElementsMap, bindableElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void): void;
-    /**
-     * Rebind the affected non deleted bound elements (for now setting only `containerId`, as we cannot rebind arrows atm).
-     * - iterates through non deleted `boundElements` of the current element
-     * - prepares updates to rebind each bound element to the current element or unbind it from `boundElements` in case of conflicts
-     *
-     * NOTE: rebind expects that affected elements were previously unbound with `BindaleElement.unbindAffected`
-     */
-    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;
+import { type GlobalPoint } from "@excalidraw/math";
+import type { LocalPoint } from "@excalidraw/math";
+import type Scene from "@excalidraw/excalidraw/scene/Scene";
+import type { AppState } from "@excalidraw/excalidraw/types";
+import { type Heading } from "./heading";
+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>
+];
+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?: {
+    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 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 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";
+/**
+ * Bound element containing bindings to `frameId`, `containerId`, `startBinding` or `endBinding`.
+ */
+export declare class BoundElement {
+    /**
+     * Unbind the affected non deleted bindable elements (removing element from `boundElements`).
+     * - iterates non deleted bindable elements (`containerId` | `startBinding.elementId` | `endBinding.elementId`) of the current element
+     * - prepares updates to unbind each bindable element's `boundElements` from the current element
+     */
+    static unbindAffected(elements: ElementsMap, boundElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void): void;
+    /**
+     * Rebind the next affected non deleted bindable elements (adding element to `boundElements`).
+     * - iterates non deleted bindable elements (`containerId` | `startBinding.elementId` | `endBinding.elementId`) of the current element
+     * - prepares updates to rebind each bindable element's `boundElements` to the current element
+     *
+     * NOTE: rebind expects that affected elements were previously unbound with `BoundElement.unbindAffected`
+     */
+    static rebindAffected: (elements: ElementsMap, boundElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void) => void;
+}
+/**
+ * Bindable element containing bindings to `boundElements`.
+ */
+export declare class BindableElement {
+    /**
+     * Unbind the affected non deleted bound elements (resetting `containerId`, `startBinding`, `endBinding` to `null`).
+     * - iterates through non deleted `boundElements` of the current element
+     * - prepares updates to unbind each bound element from the current element
+     */
+    static unbindAffected(elements: ElementsMap, bindableElement: ExcalidrawElement | undefined, updateElementWith: (affected: ExcalidrawElement, updates: ElementUpdate<ExcalidrawElement>) => void): void;
+    /**
+     * Rebind the affected non deleted bound elements (for now setting only `containerId`, as we cannot rebind arrows atm).
+     * - iterates through non deleted `boundElements` of the current element
+     * - prepares updates to rebind each bound element to the current element or unbind it from `boundElements` in case of conflicts
+     *
+     * NOTE: rebind expects that affected elements were previously unbound with `BindaleElement.unbindAffected`
+     */
+    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 → element/src}/bounds.d.ts

@@ -1,76 +1,81 @@
-import type { Degrees, GlobalPoint, LineSegment } from "@excalidraw/math";
-import type { AppState } from "../types";
-import type { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, ExcalidrawFreeDrawElement, NonDeleted, ElementsMap } from "./types";
-import type { Drawable, Op } from "roughjs/bin/core";
-export type RectangleBox = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    angle: number;
-};
-/**
- * x and y position of top left corner, x and y position of bottom right corner
- */
-export type Bounds = readonly [
-    minX: number,
-    minY: number,
-    maxX: number,
-    maxY: number
-];
-export type SceneBounds = readonly [
-    sceneX: number,
-    sceneY: number,
-    sceneX2: number,
-    sceneY2: number
-];
-export declare class ElementBounds {
-    private static boundsCache;
-    static getBounds(element: ExcalidrawElement, elementsMap: ElementsMap): Bounds;
-    private static calculateBounds;
-}
-export declare const getElementAbsoluteCoords: (element: ExcalidrawElement, elementsMap: ElementsMap, includeBoundText?: boolean) => [number, number, number, number, number, number];
-export declare const getElementLineSegments: (element: ExcalidrawElement, elementsMap: ElementsMap) => LineSegment<GlobalPoint>[];
-/**
- * Scene -> Scene coords, but in x1,x2,y1,y2 format.
- *
- * Rectangle here means any rectangular frame, not an excalidraw element.
- */
-export declare const getRectangleBoxAbsoluteCoords: (boxSceneCoords: RectangleBox) => number[];
-export declare const getDiamondPoints: (element: ExcalidrawElement) => number[];
-export declare const getMinMaxXYFromCurvePathOps: (ops: Op[], transformXY?: ((p: GlobalPoint) => GlobalPoint) | undefined) => Bounds;
-export declare const getBoundsFromPoints: (points: ExcalidrawFreeDrawElement["points"]) => Bounds;
-/** @returns number in pixels */
-export declare const getArrowheadSize: (arrowhead: Arrowhead) => number;
-/** @returns number in degrees */
-export declare const getArrowheadAngle: (arrowhead: Arrowhead) => Degrees;
-export declare const getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead) => number[] | null;
-export declare const getElementBounds: (element: ExcalidrawElement, elementsMap: ElementsMap) => Bounds;
-export declare const getCommonBounds: (elements: readonly ExcalidrawElement[], elementsMap?: ElementsMap) => 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) => Bounds;
-export declare const getElementPointsCoords: (element: ExcalidrawLinearElement, points: readonly (readonly [number, number])[]) => Bounds;
-export declare const getClosestElementBounds: (elements: readonly ExcalidrawElement[], from: {
-    x: number;
-    y: number;
-}) => Bounds;
-export interface BoundingBox {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-    midX: number;
-    midY: number;
-    width: number;
-    height: number;
-}
-export declare const getCommonBoundingBox: (elements: ExcalidrawElement[] | readonly NonDeleted<ExcalidrawElement>[]) => BoundingBox;
-/**
- * returns scene coords of user's editor viewport (visible canvas area) bounds
- */
-export declare const getVisibleSceneBounds: ({ scrollX, scrollY, width, height, zoom, }: AppState) => SceneBounds;
-export declare const getCenterForBounds: (bounds: Bounds) => GlobalPoint;
-export declare const doBoundsIntersect: (bounds1: Bounds | null, bounds2: Bounds | null) => boolean;
+import type { Degrees, GlobalPoint, LineSegment } from "@excalidraw/math";
+import type { AppState } from "@excalidraw/excalidraw/types";
+import type { ExcalidrawElement, ExcalidrawLinearElement, Arrowhead, ExcalidrawFreeDrawElement, NonDeleted, ElementsMap } from "./types";
+import type { Drawable, Op } from "roughjs/bin/core";
+export type RectangleBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    angle: number;
+};
+/**
+ * x and y position of top left corner, x and y position of bottom right corner
+ */
+export type Bounds = readonly [
+    minX: number,
+    minY: number,
+    maxX: number,
+    maxY: number
+];
+export type SceneBounds = readonly [
+    sceneX: number,
+    sceneY: number,
+    sceneX2: number,
+    sceneY2: number
+];
+export declare class ElementBounds {
+    private static boundsCache;
+    static getBounds(element: ExcalidrawElement, elementsMap: ElementsMap): Bounds;
+    private static calculateBounds;
+}
+export declare const getElementAbsoluteCoords: (element: ExcalidrawElement, elementsMap: ElementsMap, includeBoundText?: boolean) => [number, number, number, number, number, number];
+/**
+ * Given an element, return the line segments that make up the element.
+ *
+ * Uses helpers from /math
+ */
+export declare const getElementLineSegments: (element: ExcalidrawElement, elementsMap: ElementsMap) => LineSegment<GlobalPoint>[];
+/**
+ * Scene -> Scene coords, but in x1,x2,y1,y2 format.
+ *
+ * Rectangle here means any rectangular frame, not an excalidraw element.
+ */
+export declare const getRectangleBoxAbsoluteCoords: (boxSceneCoords: RectangleBox) => number[];
+export declare const getDiamondPoints: (element: ExcalidrawElement) => number[];
+export declare const getMinMaxXYFromCurvePathOps: (ops: Op[], transformXY?: ((p: GlobalPoint) => GlobalPoint) | undefined) => Bounds;
+export declare const getBoundsFromPoints: (points: ExcalidrawFreeDrawElement["points"]) => Bounds;
+/** @returns number in pixels */
+export declare const getArrowheadSize: (arrowhead: Arrowhead) => number;
+/** @returns number in degrees */
+export declare const getArrowheadAngle: (arrowhead: Arrowhead) => Degrees;
+export declare const getArrowheadPoints: (element: ExcalidrawLinearElement, shape: Drawable[], position: "start" | "end", arrowhead: Arrowhead) => number[] | null;
+export declare const getElementBounds: (element: ExcalidrawElement, elementsMap: ElementsMap) => Bounds;
+export declare const getCommonBounds: (elements: readonly ExcalidrawElement[], elementsMap?: ElementsMap) => 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) => Bounds;
+export declare const getElementPointsCoords: (element: ExcalidrawLinearElement, points: readonly (readonly [number, number])[]) => Bounds;
+export declare const getClosestElementBounds: (elements: readonly ExcalidrawElement[], from: {
+    x: number;
+    y: number;
+}) => Bounds;
+export interface BoundingBox {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    midX: number;
+    midY: number;
+    width: number;
+    height: number;
+}
+export declare const getCommonBoundingBox: (elements: ExcalidrawElement[] | readonly NonDeleted<ExcalidrawElement>[]) => BoundingBox;
+/**
+ * returns scene coords of user's editor viewport (visible canvas area) bounds
+ */
+export declare const getVisibleSceneBounds: ({ scrollX, scrollY, width, height, zoom, }: AppState) => SceneBounds;
+export declare const getCenterForBounds: (bounds: Bounds) => GlobalPoint;
+export declare const doBoundsIntersect: (bounds1: Bounds | null, bounds2: Bounds | null) => boolean;

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

@@ -1,26 +1,26 @@
-import type { GlobalPoint, LineSegment, LocalPoint } from "@excalidraw/math";
-import type { GeometricShape } from "@excalidraw/utils/geometry/shape";
-import type { ElementsMap, ExcalidrawElement } from "./types";
-import type { FrameNameBounds } from "../types";
-export declare const shouldTestInside: (element: ExcalidrawElement) => boolean;
-export type HitTestArgs<Point extends GlobalPoint | LocalPoint> = {
-    x: number;
-    y: number;
-    element: ExcalidrawElement;
-    shape: GeometricShape<Point>;
-    threshold?: number;
-    frameNameBound?: FrameNameBounds | null;
-};
-export declare const hitElementItself: <Point extends GlobalPoint | LocalPoint>({ x, y, element, shape, threshold, frameNameBound, }: HitTestArgs<Point>) => boolean;
-export declare const hitElementBoundingBox: (x: number, y: number, element: ExcalidrawElement, elementsMap: ElementsMap, tolerance?: number) => boolean;
-export declare const hitElementBoundingBoxOnly: <Point extends GlobalPoint | LocalPoint>(hitArgs: HitTestArgs<Point>, elementsMap: ElementsMap) => boolean;
-export declare const hitElementBoundText: <Point extends GlobalPoint | LocalPoint>(x: number, y: number, textShape: GeometricShape<Point> | null) => boolean;
-/**
- * Intersect a line with an element for binding test
- *
- * @param element
- * @param line
- * @param offset
- * @returns
- */
-export declare const intersectElementWithLineSegment: (element: ExcalidrawElement, line: LineSegment<GlobalPoint>, offset?: number) => GlobalPoint[];
+import { type GeometricShape } from "@excalidraw/utils/shape";
+import type { GlobalPoint, LineSegment, LocalPoint } from "@excalidraw/math";
+import type { FrameNameBounds } from "@excalidraw/excalidraw/types";
+import type { ElementsMap, ExcalidrawElement } from "./types";
+export declare const shouldTestInside: (element: ExcalidrawElement) => boolean;
+export type HitTestArgs<Point extends GlobalPoint | LocalPoint> = {
+    x: number;
+    y: number;
+    element: ExcalidrawElement;
+    shape: GeometricShape<Point>;
+    threshold?: number;
+    frameNameBound?: FrameNameBounds | null;
+};
+export declare const hitElementItself: <Point extends GlobalPoint | LocalPoint>({ x, y, element, shape, threshold, frameNameBound, }: HitTestArgs<Point>) => boolean;
+export declare const hitElementBoundingBox: (x: number, y: number, element: ExcalidrawElement, elementsMap: ElementsMap, tolerance?: number) => boolean;
+export declare const hitElementBoundingBoxOnly: <Point extends GlobalPoint | LocalPoint>(hitArgs: HitTestArgs<Point>, elementsMap: ElementsMap) => boolean;
+export declare const hitElementBoundText: <Point extends GlobalPoint | LocalPoint>(x: number, y: number, textShape: GeometricShape<Point> | null) => boolean;
+/**
+ * Intersect a line with an element for binding test
+ *
+ * @param element
+ * @param line
+ * @param offset
+ * @returns
+ */
+export declare const intersectElementWithLineSegment: (element: ExcalidrawElement, line: LineSegment<GlobalPoint>, offset?: number) => GlobalPoint[];

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

@@ -1,8 +1,8 @@
-import type { ElementOrToolType } from "../types";
-export declare const hasBackground: (type: ElementOrToolType) => boolean;
-export declare const hasStrokeColor: (type: ElementOrToolType) => boolean;
-export declare const hasStrokeWidth: (type: ElementOrToolType) => boolean;
-export declare const hasStrokeStyle: (type: ElementOrToolType) => boolean;
-export declare const canChangeRoundness: (type: ElementOrToolType) => boolean;
-export declare const toolIsArrow: (type: ElementOrToolType) => boolean;
-export declare const canHaveArrowheads: (type: ElementOrToolType) => boolean;
+import type { ElementOrToolType } from "@excalidraw/excalidraw/types";
+export declare const hasBackground: (type: ElementOrToolType) => boolean;
+export declare const hasStrokeColor: (type: ElementOrToolType) => boolean;
+export declare const hasStrokeWidth: (type: ElementOrToolType) => boolean;
+export declare const hasStrokeStyle: (type: ElementOrToolType) => boolean;
+export declare const canChangeRoundness: (type: ElementOrToolType) => boolean;
+export declare const toolIsArrow: (type: ElementOrToolType) => boolean;
+export declare const canHaveArrowheads: (type: ElementOrToolType) => boolean;

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

@@ -1,11 +1,11 @@
-import type { ExcalidrawTextContainer } from "./types";
-export declare const originalContainerCache: {
-    [id: ExcalidrawTextContainer["id"]]: {
-        height: ExcalidrawTextContainer["height"];
-    } | undefined;
-};
-export declare const updateOriginalContainerCache: (id: ExcalidrawTextContainer["id"], height: ExcalidrawTextContainer["height"]) => {
-    height: ExcalidrawTextContainer["height"];
-};
-export declare const resetOriginalContainerCache: (id: ExcalidrawTextContainer["id"]) => void;
-export declare const getOriginalContainerHeightFromCache: (id: ExcalidrawTextContainer["id"]) => number | null;
+import type { ExcalidrawTextContainer } from "./types";
+export declare const originalContainerCache: {
+    [id: ExcalidrawTextContainer["id"]]: {
+        height: ExcalidrawTextContainer["height"];
+    } | undefined;
+};
+export declare const updateOriginalContainerCache: (id: ExcalidrawTextContainer["id"], height: ExcalidrawTextContainer["height"]) => {
+    height: ExcalidrawTextContainer["height"];
+};
+export declare const resetOriginalContainerCache: (id: ExcalidrawTextContainer["id"]) => void;
+export declare const getOriginalContainerHeightFromCache: (id: ExcalidrawTextContainer["id"]) => number | null;

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

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

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

@@ -1,3 +1,3 @@
-import type { GlobalPoint } from "@excalidraw/math";
-import type { ExcalidrawBindableElement } from "./types";
-export declare const distanceToBindableElement: (element: ExcalidrawBindableElement, p: GlobalPoint) => number;
+import type { GlobalPoint } from "@excalidraw/math";
+import type { ExcalidrawBindableElement } from "./types";
+export declare const distanceToBindableElement: (element: ExcalidrawBindableElement, p: GlobalPoint) => number;

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

@@ -1,6 +1,6 @@
-import type { ElementsMap, ExcalidrawElement } from "./element/types";
-export interface Distribution {
-    space: "between";
-    axis: "x" | "y";
-}
-export declare const distributeElements: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, distribution: Distribution) => ExcalidrawElement[];
+import type { ElementsMap, ExcalidrawElement } from "./types";
+export interface Distribution {
+    space: "between";
+    axis: "x" | "y";
+}
+export declare const distributeElements: (selectedElements: ExcalidrawElement[], elementsMap: ElementsMap, distribution: Distribution) => ExcalidrawElement[];