@qrvey/utils 1.3.3 → 1.4.0-2

package/src/filters/helpers/common/index.ts

@@ -1,32 +0,0 @@
-export * from './areFiltersEquals';
-
-export * from './excludeFiltersByAggregateColumn';
-export * from './excludeFiltersByParams';
-export * from './excludeFiltersByScopes';
-
-export * from './getFilterColumnLabel';
-export * from './getFilterid';
-export * from './getFilterLabel';
-export * from './getFiltersByAggregateColumn';
-export * from './getFiltersByDatasetsColumns';
-export * from './getFiltersByParams';
-export * from './getFiltersByScopes';
-export * from './getFiltersByScopesIds';
-export * from './getFiltersByVisibility';
-export * from './getMergeFiltersSettings';
-export * from './getParamsToGetFilterSettings';
-export * from './getValuesFromModel';
-export * from './getValuesFromDataset';
-export * from './haveFiltersByDataset';
-export * from './isBetweenValidator';
-export * from './isDateDistinctProperty';
-export * from './isInValidator';
-export * from './isNullValidator';
-export * from './isRangeValidator';
-export * from './isRegularValidator';
-export * from './mergeFilters';
-export * from './mergeValues';
-export * from './resolveDatasetConditions';
-export * from './resolveFilterConditions';
-export * from './resolveScopeConditions';
-// export * from './validateFilterTextByColumn';

package/src/filters/helpers/common/isBetweenValidator.ts

@@ -1,12 +0,0 @@
-import { FILTER_VALIDATOR } from "../../constants/common/FILTER_VALIDATOR";
-import { IFValidator } from "../../interfaces/IFValidator";
-
-
-/**
- * Validates if the given validator is a Between type
- * @param validator The validator
- * @returns true: it is a between validator; false: it is not a between validator
- */
-export function isBetweenValidator(validator: IFValidator): boolean {
-    return [FILTER_VALIDATOR.BETWEEN_EXCLUSIVE, FILTER_VALIDATOR.BETWEEN_INCLUSIVE].includes(validator);
-}

package/src/filters/helpers/common/isDateDistinctProperty.ts

@@ -1,17 +0,0 @@
-import { isDateColumn } from "../../../columns/helpers/isDateColumn";
-import { DATE_DISTINCT_PROPERTIES } from "../../../dates/constants/DATE_DISTINCT_PROPERTIES";
-import { DATE_DISTINCT_TIME_PROPERTIES } from "../../../dates/constants/DATE_DISTINCT_TIME_PROPERTIES";
-import { isEmpty } from "../../../general/mix/isEmpty";
-import { IFSColumn } from "../../interfaces/common/IFSColumn";
-import { IFProperty } from "../../interfaces/IFProperty";
-import { IFUColumn } from "../../interfaces/ui/IFUColumn";
-
-/**
- * Determines if the filter column and property is a distinct group dates type
- * @param column The filter column
- * @param property The filter property
- * @returns True if the given property is included from distinct group dates type
- */
-export function isDateDistinctProperty(column: IFUColumn | IFSColumn, property: IFProperty): boolean {
-  return isDateColumn(column as any) && isEmpty(column.aggregate) && ([...DATE_DISTINCT_PROPERTIES, ...DATE_DISTINCT_TIME_PROPERTIES] as unknown as IFProperty).includes(property);
-}

package/src/filters/helpers/common/isInValidator.ts

@@ -1,11 +0,0 @@
-import { FILTER_VALIDATOR } from "../../constants/common/FILTER_VALIDATOR";
-import { IFValidator } from "../../interfaces/IFValidator";
-
-/**
- * Validates if the given validator is a In type
- * @param validator The validator
- * @returns true: it is a In validator; false: it is not a In validator
- */
-export function isInValidator(validator: IFValidator): boolean {
-    return validator === FILTER_VALIDATOR.IN;
-}

package/src/filters/helpers/common/isNullValidator.ts

@@ -1,11 +0,0 @@
-import { FILTER_VALIDATOR } from "../../constants/common/FILTER_VALIDATOR";
-import { IFValidator } from "../../interfaces/IFValidator";
-
-/**
- * Checks if the given validator is a Null type.
- * @param validator The Filter Validator
- * @returns True: It is a Null Validator; False: It is not a Null Validator.
- */
-export function isNullValidator(validator: IFValidator): boolean {
-    return [FILTER_VALIDATOR.IS_NOT_NULL, FILTER_VALIDATOR.IS_NULL].includes(validator);
-}

