@tencentcloud/web-push 1.0.1 → 1.0.3

package/src/utils/validator.ts

@@ -0,0 +1,267 @@
+/**
+ * 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 class ValidationError extends Error {
+  public field: string;
+  public value: any;
+
+  constructor(field: string, message: string, value?: any) {
+    super(`Parameter validation failed: ${field} - ${message}`);
+    this.name = 'ValidationError';
+    this.field = field;
+    this.value = value;
+  }
+}
+
+export class Validator {
+  /**
+   * Validate single value
+   */
+  static validateValue(
+    fieldName: string,
+    value: any,
+    rule: ValidationRule
+  ): void {
+    if (
+      rule.required &&
+      (value === undefined || value === null || value === '')
+    ) {
+      throw new ValidationError(
+        fieldName,
+        rule.message || `${fieldName} is required`,
+        value
+      );
+    }
+
+    if (
+      !rule.required &&
+      (value === undefined || value === null || value === '')
+    ) {
+      return;
+    }
+
+    if (rule.type && !this.checkType(value, rule.type)) {
+      throw new ValidationError(
+        fieldName,
+        rule.message || `${fieldName} must be of type ${rule.type}`,
+        value
+      );
+    }
+
+    if (rule.type === 'string' && typeof value === 'string') {
+      if (rule.min !== undefined && value.length < rule.min) {
+        throw new ValidationError(
+          fieldName,
+          rule.message ||
+            `${fieldName} length cannot be less than ${rule.min} characters`,
+          value
+        );
+      }
+      if (rule.max !== undefined && value.length > rule.max) {
+        throw new ValidationError(
+          fieldName,
+          rule.message ||
+            `${fieldName} length cannot exceed ${rule.max} characters`,
+          value
+        );
+      }
+    }
+
+    if (rule.type === 'number' && typeof value === 'number') {
+      if (rule.min !== undefined && value < rule.min) {
+        throw new ValidationError(
+          fieldName,
+          rule.message || `${fieldName} cannot be less than ${rule.min}`,
+          value
+        );
+      }
+      if (rule.max !== undefined && value > rule.max) {
+        throw new ValidationError(
+          fieldName,
+          rule.message || `${fieldName} cannot be greater than ${rule.max}`,
+          value
+        );
+      }
+    }
+
+    if (rule.pattern && typeof value === 'string') {
+      if (!rule.pattern.test(value)) {
+        throw new ValidationError(
+          fieldName,
+          rule.message || `${fieldName} format is incorrect`,
+          value
+        );
+      }
+    }
+
+    if (rule.custom) {
+      const result = rule.custom(value);
+      if (result !== true) {
+        const message =
+          typeof result === 'string'
+            ? result
+            : rule.message || `${fieldName} validation failed`;
+        throw new ValidationError(fieldName, message, value);
+      }
+    }
+  }
+
+  /**
+   * Validate object
+   */
+  static validateObject(obj: any, schema: ValidationSchema): void {
+    if (!obj || typeof obj !== 'object') {
+      throw new ValidationError('root', 'Parameter must be an object type');
+    }
+
+    for (const [fieldName, rule] of Object.entries(schema)) {
+      const value = obj[fieldName];
+      this.validateValue(fieldName, value, rule);
+    }
+  }
+
+  /**
+   * Check type
+   */
+  private static checkType(value: any, expectedType: string): boolean {
+    switch (expectedType) {
+      case 'string':
+        return typeof value === 'string';
+      case 'number':
+        return typeof value === 'number' && !isNaN(value);
+      case 'boolean':
+        return typeof value === 'boolean';
+      case 'object':
+        return (
+          value !== null && typeof value === 'object' && !Array.isArray(value)
+        );
+      case 'array':
+        return Array.isArray(value);
+      case 'function':
+        return typeof value === 'function';
+      default:
+        return false;
+    }
+  }
+
+  static validateSDKAppID(SDKAppID: any): void {
+    this.validateValue('SDKAppID', SDKAppID, {
+      required: true,
+      type: 'number',
+      custom: (value) => {
+        if (!Number.isInteger(value)) {
+          return 'SDKAppID must be an integer';
+        }
+        return true;
+      },
+      message: 'SDKAppID must be an integer between 1-999999999',
+    });
+  }
+
+  static validateAppKey(appKey: any): void {
+    this.validateValue('appKey', appKey, {
+      required: true,
+      type: 'string',
+      pattern: /^[a-zA-Z0-9_-]+$/,
+      message:
+        'appKey must be a 1-256 character string composed of letters, numbers, underscores or hyphens',
+    });
+  }
+
+  static validateUserID(userID: any): void {
+    this.validateValue('userID', userID, {
+      required: true,
+      type: 'string',
+      pattern: /^[a-zA-Z0-9_.-]+$/,
+      message:
+        'userID must be a 1-128 character string composed of letters, numbers, underscores, dots or hyphens',
+    });
+  }
+
+  static validateEventType(eventType: any): void {
+    const validEvents = [
+      'message_received',
+      'message_revoked',
+      'notification_clicked',
+    ];
+    this.validateValue('eventType', eventType, {
+      required: true,
+      type: 'string',
+      custom: (value) => {
+        if (!validEvents.includes(value)) {
+          return `eventType must be one of: ${validEvents.join(', ')}`;
+        }
+        return true;
+      },
+    });
+  }
+
+  static validateListener(listener: any): void {
+    this.validateValue('listener', listener, {
+      required: true,
+      type: 'function',
+      message: 'listener must be a function',
+    });
+  }
+
+  static validateRegisterPushOptions(options: any): void {
+    if (!options) {
+      throw new ValidationError(
+        'options',
+        'Registration options cannot be empty'
+      );
+    }
+
+    const schema: ValidationSchema = {
+      SDKAppID: {
+        required: true,
+        type: 'number',
+        custom: (value) => {
+          if (!Number.isInteger(value)) {
+            return 'SDKAppID must be an integer';
+          }
+          return true;
+        },
+      },
+      appKey: {
+        required: true,
+        type: 'string',
+        pattern: /^[a-zA-Z0-9_-]+$/,
+      },
+      userID: {
+        required: true,
+        type: 'string',
+        pattern: /^[a-zA-Z0-9_.-]+$/,
+      },
+    };
+
+    this.validateObject(options, schema);
+  }
+
+  /**
+   * Validate Service Worker path
+   */
+  static validateServiceWorkerPath(path: any): void {
+    this.validateValue('serviceWorkerPath', path, {
+      required: false,
+      type: 'string',
+      pattern: /^[a-zA-Z0-9_./-]+\.js$/,
+      message: 'serviceWorkerPath must be a valid JavaScript file path',
+    });
+  }
+}

