@qrvey/utils 1.5.0-0 → 1.5.0-11

package/dist/filters/adapters/flatUIToOldLogic.js

@@ -23,8 +23,8 @@ export function flatUIToOldLogic(uFilters, section = FILTER_SECTION.ANYWHERE) {
     let oldFilterData;
     if (isEmpty(uFilters))
         return oldFilterData;
-    uFilters = cloneDeep(uFilters);
-    const filterDetails = flatUIToOldFilterDetail(uFilters);
+    const uFilterss = cloneDeep(uFilters);
+    const filterDetails = flatUIToOldFilterDetail(uFilterss);
     return {
         collapsed: false,
         enabled: true,
@@ -32,49 +32,44 @@ export function flatUIToOldLogic(uFilters, section = FILTER_SECTION.ANYWHERE) {
         logic: getLogicBody(filterDetails),
     };
 }
-const flatUIToOldFilterDetail = (uFilters = []) => {
-    return uFilters.map((filter) => {
-        return {
-            collapsed: filter.collapsed,
-            column: {
-                dataset: {
-                    name: filter.extras.dataset.label,
-                    qrveyid: filter.extras.dataset.qrveyid,
-                },
-                id: filter.column.id,
-                qrveyid: filter.column.qrveyid,
-                text: filter.column.label,
-                type: filter.column.type,
-                aggregate: filter.column.aggregate,
-                calculation: filter.column.calculation,
-                formulaType: filter.column.formulaType,
-                linked: undefined,
-                outputFormat: filter.column.outputFormat,
-                property: filter.column.property,
-                sorting: filter.column.sorting,
-            },
-            dateSection: filter.dateSection,
-            enabled: filter.enabled,
-            extras: filter.extras,
-            lookupDisplayIndex: filter.lookupDisplayIndex,
-            info: filter.extras.info,
-            nullValues: filter.nullValues,
-            operator: filter.operator,
-            property: filter.property,
-            scope: filter.extras.scope,
-            scopeid: filter.extras.scopeid,
-            scopeEnabled: filter.extras.scopeInfo.enabled,
-            panelid: filter.extras.panelid,
-            panelName: filter.extras.filterLabel,
-            section: filter.extras.section,
-            selectAll: filter.selectAll,
-            uiValue: getUIValues(filter, { addEnableds: true }),
-            validator: filter.validator,
-            values: filter.values,
-            _newFilters: Object.assign({}, filter),
-        };
-    });
-};
+const flatUIToOldFilterDetail = (uFilters = []) => uFilters.map((filter) => ({
+    collapsed: filter.collapsed,
+    column: {
+        dataset: {
+            name: filter.extras.dataset.label,
+            qrveyid: filter.extras.dataset.qrveyid,
+        },
+        id: filter.column.id,
+        qrveyid: filter.column.qrveyid,
+        text: filter.column.label,
+        type: filter.column.type,
+        aggregate: filter.column.aggregate,
+        calculation: filter.column.calculation,
+        formulaType: filter.column.formulaType,
+        outputFormat: filter.column.outputFormat,
+        property: filter.column.property,
+        sorting: filter.column.sorting,
+    },
+    dateSection: filter.dateSection,
+    enabled: filter.enabled,
+    extras: filter.extras,
+    lookupDisplayIndex: filter.lookupDisplayIndex,
+    info: filter.extras.info,
+    nullValues: filter.nullValues,
+    operator: filter.operator,
+    property: filter.property,
+    scope: filter.extras.scope,
+    scopeid: filter.extras.scopeid,
+    scopeEnabled: filter.extras.scopeInfo.enabled,
+    panelid: filter.extras.panelid,
+    panelName: filter.extras.filterLabel,
+    section: filter.extras.section,
+    selectAll: filter.selectAll,
+    uiValue: getUIValues(filter, { addEnableds: true }),
+    validator: filter.validator,
+    values: filter.values,
+    _newFilters: Object.assign({}, filter),
+}));
 export function getLogicBody(uFilters) {
     return uFilters.reduce((scopes, props) => {
         const scopeIndex = scopes.findIndex((sc) => sc.scope === props.scope && sc.uiExtras.scopeid === props.scopeid);
@@ -149,7 +144,7 @@ function getRegularExpression(props) {
         value: getValues(props),
         uiExtras: Object.assign(Object.assign({}, props), { uiValue }),
     };
-    expression["enabled"] =
+    expression.enabled =
         props.selectAll || ((_a = expression.value) === null || _a === void 0 ? void 0 : _a.length) > 0 ? props.enabled : false;
     return expression;
 }
@@ -296,9 +291,7 @@ function getResultValues(values, props) {
             if (props.column.type === COLUMN.IMAGE) {
                 return value.valueid || value.imageUrl || value.value;
             }
-            else {
-                return value.value;
-            }
+            return value.value;
         }
     })
         .filter(Boolean);

package/dist/filters/adapters/flatUIToUI.js

@@ -91,39 +91,39 @@ function buildDataset(uFilter) {
  * @returns an filter structure
  */
 function buildFilter(uFilter) {
-    uFilter = cloneDeep(uFilter);
-    const info = !isEmpty(uFilter.extras.info)
-        ? { icon: uFilter.extras.info.icon, label: uFilter.extras.info.label }
+    const _uFilter = cloneDeep(uFilter);
+    const info = !isEmpty(_uFilter.extras.info)
+        ? { icon: _uFilter.extras.info.icon, label: _uFilter.extras.info.label }
         : undefined;
-    const property = adaptDateGroupingProperty(uFilter.property);
-    delete uFilter.extras.scopeInfo;
-    delete uFilter.extras.dataset;
+    const property = adaptDateGroupingProperty(_uFilter.property);
+    delete _uFilter.extras.scopeInfo;
+    delete _uFilter.extras.dataset;
     return {
-        collapsed: uFilter.collapsed,
+        collapsed: _uFilter.collapsed,
         column: {
-            aggregate: uFilter.column.aggregate,
-            calculation: uFilter.column.calculation,
-            formulaType: uFilter.column.formulaType,
-            id: uFilter.column.id,
-            label: uFilter.column.label,
-            outputFormat: uFilter.column.outputFormat,
-            property: uFilter.column.property,
-            qrveyid: uFilter.column.qrveyid,
-            sorting: uFilter.column.sorting,
-            uniqueid: uFilter.column.uniqueid,
-            type: uFilter.column.type,
+            aggregate: _uFilter.column.aggregate,
+            calculation: _uFilter.column.calculation,
+            formulaType: _uFilter.column.formulaType,
+            id: _uFilter.column.id,
+            label: _uFilter.column.label,
+            outputFormat: _uFilter.column.outputFormat,
+            property: _uFilter.column.property,
+            qrveyid: _uFilter.column.qrveyid,
+            sorting: _uFilter.column.sorting,
+            uniqueid: _uFilter.column.uniqueid,
+            type: _uFilter.column.type,
         },
-        dateSection: uFilter.dateSection,
-        displayed: uFilter.displayed,
-        filterid: uFilter.filterid,
-        enabled: uFilter.enabled,
-        extras: Object.assign(Object.assign({}, uFilter.extras), { panelid: uFilter.extras.panelid, filterLabel: uFilter.extras.filterLabel, info, scope: uFilter.extras.scope, scopeid: uFilter.extras.scopeid, section: uFilter.extras.section }),
-        lookupDisplayIndex: uFilter.lookupDisplayIndex,
-        nullValues: uFilter.nullValues,
-        operator: uFilter.operator,
+        dateSection: _uFilter.dateSection,
+        displayed: _uFilter.displayed,
+        filterid: _uFilter.filterid,
+        enabled: _uFilter.enabled,
+        extras: Object.assign(Object.assign({}, _uFilter.extras), { panelid: _uFilter.extras.panelid, filterLabel: _uFilter.extras.filterLabel, info, scope: _uFilter.extras.scope, scopeid: _uFilter.extras.scopeid, section: _uFilter.extras.section }),
+        lookupDisplayIndex: _uFilter.lookupDisplayIndex,
+        nullValues: _uFilter.nullValues,
+        operator: _uFilter.operator,
         property,
-        selectAll: uFilter.selectAll,
-        validator: uFilter.validator,
-        values: adaptFilterValues(uFilter),
+        selectAll: _uFilter.selectAll,
+        validator: _uFilter.validator,
+        values: adaptFilterValues(_uFilter),
     };
 }

package/dist/filters/adapters/index.d.ts

@@ -1,4 +1,3 @@
-export * from "./transformFilters";
 export * from "./modelAnswerToFilterValue";
 export * from "./adaptDateGroupingProperty";
 export * from "./adaptFilterData";

package/dist/filters/adapters/index.js

@@ -1,4 +1,3 @@
-export * from "./transformFilters";
 export * from "./modelAnswerToFilterValue";
 export * from "./adaptDateGroupingProperty";
 export * from "./adaptFilterData";

package/dist/filters/adapters/logicToFlatUI.js

@@ -157,12 +157,10 @@ function getFilter(filters, filter, getIndex = false) {
  * @returns the array of Ranking values
  */
 function refineRankingValues(values = [], uiValues = []) {
-    return values.map((valueGroup) => {
-        return [
-            ...valueGroup.map((value) => {
-                const rValue = uiValues.find((uiV) => uiV.valueid === value.value.valueid);
-                return Object.assign(Object.assign({}, value), { displayed: rValue && rValue.displayed != null ? rValue.displayed : true, enabled: rValue && rValue.enabled != null ? rValue.enabled : true });
-            }),
-        ];
-    });
+    return values.map((valueGroup) => [
+        ...valueGroup.map((value) => {
+            const rValue = uiValues.find((uiV) => uiV.valueid === value.value.valueid);
+            return Object.assign(Object.assign({}, value), { displayed: rValue && rValue.displayed != null ? rValue.displayed : true, enabled: rValue && rValue.enabled != null ? rValue.enabled : true });
+        }),
+    ]);
 }

package/dist/filters/helpers/OLD_getAggFilters.js

@@ -46,8 +46,8 @@ export function getAggFilters(logics = [], summaries = []) {
  * @returns the aggregate filters in the IFilterFilters way or as logic structure.
  */
 function getAggregateFilters(logics = []) {
-    logics = cloneDeep(logics);
-    return logics.reduce((newLogics, logic) => {
+    const _logics = cloneDeep(logics);
+    return _logics.reduce((newLogics, logic) => {
         if (!logic)
             return newLogics;
         logic.filters.forEach((filter, index) => {
@@ -78,9 +78,10 @@ function concatAggFilters(aggFilters, operator = FILTER_OPERATOR.AND) {
 }
 function getExpressionsInLogic(logics = []) {
     return logics.reduce((expressions, logic) => {
+        let _expressions = expressions;
         logic.filters.forEach((filter) => {
-            expressions = expressions.concat(filter.expressions[0].expressions);
+            _expressions = _expressions.concat(filter.expressions[0].expressions);
         });
-        return expressions;
+        return _expressions;
     }, []);
 }

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

@@ -18,7 +18,7 @@ export function buildExpression(filter) {
         validationType: getBackendValidator(filter),
         value: getBackendValues(filter),
     };
-    expression["enabled"] =
+    expression.enabled =
         filter.selectAll || ((_a = expression.value) === null || _a === void 0 ? void 0 : _a.length) > 0 ? filter.enabled : false;
     return expression;
 }

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

@@ -17,16 +17,12 @@ export function buildFilters(filters, groupColumns = false) {
             const groupedExpression = {
                 operator: FILTER_OPERATOR.AND,
                 expressions: andOperators
-                    .map((group2) => {
-                    return getColumnExpressions(group2, getFilter);
-                })
+                    .map((group2) => getColumnExpressions(group2, getFilter))
                     .filter(Boolean),
             };
             return groupedExpression;
         }
-        else {
-            return getColumnExpressions(group, getFilter);
-        }
+        return getColumnExpressions(group, getFilter);
     })
         .filter(Boolean);
     if (orOperators.length > 1) {
@@ -37,14 +33,10 @@ export function buildFilters(filters, groupColumns = false) {
             },
         ];
     }
-    else {
-        if (_hasProperty(expressions[0], "expressions")) {
-            return expressions;
-        }
-        else {
-            return [{ operator: FILTER_OPERATOR.AND, expressions }];
-        }
+    if (_hasProperty(expressions[0], "expressions")) {
+        return expressions;
     }
+    return [{ operator: FILTER_OPERATOR.AND, expressions }];
 }
 function getColumnExpressions(group, getFilter) {
     const columnOrOperators = group.split("/");
@@ -56,9 +48,7 @@ function getColumnExpressions(group, getFilter) {
                 .filter(Boolean),
         };
     }
-    else {
-        return getFilter(group);
-    }
+    return getFilter(group);
 }
 function logicToNumeric(operator, priority = false) {
     if (operator === FILTER_OPERATOR.AND) {

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

@@ -43,7 +43,7 @@ export function getBackendValidator(filter) {
         case FILTER_VALIDATOR.IS_NOT_NULL:
             return FILTER_BACKEND_VALIDATOR.IS_NOT_NULL;
         case FILTER_VALIDATOR.IN:
-            //[TODO: FILTERS - Validate with backend if this will always be the validator type]
+            // [TODO: FILTERS - Validate with backend if this will always be the validator type]
             return FILTER_BACKEND_VALIDATOR.RELATIVE;
         default:
             return FILTER_BACKEND_VALIDATOR.EQUALS;

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

@@ -102,9 +102,7 @@ function getResultValues(values, filter) {
             if (filter.column.type === COLUMN.IMAGE) {
                 return value.valueid || value.imageUrl || value.value;
             }
-            else {
-                return value.value;
-            }
+            return value.value;
         }
     })
         .filter(Boolean);

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

@@ -13,10 +13,10 @@ export function getLogicByDatasets(logic, datasets = [], settings) {
         return;
     if (isEmpty(datasets))
         return logic;
-    settings = getGetLogicByDatasetsSettings(settings);
+    const defaultSettings = getGetLogicByDatasetsSettings(settings);
     return logic.map((_l) => (Object.assign(Object.assign({}, _l), { filters: filterNestedTree(_l.filters, "expressions", (expression) => {
             const dataset = datasets.find((_data) => _data === expression.qrveyid);
-            return ((settings.letPassUndefinedProperties.qrveyid &&
+            return ((defaultSettings.letPassUndefinedProperties.qrveyid &&
                 !_hasProperty(expression, "qrveyid")) ||
                 !isEmpty(dataset));
         }) })));

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

@@ -14,8 +14,8 @@ export function getLogicByDatasetsColumns(logic, datasets = [], settings) {
         return;
     if (isEmpty(datasets))
         return logic;
-    settings = getGetLogicByDatasetsSettings(settings);
-    return logic.map((_l) => (Object.assign(Object.assign({}, _l), { filters: filterNestedTree(_l.filters, "expressions", filterCallback(settings, datasets)) })));
+    const defaultSettings = getGetLogicByDatasetsSettings(settings);
+    return logic.map((_l) => (Object.assign(Object.assign({}, _l), { filters: filterNestedTree(_l.filters, "expressions", filterCallback(defaultSettings, datasets)) })));
 }
 /**
  * Runs the function for the callback

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

@@ -7,9 +7,9 @@ import { FILTER_SCOPE } from "../../constants/common/FILTER_SCOPE";
  * @returns a new Logic array
  */
 export function getLogicByScopes(logics = [], scopes = []) {
-    logics = cloneDeep(logics);
+    const _logics = cloneDeep(logics);
     return scopes.reduce((newScopes, scope) => {
-        const filteredScopes = logics.filter((logic) => scope.label === logic.scope &&
+        const filteredScopes = _logics.filter((logic) => scope.label === logic.scope &&
             (scope.id === logic.scopeid ||
                 (logic.scope === FILTER_SCOPE.GLOBAL && logic.scopeid == null)) &&
             logic.filters.length > 0);

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

@@ -1,4 +1,3 @@
-import { cloneDeep } from "../../../general/object/cloneDeep";
 import { FILTER_SCOPE } from "../../constants/common/FILTER_SCOPE";
 import { getScopesByHierarchy } from "../getScopesByHierarchy";
 import { getLogicByScopes } from "./getLogicByScopes";
@@ -10,6 +9,5 @@ import { getLogicByScopes } from "./getLogicByScopes";
  * @returns a new array of Logic
  */
 export function getLogicByScopesHierarchy(logics = [], scopes = [], currentScope = FILTER_SCOPE.GLOBAL) {
-    logics = cloneDeep(logics);
     return getLogicByScopes(logics, getScopesByHierarchy(scopes, currentScope));
 }

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

@@ -8,8 +8,8 @@ import { cloneDeep } from "../../../general/object/cloneDeep";
 export function excludeFiltersByAggregateColumn(filterData) {
     if (isEmpty(filterData) || isEmpty(filterData.scopes))
         return;
-    filterData = cloneDeep(filterData);
-    filterData.scopes = filterData.scopes.reduce((scopes, scope) => {
+    const _filterData = cloneDeep(filterData);
+    _filterData.scopes = _filterData.scopes.reduce((scopes, scope) => {
         if (isEmpty(scope))
             return scopes;
         scope.datasets.forEach((dataset, index) => {
@@ -22,5 +22,5 @@ export function excludeFiltersByAggregateColumn(filterData) {
             scopes.push(scope);
         return scopes;
     }, []);
-    return filterData.scopes.length > 0 ? filterData : undefined;
+    return _filterData.scopes.length > 0 ? _filterData : undefined;
 }

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

@@ -1,4 +1,5 @@
 import { isEmpty } from "../../../general/mix/isEmpty";
+import { cloneDeep } from "../../../general/object/cloneDeep";
 /**
  * Excludes filters from the given Filters.
  * The validation to filter the stored filter is depending on:
@@ -19,7 +20,8 @@ export function excludeFiltersByParams(filterData, params) {
         return;
     if (isEmpty(params))
         return filterData;
-    filterData.scopes = filterData.scopes
+    const _filterData = cloneDeep(filterData);
+    _filterData.scopes = _filterData.scopes
         .map((scope) => {
         if (resolveScopeConditions(scope, params)) {
             return Object.assign(Object.assign({}, scope), { datasets: scope.datasets
@@ -39,12 +41,10 @@ export function excludeFiltersByParams(filterData, params) {
                                                 })
                                                     .filter(Boolean);
                                             }
-                                            else {
-                                                value = value;
-                                                if (params.enableds == null ||
-                                                    params.enableds === value.enabled)
-                                                    return value;
-                                            }
+                                            if (params.enableds == null ||
+                                                params.enableds ===
+                                                    value.enabled)
+                                                return value;
                                         })
                                             .filter(Boolean) });
                                 }
@@ -52,8 +52,7 @@ export function excludeFiltersByParams(filterData, params) {
                                 .filter((filter) => {
                                 var _a;
                                 return !isEmpty(filter) &&
-                                    filter.selectAll &&
-                                    ((_a = filter.values) === null || _a === void 0 ? void 0 : _a.length) > 0;
+                                    (filter.selectAll || ((_a = filter.values) === null || _a === void 0 ? void 0 : _a.length) > 0);
                             }) });
                     }
                 })
@@ -61,13 +60,13 @@ export function excludeFiltersByParams(filterData, params) {
         }
     })
         .filter((scope) => !isEmpty(scope) && scope.datasets.length > 0);
-    return filterData.scopes.length > 0 ? filterData : undefined;
+    return _filterData.scopes.length > 0 ? _filterData : undefined;
 }
 function resolveScopeConditions(scope, params) {
     return ((params.enableds == null || params.enableds !== scope.enabled) &&
         (isEmpty(params.scope) || scope.scope !== params.scope) &&
         (isEmpty(params.scopeid) || scope.scopeid !== params.scopeid) &&
-        scope.datasets.filter.length > 0);
+        scope.datasets.length > 0);
 }
 function resolveDatasetConditions(dataset, params) {
     return ((params.enableds == null || params.enableds !== dataset.enabled) &&

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

@@ -9,7 +9,7 @@ import { cloneDeep } from "../../../general/object/cloneDeep";
 export function excludeFiltersByScopes(filterData, scopes) {
     if (isEmpty(filterData) || isEmpty(filterData.scopes))
         return;
-    filterData = cloneDeep(filterData);
-    filterData.scopes = filterData.scopes.filter((scope) => !scopes.includes(scope.scope));
-    return filterData.scopes.length > 0 ? filterData : undefined;
+    const _filterData = cloneDeep(filterData);
+    _filterData.scopes = _filterData.scopes.filter((scope) => !scopes.includes(scope.scope));
+    return _filterData.scopes.length > 0 ? _filterData : undefined;
 }

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

@@ -6,5 +6,5 @@ import { getFilterColumnLabel } from "./getFilterColumnLabel";
  */
 export function getFilterLabel(filter) {
     const text = filter.extras.filterLabel || filter.column.label;
-    return text + " " + getFilterColumnLabel(filter.column);
+    return `${text} ${getFilterColumnLabel(filter.column)}`;
 }

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

@@ -8,8 +8,8 @@ import { cloneDeep } from "../../../general/object/cloneDeep";
 export function getFiltersByAggregateColumn(filterData) {
     if (isEmpty(filterData) || isEmpty(filterData.scopes))
         return;
-    filterData = cloneDeep(filterData);
-    filterData.scopes = filterData.scopes.reduce((scopes, scope) => {
+    const _filterData = cloneDeep(filterData);
+    _filterData.scopes = _filterData.scopes.reduce((scopes, scope) => {
         if (isEmpty(scope))
             return scopes;
         scope.datasets.forEach((dataset, index) => {
@@ -22,5 +22,5 @@ export function getFiltersByAggregateColumn(filterData) {
             scopes.push(scope);
         return scopes;
     }, []);
-    return filterData.scopes.length > 0 ? filterData : undefined;
+    return _filterData.scopes.length > 0 ? _filterData : undefined;
 }

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

@@ -25,17 +25,17 @@ export function getFiltersByParams(filterData, params, settings) {
         return;
     if (isEmpty(params))
         return filterData;
-    filterData = cloneDeep(filterData);
-    settings = getParamsToGetFilterSettings(settings);
-    filterData.scopes = filterData.scopes
+    const _filterData = cloneDeep(filterData);
+    const defaultSettings = getParamsToGetFilterSettings(settings);
+    _filterData.scopes = _filterData.scopes
         .map((scope) => {
-        if (resolveScopeConditions(scope, params, settings.letPassUndefinedProperties.scope, settings.letPassUndefinedParams.scope)) {
+        if (resolveScopeConditions(scope, params, defaultSettings.letPassUndefinedProperties.scope, defaultSettings.letPassUndefinedParams.scope)) {
             return Object.assign(Object.assign({}, scope), { datasets: scope.datasets
                     .map((dataset) => {
-                    if (resolveDatasetConditions(dataset, params, settings.letPassUndefinedProperties.dataset, settings.letPassUndefinedParams.dataset)) {
+                    if (resolveDatasetConditions(dataset, params, defaultSettings.letPassUndefinedProperties.dataset, defaultSettings.letPassUndefinedParams.dataset)) {
                         return Object.assign(Object.assign({}, dataset), { filters: dataset.filters
                                 .map((filter) => {
-                                if (resolveFilterConditions(filter, params, settings.letPassUndefinedProperties.filter, settings.letPassUndefinedParams.filter)) {
+                                if (resolveFilterConditions(filter, params, defaultSettings.letPassUndefinedProperties.filter, defaultSettings.letPassUndefinedParams.filter)) {
                                     return Object.assign(Object.assign({}, filter), { values: (filter.values || [])
                                             .map((value) => {
                                             if (Array.isArray(value) && value.length > 0) {
@@ -48,13 +48,11 @@ export function getFiltersByParams(filterData, params, settings) {
                                                 })
                                                     .filter(Boolean);
                                             }
-                                            else {
-                                                value = value;
-                                                if (!_hasProperty(params, "enableds") ||
-                                                    !_hasProperty(params.enableds, "values") ||
-                                                    params.enableds.values === value.enabled)
-                                                    return value;
-                                            }
+                                            if (!_hasProperty(params, "enableds") ||
+                                                !_hasProperty(params.enableds, "values") ||
+                                                params.enableds.values ===
+                                                    value.enabled)
+                                                return value;
                                         })
                                             .filter(Boolean) });
                                 }
@@ -62,18 +60,18 @@ export function getFiltersByParams(filterData, params, settings) {
                                 .filter((filter) => {
                                 var _a;
                                 return !isEmpty(filter) &&
-                                    (!settings.filterEmptyArrays.filter ||
+                                    (!defaultSettings.filterEmptyArrays.filter ||
                                         filter.selectAll ||
                                         ((_a = filter.values) === null || _a === void 0 ? void 0 : _a.length) > 0);
                             }) });
                     }
                 })
                     .filter((dataset) => !isEmpty(dataset) &&
-                    (!settings.filterEmptyArrays.dataset ||
+                    (!defaultSettings.filterEmptyArrays.dataset ||
                         dataset.filters.length > 0)) });
         }
     })
         .filter((scope) => !isEmpty(scope) &&
-        (!settings.filterEmptyArrays.scope || scope.datasets.length > 0));
-    return filterData.scopes.length > 0 ? filterData : undefined;
+        (!defaultSettings.filterEmptyArrays.scope || scope.datasets.length > 0));
+    return _filterData.scopes.length > 0 ? _filterData : undefined;
 }

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

@@ -9,7 +9,7 @@ import { cloneDeep } from "../../../general/object/cloneDeep";
 export function getFiltersByScopes(filterData, scopes) {
     if (isEmpty(filterData) || isEmpty(filterData.scopes))
         return;
-    filterData = cloneDeep(filterData);
-    filterData.scopes = filterData.scopes.filter((scope) => scopes.includes(scope.scope));
-    return filterData.scopes.length > 0 ? filterData : undefined;
+    const _filterData = cloneDeep(filterData);
+    _filterData.scopes = _filterData.scopes.filter((scope) => scopes.includes(scope.scope));
+    return _filterData.scopes.length > 0 ? _filterData : undefined;
 }

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

@@ -10,13 +10,13 @@ import { FILTER_SCOPE } from "../../constants/common/FILTER_SCOPE";
 export function getFiltersByScopesIds(filterData, scopes = []) {
     if (isEmpty(filterData) || isEmpty(filterData.scopes))
         return;
-    filterData = cloneDeep(filterData);
-    filterData.scopes = scopes.reduce((newScopes, scope) => {
-        const filteredScopes = filterData.scopes.filter((fScope) => scope.label === fScope.scope &&
+    const _filterData = cloneDeep(filterData);
+    _filterData.scopes = scopes.reduce((newScopes, scope) => {
+        const filteredScopes = _filterData.scopes.filter((fScope) => scope.label === fScope.scope &&
             (scope.id === fScope.scopeid ||
                 (fScope.scope === FILTER_SCOPE.GLOBAL && fScope.scopeid == null)) &&
             fScope.datasets.length > 0);
         return newScopes.concat(filteredScopes);
     }, []);
-    return filterData.scopes.length > 0 ? filterData : undefined;
+    return _filterData.scopes.length > 0 ? _filterData : undefined;
 }

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

@@ -11,8 +11,8 @@ import { cloneDeep } from "../../../general/object/cloneDeep";
 export function getFiltersByVisibility(filterData, scopes) {
     if (isEmpty(filterData) || isEmpty(filterData.scopes))
         return;
-    filterData = cloneDeep(filterData);
-    filterData = getFiltersByScopesIds(filterData, scopes);
-    filterData = getFiltersByParams(filterData, { enableds: { datasets: true, scopes: true, values: true } }, { filterEmptyArrays: { filter: false } });
-    return filterData;
+    let _filterData = cloneDeep(filterData);
+    _filterData = getFiltersByScopesIds(_filterData, scopes);
+    _filterData = getFiltersByParams(_filterData, { enableds: { datasets: true, scopes: true, values: true } }, { filterEmptyArrays: { filter: false } });
+    return _filterData;
 }