@qrvey/utils 1.4.0-3 → 1.4.0-6

package/dist/cjs/dates/relative/RelativeStatementAdapter.js

@@ -54,11 +54,13 @@ class RelativeStatementAdapter {
         if (typeof this.statement === "string")
             return RelativeStatementAdapter.replaceNowToken(this.statement, this.now);
         const value = this._statementToRange();
-        const path = this.cursor === RELATIVE_CURSOR_1.RELATIVE_CURSOR.LAST
-            ? "gte"
-            : this.cursor === RELATIVE_CURSOR_1.RELATIVE_CURSOR.NEXT
-                ? "lte"
-                : "";
+        let path = "";
+        if (this.cursor === RELATIVE_CURSOR_1.RELATIVE_CURSOR.LAST) {
+            path = "gte";
+        }
+        else if (this.cursor === RELATIVE_CURSOR_1.RELATIVE_CURSOR.NEXT) {
+            path = "lte";
+        }
         return (0, get_1._get)(value, path, new Date());
     }
     /**
@@ -194,11 +196,14 @@ class RelativeStatementAdapter {
         const startOrEndOf = resolveAsCalendar
             ? loweredUnit
             : DATE_GROUPING_PROPERTY_1.DATE_GROUPING_PROPERTY.DAY;
-        return (setTo === COMMON_1.COMMON_CONSTANTS.START
-            ? date.startOf(startOrEndOf)
-            : setTo === COMMON_1.COMMON_CONSTANTS.END
-                ? date.endOf(startOrEndOf)
-                : date).format(DATE_FORMATS_1.DATETIME_FORMAT);
+        let absoluteDate = date;
+        if (setTo === COMMON_1.COMMON_CONSTANTS.START) {
+            absoluteDate = date.startOf(startOrEndOf);
+        }
+        else if (setTo === COMMON_1.COMMON_CONSTANTS.END) {
+            absoluteDate = date.endOf(startOrEndOf);
+        }
+        return absoluteDate.format(DATE_FORMATS_1.DATETIME_FORMAT);
     }
 }
 exports.default = RelativeStatementAdapter;

package/dist/cjs/dates/relative/helpers/getStatementCase.js

@@ -9,12 +9,15 @@ const COMMON_1 = require("../constants/COMMON");
  * @returns {number}
  */
 function getStatementCase(includeCurrent, isCalendarDate) {
-    return includeCurrent && isCalendarDate
-        ? COMMON_1.COMMON_CONSTANTS.INCLUSIVE_AND_CALENDAR
-        : !includeCurrent && isCalendarDate
-            ? COMMON_1.COMMON_CONSTANTS.EXCLUSIVE_AND_CALENDAR
-            : !includeCurrent && !isCalendarDate
-                ? COMMON_1.COMMON_CONSTANTS.EXCLUSIVE_AND_ROLLING
-                : COMMON_1.COMMON_CONSTANTS.INCLUSIVE_AND_ROLLING;
+    if (includeCurrent && isCalendarDate) {
+        return COMMON_1.COMMON_CONSTANTS.INCLUSIVE_AND_CALENDAR;
+    }
+    else if (!includeCurrent && isCalendarDate) {
+        return COMMON_1.COMMON_CONSTANTS.EXCLUSIVE_AND_CALENDAR;
+    }
+    else if (!includeCurrent && !isCalendarDate) {
+        return COMMON_1.COMMON_CONSTANTS.EXCLUSIVE_AND_ROLLING;
+    }
+    return COMMON_1.COMMON_CONSTANTS.INCLUSIVE_AND_ROLLING;
 }
 exports.getStatementCase = getStatementCase;

package/dist/cjs/filters/adapters/adaptDateGroupingProperty.js

