@qrvey/utils 1.4.0-4 → 1.4.0-7

package/dist/dates/range/getDateRange.js

@@ -36,7 +36,6 @@ import { isValidDateObject } from "../helpers/isValidDateObject";
  * }
  */
 export function getDateRange(value, dateGroupLabel = "DAY", withTime = true) {
-    const range = {};
     const upperCaseDateGroup = dateGroupLabel.toUpperCase();
     const [timeFrom, timeTo] = withTime
         ? getStringTimeRange(value, upperCaseDateGroup)
@@ -47,60 +46,51 @@ export function getDateRange(value, dateGroupLabel = "DAY", withTime = true) {
             const yearRange = !isToken
                 ? getYearRange(value)
                 : { from: `01/01/${value}`, to: `12/31/${value}` };
-            range.from = `${yearRange.from}${timeFrom}`;
-            range.to = `${yearRange.to}${timeTo}`;
-            break;
+            return getRange(`${yearRange.from}${timeFrom}`, `${yearRange.to}${timeTo}`);
         }
         case "QUARTER": {
             const quarterRange = !isToken
                 ? getQuarterRange(value)
                 : { from: value, to: value };
-            range.from = `${quarterRange.from}${timeFrom}`;
-            range.to = `${quarterRange.to}${timeTo}`;
-            break;
+            return getRange(`${quarterRange.from}${timeFrom}`, `${quarterRange.to}${timeTo}`);
         }
         case "MONTH": {
-            const monthRange = monthInclideTokens(value)
+            const monthRange = monthIncludeTokens(value)
                 ? getMonthRangeWithToken(value)
                 : getMonthRange(value);
-            range.from = `${monthRange.from}${timeFrom}`;
-            range.to = `${monthRange.to}${timeTo}`;
-            break;
+            return getRange(`${monthRange.from}${timeFrom}`, `${monthRange.to}${timeTo}`);
         }
         case "WEEK": {
             const weekRange = !isToken
                 ? getWeekRange(value)
                 : { from: value, to: value };
-            range.from = `${weekRange.from}${timeFrom}`;
-            range.to = `${weekRange.to}${timeTo}`;
-            break;
+            return getRange(`${weekRange.from}${timeFrom}`, `${weekRange.to}${timeTo}`);
         }
         case "HOUR": {
             const hourRange = !isToken
                 ? getHourRange(value)
                 : { from: value, to: value };
-            range.from = hourRange.from;
-            range.to = hourRange.to;
-            break;
+            return getRange(hourRange.from, hourRange.to);
         }
         case "MINUTE": {
             const minuteRange = !isToken
                 ? getMinuteRange(value)
                 : { from: value, to: value };
-            range.from = minuteRange.from;
-            range.to = minuteRange.to;
-            break;
+            return getRange(minuteRange.from, minuteRange.to);
         }
         default: {
             const dayFrom = new Date(value);
             const dayTo = new Date(value);
             const includTokens = includeTokens(value, "/");
-            range.from = `${!includTokens ? getStringDate(dayFrom) : value}${timeFrom}`;
-            range.to = `${!includTokens ? getStringDate(dayTo) : value}${timeTo}`;
-            break;
+            return getRange(`${!includTokens ? getStringDate(dayFrom) : value}${timeFrom}`, `${!includTokens ? getStringDate(dayTo) : value}${timeTo}`);
         }
     }
-    return range;
+}
+function getRange(from, to) {
+    return {
+        from,
+        to,
+    };
 }
 function getStringTimeRange(value, dateGroupLabel) {
     const addLeadingZero = (unit) => `${unit < 10 ? "0" : ""}${unit}`;
@@ -236,7 +226,7 @@ function getMonthRangeWithToken(value) {
         to: `${monthToReturn}/{{LAST_DAY_MONTH}}/${year}`,
     };
 }
