@recursyve/nice-data-filter-kit 14.1.5 → 14.2.0

package/esm2020/lib/directive/selectable-list/selectable-list.directive.mjs

@@ -0,0 +1,38 @@
+import { ContentChildren, Directive, Input, QueryList } from "@angular/core";
+import { NiceSelectableListCheckboxDirective } from "./selectable-list-checkbox.directive";
+import * as i0 from "@angular/core";
+// tslint:disable-next-line:directive-class-suffix
+export class NiceSelectableListDirective {
+    constructor() {
+        this.defaultOptions = { idKey: "id", preloadWindow: 2 };
+    }
+    ngOnInit() {
+        if (!this.options) {
+            this.options = { ...this.defaultOptions };
+        }
+    }
+    ngOnChanges(changes) {
+        if ("options" in changes) {
+            this.options = {
+                ...this.defaultOptions,
+                ...changes.options.currentValue
+            };
+        }
+    }
+}
+NiceSelectableListDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+NiceSelectableListDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.3", type: NiceSelectableListDirective, selector: "[niceSelectableList]", inputs: { state: "state", options: "options" }, queries: [{ propertyName: "checkboxes", predicate: NiceSelectableListCheckboxDirective, descendants: true }], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[niceSelectableList]"
+                }]
+        }], propDecorators: { state: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], checkboxes: [{
+                type: ContentChildren,
+                args: [NiceSelectableListCheckboxDirective, { descendants: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directive/selectable-list/selectable-list.module.mjs

@@ -0,0 +1,32 @@
+import { NgModule } from "@angular/core";
+import { NiceSelectableListCheckboxDirective } from "./selectable-list-checkbox.directive";
+import { NiceSelectableListSelectAllDirective } from "./selectable-list-select-all.directive";
+import { NICE_PRELOAD_SELECTED_ENTITIES_PROVIDER } from "./selectable-list.constant";
+import { NiceSelectableListDirective } from "./selectable-list.directive";
+import { SelectableListService } from "./store/selectable-list.service";
+import * as i0 from "@angular/core";
+export class NiceSelectableListModule {
+    static register(...providers) {
+        return {
+            ngModule: NiceSelectableListModule,
+            providers: providers.map(x => ({
+                provide: NICE_PRELOAD_SELECTED_ENTITIES_PROVIDER,
+                useClass: x,
+                multi: true
+            }))
+        };
+    }
+}
+NiceSelectableListModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NiceSelectableListModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListModule, declarations: [NiceSelectableListDirective, NiceSelectableListCheckboxDirective, NiceSelectableListSelectAllDirective], exports: [NiceSelectableListDirective, NiceSelectableListCheckboxDirective, NiceSelectableListSelectAllDirective] });
+NiceSelectableListModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListModule, providers: [SelectableListService] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: NiceSelectableListModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    declarations: [NiceSelectableListDirective, NiceSelectableListCheckboxDirective, NiceSelectableListSelectAllDirective],
+                    providers: [SelectableListService],
+                    exports: [NiceSelectableListDirective, NiceSelectableListCheckboxDirective, NiceSelectableListSelectAllDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directive/selectable-list/store/selectable-list-state.service.mjs

@@ -0,0 +1,181 @@
+import { arrayAdd, arrayRemove } from "@datorama/akita";
+export class SelectableListStateService {
+    constructor(store, preloadService, options) {
+        this.store = store;
+        this.preloadService = preloadService;
+        this.options = options;
+    }
+    get idKey() {
+        return this.options?.idKey ?? "id";
+    }
+    get preloadedWindow() {
+        return this.options?.preloadWindow ?? 2;
+    }
+    setActive(entity) {
+        this.store.setActive(entity[this.idKey]);
+    }
+    getIndex(identifier) {
+        const { ids } = this.store.getValue();
+        const index = ids.indexOf(identifier);
+        return index + 1;
+    }
+    async selectAll(options) {
+        if (!this.preloadService) {
+            return this.store.update({
+                allSelected: true
+            });
+        }
+        const ids = await this.preloadService.loadAllEntities(options);
+        this.store.set(ids.map((id) => ({
+            [this.idKey]: id,
+            loaded: false
+        })));
+        return this.store.update({
+            allSelected: true
+        });
+    }
+    async select(id) {
+        this.store.update((state) => ({
+            unselectedEntity: arrayRemove(state.unselectedEntity, id)
+        }));
+        if (!this.preloadService) {
+            this.store.add({
+                [this.idKey]: id,
+                loaded: false
+            });
+        }
+        const entity = await this.preloadService.loadEntityById(id);
+        return this.store.add({
+            ...entity,
+            loaded: true
+        });
+    }
+    async selectEntity(entity) {
+        this.store.update((state) => ({
+            unselectedEntity: arrayRemove(state.unselectedEntity, entity[this.idKey])
+        }));
+        if (!this.preloadService) {
+            return this.store.upsert(entity[this.idKey], { ...entity, loaded: true });
+        }
+        const preloadedEntity = await this.preloadService.reloadEntity(entity);
+        return this.store.upsert(preloadedEntity[this.idKey], { ...preloadedEntity, loaded: true });
+    }
+    async selectManyEntities(entities) {
+        if (!this.preloadService) {
+            return this.store.upsertMany(entities.map((entity) => ({ ...entity, loaded: true })));
+        }
+        const preloadedEntities = await this.preloadService.reloadEntities(entities);
+        return this.store.upsertMany(preloadedEntities.map((preloadedEntity) => ({ ...preloadedEntity, loaded: true })));
+    }
+    unselectAll() {
+        this.store.set([]);
+        return this.store.update({
+            allSelected: false,
+            unselectedEntity: []
+        });
+    }
+    unselect(id) {
+        this.store.update((state) => ({
+            unselectedEntity: arrayAdd(state.unselectedEntity, id)
+        }));
+        this.store.remove(id);
+    }
+    unselectEntity(entity) {
+        this.store.update((state) => ({
+            unselectedEntity: arrayAdd(state.unselectedEntity, entity[this.idKey])
+        }));
+        this.store.remove(entity[this.idKey]);
+    }
+    unselectManyEntities(entities) {
+        this.store.remove(entities.map((entity) => entity[this.idKey]));
+    }
+    async setEntities(ids, activeId) {
+        this.store.update({
+            unselectedEntity: [],
+            allSelected: false
+        });
+        this.store.set(ids.map((id) => ({
+            [this.idKey]: id,
+            loaded: false
+        })));
+        if (activeId) {
+            this.store.setActive(activeId);
+        }
+    }
+    async next() {
+        const { ids, active } = this.store.getValue();
+        const index = ids.indexOf(active);
+        await this.loadActiveEntity(ids[index + 1], 1);
+    }
+    async previous() {
+        const { ids, active } = this.store.getValue();
+        const index = ids.indexOf(active);
+        await this.loadActiveEntity(ids[index - 1], -1);
+    }
+    async first() {
+        const { ids } = this.store.getValue();
+        await this.loadActiveEntity(ids[0], 1);
+    }
+    async last() {
+        const { ids } = this.store.getValue();
+        await this.loadActiveEntity(ids[ids.length - 1], -1);
+    }
+    async removeActive() {
+        const { active, ids } = this.store.getValue();
+        const index = ids.indexOf(active);
+        this.store.remove(active);
+        if (index === (ids.length - 1)) {
+            await this.loadActiveEntity(ids[index - 1], -1);
+        }
+        else {
+            await this.loadActiveEntity(ids[index + 1], 1);
+        }
+    }
+    async loadActiveEntity(id, direction) {
+        try {
+            this.store.setActive(id);
+            const { entities } = this.store.getValue();
+            if (!entities[+id + direction * this.preloadedWindow]?.loaded) {
+                await this.loadEntities(false);
+            }
+        }
+        catch (e) {
+            this.store.setError(e);
+        }
+    }
+    async loadEntities(loadExtremity) {
+        if (!this.preloadService) {
+            return;
+        }
+        const toLoad = this.getListIdToLoad(loadExtremity);
+        if (!toLoad.length) {
+            return;
+        }
+        const entities = await this.preloadService.loadEntitiesById(toLoad);
+        this.store.upsertMany(entities.map((entity) => ({ ...entity, loaded: true })));
+    }
+    getListIdToLoad(loadExtremity) {
+        const { active, ids, entities } = this.store.getValue();
+        const from = ids.indexOf(active) - this.preloadedWindow > 0 ? ids.indexOf(active) - this.preloadedWindow : 0;
+        const to = ids.indexOf(active) + this.preloadedWindow < ids.length - 1
+            ? ids.indexOf(active) + this.preloadedWindow
+            : ids.length - 1;
+        const toLoad = [];
+        if (loadExtremity) {
+            if (ids.length <= 2) {
+                return ids;
+            }
+            toLoad.push(ids[0], ids[ids.length - 1]);
+        }
+        for (let i = from; i <= to; i++) {
+            if (ids[i] === null || ids[0] === undefined) {
+                continue;
+            }
+            if (!toLoad.includes(ids[i]) && !entities[ids[i]]?.loaded) {
+                toLoad.push(ids[i]);
+            }
+        }
+        return toLoad;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selectable-list-state.service.js","sourceRoot":"","sources":["../../../../../../../projects/nice-data-filter-kit/src/lib/directive/selectable-list/store/selectable-list-state.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { arrayAdd, arrayRemove, EntityStore } from \"@datorama/akita\";\nimport { NiceSelectableListLoadAllEntitiesOptions } from \"../model/load-all-entities-options.model\";\nimport { NiceSelectableListOptions } from \"../model/selectable-list-options.model\";\nimport { NicePreloadSelectedEntitiesProvider } from \"../providers/preload-selected-entities.provider\";\nimport { SelectableListState } from \"./selectable-list.state\";\n\nexport class SelectableListStateService<T, ID = any> {\n    public get idKey(): string {\n        return this.options?.idKey ?? \"id\";\n    }\n\n    public get preloadedWindow(): number {\n        return this.options?.preloadWindow ?? 2;\n    }\n\n    constructor(\n        private store: EntityStore<SelectableListState<any>>,\n        private preloadService?: NicePreloadSelectedEntitiesProvider<T>,\n        private options?: NiceSelectableListOptions\n    ) {}\n\n    public setActive(entity: T): void {\n        this.store.setActive(entity[this.idKey]);\n    }\n\n    public getIndex(identifier: number): number {\n        const { ids } = this.store.getValue();\n        const index = ids.indexOf(identifier);\n        return index + 1;\n    }\n\n    public async selectAll(options?: NiceSelectableListLoadAllEntitiesOptions): Promise<void> {\n        if (!this.preloadService) {\n            return this.store.update({\n                allSelected: true\n            });\n        }\n\n        const ids = await this.preloadService.loadAllEntities(options);\n        this.store.set(ids.map((id) => ({\n            [this.idKey]: id,\n            loaded: false\n        })));\n\n        return this.store.update({\n            allSelected: true\n        });\n    }\n\n    public async select(id: ID): Promise<void> {\n        this.store.update((state) => ({\n            unselectedEntity: arrayRemove(state.unselectedEntity, id as any)\n        }));\n\n        if (!this.preloadService) {\n            this.store.add({\n                [this.idKey]: id,\n                loaded: false\n            });\n        }\n\n        const entity = await this.preloadService.loadEntityById(id as any);\n        return this.store.add({\n            ...entity,\n            loaded: true\n        });\n    }\n\n    public async selectEntity(entity: T): Promise<void> {\n        this.store.update((state) => ({\n            unselectedEntity: arrayRemove(state.unselectedEntity, entity[this.idKey])\n        }));\n\n        if (!this.preloadService) {\n            return this.store.upsert(entity[this.idKey], { ...entity, loaded: true });\n        }\n\n        const preloadedEntity = await this.preloadService.reloadEntity(entity);\n        return this.store.upsert(preloadedEntity[this.idKey], { ...preloadedEntity, loaded: true });\n    }\n\n    public async selectManyEntities(entities: T[]): Promise<void> {\n        if (!this.preloadService) {\n            return this.store.upsertMany(entities.map((entity) => ({ ...entity, loaded: true })));\n        }\n\n        const preloadedEntities = await this.preloadService.reloadEntities(entities);\n        return this.store.upsertMany(preloadedEntities.map((preloadedEntity) => ({ ...preloadedEntity, loaded: true })));\n    }\n\n    public unselectAll(): void {\n        this.store.set([]);\n\n        return this.store.update({\n            allSelected: false,\n            unselectedEntity: []\n        });\n    }\n\n    public unselect(id: ID): void {\n        this.store.update((state) => ({\n            unselectedEntity: arrayAdd(state.unselectedEntity, id)\n        }));\n\n        this.store.remove(id as any);\n    }\n\n    public unselectEntity(entity: T): void {\n        this.store.update((state) => ({\n            unselectedEntity: arrayAdd(state.unselectedEntity, entity[this.idKey])\n        }));\n\n        this.store.remove(entity[this.idKey]);\n    }\n\n    public unselectManyEntities(entities: T[]): void {\n        this.store.remove(entities.map((entity) => entity[this.idKey]));\n    }\n\n    public async setEntities(ids: ID[], activeId: ID): Promise<void> {\n        this.store.update({\n            unselectedEntity: [],\n            allSelected: false\n        });\n\n        this.store.set(ids.map((id) => ({\n            [this.idKey]: id,\n            loaded: false\n        })));\n\n        if (activeId) {\n            this.store.setActive(activeId);\n        }\n    }\n\n    public async next(): Promise<void> {\n        const { ids, active } = this.store.getValue();\n        const index = ids.indexOf(active);\n        await this.loadActiveEntity(ids[index + 1], 1);\n    }\n\n    public async previous(): Promise<void> {\n        const { ids, active } = this.store.getValue();\n        const index = ids.indexOf(active);\n        await this.loadActiveEntity(ids[index - 1], -1);\n    }\n\n    public async first(): Promise<void> {\n        const { ids } = this.store.getValue();\n        await this.loadActiveEntity(ids[0], 1);\n    }\n\n    public async last(): Promise<void> {\n        const { ids } = this.store.getValue();\n        await this.loadActiveEntity(ids[ids.length - 1], -1);\n    }\n\n    public async removeActive(): Promise<void> {\n        const { active, ids } = this.store.getValue();\n        const index = ids.indexOf(active);\n\n        this.store.remove(active);\n\n        if (index === (ids.length - 1)) {\n            await this.loadActiveEntity(ids[index - 1], -1);\n        } else {\n            await this.loadActiveEntity(ids[index + 1], 1);\n        }\n    }\n\n    public async loadActiveEntity(id: number, direction: number) {\n        try {\n            this.store.setActive(id);\n\n            const { entities } = this.store.getValue();\n            if (!entities[+id + direction * this.preloadedWindow]?.loaded) {\n                await this.loadEntities(false);\n            }\n        } catch (e) {\n            this.store.setError(e);\n        }\n    }\n\n    public async loadEntities(loadExtremity): Promise<void> {\n        if (!this.preloadService) {\n            return;\n        }\n\n        const toLoad = this.getListIdToLoad(loadExtremity);\n        if (!toLoad.length) {\n            return;\n        }\n\n        const entities = await this.preloadService.loadEntitiesById(toLoad);\n        this.store.upsertMany(entities.map((entity) => ({ ...entity, loaded: true })));\n    }\n\n    public getListIdToLoad(loadExtremity: boolean): number[] {\n        const { active, ids, entities } = this.store.getValue();\n        const from = ids.indexOf(active) - this.preloadedWindow > 0 ? ids.indexOf(active) - this.preloadedWindow : 0;\n        const to = ids.indexOf(active) + this.preloadedWindow < ids.length - 1\n            ? ids.indexOf(active) + this.preloadedWindow\n            : ids.length - 1;\n\n        const toLoad = [];\n        if (loadExtremity) {\n            if (ids.length <= 2) {\n                return ids;\n            }\n\n            toLoad.push(ids[0], ids[ids.length - 1]);\n        }\n\n        for (let i = from; i <= to; i++) {\n            if (ids[i] === null || ids[0] === undefined) {\n                continue;\n            }\n\n            if (!toLoad.includes(ids[i]) && !entities[ids[i]]?.loaded) {\n                toLoad.push(ids[i]);\n            }\n        }\n\n        return toLoad;\n    }\n}\n"]}

package/esm2020/lib/directive/selectable-list/store/selectable-list.service.mjs

@@ -0,0 +1,49 @@
+import { Inject, Injectable, Optional } from "@angular/core";
+import { EntityStore, QueryEntity } from "@datorama/akita";
+import { NICE_PRELOAD_SELECTED_ENTITIES_PROVIDER } from "../selectable-list.constant";
+import { SelectableListStateService } from "./selectable-list-state.service";
+import * as i0 from "@angular/core";
+export class SelectableListService {
+    constructor(providers) {
+        this.providers = providers;
+        this.stores = new Map();
+    }
+    createState(name, options) {
+        const store = new EntityStore({ allSelected: false, unselectedEntity: [] }, { name, idKey: options?.idKey });
+        const query = new QueryEntity(store);
+        const state = { store, query };
+        this.stores.set(name, state);
+        return state;
+    }
+    getState(name) {
+        return this.stores.get(name);
+    }
+    withState(stateName, options) {
+        const provider = this.providers?.find((p) => p.state === stateName);
+        const state = this.getState(stateName);
+        if (state) {
+            return new SelectableListStateService(state.store, provider, options);
+        }
+        const newState = this.createState(stateName, options);
+        return new SelectableListStateService(newState.store, provider, options);
+    }
+    query(stateName) {
+        const state = this.getState(stateName);
+        if (!state) {
+            throw new Error("No state found");
+        }
+        return state.query;
+    }
+}
+SelectableListService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: SelectableListService, deps: [{ token: NICE_PRELOAD_SELECTED_ENTITIES_PROVIDER, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+SelectableListService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: SelectableListService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.3", ngImport: i0, type: SelectableListService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [NICE_PRELOAD_SELECTED_ENTITIES_PROVIDER]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directive/selectable-list/store/selectable-list.state.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0YWJsZS1saXN0LnN0YXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmljZS1kYXRhLWZpbHRlci1raXQvc3JjL2xpYi9kaXJlY3RpdmUvc2VsZWN0YWJsZS1saXN0L3N0b3JlL3NlbGVjdGFibGUtbGlzdC5zdGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWN0aXZlU3RhdGUsIEVudGl0eVN0YXRlIH0gZnJvbSBcIkBkYXRvcmFtYS9ha2l0YVwiO1xuXG5leHBvcnQgdHlwZSBTZWxlY3RhYmxlTGlzdEVudGl0eTxUPiA9IFQgJiB7IGxvYWRlZD86IGJvb2xlYW4gfTtcblxuZXhwb3J0IGludGVyZmFjZSBTZWxlY3RhYmxlTGlzdFN0YXRlPFQ+IGV4dGVuZHMgRW50aXR5U3RhdGU8U2VsZWN0YWJsZUxpc3RFbnRpdHk8VD4sIG51bWJlcj4sIEFjdGl2ZVN0YXRlPGFueT4ge1xuICAgIGFsbFNlbGVjdGVkOiBib29sZWFuO1xuICAgIHVuc2VsZWN0ZWRFbnRpdHk6IGFueVtdO1xufVxuIl19

package/esm2020/lib/utils/query-params.utils.mjs

@@ -2,7 +2,7 @@ import { HttpParams } from "@angular/common/http";
 import { isNullOrUndefined } from "@recursyve/nice-ui-kit.v2";
 export class QueryParamsUtils {
     static hasFilterParameters(params) {
-        const keys = ["start", "length", "order", "fallbackOrder", "search", "rules"];
+        const keys = ["start", "length", "order", "search", "rules"];
         return Object.keys(params).some(key => keys.includes(key));
     }
     static extractFilterParameters(params) {
@@ -21,14 +21,6 @@ export class QueryParamsUtils {
                 delete filters.order;
             }
         }
-        if (!isNullOrUndefined(params.fallbackOrder)) {
-            try {
-                filters.fallbackOrder = JSON.parse(params.fallbackOrder);
-            }
-            catch (e) {
-                delete filters.fallbackOrder;
-            }
-        }
         if (!isNullOrUndefined(params.search)) {
             filters.search = params.search;
         }
@@ -56,12 +48,6 @@ export class QueryParamsUtils {
         else {
             params.order = null;
         }
-        if (!isNullOrUndefined(filterParameters.fallbackOrder)) {
-            params.fallbackOrder = JSON.stringify(filterParameters.fallbackOrder);
-        }
-        else {
-            params.fallbackOrder = null;
-        }
         if (!isNullOrUndefined(filterParameters.search)) {
             params.search = filterParameters.search;
         }
@@ -81,4 +67,4 @@ export class QueryParamsUtils {
         }).toString();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/public-api.mjs

@@ -3,6 +3,7 @@
  */
 export * from "./lib/api/public-api";
 export * from "./lib/components/public-api";
+export * from "./lib/directive/public-api";
 export * from "./lib/models/public-api";
 export * from "./lib/utils/public-api";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25pY2UtZGF0YS1maWx0ZXIta2l0L3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgbmljZS1kYXRhLWZpbHRlci1raXRcbiAqL1xuXG5leHBvcnQgKiBmcm9tIFwiLi9saWIvYXBpL3B1YmxpYy1hcGlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xpYi9jb21wb25lbnRzL3B1YmxpYy1hcGlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xpYi9tb2RlbHMvcHVibGljLWFwaVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL3V0aWxzL3B1YmxpYy1hcGlcIjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25pY2UtZGF0YS1maWx0ZXIta2l0L3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBuaWNlLWRhdGEtZmlsdGVyLWtpdFxuICovXG5cbmV4cG9ydCAqIGZyb20gXCIuL2xpYi9hcGkvcHVibGljLWFwaVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL2NvbXBvbmVudHMvcHVibGljLWFwaVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL2RpcmVjdGl2ZS9wdWJsaWMtYXBpXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9saWIvbW9kZWxzL3B1YmxpYy1hcGlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xpYi91dGlscy9wdWJsaWMtYXBpXCI7XG4iXX0=