@qrvey/filters 0.0.44 → 0.1.0

package/src/classes/FilterSearcher.ts

@@ -1,243 +0,0 @@
-import {
-  getLastIndexFromArray,
-  isEmpty,
-  isNaNV2,
-  objectCopy,
-} from "@qrvey/utils";
-
-import { getParamFiltersSettings } from "../helpers/filter-settings.helpers";
-import { resolveFilterConditions } from "../helpers/resolveFilterConditions";
-import { IFilterSearcherParams } from "../models/filter-searcher.models";
-import {
-  IFilterFindLastIndexReturn,
-  IFilterParamSettings,
-} from "../resources/filter-functions.resources";
-import { IFilter } from "../resources/filters.resources";
-
-/**
- * Class to search filters.
- */
-export class FilterSearcher implements IFilterSearcherParams {
-  /**
-   * Constructor
-   * @param filters the collection of filters
-   */
-  constructor(protected filters: IFilter[] = []) {
-    this.setFilters(Array.isArray(filters) ? filters : []);
-  }
-
-  /**
-   * **************************************************************************************************
-   **************************************** By Params *************************************************
-   ****************************************************************************************************
-   */
-
-  /**
-   * Searchs and excludes filters by the given params
-   * @param params params to exclude the filters
-   * @param settings settings for this function
-   * @returns the new collection of filters
-   */
-  public excludeByParams(
-    params: Partial<IFilter>,
-    settings?: IFilterParamSettings,
-  ): IFilter[] {
-    if (isEmpty(this.filters) || isEmpty(params)) return this.filters;
-
-    const completeSettings: IFilterParamSettings =
-      getParamFiltersSettings(settings);
-
-    return this.filters.filter(
-      (filter: IFilter) =>
-        !resolveFilterConditions(filter, params, completeSettings),
-    );
-  }
-
-  /**
-   * Searchs filters by the given params
-   * @param params params to search the filters
-   * @param settings settings for this function
-   * @returns the new collection of filters
-   */
-  public filterByParams(
-    params: Partial<IFilter>,
-    settings?: IFilterParamSettings,
-  ): IFilter[] {
-    if (isEmpty(this.filters) || isEmpty(params)) return this.filters;
-
-    const completeSettings: IFilterParamSettings =
-      getParamFiltersSettings(settings);
-
-    return this.filters.filter((filter: IFilter) =>
-      resolveFilterConditions(filter, params, completeSettings),
-    );
-  }
-
-  /**
-   * Searchs filters by the given params and returns the indexes
-   * @param params params to search the filters
-   * @param settings settings for this function
-   * @returns the new collection of filters
-   */
-  public filterIndexesByParams(
-    params: Partial<IFilter>,
-    settings?: IFilterParamSettings,
-  ): number[] {
-    if (isEmpty(this.filters) || isEmpty(params)) return [];
-
-    const completeSettings: IFilterParamSettings =
-      getParamFiltersSettings(settings);
-
-    return this.filters.reduce(
-      (indexes: number[], filter: IFilter, index: number) => {
-        const condition = resolveFilterConditions(
-          filter,
-          params,
-          completeSettings,
-        );
-        if (condition) {
-          indexes.push(index);
-        }
-        return indexes;
-      },
-      [],
-    );
-  }
-
-  /**
-   * Searchs filters by the given params.
-   * Gets the first match of the searching
-   * @param params params to search the filters
-   * @param settings settings for this function
-   * @returns the new collection of filters
-   */
-  public findByParams(
-    params: Partial<IFilter>,
-    settings?: IFilterParamSettings,
-  ): IFilter | undefined {
-    if (isEmpty(this.filters) || isEmpty(params)) return undefined;
-
-    return this.filters.find((filter: IFilter) =>
-      resolveFilterConditions(
-        filter,
-        params,
-        getParamFiltersSettings(settings),
-      ),
-    );
-  }
-
-  /**
-   * Searchs filters by the given params.
-   * Gets the first match of the searching and returns the related index
-   * @param params params to search the filters
-   * @param settings settings for this function
-   * @returns the new collection of filters
-   */
-  public findIndexByParams(
-    params: Partial<IFilter>,
-    settings?: IFilterParamSettings,
-  ): number {
-    if (isEmpty(this.filters) || isEmpty(params)) return -1;
-
-    return this.filters.findIndex((filter: IFilter) =>
-      resolveFilterConditions(
-        filter,
-        params,
-        getParamFiltersSettings(settings),
-      ),
-    );
-  }
-
-  /**
-   * **************************************************************************************************
-   **************************************** By Filters *************************************************
-   ****************************************************************************************************
-   */
-
-  /**
-   * Gets an index where the new filter is going to be added
-   * If an index is given, the searching is skipped
-   * @param newFilter the new filter to add
-   * @param index a custom index
-   * @returns the index result object
-   */
-  public findLastIndexByFilter(
-    newFilter: IFilter,
-    index = -1,
-  ): IFilterFindLastIndexReturn {
-    const result = {
-      index: -1,
-      nextToColumnFilter: false,
-      nextToDatasetFilter: false,
-      nextToScopeFilter: false,
-    };
-    if (isEmpty(newFilter)) return result;
-    const newIndex = isNaNV2(index) ? -1 : (index as number);
-    if (this.filters.length <= newIndex)
-      return { ...result, index: this.filters.length - 1 };
-    if (newIndex > -1) return { ...result, index: newIndex };
-
-    // Look index next to Scope - Dataset - column
-    let lastIndex = getLastIndexFromArray(
-      this.filters,
-      (aFilter: IFilter) =>
-        aFilter.columnId === newFilter.columnId &&
-        aFilter.datasetId === newFilter.datasetId &&
-        aFilter.scope === newFilter.scope &&
-        aFilter.scopeId === newFilter.scopeId,
-    );
-    if (lastIndex > -1)
-      return { ...result, index: lastIndex, nextToColumnFilter: true };
-
-    // Look index next to Scope - Dataset
-    lastIndex = getLastIndexFromArray(
-      this.filters,
-      (aFilter: IFilter) =>
-        aFilter.datasetId === newFilter.datasetId &&
-        aFilter.scope === newFilter.scope &&
-        aFilter.scopeId === newFilter.scopeId,
-    );
-    if (lastIndex > -1)
-      return { ...result, index: lastIndex, nextToDatasetFilter: true };
-
-    // Look index next to Scope
-    lastIndex = getLastIndexFromArray(
-      this.filters,
-      (aFilter: IFilter) =>
-        aFilter.scope === newFilter.scope &&
-        aFilter.scopeId === newFilter.scopeId,
-    );
-    if (lastIndex > -1)
-      return { ...result, index: lastIndex, nextToScopeFilter: true };
-
-    return result;
-  }
-
-  /**
-   * **************************************************************************************************
-   ****************************************** Getters *************************************************
-   ****************************************************************************************************
-   */
-
-  /**
-   * Gets the filter collection
-   * @returns the collection of filters of the context
-   */
-  public getFilters(): IFilter[] {
-    return this.filters;
-  }
-
-  /**
-   * **************************************************************************************************
-   ****************************************** Setters *************************************************
-   ****************************************************************************************************
-   */
-
-  /**
-   * Sets the filters
-   * @param filters the new collection of filters to set
-   */
-  public setFilters(filters: IFilter[]): void {
-    this.filters = objectCopy(filters);
-  }
-}