@@ -10,18 +10,14 @@ const DATE_DISTINCT_TIME_PROPERTY_1 = require("../../dates/constants/DATE_DISTIN
  * @returns a adapted property
  */
 function adaptDateGroupingProperty(property) {
-    return property === "p&quarter"
-        ? DATE_DISTINCT_PROPERTY_1.DATE_DISTINCT_PROPERTY.YEAR_QUARTER
-        : property === "p&month"
-            ? DATE_DISTINCT_PROPERTY_1.DATE_DISTINCT_PROPERTY.YEAR_MONTH
-            : property === "p&day"
-                ? DATE_DISTINCT_PROPERTY_1.DATE_DISTINCT_PROPERTY.MONTH_DAY
-                : property === "p&hour"
-                    ? DATE_DISTINCT_TIME_PROPERTY_1.DATE_DISTINCT_TIME_PROPERTY.DAY_HOUR
-                    : property === "p&minute"
-                        ? DATE_DISTINCT_TIME_PROPERTY_1.DATE_DISTINCT_TIME_PROPERTY.HOUR_MINUTE
-                        : property === "p&second"
-                            ? DATE_DISTINCT_TIME_PROPERTY_1.DATE_DISTINCT_TIME_PROPERTY.MINUTE_SECOND
-                            : property;
+    return ODD_PROPERTY[property];
 }
 exports.adaptDateGroupingProperty = adaptDateGroupingProperty;
+const ODD_PROPERTY = {
+    "p&quarter": DATE_DISTINCT_PROPERTY_1.DATE_DISTINCT_PROPERTY.YEAR_QUARTER,
+    "p&month": DATE_DISTINCT_PROPERTY_1.DATE_DISTINCT_PROPERTY.YEAR_MONTH,
+    "p&day": DATE_DISTINCT_PROPERTY_1.DATE_DISTINCT_PROPERTY.MONTH_DAY,
+    "p&hour": DATE_DISTINCT_TIME_PROPERTY_1.DATE_DISTINCT_TIME_PROPERTY.DAY_HOUR,
+    "p&minute": DATE_DISTINCT_TIME_PROPERTY_1.DATE_DISTINCT_TIME_PROPERTY.HOUR_MINUTE,
+    "p&second": DATE_DISTINCT_TIME_PROPERTY_1.DATE_DISTINCT_TIME_PROPERTY.MINUTE_SECOND,
+};

package/dist/cjs/filters/adapters/logicToUI.js

@@ -13,7 +13,6 @@ const logicToFlatUI_1 = require("./logicToFlatUI");
  */
 function logicToUI(logics = [], section = FILTER_SECTION_1.FILTER_SECTION.ANYWHERE, enabled = true, version = FILTER_STRUCTURE_VERSION_1.FILTER_STRUCTURE_VERSION) {
     const flatUiFilters = (0, logicToFlatUI_1.logicToFlatUI)(logics);
-    const uiFilters = (0, flatUIToUI_1.flatUIToUI)(flatUiFilters, section, enabled, version);
-    return uiFilters;
+    return (0, flatUIToUI_1.flatUIToUI)(flatUiFilters, section, enabled, version);
 }
 exports.logicToUI = logicToUI;

package/dist/cjs/filters/adapters/transformFilters.js

@@ -343,7 +343,7 @@ function getFilterEqualValues(values, columnType, destination = "value", formula
                 }))
                 : getRankingFBvalues(values);
     }
-    const formattedValues = destination === "value"
+    return destination === "value"
         ? values.map((item) => {
             let value = item.value;
             if ([columnType, formulaType].includes("DATE") &&
@@ -370,7 +370,6 @@ function getFilterEqualValues(values, columnType, destination = "value", formula
             valueid: columnType === "EXPRESSION" ? undefined : item.id || item.answerid,
             enabled: item.enabled || true,
         }));
-    return formattedValues;
 }
 function getFormulaType(oldFiltersItem) {
     if (oldFiltersItem.formulaType)
@@ -381,7 +380,6 @@ function getFormulaType(oldFiltersItem) {
             : oldFiltersItem.type === "DATE"
                 ? "date"
                 : "string";
-    return;
 }
 function getExpressions(oldFiltersItem, validations, scopeLabel, scopeid, section) {
     const expressions = [];

package/dist/cjs/filters/helpers/OLD_getAggFilters.js

@@ -36,7 +36,6 @@ function getAggFilters(logics = [], summaries = []) {
                         value: expression.value,
                     };
                 }
-                return;
             })
                 .filter(Boolean),
         });
