@uozi-admin/request/dist/index.mjs

Easy to create curd request functions.

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));

// src/index.ts
var index_exports = {};
__export(index_exports, {
  config: () => config,
  extendCurdApi: () => extendCurdApi,
  http: () => http,
  service: () => service,
  setOverrideConfig: () => setOverrideConfig,
  setRequestConfig: () => setRequestConfig,
  useAxios: () => useAxios,
  useCurdApi: () => useCurdApi
});

// src/axios.ts
var axios_exports = {};
__export(axios_exports, {
  service: () => service,
  setOverrideConfig: () => setOverrideConfig
});
import axios from "axios";

// src/config.ts
import { merge } from "lodash-es";
var config = {
  curd: {
    methods: {
      getList: "get",
      getItem: "get",
      createItem: "post",
      updateItem: "put",
      deleteItem: "delete",
      restoreItem: "post"
    }
  },
  baseURL: "/api",
  headers: {
    "Content-Type": "application/json"
  },
  timeout: 5e3
};
function setRequestConfig(userConfig) {
  Object.assign(config, merge(config, userConfig));
  return config;
}

// src/axios.ts
__reExport(axios_exports, axios_star);
import * as axios_star from "axios";
function createService() {
  return axios.create(config);
}
var service = createService();
function setOverrideConfig(userConfig) {
  const c = setRequestConfig(userConfig);
  Object.assign(service.defaults, c);
}

// src/index.ts
__reExport(index_exports, axios_exports);

// src/http.ts
var http = {
  get(url, config2 = {}) {
    return service(url, {
      method: config2.method || "get",
      ...config2
    });
  },
  post(url, data = void 0, config2 = {}) {
    return service(url, {
      method: config2.method || "post",
      data,
      ...config2
    });
  },
  put(url, data = void 0, config2 = {}) {
    return service(url, {
      method: config2.method || "put",
      data,
      ...config2
    });
  },
  delete(url, config2 = {}) {
    return service(url, {
      method: config2.method || "delete",
      ...config2
    });
  },
  patch(url, data = void 0, config2 = {}) {
    return service(url, {
      method: config2.method || "patch",
      data,
      ...config2
    });
  }
};

// src/useAxios.ts
var registeredRequestInterceptors = /* @__PURE__ */ new Set();
var registeredResponseInterceptors = /* @__PURE__ */ new Set();
function useAxios() {
  return {
    service,
    setRequestInterceptor(onFulfilled, onRejected, options) {
      const id = onFulfilled.toString() + onRejected?.toString() + JSON.stringify(options);
      if (registeredRequestInterceptors.has(id))
        return;
      service.interceptors.request.use(onFulfilled, onRejected, options);
      registeredRequestInterceptors.add(id);
    },
    setResponseInterceptor(onFulfilled, onRejected) {
      const id = onFulfilled.toString() + onRejected?.toString();
      if (registeredResponseInterceptors.has(id))
        return;
      service.interceptors.response.use(onFulfilled, onRejected);
      registeredResponseInterceptors.add(id);
    }
  };
}

// src/useCurdApi.ts
function useCurdApi(url, moreApis) {
  const getUrl = () => {
    if (typeof url === "function") {
      return url();
    }
    return url;
  };
  const getList = async (params, config2) => {
    try {
      const res = await http.get(getUrl(), { params, ...config2 });
      return Promise.resolve(res);
    } catch (err) {
      return Promise.reject(err);
    }
  };
  const getItem = async (id, params, config2) => {
    try {
      const res = await http.get(`${getUrl()}/${id}`, { params, ...config2 });
      return Promise.resolve(res);
    } catch (err) {
      return Promise.reject(err);
    }
  };
  const createItem = async (data, config2) => {
    try {
      const res = await http.post(getUrl(), data, config2);
      return Promise.resolve(res);
    } catch (err) {
      return Promise.reject(err);
    }
  };
  const updateItem = async (id, data, config2) => {
    try {
      const res = await http.post(`${getUrl()}/${id}`, data, config2);
      return Promise.resolve(res);
    } catch (err) {
      return Promise.reject(err);
    }
  };
  const deleteItem = async (id, params, config2) => {
    try {
      const res = await http.delete(`${getUrl()}/${id}`, { params, ...config2 });
      return Promise.resolve(res);
    } catch (err) {
      return Promise.reject(err);
    }
  };
  const restoreItem = async (id, params, config2) => {
    try {
      const res = await http.patch(`${getUrl()}/${id}`, {}, { params, ...config2 });
      return Promise.resolve(res);
    } catch (err) {
      return Promise.reject(err);
    }
  };
  return {
    getList,
    getItem,
    createItem,
    updateItem,
    deleteItem,
    restoreItem,
    getUrl,
    ...moreApis
  };
}
function extendCurdApi(baseCurd, newApis) {
  return Object.assign(baseCurd, newApis);
}
export {
  config,
  extendCurdApi,
  http,
  service,
  setOverrideConfig,
  setRequestConfig,
  useAxios,
  useCurdApi
};
//# sourceMappingURL=index.mjs.map