package/src/classes/FilterValidation.ts

@@ -1,221 +0,0 @@
-import { getFilterType } from "../helpers/getFilterType";
-import {
-  FILTER_GROUPING_COLUMNS,
-  FILTER_GROUPING_VALIDATORS,
-  IColumnTypeWithGrouping,
-} from "../resources/filter-grouping.resources";
-import {
-  IFilterValueRange,
-  IFilterValueRanking,
-  IFilterValueRegular,
-  IFilterValueRelativeDate,
-} from "../resources/filter-values.resources";
-import { FILTER_TYPE, IFilter } from "../resources/filters.resources";
-import { IFilterValidator } from "../resources";
-
-/**
- *
- */
-export class FilterValidation {
-  //   /**
-  //    *
-  //    * @param filter
-  //    */
-  //   filter(filter: IFilter): IFilterValidationSingleError {
-  //     const errors: IFilterValidationError[] = [];
-
-  //     if (isEmpty(filter) || !isObject(filter))
-  //       errors.push({ type: FILTER_VALIDATION.EMPTY_FILTER });
-
-  //     return {
-  //       infoErrors: getInfoErrors(errors),
-  //       errors,
-  //     };
-  //   }
-
-  //   /**
-  //    *
-  //    * @param filter
-  //    * @param values
-  //    */
-  //   static values(
-  //     filter: IFilter,
-  //     values: IFilterInputValue[],
-  //   ): IFilterValidationSingleError {
-  //     const errors: IFilterValidationError[] = [];
-  //     if (isEmpty(filter)) errors.push({ type: FILTER_VALIDATION.EMPTY_FILTER });
-
-  //     const { columnType, validator, values: filterValues } = filter;
-
-  //     const filterType = getFilterType(columnType, validator);
-
-  //     switch (filterType) {
-  //       case FILTER_TYPE.NULL:
-  //         if (!isEmpty(filterValues) || !isEmpty(values))
-  //           errors.push({ type: FILTER_VALIDATION.EMPTY_FILTER });
-  //         break;
-  //       case FILTER_TYPE.RANGE:
-  //         if (isEmpty(values))
-  //           errors.push({ type: FILTER_VALIDATION.NOT_EMPTY_VALUES });
-  //         else if (values)
-  //           FilterValidation.rangeValues(filter, values)
-  //       default:
-  //         break;
-  //     }
-  //   }
-
-  //   private static rangeValues(filter: IFilter, values: IFilterInputValueRange[]): IFilterValidationSingleError {
-  //     const errors: IFilterValidationError[] = [];
-
-  //     filter.validator
-  //     FILTER_VALIDATOR.
-
-  //     values.forEach(value => {
-  //       if (value.max
-  //     });
-  //   }
-
-  /**
-   * Validated if the given filter exists into the filter collection
-   * @param filters the collection of filters
-   * @param filter the filter to validate
-   * @returns True when the filter is duplicated in the collection
-   */
-  static isDuplicated(filters: IFilter[], filter: IFilter): boolean {
-    if (!Array.isArray(filters)) return false;
-    return filters.some(
-      (_filter: IFilter) =>
-        _filter.aggregateType === filter.aggregateType &&
-        _filter.columnId === filter.columnId &&
-        _filter.datasetId === filter.datasetId &&
-        _filter.grouping === filter.grouping &&
-        _filter.id === filter.id &&
-        _filter.lookupDisplayIndex === filter.lookupDisplayIndex &&
-        _filter.scope === filter.scope &&
-        _filter.scopeId === filter.scopeId &&
-        _filter.validator === filter.validator &&
-        FilterValidation.isFilterValueDuplicated(_filter, filter),
-    );
-  }
-
-  /**
-   * Validates if the given regular value is duplicated with another value collection
-   * @param filter1 the filter info
-   * @param filter2 the filter info to compare
-   * @returns true when the value is duplicated
-   */
-  static isFilterValueDuplicated(filter1: IFilter, filter2: IFilter): boolean {
-    const filterType1 = getFilterType(filter1.columnType, filter1.validator);
-    const filterType2 = getFilterType(filter2.columnType, filter2.validator);
-    if (filterType1 !== filterType2) return false;
-
-    switch (filterType2) {
-      case FILTER_TYPE.RANGE:
-        return this.isFilterRangeValueDuplicated(
-          filter1.values as IFilterValueRange[],
-          filter2.values as IFilterValueRange[],
-        );
-      case FILTER_TYPE.RELATIVE:
-        return this.isFilterRelativeValueDuplicated(
-          filter1.values as IFilterValueRelativeDate[],
-          filter2.values as IFilterValueRelativeDate[],
-        );
-      case FILTER_TYPE.RANKING:
-        return this.isFilterRankingValueDuplicated(
-          filter1.values as IFilterValueRanking[],
-          filter2.values as IFilterValueRanking[],
-        );
-      default:
-        return this.isFilterRegularValueDuplicated(
-          filter1.values as IFilterValueRegular[],
-          filter2.values as IFilterValueRegular[],
-        );
-    }
-  }
-
-  /**
-   * Validates if the given regular value is duplicated with another value collection
-   * @param values1 the filter regular values collection
-   * @param values2 the filter regular values collection
-   * @returns true when the regular value is duplicated
-   */
-  private static isFilterRegularValueDuplicated(
-    values1: IFilterValueRegular[],
-    values2: IFilterValueRegular[],
-  ): boolean {
-    return values1.every((value1) =>
-      values2.some(
-        (value2) => value1.id === value2.id && value1.value === value2.value,
-      ),
-    );
-  }
-
-  /**
-   * Validates if the given range value is duplicated with another value collection
-   * @param values1 the filter range values collection
-   * @param values2 the filter range values colleciton
-   * @returns true when the range value is duplicated
-   */
-  private static isFilterRangeValueDuplicated(
-    values1: IFilterValueRange[],
-    values2: IFilterValueRange[],
-  ): boolean {
-    return values1.every((value1) =>
-      values2.some(
-        (value2) =>
-          value1.id === value2.id &&
-          value1.max === value2.max &&
-          value1.min === value2.min,
-      ),
-    );
-  }
-
-  /**
-   * Validates if the given relative value is duplicated with another value collection
-   * @param values1 the filter relative values collection
-   * @param values2 the filter relative values collection
-   * @returns true when the relative value is duplicated
-   */
-  private static isFilterRelativeValueDuplicated(
-    values1: IFilterValueRelativeDate[],
-    values2: IFilterValueRelativeDate[],
-  ): boolean {
-    return values1.every((value1) =>
-      values2.some(
-        (value2) =>
-          value1.id === value2.id &&
-          value1.cursor === value2.cursor &&
-          value1.unit === value2.unit,
-      ),
-    );
-  }
-
-  /**
-   * Validates if the given ranking value is duplicated with another value collection
-   * @param _values1 the filter ranking values collection
-   * @param _values2 the filter ranking values collection
-   * @returns true when the ranking value is duplicated
-   */
-  private static isFilterRankingValueDuplicated(
-    _values1: IFilterValueRanking[],
-    _values2: IFilterValueRanking[],
-  ): boolean {
-    return false;
-  }
-
-  /**
-   * Validates if the grouping is valid to set for the given params
-   * @param columnType the column type
-   * @param validator the filter validator
-   * @returns true when the grouping is valid
-   */
-  public static isGroupingValid(
-    columnType: IColumnTypeWithGrouping,
-    validator: IFilterValidator,
-  ): boolean {
-    return (
-      FILTER_GROUPING_COLUMNS.includes(columnType) &&
-      FILTER_GROUPING_VALIDATORS.includes(validator)
-    );
-  }
-}

