@tencentcloud/web-push 1.0.0

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@tencentcloud/web-push",
+  "version": "1.0.0",
+  "description": "Tencent Cloud Web Push SDK - Service Worker-based web push notification service",
+  "main": "index.umd.js",
+  "module": "index.esm.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.esm.js",
+      "require": "./index.umd.js"
+    },
+    "./sw": "./sw.js"
+  },
+  "files": [
+    "**/*"
+  ],
+  "keywords": [
+    "web-push",
+    "service-worker",
+    "push-notification",
+    "tencent-cloud"
+  ],
+  "author": "Tencent Cloud",
+  "license": "MIT",
+  "peerDependencies": {
+    "@tencentcloud/lite-chat": "^4.2.0"
+  }
+}

package/src/core/event-emitter.d.ts

@@ -0,0 +1,9 @@
+import { EVENT } from '../types';
+export declare class EventEmitter {
+    private events;
+    on(eventName: EVENT, listener: Function): string;
+    off(eventName: EVENT, listener: Function): boolean;
+    emit(eventName: EVENT, ...args: any[]): void;
+    removeAllListeners(eventName?: EVENT): void;
+    listenerCount(eventName: EVENT): number;
+}

package/src/core/service-worker-manager.d.ts

@@ -0,0 +1,28 @@
+import { EventEmitter } from './event-emitter';
+import { SubscriptionInfo } from '../types';
+export declare class ServiceWorkerManager {
+    private static instance;
+    private registration;
+    private eventEmitter;
+    private swUrl;
+    private constructor();
+    static getInstance(eventEmitter: EventEmitter): ServiceWorkerManager;
+    private checkServiceWorkerExists;
+    private autoDetectServiceWorkerUrl;
+    setServiceWorkerUrl(url: string): void;
+    register(): Promise<ServiceWorkerRegistration>;
+    private waitForServiceWorkerReady;
+    getPushSubscription(vapidPublicKey: string): Promise<SubscriptionInfo>;
+    private getSubscriptionInfo;
+    private generateSafariToken;
+    private generateFallbackToken;
+    private generateEndpointHash;
+    unsubscribe(): Promise<boolean>;
+    unregister(): Promise<boolean>;
+    private setupMessageListener;
+    private handleServiceWorkerMessage;
+    postMessage(message: any): Promise<void>;
+    private arrayBufferToBase64;
+    private urlBase64ToUint8Array;
+    getRegistration(): ServiceWorkerRegistration | null;
+}

package/src/core/web-push-sdk.d.ts

@@ -0,0 +1,33 @@
+import { WebPushSDK as IWebPushSDK, RegisterPushOptions, EVENT } from '../types';
+export declare class WebPushSDK implements IWebPushSDK {
+    static instance: WebPushSDK;
+    private eventEmitter;
+    private serviceWorkerManager;
+    private isRegistered;
+    private registrationID;
+    private chat;
+    private SDKAppID;
+    private appKey;
+    private vapidPublicKey;
+    EVENT: typeof EVENT;
+    VERSION: string;
+    constructor();
+    static getInstance(): WebPushSDK;
+    registerPush(options?: RegisterPushOptions): Promise<string>;
+    unRegisterPush(): Promise<boolean>;
+    addPushListener(eventName: EVENT, listener: Function): string;
+    removePushListener(eventName: EVENT, listener: Function): boolean;
+    private checkBrowserSupport;
+    private requestNotificationPermission;
+    private chatLogin;
+    private getSystemPermissionMessage;
+    private showSystemPermissionAlert;
+    private getBrowserInstType;
+    private setToken;
+    private initializeBrowserCompatibility;
+    private setupInternalListeners;
+    private pushStatistics;
+    private saveState;
+    private restoreState;
+    private clearState;
+}

package/src/index.d.ts

@@ -0,0 +1,5 @@
+import { WebPushSDK } from './core/web-push-sdk';
+export * from './types/outer';
+declare const webPush: WebPushSDK;
+export { webPush };
+export default webPush;

package/src/service-worker/sw.d.ts

@@ -0,0 +1 @@
+export {};

package/src/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './inner';
+export * from './outer';

package/src/types/inner.d.ts

