优化后，再次提交

unpackage/dist/dev/mp-weixin/request/api.js

@@ -0,0 +1,332 @@
+"use strict";
+const request_request = require("./request.js");
+function getCheckPlanList(params) {
+  return request_request.requestAPI({
+    url: "/frontend/plan/list",
+    method: "GET",
+    data: params
+  });
+}
+function enterCheckPlan(oneTableId) {
+  return request_request.requestAPI({
+    url: `/frontend/task/start/${oneTableId}`,
+    method: "GET"
+  });
+}
+function getCheckTaskDetail(taskId) {
+  return request_request.requestAPI({
+    url: `/frontend/task/detail/${taskId}`,
+    method: "GET"
+  });
+}
+function submitCheckResult(params) {
+  return request_request.requestAPI({
+    url: "/frontend/task/submit",
+    method: "POST",
+    data: params
+  });
+}
+function addHiddenDanger(params) {
+  return request_request.requestAPI({
+    url: "/frontend/hazard/add",
+    method: "POST",
+    data: params
+  });
+}
+function assignHiddenDanger(params) {
+  return request_request.requestAPI({
+    url: "/frontend/hazard/assign",
+    method: "POST",
+    data: params
+  });
+}
+function getMyHiddenDangerList(params) {
+  return request_request.requestAPI({
+    url: "/frontend/hazard/my/list",
+    method: "GET",
+    data: params
+  });
+}
+function getHiddenDangerDetail(params) {
+  const filteredParams = { ...params };
+  if (filteredParams.assignId == null || filteredParams.assignId === "null" || filteredParams.assignId === "") {
+    delete filteredParams.assignId;
+  }
+  return request_request.requestAPI({
+    url: "/frontend/hazard/detail",
+    method: "GET",
+    data: filteredParams
+  });
+}
+function getHiddenDangerList(params) {
+  return request_request.requestAPI({
+    url: "/frontend/hazard/my/list",
+    method: "GET",
+    data: params
+  });
+}
+function submitRectification(params) {
+  return request_request.requestAPI({
+    url: "/frontend/hazard/rectify",
+    method: "POST",
+    data: params
+  });
+}
+function getRectifyDetail(params) {
+  return request_request.requestAPI({
+    url: "/frontend/hazard/rectify/detail",
+    method: "GET",
+    data: params
+  });
+}
+function getHiddenDangerLabelList() {
+  return request_request.requestAPI({
+    url: "/frontend/hazard/tag/list",
+    method: "GET"
+  });
+}
+function getDepartmentPersonUsers(params) {
+  return request_request.requestAPI({
+    url: "/frontend/hazard/dept/users",
+    method: "GET",
+    data: params
+  });
+}
+function getDeptUsersWithSubordinates(params) {
+  return request_request.requestAPI({
+    url: "/frontend/hazard/dept/users/with-subordinates",
+    method: "GET",
+    data: params
+  });
+}
+function addMember(params) {
+  return request_request.requestAPI({
+    url: "/frontend/member/add",
+    method: "POST",
+    data: params
+  });
+}
+function getMemberList(params) {
+  return request_request.requestAPI({
+    url: "/frontend/member/list",
+    method: "GET",
+    data: params
+  });
+}
+function lockOrUnlockMember(params) {
+  return request_request.requestAPI({
+    url: "/frontend/member/lock",
+    method: "POST",
+    data: params
+  });
+}
+function applyDelete(params) {
+  return request_request.requestAPI({
+    url: "/frontend/hazard/writeoff/apply",
+    method: "POST",
+    data: params
+  });
+}
+function getAcceptanceList(params) {
+  return request_request.requestAPI({
+    url: "/frontend/hazard/verified/list",
+    method: "GET",
+    data: params
+  });
+}
+function getMyWriteOffList(params) {
+  return request_request.requestAPI({
+    url: "/frontend/hazard/writeoff/my/list",
+    method: "GET",
+    data: params
+  });
+}
+function acceptanceRectification(params) {
+  return request_request.requestAPI({
+    url: "/frontend/hazard/verify",
+    method: "POST",
+    data: params
+  });
+}
+function login(params) {
+  return request_request.requestAPI({
+    url: "/frontend/auth/login",
+    method: "POST",
+    data: params,
+    noAuth: true
+    // 登录接口不需要 Authorization
+  });
+}
+function getCheckTableList(params) {
+  return request_request.requestAPI({
+    url: "/admin/oneTable/list",
+    method: "GET",
+    data: params
+  });
+}
+function addCheckTable(params) {
+  return request_request.requestAPI({
+    url: "/admin/oneTable/add",
+    method: "POST",
+    data: params
+  });
+}
+function getEnterprisetype() {
+  return request_request.requestAPI({
+    url: "/frontend/enterprise/type/select",
+    method: "GET"
+  });
+}
+function getEnterpriseinfo() {
+  return request_request.requestAPI({
+    url: "/frontend/enterprise/info",
+    method: "GET"
+  });
+}
+function addEnterprise(params) {
+  return request_request.requestAPI({
+    url: "/frontend/enterprise/add",
+    method: "POST",
+    data: params
+  });
+}
+function updateEnterprise(params) {
+  return request_request.requestAPI({
+    url: "/frontend/enterprise/update",
+    method: "POST",
+    data: params
+  });
+}
+function getindustry(params) {
+  return request_request.requestAPI({
+    url: "/frontend/enterprise/industry/select",
+    method: "GET"
+  });
+}
+function getRegulationList(params) {
+  return request_request.requestAPI({
+    url: "/admin/regulation/list",
+    method: "GET",
+    data: params
+  });
+}
+function addCheckPoint(params) {
+  return request_request.requestAPI({
+    url: "/admin/oneTable/checkPoint/add",
+    method: "POST",
+    data: params
+  });
+}
+function detailcheckPoint(id) {
+  return request_request.requestAPI({
+    url: `/admin/oneTable/checkPoint/detail/${id}`,
+    method: "POST"
+  });
+}
+function deleteCheckPoint(params) {
+  return request_request.requestAPI({
+    url: "/admin/oneTable/checkPoint/delete",
+    method: "POST",
+    data: params
+  });
+}
+function getCheckItemList(params) {
+  return request_request.requestAPI({
+    url: "/admin/oneTable/item/list",
+    method: "GET",
+    data: params
+  });
+}
+function getCheckItemListDetail(params) {
+  return request_request.requestAPI({
+    url: "/admin/oneTable/item/listDetail",
+    method: "GET",
+    data: params
+  });
+}
+function getDeptUsers(params) {
+  return request_request.requestAPI({
+    url: "/admin/user/dept/users",
+    method: "GET",
+    data: params
+  });
+}
+function getParentDepts() {
+  return request_request.requestAPI({
+    url: "/admin/dept/parents",
+    method: "GET"
+  });
+}
+function getInspectionWarningList(params) {
+  return request_request.requestAPI({
+    url: "/admin/warning/inspection/list",
+    method: "GET",
+    data: params
+  });
+}
+function analyzeHazardImage(params) {
+  return request_request.requestAPI({
+    url: "/frontend/ai/analyze-hazard",
+    method: "POST",
+    data: params,
+    loadingText: "AI自动识别隐患中"
+  });
+}
+function generateRectifyPlan(params) {
+  return request_request.requestAPI({
+    url: "/frontend/ai/generate-rectify-plan",
+    method: "POST",
+    data: params,
+    loadingText: "AI生成整改方案中"
+  });
+}
+function generateWriteoffContent(params) {
+  return request_request.requestAPI({
+    url: "/frontend/ai/generate-writeoff-content",
+    method: "POST",
+    data: params,
+    loadingText: "AI生成销号方案中"
+  });
+}
+exports.acceptanceRectification = acceptanceRectification;
+exports.addCheckPoint = addCheckPoint;
+exports.addCheckTable = addCheckTable;
+exports.addEnterprise = addEnterprise;
+exports.addHiddenDanger = addHiddenDanger;
+exports.addMember = addMember;
+exports.analyzeHazardImage = analyzeHazardImage;
+exports.applyDelete = applyDelete;
+exports.assignHiddenDanger = assignHiddenDanger;
+exports.deleteCheckPoint = deleteCheckPoint;
+exports.detailcheckPoint = detailcheckPoint;
+exports.enterCheckPlan = enterCheckPlan;
+exports.generateRectifyPlan = generateRectifyPlan;
+exports.generateWriteoffContent = generateWriteoffContent;
+exports.getAcceptanceList = getAcceptanceList;
+exports.getCheckItemList = getCheckItemList;
+exports.getCheckItemListDetail = getCheckItemListDetail;
+exports.getCheckPlanList = getCheckPlanList;
+exports.getCheckTableList = getCheckTableList;
+exports.getCheckTaskDetail = getCheckTaskDetail;
+exports.getDepartmentPersonUsers = getDepartmentPersonUsers;
+exports.getDeptUsers = getDeptUsers;
+exports.getDeptUsersWithSubordinates = getDeptUsersWithSubordinates;
+exports.getEnterpriseinfo = getEnterpriseinfo;
+exports.getEnterprisetype = getEnterprisetype;
+exports.getHiddenDangerDetail = getHiddenDangerDetail;
+exports.getHiddenDangerLabelList = getHiddenDangerLabelList;
+exports.getHiddenDangerList = getHiddenDangerList;
+exports.getInspectionWarningList = getInspectionWarningList;
+exports.getMemberList = getMemberList;
+exports.getMyHiddenDangerList = getMyHiddenDangerList;
+exports.getMyWriteOffList = getMyWriteOffList;
+exports.getParentDepts = getParentDepts;
+exports.getRectifyDetail = getRectifyDetail;
+exports.getRegulationList = getRegulationList;
+exports.getindustry = getindustry;
+exports.lockOrUnlockMember = lockOrUnlockMember;
+exports.login = login;
+exports.submitCheckResult = submitCheckResult;
+exports.submitRectification = submitRectification;
+exports.updateEnterprise = updateEnterprise;
+//# sourceMappingURL=../../.sourcemap/mp-weixin/request/api.js.map

