slider-captcha-sdk 1.0.13 → 1.0.15

package/dist/index.esm.js

@@ -33,8 +33,36 @@ class PopupSliderCaptcha {
     return `:root{--sc-primary:#409eff;--sc-success:#67c23a;--sc-danger:#f56c6c;--sc-border:#e4e7eb;--sc-bg:linear-gradient(90deg, #f7f9fa 0%, #e8f4fd 100%);--sc-text:#333;--sc-text-light:#999;--sc-shadow:0 4px 20px rgba(0,0,0,.3);--sc-radius:8px;--sc-transition:.3s ease}.slider-captcha-overlay{position:fixed;top:0;left:0;width:100%;height:100%;background:rgba(0,0,0,.5);z-index:9999;display:none;justify-content:center;align-items:center;opacity:0;transition:opacity var(--sc-transition)}.slider-captcha-overlay.show{opacity:1}.slider-captcha-modal{background:#fff;border-radius:var(--sc-radius);padding:20px;box-shadow:var(--sc-shadow);position:relative;max-width:90vw;max-height:90vh;transform:scale(.8) translateY(-20px);opacity:0;transition:all var(--sc-transition)}.slider-captcha-modal.show{transform:scale(1) translateY(0);opacity:1}.slider-captcha-header{display:flex;justify-content:space-between;align-items:center;margin-bottom:15px;padding-bottom:10px;border-bottom:1px solid var(--sc-border)}.slider-captcha-container{display:flex;align-items:center;position:relative;border-radius:4px;overflow:hidden;margin-bottom:15px;background:#837a7a;justify-content:center}.slider-captcha-track{width:100%;height:40px;line-height:40px;background:var(--sc-bg);border:1px solid var(--sc-border);border-radius:20px;position:relative;margin-bottom:15px;overflow:hidden}.slider-captcha-btn{width:38px;height:38px;background:#fff;border:1px solid #ccc;border-radius:50%;position:absolute;top:0;left:0;cursor:pointer;display:flex;align-items:center;justify-content:center;box-shadow:0 2px 4px rgba(0,0,0,.1);transition:all var(--sc-transition);user-select:none;z-index:1}.slider-captcha-loading{position:absolute;top:0;left:0;width:100%;height:100%;background:rgba(255,255,255,.6);display:flex;align-items:center;justify-content:center;flex-direction:column;color:#666;font-size:14px;z-index:10;border-radius:4px}.slider-captcha-error{color:var(--sc-danger);font-size:12px;text-align:center;margin-top:10px;display:none}.slider-captcha-title{margin:0;font-size:16px;color:var(--sc-text)}.slider-captcha-close,.slider-captcha-refresh{background:none;border:none;cursor:pointer;color:var(--sc-text-light);padding:0;width:30px;height:30px;display:flex;align-items:center;justify-content:center;border-radius:50%;transition:all var(--sc-transition);position:relative;font-size:0}.slider-captcha-close::before,.slider-captcha-close::after{content:'';position:absolute;width:16px;height:2px;background-color:var(--sc-text-light);border-radius:1px;transition:all var(--sc-transition)}.slider-captcha-close::before{transform:rotate(45deg)}.slider-captcha-close::after{transform:rotate(-45deg)}.slider-captcha-close:hover{background:#f5f5f5;transform:scale(1.1)}.slider-captcha-close:hover::before,.slider-captcha-close:hover::after{background-color:var(--sc-danger)}.slider-captcha-refresh{margin-left:10px}.slider-captcha-refresh svg{width:20px;height:20px;fill:var(--sc-text-light);transition:all var(--sc-transition)}.slider-captcha-refresh:hover{background:#f5f5f5;transform:scale(1.1)}.slider-captcha-refresh:hover svg{fill:var(--sc-primary);transform:rotate(180deg)}.slider-captcha-floating-time{position:absolute;bottom:-40px;left:50%;transform:translateX(-50%);color:#fff;font-size:12px;white-space:nowrap;opacity:0;pointer-events:none;z-index:10;transition:all var(--sc-transition);background:#fff;padding:2px 15px;border-radius:10px}.slider-captcha-floating-time.show{opacity:1;transform:translateX(-50%) translateY(-45px)}.slider-captcha-floating-time.success{color:var(--sc-success)}.slider-captcha-floating-time.fail{color:var(--sc-danger)}.slider-captcha-bg{width:100%;height:100%;object-fit:cover;display:block}.slider-captcha-piece{position:absolute;top:0;left:0;cursor:pointer;transition:none;z-index:2}.slider-captcha-finger{position:absolute;top:50%;left:10px;transform:translateY(-50%);font-size:20px;animation:fingerSlide 2s ease-in-out infinite;pointer-events:none;z-index:1;opacity:.6}.slider-captcha-hint{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);color:var(--sc-text-light);font-size:14px;pointer-events:none;z-index:1;transition:all var(--sc-transition)}.slider-captcha-header-buttons{display:flex;align-items:center}@keyframes fingerSlide{0%{left:10px;opacity:.6}50%{opacity:1}100%{left:calc(50% - 10px);opacity:.6}}`
   }
 