package/src/classes/FilterValues.ts

@@ -1,89 +0,0 @@
-import {
-  IFilterInputValue,
-  IFilterInputValueRange,
-  IFilterInputValueRegular,
-  IFilterInputValueRelativeDate,
-  IFilterValueRange,
-  IFilterValueRegular,
-  IFilterValueRelativeDate,
-} from "../resources/filter-values.resources";
-import { FILTER_TYPE, IFilterType } from "../resources/filters.resources";
-
-/**
- * Class to manipulate filter values and input values
- */
-export class FilterValues {
-  /**
-   * Gets the Filter Values based on Regular Input values
-   * @param values the regular input values
-   * @returns the Filter Regular Values
-   */
-  public static getFilterRegularValues(
-    values: IFilterInputValueRegular[] = [],
-  ): IFilterValueRegular[] {
-    return values.map((value: IFilterInputValueRegular) => ({
-      displayed: true,
-      enabled: true,
-      value: `${value}`,
-    }));
-  }
-
-  /**
-   * Gets the Filter Values based on Range Input values
-   * @param values the range input values
-   * @returns the Filter Range Values
-   */
-  public static getFilterRangeValues(
-    values: IFilterInputValueRange[] = [],
-  ): IFilterValueRange[] {
-    return values.map((value: IFilterInputValueRange) => ({
-      displayed: true,
-      enabled: true,
-      max: value.max,
-      min: value.min,
-    }));
-  }
-
-  /**
-   * Gets the Filter Values based on Relative Input values
-   * @param values the relative range input value
-   * @returns the Filter Relative Value
-   */
-  public static getFilterRelativeValues(
-    values: IFilterInputValueRelativeDate[] = [],
-  ): IFilterValueRelativeDate[] {
-    return values.map((value: IFilterInputValueRelativeDate) => ({
-      displayed: true,
-      enabled: true,
-      ...value,
-    }));
-  }
-
-  /**
-   * Gets the Filter Values based on the flter type
-   * @param filterType the filter type
-   * @param values the input values
-   * @returns the Filter Values
-   */
-  static getFilterValues(
-    filterType: IFilterType,
-    values: IFilterInputValue[] = [],
-  ): IFilterValueRegular[] {
-    switch (filterType) {
-      case FILTER_TYPE.REGULAR:
-        return FilterValues.getFilterRegularValues(values as string[]);
-      case FILTER_TYPE.RANGE:
-        return FilterValues.getFilterRangeValues(
-          values as IFilterInputValueRange[],
-        );
-      case FILTER_TYPE.RELATIVE:
-        return FilterValues.getFilterRelativeValues(
-          values as IFilterInputValueRelativeDate[],
-        );
-      case FILTER_TYPE.NULL:
-        return [];
-      default:
-        return [];
-    }
-  }
-}

package/src/classes/index.ts

@@ -1,7 +0,0 @@
-export * from "./FilterAdapter";
-export * from "./FilterBuilder";
-export * from "./FilterManager";
-export * from "./FilterResources";
-export * from "./FilterSearcher";
-export * from "./FilterValues";
-export * from "./FilterValidation";