unpackage/dist/dev/mp-weixin/request/luch-request/adapters/index.js

@@ -0,0 +1,85 @@
+"use strict";
+const common_vendor = require("../../../common/vendor.js");
+const request_luchRequest_helpers_buildURL = require("../helpers/buildURL.js");
+const request_luchRequest_core_buildFullPath = require("../core/buildFullPath.js");
+const request_luchRequest_core_settle = require("../core/settle.js");
+const request_luchRequest_utils = require("../utils.js");
+const mergeKeys = (keys, config2) => {
+  let config = {};
+  keys.forEach((prop) => {
+    if (!request_luchRequest_utils.isUndefined(config2[prop])) {
+      config[prop] = config2[prop];
+    }
+  });
+  return config;
+};
+const adapter = (config) => {
+  return new Promise((resolve, reject) => {
+    let fullPath = request_luchRequest_helpers_buildURL.buildURL(request_luchRequest_core_buildFullPath.buildFullPath(config.baseURL, config.url), config.params, config.paramsSerializer);
+    const _config = {
+      url: fullPath,
+      header: config.header,
+      complete: (response) => {
+        config.fullPath = fullPath;
+        response.config = config;
+        response.rawData = response.data;
+        try {
+          let jsonParseHandle = false;
+          const forcedJSONParsingType = typeof config.forcedJSONParsing;
+          if (forcedJSONParsingType === "boolean") {
+            jsonParseHandle = config.forcedJSONParsing;
+          } else if (forcedJSONParsingType === "object") {
+            const includesMethod = config.forcedJSONParsing.include || [];
+            jsonParseHandle = includesMethod.includes(config.method);
+          }
+          if (jsonParseHandle && typeof response.data === "string") {
+            response.data = JSON.parse(response.data);
+          }
+        } catch (e) {
+        }
+        request_luchRequest_core_settle.settle(resolve, reject, response);
+      }
+    };
+    let requestTask;
+    if (config.method === "UPLOAD") {
+      delete _config.header["content-type"];
+      delete _config.header["Content-Type"];
+      let otherConfig = {
+        filePath: config.filePath,
+        name: config.name
+      };
+      const optionalKeys = [
+        "timeout",
+        "formData"
+      ];
+      requestTask = common_vendor.index.uploadFile({ ..._config, ...otherConfig, ...mergeKeys(optionalKeys, config) });
+    } else if (config.method === "DOWNLOAD") {
+      const optionalKeys = [
+        "timeout",
+        "filePath"
+      ];
+      requestTask = common_vendor.index.downloadFile({ ..._config, ...mergeKeys(optionalKeys, config) });
+    } else {
+      const optionalKeys = [
+        "data",
+        "method",
+        "timeout",
+        "dataType",
+        "responseType",
+        "enableHttp2",
+        "enableQuic",
+        "enableCache",
+        "enableHttpDNS",
+        "httpDNSServiceId",
+        "enableChunked",
+        "forceCellularNetwork"
+      ];
+      requestTask = common_vendor.index.request({ ..._config, ...mergeKeys(optionalKeys, config) });
+    }
+    if (config.getTask) {
+      config.getTask(requestTask, config);
+    }
+  });
+};
+exports.adapter = adapter;
+//# sourceMappingURL=../../../../.sourcemap/mp-weixin/request/luch-request/adapters/index.js.map

