@qrvey/utils 1.16.0-2 → 1.16.0-21

package/dist/cjs/globalization/interfaces/formula_builder/II18nFormulaBuilderV2Functions.d.ts

@@ -76,11 +76,11 @@ export interface II18nFormulaBuilderV2Functions {
     roundup: II18nFormulaBuilderV2FunctionRound;
     millisecond: II18nFormulaBuilderV2FunctionMillisecond;
     text: II18nFormulaBuilderV2FunctionText;
-    agg_sum: II18nFormulaBuilderV2FunctionAggregate;
-    agg_avg: II18nFormulaBuilderV2FunctionAggregate;
-    agg_med: II18nFormulaBuilderV2FunctionAggregate;
-    agg_min: II18nFormulaBuilderV2FunctionAggregate;
-    agg_max: II18nFormulaBuilderV2FunctionAggregate;
-    agg_count: II18nFormulaBuilderV2FunctionAggregate;
-    agg_distcount: II18nFormulaBuilderV2FunctionAggregate;
+    sum: II18nFormulaBuilderV2FunctionAggregate;
+    avg: II18nFormulaBuilderV2FunctionAggregate;
+    med: II18nFormulaBuilderV2FunctionAggregate;
+    minval: II18nFormulaBuilderV2FunctionAggregate;
+    maxval: II18nFormulaBuilderV2FunctionAggregate;
+    count: II18nFormulaBuilderV2FunctionAggregate;
+    distcount: II18nFormulaBuilderV2FunctionAggregate;
 }

package/dist/cjs/globalization/labels/chart_builder/I18N_CHART_BUILDER_GENERAL.js

