@unicom-cloud/utils 0.1.24 → 0.1.26

package/axios/lib/core/Axios.js

@@ -0,0 +1,170 @@
+/* 2025-11-04 10:32:44 */
+import R from "../helpers/buildURL.js";
+import m from "../helpers/validator.js";
+import d from "../utils.js";
+import S from "./AxiosHeaders.js";
+import q from "./InterceptorManager.js";
+import T from "./buildFullPath.js";
+import U from "./dispatchRequest.js";
+import w from "./mergeConfig.js";
+const i = m.validators;
+class k {
+  constructor(t) {
+    this.defaults = t || {}, this.interceptors = {
+      request: new q(),
+      response: new q()
+    };
+  }
+  /**
+   * Dispatch a request
+   *
+   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
+   * @param {?Object} config
+   *
+   * @returns {Promise} The Promise to be fulfilled
+   */
+  async request(t, e) {
+    try {
+      return await this._request(t, e);
+    } catch (r) {
+      if (r instanceof Error) {
+        let o = {};
+        Error.captureStackTrace ? Error.captureStackTrace(o) : o = new Error();
+        const s = o.stack ? o.stack.replace(/^.+\n/, "") : "";
+        try {
+          r.stack ? s && !String(r.stack).endsWith(s.replace(/^.+\n.+\n/, "")) && (r.stack += `
+` + s) : r.stack = s;
+        } catch {
+        }
+      }
+      throw r;
+    }
+  }
+  _request(t, e) {
+    typeof t == "string" ? (e = e || {}, e.url = t) : e = t || {}, e = w(this.defaults, e);
+    const { transitional: r, paramsSerializer: o, headers: s } = e;
+    r !== void 0 && m.assertOptions(
+      r,
+      {
+        silentJSONParsing: i.transitional(i.boolean),
+        forcedJSONParsing: i.transitional(i.boolean),
+        clarifyTimeoutError: i.transitional(i.boolean)
+      },
+      !1
+    ), o != null && (d.isFunction(o) ? e.paramsSerializer = {
+      serialize: o
+    } : m.assertOptions(
+      o,
+      {
+        encode: i.function,
+        serialize: i.function
+      },
+      !0
+    )), e.allowAbsoluteUrls !== void 0 || (this.defaults.allowAbsoluteUrls !== void 0 ? e.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls : e.allowAbsoluteUrls = !0), m.assertOptions(
+      e,
+      {
+        baseUrl: i.spelling("baseURL"),
+        withXsrfToken: i.spelling("withXSRFToken")
+      },
+      !0
+    ), e.method = (e.method || this.defaults.method || "get").toLowerCase();
+    let f = s && d.merge(s.common, s[e.method]);
+    s && d.forEach(
+      ["delete", "get", "head", "post", "put", "patch", "common"],
+      (a) => {
+        delete s[a];
+      }
+    ), e.headers = S.concat(f, s);
+    const h = [];
+    let b = !0;
+    this.interceptors.request.forEach(
+      function(n) {
+        typeof n.runWhen == "function" && n.runWhen(e) === !1 || (b = b && n.synchronous, h.unshift(
+          n.fulfilled,
+          n.rejected
+        ));
+      }
+    );
+    const c = [];
+    this.interceptors.response.forEach(
+      function(n) {
+        c.push(
+          n.fulfilled,
+          n.rejected
+        );
+      }
+    );
+    let u, l = 0, p;
+    if (!b) {
+      const a = [U.bind(this), void 0];
+      for (a.unshift(...h), a.push(...c), p = a.length, u = Promise.resolve(e); l < p; )
+        u = u.then(a[l++], a[l++]);
+      return u;
+    }
+    p = h.length;
+    let y = e;
+    for (; l < p; ) {
+      const a = h[l++], n = h[l++];
+      try {
+        y = a(y);
+      } catch (A) {
+        n.call(this, A);
+        break;
+      }
+    }
+    try {
+      u = U.call(this, y);
+    } catch (a) {
+      return Promise.reject(a);
+    }
+    for (l = 0, p = c.length; l < p; )
+      u = u.then(
+        c[l++],
+        c[l++]
+      );
+    return u;
+  }
+  getUri(t) {
+    t = w(this.defaults, t);
+    const e = T(
+      t.baseURL,
+      t.url,
+      t.allowAbsoluteUrls
+    );
+    return R(e, t.params, t.paramsSerializer);
+  }
+}
+d.forEach(
+  ["delete", "get", "head", "options"],
+  function(t) {
+    k.prototype[t] = function(e, r) {
+      return this.request(
+        w(r || {}, {
+          method: t,
+          url: e,
+          data: (r || {}).data
+        })
+      );
+    };
+  }
+);
+d.forEach(["post", "put", "patch"], function(t) {
+  function e(r) {
+    return function(s, f, h) {
+      return this.request(
+        w(h || {}, {
+          method: t,
+          headers: r ? {
+            "Content-Type": "multipart/form-data"
+          } : {},
+          url: s,
+          data: f
+        })
+      );
+    };
+  }
+  k.prototype[t] = e(), k.prototype[t + "Form"] = e(!0);
+});
+export {
+  k as default
+};