unpackage/dist/dev/mp-weixin/request/luch-request/core/InterceptorManager.js

@@ -0,0 +1,25 @@
+"use strict";
+function InterceptorManager() {
+  this.handlers = [];
+}
+InterceptorManager.prototype.use = function use(fulfilled, rejected) {
+  this.handlers.push({
+    fulfilled,
+    rejected
+  });
+  return this.handlers.length - 1;
+};
+InterceptorManager.prototype.eject = function eject(id) {
+  if (this.handlers[id]) {
+    this.handlers[id] = null;
+  }
+};
+InterceptorManager.prototype.forEach = function forEach(fn) {
+  this.handlers.forEach((h) => {
+    if (h !== null) {
+      fn(h);
+    }
+  });
+};
+exports.InterceptorManager = InterceptorManager;
+//# sourceMappingURL=../../../../.sourcemap/mp-weixin/request/luch-request/core/InterceptorManager.js.map

unpackage/dist/dev/mp-weixin/request/luch-request/core/Request.js

@@ -0,0 +1,149 @@
+"use strict";
+const common_vendor = require("../../../common/vendor.js");
+const request_luchRequest_core_dispatchRequest = require("./dispatchRequest.js");
+const request_luchRequest_core_InterceptorManager = require("./InterceptorManager.js");
+const request_luchRequest_core_mergeConfig = require("./mergeConfig.js");
+const request_luchRequest_core_defaults = require("./defaults.js");
+const request_luchRequest_utils = require("../utils.js");
+const request_luchRequest_utils_clone = require("../utils/clone.js");
+class Request {
+  /**
+   * @param {Object} arg - 全局配置
+   * @param {String} arg.baseURL - 全局根路径
+   * @param {Object} arg.header - 全局header
+   * @param {String} arg.method = [GET|POST|PUT|DELETE|CONNECT|HEAD|OPTIONS|TRACE] - 全局默认请求方式
+   * @param {String} arg.dataType = [json] - 全局默认的dataType
+   * @param {String} arg.responseType = [text|arraybuffer] - 全局默认的responseType。支付宝小程序不支持
+   * @param {Object} arg.custom - 全局默认的自定义参数
+   * @param {Number} arg.timeout - 全局默认的超时时间，单位 ms。默认60000。H5(HBuilderX 2.9.9+)、APP(HBuilderX 2.9.9+)、微信小程序（2.10.0）、支付宝小程序
+   * @param {Boolean} arg.sslVerify - 全局默认的是否验证 ssl 证书。默认true.仅App安卓端支持（HBuilderX 2.3.3+）
+   * @param {Boolean} arg.withCredentials - 全局默认的跨域请求时是否携带凭证（cookies）。默认false。仅H5支持（HBuilderX 2.6.15+）
+   * @param {Boolean} arg.firstIpv4 - 全DNS解析时优先使用ipv4。默认false。仅 App-Android 支持 (HBuilderX 2.8.0+)
+   * @param {Function(statusCode):Boolean} arg.validateStatus - 全局默认的自定义验证器。默认statusCode >= 200 && statusCode < 300
+   */
+  constructor(arg = {}) {
+    if (!request_luchRequest_utils.isPlainObject(arg)) {
+      arg = {};
+      common_vendor.index.__f__("warn", "at request/luch-request/core/Request.js:37", "设置全局参数必须接收一个Object");
+    }
+    this.config = request_luchRequest_utils_clone.clone({ ...request_luchRequest_core_defaults.defaults, ...arg });
+    this.interceptors = {
+      request: new request_luchRequest_core_InterceptorManager.InterceptorManager(),
+      response: new request_luchRequest_core_InterceptorManager.InterceptorManager()
+    };
+  }
+  /**
+   * @Function
+   * @param {Request~setConfigCallback} f - 设置全局默认配置
+   */
+  setConfig(f) {
+    this.config = f(this.config);
+  }
+  middleware(config) {
+    config = request_luchRequest_core_mergeConfig.mergeConfig(this.config, config);
+    let chain = [request_luchRequest_core_dispatchRequest.dispatchRequest, void 0];
+    let promise = Promise.resolve(config);
+    this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+      chain.unshift(interceptor.fulfilled, interceptor.rejected);
+    });
+    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+      chain.push(interceptor.fulfilled, interceptor.rejected);
+    });
+    while (chain.length) {
+      promise = promise.then(chain.shift(), chain.shift());
+    }
+    return promise;
+  }
+  /**
+   * @Function
+   * @param {Object} config - 请求配置项
+   * @prop {String} options.url - 请求路径
+   * @prop {Object} options.data - 请求参数
+   * @prop {Object} [options.responseType = config.responseType] [text|arraybuffer] - 响应的数据类型
+   * @prop {Object} [options.dataType = config.dataType] - 如果设为 json，会尝试对返回的数据做一次 JSON.parse
+   * @prop {Object} [options.header = config.header] - 请求header
+   * @prop {Object} [options.method = config.method] - 请求方法
+   * @returns {Promise<unknown>}
+   */
+  request(config = {}) {
+    return this.middleware(config);
+  }
+  get(url, options = {}) {
+    return this.middleware({
+      url,
+      method: "GET",
+      ...options
+    });
+  }
+  post(url, data, options = {}) {
+    return this.middleware({
+      url,
+      data,
+      method: "POST",
+      ...options
+    });
+  }
+  put(url, data, options = {}) {
+    return this.middleware({
+      url,
+      data,
+      method: "PUT",
+      ...options
+    });
+  }
+  delete(url, data, options = {}) {
+    return this.middleware({
+      url,
+      data,
+      method: "DELETE",
+      ...options
+    });
+  }
+  connect(url, data, options = {}) {
+    return this.middleware({
+      url,
+      data,
+      method: "CONNECT",
+      ...options
+    });
+  }
+  head(url, data, options = {}) {
+    return this.middleware({
+      url,
+      data,
+      method: "HEAD",
+      ...options
+    });
+  }
+  options(url, data, options = {}) {
+    return this.middleware({
+      url,
+      data,
+      method: "OPTIONS",
+      ...options
+    });
+  }
+  trace(url, data, options = {}) {
+    return this.middleware({
+      url,
+      data,
+      method: "TRACE",
+      ...options
+    });
+  }
+  upload(url, config = {}) {
+    config.url = url;
+    config.method = "UPLOAD";
+    return this.middleware(config);
+  }
+  download(url, config = {}) {
+    config.url = url;
+    config.method = "DOWNLOAD";
+    return this.middleware(config);
+  }
+  get version() {
+    return "3.1.0";
+  }
+}
+exports.Request = Request;
+//# sourceMappingURL=../../../../.sourcemap/mp-weixin/request/luch-request/core/Request.js.map

