@abp/ng.core 5.0.1 → 5.1.1

package/esm2020/lib/strategies/auth-flow.strategy.mjs

@@ -0,0 +1,190 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Router } from '@angular/router';
+import { OAuthErrorEvent, OAuthInfoEvent, OAuthService } from 'angular-oauth2-oidc';
+import { from, of, pipe } from 'rxjs';
+import { filter, switchMap, tap } from 'rxjs/operators';
+import { ConfigStateService } from '../services/config-state.service';
+import { EnvironmentService } from '../services/environment.service';
+import { HttpErrorReporterService } from '../services/http-error-reporter.service';
+import { SessionStateService } from '../services/session-state.service';
+import { TENANT_KEY } from '../tokens/tenant-key.token';
+import { removeRememberMe, setRememberMe } from '../utils/auth-utils';
+import { noop } from '../utils/common-utils';
+export const oAuthStorage = localStorage;
+export class AuthFlowStrategy {
+    constructor(injector) {
+        this.injector = injector;
+        this.catchError = err => {
+            this.httpErrorReporter.reportError(err);
+            return of(null);
+        };
+        this.httpErrorReporter = injector.get(HttpErrorReporterService);
+        this.environment = injector.get(EnvironmentService);
+        this.configState = injector.get(ConfigStateService);
+        this.oAuthService = injector.get(OAuthService);
+        this.sessionState = injector.get(SessionStateService);
+        this.oAuthConfig = this.environment.getEnvironment().oAuthConfig;
+        this.tenantKey = injector.get(TENANT_KEY);
+        this.listenToOauthErrors();
+    }
+    async init() {
+        const shouldClear = shouldStorageClear(this.environment.getEnvironment().oAuthConfig.clientId, oAuthStorage);
+        if (shouldClear)
+            clearOAuthStorage(oAuthStorage);
+        this.oAuthService.configure(this.oAuthConfig);
+        this.oAuthService.events
+            .pipe(filter(event => event.type === 'token_refresh_error'))
+            .subscribe(() => this.navigateToLogin());
+        return this.oAuthService
+            .loadDiscoveryDocument()
+            .then(() => {
+            if (this.oAuthService.hasValidAccessToken() || !this.oAuthService.getRefreshToken()) {
+                return Promise.resolve();
+            }
+            return this.refreshToken();
+        })
+            .catch(this.catchError);
+    }
+    refreshToken() {
+        return this.oAuthService.refreshToken().catch(() => clearOAuthStorage());
+    }
+    listenToOauthErrors() {
+        this.oAuthService.events
+            .pipe(filter(event => event instanceof OAuthErrorEvent), tap(() => clearOAuthStorage()), switchMap(() => this.configState.refreshAppState()))
+            .subscribe();
+    }
+}
+export class AuthCodeFlowStrategy extends AuthFlowStrategy {
+    constructor() {
+        super(...arguments);
+        this.isInternalAuth = false;
+    }
+    async init() {
+        return super
+            .init()
+            .then(() => this.oAuthService.tryLogin().catch(noop))
+            .then(() => this.oAuthService.setupAutomaticSilentRefresh({}, 'access_token'));
+    }
+    navigateToLogin(queryParams) {
+        this.oAuthService.initCodeFlow('', this.getCultureParams(queryParams));
+    }
+    checkIfInternalAuth(queryParams) {
+        this.oAuthService.initCodeFlow('', this.getCultureParams(queryParams));
+        return false;
+    }
+    logout(queryParams) {
+        return from(this.oAuthService.revokeTokenAndLogout(this.getCultureParams(queryParams)));
+    }
+    login(queryParams) {
+        this.oAuthService.initCodeFlow('', this.getCultureParams(queryParams));
+        return of(null);
+    }
+    getCultureParams(queryParams) {
+        const lang = this.sessionState.getLanguage();
+        const culture = { culture: lang, 'ui-culture': lang };
+        return { ...(lang && culture), ...queryParams };
+    }
+}
+export class AuthPasswordFlowStrategy extends AuthFlowStrategy {
+    constructor() {
+        super(...arguments);
+        this.isInternalAuth = true;
+        this.cookieKey = 'rememberMe';
+        this.storageKey = 'passwordFlow';
+    }
+    listenToTokenExpiration() {
+        this.oAuthService.events
+            .pipe(filter(event => event instanceof OAuthInfoEvent &&
+            event.type === 'token_expires' &&
+            event.info === 'access_token'))
+            .subscribe(() => {
+            if (this.oAuthService.getRefreshToken()) {
+                this.refreshToken();
+            }
+            else {
+                this.oAuthService.logOut();
+                removeRememberMe();
+                this.configState.refreshAppState().subscribe();
+            }
+        });
+    }
+    async init() {
+        if (!getCookieValueByName(this.cookieKey) && localStorage.getItem(this.storageKey)) {
+            this.oAuthService.logOut();
+        }
+        return super.init().then(() => this.listenToTokenExpiration());
+    }
+    navigateToLogin(queryParams) {
+        const router = this.injector.get(Router);
+        router.navigate(['/account/login'], { queryParams });
+    }
+    checkIfInternalAuth() {
+        return true;
+    }
+    login(params) {
+        const tenant = this.sessionState.getTenant();
+        return from(this.oAuthService.fetchTokenUsingPasswordFlow(params.username, params.password, new HttpHeaders({ ...(tenant && tenant.id && { [this.tenantKey]: tenant.id }) }))).pipe(this.pipeToLogin(params));
+    }
+    pipeToLogin(params) {
+        const router = this.injector.get(Router);
+        return pipe(switchMap(() => this.configState.refreshAppState()), tap(() => {
+            setRememberMe(params.rememberMe);
+            if (params.redirectUrl)
+                router.navigate([params.redirectUrl]);
+        }));
+    }
+    logout(queryParams) {
+        const router = this.injector.get(Router);
+        return from(this.oAuthService.revokeTokenAndLogout(queryParams)).pipe(switchMap(() => this.configState.refreshAppState()), tap(() => {
+            router.navigateByUrl('/');
+            removeRememberMe();
+        }));
+    }
+    refreshToken() {
+        return this.oAuthService.refreshToken().catch(() => {
+            clearOAuthStorage();
+            removeRememberMe();
+        });
+    }
+}
+export const AUTH_FLOW_STRATEGY = {
+    Code(injector) {
+        return new AuthCodeFlowStrategy(injector);
+    },
+    Password(injector) {
+        return new AuthPasswordFlowStrategy(injector);
+    },
+};
+export function clearOAuthStorage(storage = oAuthStorage) {
+    const keys = [
+        'access_token',
+        'id_token',
+        'refresh_token',
+        'nonce',
+        'PKCE_verifier',
+        'expires_at',
+        'id_token_claims_obj',
+        'id_token_expires_at',
+        'id_token_stored_at',
+        'access_token_stored_at',
+        'granted_scopes',
+        'session_state',
+    ];
+    keys.forEach(key => storage.removeItem(key));
+}
+function shouldStorageClear(clientId, storage) {
+    const key = 'abpOAuthClientId';
+    if (!storage.getItem(key)) {
+        storage.setItem(key, clientId);
+        return false;
+    }
+    const shouldClear = storage.getItem(key) !== clientId;
+    if (shouldClear)
+        storage.setItem(key, clientId);
+    return shouldClear;
+}
+function getCookieValueByName(name) {
+    const match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
+    return match ? match[2] : '';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-flow.strategy.js","sourceRoot":"","sources":["../../../../../../packages/core/src/lib/strategies/auth-flow.strategy.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpHeaders } from '@angular/common/http';\r\nimport { Injector } from '@angular/core';\r\nimport { Params, Router } from '@angular/router';\r\nimport {\r\n  AuthConfig,\r\n  OAuthErrorEvent,\r\n  OAuthInfoEvent,\r\n  OAuthService,\r\n  OAuthStorage\r\n} from 'angular-oauth2-oidc';\r\nimport { from, Observable, of, pipe } from 'rxjs';\r\nimport { filter, switchMap, tap } from 'rxjs/operators';\r\nimport { LoginParams } from '../models/auth';\r\nimport { ConfigStateService } from '../services/config-state.service';\r\nimport { EnvironmentService } from '../services/environment.service';\r\nimport { HttpErrorReporterService } from '../services/http-error-reporter.service';\r\nimport { SessionStateService } from '../services/session-state.service';\r\nimport { TENANT_KEY } from '../tokens/tenant-key.token';\r\nimport { removeRememberMe, setRememberMe } from '../utils/auth-utils';\r\nimport { noop } from '../utils/common-utils';\r\n\r\nexport const oAuthStorage = localStorage;\r\n\r\nexport abstract class AuthFlowStrategy {\r\n  abstract readonly isInternalAuth: boolean;\r\n\r\n  protected httpErrorReporter: HttpErrorReporterService;\r\n  protected environment: EnvironmentService;\r\n  protected configState: ConfigStateService;\r\n  protected oAuthService: OAuthService;\r\n  protected oAuthConfig: AuthConfig;\r\n  protected sessionState: SessionStateService;\r\n  protected tenantKey: string;\r\n\r\n  abstract checkIfInternalAuth(queryParams?: Params): boolean;\r\n  abstract navigateToLogin(queryParams?: Params): void;\r\n  abstract logout(queryParams?: Params): Observable<any>;\r\n  abstract login(params?: LoginParams | Params): Observable<any>;\r\n\r\n  private catchError = err => {\r\n    this.httpErrorReporter.reportError(err);\r\n    return of(null);\r\n  };\r\n\r\n  constructor(protected injector: Injector) {\r\n    this.httpErrorReporter = injector.get(HttpErrorReporterService);\r\n    this.environment = injector.get(EnvironmentService);\r\n    this.configState = injector.get(ConfigStateService);\r\n    this.oAuthService = injector.get(OAuthService);\r\n    this.sessionState = injector.get(SessionStateService);\r\n    this.oAuthConfig = this.environment.getEnvironment().oAuthConfig;\r\n    this.tenantKey = injector.get(TENANT_KEY);\r\n\r\n    this.listenToOauthErrors();\r\n  }\r\n\r\n  async init(): Promise<any> {\r\n    const shouldClear = shouldStorageClear(\r\n      this.environment.getEnvironment().oAuthConfig.clientId,\r\n      oAuthStorage,\r\n    );\r\n    if (shouldClear) clearOAuthStorage(oAuthStorage);\r\n\r\n    this.oAuthService.configure(this.oAuthConfig);\r\n\r\n    this.oAuthService.events\r\n      .pipe(filter(event => event.type === 'token_refresh_error'))\r\n      .subscribe(() => this.navigateToLogin());\r\n\r\n    return this.oAuthService\r\n      .loadDiscoveryDocument()\r\n      .then(() => {\r\n        if (this.oAuthService.hasValidAccessToken() || !this.oAuthService.getRefreshToken()) {\r\n          return Promise.resolve();\r\n        }\r\n\r\n        return this.refreshToken();\r\n      })\r\n      .catch(this.catchError);\r\n  }\r\n\r\n  protected refreshToken() {\r\n    return this.oAuthService.refreshToken().catch(() => clearOAuthStorage());\r\n  }\r\n\r\n  protected listenToOauthErrors() {\r\n    this.oAuthService.events\r\n      .pipe(\r\n        filter(event => event instanceof OAuthErrorEvent),\r\n        tap(() => clearOAuthStorage()),\r\n        switchMap(() => this.configState.refreshAppState()),\r\n      )\r\n      .subscribe();\r\n  }\r\n}\r\n\r\nexport class AuthCodeFlowStrategy extends AuthFlowStrategy {\r\n  readonly isInternalAuth = false;\r\n\r\n  async init() {\r\n    return super\r\n      .init()\r\n      .then(() => this.oAuthService.tryLogin().catch(noop))\r\n      .then(() => this.oAuthService.setupAutomaticSilentRefresh({}, 'access_token'));\r\n  }\r\n\r\n  navigateToLogin(queryParams?: Params) {\r\n    this.oAuthService.initCodeFlow('', this.getCultureParams(queryParams));\r\n  }\r\n\r\n  checkIfInternalAuth(queryParams?: Params) {\r\n    this.oAuthService.initCodeFlow('', this.getCultureParams(queryParams));\r\n    return false;\r\n  }\r\n\r\n  logout(queryParams?: Params) {\r\n    return from(this.oAuthService.revokeTokenAndLogout(this.getCultureParams(queryParams)));\r\n  }\r\n\r\n  login(queryParams?: Params) {\r\n    this.oAuthService.initCodeFlow('', this.getCultureParams(queryParams));\r\n    return of(null);\r\n  }\r\n\r\n  private getCultureParams(queryParams?: Params) {\r\n    const lang = this.sessionState.getLanguage();\r\n    const culture = { culture: lang, 'ui-culture': lang };\r\n    return { ...(lang && culture), ...queryParams };\r\n  }\r\n}\r\n\r\nexport class AuthPasswordFlowStrategy extends AuthFlowStrategy {\r\n  readonly isInternalAuth = true;\r\n  private cookieKey = 'rememberMe';\r\n  private storageKey = 'passwordFlow';\r\n\r\n  private listenToTokenExpiration() {\r\n    this.oAuthService.events\r\n      .pipe(\r\n        filter(\r\n          event =>\r\n            event instanceof OAuthInfoEvent &&\r\n            event.type === 'token_expires' &&\r\n            event.info === 'access_token',\r\n        ),\r\n      )\r\n      .subscribe(() => {\r\n        if (this.oAuthService.getRefreshToken()) {\r\n          this.refreshToken();\r\n        } else {\r\n          this.oAuthService.logOut();\r\n          removeRememberMe();\r\n          this.configState.refreshAppState().subscribe();\r\n        }\r\n      });\r\n  }\r\n\r\n  async init() {\r\n    if (!getCookieValueByName(this.cookieKey) && localStorage.getItem(this.storageKey)) {\r\n      this.oAuthService.logOut();\r\n    }\r\n\r\n    return super.init().then(() => this.listenToTokenExpiration());\r\n  }\r\n\r\n  navigateToLogin(queryParams?: Params) {\r\n    const router = this.injector.get(Router);\r\n    router.navigate(['/account/login'], { queryParams });\r\n  }\r\n\r\n  checkIfInternalAuth() {\r\n    return true;\r\n  }\r\n\r\n  login(params: LoginParams): Observable<any> {\r\n    const tenant = this.sessionState.getTenant();\r\n\r\n    return from(\r\n      this.oAuthService.fetchTokenUsingPasswordFlow(\r\n        params.username,\r\n        params.password,\r\n        new HttpHeaders({ ...(tenant && tenant.id && { [this.tenantKey]: tenant.id }) }),\r\n      ),\r\n    ).pipe(this.pipeToLogin(params));\r\n  }\r\n\r\n  pipeToLogin(params: Pick<LoginParams, 'redirectUrl' | 'rememberMe'>) {\r\n    const router = this.injector.get(Router);\r\n\r\n    return pipe(\r\n      switchMap(() => this.configState.refreshAppState()),\r\n      tap(() => {\r\n        setRememberMe(params.rememberMe);\r\n        if (params.redirectUrl) router.navigate([params.redirectUrl]);\r\n      }),\r\n    );\r\n  }\r\n\r\n  logout(queryParams?: Params) {\r\n    const router = this.injector.get(Router);\r\n\r\n    return from(this.oAuthService.revokeTokenAndLogout(queryParams)).pipe(\r\n      switchMap(() => this.configState.refreshAppState()),\r\n      tap(() => {\r\n        router.navigateByUrl('/');\r\n        removeRememberMe();\r\n      }),\r\n    );\r\n  }\r\n\r\n  protected refreshToken() {\r\n    return this.oAuthService.refreshToken().catch(() => {\r\n      clearOAuthStorage();\r\n      removeRememberMe();\r\n    });\r\n  }\r\n}\r\n\r\nexport const AUTH_FLOW_STRATEGY = {\r\n  Code(injector: Injector) {\r\n    return new AuthCodeFlowStrategy(injector);\r\n  },\r\n  Password(injector: Injector) {\r\n    return new AuthPasswordFlowStrategy(injector);\r\n  },\r\n};\r\n\r\nexport function clearOAuthStorage(storage: OAuthStorage = oAuthStorage) {\r\n  const keys = [\r\n    'access_token',\r\n    'id_token',\r\n    'refresh_token',\r\n    'nonce',\r\n    'PKCE_verifier',\r\n    'expires_at',\r\n    'id_token_claims_obj',\r\n    'id_token_expires_at',\r\n    'id_token_stored_at',\r\n    'access_token_stored_at',\r\n    'granted_scopes',\r\n    'session_state',\r\n  ];\r\n\r\n  keys.forEach(key => storage.removeItem(key));\r\n}\r\n\r\nfunction shouldStorageClear(clientId: string, storage: OAuthStorage): boolean {\r\n  const key = 'abpOAuthClientId';\r\n  if (!storage.getItem(key)) {\r\n    storage.setItem(key, clientId);\r\n    return false;\r\n  }\r\n\r\n  const shouldClear = storage.getItem(key) !== clientId;\r\n  if (shouldClear) storage.setItem(key, clientId);\r\n  return shouldClear;\r\n}\r\n\r\nfunction getCookieValueByName(name: string) {\r\n  const match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));\r\n  return match ? match[2] : '';\r\n}\r\n"]}