package/axios/lib/core/AxiosError.js

@@ -0,0 +1,64 @@
+/* 2025-11-04 10:32:44 */
+import c from "../utils.js";
+function r(t, i, o, a, e) {
+  Error.call(this), Error.captureStackTrace ? Error.captureStackTrace(this, this.constructor) : this.stack = new Error().stack, this.message = t, this.name = "AxiosError", i && (this.code = i), o && (this.config = o), a && (this.request = a), e && (this.response = e, this.status = e.status ? e.status : null);
+}
+c.inherits(r, Error, {
+  toJSON: function() {
+    return {
+      // Standard
+      message: this.message,
+      name: this.name,
+      // Microsoft
+      description: this.description,
+      number: this.number,
+      // Mozilla
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      // Axios
+      config: c.toJSONObject(this.config),
+      code: this.code,
+      status: this.status
+    };
+  }
+});
+const u = r.prototype, R = {};
+[
+  "ERR_BAD_OPTION_VALUE",
+  "ERR_BAD_OPTION",
+  "ECONNABORTED",
+  "ETIMEDOUT",
+  "ERR_NETWORK",
+  "ERR_FR_TOO_MANY_REDIRECTS",
+  "ERR_DEPRECATED",
+  "ERR_BAD_RESPONSE",
+  "ERR_BAD_REQUEST",
+  "ERR_CANCELED",
+  "ERR_NOT_SUPPORT",
+  "ERR_INVALID_URL"
+].forEach((t) => {
+  R[t] = { value: t };
+});
+Object.defineProperties(r, R);
+Object.defineProperty(u, "isAxiosError", { value: !0 });
+r.from = (t, i, o, a, e, E) => {
+  const s = Object.create(u);
+  c.toFlatObject(
+    t,
+    s,
+    function(m) {
+      return m !== Error.prototype;
+    },
+    (n) => n !== "isAxiosError"
+  );
+  const l = t && t.message ? t.message : "Error", h = i == null && t ? t.code : i;
+  return r.call(s, l, h, o, a, e), t && s.cause == null && Object.defineProperty(s, "cause", {
+    value: t,
+    configurable: !0
+  }), s.name = t && t.name || "Error", E && Object.assign(s, E), s;
+};
+export {
+  r as default
+};

package/axios/lib/core/AxiosHeaders.js