-function monthInclideTokens(value) {
+function monthIncludeTokens(value) {
     const [month, year] = value.split(" ");
     return isTokenLabel(month) || isTokenLabel(year);
 }

package/dist/dates/relative/RelativeStatementAdapter.js

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

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

@@ -6,11 +6,14 @@ import { COMMON_CONSTANTS } from "../constants/COMMON";
  * @returns {number}
  */
 export function getStatementCase(includeCurrent, isCalendarDate) {
-    return includeCurrent && isCalendarDate
-        ? COMMON_CONSTANTS.INCLUSIVE_AND_CALENDAR
-        : !includeCurrent && isCalendarDate
-            ? COMMON_CONSTANTS.EXCLUSIVE_AND_CALENDAR
-            : !includeCurrent && !isCalendarDate
-                ? COMMON_CONSTANTS.EXCLUSIVE_AND_ROLLING
-                : COMMON_CONSTANTS.INCLUSIVE_AND_ROLLING;
+    if (includeCurrent && isCalendarDate) {
+        return COMMON_CONSTANTS.INCLUSIVE_AND_CALENDAR;
+    }
+    else if (!includeCurrent && isCalendarDate) {
+        return COMMON_CONSTANTS.EXCLUSIVE_AND_CALENDAR;
+    }
+    else if (!includeCurrent && !isCalendarDate) {
+        return COMMON_CONSTANTS.EXCLUSIVE_AND_ROLLING;
+    }
+    return COMMON_CONSTANTS.INCLUSIVE_AND_ROLLING;
 }

package/dist/filters/adapters/adaptDateGroupingProperty.js

@@ -7,17 +7,13 @@ import { DATE_DISTINCT_TIME_PROPERTY } from "../../dates/constants/DATE_DISTINCT
  * @returns a adapted property
  */
 export function adaptDateGroupingProperty(property) {
-    return property === "p&quarter"
-        ? DATE_DISTINCT_PROPERTY.YEAR_QUARTER
-        : property === "p&month"
-            ? DATE_DISTINCT_PROPERTY.YEAR_MONTH
-            : property === "p&day"
-                ? DATE_DISTINCT_PROPERTY.MONTH_DAY
-                : property === "p&hour"
-                    ? DATE_DISTINCT_TIME_PROPERTY.DAY_HOUR
-                    : property === "p&minute"
-                        ? DATE_DISTINCT_TIME_PROPERTY.HOUR_MINUTE
-                        : property === "p&second"
-                            ? DATE_DISTINCT_TIME_PROPERTY.MINUTE_SECOND
-                            : property;
+    return ODD_PROPERTY[property] || property;
 }
+const ODD_PROPERTY = {
+    "p&quarter": DATE_DISTINCT_PROPERTY.YEAR_QUARTER,
+    "p&month": DATE_DISTINCT_PROPERTY.YEAR_MONTH,
+    "p&day": DATE_DISTINCT_PROPERTY.MONTH_DAY,
+    "p&hour": DATE_DISTINCT_TIME_PROPERTY.DAY_HOUR,
+    "p&minute": DATE_DISTINCT_TIME_PROPERTY.HOUR_MINUTE,
+    "p&second": DATE_DISTINCT_TIME_PROPERTY.MINUTE_SECOND,
+};

package/dist/filters/adapters/logicToUI.js

@@ -10,6 +10,5 @@ import { logicToFlatUI } from "./logicToFlatUI";
  */
 export function logicToUI(logics = [], section = FILTER_SECTION.ANYWHERE, enabled = true, version = FILTER_STRUCTURE_VERSION) {
     const flatUiFilters = logicToFlatUI(logics);
-    const uiFilters = flatUIToUI(flatUiFilters, section, enabled, version);
-    return uiFilters;
+    return flatUIToUI(flatUiFilters, section, enabled, version);
 }

package/dist/filters/adapters/transformFilters.js

@@ -339,7 +339,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") &&
@@ -366,7 +366,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)
@@ -377,7 +376,6 @@ function getFormulaType(oldFiltersItem) {
             : oldFiltersItem.type === "DATE"
                 ? "date"
                 : "string";
-    return;
 }
 function getExpressions(oldFiltersItem, validations, scopeLabel, scopeid, section) {
     const expressions = [];

package/dist/filters/helpers/OLD_getAggFilters.js

@@ -33,7 +33,6 @@ export function getAggFilters(logics = [], summaries = []) {
                         value: expression.value,
                     };
                 }
-                return;
             })
                 .filter(Boolean),
         });
