Class Filterlist<Item, Additional, Error>

constructor

• new Filterlist<Item, Additional, Error>(params): Filterlist<Item, Additional, Error>

• Type Parameters

  • Item
  • Additional
  • Error

  Parameters

  • params: Readonly<{
        additional?: Additional;
        alwaysResetFilters?: Readonly<Record<string, unknown>>;
        appliedFilters?: Readonly<Record<string, unknown>>;
        autoload?: boolean;
        createDataStore?: ((initalValue: Readonly<{
            appliedFilters: Record<string, unknown>;
            page: number;
            pageSize?: null | number;
            sort: Readonly<{
                asc: boolean;
                param?: null | string;
            }>;
        }>) => DataStore);
        debounceTimeout?: number;
        isDefaultSortAsc?: boolean;
        items?: readonly Item[];
        loadItems: ItemsLoader<Item, Additional, Error>;
        page?: null | number;
        pageSize?: null | number;
        refreshTimeout?: number;
        resetFiltersTo?: Readonly<Record<string, unknown>>;
        saveFiltersOnResetAll?: readonly string[];
        saveItemsWhileLoad?: boolean;
        shouldRefresh?: (() => boolean);
        sort?: Readonly<{
            asc: boolean;
            param?: null | string;
        }>;
        total?: null | number;
    }>

  Returns Filterlist<Item, Additional, Error>

dataStore

dataStoreUnsubscribe

emitter

itemsLoader

listState

options

OptionalrefreshTimeout

refreshTimeoutId

requestId

OptionalshouldRefresh

applyFilter

• applyFilter(filterName): void

• apply intermediate filter value and request

  Parameters

  • filterName: string

  Returns void

applyFilters

• applyFilters(filtersNames): void

• apply multiple intermediate filter values and request

  Parameters

  • filtersNames: readonly string[]

  Returns void

deleteItem

• deleteItem(itemIndex, additional?): void

• delete item by specified index

  Parameters

  • itemIndex: number

    index of deleted item
  • Optionaladditional: Additional

    if defined, set additional param of list state

  Returns void

destroy

• destroy(): void

• Returns void

emitEvent

• emitEvent(eventType): void

• Parameters

  • eventType: EventType

  Returns void

getListState

• getListState(): Readonly<{
      additional: Additional;
      error: null | Error;
      filters: Record<string, unknown>;
      isFirstLoad: boolean;
      items: readonly Item[];
      loadedPages: number;
      loading: boolean;
      shouldClean: boolean;
      total?: null | number;
  }>

• Returns Readonly<{
      additional: Additional;
      error: null | Error;
      filters: Record<string, unknown>;
      isFirstLoad: boolean;
      items: readonly Item[];
      loadedPages: number;
      loading: boolean;
      shouldClean: boolean;
      total?: null | number;
  }>

getListStateBeforeChange

• getListStateBeforeChange(): Readonly<{
      additional: Additional;
      error: null | Error;
      filters: Record<string, unknown>;
      isFirstLoad: boolean;
      items: readonly Item[];
      loadedPages: number;
      loading: boolean;
      shouldClean: boolean;
      total?: null | number;
  }>

• Returns Readonly<{
      additional: Additional;
      error: null | Error;
      filters: Record<string, unknown>;
      isFirstLoad: boolean;
      items: readonly Item[];
      loadedPages: number;
      loading: boolean;
      shouldClean: boolean;
      total?: null | number;
  }>

getListStateBeforeReload

• getListStateBeforeReload(): Readonly<{
      additional: Additional;
      error: null | Error;
      filters: Record<string, unknown>;
      isFirstLoad: boolean;
      items: readonly Item[];
      loadedPages: number;
      loading: boolean;
      shouldClean: boolean;
      total?: null | number;
  }>

• Returns Readonly<{
      additional: Additional;
      error: null | Error;
      filters: Record<string, unknown>;
      isFirstLoad: boolean;
      items: readonly Item[];
      loadedPages: number;
      loading: boolean;
      shouldClean: boolean;
      total?: null | number;
  }>

getNextAsc

• getNextAsc(param, asc?): boolean

• Parameters

  • param: string
  • Optionalasc: boolean

  Returns boolean

getRequestParams

• getRequestParams(): Readonly<{
      appliedFilters: Record<string, unknown>;
      page: number;
      pageSize?: null | number;
      sort: Readonly<{
          asc: boolean;
          param?: null | string;
      }>;
  }>

• Returns Readonly<{
      appliedFilters: Record<string, unknown>;
      page: number;
      pageSize?: null | number;
      sort: Readonly<{
          asc: boolean;
          param?: null | string;
      }>;
  }>

getRequestParamsBeforeChange

• getRequestParamsBeforeChange(): Readonly<{
      appliedFilters: Record<string, unknown>;
      page: number;
      pageSize?: null | number;
      sort: Readonly<{
          asc: boolean;
          param?: null | string;
      }>;
  }>

• Returns Readonly<{
      appliedFilters: Record<string, unknown>;
      page: number;
      pageSize?: null | number;
      sort: Readonly<{
          asc: boolean;
          param?: null | string;
      }>;
  }>

insertItem

• insertItem(itemIndex, item, additional?): void

