@hlw-uni-mp/request 1.0.0

package/dist/index.js

@@ -0,0 +1,717 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target2, all) => {
+  for (var name in all)
+    __defProp(target2, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  InterceptorManager: () => InterceptorManager,
+  UniHttpClient: () => UniHttpClient,
+  calculateSign: () => calculateSign,
+  client: () => client,
+  default: () => index_default,
+  del: () => del,
+  doUpload: () => doUpload,
+  encryptRsa: () => encryptRsa,
+  get: () => get,
+  getClient: () => getClient,
+  getDevice: () => getDevice,
+  getHttpOptions: () => getHttpOptions,
+  http: () => http,
+  post: () => post,
+  postUploadSign: () => postUploadSign,
+  put: () => put,
+  request: () => request,
+  setupHttp: () => setupHttp,
+  sha256: () => sha256,
+  sortString: () => sortString,
+  uploadFile: () => uploadFile,
+  uploadOss: () => uploadOss
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/device/index.ts
+var deviceCache = null;
+var currentNetworkType = "";
+try {
+  if (typeof uni !== "undefined" && uni.getNetworkType) {
+    uni.getNetworkType({
+      success(res) {
+        currentNetworkType = res.networkType || "";
+        if (deviceCache) {
+          deviceCache.networkType = currentNetworkType;
+        }
+      }
+    });
+    if (uni.onNetworkStatusChange) {
+      uni.onNetworkStatusChange((res) => {
+        currentNetworkType = res.networkType || "";
+        if (deviceCache) {
+          deviceCache.networkType = currentNetworkType;
+        }
+      });
+    }
+  }
+} catch {
+}
+function getDevice() {
+  if (deviceCache) return deviceCache;
+  const deviceRaw = uni.getDeviceInfo?.() || {};
+  const windowRaw = uni.getWindowInfo?.() || {};
+  const appRaw = uni.getAppBaseInfo?.() || {};
+  const system = deviceRaw.system || "";
+  deviceCache = {
+    appid: uni.getAccountInfoSync?.().miniProgram?.appId || "",
+    appName: appRaw.appName || "",
+    version: appRaw.appVersion || "",
+    versionCode: appRaw.appVersionCode || "",
+    channel: appRaw.appChannel || "",
+    deviceId: deviceRaw.deviceId || "",
+    deviceType: deviceRaw.deviceType || "",
+    deviceOrientation: windowRaw.deviceOrientation || "portrait",
+    brand: deviceRaw.brand || "",
+    model: deviceRaw.model || "",
+    system,
+    os: system.split(" ")[0] || "",
+    pixelRatio: windowRaw.pixelRatio || 0,
+    screenWidth: windowRaw.screenWidth || 0,
+    screenHeight: windowRaw.screenHeight || 0,
+    windowWidth: windowRaw.windowWidth || 0,
+    windowHeight: windowRaw.windowHeight || 0,
+    statusBarHeight: windowRaw.statusBarHeight || 0,
+    sdkVersion: appRaw.SDKVersion || "",
+    hostName: appRaw.hostName || "",
+    hostVersion: appRaw.hostVersion || "",
+    hostLanguage: appRaw.hostLanguage || "",
+    hostTheme: appRaw.hostTheme || "",
+    platform: deviceRaw.platform || "",
+    language: appRaw.appLanguage || "",
+    networkType: currentNetworkType,
+    benchmarkLevel: deviceRaw.benchmarkLevel || 0,
+    theme: appRaw.theme || "light",
+    fontSizeSetting: appRaw.fontSizeSetting || 16
+  };
+  return deviceCache;
+}
+
+// src/crypto/rsa.ts
+function base64ToBytes(b64) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  const str = b64.replace(/[\r\n\s=]/g, "");
+  const bytes = [];
+  for (let i = 0; i < str.length; i += 4) {
+    const b0 = chars.indexOf(str[i]);
+    const b1 = chars.indexOf(str[i + 1]);
+    const b2 = i + 2 < str.length ? chars.indexOf(str[i + 2]) : 64;
+    const b3 = i + 3 < str.length ? chars.indexOf(str[i + 3]) : 64;
+    bytes.push(b0 << 2 | b1 >> 4);
+    if (b2 !== 64 && b2 !== -1) {
+      bytes.push((b1 & 15) << 4 | b2 >> 2);
+    }
+    if (b3 !== 64 && b3 !== -1) {
+      bytes.push((b2 & 3) << 6 | b3);
+    }
+  }
+  return new Uint8Array(bytes);
+}
+function bytesToBase64(bytes) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  let res = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const b2 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    res += chars[b0 >> 2];
+    res += chars[(b0 & 3) << 4 | b1 >> 4];
+    res += i + 1 < bytes.length ? chars[(b1 & 15) << 2 | b2 >> 6] : "=";
+    res += i + 2 < bytes.length ? chars[b2 & 63] : "=";
+  }
+  return res;
+}
+function stringToUtf8(str) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(str);
+  }
+  const code = unescape(encodeURIComponent(str));
+  const bytes = new Uint8Array(code.length);
+  for (let i = 0; i < code.length; i++) {
+    bytes[i] = code.charCodeAt(i);
+  }
+  return bytes;
+}
+function modPow(base, exp, mod) {
+  let res = 1n;
+  base = base % mod;
+  while (exp > 0n) {
+    if (exp & 1n) res = res * base % mod;
+    base = base * base % mod;
+    exp >>= 1n;
+  }
+  return res;
+}
+function parseDerInt(bytes, offset) {
+  if (bytes[offset] !== 2) {
+    throw new Error("ASN.1 \u89E3\u6790\u9519\u8BEF: \u975E INTEGER \u6807\u8BC6");
+  }
+  let len = bytes[offset + 1];
+  let lenBytes = 1;
+  if (len & 128) {
+    const count = len & 127;
+    len = 0;
+    for (let i = 0; i < count; i++) {
+      len = len << 8 | bytes[offset + 2 + i];
+    }
+    lenBytes = 1 + count;
+  }
+  const start = offset + 1 + lenBytes;
+  let val = 0n;
+  for (let i = start; i < start + len; i++) {
+    val = val << 8n | BigInt(bytes[i]);
+  }
+  return { val, nextOffset: start + len };
+}
+function parseSpki(der) {
+  let bitStringStart = -1;
+  for (let i = 0; i < der.length - 1; i++) {
+    if (der[i] === 3) {
+      let len = der[i + 1];
+      let contentOffset = i + 2;
+      if (len & 128) {
+        const count = len & 127;
+        contentOffset = i + 2 + count;
+      }
+      if (der[contentOffset] === 0 && der[contentOffset + 1] === 48) {
+        bitStringStart = contentOffset + 1;
+        break;
+      }
+    }
+  }
+  const rsaSeqOffset = bitStringStart !== -1 ? bitStringStart : 0;
+  let offset = rsaSeqOffset;
+  if (der[offset] === 48) {
+    let len = der[offset + 1];
+    let headerLen = 2;
+    if (len & 128) {
+      headerLen = 2 + (len & 127);
+    }
+    offset += headerLen;
+  }
+  const mod = parseDerInt(der, offset);
+  const exp = parseDerInt(der, mod.nextOffset);
+  return { n: mod.val, e: exp.val };
+}
+function parsePublicKey(pemOrBase64) {
+  const clean = pemOrBase64.replace(/-----BEGIN[A-Z\s]+-----/g, "").replace(/-----END[A-Z\s]+-----/g, "").replace(/[\r\n\s]/g, "");
+  const der = base64ToBytes(clean);
+  const { n, e } = parseSpki(der);
+  let hex = n.toString(16);
+  if (hex.length % 2 !== 0) hex = "0" + hex;
+  const keyBytes = hex.length / 2;
+  return { n, e, keyBytes };
+}
+function getRandomNonZeroByte() {
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    const buf = new Uint8Array(1);
+    while (true) {
+      crypto.getRandomValues(buf);
+      if (buf[0] !== 0) return buf[0];
+    }
+  }
+  while (true) {
+    const val = Math.floor(Math.random() * 256);
+    if (val !== 0) return val;
+  }
+}
+function encryptBlock(block, key) {
+  const k = key.keyBytes;
+  const mLen = block.length;
+  if (mLen > k - 11) {
+    throw new Error(`\u660E\u6587\u5206\u5757\u5927\u5C0F (${mLen}) \u8D85\u51FA RSA-${k * 8} \u6700\u5927\u9650\u5236 (${k - 11})`);
+  }
+  const em = new Uint8Array(k);
+  em[0] = 0;
+  em[1] = 2;
+  const psLen = k - mLen - 3;
+  for (let i = 0; i < psLen; i++) {
+    em[2 + i] = getRandomNonZeroByte();
+  }
+  em[2 + psLen] = 0;
+  em.set(block, 2 + psLen + 1);
+  let m = 0n;
+  for (let i = 0; i < em.length; i++) {
+    m = m << 8n | BigInt(em[i]);
+  }
+  const c = modPow(m, key.e, key.n);
+  const cBytes = new Uint8Array(k);
+  let temp = c;
+  for (let i = k - 1; i >= 0; i--) {
+    cBytes[i] = Number(temp & 0xffn);
+    temp >>= 8n;
+  }
+  return cBytes;
+}
+function encryptRsa(plaintext, publicKey) {
+  if (!plaintext || !publicKey) return "";
+  const key = parsePublicKey(publicKey);
+  const maxBlockSize = key.keyBytes - 11;
+  const dataBytes = stringToUtf8(plaintext);
+  const totalBlocks = Math.ceil(dataBytes.length / maxBlockSize) || 1;
+  const result = new Uint8Array(totalBlocks * key.keyBytes);
+  for (let i = 0; i < totalBlocks; i++) {
+    const start = i * maxBlockSize;
+    const end = Math.min(start + maxBlockSize, dataBytes.length);
+    const chunk = dataBytes.slice(start, end);
+    const encryptedChunk = encryptBlock(chunk, key);
+    result.set(encryptedChunk, i * key.keyBytes);
+  }
+  return bytesToBase64(result);
+}
+
+// src/crypto/sign.ts
+var import_crypto_js = __toESM(require("crypto-js"));
+function sha256(rawInput) {
+  return import_crypto_js.default.SHA256(rawInput).toString();
+}
+function sortString(data) {
+  if (data === null || data === void 0 || data === "") return "";
+  if (typeof data === "boolean") return data ? "true" : "false";
+  if (typeof data !== "object") return String(data);
+  if (Array.isArray(data)) {
+    return "[" + data.map((item) => sortString(item)).join(",") + "]";
+  }
+  const keys = Object.keys(data).sort();
+  const parts = [];
+  for (const key of keys) {
+    const val = data[key];
+    if (val !== null && val !== void 0) {
+      parts.push(`${key}=${sortString(val)}`);
+    }
+  }
+  return parts.join("&");
+}
+function calculateSign(options) {
+  const ts = String(options.timestamp);
+  const nonce = options.nonce;
+  const context = options.context;
+  const secret = options.secret || "";
+  const dataStr = sortString(options.data);
+  const raw = `ts=${ts}&nonce=${nonce}&context=${context}&data=${dataStr}&key=${secret}`;
+  return sha256(raw);
+}
+
+// src/oss.ts
+async function uploadOss(oss, source) {
+  const filePath = typeof source === "string" ? source : source?.path || source?.tempFilePath || "";
+  const name = oss.filename || filePath?.split("/").pop() || "file";
+  const formData = {
+    key: String(oss.key || ""),
+    success_action_status: "200"
+  };
+  if (oss.policy) formData.policy = String(oss.policy);
+  if (oss.OSSAccessKeyId) formData.OSSAccessKeyId = String(oss.OSSAccessKeyId);
+  if (oss.signature) formData.signature = String(oss.signature);
+  if (oss["x-oss-security-token"]) formData["x-oss-security-token"] = String(oss["x-oss-security-token"]);
+  const target2 = String(oss.host || "");
+  return new Promise((resolve, reject) => {
+    uni.uploadFile({
+      url: target2,
+      filePath,
+      name: "file",
+      formData,
+      header: {
+        "Content-Disposition": `inline;filename=${encodeURIComponent(name || "file")}`
+      },
+      success: (res) => {
+        if (res.statusCode === 200 || res.statusCode === 204) {
+          resolve(String(oss.url || ""));
+        } else {
+          reject(new Error(`\u4E0A\u4F20\u963F\u91CC\u4E91\u5931\u8D25 (${res.statusCode}): ${res.data || ""}`));
+        }
+      },
+      fail: (error) => reject(new Error(error.errMsg || "\u4E0A\u4F20\u963F\u91CC\u4E91\u5931\u8D25"))
+    });
+  });
+}
+
+// src/upload.ts
+function getFileExt(filePath) {
+  const ext = filePath.split("?")[0].split(".").pop()?.toLowerCase() || "";
+  return ["jpg", "jpeg", "png", "webp", "mp4", "mp3", "gif"].includes(ext) ? ext : "jpg";
+}
+function buildFormData(cred) {
+  if (cred.type === "local") {
+    return { key: cred.key };
+  }
+  if (cred.type === "alioss") {
+    const anyCred = cred;
+    return {
+      key: cred.key,
+      policy: cred.policy,
+      OSSAccessKeyId: cred.OSSAccessKeyId || anyCred.oSSAccessKeyId || anyCred.ossAccessKeyId || "",
+      Signature: cred.Signature || anyCred.signature || "",
+      success_action_status: cred.success_action_status || anyCred.successActionStatus || "200"
+    };
+  }
+  return {
+    key: cred.key,
+    token: cred.token
+  };
+}
+function decodeUtf8(value) {
+  if (!value) return value;
+  try {
+    return decodeURIComponent(escape(value));
+  } catch {
+    return value;
+  }
+}
+function buildHeader(cred, customHeader) {
+  if (cred.type !== "local" && !customHeader) {
+    return void 0;
+  }
+  const opts = getHttpOptions();
+  const devInfo = opts.getDevice?.() || getDevice();
+  const token = opts.getToken?.() || "";
+  const appid = devInfo?.appid || "";
+  const headers = { ...customHeader };
+  if (cred.type === "local") {
+    if (appid) headers["X-Appid"] = String(appid);
+    if (token) headers["X-Token"] = String(token);
+  }
+  return headers;
+}
+function postUploadSign(data, signUrl = "/api/v1.upload/sign") {
+  return post(signUrl, data);
+}
+function doUpload(cred, filePath, customHeader) {
+  return new Promise((resolve, reject) => {
+    uni.uploadFile({
+      url: cred.server,
+      filePath,
+      name: "file",
+      formData: buildFormData(cred),
+      header: buildHeader(cred, customHeader),
+      success: (res) => {
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          reject(new Error(`\u4E0A\u4F20\u5931\u8D25 (${res.statusCode})`));
+          return;
+        }
+        if (cred.type !== "local") {
+          resolve();
+          return;
+        }
+        try {
+          const body = JSON.parse(decodeUtf8(res.data));
+          body.code === 1 ? resolve() : reject(new Error(body.msg || "\u4E0A\u4F20\u5931\u8D25"));
+        } catch {
+          reject(new Error("\u54CD\u5E94\u89E3\u6790\u5931\u8D25"));
+        }
+      },
+      fail: (error) => reject(new Error(error?.errMsg || "\u4E0A\u4F20\u5931\u8D25"))
+    });
+  });
+}
+async function uploadFile(params) {
+  const ext = params.ext || getFileExt(params.filePath);
+  const signUrl = params.signUrl || "/api/v1.upload/sign";
+  const signRes = await postUploadSign({ biz: params.biz, ext, size: params.size }, signUrl);
+  if (signRes.code !== 1 || !signRes.data) {
+    throw new Error(signRes.msg || "\u83B7\u53D6\u4E0A\u4F20\u51ED\u8BC1\u5931\u8D25");
+  }
+  const cred = signRes.data;
+  await doUpload(cred, params.filePath, params.header);
+  return cred.url;
+}
+
+// src/index.ts
+var InterceptorManager = class {
+  constructor() {
+    this.handlers = [];
+  }
+  use(fulfilled, rejected) {
+    this.handlers.push({ fulfilled, rejected });
+    return this.handlers.length - 1;
+  }
+  eject(id) {
+    if (this.handlers[id]) {
+      this.handlers[id] = null;
+    }
+  }
+  forEach(fn) {
+    for (const h of this.handlers) {
+      if (h !== null) fn(h);
+    }
+  }
+};
+var UniHttpClient = class {
+  constructor(options = {}) {
+    this.defaults = {
+      baseURL: "",
+      timeout: 15e3,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      }
+    };
+    this.interceptors = {
+      request: new InterceptorManager(),
+      response: new InterceptorManager()
+    };
+    if (options.baseURL) this.defaults.baseURL = options.baseURL.replace(/\/+$/, "");
+    if (options.timeout) this.defaults.timeout = options.timeout;
+    if (options.headers) this.defaults.headers = { ...this.defaults.headers, ...options.headers };
+  }
+  async request(config) {
+    const cfg = {
+      method: "GET",
+      ...config,
+      baseURL: config.baseURL ?? this.defaults.baseURL,
+      headers: { ...this.defaults.headers, ...config.headers },
+      timeout: config.timeout ?? this.defaults.timeout
+    };
+    const requestChain = [];
+    this.interceptors.request.forEach((h) => {
+      requestChain.push(h.fulfilled, h.rejected);
+    });
+    let promise = Promise.resolve(cfg);
+    while (requestChain.length) {
+      promise = promise.then(requestChain.shift(), requestChain.shift());
+    }
+    let responsePromise = promise.then(async (finalConfig) => {
+      const fullUrl = this.resolveUrl(finalConfig.url, finalConfig.baseURL);
+      return this.send(fullUrl, finalConfig);
+    });
+    const responseChain = [];
+    this.interceptors.response.forEach((h) => {
+      responseChain.push(h.fulfilled, h.rejected);
+    });
+    while (responseChain.length) {
+      responsePromise = responsePromise.then(responseChain.shift(), responseChain.shift());
+    }
+    return responsePromise;
+  }
+  get(url, config) {
+    return this.request({ ...config, url, method: "GET" });
+  }
+  post(url, data, config) {
+    return this.request({ ...config, url, method: "POST", data });
+  }
+  put(url, data, config) {
+    return this.request({ ...config, url, method: "PUT", data });
+  }
+  delete(url, config) {
+    return this.request({ ...config, url, method: "DELETE" });
+  }
+  resolveUrl(url, baseURL) {
+    if (/^(https?:)?\/\//.test(url) || url.startsWith("file://")) return url;
+    const base = (baseURL || this.defaults.baseURL || "").replace(/\/+$/, "");
+    const path = url.startsWith("/") ? url : `/${url}`;
+    return base ? `${base}${path}` : path;
+  }
+  send(url, cfg) {
+    return new Promise((resolve, reject) => {
+      const isGet = (cfg.method || "GET").toUpperCase() === "GET";
+      const requestData = isGet ? cfg.params ?? cfg.data : cfg.data ?? cfg.params;
+      uni.request({
+        url,
+        method: cfg.method?.toUpperCase() || "GET",
+        data: requestData,
+        header: cfg.headers,
+        timeout: cfg.timeout,
+        success: (res) => {
+          const response = {
+            data: res.data,
+            status: res.statusCode,
+            statusText: String(res.statusCode),
+            headers: res.header || {},
+            config: cfg
+          };
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(response);
+          } else {
+            const body = res.data;
+            const error = new Error(String(body?.msg || `\u8BF7\u6C42\u5931\u8D25: ${res.statusCode}`));
+            error.response = response;
+            error.status = res.statusCode;
+            reject(error);
+          }
+        },
+        fail: (errorResult) => {
+          const error = new Error(errorResult.errMsg || "\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25");
+          error.config = cfg;
+          reject(error);
+        }
+      });
+    });
+  }
+};
+var target = null;
+var currentOptions = {};
+var lastToastTime = 0;
+function handleUnauthorized(message, callback) {
+  const now = Date.now();
+  if (now - lastToastTime > 3e3) {
+    lastToastTime = now;
+    if (typeof uni !== "undefined" && uni.showToast) {
+      uni.showToast({ title: message, icon: "none" });
+    }
+  }
+  if (callback) {
+    callback(message);
+  }
+}
+function getClient() {
+  if (target) {
+    if (currentOptions.baseURL && !target.defaults.baseURL) {
+      target.defaults.baseURL = currentOptions.baseURL;
+    }
+    return target;
+  }
+  const base = currentOptions.baseURL || "";
+  const inst = new UniHttpClient({
+    baseURL: base,
+    timeout: currentOptions.timeout || 15e3
+  });
+  inst.interceptors.request.use(
+    async (config) => {
+      const devInfo = currentOptions.getDevice?.() || getDevice();
+      const token = currentOptions.getToken?.() || "";
+      const time = Date.now();
+      const nonce = Math.random().toString(36).substring(2, 12);
+      const payload = {
+        ...devInfo,
+        token
+      };
+      const jsonStr = JSON.stringify(payload);
+      const pubKey = currentOptions.publicKey || "";
+      const secret = currentOptions.secret || "";
+      let cipher = "";
+      if (pubKey) {
+        cipher = encryptRsa(jsonStr, pubKey);
+      } else {
+        cipher = encodeURIComponent(jsonStr);
+      }
+      const signData = config.data || config.params || {};
+      const sign = calculateSign({
+        timestamp: time,
+        nonce,
+        context: cipher,
+        secret,
+        data: signData
+      });
+      config.headers = config.headers || {};
+      config.headers["X-Client-Timestamp"] = String(time);
+      config.headers["X-Client-Nonce"] = nonce;
+      config.headers["X-Client-Sign"] = sign;
+      config.headers["X-Client-Context"] = cipher;
+      if (devInfo.appid) {
+        config.headers["x-appid"] = String(devInfo.appid);
+      }
+      return config;
+    },
+    (error) => Promise.reject(error)
+  );
+  inst.interceptors.response.use(
+    async (response) => {
+      const res = response.data;
+      if (res && (res.code === 401 || res.code === 403)) {
+        const message = res.msg || "\u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55";
+        handleUnauthorized(message, currentOptions.onUnauthorized);
+      }
+      return response;
+    },
+    (error) => {
+      const status = error.response?.status;
+      const message = error.response?.data?.msg || error.message || "\u7F51\u7EDC\u8FDE\u63A5\u5F02\u5E38";
+      if (status === 401 || status === 403) {
+        handleUnauthorized(message, currentOptions.onUnauthorized);
+      }
+      return Promise.reject(error);
+    }
+  );
+  target = inst;
+  return inst;
+}
+function setupHttp(options = {}) {
+  currentOptions = { ...currentOptions, ...options };
+  if (target && options.baseURL) {
+    target.defaults.baseURL = options.baseURL;
+  }
+  return getClient();
+}
+function request(config) {
+  return getClient().request(config).then((res) => res.data);
+}
+function get(url, params) {
+  return request({ url, method: "GET", params });
+}
+function post(url, data) {
+  return request({ url, method: "POST", data });
+}
+function put(url, data) {
+  return request({ url, method: "PUT", data });
+}
+function del(url, params) {
+  return request({ url, method: "DELETE", params });
+}
+function getHttpOptions() {
+  return currentOptions;
+}
+var client = new Proxy({}, {
+  get(_, prop) {
+    const inst = getClient();
+    const val = inst[prop];
+    return typeof val === "function" ? val.bind(inst) : val;
+  }
+});
+var http = client;
+var index_default = request;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InterceptorManager,
+  UniHttpClient,
+  calculateSign,
+  client,
+  del,
+  doUpload,
+  encryptRsa,
+  get,
+  getClient,
+  getDevice,
+  getHttpOptions,
+  http,
+  post,
+  postUploadSign,
+  put,
+  request,
+  setupHttp,
+  sha256,
+  sortString,
+  uploadFile,
+  uploadOss
+});