package/src/filters/helpers/common/isRangeValidator.ts

@@ -1,17 +0,0 @@
-import { FILTER_VALIDATOR } from "../../constants/common/FILTER_VALIDATOR";
-import { IFValidator } from "../../interfaces/IFValidator";
-
-/**
- * Validates if the given validator is a Range type. Range type means the value has min and max values to filter
- * @param validator The filter validator
- * @returns true: it is a range validator
- */
-export function isRangeValidator(validator: IFValidator): boolean {
-    return [
-        FILTER_VALIDATOR.GREATER_THAN, FILTER_VALIDATOR.GREATER_THAN_EQUAL,
-        FILTER_VALIDATOR.LESS_THAN, FILTER_VALIDATOR.LESS_THAN_EQUAL,
-        FILTER_VALIDATOR.AFTER, FILTER_VALIDATOR.AFTER_ON,
-        FILTER_VALIDATOR.BEFORE, FILTER_VALIDATOR.BEFORE_ON,
-        FILTER_VALIDATOR.BETWEEN_EXCLUSIVE, FILTER_VALIDATOR.BETWEEN_INCLUSIVE
-    ].includes(validator);
-}

package/src/filters/helpers/common/isRegularValidator.ts

@@ -1,16 +0,0 @@
-import { FILTER_VALIDATOR } from "../../constants/common/FILTER_VALIDATOR";
-import { IFValidator } from "../../interfaces/IFValidator";
-
-/**
- * Validates if the given validator is a regular type. Regular type means the filter object has a value as string to filter
- * @param validator The filter validator
- * @returns true: it is a range validator
- */
-export function isRegularValidator(validator: IFValidator): boolean {
-    return [
-        FILTER_VALIDATOR.CONTAINS, FILTER_VALIDATOR.NOT_CONTAIN,
-        FILTER_VALIDATOR.ENDS_WITH, FILTER_VALIDATOR.NOT_END_WITH,
-        FILTER_VALIDATOR.EQUALS, FILTER_VALIDATOR.NOT_EQUAL,
-        FILTER_VALIDATOR.STARTS_WITH, FILTER_VALIDATOR.NOT_START_WITH,
-    ].includes(validator);
-}

package/src/filters/helpers/common/mergeFilters.ts

