@koalarx/ui 12.7.19 → 13.0.3

package/list/esm2020/lib/koala.list.module.mjs

@@ -0,0 +1,70 @@
+import { NgModule } from '@angular/core';
+import { ListComponent } from './list.component';
+import { MatTableModule } from '@angular/material/table';
+import { MatSortModule } from '@angular/material/sort';
+import { MatPaginatorIntl, MatPaginatorModule } from '@angular/material/paginator';
+import { CommonModule } from '@angular/common';
+import { KoalaFormModule } from '@koalarx/ui/form';
+import { MatMenuModule } from '@angular/material/menu';
+import { PaginationProvider } from './providers/pagination/pagination.provider';
+import { KoalaFolderPageModule } from '@koalarx/ui/folder-page';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { KoalaDynamicComponentModule } from '@koalarx/ui/dynamic-component';
+import { KoalaButtonModule } from "@koalarx/ui/button";
+import * as i0 from "@angular/core";
+export class KoalaListModule {
+}
+KoalaListModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: KoalaListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+KoalaListModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: KoalaListModule, declarations: [ListComponent], imports: [CommonModule,
+        KoalaFolderPageModule,
+        KoalaFormModule,
+        KoalaDynamicComponentModule,
+        KoalaButtonModule,
+        MatMenuModule,
+        MatTableModule,
+        MatSortModule,
+        MatTooltipModule,
+        MatPaginatorModule], exports: [ListComponent] });
+KoalaListModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: KoalaListModule, providers: [{
+            provide: MatPaginatorIntl,
+            useClass: PaginationProvider
+        }], imports: [[
+            CommonModule,
+            KoalaFolderPageModule,
+            KoalaFormModule,
+            KoalaDynamicComponentModule,
+            KoalaButtonModule,
+            MatMenuModule,
+            MatTableModule,
+            MatSortModule,
+            MatTooltipModule,
+            MatPaginatorModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: KoalaListModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ListComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        KoalaFolderPageModule,
+                        KoalaFormModule,
+                        KoalaDynamicComponentModule,
+                        KoalaButtonModule,
+                        MatMenuModule,
+                        MatTableModule,
+                        MatSortModule,
+                        MatTooltipModule,
+                        MatPaginatorModule
+                    ],
+                    exports: [
+                        ListComponent
+                    ],
+                    providers: [{
+                            provide: MatPaginatorIntl,
+                            useClass: PaginationProvider
+                        }]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/list/esm2020/lib/koala.list.service.mjs

@@ -0,0 +1,15 @@
+import { Injectable } from '@angular/core';
+import { ListBuilder } from "./list-builder/list.builder";
+import * as i0 from "@angular/core";
+export class KoalaListService {
+    build() {
+        return new ListBuilder();
+    }
+}
+KoalaListService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: KoalaListService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+KoalaListService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: KoalaListService, providedIn: "any" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: KoalaListService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "any" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia29hbGEubGlzdC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbGlzdC9zcmMvbGliL2tvYWxhLmxpc3Quc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQzs7QUFHMUQsTUFBTSxPQUFPLGdCQUFnQjtJQUVwQixLQUFLO1FBQ1YsT0FBTyxJQUFJLFdBQVcsRUFBWSxDQUFDO0lBQ3JDLENBQUM7OzZHQUpVLGdCQUFnQjtpSEFBaEIsZ0JBQWdCLGNBREosS0FBSzsyRkFDakIsZ0JBQWdCO2tCQUQ1QixVQUFVO21CQUFDLEVBQUMsVUFBVSxFQUFFLEtBQUssRUFBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IExpc3RCdWlsZGVyIH0gZnJvbSBcIi4vbGlzdC1idWlsZGVyL2xpc3QuYnVpbGRlclwiO1xuXG5ASW5qZWN0YWJsZSh7cHJvdmlkZWRJbjogXCJhbnlcIn0pXG5leHBvcnQgY2xhc3MgS29hbGFMaXN0U2VydmljZSB7XG5cbiAgcHVibGljIGJ1aWxkPERhdGFUeXBlPigpIHtcbiAgICByZXR1cm4gbmV3IExpc3RCdWlsZGVyPERhdGFUeXBlPigpO1xuICB9XG59XG4iXX0=

package/list/esm2020/lib/list-builder/list.builder.mjs

@@ -0,0 +1,97 @@
+import { KoalaDynamicComponent } from "@koalarx/ui/dynamic-component";
+import { BehaviorSubject, Observable } from "rxjs";
+import { first } from "rxjs/operators";
+export class ListBuilder {
+    constructor() {
+        this.config = {};
+    }
+    service(service, type = "all", resultIndexName, qtdResultIndexName) {
+        this.config.typeRequest = type;
+        this.config.responseIndexName = resultIndexName;
+        this.config.responseQtdResultIndexName = response => response[qtdResultIndexName ?? ''] ?? [];
+        this.config.columnSort = this.config?.filterParams?.getValue()?.sort;
+        this.config.sortDirection = this.config?.filterParams?.getValue()?.order ?? 'asc';
+        const response = service(this.config.filterParams ?? null);
+        if (response instanceof Promise) {
+            this.config.request = new Observable(observe => {
+                response.then(response => observe.next(response))
+                    .catch(error => observe.error(error));
+            }).pipe(first());
+        }
+        else {
+            this.config.request = new Observable(observe => {
+                service(this.config.filterParams ?? null).pipe(first()).subscribe(observe);
+            }).pipe(first());
+        }
+        return this;
+    }
+    filterConfig(config) {
+        this.config.filterFormConfig = config;
+        return this;
+    }
+    defaultFilter(config) {
+        this.config.filterParams = new BehaviorSubject(config);
+        return this;
+    }
+    pageSize(size) {
+        this.config.pageSize = size;
+        return this;
+    }
+    columns(columns) {
+        this.config.columnsToShowInList = columns;
+        return this;
+    }
+    itemColumn(item) {
+        (this.config.itemsList?.length > 0) ?
+            this.config.itemsList.push(item) :
+            this.config.itemsList = [item];
+        return this;
+    }
+    actionList(item) {
+        (this.config.itemsMenuListOptions?.length ?? 0 > 0) ?
+            this.config.itemsMenuListOptions?.push(item) :
+            this.config.itemsMenuListOptions = [item];
+        return this;
+    }
+    getDataSource(fn) {
+        this.config.getDataSource = fn;
+        return this;
+    }
+    getSelectionList(fn) {
+        this.config.getSelectionList = fn;
+        return this;
+    }
+    emptyListComponent(component, data) {
+        this.config.emptyListComponent = new KoalaDynamicComponent(component, data);
+        return this;
+    }
+    errorListComponent(component, data) {
+        this.config.errorListComponent = new KoalaDynamicComponent(component, data);
+        return this;
+    }
+    disableCheckboxItemList(fn) {
+        this.config.disabledCheckboxItemList = fn;
+        return this;
+    }
+    setSubList(config) {
+        this.config.subListConfig = config;
+        return this;
+    }
+    defineBtnCollapseSubListConfig(config) {
+        this.config.btnCollapseSubListConfig = config;
+        return this;
+    }
+    hidePaginator(hide = true) {
+        this.config.hidePaginator = hide;
+        return this;
+    }
+    setCustomClass(className) {
+        this.config.customClass = className;
+        return this;
+    }
+    getConfig() {
+        this.config.reload = new BehaviorSubject(false);
+        return this.config;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.builder.js","sourceRoot":"","sources":["../../../../../projects/list/src/lib/list-builder/list.builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { KoalaListConfigInterface } from \"../koala.list-config.interface\";\nimport { KoalaListItemInterface } from \"../koala-list-item.interface\";\nimport { Type } from \"@angular/core\";\nimport { KoalaDynamicComponent } from \"@koalarx/ui/dynamic-component\";\nimport { KoalaListFilterInterface } from \"../koala-list-filter.interface\";\nimport { BehaviorSubject, Observable } from \"rxjs\";\nimport { KoalaListFormFilterInterface } from \"../koala-list-form-filter.interface\";\nimport { KoalaListItemMenuOptionInterface } from \"../koala-list-item-menu-option.interface\";\nimport { SelectionModel } from \"@angular/cdk/collections\";\nimport { KoalaListPageSize } from \"../list.abstract\";\nimport { first } from \"rxjs/operators\";\nimport { KoalaListBtnCollapseSubListConfigInterface } from \"../koala-list-btn-collapse-sub-list-config.interface\";\n\nexport class ListBuilder<DataType> {\n  private config = {} as KoalaListConfigInterface;\n\n  public service(\n    service: (filter: BehaviorSubject<KoalaListFormFilterInterface>) => Observable<any> | Promise<any>,\n    type: 'all' | 'onDemand' = \"all\",\n    resultIndexName?: string,\n    qtdResultIndexName?: string\n  ) {\n    this.config.typeRequest = type;\n    this.config.responseIndexName = resultIndexName;\n    this.config.responseQtdResultIndexName = response => response[qtdResultIndexName ?? ''] ?? [];\n    this.config.columnSort = this.config?.filterParams?.getValue()?.sort;\n    this.config.sortDirection = this.config?.filterParams?.getValue()?.order ?? 'asc';\n\n    const response = service(this.config.filterParams ?? null);\n\n    if (response instanceof Promise) {\n      this.config.request = new Observable<any>(observe => {\n        response.then(response => observe.next(response))\n                .catch(error => observe.error(error));\n      }).pipe(first());\n    } else {\n      this.config.request = new Observable<any>(observe => {\n        (service(this.config.filterParams ?? null) as Observable<any>).pipe(first()).subscribe(observe);\n      }).pipe(first());\n    }\n\n    return this;\n  }\n\n  public filterConfig(config: KoalaListFilterInterface) {\n    this.config.filterFormConfig = config;\n    return this;\n  }\n\n  public defaultFilter(config: KoalaListFormFilterInterface) {\n    this.config.filterParams = new BehaviorSubject<KoalaListFormFilterInterface>(config);\n    return this;\n  }\n\n  public pageSize(size: KoalaListPageSize) {\n    this.config.pageSize = size;\n    return this;\n  }\n\n  public columns(columns: string[]) {\n    this.config.columnsToShowInList = columns;\n    return this;\n  }\n\n  public itemColumn(item: KoalaListItemInterface<DataType>) {\n    (this.config.itemsList?.length > 0) ?\n      this.config.itemsList.push(item) :\n      this.config.itemsList = [item];\n\n    return this;\n  }\n\n  public actionList(item: KoalaListItemMenuOptionInterface<DataType>) {\n    (this.config.itemsMenuListOptions?.length ?? 0 > 0) ?\n      this.config.itemsMenuListOptions?.push(item) :\n      this.config.itemsMenuListOptions = [item];\n\n    return this;\n  }\n\n  public getDataSource(fn: (dataSource: DataType[]) => void) {\n    this.config.getDataSource = fn;\n    return this;\n  }\n\n  public getSelectionList(fn: (selection: SelectionModel<DataType>) => void) {\n    this.config.getSelectionList = fn;\n    return this;\n  }\n\n  public emptyListComponent(component: Type<any>, data?: any) {\n    this.config.emptyListComponent = new KoalaDynamicComponent(component, data);\n    return this;\n  }\n\n  public errorListComponent(component: Type<any>, data?: any) {\n    this.config.errorListComponent = new KoalaDynamicComponent(component, data);\n    return this;\n  }\n\n  public disableCheckboxItemList(fn: (item: DataType) => boolean) {\n    this.config.disabledCheckboxItemList = fn;\n    return this;\n  }\n\n  public setSubList(config: (item: DataType) => KoalaListConfigInterface) {\n    this.config.subListConfig = config;\n    return this;\n  }\n\n  public defineBtnCollapseSubListConfig(config: KoalaListBtnCollapseSubListConfigInterface<DataType>) {\n    this.config.btnCollapseSubListConfig = config;\n    return this;\n  }\n\n  public hidePaginator(hide: boolean = true) {\n    this.config.hidePaginator = hide;\n    return this;\n  }\n\n  public setCustomClass(className: string) {\n    this.config.customClass = className;\n    return this;\n  }\n\n  public getConfig(): KoalaListConfigInterface {\n    this.config.reload = new BehaviorSubject<boolean>(false);\n    return this.config;\n  }\n}\n"]}

package/list/esm2020/lib/list.abstract.mjs

@@ -0,0 +1,157 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { BehaviorSubject, merge, Observable } from 'rxjs';
+import { FormAbstract } from '@koalarx/ui/form';
+import { debounceTime, first, map, startWith, switchMap } from 'rxjs/operators';
+import { MatTableDataSource } from '@angular/material/table';
+import { delay } from "@koalarx/utils/operators/delay";
+export class ListAbstract extends FormAbstract {
+    constructor(requestFunction, requestResponseFunction, formSearch) {
+        super(formSearch);
+        this.requestFunction = requestFunction;
+        this.requestResponseFunction = requestResponseFunction;
+        this.selection = new SelectionModel(true, []);
+        this.limitOptions = [10, 20, 30, 50, 100];
+        this.showMenuList = false;
+        this.allSelected$ = new BehaviorSubject(false);
+        this.dataSource = new MatTableDataSource([]);
+        this.typeRequest = 'onDemand';
+        this.filterParams = new BehaviorSubject(null);
+        this.filterError$ = new BehaviorSubject(null);
+    }
+    selectAll() {
+        this.isAllSelected() ?
+            this.selection.clear() :
+            this.dataSource.data.forEach(item => {
+                if ((this.config?.disabledCheckboxItemList && !this.config.disabledCheckboxItemList(item)) ||
+                    !this.config?.disabledCheckboxItemList) {
+                    this.selection.select(item);
+                }
+            });
+        this.isAllSelected();
+    }
+    defineStatusSelectAll(status) {
+        this.allSelected$.next(status);
+        return this.allSelected$.getValue();
+    }
+    selectItem() {
+        setTimeout(() => {
+            this.showMenuList = this.selection.hasValue();
+            this.isAllSelected();
+        }, 50);
+    }
+    async search(filter) {
+        this.loading(true);
+        this.selection.clear();
+        if (this.paginator) {
+            this.paginator.firstPage();
+        }
+        this.filterParams.next({
+            params: filter,
+            sort: this.sort?.active ?? '',
+            order: this.sort?.direction ?? 'asc',
+            page: this.paginator?.pageIndex ?? 0,
+            limit: this.paginator?.pageSize ?? 30
+        });
+    }
+    onDestroy() {
+        this.subscriptionSortList?.unsubscribe();
+        this.subscriptionList?.unsubscribe();
+        clearInterval(this.intervalSortList);
+    }
+    async afterViewInit() {
+        let tentativas = 0;
+        let stop = false;
+        do {
+            tentativas++;
+            await delay(400);
+            if (this.sort || this.emptyListComponent) {
+                this.prepareSearch().then();
+                if (this.emptyListComponent)
+                    stop = true;
+            }
+            else if (tentativas > 10) {
+                stop = true;
+            }
+        } while (!this.sort && !stop);
+    }
+    async prepareSearch() {
+        this.intervalSortList = setInterval(() => {
+            if (this.sort && !this.subscriptionSortList) {
+                this.subscriptionSortList = this.sort.sortChange.subscribe(() => {
+                    const filter = this.filterParams.value ?? {};
+                    filter.sort = this.sort?.active ?? '';
+                    filter.order = this.sort?.direction ?? '';
+                    this.filterParams.next(filter);
+                });
+            }
+            else if (!this.sort && this.subscriptionSortList) {
+                this.subscriptionSortList.unsubscribe();
+            }
+        }, 50);
+        if (this.typeRequest === 'onDemand') {
+            this.subscriptionList = merge(this.paginator?.page ?? new Observable(), this.filterParams).pipe(startWith({}), switchMap(() => new Observable(observe => {
+                this.loading(true);
+                this.selection.clear();
+                if (this.filterParams.value) {
+                    this.filterParams.value.sort = this.sort?.active ?? this.config?.columnSort ?? '';
+                    this.filterParams.value.order = this.sort?.direction ?? this.config?.sortDirection ?? '';
+                    this.filterParams.value.page = this.paginator?.pageIndex ?? 0;
+                    this.filterParams.value.limit = this.paginator?.pageSize ?? 30;
+                }
+                observe.next(true);
+            })), debounceTime(300), switchMap(() => this.runRequestFunction()), map((response) => {
+                this.loading(false);
+                return this.requestResponseFunction(response);
+            })).subscribe();
+        }
+        else {
+            if (this.paginator)
+                this.dataSource.paginator = this.paginator;
+            this.subscriptionList = this.filterParams.pipe(startWith({}), debounceTime(300), switchMap(() => this.runRequestFunction()), map((response) => {
+                this.loading(false);
+                return this.requestResponseFunction(response);
+            })).subscribe();
+        }
+        if (this.emptyListComponent) {
+            do {
+                await delay(301);
+                if (this.sort) {
+                    if (this.typeRequest === "onDemand") {
+                        this.sort.sortChange.subscribe(() => {
+                            if (this.paginator)
+                                this.paginator.pageIndex = 0;
+                        });
+                    }
+                    else {
+                        this.dataSource.sort = this.sort;
+                    }
+                }
+            } while (!this.sort);
+        }
+    }
+    isAllSelected() {
+        const numSelected = this.selection.selected.length;
+        const numRows = (this.config?.disabledCheckboxItemList ?
+            this.dataSource.data.filter(item => !(this.config?.disabledCheckboxItemList
+                ? this.config.disabledCheckboxItemList(item)
+                : '')) :
+            this.dataSource.data).length;
+        return this.defineStatusSelectAll(numSelected === numRows);
+    }
+    runRequestFunction() {
+        return new Observable(observe => {
+            this.requestFunction().pipe(first()).subscribe({
+                next: response => observe.next(response),
+                error: err => {
+                    if (this.errorListComponent) {
+                        this.filterError$.next(err);
+                        this.errorListComponent.data = err;
+                    }
+                    this.loading(false);
+                    observe.next([]);
+                }
+            });
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.abstract.js","sourceRoot":"","sources":["../../../../projects/list/src/lib/list.abstract.ts"],"names":[],"mappings":"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","sourcesContent":["import { SelectionModel } from '@angular/cdk/collections';\nimport { MatPaginator } from '@angular/material/paginator';\nimport { MatSort } from '@angular/material/sort';\nimport { BehaviorSubject, merge, Observable, Subscription } from 'rxjs';\nimport { FormAbstract } from '@koalarx/ui/form';\nimport { FormGroup } from '@angular/forms';\nimport { debounceTime, first, map, startWith, switchMap } from 'rxjs/operators';\nimport { MatTableDataSource } from '@angular/material/table';\nimport { KoalaListFormFilterInterface } from './koala-list-form-filter.interface';\nimport { KoalaDynamicComponent } from \"@koalarx/ui/dynamic-component\";\nimport { delay } from \"@koalarx/utils/operators/delay\";\nimport { KoalaListConfigInterface } from \"./koala.list-config.interface\";\n\nexport type KoalaListPageSize = 10 | 20 | 30 | 50 | 100;\n\nexport abstract class ListAbstract extends FormAbstract {\n  public selection = new SelectionModel<object>(true, []);\n  public limitOptions: number[] = [10, 20, 30, 50, 100];\n  public showMenuList: boolean = false;\n  public allSelected$ = new BehaviorSubject<boolean>(false);\n  public dataSource = new MatTableDataSource<any>([]);\n  public typeRequest: 'all' | 'onDemand' = 'onDemand';\n  public filterParams = new BehaviorSubject<KoalaListFormFilterInterface|null>(null);\n  public filterError$ = new BehaviorSubject<any>(null);\n  public emptyListComponent?: KoalaDynamicComponent;\n  public errorListComponent?: KoalaDynamicComponent;\n  public pageSize: KoalaListPageSize;\n\n  protected config?: KoalaListConfigInterface;\n  protected paginator?: MatPaginator;\n  protected sort?: MatSort;\n\n  private subscriptionList?: Subscription;\n  private subscriptionSortList?: Subscription;\n  private intervalSortList: any;\n\n  protected constructor(\n    private requestFunction: () => Observable<any>,\n    private requestResponseFunction: <T>(results: T[]) => void,\n    formSearch: () => FormGroup\n  ) {\n    super(formSearch);\n  }\n\n  public selectAll() {\n    this.isAllSelected() ?\n    this.selection.clear() :\n    this.dataSource.data.forEach(item => {\n      if (\n        (this.config?.disabledCheckboxItemList && !this.config.disabledCheckboxItemList(item)) ||\n        !this.config?.disabledCheckboxItemList\n      ) {\n        this.selection.select(item);\n      }\n    });\n\n    this.isAllSelected();\n  }\n\n  public defineStatusSelectAll(status: boolean) {\n    this.allSelected$.next(status);\n    return this.allSelected$.getValue();\n  }\n\n  public selectItem() {\n    setTimeout(() => {\n      this.showMenuList = this.selection.hasValue();\n      this.isAllSelected();\n    }, 50);\n  }\n\n  public async search(filter?: any) {\n    this.loading(true);\n    this.selection.clear();\n    if (this.paginator) {\n      this.paginator.firstPage();\n    }\n    this.filterParams.next({\n      params: filter,\n      sort: this.sort?.active ?? '',\n      order: this.sort?.direction ?? 'asc',\n      page: this.paginator?.pageIndex ?? 0,\n      limit: this.paginator?.pageSize ?? 30\n    });\n  }\n\n  protected onDestroy() {\n    this.subscriptionSortList?.unsubscribe();\n    this.subscriptionList?.unsubscribe();\n    clearInterval(this.intervalSortList);\n  }\n\n  protected async afterViewInit() {\n    let tentativas = 0;\n    let stop = false;\n    do {\n      tentativas++;\n      await delay(400);\n      if (this.sort || this.emptyListComponent) {\n        this.prepareSearch().then();\n        if (this.emptyListComponent) stop = true;\n      } else if (tentativas > 10) {\n        stop = true;\n      }\n    } while (!this.sort && !stop);\n  }\n\n  private async prepareSearch() {\n    this.intervalSortList = setInterval(() => {\n      if (this.sort && !this.subscriptionSortList) {\n        this.subscriptionSortList = this.sort.sortChange.subscribe(() => {\n          const filter = this.filterParams.value ?? {} as any;\n          filter.sort = this.sort?.active ?? '';\n          filter.order = this.sort?.direction ?? '';\n          this.filterParams.next(filter);\n        });\n      } else if (!this.sort && this.subscriptionSortList) {\n        this.subscriptionSortList.unsubscribe();\n      }\n    }, 50);\n\n    if (this.typeRequest === 'onDemand') {\n      this.subscriptionList = merge(this.paginator?.page ?? new Observable(), this.filterParams).pipe(\n        startWith({}),\n        switchMap(() => new Observable(observe => {\n          this.loading(true);\n          this.selection.clear();\n          if (this.filterParams.value) {\n            this.filterParams.value.sort = this.sort?.active ?? this.config?.columnSort ?? '';\n            this.filterParams.value.order = this.sort?.direction ?? this.config?.sortDirection ?? '';\n            this.filterParams.value.page = this.paginator?.pageIndex ?? 0;\n            this.filterParams.value.limit = this.paginator?.pageSize ?? 30;\n          }\n          observe.next(true);\n        })),\n        debounceTime(300),\n        switchMap(() => this.runRequestFunction()),\n        map((response) => {\n          this.loading(false);\n          return this.requestResponseFunction(response);\n        })\n      ).subscribe();\n    } else {\n      if (this.paginator) this.dataSource.paginator = this.paginator;\n      this.subscriptionList = this.filterParams.pipe(\n        startWith({}),\n        debounceTime(300),\n        switchMap(() => this.runRequestFunction()),\n        map((response) => {\n          this.loading(false);\n          return this.requestResponseFunction(response);\n        })\n      ).subscribe();\n    }\n\n    if (this.emptyListComponent) {\n      do {\n        await delay(301);\n        if (this.sort) {\n          if (this.typeRequest === \"onDemand\") {\n            this.sort.sortChange.subscribe(() => {\n              if (this.paginator) this.paginator.pageIndex = 0\n            });\n          } else {\n            this.dataSource.sort = this.sort;\n          }\n        }\n      } while (!this.sort);\n    }\n  }\n\n  private isAllSelected() {\n    const numSelected = this.selection.selected.length;\n    const numRows = (this.config?.disabledCheckboxItemList ?\n                     this.dataSource.data.filter(item => !(this.config?.disabledCheckboxItemList\n                                                           ? this.config.disabledCheckboxItemList(item)\n                                                           : '')) :\n                     this.dataSource.data).length;\n\n    return this.defineStatusSelectAll(numSelected === numRows);\n  }\n\n  private runRequestFunction() {\n    return new Observable<unknown[]>(observe => {\n      this.requestFunction().pipe(first()).subscribe({\n        next: response => observe.next(response),\n        error: err => {\n          if (this.errorListComponent) {\n            this.filterError$.next(err);\n            this.errorListComponent.data = err;\n          }\n          this.loading(false);\n          observe.next([]);\n        }\n      })\n    })\n  }\n}\n"]}