@@ -0,0 +1,47 @@
+export interface PushMessage {
+    messageID: string;
+    title: string;
+    body: string;
+    icon?: string;
+    tag?: string;
+    data?: any;
+    timestamp: number;
+}
+export interface NotificationClickData {
+    notification: PushMessage;
+    action?: string;
+}
+export interface StatisticsData {
+    messageID: string;
+    type: 'reach' | 'click';
+    timestamp: number;
+    SDKAppID: number;
+    registrationID: string;
+}
+export interface ServiceWorkerMessage {
+    type: 'MESSAGE_RECEIVED' | 'NOTIFICATION_CLICKED' | 'MESSAGE_REVOKED';
+    data: any;
+}
+export interface SubscriptionInfo {
+    subscription: PushSubscription;
+    token: string;
+    auth: string;
+    p256dh: string;
+    endpoint: string;
+}
+export interface WebPushCompatibilityInfo {
+    isSupported: boolean;
+    browserInfo: {
+        name: string;
+        version: string;
+        platform: string;
+        majorVersion: number;
+    };
+    features: {
+        serviceWorker: boolean;
+        pushManager: boolean;
+        notification: boolean;
+    };
+    warnings: string[];
+    recommendations: string[];
+}

package/src/types/outer.d.ts

@@ -0,0 +1,66 @@
+export interface WebPushSDK {
+    registerPush(options?: RegisterPushOptions): Promise<any>;
+    unRegisterPush(): Promise<any>;
+    addPushListener(eventName: EVENT, listener: (data: EventResult) => void): any;
+    removePushListener(eventName: EVENT, listener: (data: EventResult) => void): any;
+}
+export interface RegisterPushOptions {
+    SDKAppID: number;
+    appKey: string;
+    userID: string;
+    serviceWorkerPath?: string;
+    chat?: any;
+}
+export declare enum EVENT {
+    MESSAGE_RECEIVED = "message_received",
+    MESSAGE_REVOKED = "message_revoked",
+    NOTIFICATION_CLICKED = "notification_clicked"
+}
+export interface Message {
+    ID: String;
+    type: 'TIMTextElem' | 'TIMImageElem' | 'TIMSoundElem' | 'TIMVideoFileElem' | 'TIMFileElem' | 'TIMCustomElem' | 'TIMRelayElem' | 'TIMLocationElem' | 'TIMFaceElem';
+    payload: any;
+    conversationID: String;
+    conversationType: 'C2C' | 'GROUP';
+    to: String;
+    from: String;
+    flow: String;
+    time: Number;
+    status: String;
+    isRevoked: Boolean;
+    nick: String;
+    avatar: String;
+    isPeerRead: Boolean;
+    nameCard: String;
+    atUserList: String[];
+    cloudCustomData: String;
+    isDeleted: Boolean;
+    isModified: Boolean;
+    needReadReceipt: Boolean;
+    readReceiptInfo: any;
+    isBroadcastMessage: Boolean;
+    isSupportExtension: Boolean;
+    receiverList?: String[];
+    revoker: String;
+    sequence: Number;
+    progress: Number;
+    revokerInfo: {
+        userID: String;
+        nick: String;
+        avatar: String;
+    };
+    revokeReason: String;
+    hasRiskContent: Boolean;
+}
+export interface MessageReceivedResult {
+    message: Message;
+}
+export interface MessageRevokedResult {
+    messageID: String;
+}
+export interface MessageNotificationClickedResult {
+    ext: String;
+}
+export interface EventResult {
+    data: MessageReceivedResult | MessageRevokedResult | MessageNotificationClickedResult;
+}

package/src/utils/browser-support.d.ts