@@ -1,143 +0,0 @@
-import { isEmpty } from "../../../general/mix/isEmpty";
-import { cloneDeep } from "../../../general/object/cloneDeep";
-import { FILTER_GROUPED_COLUMN_OPERATOR } from "../../constants/common/FILTER_GROUPED_COLUMN_OPERATOR";
-import { IFSData } from "../../interfaces/common/IFSData";
-import { IFSDataset } from "../../interfaces/common/IFSDataset";
-import { IFSFilter } from "../../interfaces/common/IFSFilter";
-import { IFSScope } from "../../interfaces/common/IFSScope";
-import { IFFiltersMergeFilters } from "../../interfaces/functions/IFFiltersMergeFilters";
-import { IFUData } from "../../interfaces/ui/IFUData";
-import { getFilterid } from "./getFilterid";
-import { getMergeFiltersSettings } from "./getMergeFiltersSettings";
-import { mergeValues } from "./mergeValues";
-import { resolveDatasetConditions } from "./resolveDatasetConditions";
-import { resolveFilterConditions } from "./resolveFilterConditions";
-import { resolveScopeConditions } from "./resolveScopeConditions";
-
-/**
- * Merge filter data structures in a new one. The first Filter Data passed in the argument has the priority
- * @param filterData1 The target filter data
- * @param filterData2 the filter data to be merged
- * @param settings configuration of the mergeFilter
- * @returns a new filter data structure
- */
-export function mergeFilters(filterData1: IFSData | IFUData, filterData2: IFSData | IFUData, settings?: IFFiltersMergeFilters): IFSData | IFUData {
-    if (isEmpty(filterData1) || isEmpty(filterData1.scopes)) {
-        if (isEmpty(filterData2) || isEmpty(filterData2.scopes)) return;
-        return filterData2;
-    }
-    if (isEmpty(filterData2) || isEmpty(filterData2.scopes)) return filterData1;
-
-    filterData1 = cloneDeep(filterData1);
-    filterData2 = cloneDeep(filterData2);
-
-    settings = getMergeFiltersSettings(settings);
-    return {
-        enabled: filterData1.enabled,
-        scopes: mergeScopes(filterData1.scopes, filterData2.scopes, settings),
-        section: filterData1.section,
-        version: filterData1.version
-    };
-}
-
-/**
- * Gets a new scope structure array by merging two scope structures
- * @param scopes1 the target scope structure
- * @param scopes2 the scope to be merged
- * @param settings configuration of the mergeFilter
- * @returns a new scope structure array
- */
-function mergeScopes(scopes1: IFSScope[] = [], scopes2: IFSScope[] = [], settings?: IFFiltersMergeFilters): IFSScope[] {
-    let newScopes = scopes1.reduce((scopes: IFSScope[], scope1: IFSScope) => {
-        const scope2Index = scopes2.findIndex(scope2 => resolveScopeConditions(scope2, { scope: scope1.scope, scopeid: scope1.scopeid }));
-        if (scope2Index > -1) {
-            scope1 = {
-                ...scopes2[scope2Index],
-                datasets: mergeDatasets(scope1.datasets, scopes2[scope2Index].datasets, settings)
-            };
-            scopes2.splice(scope2Index, 1);
-        }
-        scopes.push(scope1);
-        return scopes;
-    }, [] as IFSScope[]);
-
-    if (scopes2.length > 0) newScopes = newScopes.concat(scopes2);
-    return newScopes;
-}
-
-/**
- * Gets a new dataset structure array by merging two dataset structures
- * @param datasets1 the target dataset structure
- * @param datasets2 the dataset to be merged
- * @param settings configuration of the mergeFilter
- * @returns a new dataset structure array
- */
-function mergeDatasets(datasets1: IFSDataset[] = [], datasets2: IFSDataset[] = [], settings?: IFFiltersMergeFilters): IFSDataset[] {
-    let newDatasets = datasets1.reduce((datasets: IFSDataset[], dataset1: IFSDataset) => {
-        const dataset2Index = datasets2.findIndex(dataset2 => resolveDatasetConditions(dataset2, { qrveyid: dataset1.qrveyid, linkid: dataset1.linkid }));
-        if (dataset2Index > -1) {
-            dataset1 = {
-                ...datasets2[dataset2Index],
-                filters: mergeFilterss(dataset1.filters, datasets2[dataset2Index].filters, settings)
-            };
-            datasets2.splice(dataset2Index, 1);
-        }
-        datasets.push(dataset1);
-        return datasets;
-    }, [] as IFSDataset[]);
-
-    if (datasets2.length > 0) newDatasets = newDatasets.concat(datasets2);
-    return newDatasets;
-}
-
-/**
- * Gets a new filter structure array by merging two filter structures
- * @param filters1 the target filter structure
- * @param filters2 the filter to be merged
- * @param settings configuration of the mergeFilter
- * @returns a new filter structure array
- */
-function mergeFilterss(filters1: IFSFilter[] = [], filters2: IFSFilter[] = [], settings?: IFFiltersMergeFilters): IFSFilter[] {
-    let newFilters = filters1.reduce((filters: IFSFilter[], filter1: IFSFilter) => {
-        const filter2Index = filters2.findIndex(filter2 => resolveFilterConditions(filter2, { column: filter1.column, dateSection: filter1.dateSection, panelid: filter1.extras.panelid, property: filter1.property, validator: filter1.validator }));
-        if (filter2Index > -1) {
-            filter1 = { ...filter1, values: mergeValues(filter1, filters2[filter2Index], settings) };
-            filter1 = mergeFilterProps(filter1, filters2[filter2Index], settings);
-            filters2.splice(filter2Index, 1);
-        } else {
-            filter1 = { ...filter1, operator: settings.setGroupedColumnOperator ? FILTER_GROUPED_COLUMN_OPERATOR : filter1.operator };
-        }
-        filter1.filterid = getFilterid(filter1);
-        filters.push(filter1);
-        return filters;
-    }, [] as IFSFilter[]);
-
-    if (filters2.length > 0) newFilters = newFilters.concat(filters2);
-    return newFilters;
-}
-
-/**
- * Gets a new filter structure when the setting is configured
- * @param filter1 the target filter structure
- * @param filter2 the filter to be used to merge the values
- * @param settings configuration of the mergeFilter
- * @returns a new filter structure with overwritted props
- */
-function mergeFilterProps(filter1: IFSFilter, filter2: IFSFilter, settings?: IFFiltersMergeFilters) {
-    if (settings.overwriteFilterProps) {
-        filter1 = {
-            ...filter1,
-            collapsed: filter2.collapsed ?? filter1.collapsed,
-            displayed: filter2.displayed ?? filter1.displayed,
-            dateSection: filter2.dateSection,
-            extras: filter2.extras,
-            enabled: filter2.enabled ?? filter1.enabled,
-            operator: filter2.operator || filter1.operator,
-            filterid: filter2.filterid,
-            lookupDisplayIndex: filter2.lookupDisplayIndex,
-            nullValues: filter2.nullValues,
-            selectAll: filter2.selectAll,
-        };
-    }
-    return filter1;
-}

