@alauda-fe/common 1.4.36 → 1.4.38

package/esm2022/authorization/interceptor.service.mjs

@@ -4,16 +4,19 @@
  */
 import { DialogService } from '@alauda/ui';
 import { Inject, Injectable, Injector } from '@angular/core';
-import { NEVER, throwError, catchError, concatMap, take, map, of, switchMap, } from 'rxjs';
+import { EMPTY, NEVER, from, throwError, catchError, concatMap, take, map, of, switchMap, } from 'rxjs';
 import { ApiGatewayService } from '../api/public-api';
 import { ANONYMOUS_APIS, catchPromise } from '../core/public-api';
-import { TranslateService } from '../public-api';
-import { SESSION_MANAGE_KEY, SessionManageService, } from './session-manage.service';
-import { AuthorizationStateService } from './state.service';
+import { TranslateService } from '../translate/public-api';
+import { checkAuthorizationToken, logout, refreshAuthorizationToken, } from './authorization';
+import { SESSION_MANAGE_KEY } from './constants';
+import { SessionManageService } from './session-manage.service';
+import { readStorageToken } from './storage-token';
 import * as i0 from "@angular/core";
 import * as i1 from "../api/public-api";
 import * as i2 from "@alauda/ui";
 import * as i3 from "./session-manage.service";