unpackage/dist/dev/mp-weixin/request/luch-request/core/buildFullPath.js

@@ -0,0 +1,11 @@
+"use strict";
+const request_luchRequest_helpers_isAbsoluteURL = require("../helpers/isAbsoluteURL.js");
+const request_luchRequest_helpers_combineURLs = require("../helpers/combineURLs.js");
+function buildFullPath(baseURL, requestedURL) {
+  if (baseURL && !request_luchRequest_helpers_isAbsoluteURL.isAbsoluteURL(requestedURL)) {
+    return request_luchRequest_helpers_combineURLs.combineURLs(baseURL, requestedURL);
+  }
+  return requestedURL;
+}
+exports.buildFullPath = buildFullPath;
+//# sourceMappingURL=../../../../.sourcemap/mp-weixin/request/luch-request/core/buildFullPath.js.map

unpackage/dist/dev/mp-weixin/request/luch-request/core/defaults.js

@@ -0,0 +1,18 @@
+"use strict";
+const defaults = {
+  baseURL: "",
+  header: {},
+  method: "GET",
+  dataType: "json",
+  paramsSerializer: null,
+  responseType: "text",
+  custom: {},
+  timeout: 6e4,
+  validateStatus: function validateStatus(status) {
+    return status >= 200 && status < 300;
+  },
+  // 是否尝试将响应数据json化
+  forcedJSONParsing: true
+};
+exports.defaults = defaults;
+//# sourceMappingURL=../../../../.sourcemap/mp-weixin/request/luch-request/core/defaults.js.map

unpackage/dist/dev/mp-weixin/request/luch-request/core/dispatchRequest.js

@@ -0,0 +1,7 @@
+"use strict";
+const request_luchRequest_adapters_index = require("../adapters/index.js");
+const dispatchRequest = (config) => {
+  return request_luchRequest_adapters_index.adapter(config);
+};
+exports.dispatchRequest = dispatchRequest;
+//# sourceMappingURL=../../../../.sourcemap/mp-weixin/request/luch-request/core/dispatchRequest.js.map

unpackage/dist/dev/mp-weixin/request/luch-request/core/mergeConfig.js

