@fecp/mobile 1.0.26 → 1.0.27

package/es/packages/mobile/src/components/dataDisplay/list/List.vue.mjs

@@ -0,0 +1,100 @@
+/* empty css                                                                                                                 */
+/* empty css                                                                                                                    */
+/* empty css                                                                                                                 */
+import { computed, ref, createBlock, openBlock, unref, isRef, withCtx, renderSlot } from "vue";
+import { useDataSource } from "../../../utils/dataSourceUtil.mjs";
+import { List } from "../../../../../../node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/list/index.mjs";
+const _sfc_main = {
+  __name: "List",
+  props: {
+    modelValue: {
+      type: Array,
+      default: []
+    },
+    disabledLoad: {
+      type: Boolean,
+      default: false
+    },
+    offset: {
+      type: String,
+      default: "0"
+    },
+    direction: {
+      type: String,
+      default: "down"
+    },
+    dataSource: {
+      type: String,
+      default: ""
+    },
+    params: {
+      type: Object,
+      default: {}
+    },
+    pageSize: {
+      type: String,
+      default: "10"
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const tableData = computed({
+      get: () => {
+        return props.modelValue;
+      },
+      set: (val) => {
+        emit("update:modelValue", val);
+      }
+    });
+    const finished = ref(false);
+    const error = ref(false);
+    const loading = ref(false);
+    let pageNo = 1;
+    const dataSource = useDataSource(props.dataSource);
+    call();
+    function onLoad() {
+      loading.value = true;
+      pageNo++;
+      call();
+    }
+    function call() {
+      dataSource.load({ ...props.params, pageNo, pageSize: props.pageSize }).then((res) => {
+        var _a;
+        const data = ((_a = res == null ? void 0 : res.data) == null ? void 0 : _a.records) || (res == null ? void 0 : res.data) || res;
+        tableData.value.push(...data);
+        if (data.length < props.pageSize) {
+          finished.value = true;
+        }
+        loading.value = false;
+      }).catch((err) => {
+        console.error(err);
+        error.value = true;
+        loading.value = false;
+      });
+    }
+    return (_ctx, _cache) => {
+      const _component_van_list = List;
+      return openBlock(), createBlock(_component_van_list, {
+        loading: unref(loading),
+        "onUpdate:loading": _cache[0] || (_cache[0] = ($event) => isRef(loading) ? loading.value = $event : null),
+        error: unref(error),
+        "onUpdate:error": _cache[1] || (_cache[1] = ($event) => isRef(error) ? error.value = $event : null),
+        finished: unref(finished),
+        disabled: __props.disabledLoad,
+        offset: __props.offset,
+        "finished-text": "没有更多了",
+        onLoad
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["loading", "error", "finished", "disabled", "offset"]);
+    };
+  }
+};
+export {
+  _sfc_main as default
+};

package/es/packages/mobile/src/components/dataDisplay/list/index.mjs

@@ -0,0 +1,7 @@
+import _sfc_main from "./List.vue.mjs";
+import install from "../../../utils/install.mjs";
+const MobileList = install.withInstall("MobileList", _sfc_main);
+export {
+  MobileList,
+  MobileList as default
+};

package/es/packages/mobile/src/utils/dataSourceUtil.mjs

@@ -0,0 +1,71 @@
+import useHttp from "../axios/index.mjs";
+const useDataSource = (dataSourceJson) => {
+  var _a, _b;
+  const dataSource = JSON.parse(dataSourceJson.replace(/'/g, '"'));
+  const globalDataHandle = dataSource.dataHandler ? createFn(dataSource.dataHandler.value) : (res) => res;
+  const http = useHttp(globalDataHandle);
+  const shouldFetch = ((_a = dataSource.shouldFetch) == null ? void 0 : _a.value) ? createFn(dataSource.shouldFetch.value) : () => true;
+  const willFetch = ((_b = dataSource.willFetch) == null ? void 0 : _b.value) ? createFn(dataSource.willFetch.value) : (options) => options;
+  const dataHandler = (res) => {
+    var _a2;
+    const data = ((_a2 = dataSource.dataHandler) == null ? void 0 : _a2.value) ? createFn(dataSource.dataHandler.value)(res) : res;
+    return data;
+  };
+  const errorHandler = (error) => {
+    var _a2;
+    if ((_a2 = dataSource.errorHandler) == null ? void 0 : _a2.value) {
+      createFn(dataSource.errorHandler.value)(error);
+    }
+  };
+  http.interceptors.request.use(willFetch, errorHandler);
+  http.interceptors.response.use(dataHandler, errorHandler);
+  return {
+    load: createLoad(http, dataSource, shouldFetch)
+  };
+};
+const createFn = (fnContent) => {
+  return (...args) => {
+    window.eval("var fn = " + fnContent);
+    return fn.apply(void 0, args);
+  };
+};
+const createLoad = (http, dataSource, shouldFetch) => (params) => {
+  if (!shouldFetch()) {
+    return;
+  }
+  if (dataSource.mockSwitch == "1") {
+    let mockData = dataSource.mockData;
+    return new Promise((resolve) => {
+      const mockDataHandle = createFn(dataSource.mockDataHandlerValue);
+      resolve(mockDataHandle(mockData));
+    });
+  }
+  const {
+    method,
+    uri: url,
+    params: defaultParams,
+    timeout,
+    headers,
+    serviceAddr
+  } = dataSource.options;
+  const config = { method, url, headers, timeout };
+  const data = params && JSON.stringify(params) != "{}" ? params : defaultParams;
+  if (serviceAddr) {
+    const serviceAddrValue = dataSource == null ? void 0 : dataSource.serviceAddr;
+    const serviceAddrItem = serviceAddrValue == null ? void 0 : serviceAddrValue.find(
+      (item) => item.name == serviceAddr
+    );
+    config.url = (serviceAddrItem == null ? void 0 : serviceAddrItem.url) ? serviceAddrItem.url + config.url : config.url;
+  } else {
+    config.url = config.url;
+  }
+  if (method.toLowerCase() === "get") {
+    config.params = data;
+  } else {
+    config.data = data;
+  }
+  return http.request(config);
+};
+export {
+  useDataSource
+};

package/lib/mobile.css

@@ -12,6 +12,7 @@
 :root,:host{--van-divider-margin: var(--van-padding-md) 0;--van-divider-vertical-margin: 0 var(--van-padding-xs);--van-divider-text-color: var(--van-text-color-2);--van-divider-font-size: var(--van-font-size-md);--van-divider-line-height: 24px;--van-divider-border-color: var(--van-border-color);--van-divider-content-padding: var(--van-padding-md);--van-divider-content-left-width: 10%;--van-divider-content-right-width: 10%}.van-divider{display:flex;align-items:center;margin:var(--van-divider-margin);color:var(--van-divider-text-color);font-size:var(--van-divider-font-size);line-height:var(--van-divider-line-height);border-color:var(--van-divider-border-color);border-style:solid;border-width:0}.van-divider:before,.van-divider:after{display:block;flex:1;box-sizing:border-box;height:1px;border-color:inherit;border-style:inherit;border-width:var(--van-border-width) 0 0}.van-divider:before{content:""}.van-divider--hairline:before,.van-divider--hairline:after{transform:scaleY(.5)}.van-divider--dashed{border-style:dashed}.van-divider--content-center:before,.van-divider--content-left:before,.van-divider--content-right:before{margin-right:var(--van-divider-content-padding)}.van-divider--content-center:after,.van-divider--content-left:after,.van-divider--content-right:after{margin-left:var(--van-divider-content-padding);content:""}.van-divider--content-left:before{max-width:var(--van-divider-content-left-width)}.van-divider--content-right:after{max-width:var(--van-divider-content-right-width)}.van-divider--vertical{display:inline-block;width:var(--van-border-width);height:1em;margin:var(--van-divider-vertical-margin);vertical-align:middle}.van-divider--vertical:before{height:100%;border-width:0 0 0 var(--van-border-width)}.van-divider--vertical:after{display:none}.van-divider--vertical.van-divider--hairline:before{transform:scaleX(.5)}
 :root,:host{--van-empty-padding: var(--van-padding-xl) 0;--van-empty-image-size: 160px;--van-empty-description-margin-top: var(--van-padding-md);--van-empty-description-padding: 0 60px;--van-empty-description-color: var(--van-text-color-2);--van-empty-description-font-size: var(--van-font-size-md);--van-empty-description-line-height: var(--van-line-height-md);--van-empty-bottom-margin-top: 24px}.van-empty{display:flex;flex-direction:column;align-items:center;justify-content:center;box-sizing:border-box;padding:var(--van-empty-padding)}.van-empty__image{width:var(--van-empty-image-size);height:var(--van-empty-image-size)}.van-empty__image img{width:100%;height:100%}.van-empty__description{margin-top:var(--van-empty-description-margin-top);padding:var(--van-empty-description-padding);color:var(--van-empty-description-color);font-size:var(--van-empty-description-font-size);line-height:var(--van-empty-description-line-height)}.van-empty__bottom{margin-top:var(--van-empty-bottom-margin-top)}.van-theme-dark .van-empty{opacity:.5}
 :root,:host{--van-highlight-tag-color: var(--van-primary-color)}.van-highlight__tag{color:var(--van-highlight-tag-color)}
+:root,:host{--van-list-text-color: var(--van-text-color-2);--van-list-text-font-size: var(--van-font-size-md);--van-list-text-line-height: 50px;--van-list-loading-icon-size: 16px}.van-list__loading,.van-list__finished-text,.van-list__error-text{color:var(--van-list-text-color);font-size:var(--van-list-text-font-size);line-height:var(--van-list-text-line-height);text-align:center}.van-list__placeholder{height:0;pointer-events:none}.van-list__loading-icon .van-loading__spinner{width:var(--van-list-loading-icon-size);height:var(--van-list-loading-icon-size)}
 :root,:host{--van-notice-bar-height: 40px;--van-notice-bar-padding: 0 var(--van-padding-md);--van-notice-bar-wrapable-padding: var(--van-padding-xs) var(--van-padding-md);--van-notice-bar-text-color: var(--van-orange-dark);--van-notice-bar-font-size: var(--van-font-size-md);--van-notice-bar-line-height: 24px;--van-notice-bar-background: var(--van-orange-light);--van-notice-bar-icon-size: 16px;--van-notice-bar-icon-min-width: 24px}.van-notice-bar{position:relative;display:flex;align-items:center;height:var(--van-notice-bar-height);padding:var(--van-notice-bar-padding);color:var(--van-notice-bar-text-color);font-size:var(--van-notice-bar-font-size);line-height:var(--van-notice-bar-line-height);background:var(--van-notice-bar-background)}.van-notice-bar__left-icon,.van-notice-bar__right-icon{min-width:var(--van-notice-bar-icon-min-width);font-size:var(--van-notice-bar-icon-size)}.van-notice-bar__right-icon{text-align:right;cursor:pointer}.van-notice-bar__wrap{position:relative;display:flex;flex:1;align-items:center;height:100%;overflow:hidden}.van-notice-bar__content{position:absolute;white-space:nowrap;transition-timing-function:linear}.van-notice-bar__content.van-ellipsis{max-width:100%}.van-notice-bar--wrapable{height:auto;padding:var(--van-notice-bar-wrapable-padding)}.van-notice-bar--wrapable .van-notice-bar__wrap{height:auto}.van-notice-bar--wrapable .van-notice-bar__content{position:relative;white-space:normal;word-wrap:break-word}
 :root,:host{--van-steps-background: var(--van-background-2)}.van-steps{overflow:hidden;background-color:var(--van-steps-background)}.van-steps--horizontal{padding:10px 10px 0}.van-steps--horizontal .van-steps__items{position:relative;display:flex;margin:0 0 10px;padding-bottom:22px}.van-steps--vertical{padding:0 0 0 var(--van-padding-xl)}
 :root,:host{--van-step-text-color: var(--van-text-color-2);--van-step-active-color: var(--van-primary-color);--van-step-process-text-color: var(--van-text-color);--van-step-font-size: var(--van-font-size-md);--van-step-line-color: var(--van-border-color);--van-step-finish-line-color: var(--van-primary-color);--van-step-finish-text-color: var(--van-text-color);--van-step-icon-size: 12px;--van-step-circle-size: 5px;--van-step-circle-color: var(--van-gray-6);--van-step-horizontal-title-font-size: var(--van-font-size-sm)}.van-step{position:relative;flex:1;color:var(--van-step-text-color);font-size:var(--van-step-font-size)}.van-step__circle{display:block;width:var(--van-step-circle-size);height:var(--van-step-circle-size);background-color:var(--van-step-circle-color);border-radius:50%}.van-step__line{position:absolute;background-color:var(--van-step-line-color);transition:background-color var(--van-duration-base)}.van-step--horizontal{float:left}.van-step--horizontal:first-child .van-step__title{margin-left:0;transform:none}.van-step--horizontal:last-child:not(:first-child){position:absolute;right:1px;width:auto}.van-step--horizontal:last-child:not(:first-child) .van-step__title{margin-left:0;transform:none}.van-step--horizontal:last-child:not(:first-child) .van-step__circle-container{right:-9px;left:auto}.van-step--horizontal .van-step__circle-container{position:absolute;top:30px;left:calc(var(--van-padding-xs) * -1);z-index:1;padding:0 var(--van-padding-xs);background-color:var(--van-background-2);transform:translateY(-50%)}.van-step--horizontal .van-step__title{display:inline-block;margin-left:3px;font-size:var(--van-step-horizontal-title-font-size);transform:translate(-50%)}.van-step--horizontal .van-step__line{top:30px;left:0;width:100%;height:1px}.van-step--horizontal .van-step__icon{display:block;font-size:var(--van-step-icon-size)}.van-step--horizontal .van-step--process{color:var(--van-step-process-text-color)}.van-step--vertical{display:block;float:none;padding:10px 10px 10px 0;line-height:var(--van-line-height-sm)}.van-step--vertical:not(:last-child):after{border-bottom-width:1px}.van-step--vertical .van-step__circle-container{position:absolute;top:19px;left:-15px;z-index:1;font-size:var(--van-step-icon-size);line-height:1;transform:translate(-50%,-50%)}.van-step--vertical .van-step__line{top:16px;left:-15px;width:1px;height:100%}.van-step:last-child .van-step__line{width:0}.van-step--finish{color:var(--van-step-finish-text-color)}.van-step--finish .van-step__circle,.van-step--finish .van-step__line{background-color:var(--van-step-finish-line-color)}.van-step__icon,.van-step__title{transition:color var(--van-duration-base)}.van-step__icon--active,.van-step__title--active,.van-step__icon--finish,.van-step__title--finish{color:var(--van-step-active-color)}

package/lib/node_modules/.pnpm/axios@1.8.4/node_modules/axios/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const axios = require("./lib/axios.js");
+const {
+  Axios,
+  AxiosError,
+  CanceledError,
+  isCancel,
+  CancelToken,
+  VERSION,
+  all,
+  Cancel,
+  isAxiosError,
+  spread,
+  toFormData,
+  AxiosHeaders,
+  HttpStatusCode,
+  formToJSON,
+  getAdapter,
+  mergeConfig
+} = axios.default;
+exports.default = axios.default;
+exports.Axios = Axios;
+exports.AxiosError = AxiosError;
+exports.AxiosHeaders = AxiosHeaders;
+exports.Cancel = Cancel;
+exports.CancelToken = CancelToken;
+exports.CanceledError = CanceledError;
+exports.HttpStatusCode = HttpStatusCode;
+exports.VERSION = VERSION;
+exports.all = all;
+exports.formToJSON = formToJSON;
+exports.getAdapter = getAdapter;
+exports.isAxiosError = isAxiosError;
+exports.isCancel = isCancel;
+exports.mergeConfig = mergeConfig;
+exports.spread = spread;
+exports.toFormData = toFormData;

package/lib/node_modules/.pnpm/axios@1.8.4/node_modules/axios/lib/adapters/adapters.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const utils = require("../utils.js");
+const _null = require("../helpers/null.js");
+const xhr = require("./xhr.js");
+const fetch = require("./fetch.js");
+const AxiosError = require("../core/AxiosError.js");
+const knownAdapters = {
+  http: _null.default,
+  xhr: xhr.default,
+  fetch: fetch.default
+};
+utils.default.forEach(knownAdapters, (fn, value) => {
+  if (fn) {
+    try {
+      Object.defineProperty(fn, "name", { value });
+    } catch (e) {
+    }
+    Object.defineProperty(fn, "adapterName", { value });
+  }
+});
+const renderReason = (reason) => `- ${reason}`;
+const isResolvedHandle = (adapter) => utils.default.isFunction(adapter) || adapter === null || adapter === false;
+const adapters = {
+  getAdapter: (adapters2) => {
+    adapters2 = utils.default.isArray(adapters2) ? adapters2 : [adapters2];
+    const { length } = adapters2;
+    let nameOrAdapter;
+    let adapter;
+    const rejectedReasons = {};
+    for (let i = 0; i < length; i++) {
+      nameOrAdapter = adapters2[i];
+      let id;
+      adapter = nameOrAdapter;
+      if (!isResolvedHandle(nameOrAdapter)) {
+        adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
+        if (adapter === void 0) {
+          throw new AxiosError.default(`Unknown adapter '${id}'`);
+        }
+      }
+      if (adapter) {
+        break;
+      }
+      rejectedReasons[id || "#" + i] = adapter;
+    }
+    if (!adapter) {
+      const reasons = Object.entries(rejectedReasons).map(
+        ([id, state]) => `adapter ${id} ` + (state === false ? "is not supported by the environment" : "is not available in the build")
+      );
+      let s = length ? reasons.length > 1 ? "since :\n" + reasons.map(renderReason).join("\n") : " " + renderReason(reasons[0]) : "as no adapter specified";
+      throw new AxiosError.default(
+        `There is no suitable adapter to dispatch the request ` + s,
+        "ERR_NOT_SUPPORT"
+      );
+    }
+    return adapter;
+  },
+  adapters: knownAdapters
+};
+exports.default = adapters;

package/lib/node_modules/.pnpm/axios@1.8.4/node_modules/axios/lib/adapters/fetch.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../platform/index.js");
+const utils = require("../utils.js");
+const AxiosError = require("../core/AxiosError.js");
+const composeSignals = require("../helpers/composeSignals.js");
+const trackStream = require("../helpers/trackStream.js");
+const AxiosHeaders = require("../core/AxiosHeaders.js");
+const progressEventReducer = require("../helpers/progressEventReducer.js");
+const resolveConfig = require("../helpers/resolveConfig.js");
+const settle = require("../core/settle.js");
+const isFetchSupported = typeof fetch === "function" && typeof Request === "function" && typeof Response === "function";
+const isReadableStreamSupported = isFetchSupported && typeof ReadableStream === "function";
+const encodeText = isFetchSupported && (typeof TextEncoder === "function" ? /* @__PURE__ */ ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) : async (str) => new Uint8Array(await new Response(str).arrayBuffer()));
+const test = (fn, ...args) => {
+  try {
+    return !!fn(...args);
+  } catch (e) {
+    return false;
+  }
+};
+const supportsRequestStream = isReadableStreamSupported && test(() => {
+  let duplexAccessed = false;
+  const hasContentType = new Request(index.default.origin, {
+    body: new ReadableStream(),
+    method: "POST",
+    get duplex() {
+      duplexAccessed = true;
+      return "half";
+    }
+  }).headers.has("Content-Type");
+  return duplexAccessed && !hasContentType;
+});
+const DEFAULT_CHUNK_SIZE = 64 * 1024;
+const supportsResponseStream = isReadableStreamSupported && test(() => utils.default.isReadableStream(new Response("").body));
+const resolvers = {
+  stream: supportsResponseStream && ((res) => res.body)
+};
+isFetchSupported && ((res) => {
+  ["text", "arrayBuffer", "blob", "formData", "stream"].forEach((type) => {
+    !resolvers[type] && (resolvers[type] = utils.default.isFunction(res[type]) ? (res2) => res2[type]() : (_, config) => {
+      throw new AxiosError.default(`Response type '${type}' is not supported`, AxiosError.default.ERR_NOT_SUPPORT, config);
+    });
+  });
+})(new Response());
+const getBodyLength = async (body) => {
+  if (body == null) {
+    return 0;
+  }
+  if (utils.default.isBlob(body)) {
+    return body.size;
+  }
+  if (utils.default.isSpecCompliantForm(body)) {
+    const _request = new Request(index.default.origin, {
+      method: "POST",
+      body
+    });
+    return (await _request.arrayBuffer()).byteLength;
+  }
+  if (utils.default.isArrayBufferView(body) || utils.default.isArrayBuffer(body)) {
+    return body.byteLength;
+  }
+  if (utils.default.isURLSearchParams(body)) {
+    body = body + "";
+  }
+  if (utils.default.isString(body)) {
+    return (await encodeText(body)).byteLength;
+  }
+};
+const resolveBodyLength = async (headers, body) => {
+  const length = utils.default.toFiniteNumber(headers.getContentLength());
+  return length == null ? getBodyLength(body) : length;
+};
+const fetchAdapter = isFetchSupported && (async (config) => {
+  let {
+    url,
+    method,
+    data,
+    signal,
+    cancelToken,
+    timeout,
+    onDownloadProgress,
+    onUploadProgress,
+    responseType,
+    headers,
+    withCredentials = "same-origin",
+    fetchOptions
+  } = resolveConfig.default(config);
+  responseType = responseType ? (responseType + "").toLowerCase() : "text";
+  let composedSignal = composeSignals.default([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
+  let request;
+  const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
+    composedSignal.unsubscribe();
+  });
+  let requestContentLength;
+  try {
+    if (onUploadProgress && supportsRequestStream && method !== "get" && method !== "head" && (requestContentLength = await resolveBodyLength(headers, data)) !== 0) {
+      let _request = new Request(url, {
+        method: "POST",
+        body: data,
+        duplex: "half"
+      });
+      let contentTypeHeader;
+      if (utils.default.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) {
+        headers.setContentType(contentTypeHeader);
+      }
+      if (_request.body) {
+        const [onProgress, flush] = progressEventReducer.progressEventDecorator(
+          requestContentLength,
+          progressEventReducer.progressEventReducer(progressEventReducer.asyncDecorator(onUploadProgress))
+        );
+        data = trackStream.trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+      }
+    }
+    if (!utils.default.isString(withCredentials)) {
+      withCredentials = withCredentials ? "include" : "omit";
+    }
+    const isCredentialsSupported = "credentials" in Request.prototype;
+    request = new Request(url, {
+      ...fetchOptions,
+      signal: composedSignal,
+      method: method.toUpperCase(),
+      headers: headers.normalize().toJSON(),
+      body: data,
+      duplex: "half",
+      credentials: isCredentialsSupported ? withCredentials : void 0
+    });
+    let response = await fetch(request);
+    const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response");
+    if (supportsResponseStream && (onDownloadProgress || isStreamResponse && unsubscribe)) {
+      const options = {};
+      ["status", "statusText", "headers"].forEach((prop) => {
+        options[prop] = response[prop];
+      });
+      const responseContentLength = utils.default.toFiniteNumber(response.headers.get("content-length"));
+      const [onProgress, flush] = onDownloadProgress && progressEventReducer.progressEventDecorator(
+        responseContentLength,
+        progressEventReducer.progressEventReducer(progressEventReducer.asyncDecorator(onDownloadProgress), true)
+      ) || [];
+      response = new Response(
+        trackStream.trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
+          flush && flush();
+          unsubscribe && unsubscribe();
+        }),
+        options
+      );
+    }
+    responseType = responseType || "text";
+    let responseData = await resolvers[utils.default.findKey(resolvers, responseType) || "text"](response, config);
+    !isStreamResponse && unsubscribe && unsubscribe();
+    return await new Promise((resolve, reject) => {
+      settle.default(resolve, reject, {
+        data: responseData,
+        headers: AxiosHeaders.default.from(response.headers),
+        status: response.status,
+        statusText: response.statusText,
+        config,
+        request
+      });
+    });
+  } catch (err) {
+    unsubscribe && unsubscribe();
+    if (err && err.name === "TypeError" && /fetch/i.test(err.message)) {
+      throw Object.assign(
+        new AxiosError.default("Network Error", AxiosError.default.ERR_NETWORK, config, request),
+        {
+          cause: err.cause || err
+        }
+      );
+    }
+    throw AxiosError.default.from(err, err && err.code, config, request);
+  }
+});
+exports.default = fetchAdapter;

package/lib/node_modules/.pnpm/axios@1.8.4/node_modules/axios/lib/adapters/xhr.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const utils = require("../utils.js");
+const settle = require("../core/settle.js");
+const transitional = require("../defaults/transitional.js");
+const AxiosError = require("../core/AxiosError.js");
+const CanceledError = require("../cancel/CanceledError.js");
+const parseProtocol = require("../helpers/parseProtocol.js");
+const index = require("../platform/index.js");
+const AxiosHeaders = require("../core/AxiosHeaders.js");
+const progressEventReducer = require("../helpers/progressEventReducer.js");
+const resolveConfig = require("../helpers/resolveConfig.js");
+const isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
+const xhrAdapter = isXHRAdapterSupported && function(config) {
+  return new Promise(function dispatchXhrRequest(resolve, reject) {
+    const _config = resolveConfig.default(config);
+    let requestData = _config.data;
+    const requestHeaders = AxiosHeaders.default.from(_config.headers).normalize();
+    let { responseType, onUploadProgress, onDownloadProgress } = _config;
+    let onCanceled;
+    let uploadThrottled, downloadThrottled;
+    let flushUpload, flushDownload;
+    function done() {
+      flushUpload && flushUpload();
+      flushDownload && flushDownload();
+      _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
+      _config.signal && _config.signal.removeEventListener("abort", onCanceled);
+    }
+    let request = new XMLHttpRequest();
+    request.open(_config.method.toUpperCase(), _config.url, true);
+    request.timeout = _config.timeout;
+    function onloadend() {
+      if (!request) {
+        return;
+      }
+      const responseHeaders = AxiosHeaders.default.from(
+        "getAllResponseHeaders" in request && request.getAllResponseHeaders()
+      );
+      const responseData = !responseType || responseType === "text" || responseType === "json" ? request.responseText : request.response;
+      const response = {
+        data: responseData,
+        status: request.status,
+        statusText: request.statusText,
+        headers: responseHeaders,
+        config,
+        request
+      };
+      settle.default(function _resolve(value) {
+        resolve(value);
+        done();
+      }, function _reject(err) {
+        reject(err);
+        done();
+      }, response);
+      request = null;
+    }
+    if ("onloadend" in request) {
+      request.onloadend = onloadend;
+    } else {
+      request.onreadystatechange = function handleLoad() {
+        if (!request || request.readyState !== 4) {
+          return;
+        }
+        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0)) {
+          return;
+        }
+        setTimeout(onloadend);
+      };
+    }
+    request.onabort = function handleAbort() {
+      if (!request) {
+        return;
+      }
+      reject(new AxiosError.default("Request aborted", AxiosError.default.ECONNABORTED, config, request));
+      request = null;
+    };
+    request.onerror = function handleError() {
+      reject(new AxiosError.default("Network Error", AxiosError.default.ERR_NETWORK, config, request));
+      request = null;
+    };
+    request.ontimeout = function handleTimeout() {
+      let timeoutErrorMessage = _config.timeout ? "timeout of " + _config.timeout + "ms exceeded" : "timeout exceeded";
+      const transitional$1 = _config.transitional || transitional.default;
+      if (_config.timeoutErrorMessage) {
+        timeoutErrorMessage = _config.timeoutErrorMessage;
+      }
+      reject(new AxiosError.default(
+        timeoutErrorMessage,
+        transitional$1.clarifyTimeoutError ? AxiosError.default.ETIMEDOUT : AxiosError.default.ECONNABORTED,
+        config,
+        request
+      ));
+      request = null;
+    };
+    requestData === void 0 && requestHeaders.setContentType(null);
+    if ("setRequestHeader" in request) {
+      utils.default.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
+        request.setRequestHeader(key, val);
+      });
+    }
+    if (!utils.default.isUndefined(_config.withCredentials)) {
+      request.withCredentials = !!_config.withCredentials;
+    }
+    if (responseType && responseType !== "json") {
+      request.responseType = _config.responseType;
+    }
+    if (onDownloadProgress) {
+      [downloadThrottled, flushDownload] = progressEventReducer.progressEventReducer(onDownloadProgress, true);
+      request.addEventListener("progress", downloadThrottled);
+    }
+    if (onUploadProgress && request.upload) {
+      [uploadThrottled, flushUpload] = progressEventReducer.progressEventReducer(onUploadProgress);
+      request.upload.addEventListener("progress", uploadThrottled);
+      request.upload.addEventListener("loadend", flushUpload);
+    }
+    if (_config.cancelToken || _config.signal) {
+      onCanceled = (cancel) => {
+        if (!request) {
+          return;
+        }
+        reject(!cancel || cancel.type ? new CanceledError.default(null, config, request) : cancel);
+        request.abort();
+        request = null;
+      };
+      _config.cancelToken && _config.cancelToken.subscribe(onCanceled);
+      if (_config.signal) {
+        _config.signal.aborted ? onCanceled() : _config.signal.addEventListener("abort", onCanceled);
+      }
+    }
+    const protocol = parseProtocol.default(_config.url);
+    if (protocol && index.default.protocols.indexOf(protocol) === -1) {
+      reject(new AxiosError.default("Unsupported protocol " + protocol + ":", AxiosError.default.ERR_BAD_REQUEST, config));
+      return;
+    }
+    request.send(requestData || null);
+  });
+};
+exports.default = xhrAdapter;