package/src/filters/helpers/common/mergeValues.ts

@@ -1,90 +0,0 @@
-import { isEmpty } from "../../../general/mix/isEmpty";
-import { IFSFilter } from "../../interfaces/common/IFSFilter";
-import { IFSValue } from "../../interfaces/common/IFSValue";
-import { IFSValueRange } from "../../interfaces/common/IFSValueRange";
-import { IFSValueRelativeDate } from "../../interfaces/common/IFSValueRelativeDate";
-import { IFFiltersMergeValues } from "../../interfaces/functions/IFFiltersMergeValues";
-import { IFValue } from "../../interfaces/IFValue";
-import { getMergeValuesSettings } from "./getMergeValuesSettings";
-import { isInValidator } from "./isInValidator";
-import { isNullValidator } from "./isNullValidator";
-import { isRangeValidator } from "./isRangeValidator";
-import { isRegularValidator } from "./isRegularValidator";
-
-/**
- * Gets a new value structure array by merging two value structures
- * @param filter1 the target filter structure
- * @param filter2 the filter to be used to merge the values
- * @param settings configuration of the mergeFilter
- * @returns a new value structure array
- */
-export function mergeValues(filter1: IFSFilter, filter2: IFSFilter, settings?: IFFiltersMergeValues): IFValue[] {
-    if (isEmpty(filter1) && isEmpty(filter2)) return [];
-
-    settings = getMergeValuesSettings(settings);
-
-    let newValues = [];
-    let filter1Values = filter1.values || [];
-    const filter2Values = filter2.values || [];
-    if (settings.overwriteValues) {
-        filter1Values = filter2Values;
-        newValues = filter1Values;
-    } else {
-        if (isInValidator(filter1.validator)) {
-            newValues = filter2Values.reduce((values: IFSValueRelativeDate[], value2: IFSValueRelativeDate) => {
-                const value1Index = (filter1Values as IFSValueRelativeDate[]).findIndex(value1 => value2.anchor === value1.anchor && value2.cursor === value1.cursor && value2.includeCurrent === value1.includeCurrent && value2.isCalendarDate === value1.isCalendarDate && value2.number === value1.number && value2.unit === value1.unit);
-                if (value1Index === -1) {
-                    values.push(value2);
-                } else {
-                    values[value1Index] = {
-                        anchor: value2.anchor,
-                        cursor: value2.cursor,
-                        displayed: value2.displayed ?? values[value1Index].displayed,
-                        enabled: value2.enabled ?? values[value1Index].enabled,
-                        includeCurrent: value2.includeCurrent,
-                        isCalendarDate: value2.isCalendarDate,
-                        number: value2.number,
-                        unit: value2.unit,
-                    };
-                }
-                return values;
-            }, filter1Values as IFValue[]);
-        } else if (isRangeValidator(filter1.validator)) {
-            newValues = filter2Values.reduce((values: IFSValueRange[], value2: IFSValueRange) => {
-                const value1Index = (filter1Values as IFSValueRange[]).findIndex(value1 => value2.max === value1.max && value2.min === value1.min);
-                if (value1Index === -1) {
-                    values.push(value2);
-                } else {
-                    values[value1Index] = {
-                        displayed: value2.displayed ?? values[value1Index].displayed,
-                        enabled: value2.enabled ?? values[value1Index].enabled,
-                        max: value2.max,
-                        min: value2.min,
-                    };
-                }
-                return values;
-            }, filter1Values as IFValue[]);
-        } else if (isRegularValidator(filter1.validator) || isNullValidator(filter1.validator)) {
-            newValues = filter2Values.reduce((values: IFSValue[], value2: IFSValue) => {
-                const value1Index = (filter1Values as IFSValue[]).findIndex(value1 => value2.imageUrl === value1.imageUrl && value2.value === value1.value);
-                if (value1Index === -1) {
-                    values.push(value2);
-                } else {
-                    values[value1Index] = {
-                        displayed: value2.displayed ?? values[value1Index].displayed,
-                        enabled: value2.enabled ?? values[value1Index].enabled,
-                        imageUrl: value2.imageUrl,
-                        value: value2.value,
-                        valueid: value2.valueid,
-                    };
-                }
-                return values;
-            }, filter1Values as IFValue[]);
-        } else {
-            filter1Values = filter1Values.concat(filter2Values);
-            newValues = filter1Values;
-        }
-    }
-
-    return newValues;
-}

