@alauda-fe/common 1.3.1 → 1.4.0

package/array-form-table/form/component.d.ts

@@ -78,7 +78,7 @@ export declare class ArrayFormTableComponent implements OnDestroy {
     addDisabled: boolean | '';
     actionColumnDivider: boolean | '';
     showZeroState: boolean;
-    get formDirective(): NgForm | FormGroupDirective;
+    get formDirective(): FormGroupDirective | NgForm;
     /**
      * 自定义是否展示错误内容
      * 例如 control 是 FormGroup，只有在内部子 control 错误时才需要展示错误内容

package/authorization/interceptor.service.d.ts

@@ -19,7 +19,6 @@ export declare class AuthorizationInterceptorService implements HttpInterceptor
     intercept(req: HttpRequest<unknown>, next: HttpHandler): import("rxjs").Observable<import("@angular/common/http").HttpEvent<any>>;
     isConsoleRelative(url: string): boolean;
     private retryAuth;
-    private cloneReq;
     private getAuth;
     private needAuthorization;
     private is401;

package/authorization/state.service.d.ts

@@ -2,44 +2,44 @@ import { Observable } from 'rxjs';
 import { AccountInfo } from '../page-scaffold/public-api';
 import * as i0 from "@angular/core";
 export interface AuthorizationState {
-    idToken?: string;
-    refreshToken?: string;
+    expireAt?: string;
+    issuedAt?: string;
     state?: string;
     authUrl?: string;
     logoutUrl?: string;
+    info?: AccountInfo;
 }
 export interface TokenResponse {
     token_storage: StorageType;
-    id_token: string;
-    refresh_token: string;
+    token_type: string;
+    expire_at: string;
+    issued_at: string;
 }
 export type StorageType = 'local' | 'session';
 export declare const STORAGE_TYPE_KEY = "token_storage";
-export declare const ID_TOKEN_KEY = "id_token";
-export declare const REFRESH_TOKEN_KEY = "refresh_token";
 export declare const CODE_KEY = "code";
+export declare const ID_TOKEN = "id_token";
 export declare class AuthorizationStateService {
     private readonly http;
-    private readonly refreshToken$$;
     private readonly state$;
-    private checkTokenCache;
+    private checkTokenCache$;
     private refreshTokenCache$;
     stateSnapshot: AuthorizationState;
     payloadSnapshot: AccountInfo;
     logout(specificUrl?: boolean): void;
     logoutAudit(): Observable<Object>;
     redirectToDex(redirectUrl?: string): Promise<void>;
-    refreshToken(): Observable<string>;
-    checkToken(token: string): Observable<unknown>;
-    getToken(): Observable<string>;
+    refreshToken(): Observable<unknown>;
+    checkToken(): Observable<unknown>;
     getTokenPayload<T>(): Observable<T>;
-    getAccountInfo(): Observable<AccountInfo>;
+    getAccountInfo(): Observable<any>;
     private getAuthConfiguration;
     private getExistedToken;
     private getTokenFromLocal;
-    private getTokenByRefreshToken;
     private getTokenByCode;
+    private getCookieByToken;
     private getParams;
     static ɵfac: i0.ɵɵFactoryDeclaration<AuthorizationStateService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AuthorizationStateService>;
 }
+export declare function redirectSSOEntry(entry: string): string;

package/core/abstract/base-nested-form-control.d.ts

@@ -21,7 +21,7 @@ export declare class BaseNestedFormControl<V, M = V> implements AfterViewInit, O
     protected asyncValidator: boolean;
     protected cdr: ChangeDetectorRef;
     protected destroy$$: Subject<void>;
-    protected hostForm: NgForm | FormGroupDirective;
+    protected hostForm: FormGroupDirective | NgForm;
     constructor();
     ngAfterViewInit(): void;
     ngOnDestroy(): void;

package/core/constants/patterns.d.ts

@@ -69,6 +69,10 @@ export declare const POSITIVE_INT_PATTERN: {
     pattern: RegExp;
     tip: string;
 };
+export declare const POSITIVE_NUMBER_PATTERN: {
+    pattern: RegExp;
+    tip: string;
+};
 export declare const K8S_RESOURCE_NAME_BASE: {
     pattern: RegExp;
     tip: string;

package/core/directives/scroll-to-first-invalid.directive.d.ts

@@ -13,7 +13,7 @@ export declare class ScrollToFirstInvalidDirective {
     private readonly cdkScrollable;
     labelOffset: number;
     aclScrollToFirstInvalid: boolean | '';
-    get containerEl(): HTMLElement | (Window & typeof globalThis);
+    get containerEl(): (Window & typeof globalThis) | HTMLElement;
     onSubmit(): void;
     constructor(elRef: ElementRef<HTMLElement>, controlContainer: ControlContainer, cdkScrollable: CdkScrollable);
     scrollToFirstInvalid(): void;

package/core/module.d.ts

@@ -1,24 +1,24 @@
 import * as i0 from "@angular/core";
-import * as i1 from "./pipes/time.pipe";
-import * as i2 from "./pipes/crontab-next.pipe";
-import * as i3 from "./pipes/marked.pipe";
-import * as i4 from "./pipes/page-env.pipe";
-import * as i5 from "./pipes/timezone-display.pipe";
-import * as i6 from "./pipes/cron-human-readable.pipe";
-import * as i7 from "./directives/scroll-to-first-invalid.directive";
-import * as i8 from "./directives/last-form-item.directive";
-import * as i9 from "./directives/readonly-field.directive";
-import * as i10 from "@angular/common";
-import * as i11 from "@angular/forms";
-import * as i12 from "./pipes/k8s-util.pipe.module";
-import * as i13 from "../effect-directive/module";
-import * as i14 from "../code/code.module";
-import * as i15 from "./pipes/parse-json-translate.pipe";
-import * as i16 from "./pipes/field-not-available.pipe";
-import * as i17 from "./pipes/img-header.pipe";
-import * as i18 from "./pipes/img-theme.pipe";
-import * as i19 from "./pipes/safe.pipe";
-import * as i20 from "./pipes/sanitize.pipe";
+import * as i1 from "./pipes/crontab-next.pipe";
+import * as i2 from "./pipes/marked.pipe";
+import * as i3 from "./pipes/page-env.pipe";
+import * as i4 from "./pipes/timezone-display.pipe";
+import * as i5 from "./pipes/cron-human-readable.pipe";
+import * as i6 from "./directives/scroll-to-first-invalid.directive";
+import * as i7 from "./directives/last-form-item.directive";
+import * as i8 from "./directives/readonly-field.directive";
+import * as i9 from "@angular/common";
+import * as i10 from "@angular/forms";
+import * as i11 from "./pipes/k8s-util.pipe.module";
+import * as i12 from "../effect-directive/module";
+import * as i13 from "../code/code.module";
+import * as i14 from "./pipes/parse-json-translate.pipe";
+import * as i15 from "./pipes/field-not-available.pipe";
+import * as i16 from "./pipes/img-header.pipe";
+import * as i17 from "./pipes/img-theme.pipe";
+import * as i18 from "./pipes/safe.pipe";
+import * as i19 from "./pipes/sanitize.pipe";
+import * as i20 from "./pipes/time.pipe";
 import * as i21 from "./directives/page-header-content.directive";
 import * as i22 from "./directives/intercept-deactivate.directive";
 import * as i23 from "./directives/disabled.directive";
@@ -29,6 +29,6 @@ import * as i27 from "./directives/feature-gate.directive";
 import * as i28 from "./pipes/pure.pipe";
 export declare class CoreModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<CoreModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreModule, [typeof i1.StandardDatePipe, typeof i2.CrontabNextPipe, typeof i3.MarkedPipe, typeof i4.LocaleTransformPipe, typeof i4.ThemeTransformPipe, typeof i5.TimezoneDisplayPipe, typeof i6.CronHumanReadablePipe, typeof i7.ScrollToFirstInvalidMarkerDirective, typeof i8.FormItemMarginEffectDirective, typeof i9.SpanComponent], [typeof i10.CommonModule, typeof i11.ReactiveFormsModule, typeof i12.K8sUtilPipeModule, typeof i13.EffectDirectiveModule, typeof i14.CodeModule, typeof i9.ReadonlyFieldDirective, typeof i15.ParseJsonTranslatePipe, typeof i16.FieldNotAvailablePipe, typeof i17.ImgHeaderPipe, typeof i18.ImgThemePipe, typeof i19.SafePipe, typeof i20.SanitizePipe, typeof i1.RelativeTimePipe, typeof i21.PageHeaderContentDirective, typeof i1.StandardTimePipe, typeof i7.ScrollToFirstInvalidDirective, typeof i22.InterceptDeactivateDirective, typeof i23.DisabledDirective, typeof i24.ClickOutsideDirective, typeof i25.ScrollBorderObserverDirective, typeof i26.ResizeDirective, typeof i27.FeatureGateDirective, typeof i28.PurePipe], [typeof i1.StandardDatePipe, typeof i2.CrontabNextPipe, typeof i3.MarkedPipe, typeof i4.LocaleTransformPipe, typeof i4.ThemeTransformPipe, typeof i5.TimezoneDisplayPipe, typeof i6.CronHumanReadablePipe, typeof i7.ScrollToFirstInvalidMarkerDirective, typeof i8.FormItemMarginEffectDirective, typeof i9.ReadonlyFieldDirective, typeof i15.ParseJsonTranslatePipe, typeof i16.FieldNotAvailablePipe, typeof i17.ImgHeaderPipe, typeof i18.ImgThemePipe, typeof i19.SafePipe, typeof i20.SanitizePipe, typeof i1.RelativeTimePipe, typeof i21.PageHeaderContentDirective, typeof i1.StandardTimePipe, typeof i7.ScrollToFirstInvalidDirective, typeof i22.InterceptDeactivateDirective, typeof i23.DisabledDirective, typeof i24.ClickOutsideDirective, typeof i25.ScrollBorderObserverDirective, typeof i26.ResizeDirective, typeof i27.FeatureGateDirective, typeof i28.PurePipe, typeof i12.K8sUtilPipeModule, typeof i14.CodeModule, typeof i13.EffectDirectiveModule]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreModule, [typeof i1.CrontabNextPipe, typeof i2.MarkedPipe, typeof i3.LocaleTransformPipe, typeof i3.ThemeTransformPipe, typeof i4.TimezoneDisplayPipe, typeof i5.CronHumanReadablePipe, typeof i6.ScrollToFirstInvalidMarkerDirective, typeof i7.FormItemMarginEffectDirective, typeof i8.SpanComponent], [typeof i9.CommonModule, typeof i10.ReactiveFormsModule, typeof i11.K8sUtilPipeModule, typeof i12.EffectDirectiveModule, typeof i13.CodeModule, typeof i8.ReadonlyFieldDirective, typeof i14.ParseJsonTranslatePipe, typeof i15.FieldNotAvailablePipe, typeof i16.ImgHeaderPipe, typeof i17.ImgThemePipe, typeof i18.SafePipe, typeof i19.SanitizePipe, typeof i20.RelativeTimePipe, typeof i21.PageHeaderContentDirective, typeof i20.StandardTimePipe, typeof i6.ScrollToFirstInvalidDirective, typeof i22.InterceptDeactivateDirective, typeof i23.DisabledDirective, typeof i24.ClickOutsideDirective, typeof i25.ScrollBorderObserverDirective, typeof i26.ResizeDirective, typeof i27.FeatureGateDirective, typeof i28.PurePipe, typeof i20.StandardDatePipe], [typeof i1.CrontabNextPipe, typeof i2.MarkedPipe, typeof i3.LocaleTransformPipe, typeof i3.ThemeTransformPipe, typeof i4.TimezoneDisplayPipe, typeof i5.CronHumanReadablePipe, typeof i6.ScrollToFirstInvalidMarkerDirective, typeof i7.FormItemMarginEffectDirective, typeof i8.ReadonlyFieldDirective, typeof i14.ParseJsonTranslatePipe, typeof i15.FieldNotAvailablePipe, typeof i16.ImgHeaderPipe, typeof i17.ImgThemePipe, typeof i18.SafePipe, typeof i19.SanitizePipe, typeof i20.RelativeTimePipe, typeof i21.PageHeaderContentDirective, typeof i20.StandardTimePipe, typeof i6.ScrollToFirstInvalidDirective, typeof i22.InterceptDeactivateDirective, typeof i23.DisabledDirective, typeof i24.ClickOutsideDirective, typeof i25.ScrollBorderObserverDirective, typeof i26.ResizeDirective, typeof i27.FeatureGateDirective, typeof i28.PurePipe, typeof i20.StandardDatePipe, typeof i11.K8sUtilPipeModule, typeof i13.CodeModule, typeof i12.EffectDirectiveModule]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<CoreModule>;
 }

package/core/pipes/time.pipe.d.ts

@@ -37,5 +37,5 @@ export declare class StandardTimePipe extends DateTimePipe implements PipeTransf
 export declare class StandardDatePipe extends DateTimePipe implements PipeTransform {
     format: string;
     static ɵfac: i0.ɵɵFactoryDeclaration<StandardDatePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<StandardDatePipe, "aclStandardDate", false>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<StandardDatePipe, "aclStandardDate", true>;
 }

package/core/services/context.service.d.ts

@@ -21,13 +21,12 @@ import * as i0 from "@angular/core";
  */
 export declare const CONTEXT_INIT_VALUE_TOKEN: InjectionToken<unknown>;
 export declare class ContextService<T> {
-    private readonly initValue;
+    private initValue;
     private readonly value$$;
-    value$: Observable<T>;
-    constructor(initValue: T);
+    readonly value$: Observable<T>;
     set(value?: T): void;
     get(): T;
     reset(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ContextService<any>, [{ optional: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextService<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ContextService<any>>;
 }

package/core/services/feature-gate.service.d.ts

@@ -9,7 +9,7 @@ export declare class FeatureGateService {
     private readonly http;
     private readonly cacheStore;
     constructor(http: HttpClient);
-    loadState(cluster?: string): Observable<"loaded" | "loadFailed" | "loading">;
+    loadState(cluster?: string): Observable<"loading" | "loaded" | "loadFailed">;
     /**
      * check gate status
      * @param gate - specified feature gate

package/core/services/workspace-helper.service.d.ts

@@ -3,10 +3,12 @@ import { WorkspaceParams } from '../types/public-api';
 import * as i0 from "@angular/core";
 export declare class WorkspaceHelperService {
     private readonly baseParams$$;
-    baseActivatedRoute: ActivatedRoute;
+    private _baseActivatedRoute;
     readonly baseParams: import("rxjs").Observable<WorkspaceParams>;
     get baseParamsSnapshot(): WorkspaceParams;
+    get baseActivatedRoute(): ActivatedRoute;
     setBaseParams(params: WorkspaceParams): void;
+    setBaseActivatedRoute(route: ActivatedRoute): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<WorkspaceHelperService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<WorkspaceHelperService>;
 }

package/core/utils/common.d.ts

@@ -3,7 +3,6 @@
  * @module utils
  */
 import { Sort } from '@alauda/ui';
-import { ActivatedRouteSnapshot } from '@angular/router';
 import { UnionToIntersection } from 'ts-essentials';
 import { Terminal } from 'xterm';
 import { Callback, Keys, KubernetesResource, Nullable, Readonlyable } from '../types/public-api';
@@ -57,4 +56,3 @@ export declare const parseImageAddress: (addr: string) => {
 };
 export declare const setWindowsXtermTools: (xterm: Terminal) => void;
 export declare const clearWindowsXtermTools: () => void;
-export declare function getParamFromParent(key: string, snapshot: ActivatedRouteSnapshot): string;

package/core/utils/public-api.d.ts

@@ -21,4 +21,5 @@ export * from './format-number';
 export * from './node';
 export * from './sort-fn';
 export * from './workload';
+export * from './router';
 export * from './disabled-state';

package/core/utils/router.d.ts

@@ -0,0 +1,3 @@
+import { ActivatedRouteSnapshot } from '@angular/router';
+export declare function getParamFromParent(key: string, snapshot: ActivatedRouteSnapshot): string;
+export declare function initParamFromParent$(key: string): import("rxjs").Observable<string>;

package/core/utils/version.d.ts

@@ -36,4 +36,4 @@ export declare const compareVersion: {
     gte: (v1: string, v2: string) => boolean;
     cmp: (v1: string, v2: string, operator: CompareOperator) => boolean;
 };
-export declare const compareMinorVersion: (v1: string, v2: string) => 0 | 1 | -1;
+export declare const compareMinorVersion: (v1: string, v2: string) => 1 | 0 | -1;

package/editable/editable.component.d.ts

@@ -0,0 +1,23 @@
+import { CustomBeforeAction } from '@alauda/ui';
+import { EventEmitter, TemplateRef } from '@angular/core';
+import { ButtonPosition, EditableMode } from './editable.type';
+import * as i0 from "@angular/core";
+export declare class EditableComponent {
+    beforeSave: import("@angular/core").InputSignal<CustomBeforeAction<unknown>>;
+    position: import("@angular/core").InputSignal<ButtonPosition>;
+    save: EventEmitter<void>;
+    cancel: EventEmitter<void>;
+    modeChange: EventEmitter<EditableMode>;
+    viewer: TemplateRef<unknown>;
+    editor: TemplateRef<unknown>;
+    EditableMode: typeof EditableMode;
+    bem: import("@alauda/ui").Bem;
+    loading: boolean;
+    mode: import("@angular/core").WritableSignal<EditableMode>;
+    hostClass: import("@angular/core").Signal<string>;
+    constructor();
+    saveEdit(): void;
+    cancelEdit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditableComponent, "acl-editable", never, { "beforeSave": { "alias": "beforeSave"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, { "save": "save"; "cancel": "cancel"; "modeChange": "modeChange"; }, ["viewer", "editor"], never, true, never>;
+}

package/editable/editable.directive.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class EditableViewerDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditableViewerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EditableViewerDirective, "*[aclEditableViewer]", never, {}, {}, never, never, true, never>;
+}
+export declare class EditableEditorDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditableEditorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EditableEditorDirective, "*[aclEditableEditor]", never, {}, {}, never, never, true, never>;
+}

package/editable/editable.type.d.ts

@@ -0,0 +1,5 @@
+export declare enum EditableMode {
+    View = "view",
+    Edit = "edit"
+}
+export type ButtonPosition = 'top' | 'center' | 'bottom';

package/editable/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './editable.component';
+export * from './editable.directive';

package/esm2022/authorization/guard.service.mjs

@@ -21,7 +21,7 @@ export class AuthorizationGuardService {
         this.silentlyNavigate = silentlyNavigate;
     }
     canActivate(_route, state) {
-        return this.auth.getToken().pipe(map(token => !!token), catchError(() => {
+        return this.auth.getAccountInfo().pipe(map(info => !!info), catchError(() => {
             this.silentlyNavigate.navigate(state.url, this.emptyUrl);
             return of(false);
         }));
@@ -39,4 +39,4 @@ export class AuthorizationGuardService {
                 type: Inject,
                 args: [ABNORMAL_EMPTY_URL_TOKEN]
             }] }, { type: i1.AuthorizationStateService }, { type: i2.SilentlyNavigateService }], null); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/authorization/interceptor.service.mjs

@@ -4,7 +4,7 @@
  */
 import { DialogService } from '@alauda/ui';
 import { Inject, Injectable, Injector } from '@angular/core';
-import { NEVER, combineLatest, throwError, catchError, concatMap, take, map, of, switchMap, } from 'rxjs';
+import { NEVER, 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';
@@ -24,24 +24,16 @@ export class AuthorizationInterceptorService {
         this.dialog = dialog;
         this.sessionManage = sessionManage;
     }
-    // eslint-disable-next-line sonarjs/cognitive-complexity
     intercept(req, next) {
         if (this.isConsoleRelative(req.url)) {
             return next.handle(req);
         }
         const auth = this.getAuth();
-        return combineLatest([
-            this.apiGateway.getApiAddress(),
-            auth.getToken(),
-        ]).pipe(take(1), concatMap(([apiAddress, idToken]) => {
+        return auth.getTokenPayload().pipe(switchMap(() => this.apiGateway.getApiAddress()), take(1), concatMap(apiAddress => {
             if (!this.needAuthorization(apiAddress, req)) {
                 return next.handle(req);
             }
-            if (!idToken) {
-                return NEVER;
-            }
-            const authReq = this.cloneReq(req, idToken);
-            return next.handle(authReq).pipe(catchError((error) => {
+            return next.handle(req).pipe(catchError((error) => {
                 if (this.isSessionInvalid(error)) {
                     this.handleSessionInvalid();
                     return NEVER;
@@ -54,10 +46,10 @@ export class AuthorizationInterceptorService {
                 if (!this.isUnauthorized(error)) {
                     return throwError(() => error);
                 }
-                if (this.isWatchReq(apiAddress, authReq)) {
+                if (this.isWatchReq(apiAddress, req)) {
                     return NEVER;
                 }
-                return auth.checkToken(idToken).pipe(map(() => false), catchError(() => of(true)), switchMap(expired => expired ? this.retryAuth(next, req) : throwError(() => error)));
+                return auth.checkToken().pipe(map(() => false), catchError(() => of(true)), switchMap(expired => expired ? this.retryAuth(next, req) : throwError(() => error)));
             }));
         }));
     }
@@ -70,20 +62,13 @@ export class AuthorizationInterceptorService {
     }
     retryAuth(next, req) {
         const auth = this.getAuth();
-        return auth.refreshToken().pipe(concatMap(token => next.handle(this.cloneReq(req, token)).pipe(catchError((error) => {
+        return auth.refreshToken().pipe(concatMap(() => next.handle(req).pipe(catchError((error) => {
             if (this.isUnauthorized(error)) {
                 auth.logout(true);
             }
             return throwError(() => error);
         }))));
     }
-    cloneReq(req, idToken) {
-        return req.clone({
-            setHeaders: {
-                Authorization: `Bearer ${idToken}`,
-            },
-        });
-    }
     getAuth() {
         if (!this.auth) {
             this.auth = this.injector.get(AuthorizationStateService);
@@ -146,4 +131,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":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAO3C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EACL,KAAK,EACL,aAAa,EACb,UAAU,EACV,UAAU,EACV,SAAS,EACT,IAAI,EACJ,GAAG,EACH,EAAE,EACF,SAAS,GACV,MAAM,MAAM,CAAC;AAEd,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,EAAU,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEzD,OAAO,EACL,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;;;;;AAE5D,wEAAwE;AACxE,kDAAkD;AAElD,MAAM,OAAO,+BAA+B;IAG1C,YAEmB,aAAqC,EACrC,UAA6B,EAC7B,QAAkB,EAClB,MAAqB,EACrB,aAAmC;QAJnC,kBAAa,GAAb,aAAa,CAAwB;QACrC,eAAU,GAAV,UAAU,CAAmB;QAC7B,aAAQ,GAAR,QAAQ,CAAU;QAClB,WAAM,GAAN,MAAM,CAAe;QACrB,kBAAa,GAAb,aAAa,CAAsB;IACnD,CAAC;IAEJ,wDAAwD;IACxD,SAAS,CAAC,GAAyB,EAAE,IAAiB;QACpD,IAAI,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACpC,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC1B,CAAC;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAE5B,OAAO,aAAa,CAAC;YACnB,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE;YAC/B,IAAI,CAAC,QAAQ,EAAE;SAChB,CAAC,CAAC,IAAI,CACL,IAAI,CAAC,CAAC,CAAC,EACP,SAAS,CAAC,CAAC,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,EAAE;YAClC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,GAAG,CAAC,EAAE,CAAC;gBAC7C,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAC1B,CAAC;YAED,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,OAAO,KAAK,CAAC;YACf,CAAC;YAED,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;YAC5C,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAC9B,UAAU,CAAC,CAAC,KAAwB,EAAE,EAAE;gBACtC,IAAI,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;oBACjC,IAAI,CAAC,oBAAoB,EAAE,CAAC;oBAC5B,OAAO,KAAK,CAAC;gBACf,CAAC;gBAED,aAAa;gBACb,IAAI,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;oBAC9B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;oBAClB,OAAO,KAAK,CAAC;gBACf,CAAC;gBAED,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;oBAChC,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;gBACjC,CAAC;gBAED,IAAI,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,CAAC;oBACzC,OAAO,KAAK,CAAC;gBACf,CAAC;gBAED,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,CAClC,GAAG,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EAChB,UAAU,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,EAC1B,SAAS,CAAC,OAAO,CAAC,EAAE,CAClB,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAC9D,CACF,CAAC;YACJ,CAAC,CAAC,CACH,CAAC;QACJ,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,6IAA6I;IAC7I,iBAAiB,CAAC,GAAW;QAC3B,MAAM,YAAY,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;QAE/C,OAAO,CACL,CAAC,YAAY,CAAC,UAAU,CAAC,SAAS,CAAC;YACnC,CAAC,YAAY,CAAC,UAAU,CAAC,UAAU,CAAC;YACpC,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,CAC/B,CAAC;IACJ,CAAC;IAEO,SAAS,CAAC,IAAiB,EAAE,GAAyB;QAC5D,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC5B,OAAO,IAAI,CAAC,YAAY,EAAE,CAAC,IAAI,CAC7B,SAAS,CAAC,KAAK,CAAC,EAAE,CAChB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,CACzC,UAAU,CAAC,CAAC,KAAwB,EAAE,EAAE;YACtC,IAAI,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC/B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;YAED,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC,CAAC,CACH,CACF,CACF,CAAC;IACJ,CAAC;IAEO,QAAQ,CAAC,GAAyB,EAAE,OAAe;QACzD,OAAO,GAAG,CAAC,KAAK,CAAC;YACf,UAAU,EAAE;gBACV,aAAa,EAAE,UAAU,OAAO,EAAE;aACnC;SACF,CAAC,CAAC;IACL,CAAC;IAEO,OAAO;QACb,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;QAC3D,CAAC;QACD,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAEO,iBAAiB,CACvB,UAAkB,EAClB,GAAyB;QAEzB,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE,CAAC;YACxE,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CACpC,GAAG,YAAY,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAClE,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,EAAE,KAAK,EAAqB;QACxC,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC;IACpD,CAAC;IAEO,gBAAgB,CAAC,QAA2B;QAClD,MAAM,EAAE,KAAK,EAAE,GAAG,QAAQ,CAAC;QAC3B,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,gBAAgB,CAAC;IACnE,CAAC;IAEO,oBAAoB;QAC1B,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;QAC9B,IACE,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;YACjE,IAAI,EACJ,CAAC;YACD,cAAc,CAAC,UAAU,CAAC,kBAAkB,CAAC,CAAC;YAC9C,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YACvB,OAAO;QACT,CAAC;QACD,8BAA8B;QAC9B,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;QACtD,YAAY,CACV,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;YAClB,KAAK,EAAE,SAAS,CAAC,GAAG,CAAC,sBAAsB,CAAC;YAC5C,WAAW,EAAE,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC;YACpC,YAAY,EAAE,KAAK;SACpB,CAAC,CACH,CAAC,SAAS,CAAC,GAAG,EAAE;YACf,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,cAAc,CAAC,QAA2B;QAChD,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,KAAK,cAAc,CAAC;IAC1E,CAAC;IAEO,aAAa,CAAC,QAA2B;QAC/C,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,KAAK,aAAa,CAAC;IACzE,CAAC;IAEO,QAAQ,CAAC,KAAsB;QACrC,OAAO,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,IAAI,KAAK,CAAC;IAC/D,CAAC;IAEO,UAAU,CAChB,UAAkB,EAClB,EAAE,GAAG,EAAE,MAAM,EAAwB;QAErC,MAAM,aAAa,GACjB,GAAG,CAAC,UAAU,CAAC,UAAU,GAAG,OAAO,CAAC;YACpC,GAAG,CAAC,UAAU,CAAC,UAAU,GAAG,QAAQ,CAAC;YACrC,GAAG,CAAC,UAAU,CAAC,UAAU,GAAG,cAAc,CAAC,CAAC;QAC9C,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,WAAW,EAAE,KAAK,MAAM,CAAC;QAChE,OAAO,aAAa,IAAI,SAAS,CAAC;IACpC,CAAC;gGAnLU,+BAA+B,cAIhC,cAAc;uEAJb,+BAA+B,WAA/B,+BAA+B;;iFAA/B,+BAA+B;cAD3C,UAAU;;sBAKN,MAAM;uBAAC,cAAc","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  combineLatest,\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  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  // eslint-disable-next-line sonarjs/cognitive-complexity\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 combineLatest([\n      this.apiGateway.getApiAddress(),\n      auth.getToken(),\n    ]).pipe(\n      take(1),\n      concatMap(([apiAddress, idToken]) => {\n        if (!this.needAuthorization(apiAddress, req)) {\n          return next.handle(req);\n        }\n\n        if (!idToken) {\n          return NEVER;\n        }\n\n        const authReq = this.cloneReq(req, idToken);\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(idToken).pipe(\n              map(() => false),\n              catchError(() => of(true)),\n              switchMap(expired =>\n                expired ? this.retryAuth(next, req) : 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 retryAuth(next: HttpHandler, req: HttpRequest<unknown>) {\n    const auth = this.getAuth();\n    return auth.refreshToken().pipe(\n      concatMap(token =>\n        next.handle(this.cloneReq(req, token)).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 cloneReq(req: HttpRequest<unknown>, idToken: string) {\n    return req.clone({\n      setHeaders: {\n        Authorization: `Bearer ${idToken}`,\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    // 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.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  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  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        return next.handle(req).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, req)) {\n              return NEVER;\n            }\n\n            return auth.checkToken().pipe(\n              map(() => false),\n              catchError(() => of(true)),\n              switchMap(expired =>\n                expired ? this.retryAuth(next, req) : 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 retryAuth(next: HttpHandler, req: HttpRequest<unknown>) {\n    const auth = this.getAuth();\n    return auth.refreshToken().pipe(\n      concatMap(() =>\n        next.handle(req).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    // 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.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"]}