@@ -194,6 +194,7 @@ exports.I18N_CHART_BUILDER_GENERAL = {
     },
     messages_general: {
         chart_saved: "was saved successfully.",
+        chart_saved_ai: "Chart added to the Dataset",
     },
     messages_default: {
         max_data: "Chart shows a maximum number of data points by default. To see more, go to <i>General</i> chart options and increase the <i>Max Data</i> Points to display.",
@@ -202,6 +203,7 @@ exports.I18N_CHART_BUILDER_GENERAL = {
         max_panels_increment: "Increasing the amount of panels to display above {{max_data_point_values_panels}} can affect chart performance.",
         median_aggregation_results: "The numbers are not actual, they are for preview purposes only.",
         max_limit: "Only 10,000 max data points are supported.",
+        expanded_by_default: "The maximum supported limit for this feature (Expanded by default) is 500 rows and 50 columns.",
     },
     messages_crosstab: {
         max_data: "Chart shows a maximum number of data points by default. To see more, go to <i>General</i> chart options and increase the <i>Max Records</i> and <i>Max Columns</i> to display.",

package/dist/cjs/globalization/labels/chart_builder/I18N_CHART_BUILDER_GENERAL_OPTIONS.js

@@ -29,6 +29,10 @@ exports.I18N_CHART_BUILDER_GENERAL_OPTIONS = {
         view_sorting: "Sorting",
         view_subtotals: "Subtotals",
         view_total: "Totals",
+        expanded_by_default: "Expanded by default",
+        expanded_by_default_disabled: "This option is disabled. To enable it, limit the layout to a maximum of 2 rows and 2 columns.",
+        freeze_headers: "Freeze the column headers",
+        freeze_rows: "Freeze the row headers",
     },
     tooltip_settings: {
         name: "Tooltips",

package/dist/cjs/globalization/labels/chart_builder/I18N_CHART_BUILDER_STYLE_OPTIONS.js

@@ -56,6 +56,10 @@ exports.I18N_CHART_BUILDER_STYLE_OPTIONS = {
         heatmap_pivot_axis_caption: "pivot",
         global_y_axis_caption: "global",
         multiseries_type: "Multiseries Type",
+        default_format_date_title: "Date Format",
+        type_custom_format: "Custom Format",
+        type_custom_format_placeholder: "Type custom format",
+        type_custom_format_error: "Invalid format",
     },
     color_settings: {
         color_by_category: "By category",

package/dist/cjs/globalization/labels/dashboard/I18N_DASHBOARD.js

@@ -10,6 +10,7 @@ exports.I18N_DASHBOARD = {
         chart: "Chart",
         metric: "Metric",
         summary: "Summary",
+        add_ai: "Create Chart with AI",
     },
     empty_state: {
         about_charts: "about charts",

package/dist/cjs/globalization/labels/filters/I18N_FILTER.js

@@ -30,6 +30,7 @@ exports.I18N_FILTER = {
         global: "Global Filters",
         page: "Dashboard Filters",
         tab: "Tab Filters",
+        container: "Container Filters",
         chart: "Panel Filters",
         default: "Default Filters",
         action: "Action Filters",

package/dist/cjs/globalization/labels/filters/I18N_FILTER_SCOPE.js

@@ -11,6 +11,7 @@ exports.I18N_FILTER_SCOPE = {
     global: FILTER_SCOPE_LABEL_1.FILTER_SCOPE_LABEL.GLOBAL,
     page: FILTER_SCOPE_LABEL_1.FILTER_SCOPE_LABEL.PAGE,
     tab: FILTER_SCOPE_LABEL_1.FILTER_SCOPE_LABEL.TAB,
+    container: FILTER_SCOPE_LABEL_1.FILTER_SCOPE_LABEL.CONTAINER,
     default: FILTER_SCOPE_LABEL_1.FILTER_SCOPE_LABEL.DEFAULT,
     chart: FILTER_SCOPE_LABEL_1.FILTER_SCOPE_LABEL.CHART,
     action: FILTER_SCOPE_LABEL_1.FILTER_SCOPE_LABEL.ACTION,

package/dist/cjs/globalization/labels/formula_builder/I18N_FORMULA_BUILDER.js

@@ -39,7 +39,9 @@ exports.I18N_FORMULA_BUILDER = {
     },
     create_modal: {
         title_header_create: "Create Formula",
+        title_header_create_aggregate: "Create Aggregate Formula",
         title_header_edit: "Edit Formula",
+        title_header_edit_aggregate: "Edit Aggregate Formula",
         title_header_table: "Create Table Formula",
         name: "Formula Name",
         placeholder_name: "Type Formula Name",
@@ -385,45 +387,45 @@ exports.I18N_FORMULA_BUILDER = {
                     param_num1_name: "num1",
                     param_num1_description: "The number that you want to convert to text.",
                 },
-                agg_sum: {
+                sum: {
                     description: "Returns the aggregated sum of the numeric values of a column.",
-                    function_placeholder: "AGG_SUM(column)",
+                    function_placeholder: "SUM(column)",
                     param_column_name: "column",
                     param_column_description: "The numeric column that will be aggregated.",
                 },
-                agg_avg: {
+                avg: {
                     description: "Returns the average value for all the numeric values of a column.",
-                    function_placeholder: "AGG_AVG(column)",
+                    function_placeholder: "AVG(column)",
                     param_column_name: "column",
                     param_column_description: "The numeric column that will be aggregated.",
                 },
-                agg_med: {
+                med: {
                     description: "Returns the median value for all the numeric values of a column.",
-                    function_placeholder: "AGG_MED(column)",
+                    function_placeholder: "MED(column)",
                     param_column_name: "column",
                     param_column_description: "The numeric column that will be aggregated.",
                 },
-                agg_min: {
+                minval: {
                     description: "Returns the minimum value among all the numeric values of a column.",
-                    function_placeholder: "AGG_MIN(column)",
+                    function_placeholder: "MINVAL(column)",
                     param_column_name: "column",
                     param_column_description: "The numeric column that will be aggregated.",
                 },
-                agg_max: {
+                maxval: {
                     description: "Returns the maximum value among all the numeric values of a column.",
-                    function_placeholder: "AGG_MAX(column)",
+                    function_placeholder: "MAXVAL(column)",
                     param_column_name: "column",
                     param_column_description: "The numeric column that will be aggregated.",
                 },
-                agg_count: {
+                count: {
                     description: "Returns the count of all the values of a column.",
-                    function_placeholder: "AGG_COUNT(column)",
+                    function_placeholder: "COUNT(column)",
                     param_column_name: "column",
                     param_column_description: "The column that will be aggregated.",
                 },
-                agg_distcount: {
+                distcount: {
                     description: "Returns the count of all the distinct values of a column.",
-                    function_placeholder: "AGG_DISTCOUNT(column)",
+                    function_placeholder: "DISTCOUNT(column)",
                     param_column_name: "column",
                     param_column_description: "The column that will be aggregated.",
                 },

package/dist/column_format/helpers/columnTypeByChart.js

@@ -1,4 +1,4 @@
-import { NUMERICAL_COLUMN, NUMERICAL_COLUMNS } from "../..";
+import { AGGREGATE, NUMERICAL_COLUMN, NUMERICAL_COLUMNS } from "../..";
 import { COLUMN } from "../../columns";
 import { CHART_GROUPS } from "../constants/CHART_GROUP";
 import { SHELF_TYPE } from "../constants/SHELF_TYPE";
@@ -14,6 +14,7 @@ import { parseFormulaTypeByCharts } from "./parseFormulaTypeByCharts";
  * @returns The column type of the column.
  */
 export const columnTypeByChart = (column, shelfType, chartGroup, isGroupedTable) => {
+    var _a;
     if (!column)
         return;
     const currentType = column.type === COLUMN.FORMULA
@@ -22,7 +23,8 @@ export const columnTypeByChart = (column, shelfType, chartGroup, isGroupedTable)
     const isNumericalColumn = NUMERICAL_COLUMNS.some((colType) => colType === currentType) ||
         (chartGroup === CHART_GROUPS.TABLES &&
             isGroupedTable === true &&
-            shelfType === SHELF_TYPE.COLUMNS) ||
+            shelfType === SHELF_TYPE.COLUMNS &&
+            ![AGGREGATE.MIN, AGGREGATE.MAX].includes((_a = column === null || column === void 0 ? void 0 : column.aggregate) === null || _a === void 0 ? void 0 : _a.id)) ||
         (chartGroup === CHART_GROUPS.XY && shelfType === SHELF_TYPE.VALUE);
     return isNumericalColumn === true ? NUMERICAL_COLUMN.NUMERIC : currentType;
 };

package/dist/columns/interfaces/IColumn.d.ts

@@ -22,4 +22,5 @@ export interface IColumn extends Omit<IBColumn, "text" | "bucketId" | "formulaId
     property?: IColumnPropertyType;
     slidebarValue?: number;
     sorting?: IColumnSortingSettings;
+    formulaInputType?: string;
 }

package/dist/columns/interfaces/IColunmCalculation.d.ts

@@ -1,5 +1,10 @@
+export interface IColumnCalculationLevel {
+    id: string;
+    colIndex: number;
+}
 export interface IColumnCalculation {
     abbreviation: string;
     aggregate?: string;
     value?: string;
+    levels?: IColumnCalculationLevel;
 }

package/dist/constants/Charts.Const.d.ts

@@ -30,7 +30,8 @@ export declare enum CHART_TYPE {
     RADAR_CHART = "RADAR_CHART",
     TREEMAP_CHART = "TREEMAP_CHART",
     AREA_CHART = "AREA_CHART",
-    AREA_CHART_MS = "AREA_CHART_MS"
+    AREA_CHART_MS = "AREA_CHART_MS",
+    SCATTER_CHART = "SCATTER_CHART"
 }
 export declare enum CHART_DIMENSION {
     CATEGORIES = "categories",

package/dist/constants/Charts.Const.js

@@ -32,6 +32,7 @@ export var CHART_TYPE;
     CHART_TYPE["TREEMAP_CHART"] = "TREEMAP_CHART";
     CHART_TYPE["AREA_CHART"] = "AREA_CHART";
     CHART_TYPE["AREA_CHART_MS"] = "AREA_CHART_MS";
+    CHART_TYPE["SCATTER_CHART"] = "SCATTER_CHART";
 })(CHART_TYPE || (CHART_TYPE = {}));
 export var CHART_DIMENSION;
 (function (CHART_DIMENSION) {

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

@@ -2,6 +2,7 @@ import { CanvasDevice } from "../interfaces/ICanvasGrid";
 import { FindAvailablePositionOptions } from "../interfaces/IFixedPosition";
 import { VemFixed } from "../interfaces/IVemCore";
 import { VemPositionFixed } from "../interfaces/IVemPosition";
+export declare const CANVAS_EXTRA_HEIGHT = 10;
 /**
  * update the position for a specific device
  * @param element element to be updated
@@ -45,12 +46,13 @@ export declare function findFixedAvailablePositions(canvasWidth: number, newElem
  * 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 scopeElements - scope Elements
  * @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[];
+export declare const recalculatePreservingPositions: (elements: VemFixed[], scopeElements: 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.
@@ -94,3 +96,12 @@ export declare const sortElementsFromReferencePoint: (elements: VemFixed<unknown
     x: number;
     y: number;
 }) => VemFixed<unknown>[];
+/**
+ * Updates the height of a given container element based on the bottom limit of other scoped elements.
+ * It ensures the container has at least the height required to encompass all scoped elements.
+ * @param containerItem - The element to update.
+ * @param  device - The target device context (used to access device-specific dimensions).
+ * @param scopeElements
+ * @returns  - A new version of the container element with updated height if needed.
+ */
+export declare const updateFixedElementDimensions: (containerItem: VemFixed<unknown>, device: CanvasDevice, scopeElements: VemFixed<unknown>[]) => VemFixed<unknown>;

package/dist/elements/helpers/fixed.js

@@ -1,11 +1,13 @@
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
+import { objectCopy } from "../../general";
 import { CanvasDevice } from "../interfaces/ICanvasGrid";
 import { VemPositionType } from "../interfaces/IVemPosition";
-import { dxGetFixedGridItemDevice, hasOverflow, hasOverlap, } from "../utils/fixed.position";
+import { dxGetFixedGridItemDevice, dxGetFixedGridItemsBottomLimit, hasOverflow, hasOverlap, } from "../utils/fixed.position";
 import { sortByDistanceFunction } from "../utils/general";
 import { OverlapIntervalTree } from "../utils/overlap";
 import { setElementPosition } from "../utils/position";
 const SPACE_DELTA = 10;
+export const CANVAS_EXTRA_HEIGHT = 10;
 /**
  * update the position for a specific device
  * @param element element to be updated
@@ -109,19 +111,20 @@ export function findFixedAvailablePositions(canvasWidth, newElements, elements,
  * 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 scopeElements - scope Elements
  * @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);
+export const recalculatePreservingPositions = (elements, scopeElements, device, resolution, canvasHeight) => {
+    const keepElementPositions = getElementsWithKeepPosition([...elements], scopeElements, 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 currentElements = [...scopeElements, ...defaultElements];
     const newElements = findFixedAvailablePositions(resolution, elementsToCalculate, currentElements, device, false, false, canvasHeight);
     return [...keepElementPositions, ...newElements];
 };
@@ -129,18 +132,19 @@ export const recalculatePreservingPositions = (elements, device, resolution, can
  * 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 scopeElements - 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 getElementsWithKeepPosition = (elements, scopeElements, 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 currentElements = scopeElements.filter((fElement) => fElement.elementId !== cElement.elementId);
         const overflow = hasOverflow(cElement, device, resolution, canvasHeight);
         const overlap = hasOverlap(cElement, currentElements, device);
         return !overflow && !overlap;
@@ -234,3 +238,23 @@ export const sortElementsFromReferencePoint = (elements, device, referencePoint)
     const sortedElements = [...calculatedElements].sort(sortByDistanceFunction);
     return sortedElements.map((element) => element.element);
 };
+/**
+ * Updates the height of a given container element based on the bottom limit of other scoped elements.
+ * It ensures the container has at least the height required to encompass all scoped elements.
+ * @param containerItem - The element to update.
+ * @param  device - The target device context (used to access device-specific dimensions).
+ * @param scopeElements
+ * @returns  - A new version of the container element with updated height if needed.
+ */
+export const updateFixedElementDimensions = (containerItem, device, scopeElements) => {
+    let currentElement = objectCopy(containerItem);
+    const calculatedHeight = dxGetFixedGridItemsBottomLimit(scopeElements, device);
+    const currentHeight = currentElement.position.fixed[device].height;
+    const newHeight = calculatedHeight > currentHeight
+        ? calculatedHeight + CANVAS_EXTRA_HEIGHT
+        : currentHeight;
+    currentElement = updateFixedPosition(currentElement, {
+        height: newHeight,
+    }, device);
+    return Object.assign({}, currentElement);
+};

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

@@ -17,6 +17,19 @@ interface RecalculateOptions {
  * @returns - A list of elements with updated positions if the canvas type is "fixed" or "responsive".
  */
 export declare function recalculateElements(newElements: Vem[], currentElements: Vem[], canvasWidth: number, canvasType: string, device: CanvasDevice, options?: RecalculateOptions): Vem[];
+/**
+ * Updates the dimensions of a container element using a strategy based on the given canvas type.
+ *
+ * Delegates the update logic to a specific strategy found in `updateDimensionStrategies`
+ * using the provided `canvasType` key.
+ * @param containerItem The element whose dimensions need to be updated
+ * @param scopeElements A list of elements to consider in the update strategy
+ * @param device The device context (e.g., desktop, tablet, mobile) used to retrieve device-specific properties
+ * @param canvasType The type of canvas that determines which strategy to use.
+ * @param gap The type of canvas that determines which strategy to use.
+ * @returns  - The updated element with modified dimensions, or `undefined` if no strategy is found.
+ */
+export declare function applyDynamicSize(containerItem: Vem, scopeElements: Vem[], device: CanvasDevice, canvasType: string, gap?: number): Vem | undefined;
 /**
  * The calculation is delegated to a specific strategy based on the `canvasType`.
  * @param elements - The list of elements in the canvas.

package/dist/elements/helpers/gridStrategy.js

@@ -1,7 +1,15 @@
-import { findFixedAvailablePositions, getFixedGridElementsBottomLimit, recalculatePreservingPositions, sortElementsFromReferencePoint, } from "./fixed";
-import { findResponsiveAvailablePositions, getResponsiveGridElementsBottomLimit, sortResponsiveElements, } from "./responsive";
+import { findFixedAvailablePositions, getFixedGridElementsBottomLimit, recalculatePreservingPositions, sortElementsFromReferencePoint, updateFixedElementDimensions, } from "./fixed";
+import { findResponsiveAvailablePositions, getResponsiveGridElementsBottomLimit, sortResponsiveElements, updateResponsiveElementDimensions, } from "./responsive";
 import { CanvasDevice, VemPositionType, } from "../interfaces";
 import { copyDesktopPositionToDevice } from "../utils/element";
+const applyDynamicSizeStrategies = {
+    fixed: (containerItem, scopeElements, device) => {
+        return updateFixedElementDimensions(containerItem, device, scopeElements);
+    },
+    responsive: (containerItem, scopeElements, device, gap) => {
+        return updateResponsiveElementDimensions(containerItem, device, scopeElements, gap);
+    },
+};
 const recalculateStrategies = {
     fixed: (elements, currentElements, canvasWidth, device, options) => {
         const isSorted = !currentElements.length;
@@ -15,8 +23,8 @@ const recalculateStrategies = {
                 y: 0,
             })
             : changedElements;
-        return options.canvasHeight
-            ? recalculatePreservingPositions(orderedElements, device, canvasWidth, options.canvasHeight)
+        return options.keepPosition
+            ? recalculatePreservingPositions(orderedElements, currentElements, 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) => {
@@ -61,6 +69,25 @@ export function recalculateElements(newElements, currentElements, canvasWidth, c
     const calculatedOptions = Object.assign(Object.assign({}, defaultOptions), options);
     return strategy(newElements, currentElements, canvasWidth, device, calculatedOptions);
 }
+/**
+ * Updates the dimensions of a container element using a strategy based on the given canvas type.
+ *
+ * Delegates the update logic to a specific strategy found in `updateDimensionStrategies`
+ * using the provided `canvasType` key.
+ * @param containerItem The element whose dimensions need to be updated
+ * @param scopeElements A list of elements to consider in the update strategy
+ * @param device The device context (e.g., desktop, tablet, mobile) used to retrieve device-specific properties
+ * @param canvasType The type of canvas that determines which strategy to use.
+ * @param gap The type of canvas that determines which strategy to use.
+ * @returns  - The updated element with modified dimensions, or `undefined` if no strategy is found.
+ */
+export function applyDynamicSize(containerItem, scopeElements, device, canvasType, gap = 0) {
+    const strategy = applyDynamicSizeStrategies[canvasType];
+    if (!strategy) {
+        return;
+    }
+    return strategy(containerItem, scopeElements, device, gap);
+}
 /**
  * The calculation is delegated to a specific strategy based on the `canvasType`.
  * @param elements - The list of elements in the canvas.

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

@@ -1,5 +1,5 @@
 import { CanvasDevice } from "../interfaces/ICanvasGrid";
-import { VemResponsive } from "../interfaces/IVemCore";
+import { VemFixed, VemResponsive } from "../interfaces/IVemCore";
 import { VemPositionResponsive } from "../interfaces/IVemPosition";
 /**
  * Finds the first available position for a new responsive element within a canvas.
@@ -85,3 +85,13 @@ export declare const sortByDistanceInResponsiveFunction: (a: {
     element: VemResponsive;
 }, _device: CanvasDevice) => number;
 export declare const sortResponsiveElements: (elements: VemResponsive<unknown>[], sortByDevice?: CanvasDevice) => VemResponsive<unknown>[];
+/**
+ * Updates the height (`rowSpan`) of a fixed container element based on the positions.
+ * of the fixed elements it contains, ensuring it is tall enough to encompass all child elements.
+ * @param containerItem - The container element whose height needs to be updated.
+ * @param device - The target device (used to retrieve responsive dimensions).
+ * @param scopeElements - The list of fixed elements that are scoped to the container.
+ * @param rowGapSize - row gap
+ * @returns A new container element with the updated responsive `rowSpan` height for the given device.
+ */
+export declare const updateResponsiveElementDimensions: (containerItem: VemResponsive<unknown>, device: CanvasDevice, scopeElements: VemFixed<unknown>[], rowGapSize: number) => VemResponsive<unknown>;

package/dist/elements/helpers/responsive.js

@@ -1,9 +1,12 @@
+import { objectCopy } from "../../general";
 import { CanvasDevice } from "../interfaces/ICanvasGrid";
 import { VemPositionType, } from "../interfaces/IVemPosition";
+import { dxGetFixedGridItemsBottomLimit } from "../utils/fixed.position";
 import { OverlapIntervalTree } from "../utils/overlap";
 import { setElementPosition } from "../utils/position";
 const SPACE_DELTA = 1;
 const HEIGHT_DELTA = 32;
+const CANVAS_EXTRA_ROW = 1;
 /**
  * Finds the first available position for a new responsive element within a canvas.
  * @param canvasWidth - The width of the canvas in terms of columns.
@@ -153,3 +156,29 @@ export const sortResponsiveElements = (elements, sortByDevice) => {
     }).sort((a, b) => sortByDistanceInResponsiveFunction(a, b, sortByDevice));
     return sortedElements.map((element) => element.element);
 };
+/**
+ * Updates the height (`rowSpan`) of a fixed container element based on the positions.
+ * of the fixed elements it contains, ensuring it is tall enough to encompass all child elements.
+ * @param containerItem - The container element whose height needs to be updated.
+ * @param device - The target device (used to retrieve responsive dimensions).
+ * @param scopeElements - The list of fixed elements that are scoped to the container.
+ * @param rowGapSize - row gap
+ * @returns A new container element with the updated responsive `rowSpan` height for the given device.
+ */
+export const updateResponsiveElementDimensions = (containerItem, device, scopeElements, rowGapSize) => {
+    let currentElement = objectCopy(containerItem);
+    const currentHeight = currentElement.position.responsive[device].rowSpan;
+    const delta = HEIGHT_DELTA + rowGapSize;
+    // height in px
+    const calculatedHeight = dxGetFixedGridItemsBottomLimit(scopeElements, device);
+    // convert to rows
+    const transformToRows = Math.round(calculatedHeight / delta);
+    const baseRowSpan = Math.max(currentHeight, transformToRows);
+    const newRowSpan = baseRowSpan > currentHeight
+        ? baseRowSpan + CANVAS_EXTRA_ROW
+        : currentHeight;
+    currentElement = updateResponsivePosition(currentElement, {
+        rowSpan: newRowSpan,
+    }, device);
+    return Object.assign({}, currentElement);
+};

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

@@ -10,3 +10,4 @@ export declare const dxGetFixedGridItemY: (element: VemFixed, device: CanvasDevi
 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;
+export declare const dxGetFixedGridItemsBottomLimit: (items: VemFixed[], device: CanvasDevice, allowNegative?: boolean) => number;

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

@@ -70,3 +70,9 @@ export const dxGetFixedGridItemWidth = (element, device) => {
     const position = element.position.fixed[device];
     return (_a = position === null || position === void 0 ? void 0 : position.width) !== null && _a !== void 0 ? _a : 400;
 };
+export const dxGetFixedGridItemsBottomLimit = (items, device, allowNegative = false) => {
+    return items.length === 0
+        ? 0
+        : Math.max(...items.map((gridItem) => dxGetFixedGridItemY(gridItem, device, allowNegative) +
+            dxGetFixedGridItemHeight(gridItem, device)));
+};

package/dist/filters/constants/common/FILTER_SCOPE.d.ts

@@ -4,6 +4,7 @@ export declare enum FILTER_SCOPE {
     GLOBAL = "GLOBAL",// Analyze Filters | Filters for all pages on PB/EU
     PAGE = "PAGE",// PB/EU Filters for a single page
     TAB = "TAB",// PB/EU Filters for a single tab
+    CONTAINER = "CONTAINER",
     DEFAULT = "DEFAULT",// Filters created on Chart Builder
     CHART = "CHART",// PB/EU Filters for panels inside a page/tab
     ACTION = "ACTION",// Filters created with FilterBY or other actions

package/dist/filters/constants/common/FILTER_SCOPE.js

@@ -5,6 +5,7 @@ export var FILTER_SCOPE;
     FILTER_SCOPE["GLOBAL"] = "GLOBAL";
     FILTER_SCOPE["PAGE"] = "PAGE";
     FILTER_SCOPE["TAB"] = "TAB";
+    FILTER_SCOPE["CONTAINER"] = "CONTAINER";
     FILTER_SCOPE["DEFAULT"] = "DEFAULT";
     FILTER_SCOPE["CHART"] = "CHART";
     FILTER_SCOPE["ACTION"] = "ACTION";

package/dist/filters/constants/common/FILTER_SCOPES.js

@@ -5,6 +5,7 @@ export const FILTER_SCOPES = [
     FILTER_SCOPE.GLOBAL,
     FILTER_SCOPE.PAGE,
     FILTER_SCOPE.TAB,
+    FILTER_SCOPE.CONTAINER,
     FILTER_SCOPE.DEFAULT,
     FILTER_SCOPE.CHART,
     FILTER_SCOPE.ACTION,

package/dist/filters/constants/common/FILTER_SCOPE_INFO.js

@@ -41,6 +41,14 @@ export const FILTER_SCOPE_INFO = [
         displayed: true,
         i18nLabelPath: "filter.scopes.tab",
     },
+    {
+        label: FILTER_SCOPE_LABEL.CONTAINER,
+        shortLabel: "Container",
+        abbrLabel: "CONT",
+        value: FILTER_SCOPE.CONTAINER,
+        displayed: true,
+        i18nLabelPath: "filter.scopes.container",
+    },
     {
         label: FILTER_SCOPE_LABEL.DEFAULT,
         shortLabel: "Default",

package/dist/filters/constants/common/FILTER_SCOPE_LABEL.d.ts

@@ -4,6 +4,7 @@ export declare enum FILTER_SCOPE_LABEL {
     GLOBAL = "Global",
     PAGE = "Dashboard",
     TAB = "Tab",
+    CONTAINER = "Container",
     DEFAULT = "Default",
     CHART = "Panel",
     ACTION = "Action",

package/dist/filters/constants/common/FILTER_SCOPE_LABEL.js

@@ -5,6 +5,7 @@ export var FILTER_SCOPE_LABEL;
     FILTER_SCOPE_LABEL["GLOBAL"] = "Global";
     FILTER_SCOPE_LABEL["PAGE"] = "Dashboard";
     FILTER_SCOPE_LABEL["TAB"] = "Tab";
+    FILTER_SCOPE_LABEL["CONTAINER"] = "Container";
     FILTER_SCOPE_LABEL["DEFAULT"] = "Default";
     FILTER_SCOPE_LABEL["CHART"] = "Panel";
     FILTER_SCOPE_LABEL["ACTION"] = "Action";

package/dist/filters/constants/settings/FILTER_SETTINGS_DEFAULT.js

@@ -127,7 +127,7 @@ export const FILTER_SETTINGS_DEFAULT = {
             colorPickerDisplayed: true,
             displayed: true,
             enabled: true,
-            icon: "fp-global",
+            icon: "q-icon-fp-global",
             iconsDisplayed: true,
             interaction: {
                 createDisplayed: true,
@@ -150,7 +150,7 @@ export const FILTER_SETTINGS_DEFAULT = {
             colorPickerDisplayed: true,
             displayed: true,
             enabled: true,
-            icon: "fp-page",
+            icon: "q-icon-fp-page",
             iconsDisplayed: true,
             interaction: {
                 createDisplayed: true,
@@ -173,7 +173,30 @@ export const FILTER_SETTINGS_DEFAULT = {
             colorPickerDisplayed: true,
             displayed: true,
             enabled: true,
-            icon: "fp-tab",
+            icon: "q-icon-fp-tab",
+            iconsDisplayed: true,
+            interaction: {
+                createDisplayed: true,
+                createEnabled: true,
+                deleteDisplayed: true,
+                deleteEnabled: true,
+                editDisplayed: true,
+                editEnabled: true,
+                enableDisplayed: true,
+                enableEnabled: true,
+            },
+            label: undefined,
+            readonly: false,
+        },
+        [FILTER_SCOPE.CONTAINER]: {
+            canCollapse: true,
+            collapsed: false,
+            color: "#F472F2",
+            colorized: true,
+            colorPickerDisplayed: true,
+            displayed: true,
+            enabled: true,
+            icon: "new-q-icon-an-rectangle",
             iconsDisplayed: true,
             interaction: {
                 createDisplayed: true,
@@ -196,7 +219,7 @@ export const FILTER_SETTINGS_DEFAULT = {
             colorPickerDisplayed: true,
             displayed: true,
             enabled: true,
-            icon: "fp-chart",
+            icon: "q-icon-fp-chart",
             iconsDisplayed: true,
             interaction: {
                 createDisplayed: true,
@@ -219,7 +242,7 @@ export const FILTER_SETTINGS_DEFAULT = {
             colorPickerDisplayed: true,
             displayed: true,
             enabled: true,
-            icon: "fp-global",
+            icon: "q-icon-fp-global",
             iconsDisplayed: true,
             interaction: {
                 createDisplayed: true,
@@ -242,7 +265,7 @@ export const FILTER_SETTINGS_DEFAULT = {
             colorPickerDisplayed: true,
             displayed: true,
             enabled: true,
-            icon: "ico_workflows",
+            icon: "q-icon-ico_workflows",
             iconsDisplayed: true,
             interaction: {
                 createDisplayed: true,