@qrvey/filters 0.0.45 → 0.1.0

package/src/classes/FilterBuilder.ts

@@ -1,822 +0,0 @@
-import { isEmpty, isNaNV2, objectCopy } from "@qrvey/utils";
-
-import { FilterSearcher } from "./FilterSearcher";
-import { FilterValidation } from "./FilterValidation";
-import { FilterValues } from "./FilterValues";
-
-import {
-  getEditFiltersSettings,
-  getFilterAddSettings,
-  getFilterCreateSettings,
-  getReplaceByParamsSettings,
-} from "../helpers/filter-settings.helpers";
-import { getFilterId } from "../helpers/getFilterId";
-import { getFilterType } from "../helpers/getFilterType";
-import {
-  IFilterBuilderAdd,
-  IFilterBuilderAddValue,
-  IFilterBuilderDelete,
-  IFilterBuilderDeleteValue,
-  IFilterBuilderEdit,
-  IFilterBuilderEditValue,
-  IFilterBuilderMerge,
-  IFilterBuilderMergeValue,
-  IFilterBuilderMultipleReturn,
-  IFilterBuilderSet,
-  IFilterBuilderSingleReturn,
-} from "../models/filter-builder.models";
-import {
-  IFilterAddSettings,
-  IFilterBuilderEditSettings,
-  IFilterCreateSettings,
-  IFilterFindLastIndexReturn,
-  IFilterMergeSettings,
-  IFilterParamSettings,
-  IFilterReplaceParamSettings,
-} from "../resources/filter-functions.resources";
-import { FILTER_OPERATOR } from "../resources/filter-operators.resources";
-import {
-  IFilterValue,
-  IFilterValueRange,
-  IFilterValueRegular,
-  IFilterValueRelativeDate,
-} from "../resources/filter-values.resources";
-import {
-  DEFAULT_FILTER,
-  FILTER_TYPE,
-  IFilter,
-} from "../resources/filters.resources";
-import { getFilterGrouping } from "../helpers/filter-builder.helpers";
-
-/**
- * Class to build new filters and manipulate ones.
- */
-export class FilterBuilder
-  implements
-    IFilterBuilderAdd,
-    IFilterBuilderAddValue,
-    IFilterBuilderDelete,
-    IFilterBuilderDeleteValue,
-    IFilterBuilderEdit,
-    IFilterBuilderEditValue,
-    IFilterBuilderMerge,
-    IFilterBuilderMergeValue,
-    IFilterBuilderSet
-{
-  /**
-   * Instance to search filters
-   */
-  private searchEngine: FilterSearcher;
-
-  /**
-   * Constructor
-   * @param filters the collection of filters
-   */
-  constructor(protected filters: IFilter[] = []) {
-    this.searchEngine = new FilterSearcher(filters);
-    this.filters = objectCopy(Array.isArray(filters) ? filters : []);
-  }
-
-  /**
-   * **************************************************************************************************
-   ****************************************** Adding **************************************************
-   ****************************************************************************************************
-   */
-
-  /**
-   * Adds various filter into the collection.
-   * Inserts them next to the last similar filter
-   * @param newFilters the filter to add
-   * @param inIndexes collection of indexes to add the new filters
-   * @param settings the settings object to setup this function
-   * @returns the new collection of filters
-   */
-  public addMultiple(
-    newFilters: IFilter[],
-    inIndexes?: number[],
-    settings?: IFilterAddSettings,
-  ): IFilterBuilderMultipleReturn {
-    if (isEmpty(newFilters)) return { resulting: this.filters };
-
-    const filters: IFilter[] = objectCopy(this.filters);
-    const affected: IFilter[] = [];
-    try {
-      newFilters.forEach((newFilter: IFilter, index: number) => {
-        const affectedFilter = this.addSingle(
-          newFilter,
-          inIndexes?.[index],
-          settings,
-        );
-        affected.push(affectedFilter.affected!);
-      });
-    } catch (_error) {
-      this.filters = filters;
-      return { resulting: filters };
-    }
-
-    this.sync();
-    return {
-      resulting: this.filters,
-      affected,
-      original: filters,
-    };
-  }
-
-  /**
-   * Adds one filter into the collection.
-   * - Inserts it next to the last similar filter
-   * - If the new one is match with the last similar filter, the operator will change to OR
-   * - If the id is not provided, a new one is created.
-   * - If the inIndex nunber is provided, this will be the index where the filter is inserted
-   * @param filter the filter to add
-   * @param inIndex the index to add the new filter
-   * @param settings settings object to setup this function
-   * @returns the new collection of filters
-   */
-  public addSingle(
-    filter: IFilter,
-    inIndex?: number,
-    settings?: IFilterAddSettings,
-  ): IFilterBuilderSingleReturn {
-    if (isEmpty(filter)) return { resulting: this.filters };
-    if (FilterValidation.isDuplicated(this.filters, filter))
-      return { resulting: this.filters };
-
-    const original = { ...filter };
-    const newFilter: IFilter = { ...filter };
-    const newSettings = getFilterAddSettings(settings);
-
-    if (isEmpty(filter.id) || newSettings.automaticId)
-      newFilter.id = getFilterId(newFilter);
-
-    let indexResult: IFilterFindLastIndexReturn;
-    let nextIndex: number;
-    if (isNaNV2(inIndex)) {
-      indexResult = this.searchEngine.findLastIndexByFilter(newFilter, inIndex);
-      nextIndex = indexResult.index + 1;
-    } else {
-      indexResult = {
-        index: inIndex!,
-        nextToColumnFilter: false,
-        nextToDatasetFilter: false,
-        nextToScopeFilter: false,
-      };
-      nextIndex = indexResult.index;
-    }
-
-    if (indexResult.index > -1) {
-      this.filters.splice(nextIndex, 0, newFilter);
-      if (
-        newSettings.automaticOperator &&
-        indexResult.nextToColumnFilter &&
-        indexResult.index > -1
-      )
-        this.filters[indexResult.index].operator = FILTER_OPERATOR.OR;
-    } else {
-      this.filters.push(newFilter);
-    }
-
-    this.sync();
-    return {
-      resulting: this.filters,
-      affected: newFilter,
-      original,
-    };
-  }
-
-  /**
-   * Adds one value from filter
-   * @param id the ID to search the filter to add value
-   * @param value the value to add
-   * @returns the new filter collection
-   */
-  public addValue(id: string, value: IFilterValue): IFilterBuilderSingleReturn {
-    const index = this.searchEngine.findIndexByParams({ id });
-    if (index < 0) return { resulting: this.filters };
-
-    const original: IFilter = objectCopy(this.filters[index]);
-
-    if (this.filters[index].values == null) this.filters[index].values = [];
-    this.filters[index].values?.push(value);
-
-    this.sync();
-    return {
-      resulting: this.filters,
-      affected: this.filters[index],
-      original,
-    };
-  }
-
-  /**
-   * Adds various values on filter
-   * @param id the ID to search the filter to add value
-   * @param values the collection of value to add
-   * @returns the new filter collection
-   */
-  public addValues(
-    id: string,
-    values: IFilterValue[],
-  ): IFilterBuilderSingleReturn {
-    const index = this.searchEngine.findIndexByParams({ id });
-    if (isEmpty(values) || index < 0) return { resulting: this.filters };
-
-    const filters: IFilter[] = objectCopy(this.filters);
-    const original: IFilter = objectCopy(this.filters[index]);
-
-    let affected: IFilter;
-    try {
-      values.forEach((value: IFilterValue) => {
-        affected = this.addValue(id, value).affected!;
-      });
-    } catch (_error) {
-      this.filters = filters;
-      return { resulting: filters };
-    }
-
-    this.sync();
-    return {
-      resulting: this.filters,
-      affected: affected!,
-      original,
-    };
-  }
-
-  /**
-   * **************************************************************************************************
-   **************************************** Deleting **************************************************
-   ****************************************************************************************************
-   */
-
-  /**
-   * Removes various filters by params
-   * @param params params to search the filters to delete
-   * @param settings settings for this function
-   * @returns the new collection of filters
-   */
-  public deleteByParams(
-    params: Partial<IFilter>,
-    settings?: IFilterParamSettings,
-  ): IFilterBuilderMultipleReturn {
-    const original: IFilter[] = objectCopy(this.filters);
-    const affected: IFilter[] = this.searchEngine.filterByParams(
-      params,
-      settings,
-    );
-    this.filters = this.searchEngine.excludeByParams(params, settings);
-
-    this.sync();
-    return {
-      resulting: this.filters,
-      affected,
-      original,
-    };
-  }
-
-  /**
-   * Removes various filters from the collection
-   * @param ids a collection of ID to search filters to remove
-   * @returns the new filter collection
-   */
-  public deleteMultiple(ids: string[]): IFilterBuilderMultipleReturn {
-    if (!Array.isArray(ids)) return { resulting: this.filters };
-
-    const filters: IFilter[] = objectCopy(this.filters);
-    const affected: IFilter[] = [];
-    try {
-      ids.forEach((id: string) => {
-        const deleted: IFilterBuilderSingleReturn = this.deleteSingle(id);
-        affected.push(deleted.affected!);
-      });
-    } catch (_error) {
-      this.filters = filters;
-      return { resulting: filters };
-    }
-
-    this.sync();
-    return {
-      resulting: this.filters,
-      affected,
-      original: filters,
-    };
-  }
-
-  /**
-   * Removes one filter from the collection
-   * @param id the ID to search the filter to remove
-   * @returns the new filter collection
-   */
-  public deleteSingle(id: string): IFilterBuilderSingleReturn {
-    const index = this.searchEngine.findIndexByParams({ id });
-    const original: IFilter = { ...this.filters[index] };
-
-    let deletedFilters: IFilter[] = [];
-    if (index > -1) {
-      deletedFilters = this.filters.splice(index, 1);
-    }
-
-    this.sync();
-    return {
-      resulting: this.filters,
-      affected: deletedFilters[0],
-      original,
-    };
-  }
-
-  /**
-   * Removes one value from filter
-   * @param id the ID to search the filter to remove value
-   * @param index the index to search the value to remove
-   * @returns the new filter collection
-   */
-  public deleteValue(id: string, index: number): IFilterBuilderSingleReturn {
-    if (!Number.isInteger(index)) return { resulting: this.filters };
-
-    const filterIndex = this.searchEngine.findIndexByParams({ id });
-
-    const original: IFilter = objectCopy(this.filters[filterIndex]);
-    let affectedValues: IFilterValue[] | undefined;
-    let affectedFilter: IFilter = this.filters[filterIndex];
-
-    if (filterIndex > -1) {
-      affectedValues = this.filters[filterIndex].values?.splice(index, 1);
-      affectedFilter = { ...affectedFilter, values: affectedValues };
-    }
-
-    this.sync();
-    return {
-      resulting: this.filters,
-      affected: affectedFilter,
-      original,
-    };
-  }
-
-  /**
-   * Removes various values from filter
-   * @param id the ID to search the filter to remove value
-   * @param indexes the index collection to search the value to remove
-   * @returns the new filter collection
-   */
-  public deleteValues(
-    id: string,
-    indexes: number[],
-  ): IFilterBuilderSingleReturn {
-    if (!Array.isArray(indexes)) return { resulting: this.filters };
-
-    let sortedIndex = indexes.sort();
-    sortedIndex = indexes.reverse();
-
-    const filters: IFilter[] = objectCopy(this.filters);
-    const original: IFilter | undefined = this.searchEngine.findByParams({
-      id,
-    });
-
-    try {
-      sortedIndex.forEach((index: number) => {
-        this.deleteValue(id, index);
-      });
-    } catch (_error) {
-      this.filters = filters;
-      return { resulting: filters };
-    }
-
-    this.sync();
-    const affected = this.searchEngine.findByParams({ id });
-    return {
-      resulting: this.filters,
-      affected,
-      original,
-    };
-  }
-
-  /**
-   * **************************************************************************************************
-   ****************************************** Editing *************************************************
-   ****************************************************************************************************
-   */
-
-  /**
-   * Edits various filters from the collection
-   * @param ids the collection of IDs to search filters to edit
-   * @param filters a collection of object with properties to edit
-   * @param settings settings object for the function
-   * @returns the new filter collection
-   */
-  public editMultiple(
-    ids: string[],
-    filters: Partial<IFilter>[],
-    settings?: IFilterBuilderEditSettings,
-  ): IFilterBuilderMultipleReturn {
-    if (
-      !Array.isArray(ids) ||
-      !Array.isArray(filters) ||
-      ids.length !== filters.length
-    )
-      return { resulting: this.filters };
-
-    const originalFilters = objectCopy(this.filters);
-    const editedFilters: IFilter[] = [];
-    try {
-      ids.forEach((id: string, index: number) => {
-        const editedFilter: IFilterBuilderSingleReturn = this.editSingle(
-          id,
-          filters[index],
-          settings,
-        );
-        editedFilters.push(editedFilter.affected!);
-      });
-    } catch (_error) {
-      this.filters = originalFilters;
-      return { resulting: originalFilters };
-    }
-
-    this.sync();
-    return {
-      resulting: this.filters,
-      affected: editedFilters,
-      original: originalFilters,
-    };
-  }
-
-  /**
-   * Edits one filter from the collection
-   * @param id the ID to search the filter to edit
-   * @param filter an object with properties to edit
-   * @param settings settings object for the function
-   * @returns the new filter collection
-   */
-  public editSingle(
-    id: string,
-    filter: Partial<IFilter>,
-    settings?: IFilterBuilderEditSettings,
-  ): IFilterBuilderSingleReturn {
-    if (isEmpty(filter)) return { resulting: this.filters };
-
-    const { automaticId } = getEditFiltersSettings(settings);
-
-    const index = this.searchEngine.findIndexByParams({ id });
-    const original = objectCopy(this.filters[index]);
-    let editedFilter: IFilter;
-    if (index > -1) {
-      editedFilter = { ...this.filters[index], ...filter };
-      if (FilterValidation.isDuplicated(this.filters, editedFilter))
-        return { resulting: this.filters };
-
-      if (automaticId) editedFilter.id = getFilterId(editedFilter);
-      this.filters[index] = editedFilter;
-    }
-
-    this.sync();
-    return {
-      resulting: this.filters,
-      affected: editedFilter!,
-      original,
-    };
-  }
-
-  /**
-   * Edits one value from filter
-   * @param id the ID to search the filter to edit value
-   * @param value the value to edit
-   * @param index the value index to edit
-   * @returns the new filter collection
-   */
-  editValue(
-    id: string,
-    value: IFilterValue,
-    index: number,
-  ): IFilterBuilderSingleReturn {
-    const filterIndex = this.searchEngine.findIndexByParams({ id });
-    if (
-      isEmpty(value) ||
-      filterIndex < 0 ||
-      this.filters[filterIndex].values == null ||
-      this.filters[filterIndex].values?.[index] == null
-    )
-      return { resulting: this.filters };
-
-    const original = objectCopy(this.filters[filterIndex]);
-    const oldValue = this.filters[filterIndex].values![index];
-    this.filters[filterIndex].values![index] = { ...oldValue, ...value };
-
-    this.sync();
-    return {
-      resulting: this.filters,
-      affected: this.filters[filterIndex],
-      original,
-    };
-  }
-
-  /**
-   * Edits various values from filter
-   * @param id the ID to search the filter to edit value
-   * @param values the value collection to edit
-   * @param indexes the index collection to edit
-   * @returns the new filter collection
-   */
-  public editValues(
-    id: string,
-    values: IFilterValue[],
-    indexes: number[],
-  ): IFilterBuilderSingleReturn {
-    const filterIndex = this.searchEngine.findIndexByParams({ id });
-    if (isEmpty(values) || filterIndex < 0 || !Array.isArray(indexes))
-      return { resulting: this.filters };
-
-    const original: IFilter[] = objectCopy(this.filters);
-    let finalAffectedFilter: IFilter;
-    try {
-      values.forEach((value: IFilterValue, index: number) => {
-        const affectedFilter: IFilterBuilderSingleReturn = this.editValue(
-          id,
-          value,
-          indexes[index],
-        );
-        finalAffectedFilter = affectedFilter.affected!;
-      });
-    } catch (_error) {
-      this.filters = original;
-      return { resulting: original };
-    }
-
-    this.sync();
-    return {
-      resulting: this.filters,
-      affected: finalAffectedFilter!,
-      original: original[filterIndex],
-    };
-  }
-
-  /**
-   * **************************************************************************************************
-   ****************************************** Merging *************************************************
-   ****************************************************************************************************
-   */
-
-  /**
-   * Merge the filter into the collection by some filter parameters
-   * @param filter the filter to merge
-   * @param settings the settings object to setup this function
-   * @returns the new filter collection
-   */
-  public mergeSingle(
-    filter: IFilter,
-    settings?: IFilterMergeSettings,
-  ): IFilterBuilderSingleReturn {
-    if (isEmpty(filter)) return { resulting: this.filters };
-
-    const filterIndex = this.searchEngine.findIndexByParams({
-      columnId: filter.columnId,
-      datasetId: filter.datasetId,
-      grouping: filter.grouping,
-      scope: filter.scope,
-      scopeId: filter.scopeId,
-      validator: filter.validator,
-    });
-
-    let original = filter;
-    let affected: IFilter | undefined = filter;
-    if (filterIndex > -1) {
-      original = objectCopy(this.filters[filterIndex]);
-      const { affected: affectedMergeFilter } = this.mergeValues(
-        this.filters[filterIndex].id,
-        filter.values,
-      );
-      affected = affectedMergeFilter;
-    } else {
-      const { affected: affectedAddSingle } = this.addSingle(
-        filter,
-        undefined,
-        settings,
-      );
-      affected = affectedAddSingle;
-    }
-
-    return {
-      resulting: this.filters,
-      affected,
-      original,
-    };
-  }
-
-  /**
-   * Merge the filters into the collection by some filter parameters
-   * @param filters the filter collection to merge
-   * @param settings the settings object to setup this function
-   * @returns the new filter collection
-   */
-  public mergeMultiple(
-    filters: IFilter[],
-    settings?: IFilterMergeSettings,
-  ): IFilterBuilderMultipleReturn {
-    if (!Array.isArray(filters) || isEmpty(filters))
-      return { resulting: this.filters };
-
-    const originalFilters = objectCopy(this.filters);
-    const mergedFilters: IFilter[] = [];
-    try {
-      filters.forEach((filter: IFilter) => {
-        const mergedFilter: IFilterBuilderSingleReturn = this.mergeSingle(
-          filter,
-          settings,
-        );
-        mergedFilters.push(mergedFilter.affected!);
-      });
-    } catch (_error) {
-      this.filters = originalFilters;
-      return { resulting: originalFilters };
-    }
-
-    this.sync();
-    return {
-      resulting: this.filters,
-      affected: mergedFilters,
-      original: originalFilters,
-    };
-  }
-
-  /**
-   * Merge values from filter
-   * @param id the ID to search the filter to merge values
-   * @param values the value collection to merge
-   * @returns the new filter collection
-   */
-  public mergeValues(
-    id: string,
-    values: IFilterValue[] | undefined,
-  ): IFilterBuilderSingleReturn {
-    const filterIndex = this.searchEngine.findIndexByParams({ id });
-    if (isEmpty(values) || filterIndex < 0) return { resulting: this.filters };
-
-    const original = objectCopy(this.filters[filterIndex]);
-    const filterType = getFilterType(original.columnType, original.validator);
-
-    if (isEmpty(this.filters[filterIndex].values))
-      this.filters[filterIndex].values = [];
-
-    values!.forEach((value) => {
-      switch (filterType) {
-        case FILTER_TYPE.RANGE: {
-          const valueIndex = (
-            this.filters[filterIndex].values as IFilterValueRange[]
-          ).findIndex(
-            (v) =>
-              v.max === (value as IFilterValueRange).max &&
-              v.min === (value as IFilterValueRange).min,
-          );
-          if (valueIndex < 0) {
-            this.filters[filterIndex].values?.push(value);
-          }
-          break;
-        }
-        case FILTER_TYPE.REGULAR: {
-          const valueIndex = (
-            this.filters[filterIndex].values as IFilterValueRegular[]
-          ).findIndex((v) => v.value === (value as IFilterValueRegular).value);
-          if (valueIndex < 0) {
-            this.filters[filterIndex].values?.push(value);
-          }
-          break;
-        }
-        case FILTER_TYPE.RELATIVE:
-          (this.filters[filterIndex].values as IFilterValueRelativeDate[])[0] =
-            value as IFilterValueRelativeDate;
-          break;
-      }
-    });
-
-    this.sync();
-    return {
-      resulting: this.filters,
-      affected: this.filters[filterIndex],
-      original,
-    };
-  }
-
-  /**
-   * **************************************************************************************************
-   ****************************************** Others **************************************************
-   ****************************************************************************************************
-   */
-
-  /**
-   * Builds an filter structure based on given params
-   * @param filter the partial filter params
-   * @param settings the settings object to setup this function
-   * @returns the complete filter structure
-   */
-  static createFilter(
-    filter: Partial<IFilter>,
-    settings?: IFilterCreateSettings,
-  ): IFilter {
-    const newSettings: IFilterCreateSettings =
-      getFilterCreateSettings(settings);
-
-    const newFilter: IFilter = {
-      ...DEFAULT_FILTER,
-      aggregateType: filter.aggregateType ?? DEFAULT_FILTER.aggregateType,
-      collapsed: filter.collapsed ?? DEFAULT_FILTER.collapsed,
-      columnId: filter.columnId ?? DEFAULT_FILTER.columnId,
-      columnType: filter.columnType ?? DEFAULT_FILTER.columnType,
-      customLabel: filter.customLabel ?? DEFAULT_FILTER.customLabel,
-      datasetId: filter.datasetId ?? DEFAULT_FILTER.datasetId,
-      deletable: filter.deletable ?? DEFAULT_FILTER.deletable,
-      displayed: filter.displayed ?? DEFAULT_FILTER.displayed,
-      editable: filter.editable ?? DEFAULT_FILTER.editable,
-      enableable: filter.enableable ?? DEFAULT_FILTER.enableable,
-      enabled: filter.enabled ?? DEFAULT_FILTER.enabled,
-      formulaType: filter.formulaType ?? DEFAULT_FILTER.formulaType,
-      id: filter.id || "",
-      operator: filter.operator || DEFAULT_FILTER.operator,
-      scope: filter.scope || DEFAULT_FILTER.scope,
-      scopeId: filter.scopeId || DEFAULT_FILTER.scopeId,
-      validator: filter.validator || DEFAULT_FILTER.validator,
-      grouping: getFilterGrouping(filter, newSettings),
-      selectAll: filter.selectAll ?? DEFAULT_FILTER.selectAll,
-      values: filter.values || DEFAULT_FILTER.values,
-    };
-    if (isEmpty(filter.id) || newSettings.automaticId)
-      newFilter.id = getFilterId(newFilter);
-
-    if (!isEmpty(newSettings.rawValues)) {
-      const filterType = getFilterType(
-        newFilter.columnType,
-        newFilter.validator,
-      );
-      newFilter.values = FilterValues.getFilterValues(
-        filterType,
-        newSettings.rawValues,
-      );
-    }
-    return newFilter;
-  }
-
-  /**
-   * Sets the given filters by param
-   * - Remove the filters by the sucesfull conditions and replace the given ones
-   * @param filters the filters to set
-   * @param params params to search the filters
-   * @param settings settings for this function
-   * @returns the new collection of filters
-   */
-  public replaceByParams(
-    filters: IFilter[],
-    params: Partial<IFilter>,
-    settings?: IFilterReplaceParamSettings,
-  ): IFilterBuilderMultipleReturn {
-    const original: IFilter[] = objectCopy(this.filters);
-
-    const newSettings = getReplaceByParamsSettings(settings);
-    let filterIndexes: number[] | undefined = undefined;
-    if (newSettings.addingInSameIndex) {
-      filterIndexes = this.searchEngine.filterIndexesByParams(params, settings);
-      if (isEmpty(filterIndexes)) filterIndexes = undefined;
-    }
-
-    this.filters = this.searchEngine.excludeByParams(params, newSettings);
-    this.sync();
-    const resulting = this.addMultiple(filters, filterIndexes, newSettings);
-
-    this.sync();
-    return {
-      resulting: this.filters,
-      affected: resulting.affected,
-      original,
-    };
-  }
-
-  /**
-   * Method to sync the Filter instances
-   */
-  private sync(): void {
-    this.searchEngine.setFilters(this.filters);
-  }
-
-  /**
-   * **************************************************************************************************
-   ****************************************** 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);
-    this.sync();
-  }
-}