@fecp/mobile 1.0.26 → 1.0.27

package/es/node_modules/.pnpm/axios@1.8.4/node_modules/axios/lib/utils.mjs

@@ -0,0 +1,364 @@
+import bind from "./helpers/bind.mjs";
+const { toString } = Object.prototype;
+const { getPrototypeOf } = Object;
+const kindOf = /* @__PURE__ */ ((cache) => (thing) => {
+  const str = toString.call(thing);
+  return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
+})(/* @__PURE__ */ Object.create(null));
+const kindOfTest = (type) => {
+  type = type.toLowerCase();
+  return (thing) => kindOf(thing) === type;
+};
+const typeOfTest = (type) => (thing) => typeof thing === type;
+const { isArray } = Array;
+const isUndefined = typeOfTest("undefined");
+function isBuffer(val) {
+  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
+}
+const isArrayBuffer = kindOfTest("ArrayBuffer");
+function isArrayBufferView(val) {
+  let result;
+  if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
+    result = ArrayBuffer.isView(val);
+  } else {
+    result = val && val.buffer && isArrayBuffer(val.buffer);
+  }
+  return result;
+}
+const isString = typeOfTest("string");
+const isFunction = typeOfTest("function");
+const isNumber = typeOfTest("number");
+const isObject = (thing) => thing !== null && typeof thing === "object";
+const isBoolean = (thing) => thing === true || thing === false;
+const isPlainObject = (val) => {
+  if (kindOf(val) !== "object") {
+    return false;
+  }
+  const prototype = getPrototypeOf(val);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in val) && !(Symbol.iterator in val);
+};
+const isDate = kindOfTest("Date");
+const isFile = kindOfTest("File");
+const isBlob = kindOfTest("Blob");
+const isFileList = kindOfTest("FileList");
+const isStream = (val) => isObject(val) && isFunction(val.pipe);
+const isFormData = (thing) => {
+  let kind;
+  return thing && (typeof FormData === "function" && thing instanceof FormData || isFunction(thing.append) && ((kind = kindOf(thing)) === "formdata" || // detect form-data instance
+  kind === "object" && isFunction(thing.toString) && thing.toString() === "[object FormData]"));
+};
+const isURLSearchParams = kindOfTest("URLSearchParams");
+const [isReadableStream, isRequest, isResponse, isHeaders] = ["ReadableStream", "Request", "Response", "Headers"].map(kindOfTest);
+const trim = (str) => str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
+function forEach(obj, fn, { allOwnKeys = false } = {}) {
+  if (obj === null || typeof obj === "undefined") {
+    return;
+  }
+  let i;
+  let l;
+  if (typeof obj !== "object") {
+    obj = [obj];
+  }
+  if (isArray(obj)) {
+    for (i = 0, l = obj.length; i < l; i++) {
+      fn.call(null, obj[i], i, obj);
+    }
+  } else {
+    const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
+    const len = keys.length;
+    let key;
+    for (i = 0; i < len; i++) {
+      key = keys[i];
+      fn.call(null, obj[key], key, obj);
+    }
+  }
+}
+function findKey(obj, key) {
+  key = key.toLowerCase();
+  const keys = Object.keys(obj);
+  let i = keys.length;
+  let _key;
+  while (i-- > 0) {
+    _key = keys[i];
+    if (key === _key.toLowerCase()) {
+      return _key;
+    }
+  }
+  return null;
+}
+const _global = (() => {
+  if (typeof globalThis !== "undefined") return globalThis;
+  return typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : global;
+})();
+const isContextDefined = (context) => !isUndefined(context) && context !== _global;
+function merge() {
+  const { caseless } = isContextDefined(this) && this || {};
+  const result = {};
+  const assignValue = (val, key) => {
+    const targetKey = caseless && findKey(result, key) || key;
+    if (isPlainObject(result[targetKey]) && isPlainObject(val)) {
+      result[targetKey] = merge(result[targetKey], val);
+    } else if (isPlainObject(val)) {
+      result[targetKey] = merge({}, val);
+    } else if (isArray(val)) {
+      result[targetKey] = val.slice();
+    } else {
+      result[targetKey] = val;
+    }
+  };
+  for (let i = 0, l = arguments.length; i < l; i++) {
+    arguments[i] && forEach(arguments[i], assignValue);
+  }
+  return result;
+}
+const extend = (a, b, thisArg, { allOwnKeys } = {}) => {
+  forEach(b, (val, key) => {
+    if (thisArg && isFunction(val)) {
+      a[key] = bind(val, thisArg);
+    } else {
+      a[key] = val;
+    }
+  }, { allOwnKeys });
+  return a;
+};
+const stripBOM = (content) => {
+  if (content.charCodeAt(0) === 65279) {
+    content = content.slice(1);
+  }
+  return content;
+};
+const inherits = (constructor, superConstructor, props, descriptors) => {
+  constructor.prototype = Object.create(superConstructor.prototype, descriptors);
+  constructor.prototype.constructor = constructor;
+  Object.defineProperty(constructor, "super", {
+    value: superConstructor.prototype
+  });
+  props && Object.assign(constructor.prototype, props);
+};
+const toFlatObject = (sourceObj, destObj, filter, propFilter) => {
+  let props;
+  let i;
+  let prop;
+  const merged = {};
+  destObj = destObj || {};
+  if (sourceObj == null) return destObj;
+  do {
+    props = Object.getOwnPropertyNames(sourceObj);
+    i = props.length;
+    while (i-- > 0) {
+      prop = props[i];
+      if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {
+        destObj[prop] = sourceObj[prop];
+        merged[prop] = true;
+      }
+    }
+    sourceObj = filter !== false && getPrototypeOf(sourceObj);
+  } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
+  return destObj;
+};
+const endsWith = (str, searchString, position) => {
+  str = String(str);
+  if (position === void 0 || position > str.length) {
+    position = str.length;
+  }
+  position -= searchString.length;
+  const lastIndex = str.indexOf(searchString, position);
+  return lastIndex !== -1 && lastIndex === position;
+};
+const toArray = (thing) => {
+  if (!thing) return null;
+  if (isArray(thing)) return thing;
+  let i = thing.length;
+  if (!isNumber(i)) return null;
+  const arr = new Array(i);
+  while (i-- > 0) {
+    arr[i] = thing[i];
+  }
+  return arr;
+};
+const isTypedArray = /* @__PURE__ */ ((TypedArray) => {
+  return (thing) => {
+    return TypedArray && thing instanceof TypedArray;
+  };
+})(typeof Uint8Array !== "undefined" && getPrototypeOf(Uint8Array));
+const forEachEntry = (obj, fn) => {
+  const generator = obj && obj[Symbol.iterator];
+  const iterator = generator.call(obj);
+  let result;
+  while ((result = iterator.next()) && !result.done) {
+    const pair = result.value;
+    fn.call(obj, pair[0], pair[1]);
+  }
+};
+const matchAll = (regExp, str) => {
+  let matches;
+  const arr = [];
+  while ((matches = regExp.exec(str)) !== null) {
+    arr.push(matches);
+  }
+  return arr;
+};
+const isHTMLForm = kindOfTest("HTMLFormElement");
+const toCamelCase = (str) => {
+  return str.toLowerCase().replace(
+    /[-_\s]([a-z\d])(\w*)/g,
+    function replacer(m, p1, p2) {
+      return p1.toUpperCase() + p2;
+    }
+  );
+};
+const hasOwnProperty = (({ hasOwnProperty: hasOwnProperty2 }) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype);
+const isRegExp = kindOfTest("RegExp");
+const reduceDescriptors = (obj, reducer) => {
+  const descriptors = Object.getOwnPropertyDescriptors(obj);
+  const reducedDescriptors = {};
+  forEach(descriptors, (descriptor, name) => {
+    let ret;
+    if ((ret = reducer(descriptor, name, obj)) !== false) {
+      reducedDescriptors[name] = ret || descriptor;
+    }
+  });
+  Object.defineProperties(obj, reducedDescriptors);
+};
+const freezeMethods = (obj) => {
+  reduceDescriptors(obj, (descriptor, name) => {
+    if (isFunction(obj) && ["arguments", "caller", "callee"].indexOf(name) !== -1) {
+      return false;
+    }
+    const value = obj[name];
+    if (!isFunction(value)) return;
+    descriptor.enumerable = false;
+    if ("writable" in descriptor) {
+      descriptor.writable = false;
+      return;
+    }
+    if (!descriptor.set) {
+      descriptor.set = () => {
+        throw Error("Can not rewrite read-only method '" + name + "'");
+      };
+    }
+  });
+};
+const toObjectSet = (arrayOrString, delimiter) => {
+  const obj = {};
+  const define = (arr) => {
+    arr.forEach((value) => {
+      obj[value] = true;
+    });
+  };
+  isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));
+  return obj;
+};
+const noop = () => {
+};
+const toFiniteNumber = (value, defaultValue) => {
+  return value != null && Number.isFinite(value = +value) ? value : defaultValue;
+};
+function isSpecCompliantForm(thing) {
+  return !!(thing && isFunction(thing.append) && thing[Symbol.toStringTag] === "FormData" && thing[Symbol.iterator]);
+}
+const toJSONObject = (obj) => {
+  const stack = new Array(10);
+  const visit = (source, i) => {
+    if (isObject(source)) {
+      if (stack.indexOf(source) >= 0) {
+        return;
+      }
+      if (!("toJSON" in source)) {
+        stack[i] = source;
+        const target = isArray(source) ? [] : {};
+        forEach(source, (value, key) => {
+          const reducedValue = visit(value, i + 1);
+          !isUndefined(reducedValue) && (target[key] = reducedValue);
+        });
+        stack[i] = void 0;
+        return target;
+      }
+    }
+    return source;
+  };
+  return visit(obj, 0);
+};
+const isAsyncFn = kindOfTest("AsyncFunction");
+const isThenable = (thing) => thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);
+const _setImmediate = ((setImmediateSupported, postMessageSupported) => {
+  if (setImmediateSupported) {
+    return setImmediate;
+  }
+  return postMessageSupported ? ((token, callbacks) => {
+    _global.addEventListener("message", ({ source, data }) => {
+      if (source === _global && data === token) {
+        callbacks.length && callbacks.shift()();
+      }
+    }, false);
+    return (cb) => {
+      callbacks.push(cb);
+      _global.postMessage(token, "*");
+    };
+  })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
+})(
+  typeof setImmediate === "function",
+  isFunction(_global.postMessage)
+);
+const asap = typeof queueMicrotask !== "undefined" ? queueMicrotask.bind(_global) : typeof process !== "undefined" && process.nextTick || _setImmediate;
+const utils = {
+  isArray,
+  isArrayBuffer,
+  isBuffer,
+  isFormData,
+  isArrayBufferView,
+  isString,
+  isNumber,
+  isBoolean,
+  isObject,
+  isPlainObject,
+  isReadableStream,
+  isRequest,
+  isResponse,
+  isHeaders,
+  isUndefined,
+  isDate,
+  isFile,
+  isBlob,
+  isRegExp,
+  isFunction,
+  isStream,
+  isURLSearchParams,
+  isTypedArray,
+  isFileList,
+  forEach,
+  merge,
+  extend,
+  trim,
+  stripBOM,
+  inherits,
+  toFlatObject,
+  kindOf,
+  kindOfTest,
+  endsWith,
+  toArray,
+  forEachEntry,
+  matchAll,
+  isHTMLForm,
+  hasOwnProperty,
+  hasOwnProp: hasOwnProperty,
+  // an alias to avoid ESLint no-prototype-builtins detection
+  reduceDescriptors,
+  freezeMethods,
+  toObjectSet,
+  toCamelCase,
+  noop,
+  toFiniteNumber,
+  findKey,
+  global: _global,
+  isContextDefined,
+  isSpecCompliantForm,
+  toJSONObject,
+  isAsyncFn,
+  isThenable,
+  setImmediate: _setImmediate,
+  asap
+};
+export {
+  utils as default
+};

