@qrvey/utils 1.3.0-1 → 1.3.0-12

package/src/filters/services/UChartApi.ts

@@ -0,0 +1,265 @@
+import { isDateColumn } from '../../columns/helpers/isDateColumn';
+import { isNumericalColumn } from '../../columns/helpers/isNumericalColumn';
+import { isRangeValidator } from '../helpers/common/isRangeValidator';
+import { cloneDeep } from '../../general/object/cloneDeep';
+import { IFBData } from '../interfaces/backend/IFBData';
+import { IFilterConfig } from '../interfaces/common/IFilterConfig';
+import { IFUFlattenedFilter } from '../interfaces/ui/IFUFlattenedFilter';
+import { IFBLogic } from '../interfaces/backend/IFBLogic';
+import { IFUChartSettings } from '../interfaces/ui/IFUChartSettings';
+import { isEmpty } from '../../general/mix/isEmpty';
+import { OLD_IFilterData } from '../interfaces/OLD_IFilterData';
+import { COLUMN } from '../../columns/constants/COLUMN';
+import { getAggFiltersBySummaryIndex } from '../helpers/backend/getAggFiltersBySummaryIndex';
+import { IFUColumn } from '../interfaces/ui/IFUColumn';
+import { _get } from '../../general/object/get';
+import { AGGREGATE } from '../../charts/constants/AGGREGATE';
+import { IFValidator } from '../interfaces/IFValidator';
+import { FILTER_VALIDATOR } from '../constants/common/FILTER_VALIDATOR';
+import { flatUIToOldLogic } from '../adapters/flatUIToOldLogic';
+import ChartsApi from '../../services/api/Charts.api';
+import { IFSValue } from '../interfaces/common/IFSValue';
+import { getAggFilters } from '../helpers/OLD_getAggFilters';
+
+export default class UChartApi {
+
+  /**
+   * Gets a promise with a resulting data
+   * @param config the config
+   * @param uFilter The filter Builder filter
+   * @param filterLogic Additional filter logic to apply in the preview
+   * @param chartSettings The settings of the chart. For Aggregate Columns.
+   * @returns a promise with a resulting data
+   */
+  getChartResult = (config: IFilterConfig, uFilter: IFUFlattenedFilter, filterLogic: IFBLogic[] = [], chartSettings?: IFUChartSettings, _resetApi = false): Promise<IFBData> => {
+    const requestBody = this._getPreviewRequestBody(uFilter, filterLogic, chartSettings);
+    const customChartApi = new ChartsApi({ ...config, qrvey_id: isEmpty(uFilter.column.aggregate) ? uFilter.column.qrveyid : chartSettings?.qrveyid });
+    return customChartApi.getResults(requestBody, false, true).then(response => {
+      return this._getDataFromResponse(response, uFilter);
+    }).catch(_ => {
+      return { data: [] };
+    });
+  };
+
+  /**
+   * Gets request body structure
+   * @param uFilter The filter Builder filter
+   * @param filterLogic Additional filter logic to apply in the preview
+   * @param chartSettings The settings of the chart. For Aggregate Columns.
+   * @returns the request body structure
+   */
+  private _getPreviewRequestBody = (uFilter: IFUFlattenedFilter, filterLogic: IFBLogic[] = [], chartSettings?: IFUChartSettings) => {
+    const { column, validator } = uFilter;
+    const haveAggFilters = (chartSettings?.aggregateColumns || []).length && (chartSettings?.chart || []).length;
+    let searchLogic: OLD_IFilterData;
+    if (!isEmpty(uFilter.values)) {
+        searchLogic = flatUIToOldLogic([ {
+            ...uFilter,
+            validator: this._getValidationType(column, validator),
+            column: { ...uFilter.column, linkid: undefined }
+        }]);
+    }
+    let filterCharts = [];
+    if (haveAggFilters) {
+        filterCharts = chartSettings?.chart.map(chart => {
+          if (uFilter.column.type === COLUMN.AGGREGATED_FORMULA) return chart;
+            const summaryIndex = (chart.summaries || []).findIndex(s => s.questionid === uFilter.column.id && s.aggregate === uFilter.column.aggregate);
+            const summary = summaryIndex !== -1 && chart.summaries[summaryIndex];
+            const chartAggFilters = getAggFiltersBySummaryIndex(chart.aggFilters, summaryIndex);
+            const searchAggFilters = getAggFilters(searchLogic?.logic || [], summary ? [summary] : []);
+
+            return {
+                ...chart,
+                aggFilters: searchAggFilters || chartAggFilters,
+                summaries: summary ? [summary] : []
+            };
+      }).filter(chart => chart.summaries.length);
+    }
+    const chartsBody = !filterCharts[0] ? [this._getChartBody(uFilter)] : [filterCharts[0]];
+    const filters = [
+      ...filterLogic,
+      ...!filterCharts[0] ? searchLogic?.logic || [] : []
+    ];
+    return { charts: chartsBody, logic: filters, qrveyid: column.qrveyid };
+  };
+
+  /**
+   * Gets chart body structure
+   * @param uFilter The filter Builder filter
+   * @param chartSettings The settings of the chart. For Aggregate Columns.
+   * @returns the chart body structure
+   */
+  private _getChartBody = (uFilter: IFUFlattenedFilter, chartSettings?: IFUChartSettings) => {
+    const dimensions = this._getDimensionsBody(uFilter, chartSettings);
+    const summaries = this._getSummariesBody(uFilter);
+
+    return { dimensions, summaries };
+  };
+
+  /**
+   * Gets dimension body structure
+   * @param uFilter The filter Builder filter
+   * @param chartSettings The settings of the chart. For Aggregate Columns.
+   * @returns the dimension body structure
+   */
+  private _getDimensionsBody = (uFilter: IFUFlattenedFilter, chartSettings?: IFUChartSettings) => {
+    const { column, validator } = uFilter;
+
+    let dimensions;
+    if (!isRangeValidator(validator)) {
+      dimensions = [{
+        questionid: column.id,
+        qrveyid: column.qrveyid,
+        // linkid: column.linkid,
+        maxDataPoints: this._getMaxDataPoints(column, chartSettings),
+        type: column.type,
+        formulaType: column.type === 'FORMULA' ? column.formulaType : undefined,
+        sortOption: this._getSortOption(column)
+      }];
+      dimensions = this._refineBodies([ ...dimensions ], uFilter);
+    }
+    return dimensions;
+  };
+
+  /**
+   * Gets max data point number
+   * @param column The column to filter
+   * @param chartSettings The settings of the chart. For Aggregate Columns.
+   * @returns max data point number
+   */
+  private _getMaxDataPoints = (column: IFUColumn, chartSettings?: IFUChartSettings) => {
+    return !isDateColumn(column) && !isEmpty(column.aggregate) ? _get(chartSettings, 'maxDataPoints.option', 1000) : 1000;
+  };
+
+  /**
+   * Gets sort option structure
+   * @param column The column to filter
+   * @returns sort option structure
+   */
+  private _getSortOption = (column: IFUColumn) => {
+    let sortBy = 'CATEGORY';
+    let sortDirection = isNumericalColumn(column) ? 'DESC' : 'ASC';
+    if (!isEmpty(column.sorting)) {
+      sortBy = _get(column.sorting, 'sortBy');
+      sortDirection = _get(column.sorting, 'order');
+      if (sortBy == null) sortBy = 'VALUE';
+      if (sortDirection == null) sortDirection = 'DESC';
+    }
+    return { sortBy, sortDirection };
+  };
+
+  /**
+   * Gets summaries body structure
+   * @param uFilter The filter Builder filter
+   * @returns summaries body structure
+   */
+  private _getSummariesBody = (uFilter: IFUFlattenedFilter) => {
+    const { column, validator } = uFilter;
+
+    const summary = {
+      aggregate: _get(column, 'aggregate.label', AGGREGATE.COUNT),
+      questionid: column.id,
+      property: !isDateColumn(uFilter.column) ? uFilter.property : undefined,
+      type: column.type
+    };
+    let summaries = [ summary ];
+    if (isNumericalColumn(column) || isRangeValidator(validator)) {
+      summaries = [
+        { ...summary, aggregate: AGGREGATE.MIN },
+        { ...summary, aggregate: AGGREGATE.MAX }
+      ];
+    }
+    return summaries;
+  };
+
+  /**
+   * Refines the body structure
+   * @param bodies The body structure
+   * @param uFilter The filter Builder filter
+   * @returns the body structure
+   */
+  private _refineBodies = (bodies: any[], uFilter: IFUFlattenedFilter) => {
+    const _bodies = cloneDeep(bodies);
+    if (uFilter.property != null) {
+      _bodies.forEach(body => {
+        if (isDateColumn(uFilter.column)) {
+          body['groupType'] = 'DATE';
+          body['groupValue'] = uFilter.property.toUpperCase();
+        } else {
+          body['property'] = uFilter.property;
+        }
+      });
+    }
+    return _bodies;
+  };
+
+  /**
+   * Gets the validation type for the preview request
+   * @param column The column to filter
+   * @param vaildator Validator Type
+   * @returns the validator type for the preview request
+   */
+  private _getValidationType = (column: IFUColumn, validator: IFValidator): IFValidator => {
+    if (isDateColumn(column) || column.type === COLUMN.BUCKET || isNumericalColumn(column)) {
+      return FILTER_VALIDATOR.EQUALS;
+    } else {
+      if ([FILTER_VALIDATOR.NOT_CONTAIN, FILTER_VALIDATOR.EQUALS, FILTER_VALIDATOR.NOT_EQUAL].includes(validator)) {
+        return FILTER_VALIDATOR.CONTAINS;
+      } else if (validator === FILTER_VALIDATOR.NOT_END_WITH) {
+        return FILTER_VALIDATOR.ENDS_WITH;
+      } else if (validator === FILTER_VALIDATOR.NOT_START_WITH) {
+        return FILTER_VALIDATOR.STARTS_WITH;
+      } else {
+        return validator;
+      }
+    }
+  };
+
+  /**
+   * Gets the Data from preview Response
+   * @param response The preview presponse
+   * @param uFilter The filter Builder filter
+   * @returns The resulting data
+   */
+  private _getDataFromResponse = (response: any, uFilter: IFUFlattenedFilter): IFBData => {
+    const data = { data: [] };
+    if (isRangeValidator(uFilter.validator)) {
+      data.data = isEmpty(uFilter.column.aggregate)
+        ? _get(response, '[0].summary', []).map(summary => ({ value: summary }))
+        : [{ value: _get(response, '[0].min') }, { value: _get(response, '[0].max') }];
+    } else if (!this.isResultEmpty(response)) {
+      const records = _get(response, 'data');
+      data.data = isEmpty(uFilter.column.aggregate)
+        ? records.map(record => ({
+          value: record.key.toString()
+        }))
+        : this._getResponseSummaries(records);
+    }
+    return data;
+  };
+
+  /**
+   * Gets summaries from preview response
+   * @param records The data from preview response
+   * @param values The values from the preview response
+   * @returns the sumaries
+   */
+  private _getResponseSummaries = (records: any[], values: IFSValue[] = []): IFSValue[] => {
+    records.forEach(record => {
+      const value = record.summary[0].toString();
+      if (Array.isArray(record.items) && record.items.length) values = this._getResponseSummaries(record.items, values);
+      else if (!Array.isArray(record.items) && !isEmpty(values.find(v => v.value === value))) values.push({ value });
+    });
+    return values;
+  };
+
+  private isResultEmpty = (resultObject, validateNesteddata = false): boolean => {
+    const result = _get(resultObject, '[0].data');
+    let validation = isEmpty(result);
+    if (validateNesteddata && !validation) {
+      // Searching empty data when Chart is Multiseries. At least, Chart needs a single item to draw in the serie. (See the second level of the result object)
+      validation = result.every(data => !isEmpty(data) && isEmpty(_get(data, 'items')));
+    }
+    return validation;
+  };
+}

