@alauda-fe/common 1.0.0-next.0

package/esm2022/page-scaffold/page-header/header-notify/notify.service.mjs

@@ -0,0 +1,282 @@
+import { MessageService, MessageType as Type, NotificationService, } from '@alauda/ui';
+import { Injectable } from '@angular/core';
+import { get } from 'lodash-es';
+import { Subject, of, map, switchMap, takeUntil, tap } from 'rxjs';
+import { K8sApiService } from '../../../api/k8s-api.service';
+import { WatchEvent } from '../../../api/types';
+import { AuthorizationStateService } from '../../../authorization/state.service';
+import { K8sUtilService } from '../../../core';
+import { K8SResourceList } from '../../../k8s-resource-list/k8s-resource-list';
+import { MESSAGE_CONFIG, MessageType, NOTIFY_INFO_TYPE, NOTIFY_NOT_FIXED, NOTIFY_PUSH_TYPE, dateValueOf, } from './utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../api/k8s-api.service";
+import * as i2 from "../../../authorization/state.service";
+import * as i3 from "../../../core";
+import * as i4 from "@alauda/ui";
+const NOTIFY_TYPE_MAP = {
+    [MessageType.WarningMessage]: Type.Error,
+    [MessageType.SystemMessage]: Type.Info,
+    [MessageType.ProductMessage]: Type.Success,
+    [MessageType.PlatformAnnouncement]: '',
+};
+export class NotifyService {
+    constructor(k8sApi, auth, k8sUtil, notification, messages) {
+        this.k8sApi = k8sApi;
+        this.auth = auth;
+        this.k8sUtil = k8sUtil;
+        this.notification = notification;
+        this.messages = messages;
+        this.triggerNotify$ = new Subject();
+        this.pushEnabled = true;
+        this.auiNotificationList = [];
+        this.windowUnload = false;
+        this.onDestroy$ = new Subject();
+        this.userName$ = this.auth.getTokenPayload().pipe(takeUntil(this.onDestroy$), map(account => account.email || account.name), tap(name => {
+            this.userName = name;
+            this.settingDefaultPushStatus();
+        }));
+        // 这个版本没有自动发送的消息，用户手册没有办法描述这部分功能, 先注释
+        // 因占用并发数，后续如产品需要重新加入此功能，可以和产品讨论下是否可以阉割此功能
+        // watchConfigMap$ = this.k8sApi
+        //   .watchGlobalResource({
+        //     definition: {
+        //       type: 'configmaps',
+        //     },
+        //     namespaced: true,
+        //     name: 'message-config',
+        //   })
+        //   .pipe(
+        //     takeUntil(this.onDestroy$),
+        //     catchError(() => of(null)),
+        //     map(() => {
+        //       return this.pushEnabled;
+        //     }),
+        //   );
+        // watchMessageConfigMap$ = this.watchConfigMap$.pipe(
+        //   switchMap(res =>
+        //     this.userName$.pipe(
+        //       map(() => {
+        //         return res;
+        //       }),
+        //     ),
+        //   ),
+        // );
+        this.list = new K8SResourceList({
+            fetchParams$: of({}),
+            fetcher: this.fetcher.bind(this),
+            watcher: seed => this.k8sApi
+                .watchGlobalResourceChange(seed, {
+                definition: MESSAGE_CONFIG,
+            })
+                .pipe(tap(item => {
+                const cacheInfo = this.getCacheLocalValue(NOTIFY_INFO_TYPE);
+                const infoValue = cacheInfo?.split(',') || [];
+                this.removePush(item);
+                if ([WatchEvent.Added, WatchEvent.Modified].includes(item.type) &&
+                    !infoValue.includes(this.k8sUtil.getName(item.object))) {
+                    this.dispatchNotify(item.object);
+                    const value = [...infoValue, this.k8sUtil.getName(item.object)];
+                    this.cacheNotifyInfo(value.join(','));
+                }
+            })),
+            polling: 10000,
+        });
+    }
+    watchNotify() {
+        this.triggerNotify$.pipe(takeUntil(this.onDestroy$)).subscribe(res => {
+            this.notifyMessage(res);
+        });
+    }
+    getNotifyList() {
+        return this.list.items$.pipe(takeUntil(this.onDestroy$), switchMap(res => this.userName$.pipe(map(() => res))), map(res => this.messageSort(res, 'desc')));
+    }
+    messageSort(data, type = 'asc') {
+        return data.sort((a, b) => {
+            const start = type === 'asc'
+                ? a.metadata.creationTimestamp
+                : b.metadata.creationTimestamp;
+            const end = type === 'asc'
+                ? b.metadata.creationTimestamp
+                : a.metadata.creationTimestamp;
+            return dateValueOf(start) - dateValueOf(end);
+        });
+    }
+    fetcher() {
+        return this.k8sApi
+            .getGlobalResourceList({
+            definition: MESSAGE_CONFIG,
+        })
+            .pipe(tap(res => {
+            this.handleNotify(res.items);
+        }));
+    }
+    handleNotify(data) {
+        const cacheInfo = this.getCacheLocalValue(NOTIFY_INFO_TYPE);
+        const infoValue = cacheInfo?.split(',') || [];
+        const messages = this.messageSort(data, 'desc').reduce((acc, item) => {
+            const { isResident } = item.spec;
+            if (isResident &&
+                !this.expired(item) &&
+                !infoValue.includes(this.k8sUtil.getName(item))) {
+                const pre = acc ? `${acc},` : '';
+                this.dispatchNotify(item); // 触发提示消息
+                return `${pre}${this.k8sUtil.getName(item)}`;
+            }
+            return acc;
+        }, '');
+        if (messages) {
+            this.cacheNotifyInfo(messages);
+        }
+    }
+    cacheNotifyInfo(values) {
+        this.addCacheLocalValue(NOTIFY_INFO_TYPE, values);
+    }
+    dispatchNotify(data) {
+        const notFixed = this.getCacheLocalValue(NOTIFY_NOT_FIXED);
+        const pass = !notFixed?.split(',')?.includes(this.k8sUtil.getName(data));
+        const push = this.getCacheLocalValue(NOTIFY_PUSH_TYPE);
+        if (((!data.spec.isResident && this.pushEnabled && push) ||
+            !this.expired(data)) &&
+            pass) {
+            this.triggerNotify$.next(data);
+        }
+    }
+    expired(item) {
+        const expiredTimestamp = item.spec.expiredTimestamp;
+        if (!expiredTimestamp) {
+            return true;
+        }
+        return new Date(expiredTimestamp).valueOf() < Date.now();
+    }
+    getCacheLocalValue(type) {
+        const value = window.localStorage.getItem(type);
+        return value && JSON.parse(value)[this.userName];
+    }
+    addCacheLocalValue(type, value) {
+        const preValue = window.localStorage.getItem(type);
+        window.localStorage.setItem(type, JSON.stringify({
+            ...(preValue ? JSON.parse(preValue) : {}),
+            [this.userName]: value,
+        }));
+    }
+    notifyMessage(data) {
+        const { isResident, subject, content } = data.spec;
+        const name = this.k8sUtil.getName(data);
+        const type = this.getMessageType(data);
+        if (isResident) {
+            const notificationRef = this.notification.create({
+                type: type || Type.Info,
+                title: subject,
+                ...(type ? {} : { customClass: 'platform-class' }),
+                content,
+                ...(isResident ? { duration: 0 } : {}),
+            });
+            this.auiNotificationList.push(notificationRef);
+            Object.assign(notificationRef.instance, { data });
+            notificationRef.instance.afterClosed.subscribe(() => {
+                this.closedNotifyCallback(data, name, get(notificationRef.instance, 'windowUnload', false));
+            });
+            return;
+        }
+        this.messages.create({
+            type: type || Type.Info,
+            content: subject,
+        });
+    }
+    /**
+     * 关闭通知: 手动关闭存储 添加不再展示状态记录
+     * 关闭页面、删除消息 不记录
+     */
+    closedNotifyCallback(data, name, windowUnload) {
+        this.removeNotificationList(name);
+        if (!this.windowUnload && !windowUnload) {
+            this.addNotFixed(data);
+        }
+        this.windowUnload = false;
+    }
+    /**
+     * 记录 不再展示状态 存储在 local storage
+     */
+    addNotFixed(data) {
+        if (data.spec.isResident) {
+            const notFixedVal = this.getCacheLocalValue(NOTIFY_NOT_FIXED);
+            const value = [
+                ...(notFixedVal?.split(',') || []),
+                this.k8sUtil.getName(data),
+            ];
+            this.addCacheLocalValue(NOTIFY_NOT_FIXED, value.join(','));
+        }
+        this.windowUnload = false;
+    }
+    /**
+     * 触发删除消息
+     * - 删除 local storage NOT_FIXED 存储的消息
+     * - 手动触发关闭常驻通知弹框
+     */
+    removePush(item) {
+        const name = this.k8sUtil.getName(item.object);
+        const notFixedVal = this.getCacheLocalValue(NOTIFY_NOT_FIXED)?.split(',') || [];
+        if (WatchEvent.Deleted === item.type) {
+            this.removeMessage(name);
+            this.manualCloseNotify(name);
+        }
+        if (WatchEvent.Deleted === item.type &&
+            item.object.spec.isResident &&
+            !notFixedVal.includes(name)) {
+            this.manualCloseNotify(name);
+        }
+    }
+    removeMessage(name) {
+        const cacheNotFixed = this.getCacheLocalValue(NOTIFY_NOT_FIXED)?.split(',') || [];
+        if (cacheNotFixed.length > 0) {
+            const index = cacheNotFixed.indexOf(name);
+            if (index !== -1) {
+                cacheNotFixed.splice(index, 1);
+                this.addCacheLocalValue(NOTIFY_NOT_FIXED, cacheNotFixed.join(','));
+            }
+        }
+    }
+    manualCloseNotify(name) {
+        const notifyInstance = this.auiNotificationList.find(item => this.k8sUtil.getName(get(item.instance, 'data')) === name);
+        if (notifyInstance) {
+            this.windowUnload = true;
+            notifyInstance.instance.close();
+        }
+    }
+    removeNotificationList(name) {
+        this.auiNotificationList = this.auiNotificationList.filter(item => this.k8sUtil.getName(get(item.instance, 'data')) !== name);
+    }
+    getMessageType(data) {
+        const type = this.k8sUtil.getLabel(data, 'type');
+        return NOTIFY_TYPE_MAP[type];
+    }
+    settingDefaultPushStatus() {
+        if (!window.localStorage.getItem(NOTIFY_PUSH_TYPE)) {
+            this.addCacheLocalValue(NOTIFY_PUSH_TYPE, true);
+        }
+    }
+    closeAllNotification() {
+        for (const notify of this.auiNotificationList) {
+            // 将 windowUnload 存储 instance 在 afterClosed 进行判断
+            // remove 异步 循环中 windowUnload 值已发生改变但还未触发 afterClosed 回调
+            Object.assign(notify.instance, { windowUnload: true });
+            notify.instance.close();
+        }
+        this.auiNotificationList = [];
+    }
+    destroy() {
+        // 重新加载 header 关闭所有通知，重新加载 header 重新弹出
+        this.closeAllNotification();
+        window.localStorage.removeItem(NOTIFY_INFO_TYPE);
+        this.onDestroy$.next();
+    }
+    static { this.ɵfac = function NotifyService_Factory(t) { return new (t || NotifyService)(i0.ɵɵinject(i1.K8sApiService), i0.ɵɵinject(i2.AuthorizationStateService), i0.ɵɵinject(i3.K8sUtilService), i0.ɵɵinject(i4.NotificationService), i0.ɵɵinject(i4.MessageService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: NotifyService, factory: NotifyService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NotifyService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], function () { return [{ type: i1.K8sApiService }, { type: i2.AuthorizationStateService }, { type: i3.K8sUtilService }, { type: i4.NotificationService }, { type: i4.MessageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notify.service.js","sourceRoot":"","sources":["../../../../../../../libs/common/src/page-scaffold/page-header/header-notify/notify.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  MessageService,\n  MessageType as Type,\n  NotificationComponent,\n  NotificationService,\n} from '@alauda/ui';\nimport { ComponentRef, Injectable } from '@angular/core';\nimport { get } from 'lodash-es';\nimport { Subject, of, map, switchMap, takeUntil, tap } from 'rxjs';\n\nimport { K8sApiService } from '../../../api/k8s-api.service';\nimport { WatchAPIResponse, WatchEvent } from '../../../api/types';\nimport { AuthorizationStateService } from '../../../authorization/state.service';\nimport { K8sUtilService } from '../../../core';\nimport { K8SResourceList } from '../../../k8s-resource-list/k8s-resource-list';\nimport { AccountInfo } from '../account-menu/component/component';\n\nimport {\n  MESSAGE_CONFIG,\n  Message,\n  MessageType,\n  NOTIFY_INFO_TYPE,\n  NOTIFY_NOT_FIXED,\n  NOTIFY_PUSH_TYPE,\n  dateValueOf,\n} from './utils';\n\nconst NOTIFY_TYPE_MAP = {\n  [MessageType.WarningMessage]: Type.Error,\n  [MessageType.SystemMessage]: Type.Info,\n  [MessageType.ProductMessage]: Type.Success,\n  [MessageType.PlatformAnnouncement]: '',\n};\n@Injectable({\n  providedIn: 'root',\n})\nexport class NotifyService {\n  private userName: string;\n  triggerNotify$ = new Subject<Message>();\n  pushEnabled = true;\n  auiNotificationList: Array<ComponentRef<NotificationComponent>> = [];\n  windowUnload = false;\n  onDestroy$ = new Subject<void>();\n  userName$ = this.auth.getTokenPayload<AccountInfo>().pipe(\n    takeUntil(this.onDestroy$),\n    map(account => account.email || account.name),\n    tap(name => {\n      this.userName = name;\n      this.settingDefaultPushStatus();\n    }),\n  );\n  // 这个版本没有自动发送的消息，用户手册没有办法描述这部分功能, 先注释\n  // 因占用并发数，后续如产品需要重新加入此功能，可以和产品讨论下是否可以阉割此功能\n  // watchConfigMap$ = this.k8sApi\n  //   .watchGlobalResource({\n  //     definition: {\n  //       type: 'configmaps',\n  //     },\n  //     namespaced: true,\n  //     name: 'message-config',\n  //   })\n  //   .pipe(\n  //     takeUntil(this.onDestroy$),\n  //     catchError(() => of(null)),\n  //     map(() => {\n  //       return this.pushEnabled;\n  //     }),\n  //   );\n  // watchMessageConfigMap$ = this.watchConfigMap$.pipe(\n  //   switchMap(res =>\n  //     this.userName$.pipe(\n  //       map(() => {\n  //         return res;\n  //       }),\n  //     ),\n  //   ),\n  // );\n\n  list = new K8SResourceList({\n    fetchParams$: of({}), // 使用空参数否则路由参数变化会导致重新触发 get list\n    fetcher: this.fetcher.bind(this),\n    watcher: seed =>\n      this.k8sApi\n        .watchGlobalResourceChange<Message>(seed, {\n          definition: MESSAGE_CONFIG,\n        })\n        .pipe(\n          tap(item => {\n            const cacheInfo = this.getCacheLocalValue(NOTIFY_INFO_TYPE);\n            const infoValue: string[] = cacheInfo?.split(',') || [];\n            this.removePush(item);\n            if (\n              [WatchEvent.Added, WatchEvent.Modified].includes(item.type) &&\n              !infoValue.includes(this.k8sUtil.getName(item.object))\n            ) {\n              this.dispatchNotify(item.object);\n              const value = [...infoValue, this.k8sUtil.getName(item.object)];\n              this.cacheNotifyInfo(value.join(','));\n            }\n          }),\n        ),\n    polling: 10_000,\n  });\n\n  constructor(\n    private readonly k8sApi: K8sApiService,\n    private readonly auth: AuthorizationStateService,\n    private readonly k8sUtil: K8sUtilService,\n    private readonly notification: NotificationService,\n    private readonly messages: MessageService,\n  ) {}\n\n  watchNotify() {\n    this.triggerNotify$.pipe(takeUntil(this.onDestroy$)).subscribe(res => {\n      this.notifyMessage(res);\n    });\n  }\n\n  getNotifyList() {\n    return this.list.items$.pipe(\n      takeUntil(this.onDestroy$),\n      switchMap(res => this.userName$.pipe(map(() => res))),\n      map(res => this.messageSort(res, 'desc')),\n    );\n  }\n\n  messageSort(data: Message[], type: 'asc' | 'desc' = 'asc') {\n    return data.sort((a, b) => {\n      const start =\n        type === 'asc'\n          ? a.metadata.creationTimestamp\n          : b.metadata.creationTimestamp;\n      const end =\n        type === 'asc'\n          ? b.metadata.creationTimestamp\n          : a.metadata.creationTimestamp;\n      return dateValueOf(start) - dateValueOf(end);\n    });\n  }\n\n  private fetcher() {\n    return this.k8sApi\n      .getGlobalResourceList<Message>({\n        definition: MESSAGE_CONFIG,\n      })\n      .pipe(\n        tap(res => {\n          this.handleNotify(res.items);\n        }),\n      );\n  }\n\n  private handleNotify(data: Message[]) {\n    const cacheInfo = this.getCacheLocalValue(NOTIFY_INFO_TYPE);\n    const infoValue: string[] = cacheInfo?.split(',') || [];\n    const messages = this.messageSort(data, 'desc').reduce((acc, item) => {\n      const { isResident } = item.spec;\n      if (\n        isResident &&\n        !this.expired(item) &&\n        !infoValue.includes(this.k8sUtil.getName(item))\n      ) {\n        const pre = acc ? `${acc},` : '';\n        this.dispatchNotify(item); // 触发提示消息\n        return `${pre}${this.k8sUtil.getName(item)}`;\n      }\n      return acc;\n    }, '');\n    if (messages) {\n      this.cacheNotifyInfo(messages);\n    }\n  }\n\n  private cacheNotifyInfo(values: string) {\n    this.addCacheLocalValue(NOTIFY_INFO_TYPE, values);\n  }\n\n  private dispatchNotify(data: Message) {\n    const notFixed = this.getCacheLocalValue(NOTIFY_NOT_FIXED);\n    const pass = !notFixed?.split(',')?.includes(this.k8sUtil.getName(data));\n    const push = this.getCacheLocalValue(NOTIFY_PUSH_TYPE);\n    if (\n      ((!data.spec.isResident && this.pushEnabled && push) ||\n        !this.expired(data)) &&\n      pass\n    ) {\n      this.triggerNotify$.next(data);\n    }\n  }\n\n  private expired(item: Message) {\n    const expiredTimestamp = item.spec.expiredTimestamp;\n    if (!expiredTimestamp) {\n      return true;\n    }\n    return new Date(expiredTimestamp).valueOf() < Date.now();\n  }\n\n  getCacheLocalValue(type: string): string {\n    const value = window.localStorage.getItem(type);\n    return value && JSON.parse(value)[this.userName];\n  }\n\n  addCacheLocalValue(type: string, value: string | boolean) {\n    const preValue = window.localStorage.getItem(type);\n    window.localStorage.setItem(\n      type,\n      JSON.stringify({\n        ...(preValue ? JSON.parse(preValue) : {}),\n        [this.userName]: value,\n      }),\n    );\n  }\n\n  private notifyMessage(data: Message) {\n    const { isResident, subject, content } = data.spec;\n    const name = this.k8sUtil.getName(data);\n    const type = this.getMessageType(data);\n\n    if (isResident) {\n      const notificationRef = this.notification.create({\n        type: type || Type.Info,\n        title: subject,\n        ...(type ? {} : { customClass: 'platform-class' }),\n        content,\n        ...(isResident ? { duration: 0 } : {}),\n      });\n      this.auiNotificationList.push(notificationRef);\n      Object.assign(notificationRef.instance, { data });\n      notificationRef.instance.afterClosed.subscribe(() => {\n        this.closedNotifyCallback(\n          data,\n          name,\n          get(notificationRef.instance, 'windowUnload', false),\n        );\n      });\n      return;\n    }\n    this.messages.create({\n      type: type || Type.Info,\n      content: subject,\n    });\n  }\n\n  /**\n   * 关闭通知: 手动关闭存储 添加不再展示状态记录\n   * 关闭页面、删除消息 不记录\n   */\n  private closedNotifyCallback(\n    data: Message,\n    name: string,\n    windowUnload: boolean,\n  ) {\n    this.removeNotificationList(name);\n    if (!this.windowUnload && !windowUnload) {\n      this.addNotFixed(data);\n    }\n    this.windowUnload = false;\n  }\n\n  /**\n   * 记录 不再展示状态 存储在 local storage\n   */\n  private addNotFixed(data: Message) {\n    if (data.spec.isResident) {\n      const notFixedVal = this.getCacheLocalValue(NOTIFY_NOT_FIXED);\n      const value = [\n        ...(notFixedVal?.split(',') || []),\n        this.k8sUtil.getName(data),\n      ];\n      this.addCacheLocalValue(NOTIFY_NOT_FIXED, value.join(','));\n    }\n    this.windowUnload = false;\n  }\n\n  /**\n   * 触发删除消息\n   * - 删除 local storage NOT_FIXED 存储的消息\n   * - 手动触发关闭常驻通知弹框\n   */\n  private removePush(item: WatchAPIResponse<Message>) {\n    const name = this.k8sUtil.getName(item.object);\n    const notFixedVal =\n      this.getCacheLocalValue(NOTIFY_NOT_FIXED)?.split(',') || [];\n    if (WatchEvent.Deleted === item.type) {\n      this.removeMessage(name);\n      this.manualCloseNotify(name);\n    }\n    if (\n      WatchEvent.Deleted === item.type &&\n      item.object.spec.isResident &&\n      !notFixedVal.includes(name)\n    ) {\n      this.manualCloseNotify(name);\n    }\n  }\n\n  private removeMessage(name: string) {\n    const cacheNotFixed =\n      this.getCacheLocalValue(NOTIFY_NOT_FIXED)?.split(',') || [];\n    if (cacheNotFixed.length > 0) {\n      const index = cacheNotFixed.indexOf(name);\n      if (index !== -1) {\n        cacheNotFixed.splice(index, 1);\n        this.addCacheLocalValue(NOTIFY_NOT_FIXED, cacheNotFixed.join(','));\n      }\n    }\n  }\n\n  private manualCloseNotify(name: string) {\n    const notifyInstance = this.auiNotificationList.find(\n      item => this.k8sUtil.getName(get(item.instance, 'data')) === name,\n    );\n    if (notifyInstance) {\n      this.windowUnload = true;\n      notifyInstance.instance.close();\n    }\n  }\n\n  private removeNotificationList(name: string) {\n    this.auiNotificationList = this.auiNotificationList.filter(\n      item => this.k8sUtil.getName(get(item.instance, 'data')) !== name,\n    );\n  }\n\n  private getMessageType(data: Message) {\n    const type = this.k8sUtil.getLabel(data, 'type') as MessageType;\n    return NOTIFY_TYPE_MAP[type] as Type;\n  }\n\n  private settingDefaultPushStatus() {\n    if (!window.localStorage.getItem(NOTIFY_PUSH_TYPE)) {\n      this.addCacheLocalValue(NOTIFY_PUSH_TYPE, true);\n    }\n  }\n\n  closeAllNotification() {\n    for (const notify of this.auiNotificationList) {\n      // 将 windowUnload 存储 instance 在 afterClosed 进行判断\n      // remove 异步 循环中 windowUnload 值已发生改变但还未触发 afterClosed 回调\n      Object.assign(notify.instance, { windowUnload: true });\n      notify.instance.close();\n    }\n    this.auiNotificationList = [];\n  }\n\n  destroy() {\n    // 重新加载 header 关闭所有通知，重新加载 header 重新弹出\n    this.closeAllNotification();\n    window.localStorage.removeItem(NOTIFY_INFO_TYPE);\n    this.onDestroy$.next();\n  }\n}\n"]}

package/esm2022/page-scaffold/page-header/header-notify/public-api.mjs

@@ -0,0 +1,10 @@
+/**
+ * [[include:header-notify/README.md]]
+ * @module header-notify
+ * @preferred
+ */
+/** imports */
+export * from './component/header-notify.component';
+export * from './component/notification-list/notification-list.component';
+export * from './header-notify.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9wYWdlLXNjYWZmb2xkL3BhZ2UtaGVhZGVyL2hlYWRlci1ub3RpZnkvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsY0FBYztBQUNkLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYywyREFBMkQsQ0FBQztBQUMxRSxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBbW2luY2x1ZGU6aGVhZGVyLW5vdGlmeS9SRUFETUUubWRdXVxuICogQG1vZHVsZSBoZWFkZXItbm90aWZ5XG4gKiBAcHJlZmVycmVkXG4gKi9cbi8qKiBpbXBvcnRzICovXG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudC9oZWFkZXItbm90aWZ5LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudC9ub3RpZmljYXRpb24tbGlzdC9ub3RpZmljYXRpb24tbGlzdC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9oZWFkZXItbm90aWZ5Lm1vZHVsZSc7XG4iXX0=

package/esm2022/page-scaffold/page-header/header-notify/utils.mjs

@@ -0,0 +1,44 @@
+export const NOTIFY_PREFIX = 'notify_';
+export const NOTIFY_PUSH_TYPE = `${NOTIFY_PREFIX}push`;
+export const NOTIFY_INFO_TYPE = `${NOTIFY_PREFIX}info`;
+export const NOTIFY_NOT_FIXED = `${NOTIFY_PREFIX}notFixed`;
+export function dateValueOf(value) {
+    return new Date(value).valueOf();
+}
+export const MESSAGE_CONFIG = {
+    apiGroup: 'ait.alauda.io',
+    apiVersion: 'v1alpha1',
+    type: 'messages',
+};
+export var MessageType;
+(function (MessageType) {
+    MessageType["WarningMessage"] = "WarningMessage";
+    MessageType["SystemMessage"] = "SystemMessage";
+    MessageType["ProductMessage"] = "ProductMessage";
+    MessageType["PlatformAnnouncement"] = "PlatformAnnouncement";
+})(MessageType || (MessageType = {}));
+export const MESSAGE_TYPE_MAP = {
+    [MessageType.WarningMessage]: {
+        type: 'error',
+        title: 'abnormal_message',
+    },
+    [MessageType.SystemMessage]: {
+        type: 'primary',
+        title: 'system_message',
+    },
+    [MessageType.ProductMessage]: {
+        type: 'success',
+        title: 'product_message',
+    },
+    [MessageType.PlatformAnnouncement]: {
+        color: '#00D7EA,#EEFCFD',
+        title: 'platform_announcement',
+    },
+};
+export const ALL_MESSAGE_TYPE = [
+    MessageType.WarningMessage,
+    MessageType.SystemMessage,
+    MessageType.ProductMessage,
+    MessageType.PlatformAnnouncement,
+];
+//# sourceMappingURL=data:application/json;base64,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