@recursyve/nice-data-filter-kit 12.1.30 → 13.0.3

package/esm2020/lib/components/base-list/store/base-list.service.mjs

@@ -0,0 +1,341 @@
+import { ApplicationRef, Injectable } from "@angular/core";
+import { ActivatedRoute, Router } from "@angular/router";
+import { arrayRemove, arrayUpsert } from "@datorama/akita";
+import { FileUtils } from "@recursyve/nice-ui-kit.v2";
+import { firstValueFrom, Subject } from "rxjs";
+import { map, takeUntil } from "rxjs/operators";
+import { FilterUtils } from "../../../utils/filter.utils";
+import { QueryParamsUtils } from "../../../utils/query-params.utils";
+import { QBFilterUtils } from "../../query-builder/utils/qb-filter.utils";
+import { NiceFilterService } from "../providers/base-filter.service";
+import { NiceBaseListStore } from "./base-list.store";
+import * as i0 from "@angular/core";
+import * as i1 from "./base-list.store";
+import * as i2 from "../providers/base-filter.service";
+import * as i3 from "@angular/router";
+export class NiceBaseListService {
+    constructor(store, filterService, activatedRoute, router, appRef) {
+        this.store = store;
+        this.filterService = filterService;
+        this.activatedRoute = activatedRoute;
+        this.router = router;
+        this.appRef = appRef;
+        this.queryParamsLoaded$ = new Subject();
+        this.downloadFileName = "data";
+        this.unsubscribeAll$ = new Subject();
+        this.loadingData = false;
+    }
+    async init() {
+        this.store.setFilterConfigLoading(true);
+        try {
+            const filterConfig = await firstValueFrom(this.filterService.getFilterConfig());
+            this.store.update({
+                filterConfig
+            });
+        }
+        catch (e) {
+            this.store.setError(e);
+        }
+        finally {
+            this.store.setFilterConfigLoading(false);
+        }
+    }
+    resetStore() {
+        this.store.reset();
+    }
+    resetData() {
+        this.store.update({
+            filterResult: null
+        });
+    }
+    closeSubscriptions() {
+        this.unsubscribeAll$.next(null);
+        this.unsubscribeAll$.complete();
+        this.queryParamsLoaded$.complete();
+    }
+    disableList() {
+        this.store.update({
+            disabled: true
+        });
+    }
+    enableList() {
+        this.store.update({
+            disabled: false
+        });
+    }
+    setLoading(loading) {
+        this.store.setLoading(loading);
+    }
+    setMode(mode) {
+        this.store.update({
+            mergePageResults: mode === "infinite-scroll"
+        });
+    }
+    loadQueryParams(autoLoad) {
+        this.activatedRoute?.queryParams
+            .pipe(takeUntil(this.unsubscribeAll$), map((params) => {
+            return {
+                params: QueryParamsUtils.extractFilterParameters(params)
+            };
+        }))
+            .subscribe(({ params }) => {
+            if (!params || Object.keys(params).length === 0) {
+                params = this.store.getValue().filterParameters;
+            }
+            const { filterParameters, filterResult } = this.store.getValue();
+            if (FilterUtils.filterChangeNeedsRefresh(filterParameters, params) ||
+                !filterResult) {
+                if (autoLoad) {
+                    this.loadData(params, false);
+                }
+                else {
+                    this.setParameters(params, false);
+                }
+            }
+            this.queryParamsLoaded$.next(null);
+        });
+    }
+    async resetAndLoadData(parameters, updateQueryParams = true) {
+        return this.loadData(parameters, updateQueryParams, true);
+    }
+    async loadData(parameters, updateQueryParams = true, reset = false) {
+        const { disabled } = this.store.getValue();
+        try {
+            const filterParameters = this.mergeParameters(parameters);
+            if (!disabled) {
+                this.store.setLoading(true);
+                this.loadingData = true;
+                const result = await firstValueFrom(this.filterService.filter(this.getParameters(filterParameters)));
+                this.store.setResult(result, reset);
+            }
+            if (filterParameters) {
+                this.setParameters(filterParameters, disabled ? false : updateQueryParams);
+            }
+        }
+        catch (e) {
+            this.store.setError(e);
+        }
+        finally {
+            this.store.setLoading(false);
+            this.loadingData = false;
+        }
+    }
+    async searchData(search) {
+        const { filterParameters } = this.store.getValue();
+        await this.loadData({
+            ...filterParameters,
+            search
+        });
+    }
+    async loadNewPage(start, length) {
+        const { filterParameters } = this.store.getValue();
+        await this.loadData({
+            ...filterParameters,
+            start,
+            length
+        });
+    }
+    async loadNextPage() {
+        const { filterParameters } = this.store.getValue();
+        await this.loadData({
+            ...filterParameters,
+            start: filterParameters.start + filterParameters.length
+        });
+    }
+    async resetPaging() {
+        const { filterParameters } = this.store.getValue();
+        this.store.setParameters({
+            ...filterParameters,
+            start: 0
+        });
+        this.store.update({
+            resetPaging: true
+        });
+    }
+    async downloadData(type, parameters, updateQueryParams = true) {
+        try {
+            this.store.setLoading(true);
+            this.loadingData = true;
+            const filterParameters = this.mergeParameters(parameters);
+            if (filterParameters) {
+                this.setParameters(filterParameters, updateQueryParams);
+            }
+            const result = await firstValueFrom(this.filterService.getFile(type, this.getParameters(filterParameters)));
+            FileUtils.downloadFile(`${this.downloadFileName}.${type}`, result);
+        }
+        catch (e) {
+            this.store.setError(e);
+        }
+        finally {
+            this.store.setLoading(false);
+            this.loadingData = false;
+        }
+    }
+    async printData(parameters, updateQueryParams = true) {
+        try {
+            this.store.setLoading(true);
+            this.loadingData = true;
+            const filterParameters = this.mergeParameters(parameters);
+            if (filterParameters) {
+                this.setParameters(filterParameters, updateQueryParams);
+            }
+            const result = await firstValueFrom(this.filterService.getPrintableHtml(this.getParameters(filterParameters)));
+            FileUtils.openPrintableWindow(result);
+        }
+        catch (e) {
+            this.store.setError(e);
+        }
+        finally {
+            this.store.setLoading(false);
+            this.loadingData = false;
+        }
+    }
+    updateRule(id, newRule) {
+        const { filterParameters } = this.store.getValue();
+        const rules = filterParameters.rules?.[0];
+        if (!rules || rules.rules.length === 0) {
+            this.updateRules([newRule]);
+            return;
+        }
+        const oldRule = rules.rules.find((r) => r.id === id);
+        let newRules = rules.rules;
+        if (oldRule) {
+            if (newRule) {
+                // Array replace
+                newRules = [
+                    ...rules.rules.slice(0, rules.rules.indexOf(oldRule)),
+                    newRule,
+                    ...rules.rules.slice(rules.rules.indexOf(oldRule) + 1, rules.rules.length)
+                ];
+            }
+            else {
+                newRules = rules.rules.filter((r) => r.id !== id);
+            }
+        }
+        else {
+            newRules = [...newRules, newRule];
+        }
+        this.updateRules(newRules);
+    }
+    updateDefaultRules(rule) {
+        this.store.update({
+            defaultRules: rule
+        });
+    }
+    async updateGlobalRules(rules, updateQueryParams = true) {
+        const { filterParameters } = this.store.getValue();
+        const newRules = {
+            ...filterParameters,
+            rules
+        };
+        await this.loadData(newRules, updateQueryParams);
+    }
+    addRuleFromConfig(config) {
+        const { filterParameters } = this.store.getValue();
+        const newRules = {
+            ...filterParameters,
+            rules: [
+                ...filterParameters.rules,
+                QBFilterUtils.createQueryModel(config)
+            ]
+        };
+        this.store.update({
+            showQueryBuilder: true
+        });
+        this.loadData(newRules, true);
+    }
+    updateRules(rules) {
+        const { filterParameters } = this.store.getValue();
+        const newRules = {
+            order: filterParameters.order,
+            rules: [
+                {
+                    condition: "and",
+                    rules
+                }
+            ]
+        };
+        this.loadData(newRules, true);
+    }
+    toggleQueryBuilder() {
+        this.store.update((state) => ({
+            showQueryBuilder: !state.showQueryBuilder
+        }));
+    }
+    updateListValue(value, key = "id") {
+        const { filterResult } = this.store.getValue();
+        if (!filterResult) {
+            return;
+        }
+        this.store.update({
+            filterResult: {
+                ...filterResult,
+                values: arrayUpsert(filterResult.values, value[key], value)
+            }
+        });
+    }
+    removeListValue(value, key = "id") {
+        const { filterResult } = this.store.getValue();
+        if (!filterResult) {
+            return;
+        }
+        this.store.update({
+            filterResult: {
+                ...filterResult,
+                values: arrayRemove(filterResult.values, value[key])
+            }
+        });
+    }
+    async updateQueryParams(queryParams) {
+        if (!this.activatedRoute) {
+            return;
+        }
+        await this.router.navigate([], {
+            relativeTo: this.activatedRoute,
+            queryParams,
+            queryParamsHandling: "merge"
+        });
+    }
+    getParameters(filterParameters) {
+        const { defaultRules } = this.store.getValue();
+        const parameters = {
+            ...filterParameters,
+            rules: filterParameters?.rules ? [...filterParameters.rules] : []
+        };
+        if (defaultRules?.length) {
+            parameters.rules.push({
+                condition: "and",
+                rules: defaultRules
+            });
+        }
+        return parameters;
+    }
+    mergeParameters(parameters) {
+        const { filterParameters } = this.store.getValue();
+        if (!parameters) {
+            return filterParameters;
+        }
+        return {
+            ...filterParameters,
+            ...parameters,
+            order: filterParameters.order && !parameters.order
+                ? undefined
+                : {
+                    ...filterParameters.order,
+                    ...parameters.order
+                }
+        };
+    }
+    setParameters(parameters, updateQueryParams = true) {
+        this.store.setParameters(parameters);
+        if (updateQueryParams) {
+            this.updateQueryParams(QueryParamsUtils.filterParametersToParamsMap(parameters));
+        }
+    }
+}
+NiceBaseListService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceBaseListService, deps: [{ token: i1.NiceBaseListStore }, { token: i2.NiceFilterService }, { token: i3.ActivatedRoute }, { token: i3.Router }, { token: i0.ApplicationRef }], target: i0.ɵɵFactoryTarget.Injectable });
+NiceBaseListService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceBaseListService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceBaseListService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.NiceBaseListStore }, { type: i2.NiceFilterService }, { type: i3.ActivatedRoute }, { type: i3.Router }, { type: i0.ApplicationRef }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-list.service.js","sourceRoot":"","sources":["../../../../../../../projects/nice-data-filter-kit/src/lib/components/base-list/store/base-list.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApplicationRef, Injectable } from \"@angular/core\";\nimport { ActivatedRoute, Router } from \"@angular/router\";\nimport { arrayRemove, arrayUpsert } from \"@datorama/akita\";\nimport { FileUtils } from \"@recursyve/nice-ui-kit.v2\";\nimport { firstValueFrom, Subject } from \"rxjs\";\nimport { map, takeUntil } from \"rxjs/operators\";\nimport { FilterConfigurationModel, FilterParametersModel } from \"../../../models/filter.model\";\nimport { QueryModel, QueryRuleModel } from \"../../../models/query.model\";\nimport { FilterUtils } from \"../../../utils/filter.utils\";\nimport { QueryParamsUtils } from \"../../../utils/query-params.utils\";\nimport { QBFilterUtils } from \"../../query-builder/utils/qb-filter.utils\";\nimport { NiceFilterService } from \"../providers/base-filter.service\";\nimport { NiceBaseListStore } from \"./base-list.store\";\n\n@Injectable()\nexport class NiceBaseListService {\n    public queryParamsLoaded$ = new Subject();\n\n    protected downloadFileName = \"data\";\n    protected unsubscribeAll$ = new Subject();\n    protected loadingData = false;\n\n    constructor(\n        protected store: NiceBaseListStore,\n        protected filterService: NiceFilterService<any>,\n        protected activatedRoute: ActivatedRoute,\n        protected router: Router,\n        protected appRef: ApplicationRef\n    ) {\n    }\n\n    public async init(): Promise<void> {\n        this.store.setFilterConfigLoading(true);\n        try {\n            const filterConfig = await firstValueFrom(this.filterService.getFilterConfig());\n            this.store.update({\n                filterConfig\n            });\n        } catch (e) {\n            this.store.setError(e);\n        } finally {\n            this.store.setFilterConfigLoading(false);\n        }\n    }\n\n    public resetStore(): void {\n        this.store.reset();\n    }\n\n    public resetData(): void {\n        this.store.update({\n            filterResult: null\n        });\n    }\n\n    public closeSubscriptions(): void {\n        this.unsubscribeAll$.next(null);\n        this.unsubscribeAll$.complete();\n        this.queryParamsLoaded$.complete();\n    }\n\n    public disableList(): void {\n        this.store.update({\n            disabled: true\n        });\n    }\n\n    public enableList(): void {\n        this.store.update({\n            disabled: false\n        });\n    }\n\n    public setLoading(loading: boolean): void {\n        this.store.setLoading(loading);\n    }\n\n    public setMode(mode: \"normal\" | \"infinite-scroll\"): void {\n        this.store.update({\n            mergePageResults: mode === \"infinite-scroll\"\n        });\n    }\n\n    public loadQueryParams(autoLoad: boolean): void {\n        this.activatedRoute?.queryParams\n            .pipe(\n                takeUntil(this.unsubscribeAll$),\n                map((params: { [key: string]: any }) => {\n                    return {\n                        params: QueryParamsUtils.extractFilterParameters(params)\n                    };\n                })\n            )\n            .subscribe(({ params }) => {\n                if (!params || Object.keys(params).length === 0) {\n                    params = this.store.getValue().filterParameters;\n                }\n                const { filterParameters, filterResult } = this.store.getValue();\n                if (\n                    FilterUtils.filterChangeNeedsRefresh(filterParameters, params) ||\n                    !filterResult\n                ) {\n                    if (autoLoad) {\n                        this.loadData(params, false);\n                    } else {\n                        this.setParameters(params, false);\n                    }\n                }\n\n                this.queryParamsLoaded$.next(null);\n            });\n    }\n\n    public async resetAndLoadData(parameters?: FilterParametersModel, updateQueryParams: boolean = true): Promise<void> {\n        return this.loadData(parameters, updateQueryParams, true);\n    }\n\n    public async loadData(parameters?: FilterParametersModel, updateQueryParams: boolean = true, reset: boolean = false): Promise<void> {\n        const { disabled } = this.store.getValue();\n        try {\n            const filterParameters = this.mergeParameters(parameters);\n            if (!disabled) {\n                this.store.setLoading(true);\n                this.loadingData = true;\n                const result = await firstValueFrom(this.filterService.filter(this.getParameters(filterParameters)));\n                this.store.setResult(result, reset);\n            }\n\n            if (filterParameters) {\n                this.setParameters(filterParameters, disabled ? false : updateQueryParams);\n            }\n        } catch (e) {\n            this.store.setError(e);\n        } finally {\n            this.store.setLoading(false);\n            this.loadingData = false;\n        }\n    }\n\n    public async searchData(search: string): Promise<void> {\n        const { filterParameters } = this.store.getValue();\n        await this.loadData({\n            ...filterParameters,\n            search\n        });\n    }\n\n    public async loadNewPage(start: number, length: number): Promise<void> {\n        const { filterParameters } = this.store.getValue();\n        await this.loadData({\n            ...filterParameters,\n            start,\n            length\n        });\n    }\n\n    public async loadNextPage(): Promise<void> {\n        const { filterParameters } = this.store.getValue();\n        await this.loadData({\n            ...filterParameters,\n            start: filterParameters.start + filterParameters.length\n        });\n    }\n\n    public async resetPaging(): Promise<void> {\n        const { filterParameters } = this.store.getValue();\n        this.store.setParameters({\n            ...filterParameters,\n            start: 0\n        });\n        this.store.update({\n            resetPaging: true\n        });\n    }\n\n    public async downloadData(\n        type: string,\n        parameters?: FilterParametersModel,\n        updateQueryParams: boolean = true\n    ): Promise<void> {\n        try {\n            this.store.setLoading(true);\n            this.loadingData = true;\n            const filterParameters = this.mergeParameters(parameters);\n            if (filterParameters) {\n                this.setParameters(filterParameters, updateQueryParams);\n            }\n            const result = await firstValueFrom(this.filterService.getFile(type, this.getParameters(filterParameters)));\n            FileUtils.downloadFile(`${this.downloadFileName}.${type}`, result);\n        } catch (e) {\n            this.store.setError(e);\n        } finally {\n            this.store.setLoading(false);\n            this.loadingData = false;\n        }\n    }\n\n    public async printData(parameters?: FilterParametersModel, updateQueryParams: boolean = true): Promise<void> {\n        try {\n            this.store.setLoading(true);\n            this.loadingData = true;\n            const filterParameters = this.mergeParameters(parameters);\n            if (filterParameters) {\n                this.setParameters(filterParameters, updateQueryParams);\n            }\n            const result = await firstValueFrom(this.filterService.getPrintableHtml(this.getParameters(filterParameters)));\n            FileUtils.openPrintableWindow(result);\n        } catch (e) {\n            this.store.setError(e);\n        } finally {\n            this.store.setLoading(false);\n            this.loadingData = false;\n        }\n    }\n\n    public updateRule(id: string, newRule: QueryRuleModel): void {\n        const { filterParameters } = this.store.getValue();\n        const rules = filterParameters.rules?.[0];\n        if (!rules || rules.rules.length === 0) {\n            this.updateRules([newRule]);\n            return;\n        }\n\n        const oldRule = rules.rules.find((r) => (r as QueryRuleModel).id === id) as QueryRuleModel;\n        let newRules = rules.rules;\n        if (oldRule) {\n            if (newRule) {\n                // Array replace\n                newRules = [\n                    ...rules.rules.slice(0, rules.rules.indexOf(oldRule)),\n                    newRule,\n                    ...rules.rules.slice(rules.rules.indexOf(oldRule) + 1, rules.rules.length)\n                ];\n            } else {\n                newRules = rules.rules.filter((r) => (r as QueryRuleModel).id !== id);\n            }\n        } else {\n            newRules = [...newRules, newRule];\n        }\n        this.updateRules(newRules as QueryRuleModel[]);\n    }\n\n    public updateDefaultRules(rule: (QueryRuleModel | QueryModel)[]): void {\n        this.store.update({\n            defaultRules: rule\n        });\n    }\n\n    public async updateGlobalRules(rules: QueryModel[], updateQueryParams = true): Promise<void> {\n        const { filterParameters } = this.store.getValue();\n        const newRules: FilterParametersModel = {\n            ...filterParameters,\n            rules\n        };\n\n        await this.loadData(newRules, updateQueryParams);\n    }\n\n    public addRuleFromConfig(config: FilterConfigurationModel): void {\n        const { filterParameters } = this.store.getValue();\n\n        const newRules: FilterParametersModel = {\n            ...filterParameters,\n            rules: [\n                ...(filterParameters.rules as QueryModel[]),\n                QBFilterUtils.createQueryModel(config)\n            ]\n        };\n\n        this.store.update({\n            showQueryBuilder: true\n        });\n\n        this.loadData(newRules, true);\n    }\n\n    public updateRules(rules: QueryRuleModel[]): void {\n        const { filterParameters } = this.store.getValue();\n        const newRules: FilterParametersModel = {\n            order: filterParameters.order,\n            rules: [\n                {\n                    condition: \"and\",\n                    rules\n                }\n            ]\n        };\n\n        this.loadData(newRules, true);\n    }\n\n    public toggleQueryBuilder(): void {\n        this.store.update((state) => ({\n            showQueryBuilder: !state.showQueryBuilder\n        }));\n    }\n\n    public updateListValue(value: any, key = \"id\"): void {\n        const { filterResult } = this.store.getValue();\n        if (!filterResult) {\n            return;\n        }\n\n        this.store.update({\n            filterResult: {\n                ...filterResult,\n                values: arrayUpsert(filterResult.values, value[key], value)\n            }\n        });\n    }\n\n    public removeListValue(value: any, key = \"id\"): void {\n        const { filterResult } = this.store.getValue();\n        if (!filterResult) {\n            return;\n        }\n\n        this.store.update({\n            filterResult: {\n                ...filterResult,\n                values: arrayRemove(filterResult.values, value[key])\n            }\n        });\n    }\n\n    protected async updateQueryParams(queryParams: any): Promise<void> {\n        if (!this.activatedRoute) {\n            return;\n        }\n\n        await this.router.navigate([], {\n            relativeTo: this.activatedRoute,\n            queryParams,\n            queryParamsHandling: \"merge\"\n        });\n    }\n\n    private getParameters(filterParameters?: FilterParametersModel): FilterParametersModel {\n        const { defaultRules } = this.store.getValue();\n        const parameters = {\n            ...filterParameters,\n            rules: filterParameters?.rules ? [...filterParameters.rules] : []\n        };\n        if (defaultRules?.length) {\n            parameters.rules.push({\n                condition: \"and\",\n                rules: defaultRules\n            });\n        }\n        return parameters;\n    }\n\n    private mergeParameters(parameters?: FilterParametersModel): FilterParametersModel {\n        const { filterParameters } = this.store.getValue();\n        if (!parameters) {\n            return filterParameters;\n        }\n\n        return {\n            ...filterParameters,\n            ...parameters,\n            order:\n                filterParameters.order && !parameters.order\n                    ? undefined\n                    : {\n                        ...filterParameters.order,\n                        ...parameters.order\n                    }\n        };\n    }\n\n    private setParameters(parameters: FilterParametersModel, updateQueryParams: boolean = true): void {\n        this.store.setParameters(parameters);\n        if (updateQueryParams) {\n            this.updateQueryParams(QueryParamsUtils.filterParametersToParamsMap(parameters));\n        }\n    }\n}\n"]}

