@qrvey/utils 1.15.0-8 → 1.15.0

package/dist/elements/helpers/responsive.d.ts

@@ -0,0 +1,87 @@
+import { CanvasDevice } from "../interfaces/ICanvasGrid";
+import { VemResponsive } from "../interfaces/IVemCore";
+import { VemPositionResponsive } from "../interfaces/IVemPosition";
+/**
+ * Finds the first available position for a new responsive element within a canvas.
+ * @param canvasWidth - The width of the canvas in terms of columns.
+ * @param newElement - The new responsive element to place on the canvas.
+ * @param elements - The existing elements on the canvas.
+ * @param device - The target device type (e.g., desktop, tablet, mobile) to calculate responsive positions.
+ * @returns - The column and row start positions for the new element, or `undefined` if no valid position is found.
+ */
+export declare function findAvailablePosition(canvasWidth: number, newElement: VemResponsive, elements: VemResponsive[], device: CanvasDevice): {
+    colStart: number;
+    rowStart: number;
+} | undefined;
+/**
+ * Updates the responsive position of a given element for a specified device.
+ * @param element - The responsive element to update.
+ * @param newPosition - The new position values to update for the element.
+ * @param device - The target device type (e.g., desktop, tablet, mobile) for which the position is updated.
+ * @returns - A new `VemResponsive` object with the updated responsive position for the specified device.
+ */
+export declare function updateResponsivePosition(element: VemResponsive, newPosition: Partial<VemPositionResponsive>, device: CanvasDevice): VemResponsive;
+/**
+ * Finds available positions for a list of responsive elements on a canvas and updates their positions.
+ * @param canvasWidth - The width of the canvas in grid columns.
+ * @param newElements - The list of new responsive elements to position.
+ * @param elements - The list of existing responsive elements already positioned on the canvas.
+ * @param device - The target device type (e.g., desktop, tablet, mobile) for which positions are calculated.
+ * @returns - A list of responsive elements with updated positions for the specified device.
+ */
+export declare function findResponsiveAvailablePositions(canvasWidth: number, newElements: VemResponsive[], elements: VemResponsive[], device: CanvasDevice): VemResponsive[];
+/**
+ * Adjusts the `colSpan` of a responsive element to fit within the specified canvas width and updates its position.
+ * @param element - The responsive element to adjust.
+ * @param canvasWidth - The width of the canvas in grid columns.
+ * @param canvasDevice - The target device type (e.g., desktop, tablet, mobile).
+ * @returns - The updated responsive element with an adjusted `colSpan`.
+ */
+export declare function updateResponsiveElementColSpan(element: VemResponsive, canvasWidth: number, canvasDevice: CanvasDevice): VemResponsive;
+export declare const getResponsiveGridElementsBottomLimit: (elements: VemResponsive[], device: CanvasDevice, rowGap: number) => number;
+/**
+ * Calculates the distances of elements from a reference point and returns a list of objects
+ * containing the calculated distance and the corresponding element.
+ * @param elements - An array of `VemResponsive` objects. Each object represents an element with
+ *                   a `position` property that contains responsive positions for various devices.
+ * @param device - The specific device type (key of `CanvasDevice`) to determine the responsive position.
+ * @param referencePoint - An object representing the reference point with `x` and `y` coordinates.
+ * @param referencePoint.x
+ * @param referencePoint.y
+ * @returns - An array of objects, where each object contains:
+ *            - `distance`: The squared Euclidean distance from the reference point.
+ *            - `element`: The corresponding `VemResponsive` object.
+ */
+export declare const calculateDistancesToReferencePoint: (elements: VemResponsive[], device: CanvasDevice, referencePoint: {
+    x: number;
+    y: number;
+}) => {
+    distance: number;
+    element: VemResponsive;
+}[];
+/**
+/**
+Sorts objects containing a `distance` and `element` by distance in ascending order.
+If two objects have the same distance, it resolves the tie by comparing the `colStart` property
+of their responsive positions for the `DESKTOP` device.
+ * @param a - An object containing:
+ *            - `distance`: The calculated distance from a reference point.
+ *            - `element`: A `VemResponsive` object with responsive position data.
+ * @param b - Another object with the same structure as `a`.
+ * @param a.element
+ * @param a.distance
+ * @param _device - The device type (of type `CanvasDevice`). Currently unused in this function.
+ * @param b.distance
+ * @param b.element
+ * @returns - A negative number if `a` should come before `b`,
+ *            a positive number if `a` should come after `b`,
+ *            or 0 if they have the same distance and `colStart` values.
+ */
+export declare const sortByDistanceInResponsiveFunction: (a: {
+    distance: number;
+    element: VemResponsive;
+}, b: {
+    distance: number;
+    element: VemResponsive;
+}, _device: CanvasDevice) => number;
+export declare const sortResponsiveElements: (elements: VemResponsive<unknown>[], sortByDevice?: CanvasDevice) => VemResponsive<unknown>[];

