@quantabit/push-sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2142 @@
+'use strict';
+
+var sdkConfig = require('@quantabit/sdk-config');
+var React = require('react');
+
+/** 浏览器原生 Web Push (Notification API) */
+class WebPushAdapter {
+  constructor(config = {}) {
+    this.name = 'webpush';
+    this._cbs = {};
+    this.swPath = config.serviceWorkerPath || '/sw.js';
+  }
+  onMessage(cb) {
+    this._cbs.message = cb;
+  }
+  onConnect(cb) {
+    this._cbs.connect = cb;
+  }
+  onDisconnect(cb) {
+    this._cbs.disconnect = cb;
+  }
+  onError(cb) {
+    this._cbs.error = cb;
+  }
+  async connect() {
+    if (typeof window === 'undefined') return;
+    const perm = await Notification.requestPermission();
+    if (perm !== 'granted') {
+      this._cbs.error?.(new Error('Permission denied'));
+      return;
+    }
+    if ('serviceWorker' in navigator) {
+      try {
+        await navigator.serviceWorker.register(this.swPath);
+        navigator.serviceWorker.addEventListener('message', e => this._cbs.message?.(e.data));
+      } catch (e) {
+        this._cbs.error?.(e);
+      }
+    }
+    this._cbs.connect?.();
+  }
+  async disconnect() {
+    this._cbs.disconnect?.();
+  }
+  async subscribe(topic) {/* Web Push subscription via PushManager */}
+  async send(msg) {
+    if (typeof Notification !== 'undefined') new Notification(msg.title || 'Notification', {
+      body: msg.body || msg,
+      icon: msg.icon
+    });
+  }
+}
+
+/** WebSocket 自研推送 — 最常用于自建 IM */
+class WebSocketAdapter {
+  constructor(config = {}) {
+    this.name = 'websocket';
+    if (!config.url) throw new Error('[WebSocketAdapter] config.url is required');
+    this.url = config.url;
+    this.protocols = config.protocols;
+    this._ws = null;
+    this._cbs = {};
+    this._pingInterval = config.pingInterval || 30000;
+    this._pingTimer = null;
+  }
+  onMessage(cb) {
+    this._cbs.message = cb;
+  }
+  onConnect(cb) {
+    this._cbs.connect = cb;
+  }
+  onDisconnect(cb) {
+    this._cbs.disconnect = cb;
+  }
+  onError(cb) {
+    this._cbs.error = cb;
+  }
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this._ws = new WebSocket(this.url, this.protocols);
+      this._ws.onopen = () => {
+        this._cbs.connect?.();
+        this._startPing();
+        resolve();
+      };
+      this._ws.onmessage = e => {
+        try {
+          const d = JSON.parse(e.data);
+          if (d.type === 'pong') return;
+          this._cbs.message?.(d);
+        } catch {
+          this._cbs.message?.(e.data);
+        }
+      };
+      this._ws.onclose = () => {
+        this._stopPing();
+        this._cbs.disconnect?.();
+      };
+      this._ws.onerror = e => {
+        this._cbs.error?.(e);
+        reject(e);
+      };
+    });
+  }
+  async disconnect() {
+    this._stopPing();
+    this._ws?.close();
+  }
+  async subscribe(topic) {
+    this.send({
+      type: 'subscribe',
+      topic
+    });
+  }
+  async unsubscribe(topic) {
+    this.send({
+      type: 'unsubscribe',
+      topic
+    });
+  }
+  async send(msg) {
+    if (this._ws?.readyState === WebSocket.OPEN) this._ws.send(typeof msg === 'string' ? msg : JSON.stringify(msg));
+  }
+  _startPing() {
+    this._pingTimer = setInterval(() => this.send({
+      type: 'ping'
+    }), this._pingInterval);
+  }
+  _stopPing() {
+    clearInterval(this._pingTimer);
+  }
+}
+
+/** Server-Sent Events 推送 — 单向实时流 */
+class SSEAdapter {
+  constructor(config = {}) {
+    this.name = 'sse';
+    this.url = config.url || '/api/events';
+    this._source = null;
+    this._cbs = {};
+  }
+  onMessage(cb) {
+    this._cbs.message = cb;
+  }
+  onConnect(cb) {
+    this._cbs.connect = cb;
+  }
+  onDisconnect(cb) {
+    this._cbs.disconnect = cb;
+  }
+  onError(cb) {
+    this._cbs.error = cb;
+  }
+  async connect() {
+    this._source = new EventSource(this.url);
+    this._source.onopen = () => this._cbs.connect?.();
+    this._source.onmessage = e => {
+      try {
+        this._cbs.message?.(JSON.parse(e.data));
+      } catch {
+        this._cbs.message?.(e.data);
+      }
+    };
+    this._source.onerror = e => {
+      this._cbs.error?.(e);
+      if (this._source.readyState === EventSource.CLOSED) this._cbs.disconnect?.();
+    };
+  }
+  async disconnect() {
+    this._source?.close();
+    this._cbs.disconnect?.();
+  }
+  async subscribe(topic) {/* SSE 通过 URL 参数区分 topic */}
+}
+
+/** Firebase Cloud Messaging 适配器 */
+class FCMAdapter {
+  constructor(config = {}) {
+    this.name = 'fcm';
+    this.config = config;
+    this._cbs = {};
+  }
+  onMessage(cb) {
+    this._cbs.message = cb;
+  }
+  onConnect(cb) {
+    this._cbs.connect = cb;
+  }
+  onDisconnect(cb) {
+    this._cbs.disconnect = cb;
+  }
+  onError(cb) {
+    this._cbs.error = cb;
+  }
+  async connect() {
+    try {
+      // 需要用户自行引入 firebase/messaging
+      if (typeof window !== 'undefined' && window.firebase) {
+        const messaging = window.firebase.messaging();
+        const token = await messaging.getToken({
+          vapidKey: this.config.vapidKey
+        });
+        messaging.onMessage(payload => this._cbs.message?.(payload));
+        this._cbs.connect?.();
+        return token;
+      }
+      this._cbs.connect?.();
+    } catch (e) {
+      this._cbs.error?.(e);
+    }
+  }
+  async disconnect() {
+    this._cbs.disconnect?.();
+  }
+  async subscribe(topic) {/* FCM 通过服务端管理 topic */}
+}
+
+/** OneSignal 推送适配器 */
+class OneSignalAdapter {
+  constructor(config = {}) {
+    this.name = 'onesignal';
+    this.appId = config.appId;
+    this._cbs = {};
+  }
+  onMessage(cb) {
+    this._cbs.message = cb;
+  }
+  onConnect(cb) {
+    this._cbs.connect = cb;
+  }
+  onDisconnect(cb) {
+    this._cbs.disconnect = cb;
+  }
+  onError(cb) {
+    this._cbs.error = cb;
+  }
+  async connect() {
+    if (typeof window === 'undefined') return;
+    try {
+      // 加载 OneSignal SDK (如果未加载)
+      if (!window.OneSignal) {
+        const script = document.createElement('script');
+        script.src = 'https://cdn.onesignal.com/sdks/web/v16/OneSignalSDK.page.js';
+        script.async = true;
+        document.head.appendChild(script);
+        await new Promise(r => script.onload = r);
+      }
+      window.OneSignal = window.OneSignal || [];
+      window.OneSignal.push(() => {
+        window.OneSignal.init({
+          appId: this.appId
+        });
+        window.OneSignal.on('notificationDisplay', n => this._cbs.message?.(n));
+        this._cbs.connect?.();
+      });
+    } catch (e) {
+      this._cbs.error?.(e);
+    }
+  }
+  async disconnect() {
+    this._cbs.disconnect?.();
+  }
+  async subscribe() {
+    window.OneSignal?.push(() => window.OneSignal.showSliderPrompt());
+  }
+}
+
+/** 极光推送 JPush Web Push 适配器 */
+class JPushAdapter {
+  constructor(config = {}) {
+    this.name = 'jpush';
+    this.appKey = config.appKey || config.appId;
+    this._cbs = {};
+  }
+  onMessage(cb) {
+    this._cbs.message = cb;
+  }
+  onConnect(cb) {
+    this._cbs.connect = cb;
+  }
+  onDisconnect(cb) {
+    this._cbs.disconnect = cb;
+  }
+  onError(cb) {
+    this._cbs.error = cb;
+  }
+  async connect() {
+    if (typeof window === 'undefined') return;
+    try {
+      // 极光 Web Push SDK
+      if (window.JAnalyticsInterface) {
+        window.JAnalyticsInterface.init({
+          appkey: this.appKey
+        });
+      }
+      this._cbs.connect?.();
+    } catch (e) {
+      this._cbs.error?.(e);
+    }
+  }
+  async disconnect() {
+    this._cbs.disconnect?.();
+  }
+  async subscribe(alias) {/* JPush 通过 alias/tag 订阅 */}
+  async send(msg) {/* JPush 通过服务端 REST API 发送 */}
+}
+
+/** Mock 适配器 — 用于开发和测试，模拟推送消息 */
+class MockAdapter {
+  constructor(config = {}) {
+    this.name = 'mock';
+    this._cbs = {};
+    this._timer = null;
+    this.interval = config.mockInterval || 5000;
+  }
+  onMessage(cb) {
+    this._cbs.message = cb;
+  }
+  onConnect(cb) {
+    this._cbs.connect = cb;
+  }
+  onDisconnect(cb) {
+    this._cbs.disconnect = cb;
+  }
+  onError(cb) {
+    this._cbs.error = cb;
+  }
+  async connect() {
+    this._cbs.connect?.();
+    this._timer = setInterval(() => {
+      this._cbs.message?.({
+        id: Date.now(),
+        type: 'mock',
+        title: 'Test Notification',
+        body: 'This is a mock push message',
+        time: new Date().toISOString()
+      });
+    }, this.interval);
+  }
+  async disconnect() {
+    clearInterval(this._timer);
+    this._cbs.disconnect?.();
+  }
+  async subscribe() {}
+  async send(msg) {
+    setTimeout(() => this._cbs.message?.({
+      ...msg,
+      echo: true
+    }), 100);
+  }
+  // 手动触发消息 (测试用)
+  emit(msg) {
+    this._cbs.message?.(msg);
+  }
+}
+
+/**
+ * PushManager — 统一推送管理器 (隐私合规增强版)
+ * 适配器模式：所有推送服务共享同一接口，可随时切换
+ * 
+ * ⚠️ 推送权限请求和订阅需要 functional 级别隐私同意
+ * 连接和消息处理不受限制（属于 essential 功能）
+ */
+
+// 尝试导入 ConsentManager（可选依赖，不强制）
+let consentManager = null;
+try {
+  const sdkConfig = require('@quantabit/sdk-config');
+  consentManager = sdkConfig.consentManager;
+} catch {
+  // sdk-config 不可用时静默降级
+}
+const ADAPTERS = {
+  webpush: WebPushAdapter,
+  websocket: WebSocketAdapter,
+  sse: SSEAdapter,
+  fcm: FCMAdapter,
+  onesignal: OneSignalAdapter,
+  jpush: JPushAdapter,
+  mock: MockAdapter
+};
+class PushManager {
+  constructor(config = {}) {
+    this.config = config;
+    this.debug = config.debug || false;
+    this._listeners = new Map();
+    this._middleware = [];
+    this._connected = false;
+    this._messageQueue = [];
+    this._retryCount = 0;
+    this._maxRetries = config.maxRetries || 5;
+    this._retryDelay = config.retryDelay || 3000;
+    this._initAdapter(config);
+  }
+  _initAdapter(config) {
+    if (typeof config.adapter === 'string') {
+      const Cls = ADAPTERS[config.adapter];
+      if (!Cls) throw new Error(`[PushManager] 未知适配器: ${config.adapter}, 可选: ${Object.keys(ADAPTERS).join(', ')}`);
+      this._adapter = new Cls(config);
+    } else if (config.adapter && typeof config.adapter === 'object') {
+      this._adapter = config.adapter;
+    } else {
+      this._adapter = new MockAdapter(config);
+    }
+    this._adapter.onMessage?.(msg => this._handleMessage(msg));
+    this._adapter.onConnect?.(() => {
+      this._connected = true;
+      this._retryCount = 0;
+      this._emit('connect');
+      this._flushQueue();
+    });
+    this._adapter.onDisconnect?.(() => {
+      this._connected = false;
+      this._emit('disconnect');
+      this._autoReconnect();
+    });
+    this._adapter.onError?.(err => {
+      this._emit('error', err);
+    });
+  }
+  async connect() {
+    try {
+      await this._adapter.connect?.();
+      this._connected = true;
+    } catch (e) {
+      this._autoReconnect();
+    }
+    return this;
+  }
+  async disconnect() {
+    this._connected = false;
+    await this._adapter.disconnect?.();
+    this._emit('disconnect');
+    return this;
+  }
+  async subscribe(topic = 'default') {
+    await this._adapter.subscribe?.(topic);
+    this._emit('subscribe', topic);
+    return this;
+  }
+  async unsubscribe(topic = 'default') {
+    await this._adapter.unsubscribe?.(topic);
+    return this;
+  }
+  async send(message) {
+    if (!this._connected) {
+      this._messageQueue.push(message);
+      return this;
+    }
+    await this._adapter.send?.(message);
+    return this;
+  }
+  onMessage(cb) {
+    return this._on('message', cb);
+  }
+  onConnect(cb) {
+    return this._on('connect', cb);
+  }
+  onDisconnect(cb) {
+    return this._on('disconnect', cb);
+  }
+  onError(cb) {
+    return this._on('error', cb);
+  }
+  use(mw) {
+    this._middleware.push(mw);
+    return this;
+  }
+
+  /**
+   * 请求推送权限 — 需要 functional 隐私同意
+   * 如果用户未授予 functional 同意，返回 'consent_required'
+   */
+  async requestPermission() {
+    // 隐私同意检查：推送权限需要 functional 级别同意
+    if (consentManager && !consentManager.hasConsent('functional')) {
+      if (this.debug) console.log('[PushManager] 推送权限请求被阻止（需要 functional 隐私同意）');
+      return 'consent_required';
+    }
+    if (typeof Notification !== 'undefined') return await Notification.requestPermission();
+    return 'unsupported';
+  }
+  getPermissionStatus() {
+    if (consentManager && !consentManager.hasConsent('functional')) return 'consent_required';
+    return typeof Notification !== 'undefined' ? Notification.permission : 'unsupported';
+  }
+  get isConnected() {
+    return this._connected;
+  }
+  get adapterName() {
+    return this._adapter?.name || 'unknown';
+  }
+  _handleMessage(raw) {
+    let msg = raw;
+    for (const mw of this._middleware) {
+      msg = mw(msg);
+      if (!msg) return;
+    }
+    this._emit('message', msg);
+  }
+  _flushQueue() {
+    while (this._messageQueue.length) this.send(this._messageQueue.shift());
+  }
+  _autoReconnect() {
+    if (this._retryCount >= this._maxRetries) {
+      this._emit('error', new Error('Max retries'));
+      return;
+    }
+    this._retryCount++;
+    setTimeout(() => this.connect(), this._retryDelay * Math.pow(1.5, this._retryCount - 1));
+  }
+  _on(ev, cb) {
+    if (!this._listeners.has(ev)) this._listeners.set(ev, []);
+    this._listeners.get(ev).push(cb);
+    return () => {
+      const a = this._listeners.get(ev);
+      a?.splice(a.indexOf(cb), 1);
+    };
+  }
+  _emit(ev, data) {
+    this._listeners.get(ev)?.forEach(fn => {
+      try {
+        fn(data);
+      } catch (e) {}
+    });
+  }
+}
+
+/**
+ * Push SDK - API 客户端
+ * 推送通知系统后端接口封装
+ * 
+ * 使用 BaseApiClient 基类简化代码
+ */
+
+
+/**
+ * 推送 API 客户端
+ */
+class PushApiClient extends sdkConfig.BaseApiClient {
+  constructor(config = {}) {
+    super('/push', config);
+  }
+
+  // ============ 设备管理 ============
+
+  /**
+   * 注册设备
+   * @param {Object} deviceInfo - 设备信息
+   */
+  async registerDevice(deviceInfo) {
+    return this.post('/devices', deviceInfo);
+  }
+
+  /**
+   * 更新设备 Token
+   * @param {string} deviceId - 设备 ID
+   * @param {string} token - 推送 Token
+   */
+  async updateDeviceToken(deviceId, token) {
+    return this.put(`/devices/${deviceId}/token`, {
+      token
+    });
+  }
+
+  /**
+   * 获取已注册设备
+   */
+  async getMyDevices() {
+    return this.get('/devices/my');
+  }
+
+  /**
+   * 注销设备
+   * @param {string} deviceId - 设备 ID
+   */
+  async unregisterDevice(deviceId) {
+    return this.delete(`/devices/${deviceId}`);
+  }
+
+  // ============ 推送设置 ============
+
+  /**
+   * 获取推送偏好
+   */
+  async getPreferences() {
+    return this.get('/preferences');
+  }
+
+  /**
+   * 更新推送偏好
+   * @param {Object} preferences - 偏好设置
+   */
+  async updatePreferences(preferences) {
+    return this.put('/preferences', preferences);
+  }
+
+  /**
+   * 获取免打扰设置
+   */
+  async getQuietHours() {
+    return this.get('/quiet-hours');
+  }
+
+  /**
+   * 设置免打扰时段
+   * @param {Object} settings - 免打扰设置
+   */
+  async setQuietHours(settings) {
+    return this.put('/quiet-hours', settings);
+  }
+
+  // ============ 推送话题 ============
+
+  /**
+   * 订阅话题
+   * @param {string} topic - 话题名称
+   */
+  async subscribeTopic(topic) {
+    return this.post(`/topics/${topic}/subscribe`);
+  }
+
+  /**
+   * 取消订阅话题
+   * @param {string} topic - 话题名称
+   */
+  async unsubscribeTopic(topic) {
+    return this.post(`/topics/${topic}/unsubscribe`);
+  }
+
+  /**
+   * 获取已订阅话题
+   */
+  async getSubscribedTopics() {
+    return this.get('/topics/subscribed');
+  }
+
+  /**
+   * 获取可用话题
+   */
+  async getAvailableTopics() {
+    return this.get('/topics');
+  }
+
+  // ============ 推送历史 ============
+
+  /**
+   * 获取推送历史
+   * @param {Object} params - 查询参数
+   */
+  async getHistory(params = {}) {
+    return this.get('/history', params);
+  }
+
+  /**
+   * 标记已读
+   * @param {string} pushId - 推送 ID
+   */
+  async markAsRead(pushId) {
+    return this.post(`/history/${pushId}/read`);
+  }
+
+  /**
+   * 批量标记已读
+   * @param {string[]} pushIds - 推送 ID 列表
+   */
+  async batchMarkAsRead(pushIds) {
+    return this.post('/history/batch-read', {
+      push_ids: pushIds
+    });
+  }
+
+  // ============ 管理员操作 ============
+
+  /**
+   * 发送推送（管理员）
+   * @param {Object} data - 推送数据
+   */
+  async send(data) {
+    return this.post('/send', data);
+  }
+
+  /**
+   * 发送给指定用户（管理员）
+   * @param {string[]} userIds - 用户 ID 列表
+   * @param {Object} message - 消息内容
+   */
+  async sendToUsers(userIds, message) {
+    return this.post('/send/users', {
+      user_ids: userIds,
+      ...message
+    });
+  }
+
+  /**
+   * 发送给话题订阅者（管理员）
+   * @param {string} topic - 话题
+   * @param {Object} message - 消息内容
+   */
+  async sendToTopic(topic, message) {
+    return this.post('/send/topic', {
+      topic,
+      ...message
+    });
+  }
+
+  /**
+   * 全量推送（管理员）
+   * @param {Object} message - 消息内容
+   */
+  async broadcast(message) {
+    return this.post('/send/broadcast', message);
+  }
+
+  /**
+   * 定时推送（管理员）
+   * @param {Object} data - 推送数据
+   * @param {string} scheduleAt - 发送时间
+   */
+  async schedule(data, scheduleAt) {
+    return this.post('/schedule', {
+      ...data,
+      schedule_at: scheduleAt
+    });
+  }
+
+  /**
+   * 取消定时推送（管理员）
+   * @param {string} scheduleId - 定时任务 ID
+   */
+  async cancelSchedule(scheduleId) {
+    return this.delete(`/schedule/${scheduleId}`);
+  }
+
+  // ============ 统计 ============
+
+  /**
+   * 获取推送统计（管理员）
+   * @param {Object} params - 统计参数
+   */
+  async getStats(params = {}) {
+    return this.get('/stats', params);
+  }
+
+  /**
+   * 获取送达率统计（管理员）
+   * @param {Object} params - 统计参数
+   */
+  async getDeliveryStats(params = {}) {
+    return this.get('/stats/delivery', params);
+  }
+
+  // ============ 隐私合规 ============
+
+  /**
+   * 清除所有推送数据 — GDPR 第17条
+   * 注销所有设备 + 清除订阅 + 清除历史
+   */
+  async clearAllUserData() {
+    const results = {};
+    try {
+      const devices = await this.getMyDevices();
+      for (const d of devices?.data || []) {
+        await this.unregisterDevice(d.id).catch(() => {});
+      }
+      results.devices = 'cleared';
+    } catch (e) {
+      results.deviceError = e.message;
+    }
+    try {
+      const topics = await this.getSubscribedTopics();
+      for (const t of topics?.data || []) {
+        await this.unsubscribeTopic(t.topic || t.name).catch(() => {});
+      }
+      results.topics = 'cleared';
+    } catch (e) {
+      results.topicError = e.message;
+    }
+    return {
+      cleared: true,
+      timestamp: new Date().toISOString(),
+      ...results
+    };
+  }
+
+  /**
+   * 导出推送数据 — GDPR 第20条
+   */
+  async exportPushData() {
+    try {
+      const [prefs, topics, history] = await Promise.allSettled([this.getPreferences(), this.getSubscribedTopics(), this.getHistory({
+        page_size: 50
+      })]);
+      return {
+        exportDate: new Date().toISOString(),
+        format: 'QBit Push Export (GDPR Art. 20)',
+        preferences: prefs.status === 'fulfilled' ? prefs.value?.data : null,
+        subscribedTopics: topics.status === 'fulfilled' ? topics.value?.data : [],
+        recentHistory: history.status === 'fulfilled' ? history.value?.data?.items : []
+      };
+    } catch (e) {
+      return {
+        error: e.message,
+        exportDate: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * 获取隐私数据声明
+   */
+  getDataDisclosure() {
+    return {
+      sdk: '@quantabit/push-sdk',
+      privacyLevel: 'functional',
+      consentRequired: true,
+      collected: [{
+        type: 'device_token',
+        description: 'Push notification token (APNs/FCM)',
+        retention: 'Until unregistered',
+        encrypted: true
+      }, {
+        type: 'device_info',
+        description: 'OS, version, app version',
+        retention: 'Until unregistered'
+      }, {
+        type: 'push_preferences',
+        description: 'Notification preferences and quiet hours',
+        retention: 'Until account deletion'
+      }, {
+        type: 'push_history',
+        description: 'Delivered notification records',
+        retention: '30 days'
+      }, {
+        type: 'topic_subscriptions',
+        description: 'Push topic subscriptions',
+        retention: 'Until unsubscribed'
+      }],
+      gdprCapabilities: ['delete', 'export'],
+      note: 'Push notifications require explicit user consent (device permission). Users can revoke at OS level.'
+    };
+  }
+}
+
+// 创建默认实例
+const pushApi = new PushApiClient();
+
+/**
+ * Push SDK - 类型定义
+ */
+
+// 推送渠道
+const PushChannel = {
+  WEB_PUSH: 'web_push',
+  FCM: 'fcm',
+  // Firebase Cloud Messaging
+  APNS: 'apns',
+  // Apple Push Notification
+  EMAIL: 'email',
+  SMS: 'sms',
+  WECHAT: 'wechat',
+  IN_APP: 'in_app'
+};
+
+// 推送状态
+const PushStatus = {
+  PENDING: 'pending',
+  SENT: 'sent',
+  DELIVERED: 'delivered',
+  FAILED: 'failed',
+  CLICKED: 'clicked',
+  DISMISSED: 'dismissed'
+};
+
+// 推送优先级
+const PushPriority = {
+  LOW: 'low',
+  NORMAL: 'normal',
+  HIGH: 'high'
+};
+
+// 订阅状态
+const SubscriptionStatus = {
+  ACTIVE: 'active',
+  EXPIRED: 'expired',
+  UNSUBSCRIBED: 'unsubscribed',
+  DENIED: 'denied'
+};
+
+// 权限状态
+const PermissionStatus = {
+  GRANTED: 'granted',
+  DENIED: 'denied',
+  DEFAULT: 'default',
+  PROMPT: 'prompt'
+};
+const NotificationStatus = PushStatus;
+const NotificationType = {
+  SYSTEM: 'system',
+  ANNOUNCEMENT: 'announcement',
+  TRANSACTION: 'transaction',
+  ACTIVITY: 'activity',
+  REMINDER: 'reminder',
+  MARKETING: 'marketing'
+};
+const NotificationChannel = PushChannel;
+
+/**
+ * Push SDK - Web Push 客户端
+ * 使用 BaseApiClient 基类，继承统一的配置、Token 管理和错误处理
+ */
+
+
+/**
+ * Web Push 客户端
+ */
+class WebPushClientClass extends sdkConfig.BaseApiClient {
+  constructor(config = {}) {
+    super('/push', config);
+    this.vapidPublicKey = config.vapidPublicKey || '';
+    this.onMessage = config.onMessage;
+    this.subscription = null;
+    this.registration = null;
+    this.permission = PermissionStatus.DEFAULT;
+  }
+
+  /**
+   * 初始化
+   */
+  async init(config = {}) {
+    if (config.vapidPublicKey) this.vapidPublicKey = config.vapidPublicKey;
+    if (!this.isSupported()) {
+      console.warn('Web Push is not supported');
+      return false;
+    }
+
+    // 检查权限状态
+    this.permission = Notification.permission;
+
+    // 注册 Service Worker
+    try {
+      this.registration = await navigator.serviceWorker.register('/sw.js');
+      console.log('Service Worker registered');
+    } catch (err) {
+      console.error('Service Worker registration failed:', err);
+      return false;
+    }
+
+    // 检查现有订阅
+    this.subscription = await this.registration.pushManager.getSubscription();
+
+    // 监听消息
+    this.setupMessageListener();
+    return true;
+  }
+
+  /**
+   * 检查是否支持 Web Push
+   */
+  isSupported() {
+    return typeof window !== 'undefined' && 'serviceWorker' in navigator && 'PushManager' in window && 'Notification' in window;
+  }
+
+  /**
+   * 请求权限
+   */
+  async requestPermission() {
+    if (!this.isSupported()) {
+      return PermissionStatus.DENIED;
+    }
+    try {
+      const permission = await Notification.requestPermission();
+      this.permission = permission;
+      if (permission === 'granted') {
+        await this.subscribe();
+      }
+      return permission;
+    } catch (err) {
+      console.error('Permission request failed:', err);
+      this.onError?.(err);
+      return PermissionStatus.DENIED;
+    }
+  }
+
+  /**
+   * 订阅推送
+   */
+  async subscribe() {
+    if (!this.registration) {
+      await this.init();
+    }
+    if (!this.vapidPublicKey) {
+      throw new Error('VAPID public key not configured');
+    }
+    try {
+      this.subscription = await this.registration.pushManager.subscribe({
+        userVisibleOnly: true,
+        applicationServerKey: this.urlBase64ToUint8Array(this.vapidPublicKey)
+      });
+
+      // 将订阅信息发送到服务器
+      await this.saveSubscription(this.subscription);
+      console.log('Push subscription successful');
+      return this.subscription;
+    } catch (err) {
+      console.error('Push subscription failed:', err);
+      this.onError?.(err);
+      throw err;
+    }
+  }
+
+  /**
+   * 取消订阅
+   */
+  async unsubscribe() {
+    if (!this.subscription) {
+      return;
+    }
+    try {
+      await this.subscription.unsubscribe();
+      await this.removeSubscription();
+      this.subscription = null;
+      console.log('Push unsubscribed');
+    } catch (err) {
+      console.error('Unsubscribe failed:', err);
+      this.onError?.(err);
+    }
+  }
+
+  /**
+   * 保存订阅到服务器
+   */
+  async saveSubscription(subscription) {
+    return this.post('/subscriptions', {
+      subscription: subscription.toJSON(),
+      channel: 'web_push'
+    });
+  }
+
+  /**
+   * 从服务器移除订阅
+   */
+  async removeSubscription() {
+    return this.delete('/subscriptions/current');
+  }
+
+  /**
+   * 监听消息
+   */
+  setupMessageListener() {
+    if (!('serviceWorker' in navigator)) return;
+    navigator.serviceWorker.addEventListener('message', event => {
+      if (event.data && event.data.type === 'PUSH_RECEIVED') {
+        this.onMessage?.(event.data.payload);
+      }
+    });
+  }
+
+  /**
+   * 获取订阅状态
+   */
+  getSubscriptionStatus() {
+    if (!this.isSupported()) {
+      return SubscriptionStatus.DENIED;
+    }
+    if (this.permission === 'denied') {
+      return SubscriptionStatus.DENIED;
+    }
+    if (this.subscription) {
+      return SubscriptionStatus.ACTIVE;
+    }
+    return SubscriptionStatus.UNSUBSCRIBED;
+  }
+
+  /**
+   * 获取权限状态
+   */
+  getPermissionStatus() {
+    if (!this.isSupported()) {
+      return PermissionStatus.DENIED;
+    }
+    return Notification.permission;
+  }
+
+  /**
+   * 显示本地通知
+   */
+  async showNotification(title, options = {}) {
+    if (this.permission !== 'granted') {
+      return;
+    }
+    if (this.registration) {
+      return this.registration.showNotification(title, {
+        icon: options.icon || '/icon-192.png',
+        badge: options.badge || '/badge-72.png',
+        ...options
+      });
+    }
+
+    // 降级到 Notification API
+    return new Notification(title, options);
+  }
+
+  /**
+   * Base64 转 Uint8Array
+   */
+  urlBase64ToUint8Array(base64String) {
+    const padding = '='.repeat((4 - base64String.length % 4) % 4);
+    const base64 = (base64String + padding).replace(/-/g, '+').replace(/_/g, '/');
+    const rawData = atob(base64);
+    const outputArray = new Uint8Array(rawData.length);
+    for (let i = 0; i < rawData.length; ++i) {
+      outputArray[i] = rawData.charCodeAt(i);
+    }
+    return outputArray;
+  }
+}
+const webPushClient = new WebPushClientClass();
+const WebPushClient = WebPushClientClass;
+
+/**
+ * Push SDK - 国际化
+ * 消息推送多语言支持
+ */
+
+const SUPPORTED_LANGUAGES = ['en', 'zh', 'ja', 'ko'];
+const messages = {
+  zh: {
+    // 推送
+    push: '推送',
+    notification: '通知',
+    notifications: '通知',
+    pushNotification: '推送通知',
+    // 类型
+    type: '类型',
+    system: '系统通知',
+    marketing: '营销推送',
+    transactional: '交易通知',
+    social: '社交通知',
+    reminder: '提醒',
+    alert: '警报',
+    // 渠道
+    channel: '渠道',
+    webPush: 'Web推送',
+    appPush: 'App推送',
+    email: '邮件',
+    sms: '短信',
+    inApp: '站内信',
+    // 状态
+    status: '状态',
+    pending: '待发送',
+    sent: '已发送',
+    delivered: '已送达',
+    read: '已读',
+    clicked: '已点击',
+    failed: '发送失败',
+    // 权限
+    permission: '权限',
+    granted: '已授权',
+    denied: '已拒绝',
+    default: '未设置',
+    requestPermission: '开启通知权限',
+    permissionRequired: '需要通知权限',
+    // 设置
+    settings: '设置',
+    enabled: '已开启',
+    disabled: '已关闭',
+    enablePush: '开启推送',
+    disablePush: '关闭推送',
+    // 偏好
+    preferences: '偏好设置',
+    muteAll: '全部静音',
+    muteDuration: '静音时长',
+    quietHours: '免打扰时段',
+    // 频率
+    frequency: '频率',
+    realtime: '实时',
+    daily: '每日摘要',
+    weekly: '每周摘要',
+    // 操作
+    send: '发送',
+    schedule: '定时发送',
+    cancel: '取消',
+    resend: '重试',
+    markAsRead: '标记已读',
+    markAllRead: '全部已读',
+    delete: '删除',
+    clear: '清空',
+    // 时间
+    now: '刚刚',
+    minutesAgo: '{n}分钟前',
+    hoursAgo: '{n}小时前',
+    yesterday: '昨天',
+    daysAgo: '{n}天前',
+    // 状态
+    loading: '加载中...',
+    noNotifications: '暂无通知',
+    error: '加载失败',
+    // 标题
+    unread: '未读',
+    all: '全部',
+    newNotification: '新通知'
+  },
+  en: {
+    push: 'Push',
+    notification: 'Notification',
+    notifications: 'Notifications',
+    pushNotification: 'Push Notification',
+    type: 'Type',
+    system: 'System',
+    marketing: 'Marketing',
+    transactional: 'Transactional',
+    social: 'Social',
+    reminder: 'Reminder',
+    alert: 'Alert',
+    channel: 'Channel',
+    webPush: 'Web Push',
+    appPush: 'App Push',
+    email: 'Email',
+    sms: 'SMS',
+    inApp: 'In-App',
+    status: 'Status',
+    pending: 'Pending',
+    sent: 'Sent',
+    delivered: 'Delivered',
+    read: 'Read',
+    clicked: 'Clicked',
+    failed: 'Failed',
+    permission: 'Permission',
+    granted: 'Granted',
+    denied: 'Denied',
+    default: 'Default',
+    requestPermission: 'Enable Notifications',
+    permissionRequired: 'Permission Required',
+    settings: 'Settings',
+    enabled: 'Enabled',
+    disabled: 'Disabled',
+    enablePush: 'Enable Push',
+    disablePush: 'Disable Push',
+    preferences: 'Preferences',
+    muteAll: 'Mute All',
+    muteDuration: 'Mute Duration',
+    quietHours: 'Quiet Hours',
+    frequency: 'Frequency',
+    realtime: 'Realtime',
+    daily: 'Daily Digest',
+    weekly: 'Weekly Digest',
+    send: 'Send',
+    schedule: 'Schedule',
+    cancel: 'Cancel',
+    resend: 'Resend',
+    markAsRead: 'Mark as Read',
+    markAllRead: 'Mark All Read',
+    delete: 'Delete',
+    clear: 'Clear',
+    now: 'Just now',
+    minutesAgo: '{n}m ago',
+    hoursAgo: '{n}h ago',
+    yesterday: 'Yesterday',
+    daysAgo: '{n}d ago',
+    loading: 'Loading...',
+    noNotifications: 'No Notifications',
+    error: 'Error',
+    unread: 'Unread',
+    all: 'All',
+    newNotification: 'New Notification'
+  },
+  ja: {
+    push: 'プッシュ',
+    notification: '通知',
+    notifications: '通知',
+    pushNotification: 'プッシュ通知',
+    type: 'タイプ',
+    system: 'システム',
+    marketing: 'マーケティング',
+    transactional: '取引',
+    social: 'ソーシャル',
+    reminder: 'リマインダー',
+    alert: 'アラート',
+    channel: 'チャネル',
+    webPush: 'Webプッシュ',
+    appPush: 'アプリプッシュ',
+    email: 'メール',
+    sms: 'SMS',
+    inApp: 'アプリ内',
+    status: 'ステータス',
+    pending: '待機中',
+    sent: '送信済み',
+    delivered: '配信済み',
+    read: '既読',
+    clicked: 'クリック済み',
+    failed: '失敗',
+    permission: '権限',
+    granted: '許可済み',
+    denied: '拒否',
+    default: '未設定',
+    requestPermission: '通知を許可',
+    permissionRequired: '権限が必要です',
+    settings: '設定',
+    enabled: 'オン',
+    disabled: 'オフ',
+    enablePush: 'プッシュを有効化',
+    disablePush: 'プッシュを無効化',
+    preferences: '通知設定',
+    muteAll: 'すべてミュート',
+    muteDuration: 'ミュート期間',
+    quietHours: 'おやすみ時間',
+    frequency: '頻度',
+    realtime: 'リアルタイム',
+    daily: '日次まとめ',
+    weekly: '週次まとめ',
+    send: '送信',
+    schedule: '予約送信',
+    cancel: 'キャンセル',
+    resend: '再送信',
+    markAsRead: '既読にする',
+    markAllRead: 'すべて既読',
+    delete: '削除',
+    clear: 'クリア',
+    now: 'たった今',
+    minutesAgo: '{n}分前',
+    hoursAgo: '{n}時間前',
+    yesterday: '昨日',
+    daysAgo: '{n}日前',
+    loading: '読み込み中...',
+    noNotifications: '通知はありません',
+    error: 'エラー',
+    unread: '未読',
+    all: 'すべて',
+    newNotification: '新しい通知'
+  },
+  ko: {
+    push: '푸시',
+    notification: '알림',
+    notifications: '알림',
+    pushNotification: '푸시 알림',
+    type: '유형',
+    system: '시스템',
+    marketing: '마케팅',
+    transactional: '거래',
+    social: '소셜',
+    reminder: '리마인더',
+    alert: '경고',
+    channel: '채널',
+    webPush: '웹 푸시',
+    appPush: '앱 푸시',
+    email: '이메일',
+    sms: 'SMS',
+    inApp: '인앱',
+    status: '상태',
+    pending: '대기 중',
+    sent: '전송됨',
+    delivered: '전달됨',
+    read: '읽음',
+    clicked: '클릭됨',
+    failed: '실패',
+    permission: '권한',
+    granted: '허용됨',
+    denied: '거부됨',
+    default: '미설정',
+    requestPermission: '알림 허용',
+    permissionRequired: '권한이 필요합니다',
+    settings: '설정',
+    enabled: '사용',
+    disabled: '사용 안 함',
+    enablePush: '푸시 사용',
+    disablePush: '푸시 사용 안 함',
+    preferences: '알림 설정',
+    muteAll: '모두 음소거',
+    muteDuration: '음소거 기간',
+    quietHours: '방해 금지 시간',
+    frequency: '빈도',
+    realtime: '실시간',
+    daily: '일일 다이제스트',
+    weekly: '주간 다이제스트',
+    send: '보내기',
+    schedule: '예약',
+    cancel: '취소',
+    resend: '재전송',
+    markAsRead: '읽음으로 표시',
+    markAllRead: '모두 읽음',
+    delete: '삭제',
+    clear: '비우기',
+    now: '방금',
+    minutesAgo: '{n}분 전',
+    hoursAgo: '{n}시간 전',
+    yesterday: '어제',
+    daysAgo: '{n}일 전',
+    loading: '로딩 중...',
+    noNotifications: '알림 없음',
+    error: '오류',
+    unread: '읽지 않음',
+    all: '전체',
+    newNotification: '새 알림'
+  }
+};
+let currentLanguage = 'zh';
+function setLanguage(lang) {
+  if (SUPPORTED_LANGUAGES.includes(lang)) currentLanguage = lang;
+}
+function getLanguage() {
+  return currentLanguage;
+}
+function t(key, params = {}) {
+  let text = (messages[currentLanguage] || messages.en)[key] || key;
+  Object.keys(params).forEach(k => {
+    text = text.replace(new RegExp(`\\{${k}\\}`, 'g'), params[k]);
+  });
+  return text;
+}
+
+function usePush(config = {}) {
+  const mgr = React.useRef(null);
+  const [connected, setConnected] = React.useState(false);
+  const [messages, setMessages] = React.useState([]);
+  const [lastMessage, setLastMessage] = React.useState(null);
+  const [permission, setPermission] = React.useState('default');
+  React.useEffect(() => {
+    mgr.current = new PushManager(config);
+    mgr.current.onConnect(() => setConnected(true));
+    mgr.current.onDisconnect(() => setConnected(false));
+    mgr.current.onMessage(msg => {
+      setLastMessage(msg);
+      setMessages(prev => [msg, ...prev].slice(0, 100));
+    });
+    mgr.current.connect();
+    setPermission(mgr.current.getPermissionStatus());
+    return () => mgr.current?.disconnect();
+  }, []);
+  const send = React.useCallback(msg => mgr.current?.send(msg), []);
+  const subscribe = React.useCallback(topic => mgr.current?.subscribe(topic), []);
+  const requestPermission = React.useCallback(async () => {
+    const p = await mgr.current?.requestPermission();
+    setPermission(p);
+    return p;
+  }, []);
+  const clearMessages = React.useCallback(() => setMessages([]), []);
+  return {
+    connected,
+    messages,
+    lastMessage,
+    send,
+    subscribe,
+    requestPermission,
+    permission,
+    clearMessages,
+    manager: mgr.current
+  };
+}
+function usePushPermission() {
+  const supported = typeof window !== 'undefined' && 'Notification' in window;
+  const [permission, setPermission] = React.useState(supported ? window.Notification.permission : 'denied');
+  const requestPermission = React.useCallback(async () => {
+    if (!supported) return 'denied';
+    const result = await window.Notification.requestPermission();
+    setPermission(result);
+    return result;
+  }, [supported]);
+  return {
+    supported,
+    permission,
+    requestPermission
+  };
+}
+function useNotifications(options = {}) {
+  const [notifications, setNotifications] = React.useState([]);
+  const [unreadCount, setUnreadCount] = React.useState(0);
+  const [loading, setLoading] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const refresh = React.useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const [historyResult, statsResult] = await Promise.allSettled([pushApi.getHistory(options), pushApi.getStats({
+        scope: 'unread'
+      })]);
+      const history = historyResult.status === 'fulfilled' ? historyResult.value?.data?.items || historyResult.value?.data || [] : [];
+      setNotifications(Array.isArray(history) ? history : []);
+      if (statsResult.status === 'fulfilled') {
+        setUnreadCount(statsResult.value?.data?.unread_count || statsResult.value?.data?.unread || 0);
+      }
+      return historyResult.status === 'fulfilled' ? historyResult.value : null;
+    } catch (err) {
+      setError(err.message);
+      return null;
+    } finally {
+      setLoading(false);
+    }
+  }, [options.filter, options.limit, options.page]);
+  React.useEffect(() => {
+    refresh();
+  }, [refresh]);
+  const markAsRead = React.useCallback(async pushId => {
+    const result = await pushApi.markAsRead(pushId);
+    await refresh();
+    return result;
+  }, [refresh]);
+  const markAllAsRead = React.useCallback(async () => {
+    const ids = notifications.map(item => item.id).filter(Boolean);
+    if (ids.length === 0) return null;
+    const result = await pushApi.batchMarkAsRead(ids);
+    await refresh();
+    return result;
+  }, [notifications, refresh]);
+  const deleteNotification = React.useCallback(async () => {
+    // Push history deletion is not exposed yet; keep the hook API stable.
+    await refresh();
+    return null;
+  }, [refresh]);
+  const clearAll = React.useCallback(() => {
+    setNotifications([]);
+    setUnreadCount(0);
+  }, []);
+  return {
+    notifications,
+    unreadCount,
+    loading,
+    error,
+    refresh,
+    markAsRead,
+    markAllAsRead,
+    deleteNotification,
+    clearAll
+  };
+}
+function useRealtimeNotifications(config = {}) {
+  return usePush(config);
+}
+function useNotificationPreferences() {
+  const [preferences, setPreferences] = React.useState({});
+  const [loading, setLoading] = React.useState(false);
+  const [saving, setSaving] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const refresh = React.useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await pushApi.getPreferences();
+      setPreferences(result.data || {});
+      return result;
+    } catch (err) {
+      setError(err.message);
+      return null;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  React.useEffect(() => {
+    refresh();
+  }, [refresh]);
+  const updatePreferences = React.useCallback(async nextPreferences => {
+    setSaving(true);
+    try {
+      const result = await pushApi.updatePreferences(nextPreferences);
+      setPreferences(nextPreferences);
+      return result;
+    } finally {
+      setSaving(false);
+    }
+  }, []);
+  const toggleChannel = React.useCallback(channel => {
+    const next = {
+      ...preferences,
+      channels: {
+        ...(preferences.channels || {}),
+        [channel]: !preferences.channels?.[channel]
+      }
+    };
+    return updatePreferences(next);
+  }, [preferences, updatePreferences]);
+  const toggleType = React.useCallback(type => {
+    const next = {
+      ...preferences,
+      types: {
+        ...(preferences.types || {}),
+        [type]: !preferences.types?.[type]
+      }
+    };
+    return updatePreferences(next);
+  }, [preferences, updatePreferences]);
+  return {
+    preferences,
+    loading,
+    saving,
+    error,
+    refresh,
+    updatePreferences,
+    toggleChannel,
+    toggleType
+  };
+}
+function usePushSubscription() {
+  const [topics, setTopics] = React.useState([]);
+  const refresh = React.useCallback(async () => {
+    const result = await pushApi.getSubscribedTopics();
+    setTopics(result.data || []);
+    return result;
+  }, []);
+  React.useEffect(() => {
+    refresh();
+  }, [refresh]);
+  const subscribe = React.useCallback(async topic => {
+    const result = await pushApi.subscribeTopic(topic);
+    await refresh();
+    return result;
+  }, [refresh]);
+  const unsubscribe = React.useCallback(async topic => {
+    const result = await pushApi.unsubscribeTopic(topic);
+    await refresh();
+    return result;
+  }, [refresh]);
+  return {
+    topics,
+    refresh,
+    subscribe,
+    unsubscribe
+  };
+}
+function useSendNotification() {
+  const [loading, setLoading] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const send = React.useCallback(async message => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await pushApi.send(message);
+    } catch (err) {
+      setError(err.message);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const schedule = React.useCallback(async (message, scheduleAt) => {
+    setLoading(true);
+    setError(null);
+    try {
+      return await pushApi.schedule(message, scheduleAt);
+    } catch (err) {
+      setError(err.message);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  return {
+    send,
+    schedule,
+    loading,
+    error
+  };
+}
+
+const PushContext = /*#__PURE__*/React.createContext(null);
+function PushProvider({
+  config = {},
+  children
+}) {
+  const push = usePush(config);
+  return /*#__PURE__*/React.createElement(PushContext.Provider, {
+    value: push
+  }, children);
+}
+
+function PushPermissionBanner({
+  onAllow,
+  onDismiss,
+  title = 'Enable Notifications',
+  message = 'Stay updated with real-time push notifications',
+  className = ''
+}) {
+  return /*#__PURE__*/React.createElement("div", {
+    className: `qps-banner ${className}`,
+    style: {
+      display: 'flex',
+      alignItems: 'center',
+      gap: 12,
+      padding: '12px 16px',
+      background: 'linear-gradient(135deg,#eff6ff,#eef2ff)',
+      borderRadius: 12,
+      border: '1px solid #bfdbfe'
+    }
+  }, /*#__PURE__*/React.createElement("svg", {
+    width: "24",
+    height: "24",
+    viewBox: "0 0 24 24",
+    fill: "none",
+    stroke: "#3b82f6",
+    strokeWidth: "2"
+  }, /*#__PURE__*/React.createElement("path", {
+    d: "M18 8A6 6 0 006 8c0 7-3 9-3 9h18s-3-2-3-9"
+  }), /*#__PURE__*/React.createElement("path", {
+    d: "M13.73 21a2 2 0 01-3.46 0"
+  })), /*#__PURE__*/React.createElement("div", {
+    style: {
+      flex: 1
+    }
+  }, /*#__PURE__*/React.createElement("div", {
+    style: {
+      fontSize: 14,
+      fontWeight: 600,
+      color: '#1e40af'
+    }
+  }, title), /*#__PURE__*/React.createElement("div", {
+    style: {
+      fontSize: 12,
+      color: '#3b82f6',
+      marginTop: 2
+    }
+  }, message)), /*#__PURE__*/React.createElement("button", {
+    onClick: onAllow,
+    style: {
+      padding: '6px 16px',
+      borderRadius: 8,
+      border: 'none',
+      background: '#3b82f6',
+      color: '#fff',
+      cursor: 'pointer',
+      fontSize: 13,
+      fontWeight: 600
+    }
+  }, "Allow"), onDismiss && /*#__PURE__*/React.createElement("button", {
+    onClick: onDismiss,
+    style: {
+      border: 'none',
+      background: 'none',
+      cursor: 'pointer',
+      color: '#93c5fd',
+      fontSize: 16
+    }
+  }, "\u2715"));
+}
+
+/**
+ * Push SDK - React 组件
+ * 消息推送可视化组件
+ */
+
+
+/**
+ * 通知中心
+ */
+function NotificationCenter({
+  onClose
+}) {
+  const [filter, setFilter] = React.useState('all');
+  const {
+    notifications,
+    unreadCount,
+    loading,
+    markAsRead,
+    markAllAsRead,
+    deleteNotification,
+    clearAll
+  } = useNotifications({
+    filter
+  });
+  const filteredNotifications = filter === 'unread' ? notifications.filter(n => !n.read) : notifications;
+  return /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-center"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-header"
+  }, /*#__PURE__*/React.createElement("h3", null, t('notifications')), unreadCount > 0 && /*#__PURE__*/React.createElement("span", {
+    className: "eco-push-badge"
+  }, unreadCount), onClose && /*#__PURE__*/React.createElement("button", {
+    className: "eco-push-close",
+    onClick: onClose
+  }, "\xD7")), /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-tabs"
+  }, /*#__PURE__*/React.createElement("button", {
+    className: `eco-push-tab ${filter === 'all' ? 'active' : ''}`,
+    onClick: () => setFilter('all')
+  }, t('all')), /*#__PURE__*/React.createElement("button", {
+    className: `eco-push-tab ${filter === 'unread' ? 'active' : ''}`,
+    onClick: () => setFilter('unread')
+  }, t('unread'), " ", unreadCount > 0 && `(${unreadCount})`)), /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-actions"
+  }, /*#__PURE__*/React.createElement("button", {
+    className: "eco-push-action-btn",
+    onClick: markAllAsRead
+  }, t('markAllRead')), /*#__PURE__*/React.createElement("button", {
+    className: "eco-push-action-btn",
+    onClick: clearAll
+  }, t('clear'))), /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-list"
+  }, loading ? /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-loading"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-spinner"
+  })) : filteredNotifications.length === 0 ? /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-empty"
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "eco-push-empty-icon"
+  }, "\uD83D\uDD14"), /*#__PURE__*/React.createElement("span", null, t('noNotifications'))) : filteredNotifications.map(notification => /*#__PURE__*/React.createElement(NotificationItem, {
+    key: notification.id,
+    notification: notification,
+    onRead: () => markAsRead(notification.id),
+    onDelete: () => deleteNotification(notification.id)
+  }))));
+}
+
+/**
+ * 单个通知项
+ */
+function NotificationItem({
+  notification,
+  onRead,
+  onDelete
+}) {
+  const handleClick = () => {
+    if (!notification.read) {
+      onRead?.();
+    }
+    if (notification.link) {
+      window.location.href = notification.link;
+    }
+  };
+  return /*#__PURE__*/React.createElement("div", {
+    className: `eco-push-item ${notification.read ? '' : 'unread'}`,
+    onClick: handleClick
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-item-icon"
+  }, getTypeIcon(notification.type)), /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-item-content"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-item-header"
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "eco-push-item-title"
+  }, notification.title), /*#__PURE__*/React.createElement("span", {
+    className: "eco-push-item-time"
+  }, formatTime(notification.createdAt))), /*#__PURE__*/React.createElement("p", {
+    className: "eco-push-item-body"
+  }, notification.body), notification.image && /*#__PURE__*/React.createElement("img", {
+    className: "eco-push-item-image",
+    src: notification.image,
+    alt: ""
+  })), /*#__PURE__*/React.createElement("button", {
+    className: "eco-push-item-delete",
+    onClick: e => {
+      e.stopPropagation();
+      onDelete?.();
+    }
+  }, "\xD7"));
+}
+
+/**
+ * 通知铃铛按钮
+ */
+function NotificationBell({
+  onClick
+}) {
+  const {
+    unreadCount
+  } = useNotifications({
+    limit: 0
+  });
+  return /*#__PURE__*/React.createElement("button", {
+    className: "eco-push-bell",
+    onClick: onClick
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "eco-push-bell-icon"
+  }, "\uD83D\uDD14"), unreadCount > 0 && /*#__PURE__*/React.createElement("span", {
+    className: "eco-push-bell-badge"
+  }, unreadCount > 99 ? '99+' : unreadCount));
+}
+
+/**
+ * 推送权限请求
+ */
+function PushPermissionPrompt({
+  onGranted,
+  onDenied
+}) {
+  const {
+    permission,
+    supported,
+    requestPermission
+  } = usePushPermission();
+  const [requesting, setRequesting] = React.useState(false);
+  if (!supported) return null;
+  if (permission === 'granted') return null;
+  if (permission === 'denied') {
+    return /*#__PURE__*/React.createElement("div", {
+      className: "eco-push-permission eco-push-permission-denied"
+    }, /*#__PURE__*/React.createElement("span", {
+      className: "eco-push-permission-icon"
+    }, "\uD83D\uDD15"), /*#__PURE__*/React.createElement("p", null, t('permissionRequired')));
+  }
+  const handleRequest = async () => {
+    setRequesting(true);
+    const result = await requestPermission();
+    setRequesting(false);
+    if (result === 'granted') {
+      onGranted?.();
+    } else {
+      onDenied?.();
+    }
+  };
+  return /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-permission"
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "eco-push-permission-icon"
+  }, "\uD83D\uDD14"), /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-permission-content"
+  }, /*#__PURE__*/React.createElement("h4", null, t('requestPermission')), /*#__PURE__*/React.createElement("p", null, "\u63A5\u6536\u91CD\u8981\u7684\u901A\u77E5\u548C\u66F4\u65B0")), /*#__PURE__*/React.createElement("button", {
+    className: "eco-push-permission-btn",
+    onClick: handleRequest,
+    disabled: requesting
+  }, requesting ? '...' : t('enablePush')));
+}
+
+/**
+ * 通知设置面板
+ */
+function NotificationSettings() {
+  const {
+    preferences,
+    loading,
+    saving,
+    toggleChannel,
+    toggleType,
+    updatePreferences
+  } = useNotificationPreferences();
+  if (loading) {
+    return /*#__PURE__*/React.createElement("div", {
+      className: "eco-push-settings eco-push-loading"
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "eco-push-spinner"
+    }));
+  }
+  return /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-settings"
+  }, /*#__PURE__*/React.createElement("h3", null, t('preferences')), /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-settings-section"
+  }, /*#__PURE__*/React.createElement("h4", null, t('channel')), /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-settings-list"
+  }, Object.entries(preferences.channels || {}).map(([channel, enabled]) => /*#__PURE__*/React.createElement(ToggleItem, {
+    key: channel,
+    label: t(channel),
+    checked: enabled,
+    onChange: () => toggleChannel(channel),
+    disabled: saving
+  })))), /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-settings-section"
+  }, /*#__PURE__*/React.createElement("h4", null, t('type')), /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-settings-list"
+  }, Object.entries(preferences.types || {}).map(([type, enabled]) => /*#__PURE__*/React.createElement(ToggleItem, {
+    key: type,
+    label: t(type),
+    checked: enabled,
+    onChange: () => toggleType(type),
+    disabled: saving
+  })))), /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-settings-section"
+  }, /*#__PURE__*/React.createElement("h4", null, t('quietHours')), /*#__PURE__*/React.createElement(ToggleItem, {
+    label: t('enabled'),
+    checked: preferences.quietHours?.enabled,
+    onChange: () => updatePreferences({
+      quietHours: {
+        ...preferences.quietHours,
+        enabled: !preferences.quietHours?.enabled
+      }
+    }),
+    disabled: saving
+  }), preferences.quietHours?.enabled && /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-quiet-hours"
+  }, /*#__PURE__*/React.createElement("input", {
+    type: "time",
+    value: preferences.quietHours?.start || '22:00',
+    onChange: e => updatePreferences({
+      quietHours: {
+        ...preferences.quietHours,
+        start: e.target.value
+      }
+    })
+  }), /*#__PURE__*/React.createElement("span", null, "-"), /*#__PURE__*/React.createElement("input", {
+    type: "time",
+    value: preferences.quietHours?.end || '08:00',
+    onChange: e => updatePreferences({
+      quietHours: {
+        ...preferences.quietHours,
+        end: e.target.value
+      }
+    })
+  }))));
+}
+
+/**
+ * 开关项
+ */
+function ToggleItem({
+  label,
+  checked,
+  onChange,
+  disabled
+}) {
+  return /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-toggle-item"
+  }, /*#__PURE__*/React.createElement("span", null, label), /*#__PURE__*/React.createElement("button", {
+    className: `eco-push-toggle ${checked ? 'active' : ''}`,
+    onClick: onChange,
+    disabled: disabled
+  }, /*#__PURE__*/React.createElement("span", {
+    className: "eco-push-toggle-handle"
+  })));
+}
+
+/**
+ * Toast通知
+ */
+function NotificationToast({
+  notification,
+  onClose,
+  duration = 5000
+}) {
+  React.useEffect(() => {
+    if (duration > 0) {
+      const timer = setTimeout(onClose, duration);
+      return () => clearTimeout(timer);
+    }
+  }, [duration, onClose]);
+  return /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-toast"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-toast-icon"
+  }, getTypeIcon(notification.type)), /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-toast-content"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-toast-title"
+  }, notification.title), /*#__PURE__*/React.createElement("div", {
+    className: "eco-push-toast-body"
+  }, notification.body)), /*#__PURE__*/React.createElement("button", {
+    className: "eco-push-toast-close",
+    onClick: onClose
+  }, "\xD7"));
+}
+
+// 工具函数
+function getTypeIcon(type) {
+  const icons = {
+    system: '⚙️',
+    marketing: '📢',
+    transactional: '💳',
+    social: '👥',
+    reminder: '⏰',
+    alert: '⚠️'
+  };
+  return icons[type] || '🔔';
+}
+function formatTime(timestamp) {
+  const now = Date.now();
+  const diff = now - new Date(timestamp).getTime();
+  const minutes = Math.floor(diff / 60000);
+  const hours = Math.floor(diff / 3600000);
+  const days = Math.floor(diff / 86400000);
+  if (minutes < 1) return t('now');
+  if (minutes < 60) return t('minutesAgo', {
+    n: minutes
+  });
+  if (hours < 24) return t('hoursAgo', {
+    n: hours
+  });
+  if (days === 1) return t('yesterday');
+  if (days < 7) return t('daysAgo', {
+    n: days
+  });
+  return new Date(timestamp).toLocaleDateString();
+}
+
+/**
+ * @quantabit/push-sdk — 通用推送通知适配层
+ * 
+ * 统一 API 接入多种推送服务：
+ * - 浏览器原生 Web Push (Notification API + Service Worker)
+ * - Firebase Cloud Messaging (FCM)
+ * - OneSignal
+ * - 极光推送 JPush
+ * - WebSocket 自研推送
+ * - Server-Sent Events (SSE)
+ * - 自定义适配器
+ * 
+ * 使用方式:
+ *   const push = new PushManager({ adapter: 'websocket', url: 'wss://...' });
+ *   push.subscribe();
+ *   push.onMessage(msg => console.log(msg));
+ */
+const getNotifications = pushApi.getHistory.bind(pushApi);
+const markAsRead = pushApi.markAsRead.bind(pushApi);
+const markAllAsRead = async () => pushApi.batchMarkAsRead([]);
+const send = pushApi.send.bind(pushApi);
+const schedule = pushApi.schedule.bind(pushApi);
+const getPreferences = pushApi.getPreferences.bind(pushApi);
+const updatePreferences = pushApi.updatePreferences.bind(pushApi);
+
+exports.FCMAdapter = FCMAdapter;
+exports.JPushAdapter = JPushAdapter;
+exports.MockAdapter = MockAdapter;
+exports.NotificationBell = NotificationBell;
+exports.NotificationCenter = NotificationCenter;
+exports.NotificationChannel = NotificationChannel;
+exports.NotificationItem = NotificationItem;
+exports.NotificationSettings = NotificationSettings;
+exports.NotificationStatus = NotificationStatus;
+exports.NotificationToast = NotificationToast;
+exports.NotificationType = NotificationType;
+exports.OneSignalAdapter = OneSignalAdapter;
+exports.PermissionStatus = PermissionStatus;
+exports.PushApiClient = PushApiClient;
+exports.PushChannel = PushChannel;
+exports.PushManager = PushManager;
+exports.PushPermissionBanner = PushPermissionBanner;
+exports.PushPermissionPrompt = PushPermissionPrompt;
+exports.PushPriority = PushPriority;
+exports.PushProvider = PushProvider;
+exports.PushStatus = PushStatus;
+exports.SSEAdapter = SSEAdapter;
+exports.SUPPORTED_LANGUAGES = SUPPORTED_LANGUAGES;
+exports.SubscriptionStatus = SubscriptionStatus;
+exports.WebPushAdapter = WebPushAdapter;
+exports.WebPushClient = WebPushClient;
+exports.WebSocketAdapter = WebSocketAdapter;
+exports.getLanguage = getLanguage;
+exports.getNotifications = getNotifications;
+exports.getPreferences = getPreferences;
+exports.markAllAsRead = markAllAsRead;
+exports.markAsRead = markAsRead;
+exports.messages = messages;
+exports.pushApi = pushApi;
+exports.schedule = schedule;
+exports.send = send;
+exports.setLanguage = setLanguage;
+exports.t = t;
+exports.updatePreferences = updatePreferences;
+exports.useNotificationPreferences = useNotificationPreferences;
+exports.useNotifications = useNotifications;
+exports.usePush = usePush;
+exports.usePushPermission = usePushPermission;
+exports.usePushSubscription = usePushSubscription;
+exports.useRealtimeNotifications = useRealtimeNotifications;
+exports.useSendNotification = useSendNotification;
+exports.webPushClient = webPushClient;
+//# sourceMappingURL=index.cjs.map