package/esm2020/lib/components/base-list/store/base-list.store.mjs

@@ -0,0 +1,81 @@
+import { __decorate, __metadata } from "tslib";
+import { Inject, Injectable, Optional } from "@angular/core";
+import { Store, StoreConfig } from "@datorama/akita";
+import { DEFAULT_PARAMETERS } from "../base-list.constant";
+import * as i0 from "@angular/core";
+export const initialBaseListState = {
+    disabled: false,
+    mergePageResults: false,
+    resetPaging: false,
+    filterConfigLoading: false,
+    filterResult: null,
+    filterParameters: {
+        start: 0,
+        length: 10,
+        order: {},
+        search: "",
+        rules: [],
+        data: {}
+    },
+    filterConfig: [],
+    showQueryBuilder: false,
+    defaultRules: []
+};
+let NiceBaseListStore = class NiceBaseListStore extends Store {
+    constructor(parameters) {
+        super({
+            ...initialBaseListState,
+            filterParameters: {
+                ...initialBaseListState.filterParameters,
+                ...(parameters ?? {})
+            }
+        });
+    }
+    setFilterConfigLoading(loading) {
+        this.update({
+            filterConfigLoading: loading
+        });
+    }
+    setResult(filterResult, reset = false) {
+        const { mergePageResults } = this.getValue();
+        if (mergePageResults && !reset) {
+            this.update((state) => ({
+                filterResult: {
+                    page: filterResult.page,
+                    total: filterResult.total,
+                    values: state.resetPaging ? filterResult.values : [
+                        ...(state.filterResult?.values ?? []),
+                        ...filterResult.values
+                    ]
+                },
+                resetPaging: false
+            }));
+        }
+        else {
+            this.update({
+                filterResult
+            });
+        }
+    }
+    setParameters(filterParameters) {
+        this.update({
+            filterParameters
+        });
+    }
+};
+NiceBaseListStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceBaseListStore, deps: [{ token: DEFAULT_PARAMETERS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+NiceBaseListStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceBaseListStore });
+NiceBaseListStore = __decorate([
+    StoreConfig({ name: "base-list", resettable: true }),
+    __metadata("design:paramtypes", [Object])
+], NiceBaseListStore);
+export { NiceBaseListStore };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: NiceBaseListStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DEFAULT_PARAMETERS]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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