@fecp/mobile 1.0.26 → 1.0.28

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/toStringDate.mjs

@@ -0,0 +1,159 @@
+import { __require as requireStaticParseInt } from "./staticParseInt.mjs";
+import { __require as requireHelperGetUTCDateTime } from "./helperGetUTCDateTime.mjs";
+import { __require as requireHelperGetDateTime } from "./helperGetDateTime.mjs";
+import { __require as requireIsString } from "./isString.mjs";
+import { __require as requireIsDate } from "./isDate.mjs";
+var toStringDate_1;
+var hasRequiredToStringDate;
+function requireToStringDate() {
+  if (hasRequiredToStringDate) return toStringDate_1;
+  hasRequiredToStringDate = 1;
+  var staticParseInt = requireStaticParseInt();
+  var helperGetUTCDateTime = requireHelperGetUTCDateTime();
+  var helperGetDateTime = requireHelperGetDateTime();
+  var isString = requireIsString();
+  var isDate = requireIsDate();
+  function getParseRule(txt) {
+    return "(\\d{" + txt + "})";
+  }
+  function toParseMs(num) {
+    if (num < 10) {
+      return num * 100;
+    } else if (num < 100) {
+      return num * 10;
+    }
+    return num;
+  }
+  function toParseNum(num) {
+    return isNaN(num) ? num : staticParseInt(num);
+  }
+  var d2 = getParseRule(2);
+  var d1or2 = getParseRule("1,2");
+  var d1or7 = getParseRule("1,7");
+  var d3or4 = getParseRule("3,4");
+  var place = ".{1}";
+  var d1Or2RE = place + d1or2;
+  var dzZ = "(([zZ])|([-+]\\d{2}:?\\d{2}))";
+  var defaulParseStrs = [d3or4, d1Or2RE, d1Or2RE, d1Or2RE, d1Or2RE, d1Or2RE, place + d1or7, dzZ];
+  var defaulParseREs = [];
+  for (var len = defaulParseStrs.length - 1; len >= 0; len--) {
+    var rule = "";
+    for (var i = 0; i < len + 1; i++) {
+      rule += defaulParseStrs[i];
+    }
+    defaulParseREs.push(new RegExp("^" + rule + "$"));
+  }
+  function parseDefaultRules(str) {
+    var matchRest, resMaps = {};
+    for (var i2 = 0, dfrLen = defaulParseREs.length; i2 < dfrLen; i2++) {
+      matchRest = str.match(defaulParseREs[i2]);
+      if (matchRest) {
+        resMaps.y = matchRest[1];
+        resMaps.M = matchRest[2];
+        resMaps.d = matchRest[3];
+        resMaps.H = matchRest[4];
+        resMaps.m = matchRest[5];
+        resMaps.s = matchRest[6];
+        resMaps.S = matchRest[7];
+        resMaps.Z = matchRest[8];
+        break;
+      }
+    }
+    return resMaps;
+  }
+  var customParseStrs = [
+    ["yyyy", d3or4],
+    ["yy", d2],
+    ["MM", d2],
+    ["M", d1or2],
+    ["dd", d2],
+    ["d", d1or2],
+    ["HH", d2],
+    ["H", d1or2],
+    ["mm", d2],
+    ["m", d1or2],
+    ["ss", d2],
+    ["s", d1or2],
+    ["SSS", getParseRule(3)],
+    ["S", d1or7],
+    ["Z", dzZ]
+  ];
+  var parseRuleMaps = {};
+  var parseRuleKeys = ["\\[([^\\]]+)\\]"];
+  for (var i = 0; i < customParseStrs.length; i++) {
+    var itemRule = customParseStrs[i];
+    parseRuleMaps[itemRule[0]] = itemRule[1] + "?";
+    parseRuleKeys.push(itemRule[0]);
+  }
+  var customParseRes = new RegExp(parseRuleKeys.join("|"), "g");
+  var cacheFormatMaps = {};
+  function parseCustomRules(str, format) {
+    var cacheItem = cacheFormatMaps[format];
+    if (!cacheItem) {
+      var posIndexs = [];
+      var re = format.replace(/([$(){}*+.?\\^|])/g, "\\$1").replace(customParseRes, function(text, val) {
+        var firstChar = text.charAt(0);
+        if (firstChar === "[") {
+          return val;
+        }
+        posIndexs.push(firstChar);
+        return parseRuleMaps[text];
+      });
+      cacheItem = cacheFormatMaps[format] = {
+        _i: posIndexs,
+        _r: new RegExp(re)
+      };
+    }
+    var resMaps = {};
+    var matchRest = str.match(cacheItem._r);
+    if (matchRest) {
+      var _i = cacheItem._i;
+      for (var i2 = 1, len2 = matchRest.length; i2 < len2; i2++) {
+        resMaps[_i[i2 - 1]] = matchRest[i2];
+      }
+      return resMaps;
+    }
+    return resMaps;
+  }
+  function parseTimeZone(resMaps) {
+    if (/^[zZ]/.test(resMaps.Z)) {
+      return new Date(helperGetUTCDateTime(resMaps));
+    } else {
+      var matchRest = resMaps.Z.match(/([-+])(\d{2}):?(\d{2})/);
+      if (matchRest) {
+        return new Date(helperGetUTCDateTime(resMaps) - (matchRest[1] === "-" ? -1 : 1) * staticParseInt(matchRest[2]) * 36e5 + staticParseInt(matchRest[3]) * 6e4);
+      }
+    }
+    return /* @__PURE__ */ new Date("");
+  }
+  function toStringDate(str, format) {
+    if (str) {
+      var isDType = isDate(str);
+      if (isDType || !format && /^[0-9]{11,15}$/.test(str)) {
+        return new Date(isDType ? helperGetDateTime(str) : staticParseInt(str));
+      }
+      if (isString(str)) {
+        var resMaps = format ? parseCustomRules(str, format) : parseDefaultRules(str);
+        if (resMaps.y) {
+          if (resMaps.M) {
+            resMaps.M = toParseNum(resMaps.M) - 1;
+          }
+          if (resMaps.S) {
+            resMaps.S = toParseMs(toParseNum(resMaps.S.substring(0, 3)));
+          }
+          if (resMaps.Z) {
+            return parseTimeZone(resMaps);
+          } else {
+            return new Date(resMaps.y, resMaps.M || 0, resMaps.d || 1, resMaps.H || 0, resMaps.m || 0, resMaps.s || 0, resMaps.S || 0);
+          }
+        }
+      }
+    }
+    return /* @__PURE__ */ new Date("");
+  }
+  toStringDate_1 = toStringDate;
+  return toStringDate_1;
+}
+export {
+  requireToStringDate as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/toStringJSON.mjs

@@ -0,0 +1,26 @@
+import { __require as requireIsPlainObject } from "./isPlainObject.mjs";
+import { __require as requireIsString } from "./isString.mjs";
+var toStringJSON_1;
+var hasRequiredToStringJSON;
+function requireToStringJSON() {
+  if (hasRequiredToStringJSON) return toStringJSON_1;
+  hasRequiredToStringJSON = 1;
+  var isPlainObject = requireIsPlainObject();
+  var isString = requireIsString();
+  function toStringJSON(str) {
+    if (isPlainObject(str)) {
+      return str;
+    } else if (isString(str)) {
+      try {
+        return JSON.parse(str);
+      } catch (e) {
+      }
+    }
+    return {};
+  }
+  toStringJSON_1 = toStringJSON;
+  return toStringJSON_1;
+}
+export {
+  requireToStringJSON as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/toTreeArray.mjs

@@ -0,0 +1,45 @@
+import { __require as requireSetupDefaults } from "./setupDefaults.mjs";
+import { __require as requireArrayEach } from "./arrayEach.mjs";
+import { __require as requireAssign } from "./assign.mjs";
+var toTreeArray_1;
+var hasRequiredToTreeArray;
+function requireToTreeArray() {
+  if (hasRequiredToTreeArray) return toTreeArray_1;
+  hasRequiredToTreeArray = 1;
+  var setupDefaults = requireSetupDefaults();
+  var arrayEach = requireArrayEach();
+  var assign = requireAssign();
+  function unTreeList(result, parentItem, array, opts) {
+    var optKey = opts.key;
+    var optParentKey = opts.parentKey;
+    var optChildren = opts.children;
+    var optData = opts.data;
+    var optUpdated = opts.updated;
+    var optClear = opts.clear;
+    arrayEach(array, function(item) {
+      var childList = item[optChildren];
+      if (optData) {
+        item = item[optData];
+      }
+      if (optUpdated !== false) {
+        item[optParentKey] = parentItem ? parentItem[optKey] : null;
+      }
+      result.push(item);
+      if (childList && childList.length) {
+        unTreeList(result, item, childList, opts);
+      }
+      if (optClear) {
+        delete item[optChildren];
+      }
+    });
+    return result;
+  }
+  function toTreeArray(array, options) {
+    return unTreeList([], null, array, assign({}, setupDefaults.treeOptions, options));
+  }
+  toTreeArray_1 = toTreeArray;
+  return toTreeArray_1;
+}
+export {
+  requireToTreeArray as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/toValueString.mjs

@@ -0,0 +1,23 @@
+import { __require as requireEqNull } from "./eqNull.mjs";
+import { __require as requireIsNumber } from "./isNumber.mjs";
+import { __require as requireToNumberString } from "./toNumberString.mjs";
+var toValueString_1;
+var hasRequiredToValueString;
+function requireToValueString() {
+  if (hasRequiredToValueString) return toValueString_1;
+  hasRequiredToValueString = 1;
+  var eqNull = requireEqNull();
+  var isNumber = requireIsNumber();
+  var toNumberString = requireToNumberString();
+  function toValueString(obj) {
+    if (isNumber(obj)) {
+      return toNumberString(obj);
+    }
+    return "" + (eqNull(obj) ? "" : obj);
+  }
+  toValueString_1 = toValueString;
+  return toValueString_1;
+}
+export {
+  requireToValueString as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/trim.mjs

@@ -0,0 +1,18 @@
+import { __require as requireTrimRight } from "./trimRight.mjs";
+import { __require as requireTrimLeft } from "./trimLeft.mjs";
+var trim_1;
+var hasRequiredTrim;
+function requireTrim() {
+  if (hasRequiredTrim) return trim_1;
+  hasRequiredTrim = 1;
+  var trimRight = requireTrimRight();
+  var trimLeft = requireTrimLeft();
+  function trim(str) {
+    return str && str.trim ? str.trim() : trimRight(trimLeft(str));
+  }
+  trim_1 = trim;
+  return trim_1;
+}
+export {
+  requireTrim as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/trimLeft.mjs

@@ -0,0 +1,16 @@
+import { __require as requireToValueString } from "./toValueString.mjs";
+var trimLeft_1;
+var hasRequiredTrimLeft;
+function requireTrimLeft() {
+  if (hasRequiredTrimLeft) return trimLeft_1;
+  hasRequiredTrimLeft = 1;
+  var toValueString = requireToValueString();
+  function trimLeft(str) {
+    return str && str.trimLeft ? str.trimLeft() : toValueString(str).replace(/^[\s\uFEFF\xA0]+/g, "");
+  }
+  trimLeft_1 = trimLeft;
+  return trimLeft_1;
+}
+export {
+  requireTrimLeft as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/trimRight.mjs

@@ -0,0 +1,16 @@
+import { __require as requireToValueString } from "./toValueString.mjs";
+var trimRight_1;
+var hasRequiredTrimRight;
+function requireTrimRight() {
+  if (hasRequiredTrimRight) return trimRight_1;
+  hasRequiredTrimRight = 1;
+  var toValueString = requireToValueString();
+  function trimRight(str) {
+    return str && str.trimRight ? str.trimRight() : toValueString(str).replace(/[\s\uFEFF\xA0]+$/g, "");
+  }
+  trimRight_1 = trimRight;
+  return trimRight_1;
+}
+export {
+  requireTrimRight as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/unescape.mjs

@@ -0,0 +1,22 @@
+import { __require as requireStaticEscapeMap } from "./staticEscapeMap.mjs";
+import { __require as requireHelperFormatEscaper } from "./helperFormatEscaper.mjs";
+import { __require as requireEach } from "./each.mjs";
+var _unescape;
+var hasRequired_unescape;
+function require_unescape() {
+  if (hasRequired_unescape) return _unescape;
+  hasRequired_unescape = 1;
+  var staticEscapeMap = requireStaticEscapeMap();
+  var helperFormatEscaper = requireHelperFormatEscaper();
+  var each = requireEach();
+  var unescapeMap = {};
+  each(staticEscapeMap, function(item, key) {
+    unescapeMap[staticEscapeMap[key]] = key;
+  });
+  var unescape = helperFormatEscaper(unescapeMap);
+  _unescape = unescape;
+  return _unescape;
+}
+export {
+  require_unescape as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/union.mjs

@@ -0,0 +1,25 @@
+import { __require as requireUniq } from "./uniq.mjs";
+import { __require as requireToArray } from "./toArray.mjs";
+var union_1;
+var hasRequiredUnion;
+function requireUnion() {
+  if (hasRequiredUnion) return union_1;
+  hasRequiredUnion = 1;
+  var uniq = requireUniq();
+  var toArray = requireToArray();
+  function union() {
+    var args = arguments;
+    var result = [];
+    var index = 0;
+    var len = args.length;
+    for (; index < len; index++) {
+      result = result.concat(toArray(args[index]));
+    }
+    return uniq(result);
+  }
+  union_1 = union;
+  return union_1;
+}
+export {
+  requireUnion as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/uniq.mjs

@@ -0,0 +1,42 @@
+import { __require as requireEach } from "./each.mjs";
+import { __require as requireIncludes } from "./includes.mjs";
+import { __require as requireIsFunction } from "./isFunction.mjs";
+import { __require as requireProperty } from "./property.mjs";
+var uniq_1;
+var hasRequiredUniq;
+function requireUniq() {
+  if (hasRequiredUniq) return uniq_1;
+  hasRequiredUniq = 1;
+  var each = requireEach();
+  var includes = requireIncludes();
+  var isFunction = requireIsFunction();
+  var property = requireProperty();
+  function uniq(array, iterate, context) {
+    var result = [];
+    if (iterate) {
+      if (!isFunction(iterate)) {
+        iterate = property(iterate);
+      }
+      var val, valMap = {};
+      each(array, function(item, key) {
+        val = iterate.call(context, item, key, array);
+        if (!valMap[val]) {
+          valMap[val] = 1;
+          result.push(item);
+        }
+      });
+    } else {
+      each(array, function(value) {
+        if (!includes(result, value)) {
+          result.push(value);
+        }
+      });
+    }
+    return result;
+  }
+  uniq_1 = uniq;
+  return uniq_1;
+}
+export {
+  requireUniq as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/uniqueId.mjs

@@ -0,0 +1,18 @@
+import { __require as requireSetupDefaults } from "./setupDefaults.mjs";
+import { __require as requireEqNull } from "./eqNull.mjs";
+var uniqueId_1;
+var hasRequiredUniqueId;
+function requireUniqueId() {
+  if (hasRequiredUniqueId) return uniqueId_1;
+  hasRequiredUniqueId = 1;
+  var setupDefaults = requireSetupDefaults();
+  var eqNull = requireEqNull();
+  function uniqueId(prefix) {
+    return "" + (eqNull(prefix) ? "" : prefix) + setupDefaults.keyId++;
+  }
+  uniqueId_1 = uniqueId;
+  return uniqueId_1;
+}
+export {
+  requireUniqueId as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/unserialize.mjs

@@ -0,0 +1,28 @@
+import { __require as requireStaticDecodeURIComponent } from "./staticDecodeURIComponent.mjs";
+import { __require as requireArrayEach } from "./arrayEach.mjs";
+import { __require as requireIsString } from "./isString.mjs";
+var unserialize_1;
+var hasRequiredUnserialize;
+function requireUnserialize() {
+  if (hasRequiredUnserialize) return unserialize_1;
+  hasRequiredUnserialize = 1;
+  var staticDecodeURIComponent = requireStaticDecodeURIComponent();
+  var arrayEach = requireArrayEach();
+  var isString = requireIsString();
+  function unserialize(str) {
+    var items;
+    var result = {};
+    if (str && isString(str)) {
+      arrayEach(str.split("&"), function(param) {
+        items = param.split("=");
+        result[staticDecodeURIComponent(items[0])] = staticDecodeURIComponent(items[1] || "");
+      });
+    }
+    return result;
+  }
+  unserialize_1 = unserialize;
+  return unserialize_1;
+}
+export {
+  requireUnserialize as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/unzip.mjs

@@ -0,0 +1,29 @@
+import { __require as requirePluck } from "./pluck.mjs";
+import { __require as requireMax } from "./max.mjs";
+var unzip_1;
+var hasRequiredUnzip;
+function requireUnzip() {
+  if (hasRequiredUnzip) return unzip_1;
+  hasRequiredUnzip = 1;
+  var pluck = requirePluck();
+  var max = requireMax();
+  function unzip(arrays) {
+    var index, maxItem, len;
+    var result = [];
+    if (arrays && arrays.length) {
+      index = 0;
+      maxItem = max(arrays, function(item) {
+        return item ? item.length : 0;
+      });
+      for (len = maxItem ? maxItem.length : 0; index < len; index++) {
+        result.push(pluck(arrays, index));
+      }
+    }
+    return result;
+  }
+  unzip_1 = unzip;
+  return unzip_1;
+}
+export {
+  requireUnzip as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/values.mjs

@@ -0,0 +1,14 @@
+import { __require as requireHelperCreateGetObjects } from "./helperCreateGetObjects.mjs";
+var values_1;
+var hasRequiredValues;
+function requireValues() {
+  if (hasRequiredValues) return values_1;
+  hasRequiredValues = 1;
+  var helperCreateGetObjects = requireHelperCreateGetObjects();
+  var values = helperCreateGetObjects("values", 0);
+  values_1 = values;
+  return values_1;
+}
+export {
+  requireValues as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/zip.mjs

@@ -0,0 +1,16 @@
+import { __require as requireUnzip } from "./unzip.mjs";
+var zip_1;
+var hasRequiredZip;
+function requireZip() {
+  if (hasRequiredZip) return zip_1;
+  hasRequiredZip = 1;
+  var unzip = requireUnzip();
+  function zip() {
+    return unzip(arguments);
+  }
+  zip_1 = zip;
+  return zip_1;
+}
+export {
+  requireZip as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.4/node_modules/xe-utils/zipObject.mjs

@@ -0,0 +1,23 @@
+import { __require as requireValues } from "./values.mjs";
+import { __require as requireEach } from "./each.mjs";
+var zipObject_1;
+var hasRequiredZipObject;
+function requireZipObject() {
+  if (hasRequiredZipObject) return zipObject_1;
+  hasRequiredZipObject = 1;
+  var values = requireValues();
+  var each = requireEach();
+  function zipObject(props, arr) {
+    var result = {};
+    arr = arr || [];
+    each(values(props), function(val, key) {
+      result[val] = arr[key];
+    });
+    return result;
+  }
+  zipObject_1 = zipObject;
+  return zipObject_1;
+}
+export {
+  requireZipObject as __require
+};

package/es/packages/mobile/index.mjs

@@ -10,6 +10,8 @@ import { MobileCollapseItem } from "./src/components/dataDisplay/collapseItem/in
 import { MobileDivider } from "./src/components/dataDisplay/divider/index.mjs";
 import { MobileEmpty } from "./src/components/dataDisplay/empty/index.mjs";
 import { MobileHighlight } from "./src/components/dataDisplay/highlight/index.mjs";
+import { MobileList } from "./src/components/dataDisplay/list/index.mjs";
+import { MobileTable } from "./src/components/dataDisplay/table/index.mjs";
 import { MobileNoticeBar } from "./src/components/dataDisplay/noticeBar/index.mjs";
 import { MobileSteps } from "./src/components/dataDisplay/steps/index.mjs";
 import { MobileStep } from "./src/components/dataDisplay/step/index.mjs";
@@ -99,6 +101,7 @@ export {
   MobileImage,
   MobileIndexAnchor,
   MobileIndexBar,
+  MobileList,
   MobileLoading,
   MobileNavBar,
   MobileNoticeBar,
@@ -118,6 +121,7 @@ export {
   MobileTab,
   MobileTabbar,
   MobileTabbarItem,
+  MobileTable,
   MobileTabs,
   MobileTextEllipsis,
   MobileTreeSelect,

package/es/packages/mobile/src/axios/config.mjs

@@ -0,0 +1,105 @@
+import "../../../../node_modules/.pnpm/axios@1.8.4/node_modules/axios/index.mjs";
+import axios$1 from "../../../../node_modules/.pnpm/axios@1.8.4/node_modules/axios/lib/axios.mjs";
+const axios = () => {
+  const service = axios$1.create({
+    withCredentials: false
+  });
+  const pendingMap = /* @__PURE__ */ new Map();
+  service.interceptors.request.use(
+    (config) => {
+      removePending(config);
+      addPending(config);
+      if (config.url != "/login") {
+        config.headers.token = sessionStorage.getItem("token");
+        config.headers.refreshToken = sessionStorage.getItem("refreshToken");
+      }
+      config.headers.crypto = false;
+      config.headers.sig = false;
+      return config;
+    },
+    (error) => {
+      Promise.reject(error);
+    }
+  );
+  service.interceptors.response.use(
+    (response) => {
+      removePending(response.config);
+      if (response.config.responseType == "blob") {
+        return response;
+      }
+      if (response.data && response.data.code == "500") {
+        return Promise.reject(response.data);
+      }
+      if (response.data.message) ;
+      let responseData = response.data;
+      return responseData;
+    },
+    async (error) => {
+      error.config && removePending(error.config);
+      if (axios$1.isCancel(error)) {
+        return console.error("请求的重复请求：" + error.message);
+      }
+      if (error.response.config.responseType == "blob") {
+        let reader = new FileReader();
+        reader.onload = function(event) {
+          let data = JSON.parse(reader.result);
+          showErrorMessage(data.message, data.messageType);
+          return Promise.reject(error);
+        };
+        reader.readAsText(error.response.data);
+      } else {
+        httpErrorStatusHandle(error);
+        return Promise.reject(error);
+      }
+    }
+  );
+  function addPending(config) {
+    const pendingKey = getPendingKey(config);
+    config.cancelToken = config.cancelToken || new axios$1.CancelToken((cancel) => {
+      if (!pendingMap.has(pendingKey)) {
+        pendingMap.set(pendingKey, cancel);
+      }
+    });
+  }
+  function removePending(config) {
+    const pendingKey = getPendingKey(config);
+    if (pendingMap.has(pendingKey)) {
+      const cancelToken = pendingMap.get(pendingKey);
+      cancelToken(pendingKey);
+      pendingMap.delete(pendingKey);
+    }
+  }
+  function getPendingKey(config) {
+    let { url, method, params, data } = config;
+    if (typeof data === "string") data = JSON.parse(data);
+    return [url, method, JSON.stringify(params), JSON.stringify(data)].join(
+      "&"
+    );
+  }
+  return {
+    request(config) {
+      return service(config);
+    },
+    interceptors: {
+      request: {
+        use(fnHandle, fnError) {
+          return service.interceptors.request.use(fnHandle, fnError);
+        },
+        eject(id) {
+          return service.interceptors.request.eject(id);
+        }
+      },
+      response: {
+        use(fnHandle, fnError) {
+          return service.interceptors.response.use(fnHandle, fnError);
+        },
+        eject(id) {
+          return service.interceptors.response.eject(id);
+        }
+      }
+    }
+  };
+};
+export {
+  axios as default
+};

package/es/packages/mobile/src/axios/index.mjs

@@ -0,0 +1,11 @@
+import axios from "./config.mjs";
+const useHttp = (dataHandler) => {
+  const http = axios();
+  http.interceptors.response.use(dataHandler, (error) => {
+    console.log(error);
+  });
+  return http;
+};
+export {
+  useHttp as default
+};