@eui/core 16.0.0-next.1 → 16.0.0-next.10

package/lib/services/ux-timezone.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ux-timezone.service.d.ts","sourceRoot":"","sources":["../../../src/lib/services/ux-timezone.service.ts"],"names":[],"mappings":";AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwPxB,CAAC;AAEF,MAAM,WAAW,QAAQ;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,YAAY,EAAE,QAAQ,EAiblC,CAAC;AAGF,qBACa,iBAAiB;IAC1B;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAIhC;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;IAQxB,YAAY,IAAI,QAAQ,EAAE;IAI1B,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ;yCAvBxB,iBAAiB;6CAAjB,iBAAiB;CA0B7B"}
+{"version":3,"file":"ux-timezone.service.d.ts","sourceRoot":"","sources":["../../../src/lib/services/ux-timezone.service.ts"],"names":[],"mappings":";AAIA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwPxB,CAAC;AAEF,MAAM,WAAW,QAAQ;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,YAAY,EAAE,QAAQ,EAiblC,CAAC;AAGF,qBACa,iBAAiB;IAC1B;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAIhC;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;IAQxB,YAAY,IAAI,QAAQ,EAAE;IAI1B,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ;yCAvBxB,iBAAiB;6CAAjB,iBAAiB;CA0B7B"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@eui/core",
-    "version": "16.0.0-next.1",
+    "version": "16.0.0-next.10",
     "tag": "next",
     "description": "eUI core package - holding UI components for Desktop applications",
     "homepage": "https://eui.ecdevops.eu",
@@ -15,11 +15,7 @@
         "npm": "Please use yarn instead of NPM to install dependencies"
     },
     "license": "EUPL-1.1",
-    "module": "fesm2015/eui-core.mjs",
-    "es2020": "fesm2020/eui-core.mjs",
-    "esm2020": "esm2020/eui-core.mjs",
-    "fesm2020": "fesm2020/eui-core.mjs",
-    "fesm2015": "fesm2015/eui-core.mjs",
+    "module": "fesm2022/eui-core.mjs",
     "typings": "index.d.ts",
     "exports": {
         "./package.json": {
@@ -27,11 +23,9 @@
         },
         ".": {
             "types": "./index.d.ts",
-            "esm2020": "./esm2020/eui-core.mjs",
-            "es2020": "./fesm2020/eui-core.mjs",
-            "es2015": "./fesm2015/eui-core.mjs",
-            "node": "./fesm2015/eui-core.mjs",
-            "default": "./fesm2020/eui-core.mjs"
+            "esm2022": "./esm2022/eui-core.mjs",
+            "esm": "./esm2022/eui-core.mjs",
+            "default": "./fesm2022/eui-core.mjs"
         }
     },
     "sideEffects": false,

package/esm2020/lib/services/locale/locale.service.mjs