@@ -0,0 +1,68 @@
+"use strict";
+const request_luchRequest_utils = require("../utils.js");
+const mergeKeys = (keys, globalsConfig, config2) => {
+  let config = {};
+  keys.forEach((prop) => {
+    if (!request_luchRequest_utils.isUndefined(config2[prop])) {
+      config[prop] = config2[prop];
+    } else if (!request_luchRequest_utils.isUndefined(globalsConfig[prop])) {
+      config[prop] = globalsConfig[prop];
+    }
+  });
+  return config;
+};
+const mergeConfig = (globalsConfig, config2 = {}) => {
+  const method = config2.method || globalsConfig.method || "GET";
+  let config = {
+    baseURL: config2.baseURL || globalsConfig.baseURL || "",
+    method,
+    url: config2.url || "",
+    params: config2.params || {},
+    custom: { ...globalsConfig.custom || {}, ...config2.custom || {} },
+    header: request_luchRequest_utils.deepMerge(globalsConfig.header || {}, config2.header || {})
+  };
+  const defaultToConfig2Keys = ["getTask", "validateStatus", "paramsSerializer", "forcedJSONParsing"];
+  config = { ...config, ...mergeKeys(defaultToConfig2Keys, globalsConfig, config2) };
+  if (method === "DOWNLOAD") {
+    const downloadKeys = [
+      "timeout",
+      "filePath"
+    ];
+    config = { ...config, ...mergeKeys(downloadKeys, globalsConfig, config2) };
+  } else if (method === "UPLOAD") {
+    delete config.header["content-type"];
+    delete config.header["Content-Type"];
+    const uploadKeys = [
+      "filePath",
+      "name",
+      "timeout",
+      "formData"
+    ];
+    uploadKeys.forEach((prop) => {
+      if (!request_luchRequest_utils.isUndefined(config2[prop])) {
+        config[prop] = config2[prop];
+      }
+    });
+    if (request_luchRequest_utils.isUndefined(config.timeout) && !request_luchRequest_utils.isUndefined(globalsConfig.timeout)) {
+      config["timeout"] = globalsConfig["timeout"];
+    }
+  } else {
+    const defaultsKeys = [
+      "data",
+      "timeout",
+      "dataType",
+      "responseType",
+      "enableHttp2",
+      "enableQuic",
+      "enableCache",
+      "enableHttpDNS",
+      "httpDNSServiceId",
+      "enableChunked",
+      "forceCellularNetwork"
+    ];
+    config = { ...config, ...mergeKeys(defaultsKeys, globalsConfig, config2) };
+  }
+  return config;
+};
+exports.mergeConfig = mergeConfig;
+//# sourceMappingURL=../../../../.sourcemap/mp-weixin/request/luch-request/core/mergeConfig.js.map

unpackage/dist/dev/mp-weixin/request/luch-request/core/settle.js

@@ -0,0 +1,12 @@
+"use strict";
+function settle(resolve, reject, response) {
+  const validateStatus = response.config.validateStatus;
+  const status = response.statusCode;
+  if (status && (!validateStatus || validateStatus(status))) {
+    resolve(response);
+  } else {
+    reject(response);
+  }
+}
+exports.settle = settle;
+//# sourceMappingURL=../../../../.sourcemap/mp-weixin/request/luch-request/core/settle.js.map

unpackage/dist/dev/mp-weixin/request/luch-request/helpers/buildURL.js

@@ -0,0 +1,47 @@
+"use strict";
+const request_luchRequest_utils = require("../utils.js");
+function encode(val) {
+  return encodeURIComponent(val).replace(/%40/gi, "@").replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+}
+function buildURL(url, params, paramsSerializer) {
+  if (!params) {
+    return url;
+  }
+  var serializedParams;
+  if (paramsSerializer) {
+    serializedParams = paramsSerializer(params);
+  } else if (request_luchRequest_utils.isURLSearchParams(params)) {
+    serializedParams = params.toString();
+  } else {
+    var parts = [];
+    request_luchRequest_utils.forEach(params, function serialize(val, key) {
+      if (val === null || typeof val === "undefined") {
+        return;
+      }
+      if (request_luchRequest_utils.isArray(val)) {
+        key = key + "[]";
+      } else {
+        val = [val];
+      }
+      request_luchRequest_utils.forEach(val, function parseValue(v) {
+        if (request_luchRequest_utils.isDate(v)) {
+          v = v.toISOString();
+        } else if (request_luchRequest_utils.isObject(v)) {
+          v = JSON.stringify(v);
+        }
+        parts.push(encode(key) + "=" + encode(v));
+      });
+    });
+    serializedParams = parts.join("&");
+  }
+  if (serializedParams) {
+    var hashmarkIndex = url.indexOf("#");
+    if (hashmarkIndex !== -1) {
+      url = url.slice(0, hashmarkIndex);
+    }
+    url += (url.indexOf("?") === -1 ? "?" : "&") + serializedParams;
+  }
+  return url;
+}
+exports.buildURL = buildURL;
+//# sourceMappingURL=../../../../.sourcemap/mp-weixin/request/luch-request/helpers/buildURL.js.map

unpackage/dist/dev/mp-weixin/request/luch-request/helpers/combineURLs.js

@@ -0,0 +1,6 @@
+"use strict";
+function combineURLs(baseURL, relativeURL) {
+  return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+}
+exports.combineURLs = combineURLs;
+//# sourceMappingURL=../../../../.sourcemap/mp-weixin/request/luch-request/helpers/combineURLs.js.map

unpackage/dist/dev/mp-weixin/request/luch-request/helpers/isAbsoluteURL.js

@@ -0,0 +1,6 @@
+"use strict";
+function isAbsoluteURL(url) {
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+}
+exports.isAbsoluteURL = isAbsoluteURL;
+//# sourceMappingURL=../../../../.sourcemap/mp-weixin/request/luch-request/helpers/isAbsoluteURL.js.map

unpackage/dist/dev/mp-weixin/request/luch-request/index.js