@@ -53,7 +52,7 @@ exports.getAggFilters = getAggFilters;
  */
 function getAggregateFilters(logics = []) {
     logics = (0, cloneDeep_1.cloneDeep)(logics);
-    const aggregateLogics = logics.reduce((newLogics, logic) => {
+    return logics.reduce((newLogics, logic) => {
         if (!logic)
             return newLogics;
         logic.filters.forEach((filter, index) => {
@@ -70,7 +69,6 @@ function getAggregateFilters(logics = []) {
             newLogics.push(logic);
         return newLogics;
     }, []);
-    return aggregateLogics;
 }
 function concatAggFilters(aggFilters, operator = FILTER_OPERATOR_1.FILTER_OPERATOR.AND) {
     const expressions = aggFilters.filter(Boolean);

package/dist/cjs/filters/helpers/backend/buildFilters.js

@@ -65,7 +65,10 @@ function getColumnExpressions(group, getFilter) {
     }
 }
 function logicToNumeric(operator, priority = false) {
-    return operator === FILTER_OPERATOR_1.FILTER_OPERATOR.AND ? "*" : priority ? "/" : "+";
+    if (operator === FILTER_OPERATOR_1.FILTER_OPERATOR.AND) {
+        return "*";
+    }
+    return priority ? "/" : "+";
 }
 function numericExpression(filters, groupColumns = false) {
     let expression = "";
@@ -75,5 +78,5 @@ function numericExpression(filters, groupColumns = false) {
         const operator = logicToNumeric(item.operator, groupColumns && ((_a = item.column) === null || _a === void 0 ? void 0 : _a.id) === (nextColumn === null || nextColumn === void 0 ? void 0 : nextColumn.id));
         expression += `${item.filterid}${operator}`;
     });
-    return expression.substr(0, expression.length - 1);
+    return expression.substring(0, expression.length - 1);
 }

package/dist/cjs/filters/helpers/backend/getBackendGroupValue.js

@@ -13,8 +13,7 @@ function getBackendGroupValue(filter) {
     if ((0, isEmpty_1.isEmpty)(filter.column.aggregate) &&
         (0, isDateColumn_1.isDateColumn)(filter.column) &&
         filter.property != null) {
-        const property = (0, adaptDateGroupingProperty_1.adaptDateGroupingProperty)(filter.property);
-        return property;
+        return (0, adaptDateGroupingProperty_1.adaptDateGroupingProperty)(filter.property);
     }
 }
 exports.getBackendGroupValue = getBackendGroupValue;

package/dist/cjs/filters/helpers/backend/getBackendValues.js

@@ -16,60 +16,82 @@ function getBackendValues(filter) {
     switch (filter.validator) {
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.EQUALS:
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.NOT_EQUAL:
-            if (filter.column.type === COLUMN_1.COLUMN.RANKING &&
-                (0, isEmpty_1.isEmpty)(filter.column.aggregate))
-                return getRankingValues(values);
-            return getResultValues(values, filter);
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.CONTAINS:
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.NOT_CONTAIN:
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.STARTS_WITH:
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.NOT_START_WITH:
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.ENDS_WITH:
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.NOT_END_WITH:
-            return values.map((value) => value.enabled ? value.value : undefined);
+            if (filter.column.type === COLUMN_1.COLUMN.RANKING &&
+                (0, isEmpty_1.isEmpty)(filter.column.aggregate))
+                return getRankingValues(values);
+            return getResultValues(values, filter);
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.BETWEEN_INCLUSIVE:
-            return values
-                .map((value) => value.enabled ? { lte: value.max, gte: value.min } : undefined)
-                .filter(Boolean);
+            return getExclusiveRange(values);
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.BETWEEN_EXCLUSIVE:
-            return values
-                .map((value) => value.enabled ? { lt: value.max, gt: value.min } : undefined)
-                .filter(Boolean);
+            return getInclusiveRange(values);
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.BEFORE:
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.LESS_THAN:
-            return values
-                .map((value) => (value.enabled ? { lt: value.max } : undefined))
-                .filter(Boolean);
+            return getBeforeValues(values);
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.BEFORE_ON:
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.LESS_THAN_EQUAL:
-            return values
-                .map((value) => (value.enabled ? { lte: value.max } : undefined))
-                .filter(Boolean);
+            return getBeforeOnValues(values);
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.AFTER:
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.GREATER_THAN:
-            return values
-                .map((value) => (value.enabled ? { gt: value.min } : undefined))
-                .filter(Boolean);
+            return getAfterValues(values);
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.AFTER_ON:
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.GREATER_THAN_EQUAL:
-            return values
-                .map((value) => (value.enabled ? { gte: value.min } : undefined))
-                .filter(Boolean);
+            return getAfterOnValues(values);
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.IS_NULL:
-        case FILTER_VALIDATOR_1.FILTER_VALIDATOR.IS_NOT_NULL: {
-            const addValue = values.length > 0 &&
-                values.every((value) => value.enabled);
-            return addValue ? [FILTER_VALIDATOR_INFO_1.FILTER_VALIDATOR_INFO[filter.validator].label] : [];
-        }
+        case FILTER_VALIDATOR_1.FILTER_VALIDATOR.IS_NOT_NULL:
+            return getNullValues(values, filter);
         case FILTER_VALIDATOR_1.FILTER_VALIDATOR.IN:
-            return values
-                .map((value) => (value.enabled ? value : undefined))
-                .filter(Boolean);
+            return getInValues(values);
         default:
             return [];
     }
 }
 exports.getBackendValues = getBackendValues;
+function getExclusiveRange(values) {
+    return values
+        .map((value) => getValue(value, { lte: value.max, gte: value.min }))
+        .filter(Boolean);
+}
+function getInclusiveRange(values) {
+    return values
+        .map((value) => getValue(value, { lt: value.max, gt: value.min }))
+        .filter(Boolean);
+}
+function getBeforeValues(values) {
+    return values
+        .map((value) => getValue(value, { lt: value.max }))
+        .filter(Boolean);
+}
+function getBeforeOnValues(values) {
+    return values
+        .map((value) => getValue(value, { lte: value.max }))
+        .filter(Boolean);
+}
+function getAfterValues(values) {
+    return values
+        .map((value) => getValue(value, { gt: value.min }))
+        .filter(Boolean);
+}
+function getAfterOnValues(values) {
+    return values
+        .map((value) => getValue(value, { gte: value.min }))
+        .filter(Boolean);
+}
+function getNullValues(values, filter) {
+    const addValue = values.length > 0 && values.every((value) => value.enabled);
+    return addValue ? [FILTER_VALIDATOR_INFO_1.FILTER_VALIDATOR_INFO[filter.validator].label] : [];
+}
+function getInValues(values) {
+    return values.map((value) => getValue(value, value)).filter(Boolean);
+}
+function getValue(objectValue, value) {
+    return objectValue.enabled ? value : undefined;
+}
 /**
  * Gets the expression values. Depending on the column type
  * @private

package/dist/cjs/filters/helpers/backend/getLogicByDatasetsColumns.d.ts

@@ -5,8 +5,8 @@ import { IFFGetLogicByDatasetsColumns } from "../../interfaces/functions/IFFGetL
  * @todo MODULE NO READY
  * Filters the logic by a datasets array
  * If an qrveyid is not provided in the expression a the filter passes normally
- * @param logic The logic of the filter
- * @param datasets The collection of datasets
+ * @param {IFBLogic[]} logic The logic of the filters
+ * @param {IDataset[]} datasets The collection of datasets
  * @returns a new filtered logic
  */
 export declare function getLogicByDatasetsColumns(logic: IFBLogic[], datasets?: IDataset[], settings?: IFFGetLogicByDatasetsColumns): IFBLogic[];

package/dist/cjs/filters/helpers/backend/getLogicByDatasetsColumns.js

@@ -8,8 +8,8 @@ const hasProperty_1 = require("../../../general/object/hasProperty");
  * @todo MODULE NO READY
  * Filters the logic by a datasets array
  * If an qrveyid is not provided in the expression a the filter passes normally
- * @param logic The logic of the filter
- * @param datasets The collection of datasets
+ * @param {IFBLogic[]} logic The logic of the filters
+ * @param {IDataset[]} datasets The collection of datasets
  * @returns a new filtered logic
  */
 function getLogicByDatasetsColumns(logic, datasets = [], settings) {
@@ -18,28 +18,65 @@ function getLogicByDatasetsColumns(logic, datasets = [], settings) {
     if ((0, isEmpty_1.isEmpty)(datasets))
         return logic;
     settings = getGetLogicByDatasetsSettings(settings);
-    return logic.map((_l) => (Object.assign(Object.assign({}, _l), { filters: (0, filterNestedTree_1.filterNestedTree)(_l.filters, "expressions", (expression) => {
-            const letQrveyidPass = settings.letPassUndefinedProperties.qrveyid ||
-                (0, hasProperty_1._hasProperty)(expression, "qrveyid");
-            let letQuestionidPass = settings.letPassUndefinedProperties.questionid ||
-                (0, hasProperty_1._hasProperty)(expression, "questionid");
-            const dataset = letQrveyidPass
-                ? datasets.find((_data) => _data.qrveyid === expression.qrveyid)
-                : undefined;
-            if (!(0, isEmpty_1.isEmpty)(dataset)) {
-                const column = letQuestionidPass
-                    ? (dataset.options || []).find((option) => option.id === expression.questionid)
-                    : undefined;
-                letQuestionidPass = letQuestionidPass || !(0, isEmpty_1.isEmpty)(column);
-            }
-            return letQrveyidPass && !(0, isEmpty_1.isEmpty)(dataset) && letQuestionidPass;
-        }) })));
+    return logic.map((_l) => (Object.assign(Object.assign({}, _l), { filters: (0, filterNestedTree_1.filterNestedTree)(_l.filters, "expressions", filterCallback(settings, datasets)) })));
 }
 exports.getLogicByDatasetsColumns = getLogicByDatasetsColumns;
+/**
+ * Runs the function for the callback
+ * @param {IFFGetLogicByDatasetsColumns} settings the settings for the helper
+ * @param {IDataset[]} datasets The dataset collection
+ * @returns
+ */
+function filterCallback(settings, datasets = []) {
+    return (expression) => {
+        const letQrveyidPass = getLetQrveyidPass(expression, settings);
+        let letQuestionidPass = getLetQuestionidPass(expression, settings);
+        const dataset = getDataset(expression, letQrveyidPass, datasets);
+        if (!(0, isEmpty_1.isEmpty)(dataset)) {
+            const column = letQuestionidPass
+                ? (dataset.options || []).find((option) => option.id === expression.questionid)
+                : undefined;
+            letQuestionidPass = letQuestionidPass || !(0, isEmpty_1.isEmpty)(column);
+        }
+        return letQrveyidPass && !(0, isEmpty_1.isEmpty)(dataset) && letQuestionidPass;
+    };
+}
+/**
+ * Gets the letQrveyidPass flag
+ * @param {IFBExpression} expression the logic expression of the filter
+ * @param {IFFGetLogicByDatasetsColumns} settings the settings for the helper
+ * @returns {boolean} true: the qrveyid will be passed
+ */
+function getLetQrveyidPass(expression, settings) {
+    return (settings.letPassUndefinedProperties.qrveyid ||
+        (0, hasProperty_1._hasProperty)(expression, "qrveyid"));
+}
+/**
+ * Gets the letQuestionidPass flag
+ * @param {IFBExpression} expression the logic expression of the filter
+ * @param {IFFGetLogicByDatasetsColumns} settings the settings for the helper
+ * @returns {boolean} true: the questionid will be passed
+ */
+function getLetQuestionidPass(expression, settings) {
+    return (settings.letPassUndefinedProperties.questionid ||
+        (0, hasProperty_1._hasProperty)(expression, "questionid"));
+}
+/**
+ * Gets the dataset related to the expression
+ * @param {IFBExpression} expression the logic expression of the filter
+ * @param {boolean} letQrveyidPass flag that allows perform the condition to compare the qrveyid with the datasets
+ * @param {IDataset[]} datasets The dataset collection
+ * @returns {IDataset} the dataset object
+ */
+function getDataset(expression, letQrveyidPass, datasets = []) {
+    return letQrveyidPass
+        ? datasets.find((_data) => _data.qrveyid === expression.qrveyid)
+        : undefined;
+}
 /**
  * Gets the default settings for the getLogicByDatasetsColumn function
- * @param settings the settings given by the implementer
- * @returns an object with all properties set
+ * @param {IFFGetLogicByDatasetsColumns} settings the settings for the helper given by the implementer
+ * @returns {IFFGetLogicByDatasetsColumns} an object with all properties set
  */
 function getGetLogicByDatasetsSettings(settings) {
     var _a, _b, _c, _d, _e;

package/dist/cjs/filters/helpers/common/excludeFiltersByParams.js

@@ -34,8 +34,7 @@ function excludeFiltersByParams(filterData, params) {
                                     return Object.assign(Object.assign({}, filter), { values: (filter.values || [])
                                             .map((value) => {
                                             if (Array.isArray(value) && value.length > 0) {
-                                                const rankingValues = value;
-                                                return rankingValues
+                                                return value
                                                     .map((rValue) => {
                                                     if (params.enableds == null ||
                                                         params.enableds === rValue.enabled)

package/dist/cjs/filters/helpers/common/getFiltersByDatasetsColumns.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFiltersByDatasetsColumns = void 0;
+const getDatasetColumn_1 = require("../../../columns/helpers/getDatasetColumn");
 const isEmpty_1 = require("../../../general/mix/isEmpty");
+const getDatasetByColumn_1 = require("../../../qrvey/helpers/getDatasetByColumn");
 /**
  * Filtering the filters by the columns of datasets.
  * Module specially for CLS.
@@ -14,26 +16,34 @@ function getFiltersByDatasetsColumns(data, datasets = []) {
         return;
     if ((0, isEmpty_1.isEmpty)(datasets))
         return data;
-    const newData = Object.assign(Object.assign({}, data), { scopes: data.scopes
-            .map((scope) => (Object.assign(Object.assign({}, scope), { datasets: scope.datasets
-                .map((filterDataset) => {
-                const dataset = datasets.find((_data) => _data.qrveyid === filterDataset.qrveyid);
-                if (!(0, isEmpty_1.isEmpty)(dataset)) {
-                    return Object.assign(Object.assign({}, filterDataset), { filters: filterDataset.filters
-                            .map((filter) => {
-                            const column = (dataset.options || []).find((cInfo) => cInfo.id === filter.column.id &&
-                                cInfo.qrveyid === filter.column.qrveyid);
-                            if (!(0, isEmpty_1.isEmpty)(column)) {
-                                return Object.assign({}, filter);
-                            }
-                        })
-                            .filter(Boolean) });
-                }
-            })
-                .filter((dataset) => !(0, isEmpty_1.isEmpty)(dataset) && dataset.filters.length > 0) })))
-            .filter((scope) => !(0, isEmpty_1.isEmpty)(scope) && scope.datasets.length > 0) });
+    const newData = Object.assign(Object.assign({}, data), { scopes: getScopes(data.scopes, datasets) });
     if (!(0, isEmpty_1.isEmpty)(newData) && newData.scopes.length > 0) {
         return newData;
     }
 }
 exports.getFiltersByDatasetsColumns = getFiltersByDatasetsColumns;
+function getScopes(scopes, datasets = []) {
+    return scopes
+        .map((scope) => (Object.assign(Object.assign({}, scope), { datasets: getDatasets(scope.datasets, datasets) })))
+        .filter((scope) => !(0, isEmpty_1.isEmpty)(scope) && scope.datasets.length > 0);
+}
+function getDatasets(scopeDatasets, datasets) {
+    return scopeDatasets
+        .map((scopeDataset) => {
+        const dataset = (0, getDatasetByColumn_1.getDatasetByColumn)({ qrveyid: scopeDataset.qrveyid }, datasets);
+        if (!(0, isEmpty_1.isEmpty)(dataset)) {
+            return Object.assign(Object.assign({}, scopeDataset), { filters: getFilters(scopeDataset.filters, dataset) });
+        }
+    })
+        .filter((dataset) => !(0, isEmpty_1.isEmpty)(dataset) && dataset.filters.length > 0);
+}
+function getFilters(filters, dataset) {
+    return filters
+        .map((filter) => {
+        const column = (0, getDatasetColumn_1.getDatasetColumn)(filter.column, dataset);
+        if (!(0, isEmpty_1.isEmpty)(column)) {
+            return Object.assign({}, filter);
+        }
+    })
+        .filter(Boolean);
+}

package/dist/cjs/filters/helpers/common/getFiltersByParams.js

@@ -42,8 +42,7 @@ function getFiltersByParams(filterData, params, settings) {
                                     return Object.assign(Object.assign({}, filter), { values: (filter.values || [])
                                             .map((value) => {
                                             if (Array.isArray(value) && value.length > 0) {
-                                                const rankingValues = value;
-                                                return rankingValues
+                                                return value
                                                     .map((rValue) => {
                                                     if (!(0, hasProperty_1._hasProperty)(params, "enableds") ||
                                                         !(0, hasProperty_1._hasProperty)(params.enableds, "values") ||

package/dist/cjs/filters/helpers/getAggFiltersFromFilterData.js

@@ -14,6 +14,5 @@ function getAggFiltersFromFilterData(filterData, _summaries) {
     filterData = Object.assign({}, (0, getFiltersByAggregateColumn_1.getFiltersByAggregateColumn)(filterData));
     if ((0, isEmpty_1.isEmpty)(filterData))
         return;
-    return;
 }
 exports.getAggFiltersFromFilterData = getAggFiltersFromFilterData;

package/dist/cjs/filters/helpers/getScopesByHierarchy.js

@@ -11,10 +11,12 @@ const FILTER_SCOPE_1 = require("../constants/common/FILTER_SCOPE");
 function getScopesByHierarchy(scopes = [], currentScope = FILTER_SCOPE_1.FILTER_SCOPE.GLOBAL) {
     const scopeIndex = scopes.findIndex((s) => s.label === currentScope);
     const chartScopeIndex = scopes.findIndex((s) => s.label === FILTER_SCOPE_1.FILTER_SCOPE.CHART);
-    return scopeIndex !== -1
-        ? scopes.slice(0, scopeIndex)
-        : chartScopeIndex !== -1
-            ? scopes.slice(0, chartScopeIndex)
-            : [];
+    if (scopeIndex !== -1) {
+        return scopes.slice(0, scopeIndex);
+    }
+    else if (chartScopeIndex !== -1) {
+        return scopes.slice(0, chartScopeIndex);
+    }
+    return [];
 }
 exports.getScopesByHierarchy = getScopesByHierarchy;