shared-ui-test-2 1.0.0

package/esm2022/services/api/common-crud-api.service.mjs

@@ -0,0 +1,59 @@
+import { Injectable } from '@angular/core';
+import { finalize, share } from 'rxjs/operators';
+import { RestApiService } from '../../modules/ui-kit/services/api/rest-api.service';
+import * as i0 from "@angular/core";
+export class CommonCrudApiService extends RestApiService {
+    constructor() {
+        super(...arguments);
+        /**
+         * Entities cache
+         */
+        this._entities = new Map();
+        this._entityIds = new Map();
+    }
+    getItemsList(params, path) {
+        const paramsJSON = JSON.stringify(params);
+        this._entities.set(paramsJSON, this._entities.get(paramsJSON) || this.getList(params, path)
+            .pipe(share()));
+        return this._entities.get(paramsJSON);
+    }
+    getOnlyActiveItemsList(params, path) {
+        return this.getItemsList({
+            ...params,
+            activeOnly: true,
+        }, path);
+    }
+    /**
+     * Api methods
+     */
+    getSingleItem(id, params, path) {
+        this._entityIds[id] = this._entityIds[id] || this.getItemById(id, params, path)
+            .pipe(share());
+        return this._entityIds[id];
+    }
+    postNewItem(params, path) {
+        return this.postItem(params, undefined, path).pipe(finalize(() => this.clearAllCache()));
+    }
+    updateItem(params, path) {
+        return this.patchItem(params, path).pipe(finalize(() => this.clearAllCache()));
+    }
+    putItem(id, params, path) {
+        return this.putItemById(id, params, path).pipe(finalize(() => this.clearAllCache()));
+    }
+    deleteItem(id, params, path) {
+        return this.deleteItemById(id, params, path).pipe(finalize(() => this.clearAllCache()));
+    }
+    clearAllCache() {
+        this._entities.clear();
+        this._entityIds.clear();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommonCrudApiService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommonCrudApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CommonCrudApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/api/filter-api.service.mjs

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, combineLatest } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./common-crud-api.service";
+export class FilterApiService {
+    set filterState(filterFn) {
+        this._filterState.next(filterFn);
+    }
+    get filterState$() {
+        return this._filterState.asObservable();
+    }
+    get filteredEntities$() {
+        return this._filteredEntities$;
+    }
+    constructor(apiService) {
+        this.apiService = apiService;
+        /**
+         * Filter state
+         */
+        this._filterState = new BehaviorSubject(null);
+        this._filteredEntities$ = combineLatest(this.apiService.getItemsList(), this.filterState$).pipe(filter(([entities]) => !!entities), map(([entities, filterFn]) => filterFn ? ({ ...entities, resultSet: entities.resultSet.filter(filterFn) }) : entities));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FilterApiService, deps: [{ token: i1.CommonCrudApiService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FilterApiService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FilterApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.CommonCrudApiService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/selectable.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class SelectableService {
+    constructor() {
+        this._activeItem$ = new BehaviorSubject(null);
+    }
+    get activeItem$() {
+        return this._activeItem$.asObservable();
+    }
+    get activeItem() {
+        return this._activeItem$.value;
+    }
+    set activeItem(item) {
+        this._activeItem$.next(item);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectableService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectableService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectableService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0YWJsZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vbGliL3NyYy9zZXJ2aWNlcy9zZWxlY3RhYmxlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQWMsZUFBZSxFQUFFLE1BQU0sTUFBTSxDQUFDOztBQUduRCxNQUFNLE9BQU8saUJBQWlCO0lBRDlCO1FBR1UsaUJBQVksR0FBOEIsSUFBSSxlQUFlLENBQUMsSUFBSSxDQUFDLENBQUM7S0FjN0U7SUFaQyxJQUFJLFdBQVc7UUFDYixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDMUMsQ0FBQztJQUVELElBQUksVUFBVTtRQUNaLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUM7SUFDakMsQ0FBQztJQUVELElBQUksVUFBVSxDQUFDLElBQWM7UUFDM0IsSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDL0IsQ0FBQzsrR0FkVSxpQkFBaUI7bUhBQWpCLGlCQUFpQjs7NEZBQWpCLGlCQUFpQjtrQkFEN0IsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE9ic2VydmFibGUsIEJlaGF2aW9yU3ViamVjdCB9IGZyb20gJ3J4anMnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgU2VsZWN0YWJsZVNlcnZpY2U8VD4ge1xuXG4gIHByaXZhdGUgX2FjdGl2ZUl0ZW0kOiBCZWhhdmlvclN1YmplY3Q8VCB8IG51bGw+ID0gbmV3IEJlaGF2aW9yU3ViamVjdChudWxsKTtcblxuICBnZXQgYWN0aXZlSXRlbSQoKTogT2JzZXJ2YWJsZTxUPiB7XG4gICAgcmV0dXJuIHRoaXMuX2FjdGl2ZUl0ZW0kLmFzT2JzZXJ2YWJsZSgpO1xuICB9XG5cbiAgZ2V0IGFjdGl2ZUl0ZW0oKTogVCB7XG4gICAgcmV0dXJuIHRoaXMuX2FjdGl2ZUl0ZW0kLnZhbHVlO1xuICB9XG5cbiAgc2V0IGFjdGl2ZUl0ZW0oaXRlbTogVCB8IG51bGwpIHtcbiAgICB0aGlzLl9hY3RpdmVJdGVtJC5uZXh0KGl0ZW0pO1xuICB9XG5cbn1cbiJdfQ==

package/esm2022/shared-pipes/pipes/search.pipe.mjs

@@ -0,0 +1,48 @@
+import { Pipe } from '@angular/core';
+import { isUndefined, isNull } from 'lodash';
+import * as i0 from "@angular/core";
+import * as i1 from "../../modules/ui-kit/services/data-table.service";
+export class SearchPipe {
+    constructor(dataTableService) {
+        this.dataTableService = dataTableService;
+    }
+    transform(items, search, columns) {
+        if (isUndefined(columns)) {
+            columns = [];
+        }
+        if (search) {
+            items = items.filter((item) => {
+                if (item.data) {
+                    return this.findItem(item.data, search, columns);
+                }
+                return this.findItem(item, search, columns);
+            });
+        }
+        if (items) {
+            this.dataTableService.searchedRowCount$.next(items.length);
+        }
+        return items;
+    }
+    findItem(item, search, columns) {
+        if (columns.length === 0) {
+            columns = this.getAllProperties(item);
+        }
+        return columns.filter((column) => this.ifDefinedAndNotNull(item, column) && this.isMatched(item[column], search)).length > 0;
+    }
+    getAllProperties(item) {
+        return Object.keys(item);
+    }
+    isMatched(data, searchValue) {
+        return data.toString().toLocaleLowerCase().includes(searchValue.toLocaleLowerCase());
+    }
+    ifDefinedAndNotNull(data, propertyName) {
+        return !isUndefined(data[propertyName]) && !isNull(data[propertyName]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SearchPipe, deps: [{ token: i1.DataTableService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: SearchPipe, name: "search" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SearchPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'search' }]
+        }], ctorParameters: () => [{ type: i1.DataTableService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWIvc3JjL3NoYXJlZC1waXBlcy9waXBlcy9zZWFyY2gucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUNwRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sRUFBRSxNQUFNLFFBQVEsQ0FBQzs7O0FBSzdDLE1BQU0sT0FBTyxVQUFVO0lBRXJCLFlBQW9CLGdCQUFrQztRQUFsQyxxQkFBZ0IsR0FBaEIsZ0JBQWdCLENBQWtCO0lBQUksQ0FBQztJQUVwRCxTQUFTLENBQUMsS0FBWSxFQUFFLE1BQWMsRUFBRSxPQUFrQjtRQUUvRCxJQUFJLFdBQVcsQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDO1lBQ3pCLE9BQU8sR0FBRyxFQUFFLENBQUM7UUFDZixDQUFDO1FBRUQsSUFBSSxNQUFNLEVBQUUsQ0FBQztZQUNYLEtBQUssR0FBRyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUU7Z0JBQzVCLElBQUksSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO29CQUNkLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQztnQkFDbkQsQ0FBQztnQkFDRCxPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQztZQUM5QyxDQUFDLENBQUMsQ0FBQztRQUNMLENBQUM7UUFFRCxJQUFJLEtBQUssRUFBRSxDQUFDO1lBQ1YsSUFBSSxDQUFDLGdCQUFnQixDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDN0QsQ0FBQztRQUVELE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztJQUVPLFFBQVEsQ0FBQyxJQUFTLEVBQUUsTUFBYyxFQUFFLE9BQWlCO1FBQzNELElBQUksT0FBTyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUN6QixPQUFPLEdBQUcsSUFBSSxDQUFDLGdCQUFnQixDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3hDLENBQUM7UUFFRCxPQUFPLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUM3QixJQUFJLENBQUMsbUJBQW1CLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxJQUFJLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLE1BQU0sQ0FBQyxDQUMvRSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUM7SUFDakIsQ0FBQztJQUVPLGdCQUFnQixDQUFDLElBQWU7UUFDdEMsT0FBTyxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzNCLENBQUM7SUFFTyxTQUFTLENBQUMsSUFBUyxFQUFFLFdBQW1CO1FBQzlDLE9BQU8sSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDLGlCQUFpQixFQUFFLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxpQkFBaUIsRUFBRSxDQUFDLENBQUM7SUFDdkYsQ0FBQztJQUVPLG1CQUFtQixDQUFDLElBQVMsRUFBRSxZQUFvQjtRQUN6RCxPQUFPLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFDO0lBQ3pFLENBQUM7K0dBOUNVLFVBQVU7NkdBQVYsVUFBVTs7NEZBQVYsVUFBVTtrQkFEdEIsSUFBSTttQkFBQyxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBpc1VuZGVmaW5lZCwgaXNOdWxsIH0gZnJvbSAnbG9kYXNoJztcbmltcG9ydCB7IERhdGFUYWJsZVNlcnZpY2UgfSBmcm9tICcuLi8uLi9tb2R1bGVzL3VpLWtpdC9zZXJ2aWNlcy9kYXRhLXRhYmxlLnNlcnZpY2UnO1xuaW1wb3J0IHsgSUtleVZhbHVlIH0gZnJvbSAnLi4vLi4vbW9kdWxlcy91aS1raXQvaW50ZXJmYWNlcy9nZW5lcmljLmludGVyZmFjZSc7XG5cbkBQaXBlKHsgbmFtZTogJ3NlYXJjaCcgfSlcbmV4cG9ydCBjbGFzcyBTZWFyY2hQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSBkYXRhVGFibGVTZXJ2aWNlOiBEYXRhVGFibGVTZXJ2aWNlKSB7IH1cblxuICBwdWJsaWMgdHJhbnNmb3JtKGl0ZW1zOiBhbnlbXSwgc2VhcmNoOiBzdHJpbmcsIGNvbHVtbnM/OiBzdHJpbmdbXSk6IElLZXlWYWx1ZVtdIHtcblxuICAgIGlmIChpc1VuZGVmaW5lZChjb2x1bW5zKSkge1xuICAgICAgY29sdW1ucyA9IFtdO1xuICAgIH1cblxuICAgIGlmIChzZWFyY2gpIHtcbiAgICAgIGl0ZW1zID0gaXRlbXMuZmlsdGVyKChpdGVtKSA9PiB7XG4gICAgICAgIGlmIChpdGVtLmRhdGEpIHtcbiAgICAgICAgICByZXR1cm4gdGhpcy5maW5kSXRlbShpdGVtLmRhdGEsIHNlYXJjaCwgY29sdW1ucyk7XG4gICAgICAgIH1cbiAgICAgICAgcmV0dXJuIHRoaXMuZmluZEl0ZW0oaXRlbSwgc2VhcmNoLCBjb2x1bW5zKTtcbiAgICAgIH0pO1xuICAgIH1cblxuICAgIGlmIChpdGVtcykge1xuICAgICAgdGhpcy5kYXRhVGFibGVTZXJ2aWNlLnNlYXJjaGVkUm93Q291bnQkLm5leHQoaXRlbXMubGVuZ3RoKTtcbiAgICB9XG5cbiAgICByZXR1cm4gaXRlbXM7XG4gIH1cblxuICBwcml2YXRlIGZpbmRJdGVtKGl0ZW06IGFueSwgc2VhcmNoOiBzdHJpbmcsIGNvbHVtbnM6IHN0cmluZ1tdKTogYm9vbGVhbiB7XG4gICAgaWYgKGNvbHVtbnMubGVuZ3RoID09PSAwKSB7XG4gICAgICBjb2x1bW5zID0gdGhpcy5nZXRBbGxQcm9wZXJ0aWVzKGl0ZW0pO1xuICAgIH1cbiAgICBcbiAgICByZXR1cm4gY29sdW1ucy5maWx0ZXIoKGNvbHVtbikgPT4gXG4gICAgICAgIHRoaXMuaWZEZWZpbmVkQW5kTm90TnVsbChpdGVtLCBjb2x1bW4pICYmIHRoaXMuaXNNYXRjaGVkKGl0ZW1bY29sdW1uXSwgc2VhcmNoKSxcbiAgICAgICkubGVuZ3RoID4gMDtcbiAgfVxuXG4gIHByaXZhdGUgZ2V0QWxsUHJvcGVydGllcyhpdGVtOiBJS2V5VmFsdWUpOiBzdHJpbmdbXSB7XG4gICAgcmV0dXJuIE9iamVjdC5rZXlzKGl0ZW0pO1xuICB9XG5cbiAgcHJpdmF0ZSBpc01hdGNoZWQoZGF0YTogYW55LCBzZWFyY2hWYWx1ZTogc3RyaW5nKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIGRhdGEudG9TdHJpbmcoKS50b0xvY2FsZUxvd2VyQ2FzZSgpLmluY2x1ZGVzKHNlYXJjaFZhbHVlLnRvTG9jYWxlTG93ZXJDYXNlKCkpO1xuICB9XG5cbiAgcHJpdmF0ZSBpZkRlZmluZWRBbmROb3ROdWxsKGRhdGE6IGFueSwgcHJvcGVydHlOYW1lOiBzdHJpbmcpOiBib29sZWFuIHtcbiAgICByZXR1cm4gIWlzVW5kZWZpbmVkKGRhdGFbcHJvcGVydHlOYW1lXSkgJiYgIWlzTnVsbChkYXRhW3Byb3BlcnR5TmFtZV0pO1xuICB9XG59XG4iXX0=

package/esm2022/shared-ui-test-2.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkLXVpLXRlc3QtMi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2xpYi9zcmMvc2hhcmVkLXVpLXRlc3QtMi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/shared.module.mjs

@@ -0,0 +1,57 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { NgLetModule } from './directives/let.directive';
+import { DynamicCardsModule } from './modules/dynamic-cards/dynamic-cards.module';
+import { DynamicFormsModule } from './modules/dynamic-forms/dynamic-forms.module';
+import { UiKitModule } from './modules/ui-kit/ui-kit.module';
+import { QueryBuilderModule } from './modules/query-builder/query-builder.module';
+import { FlexLayoutModule } from '@angular/flex-layout';
+import * as i0 from "@angular/core";
+export class SharedModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SharedModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: SharedModule, imports: [CommonModule,
+            NgLetModule,
+            DynamicFormsModule,
+            UiKitModule,
+            DynamicCardsModule,
+            QueryBuilderModule], exports: [NgLetModule,
+            DynamicFormsModule,
+            FlexLayoutModule,
+            UiKitModule,
+            DynamicCardsModule,
+            QueryBuilderModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SharedModule, imports: [CommonModule,
+            NgLetModule,
+            DynamicFormsModule,
+            UiKitModule,
+            DynamicCardsModule,
+            QueryBuilderModule, NgLetModule,
+            DynamicFormsModule,
+            FlexLayoutModule,
+            UiKitModule,
+            DynamicCardsModule,
+            QueryBuilderModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SharedModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [
+                        CommonModule,
+                        NgLetModule,
+                        DynamicFormsModule,
+                        UiKitModule,
+                        DynamicCardsModule,
+                        QueryBuilderModule,
+                    ],
+                    exports: [
+                        NgLetModule,
+                        DynamicFormsModule,
+                        FlexLayoutModule,
+                        UiKitModule,
+                        DynamicCardsModule,
+                        QueryBuilderModule,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/validators/debounce-async.validator.mjs

@@ -0,0 +1,12 @@
+import { Subject, timer } from 'rxjs';
+import { takeUntil, switchMap } from 'rxjs/operators';
+export class DebounceAsyncValidator {
+    constructor() {
+        this.cancelRequest = new Subject();
+    }
+    debounceRequest(...args) {
+        this.cancelRequest.next(null);
+        return timer(this.DEBOUNCE_TIME).pipe(takeUntil(this.cancelRequest), switchMap(() => this.sendRequest(...args)));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVib3VuY2UtYXN5bmMudmFsaWRhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vbGliL3NyYy92YWxpZGF0b3JzL2RlYm91bmNlLWFzeW5jLnZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQWMsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUNsRCxPQUFPLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRXRELE1BQU0sT0FBZ0Isc0JBQXNCO0lBQTVDO1FBRVMsa0JBQWEsR0FBRyxJQUFJLE9BQU8sRUFBRSxDQUFDO0lBaUJ2QyxDQUFDO0lBVFcsZUFBZSxDQUFDLEdBQUcsSUFBSTtRQUMvQixJQUFJLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUU5QixPQUFPLEtBQUssQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLENBQUMsSUFBSSxDQUNuQyxTQUFTLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxFQUM3QixTQUFTLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxHQUFHLElBQUksQ0FBQyxDQUFDLENBQzNDLENBQUM7SUFDSixDQUFDO0NBRUYiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBc3luY1ZhbGlkYXRvciwgQWJzdHJhY3RDb250cm9sLCBWYWxpZGF0aW9uRXJyb3JzIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgU3ViamVjdCwgdGltZXIgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IHRha2VVbnRpbCwgc3dpdGNoTWFwIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgRGVib3VuY2VBc3luY1ZhbGlkYXRvciBpbXBsZW1lbnRzIEFzeW5jVmFsaWRhdG9yIHtcblxuICBwdWJsaWMgY2FuY2VsUmVxdWVzdCA9IG5ldyBTdWJqZWN0KCk7XG5cbiAgcHVibGljIGFic3RyYWN0IHJlYWRvbmx5IERFQk9VTkNFX1RJTUU6IG51bWJlcjtcblxuICBwdWJsaWMgYWJzdHJhY3QgdmFsaWRhdGUoY29udHJvbDogQWJzdHJhY3RDb250cm9sKTogUHJvbWlzZTxWYWxpZGF0aW9uRXJyb3JzIHwgbnVsbD4gfCBPYnNlcnZhYmxlPFZhbGlkYXRpb25FcnJvcnMgfCBudWxsPjtcblxuICBwcm90ZWN0ZWQgYWJzdHJhY3Qgc2VuZFJlcXVlc3QoLi4uYXJncyk6IE9ic2VydmFibGU8VmFsaWRhdGlvbkVycm9ycyB8IG51bGw+O1xuXG4gIHByb3RlY3RlZCBkZWJvdW5jZVJlcXVlc3QoLi4uYXJncyk6IE9ic2VydmFibGU8VmFsaWRhdGlvbkVycm9ycyB8IG51bGw+IHtcbiAgICB0aGlzLmNhbmNlbFJlcXVlc3QubmV4dChudWxsKTtcblxuICAgIHJldHVybiB0aW1lcih0aGlzLkRFQk9VTkNFX1RJTUUpLnBpcGUoXG4gICAgICB0YWtlVW50aWwodGhpcy5jYW5jZWxSZXF1ZXN0KSxcbiAgICAgIHN3aXRjaE1hcCgoKSA9PiB0aGlzLnNlbmRSZXF1ZXN0KC4uLmFyZ3MpKSxcbiAgICApO1xuICB9XG5cbn1cbiJdfQ==