@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/esm2022/authorization/state.service.mjs

@@ -0,0 +1,227 @@
+/**
+ * @packageDocumentation
+ * @module authorization
+ */
+import { HttpClient } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+import { decodeUrl } from 'ab64';
+import { EMPTY, Subject, concat, of, catchError, map, shareReplay, switchMap, tap, pipe, from, } from 'rxjs';
+import { API_GATEWAY, NOT_NOTIFY_ON_ERROR_HEADERS, publishRef, getTopWindow, } from '../core/public-api';
+import { getInitUrl } from './app-init-url';
+import { asyncReadStorageToken, cleanStorageToken, readStorageToken, readStorageType, writeStorageToken, } from './storage-token';
+import * as i0 from "@angular/core";
+export const STORAGE_TYPE_KEY = 'token_storage';
+export const ID_TOKEN_KEY = 'id_token';
+export const REFRESH_TOKEN_KEY = 'refresh_token';
+export const CODE_KEY = 'code';
+const LOGIN_API = '/console/api/v1/token/login';
+const CALLBACK_API = '/console/api/v1/token/callback';
+const TOKEN_REFRESH_API = '/console/api/v1/token/refresh';
+const TOKEN_INFO_API = '/console/api/v1/token/info';
+const REDIRECT_URIS = new Set(['redirect_uri', 'post_logout_redirect_uri']);
+export class AuthorizationStateService {
+    constructor() {
+        this.http = inject(HttpClient);
+        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);
+        }), shareReplay(1));
+        this.checkTokenCache = {};
+        this.stateSnapshot = null;
+    }
+    logout(specificUrl = false) {
+        cleanStorageToken();
+        this.redirectToDex(specificUrl && location.href);
+    }
+    logoutAudit() {
+        return this.http.post(`${API_GATEWAY}/auth/v1/logout`, {}, {
+            headers: NOT_NOTIFY_ON_ERROR_HEADERS,
+        });
+    }
+    async redirectToDex(redirectUrl = null) {
+        if (!this.stateSnapshot) {
+            return;
+        }
+        // 主动退出或 session 模式跳转到 dex 前需要主动清除 `user_login` cookie 防止自动授权
+        if (!!this.stateSnapshot.idToken || readStorageType() === 'session') {
+            try {
+                await fetch(`${this.stateSnapshot.logoutUrl}&id_token_hint=${
+                // 主动退出时禁用现有 token
+                this.stateSnapshot.idToken || ''}`);
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        const href = replaceRedirectUrl(this.stateSnapshot.authUrl, 
+        // authUrl 中的 redirectUrl 是根路由，根路由二次重定向回 portal 时会丢失 code 导致登录失败
+        // 如果后期有定制化要求默认首页不是 portal，可以改回之前的方案，使用浏览器导航打开 logoutUrl，然后 dex 重定向到根路由，根路由重定向到默认首页，首页再将 authUrl 中的 redirectUrl 替换为当前 url 跳转到 dex 进行登录；
+        // 最好环境变量增加默认首页地址或者 dex redirectUrl 直接是正确地址
+        redirectUrl || location.origin + '/console-portal');
+        try {
+            getTopWindow().location.href = href;
+        }
+        catch {
+            // should never happen, just for robustness in case of cross-origin iframe
+            location.href = href;
+        }
+    }
+    refreshToken() {
+        const refreshToken = readStorageToken()?.refreshToken;
+        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(TOKEN_INFO_API, {
+                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) || {}));
+    }
+    getAuthConfiguration() {
+        return this.http
+            .get(LOGIN_API)
+            .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[CODE_KEY] || hashParams[CODE_KEY];
+        if (code) {
+            return this.getTokenByCode(code, config.state);
+        }
+        const refreshToken = queryParams[REFRESH_TOKEN_KEY] || hashParams[REFRESH_TOKEN_KEY];
+        if (refreshToken) {
+            return this.getTokenByRefreshToken(refreshToken);
+        }
+        const idToken = queryParams[ID_TOKEN_KEY] || hashParams[ID_TOKEN_KEY];
+        if (idToken) {
+            writeStorageToken({
+                storageType: (queryParams[STORAGE_TYPE_KEY] ||
+                    hashParams[STORAGE_TYPE_KEY]),
+                idToken,
+                refreshToken: '',
+            });
+        }
+        return from(asyncReadStorageToken());
+    }
+    getTokenByRefreshToken(refreshToken) {
+        return this.http
+            .get(TOKEN_REFRESH_API, {
+            params: { refresh_token: refreshToken },
+        })
+            .pipe(mapTokenResponse());
+    }
+    getTokenByCode(code, state) {
+        return this.http
+            .get(CALLBACK_API, {
+            params: { code, state },
+        })
+            .pipe(mapTokenResponse());
+    }
+    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 };
+    }
+    static { this.ɵfac = function AuthorizationStateService_Factory(t) { return new (t || AuthorizationStateService)(); }; }
+    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' }]
+    }], null, null); })();
+function replaceRedirectUrl(dexUrl, redirectUrl) {
+    const [path, queryParams] = dexUrl.split('?');
+    const replacedQueryParams = queryParams
+        .split('&')
+        .map(pair => {
+        const [key, value] = pair.split('=');
+        return REDIRECT_URIS.has(key)
+            ? `${key}=${encodeURIComponent(redirectUrl)}`
+            : `${key}=${value}`;
+    })
+        .join('&');
+    return `${path}?${replacedQueryParams}`;
+}
+function parseParams(query) {
+    if (!query) {
+        return {};
+    }
+    return query.split('&').reduce((acc, param) => {
+        const [key, value] = param.split('=');
+        return {
+            ...acc,
+            [key]: value,
+        };
+    }, {});
+}
+function getAccountInfo(state) {
+    return state.idToken
+        ? JSON.parse(decodeUrl(state.idToken.split('.')[1]))
+        : null;
+}
+function mapTokenResponse() {
+    return pipe(tap(({ token_storage, id_token, refresh_token }) => {
+        writeStorageToken({
+            storageType: token_storage,
+            idToken: id_token,
+            refreshToken: refresh_token,
+        });
+    }), map(({ id_token, refresh_token }) => ({
+        idToken: id_token,
+        refreshToken: refresh_token,
+    })));
+}
+//# 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 { decodeUrl } from 'ab64';\nimport {\n  EMPTY,\n  Observable,\n  Subject,\n  concat,\n  of,\n  catchError,\n  map,\n  shareReplay,\n  switchMap,\n  tap,\n  pipe,\n  from,\n} from 'rxjs';\n\nimport {\n  StringMap,\n  API_GATEWAY,\n  NOT_NOTIFY_ON_ERROR_HEADERS,\n  publishRef,\n  getTopWindow,\n} from '../core/public-api';\nimport { AccountInfo } from '../page-scaffold/public-api';\n\nimport { getInitUrl } from './app-init-url';\nimport {\n  asyncReadStorageToken,\n  cleanStorageToken,\n  readStorageToken,\n  readStorageType,\n  writeStorageToken,\n} from './storage-token';\n\nexport interface AuthorizationState {\n  idToken?: string;\n  refreshToken?: string;\n  state?: string;\n  authUrl?: string;\n  logoutUrl?: string;\n}\n\nexport interface TokenResponse {\n  token_storage: StorageType;\n  id_token: string;\n  refresh_token: string;\n}\n\nexport type StorageType = 'local' | 'session';\n\nexport const STORAGE_TYPE_KEY = 'token_storage';\nexport const ID_TOKEN_KEY = 'id_token';\nexport const REFRESH_TOKEN_KEY = 'refresh_token';\nexport const CODE_KEY = 'code';\n\nconst LOGIN_API = '/console/api/v1/token/login';\nconst CALLBACK_API = '/console/api/v1/token/callback';\nconst TOKEN_REFRESH_API = '/console/api/v1/token/refresh';\nconst TOKEN_INFO_API = '/console/api/v1/token/info';\n\nconst REDIRECT_URIS = new Set(['redirect_uri', 'post_logout_redirect_uri']);\n\n@Injectable({ providedIn: 'root' })\nexport class AuthorizationStateService {\n  private readonly http = inject(HttpClient);\n\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    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  logout(specificUrl = false) {\n    cleanStorageToken();\n    this.redirectToDex(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  async redirectToDex(redirectUrl: string = null) {\n    if (!this.stateSnapshot) {\n      return;\n    }\n\n    // 主动退出或 session 模式跳转到 dex 前需要主动清除 `user_login` cookie 防止自动授权\n    if (!!this.stateSnapshot.idToken || readStorageType() === 'session') {\n      try {\n        await fetch(\n          `${this.stateSnapshot.logoutUrl}&id_token_hint=${\n            // 主动退出时禁用现有 token\n            this.stateSnapshot.idToken || ''\n          }`,\n        );\n      } catch (e) {\n        console.error(e);\n      }\n    }\n\n    const href = replaceRedirectUrl(\n      this.stateSnapshot.authUrl,\n      // authUrl 中的 redirectUrl 是根路由，根路由二次重定向回 portal 时会丢失 code 导致登录失败\n      // 如果后期有定制化要求默认首页不是 portal，可以改回之前的方案，使用浏览器导航打开 logoutUrl，然后 dex 重定向到根路由，根路由重定向到默认首页，首页再将 authUrl 中的 redirectUrl 替换为当前 url 跳转到 dex 进行登录；\n      // 最好环境变量增加默认首页地址或者 dex redirectUrl 直接是正确地址\n      redirectUrl || location.origin + '/console-portal',\n    );\n\n    try {\n      getTopWindow().location.href = href;\n    } catch {\n      // should never happen, just for robustness in case of cross-origin iframe\n      location.href = href;\n    }\n  }\n\n  refreshToken() {\n    const refreshToken = readStorageToken()?.refreshToken;\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(TOKEN_INFO_API, {\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  private getAuthConfiguration() {\n    return this.http\n      .get<{ auth_url: string; state: string; logout_url: string }>(LOGIN_API)\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(\n    config: AuthorizationState,\n  ): Observable<{ idToken?: string; refreshToken?: string }> {\n    const { queryParams, hashParams } = this.getParams();\n\n    const code = queryParams[CODE_KEY] || hashParams[CODE_KEY];\n\n    if (code) {\n      return this.getTokenByCode(code, config.state);\n    }\n\n    const refreshToken =\n      queryParams[REFRESH_TOKEN_KEY] || hashParams[REFRESH_TOKEN_KEY];\n\n    if (refreshToken) {\n      return this.getTokenByRefreshToken(refreshToken);\n    }\n\n    const idToken = queryParams[ID_TOKEN_KEY] || hashParams[ID_TOKEN_KEY];\n\n    if (idToken) {\n      writeStorageToken({\n        storageType: (queryParams[STORAGE_TYPE_KEY] ||\n          hashParams[STORAGE_TYPE_KEY]) as TokenResponse['token_storage'],\n        idToken,\n        refreshToken: '',\n      });\n    }\n\n    return from(asyncReadStorageToken());\n  }\n\n  private getTokenByRefreshToken(refreshToken: string) {\n    return this.http\n      .get<TokenResponse>(TOKEN_REFRESH_API, {\n        params: { refresh_token: refreshToken },\n      })\n      .pipe(mapTokenResponse());\n  }\n\n  private getTokenByCode(code: string, state: string) {\n    return this.http\n      .get<TokenResponse>(CALLBACK_API, {\n        params: { code, state },\n      })\n      .pipe(mapTokenResponse());\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\nfunction replaceRedirectUrl(dexUrl: string, redirectUrl: string) {\n  const [path, queryParams] = dexUrl.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(redirectUrl)}`\n        : `${key}=${value}`;\n    })\n    .join('&');\n\n  return `${path}?${replacedQueryParams}`;\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): AccountInfo {\n  return state.idToken\n    ? JSON.parse(decodeUrl(state.idToken.split('.')[1]))\n    : null;\n}\n\nfunction mapTokenResponse() {\n  return pipe(\n    tap(({ token_storage, id_token, refresh_token }: TokenResponse) => {\n      writeStorageToken({\n        storageType: token_storage,\n        idToken: id_token,\n        refreshToken: refresh_token,\n      });\n    }),\n    map(({ id_token, refresh_token }) => ({\n      idToken: id_token,\n      refreshToken: refresh_token,\n    })),\n  );\n}\n"]}

