tav-ui/lib/packages/components/file/src/hooks/use-request2.js

Tav UI

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var vue = require('vue');
var lodashEs = require('lodash-es');
require('../../../../locales/index2.js');
var useMessage = require('../../../../hooks/web/useMessage2.js');
var consts = require('../consts2.js');
var transfer = require('../../../../locales/transfer2.js');

const { createMessage } = useMessage.useMessage();
function useRequest(options) {
  const resultRef = vue.ref([]);
  const errorRef = vue.ref("");
  const { setLoading, setDisable, loading } = options;
  async function handleApi(options2) {
    const {
      apiParams: _apiParams,
      api: _api,
      beforeApi: _beforeApi,
      afterApi: _afterApi,
      catchError: _catchError,
      transformApiParamsToFormData: _transformApiParamsToFormData,
      successMessage: _successMessage,
      failureMessage: _failureMessage,
      useSuccessPassRes: _useSuccessPassRes,
      callback: _callback,
      responseDataType: _responseDataType = "array"
    } = options2;
    let apiParams = _apiParams;
    let api = _api;
    let beforeApi = _beforeApi;
    let afterApi = _afterApi;
    let catchError = _catchError;
    let transformApiParamsToFormData = _transformApiParamsToFormData;
    let successMessage = _successMessage;
    let failureMessage = _failureMessage;
    let useSuccessPassRes = _useSuccessPassRes;
    let callback = _callback;
    let responseDataType = _responseDataType;
    if (!api || !lodashEs.isFunction(api))
      return;
    if (loading) {
      loading.value.value = true;
    } else {
      setLoading(true);
    }
    setDisable(true);
    try {
      if (beforeApi && lodashEs.isFunction(beforeApi)) {
        const beforeApiResult = await beforeApi(apiParams);
        if (lodashEs.isObject(beforeApiResult)) {
          apiParams = beforeApiResult.apiParams;
          api = beforeApiResult.api;
          beforeApi = beforeApiResult.beforeApi;
          afterApi = beforeApiResult.afterApi;
          catchError = beforeApiResult.catchError;
          transformApiParamsToFormData = beforeApiResult.transformApiParamsToFormData;
          successMessage = beforeApiResult.successMessage;
          failureMessage = beforeApiResult.failureMessage;
          useSuccessPassRes = beforeApiResult.useSuccessPassRes;
          callback = beforeApiResult.callback;
          responseDataType = beforeApiResult.responseDataType;
        }
        if (lodashEs.isBoolean(beforeApiResult) && beforeApiResult === false) {
          callback && callback();
          return;
        }
      }
      if (responseDataType === "object") {
        resultRef.value = {};
      }
      let apiResult;
      if (transformApiParamsToFormData) {
        if (!transformApiParamsToFormData.filterNames) {
          const formData = new FormData();
          for (const [k, v] of Object.entries(apiParams)) {
            if (transformApiParamsToFormData["fileFiledName"] && k === transformApiParamsToFormData["fileFiledName"]) {
              ;
              v.forEach((file) => {
                formData.append(transformApiParamsToFormData["fileFiledName"], file);
              });
            } else {
              formData.append(k, v);
            }
          }
          apiResult = await api(formData);
        } else {
          const formData = new FormData();
          const __apiParams = {};
          for (const [k, v] of Object.entries(apiParams)) {
            if (transformApiParamsToFormData.filterNames.includes(k)) {
              __apiParams[k] = v;
            } else {
              if (transformApiParamsToFormData["fileFiledName"] && k === transformApiParamsToFormData["fileFiledName"]) {
                ;
                v.forEach((file) => {
                  formData.append(transformApiParamsToFormData["fileFiledName"], file);
                });
              } else {
                formData.append(k, v);
              }
            }
          }
          __apiParams["formData"] = formData;
          apiResult = await api(__apiParams);
        }
      } else {
        apiResult = await api(apiParams);
      }
      const apiSuccess = useSuccessPassRes ? apiResult.success : apiResult.data && apiResult.success;
      if (apiSuccess) {
        resultRef.value = apiResult.data;
        errorRef.value = "";
        successMessage && createMessage.success(successMessage());
        if (afterApi && lodashEs.isFunction(afterApi)) {
          resultRef.value = await afterApi(apiResult.data) || apiResult.data;
          errorRef.value = "";
        }
      } else {
        resultRef.value = [];
        errorRef.value = failureMessage ? failureMessage() : consts.DEFAULT_HTTP_ERROR_TIP(transfer.tavI18n);
      }
    } catch (error2) {
      resultRef.value = [];
      errorRef.value = failureMessage ? failureMessage() : consts.DEFAULT_HTTP_ERROR_TIP(transfer.tavI18n);
      if (catchError && lodashEs.isFunction(catchError)) {
        await catchError(error2);
      }
    } finally {
      if (loading) {
        loading.value.value = false;
      } else {
        setLoading(false);
      }
      setDisable(false);
      callback && callback();
    }
  }
  const result = vue.computed(() => vue.unref(resultRef));
  const error = vue.computed(() => vue.unref(errorRef));
  return {
    result,
    error,
    handleApi
  };
}

exports.useRequest = useRequest;
//# sourceMappingURL=use-request2.js.map