@@ -0,0 +1,3 @@
+"use strict";
+const request_luchRequest_core_Request = require("./core/Request.js");
+//# sourceMappingURL=../../../.sourcemap/mp-weixin/request/luch-request/index.js.map

unpackage/dist/dev/mp-weixin/request/luch-request/utils.js

@@ -0,0 +1,64 @@
+"use strict";
+var toString = Object.prototype.toString;
+function isArray(val) {
+  return toString.call(val) === "[object Array]";
+}
+function isObject(val) {
+  return val !== null && typeof val === "object";
+}
+function isDate(val) {
+  return toString.call(val) === "[object Date]";
+}
+function isURLSearchParams(val) {
+  return typeof URLSearchParams !== "undefined" && val instanceof URLSearchParams;
+}
+function forEach(obj, fn) {
+  if (obj === null || typeof obj === "undefined") {
+    return;
+  }
+  if (typeof obj !== "object") {
+    obj = [obj];
+  }
+  if (isArray(obj)) {
+    for (var i = 0, l = obj.length; i < l; i++) {
+      fn.call(null, obj[i], i, obj);
+    }
+  } else {
+    for (var key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        fn.call(null, obj[key], key, obj);
+      }
+    }
+  }
+}
+function isPlainObject(obj) {
+  return Object.prototype.toString.call(obj) === "[object Object]";
+}
+function deepMerge() {
+  let result = {};
+  function assignValue(val, key) {
+    if (typeof result[key] === "object" && typeof val === "object") {
+      result[key] = deepMerge(result[key], val);
+    } else if (typeof val === "object") {
+      result[key] = deepMerge({}, val);
+    } else {
+      result[key] = val;
+    }
+  }
+  for (let i = 0, l = arguments.length; i < l; i++) {
+    forEach(arguments[i], assignValue);
+  }
+  return result;
+}
+function isUndefined(val) {
+  return typeof val === "undefined";
+}
+exports.deepMerge = deepMerge;
+exports.forEach = forEach;
+exports.isArray = isArray;
+exports.isDate = isDate;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.isURLSearchParams = isURLSearchParams;
+exports.isUndefined = isUndefined;
+//# sourceMappingURL=../../../.sourcemap/mp-weixin/request/luch-request/utils.js.map

unpackage/dist/dev/mp-weixin/request/luch-request/utils/clone.js

@@ -0,0 +1,196 @@
+"use strict";
+var clone = function() {
+  function _instanceof(obj, type) {
+    return type != null && obj instanceof type;
+  }
+  var nativeMap;
+  try {
+    nativeMap = Map;
+  } catch (_) {
+    nativeMap = function() {
+    };
+  }
+  var nativeSet;
+  try {
+    nativeSet = Set;
+  } catch (_) {
+    nativeSet = function() {
+    };
+  }
+  var nativePromise;
+  try {
+    nativePromise = Promise;
+  } catch (_) {
+    nativePromise = function() {
+    };
+  }
+  function clone2(parent, circular, depth, prototype, includeNonEnumerable) {
+    if (typeof circular === "object") {
+      depth = circular.depth;
+      prototype = circular.prototype;
+      includeNonEnumerable = circular.includeNonEnumerable;
+      circular = circular.circular;
+    }
+    var allParents = [];
+    var allChildren = [];
+    var useBuffer = typeof Buffer != "undefined";
+    if (typeof circular == "undefined")
+      circular = true;
+    if (typeof depth == "undefined")
+      depth = Infinity;
+    function _clone(parent2, depth2) {
+      if (parent2 === null)
+        return null;
+      if (depth2 === 0)
+        return parent2;
+      var child;
+      var proto;
+      if (typeof parent2 != "object") {
+        return parent2;
+      }
+      if (_instanceof(parent2, nativeMap)) {
+        child = new nativeMap();
+      } else if (_instanceof(parent2, nativeSet)) {
+        child = new nativeSet();
+      } else if (_instanceof(parent2, nativePromise)) {
+        child = new nativePromise(function(resolve, reject) {
+          parent2.then(function(value) {
+            resolve(_clone(value, depth2 - 1));
+          }, function(err) {
+            reject(_clone(err, depth2 - 1));
+          });
+        });
+      } else if (clone2.__isArray(parent2)) {
+        child = [];
+      } else if (clone2.__isRegExp(parent2)) {
+        child = new RegExp(parent2.source, __getRegExpFlags(parent2));
+        if (parent2.lastIndex)
+          child.lastIndex = parent2.lastIndex;
+      } else if (clone2.__isDate(parent2)) {
+        child = new Date(parent2.getTime());
+      } else if (useBuffer && Buffer.isBuffer(parent2)) {
+        if (Buffer.from) {
+          child = Buffer.from(parent2);
+        } else {
+          child = new Buffer(parent2.length);
+          parent2.copy(child);
+        }
+        return child;
+      } else if (_instanceof(parent2, Error)) {
+        child = Object.create(parent2);
+      } else {
+        if (typeof prototype == "undefined") {
+          proto = Object.getPrototypeOf(parent2);
+          child = Object.create(proto);
+        } else {
+          child = Object.create(prototype);
+          proto = prototype;
+        }
+      }
+      if (circular) {
+        var index = allParents.indexOf(parent2);
+        if (index != -1) {
+          return allChildren[index];
+        }
+        allParents.push(parent2);
+        allChildren.push(child);
+      }
+      if (_instanceof(parent2, nativeMap)) {
+        parent2.forEach(function(value, key) {
+          var keyChild = _clone(key, depth2 - 1);
+          var valueChild = _clone(value, depth2 - 1);
+          child.set(keyChild, valueChild);
+        });
+      }
+      if (_instanceof(parent2, nativeSet)) {
+        parent2.forEach(function(value) {
+          var entryChild = _clone(value, depth2 - 1);
+          child.add(entryChild);
+        });
+      }
+      for (var i in parent2) {
+        var attrs = Object.getOwnPropertyDescriptor(parent2, i);
+        if (attrs) {
+          child[i] = _clone(parent2[i], depth2 - 1);
+        }
+        try {
+          var objProperty = Object.getOwnPropertyDescriptor(parent2, i);
+          if (objProperty.set === "undefined") {
+            continue;
+          }
+          child[i] = _clone(parent2[i], depth2 - 1);
+        } catch (e) {
+          if (e instanceof TypeError) {
+            continue;
+          } else if (e instanceof ReferenceError) {
+            continue;
+          }
+        }
+      }
+      if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(parent2);
+        for (var i = 0; i < symbols.length; i++) {
+          var symbol = symbols[i];
+          var descriptor = Object.getOwnPropertyDescriptor(parent2, symbol);
+          if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {
+            continue;
+          }
+          child[symbol] = _clone(parent2[symbol], depth2 - 1);
+          Object.defineProperty(child, symbol, descriptor);
+        }
+      }
+      if (includeNonEnumerable) {
+        var allPropertyNames = Object.getOwnPropertyNames(parent2);
+        for (var i = 0; i < allPropertyNames.length; i++) {
+          var propertyName = allPropertyNames[i];
+          var descriptor = Object.getOwnPropertyDescriptor(parent2, propertyName);
+          if (descriptor && descriptor.enumerable) {
+            continue;
+          }
+          child[propertyName] = _clone(parent2[propertyName], depth2 - 1);
+          Object.defineProperty(child, propertyName, descriptor);
+        }
+      }
+      return child;
+    }
+    return _clone(parent, depth);
+  }
+  clone2.clonePrototype = function clonePrototype(parent) {
+    if (parent === null)
+      return null;
+    var c = function() {
+    };
+    c.prototype = parent;
+    return new c();
+  };
+  function __objToStr(o) {
+    return Object.prototype.toString.call(o);
+  }
+  clone2.__objToStr = __objToStr;
+  function __isDate(o) {
+    return typeof o === "object" && __objToStr(o) === "[object Date]";
+  }
+  clone2.__isDate = __isDate;
+  function __isArray(o) {
+    return typeof o === "object" && __objToStr(o) === "[object Array]";
+  }
+  clone2.__isArray = __isArray;
+  function __isRegExp(o) {
+    return typeof o === "object" && __objToStr(o) === "[object RegExp]";
+  }
+  clone2.__isRegExp = __isRegExp;
+  function __getRegExpFlags(re) {
+    var flags = "";
+    if (re.global)
+      flags += "g";
+    if (re.ignoreCase)
+      flags += "i";
+    if (re.multiline)
+      flags += "m";
+    return flags;
+  }
+  clone2.__getRegExpFlags = __getRegExpFlags;
+  return clone2;
+}();
+exports.clone = clone;
+//# sourceMappingURL=../../../../.sourcemap/mp-weixin/request/luch-request/utils/clone.js.map

