@abp/ng.core 7.2.1 → 7.3.0-rc.1

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

@@ -0,0 +1,103 @@
+import { Injectable, Injector } from '@angular/core';
+import { BehaviorSubject, of, ReplaySubject, Subject, } from 'rxjs';
+import { catchError, debounceTime, filter, shareReplay, switchMap, takeUntil, tap, } from 'rxjs/operators';
+import { LIST_QUERY_DEBOUNCE_TIME } from '../tokens/list.token';
+import * as i0 from "@angular/core";
+class ListService {
+    set filter(value) {
+        this._filter = value;
+        this.get();
+    }
+    get filter() {
+        return this._filter;
+    }
+    set maxResultCount(value) {
+        this._maxResultCount = value;
+        this.get();
+    }
+    get maxResultCount() {
+        return this._maxResultCount;
+    }
+    set page(value) {
+        if (value === this._page)
+            return;
+        this._page = value;
+        this.get();
+    }
+    get page() {
+        return this._page;
+    }
+    set sortKey(value) {
+        this._sortKey = value;
+        this.get();
+    }
+    get sortKey() {
+        return this._sortKey;
+    }
+    set sortOrder(value) {
+        this._sortOrder = value;
+        this.get();
+    }
+    get sortOrder() {
+        return this._sortOrder;
+    }
+    get query$() {
+        return this._query$
+            .asObservable()
+            .pipe(this.delay, shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    get isLoading$() {
+        return this._isLoading$.asObservable();
+    }
+    constructor(injector) {
+        this._filter = '';
+        this._maxResultCount = 10;
+        this._skipCount = 0;
+        this._page = 0;
+        this._sortKey = '';
+        this._sortOrder = '';
+        this._query$ = new ReplaySubject(1);
+        this._isLoading$ = new BehaviorSubject(false);
+        this.destroy$ = new Subject();
+        this.get = () => {
+            this.resetPageWhenUnchanged();
+            this.next();
+        };
+        this.getWithoutPageReset = () => {
+            this.next();
+        };
+        const delay = injector.get(LIST_QUERY_DEBOUNCE_TIME, 300);
+        this.delay = delay ? debounceTime(delay) : tap();
+        this.get();
+    }
+    hookToQuery(streamCreatorCallback) {
+        return this.query$.pipe(tap(() => this._isLoading$.next(true)), switchMap(query => streamCreatorCallback(query).pipe(catchError(() => of(null)))), filter(Boolean), tap(() => this._isLoading$.next(false)), shareReplay({ bufferSize: 1, refCount: true }), takeUntil(this.destroy$));
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+    }
+    resetPageWhenUnchanged() {
+        const skipCount = this._page * this._maxResultCount;
+        if (skipCount === this._skipCount) {
+            this._page = 0;
+            this._skipCount = 0;
+        }
+        else
+            this._skipCount = skipCount;
+    }
+    next() {
+        this._query$.next({
+            filter: this._filter || undefined,
+            maxResultCount: this._maxResultCount,
+            skipCount: this._page * this._maxResultCount,
+            sorting: this._sortOrder ? `${this._sortKey} ${this._sortOrder}` : undefined,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ListService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ListService }); }
+}
+export { ListService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ListService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.service.js","sourceRoot":"","sources":["../../../../../../packages/core/src/lib/services/list.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, OnDestroy } from '@angular/core';\r\nimport {\r\n  BehaviorSubject,\r\n  MonoTypeOperatorFunction,\r\n  Observable,\r\n  of,\r\n  ReplaySubject,\r\n  Subject,\r\n} from 'rxjs';\r\nimport {\r\n  catchError,\r\n  debounceTime,\r\n  filter,\r\n  shareReplay,\r\n  switchMap,\r\n  takeUntil,\r\n  tap,\r\n} from 'rxjs/operators';\r\nimport { ABP } from '../models/common';\r\nimport { PagedResultDto } from '../models/dtos';\r\nimport { LIST_QUERY_DEBOUNCE_TIME } from '../tokens/list.token';\r\n\r\n@Injectable()\r\nexport class ListService<QueryParamsType = ABP.PageQueryParams | any> implements OnDestroy {\r\n  private _filter = '';\r\n  set filter(value: string) {\r\n    this._filter = value;\r\n    this.get();\r\n  }\r\n  get filter(): string {\r\n    return this._filter;\r\n  }\r\n\r\n  private _maxResultCount = 10;\r\n  set maxResultCount(value: number) {\r\n    this._maxResultCount = value;\r\n    this.get();\r\n  }\r\n  get maxResultCount(): number {\r\n    return this._maxResultCount;\r\n  }\r\n\r\n  private _skipCount = 0;\r\n  private _page = 0;\r\n  set page(value: number) {\r\n    if (value === this._page) return;\r\n\r\n    this._page = value;\r\n    this.get();\r\n  }\r\n  get page(): number {\r\n    return this._page;\r\n  }\r\n\r\n  private _sortKey = '';\r\n  set sortKey(value: string) {\r\n    this._sortKey = value;\r\n    this.get();\r\n  }\r\n  get sortKey(): string {\r\n    return this._sortKey;\r\n  }\r\n\r\n  private _sortOrder = '';\r\n  set sortOrder(value: string) {\r\n    this._sortOrder = value;\r\n    this.get();\r\n  }\r\n  get sortOrder(): string {\r\n    return this._sortOrder;\r\n  }\r\n\r\n  private _query$ = new ReplaySubject<QueryParamsType>(1);\r\n\r\n  get query$(): Observable<QueryParamsType> {\r\n    return this._query$\r\n      .asObservable()\r\n      .pipe(this.delay, shareReplay({ bufferSize: 1, refCount: true }));\r\n  }\r\n\r\n  private _isLoading$ = new BehaviorSubject(false);\r\n\r\n  private destroy$ = new Subject<void>();\r\n\r\n  private delay: MonoTypeOperatorFunction<QueryParamsType>;\r\n\r\n  get isLoading$(): Observable<boolean> {\r\n    return this._isLoading$.asObservable();\r\n  }\r\n\r\n  get = () => {\r\n    this.resetPageWhenUnchanged();\r\n    this.next();\r\n  };\r\n\r\n  getWithoutPageReset = () => {\r\n    this.next();\r\n  };\r\n\r\n  constructor(injector: Injector) {\r\n    const delay = injector.get(LIST_QUERY_DEBOUNCE_TIME, 300);\r\n    this.delay = delay ? debounceTime(delay) : tap();\r\n    this.get();\r\n  }\r\n\r\n  hookToQuery<T>(\r\n    streamCreatorCallback: QueryStreamCreatorCallback<T, QueryParamsType>,\r\n  ): Observable<PagedResultDto<T>> {\r\n    return this.query$.pipe(\r\n      tap(() => this._isLoading$.next(true)),\r\n      switchMap(query => streamCreatorCallback(query).pipe(catchError(() => of(null)))),\r\n      filter(Boolean),\r\n      tap(() => this._isLoading$.next(false)),\r\n      shareReplay<any>({ bufferSize: 1, refCount: true }),\r\n      takeUntil(this.destroy$),\r\n    );\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.destroy$.next();\r\n  }\r\n\r\n  private resetPageWhenUnchanged() {\r\n    const skipCount = this._page * this._maxResultCount;\r\n\r\n    if (skipCount === this._skipCount) {\r\n      this._page = 0;\r\n      this._skipCount = 0;\r\n    } else this._skipCount = skipCount;\r\n  }\r\n\r\n  private next() {\r\n    this._query$.next({\r\n      filter: this._filter || undefined,\r\n      maxResultCount: this._maxResultCount,\r\n      skipCount: this._page * this._maxResultCount,\r\n      sorting: this._sortOrder ? `${this._sortKey} ${this._sortOrder}` : undefined,\r\n    } as any as QueryParamsType);\r\n  }\r\n}\r\n\r\nexport type QueryStreamCreatorCallback<T, QueryParamsType = ABP.PageQueryParams> = (\r\n  query: QueryParamsType,\r\n) => Observable<PagedResultDto<T>>;\r\n"]}

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

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+class AbpLocalStorageService {
+    constructor() { }
+    get length() {
+        return localStorage.length;
+    }
+    clear() {
+        localStorage.clear();
+    }
+    getItem(key) {
+        return localStorage.getItem(key);
+    }
+    key(index) {
+        return localStorage.key(index);
+    }
+    removeItem(key) {
+        localStorage.removeItem(key);
+    }
+    setItem(key, value) {
+        localStorage.setItem(key, value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpLocalStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpLocalStorageService, providedIn: 'root' }); }
+}
+export { AbpLocalStorageService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpLocalStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWwtc3RvcmFnZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvbGliL3NlcnZpY2VzL2xvY2FsLXN0b3JhZ2Uuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUUzQyxNQUdhLHNCQUFzQjtJQUNqQyxnQkFBZSxDQUFDO0lBRWhCLElBQUksTUFBTTtRQUNSLE9BQU8sWUFBWSxDQUFDLE1BQU0sQ0FBQztJQUM3QixDQUFDO0lBRUQsS0FBSztRQUNILFlBQVksQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUN2QixDQUFDO0lBQ0QsT0FBTyxDQUFDLEdBQVc7UUFDakIsT0FBTyxZQUFZLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ25DLENBQUM7SUFDRCxHQUFHLENBQUMsS0FBYTtRQUNmLE9BQU8sWUFBWSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNqQyxDQUFDO0lBQ0QsVUFBVSxDQUFDLEdBQVc7UUFDcEIsWUFBWSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUMvQixDQUFDO0lBQ0QsT0FBTyxDQUFDLEdBQVcsRUFBRSxLQUFhO1FBQ2hDLFlBQVksQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQ25DLENBQUM7OEdBckJVLHNCQUFzQjtrSEFBdEIsc0JBQXNCLGNBRnJCLE1BQU07O1NBRVAsc0JBQXNCOzJGQUF0QixzQkFBc0I7a0JBSGxDLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290JyxcclxufSlcclxuZXhwb3J0IGNsYXNzIEFicExvY2FsU3RvcmFnZVNlcnZpY2UgaW1wbGVtZW50cyBTdG9yYWdlIHtcclxuICBjb25zdHJ1Y3RvcigpIHt9XHJcbiAgW25hbWU6IHN0cmluZ106IGFueTtcclxuICBnZXQgbGVuZ3RoKCk6IG51bWJlciB7XHJcbiAgICByZXR1cm4gbG9jYWxTdG9yYWdlLmxlbmd0aDtcclxuICB9XHJcblxyXG4gIGNsZWFyKCk6IHZvaWQge1xyXG4gICAgbG9jYWxTdG9yYWdlLmNsZWFyKCk7XHJcbiAgfVxyXG4gIGdldEl0ZW0oa2V5OiBzdHJpbmcpOiBzdHJpbmcge1xyXG4gICAgcmV0dXJuIGxvY2FsU3RvcmFnZS5nZXRJdGVtKGtleSk7XHJcbiAgfVxyXG4gIGtleShpbmRleDogbnVtYmVyKTogc3RyaW5nIHtcclxuICAgIHJldHVybiBsb2NhbFN0b3JhZ2Uua2V5KGluZGV4KTtcclxuICB9XHJcbiAgcmVtb3ZlSXRlbShrZXk6IHN0cmluZyk6IHZvaWQge1xyXG4gICAgbG9jYWxTdG9yYWdlLnJlbW92ZUl0ZW0oa2V5KTtcclxuICB9XHJcbiAgc2V0SXRlbShrZXk6IHN0cmluZywgdmFsdWU6IHN0cmluZyk6IHZvaWQge1xyXG4gICAgbG9jYWxTdG9yYWdlLnNldEl0ZW0oa2V5LCB2YWx1ZSk7XHJcbiAgfVxyXG59XHJcbiJdfQ==

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

@@ -0,0 +1,218 @@
+import { registerLocaleData } from '@angular/common';
+import { Injectable, Injector, isDevMode, Optional, SkipSelf } from '@angular/core';
+import { BehaviorSubject, combineLatest, from, Subject } from 'rxjs';
+import { filter, map, switchMap } from 'rxjs/operators';
+import { localizations$ } from '../tokens/localization.token';
+import { CORE_OPTIONS } from '../tokens/options.token';
+import { createLocalizer, createLocalizerWithFallback } from '../utils/localization-utils';
+import { interpolate } from '../utils/string-utils';
+import { ConfigStateService } from './config-state.service';
+import { SessionStateService } from './session-state.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./session-state.service";
+import * as i2 from "./config-state.service";
+class LocalizationService {
+    /**
+     * Returns currently selected language
+     * Even though this looks like it's redundant to return the same value as `getLanguage()`,
+     * it's actually not. This could be invoked any time, and the latestLang could be different from the
+     * sessionState.getLanguage() value.
+     */
+    get currentLang() {
+        return this.latestLang || this.sessionState.getLanguage();
+    }
+    get currentLang$() {
+        return this.sessionState.getLanguage$();
+    }
+    get languageChange$() {
+        return this._languageChange$.asObservable();
+    }
+    constructor(sessionState, injector, otherInstance, configState) {
+        this.sessionState = sessionState;
+        this.injector = injector;
+        this.configState = configState;
+        this.latestLang = this.sessionState.getLanguage();
+        this._languageChange$ = new Subject();
+        this.uiLocalizations$ = new BehaviorSubject(new Map());
+        this.localizations$ = new BehaviorSubject(new Map());
+        if (otherInstance)
+            throw new Error('LocalizationService should have only one instance.');
+        this.listenToSetLanguage();
+        this.initLocalizationValues();
+    }
+    initLocalizationValues() {
+        localizations$.subscribe(val => this.addLocalization(val));
+        const legacyResources$ = this.configState.getDeep$('localization.values');
+        const remoteLocalizations$ = this.configState.getDeep$('localization.resources');
+        const currentLanguage$ = this.sessionState.getLanguage$();
+        const uiLocalizations$ = combineLatest([currentLanguage$, this.uiLocalizations$]).pipe(map(([currentLang, localizations]) => localizations.get(currentLang)));
+        combineLatest([legacyResources$, remoteLocalizations$, uiLocalizations$])
+            .pipe(map(([legacy, resource, local]) => {
+            if (!resource) {
+                return;
+            }
+            const remote = combineLegacyandNewResources(legacy || {}, resource);
+            if (remote) {
+                if (!local) {
+                    local = new Map();
+                }
+                Object.entries(remote).forEach(entry => {
+                    const resourceName = entry[0];
+                    const remoteTexts = entry[1];
+                    let resource = local?.get(resourceName) || {};
+                    resource = { ...resource, ...remoteTexts };
+                    local?.set(resourceName, resource);
+                });
+            }
+            return local;
+        }), filter(Boolean))
+            .subscribe(val => this.localizations$.next(val));
+    }
+    addLocalization(localizations) {
+        if (!localizations)
+            return;
+        const localizationMap = this.uiLocalizations$.value;
+        localizations.forEach(loc => {
+            const cultureMap = localizationMap.get(loc.culture) || new Map();
+            loc.resources.forEach(res => {
+                let resource = cultureMap.get(res.resourceName) || {};
+                resource = { ...resource, ...res.texts };
+                cultureMap.set(res.resourceName, resource);
+            });
+            localizationMap.set(loc.culture, cultureMap);
+        });
+        this.uiLocalizations$.next(localizationMap);
+    }
+    listenToSetLanguage() {
+        this.sessionState
+            .onLanguageChange$()
+            .pipe(filter(lang => this.configState.getDeep('localization.currentCulture.cultureName') !== lang), switchMap(lang => this.configState.refreshAppState().pipe(map(() => lang))), filter(Boolean), switchMap(lang => from(this.registerLocale(lang).then(() => lang))))
+            .subscribe(lang => this._languageChange$.next(lang));
+    }
+    registerLocale(locale) {
+        const { registerLocaleFn } = this.injector.get(CORE_OPTIONS);
+        return registerLocaleFn(locale).then(module => {
+            if (module?.default)
+                registerLocaleData(module.default);
+            this.latestLang = locale;
+        });
+    }
+    /**
+     * Returns an observable localized text with the given interpolation parameters in current language.
+     * @param key Localizaton key to replace with localized text
+     * @param interpolateParams Values to interpolate
+     */
+    get(key, ...interpolateParams) {
+        return this.configState
+            .getAll$()
+            .pipe(map(state => this.getLocalization(state, key, ...interpolateParams)));
+    }
+    getResource(resourceName) {
+        return this.localizations$.value.get(resourceName);
+    }
+    getResource$(resourceName) {
+        return this.localizations$.pipe(map(res => res.get(resourceName)));
+    }
+    /**
+     * Returns localized text with the given interpolation parameters in current language.
+     * @param key Localization key to replace with localized text
+     * @param interpolateParams Values to intepolate.
+     */
+    instant(key, ...interpolateParams) {
+        return this.getLocalization(this.configState.getAll(), key, ...interpolateParams);
+    }
+    localize(resourceName, key, defaultValue) {
+        return this.configState.getOne$('localization').pipe(map(createLocalizer), map(localize => localize(resourceName, key, defaultValue)));
+    }
+    localizeSync(resourceName, key, defaultValue) {
+        const localization = this.configState.getOne('localization');
+        return createLocalizer(localization)(resourceName, key, defaultValue);
+    }
+    localizeWithFallback(resourceNames, keys, defaultValue) {
+        return this.configState.getOne$('localization').pipe(map(createLocalizerWithFallback), map(localizeWithFallback => localizeWithFallback(resourceNames, keys, defaultValue)));
+    }
+    localizeWithFallbackSync(resourceNames, keys, defaultValue) {
+        const localization = this.configState.getOne('localization');
+        return createLocalizerWithFallback(localization)(resourceNames, keys, defaultValue);
+    }
+    getLocalization(state, key, ...interpolateParams) {
+        if (!key)
+            key = '';
+        let defaultValue = '';
+        if (typeof key !== 'string') {
+            defaultValue = key.defaultValue;
+            key = key.key;
+        }
+        const keys = key.split('::');
+        const warn = (message) => {
+            if (isDevMode())
+                console.warn(message);
+        };
+        if (keys.length < 2) {
+            warn('The localization source separator (::) not found.');
+            return defaultValue || key;
+        }
+        if (!state.localization)
+            return defaultValue || keys[1];
+        const sourceName = keys[0] || state.localization.defaultResourceName;
+        const sourceKey = keys[1];
+        if (sourceName === '_') {
+            return defaultValue || sourceKey;
+        }
+        if (!sourceName) {
+            warn('Localization source name is not specified and the defaultResourceName was not defined!');
+            return defaultValue || sourceKey;
+        }
+        const source = this.localizations$.value.get(sourceName);
+        if (!source) {
+            warn('Could not find localization source: ' + sourceName);
+            return defaultValue || sourceKey;
+        }
+        let localization = source[sourceKey];
+        if (typeof localization === 'undefined') {
+            return defaultValue || sourceKey;
+        }
+        interpolateParams = interpolateParams.filter(params => params != null);
+        if (localization)
+            localization = interpolate(localization, interpolateParams);
+        if (typeof localization !== 'string')
+            localization = '';
+        return localization || defaultValue || key;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: LocalizationService, deps: [{ token: i1.SessionStateService }, { token: i0.Injector }, { token: LocalizationService, optional: true, skipSelf: true }, { token: i2.ConfigStateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: LocalizationService, providedIn: 'root' }); }
+}
+export { LocalizationService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: LocalizationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.SessionStateService }, { type: i0.Injector }, { type: LocalizationService, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i2.ConfigStateService }]; } });
+function recursivelyMergeBaseResources(baseResourceName, source) {
+    const item = source[baseResourceName];
+    if (item.baseResources.length === 0) {
+        return item;
+    }
+    return item.baseResources.reduce((acc, baseResource) => {
+        const baseItem = recursivelyMergeBaseResources(baseResource, source);
+        const texts = { ...baseItem.texts, ...item.texts };
+        return { ...acc, texts };
+    }, item);
+}
+function mergeResourcesWithBaseResource(resource) {
+    const entities = Object.keys(resource).map(key => {
+        const newValue = recursivelyMergeBaseResources(key, resource);
+        return [key, newValue];
+    });
+    return entities.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+}
+function combineLegacyandNewResources(legacy, resource) {
+    const mergedResource = mergeResourcesWithBaseResource(resource);
+    return Object.entries(mergedResource).reduce((acc, [key, value]) => {
+        return { ...acc, [key]: value.texts };
+    }, legacy);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localization.service.js","sourceRoot":"","sources":["../../../../../../packages/core/src/lib/services/localization.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { registerLocaleData } from '@angular/common';\r\nimport { Injectable, Injector, isDevMode, Optional, SkipSelf } from '@angular/core';\r\nimport { BehaviorSubject, combineLatest, from, Observable, Subject } from 'rxjs';\r\nimport { filter, map, switchMap } from 'rxjs/operators';\r\nimport { ABP } from '../models/common';\r\nimport { LocalizationWithDefault } from '../models/localization';\r\nimport {\r\n  ApplicationConfigurationDto,\r\n  ApplicationLocalizationResourceDto,\r\n} from '../proxy/volo/abp/asp-net-core/mvc/application-configurations/models';\r\nimport { localizations$ } from '../tokens/localization.token';\r\nimport { CORE_OPTIONS } from '../tokens/options.token';\r\nimport { createLocalizer, createLocalizerWithFallback } from '../utils/localization-utils';\r\nimport { interpolate } from '../utils/string-utils';\r\nimport { ConfigStateService } from './config-state.service';\r\nimport { SessionStateService } from './session-state.service';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class LocalizationService {\r\n  private latestLang = this.sessionState.getLanguage();\r\n  private _languageChange$ = new Subject<string>();\r\n\r\n  private uiLocalizations$ = new BehaviorSubject(\r\n    new Map<string, Map<string, Record<string, string>>>(),\r\n  );\r\n\r\n  private localizations$ = new BehaviorSubject(new Map<string, Record<string, string>>());\r\n\r\n  /**\r\n   * Returns currently selected language\r\n   * Even though this looks like it's redundant to return the same value as `getLanguage()`,\r\n   * it's actually not. This could be invoked any time, and the latestLang could be different from the\r\n   * sessionState.getLanguage() value.\r\n   */\r\n  get currentLang(): string {\r\n    return this.latestLang || this.sessionState.getLanguage();\r\n  }\r\n\r\n  get currentLang$(): Observable<string> {\r\n    return this.sessionState.getLanguage$();\r\n  }\r\n\r\n  get languageChange$(): Observable<string> {\r\n    return this._languageChange$.asObservable();\r\n  }\r\n\r\n  constructor(\r\n    private sessionState: SessionStateService,\r\n    private injector: Injector,\r\n    @Optional()\r\n    @SkipSelf()\r\n    otherInstance: LocalizationService,\r\n    private configState: ConfigStateService,\r\n  ) {\r\n    if (otherInstance) throw new Error('LocalizationService should have only one instance.');\r\n\r\n    this.listenToSetLanguage();\r\n    this.initLocalizationValues();\r\n  }\r\n\r\n  private initLocalizationValues() {\r\n    localizations$.subscribe(val => this.addLocalization(val));\r\n\r\n    const legacyResources$ = this.configState.getDeep$('localization.values') as Observable<\r\n      Record<string, Record<string, string>>\r\n    >;\r\n\r\n    const remoteLocalizations$ = this.configState.getDeep$('localization.resources') as Observable<\r\n      Record<string, ApplicationLocalizationResourceDto>\r\n    >;\r\n\r\n    const currentLanguage$ = this.sessionState.getLanguage$();\r\n\r\n    const uiLocalizations$ = combineLatest([currentLanguage$, this.uiLocalizations$]).pipe(\r\n      map(([currentLang, localizations]) => localizations.get(currentLang)),\r\n    );\r\n\r\n    combineLatest([legacyResources$, remoteLocalizations$, uiLocalizations$])\r\n      .pipe(\r\n        map(([legacy, resource, local]) => {\r\n          if (!resource) {\r\n            return;\r\n          }\r\n          const remote = combineLegacyandNewResources(legacy || {}, resource);\r\n          if (remote) {\r\n            if (!local) {\r\n              local = new Map();\r\n            }\r\n\r\n            Object.entries(remote).forEach(entry => {\r\n              const resourceName = entry[0];\r\n              const remoteTexts = entry[1];\r\n              let resource = local?.get(resourceName) || {};\r\n              resource = { ...resource, ...remoteTexts };\r\n\r\n              local?.set(resourceName, resource);\r\n            });\r\n          }\r\n\r\n          return local;\r\n        }),\r\n        filter(Boolean)\r\n      )\r\n      .subscribe(val => this.localizations$.next(val));\r\n  }\r\n\r\n  addLocalization(localizations?: ABP.Localization[]) {\r\n    if (!localizations) return;\r\n\r\n    const localizationMap = this.uiLocalizations$.value;\r\n\r\n    localizations.forEach(loc => {\r\n      const cultureMap =\r\n        localizationMap.get(loc.culture) || new Map<string, Record<string, string>>();\r\n\r\n      loc.resources.forEach(res => {\r\n        let resource: Record<string, string> = cultureMap.get(res.resourceName) || {};\r\n\r\n        resource = { ...resource, ...res.texts };\r\n\r\n        cultureMap.set(res.resourceName, resource);\r\n      });\r\n\r\n      localizationMap.set(loc.culture, cultureMap);\r\n    });\r\n\r\n    this.uiLocalizations$.next(localizationMap);\r\n  }\r\n\r\n  private listenToSetLanguage() {\r\n    this.sessionState\r\n      .onLanguageChange$()\r\n      .pipe(\r\n        filter(\r\n          lang => this.configState.getDeep('localization.currentCulture.cultureName') !== lang,\r\n        ),\r\n        switchMap(lang => this.configState.refreshAppState().pipe(map(() => lang))),\r\n        filter(Boolean),\r\n        switchMap(lang => from(this.registerLocale(lang).then(() => lang))),\r\n      )\r\n      .subscribe(lang => this._languageChange$.next(lang));\r\n  }\r\n\r\n  registerLocale(locale: string) {\r\n    const { registerLocaleFn }: ABP.Root = this.injector.get(CORE_OPTIONS);\r\n\r\n    return registerLocaleFn(locale).then(module => {\r\n      if (module?.default) registerLocaleData(module.default);\r\n      this.latestLang = locale;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Returns an observable localized text with the given interpolation parameters in current language.\r\n   * @param key Localizaton key to replace with localized text\r\n   * @param interpolateParams Values to interpolate\r\n   */\r\n  get(key: string | LocalizationWithDefault, ...interpolateParams: string[]): Observable<string> {\r\n    return this.configState\r\n      .getAll$()\r\n      .pipe(map(state => this.getLocalization(state, key, ...interpolateParams)));\r\n  }\r\n\r\n  getResource(resourceName: string) {\r\n    return this.localizations$.value.get(resourceName);\r\n  }\r\n\r\n  getResource$(resourceName: string) {\r\n    return this.localizations$.pipe(map(res => res.get(resourceName)));\r\n  }\r\n\r\n  /**\r\n   * Returns localized text with the given interpolation parameters in current language.\r\n   * @param key Localization key to replace with localized text\r\n   * @param interpolateParams Values to intepolate.\r\n   */\r\n  instant(key: string | LocalizationWithDefault, ...interpolateParams: string[]): string {\r\n    return this.getLocalization(this.configState.getAll(), key, ...interpolateParams);\r\n  }\r\n\r\n  localize(resourceName: string, key: string, defaultValue: string): Observable<string | null> {\r\n    return this.configState.getOne$('localization').pipe(\r\n      map(createLocalizer),\r\n      map(localize => localize(resourceName, key, defaultValue)),\r\n    );\r\n  }\r\n\r\n  localizeSync(resourceName: string, key: string, defaultValue: string): string | null {\r\n    const localization = this.configState.getOne('localization');\r\n    return createLocalizer(localization)(resourceName, key, defaultValue);\r\n  }\r\n\r\n  localizeWithFallback(\r\n    resourceNames: string[],\r\n    keys: string[],\r\n    defaultValue: string,\r\n  ): Observable<string> {\r\n    return this.configState.getOne$('localization').pipe(\r\n      map(createLocalizerWithFallback),\r\n      map(localizeWithFallback => localizeWithFallback(resourceNames, keys, defaultValue)),\r\n    );\r\n  }\r\n\r\n  localizeWithFallbackSync(resourceNames: string[], keys: string[], defaultValue: string): string {\r\n    const localization = this.configState.getOne('localization');\r\n    return createLocalizerWithFallback(localization)(resourceNames, keys, defaultValue);\r\n  }\r\n\r\n  private getLocalization(\r\n    state: ApplicationConfigurationDto,\r\n    key: string | LocalizationWithDefault,\r\n    ...interpolateParams: string[]\r\n  ) {\r\n    if (!key) key = '';\r\n    let defaultValue = '';\r\n\r\n    if (typeof key !== 'string') {\r\n      defaultValue = key.defaultValue;\r\n      key = key.key;\r\n    }\r\n\r\n    const keys = key.split('::') as string[];\r\n    const warn = (message: string) => {\r\n      if (isDevMode()) console.warn(message);\r\n    };\r\n\r\n    if (keys.length < 2) {\r\n      warn('The localization source separator (::) not found.');\r\n      return defaultValue || (key as string);\r\n    }\r\n    if (!state.localization) return defaultValue || keys[1];\r\n\r\n    const sourceName = keys[0] || state.localization.defaultResourceName;\r\n    const sourceKey = keys[1];\r\n\r\n    if (sourceName === '_') {\r\n      return defaultValue || sourceKey;\r\n    }\r\n\r\n    if (!sourceName) {\r\n      warn(\r\n        'Localization source name is not specified and the defaultResourceName was not defined!',\r\n      );\r\n\r\n      return defaultValue || sourceKey;\r\n    }\r\n\r\n    const source = this.localizations$.value.get(sourceName);\r\n    if (!source) {\r\n      warn('Could not find localization source: ' + sourceName);\r\n      return defaultValue || sourceKey;\r\n    }\r\n\r\n    let localization = source[sourceKey];\r\n    if (typeof localization === 'undefined') {\r\n      return defaultValue || sourceKey;\r\n    }\r\n\r\n    interpolateParams = interpolateParams.filter(params => params != null);\r\n    if (localization) localization = interpolate(localization, interpolateParams);\r\n\r\n    if (typeof localization !== 'string') localization = '';\r\n\r\n    return localization || defaultValue || (key as string);\r\n  }\r\n}\r\n\r\nfunction recursivelyMergeBaseResources(baseResourceName: string, source: ResourceDto): ApplicationLocalizationResourceDto {\r\n  const item = source[baseResourceName];\r\n\r\n  if (item.baseResources.length === 0) {\r\n    return item;\r\n  }\r\n\r\n  return item.baseResources.reduce((acc, baseResource) => {\r\n    const baseItem = recursivelyMergeBaseResources(baseResource, source);\r\n    const texts = { ...baseItem.texts, ...item.texts };\r\n    return { ...acc, texts };\r\n  }, item);\r\n}\r\n\r\nfunction mergeResourcesWithBaseResource(resource: ResourceDto): ResourceDto {\r\n  const entities: Array<[string, ApplicationLocalizationResourceDto]> = Object.keys(resource).map(key => {\r\n    const newValue = recursivelyMergeBaseResources(key, resource);\r\n    return [key, newValue];\r\n  });\r\n  return entities.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});\r\n}\r\n\r\nfunction combineLegacyandNewResources(\r\n  legacy: LegacyLanguageDto,\r\n  resource: ResourceDto,\r\n): LegacyLanguageDto {\r\n  const mergedResource = mergeResourcesWithBaseResource(resource);\r\n\r\n  return Object.entries(mergedResource).reduce((acc, [key, value]) => {\r\n    return { ...acc, [key]: value.texts };\r\n  }, legacy);\r\n}\r\n\r\nexport type LegacyLanguageDto = Record<string, Record<string, string>>;\r\nexport type ResourceDto = Record<string, ApplicationLocalizationResourceDto>;\r\n"]}

package/esm2022/lib/services/multi-tenancy.service.mjs

@@ -0,0 +1,49 @@
+import { Inject, Injectable } from '@angular/core';
+import { map, switchMap } from 'rxjs/operators';
+import { AbpTenantService } from '../proxy/pages/abp/multi-tenancy';
+import { TENANT_KEY } from '../tokens/tenant-key.token';
+import { ConfigStateService } from './config-state.service';
+import { RestService } from './rest.service';
+import { SessionStateService } from './session-state.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./rest.service";
+import * as i2 from "./session-state.service";
+import * as i3 from "../proxy/pages/abp/multi-tenancy";
+import * as i4 from "./config-state.service";
+class MultiTenancyService {
+    constructor(restService, sessionState, tenantService, configStateService, tenantKey) {
+        this.restService = restService;
+        this.sessionState = sessionState;
+        this.tenantService = tenantService;
+        this.configStateService = configStateService;
+        this.tenantKey = tenantKey;
+        this.domainTenant = null;
+        this.isTenantBoxVisible = true;
+        this.apiName = 'abp';
+        this.setTenantToState = (tenant) => {
+            this.sessionState.setTenant({ id: tenant.tenantId, name: tenant.name, isAvailable: true });
+            return this.configStateService.refreshAppState().pipe(map(_ => tenant));
+        };
+    }
+    setTenantByName(tenantName) {
+        return this.tenantService
+            .findTenantByName(tenantName)
+            .pipe(switchMap(this.setTenantToState));
+    }
+    setTenantById(tenantId) {
+        return this.tenantService
+            .findTenantById(tenantId)
+            .pipe(switchMap(this.setTenantToState));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: MultiTenancyService, deps: [{ token: i1.RestService }, { token: i2.SessionStateService }, { token: i3.AbpTenantService }, { token: i4.ConfigStateService }, { token: TENANT_KEY }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: MultiTenancyService, providedIn: 'root' }); }
+}
+export { MultiTenancyService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: MultiTenancyService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.RestService }, { type: i2.SessionStateService }, { type: i3.AbpTenantService }, { type: i4.ConfigStateService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TENANT_KEY]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXVsdGktdGVuYW5jeS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvbGliL3NlcnZpY2VzL211bHRpLXRlbmFuY3kuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRCxPQUFPLEVBQUUsR0FBRyxFQUFFLFNBQVMsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ2hELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBS3BFLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUN4RCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUM1RCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDN0MsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUM7Ozs7OztBQUU5RCxNQUNhLG1CQUFtQjtJQVk5QixZQUNVLFdBQXdCLEVBQ3hCLFlBQWlDLEVBQ2pDLGFBQStCLEVBQy9CLGtCQUFzQyxFQUNuQixTQUFpQjtRQUpwQyxnQkFBVyxHQUFYLFdBQVcsQ0FBYTtRQUN4QixpQkFBWSxHQUFaLFlBQVksQ0FBcUI7UUFDakMsa0JBQWEsR0FBYixhQUFhLENBQWtCO1FBQy9CLHVCQUFrQixHQUFsQixrQkFBa0IsQ0FBb0I7UUFDbkIsY0FBUyxHQUFULFNBQVMsQ0FBUTtRQWhCOUMsaUJBQVksR0FBNEIsSUFBSSxDQUFDO1FBRTdDLHVCQUFrQixHQUFHLElBQUksQ0FBQztRQUUxQixZQUFPLEdBQUcsS0FBSyxDQUFDO1FBRVIscUJBQWdCLEdBQUcsQ0FBQyxNQUEyQixFQUFFLEVBQUU7WUFDekQsSUFBSSxDQUFDLFlBQVksQ0FBQyxTQUFTLENBQUMsRUFBRSxFQUFFLEVBQUUsTUFBTSxDQUFDLFFBQVEsRUFBRSxJQUFJLEVBQUUsTUFBTSxDQUFDLElBQUksRUFBRSxXQUFXLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztZQUMzRixPQUFPLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxlQUFlLEVBQUUsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQztRQUMxRSxDQUFDLENBQUM7SUFRRSxDQUFDO0lBRUwsZUFBZSxDQUFDLFVBQWtCO1FBQ2hDLE9BQU8sSUFBSSxDQUFDLGFBQWE7YUFDdEIsZ0JBQWdCLENBQUMsVUFBVSxDQUFDO2FBQzVCLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLENBQUMsQ0FBQztJQUM1QyxDQUFDO0lBRUQsYUFBYSxDQUFDLFFBQWdCO1FBQzVCLE9BQU8sSUFBSSxDQUFDLGFBQWE7YUFDdEIsY0FBYyxDQUFDLFFBQVEsQ0FBQzthQUN4QixJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLENBQUM7SUFDNUMsQ0FBQzs4R0E5QlUsbUJBQW1CLGtKQWlCcEIsVUFBVTtrSEFqQlQsbUJBQW1CLGNBRE4sTUFBTTs7U0FDbkIsbUJBQW1COzJGQUFuQixtQkFBbUI7a0JBRC9CLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFOzswQkFrQjdCLE1BQU07MkJBQUMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdCwgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBtYXAsIHN3aXRjaE1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcclxuaW1wb3J0IHsgQWJwVGVuYW50U2VydmljZSB9IGZyb20gJy4uL3Byb3h5L3BhZ2VzL2FicC9tdWx0aS10ZW5hbmN5JztcclxuaW1wb3J0IHtcclxuICBDdXJyZW50VGVuYW50RHRvLFxyXG4gIEZpbmRUZW5hbnRSZXN1bHREdG8sXHJcbn0gZnJvbSAnLi4vcHJveHkvdm9sby9hYnAvYXNwLW5ldC1jb3JlL212Yy9tdWx0aS10ZW5hbmN5L21vZGVscyc7XHJcbmltcG9ydCB7IFRFTkFOVF9LRVkgfSBmcm9tICcuLi90b2tlbnMvdGVuYW50LWtleS50b2tlbic7XHJcbmltcG9ydCB7IENvbmZpZ1N0YXRlU2VydmljZSB9IGZyb20gJy4vY29uZmlnLXN0YXRlLnNlcnZpY2UnO1xyXG5pbXBvcnQgeyBSZXN0U2VydmljZSB9IGZyb20gJy4vcmVzdC5zZXJ2aWNlJztcclxuaW1wb3J0IHsgU2Vzc2lvblN0YXRlU2VydmljZSB9IGZyb20gJy4vc2Vzc2lvbi1zdGF0ZS5zZXJ2aWNlJztcclxuXHJcbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXHJcbmV4cG9ydCBjbGFzcyBNdWx0aVRlbmFuY3lTZXJ2aWNlIHtcclxuICBkb21haW5UZW5hbnQ6IEN1cnJlbnRUZW5hbnREdG8gfCBudWxsID0gbnVsbDtcclxuXHJcbiAgaXNUZW5hbnRCb3hWaXNpYmxlID0gdHJ1ZTtcclxuXHJcbiAgYXBpTmFtZSA9ICdhYnAnO1xyXG5cclxuICBwcml2YXRlIHNldFRlbmFudFRvU3RhdGUgPSAodGVuYW50OiBGaW5kVGVuYW50UmVzdWx0RHRvKSA9PiB7XHJcbiAgICB0aGlzLnNlc3Npb25TdGF0ZS5zZXRUZW5hbnQoeyBpZDogdGVuYW50LnRlbmFudElkLCBuYW1lOiB0ZW5hbnQubmFtZSwgaXNBdmFpbGFibGU6IHRydWUgfSk7XHJcbiAgICByZXR1cm4gdGhpcy5jb25maWdTdGF0ZVNlcnZpY2UucmVmcmVzaEFwcFN0YXRlKCkucGlwZShtYXAoXyA9PiB0ZW5hbnQpKTtcclxuICB9O1xyXG5cclxuICBjb25zdHJ1Y3RvcihcclxuICAgIHByaXZhdGUgcmVzdFNlcnZpY2U6IFJlc3RTZXJ2aWNlLFxyXG4gICAgcHJpdmF0ZSBzZXNzaW9uU3RhdGU6IFNlc3Npb25TdGF0ZVNlcnZpY2UsXHJcbiAgICBwcml2YXRlIHRlbmFudFNlcnZpY2U6IEFicFRlbmFudFNlcnZpY2UsXHJcbiAgICBwcml2YXRlIGNvbmZpZ1N0YXRlU2VydmljZTogQ29uZmlnU3RhdGVTZXJ2aWNlLFxyXG4gICAgQEluamVjdChURU5BTlRfS0VZKSBwdWJsaWMgdGVuYW50S2V5OiBzdHJpbmcsXHJcbiAgKSB7IH1cclxuXHJcbiAgc2V0VGVuYW50QnlOYW1lKHRlbmFudE5hbWU6IHN0cmluZykge1xyXG4gICAgcmV0dXJuIHRoaXMudGVuYW50U2VydmljZVxyXG4gICAgICAuZmluZFRlbmFudEJ5TmFtZSh0ZW5hbnROYW1lKVxyXG4gICAgICAucGlwZShzd2l0Y2hNYXAodGhpcy5zZXRUZW5hbnRUb1N0YXRlKSk7XHJcbiAgfVxyXG5cclxuICBzZXRUZW5hbnRCeUlkKHRlbmFudElkOiBzdHJpbmcpIHtcclxuICAgIHJldHVybiB0aGlzLnRlbmFudFNlcnZpY2VcclxuICAgICAgLmZpbmRUZW5hbnRCeUlkKHRlbmFudElkKVxyXG4gICAgICAucGlwZShzd2l0Y2hNYXAodGhpcy5zZXRUZW5hbnRUb1N0YXRlKSk7XHJcbiAgfVxyXG59XHJcbiJdfQ==

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

@@ -0,0 +1,64 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { ConfigStateService } from './config-state.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./config-state.service";
+class PermissionService {
+    constructor(configState) {
+        this.configState = configState;
+    }
+    getGrantedPolicy$(key) {
+        return this.getStream().pipe(map(grantedPolicies => this.isPolicyGranted(key, grantedPolicies)));
+    }
+    getGrantedPolicy(key) {
+        const policies = this.getSnapshot();
+        return this.isPolicyGranted(key, policies);
+    }
+    filterItemsByPolicy(items) {
+        const policies = this.getSnapshot();
+        return items.filter(item => !item.requiredPolicy || this.isPolicyGranted(item.requiredPolicy, policies));
+    }
+    filterItemsByPolicy$(items) {
+        return this.getStream().pipe(map(policies => items.filter(item => !item.requiredPolicy || this.isPolicyGranted(item.requiredPolicy, policies))));
+    }
+    isPolicyGranted(key, grantedPolicies) {
+        if (!key)
+            return true;
+        const orRegexp = /\|\|/g;
+        const andRegexp = /&&/g;
+        // TODO: Allow combination of ANDs & ORs
+        if (orRegexp.test(key)) {
+            const keys = key.split('||').filter(Boolean);
+            if (keys.length < 2)
+                return false;
+            return keys.some(k => this.getPolicy(k.trim(), grantedPolicies));
+        }
+        else if (andRegexp.test(key)) {
+            const keys = key.split('&&').filter(Boolean);
+            if (keys.length < 2)
+                return false;
+            return keys.every(k => this.getPolicy(k.trim(), grantedPolicies));
+        }
+        return this.getPolicy(key, grantedPolicies);
+    }
+    getStream() {
+        return this.configState.getAll$().pipe(map(this.mapToPolicies));
+    }
+    getSnapshot() {
+        return this.mapToPolicies(this.configState.getAll());
+    }
+    mapToPolicies(applicationConfiguration) {
+        return applicationConfiguration?.auth?.grantedPolicies || {};
+    }
+    getPolicy(key, grantedPolicies) {
+        return grantedPolicies[key] || false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: PermissionService, deps: [{ token: i1.ConfigStateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: PermissionService, providedIn: 'root' }); }
+}
+export { PermissionService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: PermissionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.ConfigStateService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/replaceable-components.service.mjs

@@ -0,0 +1,50 @@
+import { Injectable, NgZone } from '@angular/core';
+import { Router } from '@angular/router';
+import { map } from 'rxjs/operators';
+import { InternalStore } from '../utils/internal-store-utils';
+import { reloadRoute } from '../utils/route-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+class ReplaceableComponentsService {
+    get replaceableComponents$() {
+        return this.store.sliceState(state => state);
+    }
+    get replaceableComponents() {
+        return this.store.state;
+    }
+    get onUpdate$() {
+        return this.store.sliceUpdate(state => state);
+    }
+    constructor(ngZone, router) {
+        this.ngZone = ngZone;
+        this.router = router;
+        this.store = new InternalStore([]);
+    }
+    add(replaceableComponent, reload) {
+        const replaceableComponents = [...this.store.state];
+        const index = replaceableComponents.findIndex(component => component.key === replaceableComponent.key);
+        if (index > -1) {
+            replaceableComponents[index] = replaceableComponent;
+        }
+        else {
+            replaceableComponents.push(replaceableComponent);
+        }
+        this.store.set(replaceableComponents);
+        if (reload)
+            reloadRoute(this.router, this.ngZone);
+    }
+    get(replaceableComponentKey) {
+        return this.replaceableComponents.find(component => component.key === replaceableComponentKey);
+    }
+    get$(replaceableComponentKey) {
+        return this.replaceableComponents$.pipe(map(components => components.find(component => component.key === replaceableComponentKey)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ReplaceableComponentsService, deps: [{ token: i0.NgZone }, { token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ReplaceableComponentsService, providedIn: 'root' }); }
+}
+export { ReplaceableComponentsService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ReplaceableComponentsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i1.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,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