mix-public 1.0.0

package/resource/cookie.js

@@ -0,0 +1,224 @@
+class indexedDb {
+  constructor(dbName, version, storeName) {
+    this.dbName = dbName
+    this.version = version
+    this.storeName = storeName
+    this.indexdbrequest = window.indexedDB.open(dbName, version)
+    this.db
+    this.indexdbrequest.onsuccess = this.onsuccess
+    this.indexdbrequest.onerror = this.onerror
+    this.indexdbrequest.onupgradeneeded = this.onupgradeneeded
+  }
+  onsuccess = (event) => {
+    this.db = event.target.result // 数据库对象
+  }
+  onerror = (event) => {
+    console.log("indexdb error :", event)
+  }
+  onupgradeneeded = (event) => {
+    // 数据库创建或升级的时候会触发
+    this.db = event.target.result // 数据库对象
+    let objectStore
+    if (!this.db.objectStoreNames.contains(this.storeName)) {
+      objectStore = this.db.createObjectStore(this.storeName, { keyPath: "id" }) // 创建表
+      // objectStore.createIndex('name', 'name', { unique: true }) // 创建索引 可以让你搜索任意字段
+    }
+  }
+  // 添加数据
+  addData(data) {
+    return new Promise((resolve, reject) => {
+      const req = this.db
+        ?.transaction([this.storeName], "readwrite") // 事务对象 指定表格名称和操作模式（"只读"或"读写"）
+        .objectStore(this.storeName) // 仓库对象
+        .add(data)
+
+      if (!req) return
+      // 操作成功
+      req["onsuccess"] = function (event) {
+        resolve({
+          code: 200,
+          success: true,
+          data: req.result,
+          msg: "数据添加成功!",
+        })
+      }
+      // 操作失败
+      req.onerror = function (event) {
+        let data = {
+          code: -1,
+          success: false,
+          data: req.result,
+          msg: "数据添加失败!",
+        }
+        resolve(data)
+      }
+    })
+  }
+
+  // 根据id获取数据
+  getDataByKey(key) {
+    return new Promise((resolve, reject) => {
+      const req = this.db
+        ?.transaction([this.storeName])
+        .objectStore(this.storeName)
+        .get(key)
+      if (!req) return
+
+      // 操作成功
+      req["onsuccess"] = function (event) {
+        resolve({
+          code: 200,
+          success: true,
+          data: req.result,
+          msg: "数据获取成功!",
+        })
+      }
+      // 操作失败
+      req.onerror = function (event) {
+        let data = {
+          code: -1,
+          success: false,
+          data: req.result,
+          msg: "数据获取失败!",
+        }
+        resolve(data)
+      }
+    })
+  }
+
+  // 根据id修改数据
+  updateDBfunction(data) {
+    return new Promise((resolve, reject) => {
+      const req = this.db
+        ?.transaction([this.storeName], "readwrite")
+        .objectStore(this.storeName)
+        .put(data)
+      if (!req) return
+
+      // 操作成功
+      req["onsuccess"] = function (event) {
+        resolve({ code: 200, success: true, data: null, msg: "数据更新成功!" })
+      }
+      // 操作失败
+      req.onerror = function (event) {
+        let data = {
+          code: -1,
+          success: false,
+          data: null,
+          msg: "数据更新失败!",
+        }
+        resolve(data)
+      }
+    })
+  }
+
+  // 根据id删除数据
+  deleteDB(id) {
+    return new Promise((resolve, reject) => {
+      let req = this.db
+        ?.transaction([this.storeName], "readwrite")
+        .objectStore(this.storeName)
+        .delete(id)
+      if (!req) return
+
+      // 操作成功
+      req["onsuccess"] = function (event) {
+        resolve({ code: 200, success: true, data: null, msg: "数据删除成功!" })
+      }
+      // 操作失败
+      req.onerror = function (event) {
+        let data = {
+          code: -1,
+          success: false,
+          data: null,
+          msg: "数据删除失败!",
+        }
+        resolve(data)
+      }
+    })
+  }
+}
+const local = {
+  get: function (e) {
+    return localStorage.getItem(e)
+  },
+  set: function (key, val) {
+    localStorage.setItem(key, val)
+  },
+}
+
+const cookie = {
+  get: function (name) {
+    var arr,
+      reg = new RegExp("(^| )" + name + "=([^;]*)(;|$)")
+    if ((arr = document.cookie.match(reg))) return unescape(arr[2])
+    else return null
+  },
+  set: function (name, value, date = 30) {
+    var Days = date // 设置有效期
+    var exp = new Date()
+    exp.setTime(exp.getTime() + Days * 24 * 60 * 60 * 1000)
+    document.cookie =
+      name + "=" + escape(value) + ";expires=" + exp.toGMTString()
+  },
+  del: function delCookie(name) {
+    var exp = new Date()
+    exp.setTime(exp.getTime() - 1)
+    var cval = getCookie(name)
+    if (cval != null)
+      document.cookie = name + "=" + cval + ";expires=" + exp.toGMTString()
+  },
+}
+
+export const Cookies =  {
+  get: function (
+    name,
+    type = 1,
+    conf = { dbname: "dbname", version: 1, table: "cookies" },
+  ) {
+    switch (type) {
+      case 1:
+        return cookie.get(name)
+      case 2:
+        return local.get(name)
+      case 3:
+        return new Promise((resolve, reject) => {
+          const db = new indexedDb(conf.dbname, conf.version, conf.table)
+          setTimeout(async () => {
+            const res = await db.getDataByKey(name)
+            resolve(res.data?.name)
+          }, 500)
+        })
+    }
+  },
+  set: function (
+    name,
+    value,
+    type = 1,
+    conf = { dbname: "dbname", version: 1, table: "cookies" },
+  ) {
+    switch (type) {
+      case 1:
+        return cookie.set(name, value)
+      case 2:
+        return local.set(name, value)
+      case 3:
+        return new Promise(async (resolve, reject) => {
+          const db = await new indexedDb(conf.dbname, conf.version, conf.table)
+          setTimeout(async () => {
+            const res = await db.getDataByKey(name)
+            if (res.data) {
+              const updata = await db.updateDBfunction({
+                name: value,
+                id: name,
+              })
+              resolve(updata.data)
+            } else {
+              const adddata = await db.addData({ data: value, id: name })
+              resolve(adddata.data)
+            }
+          }, 500)
+        })
+    }
+  },
+}