package/src/filters/services/UChartPaginationApi.ts

@@ -0,0 +1,326 @@
+import { isNumericalColumn } from "../../columns/helpers/isNumericalColumn";
+import { isDateColumn } from "../../columns/helpers/isDateColumn";
+import { getAggFilters } from "../helpers/OLD_getAggFilters";
+import { IFBData } from "../interfaces/backend/IFBData";
+import { IFSValue } from "../interfaces/common/IFSValue";
+import ChartsApi from "../../services/api/Charts.api";
+import { isRangeValidator } from "../helpers/common/isRangeValidator";
+import { getUniqueArray } from "../../general/array/getUniqueArray";
+import { IFilterConfig } from "../interfaces/common/IFilterConfig";
+import { IFUFlattenedFilter } from "../interfaces/ui/IFUFlattenedFilter";
+import { IFBLogic } from "../interfaces/backend/IFBLogic";
+import { isEmpty } from "../../general/mix/isEmpty";
+import { IFUChartSettings } from "../interfaces/ui/IFUChartSettings";
+import { OLD_IFilterData } from "../interfaces/OLD_IFilterData";
+import { getAggFiltersBySummaryIndex } from "../helpers/backend/getAggFiltersBySummaryIndex";
+import { COLUMN } from "../../columns/constants/COLUMN";
+import { _get } from "../../general/object/get";
+import { IFUColumn } from "../interfaces/ui/IFUColumn";
+import { AGGREGATE } from "../../charts/constants/AGGREGATE";
+import { cloneDeep } from "../../general/object/cloneDeep";
+import { FILTER_VALIDATOR } from "../constants/common/FILTER_VALIDATOR";
+import { IFValidator } from "../interfaces/IFValidator";
+import { flatUIToOldLogic } from '../adapters/flatUIToOldLogic';
+
+export default class UChartPaginationApi {
+
+    afterKey: any;
+    uFilter: IFUFlattenedFilter;
+
+    /**
+     * Gets afterKey object
+     * @returns the afterKey object
+     */
+    getAfterKey = (): any => {
+        return this.afterKey;
+    };
+
+    /**
+     * Gets a promise with a resulting data
+     * @param config the config
+     * @param uFilter The filter Builder filter
+     * @param filterLogic Additional filter logic to apply in the preview
+     * @param chartSettings The settings of the chart. For Aggregate Columns.
+     * @returns a promise with a resulting data
+     */
+    getChartResult = (config: IFilterConfig, uFilter: IFUFlattenedFilter, filterLogic: IFBLogic[] = [], chartSettings?: IFUChartSettings, resetApi = false): Promise<IFBData> => {
+        this.refineAfterkey(uFilter, resetApi);
+        this.setProps(uFilter);
+
+        const requestBody = this._getPreviewRequestBody(uFilter, filterLogic, chartSettings, this.afterKey);
+        const customChartApi = new ChartsApi({ ...config, qrvey_id: isEmpty(uFilter.column.aggregate) ? uFilter.column.qrveyid : chartSettings?.qrveyid });
+        return customChartApi.getResultsPagination(requestBody, false).then(response => {
+          return this._getDataFromResponse(response, uFilter);
+        }).catch(_ => {
+          return { data: [], total: 0 };
+        });
+    };
+
+    /**
+     * Gets request body structure
+     * @param uFilter The filter Builder filter
+     * @param filterLogic Additional filter logic to apply in the preview
+     * @param chartSettings The settings of the chart. For Aggregate Columns.
+     * @returns the request body structure
+     */
+    private _getPreviewRequestBody = (uFilter: IFUFlattenedFilter, filterLogic: IFBLogic[] = [], chartSettings?: IFUChartSettings, afterKey?: any) => {
+        const { column, validator } = uFilter;
+        const haveAggFilters = (chartSettings?.aggregateColumns || []).length && (chartSettings?.chart || []).length;
+        let searchLogic: OLD_IFilterData;
+        if (!isEmpty(uFilter.values)) {
+            searchLogic = flatUIToOldLogic([ {
+                ...uFilter,
+                validator: this._getValidationType(column, validator),
+                column: { ...uFilter.column, linkid: undefined } 
+            }]);
+        }
+        let filterCharts = [];
+        if (haveAggFilters) {
+            filterCharts = chartSettings?.chart.map(chart => {
+                const summaryIndex = (chart.summaries || []).findIndex(s => s.questionid === uFilter.column.id && s.aggregate === uFilter.column.aggregate);
+                const summary = summaryIndex !== -1 && chart.summaries[summaryIndex];
+                const chartAggFilters = getAggFiltersBySummaryIndex(chart.aggFilters, summaryIndex);
+                const searchAggFilters = getAggFilters(searchLogic?.logic || [], summary ? [summary] : []);
+
+                return {
+                    ...chart,
+                    aggFilters: searchAggFilters || chartAggFilters,
+                    summaries: summary ? [summary] : []
+                };
+          }).filter(chart => chart.summaries.length);
+        }
+
+        const dimensions = !filterCharts[0] ? this._getDimensionsBody(uFilter) : this._getDimensionsBodyAdapter(filterCharts[0].dimensions);
+        const summaries = !filterCharts[0] ? this._getSummariesBody(uFilter) : filterCharts[0].summaries;
+        const maxDataPoints = this._getMaxDataPoints(column, chartSettings);
+
+        const filters = [
+          ...filterLogic,
+          ...!filterCharts[0] ? searchLogic?.logic || [] : []
+        ];
+        return { dimensions, summaries, maxDataPoints, afterKey, logic: filters };
+    };
+    
+    /**
+     * Gets dimension body structure
+     * @param uFilter The filter Builder filter
+     * @returns the dimension body structure
+     */
+    private _getDimensionsBody = (uFilter: IFUFlattenedFilter) => {
+        const { column, validator } = uFilter;
+
+        let dimensions;
+        if (!isRangeValidator(validator)) {
+            dimensions = [{
+                questionid: column.id,
+                type: column.type,
+                formulaType: column.type === COLUMN.FORMULA ? column.formulaType : undefined,
+                sort: this._getSortOption(column)
+            }];
+            dimensions = this._refineBodies([ ...dimensions ], uFilter);
+        }
+        return dimensions;
+    };
+
+    /**
+     * Get a dimension body structure foor pagination endpoint
+     * @param dimensions 
+     * @returns the dimension body structure
+     */
+    private _getDimensionsBodyAdapter = (dimensions = []) => {
+        return dimensions.map(dimension => ({
+            questionid: dimension.questionid,
+            type: dimension.type,
+            formulaType: dimension.type === COLUMN.FORMULA ? dimension.formulaType : undefined,
+            groupType: dimension.groupType,
+            groupValue: dimension.groupValue,
+            sort: {
+                by: _get(dimension, 'sortOption.sortBy', 'VALUE'),
+                direction: _get(dimension, 'sortOption.sortDirection', 'DESC'),
+            }
+        }));
+    };
+
+    /**
+     * Gets max data point number
+     * @param column The column to filter
+     * @param chartSettings The settings of the chart. For Aggregate Columns.
+     * @returns max data point number
+     */
+    private _getMaxDataPoints = (column: IFUColumn, chartSettings?: IFUChartSettings) => {
+        return !isDateColumn(column) && !isEmpty(column.aggregate) ? _get(chartSettings, 'maxDataPoints.option', 1000) : 1000;
+    };
+
+
+    /**
+     * Gets sort option structure
+     * @param column The column to filter
+     * @returns sort option structure
+     */
+    private _getSortOption = (column: IFUColumn) => {
+        let by = 'CATEGORY';
+        let direction = isNumericalColumn(column) ? 'DESC' : 'ASC';
+        if (!isEmpty(column.sorting)) {
+            by = _get(column.sorting, 'sortBy');
+            direction = _get(column.sorting, 'order');
+            if (by == null) by = 'VALUE';
+            if (direction == null) direction = 'DESC';
+        }
+        return { by, direction };
+    };
+
+    /**
+     * Gets summaries body structure
+     * @param uFilter The filter Builder filter
+     * @returns summaries body structure
+     */
+    private _getSummariesBody = (uFilter: IFUFlattenedFilter) => {
+        const { column, validator } = uFilter;
+
+        const summary = {
+            aggregate: _get(column, 'aggregate.label', AGGREGATE.COUNT),
+            questionid: column.id,
+            property: !isDateColumn(uFilter.column) ? uFilter.property : undefined,
+            type: column.type
+        };
+        let summaries = [ summary ];
+        if (isNumericalColumn(column) || isRangeValidator(validator)) {
+            summaries = [
+            { ...summary, aggregate: AGGREGATE.MIN },
+            { ...summary, aggregate: AGGREGATE.MAX }
+            ];
+        }
+        return summaries;
+    };
+
+    /**
+     * Refines the body structure
+     * @param bodies The body structure
+     * @param uFilter The filter Builder filter
+     * @returns the body structure
+     */
+    private _refineBodies = (bodies: any[], uFilter: IFUFlattenedFilter) => {
+        const _bodies = cloneDeep(bodies);
+        if (uFilter.property != null) {
+            _bodies.forEach(body => {
+                if (isDateColumn(uFilter.column)) {
+                    body['groupType'] = 'DATE';
+                    body['groupValue'] = uFilter.property.toUpperCase();
+                } else {
+                    body['property'] = uFilter.property;
+                }
+            });
+        }
+        return _bodies;
+    };
+
+    /**
+     * Gets the validation type for the preview request
+     * @param column The column to filter
+     * @param vaildator Validator Type
+     * @returns the validator type for the preview request
+     */
+    private _getValidationType = (column: IFUColumn, validator: IFValidator): IFValidator => {
+        if (isDateColumn(column) || column.type === COLUMN.BUCKET || isNumericalColumn(column)) {
+            return FILTER_VALIDATOR.EQUALS;
+        } else {
+            if ([FILTER_VALIDATOR.NOT_CONTAIN, FILTER_VALIDATOR.EQUALS, FILTER_VALIDATOR.NOT_EQUAL].includes(validator)) {
+                return FILTER_VALIDATOR.CONTAINS;
+            } else if (validator === FILTER_VALIDATOR.NOT_END_WITH) {
+                return FILTER_VALIDATOR.ENDS_WITH;
+            } else if (validator === FILTER_VALIDATOR.NOT_START_WITH) {
+                return FILTER_VALIDATOR.STARTS_WITH;
+            } else {
+                return validator;
+            }
+        }
+    };
+
+    /**
+     * Gets the Data from preview Response
+     * @param response The preview presponse
+     * @param uFilter The filter Builder filter
+     * @returns The resulting data
+     */
+    private _getDataFromResponse = (response: any, uFilter: IFUFlattenedFilter): IFBData => {
+        const data = { data: [], total: 0 };
+        if (!this.isResultPaginationEmpty(response)) {
+            const records = _get(response, 'data');
+            data.data = isEmpty(uFilter.column.aggregate)
+                ? records.map(record => ({
+                value: record.key.toString()
+                }))
+                : this._getResponseSummaries(records);
+
+            data.data = getUniqueArray(data.data, 'value');
+            data.total = _get(response, 'totalGroups', 0) ?? 0;
+            this.setAfterKey(_get(response, 'afterKey'));
+        }
+        return data;
+    };
+
+    /**
+     * Gets summaries from preview response
+     * @param records The data from preview response
+     * @param values The values from the preview response
+     * @returns the sumaries
+     */
+    private _getResponseSummaries = (records: any[], values: IFSValue[] = []): IFSValue[] => {
+        records.forEach(record => {
+            const value = record.summaries[0].toString();
+            value && values.push({ value });
+        });
+        return values;
+    };
+
+    /**
+     * Refines the afterKey object
+     * @param props 
+     */
+    private refineAfterkey = (uFilter: IFUFlattenedFilter, forceSet = false): void => {
+        if (forceSet
+            || _get(uFilter, 'values[0].value', '') !==  _get(this.uFilter, 'values[0].value', '')
+            || !this.areColumnsEquals(uFilter.column, _get(this.uFilter, 'column'))
+            || uFilter.validator !== this.uFilter.validator
+            || uFilter.property !== this.uFilter.property
+            || uFilter.extras.scope !== this.uFilter.extras.scope
+        ) this.setAfterKey(undefined);
+    };
+
+    /**
+     * Sets the afterKey object
+     * @param afterKey the afterKey object
+     */
+    setAfterKey = (afterKey: any): void => {
+        this.afterKey = afterKey;
+    };
+
+    /**
+     * Sets the Filter Builder Filter
+     * @param uFilter
+     */
+    setProps = (uFilter: IFUFlattenedFilter): void => {
+        this.uFilter = cloneDeep(uFilter);
+    };
+
+    /**
+     * Checks if two filter columns are the same.
+     * @param column1 
+     * @param column2 
+     * @returns True: Columns are equal; False: Columns are not equal
+     */
+    areColumnsEquals = (column1: IFUColumn, column2: IFUColumn): boolean => {
+        if (isEmpty(column1) || isEmpty(column2)) return false;
+
+        return column1.id === column2.id &&
+            column1.qrveyid === column2.qrveyid &&
+            column1.property === column2.property &&
+            column1.aggregate === column2.aggregate;
+    };
+
+    isResultPaginationEmpty = (resultObject): boolean => {
+        const result = _get(resultObject, 'data');
+        return isEmpty(result);
+      };
+      
+}