package/CHANGELOG.md

@@ -1,50 +0,0 @@
-# Changelog
-
-## [1.0.1] - 2025-12-19
-
-- Optimize subscription logic
-- Optimized state persistence logic, only persisting VAPID public key while resetting temporary states each session
-
-## [1.0.0] - 2025-12-17
-
-### Added
-
-- 🎉 Initial release
-- ✨ Service Worker-based push notification support
-- ✨ Complete TypeScript type definitions
-- ✨ Event-driven message handling mechanism
-- ✨ Built-in analytics functionality
-- ✨ Local state persistence
-- ✨ VAPID authentication support
-- ✨ Cross-platform push notification support
-
-### Features
-
-- 📱 Support for message received, notification clicked, and message revoked events
-- 🔧 Flexible device identifier management
-- 📊 Automatic message delivery and click rate statistics
-- 🎯 Seamless integration with Chat SDK
-- 💾 Automatic state recovery
-- 🔒 Secure push subscription management
-
-### API Interface
-
-- `registerPush()` - Register push service
-- `unRegisterPush()` - Unregister push service
-- `addPushListener()` - Add event listener
-- `removePushListener()` - Remove event listener
-
-### Browser Support
-
-- Chrome 50+
-- Firefox 44+
-- Safari 16+
-- Edge 17+
-
-### Development Tools
-
-- Vite build tool
-- TypeScript support
-- Jest unit testing
-- ESLint code linting
-- Complete example application

package/index.d.ts

@@ -1,110 +0,0 @@
-export declare enum EVENT {
-    MESSAGE_RECEIVED = "message_received",
-    MESSAGE_REVOKED = "message_revoked",
-    NOTIFICATION_CLICKED = "notification_clicked"
-}
-
-export declare interface EventResult {
-    data: MessageReceivedResult | MessageRevokedResult | MessageNotificationClickedResult;
-}
-
-export declare 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 declare interface MessageNotificationClickedResult {
-    ext: String;
-}
-
-export declare interface MessageReceivedResult {
-    message: Message;
-}
-
-export declare interface MessageRevokedResult {
-    messageID: String;
-}
-
-export declare interface RegisterPushOptions {
-    SDKAppID: number;
-    appKey: string;
-    userID: string;
-    serviceWorkerPath?: string;
-    chat?: any;
-}
-
-declare const webPush: WebPushSDK_2;
-export default webPush;
-export { webPush }
-
-export declare 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;
-}
-
-declare class WebPushSDK_2 implements WebPushSDK {
-    static instance: WebPushSDK_2;
-    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_2;
-    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 clearState;
-}
-
-export { }