+  // 优化：添加常量定义，提高可维护性
+  static CONSTANTS = {
+    CACHE_DURATION: 5 * 60 * 1000, // 5分钟缓存
+    MAX_RETRY_ATTEMPTS: 3,
+    DEFAULT_TIMEOUT: 30000,
+    ANIMATION_DURATION: 300,
+    FLOATING_TIME_DURATION: 2500,
+    THROTTLE_DELAY: 16
+  }
+
+  // 优化：添加错误类型枚举
+  static ERROR_TYPES = {
+    NETWORK_ERROR: 'NETWORK_ERROR',
+    TIMEOUT_ERROR: 'TIMEOUT_ERROR',
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+    IMAGE_LOAD_ERROR: 'IMAGE_LOAD_ERROR',
+    CAPTCHA_DATA_ERROR: 'CAPTCHA_DATA_ERROR'
+  }
+
   constructor(options = {}) {
-    this.options = { ...PopupSliderCaptcha.DEFAULTS, ...options };
+    // 优化：合并默认配置，使用常量
+    this.options = { 
+      ...PopupSliderCaptcha.DEFAULTS, 
+      ...options,
+      timeout: options.timeout || PopupSliderCaptcha.CONSTANTS.DEFAULT_TIMEOUT,
+      maxRetries: options.maxRetries || PopupSliderCaptcha.CONSTANTS.MAX_RETRY_ATTEMPTS,
+      throttleDelay: options.throttleDelay || PopupSliderCaptcha.CONSTANTS.THROTTLE_DELAY
+    };
+    
+    // 优化：初始化所有属性
     this.elements = {};
     this.state = this.createInitialState();
     this.captchaData = null;
@@ -45,11 +73,18 @@ class PopupSliderCaptcha {
     this.rafId = null;
     this.cachedDimensions = null;
     this.imageCache = new Map();
+    this.abortController = null;
 
     // 优化：使用箭头函数绑定this，避免重复bind调用
     this.throttledHandleMove = this.throttle((e) => this.handleMove(e), this.options.throttleDelay);
 
-    this.init();
+    // 优化：添加错误处理
+    try {
+      this.init();
+    } catch (error) {
+      console.error('滑块验证码初始化失败:', error);
+      this.handleError(PopupSliderCaptcha.ERROR_TYPES.VALIDATION_ERROR, error.message);
+    }
   }
 
   // 优化：提取初始状态创建为独立方法
@@ -376,7 +411,6 @@ class PopupSliderCaptcha {
   show() {
     this.state.isVisible = true;
     this.elements.overlay.style.display = "flex";
-    this.elements.overlay.offsetHeight; // 强制重绘
 
     requestAnimationFrame(() => {
       this.elements.overlay.classList.add("show");
@@ -400,56 +434,158 @@ class PopupSliderCaptcha {
     }, 300);
   }
 
-  // 优化：简化加载逻辑
+  // 优化：添加统一错误处理方法
+  handleError(errorType, message, originalError = null) {
+    const errorMessages = {
+      [PopupSliderCaptcha.ERROR_TYPES.NETWORK_ERROR]: '网络连接失败，请检查网络设置',
+      [PopupSliderCaptcha.ERROR_TYPES.TIMEOUT_ERROR]: '请求超时，请重试',
+      [PopupSliderCaptcha.ERROR_TYPES.VALIDATION_ERROR]: '验证失败，请重试',
+      [PopupSliderCaptcha.ERROR_TYPES.IMAGE_LOAD_ERROR]: '图片加载失败，请刷新重试',
+      [PopupSliderCaptcha.ERROR_TYPES.CAPTCHA_DATA_ERROR]: '验证码数据错误，请刷新重试'
+    };
+
+    const errorMessage = errorMessages[errorType] || message || '未知错误';
+    
+    // 调用用户自定义错误处理
+    if (this.options.onError) {
+      this.options.onError({
+        type: errorType,
+        message: errorMessage,
+        originalError
+      });
+    }
+
+    this.showError(errorMessage);
+    console.error(`滑块验证码错误 [${errorType}]:`, errorMessage, originalError);
+  }
+
+  // 优化：简化加载逻辑，增强错误处理
   async loadCaptcha() {
     try {
       this.showLoading();
       this.startTime = Date.now();
 
-      const controller = new AbortController();
-      const timeoutId = this.safeSetTimeout(() => controller.abort(), this.options.timeout);
+      // 取消之前的请求
+      if (this.abortController) {
+        this.abortController.abort();
+      }
+      this.abortController = new AbortController();
 
       const response = await fetch(this.options.apiUrl, {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ place: 2, timestamp: Date.now() }),
-        signal: controller.signal
+        headers: { 
+          "Content-Type": "application/json",
+          ...this.options.headers
+        },
+        body: JSON.stringify({ 
+          place: 2, 
+          timestamp: Date.now(),
+          ...this.options.requestData
+        }),
+        signal: this.abortController.signal
       });
 
-      this.safeClearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+      }
 
-      if (!response.ok) throw new Error(`HTTP ${response.status}`)
       const data = await response.json();
 
-      if (data.data?.canvasSrc && data.data?.blockSrc) {
-        this.captchaData = data.data;
-        this.showCaptcha();
-        await this.renderCaptcha();
-      } else {
+      // 优化：更严格的数据验证
+      if (!this.validateCaptchaData(data)) {
         throw new Error("验证码数据格式错误")
       }
+
+      this.captchaData = data.data;
+      this.showCaptcha();
+      await this.renderCaptcha();
     } catch (error) {
-      const message = error.name === 'AbortError' ? "请求超时，请重试" : `加载验证码失败: ${error.message}`;
-      this.showError(message);
+      if (error.name === 'AbortError') {
+        this.handleError(PopupSliderCaptcha.ERROR_TYPES.TIMEOUT_ERROR, '请求被取消');
+      } else if (error.message.includes('Failed to fetch') || error.message.includes('NetworkError')) {
+        this.handleError(PopupSliderCaptcha.ERROR_TYPES.NETWORK_ERROR, '网络连接失败');
+      } else {
+        this.handleError(PopupSliderCaptcha.ERROR_TYPES.CAPTCHA_DATA_ERROR, error.message, error);
+      }
     }
   }
 
+  // 优化：添加验证码数据验证方法
+  validateCaptchaData(data) {
+    if (!data || typeof data !== 'object') return false
+    
+    const requiredFields = ['canvasSrc', 'blockSrc', 'canvasWidth', 'canvasHeight', 'blockWidth', 'blockHeight', 'blockY', 'nonceStr'];
+    const dataObj = data.data || data;
+    
+    return requiredFields.every(field => {
+      const value = dataObj[field];
+      return value !== null && value !== undefined && value !== ''
+    })
+  }
+
   async renderCaptcha() {
     return new Promise((resolve, reject) => {
-      let loadedCount = 0;
-      const onLoad = () => ++loadedCount === 2 && (this.hideLoading(), resolve());
-      const onError = () => reject(new Error("图片加载失败"));
-
-      this.loadImage(this.elements.backgroundImg, this.captchaData.canvasSrc, {
-        width: this.captchaData.canvasWidth,
-        height: this.captchaData.canvasHeight
-      }, onLoad, onError);
-
-      this.loadImage(this.elements.sliderImg, this.captchaData.blockSrc, {
-        width: this.captchaData.blockWidth,
-        height: this.captchaData.blockHeight,
-        top: this.captchaData.blockY
-      }, onLoad, onError);
+      let hasError = false;
+
+      // 优化：并行加载图片，提高性能
+      const loadPromises = [
+        this.loadImageAsync(this.elements.backgroundImg, this.captchaData.canvasSrc, {
+          width: this.captchaData.canvasWidth,
+          height: this.captchaData.canvasHeight
+        }),
+        this.loadImageAsync(this.elements.sliderImg, this.captchaData.blockSrc, {
+          width: this.captchaData.blockWidth,
+          height: this.captchaData.blockHeight,
+          top: this.captchaData.blockY
+        })
+      ];
+
+      Promise.all(loadPromises)
+        .then(() => {
+          if (!hasError) {
+            this.hideLoading();
+            resolve();
+          }
+        })
+        .catch((error) => {
+          if (!hasError) {
+            hasError = true;
+            this.handleError(PopupSliderCaptcha.ERROR_TYPES.IMAGE_LOAD_ERROR, '图片加载失败', error);
+            reject(error);
+          }
+        });
+    })
+  }
+
+  // 优化：添加异步图片加载方法
+  async loadImageAsync(imgElement, src, styles) {
+    return new Promise((resolve, reject) => {
+      // 检查缓存
+      if (this.imageCache.has(src)) {
+        const cachedImg = this.imageCache.get(src);
+        imgElement.src = cachedImg.src;
+        this.applyStyles(imgElement, styles);
+        resolve();
+        return
+      }
+
+      const timeoutId = this.safeSetTimeout(() => {
+        reject(new Error('图片加载超时'));
+      }, 10000); // 10秒超时
+
+      imgElement.onload = () => {
+        this.safeClearTimeout(timeoutId);
+        this.imageCache.set(src, imgElement.cloneNode());
+        resolve();
+      };
+      
+      imgElement.onerror = (error) => {
+        this.safeClearTimeout(timeoutId);
+        reject(error);
+      };
+      
+      imgElement.src = src;
+      this.applyStyles(imgElement, styles);
     })
   }
 
@@ -536,38 +672,68 @@ class PopupSliderCaptcha {
     }
 
     try {
-      const controller = new AbortController();
-      const timeoutId = this.safeSetTimeout(() => controller.abort(), this.options.timeout);
+      // 取消之前的验证请求
+      if (this.abortController) {
+        this.abortController.abort();
+      }
+      this.abortController = new AbortController();
 
       const response = await fetch(this.options.verifyUrl, {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: { 
+          "Content-Type": "application/json",
+          ...this.options.headers
+        },
         body: JSON.stringify({
           loginVo: {
             nonceStr: this.captchaData.nonceStr,
             value: this.getPosition()
           },
-          dragEventList: [...this.times]
+          dragEventList: [...this.times],
+          ...this.options.verifyData
         }),
-        signal: controller.signal
+        signal: this.abortController.signal
       });
 
-      this.safeClearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+      }
 
-      if (!response.ok) throw new Error(`HTTP ${response.status}`)
       const data = await response.json();
 
-      if (data.code === "0" || data.success === true) {
-        this.onVerifySuccess(data.data);
+      // 优化：更灵活的验证结果判断
+      if (this.isVerifySuccess(data)) {
+        this.onVerifySuccess(data.data || data.result);
       } else {
-        this.onVerifyFail(data.message || "验证失败，请重试！");
+        this.onVerifyFail(data.message || data.msg || "验证失败，请重试！");
       }
     } catch (error) {
-      const message = error.name === 'AbortError' ? "验证超时，请重试" : "网络错误";
-      this.onVerifyFail(message);
+      if (error.name === 'AbortError') {
+        this.handleError(PopupSliderCaptcha.ERROR_TYPES.TIMEOUT_ERROR, '验证请求被取消');
+      } else if (error.message.includes('Failed to fetch') || error.message.includes('NetworkError')) {
+        this.handleError(PopupSliderCaptcha.ERROR_TYPES.NETWORK_ERROR, '网络连接失败');
+      } else {
+        this.handleError(PopupSliderCaptcha.ERROR_TYPES.VALIDATION_ERROR, error.message, error);
+      }
     }
   }
 