package/esm2020/lib/tokens/options.token.mjs

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+export const CORE_OPTIONS = new InjectionToken('CORE_OPTIONS');
+export function coreOptionsFactory({ ...options }) {
+    return {
+        ...options,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL2xpYi90b2tlbnMvb3B0aW9ucy50b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRy9DLE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxJQUFJLGNBQWMsQ0FBVyxjQUFjLENBQUMsQ0FBQztBQUV6RSxNQUFNLFVBQVUsa0JBQWtCLENBQUMsRUFBRSxHQUFHLE9BQU8sRUFBWTtJQUN6RCxPQUFPO1FBQ0wsR0FBRyxPQUFPO0tBQ0MsQ0FBQztBQUNoQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQUJQIH0gZnJvbSAnLi4vbW9kZWxzL2NvbW1vbic7XHJcblxyXG5leHBvcnQgY29uc3QgQ09SRV9PUFRJT05TID0gbmV3IEluamVjdGlvblRva2VuPEFCUC5Sb290PignQ09SRV9PUFRJT05TJyk7XHJcblxyXG5leHBvcnQgZnVuY3Rpb24gY29yZU9wdGlvbnNGYWN0b3J5KHsgLi4ub3B0aW9ucyB9OiBBQlAuUm9vdCkge1xyXG4gIHJldHVybiB7XHJcbiAgICAuLi5vcHRpb25zLFxyXG4gIH0gYXMgQUJQLlJvb3Q7XHJcbn1cclxuIl19

package/esm2020/lib/utils/array-utils.mjs

@@ -0,0 +1,7 @@
+export function pushValueTo(array) {
+    return (element) => {
+        array.push(element);
+        return array;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXktdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9saWIvdXRpbHMvYXJyYXktdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxVQUFVLFdBQVcsQ0FBSSxLQUFVO0lBQ3ZDLE9BQU8sQ0FBQyxPQUFVLEVBQUUsRUFBRTtRQUNwQixLQUFLLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ3BCLE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQyxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBwdXNoVmFsdWVUbzxUPihhcnJheTogVFtdKSB7XHJcbiAgcmV0dXJuIChlbGVtZW50OiBUKSA9PiB7XHJcbiAgICBhcnJheS5wdXNoKGVsZW1lbnQpO1xyXG4gICAgcmV0dXJuIGFycmF5O1xyXG4gIH07XHJcbn1cclxuIl19

package/esm2020/lib/utils/initial-utils.mjs

@@ -0,0 +1,63 @@
+import { registerLocaleData } from '@angular/common';
+import { OAuthService } from 'angular-oauth2-oidc';
+import { tap, catchError } from 'rxjs/operators';
+import { throwError } from 'rxjs';
+import { AuthService } from '../services/auth.service';
+import { ConfigStateService } from '../services/config-state.service';
+import { EnvironmentService } from '../services/environment.service';
+import { SessionStateService } from '../services/session-state.service';
+import { clearOAuthStorage } from '../strategies/auth-flow.strategy';
+import { CORE_OPTIONS } from '../tokens/options.token';
+import { APP_INIT_ERROR_HANDLERS } from '../tokens/app-config.token';
+import { getRemoteEnv } from './environment-utils';
+import { parseTenantFromUrl } from './multi-tenancy-utils';
+export function getInitialData(injector) {
+    const fn = async () => {
+        const environmentService = injector.get(EnvironmentService);
+        const configState = injector.get(ConfigStateService);
+        const options = injector.get(CORE_OPTIONS);
+        environmentService.setState(options.environment);
+        await getRemoteEnv(injector, options.environment);
+        await parseTenantFromUrl(injector);
+        await injector.get(AuthService).init();
+        if (options.skipGetAppConfiguration)
+            return;
+        return configState
+            .refreshAppState()
+            .pipe(tap(() => checkAccessToken(injector)), tap(() => {
+            const currentTenant = configState.getOne('currentTenant');
+            injector.get(SessionStateService).setTenant(currentTenant);
+        }), catchError(error => {
+            const appInitErrorHandlers = injector.get(APP_INIT_ERROR_HANDLERS, null);
+            if (appInitErrorHandlers && appInitErrorHandlers.length) {
+                appInitErrorHandlers.forEach(func => func(error));
+            }
+            return throwError(error);
+        }))
+            .toPromise();
+    };
+    return fn;
+}
+export function checkAccessToken(injector) {
+    const configState = injector.get(ConfigStateService);
+    const oAuth = injector.get(OAuthService);
+    if (oAuth.hasValidAccessToken() && !configState.getDeep('currentUser.id')) {
+        clearOAuthStorage();
+    }
+}
+export function localeInitializer(injector) {
+    const fn = () => {
+        const sessionState = injector.get(SessionStateService);
+        const { registerLocaleFn } = injector.get(CORE_OPTIONS);
+        const lang = sessionState.getLanguage() || 'en';
+        return new Promise((resolve, reject) => {
+            registerLocaleFn(lang).then(module => {
+                if (module?.default)
+                    registerLocaleData(module.default);
+                return resolve('resolved');
+            }, reject);
+        });
+    };
+    return fn;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/internal-store-utils.mjs

@@ -0,0 +1,36 @@
+import compare from 'just-compare';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { distinctUntilChanged, filter, map } from 'rxjs/operators';
+import { deepMerge } from './object-utils';
+export class InternalStore {
+    constructor(initialState) {
+        this.initialState = initialState;
+        this.state$ = new BehaviorSubject(this.initialState);
+        this.update$ = new Subject();
+        this.sliceState = (selector, compareFn = compare) => this.state$.pipe(map(selector), distinctUntilChanged(compareFn));
+        this.sliceUpdate = (selector, filterFn = (x) => x !== undefined) => this.update$.pipe(map(selector), filter(filterFn));
+    }
+    get state() {
+        return this.state$.value;
+    }
+    patch(state) {
+        let patchedState = state;
+        if (typeof state === 'object' && !Array.isArray(state)) {
+            patchedState = { ...this.state, ...state };
+        }
+        this.state$.next(patchedState);
+        this.update$.next(patchedState);
+    }
+    deepPatch(state) {
+        this.state$.next(deepMerge(this.state, state));
+        this.update$.next(state);
+    }
+    set(state) {
+        this.state$.next(state);
+        this.update$.next(state);
+    }
+    reset() {
+        this.set(this.initialState);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJuYWwtc3RvcmUtdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9saWIvdXRpbHMvaW50ZXJuYWwtc3RvcmUtdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBQ25DLE9BQU8sRUFBRSxlQUFlLEVBQUUsT0FBTyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQ2hELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLEVBQUUsR0FBRyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFbkUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRTNDLE1BQU0sT0FBTyxhQUFhO0lBbUJ4QixZQUFvQixZQUFtQjtRQUFuQixpQkFBWSxHQUFaLFlBQVksQ0FBTztRQWxCL0IsV0FBTSxHQUFHLElBQUksZUFBZSxDQUFRLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUV2RCxZQUFPLEdBQUcsSUFBSSxPQUFPLEVBQXNCLENBQUM7UUFNcEQsZUFBVSxHQUFHLENBQ1gsUUFBaUMsRUFDakMsWUFBK0MsT0FBTyxFQUN0RCxFQUFFLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxFQUFFLG9CQUFvQixDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7UUFFdEUsZ0JBQVcsR0FBRyxDQUNaLFFBQThDLEVBQzlDLFdBQVcsQ0FBQyxDQUFRLEVBQUUsRUFBRSxDQUFDLENBQUMsS0FBSyxTQUFTLEVBQ3hDLEVBQUUsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLEVBQUUsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7SUFFZCxDQUFDO0lBZDNDLElBQUksS0FBSztRQUNQLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUM7SUFDM0IsQ0FBQztJQWNELEtBQUssQ0FBQyxLQUFxQjtRQUN6QixJQUFJLFlBQVksR0FBRyxLQUFjLENBQUM7UUFFbEMsSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFO1lBQ3RELFlBQVksR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDLEtBQUssRUFBRSxHQUFHLEtBQUssRUFBRSxDQUFDO1NBQzVDO1FBRUQsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDL0IsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsWUFBa0MsQ0FBQyxDQUFDO0lBQ3hELENBQUM7SUFFRCxTQUFTLENBQUMsS0FBeUI7UUFDakMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLENBQUMsQ0FBQztRQUMvQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUMzQixDQUFDO0lBRUQsR0FBRyxDQUFDLEtBQVk7UUFDZCxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUN4QixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUEyQixDQUFDLENBQUM7SUFDakQsQ0FBQztJQUVELEtBQUs7UUFDSCxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUM5QixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgY29tcGFyZSBmcm9tICdqdXN0LWNvbXBhcmUnO1xyXG5pbXBvcnQgeyBCZWhhdmlvclN1YmplY3QsIFN1YmplY3QgfSBmcm9tICdyeGpzJztcclxuaW1wb3J0IHsgZGlzdGluY3RVbnRpbENoYW5nZWQsIGZpbHRlciwgbWFwIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xyXG5pbXBvcnQgeyBEZWVwUGFydGlhbCB9IGZyb20gJy4uL21vZGVscyc7XHJcbmltcG9ydCB7IGRlZXBNZXJnZSB9IGZyb20gJy4vb2JqZWN0LXV0aWxzJztcclxuXHJcbmV4cG9ydCBjbGFzcyBJbnRlcm5hbFN0b3JlPFN0YXRlPiB7XHJcbiAgcHJpdmF0ZSBzdGF0ZSQgPSBuZXcgQmVoYXZpb3JTdWJqZWN0PFN0YXRlPih0aGlzLmluaXRpYWxTdGF0ZSk7XHJcblxyXG4gIHByaXZhdGUgdXBkYXRlJCA9IG5ldyBTdWJqZWN0PERlZXBQYXJ0aWFsPFN0YXRlPj4oKTtcclxuXHJcbiAgZ2V0IHN0YXRlKCkge1xyXG4gICAgcmV0dXJuIHRoaXMuc3RhdGUkLnZhbHVlO1xyXG4gIH1cclxuXHJcbiAgc2xpY2VTdGF0ZSA9IDxTbGljZT4oXHJcbiAgICBzZWxlY3RvcjogKHN0YXRlOiBTdGF0ZSkgPT4gU2xpY2UsXHJcbiAgICBjb21wYXJlRm46IChzMTogU2xpY2UsIHMyOiBTbGljZSkgPT4gYm9vbGVhbiA9IGNvbXBhcmUsXHJcbiAgKSA9PiB0aGlzLnN0YXRlJC5waXBlKG1hcChzZWxlY3RvciksIGRpc3RpbmN0VW50aWxDaGFuZ2VkKGNvbXBhcmVGbikpO1xyXG5cclxuICBzbGljZVVwZGF0ZSA9IDxTbGljZT4oXHJcbiAgICBzZWxlY3RvcjogKHN0YXRlOiBEZWVwUGFydGlhbDxTdGF0ZT4pID0+IFNsaWNlLFxyXG4gICAgZmlsdGVyRm4gPSAoeDogU2xpY2UpID0+IHggIT09IHVuZGVmaW5lZCxcclxuICApID0+IHRoaXMudXBkYXRlJC5waXBlKG1hcChzZWxlY3RvciksIGZpbHRlcihmaWx0ZXJGbikpO1xyXG5cclxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGluaXRpYWxTdGF0ZTogU3RhdGUpIHt9XHJcblxyXG4gIHBhdGNoKHN0YXRlOiBQYXJ0aWFsPFN0YXRlPikge1xyXG4gICAgbGV0IHBhdGNoZWRTdGF0ZSA9IHN0YXRlIGFzIFN0YXRlO1xyXG5cclxuICAgIGlmICh0eXBlb2Ygc3RhdGUgPT09ICdvYmplY3QnICYmICFBcnJheS5pc0FycmF5KHN0YXRlKSkge1xyXG4gICAgICBwYXRjaGVkU3RhdGUgPSB7IC4uLnRoaXMuc3RhdGUsIC4uLnN0YXRlIH07XHJcbiAgICB9XHJcblxyXG4gICAgdGhpcy5zdGF0ZSQubmV4dChwYXRjaGVkU3RhdGUpO1xyXG4gICAgdGhpcy51cGRhdGUkLm5leHQocGF0Y2hlZFN0YXRlIGFzIERlZXBQYXJ0aWFsPFN0YXRlPik7XHJcbiAgfVxyXG5cclxuICBkZWVwUGF0Y2goc3RhdGU6IERlZXBQYXJ0aWFsPFN0YXRlPikge1xyXG4gICAgdGhpcy5zdGF0ZSQubmV4dChkZWVwTWVyZ2UodGhpcy5zdGF0ZSwgc3RhdGUpKTtcclxuICAgIHRoaXMudXBkYXRlJC5uZXh0KHN0YXRlKTtcclxuICB9XHJcblxyXG4gIHNldChzdGF0ZTogU3RhdGUpIHtcclxuICAgIHRoaXMuc3RhdGUkLm5leHQoc3RhdGUpO1xyXG4gICAgdGhpcy51cGRhdGUkLm5leHQoc3RhdGUgYXMgRGVlcFBhcnRpYWw8U3RhdGU+KTtcclxuICB9XHJcblxyXG4gIHJlc2V0KCkge1xyXG4gICAgdGhpcy5zZXQodGhpcy5pbml0aWFsU3RhdGUpO1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2020/lib/utils/localization-utils.mjs

@@ -0,0 +1,49 @@
+// This will not be necessary when only Angukar 9.1+ is supported
+export function getLocaleDirection(locale) {
+    return /^(ar(-[A-Z]{2})?|ckb(-IR)?|fa(-AF)?|he|ks|lrc(-IQ)?|mzn|pa-Arab|ps(-PK)?|sd|ug|ur(-IN)?|uz-Arab|yi)$/.test(locale)
+        ? 'rtl'
+        : 'ltr';
+}
+export function createLocalizer(localization) {
+    return (resourceName, key, defaultValue) => {
+        if (resourceName === '_')
+            return key;
+        const resource = localization?.values?.[resourceName];
+        if (!resource)
+            return defaultValue;
+        return resource[key] || defaultValue;
+    };
+}
+export function createLocalizerWithFallback(localization) {
+    const findLocalization = createLocalizationFinder(localization);
+    return (resourceNames, keys, defaultValue) => {
+        const { localized } = findLocalization(resourceNames, keys);
+        return localized || defaultValue;
+    };
+}
+export function createLocalizationPipeKeyGenerator(localization) {
+    const findLocalization = createLocalizationFinder(localization);
+    return (resourceNames, keys, defaultKey) => {
+        const { resourceName, key } = findLocalization(resourceNames, keys);
+        return !resourceName ? defaultKey : resourceName === '_' ? key : `${resourceName}::${key}`;
+    };
+}
+function createLocalizationFinder(localization) {
+    const localize = createLocalizer(localization);
+    return (resourceNames, keys) => {
+        resourceNames = resourceNames.concat(localization.defaultResourceName || '').filter(Boolean);
+        const resourceCount = resourceNames.length;
+        const keyCount = keys.length;
+        for (let i = 0; i < resourceCount; i++) {
+            const resourceName = resourceNames[i];
+            for (let j = 0; j < keyCount; j++) {
+                const key = keys[j];
+                const localized = localize(resourceName, key, null);
+                if (localized)
+                    return { resourceName, key, localized };
+            }
+        }
+        return { resourceName: undefined, key: undefined, localized: undefined };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/multi-tenancy-utils.mjs

@@ -0,0 +1,78 @@
+import clone from 'just-clone';
+import { tap } from 'rxjs/operators';
+import { EnvironmentService } from '../services/environment.service';
+import { MultiTenancyService } from '../services/multi-tenancy.service';
+import { createTokenParser } from './string-utils';
+const tenancyPlaceholder = '{0}';
+function getCurrentTenancyName(appBaseUrl) {
+    if (appBaseUrl.charAt(appBaseUrl.length - 1) !== '/')
+        appBaseUrl += '/';
+    const parseTokens = createTokenParser(appBaseUrl);
+    const token = tenancyPlaceholder.replace(/[}{]/g, '');
+    return parseTokens(window.location.href)[token]?.[0];
+}
+function getCurrentTenancyNameFromUrl(tenantKey) {
+    const urlParams = new URLSearchParams(window.location.search);
+    return urlParams.get(tenantKey);
+}
+export async function parseTenantFromUrl(injector) {
+    const environmentService = injector.get(EnvironmentService);
+    const multiTenancyService = injector.get(MultiTenancyService);
+    const baseUrl = environmentService.getEnvironment()?.application?.baseUrl || '';
+    const tenancyName = getCurrentTenancyName(baseUrl);
+    const hideTenantBox = () => {
+        multiTenancyService.isTenantBoxVisible = false;
+    };
+    const setDomainTenant = (tenant) => {
+        multiTenancyService.domainTenant = {
+            id: tenant.tenantId,
+            name: tenant.name,
+            isAvailable: true,
+        };
+    };
+    const setEnvironmentWithDomainTenant = (tenant) => {
+        hideTenantBox();
+        setDomainTenant(tenant);
+    };
+    if (tenancyName) {
+        /**
+         * We have to replace tenant name within the urls from environment,
+         * because the code below will make a http request to find information about the domain tenant.
+         * Before this request takes place, we need to replace placeholders aka "{0}".
+         */
+        replaceTenantNameWithinEnvironment(injector, tenancyName);
+        return multiTenancyService
+            .setTenantByName(tenancyName)
+            .pipe(tap(setEnvironmentWithDomainTenant))
+            .toPromise();
+    }
+    else {
+        /**
+         * If there is no tenant, we still have to clean up {0}. from baseUrl to avoid incorrect http requests.
+         */
+        replaceTenantNameWithinEnvironment(injector, '', tenancyPlaceholder + '.');
+        const tenantIdFromQueryParams = getCurrentTenancyNameFromUrl(multiTenancyService.tenantKey);
+        if (tenantIdFromQueryParams) {
+            return multiTenancyService.setTenantById(tenantIdFromQueryParams).toPromise();
+        }
+    }
+    return Promise.resolve();
+}
+function replaceTenantNameWithinEnvironment(injector, tenancyName, placeholder = tenancyPlaceholder) {
+    const environmentService = injector.get(EnvironmentService);
+    const environment = clone(environmentService.getEnvironment());
+    if (environment.application.baseUrl) {
+        environment.application.baseUrl = environment.application.baseUrl.replace(placeholder, tenancyName);
+    }
+    if (environment.oAuthConfig.redirectUri) {
+        environment.oAuthConfig.redirectUri = environment.oAuthConfig.redirectUri.replace(placeholder, tenancyName);
+    }
+    environment.oAuthConfig.issuer = environment.oAuthConfig.issuer.replace(placeholder, tenancyName);
+    Object.keys(environment.apis).forEach(api => {
+        Object.keys(environment.apis[api]).forEach(key => {
+            environment.apis[api][key] = environment.apis[api][key].replace(placeholder, tenancyName);
+        });
+    });
+    return environmentService.setState(environment);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multi-tenancy-utils.js","sourceRoot":"","sources":["../../../../../../packages/core/src/lib/utils/multi-tenancy-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector } from '@angular/core';\r\nimport clone from 'just-clone';\r\n\r\nimport { tap } from 'rxjs/operators';\r\nimport { Environment } from '../models/environment';\r\n\r\nimport { FindTenantResultDto } from '../proxy/volo/abp/asp-net-core/mvc/multi-tenancy/models';\r\nimport { EnvironmentService } from '../services/environment.service';\r\nimport { MultiTenancyService } from '../services/multi-tenancy.service';\r\nimport { createTokenParser } from './string-utils';\r\n\r\nconst tenancyPlaceholder = '{0}';\r\n\r\nfunction getCurrentTenancyName(appBaseUrl: string): string {\r\n  if (appBaseUrl.charAt(appBaseUrl.length - 1) !== '/') appBaseUrl += '/';\r\n\r\n  const parseTokens = createTokenParser(appBaseUrl);\r\n  const token = tenancyPlaceholder.replace(/[}{]/g, '');\r\n  return parseTokens(window.location.href)[token]?.[0];\r\n}\r\n\r\nfunction getCurrentTenancyNameFromUrl(tenantKey: string) {\r\n  const urlParams = new URLSearchParams(window.location.search);\r\n  return urlParams.get(tenantKey);\r\n}\r\n\r\nexport async function parseTenantFromUrl(injector: Injector) {\r\n  const environmentService = injector.get(EnvironmentService);\r\n  const multiTenancyService = injector.get(MultiTenancyService);\r\n\r\n  const baseUrl = environmentService.getEnvironment()?.application?.baseUrl || '';\r\n  const tenancyName = getCurrentTenancyName(baseUrl);\r\n\r\n  const hideTenantBox = () => {\r\n    multiTenancyService.isTenantBoxVisible = false;\r\n  };\r\n\r\n  const setDomainTenant = (tenant: FindTenantResultDto) => {\r\n    multiTenancyService.domainTenant = {\r\n      id: tenant.tenantId,\r\n      name: tenant.name,\r\n      isAvailable: true,\r\n    };\r\n  };\r\n\r\n  const setEnvironmentWithDomainTenant = (tenant: FindTenantResultDto) => {\r\n    hideTenantBox();\r\n    setDomainTenant(tenant);\r\n  };\r\n\r\n  if (tenancyName) {\r\n    /**\r\n     * We have to replace tenant name within the urls from environment,\r\n     * because the code below will make a http request to find information about the domain tenant.\r\n     * Before this request takes place, we need to replace placeholders aka \"{0}\".\r\n     */\r\n    replaceTenantNameWithinEnvironment(injector, tenancyName);\r\n    return multiTenancyService\r\n      .setTenantByName(tenancyName)\r\n      .pipe(tap(setEnvironmentWithDomainTenant))\r\n      .toPromise();\r\n  } else {\r\n    /**\r\n     * If there is no tenant, we still have to clean up {0}. from baseUrl to avoid incorrect http requests.\r\n     */\r\n    replaceTenantNameWithinEnvironment(injector, '', tenancyPlaceholder + '.');\r\n\r\n    const tenantIdFromQueryParams = getCurrentTenancyNameFromUrl(multiTenancyService.tenantKey);\r\n    if (tenantIdFromQueryParams) {\r\n      return multiTenancyService.setTenantById(tenantIdFromQueryParams).toPromise();\r\n    }\r\n  }\r\n\r\n  return Promise.resolve();\r\n}\r\n\r\nfunction replaceTenantNameWithinEnvironment(\r\n  injector: Injector,\r\n  tenancyName: string,\r\n  placeholder = tenancyPlaceholder,\r\n) {\r\n  const environmentService = injector.get(EnvironmentService);\r\n\r\n  const environment = clone(environmentService.getEnvironment()) as Environment;\r\n\r\n  if (environment.application.baseUrl) {\r\n    environment.application.baseUrl = environment.application.baseUrl.replace(\r\n      placeholder,\r\n      tenancyName,\r\n    );\r\n  }\r\n\r\n  if (environment.oAuthConfig.redirectUri) {\r\n    environment.oAuthConfig.redirectUri = environment.oAuthConfig.redirectUri.replace(\r\n      placeholder,\r\n      tenancyName,\r\n    );\r\n  }\r\n\r\n  environment.oAuthConfig.issuer = environment.oAuthConfig.issuer.replace(placeholder, tenancyName);\r\n\r\n  Object.keys(environment.apis).forEach(api => {\r\n    Object.keys(environment.apis[api]).forEach(key => {\r\n      environment.apis[api][key] = environment.apis[api][key].replace(placeholder, tenancyName);\r\n    });\r\n  });\r\n\r\n  return environmentService.setState(environment);\r\n}\r\n"]}