package/lib/node_modules/.pnpm/axios@1.8.4/node_modules/axios/lib/axios.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const utils = require("./utils.js");
+const bind = require("./helpers/bind.js");
+const Axios = require("./core/Axios.js");
+const mergeConfig = require("./core/mergeConfig.js");
+const index = require("./defaults/index.js");
+const formDataToJSON = require("./helpers/formDataToJSON.js");
+const CanceledError = require("./cancel/CanceledError.js");
+const CancelToken = require("./cancel/CancelToken.js");
+const isCancel = require("./cancel/isCancel.js");
+const data = require("./env/data.js");
+const toFormData = require("./helpers/toFormData.js");
+const AxiosError = require("./core/AxiosError.js");
+const spread = require("./helpers/spread.js");
+const isAxiosError = require("./helpers/isAxiosError.js");
+const AxiosHeaders = require("./core/AxiosHeaders.js");
+const adapters = require("./adapters/adapters.js");
+const HttpStatusCode = require("./helpers/HttpStatusCode.js");
+function createInstance(defaultConfig) {
+  const context = new Axios.default(defaultConfig);
+  const instance = bind.default(Axios.default.prototype.request, context);
+  utils.default.extend(instance, Axios.default.prototype, context, { allOwnKeys: true });
+  utils.default.extend(instance, context, null, { allOwnKeys: true });
+  instance.create = function create(instanceConfig) {
+    return createInstance(mergeConfig.default(defaultConfig, instanceConfig));
+  };
+  return instance;
+}
+const axios = createInstance(index.default);
+axios.Axios = Axios.default;
+axios.CanceledError = CanceledError.default;
+axios.CancelToken = CancelToken.default;
+axios.isCancel = isCancel.default;
+axios.VERSION = data.VERSION;
+axios.toFormData = toFormData.default;
+axios.AxiosError = AxiosError.default;
+axios.Cancel = axios.CanceledError;
+axios.all = function all(promises) {
+  return Promise.all(promises);
+};
+axios.spread = spread.default;
+axios.isAxiosError = isAxiosError.default;
+axios.mergeConfig = mergeConfig.default;
+axios.AxiosHeaders = AxiosHeaders.default;
+axios.formToJSON = (thing) => formDataToJSON.default(utils.default.isHTMLForm(thing) ? new FormData(thing) : thing);
+axios.getAdapter = adapters.default.getAdapter;
+axios.HttpStatusCode = HttpStatusCode.default;
+axios.default = axios;
+exports.default = axios;