@qrvey/utils 1.15.0-23 → 1.15.0-25

package/dist/cjs/columns/helpers/index.d.ts

@@ -6,3 +6,4 @@ export * from "./isComplexColumn";
 export * from "./isCompoundColumn";
 export * from "./isDateColumn";
 export * from "./isNumericalColumn";
+export * from "./isStringColumn";

package/dist/cjs/columns/helpers/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./isComplexColumn"), exports);
 __exportStar(require("./isCompoundColumn"), exports);
 __exportStar(require("./isDateColumn"), exports);
 __exportStar(require("./isNumericalColumn"), exports);
+__exportStar(require("./isStringColumn"), exports);

package/dist/cjs/elements/helpers/fixed.d.ts

@@ -37,11 +37,22 @@ export declare const getFixedPositionByDevice: (item: VemFixed, device: CanvasDe
  * @param [startWithPositionY] - Whether to start the position search for each new element based on its initial Y-coordinate. Defaults to `false`.
  * @param [findRightToLeft] - Whether to search for positions from right to left. Defaults to `false`.
  * @param [canvasHeight] - The maximum height of the canvas in pixels. If not provided, the search height is unlimited.
- * @returns
+ * @returns List of elements with their recalculated positions.
  */
 export declare function findFixedAvailablePositions(canvasWidth: number, newElements: VemFixed[], elements: VemFixed[], device: CanvasDevice, startWithPositionY?: boolean, findRightToLeft?: boolean, canvasHeight?: number): VemFixed[];
 /**
- * Adjusts the `width` of a responsive element to fit within the specified canvas width and updates its position.
+ * Recalculates the positions of elements on the canvas, preserving the position of those
+ * that meet certain conditions (no overflow or overlap). Elements that do not meet these
+ * conditions are recalculated to find a new valid position.
+ * @param elements - List of elements to recalculate.
+ * @param device - The device on which the canvas is being rendered.
+ * @param resolution - The resolution of the canvas.
+ * @param [canvasHeight] - Optional height of the canvas.
+ * @returns - List of elements with their recalculated positions.
+ */
+export declare const recalculatePreservingPositions: (elements: VemFixed[], device: CanvasDevice, resolution: number, canvasHeight?: number) => VemFixed[];
+/**
+ * Adjusts the `width` of a fixed element to fit within the specified canvas width and updates its position.
  * @param element - The fixed element to adjust.
  * @param canvasWidth - The width of the canvas in grid columns.
  * @param canvasDevice - The target device type (e.g., desktop, tablet, mobile).

package/dist/cjs/elements/helpers/fixed.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortElementsFromReferencePoint = exports.calculateDistancesToReferencePoint = exports.getFixedGridElementsBottomLimit = exports.calculateWidth = exports.findFixedAvailablePositions = exports.getFixedPositionByDevice = exports.findAvailablePosition = exports.updateFixedPosition = void 0;
+exports.sortElementsFromReferencePoint = exports.calculateDistancesToReferencePoint = exports.getFixedGridElementsBottomLimit = exports.calculateWidth = exports.recalculatePreservingPositions = exports.findFixedAvailablePositions = exports.getFixedPositionByDevice = exports.findAvailablePosition = exports.updateFixedPosition = void 0;
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+const ICanvasGrid_1 = require("../interfaces/ICanvasGrid");
 const IVemPosition_1 = require("../interfaces/IVemPosition");
+const fixed_position_1 = require("../utils/fixed.position");
 const general_1 = require("../utils/general");
 const overlap_1 = require("../utils/overlap");
 const position_1 = require("../utils/position");
@@ -90,7 +93,7 @@ const isValidPosition = (position) => {
  * @param [startWithPositionY] - Whether to start the position search for each new element based on its initial Y-coordinate. Defaults to `false`.
  * @param [findRightToLeft] - Whether to search for positions from right to left. Defaults to `false`.
  * @param [canvasHeight] - The maximum height of the canvas in pixels. If not provided, the search height is unlimited.
- * @returns
+ * @returns List of elements with their recalculated positions.
  */
 function findFixedAvailablePositions(canvasWidth, newElements, elements, device, startWithPositionY = false, findRightToLeft = false, canvasHeight) {
     const processedElements = elements.slice();
@@ -109,7 +112,50 @@ function findFixedAvailablePositions(canvasWidth, newElements, elements, device,
 }
 exports.findFixedAvailablePositions = findFixedAvailablePositions;
 /**
- * Adjusts the `width` of a responsive element to fit within the specified canvas width and updates its position.
+ * Recalculates the positions of elements on the canvas, preserving the position of those
+ * that meet certain conditions (no overflow or overlap). Elements that do not meet these
+ * conditions are recalculated to find a new valid position.
+ * @param elements - List of elements to recalculate.
+ * @param device - The device on which the canvas is being rendered.
+ * @param resolution - The resolution of the canvas.
+ * @param [canvasHeight] - Optional height of the canvas.
+ * @returns - List of elements with their recalculated positions.
+ */
+const recalculatePreservingPositions = (elements, device, resolution, canvasHeight) => {
+    const keepElementPositions = getElementsWithKeepPosition([...elements], device, resolution, canvasHeight);
+    const elementIds = keepElementPositions.map((element) => element.elementId);
+    const elementsToCalculate = elements.filter((cElement) => !elementIds.includes(cElement.elementId));
+    const defaultElements = keepElementPositions.length
+        ? keepElementPositions
+        : [];
+    const currentElements = canvasHeight ? defaultElements : elements;
+    const newElements = findFixedAvailablePositions(resolution, elementsToCalculate, currentElements, device, false, false, canvasHeight);
+    return [...keepElementPositions, ...newElements];
+};
+exports.recalculatePreservingPositions = recalculatePreservingPositions;
+/**
+ * Filters elements that should retain their current position on the canvas by checking
+ * that they do not have overflow (spilling outside the canvas) or overlap (colliding with other elements).
+ * @param elements - List of elements to check.
+ * @param device - The device on which the canvas is being rendered.
+ * @param resolution - The resolution of the canvas.
+ * @param [canvasHeight] - Optional height of the canvas.
+ * @returns - List of elements that can retain their current position.
+ */
+const getElementsWithKeepPosition = (elements, device, resolution, canvasHeight) => {
+    const calculatedElements = elements.map((mElement) => {
+        const desktopPosition = (0, fixed_position_1.dxGetFixedGridItemDevice)(mElement, ICanvasGrid_1.CanvasDevice.DESKTOP);
+        return updateFixedPosition(mElement, desktopPosition, device);
+    });
+    return calculatedElements.filter((cElement) => {
+        const currentElements = calculatedElements.filter((fElement) => fElement.elementId !== cElement.elementId);
+        const overflow = (0, fixed_position_1.hasOverflow)(cElement, device, resolution, canvasHeight);
+        const overlap = (0, fixed_position_1.hasOverlap)(cElement, currentElements, device);
+        return !overflow && !overlap;
+    });
+};
+/**
+ * Adjusts the `width` of a fixed element to fit within the specified canvas width and updates its position.
  * @param element - The fixed element to adjust.
  * @param canvasWidth - The width of the canvas in grid columns.
  * @param canvasDevice - The target device type (e.g., desktop, tablet, mobile).
@@ -117,11 +163,19 @@ exports.findFixedAvailablePositions = findFixedAvailablePositions;
  */
 function calculateWidth(element, canvasWidth, canvasDevice) {
     const currentPosition = element.position.fixed[canvasDevice];
-    const fixedWidth = Math.min(currentPosition.width, canvasWidth);
+    const fixedWidth = Math.min(currentPosition === null || currentPosition === void 0 ? void 0 : currentPosition.width, canvasWidth);
     const position = Object.assign(Object.assign({}, currentPosition), { width: fixedWidth });
     return (0, position_1.setElementPosition)(element, IVemPosition_1.VemPositionType.FIXED, canvasDevice, position);
 }
 exports.calculateWidth = calculateWidth;
+/**
+ * Retrieves the Y-coordinate of a fixed grid element for a specific device.
+ * If `allowNegative` is false (default), the function ensures the Y-coordinate is non-negative.
+ * @param element - The element to retrieve the Y-coordinate from.
+ * @param device - The device for which the Y-coordinate is calculated.
+ * @param [allowNegative] - Whether to allow negative Y-coordinates.
+ * @returns - The Y-coordinate of the element.
+ */
 const getFixedGridElementY = (element, device, allowNegative = false) => {
     var _a;
     const position = element.position.fixed[device];
@@ -131,6 +185,12 @@ const getFixedGridElementY = (element, device, allowNegative = false) => {
     }
     return itemY;
 };
+/**
+ * Retrieves the height of a fixed grid element for a specific device.
+ * @param element - The element to retrieve the height from.
+ * @param device - The device for which the height is calculated.
+ * @returns - The height of the element, or undefined if not defined.
+ */
 const getFixedGridElementHeight = (element, device) => {
     const position = element.position.fixed[device];
     return position === null || position === void 0 ? void 0 : position.height;

package/dist/cjs/elements/helpers/gridStrategy.d.ts

@@ -3,6 +3,7 @@ interface RecalculateOptions {
     canvasHeight?: number;
     sort?: CanvasDevice;
     allowCopy?: boolean;
+    keepPosition?: boolean;
 }
 /**
  * Recalculates the positions of elements on a canvas based on the canvas type.

package/dist/cjs/elements/helpers/gridStrategy.js

@@ -18,7 +18,9 @@ const recalculateStrategies = {
                 y: 0,
             })
             : changedElements;
-        return (0, fixed_1.findFixedAvailablePositions)(canvasWidth, orderedElements, currentElements, device, false, false, options === null || options === void 0 ? void 0 : options.canvasHeight);
+        return options.canvasHeight
+            ? (0, fixed_1.recalculatePreservingPositions)(orderedElements, device, canvasWidth, options.canvasHeight)
+            : (0, fixed_1.findFixedAvailablePositions)(canvasWidth, orderedElements, currentElements, device, false, false, options === null || options === void 0 ? void 0 : options.canvasHeight);
     },
     responsive: (elements, currentElements, canvasWidth, device, options) => {
         const isSorted = !currentElements.length;

package/dist/cjs/elements/utils/element.js

@@ -19,7 +19,7 @@ const copyDesktopPositionToDevice = (elements, newCanvasDevice, canvasType) => {
         var _a;
         if (!((_a = element.position[canvasType]) === null || _a === void 0 ? void 0 : _a[newCanvasDevice])) {
             const desktopViewPosition = element.position[canvasType][ICanvasGrid_1.CanvasDevice.DESKTOP];
-            const newDevicePosition = Object.assign(Object.assign({}, desktopViewPosition), defaultPositionMap[canvasType]);
+            const newDevicePosition = Object.assign(Object.assign(Object.assign({}, desktopViewPosition), defaultPositionMap[canvasType]), { preCalculated: true });
             return (0, position_1.setElementPosition)(element, canvasType, newCanvasDevice, newDevicePosition);
         }
         return element;

package/dist/cjs/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/cjs/elements/utils/fixed.position.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dxGetFixedGridItemWidth = exports.dxGetFixedGridItemHeight = exports.dxGetFixedGridItemZ = exports.dxGetFixedGridItemY = exports.dxGetFixedGridItemX = exports.dxGetFixedGridItemDevice = exports.checkFixedGridItemsOverlap = exports.itemYOverflow = exports.itemXOverflow = exports.hasOverlap = exports.hasOverflow = void 0;
+const hasOverflow = (element, device, resolution, canvasHeight) => {
+    const hasXOverflow = (0, exports.itemXOverflow)(element, device, resolution);
+    const hasYOverflow = canvasHeight
+        ? (0, exports.itemYOverflow)(element, device, canvasHeight)
+        : false;
+    return hasXOverflow || hasYOverflow;
+};
+exports.hasOverflow = hasOverflow;
+const hasOverlap = (element, elements, device) => {
+    const elementPosition = element.position.fixed[device];
+    if (!elementPosition)
+        return;
+    const overlappingElements = elements.filter((cElement) => (0, exports.checkFixedGridItemsOverlap)(elementPosition, cElement.position.fixed[device]));
+    return overlappingElements.length;
+};
+exports.hasOverlap = hasOverlap;
+const itemXOverflow = (item, device, resolution) => {
+    const fixedPosition = item.position.fixed;
+    return (!!fixedPosition[device] &&
+        fixedPosition[device].x + fixedPosition[device].width > resolution);
+};
+exports.itemXOverflow = itemXOverflow;
+const itemYOverflow = (item, device, canvasHeight) => {
+    const fixedPosition = item.position.fixed;
+    return (!!fixedPosition[device] &&
+        fixedPosition[device].y + fixedPosition[device].height > canvasHeight);
+};
+exports.itemYOverflow = itemYOverflow;
+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);
+};
+exports.checkFixedGridItemsOverlap = checkFixedGridItemsOverlap;
+const dxGetFixedGridItemDevice = (element, device) => {
+    return {
+        x: (0, exports.dxGetFixedGridItemX)(element, device),
+        y: (0, exports.dxGetFixedGridItemY)(element, device),
+        z: (0, exports.dxGetFixedGridItemZ)(element, device),
+        height: (0, exports.dxGetFixedGridItemHeight)(element, device),
+        width: (0, exports.dxGetFixedGridItemWidth)(element, device),
+    };
+};
+exports.dxGetFixedGridItemDevice = dxGetFixedGridItemDevice;
+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;
+};
+exports.dxGetFixedGridItemX = dxGetFixedGridItemX;
+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;
+};
+exports.dxGetFixedGridItemY = dxGetFixedGridItemY;
+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;
+};
+exports.dxGetFixedGridItemZ = dxGetFixedGridItemZ;
+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;
+};
+exports.dxGetFixedGridItemHeight = dxGetFixedGridItemHeight;
+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;
+};
+exports.dxGetFixedGridItemWidth = dxGetFixedGridItemWidth;

package/dist/columns/helpers/index.d.ts

@@ -6,3 +6,4 @@ export * from "./isComplexColumn";
 export * from "./isCompoundColumn";
 export * from "./isDateColumn";
 export * from "./isNumericalColumn";
+export * from "./isStringColumn";

package/dist/columns/helpers/index.js

@@ -6,3 +6,4 @@ export * from "./isComplexColumn";
 export * from "./isCompoundColumn";
 export * from "./isDateColumn";
 export * from "./isNumericalColumn";
+export * from "./isStringColumn";

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

@@ -37,11 +37,22 @@ export declare const getFixedPositionByDevice: (item: VemFixed, device: CanvasDe
  * @param [startWithPositionY] - Whether to start the position search for each new element based on its initial Y-coordinate. Defaults to `false`.
  * @param [findRightToLeft] - Whether to search for positions from right to left. Defaults to `false`.
  * @param [canvasHeight] - The maximum height of the canvas in pixels. If not provided, the search height is unlimited.
- * @returns
+ * @returns List of elements with their recalculated positions.
  */
 export declare function findFixedAvailablePositions(canvasWidth: number, newElements: VemFixed[], elements: VemFixed[], device: CanvasDevice, startWithPositionY?: boolean, findRightToLeft?: boolean, canvasHeight?: number): VemFixed[];
 /**
- * Adjusts the `width` of a responsive element to fit within the specified canvas width and updates its position.
+ * Recalculates the positions of elements on the canvas, preserving the position of those
+ * that meet certain conditions (no overflow or overlap). Elements that do not meet these
+ * conditions are recalculated to find a new valid position.
+ * @param elements - List of elements to recalculate.
+ * @param device - The device on which the canvas is being rendered.
+ * @param resolution - The resolution of the canvas.
+ * @param [canvasHeight] - Optional height of the canvas.
+ * @returns - List of elements with their recalculated positions.
+ */
+export declare const recalculatePreservingPositions: (elements: VemFixed[], device: CanvasDevice, resolution: number, canvasHeight?: number) => VemFixed[];
+/**
+ * Adjusts the `width` of a fixed element to fit within the specified canvas width and updates its position.
  * @param element - The fixed element to adjust.
  * @param canvasWidth - The width of the canvas in grid columns.
  * @param canvasDevice - The target device type (e.g., desktop, tablet, mobile).

package/dist/elements/helpers/fixed.js

@@ -1,4 +1,7 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+import { CanvasDevice } from "../interfaces/ICanvasGrid";
 import { VemPositionType } from "../interfaces/IVemPosition";
+import { dxGetFixedGridItemDevice, hasOverflow, hasOverlap, } from "../utils/fixed.position";
 import { sortByDistanceFunction } from "../utils/general";
 import { OverlapIntervalTree } from "../utils/overlap";
 import { setElementPosition } from "../utils/position";
@@ -84,7 +87,7 @@ const isValidPosition = (position) => {
  * @param [startWithPositionY] - Whether to start the position search for each new element based on its initial Y-coordinate. Defaults to `false`.
  * @param [findRightToLeft] - Whether to search for positions from right to left. Defaults to `false`.
  * @param [canvasHeight] - The maximum height of the canvas in pixels. If not provided, the search height is unlimited.
- * @returns
+ * @returns List of elements with their recalculated positions.
  */
 export function findFixedAvailablePositions(canvasWidth, newElements, elements, device, startWithPositionY = false, findRightToLeft = false, canvasHeight) {
     const processedElements = elements.slice();
@@ -102,7 +105,49 @@ export function findFixedAvailablePositions(canvasWidth, newElements, elements,
     return resultElems;
 }
 /**
- * Adjusts the `width` of a responsive element to fit within the specified canvas width and updates its position.
+ * Recalculates the positions of elements on the canvas, preserving the position of those
+ * that meet certain conditions (no overflow or overlap). Elements that do not meet these
+ * conditions are recalculated to find a new valid position.
+ * @param elements - List of elements to recalculate.
+ * @param device - The device on which the canvas is being rendered.
+ * @param resolution - The resolution of the canvas.
+ * @param [canvasHeight] - Optional height of the canvas.
+ * @returns - List of elements with their recalculated positions.
+ */
+export const recalculatePreservingPositions = (elements, device, resolution, canvasHeight) => {
+    const keepElementPositions = getElementsWithKeepPosition([...elements], device, resolution, canvasHeight);
+    const elementIds = keepElementPositions.map((element) => element.elementId);
+    const elementsToCalculate = elements.filter((cElement) => !elementIds.includes(cElement.elementId));
+    const defaultElements = keepElementPositions.length
+        ? keepElementPositions
+        : [];
+    const currentElements = canvasHeight ? defaultElements : elements;
+    const newElements = findFixedAvailablePositions(resolution, elementsToCalculate, currentElements, device, false, false, canvasHeight);
+    return [...keepElementPositions, ...newElements];
+};
+/**
+ * Filters elements that should retain their current position on the canvas by checking
+ * that they do not have overflow (spilling outside the canvas) or overlap (colliding with other elements).
+ * @param elements - List of elements to check.
+ * @param device - The device on which the canvas is being rendered.
+ * @param resolution - The resolution of the canvas.
+ * @param [canvasHeight] - Optional height of the canvas.
+ * @returns - List of elements that can retain their current position.
+ */
+const getElementsWithKeepPosition = (elements, device, resolution, canvasHeight) => {
+    const calculatedElements = elements.map((mElement) => {
+        const desktopPosition = dxGetFixedGridItemDevice(mElement, CanvasDevice.DESKTOP);
+        return updateFixedPosition(mElement, desktopPosition, device);
+    });
+    return calculatedElements.filter((cElement) => {
+        const currentElements = calculatedElements.filter((fElement) => fElement.elementId !== cElement.elementId);
+        const overflow = hasOverflow(cElement, device, resolution, canvasHeight);
+        const overlap = hasOverlap(cElement, currentElements, device);
+        return !overflow && !overlap;
+    });
+};
+/**
+ * Adjusts the `width` of a fixed element to fit within the specified canvas width and updates its position.
  * @param element - The fixed element to adjust.
  * @param canvasWidth - The width of the canvas in grid columns.
  * @param canvasDevice - The target device type (e.g., desktop, tablet, mobile).
@@ -110,10 +155,18 @@ export function findFixedAvailablePositions(canvasWidth, newElements, elements,
  */
 export function calculateWidth(element, canvasWidth, canvasDevice) {
     const currentPosition = element.position.fixed[canvasDevice];
-    const fixedWidth = Math.min(currentPosition.width, canvasWidth);
+    const fixedWidth = Math.min(currentPosition === null || currentPosition === void 0 ? void 0 : currentPosition.width, canvasWidth);
     const position = Object.assign(Object.assign({}, currentPosition), { width: fixedWidth });
     return setElementPosition(element, VemPositionType.FIXED, canvasDevice, position);
 }
+/**
+ * Retrieves the Y-coordinate of a fixed grid element for a specific device.
+ * If `allowNegative` is false (default), the function ensures the Y-coordinate is non-negative.
+ * @param element - The element to retrieve the Y-coordinate from.
+ * @param device - The device for which the Y-coordinate is calculated.
+ * @param [allowNegative] - Whether to allow negative Y-coordinates.
+ * @returns - The Y-coordinate of the element.
+ */
 const getFixedGridElementY = (element, device, allowNegative = false) => {
     var _a;
     const position = element.position.fixed[device];
@@ -123,6 +176,12 @@ const getFixedGridElementY = (element, device, allowNegative = false) => {
     }
     return itemY;
 };
+/**
+ * Retrieves the height of a fixed grid element for a specific device.
+ * @param element - The element to retrieve the height from.
+ * @param device - The device for which the height is calculated.
+ * @returns - The height of the element, or undefined if not defined.
+ */
 const getFixedGridElementHeight = (element, device) => {
     const position = element.position.fixed[device];
     return position === null || position === void 0 ? void 0 : position.height;

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

@@ -3,6 +3,7 @@ interface RecalculateOptions {
     canvasHeight?: number;
     sort?: CanvasDevice;
     allowCopy?: boolean;
+    keepPosition?: boolean;
 }
 /**
  * Recalculates the positions of elements on a canvas based on the canvas type.

package/dist/elements/helpers/gridStrategy.js

@@ -1,4 +1,4 @@
-import { findFixedAvailablePositions, getFixedGridElementsBottomLimit, sortElementsFromReferencePoint, } from "./fixed";
+import { findFixedAvailablePositions, getFixedGridElementsBottomLimit, recalculatePreservingPositions, sortElementsFromReferencePoint, } from "./fixed";
 import { findResponsiveAvailablePositions, getResponsiveGridElementsBottomLimit, sortResponsiveElements, } from "./responsive";
 import { CanvasDevice, VemPositionType, } from "../interfaces";
 import { copyDesktopPositionToDevice } from "../utils/element";
@@ -15,7 +15,9 @@ const recalculateStrategies = {
                 y: 0,
             })
             : changedElements;
-        return findFixedAvailablePositions(canvasWidth, orderedElements, currentElements, device, false, false, options === null || options === void 0 ? void 0 : options.canvasHeight);
+        return options.canvasHeight
+            ? recalculatePreservingPositions(orderedElements, device, canvasWidth, options.canvasHeight)
+            : findFixedAvailablePositions(canvasWidth, orderedElements, currentElements, device, false, false, options === null || options === void 0 ? void 0 : options.canvasHeight);
     },
     responsive: (elements, currentElements, canvasWidth, device, options) => {
         const isSorted = !currentElements.length;

package/dist/elements/utils/element.js

@@ -16,7 +16,7 @@ export const copyDesktopPositionToDevice = (elements, newCanvasDevice, canvasTyp
         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({}, desktopViewPosition), defaultPositionMap[canvasType]);
+            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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qrvey/utils",
-  "version": "1.15.0-23",
+  "version": "1.15.0-25",
   "description": "Helper, Utils for all Qrvey Projects",
   "homepage": "https://bitbucket.org/qrvey/qrvey_utils/wiki/Home",
   "main": "dist/index.js",