@@ -49,7 +48,7 @@ export function getAggFilters(logics = [], summaries = []) {
  */
 function getAggregateFilters(logics = []) {
     logics = cloneDeep(logics);
-    const aggregateLogics = logics.reduce((newLogics, logic) => {
+    return logics.reduce((newLogics, logic) => {
         if (!logic)
             return newLogics;
         logic.filters.forEach((filter, index) => {
@@ -66,7 +65,6 @@ function getAggregateFilters(logics = []) {
             newLogics.push(logic);
         return newLogics;
     }, []);
-    return aggregateLogics;
 }
 function concatAggFilters(aggFilters, operator = FILTER_OPERATOR.AND) {
     const expressions = aggFilters.filter(Boolean);

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

@@ -61,7 +61,10 @@ function getColumnExpressions(group, getFilter) {
     }
 }
 function logicToNumeric(operator, priority = false) {
-    return operator === FILTER_OPERATOR.AND ? "*" : priority ? "/" : "+";
+    if (operator === FILTER_OPERATOR.AND) {
+        return "*";
+    }
+    return priority ? "/" : "+";
 }
 function numericExpression(filters, groupColumns = false) {
     let expression = "";
@@ -71,5 +74,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/filters/helpers/backend/getBackendGroupValue.js

@@ -10,7 +10,6 @@ export function getBackendGroupValue(filter) {
     if (isEmpty(filter.column.aggregate) &&
         isDateColumn(filter.column) &&
         filter.property != null) {
-        const property = adaptDateGroupingProperty(filter.property);
-        return property;
+        return adaptDateGroupingProperty(filter.property);
     }
 }

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

@@ -13,59 +13,81 @@ export function getBackendValues(filter) {
     switch (filter.validator) {
         case FILTER_VALIDATOR.EQUALS:
         case FILTER_VALIDATOR.NOT_EQUAL:
-            if (filter.column.type === COLUMN.RANKING &&
-                isEmpty(filter.column.aggregate))
-                return getRankingValues(values);
-            return getResultValues(values, filter);
         case FILTER_VALIDATOR.CONTAINS:
         case FILTER_VALIDATOR.NOT_CONTAIN:
         case FILTER_VALIDATOR.STARTS_WITH:
         case FILTER_VALIDATOR.NOT_START_WITH:
         case FILTER_VALIDATOR.ENDS_WITH:
         case FILTER_VALIDATOR.NOT_END_WITH:
-            return values.map((value) => value.enabled ? value.value : undefined);
+            if (filter.column.type === COLUMN.RANKING &&
+                isEmpty(filter.column.aggregate))
+                return getRankingValues(values);
+            return getResultValues(values, filter);
         case 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.BETWEEN_EXCLUSIVE:
-            return values
-                .map((value) => value.enabled ? { lt: value.max, gt: value.min } : undefined)
-                .filter(Boolean);
+            return getInclusiveRange(values);
         case FILTER_VALIDATOR.BEFORE:
         case FILTER_VALIDATOR.LESS_THAN:
-            return values
-                .map((value) => (value.enabled ? { lt: value.max } : undefined))
-                .filter(Boolean);
+            return getBeforeValues(values);
         case FILTER_VALIDATOR.BEFORE_ON:
         case FILTER_VALIDATOR.LESS_THAN_EQUAL:
-            return values
-                .map((value) => (value.enabled ? { lte: value.max } : undefined))
-                .filter(Boolean);
+            return getBeforeOnValues(values);
         case FILTER_VALIDATOR.AFTER:
         case FILTER_VALIDATOR.GREATER_THAN:
-            return values
-                .map((value) => (value.enabled ? { gt: value.min } : undefined))
-                .filter(Boolean);
+            return getAfterValues(values);
         case FILTER_VALIDATOR.AFTER_ON:
         case FILTER_VALIDATOR.GREATER_THAN_EQUAL:
-            return values
-                .map((value) => (value.enabled ? { gte: value.min } : undefined))
-                .filter(Boolean);
+            return getAfterOnValues(values);
         case FILTER_VALIDATOR.IS_NULL:
-        case FILTER_VALIDATOR.IS_NOT_NULL: {
-            const addValue = values.length > 0 &&
-                values.every((value) => value.enabled);
-            return addValue ? [FILTER_VALIDATOR_INFO[filter.validator].label] : [];
-        }
+        case FILTER_VALIDATOR.IS_NOT_NULL:
+            return getNullValues(values, filter);
         case FILTER_VALIDATOR.IN:
-            return values
-                .map((value) => (value.enabled ? value : undefined))
-                .filter(Boolean);
+            return getInValues(values);
         default:
             return [];
     }
 }
+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[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/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/filters/helpers/backend/getLogicByDatasetsColumns.js

@@ -5,8 +5,8 @@ import { _hasProperty } from "../../../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
  */
 export function getLogicByDatasetsColumns(logic, datasets = [], settings) {
@@ -15,27 +15,64 @@ export function getLogicByDatasetsColumns(logic, datasets = [], settings) {
     if (isEmpty(datasets))
         return logic;
     settings = getGetLogicByDatasetsSettings(settings);
-    return logic.map((_l) => (Object.assign(Object.assign({}, _l), { filters: filterNestedTree(_l.filters, "expressions", (expression) => {
-            const letQrveyidPass = settings.letPassUndefinedProperties.qrveyid ||
-                _hasProperty(expression, "qrveyid");
-            let letQuestionidPass = settings.letPassUndefinedProperties.questionid ||
-                _hasProperty(expression, "questionid");
-            const dataset = letQrveyidPass
-                ? datasets.find((_data) => _data.qrveyid === expression.qrveyid)
+    return logic.map((_l) => (Object.assign(Object.assign({}, _l), { filters: filterNestedTree(_l.filters, "expressions", filterCallback(settings, datasets)) })));
+}
+/**
+ * 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 (!isEmpty(dataset)) {
+            const column = letQuestionidPass
+                ? (dataset.options || []).find((option) => option.id === expression.questionid)
                 : undefined;
-            if (!isEmpty(dataset)) {
-                const column = letQuestionidPass
-                    ? (dataset.options || []).find((option) => option.id === expression.questionid)
-                    : undefined;
-                letQuestionidPass = letQuestionidPass || !isEmpty(column);
-            }
-            return letQrveyidPass && !isEmpty(dataset) && letQuestionidPass;
-        }) })));
+            letQuestionidPass = letQuestionidPass || !isEmpty(column);
+        }
+        return letQrveyidPass && !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 ||
+        _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 ||
+        _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/filters/helpers/common/excludeFiltersByParams.js

@@ -31,8 +31,7 @@ export 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/filters/helpers/common/getFiltersByDatasetsColumns.js

@@ -1,4 +1,6 @@
+import { getDatasetColumn } from "../../../columns/helpers/getDatasetColumn";
 import { isEmpty } from "../../../general/mix/isEmpty";
+import { getDatasetByColumn } from "../../../qrvey/helpers/getDatasetByColumn";
 /**
  * Filtering the filters by the columns of datasets.
  * Module specially for CLS.
@@ -11,25 +13,33 @@ export function getFiltersByDatasetsColumns(data, datasets = []) {
         return;
     if (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 (!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 (!isEmpty(column)) {
-                                return Object.assign({}, filter);
-                            }
-                        })
-                            .filter(Boolean) });
-                }
-            })
-                .filter((dataset) => !isEmpty(dataset) && dataset.filters.length > 0) })))
-            .filter((scope) => !isEmpty(scope) && scope.datasets.length > 0) });
+    const newData = Object.assign(Object.assign({}, data), { scopes: getScopes(data.scopes, datasets) });
     if (!isEmpty(newData) && newData.scopes.length > 0) {
         return newData;
     }
 }
+function getScopes(scopes, datasets = []) {
+    return scopes
+        .map((scope) => (Object.assign(Object.assign({}, scope), { datasets: getDatasets(scope.datasets, datasets) })))
+        .filter((scope) => !isEmpty(scope) && scope.datasets.length > 0);
+}
+function getDatasets(scopeDatasets, datasets) {
+    return scopeDatasets
+        .map((scopeDataset) => {
+        const dataset = getDatasetByColumn({ qrveyid: scopeDataset.qrveyid }, datasets);
+        if (!isEmpty(dataset)) {
+            return Object.assign(Object.assign({}, scopeDataset), { filters: getFilters(scopeDataset.filters, dataset) });
+        }
+    })
+        .filter((dataset) => !isEmpty(dataset) && dataset.filters.length > 0);
+}
+function getFilters(filters, dataset) {
+    return filters
+        .map((filter) => {
+        const column = getDatasetColumn(filter.column, dataset);
+        if (!isEmpty(column)) {
+            return Object.assign({}, filter);
+        }
+    })
+        .filter(Boolean);
+}

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

@@ -39,8 +39,7 @@ export 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 (!_hasProperty(params, "enableds") ||
                                                         !_hasProperty(params.enableds, "values") ||

package/dist/filters/helpers/getAggFiltersFromFilterData.js

@@ -11,5 +11,4 @@ export function getAggFiltersFromFilterData(filterData, _summaries) {
     filterData = Object.assign({}, getFiltersByAggregateColumn(filterData));
     if (isEmpty(filterData))
         return;
-    return;
 }

package/dist/filters/helpers/getScopesByHierarchy.js

@@ -8,9 +8,11 @@ import { FILTER_SCOPE } from "../constants/common/FILTER_SCOPE";
 export function getScopesByHierarchy(scopes = [], currentScope = FILTER_SCOPE.GLOBAL) {
     const scopeIndex = scopes.findIndex((s) => s.label === currentScope);
     const chartScopeIndex = scopes.findIndex((s) => s.label === 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 [];
 }