+const AUTHORIZATION_API_PREFIX = '/console/api/v2/token/';
 // Interceptor must provide with correct order, not provide in root here
 // https://angular.cn/guide/http#interceptor-order
 export class AuthorizationInterceptorService {
@@ -26,47 +29,34 @@ export class AuthorizationInterceptorService {
         this.sessionInvalidConfirm = false;
     }
     intercept(req, next) {
-        if (this.isConsoleRelative(req.url)) {
-            return next.handle(req);
+        if (this.isRelativeUrl(req.url)) {
+            if (!this.isConsoleApi(req.url) || !this.needConsoleAuthorization(req)) {
+                return next.handle(req);
+            }
+            return this.handleAuthorizedRequest(next, req, null);
         }
-        const auth = this.getAuth();
-        return auth.getTokenPayload().pipe(switchMap(() => this.apiGateway.getApiAddress()), take(1), concatMap(apiAddress => {
+        return this.apiGateway.getApiAddress().pipe(take(1), concatMap(apiAddress => {
             if (!this.needAuthorization(apiAddress, req)) {
                 return next.handle(req);
             }
-            const idToken = auth.getTokenByStorage();
-            const authReq = this.cloneReq(req, idToken);
-            return next.handle(authReq).pipe(catchError((error) => {
-                if (this.isSessionInvalid(error)) {
-                    this.handleSessionInvalid();
-                    return NEVER;
-                }
-                // 当用户被禁用自动登出
-                if (this.isInvalidUser(error)) {
-                    auth.logout(true);
-                    return NEVER;
-                }
-                if (!this.isUnauthorized(error)) {
-                    return throwError(() => error);
-                }
-                if (this.isWatchReq(apiAddress, authReq)) {
-                    return NEVER;
-                }
-                return auth.checkToken().pipe(map(() => false), catchError(() => of(true)), switchMap(expired => expired
-                    ? this.retryAuth(next, authReq)
-                    : throwError(() => error)));
-            }));
+            return this.handleAuthorizedRequest(next, req, apiAddress);
         }));
     }
-    // console relative means url protocol+hostname+port same with console, for this case, just check url start with ```http(s)://``` or ```//```
-    isConsoleRelative(url) {
+    // A relative URL shares the same origin as the console (no http(s):// or // prefix)
+    isRelativeUrl(url) {
         const lowerCaseUrl = (url || '').toLowerCase();
         return (!lowerCaseUrl.startsWith('http://') &&
             !lowerCaseUrl.startsWith('https://') &&
             !lowerCaseUrl.startsWith('//'));
     }
+    isConsoleApi(url) {
+        return this.isRelativeUrl(url) && url.startsWith('/console/api/');
+    }
+    isAuthorizationApi(url) {
+        return url.startsWith(AUTHORIZATION_API_PREFIX);
+    }
     cloneReq(req, idToken) {
-        return idToken
+        return idToken && !req.headers.get('Authorization')
             ? req.clone({
                 setHeaders: {
                     Authorization: `Bearer ${idToken}`,
@@ -74,26 +64,58 @@ export class AuthorizationInterceptorService {
             })
             : req;
     }
+    handleAuthorizedRequest(next, req, apiAddress) {
+        const isConsoleApi = this.isConsoleApi(req.url);
+        const isAuthorizationApi = this.isAuthorizationApi(req.url);
+        const idToken = readStorageToken();
+        const authReq = this.cloneReq(req, idToken);
+        return next.handle(authReq).pipe(catchError((error) => {
+            if (this.isSessionInvalid(error)) {
+                this.handleSessionInvalid();
+                return NEVER;
+            }
+            // 当用户被禁用自动登出
+            if (this.isInvalidUser(error)) {
+                logout(true);
+                return NEVER;
+            }
+            if (!this.isUnauthorized(error)) {
+                return throwError(() => error);
+            }
+            if (isAuthorizationApi) {
+                return throwError(() => error);
+            }
+            if (!isConsoleApi && this.isWatchReq(apiAddress, authReq)) {
+                return NEVER;
+            }
+            return from(checkAuthorizationToken()).pipe(map(() => false), catchError(() => of(true)), switchMap(expired => expired || (isConsoleApi && !idToken)
+                ? this.retryAuth(next, authReq)
+                : throwError(() => error)));
+        }));
+    }
     retryAuth(next, req) {
-        const auth = this.getAuth();
-        return auth.refreshToken().pipe(concatMap(({ id_token: idToken }) => {
+        return from(refreshAuthorizationToken()).pipe(catchError(() => {
+            logout(true);
+            return EMPTY;
+        }), concatMap(({ id_token: idToken }) => {
             const authReq = this.cloneReq(req, idToken);
             return next.handle(authReq).pipe(catchError((error) => {
                 if (this.isUnauthorized(error)) {
-                    auth.logout(true);
+                    logout(true);
                 }
                 return throwError(() => error);
             }));
         }));
     }
-    getAuth() {
-        if (!this.auth) {
-            this.auth = this.injector.get(AuthorizationStateService);
+    needAuthorization(apiAddress, req) {
+        if (req.headers.get('Authorization') ||
+            (!this.isConsoleApi(req.url) && !req.url.startsWith(apiAddress))) {
+            return false;
         }
-        return this.auth;
+        return !this.anonymousApis.some(api => api instanceof RegExp ? api.test(req.url) : req.url.includes(api));
     }
-    needAuthorization(apiAddress, req) {
-        if (!req.url.startsWith(apiAddress) || req.headers.get('Authorization')) {
+    needConsoleAuthorization(req) {
+        if (req.headers.get('Authorization')) {
             return false;
         }
         return !this.anonymousApis.some(api => api instanceof RegExp ? api.test(req.url) : req.url.includes(api));
@@ -110,7 +132,7 @@ export class AuthorizationInterceptorService {
         if (Date.now() - parseInt(sessionStorage.getItem(SESSION_MANAGE_KEY)) <
             5000) {
             sessionStorage.removeItem(SESSION_MANAGE_KEY);
-            this.auth.logout(true);
+            logout(true);
             return;
         }
         if (this.sessionInvalidConfirm) {
@@ -125,7 +147,7 @@ export class AuthorizationInterceptorService {
             cancelButton: false,
         })).subscribe(() => {
             this.sessionInvalidConfirm = false;
-            this.auth.logout(true);
+            logout(true);
         });
     }
     isUnauthorized(errorRes) {
@@ -153,4 +175,4 @@ export class AuthorizationInterceptorService {
                 type: Inject,
                 args: [ANONYMOUS_APIS]
             }] }, { type: i1.ApiGatewayService }, { type: i0.Injector }, { type: i2.DialogService }, { type: i3.SessionManageService }], null); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.service.js","sourceRoot":"","sources":["../../../../../libs/common/src/authorization/interceptor.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module authorization\n */\n\nimport { DialogService } from '@alauda/ui';\nimport {\n  HttpErrorResponse,\n  HttpHandler,\n  HttpInterceptor,\n  HttpRequest,\n} from '@angular/common/http';\nimport { Inject, Injectable, Injector } from '@angular/core';\nimport {\n  NEVER,\n  throwError,\n  catchError,\n  concatMap,\n  take,\n  map,\n  of,\n  switchMap,\n} from 'rxjs';\n\nimport { ApiGatewayService } from '../api/public-api';\nimport { ANONYMOUS_APIS, catchPromise } from '../core/public-api';\nimport { Status, TranslateService } from '../public-api';\n\nimport {\n  SESSION_MANAGE_KEY,\n  SessionManageService,\n} from './session-manage.service';\nimport { AuthorizationStateService } from './state.service';\n\n// Interceptor must provide with correct order, not provide in root here\n// https://angular.cn/guide/http#interceptor-order\n@Injectable()\nexport class AuthorizationInterceptorService implements HttpInterceptor {\n  private auth: AuthorizationStateService;\n\n  private sessionInvalidConfirm = false;\n\n  constructor(\n    @Inject(ANONYMOUS_APIS)\n    private readonly anonymousApis: Array<string | RegExp>,\n    private readonly apiGateway: ApiGatewayService,\n    private readonly injector: Injector,\n    private readonly dialog: DialogService,\n    private readonly sessionManage: SessionManageService,\n  ) {}\n\n  intercept(req: HttpRequest<unknown>, next: HttpHandler) {\n    if (this.isConsoleRelative(req.url)) {\n      return next.handle(req);\n    }\n\n    const auth = this.getAuth();\n\n    return auth.getTokenPayload().pipe(\n      switchMap(() => this.apiGateway.getApiAddress()),\n      take(1),\n      concatMap(apiAddress => {\n        if (!this.needAuthorization(apiAddress, req)) {\n          return next.handle(req);\n        }\n\n        const idToken = auth.getTokenByStorage();\n\n        const authReq = this.cloneReq(req, idToken);\n\n        return next.handle(authReq).pipe(\n          catchError((error: HttpErrorResponse) => {\n            if (this.isSessionInvalid(error)) {\n              this.handleSessionInvalid();\n              return NEVER;\n            }\n\n            // 当用户被禁用自动登出\n            if (this.isInvalidUser(error)) {\n              auth.logout(true);\n              return NEVER;\n            }\n\n            if (!this.isUnauthorized(error)) {\n              return throwError(() => error);\n            }\n\n            if (this.isWatchReq(apiAddress, authReq)) {\n              return NEVER;\n            }\n\n            return auth.checkToken().pipe(\n              map(() => false),\n              catchError(() => of(true)),\n              switchMap(expired =>\n                expired\n                  ? this.retryAuth(next, authReq)\n                  : throwError(() => error),\n              ),\n            );\n          }),\n        );\n      }),\n    );\n  }\n\n  // console relative means url protocol+hostname+port same with console, for this case, just check url start with ```http(s)://``` or ```//```\n  isConsoleRelative(url: string) {\n    const lowerCaseUrl = (url || '').toLowerCase();\n\n    return (\n      !lowerCaseUrl.startsWith('http://') &&\n      !lowerCaseUrl.startsWith('https://') &&\n      !lowerCaseUrl.startsWith('//')\n    );\n  }\n\n  private cloneReq(req: HttpRequest<unknown>, idToken: string) {\n    return idToken\n      ? req.clone({\n          setHeaders: {\n            Authorization: `Bearer ${idToken}`,\n          },\n        })\n      : req;\n  }\n\n  private retryAuth(next: HttpHandler, req: HttpRequest<unknown>) {\n    const auth = this.getAuth();\n    return auth.refreshToken().pipe(\n      concatMap(({ id_token: idToken }) => {\n        const authReq = this.cloneReq(req, idToken);\n        return next.handle(authReq).pipe(\n          catchError((error: HttpErrorResponse) => {\n            if (this.isUnauthorized(error)) {\n              auth.logout(true);\n            }\n\n            return throwError(() => error);\n          }),\n        );\n      }),\n    );\n  }\n\n  private getAuth() {\n    if (!this.auth) {\n      this.auth = this.injector.get(AuthorizationStateService);\n    }\n    return this.auth;\n  }\n\n  private needAuthorization(\n    apiAddress: string,\n    req: HttpRequest<unknown>,\n  ): boolean {\n    if (!req.url.startsWith(apiAddress) || req.headers.get('Authorization')) {\n      return false;\n    }\n\n    return !this.anonymousApis.some(api =>\n      api instanceof RegExp ? api.test(req.url) : req.url.includes(api),\n    );\n  }\n\n  private is401({ error }: HttpErrorResponse) {\n    return this.isStatus(error) && error.code === 401;\n  }\n\n  private isSessionInvalid(errorRes: HttpErrorResponse) {\n    const { error } = errorRes;\n    return this.is401(errorRes) && error.reason === 'SessionInvalid';\n  }\n\n  private handleSessionInvalid() {\n    this.sessionManage.complete();\n    if (\n      Date.now() - parseInt(sessionStorage.getItem(SESSION_MANAGE_KEY)) <\n      5000\n    ) {\n      sessionStorage.removeItem(SESSION_MANAGE_KEY);\n      this.auth.logout(true);\n      return;\n    }\n\n    if (this.sessionInvalidConfirm) {\n      return;\n    }\n\n    this.sessionInvalidConfirm = true;\n    // fix circle dependency error\n    const translate = this.injector.get(TranslateService);\n    catchPromise(\n      this.dialog.confirm({\n        title: translate.get('session_invalid_hint'),\n        confirmText: translate.get('i_know'),\n        cancelButton: false,\n      }),\n    ).subscribe(() => {\n      this.sessionInvalidConfirm = false;\n      this.auth.logout(true);\n    });\n  }\n\n  private isUnauthorized(errorRes: HttpErrorResponse) {\n    return this.is401(errorRes) && errorRes.error.reason === 'Unauthorized';\n  }\n\n  private isInvalidUser(errorRes: HttpErrorResponse) {\n    return this.is401(errorRes) && errorRes.error.reason === 'InvalidUser';\n  }\n\n  private isStatus(error: string | Status): error is Status {\n    return error && typeof error !== 'string' && 'code' in error;\n  }\n\n  private isWatchReq(\n    apiAddress: string,\n    { url, params }: HttpRequest<unknown>,\n  ) {\n    const isStandardApi =\n      url.startsWith(apiAddress + '/api/') ||\n      url.startsWith(apiAddress + '/apis/') ||\n      url.startsWith(apiAddress + '/kubernetes/');\n    const isWatchOn = params.get('watch')?.toLowerCase() === 'true';\n    return isStandardApi && isWatchOn;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.service.js","sourceRoot":"","sources":["../../../../../libs/common/src/authorization/interceptor.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module authorization\n */\n\nimport { DialogService } from '@alauda/ui';\nimport {\n  HttpErrorResponse,\n  HttpHandler,\n  HttpInterceptor,\n  HttpRequest,\n} from '@angular/common/http';\nimport { Inject, Injectable, Injector } from '@angular/core';\nimport {\n  EMPTY,\n  NEVER,\n  from,\n  throwError,\n  catchError,\n  concatMap,\n  take,\n  map,\n  of,\n  switchMap,\n} from 'rxjs';\n\nimport { ApiGatewayService } from '../api/public-api';\nimport { ANONYMOUS_APIS, catchPromise, Status } from '../core/public-api';\nimport { TranslateService } from '../translate/public-api';\n\nimport {\n  checkAuthorizationToken,\n  logout,\n  refreshAuthorizationToken,\n} from './authorization';\nimport { SESSION_MANAGE_KEY } from './constants';\nimport { SessionManageService } from './session-manage.service';\nimport { readStorageToken } from './storage-token';\n\nconst AUTHORIZATION_API_PREFIX = '/console/api/v2/token/';\n\n// Interceptor must provide with correct order, not provide in root here\n// https://angular.cn/guide/http#interceptor-order\n@Injectable()\nexport class AuthorizationInterceptorService implements HttpInterceptor {\n  private sessionInvalidConfirm = false;\n\n  constructor(\n    @Inject(ANONYMOUS_APIS)\n    private readonly anonymousApis: Array<string | RegExp>,\n    private readonly apiGateway: ApiGatewayService,\n    private readonly injector: Injector,\n    private readonly dialog: DialogService,\n    private readonly sessionManage: SessionManageService,\n  ) {}\n\n  intercept(req: HttpRequest<unknown>, next: HttpHandler) {\n    if (this.isRelativeUrl(req.url)) {\n      if (!this.isConsoleApi(req.url) || !this.needConsoleAuthorization(req)) {\n        return next.handle(req);\n      }\n\n      return this.handleAuthorizedRequest(next, req, null);\n    }\n\n    return this.apiGateway.getApiAddress().pipe(\n      take(1),\n      concatMap(apiAddress => {\n        if (!this.needAuthorization(apiAddress, req)) {\n          return next.handle(req);\n        }\n\n        return this.handleAuthorizedRequest(next, req, apiAddress);\n      }),\n    );\n  }\n\n  // A relative URL shares the same origin as the console (no http(s):// or // prefix)\n  private isRelativeUrl(url: string) {\n    const lowerCaseUrl = (url || '').toLowerCase();\n\n    return (\n      !lowerCaseUrl.startsWith('http://') &&\n      !lowerCaseUrl.startsWith('https://') &&\n      !lowerCaseUrl.startsWith('//')\n    );\n  }\n\n  private isConsoleApi(url: string) {\n    return this.isRelativeUrl(url) && url.startsWith('/console/api/');\n  }\n\n  private isAuthorizationApi(url: string) {\n    return url.startsWith(AUTHORIZATION_API_PREFIX);\n  }\n\n  private cloneReq(req: HttpRequest<unknown>, idToken: string) {\n    return idToken && !req.headers.get('Authorization')\n      ? req.clone({\n          setHeaders: {\n            Authorization: `Bearer ${idToken}`,\n          },\n        })\n      : req;\n  }\n\n  private handleAuthorizedRequest(\n    next: HttpHandler,\n    req: HttpRequest<unknown>,\n    apiAddress: string | null,\n  ) {\n    const isConsoleApi = this.isConsoleApi(req.url);\n    const isAuthorizationApi = this.isAuthorizationApi(req.url);\n    const idToken = readStorageToken();\n    const authReq = this.cloneReq(req, idToken);\n\n    return next.handle(authReq).pipe(\n      catchError((error: HttpErrorResponse) => {\n        if (this.isSessionInvalid(error)) {\n          this.handleSessionInvalid();\n          return NEVER;\n        }\n\n        // 当用户被禁用自动登出\n        if (this.isInvalidUser(error)) {\n          logout(true);\n          return NEVER;\n        }\n\n        if (!this.isUnauthorized(error)) {\n          return throwError(() => error);\n        }\n\n        if (isAuthorizationApi) {\n          return throwError(() => error);\n        }\n\n        if (!isConsoleApi && this.isWatchReq(apiAddress, authReq)) {\n          return NEVER;\n        }\n\n        return from(checkAuthorizationToken()).pipe(\n          map(() => false),\n          catchError(() => of(true)),\n          switchMap(expired =>\n            expired || (isConsoleApi && !idToken)\n              ? this.retryAuth(next, authReq)\n              : throwError(() => error),\n          ),\n        );\n      }),\n    );\n  }\n\n  private retryAuth(next: HttpHandler, req: HttpRequest<unknown>) {\n    return from(refreshAuthorizationToken()).pipe(\n      catchError(() => {\n        logout(true);\n        return EMPTY;\n      }),\n      concatMap(({ id_token: idToken }) => {\n        const authReq = this.cloneReq(req, idToken);\n        return next.handle(authReq).pipe(\n          catchError((error: HttpErrorResponse) => {\n            if (this.isUnauthorized(error)) {\n              logout(true);\n            }\n\n            return throwError(() => error);\n          }),\n        );\n      }),\n    );\n  }\n\n  private needAuthorization(\n    apiAddress: string,\n    req: HttpRequest<unknown>,\n  ): boolean {\n    if (\n      req.headers.get('Authorization') ||\n      (!this.isConsoleApi(req.url) && !req.url.startsWith(apiAddress))\n    ) {\n      return false;\n    }\n\n    return !this.anonymousApis.some(api =>\n      api instanceof RegExp ? api.test(req.url) : req.url.includes(api),\n    );\n  }\n\n  private needConsoleAuthorization(req: HttpRequest<unknown>) {\n    if (req.headers.get('Authorization')) {\n      return false;\n    }\n\n    return !this.anonymousApis.some(api =>\n      api instanceof RegExp ? api.test(req.url) : req.url.includes(api),\n    );\n  }\n\n  private is401({ error }: HttpErrorResponse) {\n    return this.isStatus(error) && error.code === 401;\n  }\n\n  private isSessionInvalid(errorRes: HttpErrorResponse) {\n    const { error } = errorRes;\n    return this.is401(errorRes) && error.reason === 'SessionInvalid';\n  }\n\n  private handleSessionInvalid() {\n    this.sessionManage.complete();\n    if (\n      Date.now() - parseInt(sessionStorage.getItem(SESSION_MANAGE_KEY)) <\n      5000\n    ) {\n      sessionStorage.removeItem(SESSION_MANAGE_KEY);\n      logout(true);\n      return;\n    }\n\n    if (this.sessionInvalidConfirm) {\n      return;\n    }\n\n    this.sessionInvalidConfirm = true;\n    // fix circle dependency error\n    const translate = this.injector.get(TranslateService);\n    catchPromise(\n      this.dialog.confirm({\n        title: translate.get('session_invalid_hint'),\n        confirmText: translate.get('i_know'),\n        cancelButton: false,\n      }),\n    ).subscribe(() => {\n      this.sessionInvalidConfirm = false;\n      logout(true);\n    });\n  }\n\n  private isUnauthorized(errorRes: HttpErrorResponse) {\n    return this.is401(errorRes) && errorRes.error.reason === 'Unauthorized';\n  }\n\n  private isInvalidUser(errorRes: HttpErrorResponse) {\n    return this.is401(errorRes) && errorRes.error.reason === 'InvalidUser';\n  }\n\n  private isStatus(error: string | Status): error is Status {\n    return error && typeof error !== 'string' && 'code' in error;\n  }\n\n  private isWatchReq(\n    apiAddress: string,\n    { url, params }: HttpRequest<unknown>,\n  ) {\n    const isStandardApi =\n      url.startsWith(apiAddress + '/api/') ||\n      url.startsWith(apiAddress + '/apis/') ||\n      url.startsWith(apiAddress + '/kubernetes/');\n    const isWatchOn = params.get('watch')?.toLowerCase() === 'true';\n    return isStandardApi && isWatchOn;\n  }\n}\n"]}

package/esm2022/authorization/public-api.mjs

@@ -12,4 +12,5 @@ export * from './state.service';
 export * from './storage-token';
 export * from './authorization';
 export * from './constants';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9hdXRob3JpemF0aW9uL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUVILGNBQWM7QUFDZCxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBbW2luY2x1ZGU6YXV0aG9yaXphdGlvbi9SRUFETUUubWRdXVxuICogQG1vZHVsZSBhdXRob3JpemF0aW9uXG4gKiBAcHJlZmVycmVkXG4gKi9cblxuLyoqIGltcG9ydHMgKi9cbmV4cG9ydCAqIGZyb20gJy4vZ3VhcmQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2ludGVyY2VwdG9yLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9hcHAtaW5pdC11cmwnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXNzaW9uLW1hbmFnZS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc3RhdGUuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3N0b3JhZ2UtdG9rZW4nO1xuZXhwb3J0ICogZnJvbSAnLi9hdXRob3JpemF0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vY29uc3RhbnRzJztcbiJdfQ==
+export * from './token-client';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9hdXRob3JpemF0aW9uL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUVILGNBQWM7QUFDZCxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFtbaW5jbHVkZTphdXRob3JpemF0aW9uL1JFQURNRS5tZF1dXG4gKiBAbW9kdWxlIGF1dGhvcml6YXRpb25cbiAqIEBwcmVmZXJyZWRcbiAqL1xuXG4vKiogaW1wb3J0cyAqL1xuZXhwb3J0ICogZnJvbSAnLi9ndWFyZC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vaW50ZXJjZXB0b3Iuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2FwcC1pbml0LXVybCc7XG5leHBvcnQgKiBmcm9tICcuL3Nlc3Npb24tbWFuYWdlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zdGF0ZS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc3RvcmFnZS10b2tlbic7XG5leHBvcnQgKiBmcm9tICcuL2F1dGhvcml6YXRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9jb25zdGFudHMnO1xuZXhwb3J0ICogZnJvbSAnLi90b2tlbi1jbGllbnQnO1xuIl19

package/esm2022/authorization/runtime.mjs

@@ -0,0 +1,96 @@
+import { noop } from '../core/public-api';
+import { TOKEN_INFO_API, TOKEN_REFRESH_API } from './constants';
+import { readStorageToken, writeStorageToken } from './storage-token';
+let cachedAccountInfo;
+export function resetAuthRuntimeCache() {
+    cachedAccountInfo = undefined;
+}
+export function getCachedAccountInfo() {
+    return cachedAccountInfo;
+}
+export function setCachedAccountInfo(info) {
+    cachedAccountInfo = info;
+}
+export function createAuthorizedFetchInit(init = {}) {
+    const headers = new Headers(init.headers);
+    const idToken = readStorageToken();
+    if (idToken && !headers.has('Authorization')) {
+        headers.set('Authorization', `Bearer ${idToken}`);
+    }
+    return {
+        ...init,
+        credentials: init.credentials ?? 'same-origin',
+        headers,
+    };
+}
+// Sends request with auth header but no 401 retry — for token management APIs
+export function fetchTokenApi(input, init) {
+    return fetch(input, createAuthorizedFetchInit(init));
+}
+export async function fetchAuthorizedResource(input, init) {
+    const response = await fetch(input, createAuthorizedFetchInit(init));
+    if (response.status !== 401) {
+        return response;
+    }
+    const { refreshAuthorizationToken, logout } = await import('./authorization');
+    const refreshed = await refreshAuthorizationToken().catch(() => null);
+    if (!refreshed) {
+        logout(true);
+        return new Promise(noop);
+    }
+    return fetch(input, createAuthorizedFetchInit(init));
+}
+export async function requestTokenInfo(force = false) {
+    if (!force && cachedAccountInfo !== undefined) {
+        return cachedAccountInfo;
+    }
+    return fetchTokenApi(TOKEN_INFO_API).then(async (response) => {
+        if (response.ok) {
+            const info = await response.json();
+            cachedAccountInfo = info;
+            return info;
+        }
+        if (response.status === 401) {
+            cachedAccountInfo = null;
+            return null;
+        }
+        throw createResponseError(response, 'Failed to fetch token info');
+    });
+}
+export async function requestTokenRefresh() {
+    return fetchTokenApi(TOKEN_REFRESH_API).then(async (response) => {
+        if (response.ok) {
+            const tokenResponse = await response.json();
+            if (tokenResponse.id_token) {
+                writeStorageToken(tokenResponse.id_token);
+            }
+            cachedAccountInfo = undefined;
+            return tokenResponse;
+        }
+        if (response.status === 401) {
+            cachedAccountInfo = null;
+            return null;
+        }
+        throw createResponseError(response, 'Failed to refresh token');
+    });
+}
+export async function resolveTokenInfoWithRefresh() {
+    const info = await requestTokenInfo();
+    if (info) {
+        return info;
+    }
+    const refreshed = await requestTokenRefresh();
+    if (!refreshed) {
+        return null;
+    }
+    return requestTokenInfo(true);
+}
+function createResponseError(response, message) {
+    const error = new Error(`${message}: ${response.status} ${response.statusText}`);
+    Object.assign(error, {
+        status: response.status,
+        statusText: response.statusText,
+    });
+    return error;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../../../libs/common/src/authorization/runtime.ts"],"names":[],"mappings":"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","sourcesContent":["import { noop } from '../core/public-api';\nimport type { AccountInfo } from '../page-scaffold/page-header/account-menu/component/component';\n\nimport { TOKEN_INFO_API, TOKEN_REFRESH_API } from './constants';\nimport { readStorageToken, writeStorageToken } from './storage-token';\n\nexport interface TokenResponse {\n  token_storage: string;\n  token_type: string;\n  expire_at: string;\n  issued_at: string;\n  id_token?: string;\n}\n\nlet cachedAccountInfo: AccountInfo | null | undefined;\n\nexport function resetAuthRuntimeCache() {\n  cachedAccountInfo = undefined;\n}\n\nexport function getCachedAccountInfo() {\n  return cachedAccountInfo;\n}\n\nexport function setCachedAccountInfo(info: AccountInfo | null | undefined) {\n  cachedAccountInfo = info;\n}\n\nexport function createAuthorizedFetchInit(init: RequestInit = {}) {\n  const headers = new Headers(init.headers);\n  const idToken = readStorageToken();\n\n  if (idToken && !headers.has('Authorization')) {\n    headers.set('Authorization', `Bearer ${idToken}`);\n  }\n\n  return {\n    ...init,\n    credentials: init.credentials ?? 'same-origin',\n    headers,\n  } satisfies RequestInit;\n}\n\n// Sends request with auth header but no 401 retry — for token management APIs\nexport function fetchTokenApi(input: RequestInfo | URL, init?: RequestInit) {\n  return fetch(input, createAuthorizedFetchInit(init));\n}\n\nexport async function fetchAuthorizedResource(\n  input: RequestInfo | URL,\n  init?: RequestInit,\n) {\n  const response = await fetch(input, createAuthorizedFetchInit(init));\n\n  if (response.status !== 401) {\n    return response;\n  }\n\n  const { refreshAuthorizationToken, logout } = await import('./authorization');\n  const refreshed = await refreshAuthorizationToken().catch(() => null);\n\n  if (!refreshed) {\n    logout(true);\n    return new Promise<never>(noop);\n  }\n\n  return fetch(input, createAuthorizedFetchInit(init));\n}\n\nexport async function requestTokenInfo(force = false) {\n  if (!force && cachedAccountInfo !== undefined) {\n    return cachedAccountInfo;\n  }\n\n  return fetchTokenApi(TOKEN_INFO_API).then(async response => {\n    if (response.ok) {\n      const info: AccountInfo = await response.json();\n      cachedAccountInfo = info;\n      return info;\n    }\n\n    if (response.status === 401) {\n      cachedAccountInfo = null;\n      return null;\n    }\n\n    throw createResponseError(response, 'Failed to fetch token info');\n  });\n}\n\nexport async function requestTokenRefresh() {\n  return fetchTokenApi(TOKEN_REFRESH_API).then(async response => {\n    if (response.ok) {\n      const tokenResponse: TokenResponse = await response.json();\n\n      if (tokenResponse.id_token) {\n        writeStorageToken(tokenResponse.id_token);\n      }\n      cachedAccountInfo = undefined;\n\n      return tokenResponse;\n    }\n\n    if (response.status === 401) {\n      cachedAccountInfo = null;\n      return null;\n    }\n\n    throw createResponseError(response, 'Failed to refresh token');\n  });\n}\n\nexport async function resolveTokenInfoWithRefresh() {\n  const info = await requestTokenInfo();\n\n  if (info) {\n    return info;\n  }\n\n  const refreshed = await requestTokenRefresh();\n\n  if (!refreshed) {\n    return null;\n  }\n\n  return requestTokenInfo(true);\n}\n\nfunction createResponseError(response: Response, message: string) {\n  const error = new Error(\n    `${message}: ${response.status} ${response.statusText}`,\n  );\n\n  Object.assign(error, {\n    status: response.status,\n    statusText: response.statusText,\n  });\n\n  return error;\n}\n"]}

package/esm2022/authorization/session-manage.service.mjs

@@ -2,14 +2,12 @@ import { HttpClient } from '@angular/common/http';
 import { Inject, Injectable } from '@angular/core';
 import { bufferTime, filter, fromEvent, merge, switchMap, withLatestFrom, } from 'rxjs';
 import { PageVisibilityService } from '../api/page-visibility.service';
-import { getGlobalEnvironments } from '../core/constants/public-api';
-import { API_GATEWAY, TOKEN_DISABLE_SESSION_MANAGE, skipError, } from '../public-api';
+import { skipError, API_GATEWAY, getGlobalEnvironments, TOKEN_DISABLE_SESSION_MANAGE, } from '../core/public-api';
+import { HEARTBEAT_POLLING, SESSION_MANAGE_KEY } from './constants';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common/http";
 import * as i2 from "../api/page-visibility.service";
 const EVENT_TRIGGERS = ['click', 'keypress'];
-export const HEARTBEAT_POLLING = 15_000;
-export const SESSION_MANAGE_KEY = 'session-manage-construct-time';
 export class SessionManageService {
     constructor(http, pageVisibility, disabled) {
         this.http = http;
@@ -44,4 +42,4 @@ export class SessionManageService {
                 type: Inject,
                 args: [TOKEN_DISABLE_SESSION_MANAGE]
             }] }], null); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/authorization/state.service.mjs

@@ -2,47 +2,26 @@
  * @packageDocumentation
  * @module authorization
  */
-import { HttpClient } from '@angular/common/http';
-import { Injectable, inject } from '@angular/core';
-import { EMPTY, of, catchError, map, shareReplay, switchMap, tap, timer, fromEvent, merge, timeout, } from 'rxjs';
-import { publishRef, getGlobalEnvironments, TRUE, skipError, catchPromise, } from '../core/public-api';
-import { attachAuthorizationHeader, getAuthorizationState, logout, logoutAudit, } from './authorization';
-import { TOKEN_INFO_API, LOADING_CACHE, TOKEN_REFRESH_API } from './constants';
-import { HEARTBEAT_POLLING } from './session-manage.service';
-import { readStorageAliveRecord, readStorageToken, refreshStorageAliveRecord, writeStorageToken, } from './storage-token';
+import { Injectable } from '@angular/core';
+import { EMPTY, from, of, catchError, map, tap, timer, fromEvent, merge, timeout, } from 'rxjs';
+import { getGlobalEnvironments, TRUE, catchPromise } from '../core/public-api';
+import { checkAuthorizationToken, getAuthorizationState, logout, logoutAudit, refreshAuthorizationToken, } from './authorization';
+import { LOADING_CACHE, HEARTBEAT_POLLING } from './constants';
+import { readStorageAliveRecord, refreshStorageAliveRecord, readStorageToken, } from './storage-token';
 import * as i0 from "@angular/core";
 export class AuthorizationStateService {
     constructor() {
-        this.http = inject(HttpClient);
-        this.state$ = this.http
-            .get(TOKEN_INFO_API, {
-            headers: attachAuthorizationHeader(),
-        })
-            .pipe(skipError(null), tap(info => {
-            if (!info) {
-                logout(true);
-            }
-            this.payloadSnapshot = info;
-        }), map(info => ({
-            ...getAuthorizationState(),
-            info,
-        })), shareReplay(1));
-        this.checkTokenCache$ = null;
+        this.state = getAuthorizationState();
+        this.payloadSnapshot = this.state.info ?? null;
         this.logout = logout;
         if (getGlobalEnvironments('CLOSE_BROWSER_END_SESSION') === TRUE) {
-            this.state$
-                .pipe(switchMap(state => {
-                const aliveRecord = readStorageAliveRecord();
-                if (!aliveRecord ||
-                    Date.now() - aliveRecord > HEARTBEAT_POLLING + LOADING_CACHE) {
-                    this.logoutWithAudit();
-                    return EMPTY;
-                }
-                return of(state);
-            }), switchMap(() => {
-                return merge(timer(0, HEARTBEAT_POLLING), fromEvent(window, 'beforeunload'));
-            }))
-                .subscribe(refreshStorageAliveRecord);
+            const aliveRecord = readStorageAliveRecord();
+            if (!aliveRecord ||
+                Date.now() - aliveRecord > HEARTBEAT_POLLING + LOADING_CACHE) {
+                this.logoutWithAudit();
+                return;
+            }
+            merge(timer(0, HEARTBEAT_POLLING), fromEvent(window, 'beforeunload')).subscribe(refreshStorageAliveRecord);
         }
     }
     logoutWithAudit() {
@@ -51,41 +30,21 @@ export class AuthorizationStateService {
             .subscribe(redirectUrl => logout(redirectUrl));
     }
     refreshToken() {
-        if (this.refreshTokenCache$) {
-            return this.refreshTokenCache$;
-        }
-        this.refreshTokenCache$ = this.http
-            .get(TOKEN_REFRESH_API)
-            .pipe(tap(({ id_token: idToken }) => {
-            writeStorageToken(idToken);
-            this.refreshTokenCache$ = null;
-        }), catchError(() => {
+        return from(refreshAuthorizationToken()).pipe(catchError(() => {
             logout(true);
             return EMPTY;
-        }), publishRef());
-        return this.refreshTokenCache$;
+        }));
     }
     checkToken() {
-        if (!this.checkTokenCache$) {
-            this.checkTokenCache$ = this.http.get(TOKEN_INFO_API).pipe(tap({
-                next: () => {
-                    this.checkTokenCache$ = null;
-                },
-                error: () => {
-                    this.checkTokenCache$ = null;
-                },
-            }), publishRef());
-        }
-        return this.checkTokenCache$;
+        return from(checkAuthorizationToken()).pipe(tap(info => {
+            this.payloadSnapshot = info;
+        }));
     }
     getTokenPayload() {
-        return this.state$.pipe(map(state => state.info));
+        return of(this.state.info);
     }
     getAccountInfo() {
-        if (this.payloadSnapshot) {
-            return of(this.payloadSnapshot);
-        }
-        return this.state$.pipe(map(state => state.info || {}));
+        return of(this.payloadSnapshot || {});
     }
     getTokenByStorage() {
         return readStorageToken();
@@ -97,4 +56,4 @@ export class AuthorizationStateService {
         type: Injectable,
         args: [{ providedIn: 'root' }]
     }], () => [], null); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state.service.js","sourceRoot":"","sources":["../../../../../libs/common/src/authorization/state.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module authorization\n */\n\nimport { HttpClient } from '@angular/common/http';\nimport { Injectable, inject } from '@angular/core';\nimport {\n  EMPTY,\n  Observable,\n  of,\n  catchError,\n  map,\n  shareReplay,\n  switchMap,\n  tap,\n  timer,\n  fromEvent,\n  merge,\n  timeout,\n} from 'rxjs';\n\nimport {\n  publishRef,\n  getGlobalEnvironments,\n  TRUE,\n  skipError,\n  catchPromise,\n} from '../core/public-api';\nimport { AccountInfo } from '../page-scaffold/public-api';\n\nimport {\n  attachAuthorizationHeader,\n  getAuthorizationState,\n  logout,\n  logoutAudit,\n  TokenResponse,\n} from './authorization';\nimport { TOKEN_INFO_API, LOADING_CACHE, TOKEN_REFRESH_API } from './constants';\nimport { HEARTBEAT_POLLING } from './session-manage.service';\nimport {\n  readStorageAliveRecord,\n  readStorageToken,\n  refreshStorageAliveRecord,\n  writeStorageToken,\n} from './storage-token';\n\n@Injectable({ providedIn: 'root' })\nexport class AuthorizationStateService {\n  private readonly http = inject(HttpClient);\n\n  private readonly state$ = this.http\n    .get<AccountInfo>(TOKEN_INFO_API, {\n      headers: attachAuthorizationHeader(),\n    })\n    .pipe(\n      skipError(null),\n      tap(info => {\n        if (!info) {\n          logout(true);\n        }\n\n        this.payloadSnapshot = info;\n      }),\n      map(info => ({\n        ...getAuthorizationState(),\n        info,\n      })),\n      shareReplay(1),\n    );\n\n  private checkTokenCache$: Observable<unknown> = null;\n  private refreshTokenCache$: Observable<TokenResponse>;\n\n  payloadSnapshot: AccountInfo;\n\n  logout = logout;\n\n  constructor() {\n    if (getGlobalEnvironments('CLOSE_BROWSER_END_SESSION') === TRUE) {\n      this.state$\n        .pipe(\n          switchMap(state => {\n            const aliveRecord = readStorageAliveRecord();\n            if (\n              !aliveRecord ||\n              Date.now() - aliveRecord > HEARTBEAT_POLLING + LOADING_CACHE\n            ) {\n              this.logoutWithAudit();\n              return EMPTY;\n            }\n            return of(state);\n          }),\n          switchMap(() => {\n            return merge(\n              timer(0, HEARTBEAT_POLLING),\n              fromEvent(window, 'beforeunload'),\n            );\n          }),\n        )\n        .subscribe(refreshStorageAliveRecord);\n    }\n  }\n\n  logoutWithAudit() {\n    catchPromise(logoutAudit())\n      .pipe(\n        timeout(1000),\n        map(res => res?.logout_redirect_url),\n      )\n      .subscribe(redirectUrl => logout(redirectUrl));\n  }\n\n  refreshToken() {\n    if (this.refreshTokenCache$) {\n      return this.refreshTokenCache$;\n    }\n\n    this.refreshTokenCache$ = this.http\n      .get<TokenResponse>(TOKEN_REFRESH_API)\n      .pipe(\n        tap(({ id_token: idToken }) => {\n          writeStorageToken(idToken);\n          this.refreshTokenCache$ = null;\n        }),\n        catchError(() => {\n          logout(true);\n          return EMPTY;\n        }),\n        publishRef(),\n      );\n\n    return this.refreshTokenCache$;\n  }\n\n  checkToken() {\n    if (!this.checkTokenCache$) {\n      this.checkTokenCache$ = this.http.get(TOKEN_INFO_API).pipe(\n        tap({\n          next: () => {\n            this.checkTokenCache$ = null;\n          },\n          error: () => {\n            this.checkTokenCache$ = null;\n          },\n        }),\n        publishRef(),\n      );\n    }\n    return this.checkTokenCache$;\n  }\n\n  getTokenPayload<T>() {\n    return this.state$.pipe(map(state => state.info as T));\n  }\n\n  getAccountInfo() {\n    if (this.payloadSnapshot) {\n      return of(this.payloadSnapshot);\n    }\n    return this.state$.pipe(map(state => state.info || {}));\n  }\n\n  getTokenByStorage() {\n    return readStorageToken();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdGUuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9hdXRob3JpemF0aW9uL3N0YXRlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBRUgsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQ0wsS0FBSyxFQUNMLElBQUksRUFDSixFQUFFLEVBQ0YsVUFBVSxFQUNWLEdBQUcsRUFDSCxHQUFHLEVBQ0gsS0FBSyxFQUNMLFNBQVMsRUFDVCxLQUFLLEVBQ0wsT0FBTyxHQUNSLE1BQU0sTUFBTSxDQUFDO0FBRWQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLElBQUksRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUUvRSxPQUFPLEVBQ0wsdUJBQXVCLEVBQ3ZCLHFCQUFxQixFQUNyQixNQUFNLEVBQ04sV0FBVyxFQUNYLHlCQUF5QixHQUMxQixNQUFNLGlCQUFpQixDQUFDO0FBQ3pCLE9BQU8sRUFBRSxhQUFhLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDL0QsT0FBTyxFQUNMLHNCQUFzQixFQUN0Qix5QkFBeUIsRUFDekIsZ0JBQWdCLEdBQ2pCLE1BQU0saUJBQWlCLENBQUM7O0FBR3pCLE1BQU0sT0FBTyx5QkFBeUI7SUFNcEM7UUFMaUIsVUFBSyxHQUFHLHFCQUFxQixFQUFFLENBQUM7UUFDakQsb0JBQWUsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksSUFBSSxJQUFJLENBQUM7UUFFMUMsV0FBTSxHQUFHLE1BQU0sQ0FBQztRQUdkLElBQUkscUJBQXFCLENBQUMsMkJBQTJCLENBQUMsS0FBSyxJQUFJLEVBQUUsQ0FBQztZQUNoRSxNQUFNLFdBQVcsR0FBRyxzQkFBc0IsRUFBRSxDQUFDO1lBQzdDLElBQ0UsQ0FBQyxXQUFXO2dCQUNaLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxXQUFXLEdBQUcsaUJBQWlCLEdBQUcsYUFBYSxFQUM1RCxDQUFDO2dCQUNELElBQUksQ0FBQyxlQUFlLEVBQUUsQ0FBQztnQkFDdkIsT0FBTztZQUNULENBQUM7WUFFRCxLQUFLLENBQ0gsS0FBSyxDQUFDLENBQUMsRUFBRSxpQkFBaUIsQ0FBQyxFQUMzQixTQUFTLENBQUMsTUFBTSxFQUFFLGNBQWMsQ0FBQyxDQUNsQyxDQUFDLFNBQVMsQ0FBQyx5QkFBeUIsQ0FBQyxDQUFDO1FBQ3pDLENBQUM7SUFDSCxDQUFDO0lBRUQsZUFBZTtRQUNiLFlBQVksQ0FBQyxXQUFXLEVBQUUsQ0FBQzthQUN4QixJQUFJLENBQ0gsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUNiLEdBQUcsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsRUFBRSxtQkFBbUIsQ0FBQyxDQUNyQzthQUNBLFNBQVMsQ0FBQyxXQUFXLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDO0lBQ25ELENBQUM7SUFFRCxZQUFZO1FBQ1YsT0FBTyxJQUFJLENBQUMseUJBQXlCLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FDM0MsVUFBVSxDQUFDLEdBQUcsRUFBRTtZQUNkLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUNiLE9BQU8sS0FBSyxDQUFDO1FBQ2YsQ0FBQyxDQUFDLENBQ0gsQ0FBQztJQUNKLENBQUM7SUFFRCxVQUFVO1FBQ1IsT0FBTyxJQUFJLENBQUMsdUJBQXVCLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FDekMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFO1lBQ1QsSUFBSSxDQUFDLGVBQWUsR0FBRyxJQUFJLENBQUM7UUFDOUIsQ0FBQyxDQUFDLENBQ0gsQ0FBQztJQUNKLENBQUM7SUFFRCxlQUFlO1FBQ2IsT0FBTyxFQUFFLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFTLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBRUQsY0FBYztRQUNaLE9BQU8sRUFBRSxDQUFDLElBQUksQ0FBQyxlQUFlLElBQUksRUFBRSxDQUFDLENBQUM7SUFDeEMsQ0FBQztJQUVELGlCQUFpQjtRQUNmLE9BQU8sZ0JBQWdCLEVBQUUsQ0FBQztJQUM1QixDQUFDOzBGQTVEVSx5QkFBeUI7dUVBQXpCLHlCQUF5QixXQUF6Qix5QkFBeUIsbUJBRFosTUFBTTs7aUZBQ25CLHlCQUF5QjtjQURyQyxVQUFVO2VBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAcGFja2FnZURvY3VtZW50YXRpb25cbiAqIEBtb2R1bGUgYXV0aG9yaXphdGlvblxuICovXG5cbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7XG4gIEVNUFRZLFxuICBmcm9tLFxuICBvZixcbiAgY2F0Y2hFcnJvcixcbiAgbWFwLFxuICB0YXAsXG4gIHRpbWVyLFxuICBmcm9tRXZlbnQsXG4gIG1lcmdlLFxuICB0aW1lb3V0LFxufSBmcm9tICdyeGpzJztcblxuaW1wb3J0IHsgZ2V0R2xvYmFsRW52aXJvbm1lbnRzLCBUUlVFLCBjYXRjaFByb21pc2UgfSBmcm9tICcuLi9jb3JlL3B1YmxpYy1hcGknO1xuXG5pbXBvcnQge1xuICBjaGVja0F1dGhvcml6YXRpb25Ub2tlbixcbiAgZ2V0QXV0aG9yaXphdGlvblN0YXRlLFxuICBsb2dvdXQsXG4gIGxvZ291dEF1ZGl0LFxuICByZWZyZXNoQXV0aG9yaXphdGlvblRva2VuLFxufSBmcm9tICcuL2F1dGhvcml6YXRpb24nO1xuaW1wb3J0IHsgTE9BRElOR19DQUNIRSwgSEVBUlRCRUFUX1BPTExJTkcgfSBmcm9tICcuL2NvbnN0YW50cyc7XG5pbXBvcnQge1xuICByZWFkU3RvcmFnZUFsaXZlUmVjb3JkLFxuICByZWZyZXNoU3RvcmFnZUFsaXZlUmVjb3JkLFxuICByZWFkU3RvcmFnZVRva2VuLFxufSBmcm9tICcuL3N0b3JhZ2UtdG9rZW4nO1xuXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxuZXhwb3J0IGNsYXNzIEF1dGhvcml6YXRpb25TdGF0ZVNlcnZpY2Uge1xuICBwcml2YXRlIHJlYWRvbmx5IHN0YXRlID0gZ2V0QXV0aG9yaXphdGlvblN0YXRlKCk7XG4gIHBheWxvYWRTbmFwc2hvdCA9IHRoaXMuc3RhdGUuaW5mbyA/PyBudWxsO1xuXG4gIGxvZ291dCA9IGxvZ291dDtcblxuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBpZiAoZ2V0R2xvYmFsRW52aXJvbm1lbnRzKCdDTE9TRV9CUk9XU0VSX0VORF9TRVNTSU9OJykgPT09IFRSVUUpIHtcbiAgICAgIGNvbnN0IGFsaXZlUmVjb3JkID0gcmVhZFN0b3JhZ2VBbGl2ZVJlY29yZCgpO1xuICAgICAgaWYgKFxuICAgICAgICAhYWxpdmVSZWNvcmQgfHxcbiAgICAgICAgRGF0ZS5ub3coKSAtIGFsaXZlUmVjb3JkID4gSEVBUlRCRUFUX1BPTExJTkcgKyBMT0FESU5HX0NBQ0hFXG4gICAgICApIHtcbiAgICAgICAgdGhpcy5sb2dvdXRXaXRoQXVkaXQoKTtcbiAgICAgICAgcmV0dXJuO1xuICAgICAgfVxuXG4gICAgICBtZXJnZShcbiAgICAgICAgdGltZXIoMCwgSEVBUlRCRUFUX1BPTExJTkcpLFxuICAgICAgICBmcm9tRXZlbnQod2luZG93LCAnYmVmb3JldW5sb2FkJyksXG4gICAgICApLnN1YnNjcmliZShyZWZyZXNoU3RvcmFnZUFsaXZlUmVjb3JkKTtcbiAgICB9XG4gIH1cblxuICBsb2dvdXRXaXRoQXVkaXQoKSB7XG4gICAgY2F0Y2hQcm9taXNlKGxvZ291dEF1ZGl0KCkpXG4gICAgICAucGlwZShcbiAgICAgICAgdGltZW91dCgxMDAwKSxcbiAgICAgICAgbWFwKHJlcyA9PiByZXM/LmxvZ291dF9yZWRpcmVjdF91cmwpLFxuICAgICAgKVxuICAgICAgLnN1YnNjcmliZShyZWRpcmVjdFVybCA9PiBsb2dvdXQocmVkaXJlY3RVcmwpKTtcbiAgfVxuXG4gIHJlZnJlc2hUb2tlbigpIHtcbiAgICByZXR1cm4gZnJvbShyZWZyZXNoQXV0aG9yaXphdGlvblRva2VuKCkpLnBpcGUoXG4gICAgICBjYXRjaEVycm9yKCgpID0+IHtcbiAgICAgICAgbG9nb3V0KHRydWUpO1xuICAgICAgICByZXR1cm4gRU1QVFk7XG4gICAgICB9KSxcbiAgICApO1xuICB9XG5cbiAgY2hlY2tUb2tlbigpIHtcbiAgICByZXR1cm4gZnJvbShjaGVja0F1dGhvcml6YXRpb25Ub2tlbigpKS5waXBlKFxuICAgICAgdGFwKGluZm8gPT4ge1xuICAgICAgICB0aGlzLnBheWxvYWRTbmFwc2hvdCA9IGluZm87XG4gICAgICB9KSxcbiAgICApO1xuICB9XG5cbiAgZ2V0VG9rZW5QYXlsb2FkPFQ+KCkge1xuICAgIHJldHVybiBvZih0aGlzLnN0YXRlLmluZm8gYXMgVCk7XG4gIH1cblxuICBnZXRBY2NvdW50SW5mbygpIHtcbiAgICByZXR1cm4gb2YodGhpcy5wYXlsb2FkU25hcHNob3QgfHwge30pO1xuICB9XG5cbiAgZ2V0VG9rZW5CeVN0b3JhZ2UoKSB7XG4gICAgcmV0dXJuIHJlYWRTdG9yYWdlVG9rZW4oKTtcbiAgfVxufVxuIl19