@@ -0,0 +1,69 @@
+export interface BrowserInfo {
+    name: string;
+    version: string;
+    majorVersion: number;
+    platform: string;
+    userAgent: string;
+    language: string;
+}
+export interface WebPushCapability {
+    supported: boolean;
+    reason?: string;
+    browserName: string;
+    browserVersion: string;
+}
+export interface FeatureSupport {
+    serviceWorker: boolean;
+    pushManager: boolean;
+    notification: boolean;
+    webPush: boolean;
+}
+export interface PushSubscriptionOptions {
+    userVisibleOnly: boolean;
+    applicationServerKey?: BufferSource | string;
+}
+export interface NotificationOptions {
+    body?: string;
+    icon?: string;
+    badge?: string;
+    image?: string;
+    tag?: string;
+    data?: any;
+    requireInteraction?: boolean;
+    silent?: boolean;
+    timestamp?: number;
+    actions?: Array<{
+        action: string;
+        title: string;
+        icon?: string;
+    }>;
+    dir?: 'auto' | 'ltr' | 'rtl';
+    lang?: string;
+    renotify?: boolean;
+    vibrate?: number[];
+}
+export declare class BrowserSupport {
+    private static instance;
+    private browserInfo;
+    private constructor();
+    static getInstance(): BrowserSupport;
+    getBrowserInfo(): BrowserInfo;
+    private detectPlatform;
+    private detectLanguage;
+    getFeatureSupport(): FeatureSupport;
+    detectWebPushCapability(): WebPushCapability;
+    private checkBrowserVersionSupport;
+    isWebPushSupported(): boolean;
+    getUnsupportedReason(): string | undefined;
+    checkNotificationPermission(): Promise<NotificationPermission>;
+    requestNotificationPermission(): Promise<NotificationPermission>;
+    requiresUserGesture(): boolean;
+    handleBrowserSpecificError(error: Error): NotificationPermission;
+    checkBrowserSupport(): boolean;
+}
+export declare const browserSupport: BrowserSupport;
+export declare function getBrowserInfo(): BrowserInfo;
+export declare function getFeatureSupport(): FeatureSupport;
+export declare function detectWebPushCapability(): WebPushCapability;
+export declare function isWebPushSupported(): boolean;
+export declare function getUnsupportedReason(): string | undefined;

package/src/utils/logger.d.ts