package/src/filters/helpers/common/resolveDatasetConditions.ts

@@ -1,19 +0,0 @@
-import { isEmpty } from "../../../general/mix/isEmpty";
-import { _hasProperty } from "../../../general/object/hasProperty";
-import { IFSDataset } from "../../interfaces/common/IFSDataset";
-import { IFSParamsToGetFilter } from "../../interfaces/common/IFSParamsToGetFilter";
-
-/**
- * Resolves the conditions by given params
- * @param filter The dataset structure
- * @param params given parameters to validate the dataset
- * @param letPassUndefinedProperties Flag to avoid applying the condition when the filter properties are undefined
- * @param letPassUndefinedParams Flag to avoid applying the condition when the param properties are explicit undefined.
- * @returns true: the condition is satisfied
- */
-export function resolveDatasetConditions(dataset: IFSDataset, params: IFSParamsToGetFilter, letPassUndefinedProperties = false, letPassUndefinedParams = true): boolean {
-    return (!_hasProperty(params, 'enableds') || !_hasProperty(params.enableds, 'datasets') || (letPassUndefinedProperties && dataset.enabled == null) || (letPassUndefinedParams && params.enableds.datasets == null) || params.enableds.datasets === dataset.enabled) &&
-    (!_hasProperty(params, 'qrveyid') || (letPassUndefinedProperties && dataset.qrveyid == null) || (letPassUndefinedParams && isEmpty(params.qrveyid)) || params.qrveyid === dataset.qrveyid) &&
-    (!_hasProperty(params, 'linkid') || (letPassUndefinedProperties && dataset.linkid == null) || (letPassUndefinedParams && isEmpty(params.linkid)) || params.linkid === dataset.linkid) &&
-    dataset.filters.length > 0;
-}

package/src/filters/helpers/common/resolveFilterConditions.ts

@@ -1,24 +0,0 @@
-import { isEmpty } from "../../../general/mix/isEmpty";
-import { _hasProperty } from "../../../general/object/hasProperty";
-import { IFSFilter } from "../../interfaces/common/IFSFilter";
-import { IFSParamsToGetFilter } from "../../interfaces/common/IFSParamsToGetFilter";
-
-/**
- * Resolves the conditions by given params
- * @param filter The filter
- * @param params given parameters to validate the filter
- * @param letPassUndefinedProperties Flag to avoid applying the condition when the filter properties are undefined
- * @param letPassUndefinedParams Flag to avoid applying the condition when the param properties are explicit undefined.
- * @returns true: the condition is satisfied
- */
-export function resolveFilterConditions(filter: IFSFilter, params: IFSParamsToGetFilter, letPassUndefinedProperties = false, letPassUndefinedParams = true): boolean {
-    return (!_hasProperty(params, 'enableds') || !_hasProperty(params.enableds, 'filters') || (letPassUndefinedProperties && filter.enabled == null) || (letPassUndefinedParams && params.enableds.filters == null) || params.enableds.filters === filter.enabled) &&
-    (!_hasProperty(params, 'dateSection') || (letPassUndefinedProperties && filter.dateSection == null) || (letPassUndefinedParams && isEmpty(params.dateSection)) || params.dateSection === filter.dateSection) &&
-    (!_hasProperty(params, 'panelid') || (letPassUndefinedProperties && filter.extras.panelid == null) || (letPassUndefinedParams && isEmpty(params.panelid)) || params.panelid === filter.extras.panelid) &&
-    (!_hasProperty(params, 'property') || (letPassUndefinedProperties && filter.property == null) || (letPassUndefinedParams && isEmpty(params.property)) || params.property === filter.property) &&
-    (!_hasProperty(params, 'validator') || (letPassUndefinedProperties && filter.validator == null) || (letPassUndefinedParams && isEmpty(params.validator)) || params.validator === filter.validator) &&
-    (!_hasProperty(params, 'column') || (letPassUndefinedProperties && filter.column == null) || (letPassUndefinedParams && isEmpty(params.column)) || ((letPassUndefinedParams && isEmpty(params.column?.id) || params.column?.id === filter.column.id) &&
-        (letPassUndefinedParams && isEmpty(params.column?.qrveyid) || params.column?.qrveyid === filter.column.qrveyid) &&
-        (letPassUndefinedParams && isEmpty(params.column?.linkid) || params.column?.linkid === filter.column.linkid) &&
-        (letPassUndefinedParams && isEmpty(params.column?.aggregate) || params.column?.aggregate === filter.column.aggregate)));
-}