package/esm2022/authorization/storage-token.mjs

@@ -0,0 +1,98 @@
+import { ID_TOKEN_KEY, REFRESH_TOKEN_KEY, STORAGE_TYPE_KEY, } from './state.service';
+let sessionTokenShareChannel;
+const SESSION_TOKEN_SHARE_CHANNEL = 'SESSION_TOKEN_SHARE_CHANNEL';
+const SESSION_CLOSE_TIMESTAMP = 'session_close_timestamp';
+const recordSessionTimestamp = () => {
+    sessionStorage.setItem(SESSION_CLOSE_TIMESTAMP, Date.now().toString());
+};
+const getStorage = (storageType) => storageType === 'session' ? sessionStorage : localStorage;
+export function readStorageType() {
+    return (localStorage.getItem(STORAGE_TYPE_KEY) === 'session' ? 'session' : 'local');
+}
+export function cleanStorageToken() {
+    localStorage.removeItem(ID_TOKEN_KEY);
+    localStorage.removeItem(REFRESH_TOKEN_KEY);
+    sessionStorage.removeItem(ID_TOKEN_KEY);
+    sessionStorage.removeItem(REFRESH_TOKEN_KEY);
+}
+export function writeStorageToken(token) {
+    cleanStorageToken();
+    sessionStorage.removeItem(SESSION_CLOSE_TIMESTAMP);
+    const storage = getStorage(token.storageType);
+    storage.setItem(ID_TOKEN_KEY, token.idToken);
+    storage.setItem(REFRESH_TOKEN_KEY, token.refreshToken);
+    localStorage.setItem(STORAGE_TYPE_KEY, token.storageType);
+    if (token.storageType === 'session') {
+        setupSessionTokenShareChannel();
+    }
+    else {
+        closeSessionTokenShareChannel();
+    }
+}
+export function readStorageToken() {
+    const storageType = readStorageType();
+    if (storageType === 'session') {
+        const sessionTimestamp = sessionStorage.getItem(SESSION_CLOSE_TIMESTAMP);
+        sessionStorage.removeItem(SESSION_CLOSE_TIMESTAMP);
+        if (sessionTimestamp &&
+            Date.now() - parseInt(sessionTimestamp) > 10 * 1000) {
+            // 浏览器恢复标签时清除 session token
+            cleanStorageToken();
+            console.warn('session timeout');
+        }
+        setupSessionTokenShareChannel();
+    }
+    const storage = getStorage(storageType);
+    return {
+        storageType,
+        idToken: storage.getItem(ID_TOKEN_KEY),
+        refreshToken: storage.getItem(REFRESH_TOKEN_KEY),
+    };
+}
+export function asyncReadStorageToken() {
+    const storageToken = readStorageToken();
+    if (storageToken.storageType === 'session' && !storageToken.idToken) {
+        return new Promise(resolve => {
+            const timer = window.setTimeout(() => {
+                console.warn('request session token timeout');
+                sessionTokenShareChannel.removeEventListener('message', receiveSessionToken);
+                resolve({});
+            }, 50);
+            function receiveSessionToken({ data, }) {
+                if (data.type === 'provide') {
+                    window.clearTimeout(timer);
+                    sessionTokenShareChannel.removeEventListener('message', receiveSessionToken);
+                    writeStorageToken(data.token);
+                    resolve(data.token);
+                }
+            }
+            sessionTokenShareChannel.addEventListener('message', receiveSessionToken);
+            sessionTokenShareChannel.postMessage({ type: 'request' });
+        });
+    }
+    return Promise.resolve(storageToken);
+}
+function setupSessionTokenShareChannel() {
+    if (sessionTokenShareChannel) {
+        return;
+    }
+    sessionTokenShareChannel = new BroadcastChannel(SESSION_TOKEN_SHARE_CHANNEL);
+    sessionTokenShareChannel.addEventListener('message', ({ data }) => {
+        if (data.type === 'request') {
+            sessionTokenShareChannel.postMessage({
+                type: 'provide',
+                token: readStorageToken(),
+            });
+        }
+    });
+    window.addEventListener('beforeunload', recordSessionTimestamp);
+}
+function closeSessionTokenShareChannel() {
+    if (!sessionTokenShareChannel) {
+        return;
+    }
+    sessionTokenShareChannel.close();
+    sessionTokenShareChannel = null;
+    window.removeEventListener('beforeunload', recordSessionTimestamp);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage-token.js","sourceRoot":"","sources":["../../../../../libs/common/src/authorization/storage-token.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ID_TOKEN_KEY,\n  REFRESH_TOKEN_KEY,\n  STORAGE_TYPE_KEY,\n  StorageType,\n} from './state.service';\n\nlet sessionTokenShareChannel: BroadcastChannel;\n\nconst SESSION_TOKEN_SHARE_CHANNEL = 'SESSION_TOKEN_SHARE_CHANNEL';\n\nconst SESSION_CLOSE_TIMESTAMP = 'session_close_timestamp';\n\nconst recordSessionTimestamp = () => {\n  sessionStorage.setItem(SESSION_CLOSE_TIMESTAMP, Date.now().toString());\n};\n\nconst getStorage = (storageType: StorageType): Storage =>\n  storageType === 'session' ? sessionStorage : localStorage;\n\ntype SessionTokenShareData =\n  | {\n      type: 'provide';\n      token: StorageToken;\n    }\n  | { type: 'request' };\n\nexport interface StorageToken {\n  storageType: StorageType;\n  idToken: string;\n  refreshToken: string;\n}\n\nexport function readStorageType() {\n  return (\n    localStorage.getItem(STORAGE_TYPE_KEY) === 'session' ? 'session' : 'local'\n  ) as StorageType;\n}\n\nexport function cleanStorageToken() {\n  localStorage.removeItem(ID_TOKEN_KEY);\n  localStorage.removeItem(REFRESH_TOKEN_KEY);\n\n  sessionStorage.removeItem(ID_TOKEN_KEY);\n  sessionStorage.removeItem(REFRESH_TOKEN_KEY);\n}\n\nexport function writeStorageToken(token: StorageToken) {\n  cleanStorageToken();\n  sessionStorage.removeItem(SESSION_CLOSE_TIMESTAMP);\n\n  const storage = getStorage(token.storageType);\n\n  storage.setItem(ID_TOKEN_KEY, token.idToken);\n  storage.setItem(REFRESH_TOKEN_KEY, token.refreshToken);\n  localStorage.setItem(STORAGE_TYPE_KEY, token.storageType);\n\n  if (token.storageType === 'session') {\n    setupSessionTokenShareChannel();\n  } else {\n    closeSessionTokenShareChannel();\n  }\n}\n\nexport function readStorageToken(): Partial<StorageToken> {\n  const storageType = readStorageType();\n\n  if (storageType === 'session') {\n    const sessionTimestamp = sessionStorage.getItem(SESSION_CLOSE_TIMESTAMP);\n    sessionStorage.removeItem(SESSION_CLOSE_TIMESTAMP);\n\n    if (\n      sessionTimestamp &&\n      Date.now() - parseInt(sessionTimestamp) > 10 * 1000\n    ) {\n      // 浏览器恢复标签时清除 session token\n      cleanStorageToken();\n      console.warn('session timeout');\n    }\n\n    setupSessionTokenShareChannel();\n  }\n\n  const storage = getStorage(storageType);\n\n  return {\n    storageType,\n    idToken: storage.getItem(ID_TOKEN_KEY),\n    refreshToken: storage.getItem(REFRESH_TOKEN_KEY),\n  };\n}\n\nexport function asyncReadStorageToken(): Promise<Partial<StorageToken>> {\n  const storageToken = readStorageToken();\n\n  if (storageToken.storageType === 'session' && !storageToken.idToken) {\n    return new Promise(resolve => {\n      const timer = window.setTimeout(() => {\n        console.warn('request session token timeout');\n\n        sessionTokenShareChannel.removeEventListener(\n          'message',\n          receiveSessionToken,\n        );\n        resolve({});\n      }, 50);\n\n      function receiveSessionToken({\n        data,\n      }: MessageEvent<SessionTokenShareData>) {\n        if (data.type === 'provide') {\n          window.clearTimeout(timer);\n          sessionTokenShareChannel.removeEventListener(\n            'message',\n            receiveSessionToken,\n          );\n\n          writeStorageToken(data.token);\n          resolve(data.token);\n        }\n      }\n\n      sessionTokenShareChannel.addEventListener('message', receiveSessionToken);\n\n      sessionTokenShareChannel.postMessage({ type: 'request' });\n    });\n  }\n\n  return Promise.resolve(storageToken);\n}\n\nfunction setupSessionTokenShareChannel() {\n  if (sessionTokenShareChannel) {\n    return;\n  }\n\n  sessionTokenShareChannel = new BroadcastChannel(SESSION_TOKEN_SHARE_CHANNEL);\n\n  sessionTokenShareChannel.addEventListener(\n    'message',\n    ({ data }: MessageEvent<SessionTokenShareData>) => {\n      if (data.type === 'request') {\n        sessionTokenShareChannel.postMessage({\n          type: 'provide',\n          token: readStorageToken(),\n        } as SessionTokenShareData);\n      }\n    },\n  );\n\n  window.addEventListener('beforeunload', recordSessionTimestamp);\n}\n\nfunction closeSessionTokenShareChannel() {\n  if (!sessionTokenShareChannel) {\n    return;\n  }\n\n  sessionTokenShareChannel.close();\n  sessionTokenShareChannel = null;\n\n  window.removeEventListener('beforeunload', recordSessionTimestamp);\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/public-api';
+import { K8sUtilService } from '../../core/services/public-api';
+import { skipError } from '../../core/utils/public-api';
+import { matchLabelsToString } from '../../k8s-resource-list/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/services/public-api";
+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/notification-disabled-container/component.mjs

@@ -0,0 +1,87 @@
+import { __decorate, __metadata } from "tslib";
+import { TooltipModule } from '@alauda/ui';
+import { AsyncPipe, NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ContentChild, Input, TemplateRef, } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { Observable, catchError, map, of, startWith, switchMap } from 'rxjs';
+import { K8sApiService } from '../../api/public-api';
+import { NOTIFICATION_SERVER_NAME, ObservableInput, RESOURCE_TYPES, publishRef, } from '../../core/public-api';
+import { TranslateModule } from '../../translate/public-api';
+import * as i0 from "@angular/core";
+import * as i1 from "../../api/public-api";
+import * as i2 from "@alauda/ui";
+import * as i3 from "../../translate/translate.pipe";
+import * as i4 from "@angular/router";
+const _c0 = "/manage-platform/platform-setting/notification-server/create";
+const _c1 = function () { return [_c0]; };
+function NotificationDisabledContainerComponent_ng_template_5_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtext(0);
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵelementStart(2, "a", 3);
+    i0.ɵɵtext(3);
+    i0.ɵɵpipe(4, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(1, 3, "notification_not_config_tip"), " ");
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("routerLink", i0.ɵɵpureFunction0(7, _c1));
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(4, 5, "set_now"), " ");
+} }
+const _c2 = function (a0) { return { $implicit: a0 }; };
+export class NotificationDisabledContainerComponent {
+    constructor(k8sApi) {
+        this.k8sApi = k8sApi;
+        // TODO: @hwzhu 由于权限问题，临时放开除平台管理以外的通知服务器限制，后续更新高级API后再恢复全产品判断 jira: AIT-40333
+        this.notificationServerOn$ = this.enableToSetNotification$.pipe(switchMap(enable => enable
+            ? this.k8sApi
+                .getGlobalResource({
+                type: RESOURCE_TYPES.SECRET,
+                namespaced: true,
+                name: NOTIFICATION_SERVER_NAME,
+            })
+                .pipe(map(res => !!res), catchError(() => of(false)), startWith(false), publishRef())
+            : of(true)), publishRef());
+    }
+    static { this.ɵfac = function NotificationDisabledContainerComponent_Factory(t) { return new (t || NotificationDisabledContainerComponent)(i0.ɵɵdirectiveInject(i1.K8sApiService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: NotificationDisabledContainerComponent, selectors: [["acl-notification-disabled-container"]], contentQueries: function NotificationDisabledContainerComponent_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
+            i0.ɵɵcontentQuery(dirIndex, TemplateRef, 7);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.inputRef = _t.first);
+        } }, inputs: { enableToSetNotification: "enableToSetNotification" }, standalone: true, features: [i0.ɵɵStandaloneFeature], decls: 7, vars: 12, consts: [[1, "acl-notification-disabled-container", 3, "auiTooltip", "auiTooltipDisabled"], [3, "ngTemplateOutlet", "ngTemplateOutletContext"], ["notConfigTips", ""], [3, "routerLink"]], template: function NotificationDisabledContainerComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "span", 0);
+            i0.ɵɵpipe(1, "translate");
+            i0.ɵɵpipe(2, "async");
+            i0.ɵɵelementContainer(3, 1);
+            i0.ɵɵpipe(4, "async");
+            i0.ɵɵelementEnd();
+            i0.ɵɵtemplate(5, NotificationDisabledContainerComponent_ng_template_5_Template, 5, 8, "ng-template", null, 2, i0.ɵɵtemplateRefExtractor);
+        } if (rf & 2) {
+            const _r0 = i0.ɵɵreference(6);
+            i0.ɵɵproperty("auiTooltip", ctx.enableToSetNotification ? _r0 : i0.ɵɵpipeBind1(1, 4, "notification_not_allow_tip"))("auiTooltipDisabled", i0.ɵɵpipeBind1(2, 6, ctx.notificationServerOn$));
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("ngTemplateOutlet", ctx.inputRef)("ngTemplateOutletContext", i0.ɵɵpureFunction1(10, _c2, !i0.ɵɵpipeBind1(4, 8, ctx.notificationServerOn$)));
+        } }, dependencies: [TooltipModule, i2.TooltipDirective, TranslateModule, i3.TranslatePipe, RouterModule, i4.RouterLink, NgTemplateOutlet,
+            AsyncPipe], encapsulation: 2, changeDetection: 0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], NotificationDisabledContainerComponent.prototype, "enableToSetNotification$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NotificationDisabledContainerComponent, [{
+        type: Component,
+        args: [{ standalone: true, selector: 'acl-notification-disabled-container', imports: [
+                    TooltipModule,
+                    TranslateModule,
+                    RouterModule,
+                    NgTemplateOutlet,
+                    AsyncPipe,
+                ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<span\n  class=\"acl-notification-disabled-container\"\n  [auiTooltip]=\"\n    enableToSetNotification\n      ? notConfigTips\n      : ('notification_not_allow_tip' | translate)\n  \"\n  [auiTooltipDisabled]=\"notificationServerOn$ | async\"\n>\n  <ng-container\n    [ngTemplateOutlet]=\"inputRef\"\n    [ngTemplateOutletContext]=\"{\n      $implicit: !(notificationServerOn$ | async)\n    }\"\n  ></ng-container>\n</span>\n\n<ng-template #notConfigTips>\n  {{ 'notification_not_config_tip' | translate }}\n  <a\n    [routerLink]=\"[\n      '/manage-platform/platform-setting/notification-server/create'\n    ]\"\n  >\n    {{ 'set_now' | translate }}\n  </a>\n</ng-template>\n" }]
+    }], function () { return [{ type: i1.K8sApiService }]; }, { enableToSetNotification: [{
+            type: Input
+        }], enableToSetNotification$: [], inputRef: [{
+            type: ContentChild,
+            args: [TemplateRef, { static: true }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/business/notification-disabled-container/public-api.mjs

@@ -0,0 +1,2 @@
+export { NotificationDisabledContainerComponent } from './component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9idXNpbmVzcy9ub3RpZmljYXRpb24tZGlzYWJsZWQtY29udGFpbmVyL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHNDQUFzQyxFQUFFLE1BQU0sYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgTm90aWZpY2F0aW9uRGlzYWJsZWRDb250YWluZXJDb21wb25lbnQgfSBmcm9tICcuL2NvbXBvbmVudCc7XG4iXX0=

package/esm2022/business/public-api.mjs

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