@alauda-fe/common 1.0.0-next.0

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

@@ -0,0 +1,60 @@
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { asyncScheduler, bufferTime, filter, fromEvent, map, merge, subscribeOn, switchMap, withLatestFrom, } from 'rxjs';
+import { PageVisibilityService } from '../api/page-visibility.service';
+import { API_GATEWAY, K8sApiService, TOKEN_DISABLE_SESSION_MANAGE, publishRef, skipError, } from '../public-api';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../api/page-visibility.service";
+import * as i3 from "../public-api";
+const EVENT_TRIGGERS = ['click', 'keypress'];
+const HEARTBEAT_POLLING = 15000;
+export const SESSION_MANAGE_KEY = 'session-manage-construct-time';
+export class SessionManageService {
+    constructor(http, pageVisibility, k8sApi, disabled) {
+        this.http = http;
+        this.pageVisibility = pageVisibility;
+        this.k8sApi = k8sApi;
+        this.visibility$ = this.pageVisibility.getPageVisibility();
+        this.policy$ = this.k8sApi
+            .getGlobalResource({
+            definition: {
+                type: 'userpolicies',
+                apiGroup: 'security.alauda.io',
+                apiVersion: 'v1alpha1',
+            },
+            name: 'user-security-policy',
+        })
+            .pipe(map(p => p.rules
+            .find(r => r.name === 'AccessControlPolicy')
+            ?.items?.find(i => i.key === 'SESSION_SWITCH')?.enable), subscribeOn(asyncScheduler), publishRef());
+        this.userAction$ = merge(...EVENT_TRIGGERS.map(ev => fromEvent(document, ev)))
+            .pipe(bufferTime(HEARTBEAT_POLLING), withLatestFrom(this.visibility$, this.policy$))
+            .pipe(filter(([_, v, p]) => v && p), switchMap(([i]) => this.http
+            .get(`${API_GATEWAY}/auth/v1/heartbeat`, {
+            params: { action: !!i.length },
+        })
+            .pipe(
+        // 错误由 HttpInterceptor 处理，仅由 HttpInterceptor 主动结束此流，自身一直进行心跳
+        skipError())));
+        if (!disabled) {
+            sessionStorage.setItem(SESSION_MANAGE_KEY, String(Date.now()));
+            this.subscription = this.userAction$.subscribe();
+        }
+    }
+    complete() {
+        this.subscription?.unsubscribe();
+    }
+    static { this.ɵfac = function SessionManageService_Factory(t) { return new (t || SessionManageService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.PageVisibilityService), i0.ɵɵinject(i3.K8sApiService), i0.ɵɵinject(TOKEN_DISABLE_SESSION_MANAGE)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SessionManageService, factory: SessionManageService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SessionManageService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.PageVisibilityService }, { type: i3.K8sApiService }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [TOKEN_DISABLE_SESSION_MANAGE]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vzc2lvbi1tYW5hZ2Uuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9hdXRob3JpemF0aW9uL3Nlc3Npb24tbWFuYWdlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ25ELE9BQU8sRUFFTCxjQUFjLEVBQ2QsVUFBVSxFQUNWLE1BQU0sRUFDTixTQUFTLEVBQ1QsR0FBRyxFQUNILEtBQUssRUFDTCxXQUFXLEVBQ1gsU0FBUyxFQUNULGNBQWMsR0FDZixNQUFNLE1BQU0sQ0FBQztBQUVkLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3ZFLE9BQU8sRUFDTCxXQUFXLEVBQ1gsYUFBYSxFQUViLDRCQUE0QixFQUM1QixVQUFVLEVBQ1YsU0FBUyxHQUNWLE1BQU0sZUFBZSxDQUFDOzs7OztBQUV2QixNQUFNLGNBQWMsR0FBRyxDQUFDLE9BQU8sRUFBRSxVQUFVLENBQUMsQ0FBQztBQUM3QyxNQUFNLGlCQUFpQixHQUFHLEtBQU0sQ0FBQztBQUNqQyxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRywrQkFBK0IsQ0FBQztBQUtsRSxNQUFNLE9BQU8sb0JBQW9CO0lBNEMvQixZQUNtQixJQUFnQixFQUNoQixjQUFxQyxFQUNyQyxNQUFxQixFQUNBLFFBQWlCO1FBSHRDLFNBQUksR0FBSixJQUFJLENBQVk7UUFDaEIsbUJBQWMsR0FBZCxjQUFjLENBQXVCO1FBQ3JDLFdBQU0sR0FBTixNQUFNLENBQWU7UUE3Q3ZCLGdCQUFXLEdBQUcsSUFBSSxDQUFDLGNBQWMsQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO1FBQ3RELFlBQU8sR0FBRyxJQUFJLENBQUMsTUFBTTthQUNuQyxpQkFBaUIsQ0FBeUI7WUFDekMsVUFBVSxFQUFFO2dCQUNWLElBQUksRUFBRSxjQUFjO2dCQUNwQixRQUFRLEVBQUUsb0JBQW9CO2dCQUM5QixVQUFVLEVBQUUsVUFBVTthQUN2QjtZQUNELElBQUksRUFBRSxzQkFBc0I7U0FDN0IsQ0FBQzthQUNELElBQUksQ0FDSCxHQUFHLENBQ0QsQ0FBQyxDQUFDLEVBQUUsQ0FDRixDQUFDLENBQUMsS0FBSzthQUNKLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLEtBQUsscUJBQXFCLENBQUM7WUFDNUMsRUFBRSxLQUFLLEVBQUUsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLEdBQUcsS0FBSyxnQkFBZ0IsQ0FBQyxFQUFFLE1BQU0sQ0FDM0QsRUFDRCxXQUFXLENBQUMsY0FBYyxDQUFDLEVBQzNCLFVBQVUsRUFBRSxDQUNiLENBQUM7UUFFYSxnQkFBVyxHQUFHLEtBQUssQ0FDbEMsR0FBRyxjQUFjLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsU0FBUyxDQUFDLFFBQVEsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUNyRDthQUNFLElBQUksQ0FDSCxVQUFVLENBQUMsaUJBQWlCLENBQUMsRUFDN0IsY0FBYyxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUMvQzthQUNBLElBQUksQ0FDSCxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsRUFDN0IsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQ2hCLElBQUksQ0FBQyxJQUFJO2FBQ04sR0FBRyxDQUFDLEdBQUcsV0FBVyxvQkFBb0IsRUFBRTtZQUN2QyxNQUFNLEVBQUUsRUFBRSxNQUFNLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLEVBQUU7U0FDL0IsQ0FBQzthQUNELElBQUk7UUFDSCw0REFBNEQ7UUFDNUQsU0FBUyxFQUFFLENBQ1osQ0FDSixDQUNGLENBQUM7UUFRRixJQUFJLENBQUMsUUFBUSxFQUFFO1lBQ2IsY0FBYyxDQUFDLE9BQU8sQ0FBQyxrQkFBa0IsRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUMsQ0FBQztZQUMvRCxJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsU0FBUyxFQUFFLENBQUM7U0FDbEQ7SUFDSCxDQUFDO0lBRUQsUUFBUTtRQUNOLElBQUksQ0FBQyxZQUFZLEVBQUUsV0FBVyxFQUFFLENBQUM7SUFDbkMsQ0FBQztxRkExRFUsb0JBQW9CLGdIQWdEckIsNEJBQTRCO3VFQWhEM0Isb0JBQW9CLFdBQXBCLG9CQUFvQixtQkFGbkIsTUFBTTs7dUZBRVAsb0JBQW9CO2NBSGhDLFVBQVU7ZUFBQztnQkFDVixVQUFVLEVBQUUsTUFBTTthQUNuQjs7c0JBaURJLE1BQU07dUJBQUMsNEJBQTRCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSHR0cENsaWVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IEluamVjdCwgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtcbiAgU3Vic2NyaXB0aW9uLFxuICBhc3luY1NjaGVkdWxlcixcbiAgYnVmZmVyVGltZSxcbiAgZmlsdGVyLFxuICBmcm9tRXZlbnQsXG4gIG1hcCxcbiAgbWVyZ2UsXG4gIHN1YnNjcmliZU9uLFxuICBzd2l0Y2hNYXAsXG4gIHdpdGhMYXRlc3RGcm9tLFxufSBmcm9tICdyeGpzJztcblxuaW1wb3J0IHsgUGFnZVZpc2liaWxpdHlTZXJ2aWNlIH0gZnJvbSAnLi4vYXBpL3BhZ2UtdmlzaWJpbGl0eS5zZXJ2aWNlJztcbmltcG9ydCB7XG4gIEFQSV9HQVRFV0FZLFxuICBLOHNBcGlTZXJ2aWNlLFxuICBTZWN1cml0eVBvbGljeVJlc291cmNlLFxuICBUT0tFTl9ESVNBQkxFX1NFU1NJT05fTUFOQUdFLFxuICBwdWJsaXNoUmVmLFxuICBza2lwRXJyb3IsXG59IGZyb20gJy4uL3B1YmxpYy1hcGknO1xuXG5jb25zdCBFVkVOVF9UUklHR0VSUyA9IFsnY2xpY2snLCAna2V5cHJlc3MnXTtcbmNvbnN0IEhFQVJUQkVBVF9QT0xMSU5HID0gMTVfMDAwO1xuZXhwb3J0IGNvbnN0IFNFU1NJT05fTUFOQUdFX0tFWSA9ICdzZXNzaW9uLW1hbmFnZS1jb25zdHJ1Y3QtdGltZSc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBTZXNzaW9uTWFuYWdlU2VydmljZSB7XG4gIHByaXZhdGUgcmVhZG9ubHkgc3Vic2NyaXB0aW9uOiBTdWJzY3JpcHRpb247XG4gIHByaXZhdGUgcmVhZG9ubHkgdmlzaWJpbGl0eSQgPSB0aGlzLnBhZ2VWaXNpYmlsaXR5LmdldFBhZ2VWaXNpYmlsaXR5KCk7XG4gIHByaXZhdGUgcmVhZG9ubHkgcG9saWN5JCA9IHRoaXMuazhzQXBpXG4gICAgLmdldEdsb2JhbFJlc291cmNlPFNlY3VyaXR5UG9saWN5UmVzb3VyY2U+KHtcbiAgICAgIGRlZmluaXRpb246IHtcbiAgICAgICAgdHlwZTogJ3VzZXJwb2xpY2llcycsXG4gICAgICAgIGFwaUdyb3VwOiAnc2VjdXJpdHkuYWxhdWRhLmlvJyxcbiAgICAgICAgYXBpVmVyc2lvbjogJ3YxYWxwaGExJyxcbiAgICAgIH0sXG4gICAgICBuYW1lOiAndXNlci1zZWN1cml0eS1wb2xpY3knLFxuICAgIH0pXG4gICAgLnBpcGUoXG4gICAgICBtYXAoXG4gICAgICAgIHAgPT5cbiAgICAgICAgICBwLnJ1bGVzXG4gICAgICAgICAgICAuZmluZChyID0+IHIubmFtZSA9PT0gJ0FjY2Vzc0NvbnRyb2xQb2xpY3knKVxuICAgICAgICAgICAgPy5pdGVtcz8uZmluZChpID0+IGkua2V5ID09PSAnU0VTU0lPTl9TV0lUQ0gnKT8uZW5hYmxlLFxuICAgICAgKSxcbiAgICAgIHN1YnNjcmliZU9uKGFzeW5jU2NoZWR1bGVyKSxcbiAgICAgIHB1Ymxpc2hSZWYoKSxcbiAgICApO1xuXG4gIHByaXZhdGUgcmVhZG9ubHkgdXNlckFjdGlvbiQgPSBtZXJnZShcbiAgICAuLi5FVkVOVF9UUklHR0VSUy5tYXAoZXYgPT4gZnJvbUV2ZW50KGRvY3VtZW50LCBldikpLFxuICApXG4gICAgLnBpcGUoXG4gICAgICBidWZmZXJUaW1lKEhFQVJUQkVBVF9QT0xMSU5HKSxcbiAgICAgIHdpdGhMYXRlc3RGcm9tKHRoaXMudmlzaWJpbGl0eSQsIHRoaXMucG9saWN5JCksXG4gICAgKVxuICAgIC5waXBlKFxuICAgICAgZmlsdGVyKChbXywgdiwgcF0pID0+IHYgJiYgcCksXG4gICAgICBzd2l0Y2hNYXAoKFtpXSkgPT5cbiAgICAgICAgdGhpcy5odHRwXG4gICAgICAgICAgLmdldChgJHtBUElfR0FURVdBWX0vYXV0aC92MS9oZWFydGJlYXRgLCB7XG4gICAgICAgICAgICBwYXJhbXM6IHsgYWN0aW9uOiAhIWkubGVuZ3RoIH0sXG4gICAgICAgICAgfSlcbiAgICAgICAgICAucGlwZShcbiAgICAgICAgICAgIC8vIOmUmeivr+eUsSBIdHRwSW50ZXJjZXB0b3Ig5aSE55CG77yM5LuF55SxIEh0dHBJbnRlcmNlcHRvciDkuLvliqjnu5PmnZ/mraTmtYHvvIzoh6rouqvkuIDnm7Tov5vooYzlv4Pot7NcbiAgICAgICAgICAgIHNraXBFcnJvcigpLFxuICAgICAgICAgICksXG4gICAgICApLFxuICAgICk7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHJpdmF0ZSByZWFkb25seSBodHRwOiBIdHRwQ2xpZW50LFxuICAgIHByaXZhdGUgcmVhZG9ubHkgcGFnZVZpc2liaWxpdHk6IFBhZ2VWaXNpYmlsaXR5U2VydmljZSxcbiAgICBwcml2YXRlIHJlYWRvbmx5IGs4c0FwaTogSzhzQXBpU2VydmljZSxcbiAgICBASW5qZWN0KFRPS0VOX0RJU0FCTEVfU0VTU0lPTl9NQU5BR0UpIGRpc2FibGVkOiBib29sZWFuLFxuICApIHtcbiAgICBpZiAoIWRpc2FibGVkKSB7XG4gICAgICBzZXNzaW9uU3RvcmFnZS5zZXRJdGVtKFNFU1NJT05fTUFOQUdFX0tFWSwgU3RyaW5nKERhdGUubm93KCkpKTtcbiAgICAgIHRoaXMuc3Vic2NyaXB0aW9uID0gdGhpcy51c2VyQWN0aW9uJC5zdWJzY3JpYmUoKTtcbiAgICB9XG4gIH1cblxuICBjb21wbGV0ZSgpIHtcbiAgICB0aGlzLnN1YnNjcmlwdGlvbj8udW5zdWJzY3JpYmUoKTtcbiAgfVxufVxuIl19

package/esm2022/authorization/state.service.mjs

@@ -0,0 +1,254 @@
+/**
+ * @packageDocumentation
+ * @module authorization
+ */
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { decodeUrl } from 'ab64';
+import { EMPTY, Subject, concat, of, catchError, map, shareReplay, switchMap, takeUntil, tap, } from 'rxjs';
+import { API_GATEWAY, CODE_KEY, ID_TOKEN_KEY, NOT_NOTIFY_ON_ERROR_HEADERS, REFRESH_TOKEN_KEY, TOKEN_CALLBACK_API, TOKEN_INFO_API, TOKEN_LOGIN_API, TOKEN_REFRESH_API, publishRef, } from '../core/public-api';
+import { getInitUrl } from './app-init-url';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+const REDIRECT_URIS = new Set(['redirect_uri', 'post_logout_redirect_uri']);
+export class AuthorizationStateService {
+    constructor(http, idTokenKey, refreshTokenKey, codeKey, apiTokenLogin, apiTokenCallback, apiRefreshToken, apiTokenInfo) {
+        this.http = http;
+        this.idTokenKey = idTokenKey;
+        this.refreshTokenKey = refreshTokenKey;
+        this.codeKey = codeKey;
+        this.apiTokenLogin = apiTokenLogin;
+        this.apiTokenCallback = apiTokenCallback;
+        this.apiRefreshToken = apiRefreshToken;
+        this.apiTokenInfo = apiTokenInfo;
+        this.destroy$$ = new Subject();
+        this.refreshToken$$ = new Subject();
+        this.state$ = this.getAuthConfiguration().pipe(switchMap(config => concat(this.getExistedToken(config), this.refreshToken$$).pipe(map(token => ({ ...config, ...token })))), tap(state => {
+            this.stateSnapshot = state;
+            if (!state.idToken) {
+                this.logout(true);
+            }
+            this.payloadSnapshot = getAccountInfo(state);
+        }), takeUntil(this.destroy$$), shareReplay(1));
+        this.checkTokenCache = {};
+        this.stateSnapshot = null;
+    }
+    logout(specificUrl = false) {
+        localStorage.removeItem(this.idTokenKey);
+        localStorage.removeItem(this.refreshTokenKey);
+        this.redirectToUrl(specificUrl && location.href);
+    }
+    logoutAudit() {
+        return this.http.post(`${API_GATEWAY}/auth/v1/logout`, {}, {
+            headers: NOT_NOTIFY_ON_ERROR_HEADERS,
+        });
+    }
+    redirectToUrl(href = '') {
+        if (this.stateSnapshot) {
+            let url = '';
+            /**
+             * 已存在授权信息（logoutUrl 和 idToken 都存在）场景：
+             * 1、主动登出（退出登录，此时 href 为空）时不记录任何信息，再次登录后重定向到平台首页。
+             * 2、被动登出（token 过期、失效，此时 href 不为空）时替换 post_logout_redirect_uri 为 href，再次登录后重定向到 href 页面。
+             * 不存在授权信息场景：
+             * 1、存在 href（未登录时直接访问 href）授权后重定向到 href 页面。
+             * 2、不存在 href（登录页进入）否则授权后重定向到平台首页。
+             */
+            if (this.stateSnapshot.logoutUrl && this.stateSnapshot.idToken) {
+                const logoutUrl = `${this.stateSnapshot.logoutUrl}&id_token_hint=${this.stateSnapshot.idToken}`;
+                url = href ? this.replaceRedirectUrl(logoutUrl, href) : logoutUrl;
+            }
+            else {
+                const authUrl = this.stateSnapshot.authUrl;
+                url = href ? this.replaceRedirectUrl(authUrl, href) : authUrl;
+            }
+            try {
+                parent.top.location.href = url;
+            }
+            catch {
+                // should never happen, just for robustness in case of cross-origin iframe
+                location.href = url;
+            }
+        }
+    }
+    refreshToken() {
+        const refreshToken = localStorage.getItem(this.refreshTokenKey);
+        if (refreshToken) {
+            if (!this.refreshTokenCache$) {
+                this.refreshTokenCache$ = this.getTokenByRefreshToken(refreshToken).pipe(tap(token => {
+                    this.refreshTokenCache$ = null;
+                    this.refreshToken$$.next(token);
+                }), map(({ idToken }) => idToken), catchError(() => {
+                    this.logout(true);
+                    return EMPTY;
+                }), publishRef());
+            }
+            return this.refreshTokenCache$;
+        }
+        this.logout(true);
+        return EMPTY;
+    }
+    checkToken(token) {
+        if (!this.checkTokenCache[token]) {
+            this.checkTokenCache[token] = this.http
+                .get(this.apiTokenInfo, {
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            })
+                .pipe(tap({
+                next: () => {
+                    this.checkTokenCache[token] = null;
+                },
+                error: () => {
+                    this.checkTokenCache[token] = null;
+                },
+            }), publishRef());
+        }
+        return this.checkTokenCache[token];
+    }
+    getToken() {
+        return this.state$.pipe(map(state => state.idToken));
+    }
+    getTokenPayload() {
+        return this.state$.pipe(map(state => getAccountInfo(state)));
+    }
+    getAccountInfo() {
+        if (this.payloadSnapshot) {
+            return of(this.payloadSnapshot);
+        }
+        return this.state$.pipe(map(state => getAccountInfo(state) || {}));
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    getAuthConfiguration() {
+        return this.http
+            .get(this.apiTokenLogin)
+            .pipe(map(res => ({
+            authUrl: res.auth_url,
+            state: res.state,
+            logoutUrl: res.logout_url || '',
+        })));
+    }
+    getExistedToken(config) {
+        return this.getTokenFromLocal(config).pipe(catchError(error => {
+            console.error(error);
+            return of({ idToken: '', refreshToken: '' });
+        }));
+    }
+    getTokenFromLocal(config) {
+        const { queryParams, hashParams } = this.getParams();
+        const code = queryParams[this.codeKey] || hashParams[this.codeKey];
+        if (code) {
+            return this.getTokenByCode(code, config.state);
+        }
+        const refreshToken = queryParams[this.refreshTokenKey] || hashParams[this.refreshTokenKey];
+        if (refreshToken) {
+            return this.getTokenByRefreshToken(refreshToken);
+        }
+        const idToken = queryParams[this.idTokenKey] || hashParams[this.idTokenKey];
+        if (idToken) {
+            localStorage.setItem(this.idTokenKey, idToken);
+        }
+        return of({
+            idToken: idToken ?? localStorage.getItem(this.idTokenKey) ?? '',
+            refreshToken: localStorage.getItem(this.refreshTokenKey) ?? '',
+        });
+    }
+    getTokenByRefreshToken(refreshToken) {
+        return this.http
+            .get(this.apiRefreshToken, {
+            params: { refresh_token: refreshToken },
+        })
+            .pipe(tap(({ id_token, refresh_token }) => {
+            localStorage.setItem(this.idTokenKey, id_token);
+            localStorage.setItem(this.refreshTokenKey, refresh_token);
+        }), map(({ id_token, refresh_token }) => ({
+            idToken: id_token,
+            refreshToken: refresh_token,
+        })));
+    }
+    getTokenByCode(code, state) {
+        return this.http
+            .get(this.apiTokenCallback, {
+            params: { code, state },
+        })
+            .pipe(tap(({ id_token, refresh_token }) => {
+            localStorage.setItem(this.idTokenKey, id_token);
+            localStorage.setItem(this.refreshTokenKey, refresh_token);
+        }), map(({ id_token, refresh_token }) => ({
+            idToken: id_token,
+            refreshToken: refresh_token,
+        })));
+    }
+    getParams() {
+        const initUrl = getInitUrl();
+        const initLocation = new URL(initUrl);
+        const queryParams = parseParams(initLocation.search ? initLocation.search.slice(1) : '');
+        const hashParams = parseParams(initLocation.hash ? initLocation.hash.slice(1) : '');
+        return { queryParams, hashParams };
+    }
+    replaceRedirectUrl(authUrl, href) {
+        const [path, queryParams] = authUrl.split('?');
+        const replacedQueryParams = queryParams
+            .split('&')
+            .map(pair => {
+            const [key, value] = pair.split('=');
+            return REDIRECT_URIS.has(key)
+                ? `${key}=${encodeURIComponent(href) || value}`
+                : `${key}=${value}`;
+        })
+            .join('&');
+        return `${path}?${replacedQueryParams}`;
+    }
+    static { this.ɵfac = function AuthorizationStateService_Factory(t) { return new (t || AuthorizationStateService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(ID_TOKEN_KEY), i0.ɵɵinject(REFRESH_TOKEN_KEY), i0.ɵɵinject(CODE_KEY), i0.ɵɵinject(TOKEN_LOGIN_API), i0.ɵɵinject(TOKEN_CALLBACK_API), i0.ɵɵinject(TOKEN_REFRESH_API), i0.ɵɵinject(TOKEN_INFO_API)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AuthorizationStateService, factory: AuthorizationStateService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AuthorizationStateService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [ID_TOKEN_KEY]
+            }] }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [REFRESH_TOKEN_KEY]
+            }] }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [CODE_KEY]
+            }] }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [TOKEN_LOGIN_API]
+            }] }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [TOKEN_CALLBACK_API]
+            }] }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [TOKEN_REFRESH_API]
+            }] }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [TOKEN_INFO_API]
+            }] }]; }, null); })();
+function parseParams(query) {
+    if (!query) {
+        return {};
+    }
+    return query.split('&').reduce((acc, param) => {
+        const [key, value] = param.split('=');
+        return {
+            ...acc,
+            [key]: value,
+        };
+    }, {});
+}
+function getAccountInfo(state) {
+    let accountInfo;
+    try {
+        accountInfo = JSON.parse(decodeUrl(state.idToken.split('.')[1]));
+    }
+    catch { }
+    return accountInfo;
+}
+//# 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 { Inject, Injectable, OnDestroy } from '@angular/core';\nimport { decodeUrl } from 'ab64';\nimport {\n  EMPTY,\n  Observable,\n  Subject,\n  concat,\n  of,\n  catchError,\n  map,\n  shareReplay,\n  switchMap,\n  takeUntil,\n  tap,\n} from 'rxjs';\n\nimport { StringMap } from '../core';\nimport {\n  API_GATEWAY,\n  CODE_KEY,\n  ID_TOKEN_KEY,\n  NOT_NOTIFY_ON_ERROR_HEADERS,\n  REFRESH_TOKEN_KEY,\n  TOKEN_CALLBACK_API,\n  TOKEN_INFO_API,\n  TOKEN_LOGIN_API,\n  TOKEN_REFRESH_API,\n  publishRef,\n} from '../core/public-api';\nimport { AccountInfo } from '../page-scaffold';\n\nimport { getInitUrl } from './app-init-url';\n\nexport interface AuthorizationState {\n  idToken?: string;\n  refreshToken?: string;\n  authUrl?: string;\n  state?: string;\n  logoutUrl?: string;\n}\n\nconst REDIRECT_URIS = new Set(['redirect_uri', 'post_logout_redirect_uri']);\n@Injectable({ providedIn: 'root' })\nexport class AuthorizationStateService implements OnDestroy {\n  private readonly destroy$$ = new Subject<void>();\n  private readonly refreshToken$$ = new Subject<{\n    idToken: string;\n    refreshToken: string;\n  }>();\n\n  private readonly state$ = this.getAuthConfiguration().pipe(\n    switchMap(config =>\n      concat(this.getExistedToken(config), this.refreshToken$$).pipe(\n        map(token => ({ ...config, ...token })),\n      ),\n    ),\n    tap(state => {\n      this.stateSnapshot = state;\n      if (!state.idToken) {\n        this.logout(true);\n      }\n      this.payloadSnapshot = getAccountInfo(state);\n    }),\n    takeUntil(this.destroy$$),\n    shareReplay(1),\n  );\n\n  private checkTokenCache: Record<string, Observable<unknown>> = {};\n  private refreshTokenCache$: Observable<string>;\n\n  stateSnapshot: AuthorizationState = null;\n\n  payloadSnapshot: AccountInfo;\n\n  constructor(\n    private readonly http: HttpClient,\n    @Inject(ID_TOKEN_KEY) private readonly idTokenKey: string,\n    @Inject(REFRESH_TOKEN_KEY) private readonly refreshTokenKey: string,\n    @Inject(CODE_KEY) private readonly codeKey: string,\n    @Inject(TOKEN_LOGIN_API) private readonly apiTokenLogin: string,\n    @Inject(TOKEN_CALLBACK_API) private readonly apiTokenCallback: string,\n    @Inject(TOKEN_REFRESH_API) private readonly apiRefreshToken: string,\n    @Inject(TOKEN_INFO_API) private readonly apiTokenInfo: string,\n  ) {}\n\n  logout(specificUrl = false) {\n    localStorage.removeItem(this.idTokenKey);\n    localStorage.removeItem(this.refreshTokenKey);\n    this.redirectToUrl(specificUrl && location.href);\n  }\n\n  logoutAudit() {\n    return this.http.post(\n      `${API_GATEWAY}/auth/v1/logout`,\n      {},\n      {\n        headers: NOT_NOTIFY_ON_ERROR_HEADERS,\n      },\n    );\n  }\n\n  redirectToUrl(href = '') {\n    if (this.stateSnapshot) {\n      let url = '';\n      /**\n       * 已存在授权信息（logoutUrl 和 idToken 都存在）场景：\n       * 1、主动登出（退出登录，此时 href 为空）时不记录任何信息，再次登录后重定向到平台首页。\n       * 2、被动登出（token 过期、失效，此时 href 不为空）时替换 post_logout_redirect_uri 为 href，再次登录后重定向到 href 页面。\n       * 不存在授权信息场景：\n       * 1、存在 href（未登录时直接访问 href）授权后重定向到 href 页面。\n       * 2、不存在 href（登录页进入）否则授权后重定向到平台首页。\n       */\n      if (this.stateSnapshot.logoutUrl && this.stateSnapshot.idToken) {\n        const logoutUrl = `${this.stateSnapshot.logoutUrl}&id_token_hint=${this.stateSnapshot.idToken}`;\n        url = href ? this.replaceRedirectUrl(logoutUrl, href) : logoutUrl;\n      } else {\n        const authUrl = this.stateSnapshot.authUrl;\n        url = href ? this.replaceRedirectUrl(authUrl, href) : authUrl;\n      }\n      try {\n        parent.top.location.href = url;\n      } catch {\n        // should never happen, just for robustness in case of cross-origin iframe\n        location.href = url;\n      }\n    }\n  }\n\n  refreshToken() {\n    const refreshToken = localStorage.getItem(this.refreshTokenKey);\n    if (refreshToken) {\n      if (!this.refreshTokenCache$) {\n        this.refreshTokenCache$ = this.getTokenByRefreshToken(\n          refreshToken,\n        ).pipe(\n          tap(token => {\n            this.refreshTokenCache$ = null;\n            this.refreshToken$$.next(token);\n          }),\n          map(({ idToken }) => idToken),\n          catchError(() => {\n            this.logout(true);\n            return EMPTY;\n          }),\n          publishRef(),\n        );\n      }\n      return this.refreshTokenCache$;\n    }\n    this.logout(true);\n    return EMPTY;\n  }\n\n  checkToken(token: string) {\n    if (!this.checkTokenCache[token]) {\n      this.checkTokenCache[token] = this.http\n        .get(this.apiTokenInfo, {\n          headers: {\n            Authorization: `Bearer ${token}`,\n          },\n        })\n        .pipe(\n          tap({\n            next: () => {\n              this.checkTokenCache[token] = null;\n            },\n            error: () => {\n              this.checkTokenCache[token] = null;\n            },\n          }),\n          publishRef(),\n        );\n    }\n    return this.checkTokenCache[token];\n  }\n\n  getToken() {\n    return this.state$.pipe(map(state => state.idToken));\n  }\n\n  getTokenPayload<T>() {\n    return this.state$.pipe(map(state => getAccountInfo(state) as T));\n  }\n\n  getAccountInfo() {\n    if (this.payloadSnapshot) {\n      return of(this.payloadSnapshot);\n    }\n    return this.state$.pipe(map(state => getAccountInfo(state) || {}));\n  }\n\n  ngOnDestroy() {\n    this.destroy$$.next();\n    this.destroy$$.complete();\n  }\n\n  private getAuthConfiguration() {\n    return this.http\n      .get<{ auth_url: string; state: string; logout_url: string }>(\n        this.apiTokenLogin,\n      )\n      .pipe(\n        map(res => ({\n          authUrl: res.auth_url,\n          state: res.state,\n          logoutUrl: res.logout_url || '',\n        })),\n      );\n  }\n\n  private getExistedToken(config: AuthorizationState) {\n    return this.getTokenFromLocal(config).pipe(\n      catchError(error => {\n        console.error(error);\n        return of({ idToken: '', refreshToken: '' });\n      }),\n    );\n  }\n\n  private getTokenFromLocal(config: AuthorizationState) {\n    const { queryParams, hashParams } = this.getParams();\n\n    const code = queryParams[this.codeKey] || hashParams[this.codeKey];\n\n    if (code) {\n      return this.getTokenByCode(code, config.state);\n    }\n\n    const refreshToken =\n      queryParams[this.refreshTokenKey] || hashParams[this.refreshTokenKey];\n    if (refreshToken) {\n      return this.getTokenByRefreshToken(refreshToken);\n    }\n\n    const idToken = queryParams[this.idTokenKey] || hashParams[this.idTokenKey];\n    if (idToken) {\n      localStorage.setItem(this.idTokenKey, idToken);\n    }\n\n    return of({\n      idToken: idToken ?? localStorage.getItem(this.idTokenKey) ?? '',\n      refreshToken: localStorage.getItem(this.refreshTokenKey) ?? '',\n    });\n  }\n\n  private getTokenByRefreshToken(refreshToken: string) {\n    return this.http\n      .get<{ id_token: string; refresh_token: string }>(this.apiRefreshToken, {\n        params: { refresh_token: refreshToken },\n      })\n      .pipe(\n        tap(({ id_token, refresh_token }) => {\n          localStorage.setItem(this.idTokenKey, id_token);\n          localStorage.setItem(this.refreshTokenKey, refresh_token);\n        }),\n        map(({ id_token, refresh_token }) => ({\n          idToken: id_token,\n          refreshToken: refresh_token,\n        })),\n      );\n  }\n\n  private getTokenByCode(code: string, state: string) {\n    return this.http\n      .get<{ id_token: string; refresh_token: string }>(this.apiTokenCallback, {\n        params: { code, state },\n      })\n      .pipe(\n        tap(({ id_token, refresh_token }) => {\n          localStorage.setItem(this.idTokenKey, id_token);\n          localStorage.setItem(this.refreshTokenKey, refresh_token);\n        }),\n        map(({ id_token, refresh_token }) => ({\n          idToken: id_token,\n          refreshToken: refresh_token,\n        })),\n      );\n  }\n\n  private getParams() {\n    const initUrl = getInitUrl();\n\n    const initLocation = new URL(initUrl);\n\n    const queryParams = parseParams(\n      initLocation.search ? initLocation.search.slice(1) : '',\n    );\n\n    const hashParams = parseParams(\n      initLocation.hash ? initLocation.hash.slice(1) : '',\n    );\n\n    return { queryParams, hashParams };\n  }\n\n  private replaceRedirectUrl(authUrl: string, href: string) {\n    const [path, queryParams] = authUrl.split('?');\n\n    const replacedQueryParams = queryParams\n      .split('&')\n      .map(pair => {\n        const [key, value] = pair.split('=');\n        return REDIRECT_URIS.has(key)\n          ? `${key}=${encodeURIComponent(href) || value}`\n          : `${key}=${value}`;\n      })\n      .join('&');\n\n    return `${path}?${replacedQueryParams}`;\n  }\n}\n\nfunction parseParams(query: string): StringMap {\n  if (!query) {\n    return {};\n  }\n\n  return query.split('&').reduce((acc, param) => {\n    const [key, value] = param.split('=');\n\n    return {\n      ...acc,\n      [key]: value,\n    };\n  }, {});\n}\n\nfunction getAccountInfo(state: AuthorizationState) {\n  let accountInfo;\n  try {\n    accountInfo = JSON.parse(\n      decodeUrl(state.idToken.split('.')[1]),\n    ) as AccountInfo;\n  } catch {}\n  return accountInfo;\n}\n"]}