package/src/filters/helpers/common/resolveScopeConditions.ts

@@ -1,19 +0,0 @@
-import { isEmpty } from "../../../general/mix/isEmpty";
-import { _hasProperty } from "../../../general/object/hasProperty";
-import { IFSParamsToGetFilter } from "../../interfaces/common/IFSParamsToGetFilter";
-import { IFSScope } from "../../interfaces/common/IFSScope";
-
-/**
- * Resolves the conditions by given params
- * @param filter The filter scope structure
- * @param params given parameters to validate the filter
- * @param letPassUndefinedProperties Flag to avoid applying the condition when the filter properties are undefined
- * @param letPassUndefinedParams Flag to avoid applying the condition when the param properties are explicit undefined.
- * @returns true: the condition is satisfied
- */
-export function resolveScopeConditions(scope: IFSScope, params: IFSParamsToGetFilter, letPassUndefinedProperties = false, letPassUndefinedParams = true): boolean {
-    return (!_hasProperty(params, 'enableds') || !_hasProperty(params.enableds, 'scopes') || (letPassUndefinedProperties && scope.enabled == null) || (letPassUndefinedParams && params.enableds.scopes == null) || params.enableds.scopes === scope.enabled) &&
-    (!_hasProperty(params, 'scope') || (letPassUndefinedProperties && scope.scope == null) || (letPassUndefinedParams && isEmpty(params.scope)) || scope.scope === params.scope) &&
-    (!_hasProperty(params, 'scopeid') || (letPassUndefinedProperties && scope.scopeid == null) || (letPassUndefinedParams && isEmpty(params.scopeid)) || scope.scopeid === params.scopeid) &&
-    scope.datasets.filter.length > 0;
-}

package/src/filters/helpers/common/validateFilterTextByColumnType.ts

@@ -1,29 +0,0 @@
-// import { IFSColumn, IFUColumn } from "../..";
-// import { isDateColumn, isEmpty, isTokenLabel } from "../../..";
-// import { DATE_FORMAT } from "../../../date/constants/DATE_FORMAT";
-// import { IDateFormat } from "../../../date/interfaces/IDateFormat";
-
-// export function validateFilterTextByColumn(column: IFSColumn | IFUColumn, text = '', extras = {}) {
-//     if (isDateColumn(column as any)) validateDateColumn(text, extras?.dateGroup);
-// }
-
-// function validateDateColumn(date = '', dateGroup: IDateFormat = DATE_FORMAT.DAY): boolean {
-//     if (isEmpty(date)) return false;
-//     if (isTokenLabel(date)) return true;
-
-//     let regexStr = '';
-//     if (format === DATE_FORMAT.MONTH) {
-//     return validateDateFormat(date, ' ', format);
-//     } else if (format === DATE_FORMAT.QUARTER) {
-//     return validateDateFormat(date, ' ', format);
-//     } else if (format === DATE_FORMAT.YEAR) {
-//     regexStr = `^\\d{4}$`;
-//     }else if (format === DATE_FORMAT.WEEK) {
-//     return validateDateFormat(date, ' ', format);
-//     } else {
-//     const refineDate = date.split(' ')[0]; // reafine date if have time
-//     return validateDateFormat(refineDate, '/', format);
-//     }
-//     const regex = new RegExp(regexStr, 'g');
-//     return regex.test(date);
-// }