unpackage/dist/dev/mp-weixin/request/request.js

@@ -0,0 +1,119 @@
+"use strict";
+const common_vendor = require("../common/vendor.js");
+const request_luchRequest_core_Request = require("./luch-request/core/Request.js");
+const baseUrl = "https://yingji.hexieapi.com/prod-api";
+const imageBaseUrl = baseUrl.replace(/\/prod-api\/?$/, "");
+new request_luchRequest_core_Request.Request({
+  baseURL: baseUrl,
+  timeout: 1e4
+});
+const getToken = () => {
+  const token = common_vendor.index.getStorageSync("token");
+  return token ? `Bearer ${token}` : "";
+};
+const isEmptyObject = (obj) => {
+  return Object.keys(obj).length === 0;
+};
+const objectToQueryString = (obj) => {
+  const keyValuePairs = [];
+  for (let key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      keyValuePairs.push(encodeURIComponent(key) + "=" + encodeURIComponent(obj[key]));
+    }
+  }
+  return keyValuePairs.join("&");
+};
+function showToast(title) {
+  setTimeout(() => {
+    common_vendor.index.showToast({
+      title,
+      icon: "none",
+      duration: 2e3
+    });
+  }, 100);
+}
+const requestAPI = (config) => {
+  let { url, method = "GET", data = {}, noAuth = false, loadingText } = typeof config === "object" && config.url ? config : { url: config, method: arguments[1] || "GET", data: arguments[2] || {} };
+  if (method == "GET" && !isEmptyObject(data)) {
+    url += "?" + objectToQueryString(data);
+  }
+  if (loadingText !== false) {
+    common_vendor.index.showLoading({
+      title: loadingText || "加载中..."
+    });
+  }
+  const header = {
+    "Content-Type": "application/json"
+  };
+  if (!noAuth) {
+    const token = getToken();
+    if (token) {
+      header["Authorization"] = token;
+    }
+  }
+  return new Promise((resolve, reject) => {
+    common_vendor.index.request({
+      url: baseUrl + url,
+      method,
+      data,
+      header,
+      success: (res) => {
+        common_vendor.index.hideLoading();
+        if (res.statusCode !== 200) {
+          common_vendor.index.__f__("error", "at request/request.js:85", "HTTP错误:", res.statusCode);
+          reject(`HTTP_${res.statusCode}`);
+          return;
+        }
+        if (res.data && res.data.code !== void 0) {
+          if (res.data.code === 200 || res.data.code === 0 || res.code === 0) {
+            resolve(res.data);
+          } else if (res.data.code === 401) {
+            common_vendor.index.removeStorageSync("token");
+            common_vendor.index.removeStorageSync("userInfo");
+            showToast("登录已过期，请重新登录");
+            setTimeout(() => {
+              common_vendor.index.reLaunch({
+                url: "/pages/login/login"
+              });
+            }, 1500);
+            reject({ code: 401, msg: "登录已过期" });
+          } else {
+            const errorMsg = res.data.msg || res.data.message || res.data.error || res.msg || "请求失败";
+            common_vendor.index.__f__("error", "at request/request.js:110", "接口错误:", res.data);
+            showToast(errorMsg);
+            reject({ code: res.data.code, msg: errorMsg, data: res.data });
+          }
+        } else {
+          resolve(res.data);
+        }
+      },
+      fail: (err) => {
+        common_vendor.index.__f__("error", "at request/request.js:121", "网络请求失败:", err);
+        common_vendor.index.hideLoading();
+        if (err.errMsg && err.errMsg.includes("request:fail")) {
+          showToast("网络连接失败，请检查网络设置");
+        } else if (err.errMsg && err.errMsg.includes("timeout")) {
+          showToast("请求超时，请稍后重试");
+        } else {
+          showToast("网络异常，请稍后重试");
+        }
+        reject(err);
+      }
+    });
+  });
+};
+const toImageUrl = (filePath) => {
+  if (!filePath)
+    return "";
+  const p = String(filePath);
+  if (p.startsWith("http://") || p.startsWith("https://")) {
+    return p.replace(/\/prod-api(?=\/|$)/, "");
+  }
+  const normalized = p.startsWith("/") ? p : `/${p}`;
+  return imageBaseUrl + normalized;
+};
+exports.baseUrl = baseUrl;
+exports.getToken = getToken;
+exports.requestAPI = requestAPI;
+exports.toImageUrl = toImageUrl;
+//# sourceMappingURL=../../.sourcemap/mp-weixin/request/request.js.map