package/resource/cryptoJS.js

@@ -0,0 +1,57 @@
+/*
+ * @Author: Gui
+ * @Date: 2023-07-04 11:59:05
+ * @LastEditors: guicheng 1625811865@qq.com
+ * @LastEditTime: 2026-01-26 15:29:20
+ * @Description: kxs files
+ * @filePath:
+ */
+import CryptoJS from "crypto-js"
+// 加密
+export const mixLocalShakeDownEncrypt = function (message) {
+  const keyHex = CryptoJS.enc.Utf8.parse("2024SIG4W1SAVDTSA6OV0VN1G07PS3N5")
+  const ivHex = CryptoJS.enc.Utf8.parse("24072615")
+  const srcs = CryptoJS.enc.Utf8.parse(message)
+  const encrypted = CryptoJS.TripleDES.encrypt(srcs, keyHex, {
+    iv: ivHex,
+    mode: CryptoJS.mode.CBC,
+    padding: CryptoJS.pad.Pkcs7,
+  })
+  return encrypted.toString()
+}
+// 解密
+export const mixLocalShakeDownDecrypt = function (message) {
+  try {
+    if (!message) {
+      return message
+    }
+
+    const keyHex = CryptoJS.enc.Utf8.parse("2024SIG4W1SAVDTSA6OV0VN1G07PS3N5")
+    const ivHex = CryptoJS.enc.Utf8.parse("24072615")
+    const base64 = CryptoJS.enc.Base64.parse(message)
+    const src = CryptoJS.enc.Base64.stringify(base64)
+    const decrypt = CryptoJS.TripleDES.decrypt(src, keyHex, {
+      iv: ivHex,
+      mode: CryptoJS.mode.CBC,
+      padding: CryptoJS.pad.Pkcs7,
+    })
+    const decryptedStr = decrypt.toString(CryptoJS.enc.Utf8)
+    return decryptedStr.toString()
+  } catch (err) {
+    return ""
+  }
+}
+// 加密
+export const mixRemoteShakeDownEncrypt = function (message) {
+  const keyHex = CryptoJS.enc.Utf8.parse("CBTU1dD4Kd5pyiGWTsI10jRQ3SvKusSV")
+  const ivHex = CryptoJS.enc.Utf8.parse("DYgjCEIMVrj2W9xN")
+  const srcs = CryptoJS.enc.Utf8.parse(message)
+  const encrypted = CryptoJS.AES.encrypt(srcs, keyHex, {
+    iv: ivHex,
+    mode: CryptoJS.mode.CBC,
+    padding: CryptoJS.pad.Pkcs7,
+  })
+
+  const str = CryptoJS.enc.Utf8.parse(encrypted.toString())
+  return CryptoJS.enc.Base64.stringify(str)
+}