package/src/filters/helpers/getAggFiltersFromFilterData.ts

@@ -1,63 +0,0 @@
-import { isEmpty } from "../../general/mix/isEmpty";
-import { IFBFilterAggregate } from "../interfaces/backend/IFBFilterAggregate";
-import { IFSData } from "../interfaces/common/IFSData";
-import { getFiltersByAggregateColumn } from "./common/getFiltersByAggregateColumn";
-
-/**
- * @todo FIX AGGREGATE FILTERS
- * @private
- * @param filterData 
- * @param _summaries 
- * @returns the aggFilters structure
- */
-export function getAggFiltersFromFilterData(filterData: IFSData, _summaries: any[]): IFBFilterAggregate {
-  filterData = { ...getFiltersByAggregateColumn(filterData) }; 
-  if (isEmpty(filterData)) return;
-
-  // const uFilters = FDToFlatUI(filterData);
-
-  // const aggFilters: IFBExpressionAggregate[] = uFilters.map(uFilter => {
-  //   const summaryIndex = summaries.findIndex(summary =>
-  //       uFilter.column.id === summary.questionid &&
-  //       uFilter.column.qrveyid === summary.qrveyid &&
-  //       uFilter.column.linkid === summary.linkid &&
-  //       uFilter.column.aggregate === summary.aggregate
-  //   );
-  //   if (summaryIndex > -1) {
-  //       return {
-  //         enabled: uFilter.enabled,
-  //         summaryIndex,
-  //         validationType: getBackendValidator(uFilter.validator),
-  //         value: getBackendValues(uFilter),
-  //       };
-  //     }
-  // }).filter(Boolean);
-
-//   // [TODO: FILTERS - Adapt filter.validator and filter.values in the backend format]
-//   const aggFilters: IFBFilterAggregate[] = filterData.scopes.map((scope) => {
-//     scope.datasets.forEach(dataset => {
-//       buildFilters(dataset.filters);
-      
-//       const filters = dataset.filters.map((filter): IFBExpressionAggregate => {
-//         filter
-//         const summaryIndex = summaries.findIndex(summary =>
-//           filter.column.id === summary.questionid &&
-//           dataset.qrveyid === summary.qrveyid &&
-//           dataset.linkid === summary.linkid &&
-//           filter.column.aggregate === summary.aggregate
-//         );
-//         if (summaryIndex > -1) {
-//           return {
-//             enabled: filter.enabled,
-//             summaryIndex,
-//             validationType: filter.validator as any,
-//             value: filter.values as any,
-//           };
-//         }
-//       }).filter(Boolean);
-//     })
-
-//   }).filter(aggFilter => aggFilter && aggFilter.expressions && aggFilter.expressions.length);
-  
-  return; // aggFilters && concatAggFilters(aggFilters);
-}

package/src/filters/helpers/getAvailableScopes.ts

@@ -1,29 +0,0 @@
-import { isEmpty } from "../../general/mix/isEmpty";
-import { FILTER_SCOPE } from "../constants/common/FILTER_SCOPE";
-import { IFSAvailableScope } from "../interfaces/common/IFSAvailableScope";
-import { IFSScopeID } from "../interfaces/common/IFSScopeID";
-
-/**
- * Gets Scopes/Scope IDs by given IDs
- * @param config given Differnts IDs in order set a available scope
- * @returns a Scopes/Scope IDs array
- */
-export function getAvailableScopes(config: IFSAvailableScope): IFSScopeID[] {
-    if (isEmpty(config)) return;
-
-    if (config.scope != null) return [ { label: config.scope, id: config.scopeid } ];
-
-    let scopes = [];
-    if (!isEmpty(config.predefinedScopes)) scopes = config.predefinedScopes;
-    scopes = [ ...scopes, { label: FILTER_SCOPE.GLOBAL, id: undefined } ];
-
-    if (config.tabid != null || config.pageid != null || config.panelid != null) {
-        if (config.pageid) scopes = [...scopes, { label: FILTER_SCOPE.PAGE, id: config.pageid }];
-        if (config.tabid) scopes = [ ...scopes, { label: FILTER_SCOPE.TAB, id: config.tabid }];
-        if (config.defaultid) scopes = [...scopes, { label: FILTER_SCOPE.DEFAULT, id: config.defaultid }];
-        if (config.panelid || config.tabid || config.pageid) scopes = [...scopes, { label: FILTER_SCOPE.CHART, id: config.panelid || config.tabid || config.pageid }];
-    } else if (config.defaultid) {
-        scopes = [...scopes, { label: FILTER_SCOPE.DEFAULT, id: config.defaultid }];
-    }
-    return scopes;
-}