package/es/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/composables/use-tab-status.mjs

@@ -1,5 +1,7 @@
-import "vue";
+import { inject } from "vue";
 const TAB_STATUS_KEY = Symbol();
+const useTabStatus = () => inject(TAB_STATUS_KEY, null);
 export {
-  TAB_STATUS_KEY
+  TAB_STATUS_KEY,
+  useTabStatus
 };

package/es/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/list/List.mjs

@@ -0,0 +1,145 @@
+import { defineComponent, ref, computed, watch, onUpdated, onMounted, createVNode, nextTick } from "vue";
+import { useScrollParent, useEventListener, useRect } from "../../../../../@vant_use@1.6.0_vue@3.5.13_typescript@5.7.3_/node_modules/@vant/use/dist/index.esm.mjs";
+import { useExpose } from "../composables/use-expose.mjs";
+import { useTabStatus } from "../composables/use-tab-status.mjs";
+import { Loading } from "../loading/index.mjs";
+import { truthProp, makeStringProp, makeNumericProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { isHidden } from "../utils/dom.mjs";
+const [name, bem, t] = createNamespace("list");
+const listProps = {
+  error: Boolean,
+  offset: makeNumericProp(300),
+  loading: Boolean,
+  disabled: Boolean,
+  finished: Boolean,
+  scroller: Object,
+  errorText: String,
+  direction: makeStringProp("down"),
+  loadingText: String,
+  finishedText: String,
+  immediateCheck: truthProp
+};
+var stdin_default = defineComponent({
+  name,
+  props: listProps,
+  emits: ["load", "update:error", "update:loading"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const loading = ref(props.loading);
+    const root = ref();
+    const placeholder = ref();
+    const tabStatus = useTabStatus();
+    const scrollParent = useScrollParent(root);
+    const scroller = computed(() => props.scroller || scrollParent.value);
+    const check = () => {
+      nextTick(() => {
+        if (loading.value || props.finished || props.disabled || props.error || // skip check when inside an inactive tab
+        (tabStatus == null ? void 0 : tabStatus.value) === false) {
+          return;
+        }
+        const {
+          direction
+        } = props;
+        const offset = +props.offset;
+        const scrollParentRect = useRect(scroller);
+        if (!scrollParentRect.height || isHidden(root)) {
+          return;
+        }
+        let isReachEdge = false;
+        const placeholderRect = useRect(placeholder);
+        if (direction === "up") {
+          isReachEdge = scrollParentRect.top - placeholderRect.top <= offset;
+        } else {
+          isReachEdge = placeholderRect.bottom - scrollParentRect.bottom <= offset;
+        }
+        if (isReachEdge) {
+          loading.value = true;
+          emit("update:loading", true);
+          emit("load");
+        }
+      });
+    };
+    const renderFinishedText = () => {
+      if (props.finished) {
+        const text = slots.finished ? slots.finished() : props.finishedText;
+        if (text) {
+          return createVNode("div", {
+            "class": bem("finished-text")
+          }, [text]);
+        }
+      }
+    };
+    const clickErrorText = () => {
+      emit("update:error", false);
+      check();
+    };
+    const renderErrorText = () => {
+      if (props.error) {
+        const text = slots.error ? slots.error() : props.errorText;
+        if (text) {
+          return createVNode("div", {
+            "role": "button",
+            "class": bem("error-text"),
+            "tabindex": 0,
+            "onClick": clickErrorText
+          }, [text]);
+        }
+      }
+    };
+    const renderLoading = () => {
+      if (loading.value && !props.finished && !props.disabled) {
+        return createVNode("div", {
+          "class": bem("loading")
+        }, [slots.loading ? slots.loading() : createVNode(Loading, {
+          "class": bem("loading-icon")
+        }, {
+          default: () => [props.loadingText || t("loading")]
+        })]);
+      }
+    };
+    watch(() => [props.loading, props.finished, props.error], check);
+    if (tabStatus) {
+      watch(tabStatus, (tabActive) => {
+        if (tabActive) {
+          check();
+        }
+      });
+    }
+    onUpdated(() => {
+      loading.value = props.loading;
+    });
+    onMounted(() => {
+      if (props.immediateCheck) {
+        check();
+      }
+    });
+    useExpose({
+      check
+    });
+    useEventListener("scroll", check, {
+      target: scroller,
+      passive: true
+    });
+    return () => {
+      var _a;
+      const Content = (_a = slots.default) == null ? void 0 : _a.call(slots);
+      const Placeholder = createVNode("div", {
+        "ref": placeholder,
+        "class": bem("placeholder")
+      }, null);
+      return createVNode("div", {
+        "ref": root,
+        "role": "feed",
+        "class": bem(),
+        "aria-busy": loading.value
+      }, [props.direction === "down" ? Content : Placeholder, renderLoading(), renderFinishedText(), renderErrorText(), props.direction === "up" ? Content : Placeholder]);
+    };
+  }
+});
+export {
+  stdin_default as default,
+  listProps
+};

package/es/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/list/index.mjs

@@ -0,0 +1,8 @@
+import stdin_default from "./List.mjs";
+import { listProps } from "./List.mjs";
+import { withInstall } from "../utils/with-install.mjs";
+const List = withInstall(stdin_default);
+export {
+  List,
+  listProps
+};

package/es/packages/mobile/index.mjs

@@ -10,6 +10,7 @@ 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 { 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 +100,7 @@ export {
   MobileImage,
   MobileIndexAnchor,
   MobileIndexBar,
+  MobileList,
   MobileLoading,
   MobileNavBar,
   MobileNoticeBar,

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
+};

package/es/packages/mobile/src/components/all.mjs

@@ -8,6 +8,7 @@ import { MobileCollapseItem } from "./dataDisplay/collapseItem/index.mjs";
 import { MobileDivider } from "./dataDisplay/divider/index.mjs";
 import { MobileEmpty } from "./dataDisplay/empty/index.mjs";
 import { MobileHighlight } from "./dataDisplay/highlight/index.mjs";
+import { MobileList } from "./dataDisplay/list/index.mjs";
 import { MobileNoticeBar } from "./dataDisplay/noticeBar/index.mjs";
 import { MobileSteps } from "./dataDisplay/steps/index.mjs";
 import { MobileStep } from "./dataDisplay/step/index.mjs";
@@ -86,6 +87,7 @@ export {
   MobileImage,
   MobileIndexAnchor,
   MobileIndexBar,
+  MobileList,
   MobileLoading,
   MobileNavBar,
   MobileNoticeBar,