unpackage/dist/dev/mp-weixin/request/three_one_api/area.js

@@ -0,0 +1,43 @@
+"use strict";
+const request_request = require("../request.js");
+function deleteArea(params) {
+  return request_request.requestAPI({
+    url: "/frontend/area/delete",
+    method: "POST",
+    data: params
+  });
+}
+function updateArea(params) {
+  return request_request.requestAPI({
+    url: "/frontend/area/update",
+    method: "POST",
+    data: params
+  });
+}
+function addArea(params) {
+  return request_request.requestAPI({
+    url: "/frontend/area/add",
+    method: "POST",
+    data: params
+  });
+}
+function getAreaDetail(params) {
+  return request_request.requestAPI({
+    url: "/frontend/area/detail",
+    method: "GET",
+    data: params
+  });
+}
+function getAreaList(params) {
+  return request_request.requestAPI({
+    url: "/frontend/area/list",
+    method: "GET",
+    data: params
+  });
+}
+exports.addArea = addArea;
+exports.deleteArea = deleteArea;
+exports.getAreaDetail = getAreaDetail;
+exports.getAreaList = getAreaList;
+exports.updateArea = updateArea;
+//# sourceMappingURL=../../../.sourcemap/mp-weixin/request/three_one_api/area.js.map

unpackage/dist/dev/mp-weixin/request/three_one_api/info.js

@@ -0,0 +1,26 @@
+"use strict";
+const request_request = require("../request.js");
+function getProfileDetail() {
+  return request_request.requestAPI({
+    url: "/frontend/profile/detail",
+    method: "GET"
+  });
+}
+function updateProfile(params) {
+  return request_request.requestAPI({
+    url: "/frontend/profile/update",
+    method: "POST",
+    data: params
+  });
+}
+function updatePassword(params) {
+  return request_request.requestAPI({
+    url: "/frontend/profile/password",
+    method: "POST",
+    data: params
+  });
+}
+exports.getProfileDetail = getProfileDetail;
+exports.updatePassword = updatePassword;
+exports.updateProfile = updateProfile;
+//# sourceMappingURL=../../../.sourcemap/mp-weixin/request/three_one_api/info.js.map

unpackage/dist/dev/mp-weixin/request/three_one_api/license.js

@@ -0,0 +1,50 @@
+"use strict";
+const request_request = require("../request.js");
+function getLicenseEnterpriseSelect() {
+  return request_request.requestAPI({
+    url: "/frontend/license/enterprise/select",
+    method: "GET"
+  });
+}
+function deleteLicense(params) {
+  return request_request.requestAPI({
+    url: "/frontend/license/delete",
+    method: "POST",
+    data: params
+  });
+}
+function updateLicense(params) {
+  return request_request.requestAPI({
+    url: "/frontend/license/update",
+    method: "POST",
+    data: params
+  });
+}
+function addLicense(params) {
+  return request_request.requestAPI({
+    url: "/frontend/license/add",
+    method: "POST",
+    data: params
+  });
+}
+function getLicenseDetail(params) {
+  return request_request.requestAPI({
+    url: "/frontend/license/detail",
+    method: "GET",
+    data: params
+  });
+}
+function getLicenseList(params) {
+  return request_request.requestAPI({
+    url: "/frontend/license/list",
+    method: "GET",
+    data: params
+  });
+}
+exports.addLicense = addLicense;
+exports.deleteLicense = deleteLicense;
+exports.getLicenseDetail = getLicenseDetail;
+exports.getLicenseEnterpriseSelect = getLicenseEnterpriseSelect;
+exports.getLicenseList = getLicenseList;
+exports.updateLicense = updateLicense;
+//# sourceMappingURL=../../../.sourcemap/mp-weixin/request/three_one_api/license.js.map