@@ -0,0 +1,192 @@
+/* 2025-11-04 10:32:44 */
+import A from "../helpers/parseHeaders.js";
+import i from "../utils.js";
+const h = Symbol("internals");
+function y(o) {
+  return o && String(o).trim().toLowerCase();
+}
+function m(o) {
+  return o === !1 || o == null ? o : i.isArray(o) ? o.map(m) : String(o);
+}
+function S(o) {
+  const t = /* @__PURE__ */ Object.create(null), e = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
+  let s;
+  for (; s = e.exec(o); )
+    t[s[1]] = s[2];
+  return t;
+}
+const k = (o) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(o.trim());
+function g(o, t, e, s, n) {
+  if (i.isFunction(s))
+    return s.call(this, t, e);
+  if (n && (t = e), !!i.isString(t)) {
+    if (i.isString(s))
+      return t.indexOf(s) !== -1;
+    if (i.isRegExp(s))
+      return s.test(t);
+  }
+}
+function E(o) {
+  return o.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (t, e, s) => e.toUpperCase() + s);
+}
+function j(o, t) {
+  const e = i.toCamelCase(" " + t);
+  ["get", "set", "has"].forEach((s) => {
+    Object.defineProperty(o, s + e, {
+      value: function(n, r, f) {
+        return this[s].call(this, t, n, r, f);
+      },
+      configurable: !0
+    });
+  });
+}
+class b {
+  constructor(t) {
+    t && this.set(t);
+  }
+  set(t, e, s) {
+    const n = this;
+    function r(c, l, a) {
+      const u = y(l);
+      if (!u)
+        throw new Error("header name must be a non-empty string");
+      const p = i.findKey(n, u);
+      (!p || n[p] === void 0 || a === !0 || a === void 0 && n[p] !== !1) && (n[p || l] = m(c));
+    }
+    const f = (c, l) => i.forEach(
+      c,
+      (a, u) => r(a, u, l)
+    );
+    if (i.isPlainObject(t) || t instanceof this.constructor)
+      f(t, e);
+    else if (i.isString(t) && (t = t.trim()) && !k(t))
+      f(A(t), e);
+    else if (i.isObject(t) && i.isIterable(t)) {
+      let c = {}, l, a;
+      for (const u of t) {
+        if (!i.isArray(u))
+          throw TypeError("Object iterator must return a key-value pair");
+        c[a = u[0]] = (l = c[a]) ? i.isArray(l) ? [...l, u[1]] : [l, u[1]] : u[1];
+      }
+      f(c, e);
+    } else
+      t != null && r(e, t, s);
+    return this;
+  }
+  get(t, e) {
+    if (t = y(t), t) {
+      const s = i.findKey(this, t);
+      if (s) {
+        const n = this[s];
+        if (!e)
+          return n;
+        if (e === !0)
+          return S(n);
+        if (i.isFunction(e))
+          return e.call(this, n, s);
+        if (i.isRegExp(e))
+          return e.exec(n);
+        throw new TypeError("parser must be boolean|regexp|function");
+      }
+    }
+  }
+  has(t, e) {
+    if (t = y(t), t) {
+      const s = i.findKey(this, t);
+      return !!(s && this[s] !== void 0 && (!e || g(this, this[s], s, e)));
+    }
+    return !1;
+  }
+  delete(t, e) {
+    const s = this;
+    let n = !1;
+    function r(f) {
+      if (f = y(f), f) {
+        const c = i.findKey(s, f);
+        c && (!e || g(s, s[c], c, e)) && (delete s[c], n = !0);
+      }
+    }
+    return i.isArray(t) ? t.forEach(r) : r(t), n;
+  }
+  clear(t) {
+    const e = Object.keys(this);
+    let s = e.length, n = !1;
+    for (; s--; ) {
+      const r = e[s];
+      (!t || g(this, this[r], r, t, !0)) && (delete this[r], n = !0);
+    }
+    return n;
+  }
+  normalize(t) {
+    const e = this, s = {};
+    return i.forEach(this, (n, r) => {
+      const f = i.findKey(s, r);
+      if (f) {
+        e[f] = m(n), delete e[r];
+        return;
+      }
+      const c = t ? E(r) : String(r).trim();
+      c !== r && delete e[r], e[c] = m(n), s[c] = !0;
+    }), this;
+  }
+  concat(...t) {
+    return this.constructor.concat(this, ...t);
+  }
+  toJSON(t) {
+    const e = /* @__PURE__ */ Object.create(null);
+    return i.forEach(this, (s, n) => {
+      s != null && s !== !1 && (e[n] = t && i.isArray(s) ? s.join(", ") : s);
+    }), e;
+  }
+  [Symbol.iterator]() {
+    return Object.entries(this.toJSON())[Symbol.iterator]();
+  }
+  toString() {
+    return Object.entries(this.toJSON()).map(([t, e]) => t + ": " + e).join(`
+`);
+  }
+  getSetCookie() {
+    return this.get("set-cookie") || [];
+  }
+  get [Symbol.toStringTag]() {
+    return "AxiosHeaders";
+  }
+  static from(t) {
+    return t instanceof this ? t : new this(t);
+  }
+  static concat(t, ...e) {
+    const s = new this(t);
+    return e.forEach((n) => s.set(n)), s;
+  }
+  static accessor(t) {
+    const s = (this[h] = this[h] = {
+      accessors: {}
+    }).accessors, n = this.prototype;
+    function r(f) {
+      const c = y(f);
+      s[c] || (j(n, f), s[c] = !0);
+    }
+    return i.isArray(t) ? t.forEach(r) : r(t), this;
+  }
+}
+b.accessor([
+  "Content-Type",
+  "Content-Length",
+  "Accept",
+  "Accept-Encoding",
+  "User-Agent",
+  "Authorization"
+]);
+i.reduceDescriptors(b.prototype, ({ value: o }, t) => {
+  let e = t[0].toUpperCase() + t.slice(1);
+  return {
+    get: () => o,
+    set(s) {
+      this[e] = s;
+    }
+  };
+});
+i.freezeMethods(b);
+export {
+  b as default
+};