package/esm2022/business/module-info/api.service.mjs

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { map, pluck } from 'rxjs';
+import { K8sApiService } from '../../api/k8s-api.service';
+import { COMMON_RESOURCE_DEFINITIONS } from '../../core';
+import { K8sUtilService } from '../../core/services';
+import { skipError } from '../../core/utils';
+import { matchLabelsToString } from '../../k8s-resource-list/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/services";
+import * as i2 from "../../api/k8s-api.service";
+export class ModuleInfoApiService {
+    constructor(k8sUtil, k8sApi) {
+        this.k8sUtil = k8sUtil;
+        this.k8sApi = k8sApi;
+    }
+    getModuleInfo({ cluster, module, single = true }) {
+        return this.k8sApi
+            .getGlobalResourceList({
+            definition: COMMON_RESOURCE_DEFINITIONS.MODULE_INFO,
+            queryParams: {
+                labelSelector: matchLabelsToString({
+                    [this.k8sUtil.normalizeType('cluster-name')]: cluster,
+                    [this.k8sUtil.normalizeType('module-name')]: module,
+                }),
+            },
+        })
+            .pipe(skipError({ items: [] }), pluck('items'), map(items => (single ? items?.[0] : items)));
+    }
+    isModuleEnabled({ cluster, module }) {
+        return this.getModuleInfo({ cluster, module }).pipe(map(moduleInfo => moduleInfo?.status?.phase === 'Running'));
+    }
+    static { this.ɵfac = function ModuleInfoApiService_Factory(t) { return new (t || ModuleInfoApiService)(i0.ɵɵinject(i1.K8sUtilService), i0.ɵɵinject(i2.K8sApiService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ModuleInfoApiService, factory: ModuleInfoApiService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ModuleInfoApiService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.K8sUtilService }, { type: i2.K8sApiService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/business/module-info/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './api.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9idXNpbmVzcy9tb2R1bGUtaW5mby9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZUFBZSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hcGkuc2VydmljZSc7XG4iXX0=

package/esm2022/business/public-api.mjs

@@ -0,0 +1,8 @@
+/**
+ * @packageDocumentation
+ * @module business
+ * @preferred
+ */
+export * from './resource-select/public-api';
+export * from './module-info/public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9idXNpbmVzcy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFFSCxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICogQG1vZHVsZSBidXNpbmVzc1xuICogQHByZWZlcnJlZFxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcmVzb3VyY2Utc2VsZWN0L3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9tb2R1bGUtaW5mby9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/business/resource-select/base-list.mjs

@@ -0,0 +1,84 @@
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectorRef, Directive, EventEmitter, inject, Input, Output, } from '@angular/core';
+import { Observable, Subject, takeUntil } from 'rxjs';
+import { AuthorizationStateService } from '../../authorization/state.service';
+import { K8sUtilService } from '../../core/services';
+import { ObservableInput } from '../../core/utils';
+import { ResourceSelectContextService } from './context.service';
+import { setWorkspaceParams } from './utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/services";
+import * as i2 from "./context.service";
+export class ResourceListBase {
+    constructor(cdr, k8sUtil, contextService) {
+        this.cdr = cdr;
+        this.k8sUtil = k8sUtil;
+        this.contextService = contextService;
+        this.context = 'page';
+        this.fields = [];
+        this.selectItem = new EventEmitter();
+        this.load = new EventEmitter();
+        this.reload$$ = new Subject();
+        this.destroy$$ = new Subject();
+        this.loading = true;
+        this.forceLoading = false;
+        this.auth = inject(AuthorizationStateService);
+        this.contextService.reload$$
+            .asObservable()
+            .pipe(takeUntil(this.destroy$$))
+            .subscribe(() => {
+            this.reload();
+            this.cdr.markForCheck();
+        });
+    }
+    reload() {
+        this.forceLoading = true;
+        this.reload$$.next();
+    }
+    onSelect(selected) {
+        let obj;
+        switch (selected.__origin.kind) {
+            case 'Project': {
+                obj = { project: selected.name };
+                break;
+            }
+            case 'Namespace': {
+                obj = {
+                    project: this.k8sUtil.getLabel(selected.__origin, 'project'),
+                    cluster: selected.cluster,
+                    namespace: selected.name,
+                    servicemesh: selected.serviceMeshName || '',
+                };
+            }
+        }
+        this.auth.getAccountInfo().subscribe(({ email }) => {
+            setWorkspaceParams(obj, email);
+        });
+        this.selectItem.emit(selected);
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+    }
+    static { this.ɵfac = function ResourceListBase_Factory(t) { return new (t || ResourceListBase)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i1.K8sUtilService), i0.ɵɵdirectiveInject(i2.ResourceSelectContextService)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ResourceListBase, inputs: { context: "context", popupLite: "popupLite", fields: "fields" }, outputs: { selectItem: "selectItem", load: "load" } }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ResourceListBase.prototype, "fields$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ResourceListBase, [{
+        type: Directive
+    }], function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.K8sUtilService }, { type: i2.ResourceSelectContextService }]; }, { context: [{
+            type: Input
+        }], popupLite: [{
+            type: Input
+        }], fields: [{
+            type: Input
+        }], fields$: [], selectItem: [{
+            type: Output
+        }], 
+    // eslint-disable-next-line @angular-eslint/no-output-native
+    load: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1saXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vc3JjL2J1c2luZXNzL3Jlc291cmNlLXNlbGVjdC9iYXNlLWxpc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFDTCxpQkFBaUIsRUFDakIsU0FBUyxFQUNULFlBQVksRUFDWixNQUFNLEVBQ04sS0FBSyxFQUVMLE1BQU0sR0FDUCxNQUFNLGVBQWUsQ0FBQztBQUN2QixPQUFPLEVBQUUsVUFBVSxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFFdEQsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFDOUUsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3JELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUduRCxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUVqRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxTQUFTLENBQUM7Ozs7QUFLN0MsTUFBTSxPQUFnQixnQkFBZ0I7SUErQnBDLFlBQ3FCLEdBQXNCLEVBQ3RCLE9BQXVCLEVBQ3ZCLGNBQTRDO1FBRjVDLFFBQUcsR0FBSCxHQUFHLENBQW1CO1FBQ3RCLFlBQU8sR0FBUCxPQUFPLENBQWdCO1FBQ3ZCLG1CQUFjLEdBQWQsY0FBYyxDQUE4QjtRQWhDakUsWUFBTyxHQUFpQixNQUFNLENBQUM7UUFPL0IsV0FBTSxHQUF3QixFQUFFLENBQUM7UUFNakMsZUFBVSxHQUFHLElBQUksWUFBWSxFQUFnQixDQUFDO1FBSTlDLFNBQUksR0FBRyxJQUFJLFlBQVksRUFBdUIsQ0FBQztRQUUvQyxhQUFRLEdBQUcsSUFBSSxPQUFPLEVBQVEsQ0FBQztRQUUvQixjQUFTLEdBQUcsSUFBSSxPQUFPLEVBQVEsQ0FBQztRQUVoQyxZQUFPLEdBQUcsSUFBSSxDQUFDO1FBRWYsaUJBQVksR0FBRyxLQUFLLENBQUM7UUFFckIsU0FBSSxHQUFHLE1BQU0sQ0FBQyx5QkFBeUIsQ0FBQyxDQUFDO1FBT3ZDLElBQUksQ0FBQyxjQUFjLENBQUMsUUFBUTthQUN6QixZQUFZLEVBQUU7YUFDZCxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQzthQUMvQixTQUFTLENBQUMsR0FBRyxFQUFFO1lBQ2QsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ2QsSUFBSSxDQUFDLEdBQUcsQ0FBQyxZQUFZLEVBQUUsQ0FBQztRQUMxQixDQUFDLENBQUMsQ0FBQztJQUNQLENBQUM7SUFFRCxNQUFNO1FBQ0osSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUM7UUFDekIsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUN2QixDQUFDO0lBRUQsUUFBUSxDQUFDLFFBQXNCO1FBQzdCLElBQUksR0FBb0IsQ0FBQztRQUN6QixRQUFRLFFBQVEsQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFO1lBQzlCLEtBQUssU0FBUyxDQUFDLENBQUM7Z0JBQ2QsR0FBRyxHQUFHLEVBQUUsT0FBTyxFQUFFLFFBQVEsQ0FBQyxJQUFJLEVBQUUsQ0FBQztnQkFDakMsTUFBTTthQUNQO1lBQ0QsS0FBSyxXQUFXLENBQUMsQ0FBQztnQkFDaEIsR0FBRyxHQUFHO29CQUNKLE9BQU8sRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFLFNBQVMsQ0FBQztvQkFDNUQsT0FBTyxFQUFFLFFBQVEsQ0FBQyxPQUFPO29CQUN6QixTQUFTLEVBQUUsUUFBUSxDQUFDLElBQUk7b0JBQ3hCLFdBQVcsRUFBRSxRQUFRLENBQUMsZUFBZSxJQUFJLEVBQUU7aUJBQzVDLENBQUM7YUFDSDtTQUNGO1FBQ0QsSUFBSSxDQUFDLElBQUksQ0FBQyxjQUFjLEVBQUUsQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLEtBQUssRUFBRSxFQUFFLEVBQUU7WUFDakQsa0JBQWtCLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBQ2pDLENBQUMsQ0FBQyxDQUFDO1FBQ0gsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDakMsQ0FBQztJQU9ELFdBQVc7UUFDVCxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3hCLENBQUM7aUZBL0VtQixnQkFBZ0I7b0VBQWhCLGdCQUFnQjs7QUFZcEM7SUFEQyxlQUFlLEVBQUU7OEJBQ1QsVUFBVTtpREFBc0I7dUZBWnJCLGdCQUFnQjtjQURyQyxTQUFTOzRJQUdSLE9BQU87a0JBRE4sS0FBSztZQUtOLFNBQVM7a0JBRFIsS0FBSztZQUlOLE1BQU07a0JBREwsS0FBSztZQUlOLE9BQU8sTUFHUCxVQUFVO2tCQURULE1BQU07O0lBSVAsNERBQTREO0lBQzVELElBQUk7a0JBRkgsTUFBTSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIENoYW5nZURldGVjdG9yUmVmLFxuICBEaXJlY3RpdmUsXG4gIEV2ZW50RW1pdHRlcixcbiAgaW5qZWN0LFxuICBJbnB1dCxcbiAgT25EZXN0cm95LFxuICBPdXRwdXQsXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgU3ViamVjdCwgdGFrZVVudGlsIH0gZnJvbSAncnhqcyc7XG5cbmltcG9ydCB7IEF1dGhvcml6YXRpb25TdGF0ZVNlcnZpY2UgfSBmcm9tICcuLi8uLi9hdXRob3JpemF0aW9uL3N0YXRlLnNlcnZpY2UnO1xuaW1wb3J0IHsgSzhzVXRpbFNlcnZpY2UgfSBmcm9tICcuLi8uLi9jb3JlL3NlcnZpY2VzJztcbmltcG9ydCB7IE9ic2VydmFibGVJbnB1dCB9IGZyb20gJy4uLy4uL2NvcmUvdXRpbHMnO1xuXG5pbXBvcnQgeyBLdWJlcm5ldGVzUmVzb3VyY2UsIFdvcmtzcGFjZVBhcmFtcyB9IGZyb20gJy4vLi4vLi4vY29yZSc7XG5pbXBvcnQgeyBSZXNvdXJjZVNlbGVjdENvbnRleHRTZXJ2aWNlIH0gZnJvbSAnLi9jb250ZXh0LnNlcnZpY2UnO1xuaW1wb3J0IHsgQ29uZmlndXJhYmxlRmllbGQsIERhdGFJdGVtQmFzZSwgUmVzb3VyY2VEYXRhTnVtYmVycyB9IGZyb20gJy4vdHlwZXMnO1xuaW1wb3J0IHsgc2V0V29ya3NwYWNlUGFyYW1zIH0gZnJvbSAnLi91dGlscyc7XG5cbmV4cG9ydCB0eXBlIFVzYWdlQ29udGV4dCA9ICdwYWdlJyB8ICdwb3B1cCc7XG5cbkBEaXJlY3RpdmUoKVxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIFJlc291cmNlTGlzdEJhc2UgaW1wbGVtZW50cyBPbkRlc3Ryb3kge1xuICBASW5wdXQoKVxuICBjb250ZXh0OiBVc2FnZUNvbnRleHQgPSAncGFnZSc7XG5cbiAgLy8gcG9wdXAg5b2i5oCB55qE57K+566A5qih5byPXG4gIEBJbnB1dCgpXG4gIHBvcHVwTGl0ZTogYm9vbGVhbjtcblxuICBASW5wdXQoKVxuICBmaWVsZHM6IENvbmZpZ3VyYWJsZUZpZWxkW10gPSBbXTtcblxuICBAT2JzZXJ2YWJsZUlucHV0KClcbiAgZmllbGRzJDogT2JzZXJ2YWJsZTxDb25maWd1cmFibGVGaWVsZFtdPjtcblxuICBAT3V0cHV0KClcbiAgc2VsZWN0SXRlbSA9IG5ldyBFdmVudEVtaXR0ZXI8RGF0YUl0ZW1CYXNlPigpO1xuXG4gIEBPdXRwdXQoKVxuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQGFuZ3VsYXItZXNsaW50L25vLW91dHB1dC1uYXRpdmVcbiAgbG9hZCA9IG5ldyBFdmVudEVtaXR0ZXI8UmVzb3VyY2VEYXRhTnVtYmVycz4oKTtcblxuICByZWxvYWQkJCA9IG5ldyBTdWJqZWN0PHZvaWQ+KCk7XG5cbiAgZGVzdHJveSQkID0gbmV3IFN1YmplY3Q8dm9pZD4oKTtcblxuICBsb2FkaW5nID0gdHJ1ZTtcblxuICBmb3JjZUxvYWRpbmcgPSBmYWxzZTtcblxuICBhdXRoID0gaW5qZWN0KEF1dGhvcml6YXRpb25TdGF0ZVNlcnZpY2UpO1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHByb3RlY3RlZCByZWFkb25seSBjZHI6IENoYW5nZURldGVjdG9yUmVmLFxuICAgIHByb3RlY3RlZCByZWFkb25seSBrOHNVdGlsOiBLOHNVdGlsU2VydmljZSxcbiAgICBwcm90ZWN0ZWQgcmVhZG9ubHkgY29udGV4dFNlcnZpY2U6IFJlc291cmNlU2VsZWN0Q29udGV4dFNlcnZpY2UsXG4gICkge1xuICAgIHRoaXMuY29udGV4dFNlcnZpY2UucmVsb2FkJCRcbiAgICAgIC5hc09ic2VydmFibGUoKVxuICAgICAgLnBpcGUodGFrZVVudGlsKHRoaXMuZGVzdHJveSQkKSlcbiAgICAgIC5zdWJzY3JpYmUoKCkgPT4ge1xuICAgICAgICB0aGlzLnJlbG9hZCgpO1xuICAgICAgICB0aGlzLmNkci5tYXJrRm9yQ2hlY2soKTtcbiAgICAgIH0pO1xuICB9XG5cbiAgcmVsb2FkKCkge1xuICAgIHRoaXMuZm9yY2VMb2FkaW5nID0gdHJ1ZTtcbiAgICB0aGlzLnJlbG9hZCQkLm5leHQoKTtcbiAgfVxuXG4gIG9uU2VsZWN0KHNlbGVjdGVkOiBEYXRhSXRlbUJhc2UpIHtcbiAgICBsZXQgb2JqOiBXb3Jrc3BhY2VQYXJhbXM7XG4gICAgc3dpdGNoIChzZWxlY3RlZC5fX29yaWdpbi5raW5kKSB7XG4gICAgICBjYXNlICdQcm9qZWN0Jzoge1xuICAgICAgICBvYmogPSB7IHByb2plY3Q6IHNlbGVjdGVkLm5hbWUgfTtcbiAgICAgICAgYnJlYWs7XG4gICAgICB9XG4gICAgICBjYXNlICdOYW1lc3BhY2UnOiB7XG4gICAgICAgIG9iaiA9IHtcbiAgICAgICAgICBwcm9qZWN0OiB0aGlzLms4c1V0aWwuZ2V0TGFiZWwoc2VsZWN0ZWQuX19vcmlnaW4sICdwcm9qZWN0JyksXG4gICAgICAgICAgY2x1c3Rlcjogc2VsZWN0ZWQuY2x1c3RlcixcbiAgICAgICAgICBuYW1lc3BhY2U6IHNlbGVjdGVkLm5hbWUsXG4gICAgICAgICAgc2VydmljZW1lc2g6IHNlbGVjdGVkLnNlcnZpY2VNZXNoTmFtZSB8fCAnJyxcbiAgICAgICAgfTtcbiAgICAgIH1cbiAgICB9XG4gICAgdGhpcy5hdXRoLmdldEFjY291bnRJbmZvKCkuc3Vic2NyaWJlKCh7IGVtYWlsIH0pID0+IHtcbiAgICAgIHNldFdvcmtzcGFjZVBhcmFtcyhvYmosIGVtYWlsKTtcbiAgICB9KTtcbiAgICB0aGlzLnNlbGVjdEl0ZW0uZW1pdChzZWxlY3RlZCk7XG4gIH1cblxuICBhYnN0cmFjdCBtYXBSZXNvdXJjZShcbiAgICByZXM6IEt1YmVybmV0ZXNSZXNvdXJjZVtdLFxuICAgIHBhcmFtcz86IHVua25vd24sXG4gICk6IERhdGFJdGVtQmFzZVtdO1xuXG4gIG5nT25EZXN0cm95KCkge1xuICAgIHRoaXMuZGVzdHJveSQkLm5leHQoKTtcbiAgfVxufVxuIl19

package/esm2022/business/resource-select/context.service.mjs

@@ -0,0 +1,69 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { K8sUtilService } from '../../core/services';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../core/services";
+export class ResourceSelectContextService {
+    set cachedServiceMeshes(value) {
+        this._cachedServiceMeshes = value;
+    }
+    get cachedServiceMeshes() {
+        return this._cachedServiceMeshes;
+    }
+    set cachedClusters(value) {
+        this._cachedClusters = value;
+    }
+    get cachedClusters() {
+        return this._cachedClusters;
+    }
+    get cachedProjects() {
+        return this._cachedProjects;
+    }
+    set cachedProjects(value) {
+        this._cachedProjects = value;
+    }
+    set cachedProjectResources(projects) {
+        this._cachedProjectResources = projects;
+    }
+    get cachedProjectResources() {
+        return this._cachedProjectResources;
+    }
+    set cachedServiceMeshGroupResources(meshes) {
+        this._cachedServiceMeshGroupResources = meshes;
+    }
+    get cachedServiceMeshGroupResources() {
+        return this._cachedServiceMeshGroupResources;
+    }
+    constructor(http, k8sUtil) {
+        this.http = http;
+        this.k8sUtil = k8sUtil;
+        this.userEmail = this.k8sUtil.normalizeType('user.email', 'auth');
+        this.reload$$ = new Subject();
+        this._cachedServiceMeshes = [];
+        this._cachedClusters = [];
+        this._cachedProjects = [];
+        this._cachedProjectResources = [];
+        this._cachedServiceMeshGroupResources = [];
+        this.cachedNamespaces = {};
+    }
+    storeNamespaces(project, cluster, namespaces) {
+        this.cachedNamespaces[`${project}_${cluster}`] = namespaces;
+    }
+    getCachedNamespaces(project, cluster) {
+        return this.cachedNamespaces[`${project}_${cluster}`];
+    }
+    getUser(email) {
+        return this.http.get(`{{API_GATEWAY}}/apis/auth.alauda.io/v1/users/${email}`);
+    }
+    static { this.ɵfac = function ResourceSelectContextService_Factory(t) { return new (t || ResourceSelectContextService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.K8sUtilService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ResourceSelectContextService, factory: ResourceSelectContextService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ResourceSelectContextService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.K8sUtilService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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