@@ -1,231 +0,0 @@
-/**
- * Angular is using a gulp task to generate the locales that we dynamically import. This task can be found here
- * https://github.com/angular/angular/blob/master/tools/gulp-tasks/cldr/cldr-data.js
- * That task is utilizing the CLDR library to load and construct the locale for each region. This service is responsible
- * to load those locale dynamically upon request and to update the state of the eUI app.
- *
- * Parts that are handles through configuration:
- *  - update of the LOCALE_ID token
- *  - initial dynamical load of locales
- *  - bind to translation service for locale changes
- */
-import { Inject, Injectable, InjectionToken, LOCALE_ID, Optional } from '@angular/core';
-import { getLocaleId } from '@angular/common';
-import { EuiService, getLocaleState, getLocaleServiceConfigFromBase, } from '@eui/base';
-import { of, Subject, throwError } from 'rxjs';
-import { catchError, filter, map, switchMap, take, takeUntil, tap } from 'rxjs/operators';
-import { UpdateLocaleStateAction } from '../store';
-import { GLOBAL_CONFIG_TOKEN } from '../config/tokens';
-import { createSelector } from '@ngrx/store';
-import * as i0 from "@angular/core";
-import * as i1 from "../store";
-import * as i2 from "../i18n";
-import * as i3 from "../log";
-export const LOCALE_ID_MAPPER = new InjectionToken('localeIdMapper');
-export class LocaleService extends EuiService {
-    constructor(store, baseGlobalConfig, locale_id, localeMapper, i18n, log) {
-        super({ id: getLocaleId(locale_id) });
-        this.store = store;
-        this.baseGlobalConfig = baseGlobalConfig;
-        this.locale_id = locale_id;
-        this.localeMapper = localeMapper;
-        this.i18n = i18n;
-        this.log = log;
-        this.subNotifier = new Subject();
-        if (log) {
-            this.logger = log.getLogger('core.LocaleService');
-        }
-        this.config = getLocaleServiceConfigFromBase(this.baseGlobalConfig);
-        // in case no localeMapper provided, set the angular getLocaleId as default
-        if (!this.localeMapper) {
-            this.localeMapper = getLocaleId;
-        }
-    }
-    ngOnDestroy() {
-        this.subNotifier.next(void 0);
-        this.subNotifier.complete();
-    }
-    getState(keyOrMapFn) {
-        let selector = getLocaleState;
-        if (keyOrMapFn) {
-            switch (typeof keyOrMapFn) {
-                case 'function':
-                    selector = createSelector(getLocaleState, keyOrMapFn);
-                    break;
-                case 'string':
-                    selector = createSelector(getLocaleState, (state) => state[keyOrMapFn]);
-                    break;
-            }
-        }
-        return this.store.select(selector).pipe(takeUntil(this.subNotifier), 
-        // in case service didn't init fallback to LOCALE_ID token value
-        map((state) => (state ? state : this.stateInstance ? this.stateInstance : this.locale_id)));
-    }
-    init(state) {
-        super.initEuiService();
-        // bind language changes to locale changes
-        if (this.config?.bindWithTranslate) {
-            this.bindTranslateServiceLangChangeToState();
-        }
-        // dynamically load locale based on provided configuration
-        const availableLocales = state?.available || this.config?.available || this.getBrowserLocales() || [this.currentLocale];
-        return this.loadLocale(availableLocales).pipe(takeUntil(this.subNotifier), tap(() => this.updateState({ id: this.currentLocale })));
-    }
-    /**
-     * dynamically load locale and update the state
-     */
-    updateState(state) {
-        try {
-            const id = this.localeMapper(state.id);
-            this.store.dispatch(new UpdateLocaleStateAction({ ...state, id }));
-            // update global TOKEN ID based on configuration
-            if (this.config.affectGlobalLocale) {
-                this.locale_id = id;
-            }
-        }
-        catch (e) {
-            const message = `Locale for '${state.id}' is not available.
-                 Please use addLocale('${state.id}') first`;
-            if (this.log) {
-                this.logger.info(message, e);
-            }
-            throw new Error(message);
-        }
-    }
-    addLocale(id) {
-        return this.loadLocale(id);
-    }
-    get previousLocale() {
-        return this.prevStateInstance?.id || this.currentLocale;
-    }
-    get currentLocale() {
-        return this.stateInstance?.id;
-    }
-    /**
-     * load and register locale data dynamically
-     *
-     * @param locale array of locale to load
-     */
-    loadLocale(locale) {
-        // locale = Array.isArray(locale) ? locale : [locale];
-        // const localeImports: Observable<{ data: any, localeId: string, extraData: any }>[]
-        //     = this.filterRegisteredLocales(locale).map(this.importDataAndExtraLocale.bind(this));
-        //
-        // // in case localeImports array is empty because locale exists, Observable still needs to complete
-        // if (localeImports.length < 1) {
-        //     return of({ success: true });
-        // }
-        //
-        // return forkJoin(...localeImports).pipe(
-        //     takeUntil(this.subNotifier),
-        //     map(localeData => {
-        //         // filter out null results and registerLocaleData including extra
-        //         localeData.filter(({ data }) => data)
-        //             .forEach(({ data, localeId, extraData }) => registerLocaleData(data, localeId, extraData));
-        //         return { success: true };
-        //     }),
-        //     catchError(error => {
-        //         if (this.log) {
-        //             this.logger.debug(`Locale load error: ${error.message}`, error);
-        //         }
-        //         return of({ success: false, error: error });
-        //     })
-        // );
-        return of({ success: true });
-    }
-    /**
-     * listen for language changes and dynamically set locale accordingly. In case of non registered locale register it
-     * dynamically.
-     */
-    bindTranslateServiceLangChangeToState() {
-        if (this.i18n) {
-            this.i18n.onStateChange
-                .pipe(takeUntil(this.subNotifier), 
-            // filter out null values
-            filter((state) => state?.activeLang !== null && state?.activeLang !== undefined), 
-            // BEWARE: filter is based on convention that locale id sliced(2) will match activeLang e.g. en-US => en
-            // Also, if activeLang is 'en' and locale is 'en-GB' it will not trigger locale change
-            filter((state) => state.activeLang.toLowerCase() !== this.stateInstance?.id.slice(0, 2).toLowerCase()), 
-            // to check if registration of locale otherwise register it
-            switchMap((value) => of(value).pipe(
-            // getLocaleId may throw Error(`Missing locale data for the locale "${locale}".`);
-            switchMap((i18state) => {
-                // check if activeLang is null or undefined
-                if (!i18state.activeLang) {
-                    return throwError('Has i18nService initialized? If not make sure i18nService.init().subscribe(..)');
-                }
-                return of(this.localeMapper(i18state.activeLang));
-            }), catchError((error) => {
-                if (this.log) {
-                    this.logger.debug(error);
-                }
-                return this.loadLocale(value?.activeLang).pipe(filter((s) => s.success), map(() => this.localeMapper(value?.activeLang)), catchError((e) => {
-                    if (this.log) {
-                        this.logger.debug('Something went terribly really wrong during locale loading', e.err.message);
-                    }
-                    return of(e);
-                }));
-            }))), 
-            // update the "available" array attribute with newly registered
-            switchMap((id) => this.getState().pipe(take(1), map((state) => {
-                const available = state?.available ? state.available : [];
-                return { ...state, id, available: Array.from(new Set([...available, id])) };
-            }))))
-                .subscribe((state) => {
-                this.updateState(state);
-            });
-        }
-    }
-    /**
-     * retrieve locales from browser
-     *
-     * @param options
-     */
-    getBrowserLocales() {
-        const browserLocales = navigator.languages === undefined ? [navigator.language] : navigator.languages;
-        if (!browserLocales) {
-            return undefined;
-        }
-        return browserLocales.map((locale) => locale.trim());
-    }
-    /**
-     * if locale is already registered filtered out.
-     *
-     * @param locales A string array contains all locale id e.g. ["el", "el-CY"]
-     */
-    filterRegisteredLocales(locales) {
-        return locales.filter((loc) => {
-            try {
-                getLocaleId(loc);
-                return false;
-            }
-            catch (e) {
-                return true;
-            }
-        });
-    }
-}
-/** @nocollapse */ LocaleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.2", ngImport: i0, type: LocaleService, deps: [{ token: i1.StoreService }, { token: GLOBAL_CONFIG_TOKEN }, { token: LOCALE_ID }, { token: LOCALE_ID_MAPPER, optional: true }, { token: i2.I18nService, optional: true }, { token: i3.LogService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ LocaleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.2", ngImport: i0, type: LocaleService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.2", ngImport: i0, type: LocaleService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return [{ type: i1.StoreService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [GLOBAL_CONFIG_TOKEN]
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [LOCALE_ID]
-                }] }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [LOCALE_ID_MAPPER]
-                }] }, { type: i2.I18nService, decorators: [{
-                    type: Optional
-                }] }, { type: i3.LogService, decorators: [{
-                    type: Optional
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"locale.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/locale/locale.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,SAAS,EAAa,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnG,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EACH,UAAU,EAEV,cAAc,EACd,8BAA8B,GAKjC,MAAM,WAAW,CAAC;AACnB,OAAO,EAAc,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAC1F,OAAO,EAAgB,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAGjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;;;;;AAG7C,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,cAAc,CAAe,gBAAgB,CAAC,CAAC;AAKnF,MAAM,OAAO,aAAmD,SAAQ,UAA2B;IAK/F,YACc,KAAmB,EACU,gBAA8B,EACxC,SAAiB,EACA,YAA0B,EACpD,IAAiB,EACjB,GAAe;QAEnC,KAAK,CAAC,EAAE,EAAE,EAAE,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QAP5B,UAAK,GAAL,KAAK,CAAc;QACU,qBAAgB,GAAhB,gBAAgB,CAAc;QACxC,cAAS,GAAT,SAAS,CAAQ;QACA,iBAAY,GAAZ,YAAY,CAAc;QACpD,SAAI,GAAJ,IAAI,CAAa;QACjB,QAAG,GAAH,GAAG,CAAY;QAT/B,gBAAW,GAAiB,IAAI,OAAO,EAAE,CAAC;QAY9C,IAAI,GAAG,EAAE;YACL,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,SAAS,CAAC,oBAAoB,CAAC,CAAC;SACrD;QAED,IAAI,CAAC,MAAM,GAAG,8BAA8B,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QACpE,2EAA2E;QAC3E,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACpB,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;SACnC;IACL,CAAC;IAED,WAAW;QACP,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAC9B,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;IAChC,CAAC;IAID,QAAQ,CAAI,UAAuC;QAC/C,IAAI,QAAQ,GAAQ,cAAc,CAAC;QAEnC,IAAI,UAAU,EAAE;YACZ,QAAQ,OAAO,UAAU,EAAE;gBACvB,KAAK,UAAU;oBACX,QAAQ,GAAG,cAAc,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;oBACtD,MAAM;gBACV,KAAK,QAAQ;oBACT,QAAQ,GAAG,cAAc,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;oBACxE,MAAM;aACb;SACJ;QACD,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CACnC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC;QAC3B,gEAAgE;QAChE,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAC7F,CAAC;IACN,CAAC;IAED,IAAI,CAAC,KAA+B;QAChC,KAAK,CAAC,cAAc,EAAE,CAAC;QAEvB,0CAA0C;QAC1C,IAAI,IAAI,CAAC,MAAM,EAAE,iBAAiB,EAAE;YAChC,IAAI,CAAC,qCAAqC,EAAE,CAAC;SAChD;QAED,0DAA0D;QAC1D,MAAM,gBAAgB,GAAG,KAAK,EAAE,SAAS,IAAI,IAAI,CAAC,MAAM,EAAE,SAAS,IAAI,IAAI,CAAC,iBAAiB,EAAE,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACxH,OAAO,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,IAAI,CACzC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,EAC3B,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAC1D,CAAC;IACN,CAAC;IAED;;OAEG;IACH,WAAW,CAAC,KAAkB;QAC1B,IAAI;YACA,MAAM,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YACvC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,uBAAuB,CAAC,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;YACnE,gDAAgD;YAChD,IAAI,IAAI,CAAC,MAAM,CAAC,kBAAkB,EAAE;gBAChC,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;aACvB;SACJ;QAAC,OAAO,CAAC,EAAE;YACR,MAAM,OAAO,GAAG,eAAe,KAAK,CAAC,EAAE;yCACV,KAAK,CAAC,EAAE,UAAU,CAAC;YAChD,IAAI,IAAI,CAAC,GAAG,EAAE;gBACV,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;aAChC;YACD,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;SAC5B;IACL,CAAC;IAED,SAAS,CAAC,EAAU;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;IAC/B,CAAC;IAED,IAAI,cAAc;QACd,OAAO,IAAI,CAAC,iBAAiB,EAAE,EAAE,IAAI,IAAI,CAAC,aAAa,CAAC;IAC5D,CAAC;IAED,IAAI,aAAa;QACb,OAAO,IAAI,CAAC,aAAa,EAAE,EAAE,CAAC;IAClC,CAAC;IAED;;;;OAIG;IACK,UAAU,CAAC,MAAyB;QACxC,sDAAsD;QACtD,qFAAqF;QACrF,4FAA4F;QAC5F,EAAE;QACF,oGAAoG;QACpG,kCAAkC;QAClC,oCAAoC;QACpC,IAAI;QACJ,EAAE;QACF,0CAA0C;QAC1C,mCAAmC;QACnC,0BAA0B;QAC1B,4EAA4E;QAC5E,gDAAgD;QAChD,0GAA0G;QAC1G,oCAAoC;QACpC,UAAU;QACV,4BAA4B;QAC5B,0BAA0B;QAC1B,+EAA+E;QAC/E,YAAY;QACZ,uDAAuD;QACvD,SAAS;QACT,KAAK;QACL,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;IACjC,CAAC;IAED;;;OAGG;IACK,qCAAqC;QACzC,IAAI,IAAI,CAAC,IAAI,EAAE;YACX,IAAI,CAAC,IAAI,CAAC,aAAa;iBAClB,IAAI,CACD,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC;YAC3B,yBAAyB;YACzB,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,IAAI,KAAK,EAAE,UAAU,KAAK,SAAS,CAAC;YAChF,wGAAwG;YACxG,sFAAsF;YACtF,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,WAAW,EAAE,KAAK,IAAI,CAAC,aAAa,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;YACtG,2DAA2D;YAC3D,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CAChB,EAAE,CAAC,KAAK,CAAC,CAAC,IAAI;YACV,kFAAkF;YAClF,SAAS,CAAC,CAAC,QAAQ,EAAE,EAAE;gBACnB,2CAA2C;gBAC3C,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE;oBACtB,OAAO,UAAU,CAAC,gFAAgF,CAAC,CAAC;iBACvG;gBACD,OAAO,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;YACtD,CAAC,CAAC,EACF,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;gBACjB,IAAI,IAAI,CAAC,GAAG,EAAE;oBACV,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;iBAC5B;gBACD,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,IAAI,CAC1C,MAAM,CAAC,CAAC,CAAmB,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAC1C,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,EAC/C,UAAU,CAAC,CAAC,CAAC,EAAE,EAAE;oBACb,IAAI,IAAI,CAAC,GAAG,EAAE;wBACV,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,4DAA4D,EAAE,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;qBAClG;oBACD,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;gBACjB,CAAC,CAAC,CACL,CAAC;YACN,CAAC,CAAC,CACL,CACJ;YACD,+DAA+D;YAC/D,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,CACb,IAAI,CAAC,QAAQ,EAAE,CAAC,IAAI,CAChB,IAAI,CAAC,CAAC,CAAC,EACP,GAAG,CAAC,CAAC,KAAkB,EAAE,EAAE;gBACvB,MAAM,SAAS,GAAG,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC1D,OAAO,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAChF,CAAC,CAAC,CACL,CACJ,CACJ;iBACA,SAAS,CAAC,CAAC,KAAkB,EAAE,EAAE;gBAC9B,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;YAC5B,CAAC,CAAC,CAAC;SACV;IACL,CAAC;IAED;;;;OAIG;IACK,iBAAiB;QACrB,MAAM,cAAc,GAAG,SAAS,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC;QAEtG,IAAI,CAAC,cAAc,EAAE;YACjB,OAAO,SAAS,CAAC;SACpB;QAED,OAAO,cAAc,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IACzD,CAAC;IAED;;;;OAIG;IACK,uBAAuB,CAAC,OAAiB;QAC7C,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,GAAW,EAAE,EAAE;YAClC,IAAI;gBACA,WAAW,CAAC,GAAG,CAAC,CAAC;gBACjB,OAAO,KAAK,CAAC;aAChB;YAAC,OAAO,CAAC,EAAE;gBACR,OAAO,IAAI,CAAC;aACf;QACL,CAAC,CAAC,CAAC;IACP,CAAC;;oIA9NQ,aAAa,8CAOV,mBAAmB,aACnB,SAAS,aACG,gBAAgB;wIAT/B,aAAa,cAFV,MAAM;kGAET,aAAa;kBAHzB,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB;;0BAQQ,MAAM;2BAAC,mBAAmB;;0BAC1B,MAAM;2BAAC,SAAS;;0BAChB,QAAQ;;0BAAI,MAAM;2BAAC,gBAAgB;;0BACnC,QAAQ;;0BACR,QAAQ","sourcesContent":["/**\n * Angular is using a gulp task to generate the locales that we dynamically import. This task can be found here\n * https://github.com/angular/angular/blob/master/tools/gulp-tasks/cldr/cldr-data.js\n * That task is utilizing the CLDR library to load and construct the locale for each region. This service is responsible\n * to load those locale dynamically upon request and to update the state of the eUI app.\n *\n * Parts that are handles through configuration:\n *  - update of the LOCALE_ID token\n *  - initial dynamical load of locales\n *  - bind to translation service for locale changes\n */\n\nimport { Inject, Injectable, InjectionToken, LOCALE_ID, OnDestroy, Optional } from '@angular/core';\nimport { getLocaleId } from '@angular/common';\nimport {\n    EuiService,\n    EuiServiceStatus,\n    getLocaleState,\n    getLocaleServiceConfigFromBase,\n    GlobalConfig,\n    LocaleServiceConfig,\n    LocaleState,\n    Logger,\n} from '@eui/base';\nimport { Observable, of, Subject, throwError } from 'rxjs';\nimport { catchError, filter, map, switchMap, take, takeUntil, tap } from 'rxjs/operators';\nimport { StoreService, UpdateLocaleStateAction } from '../store';\nimport { LogService } from '../log';\nimport { I18nService } from '../i18n';\nimport { GLOBAL_CONFIG_TOKEN } from '../config/tokens';\nimport { createSelector } from '@ngrx/store';\n\nexport type LocaleMapper = (locale: string) => any;\nexport const LOCALE_ID_MAPPER = new InjectionToken<LocaleMapper>('localeIdMapper');\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class LocaleService<T extends LocaleState = LocaleState> extends EuiService<T | LocaleState> implements OnDestroy {\n    private readonly logger: Logger;\n    private subNotifier: Subject<any> = new Subject();\n    protected config: LocaleServiceConfig;\n\n    constructor(\n        protected store: StoreService,\n        @Inject(GLOBAL_CONFIG_TOKEN) protected baseGlobalConfig: GlobalConfig,\n        @Inject(LOCALE_ID) protected locale_id: string,\n        @Optional() @Inject(LOCALE_ID_MAPPER) private localeMapper: LocaleMapper,\n        @Optional() private i18n: I18nService,\n        @Optional() private log: LogService\n    ) {\n        super({ id: getLocaleId(locale_id) });\n        if (log) {\n            this.logger = log.getLogger('core.LocaleService');\n        }\n\n        this.config = getLocaleServiceConfigFromBase(this.baseGlobalConfig);\n        // in case no localeMapper provided, set the angular getLocaleId as default\n        if (!this.localeMapper) {\n            this.localeMapper = getLocaleId;\n        }\n    }\n\n    ngOnDestroy(): void {\n        this.subNotifier.next(void 0);\n        this.subNotifier.complete();\n    }\n\n    getState<K = T>(mapFn?: (state: T) => K): Observable<K>;\n    getState<a extends keyof T>(key?: a): Observable<T[a]>;\n    getState<K>(keyOrMapFn?: ((state: T) => K) | string): Observable<K> {\n        let selector: any = getLocaleState;\n\n        if (keyOrMapFn) {\n            switch (typeof keyOrMapFn) {\n                case 'function':\n                    selector = createSelector(getLocaleState, keyOrMapFn);\n                    break;\n                case 'string':\n                    selector = createSelector(getLocaleState, (state) => state[keyOrMapFn]);\n                    break;\n            }\n        }\n        return this.store.select(selector).pipe(\n            takeUntil(this.subNotifier),\n            // in case service didn't init fallback to LOCALE_ID token value\n            map((state) => (state ? state : this.stateInstance ? this.stateInstance : this.locale_id))\n        );\n    }\n\n    init(state?: LocaleState | undefined): Observable<EuiServiceStatus> {\n        super.initEuiService();\n\n        // bind language changes to locale changes\n        if (this.config?.bindWithTranslate) {\n            this.bindTranslateServiceLangChangeToState();\n        }\n\n        // dynamically load locale based on provided configuration\n        const availableLocales = state?.available || this.config?.available || this.getBrowserLocales() || [this.currentLocale];\n        return this.loadLocale(availableLocales).pipe(\n            takeUntil(this.subNotifier),\n            tap(() => this.updateState({ id: this.currentLocale }))\n        );\n    }\n\n    /**\n     * dynamically load locale and update the state\n     */\n    updateState(state: LocaleState): void {\n        try {\n            const id = this.localeMapper(state.id);\n            this.store.dispatch(new UpdateLocaleStateAction({ ...state, id }));\n            // update global TOKEN ID based on configuration\n            if (this.config.affectGlobalLocale) {\n                this.locale_id = id;\n            }\n        } catch (e) {\n            const message = `Locale for '${state.id}' is not available.\n                 Please use addLocale('${state.id}') first`;\n            if (this.log) {\n                this.logger.info(message, e);\n            }\n            throw new Error(message);\n        }\n    }\n\n    addLocale(id: string): Observable<EuiServiceStatus> {\n        return this.loadLocale(id);\n    }\n\n    get previousLocale(): string {\n        return this.prevStateInstance?.id || this.currentLocale;\n    }\n\n    get currentLocale(): string {\n        return this.stateInstance?.id;\n    }\n\n    /**\n     * load and register locale data dynamically\n     *\n     * @param locale array of locale to load\n     */\n    private loadLocale(locale: string[] | string): Observable<EuiServiceStatus> {\n        // locale = Array.isArray(locale) ? locale : [locale];\n        // const localeImports: Observable<{ data: any, localeId: string, extraData: any }>[]\n        //     = this.filterRegisteredLocales(locale).map(this.importDataAndExtraLocale.bind(this));\n        //\n        // // in case localeImports array is empty because locale exists, Observable still needs to complete\n        // if (localeImports.length < 1) {\n        //     return of({ success: true });\n        // }\n        //\n        // return forkJoin(...localeImports).pipe(\n        //     takeUntil(this.subNotifier),\n        //     map(localeData => {\n        //         // filter out null results and registerLocaleData including extra\n        //         localeData.filter(({ data }) => data)\n        //             .forEach(({ data, localeId, extraData }) => registerLocaleData(data, localeId, extraData));\n        //         return { success: true };\n        //     }),\n        //     catchError(error => {\n        //         if (this.log) {\n        //             this.logger.debug(`Locale load error: ${error.message}`, error);\n        //         }\n        //         return of({ success: false, error: error });\n        //     })\n        // );\n        return of({ success: true });\n    }\n\n    /**\n     * listen for language changes and dynamically set locale accordingly. In case of non registered locale register it\n     * dynamically.\n     */\n    private bindTranslateServiceLangChangeToState() {\n        if (this.i18n) {\n            this.i18n.onStateChange\n                .pipe(\n                    takeUntil(this.subNotifier),\n                    // filter out null values\n                    filter((state) => state?.activeLang !== null && state?.activeLang !== undefined),\n                    // BEWARE: filter is based on convention that locale id sliced(2) will match activeLang e.g. en-US => en\n                    // Also, if activeLang is 'en' and locale is 'en-GB' it will not trigger locale change\n                    filter((state) => state.activeLang.toLowerCase() !== this.stateInstance?.id.slice(0, 2).toLowerCase()),\n                    // to check if registration of locale otherwise register it\n                    switchMap((value) =>\n                        of(value).pipe(\n                            // getLocaleId may throw Error(`Missing locale data for the locale \"${locale}\".`);\n                            switchMap((i18state) => {\n                                // check if activeLang is null or undefined\n                                if (!i18state.activeLang) {\n                                    return throwError('Has i18nService initialized? If not make sure i18nService.init().subscribe(..)');\n                                }\n                                return of(this.localeMapper(i18state.activeLang));\n                            }),\n                            catchError((error) => {\n                                if (this.log) {\n                                    this.logger.debug(error);\n                                }\n                                return this.loadLocale(value?.activeLang).pipe(\n                                    filter((s: EuiServiceStatus) => s.success),\n                                    map(() => this.localeMapper(value?.activeLang)),\n                                    catchError((e) => {\n                                        if (this.log) {\n                                            this.logger.debug('Something went terribly really wrong during locale loading', e.err.message);\n                                        }\n                                        return of(e);\n                                    })\n                                );\n                            })\n                        )\n                    ),\n                    // update the \"available\" array attribute with newly registered\n                    switchMap((id) =>\n                        this.getState().pipe(\n                            take(1),\n                            map((state: LocaleState) => {\n                                const available = state?.available ? state.available : [];\n                                return { ...state, id, available: Array.from(new Set([...available, id])) };\n                            })\n                        )\n                    )\n                )\n                .subscribe((state: LocaleState) => {\n                    this.updateState(state);\n                });\n        }\n    }\n\n    /**\n     * retrieve locales from browser\n     *\n     * @param options\n     */\n    private getBrowserLocales(): string[] {\n        const browserLocales = navigator.languages === undefined ? [navigator.language] : navigator.languages;\n\n        if (!browserLocales) {\n            return undefined;\n        }\n\n        return browserLocales.map((locale) => locale.trim());\n    }\n\n    /**\n     * if locale is already registered filtered out.\n     *\n     * @param locales A string array contains all locale id e.g. [\"el\", \"el-CY\"]\n     */\n    private filterRegisteredLocales(locales: string[]): string[] {\n        return locales.filter((loc: string) => {\n            try {\n                getLocaleId(loc);\n                return false;\n            } catch (e) {\n                return true;\n            }\n        });\n    }\n\n    /**\n     * returns an Observable which loads the locale based on provided ID\n     *\n     * @param id the locale id e.g. en, el-CY\n     * @private\n     */\n    // private importLocale(id: string): Promise<any> {\n    //     // in case of an error, catch it and return null\n    //     return import(\n    //         /* webpackExclude: /\\.d\\.ts$/ */\n    //         /* webpackMode: \"lazy-once\" */\n    //         /* webpackChunkName: \"i18n-base\" */\n    //         `@/../node_modules/@angular/common/locales/${id}`)\n    //         .then(m => m.default)\n    //         .catch(error => {\n    //             if (this.log) {\n    //                 this.logger.debug(`Locale with ID: \"${id}\" failed to load. Error: ${error.message}`, error);\n    //             }\n    //             return null;\n    //         });\n    // }\n\n    /**\n     * returns a Promise which loads the locale based on provided ID\n     *\n     * @param id the locale id e.g. en, el-CY\n     * @private\n     */\n    // private importExtraLocale(id: string): Promise<any> {\n    //     // in case of an error, catch it and return null\n    //     return import(\n    //         /* webpackExclude: /\\.d\\.ts$/ */\n    //         /* webpackMode: \"lazy-once\" */\n    //         /* webpackChunkName: \"i18n-extra\" */\n    //         `@/../node_modules/@angular/common/locales/extra/${id}`)\n    //         .then(m => m.default)\n    //         .catch(error => {\n    //             if (this.log) {\n    //                 this.logger.debug(`Extra Locale with ID: \"${id}\" failed to load. Error: ${error.message}`, error);\n    //             }\n    //             return null;\n    //         });\n    // }\n\n    /**\n     * Imports Locale and then Extra. It returns the Object which registerLocale(...) function needs.\n     *\n     * @param localeId The id of the locale\n     * @private\n     */\n    // private importDataAndExtraLocale(localeId: string): Observable<{ data: any, localeId: string, extraData: any }> {\n    //     return from(this.importLocale(localeId)).pipe(\n    //         mergeMap((data) => from(this.importExtraLocale(localeId)).pipe(map((extraData) =>\n    //                 Object.assign({}, { data, localeId, extraData }))),\n    //             1\n    //         ));\n    // }\n}\n"]}

package/esm2020/lib/services/storage/local-forage.service.mjs

@@ -1,93 +0,0 @@
-import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
-import { from } from 'rxjs';
-import { take, tap } from 'rxjs/operators';
-import * as lf from 'localforage';
-import { AsyncStorageService } from './async-storage.service';
-import * as i0 from "@angular/core";
-import * as i1 from "../log/log.service";
-/** @internal */
-export const localForage = 'defineDriver' in lf ? lf : lf['default'];
-export const LOCAL_FORAGE_SERVICE_CONFIG_TOKEN = new InjectionToken('LOCAL_FORAGE_SERVICE_CONFIG');
-/**
- * localforage service, using the localForage javascript library
- * https://localforage.github.io/localForage
- */
-export class LocalForageService extends AsyncStorageService {
-    constructor(config, log) {
-        super();
-        this.config = config;
-        this.log = log;
-        // configure localforage, if specified
-        if (config) {
-            localForage.config(config);
-        }
-    }
-    /**
-     * the name of the storage service
-     */
-    name() {
-        return LocalForageService.NAME;
-    }
-    /**
-     * reflects the readiness of the storage
-     * @returns one time emission Observable<void>
-     */
-    ready() {
-        return from(localForage.ready()).pipe(take(1), tap(() => { }, (err) => {
-            if (this.log) {
-                this.log.error(this.name(), 'ready', err);
-            }
-        }));
-    }
-    /**
-     * retrieve an object from localforage
-     * @param key the associated key
-     * @returns one time emission Observable of value
-     */
-    get(key) {
-        return from(localForage.getItem(key)).pipe(take(1), tap(() => { }, (err) => {
-            if (this.log) {
-                this.log.error(this.name(), 'get', err);
-            }
-        }));
-    }
-    /**
-     * sets an object in localforage
-     * @param key the associated key
-     * @param value the value to set
-     * @returns one time emission Observable
-     */
-    set(key, value) {
-        return from(localForage.setItem(key, value)).pipe(take(1), tap(() => { }, (err) => {
-            if (this.log) {
-                this.log.error(this.name(), 'set', err);
-            }
-        }));
-    }
-    /**
-     * removes an object from localforage
-     * @param key the associated key
-     * @returns one time emission Observable
-     */
-    remove(key) {
-        return from(localForage.removeItem(key)).pipe(take(1), tap(() => { }, (err) => {
-            if (this.log) {
-                this.log.error(this.name(), 'remove', err);
-            }
-        }));
-    }
-}
-LocalForageService.NAME = 'LocalForageService';
-/** @nocollapse */ LocalForageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.2", ngImport: i0, type: LocalForageService, deps: [{ token: LOCAL_FORAGE_SERVICE_CONFIG_TOKEN, optional: true }, { token: i1.LogService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ LocalForageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.2", ngImport: i0, type: LocalForageService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.2", ngImport: i0, type: LocalForageService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [LOCAL_FORAGE_SERVICE_CONFIG_TOKEN]
-                }, {
-                    type: Optional
-                }] }, { type: i1.LogService, decorators: [{
-                    type: Optional
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/storage/local-storage.service.mjs

@@ -1,75 +0,0 @@
-import { Injectable, Optional } from '@angular/core';
-import { StorageService } from './storage.service';
-import * as i0 from "@angular/core";
-import * as i1 from "../log/log.service";
-/**
- * localStorage service
- */
-export class LocalStorageService extends StorageService {
-    constructor(log) {
-        super();
-        this.log = log;
-    }
-    /**
-     * the name of the storage service
-     */
-    name() {
-        return LocalStorageService.NAME;
-    }
-    /**
-     * retrieve an object from local storage
-     * @param key the associated key
-     * @returns the value or undefined, if case of error
-     */
-    get(key) {
-        try {
-            const serialized = localStorage.getItem(key);
-            return serialized && JSON.parse(serialized);
-        }
-        catch (err) {
-            if (this.log) {
-                this.log.error(this.name(), 'get', err);
-            }
-            return undefined;
-        }
-    }
-    /**
-     * sets an object in local storage
-     * @param key the associated key
-     * @param value the value to set
-     */
-    set(key, value) {
-        try {
-            const serialized = JSON.stringify(value);
-            localStorage.setItem(key, serialized);
-        }
-        catch (err) {
-            if (this.log) {
-                this.log.error(this.name(), 'set', err);
-            }
-        }
-    }
-    /**
-     * removes an object from local storage
-     * @param key the associated key
-     */
-    remove(key) {
-        try {
-            localStorage.removeItem(key);
-        }
-        catch (err) {
-            if (this.log) {
-                this.log.error(this.name(), 'remove', err);
-            }
-        }
-    }
-}
-LocalStorageService.NAME = 'LocalStorageService';
-/** @nocollapse */ LocalStorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.2", ngImport: i0, type: LocalStorageService, deps: [{ token: i1.LogService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ LocalStorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.2", ngImport: i0, type: LocalStorageService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.2", ngImport: i0, type: LocalStorageService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.LogService, decorators: [{
-                    type: Optional
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/storage/session-storage.service.mjs

@@ -1,75 +0,0 @@
-import { Injectable, Optional } from '@angular/core';
-import { StorageService } from './storage.service';
-import * as i0 from "@angular/core";
-import * as i1 from "../log/log.service";
-/**
- * sessionStorage service
- */
-export class SessionStorageService extends StorageService {
-    constructor(log) {
-        super();
-        this.log = log;
-    }
-    /**
-     * the name of the storage service
-     */
-    name() {
-        return SessionStorageService.NAME;
-    }
-    /**
-     * retrieve an object from session storage
-     * @param key the associated key
-     * @returns the value or undefined, if case of error
-     */
-    get(key) {
-        try {
-            const serialized = sessionStorage.getItem(key);
-            return serialized && JSON.parse(serialized);
-        }
-        catch (err) {
-            if (this.log) {
-                this.log.error(this.name(), 'get', err);
-            }
-            return undefined;
-        }
-    }
-    /**
-     * sets an object in session storage
-     * @param key the associated key
-     * @param value the value to set
-     */
-    set(key, value) {
-        try {
-            const serialized = JSON.stringify(value);
-            sessionStorage.setItem(key, serialized);
-        }
-        catch (err) {
-            if (this.log) {
-                this.log.error(this.name(), 'set', err);
-            }
-        }
-    }
-    /**
-     * removes an object from session storage
-     * @param key the associated key
-     */
-    remove(key) {
-        try {
-            sessionStorage.removeItem(key);
-        }
-        catch (err) {
-            if (this.log) {
-                this.log.error(this.name(), 'remove', err);
-            }
-        }
-    }
-}
-SessionStorageService.NAME = 'SessionStorageService';
-/** @nocollapse */ SessionStorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.2", ngImport: i0, type: SessionStorageService, deps: [{ token: i1.LogService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ SessionStorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0-next.2", ngImport: i0, type: SessionStorageService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.2", ngImport: i0, type: SessionStorageService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.LogService, decorators: [{
-                    type: Optional
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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