package/src/filters/helpers/getAvailableScopesIDsByConfig.ts

@@ -1,18 +0,0 @@
-import { getAttribute } from "../../general/object/getAttribute";
-import { IFSAvailableScope } from "../interfaces/common/IFSAvailableScope";
-
-/**
- * Gets the Scopes IDS for the Available Scope function by any config
- * @param config any config
- * @returns a Available Scope IDS config
- */
-export function getAvailableScopesIDsByConfig(config: any = {}): IFSAvailableScope {
-    return {
-        scope: config.scope,
-        scopeid: getAttribute(config, 'scope_id') || config.scopeid,
-        qrveyid: getAttribute(config, 'qrvey_id') || config.qrveyid,
-        tabid: getAttribute(config, 'tab_id') || config.tabid,
-        pageid: getAttribute(config, 'page_id') || config.pageid,
-        defaultid: getAttribute(config, 'default_id') || config.defaultid,
-    };
-}

package/src/filters/helpers/getScopesByHierarchy.ts

@@ -1,19 +0,0 @@
-import { FILTER_SCOPE } from "../constants/common/FILTER_SCOPE";
-import { IFSScopeID } from "../interfaces/common/IFSScopeID";
-import { IFScope } from "../interfaces/IFScope";
-
-/**
- * [TODO: Make a description for this]
- * @param scopes the collection of Scopes/Scope IDs
- * @param currentScope Current scope type
- * @returns A new array of Scopes/Scope IDs
- */
-export function getScopesByHierarchy(scopes: IFSScopeID[] = [], currentScope: IFScope = FILTER_SCOPE.GLOBAL): IFSScopeID[] {
-    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)
-        : [];
-}

package/src/filters/helpers/index.ts

@@ -1,12 +0,0 @@
-export * from './backend/index';
-export * from './builder/index';
-export * from './common/index';
-export * from './ui/index';
-
-export * from './applyHierarchyForAggFilters';
-// export * from './getAggFiltersFromFilterData';
-export * from './getAvailableScopes';
-export * from './getAvailableScopesIDsByConfig';
-export * from './getScopesByHierarchy';
-
-export * from './OLD_getAggFilters';

package/src/filters/helpers/ui/excludeUIFiltersByAggregate.ts

@@ -1,12 +0,0 @@
-import { cloneDeep } from "../../../general/object/cloneDeep";
-import { IFUFilter } from "../../interfaces/ui/IFUFilter";
-
-/**
- * Excludes Aggregate Filters in the Flattened UI Filters array
- * @param uFilters Collection of Flat UI Filters
- * @returns a new Flat UI Filters that were excluded the aggregate filters
- */
-export function excludeUIFiltersByAggregate(uFilters: IFUFilter[] = []): IFUFilter[] {
-  uFilters = cloneDeep(uFilters);
-  return uFilters.filter(uFilter => uFilter.column.aggregate == null);
-}

package/src/filters/helpers/ui/excludeUIFlatFiltersByScopes.ts

@@ -1,17 +0,0 @@
-import { isEmpty } from "../../../general/mix/isEmpty";
-import { cloneDeep } from "../../../general/object/cloneDeep";
-import { IFScope } from "../../interfaces/IFScope";
-import { IFUFlattenedFilter } from "../../interfaces/ui/IFUFlattenedFilter";
-
-/**
- * Excludes and returns a UI Flat Filters without filters by the given scopes
- * @param uFilters The Flatten UI Filters
- * @param scopes collection of scopes types
- * @returns The new array of UI Flattened filters
- */
-export function excludeUIFlatFiltersByScopes(uFilters: IFUFlattenedFilter[] = [], scopes: IFScope[] = []): IFUFlattenedFilter[] {
-    if (isEmpty(uFilters)) return [];
-
-    uFilters = cloneDeep(uFilters);
-    return uFilters.filter(uFilter => !scopes.includes(uFilter.extras.scope));
-}