+  // 优化：添加验证成功判断方法
+  isVerifySuccess(data) {
+    if (!data || typeof data !== 'object') return false
+    
+    // 支持多种成功标识
+    const successIndicators = [
+      data.code === "0",
+      data.code === 0,
+      data.success === true,
+      data.status === 'success',
+      data.result === true
+    ];
+    
+    return successIndicators.some(indicator => indicator === true)
+  }
+
   onVerifySuccess(ticket) {
     const duration = Date.now() - this.startTime;
     const durationText = `验证成功！耗时：${(duration / 1000).toFixed(2)}s`;
@@ -708,36 +874,66 @@ class PopupSliderCaptcha {
   }
 
   destroy() {
-    // 恢复body样式
-    document.body.style.userSelect = "";
-    document.body.style.cursor = "";
+    try {
+      // 取消所有进行中的请求
+      if (this.abortController) {
+        this.abortController.abort();
+        this.abortController = null;
+      }
 
-    // 清理所有定时器
-    this.clearAllTimers();
+      // 恢复body样式
+      if (document.body) {
+        document.body.style.userSelect = "";
+        document.body.style.cursor = "";
+      }
 
-    // 移除所有事件监听器
-    this.removeAllEventListeners();
+      // 清理所有定时器
+      this.clearAllTimers();
 
-    // 清理图片资源
-    this.cleanupImages();
+      // 移除所有事件监听器
+      this.removeAllEventListeners();
 
-    // 移除DOM元素
-    if (this.elements.overlay?.parentNode) {
-      this.elements.overlay.parentNode.removeChild(this.elements.overlay);
-    }
+      // 清理图片资源
+      this.cleanupImages();
 
-    // 清理样式表
-    const styleElement = document.getElementById('slider-captcha-styles');
-    if (styleElement) {
-      styleElement.remove();
-    }
+      // 移除DOM元素
+      if (this.elements?.overlay?.parentNode) {
+        this.elements.overlay.parentNode.removeChild(this.elements.overlay);
+      }
 
-    // 清空所有属性
-    Object.keys(this).forEach(key => {
-      if (key !== 'constructor') {
-        this[key] = null;
+      // 清理样式表（只有在没有其他实例使用时才删除）
+      const styleElement = document.getElementById('slider-captcha-styles');
+      if (styleElement && !this.hasOtherInstances()) {
+        styleElement.remove();
       }
-    });
+
+      // 清空缓存
+      this.imageCache.clear();
+      this.cachedDimensions = null;
+
+      // 清空所有属性
+      Object.keys(this).forEach(key => {
+        if (key !== 'constructor') {
+          this[key] = null;
+        }
+      });
+
+      // 调用销毁回调
+      if (this.options.onDestroy) {
+        this.options.onDestroy();
+      }
+    } catch (error) {
+      console.error('销毁滑块验证码时出错:', error);
+    }
+  }
+
+  // 优化：检查是否有其他实例在使用样式
+  hasOtherInstances() {
+    // 简单的检查方式，可以通过全局计数器实现
+    if (typeof window !== 'undefined') {
+      return window.sliderCaptchaInstanceCount > 1
+    }
+    return false
   }
 
   static create(options) {
@@ -762,27 +958,48 @@ if (typeof module !== "undefined" && module.exports) {
   window.SliderCaptcha = PopupSliderCaptcha;
 }
 
+// Add ES6 export for modern module systems
+var PopupSliderCaptcha$1 = PopupSliderCaptcha;
+
 /**
  * 密码校验工具类
  * 提供密码加密和校验功能
  */
 class PasswordValidator {
+  // 优化：添加常量定义
+  static CONSTANTS = {
+    DEFAULT_TIMEOUT: 10000,
+    CACHE_DURATION: 5 * 60 * 1000, // 5分钟缓存
+    MAX_RETRY_ATTEMPTS: 3,
+    MIN_PASSWORD_LENGTH: 1
+  }
+
+  // 优化：添加错误类型枚举
+  static ERROR_TYPES = {
+    NETWORK_ERROR: 'NETWORK_ERROR',
+    TIMEOUT_ERROR: 'TIMEOUT_ERROR',
+    ENCRYPTION_ERROR: 'ENCRYPTION_ERROR',
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+    PUBLIC_KEY_ERROR: 'PUBLIC_KEY_ERROR'
+  }
+
   constructor(options = {}) {
+    // 优化：合并配置，使用常量
     this.options = {
-      // 获取公钥的接口地址
       publicKeyUrl: options.publicKeyUrl || '/microservice/strongPassword/getPublicKey',
-      // 密码校验接口地址
       validateUrl: options.validateUrl || '/microservice/strongPassword/checkPassword',
-      // 请求超时时间
-      timeout: options.timeout || 10000,
-      // 自定义请求头
+      timeout: options.timeout || PasswordValidator.CONSTANTS.DEFAULT_TIMEOUT,
       headers: options.headers || {},
+      retryAttempts: options.retryAttempts || PasswordValidator.CONSTANTS.MAX_RETRY_ATTEMPTS,
+      cacheDuration: options.cacheDuration || PasswordValidator.CONSTANTS.CACHE_DURATION,
       ...options
     };
 
     // 缓存公钥，避免重复请求
     this.publicKeyCache = null;
     this.publicKeyExpiry = null;
+    this.retryCount = 0;
+    this.abortController = null;
   }
 
   /**
@@ -790,31 +1007,94 @@ class PasswordValidator {
    * @returns {Promise<string>} 公钥字符串
    */
   async getPublicKey() {
-    // 检查缓存是否有效（5分钟有效期）
+    // 检查缓存是否有效
     if (this.publicKeyCache && this.publicKeyExpiry && Date.now() < this.publicKeyExpiry) {
       return this.publicKeyCache
     }
 
     try {
+      // 取消之前的请求
+      if (this.abortController) {
+        this.abortController.abort();
+      }
+      this.abortController = new AbortController();
+
       const response = await this.makeRequest(this.options.publicKeyUrl, {
-        method: 'GET'
+        method: 'GET',
+        signal: this.abortController.signal
       });
 
-      if (response.code !== '0' ) {
-        throw new Error('获取公钥失败：' + (response.message || '未知错误'))
+      // 优化：更灵活的成功判断
+      if (!this.isSuccessResponse(response)) {
+        throw new Error('获取公钥失败：' + (response.message || response.msg || '未知错误'))
+      }
+
+      // 验证公钥格式
+      const publicKey = response.data || response.result;
+      if (!this.validatePublicKey(publicKey)) {
+        throw new Error('公钥格式无效')
       }
 
-      // 缓存公钥，设置5分钟过期时间
-      this.publicKeyCache = response.data;
-      this.publicKeyExpiry = Date.now() + 5 * 60 * 1000;
+      // 缓存公钥
+      this.publicKeyCache = publicKey;
+      this.publicKeyExpiry = Date.now() + this.options.cacheDuration;
 
       return this.publicKeyCache
     } catch (error) {
       console.error('获取公钥失败:', error);
+      this.handleError(PasswordValidator.ERROR_TYPES.PUBLIC_KEY_ERROR, error.message, error);
       throw new Error('获取公钥失败: ' + error.message)
     }
   }
 
+  // 优化：添加响应成功判断方法
+  isSuccessResponse(response) {
+    if (!response || typeof response !== 'object') return false
+
+    const successIndicators = [
+      response.code === '0',
+      response.code === 0,
+      response.success === true,
+      response.status === 'success',
+      response.result === true
+    ];
+
+    return successIndicators.some(indicator => indicator === true)
+  }
+
+  // 优化：添加公钥验证方法
+  validatePublicKey(publicKey) {
+    if (!publicKey || typeof publicKey !== 'string') return false
+
+    // 基本的RSA公钥格式检查
+    const rsaPattern = /^-----BEGIN PUBLIC KEY-----[\s\S]*-----END PUBLIC KEY-----$/;
+    return rsaPattern.test(publicKey.trim())
+  }
+
+  // 优化：添加统一错误处理方法
+  handleError(errorType, message, originalError = null) {
+    const errorMessages = {
+      [PasswordValidator.ERROR_TYPES.NETWORK_ERROR]: '网络连接失败，请检查网络设置',
+      [PasswordValidator.ERROR_TYPES.TIMEOUT_ERROR]: '请求超时，请重试',
+      [PasswordValidator.ERROR_TYPES.ENCRYPTION_ERROR]: '密码加密失败',
+      [PasswordValidator.ERROR_TYPES.VALIDATION_ERROR]: '密码验证失败',
+      [PasswordValidator.ERROR_TYPES.PUBLIC_KEY_ERROR]: '获取公钥失败'
+    };
+
+    const errorMessage = errorMessages[errorType] || message || '未知错误';
+
+    // 调用用户自定义错误处理
+    if (this.options.onError) {
+      this.options.onError({
+        type: errorType,
+        message: errorMessage,
+        originalError
+      });
+    }
+
+    console.error(`密码校验器错误 [${errorType}]:`, errorMessage, originalError);
+  }
+
   /**
    * 使用RSA公钥加密密码
    * @param {string} password 原始密码
@@ -823,9 +1103,22 @@ class PasswordValidator {
    */
   encryptPassword(password, publicKey) {
     try {
+      // 优化：输入验证
+      if (!password || typeof password !== 'string') {
+        throw new Error('密码不能为空')
+      }
+
+      if (password.length < PasswordValidator.CONSTANTS.MIN_PASSWORD_LENGTH) {
+        throw new Error('密码长度不足')
+      }
+
+      if (!publicKey || typeof publicKey !== 'string') {
+        throw new Error('公钥不能为空')
+      }
+
       // 使用导入的JSEncrypt进行RSA加密
-      if (!JSEncrypt) {
-        throw new Error('JSEncrypt库未正确加载')
+      if (typeof JSEncrypt === 'undefined') {
+        throw new Error('JSEncrypt库未正确加载，请确保已引入JSEncrypt库')
       }
 
       const encrypt = new JSEncrypt();
@@ -833,12 +1126,13 @@ class PasswordValidator {
       const encrypted = encrypt.encrypt(password);
 
       if (!encrypted) {
-        throw new Error('密码加密失败')
+        throw new Error('密码加密失败，可能是公钥格式不正确')
       }
 
       return encrypted
     } catch (error) {
       console.error('密码加密失败:', error);
+      this.handleError(PasswordValidator.ERROR_TYPES.ENCRYPTION_ERROR, error.message, error);
       throw new Error('密码加密失败: ' + error.message)
     }
   }
@@ -846,12 +1140,24 @@ class PasswordValidator {
   /**
    * 校验密码
    * @param {string} password 原始密码
-   * @param {string} userName 用户
+   * @param {string} userName 用户名
    * @param {Object} additionalData 额外的校验数据
    * @returns {Promise<Object>} 校验结果
    */
   async validatePassword(password, userName, additionalData = {}) {
     try {
+      // 优化：输入验证
+      if (!password || typeof password !== 'string') {
+        throw new Error('密码不能为空')
+      }
+
+      if (!userName || typeof userName !== 'string') {
+        throw new Error('用户名不能为空')
+      }
+
+      // 重置重试计数
+      this.retryCount = 0;
+
       // 1. 获取公钥
       const publicKey = await this.getPublicKey();
 
@@ -869,15 +1175,34 @@ class PasswordValidator {
         })
       });
 
+      // 优化：统一返回格式
       return {
-       ...response
+        success: this.isSuccessResponse(response),
+        data: response.data || response.result,
+        message: response.message || response.msg || '验证完成',
+        code: response.code || response.status,
+        originalResponse: response
       }
     } catch (error) {
       console.error('密码校验失败:', error);
+
+      // 优化：根据错误类型返回不同的错误信息
+      let errorType = PasswordValidator.ERROR_TYPES.VALIDATION_ERROR;
+      if (error.message.includes('网络') || error.message.includes('fetch')) {
+        errorType = PasswordValidator.ERROR_TYPES.NETWORK_ERROR;
+      } else if (error.message.includes('超时') || error.message.includes('timeout')) {
+        errorType = PasswordValidator.ERROR_TYPES.TIMEOUT_ERROR;
+      } else if (error.message.includes('加密')) {
+        errorType = PasswordValidator.ERROR_TYPES.ENCRYPTION_ERROR;
+      }
+
+      this.handleError(errorType, error.message, error);
+
       return {
         success: false,
-        message: error.msg,
-        code: 'VALIDATION_ERROR'
+        message: error.message || '密码校验失败',
+        code: errorType,
+        error: error
       }
     }
   }
@@ -889,8 +1214,15 @@ class PasswordValidator {
    * @returns {Promise<Object>} 响应结果
    */
   async makeRequest(url, options = {}) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
+    // 优化：使用实例的abortController
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+    this.abortController = new AbortController();
+
+    const timeoutId = setTimeout(() => {
+      this.abortController.abort();
+    }, this.options.timeout);
 
     try {
       const response = await fetch(url, {
@@ -900,7 +1232,7 @@ class PasswordValidator {
           ...this.options.headers,
           ...options.headers
         },
-        signal: controller.signal
+        signal: this.abortController.signal
       });
 
       clearTimeout(timeoutId);
@@ -909,14 +1241,27 @@ class PasswordValidator {
         throw new Error(`HTTP错误: ${response.status} ${response.statusText}`)
       }
 
-      return await response.json()
+      const data = await response.json();
+
+      // 优化：记录请求日志（开发环境）
+      if (this.options.debug) {
+        console.log('密码校验器请求:', { url, options, response: data });
+      }
+
+      return data
     } catch (error) {
       clearTimeout(timeoutId);
 
       if (error.name === 'AbortError') {
+        this.handleError(PasswordValidator.ERROR_TYPES.TIMEOUT_ERROR, '请求超时', error);
         throw new Error('请求超时')
       }
 
+      if (error.message.includes('Failed to fetch') || error.message.includes('NetworkError')) {
+        this.handleError(PasswordValidator.ERROR_TYPES.NETWORK_ERROR, '网络连接失败', error);
+        throw new Error('网络连接失败')
+      }
+
       throw error
     }
   }
@@ -938,8 +1283,65 @@ class PasswordValidator {
     // 清除缓存，使用新配置重新获取
     this.clearCache();
   }
+
+  /**
+   * 取消当前请求
+   */
+  cancelRequest() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+  }
+
+  /**
+   * 检查是否正在请求中
+   * @returns {boolean} 是否正在请求
+   */
+  isRequesting() {
+    return this.abortController && !this.abortController.signal.aborted
+  }
+
+  /**
+   * 获取缓存状态
+   * @returns {Object} 缓存状态信息
+   */
+  getCacheStatus() {
+    return {
+      hasCache: !!this.publicKeyCache,
+      isExpired: this.publicKeyExpiry ? Date.now() > this.publicKeyExpiry : true,
+      expiryTime: this.publicKeyExpiry,
+      remainingTime: this.publicKeyExpiry ? Math.max(0, this.publicKeyExpiry - Date.now()) : 0
+    }
+  }
+
+  /**
+   * 销毁实例，清理资源
+   */
+  destroy() {
+    try {
+      // 取消所有进行中的请求
+      this.cancelRequest();
+
+      // 清除缓存
+      this.clearCache();
+
+      // 重置状态
+      this.retryCount = 0;
+
+      // 调用销毁回调
+      if (this.options.onDestroy) {
+        this.options.onDestroy();
+      }
+    } catch (error) {
+      console.error('销毁密码校验器时出错:', error);
+    }
+  }
 }
 
+// 导出类和创建实例的工厂函数
+var PasswordValidator$1 = PasswordValidator;
+
 /**
  * 创建密码校验器实例的工厂函数
  * @param {Object} options 配置选项
@@ -967,19 +1369,19 @@ async function validatePassword(password, options = {}, additionalData = {}) {
 
 // 默认导出（向后兼容）
 var index = {
-  PopupSliderCaptcha,
-  PasswordValidator,
+  PopupSliderCaptcha: PopupSliderCaptcha$1,
+  PasswordValidator: PasswordValidator$1,
   createPasswordValidator,
   validatePassword
 };
 
 // 全局注册（用于UMD构建）
 if (typeof window !== 'undefined') {
-  window.SliderCaptcha = PopupSliderCaptcha;
-  window.PopupSliderCaptcha = PopupSliderCaptcha;
-  window.PasswordValidator = PasswordValidator;
+  window.SliderCaptcha = PopupSliderCaptcha$1;
+  window.PopupSliderCaptcha = PopupSliderCaptcha$1;
+  window.PasswordValidator = PasswordValidator$1;
   window.createPasswordValidator = createPasswordValidator;
   window.validatePassword = validatePassword;
 }
 
-export { PasswordValidator, PopupSliderCaptcha, createPasswordValidator, index as default, validatePassword };
+export { PasswordValidator$1 as PasswordValidator, PopupSliderCaptcha$1 as PopupSliderCaptcha, createPasswordValidator, index as default, validatePassword };