package/src/filters/services/index.ts

@@ -0,0 +1,3 @@
+export * from './Filters.api';
+export * from './UChartApi';
+export * from './UChartPaginationApi';

package/src/general/array/addPropertyToArrayOfObjects.ts

@@ -0,0 +1,32 @@
+import { isEmpty } from '../mix/isEmpty';
+import { isObject } from '../object/isObject';
+
+/**
+ * It takes an array of objects, adds a property to each object, and returns the new array.
+ * @param {Object} info - Information needed to add property to the array of objects.
+ * @param {Array} info.array - The array of objects you want to add a property to.
+ * @param {string} info.property - The property you want to add to the object.
+ * @param {any} info.value - - The value to be added to the array of objects.
+ * ----------------------------------------------------------------------------------------------
+ * @example <caption>Example usage of addPropertyToArrayOfObjects.</caption>
+ * addPropertyToArrayOfObjects({
+ * 	array: [{ name: "John", lastName: "Doe" }, { name: "Chris", lastName: "Musk" }],
+ * 	property: "lastName",
+ * 	value: 'Peck'
+ * });
+ * @returns the new array created.
+ */
+export function addPropertyToArrayOfObjects(obj: AddPropertyToArrayOfObjectsParams): any[] {
+	if (isEmpty(obj) || !isObject(obj)) return [];
+	const { array, property, value } = obj;
+	if (Array.isArray(array)) {
+		if (isEmpty(array) || isEmpty(property)) return array;
+		return array.map((element) => ({ ...element, [property]: value }));
+	}
+	return [];
+}
+type AddPropertyToArrayOfObjectsParams = {
+	array: any[];
+	property: string;
+	value: any;
+};