package/axios/lib/core/InterceptorManager.js

@@ -0,0 +1,59 @@
+/* 2025-11-04 10:32:44 */
+import n from "../utils.js";
+class a {
+  constructor() {
+    this.handlers = [];
+  }
+  /**
+   * Add a new interceptor to the stack
+   *
+   * @param {Function} fulfilled The function to handle `then` for a `Promise`
+   * @param {Function} rejected The function to handle `reject` for a `Promise`
+   *
+   * @return {Number} An ID used to remove interceptor later
+   */
+  use(s, h, r) {
+    return this.handlers.push({
+      fulfilled: s,
+      rejected: h,
+      synchronous: r ? r.synchronous : !1,
+      runWhen: r ? r.runWhen : null
+    }), this.handlers.length - 1;
+  }
+  /**
+   * Remove an interceptor from the stack
+   *
+   * @param {Number} id The ID that was returned by `use`
+   *
+   * @returns {void}
+   */
+  eject(s) {
+    this.handlers[s] && (this.handlers[s] = null);
+  }
+  /**
+   * Clear all interceptors from the stack
+   *
+   * @returns {void}
+   */
+  clear() {
+    this.handlers && (this.handlers = []);
+  }
+  /**
+   * Iterate over all the registered interceptors
+   *
+   * This method is particularly useful for skipping over any
+   * interceptors that may have become `null` calling `eject`.
+   *
+   * @param {Function} fn The function to call for each interceptor
+   *
+   * @returns {void}
+   */
+  forEach(s) {
+    n.forEach(this.handlers, function(r) {
+      r !== null && s(r);
+    });
+  }
+}
+export {
+  a as default
+};

package/axios/lib/core/buildFullPath.js

@@ -0,0 +1,10 @@
+/* 2025-11-04 10:32:44 */
+import r from "../helpers/combineURLs.js";
+import f from "../helpers/isAbsoluteURL.js";
+function u(l, i, t) {
+  let o = !f(i);
+  return l && (o || t == !1) ? r(l, i) : i;
+}
+export {
+  u as default
+};

package/axios/lib/core/dispatchRequest.js

@@ -0,0 +1,35 @@
+/* 2025-11-04 10:32:44 */
+import p from "../adapters/adapters.js";
+import l from "../cancel/CanceledError.js";
+import m from "../cancel/isCancel.js";
+import r from "./AxiosHeaders.js";
+import o from "../defaults/index.js";
+import a from "./transformData.js";
+function d(e) {
+  if (e.cancelToken && e.cancelToken.throwIfRequested(), e.signal && e.signal.aborted)
+    throw new l(null, e);
+}
+function q(e) {
+  return d(e), e.headers = r.from(e.headers), e.data = a.call(e, e.transformRequest), ["post", "put", "patch"].indexOf(e.method) !== -1 && e.headers.setContentType("application/x-www-form-urlencoded", !1), p.getAdapter(
+    e.adapter || o.adapter,
+    e
+  )(e).then(
+    function(t) {
+      return d(e), t.data = a.call(
+        e,
+        e.transformResponse,
+        t
+      ), t.headers = r.from(t.headers), t;
+    },
+    function(t) {
+      return m(t) || (d(e), t && t.response && (t.response.data = a.call(
+        e,
+        e.transformResponse,
+        t.response
+      ), t.response.headers = r.from(t.response.headers))), Promise.reject(t);
+    }
+  );
+}
+export {
+  q as default
+};