package/dist/elements/helpers/responsive.js

@@ -0,0 +1,155 @@
+import { CanvasDevice } from "../interfaces/ICanvasGrid";
+import { VemPositionType, } from "../interfaces/IVemPosition";
+import { OverlapIntervalTree } from "../utils/overlap";
+import { setElementPosition } from "../utils/position";
+const SPACE_DELTA = 1;
+const HEIGHT_DELTA = 32;
+/**
+ * Finds the first available position for a new responsive element within a canvas.
+ * @param canvasWidth - The width of the canvas in terms of columns.
+ * @param newElement - The new responsive element to place on the canvas.
+ * @param elements - The existing elements on the canvas.
+ * @param device - The target device type (e.g., desktop, tablet, mobile) to calculate responsive positions.
+ * @returns - The column and row start positions for the new element, or `undefined` if no valid position is found.
+ */
+export function findAvailablePosition(canvasWidth, newElement, elements, device) {
+    const { colSpan: newWidth, rowSpan: newHeight } = newElement.position.responsive[device];
+    const sortedElements = elements
+        .slice()
+        .sort((a, b) => a.position.responsive[device].rowStart -
+        b.position.responsive[device].rowStart);
+    const intervalTree = new OverlapIntervalTree();
+    for (const element of sortedElements) {
+        const elemPosition = element.position.responsive[device];
+        const colEnd = elemPosition.colStart + (elemPosition.colSpan - 1);
+        const rowEnd = elemPosition.rowStart + elemPosition.rowSpan - 1;
+        if (!intervalTree.overlaps(elemPosition.colStart, colEnd, elemPosition.rowStart, rowEnd)) {
+            intervalTree.insert(elemPosition.colStart, colEnd, elemPosition.rowStart, rowEnd);
+        }
+    }
+    for (let rowStart = 1; rowStart <= Infinity - newHeight; rowStart += SPACE_DELTA) {
+        // height iteration will be until it finds a result
+        for (let colStart = 1; colStart <= canvasWidth - newWidth + 1; colStart += SPACE_DELTA) {
+            if (!intervalTree.overlaps(colStart, colStart + newWidth - 1, rowStart, rowStart + newHeight - 1)) {
+                const col = colStart === 0 ? 1 : colStart;
+                const row = rowStart === 0 ? 1 : rowStart;
+                return { colStart: col, rowStart: row };
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Updates the responsive position of a given element for a specified device.
+ * @param element - The responsive element to update.
+ * @param newPosition - The new position values to update for the element.
+ * @param device - The target device type (e.g., desktop, tablet, mobile) for which the position is updated.
+ * @returns - A new `VemResponsive` object with the updated responsive position for the specified device.
+ */
+export function updateResponsivePosition(element, newPosition, device) {
+    var _a;
+    return Object.assign(Object.assign({}, element), { position: Object.assign(Object.assign({}, element.position), { responsive: Object.assign(Object.assign({}, element.position.responsive), { [device]: Object.assign(Object.assign({}, (_a = element.position.responsive) === null || _a === void 0 ? void 0 : _a[device]), newPosition) }) }) });
+}
+/**
+ * Finds available positions for a list of responsive elements on a canvas and updates their positions.
+ * @param canvasWidth - The width of the canvas in grid columns.
+ * @param newElements - The list of new responsive elements to position.
+ * @param elements - The list of existing responsive elements already positioned on the canvas.
+ * @param device - The target device type (e.g., desktop, tablet, mobile) for which positions are calculated.
+ * @returns - A list of responsive elements with updated positions for the specified device.
+ */
+export function findResponsiveAvailablePositions(canvasWidth, newElements, elements, device) {
+    const processedElements = elements.slice();
+    const resultElems = [];
+    newElements.forEach((nElement) => {
+        const newElement = updateResponsiveElementColSpan(nElement, canvasWidth, device);
+        const availablePosition = findAvailablePosition(canvasWidth, newElement, processedElements, device);
+        const newElemWithPosition = updateResponsivePosition(newElement, availablePosition, device);
+        resultElems.push(newElemWithPosition);
+        processedElements.push(newElemWithPosition);
+    });
+    return resultElems;
+}
+/**
+ * Adjusts the `colSpan` of a responsive element to fit within the specified canvas width and updates its position.
+ * @param element - The responsive element to adjust.
+ * @param canvasWidth - The width of the canvas in grid columns.
+ * @param canvasDevice - The target device type (e.g., desktop, tablet, mobile).
+ * @returns - The updated responsive element with an adjusted `colSpan`.
+ */
+export function updateResponsiveElementColSpan(element, canvasWidth, canvasDevice) {
+    const currentPosition = element.position.responsive[canvasDevice];
+    const fixedColSpan = Math.min(currentPosition.colSpan, canvasWidth);
+    const position = Object.assign(Object.assign({}, currentPosition), { colSpan: fixedColSpan });
+    return setElementPosition(element, VemPositionType.RESPONSIVE, canvasDevice, position);
+}
+export const getResponsiveGridElementsBottomLimit = (elements, device, rowGap) => {
+    if (!elements.length)
+        return 0;
+    const mappedElements = elements.map((element) => {
+        const elementPosition = element.position.responsive;
+        const maxRows = elementPosition[device].rowStart + elementPosition[device].rowSpan;
+        return maxRows * HEIGHT_DELTA + (maxRows - 1) * rowGap;
+    });
+    return Math.max(...mappedElements);
+};
+/**
+ * Calculates the distances of elements from a reference point and returns a list of objects
+ * containing the calculated distance and the corresponding element.
+ * @param elements - An array of `VemResponsive` objects. Each object represents an element with
+ *                   a `position` property that contains responsive positions for various devices.
+ * @param device - The specific device type (key of `CanvasDevice`) to determine the responsive position.
+ * @param referencePoint - An object representing the reference point with `x` and `y` coordinates.
+ * @param referencePoint.x
+ * @param referencePoint.y
+ * @returns - An array of objects, where each object contains:
+ *            - `distance`: The squared Euclidean distance from the reference point.
+ *            - `element`: The corresponding `VemResponsive` object.
+ */
+export const calculateDistancesToReferencePoint = (elements, device, referencePoint) => {
+    return elements.map((element) => {
+        var _a, _b;
+        const position = (_b = (_a = element.position) === null || _a === void 0 ? void 0 : _a.responsive) === null || _b === void 0 ? void 0 : _b[device];
+        if (!position) {
+            throw new Error(`Position for device ${device} is undefined for element with Id ${element.elementId}.`);
+        }
+        const distance = Math.pow(referencePoint.x - position.colStart, 2) +
+            Math.pow(referencePoint.y - position.rowStart, 2);
+        return {
+            distance,
+            element,
+        };
+    });
+};
+/**
+/**
+Sorts objects containing a `distance` and `element` by distance in ascending order.
+If two objects have the same distance, it resolves the tie by comparing the `colStart` property
+of their responsive positions for the `DESKTOP` device.
+ * @param a - An object containing:
+ *            - `distance`: The calculated distance from a reference point.
+ *            - `element`: A `VemResponsive` object with responsive position data.
+ * @param b - Another object with the same structure as `a`.
+ * @param a.element
+ * @param a.distance
+ * @param _device - The device type (of type `CanvasDevice`). Currently unused in this function.
+ * @param b.distance
+ * @param b.element
+ * @returns - A negative number if `a` should come before `b`,
+ *            a positive number if `a` should come after `b`,
+ *            or 0 if they have the same distance and `colStart` values.
+ */
+export const sortByDistanceInResponsiveFunction = (a, b, _device) => {
+    if (a.distance === b.distance) {
+        return (a.element.position.responsive[CanvasDevice.DESKTOP].colStart -
+            b.element.position.responsive[CanvasDevice.DESKTOP].colStart);
+    }
+    return a.distance - b.distance;
+};
+export const sortResponsiveElements = (elements, sortByDevice) => {
+    const sortedElements = calculateDistancesToReferencePoint(elements, sortByDevice, {
+        x: 1,
+        y: 1,
+    }).sort((a, b) => sortByDistanceInResponsiveFunction(a, b, sortByDevice));
+    return sortedElements.map((element) => element.element);
+};

package/dist/elements/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./helpers/index";
+export * from "./interfaces/index";

package/dist/elements/index.js

@@ -0,0 +1,2 @@
+export * from "./helpers/index";
+export * from "./interfaces/index";

package/dist/elements/interfaces/ICanvasGrid.d.ts

@@ -0,0 +1,5 @@
+export declare enum CanvasDevice {
+    DESKTOP = "desktop",
+    TABLET = "tablet",
+    MOBILE = "mobile"
+}

package/dist/elements/interfaces/ICanvasGrid.js

@@ -0,0 +1,6 @@
+export var CanvasDevice;
+(function (CanvasDevice) {
+    CanvasDevice["DESKTOP"] = "desktop";
+    CanvasDevice["TABLET"] = "tablet";
+    CanvasDevice["MOBILE"] = "mobile";
+})(CanvasDevice || (CanvasDevice = {}));

package/dist/elements/interfaces/IFixedPosition.d.ts

@@ -0,0 +1,5 @@
+export interface FindAvailablePositionOptions {
+    initialY?: number;
+    findRightToLeft?: boolean;
+    canvasHeight?: number;
+}

package/dist/elements/interfaces/IFixedPosition.js

@@ -0,0 +1 @@
+export {};

package/dist/elements/interfaces/IVemCore.d.ts

@@ -0,0 +1,29 @@
+import { VemPositionConfigFixed, VemPositionConfigMap, VemPositionConfigResponsive, VemPositionType } from "./IVemPosition";
+interface VemBase {
+    elementId: string;
+    type: string;
+    contentId?: string;
+}
+export interface VemCorePosition {
+    fixed?: VemPositionConfigFixed;
+    responsive?: VemPositionConfigResponsive;
+}
+interface VemCore<TPosition extends VemPositionType | unknown, TItemData = unknown> extends VemBase {
+    itemData: TItemData;
+    /** Indicates if its a personalized Vem */
+    isEup?: boolean;
+    /** Data to be saved in the client chart when it's saved by EUP (Only applies for VemAnalytics) */
+    chartBody?: unknown;
+    /** Dashboard Actions in the element */
+    actions?: unknown[];
+    position: TPosition extends VemPositionType ? VemCorePosition & Record<TPosition, VemPositionConfigMap[TPosition]> : VemCorePosition;
+}
+export type Vem<T = unknown, TPosition extends VemPositionType = VemPositionType> = VemCore<TPosition, T>;
+export type VemPos<TPosition extends VemPositionType> = VemCore<TPosition>;
+export type VemResponsive<T = unknown> = VemCore<VemPositionType.RESPONSIVE, T>;
+export type VemFixed<T = unknown> = VemCore<VemPositionType.FIXED, T>;
+export interface VemElementMap<T = unknown> {
+    [VemPositionType.FIXED]: VemFixed<T>;
+    [VemPositionType.RESPONSIVE]: VemResponsive<T>;
+}
+export {};

package/dist/elements/interfaces/IVemCore.js

@@ -0,0 +1 @@
+import { VemPositionType, } from "./IVemPosition";

package/dist/elements/interfaces/IVemPosition.d.ts

@@ -0,0 +1,44 @@
+export interface VemSizeFixed {
+    width: number;
+    height: number;
+}
+export interface VemSizeResponsive {
+    colSpan: number;
+    rowSpan: number;
+}
+export interface VemPositionFixed extends VemSizeFixed {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface VemPositionResponsive extends VemSizeResponsive {
+    colStart: number;
+    rowStart: number;
+}
+export type VemPosition = VemPositionFixed | VemPositionResponsive;
+export interface VemPositionMap {
+    [VemPositionType.FIXED]: VemPositionFixed;
+    [VemPositionType.RESPONSIVE]: VemPositionResponsive;
+}
+export declare enum VemPositionType {
+    FIXED = "fixed",
+    RESPONSIVE = "responsive"
+}
+interface VemPositionBase<TPosition extends VemPosition> {
+    desktop: TPosition;
+    tablet?: TPosition;
+    mobile?: TPosition;
+}
+export type VemPositionConfigFixed = VemPositionBase<VemPositionFixed>;
+export type VemPositionConfigResponsive = VemPositionBase<VemPositionResponsive>;
+export type VemPositionConfig = VemPositionConfigFixed | VemPositionConfigResponsive;
+export interface VemPositionConfigMap {
+    [VemPositionType.FIXED]: VemPositionConfigFixed;
+    [VemPositionType.RESPONSIVE]: VemPositionConfigResponsive;
+}
+export type VemSize = VemSizeFixed | VemSizeResponsive;
+export interface VemSizeConfig {
+    [VemPositionType.FIXED]: VemSizeFixed;
+    [VemPositionType.RESPONSIVE]: VemSizeResponsive;
+}
+export {};

package/dist/elements/interfaces/IVemPosition.js

@@ -0,0 +1,5 @@
+export var VemPositionType;
+(function (VemPositionType) {
+    VemPositionType["FIXED"] = "fixed";
+    VemPositionType["RESPONSIVE"] = "responsive";
+})(VemPositionType || (VemPositionType = {}));

package/dist/elements/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ICanvasGrid";
+export * from "./IFixedPosition";
+export * from "./IVemCore";
+export * from "./IVemPosition";

package/dist/elements/interfaces/index.js

@@ -0,0 +1,4 @@
+export * from "./ICanvasGrid";
+export * from "./IFixedPosition";
+export * from "./IVemCore";
+export * from "./IVemPosition";

package/dist/elements/utils/element.d.ts

@@ -0,0 +1,4 @@
+import { CanvasDevice } from "../interfaces/ICanvasGrid";
+import { Vem } from "../interfaces/IVemCore";
+import { VemPositionType } from "../interfaces/IVemPosition";
+export declare const copyDesktopPositionToDevice: (elements: Vem[], newCanvasDevice: CanvasDevice, canvasType: VemPositionType) => Vem[];

package/dist/elements/utils/element.js

@@ -0,0 +1,24 @@
+import { setElementPosition } from "./position";
+import { CanvasDevice } from "../interfaces/ICanvasGrid";
+import { VemPositionType, } from "../interfaces/IVemPosition";
+export const copyDesktopPositionToDevice = (elements, newCanvasDevice, canvasType) => {
+    const defaultPositionMap = {
+        [VemPositionType.FIXED]: {
+            x: 0,
+            y: 0,
+        },
+        [VemPositionType.RESPONSIVE]: {
+            colStart: 1,
+            rowStart: 1,
+        },
+    };
+    return elements.map((element) => {
+        var _a;
+        if (!((_a = element.position[canvasType]) === null || _a === void 0 ? void 0 : _a[newCanvasDevice])) {
+            const desktopViewPosition = element.position[canvasType][CanvasDevice.DESKTOP];
+            const newDevicePosition = Object.assign(Object.assign(Object.assign({}, desktopViewPosition), defaultPositionMap[canvasType]), { preCalculated: true });
+            return setElementPosition(element, canvasType, newCanvasDevice, newDevicePosition);
+        }
+        return element;
+    });
+};

package/dist/elements/utils/fixed.position.d.ts

@@ -0,0 +1,12 @@
+import { CanvasDevice, VemFixed, VemPositionFixed } from "../interfaces";
+export declare const hasOverflow: (element: VemFixed, device: CanvasDevice, resolution: number, canvasHeight?: number) => boolean;
+export declare const hasOverlap: (element: VemFixed, elements: VemFixed[], device: CanvasDevice) => number;
+export declare const itemXOverflow: (item: VemFixed, device: CanvasDevice, resolution: number) => boolean;
+export declare const itemYOverflow: (item: VemFixed, device: CanvasDevice, canvasHeight: number) => boolean;
+export declare const checkFixedGridItemsOverlap: (item: VemPositionFixed, itemToCompare: VemPositionFixed) => boolean;
+export declare const dxGetFixedGridItemDevice: (element: VemFixed, device: CanvasDevice) => VemPositionFixed;
+export declare const dxGetFixedGridItemX: (element: VemFixed, device: CanvasDevice, allowNegative?: boolean) => number;
+export declare const dxGetFixedGridItemY: (element: VemFixed, device: CanvasDevice, allowNegative?: boolean) => number;
+export declare const dxGetFixedGridItemZ: (element: VemFixed, device: CanvasDevice) => number;
+export declare const dxGetFixedGridItemHeight: (element: VemFixed, device: CanvasDevice) => number;
+export declare const dxGetFixedGridItemWidth: (element: VemFixed, device: CanvasDevice) => number;

package/dist/elements/utils/fixed.position.js

@@ -0,0 +1,72 @@
+export const hasOverflow = (element, device, resolution, canvasHeight) => {
+    const hasXOverflow = itemXOverflow(element, device, resolution);
+    const hasYOverflow = canvasHeight
+        ? itemYOverflow(element, device, canvasHeight)
+        : false;
+    return hasXOverflow || hasYOverflow;
+};
+export const hasOverlap = (element, elements, device) => {
+    const elementPosition = element.position.fixed[device];
+    if (!elementPosition)
+        return;
+    const overlappingElements = elements.filter((cElement) => checkFixedGridItemsOverlap(elementPosition, cElement.position.fixed[device]));
+    return overlappingElements.length;
+};
+export const itemXOverflow = (item, device, resolution) => {
+    const fixedPosition = item.position.fixed;
+    return (!!fixedPosition[device] &&
+        fixedPosition[device].x + fixedPosition[device].width > resolution);
+};
+export const itemYOverflow = (item, device, canvasHeight) => {
+    const fixedPosition = item.position.fixed;
+    return (!!fixedPosition[device] &&
+        fixedPosition[device].y + fixedPosition[device].height > canvasHeight);
+};
+export const checkFixedGridItemsOverlap = (item, itemToCompare) => {
+    return !(item.x + item.width < itemToCompare.x ||
+        item.x > itemToCompare.x + itemToCompare.width ||
+        item.y + item.height < itemToCompare.y ||
+        item.y > itemToCompare.y + itemToCompare.height);
+};
+export const dxGetFixedGridItemDevice = (element, device) => {
+    return {
+        x: dxGetFixedGridItemX(element, device),
+        y: dxGetFixedGridItemY(element, device),
+        z: dxGetFixedGridItemZ(element, device),
+        height: dxGetFixedGridItemHeight(element, device),
+        width: dxGetFixedGridItemWidth(element, device),
+    };
+};
+export const dxGetFixedGridItemX = (element, device, allowNegative = false) => {
+    var _a;
+    const position = element.position.fixed[device];
+    const itemX = (_a = position === null || position === void 0 ? void 0 : position.x) !== null && _a !== void 0 ? _a : 0;
+    if (!allowNegative) {
+        return itemX >= 0 ? itemX : 0;
+    }
+    return itemX;
+};
+export const dxGetFixedGridItemY = (element, device, allowNegative = false) => {
+    var _a;
+    const position = element.position.fixed[device];
+    const itemY = (_a = position === null || position === void 0 ? void 0 : position.y) !== null && _a !== void 0 ? _a : 0;
+    if (!allowNegative) {
+        return itemY >= 0 ? itemY : 0;
+    }
+    return itemY;
+};
+export const dxGetFixedGridItemZ = (element, device) => {
+    var _a;
+    const position = element.position.fixed[device];
+    return (_a = position === null || position === void 0 ? void 0 : position.z) !== null && _a !== void 0 ? _a : 1;
+};
+export const dxGetFixedGridItemHeight = (element, device) => {
+    var _a;
+    const position = element.position.fixed[device];
+    return (_a = position === null || position === void 0 ? void 0 : position.height) !== null && _a !== void 0 ? _a : 400;
+};
+export const dxGetFixedGridItemWidth = (element, device) => {
+    var _a;
+    const position = element.position.fixed[device];
+    return (_a = position === null || position === void 0 ? void 0 : position.width) !== null && _a !== void 0 ? _a : 400;
+};

package/dist/elements/utils/general.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Compares two objects based on their `distance` property and determines their relative order.
+ * @param a - An object with a `distance` property (number).
+ * @param b - Another object with a `distance` property (number).
+ * @param a.distance
+ * @param b.distance
+ * @returns - A negative number if `a` has a smaller distance than `b`,
+ *            a positive number if `a` has a larger distance than `b`,
+ *            or 0 if both have equal distances.
+ */
+export declare const sortByDistanceFunction: (a: {
+    distance: number;
+}, b: {
+    distance: number;
+}) => 0 | 1 | -1;

package/dist/elements/utils/general.js

@@ -0,0 +1,16 @@
+/**
+ * Compares two objects based on their `distance` property and determines their relative order.
+ * @param a - An object with a `distance` property (number).
+ * @param b - Another object with a `distance` property (number).
+ * @param a.distance
+ * @param b.distance
+ * @returns - A negative number if `a` has a smaller distance than `b`,
+ *            a positive number if `a` has a larger distance than `b`,
+ *            or 0 if both have equal distances.
+ */
+export const sortByDistanceFunction = (a, b) => {
+    if (a.distance === b.distance) {
+        return 0;
+    }
+    return a.distance < b.distance ? -1 : 1;
+};

package/dist/elements/utils/overlap.d.ts

@@ -0,0 +1,63 @@
+interface OverlapNode {
+    startX: number;
+    endX: number;
+    startY: number;
+    endY: number;
+    maxEndX: number;
+    maxEndY: number;
+    left?: OverlapNode;
+    right?: OverlapNode;
+}
+/**
+ *
+ */
+export declare class OverlapIntervalTree {
+    root?: OverlapNode;
+    /**
+     *
+     */
+    constructor();
+    /**
+     *
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    insert(startX: number, endX: number, startY: number, endY: number): void;
+    /**
+     *
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    private _initNode;
+    /**
+     *
+     * @param node
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    private _insert;
+    /**
+     *
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    overlaps(startX: number, endX: number, startY: number, endY: number): boolean;
+    /**
+     *
+     * @param node
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    private _overlaps;
+}
+export {};