package/src/general/array/getArrayByProperty.ts

@@ -0,0 +1,14 @@
+import { isEmpty } from "../mix/isEmpty";
+
+/**
+ * Gets a collection of object values by the given property
+ * @param arr An array
+ * @param property the property to get the value collection
+ * @returns a collection of values by property
+ */
+export function getArrayByProperty<T = any>(arr: T[], property: string): T[] {
+    if (!Array.isArray(arr)) return arr;
+    return (arr as any).map(a => {
+        if (!isEmpty(a)) return a[property];
+    }).filter(Boolean);
+}

package/src/general/array/getUniqueArray.ts

@@ -0,0 +1,11 @@
+/**
+ * Remove duplicated items from a given array by property name
+ * // 1. Store the keys of the unique objects
+ * // 2. Eliminate the dead keys & store unique objects
+ * @param arr The array
+ * @param prop Property name to search duplicated values
+ * @return Array without duplicated items.
+ */
+export function getUniqueArray(arr: any[], prop: string): any[] {
+    return arr.map(e => e[prop]).map((e, i, final) => final.indexOf(e) === i && i).filter(e => arr[e]).map(e => arr[e]);
+}

package/src/general/array/index.ts

@@ -1,5 +1,7 @@
+export * from './addPropertyToArrayOfObjects';
 export * from './delete';
 export * from './flattenDeep';
+export * from './getArrayByProperty';
 export * from './filterNestedTree';
 export * from './getFirstIndexFromArray';
 export * from './getLastIndexFromArray';