@excalidraw/element 0.18.0-042a6979d → 0.18.0-063e025

package/dist/types/excalidraw/viewport.d.ts

@@ -0,0 +1,316 @@
+import type { SceneBounds } from "@excalidraw/element";
+import type { Bounds } from "@excalidraw/common";
+import type { ExcalidrawElement, NonDeleted, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
+import type { AppState, NormalizedZoomValue, Offsets, PointerCoords, ScrollConstraints, ViewportOffsets, Zoom } from "./types";
+export declare const SCROLL_TO_CONTENT_ANIMATION_KEY = "animateScrollToContent";
+/** default rubberband overscroll give for scroll locks, in viewport px */
+export declare const DEFAULT_OVERSCROLL = 150;
+export type AnimationOptions = {
+    duration?: number;
+};
+export type SetViewportRect = {
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+};
+export declare const isSetViewportRect: (target: unknown) => target is SetViewportRect;
+export type SetViewportOptions = {
+    /**
+     * what to show in the viewport: an explicit scene-coordinate box/rect,
+     * element(s), or an element id / element-link URL.
+     *
+     * IMPORTANT: if supplying ExcalidrawElement(s), only non-deleted elements
+     * that actually exist on the canvas are considered. If you want to navigate
+     * to elements that's not on canvas yet, supply their bounds by using
+     * `getCommonBounds` (see {@link getCommonBounds}).
+     */
+    target: Bounds | SetViewportRect | ExcalidrawElement | readonly ExcalidrawElement[] | string;
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/object-fit
+     *
+     * - `scale-down` - zoom out so the target fits the viewport, never zooming past 100%
+     * - `contain` - zoom the target so it fills the viewport (may exceed 100%)
+     * - `none` - keep the current zoom, only center the target in the viewport
+     */
+    fit?: "scale-down" | "contain" | "none";
+    lock?: {
+        /** constraints panning to the target box */
+        scroll?: ScrollConstraints["lockScroll"];
+        /** makes the resolved zoom the minimum zoom */
+        zoom?: ScrollConstraints["lockZoom"];
+        /**
+         * Rubberband give past the lock, in viewport px (zoom-independent): how
+         * far the user can pan beyond the constraint before snapping back.
+         * `true` (default) uses {@link DEFAULT_OVERSCROLL}, `false` disables
+         * (rigid lock), a number sets the give explicitly.
+         */
+        overscroll?: boolean | number;
+    };
+    animation?: AnimationOptions | boolean;
+    /**
+     * CSS-style per-side viewport insets, in viewport pixels
+     * (zoom-independent) — static values, editor-UI-derived (`ui`), or a
+     * combination. See {@link ViewportOffsets}.
+     */
+    offsets?: ViewportOffsets;
+};
+type Viewport = Pick<AppState, "scrollX" | "scrollY" | "zoom">;
+/**
+ * Clamps a proposed scroll/zoom against the active lock (`scrollConstraints`).
+ * Returns the input scroll/zoom unchanged when there is no lock.
+ * `overscroll` (screen px, zoom-independent) is rubberband give past the
+ * resting clamp — pass 0 for a hard clamp.
+ */
+export declare const constrainScrollState: (state: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "width" | "height" | "scrollConstraints">, overscroll?: number) => Viewport;
+export declare const isViewportOverscrolled: (state: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "width" | "height" | "scrollConstraints">) => boolean;
+/**
+ * Rubberband snap-back: animates the viewport from its current (possibly
+ * overscrolled) position back inside the lock box via the shared
+ * AnimationController. No-op when already within the hard bounds (or when there
+ * is no lock).
+ */
+export declare const animateToConstraints: (state: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "width" | "height" | "scrollConstraints">, onFrame: (viewport: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "shouldCacheIgnoreZoom">) => void, duration?: number) => void;
+/**
+ * Scrolls (and, per `fit`, zooms) the viewport so the given target box is in
+ * view, optionally animating the transition. `onComplete` runs once the
+ * viewport has settled on the target.
+ */
+export declare const setViewportToBounds: (state: AppState, bounds: Bounds, opts: Pick<SetViewportOptions, "fit" | "animation"> & {
+    offsets?: Offsets;
+}, onFrame: (state: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "shouldCacheIgnoreZoom">) => void, onComplete?: () => void) => void;
+export declare const zoomToFitBounds: ({ bounds, appState, canvasOffsets, fit, minZoom, maxZoom, steppedZoom, }: {
+    bounds: SceneBounds;
+    canvasOffsets?: Offsets;
+    appState: Readonly<AppState>;
+    fit?: SetViewportOptions["fit"];
+    minZoom?: number;
+    maxZoom?: number;
+    steppedZoom?: boolean;
+}) => {
+    appState: {
+        scrollX: number;
+        scrollY: number;
+        zoom: {
+            value: NormalizedZoomValue;
+        };
+        contextMenu: {
+            items: import("./components/ContextMenu").ContextMenuItems;
+            top: number;
+            left: number;
+        } | null;
+        showWelcomeScreen: boolean;
+        isLoading: boolean;
+        errorMessage: React.ReactNode;
+        activeEmbeddable: {
+            element: import("@excalidraw/element/types").NonDeletedExcalidrawElement;
+            state: "hover" | "active";
+        } | null;
+        newElement: NonDeleted<import("@excalidraw/element/types").ExcalidrawNonSelectionElement> | null;
+        resizingElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
+        multiElement: NonDeleted<import("@excalidraw/element/types").ExcalidrawLinearElement> | null;
+        selectionElement: import("@excalidraw/element/types").NonDeletedExcalidrawElement | null;
+        isBindingEnabled: boolean;
+        boxSelectionMode: import("./types").BoxSelectionMode;
+        bindingPreference: "enabled" | "disabled";
+        isMidpointSnappingEnabled: boolean;
+        suggestedBinding: {
+            element: NonDeleted<import("@excalidraw/element/types").ExcalidrawBindableElement>;
+            midPoint?: import("@excalidraw/math").GlobalPoint;
+        } | null;
+        frameToHighlight: NonDeleted<import("@excalidraw/element/types").ExcalidrawFrameLikeElement> | null;
+        frameRendering: {
+            enabled: boolean;
+            name: boolean;
+            outline: boolean;
+            clip: boolean;
+        };
+        editingFrame: string | null;
+        elementsToHighlight: readonly import("@excalidraw/element/types").NonDeletedExcalidrawElement[] | null;
+        editingTextElement: import("@excalidraw/element/types").ExcalidrawTextElement | null;
+        activeTool: {
+            lastActiveTool: import("./types").ActiveTool | null;
+            locked: boolean;
+            fromSelection: boolean;
+        } & import("./types").ActiveTool;
+        preferredSelectionTool: {
+            type: "selection" | "lasso";
+            initialized: boolean;
+        };
+        penMode: boolean;
+        penDetected: boolean;
+        exportBackground: boolean;
+        exportEmbedScene: boolean;
+        exportWithDarkMode: boolean;
+        exportScale: number;
+        currentItemStrokeColor: string;
+        currentItemBackgroundColor: string;
+        currentItemFillStyle: ExcalidrawElement["fillStyle"];
+        currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
+        currentItemStrokeStyle: ExcalidrawElement["strokeStyle"];
+        currentItemRoughness: number;
+        currentItemStrokeVariability: import("@excalidraw/element/types").StrokeVariability;
+        currentItemOpacity: number;
+        currentItemFontFamily: import("@excalidraw/element/types").FontFamilyValues;
+        currentItemFontSize: number;
+        currentItemTextAlign: import("@excalidraw/element/types").TextAlign;
+        currentItemStartArrowhead: import("@excalidraw/element/types").Arrowhead | null;
+        currentItemEndArrowhead: import("@excalidraw/element/types").Arrowhead | null;
+        currentHoveredFontFamily: import("@excalidraw/element/types").FontFamilyValues | null;
+        currentItemRoundness: import("@excalidraw/element/types").StrokeRoundness;
+        currentItemArrowType: "sharp" | "round" | "elbow";
+        viewBackgroundColor: string;
+        scrollConstraints: ScrollConstraints | null;
+        cursorButton: "up" | "down";
+        scrolledOutside: boolean;
+        name: string | null;
+        isResizing: boolean;
+        isRotating: boolean;
+        openMenu: "canvas" | null;
+        openPopup: "canvasBackground" | "elementBackground" | "elementStroke" | "fontFamily" | "compactTextProperties" | "compactStrokeStyles" | "compactOtherProperties" | "compactArrowProperties" | null;
+        openSidebar: {
+            name: import("./types").SidebarName;
+            tab?: import("./types").SidebarTabName;
+        } | null;
+        openDialog: null | {
+            name: "imageExport" | "help" | "jsonExport";
+        } | {
+            name: "ttd";
+            tab: "text-to-diagram" | "mermaid";
+        } | {
+            name: "commandPalette";
+        } | {
+            name: "settings";
+        } | {
+            name: "elementLinkSelector";
+            sourceElementId: ExcalidrawElement["id"];
+        } | {
+            name: "charts";
+            data: import("./charts").Spreadsheet;
+            rawText: string;
+        };
+        defaultSidebarDockedPreference: boolean;
+        lastPointerDownWith: import("@excalidraw/element/types").PointerType;
+        selectedElementIds: Readonly<{
+            [id: string]: true;
+        }>;
+        hoveredElementIds: Readonly<{
+            [id: string]: true;
+        }>;
+        previousSelectedElementIds: {
+            [id: string]: true;
+        };
+        selectedElementsAreBeingDragged: boolean;
+        shouldCacheIgnoreZoom: boolean;
+        toast: {
+            message: React.ReactNode;
+            closable?: boolean;
+            duration?: number;
+        } | null;
+        zenModeEnabled: boolean;
+        theme: import("@excalidraw/element/types").Theme;
+        gridSize: number;
+        gridStep: number;
+        gridModeEnabled: boolean;
+        viewModeEnabled: boolean;
+        selectedGroupIds: {
+            [groupId: string]: boolean;
+        };
+        editingGroupId: import("@excalidraw/element/types").GroupId | null;
+        width: number;
+        height: number;
+        offsetTop: number;
+        offsetLeft: number;
+        fileHandle: FileSystemFileHandle | null;
+        collaborators: Map<import("./types").SocketId, import("./types").Collaborator>;
+        stats: {
+            open: boolean;
+            panels: number;
+        };
+        showHyperlinkPopup: false | "info" | "editor";
+        selectedLinearElement: import("@excalidraw/element").LinearElementEditor | null;
+        snapLines: readonly import("./snapping").SnapLine[];
+        originSnapOffset: {
+            x: number;
+            y: number;
+        } | null;
+        objectsSnapModeEnabled: boolean;
+        userToFollow: import("./types").UserToFollow | null;
+        followedBy: Set<import("./types").SocketId>;
+        isCropping: boolean;
+        croppingElementId: ExcalidrawElement["id"] | null;
+        searchMatches: Readonly<{
+            focusedId: ExcalidrawElement["id"] | null;
+            matches: readonly import("./types").SearchMatch[];
+        }> | null;
+        activeLockedId: string | null;
+        lockedMultiSelections: {
+            [groupId: string]: true;
+        };
+        bindMode: import("@excalidraw/element/types").BindMode;
+    };
+    captureUpdate: "EVENTUALLY";
+};
+/** Computes the viewport (scroll + zoom) that brings the target box into view,
+ * based on the requested fit behavior. */
+export declare const getTargetViewport: (state: AppState, bounds: Bounds, fit?: SetViewportOptions["fit"], offsets?: Offsets) => Viewport;
+export type ResolvedViewportTarget = {
+    /** null when the target couldn't be resolved (unknown id/link, or all
+     * supplied elements deleted) */
+    bounds: Bounds | null;
+    /** how the target was specified, so callers can react to unresolved
+     * targets themselves (e.g. toast on a broken element link) */
+    type: "element" | "area" | "link";
+};
+/** Resolves a `setViewport` target to a scene-coordinate box. */
+export declare const resolveViewportTarget: (target: SetViewportOptions["target"], elementsMap: NonDeletedSceneElementsMap, appState: Pick<AppState, "width" | "height">) => ResolvedViewportTarget;
+/** Computes the viewport patch for landing on `bounds`: the target
+ * scroll/zoom, plus the scroll lock to install — or `scrollConstraints: null`
+ * to clear a previous lock when none is requested. */
+export declare const getConstrainedTargetViewport: (appState: AppState, bounds: Bounds, { fit, offsets, lock, }: Pick<SetViewportOptions, "fit" | "lock"> & {
+    offsets?: Offsets;
+}) => Viewport & {
+    scrollConstraints: ScrollConstraints | null;
+};
+/**
+ * Interpolates the viewport from `from` to `target` at the (already-eased)
+ * blend amount `factor` (0 = `from`, 1 = `target`).
+ *
+ * Zoom is interpolated geometrically (so it feels uniform), but the pan can't
+ * simply lerp alongside it: pairing a geometric zoom with a linear scroll (or
+ * a linearly-tweened focal point) makes scene points swoop along curved,
+ * non-monotone screen paths once the zoom ratio exceeds ~e (the destination
+ * visibly drifts away before converging). Instead we interpolate the view
+ * transform affinely — a scene point maps to screen as
+ * `(scenePt + scroll) * zoom`, and requiring every point to travel a straight
+ * screen line forces `zoom` to be a convex blend `(1-m)*z0 + m*z1` with
+ * `scroll * zoom` lerped by that same weight. Deriving `m` from the geometric
+ * zoom keeps its pacing while making all screen trajectories straight and
+ * monotone.
+ */
+export declare const interpolateViewport: ({ from, target, factor, }: {
+    from: Viewport;
+    target: Viewport;
+    factor: number;
+}) => Viewport;
+export declare const getClosestElementBounds: (elements: readonly ExcalidrawElement[], from: {
+    x: number;
+    y: number;
+}) => Bounds;
+export declare const centerScrollOn: ({ scenePoint, viewportDimensions, zoom, offsets, }: {
+    scenePoint: PointerCoords;
+    viewportDimensions: {
+        height: number;
+        width: number;
+    };
+    zoom: Zoom;
+    offsets?: Offsets;
+}) => {
+    scrollX: number;
+    scrollY: number;
+};
+export declare const getScrollToContentState: (elements: readonly ExcalidrawElement[], appState: AppState) => {
+    scrollX: number;
+    scrollY: number;
+};
+export {};

package/dist/types/excalidraw/wysiwyg/textWysiwyg.d.ts

@@ -1,15 +1,14 @@
-import type { ExcalidrawElement, ExcalidrawTextElement } from "@excalidraw/element/types";
+import type { ExcalidrawTextElement } from "@excalidraw/element/types";
 import type App from "../components/App";
 type SubmitHandler = () => void;
-export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, autoSelect, }: {
-    id: ExcalidrawElement["id"];
+export declare const textWysiwyg: ({ onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, autoSelect, initialCaretSceneCoords, }: {
     /**
      * textWysiwyg only deals with `originalText`
      *
      * Note: `text`, which can be wrapped and therefore different from `originalText`,
      *       is derived from `originalText`
      */
-    onChange?: ((nextOriginalText: string) => void) | undefined;
+    onChange?: (nextOriginalText: string) => void;
     onSubmit: (data: {
         viaKeyboard: boolean;
         nextOriginalText: string;
@@ -19,6 +18,10 @@ export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords,
     canvas: HTMLCanvasElement;
     excalidrawContainer: HTMLDivElement | null;
     app: App;
-    autoSelect?: boolean | undefined;
+    autoSelect?: boolean;
+    initialCaretSceneCoords?: {
+        x: number;
+        y: number;
+    } | null;
 }) => SubmitHandler;
 export {};

package/dist/types/fractional-indexing/src/index.d.ts

@@ -0,0 +1,29 @@
+export declare const BASE_62_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+/**
+ * @param {string} key
+ * @param {string} digits
+ * @return {void}
+ */
+export declare function validateOrderKey(key: string, digits?: string): void;
+/**
+ * @param {string | null | undefined} a
+ * @param {string | null | undefined} b
+ * @param {string=} digits
+ * @return {string}
+ */
+export declare function generateKeyBetween(a: string | null | undefined, b: string | null | undefined, digits?: string): string;
+/**
+ * same preconditions as generateKeysBetween.
+ * n >= 0.
+ * Returns an array of n distinct keys in sorted order.
+ * If a and b are both null, returns [a0, a1, ...]
+ * If one or the other is null, returns consecutive "integer"
+ * keys.  Otherwise, returns relatively short keys between
+ * a and b.
+ * @param {string | null | undefined} a
+ * @param {string | null | undefined} b
+ * @param {number} n
+ * @param {string} digits
+ * @return {string[]}
+ */
+export declare function generateNKeysBetween(a: string | null | undefined, b: string | null | undefined, n: number, digits?: string): string[];

package/dist/types/laser-pointer/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./state";
+export type { Point } from "./math";

package/dist/types/laser-pointer/src/math.d.ts

@@ -0,0 +1,16 @@
+export type Point = [x: number, y: number, r: number];
+export declare function add([ax, ay, ar]: Point, [bx, by, br]: Point): Point;
+export declare function sub([ax, ay, ar]: Point, [bx, by, br]: Point): Point;
+export declare function smul([x, y, r]: Point, s: number): Point;
+export declare function norm([x, y, r]: Point): Point;
+export declare function rot([x, y, r]: Point, rad: number): Point;
+export declare function plerp(a: Point, b: Point, t: number): Point;
+export declare function lerp(a: number, b: number, t: number): number;
+export declare function angle(p: Point, p1: Point, p2: Point): number;
+export declare function normAngle(a: number): number;
+export declare function mag([x, y]: Point): number;
+export declare function dist([ax, ay]: Point, [bx, by]: Point): number;
+export declare function getCircleAndPerpendicularLineIntersectionsAtPoint(point: Point, direction: Point, radius: number): [Point, Point];
+export declare function runLength(ps: Point[]): number;
+export declare const clamp: (v: number, min: number, max: number) => number;
+export declare function distancePointToSegment(p3: Point, p1: Point, p2: Point): number;

package/dist/types/laser-pointer/src/simplify.d.ts

@@ -0,0 +1,2 @@
+import { type Point } from "./math";
+export declare function douglasPeucker(points: Point[], epsilon: number): Point[];

package/dist/types/laser-pointer/src/state.d.ts

@@ -0,0 +1,35 @@
+import type { Point } from "./math";
+export type SizeMappingDetails = {
+    pressure: number;
+    runningLength: number;
+    currentIndex: number;
+    totalLength: number;
+};
+export type LaserPointerOptions = {
+    size: number;
+    streamline: number;
+    simplify: number;
+    simplifyPhase: "tail" | "output" | "input";
+    keepHead: boolean;
+    sizeMapping: (details: SizeMappingDetails) => number;
+};
+export declare class LaserPointer {
+    static defaults: LaserPointerOptions;
+    static constants: {
+        cornerDetectionMaxAngle: number;
+        cornerDetectionVariance: (s: number) => 1 | 0.5;
+        maxTailLength: number;
+    };
+    options: LaserPointerOptions;
+    constructor(options: Partial<LaserPointerOptions>);
+    originalPoints: Point[];
+    private stablePoints;
+    private tailPoints;
+    private isFresh;
+    private get lastPoint();
+    addPoint(point: Point): void;
+    close(): void;
+    stabilizeTail(): void;
+    private getSize;
+    getStrokeOutline(sizeOverride?: number | undefined): Point[];
+}

package/dist/types/math/src/constants.d.ts

@@ -1,3 +1,2 @@
-export declare const PRECISION = 0.0001;
 export declare const LegendreGaussN24TValues: number[];
 export declare const LegendreGaussN24CValues: number[];

package/dist/types/math/src/curve.d.ts

@@ -12,7 +12,10 @@ export declare const bezierEquation: <Point extends GlobalPoint | LocalPoint>(c:
 /**
  * Computes the intersection between a cubic spline and a line segment.
  */
-export declare function curveIntersectLineSegment<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, l: LineSegment<Point>): Point[];
+export declare function curveIntersectLineSegment<Point extends GlobalPoint | LocalPoint>(c: Curve<Point>, l: LineSegment<Point>, opts?: {
+    tolerance?: number;
+    iterLimit?: number;
+}): Point[];
 /**
  * Finds the closest point on the Bezier curve from another point
  *

package/dist/types/math/src/point.d.ts

@@ -1,4 +1,4 @@
-import type { LocalPoint, GlobalPoint, Radians, Degrees, Vector } from "./types";
+import type { LocalPoint, GlobalPoint, Radians, Degrees, Vector, GlobalCoord, LocalCoord } from "./types";
 /**
  * Create a properly typed Point instance from the X and Y coordinates.
  *
@@ -7,6 +7,11 @@ import type { LocalPoint, GlobalPoint, Radians, Degrees, Vector } from "./types"
  * @returns The branded and created point
  */
 export declare function pointFrom<Point extends GlobalPoint | LocalPoint>(x: number, y: number): Point;
+export declare function pointFrom<Coord extends GlobalCoord | LocalCoord>(coords: Coord): Coord extends GlobalCoord ? GlobalPoint : LocalPoint;
+export declare function pointFrom<Point extends GlobalPoint | LocalPoint>(coords: {
+    x: number;
+    y: number;
+}): Point;
 /**
  * Converts and remaps an array containing a pair of numbers to Point.
  *
@@ -52,7 +57,7 @@ export declare function pointsEqual<Point extends GlobalPoint | LocalPoint>(a: P
  * @param angle The radians to rotate the point by
  * @returns The rotated point
  */
-export declare function pointRotateRads<Point extends GlobalPoint | LocalPoint>([x, y]: Point, [cx, cy]: Point, angle: Radians): Point;
+export declare function pointRotateRads<Point extends GlobalPoint | LocalPoint>(point: Point, center: Point, angle: Radians): Point;
 /**
  * Rotate a point by [angle] degree.
  *
@@ -120,3 +125,4 @@ export declare const pointScaleFromOrigin: <P extends GlobalPoint | LocalPoint>(
  * @returns TRUE if q is indeed between p and r
  */
 export declare const isPointWithinBounds: <P extends GlobalPoint | LocalPoint>(p: P, q: P, r: P) => boolean;
+export declare const isValidPoint: (point: unknown) => point is LocalPoint;

package/dist/types/math/src/polygon.d.ts

@@ -1,6 +1,6 @@
 import type { GlobalPoint, LocalPoint, Polygon } from "./types";
 export declare function polygon<Point extends GlobalPoint | LocalPoint>(...points: Point[]): Polygon<Point>;
 export declare function polygonFromPoints<Point extends GlobalPoint | LocalPoint>(points: Point[]): Polygon<Point>;
-export declare const polygonIncludesPoint: <Point extends GlobalPoint | LocalPoint>(point: Point, polygon: Polygon<Point>) => boolean;
+export declare const polygonIncludesPoint: <Point extends LocalPoint | GlobalPoint>(point: Point, polygon: Polygon<Point>) => boolean;
 export declare const polygonIncludesPointNonZero: <Point extends [number, number]>(point: Point, polygon: Point[]) => boolean;
-export declare const pointOnPolygon: <Point extends GlobalPoint | LocalPoint>(p: Point, poly: Polygon<Point>, threshold?: number) => boolean;
+export declare const pointOnPolygon: <Point extends LocalPoint | GlobalPoint>(p: Point, poly: Polygon<Point>, threshold?: number) => boolean;

package/dist/types/math/src/range.d.ts

@@ -13,9 +13,7 @@ export declare function rangeInclusive(start: number, end: number): InclusiveRan
  * @param pair The number pair to convert to an inclusive range
  * @returns The new inclusive range
  */
-export declare function rangeInclusiveFromPair(pair: [start: number, end: number]): [number, number] & {
-    _brand: "excalimath_degree";
-};
+export declare function rangeInclusiveFromPair(pair: [start: number, end: number]): InclusiveRange;
 /**
  * Given two ranges, return if the two ranges overlap with each other e.g.
  * [1, 3] overlaps with [2, 4] while [1, 3] does not overlap with [4, 5].

package/dist/types/math/src/segment.d.ts

@@ -21,14 +21,14 @@ export declare const isLineSegment: <Point extends GlobalPoint | LocalPoint>(seg
  * @param origin
  * @returns
  */
-export declare const lineSegmentRotate: <Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, angle: Radians, origin?: Point | undefined) => LineSegment<Point>;
+export declare const lineSegmentRotate: <Point extends LocalPoint | GlobalPoint>(l: LineSegment<Point>, angle: Radians, origin?: Point) => LineSegment<Point>;
 /**
  * Calculates the point two line segments with a definite start and end point
  * intersect at.
  */
 export declare const segmentsIntersectAt: <Point extends GlobalPoint | LocalPoint>(a: Readonly<LineSegment<Point>>, b: Readonly<LineSegment<Point>>) => Point | null;
-export declare const pointOnLineSegment: <Point extends GlobalPoint | LocalPoint>(point: Point, line: LineSegment<Point>, threshold?: number) => boolean;
-export declare const distanceToLineSegment: <Point extends GlobalPoint | LocalPoint>(point: Point, line: LineSegment<Point>) => number;
+export declare const pointOnLineSegment: <Point extends LocalPoint | GlobalPoint>(point: Point, line: LineSegment<Point>, threshold?: number) => boolean;
+export declare const distanceToLineSegment: <Point extends LocalPoint | GlobalPoint>(point: Point, line: LineSegment<Point>) => number;
 /**
  * Returns the intersection point of a segment and a line
  *
@@ -37,3 +37,4 @@ export declare const distanceToLineSegment: <Point extends GlobalPoint | LocalPo
  * @returns
  */
 export declare function lineSegmentIntersectionPoints<Point extends GlobalPoint | LocalPoint>(l: LineSegment<Point>, s: LineSegment<Point>, threshold?: number): Point | null;
+export declare function lineSegmentsDistance<Point extends GlobalPoint | LocalPoint>(s1: LineSegment<Point>, s2: LineSegment<Point>): number;

package/dist/types/math/src/types.d.ts

@@ -19,12 +19,24 @@ export type InclusiveRange = [number, number] & {
     _brand: "excalimath_degree";
 };
 /**
- * Represents a 2D position in world or canvas space. A
+ * Represents a 2D position in world/canvas/scene space. A
  * global coordinate.
  */
 export type GlobalPoint = [x: number, y: number] & {
     _brand: "excalimath__globalpoint";
 };
+/**
+ * Represents a 2D position in world/canvas/scene space. A
+ * global coordinate.
+ *
+ * TODO remove this once we migrate the codebase to use Point tuples everywhere
+ */
+export type GlobalCoord = {
+    x: number;
+    y: number;
+} & {
+    _brand: "excalimath__globalcoord";
+};
 /**
  * Represents a 2D position in whatever local space it's
  * needed. A local coordinate.
@@ -32,6 +44,18 @@ export type GlobalPoint = [x: number, y: number] & {
 export type LocalPoint = [x: number, y: number] & {
     _brand: "excalimath__localpoint";
 };
+/**
+ * Represents a 2D position in whatever local space it's needed.
+ * A local coordinate.
+ *
+ * TODO remove this once we migrate the codebase to use Point tuples everywhere
+ */
+export type LocalCoord = {
+    x: number;
+    y: number;
+} & {
+    _brand: "excalimath__localcoord";
+};
 /**
  * A line is an infinitely long object with no width, depth, or curvature.
  */

package/dist/types/utils/src/export.d.ts

@@ -1,13 +1,13 @@
 import { MIME_TYPES } from "@excalidraw/common";
-import type { ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted } from "@excalidraw/element/types";
+import type { ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
 import type { AppState, BinaryFiles } from "@excalidraw/excalidraw/types";
 export { MIME_TYPES };
 type ExportOpts = {
-    elements: readonly NonDeleted<ExcalidrawElement>[];
+    elements: readonly NonDeletedExcalidrawElement[];
     appState?: Partial<Omit<AppState, "offsetTop" | "offsetLeft">>;
     files: BinaryFiles | null;
     maxWidthOrHeight?: number;
-    exportingFrame?: ExcalidrawFrameLikeElement | null;
+    exportingFrame?: NonDeleted<ExcalidrawFrameLikeElement> | null;
     getDimensions?: (width: number, height: number) => {
         width: number;
         height: number;
@@ -15,7 +15,7 @@ type ExportOpts = {
     };
 };
 export declare const exportToCanvas: ({ elements, appState, files, maxWidthOrHeight, getDimensions, exportPadding, exportingFrame, }: ExportOpts & {
-    exportPadding?: number | undefined;
+    exportPadding?: number;
 }) => Promise<HTMLCanvasElement>;
 export declare const exportToBlob: (opts: ExportOpts & {
     mimeType?: string;
@@ -23,10 +23,10 @@ export declare const exportToBlob: (opts: ExportOpts & {
     exportPadding?: number;
 }) => Promise<Blob>;
 export declare const exportToSvg: ({ elements, appState, files, exportPadding, renderEmbeddables, exportingFrame, skipInliningFonts, reuseImages, }: Omit<ExportOpts, "getDimensions"> & {
-    exportPadding?: number | undefined;
-    renderEmbeddables?: boolean | undefined;
-    skipInliningFonts?: true | undefined;
-    reuseImages?: boolean | undefined;
+    exportPadding?: number;
+    renderEmbeddables?: boolean;
+    skipInliningFonts?: true;
+    reuseImages?: boolean;
 }) => Promise<SVGSVGElement>;
 export declare const exportToClipboard: (opts: ExportOpts & {
     mimeType?: string;

package/dist/types/utils/src/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./export";
-export * from "./withinBounds";
-export * from "./bbox";
+export { elementsOverlappingBBox } from "@excalidraw/element";
 export { getCommonBounds } from "@excalidraw/element";

package/dist/types/utils/src/shape.d.ts

@@ -46,13 +46,13 @@ export declare const getClosedCurveShape: <Point extends GlobalPoint | LocalPoin
  * @param gap Optional value to inflate the shape before testing
  * @returns An array of intersections
  */
-export declare const segmentIntersectRectangleElement: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawBindableElement, segment: LineSegment<Point>, gap?: number) => Point[];
-export declare const pointOnEllipse: <Point extends GlobalPoint | LocalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
-export declare const pointInEllipse: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
-export declare const ellipseAxes: <Point extends GlobalPoint | LocalPoint>(ellipse: Ellipse<Point>) => {
+export declare const segmentIntersectRectangleElement: <Point extends LocalPoint | GlobalPoint>(element: ExcalidrawBindableElement, segment: LineSegment<Point>, gap?: number) => Point[];
+export declare const pointOnEllipse: <Point extends LocalPoint | GlobalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
+export declare const pointInEllipse: <Point extends LocalPoint | GlobalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
+export declare const ellipseAxes: <Point extends LocalPoint | GlobalPoint>(ellipse: Ellipse<Point>) => {
     majorAxis: number;
     minorAxis: number;
 };
-export declare const ellipseFocusToCenter: <Point extends GlobalPoint | LocalPoint>(ellipse: Ellipse<Point>) => number;
-export declare const ellipseExtremes: <Point extends GlobalPoint | LocalPoint>(ellipse: Ellipse<Point>) => import("@excalidraw/math").Vector[];
+export declare const ellipseFocusToCenter: <Point extends LocalPoint | GlobalPoint>(ellipse: Ellipse<Point>) => number;
+export declare const ellipseExtremes: <Point extends LocalPoint | GlobalPoint>(ellipse: Ellipse<Point>) => import("@excalidraw/math").Vector[];
 export {};