package/resource/http.js

@@ -0,0 +1,349 @@
+/**
+ * 原生JavaScript HTTP请求库
+ * 支持GET、POST、PUT、DELETE等方法
+ * 支持请求/响应拦截器、超时控制、取消请求等功能
+ */
+
+class MixHttpRequest {
+  constructor(config = {}) {
+    this.defaultConfig = {
+      baseURL: 'https://app-manager.kexiaoshuang.com/',
+      timeout: 10000, // 10秒超时
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      ...config
+    };
+    
+    // 拦截器
+    this.interceptors = {
+      request: {
+        use: (onFulfilled, onRejected) => {
+          this.requestInterceptor = { onFulfilled, onRejected };
+        }
+      },
+      response: {
+        use: (onFulfilled, onRejected) => {
+          this.responseInterceptor = { onFulfilled, onRejected };
+        }
+      }
+    };
+    
+    this.requestInterceptor = null;
+    this.responseInterceptor = null;
+    this.abortControllers = new Map(); // 存储AbortController用于取消请求
+  }
+
+  /**
+   * 发送HTTP请求
+   * @param {string} url - 请求URL
+   * @param {Object} config - 请求配置
+   * @returns {Promise} - 返回Promise对象
+   */
+  request(url, config = {}) {
+    // 合并配置
+    const mergedConfig = {
+      ...this.defaultConfig,
+      ...config,
+      headers: {
+        ...this.defaultConfig.headers,
+        ...(config.headers || {})
+      }
+    };
+    
+    // 处理完整URL
+    const fullUrl = mergedConfig.baseURL ? `${mergedConfig.baseURL}${url}` : url;
+    
+    // 创建AbortController用于取消请求
+    const abortController = new AbortController();
+    const requestId = Date.now() + Math.random().toString(36).substr(2, 9);
+    this.abortControllers.set(requestId, abortController);
+    
+    // 请求拦截器
+    let requestConfig = { ...mergedConfig, url: fullUrl, signal: abortController.signal };
+    if (this.requestInterceptor) {
+      try {
+        if (this.requestInterceptor.onFulfilled) {
+          requestConfig = this.requestInterceptor.onFulfilled(requestConfig) || requestConfig;
+        }
+      } catch (error) {
+        if (this.requestInterceptor.onRejected) {
+          return Promise.reject(this.requestInterceptor.onRejected(error));
+        }
+        return Promise.reject(error);
+      }
+    }
+    
+    // 创建请求Promise
+    const requestPromise = new Promise((resolve, reject) => {
+      const { timeout, signal } = requestConfig;
+      
+      // 设置超时
+      let timeoutId;
+      if (timeout > 0) {
+        timeoutId = setTimeout(() => {
+          abortController.abort();
+          reject(new Error(`请求超时 (${timeout}ms)`));
+          this.abortControllers.delete(requestId);
+        }, timeout);
+      }
+      
+      // 发送请求
+      this._sendRequest(requestConfig)
+        .then(response => {
+          clearTimeout(timeoutId);
+          this.abortControllers.delete(requestId);
+          
+          // 响应拦截器
+          if (this.responseInterceptor) {
+            try {
+              if (this.responseInterceptor.onFulfilled) {
+                response = this.responseInterceptor.onFulfilled(response) || response;
+              }
+              resolve(response);
+            } catch (error) {
+              if (this.responseInterceptor.onRejected) {
+                reject(this.responseInterceptor.onRejected(error));
+              } else {
+                reject(error);
+              }
+            }
+          } else {
+            resolve(response);
+          }
+        })
+        .catch(error => {
+          clearTimeout(timeoutId);
+          this.abortControllers.delete(requestId);
+          
+          // 响应拦截器错误处理
+          if (this.responseInterceptor && this.responseInterceptor.onRejected) {
+            reject(this.responseInterceptor.onRejected(error));
+          } else {
+            reject(error);
+          }
+        });
+    });
+    
+    // 添加取消方法
+    requestPromise.cancel = (reason = '请求已被取消') => {
+      abortController.abort();
+      this.abortControllers.delete(requestId);
+      return Promise.reject(new Error(reason));
+    };
+    
+    return requestPromise;
+  }
+
+  /**
+   * 实际发送请求的方法
+   * @param {Object} config - 请求配置
+   * @returns {Promise} - 返回Promise对象
+   */
+  _sendRequest(config) {
+    return new Promise((resolve, reject) => {
+      const { url, method = 'GET', headers, body, signal } = config;
+      
+      // 创建XMLHttpRequest对象
+      const xhr = new XMLHttpRequest();
+      
+      // 初始化请求
+      xhr.open(method.toUpperCase(), url, true);
+      
+      // 设置请求头
+      if (headers) {
+        Object.keys(headers).forEach(key => {
+          if (headers[key] !== null && headers[key] !== undefined) {
+            xhr.setRequestHeader(key, headers[key]);
+          }
+        });
+      }
+      
+      // 处理响应
+      xhr.onload = () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          let responseData;
+          try {
+            // 尝试解析JSON
+            responseData = xhr.responseText ? JSON.parse(xhr.responseText) : xhr.responseText;
+          } catch {
+            // 如果不是JSON，返回原始文本
+            responseData = xhr.responseText;
+          }
+          
+          const response = {
+            data: responseData,
+            status: xhr.status,
+            statusText: xhr.statusText,
+            headers: this._parseResponseHeaders(xhr.getAllResponseHeaders()),
+            config
+          };
+          resolve(response);
+        } else {
+          reject(this._createError(xhr, config));
+        }
+      };
+      
+      // 处理错误
+      xhr.onerror = () => {
+        reject(this._createError(xhr, config));
+      };
+      
+      xhr.onabort = () => {
+        reject(new Error('请求已被取消'));
+      };
+      
+      // 设置中止信号
+      if (signal) {
+        signal.addEventListener('abort', () => {
+          xhr.abort();
+        });
+      }
+      
+      // 发送请求
+      xhr.send(this._prepareRequestBody(body, headers));
+    });
+  }
+
+  /**
+   * 准备请求体
+   * @param {*} body - 请求体数据
+   * @param {Object} headers - 请求头
+   * @returns {*} - 处理后的请求体
+   */
+  _prepareRequestBody(body, headers) {
+    if (!body) return null;
+    
+    const contentType = headers['Content-Type'] || '';
+    
+    if (contentType.includes('application/json')) {
+      return JSON.stringify(body);
+    } else if (contentType.includes('application/x-www-form-urlencoded')) {
+      return new URLSearchParams(body).toString();
+    } else if (body instanceof FormData || body instanceof URLSearchParams) {
+      return body;
+    }
+    
+    return body;
+  }
+
+  /**
+   * 解析响应头
+   * @param {string} headersString - 响应头字符串
+   * @returns {Object} - 解析后的响应头对象
+   */
+  _parseResponseHeaders(headersString) {
+    const headers = {};
+    if (!headersString) return headers;
+    
+    const lines = headersString.trim().split(/[\r\n]+/);
+    lines.forEach(line => {
+      const parts = line.split(': ');
+      const header = parts.shift();
+      const value = parts.join(': ');
+      if (header) {
+        headers[header] = value;
+      }
+    });
+    
+    return headers;
+  }
+
+  /**
+   * 创建错误对象
+   * @param {XMLHttpRequest} xhr - XMLHttpRequest对象
+   * @param {Object} config - 请求配置
+   * @returns {Error} - 错误对象
+   */
+  _createError(xhr, config) {
+    const error = new Error(`请求失败: ${xhr.status} ${xhr.statusText}`);
+    error.status = xhr.status;
+    error.statusText = xhr.statusText;
+    error.config = config;
+    
+    try {
+      error.data = xhr.responseText ? JSON.parse(xhr.responseText) : xhr.responseText;
+    } catch {
+      error.data = xhr.responseText;
+    }
+    
+    return error;
+  }
+
+  /**
+   * GET请求
+   * @param {string} url - 请求URL
+   * @param {Object} config - 请求配置
+   * @returns {Promise} - 返回Promise对象
+   */
+  get(url, config = {}) {
+    return this.request(url, { ...config, method: 'GET' });
+  }
+
+  /**
+   * POST请求
+   * @param {string} url - 请求URL
+   * @param {*} data - 请求数据
+   * @param {Object} config - 请求配置
+   * @returns {Promise} - 返回Promise对象
+   */
+  post(url, data = null, config = {}) {
+    return this.request(url, { ...config, method: 'POST', body: data });
+  }
+
+  /**
+   * PUT请求
+   * @param {string} url - 请求URL
+   * @param {*} data - 请求数据
+   * @param {Object} config - 请求配置
+   * @returns {Promise} - 返回Promise对象
+   */
+  put(url, data = null, config = {}) {
+    return this.request(url, { ...config, method: 'PUT', body: data });
+  }
+
+  /**
+   * DELETE请求
+   * @param {string} url - 请求URL
+   * @param {Object} config - 请求配置
+   * @returns {Promise} - 返回Promise对象
+   */
+  delete(url, config = {}) {
+    return this.request(url, { ...config, method: 'DELETE' });
+  }
+
+  /**
+   * PATCH请求
+   * @param {string} url - 请求URL
+   * @param {*} data - 请求数据
+   * @param {Object} config - 请求配置
+   * @returns {Promise} - 返回Promise对象
+   */
+  patch(url, data = null, config = {}) {
+    return this.request(url, { ...config, method: 'PATCH', body: data });
+  }
+
+  /**
+   * 取消请求
+   * @param {string} requestId - 请求ID
+   */
+  cancelRequest(requestId) {
+    if (this.abortControllers.has(requestId)) {
+      this.abortControllers.get(requestId).abort();
+      this.abortControllers.delete(requestId);
+    }
+  }
+
+  /**
+   * 取消所有待处理请求
+   */
+  cancelAllRequests() {
+    this.abortControllers.forEach(controller => {
+      controller.abort();
+    });
+    this.abortControllers.clear();
+  }
+}
+
+// 创建默认实例
+export const mixHttp = new MixHttpRequest();