package/axios/lib/core/mergeConfig.js

@@ -0,0 +1,74 @@
+/* 2025-11-04 10:32:44 */
+import i from "../utils.js";
+import h from "./AxiosHeaders.js";
+const c = (s) => s instanceof h ? { ...s } : s;
+function x(s, f) {
+  f = f || {};
+  const u = {};
+  function o(t, e, r, d) {
+    return i.isPlainObject(t) && i.isPlainObject(e) ? i.merge.call({ caseless: d }, t, e) : i.isPlainObject(e) ? i.merge({}, e) : i.isArray(e) ? e.slice() : e;
+  }
+  function l(t, e, r, d) {
+    if (i.isUndefined(e)) {
+      if (!i.isUndefined(t))
+        return o(void 0, t, r, d);
+    } else return o(t, e, r, d);
+  }
+  function a(t, e) {
+    if (!i.isUndefined(e))
+      return o(void 0, e);
+  }
+  function n(t, e) {
+    if (i.isUndefined(e)) {
+      if (!i.isUndefined(t))
+        return o(void 0, t);
+    } else return o(void 0, e);
+  }
+  function m(t, e, r) {
+    if (r in f)
+      return o(t, e);
+    if (r in s)
+      return o(void 0, t);
+  }
+  const g = {
+    url: a,
+    method: a,
+    data: a,
+    baseURL: n,
+    transformRequest: n,
+    transformResponse: n,
+    paramsSerializer: n,
+    timeout: n,
+    timeoutMessage: n,
+    withCredentials: n,
+    withXSRFToken: n,
+    adapter: n,
+    responseType: n,
+    xsrfCookieName: n,
+    xsrfHeaderName: n,
+    onUploadProgress: n,
+    onDownloadProgress: n,
+    decompress: n,
+    maxContentLength: n,
+    maxBodyLength: n,
+    beforeRedirect: n,
+    transport: n,
+    httpAgent: n,
+    httpsAgent: n,
+    cancelToken: n,
+    socketPath: n,
+    responseEncoding: n,
+    validateStatus: m,
+    headers: (t, e, r) => l(c(t), c(e), r, !0)
+  };
+  return i.forEach(
+    Object.keys({ ...s, ...f }),
+    function(e) {
+      const r = g[e] || l, d = r(s[e], f[e], e);
+      i.isUndefined(d) && r !== m || (u[e] = d);
+    }
+  ), u;
+}
+export {
+  x as default
+};

package/axios/lib/core/settle.js

@@ -0,0 +1,17 @@
+/* 2025-11-04 10:32:44 */
+import a from "./AxiosError.js";
+function E(i, f, t) {
+  const u = t.config.validateStatus;
+  !t.status || !u || u(t.status) ? i(t) : f(
+    new a(
+      "Request failed with status code " + t.status,
+      [a.ERR_BAD_REQUEST, a.ERR_BAD_RESPONSE][Math.floor(t.status / 100) - 4],
+      t.config,
+      t.request,
+      t
+    )
+  );
+}
+export {
+  E as default
+};

package/axios/lib/core/transformData.js

@@ -0,0 +1,19 @@
+/* 2025-11-04 10:32:44 */
+import e from "./AxiosHeaders.js";
+import s from "../defaults/index.js";
+import m from "../utils.js";
+function h(f, t) {
+  const a = this || s, r = t || a, n = e.from(r.headers);
+  let o = r.data;
+  return m.forEach(f, function(i) {
+    o = i.call(
+      a,
+      o,
+      n.normalize(),
+      t ? t.status : void 0
+    );
+  }), n.normalize(), o;
+}
+export {
+  h as default
+};