• insert item by specified index

  Parameters

  • itemIndex: number

    index of updated item
  • item: Item

    updated item
  • Optionaladditional: Additional

    if defined, set additional param of list state

  Returns void

loadItemsOnInit

• loadItemsOnInit(): Promise<void>

• Returns Promise<void>

loadMore

• loadMore(): Promise<void>

• load next pack of items next to the last item, can be used for infinite scroll realization

  Returns Promise<void>

onChangeDataStore

• onChangeDataStore(nextValue, prevValue): void

• Parameters

  • nextValue: Readonly<{
        appliedFilters: Record<string, unknown>;
        page: number;
        pageSize?: null | number;
        sort: Readonly<{
            asc: boolean;
            param?: null | string;
        }>;
    }>
  • prevValue: Readonly<{
        appliedFilters: Record<string, unknown>;
        page: number;
        pageSize?: null | number;
        sort: Readonly<{
            asc: boolean;
            param?: null | string;
        }>;
    }>

  Returns void

onError

• onError(error): void

• Parameters

  • error: LoadListError<Error, Additional>

  Returns void

onInit

• onInit(): void

• Returns void

onSuccess

• onSuccess(response): void

• Parameters

  • response: Readonly<{
        additional?: Additional;
        items: readonly Item[];
        total?: null | number;
    }>

  Returns void

reload

• reload(): Promise<void>

• reload the list in the current state

  Returns Promise<void>

reloadByTimeout

• reloadByTimeout(): void

• Returns void

requestItems

• requestItems(): Promise<void>

• Returns Promise<void>

resetAllFilters

• resetAllFilters(): void

• reset all of the filters to the corresponding value in resetFiltersTo (or undefined) and request

  Returns void

resetFilter

• resetFilter(filterName): void

• reset filter to the corresponding value in resetFiltersTo (or undefined) and request

  Parameters

  • filterName: string

  Returns void

resetFilters

• resetFilters(filtersNames): void

• reset multiple filters to the corresponding value in resetFiltersTo (or undefined) and request

  Parameters

  • filtersNames: readonly string[]

  Returns void

resetSorting

• resetSorting(): void

• resets sorting

  sort param will be setted with null, asc will be setted with isDefaultSortAsc param

  Returns void

setAndApplyEmptyFilters

• setAndApplyEmptyFilters(values): void

• set multiple filter values that currently undefined and request

  Parameters

  • values: Record<string, unknown>

  Returns void

setAndApplyFilter

• setAndApplyFilter(filterName, value): void

• set filter value and request

  Parameters

  • filterName: string
  • value: unknown

  Returns void

setAndApplyFilters

• setAndApplyFilters(values): void

• set multiple filter values and request

  Parameters

  • values: Record<string, unknown>

  Returns void

setFiltersValues

• setFiltersValues(values): void

• set multiple intermediate filter values witout request

  Parameters

  • values: Record<string, unknown>

  Returns void

setFilterValue

• setFilterValue(filterName, value): void

• set intermediate filter value of the filter without request

  Parameters

  • filterName: string
  • value: unknown

  Returns void

setListState

• setListState(nextListState): void

• Parameters

  • nextListState: Readonly<{
        additional: Additional;
        error: null | Error;
        filters: Record<string, unknown>;
        isFirstLoad: boolean;
        items: readonly Item[];
        loadedPages: number;
        loading: boolean;
        shouldClean: boolean;
        total?: null | number;
    }>

  Returns void

setPage

• setPage(page): void

• load specific page

  Parameters

  • page: number

  Returns void

setPageSize

• setPageSize(pageSize): void

• set number of items on page and request

  Parameters

  • pageSize: undefined | null | number

  Returns void

setRefreshTimeout

• setRefreshTimeout(nextValue): void

• Parameters

  • nextValue: undefined | null | number

  Returns void

setRequestParams

• setRequestParams(nextRequestParams): void

• Parameters

  • nextRequestParams: Readonly<{
        appliedFilters: Record<string, unknown>;
        page: number;
        pageSize?: null | number;
        sort: Readonly<{
            asc: boolean;
            param?: null | string;
        }>;
    }>

  Returns void

setSorting

• setSorting(param, asc?): void

• sets sorting column

  if asc defined and Boolean, sets it

  otherwise, if this column differs from previous sorting column, asc will be setted with isDefaultSortAsc param from decorator

  otherwise, it will be reverse asc param from previous state

  Parameters

  • param: string
  • Optionalasc: boolean

  Returns void

setTotal

• setTotal(total): void

• Parameters

  • total: undefined | null | number

  Returns void

updateItem

• updateItem(itemIndex, item, additional?): void

• update item by specified index

  Parameters

  • itemIndex: number

    index of updated item
  • item: Item

    updated item
  • Optionaladditional: Additional

    if defined, set additional param of list state

  Returns void

updateStateAndRequest

• updateStateAndRequest(updateStateParams): void

• set filters, applied filters, sorting, page and pageSize and request then

  Parameters

  • updateStateParams: Readonly<{
        appliedFilters?: Record<string, unknown>;
        filters?: Record<string, unknown>;
        page?: null | number;
        pageSize?: null | number;
        sort?: Readonly<{
            asc: boolean;
            param?: null | string;
        }>;
    }>

  Returns void