@@ -0,0 +1,10 @@
+export declare class Logger {
+    private static instance;
+    private constructor();
+    static getInstance(): Logger;
+    log(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+}
+export declare const logger: Logger;

package/src/utils/storage.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Local storage utility class
+ */
+export declare class Storage {
+    private static readonly PREFIX;
+    static set(key: string, value: any): void;
+    static get<T>(key: string, defaultValue?: T): T | null;
+    static remove(key: string): void;
+    static clear(): void;
+}

package/src/utils/validator.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Parameter validation utility class
+ */
+export interface ValidationRule {
+    required?: boolean;
+    type?: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'function';
+    min?: number;
+    max?: number;
+    pattern?: RegExp;
+    custom?: (value: any) => boolean | string;
+    message?: string;
+}
+export interface ValidationSchema {
+    [key: string]: ValidationRule;
+}
+export declare class ValidationError extends Error {
+    field: string;
+    value: any;
+    constructor(field: string, message: string, value?: any);
+}
+export declare class Validator {
+    /**
+     * Validate single value
+     */
+    static validateValue(fieldName: string, value: any, rule: ValidationRule): void;
+    /**
+     * Validate object
+     */
+    static validateObject(obj: any, schema: ValidationSchema): void;
+    /**
+     * Check type
+     */
+    private static checkType;
+    static validateSDKAppID(SDKAppID: any): void;
+    static validateAppKey(appKey: any): void;
+    static validateUserID(userID: any): void;
+    static validateEventType(eventType: any): void;
+    static validateListener(listener: any): void;
+    static validateRegisterPushOptions(options: any): void;
+    static validatePushMessage(message: any): void;
+    /**
+     * Validate URL format
+     */
+    static validateURL(url: any, fieldName?: string): void;
+    /**
+     * Validate Service Worker path
+     */
+    static validateServiceWorkerPath(path: any): void;
+}
+/**
+ * Parameter validation decorator
+ */
+export declare function validateParams(schema: ValidationSchema): (_target: any, _propertyName: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Single parameter validation decorator
+ */
+export declare function validateParam(paramIndex: number, rule: ValidationRule): (_target: any, _propertyName: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/sw.js

@@ -0,0 +1 @@
+!function(){"use strict";function t(t,...e){console.log(`[WebPush SW] ${t}`,...e)}function e(t,...e){console.warn(`[WebPush SW] ${t}`,...e)}function a(t,...e){console.error(`[WebPush SW] ${t}`,...e)}async function i(t){try{(await self.clients.matchAll({includeUncontrolled:!0,type:"window"})).forEach(e=>{e.postMessage(t)})}catch(e){a("Failed to send message to clients",e)}}async function n(i){try{if(!i.rptURL||!i.rptExt)return void e("Missing rptURL or rptExt, skipping report");const a={webpushEvents:[{id:i.id,EventType:i.eventType||1,EventTime:Math.floor(Date.now()/1e3),rptExt:i.rptExt}]};t("Reporting WebPush event",{rptURL:i.rptURL,reportData:a});const n=await fetch(i.rptURL,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(a)});n.ok?t("WebPush event reported successfully"):e("Failed to report WebPush event",n.status,n.statusText)}catch(n){a("Error reporting WebPush event",n)}}self.addEventListener("install",e=>{t("Service Worker installing..."),self.skipWaiting()}),self.addEventListener("activate",e=>{t("Service Worker activating..."),e.waitUntil(self.clients.claim())}),self.addEventListener("push",o=>{if(t("Push message received",o),o.data)try{let e;try{e=o.data.json(),t("Push message data (JSON):",e)}catch{const a=o.data.text();t("Push message data (Text):",a),e={id:"",title:"WebPush Notification",desc:a||"You have a new message",url:"/",icon:"",tag:"",image:"",rptExt:"",rptURL:""}}const a={messageID:e.id||Date.now().toString(36)+Math.random().toString(36).substr(2),title:e.title||"New Message",body:e.desc||"You have a new message",icon:e.icon||"",tag:e.tag||e?.id?.slice(-100)||"push-"+Date.now()+"-"+Math.random().toString(36).substr(2,5),data:{url:e.url,image:e.image,rptExt:e.rptExt,rptURL:e.rptURL},timestamp:Date.now()},s=self.registration.showNotification(a.title,{body:a.body,icon:a.icon,image:e.image,tag:a.tag,data:a,requireInteraction:!1}),r=i({type:"MESSAGE_RECEIVED",data:a}),c=e.rptURL&&e.rptExt?n({id:e.id,rptURL:e.rptURL,rptExt:e.rptExt,eventType:1}):Promise.resolve();o.waitUntil(Promise.all([s,r,c]))}catch(s){a("Failed to process push message",s),o.waitUntil(self.registration.showNotification("WebPush Notification",{body:"You have a new message",icon:"/vite.svg",tag:"fallback"}))}else e("Push message has no data")}),self.addEventListener("notificationclick",e=>{t("Notification clicked",e);const o=e.notification,s=e.action,r=o.data;if(o.close(),"close"===s)return;const c=i({type:"NOTIFICATION_CLICKED",data:{notification:r,action:s}}),l=async function(t="/"){try{const e=await self.clients.matchAll({type:"window",includeUncontrolled:!0}),a=new URL(t,self.location.origin).href;for(const t of e)if(t.url===a&&"focus"in t)return void(await t.focus());for(const i of e)if(i.url.startsWith(self.location.origin)&&"focus"in i)return await i.focus(),void i.postMessage({type:"NAVIGATE_TO",url:t});self.clients.openWindow&&await self.clients.openWindow(t)}catch(e){a("Failed to open or focus window",e)}}(r?.data?.url||"/"),d=r?.data?.rptURL&&r?.data?.rptExt?n({id:r.messageID,rptURL:r.data.rptURL,rptExt:r.data.rptExt,eventType:2}):Promise.resolve();e.waitUntil(Promise.all([c,l,d]))}),self.addEventListener("notificationclose",e=>{t("Notification closed",e)}),self.addEventListener("message",e=>{t("Message received from main thread",e.data);const{type:n,payload:o}=e.data;switch(n){case"SHOW_NOTIFICATION":!async function(e){try{const{eventType:a,data:i,options:n}=e;t("Handling show notification request",{eventType:a,data:i,options:n}),await self.registration.showNotification(n.title,{body:n.body,icon:n.icon,badge:n.badge,tag:n.tag,requireInteraction:n.requireInteraction,silent:n.silent,data:n.data}),t("Notification shown successfully",n.title)}catch(i){a("Failed to handle show notification",i)}}(o);break;case"REVOKE_MESSAGE":!async function(t){try{(await self.registration.getNotifications()).forEach(e=>{e.data&&e.data.messageID===t&&e.close()}),await i({type:"MESSAGE_REVOKED",data:{messageID:t}})}catch(e){a("Failed to handle message revocation",e)}}(o.messageID);break;case"UPDATE_CONFIG":t("Updating configuration",o)}}),self.addEventListener("error",t=>{a("Service Worker error",t.error)}),self.addEventListener("unhandledrejection",t=>{a("Service Worker unhandled promise rejection",t.reason)})}();