@wizishop/img-manager 18.2.0 → 18.2.2-beta

package/esm2022/lib/services/img-selection.service.mjs

@@ -0,0 +1,75 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ImgSelectionService {
+    multipleImgMode = false;
+    imgSelection$ = new BehaviorSubject([]);
+    imgSelectedListLoading$ = new BehaviorSubject(false);
+    constructor() { }
+    getImgSelection() {
+        return this.imgSelection$.getValue();
+    }
+    // Use in img manager webelement, when the product img selection is retrieved
+    setImgSelection(imgSelectedList) {
+        this.imgSelection$.next(imgSelectedList || []);
+    }
+    addImgSelected(picture) {
+        if (this.multipleImgMode) {
+            this.imgSelection$.next([...this.imgSelection$.getValue(), picture]);
+        }
+        else {
+            this.imgSelection$.next([picture]);
+        }
+    }
+    removeImgSelectedByIndex(index) {
+        const imgSelectedList = this.imgSelection$.getValue();
+        imgSelectedList.splice(index, 1);
+        this.imgSelection$.next(imgSelectedList);
+    }
+    removeImgSelectedById(id_file) {
+        if (!this.multipleImgMode) {
+            this.imgSelection$.next([]);
+            return;
+        }
+        this.imgSelection$.next(this.imgSelection$.getValue().filter(img => img.id_file !== id_file));
+    }
+    removeImgSelectionByIds(id_file_list) {
+        if (!this.multipleImgMode) {
+            this.imgSelection$.next([]);
+            return;
+        }
+        this.imgSelection$.next(this.imgSelection$.getValue().filter(img => id_file_list.includes(img.id_file)));
+    }
+    removeAllImgSelected() {
+        this.imgSelection$.next([]);
+    }
+    setMultipleImgMode(activated) {
+        this.multipleImgMode = activated;
+    }
+    initImgSelectedList(imgSelectedList) {
+        // Retrieve the imgSelectedList from parameter
+        if (imgSelectedList) {
+            this.imgSelection$.next(imgSelectedList);
+            return;
+        }
+        this.imgSelection$.next([]);
+    }
+    /**
+     * Use angular cdk function
+     * Called by img selection component
+     * @param event
+     */
+    moveImgOrder(event) {
+        const fromIndex = event.previousIndex;
+        const toIndex = event.currentIndex;
+        const imgSelectedList = this.imgSelection$.getValue();
+        imgSelectedList.splice(toIndex, 0, imgSelectedList.splice(fromIndex, 1)[0]);
+        this.imgSelection$.next(imgSelectedList);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ImgSelectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ImgSelectionService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ImgSelectionService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1nLXNlbGVjdGlvbi5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvd3otaW1nLW1hbmFnZXIvc3JjL2xpYi9zZXJ2aWNlcy9pbWctc2VsZWN0aW9uLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBc0IsTUFBTSxlQUFlLENBQUM7QUFFL0QsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLE1BQU0sQ0FBQzs7QUFJdkMsTUFBTSxPQUFPLG1CQUFtQjtJQUU1QixlQUFlLEdBQVksS0FBSyxDQUFDO0lBQ2pDLGFBQWEsR0FBcUMsSUFBSSxlQUFlLENBQWtCLEVBQUUsQ0FBQyxDQUFDO0lBQzNGLHVCQUF1QixHQUE2QixJQUFJLGVBQWUsQ0FBVSxLQUFLLENBQUMsQ0FBQztJQUV4RixnQkFBZSxDQUFDO0lBRWhCLGVBQWU7UUFDWCxPQUFPLElBQUksQ0FBQyxhQUFhLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDekMsQ0FBQztJQUVELDZFQUE2RTtJQUM3RSxlQUFlLENBQUMsZUFBZ0M7UUFDNUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsZUFBZSxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQ25ELENBQUM7SUFFRCxjQUFjLENBQUMsT0FBdUI7UUFDbEMsSUFBSSxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7WUFDdkIsSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsUUFBUSxFQUFFLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQztRQUN6RSxDQUFDO2FBQU0sQ0FBQztZQUNKLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztRQUN2QyxDQUFDO0lBQ0wsQ0FBQztJQUVELHdCQUF3QixDQUFDLEtBQWE7UUFDbEMsTUFBTSxlQUFlLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUN0RCxlQUFlLENBQUMsTUFBTSxDQUFDLEtBQUssRUFBRSxDQUFDLENBQUMsQ0FBQztRQUNqQyxJQUFJLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsQ0FBQztJQUU3QyxDQUFDO0lBRUQscUJBQXFCLENBQUMsT0FBZTtRQUNqQyxJQUFJLENBQUMsSUFBSSxDQUFDLGVBQWUsRUFBRSxDQUFDO1lBQ3hCLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1lBQzVCLE9BQU87UUFDWCxDQUFDO1FBQ0QsSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsT0FBTyxLQUFLLE9BQU8sQ0FBQyxDQUFDLENBQUM7SUFDbEcsQ0FBQztJQUVELHVCQUF1QixDQUFDLFlBQXNCO1FBQzFDLElBQUksQ0FBQyxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7WUFDeEIsSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUM7WUFDNUIsT0FBTztRQUNYLENBQUM7UUFDRCxJQUFJLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLFFBQVEsRUFBRSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUM3RyxDQUFDO0lBRUQsb0JBQW9CO1FBQ2hCLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ2hDLENBQUM7SUFFRCxrQkFBa0IsQ0FBQyxTQUFrQjtRQUNqQyxJQUFJLENBQUMsZUFBZSxHQUFHLFNBQVMsQ0FBQztJQUNyQyxDQUFDO0lBRUQsbUJBQW1CLENBQUMsZUFBZ0M7UUFDaEQsOENBQThDO1FBQzlDLElBQUksZUFBZSxFQUFFLENBQUM7WUFDbEIsSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUM7WUFDekMsT0FBTztRQUNYLENBQUM7UUFDRCxJQUFJLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUNoQyxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILFlBQVksQ0FBQyxLQUE0QjtRQUNyQyxNQUFNLFNBQVMsR0FBRyxLQUFLLENBQUMsYUFBYSxDQUFDO1FBQ3RDLE1BQU0sT0FBTyxHQUFHLEtBQUssQ0FBQyxZQUFZLENBQUM7UUFDbkMsTUFBTSxlQUFlLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUN0RCxlQUFlLENBQUMsTUFBTSxDQUFDLE9BQU8sRUFBRSxDQUFDLEVBQUUsZUFBZSxDQUFDLE1BQU0sQ0FBQyxTQUFTLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUM1RSxJQUFJLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsQ0FBQztJQUM3QyxDQUFDO3VHQTVFUSxtQkFBbUI7MkdBQW5CLG1CQUFtQjs7MkZBQW5CLG1CQUFtQjtrQkFEL0IsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUsIE9wdGlvbmFsLCBTa2lwU2VsZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBJbWdQaWN0dXJlRFRPIH0gZnJvbSAnLi4vZHRvL2ltZy1tYW5hZ2VyLmR0byc7XHJcbmltcG9ydCB7IEJlaGF2aW9yU3ViamVjdCB9IGZyb20gJ3J4anMnO1xyXG5pbXBvcnQgeyBDZGtEcmFnRHJvcCB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9kcmFnLWRyb3AnO1xyXG5cclxuQEluamVjdGFibGUoKVxyXG5leHBvcnQgY2xhc3MgSW1nU2VsZWN0aW9uU2VydmljZSB7XHJcblxyXG4gICAgbXVsdGlwbGVJbWdNb2RlOiBib29sZWFuID0gZmFsc2U7XHJcbiAgICBpbWdTZWxlY3Rpb24kOiBCZWhhdmlvclN1YmplY3Q8SW1nUGljdHVyZURUT1tdPiA9IG5ldyBCZWhhdmlvclN1YmplY3Q8SW1nUGljdHVyZURUT1tdPihbXSk7XHJcbiAgICBpbWdTZWxlY3RlZExpc3RMb2FkaW5nJDogQmVoYXZpb3JTdWJqZWN0PGJvb2xlYW4+ID0gbmV3IEJlaGF2aW9yU3ViamVjdDxib29sZWFuPihmYWxzZSk7XHJcblxyXG4gICAgY29uc3RydWN0b3IoKSB7fVxyXG5cclxuICAgIGdldEltZ1NlbGVjdGlvbigpIHtcclxuICAgICAgICByZXR1cm4gdGhpcy5pbWdTZWxlY3Rpb24kLmdldFZhbHVlKCk7XHJcbiAgICB9XHJcblxyXG4gICAgLy8gVXNlIGluIGltZyBtYW5hZ2VyIHdlYmVsZW1lbnQsIHdoZW4gdGhlIHByb2R1Y3QgaW1nIHNlbGVjdGlvbiBpcyByZXRyaWV2ZWRcclxuICAgIHNldEltZ1NlbGVjdGlvbihpbWdTZWxlY3RlZExpc3Q6IEltZ1BpY3R1cmVEVE9bXSkge1xyXG4gICAgICAgIHRoaXMuaW1nU2VsZWN0aW9uJC5uZXh0KGltZ1NlbGVjdGVkTGlzdCB8fCBbXSk7XHJcbiAgICB9XHJcblxyXG4gICAgYWRkSW1nU2VsZWN0ZWQocGljdHVyZSA6IEltZ1BpY3R1cmVEVE8pIHtcclxuICAgICAgICBpZiAodGhpcy5tdWx0aXBsZUltZ01vZGUpIHtcclxuICAgICAgICAgICAgdGhpcy5pbWdTZWxlY3Rpb24kLm5leHQoWy4uLnRoaXMuaW1nU2VsZWN0aW9uJC5nZXRWYWx1ZSgpLCBwaWN0dXJlXSk7XHJcbiAgICAgICAgfSBlbHNlIHtcclxuICAgICAgICAgICAgdGhpcy5pbWdTZWxlY3Rpb24kLm5leHQoW3BpY3R1cmVdKTtcclxuICAgICAgICB9XHJcbiAgICB9XHJcblxyXG4gICAgcmVtb3ZlSW1nU2VsZWN0ZWRCeUluZGV4KGluZGV4OiBudW1iZXIpIHtcclxuICAgICAgICBjb25zdCBpbWdTZWxlY3RlZExpc3QgPSB0aGlzLmltZ1NlbGVjdGlvbiQuZ2V0VmFsdWUoKTtcclxuICAgICAgICBpbWdTZWxlY3RlZExpc3Quc3BsaWNlKGluZGV4LCAxKTtcclxuICAgICAgICB0aGlzLmltZ1NlbGVjdGlvbiQubmV4dChpbWdTZWxlY3RlZExpc3QpO1xyXG5cclxuICAgIH1cclxuXHJcbiAgICByZW1vdmVJbWdTZWxlY3RlZEJ5SWQoaWRfZmlsZTogc3RyaW5nKSB7XHJcbiAgICAgICAgaWYgKCF0aGlzLm11bHRpcGxlSW1nTW9kZSkge1xyXG4gICAgICAgICAgICB0aGlzLmltZ1NlbGVjdGlvbiQubmV4dChbXSk7XHJcbiAgICAgICAgICAgIHJldHVybjtcclxuICAgICAgICB9XHJcbiAgICAgICAgdGhpcy5pbWdTZWxlY3Rpb24kLm5leHQodGhpcy5pbWdTZWxlY3Rpb24kLmdldFZhbHVlKCkuZmlsdGVyKGltZyA9PiBpbWcuaWRfZmlsZSAhPT0gaWRfZmlsZSkpO1xyXG4gICAgfVxyXG5cclxuICAgIHJlbW92ZUltZ1NlbGVjdGlvbkJ5SWRzKGlkX2ZpbGVfbGlzdDogc3RyaW5nW10pIHtcclxuICAgICAgICBpZiAoIXRoaXMubXVsdGlwbGVJbWdNb2RlKSB7XHJcbiAgICAgICAgICAgIHRoaXMuaW1nU2VsZWN0aW9uJC5uZXh0KFtdKTtcclxuICAgICAgICAgICAgcmV0dXJuO1xyXG4gICAgICAgIH1cclxuICAgICAgICB0aGlzLmltZ1NlbGVjdGlvbiQubmV4dCh0aGlzLmltZ1NlbGVjdGlvbiQuZ2V0VmFsdWUoKS5maWx0ZXIoaW1nID0+IGlkX2ZpbGVfbGlzdC5pbmNsdWRlcyhpbWcuaWRfZmlsZSkpKTtcclxuICAgIH1cclxuXHJcbiAgICByZW1vdmVBbGxJbWdTZWxlY3RlZCgpIHsgLy8gVE9ETyB0ZXN0IGl0XHJcbiAgICAgICAgdGhpcy5pbWdTZWxlY3Rpb24kLm5leHQoW10pO1xyXG4gICAgfVxyXG5cclxuICAgIHNldE11bHRpcGxlSW1nTW9kZShhY3RpdmF0ZWQ6IGJvb2xlYW4pIHtcclxuICAgICAgICB0aGlzLm11bHRpcGxlSW1nTW9kZSA9IGFjdGl2YXRlZDtcclxuICAgIH1cclxuXHJcbiAgICBpbml0SW1nU2VsZWN0ZWRMaXN0KGltZ1NlbGVjdGVkTGlzdDogSW1nUGljdHVyZURUT1tdKSB7XHJcbiAgICAgICAgLy8gUmV0cmlldmUgdGhlIGltZ1NlbGVjdGVkTGlzdCBmcm9tIHBhcmFtZXRlclxyXG4gICAgICAgIGlmIChpbWdTZWxlY3RlZExpc3QpIHtcclxuICAgICAgICAgICAgdGhpcy5pbWdTZWxlY3Rpb24kLm5leHQoaW1nU2VsZWN0ZWRMaXN0KTtcclxuICAgICAgICAgICAgcmV0dXJuO1xyXG4gICAgICAgIH1cclxuICAgICAgICB0aGlzLmltZ1NlbGVjdGlvbiQubmV4dChbXSk7XHJcbiAgICB9XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBVc2UgYW5ndWxhciBjZGsgZnVuY3Rpb25cclxuICAgICAqIENhbGxlZCBieSBpbWcgc2VsZWN0aW9uIGNvbXBvbmVudFxyXG4gICAgICogQHBhcmFtIGV2ZW50XHJcbiAgICAgKi9cclxuICAgIG1vdmVJbWdPcmRlcihldmVudDogQ2RrRHJhZ0Ryb3A8c3RyaW5nW10+KSB7XHJcbiAgICAgICAgY29uc3QgZnJvbUluZGV4ID0gZXZlbnQucHJldmlvdXNJbmRleDtcclxuICAgICAgICBjb25zdCB0b0luZGV4ID0gZXZlbnQuY3VycmVudEluZGV4O1xyXG4gICAgICAgIGNvbnN0IGltZ1NlbGVjdGVkTGlzdCA9IHRoaXMuaW1nU2VsZWN0aW9uJC5nZXRWYWx1ZSgpO1xyXG4gICAgICAgIGltZ1NlbGVjdGVkTGlzdC5zcGxpY2UodG9JbmRleCwgMCwgaW1nU2VsZWN0ZWRMaXN0LnNwbGljZShmcm9tSW5kZXgsIDEpWzBdKTtcclxuICAgICAgICB0aGlzLmltZ1NlbGVjdGlvbiQubmV4dChpbWdTZWxlY3RlZExpc3QpO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2022/lib/services/pexels.service.mjs

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { map } from "rxjs/operators";
+import { TranslateService } from '@ngx-translate/core';
+import { ApiService } from './api.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./api.service";
+import * as i3 from "@ngx-translate/core";
+export class PexelsService {
+    http;
+    apiService;
+    translateService;
+    get apiBaseUrl() {
+        return this.apiService.CONFIG.pexels_route;
+    }
+    ;
+    get apiKey() {
+        return this.apiService.CONFIG.pexels_token;
+    }
+    lang;
+    languages = { 'fr': 'fr-FR', 'en': 'en-US', 'it': 'it-IT', 'es': 'es-ES' };
+    constructor(http, apiService, translateService) {
+        this.http = http;
+        this.apiService = apiService;
+        this.translateService = translateService;
+        this.setLang(this.translateService.currentLang);
+        this.translateService.onLangChange.subscribe(langData => {
+            this.setLang(langData.lang);
+        });
+    }
+    setLang(lang) {
+        this.lang = this.languages[lang] ? this.languages[lang] : 'fr-FR';
+    }
+    searchOnPexels(toSearch, perPage, page) {
+        const httpOptions = {
+            headers: new HttpHeaders({
+                Authorization: this.apiKey
+            })
+        };
+        let request;
+        // If search value is not empty or blank
+        if (toSearch && !/^\s*$/.test(toSearch)) {
+            request = `/search?query=${toSearch}&per_page=${perPage}&page=${page}&locale=${this.lang}`;
+        }
+        else { // Search by category or display Pexels selection
+            const shopCategory = this.apiService.getShopCategory();
+            // Search by shop category
+            if (shopCategory && shopCategory !== 'other' && shopCategory !== 'btob' && shopCategory !== 'default') {
+                request = `/search?query=${shopCategory}&per_page=${perPage}&page=${page}&locale=en-US`;
+            }
+            else { // Display Pexels selection
+                request = `/curated?per_page=${perPage}&page=${page}`;
+            }
+        }
+        return this.http.get(this.apiBaseUrl + request, httpOptions).pipe(map((data) => {
+            return data;
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: PexelsService, deps: [{ token: i1.HttpClient }, { token: i2.ApiService }, { token: i3.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: PexelsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: PexelsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ApiService }, { type: i3.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/rename-picture.service.mjs

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+import { AlertService } from './alert.service';
+import { ApiService } from './api.service';
+import { ImgManagerService } from './img-manager.service';
+import { tap } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./api.service";
+import * as i2 from "./alert.service";
+import * as i3 from "./img-manager.service";
+export class RenamePictureService {
+    apiService;
+    alertService;
+    imgManagerService;
+    picturesList = [];
+    errorRenameImg = 'ImgManager.ImgList.errorRenameImg';
+    msgSavingImgName = 'ImgManager.ImgLib.savingImgName';
+    msgImgNameSaved = 'ImgManager.ImgLib.imgNameSaved';
+    constructor(apiService, alertService, imgManagerService) {
+        this.apiService = apiService;
+        this.alertService = alertService;
+        this.imgManagerService = imgManagerService;
+    }
+    setPicturesList(picturesList) {
+        this.picturesList = picturesList;
+    }
+    renamePicture(pictureNameUpdate) {
+        const picture = this.getPictureById(pictureNameUpdate.id);
+        if (!picture) {
+            this.alertService.openAlert(this.errorRenameImg);
+            return;
+        }
+        this.alertService.openAlert(this.msgSavingImgName);
+        this.apiService
+            .changeImgName(picture.display_name, picture.id_file).pipe(tap(() => this.imgManagerService.refreshImageList$.next()))
+            .subscribe({
+            next: (data) => {
+                picture.display_name = data.display_name;
+                this.alertService.openAlert(this.msgImgNameSaved);
+            },
+            error: () => {
+                picture.display_name = pictureNameUpdate.previousName;
+                this.alertService.openAlert(this.errorRenameImg);
+            }
+        });
+    }
+    changeImageName(name, idFile) {
+        return this.apiService.changeImgName(name, idFile).pipe(tap(() => this.imgManagerService.refreshImageList$.next()));
+    }
+    getPictureById(id_file) {
+        if (!this.picturesList) {
+            return;
+        }
+        for (const picture of this.picturesList) {
+            if (picture.id_file === id_file) {
+                return picture;
+            }
+        }
+        return null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: RenamePictureService, deps: [{ token: i1.ApiService }, { token: i2.AlertService }, { token: i3.ImgManagerService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: RenamePictureService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: RenamePictureService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.ApiService }, { type: i2.AlertService }, { type: i3.ImgManagerService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVuYW1lLXBpY3R1cmUuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3d6LWltZy1tYW5hZ2VyL3NyYy9saWIvc2VydmljZXMvcmVuYW1lLXBpY3R1cmUuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUcvQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQzFELE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxNQUFNLENBQUM7Ozs7O0FBRzNCLE1BQU0sT0FBTyxvQkFBb0I7SUFRbkI7SUFDQTtJQUNBO0lBUkYsWUFBWSxHQUFvQixFQUFFLENBQUM7SUFDbkMsY0FBYyxHQUFHLG1DQUFtQyxDQUFDO0lBQ3JELGdCQUFnQixHQUFHLGlDQUFpQyxDQUFDO0lBQ3JELGVBQWUsR0FBRyxnQ0FBZ0MsQ0FBQztJQUUzRCxZQUNVLFVBQXNCLEVBQ3RCLFlBQTBCLEVBQzFCLGlCQUFvQztRQUZwQyxlQUFVLEdBQVYsVUFBVSxDQUFZO1FBQ3RCLGlCQUFZLEdBQVosWUFBWSxDQUFjO1FBQzFCLHNCQUFpQixHQUFqQixpQkFBaUIsQ0FBbUI7SUFFN0MsQ0FBQztJQUVGLGVBQWUsQ0FBQyxZQUE2QjtRQUN6QyxJQUFJLENBQUMsWUFBWSxHQUFHLFlBQVksQ0FBQztJQUNyQyxDQUFDO0lBRUQsYUFBYSxDQUFDLGlCQUFvQztRQUM5QyxNQUFNLE9BQU8sR0FBa0IsSUFBSSxDQUFDLGNBQWMsQ0FBQyxpQkFBaUIsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUN6RSxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDYixJQUFJLENBQUMsWUFBWSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUM7WUFDakQsT0FBTztRQUNULENBQUM7UUFDRCxJQUFJLENBQUMsWUFBWSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztRQUNuRCxJQUFJLENBQUMsVUFBVTthQUNaLGFBQWEsQ0FBQyxPQUFPLENBQUMsWUFBWSxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQyxJQUFJLENBQ3hELEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsaUJBQWlCLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FDM0Q7YUFDQSxTQUFTLENBQUM7WUFDVCxJQUFJLEVBQUUsQ0FBQyxJQUFtQixFQUFFLEVBQUU7Z0JBQzVCLE9BQU8sQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQztnQkFDekMsSUFBSSxDQUFDLFlBQVksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLGVBQWUsQ0FBQyxDQUFDO1lBQ3BELENBQUM7WUFDRCxLQUFLLEVBQUUsR0FBSSxFQUFFO2dCQUNYLE9BQU8sQ0FBQyxZQUFZLEdBQUcsaUJBQWlCLENBQUMsWUFBWSxDQUFDO2dCQUN0RCxJQUFJLENBQUMsWUFBWSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUM7WUFDbkQsQ0FBQztTQUNGLENBQUMsQ0FBQztJQUNULENBQUM7SUFFRCxlQUFlLENBQUMsSUFBWSxFQUFFLE1BQWM7UUFDMUMsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLGFBQWEsQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUNyRCxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLGlCQUFpQixDQUFDLElBQUksRUFBRSxDQUFDLENBQzNELENBQUM7SUFDSixDQUFDO0lBRU8sY0FBYyxDQUFDLE9BQWU7UUFDbEMsSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztZQUN2QixPQUFPO1FBQ1QsQ0FBQztRQUVELEtBQUssTUFBTSxPQUFPLElBQUksSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1lBQ3hDLElBQUcsT0FBTyxDQUFDLE9BQU8sS0FBSyxPQUFPLEVBQUUsQ0FBQztnQkFDL0IsT0FBTyxPQUFPLENBQUM7WUFDakIsQ0FBQztRQUNILENBQUM7UUFFRCxPQUFPLElBQUksQ0FBQztJQUNoQixDQUFDO3VHQTNEUSxvQkFBb0I7MkdBQXBCLG9CQUFvQjs7MkZBQXBCLG9CQUFvQjtrQkFEaEMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQWxlcnRTZXJ2aWNlIH0gZnJvbSAnLi9hbGVydC5zZXJ2aWNlJztcclxuaW1wb3J0IHsgSW1nUGljdHVyZURUTyB9IGZyb20gJy4uL2R0by9pbWctbWFuYWdlci5kdG8nO1xyXG5pbXBvcnQgeyBQaWN0dXJlTmFtZVVwZGF0ZSB9IGZyb20gJy4uL2R0by9waWN0dXJlLW5hbWUtdXBkYXRlLmR0byc7XHJcbmltcG9ydCB7IEFwaVNlcnZpY2UgfSBmcm9tICcuL2FwaS5zZXJ2aWNlJztcclxuaW1wb3J0IHsgSW1nTWFuYWdlclNlcnZpY2UgfSBmcm9tICcuL2ltZy1tYW5hZ2VyLnNlcnZpY2UnO1xyXG5pbXBvcnQgeyB0YXAgfSBmcm9tICdyeGpzJztcclxuXHJcbkBJbmplY3RhYmxlKClcclxuZXhwb3J0IGNsYXNzIFJlbmFtZVBpY3R1cmVTZXJ2aWNlIHtcclxuXHJcbiAgICBwcml2YXRlIHBpY3R1cmVzTGlzdDogSW1nUGljdHVyZURUT1tdID0gW107XHJcbiAgICBwcml2YXRlIGVycm9yUmVuYW1lSW1nID0gJ0ltZ01hbmFnZXIuSW1nTGlzdC5lcnJvclJlbmFtZUltZyc7XHJcbiAgICBwcml2YXRlIG1zZ1NhdmluZ0ltZ05hbWUgPSAnSW1nTWFuYWdlci5JbWdMaWIuc2F2aW5nSW1nTmFtZSc7XHJcbiAgICBwcml2YXRlIG1zZ0ltZ05hbWVTYXZlZCA9ICdJbWdNYW5hZ2VyLkltZ0xpYi5pbWdOYW1lU2F2ZWQnO1xyXG5cclxuICAgIGNvbnN0cnVjdG9yKFxyXG4gICAgICBwcml2YXRlIGFwaVNlcnZpY2U6IEFwaVNlcnZpY2UsXHJcbiAgICAgIHByaXZhdGUgYWxlcnRTZXJ2aWNlOiBBbGVydFNlcnZpY2UsXHJcbiAgICAgIHByaXZhdGUgaW1nTWFuYWdlclNlcnZpY2U6IEltZ01hbmFnZXJTZXJ2aWNlXHJcbiAgICApXHJcbiAgICB7fVxyXG5cclxuICAgIHNldFBpY3R1cmVzTGlzdChwaWN0dXJlc0xpc3Q6IEltZ1BpY3R1cmVEVE9bXSkgeyAvLyB0b2RvIGdldCBmcm9tIGltZyBtYW5hZ2VyIHNlcnZpY2VcclxuICAgICAgICB0aGlzLnBpY3R1cmVzTGlzdCA9IHBpY3R1cmVzTGlzdDtcclxuICAgIH1cclxuXHJcbiAgICByZW5hbWVQaWN0dXJlKHBpY3R1cmVOYW1lVXBkYXRlOiBQaWN0dXJlTmFtZVVwZGF0ZSkge1xyXG4gICAgICAgIGNvbnN0IHBpY3R1cmU6IEltZ1BpY3R1cmVEVE8gPSB0aGlzLmdldFBpY3R1cmVCeUlkKHBpY3R1cmVOYW1lVXBkYXRlLmlkKTtcclxuICAgICAgICBpZiAoIXBpY3R1cmUpIHtcclxuICAgICAgICAgIHRoaXMuYWxlcnRTZXJ2aWNlLm9wZW5BbGVydCh0aGlzLmVycm9yUmVuYW1lSW1nKTtcclxuICAgICAgICAgIHJldHVybjtcclxuICAgICAgICB9XHJcbiAgICAgICAgdGhpcy5hbGVydFNlcnZpY2Uub3BlbkFsZXJ0KHRoaXMubXNnU2F2aW5nSW1nTmFtZSk7XHJcbiAgICAgICAgdGhpcy5hcGlTZXJ2aWNlXHJcbiAgICAgICAgICAuY2hhbmdlSW1nTmFtZShwaWN0dXJlLmRpc3BsYXlfbmFtZSwgcGljdHVyZS5pZF9maWxlKS5waXBlKFxyXG4gICAgICAgICAgICB0YXAoKCkgPT4gdGhpcy5pbWdNYW5hZ2VyU2VydmljZS5yZWZyZXNoSW1hZ2VMaXN0JC5uZXh0KCkpXHJcbiAgICAgICAgICApXHJcbiAgICAgICAgICAuc3Vic2NyaWJlKHtcclxuICAgICAgICAgICAgbmV4dDogKGRhdGE6IEltZ1BpY3R1cmVEVE8pID0+IHtcclxuICAgICAgICAgICAgICBwaWN0dXJlLmRpc3BsYXlfbmFtZSA9IGRhdGEuZGlzcGxheV9uYW1lO1xyXG4gICAgICAgICAgICAgIHRoaXMuYWxlcnRTZXJ2aWNlLm9wZW5BbGVydCh0aGlzLm1zZ0ltZ05hbWVTYXZlZCk7XHJcbiAgICAgICAgICAgIH0sXHJcbiAgICAgICAgICAgIGVycm9yOiAoKSAgPT4ge1xyXG4gICAgICAgICAgICAgIHBpY3R1cmUuZGlzcGxheV9uYW1lID0gcGljdHVyZU5hbWVVcGRhdGUucHJldmlvdXNOYW1lO1xyXG4gICAgICAgICAgICAgIHRoaXMuYWxlcnRTZXJ2aWNlLm9wZW5BbGVydCh0aGlzLmVycm9yUmVuYW1lSW1nKTtcclxuICAgICAgICAgICAgfVxyXG4gICAgICAgICAgfSk7XHJcbiAgICB9XHJcblxyXG4gICAgY2hhbmdlSW1hZ2VOYW1lKG5hbWU6IHN0cmluZywgaWRGaWxlOiBzdHJpbmcpIHtcclxuICAgICAgcmV0dXJuIHRoaXMuYXBpU2VydmljZS5jaGFuZ2VJbWdOYW1lKG5hbWUsIGlkRmlsZSkucGlwZShcclxuICAgICAgICB0YXAoKCkgPT4gdGhpcy5pbWdNYW5hZ2VyU2VydmljZS5yZWZyZXNoSW1hZ2VMaXN0JC5uZXh0KCkpXHJcbiAgICAgICk7XHJcbiAgICB9XHJcblxyXG4gICAgcHJpdmF0ZSBnZXRQaWN0dXJlQnlJZChpZF9maWxlOiBzdHJpbmcpOiBJbWdQaWN0dXJlRFRPIHtcclxuICAgICAgICBpZiAoIXRoaXMucGljdHVyZXNMaXN0KSB7XHJcbiAgICAgICAgICByZXR1cm47XHJcbiAgICAgICAgfVxyXG5cclxuICAgICAgICBmb3IgKGNvbnN0IHBpY3R1cmUgb2YgdGhpcy5waWN0dXJlc0xpc3QpIHtcclxuICAgICAgICAgIGlmKHBpY3R1cmUuaWRfZmlsZSA9PT0gaWRfZmlsZSkge1xyXG4gICAgICAgICAgICByZXR1cm4gcGljdHVyZTtcclxuICAgICAgICAgIH1cclxuICAgICAgICB9XHJcblxyXG4gICAgICAgIHJldHVybiBudWxsO1xyXG4gICAgfVxyXG5cclxufSJdfQ==

package/esm2022/lib/services/snackbar.service.mjs

@@ -0,0 +1,67 @@
+import { Injectable } from '@angular/core';
+import { NwbSnackbarService } from '@wizishop/ng-wizi-bulma';
+import { TranslateService } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@wizishop/ng-wizi-bulma";
+import * as i2 from "@ngx-translate/core";
+export class SnackBarService {
+    nwbSnackbar;
+    translateService;
+    actionMsg = 'ImgManager.snackBar.action';
+    snackBarConfigAction = {
+        message: '',
+        duration: 5000
+    };
+    snackBarConfig = {
+        message: '',
+        duration: 5000
+    };
+    snackBarRefComponent;
+    constructor(nwbSnackbar, translateService) {
+        this.nwbSnackbar = nwbSnackbar;
+        this.translateService = translateService;
+    }
+    openSnackBar(msgKey) {
+        this.closePreviousSnackbar();
+        this.translateService.get(msgKey).subscribe(trans => {
+            this.snackBarConfig.message = trans;
+            this.snackBarRefComponent = this.nwbSnackbar.open(this.snackBarConfig);
+            this.snackBarRefComponent.afterClosed().subscribe();
+        });
+    }
+    openSnackBarWithAction(msgKey) {
+        return new Observable(observer => {
+            this.translateService.get([msgKey, this.actionMsg]).subscribe((trans) => {
+                this.snackBarConfigAction.message = trans[msgKey];
+                this.snackBarConfigAction.action = trans[this.actionMsg];
+                this.closePreviousSnackbar();
+                this.snackBarRefComponent = this.nwbSnackbar.open(this.snackBarConfigAction);
+                this.snackBarRefComponent.afterClosed().subscribe(manualClose => {
+                    observer.next(manualClose);
+                    observer.complete();
+                });
+            });
+        });
+    }
+    openSnackBarWithBackendRespons(msgKey, msgBackend) {
+        this.translateService.get(msgKey).subscribe(trans => {
+            this.snackBarConfig.message = trans;
+            this.snackBarConfig.message += '<br/>' + JSON.parse(msgBackend).message;
+            this.closePreviousSnackbar();
+            this.snackBarRefComponent = this.nwbSnackbar.open(this.snackBarConfig);
+            this.snackBarRefComponent.afterClosed().subscribe();
+        });
+    }
+    closePreviousSnackbar() {
+        if (this.snackBarRefComponent) {
+            this.snackBarRefComponent.dismiss(false);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SnackBarService, deps: [{ token: i1.NwbSnackbarService }, { token: i2.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SnackBarService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SnackBarService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.NwbSnackbarService }, { type: i2.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/table/filters-table.service.mjs

@@ -0,0 +1,61 @@
+import { Injectable } from '@angular/core';
+import { NwbFilterRoutingBuilder } from '@wizishop/ng-wizi-bulma';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@wizishop/ng-wizi-bulma";
+export class FiltersTableService {
+    filterRoutingBuilder;
+    filterGroups = new Map();
+    dataTableFilters = {
+        sort: undefined,
+        order: undefined,
+        searchValue: undefined,
+        totalItems: 0,
+        itemsPerPage: 0,
+        currentPage: 0
+    };
+    sortSubject = new Subject();
+    constructor(filterRoutingBuilder) {
+        this.filterRoutingBuilder = filterRoutingBuilder;
+    }
+    getTableFilterGroup(dataTableName) {
+        if (this.filterGroups.has(dataTableName)) {
+            return this.filterGroups.get(dataTableName);
+        }
+        const filterGroup = this.filterRoutingBuilder.group(this.dataTableFilters, dataTableName);
+        this.filterGroups.set(dataTableName, filterGroup);
+        return filterGroup;
+    }
+    /**
+     * Use to reset the others sorts of the table
+     * @param dataTableName
+     * @param sortName
+     * @param order
+     */
+    emitSortChange(dataTableName, sortName, order) {
+        this.sortSubject.next({ dataTableName, sortName, order });
+    }
+    getSortChangeListner() {
+        return this.sortSubject.asObservable();
+    }
+    setPaginationFilters(dataTableName, totalItems, itemsPerPage, currentPage) {
+        const filterGroup = this.getTableFilterGroup(dataTableName);
+        filterGroup.setValues({
+            itemsPerPage,
+            currentPage
+        });
+    }
+    setInitialPaginationFiltersIfNotExist(dataTableName, itemsPerPage, currentPage) {
+        const filterGroup = this.getTableFilterGroup(dataTableName);
+        filterGroup.setValues({
+            itemsPerPage: filterGroup.get('itemsPerPage') ? parseInt(filterGroup.get('itemsPerPage')) : itemsPerPage,
+            currentPage: filterGroup.get('currentPage') ? parseInt(filterGroup.get('currentPage')) : currentPage
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: FiltersTableService, deps: [{ token: i1.NwbFilterRoutingBuilder }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: FiltersTableService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: FiltersTableService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.NwbFilterRoutingBuilder }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/upload.service.mjs

@@ -0,0 +1,20 @@
+import { Injectable, inject } from '@angular/core';
+import { ApiService } from './api.service';
+import { Subject, tap } from 'rxjs';
+import * as i0 from "@angular/core";
+export class UploadService {
+    imageUploaded$ = new Subject();
+    apiService = inject(ApiService);
+    uploadFile(formData) {
+        return this.apiService.uploadFile(formData).pipe(tap((img) => this.imageUploaded$.next(img)));
+    }
+    uploadFileByUrl(url, fileName) {
+        return this.apiService.uploadFileByUrl(url, fileName).pipe(tap((img) => this.imageUploaded$.next(img)));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: UploadService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: UploadService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: UploadService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/user-settings.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class UserSettingsService {
+    userdisplayPreference = 'WzImgManagerListDisplayed';
+    /**
+     * true : display list
+     * false : display mosaic
+     * @param value
+     */
+    setUserDisplayPreference(value) {
+        localStorage.setItem(this.userdisplayPreference, '' + value);
+    }
+    getUserDisplayPreference() {
+        const value = localStorage.getItem(this.userdisplayPreference);
+        return value == 'true';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: UserSettingsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: UserSettingsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: UserSettingsService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1zZXR0aW5ncy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvd3otaW1nLW1hbmFnZXIvc3JjL2xpYi9zZXJ2aWNlcy91c2VyLXNldHRpbmdzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFHM0MsTUFBTSxPQUFPLG1CQUFtQjtJQUVwQixxQkFBcUIsR0FBRywyQkFBMkIsQ0FBQztJQUU1RDs7OztPQUlHO0lBQ0gsd0JBQXdCLENBQUMsS0FBYztRQUNuQyxZQUFZLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxxQkFBcUIsRUFBRSxFQUFFLEdBQUcsS0FBSyxDQUFDLENBQUM7SUFDakUsQ0FBQztJQUVELHdCQUF3QjtRQUNwQixNQUFNLEtBQUssR0FBRyxZQUFZLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDO1FBQy9ELE9BQU8sS0FBSyxJQUFJLE1BQU0sQ0FBQztJQUMzQixDQUFDO3VHQWhCUSxtQkFBbUI7MkdBQW5CLG1CQUFtQjs7MkZBQW5CLG1CQUFtQjtrQkFEL0IsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbkBJbmplY3RhYmxlKClcclxuZXhwb3J0IGNsYXNzIFVzZXJTZXR0aW5nc1NlcnZpY2Uge1xyXG5cclxuICAgIHByaXZhdGUgdXNlcmRpc3BsYXlQcmVmZXJlbmNlID0gJ1d6SW1nTWFuYWdlckxpc3REaXNwbGF5ZWQnO1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogdHJ1ZSA6IGRpc3BsYXkgbGlzdFxyXG4gICAgICogZmFsc2UgOiBkaXNwbGF5IG1vc2FpY1xyXG4gICAgICogQHBhcmFtIHZhbHVlXHJcbiAgICAgKi9cclxuICAgIHNldFVzZXJEaXNwbGF5UHJlZmVyZW5jZSh2YWx1ZTogYm9vbGVhbikge1xyXG4gICAgICAgIGxvY2FsU3RvcmFnZS5zZXRJdGVtKHRoaXMudXNlcmRpc3BsYXlQcmVmZXJlbmNlLCAnJyArIHZhbHVlKTtcclxuICAgIH1cclxuXHJcbiAgICBnZXRVc2VyRGlzcGxheVByZWZlcmVuY2UoKTogYm9vbGVhbiB7XHJcbiAgICAgICAgY29uc3QgdmFsdWUgPSBsb2NhbFN0b3JhZ2UuZ2V0SXRlbSh0aGlzLnVzZXJkaXNwbGF5UHJlZmVyZW5jZSk7XHJcbiAgICAgICAgcmV0dXJuIHZhbHVlID09ICd0cnVlJztcclxuICAgIH1cclxuXHJcbn1cclxuIl19