@harishmano/react-enterprise-api 1.0.0

package/dist/index.js

@@ -0,0 +1,696 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createApiClient: () => createApiClient,
+  createResource: () => createResource
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/createApiClient.ts
+var import_axios = __toESM(require("axios"));
+
+// src/resource.ts
+var import_react_query = require("@tanstack/react-query");
+
+// src/utils.ts
+function buildQueryParams(options, defaultParams) {
+  var _a;
+  const params = { ...defaultParams };
+  if (!options) return params;
+  if (options.pagination) {
+    const { page, pageSize, sortBy, sortOrder } = options.pagination;
+    if (page !== void 0) params.page = page;
+    if (pageSize !== void 0) params.pageSize = pageSize;
+    if (sortBy) params.sortBy = sortBy;
+    if (sortOrder) params.sortOrder = sortOrder;
+  }
+  if (options.search) {
+    params.search = options.search;
+    if ((_a = options.searchFields) == null ? void 0 : _a.length) {
+      params.searchFields = options.searchFields.join(",");
+    }
+  }
+  if (options.filters) {
+    if (Array.isArray(options.filters)) {
+      params.filters = JSON.stringify(options.filters);
+    } else {
+      Object.assign(params, options.filters);
+    }
+  }
+  return params;
+}
+function buildQueryKey(resource, options) {
+  const key = [resource];
+  if (options == null ? void 0 : options.pagination) key.push({ pagination: options.pagination });
+  if (options == null ? void 0 : options.search) key.push({ search: options.search });
+  if (options == null ? void 0 : options.filters) key.push({ filters: serializeFilters(options.filters) });
+  return key;
+}
+function serializeFilters(filters) {
+  if (!filters) return "";
+  return JSON.stringify(filters);
+}
+function triggerBrowserDownload(blob, filename, mimeType) {
+  const resolvedBlob = mimeType && blob.type !== mimeType ? new Blob([blob], { type: mimeType }) : blob;
+  const url = URL.createObjectURL(resolvedBlob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/resource.ts
+function createResource(client, name, resourceOptions = {}) {
+  const {
+    path = `/${name}`,
+    defaultParams,
+    transform,
+    staleTime: defaultStaleTime = 1e3 * 60,
+    optimistic = false
+  } = resourceOptions;
+  function applyTransform(data) {
+    return transform ? transform(data) : data;
+  }
+  function useList(options) {
+    var _a;
+    const params = buildQueryParams(options, defaultParams);
+    const queryKey = buildQueryKey(name, options);
+    return (0, import_react_query.useQuery)({
+      queryKey,
+      queryFn: async ({ signal }) => {
+        const res = await client.get(path, {
+          params,
+          signal,
+          ...options == null ? void 0 : options.axiosConfig
+        });
+        return applyTransform(res.data);
+      },
+      staleTime: (_a = options == null ? void 0 : options.staleTime) != null ? _a : defaultStaleTime,
+      placeholderData: import_react_query.keepPreviousData,
+      enabled: options == null ? void 0 : options.enabled,
+      refetchInterval: options == null ? void 0 : options.refetchInterval
+    });
+  }
+  function useGet(id, options) {
+    var _a, _b;
+    return (0, import_react_query.useQuery)({
+      queryKey: [name, id],
+      queryFn: async ({ signal }) => {
+        const res = await client.get(`${path}/${id}`, {
+          params: buildQueryParams(options, defaultParams),
+          signal,
+          ...options == null ? void 0 : options.axiosConfig
+        });
+        return applyTransform(res.data);
+      },
+      staleTime: (_a = options == null ? void 0 : options.staleTime) != null ? _a : defaultStaleTime,
+      enabled: (_b = options == null ? void 0 : options.enabled) != null ? _b : !!id,
+      refetchInterval: options == null ? void 0 : options.refetchInterval
+    });
+  }
+  function usePaginatedList(pagination, options) {
+    var _a;
+    const mergedOptions = { ...options, pagination };
+    const params = buildQueryParams(mergedOptions, defaultParams);
+    const queryKey = buildQueryKey(`${name}/paginated`, mergedOptions);
+    return (0, import_react_query.useQuery)({
+      queryKey,
+      queryFn: async ({ signal }) => {
+        const res = await client.get(path, {
+          params,
+          signal,
+          ...options == null ? void 0 : options.axiosConfig
+        });
+        return applyTransform(res.data);
+      },
+      staleTime: (_a = options == null ? void 0 : options.staleTime) != null ? _a : defaultStaleTime,
+      placeholderData: import_react_query.keepPreviousData,
+      enabled: options == null ? void 0 : options.enabled
+    });
+  }
+  function useInfiniteList(options) {
+    var _a;
+    const baseParams = buildQueryParams(options, defaultParams);
+    return (0, import_react_query.useInfiniteQuery)({
+      queryKey: [...buildQueryKey(name, options), "infinite"],
+      queryFn: async ({ pageParam = 1, signal }) => {
+        var _a2;
+        const res = await client.get(path, {
+          params: { ...baseParams, page: pageParam, pageSize: (_a2 = options == null ? void 0 : options.pageSize) != null ? _a2 : 20 },
+          signal,
+          ...options == null ? void 0 : options.axiosConfig
+        });
+        return applyTransform(res.data);
+      },
+      initialPageParam: 1,
+      getNextPageParam: (lastPage, allPages) => Array.isArray(lastPage) && lastPage.length > 0 ? allPages.length + 1 : void 0,
+      staleTime: (_a = options == null ? void 0 : options.staleTime) != null ? _a : defaultStaleTime,
+      enabled: options == null ? void 0 : options.enabled
+    });
+  }
+  function useCursorList(pagination, options) {
+    var _a;
+    const baseParams = buildQueryParams(options, defaultParams);
+    return (0, import_react_query.useInfiniteQuery)({
+      queryKey: [...buildQueryKey(name, options), "cursor", pagination],
+      queryFn: async ({ pageParam, signal }) => {
+        var _a2;
+        const res = await client.get(path, {
+          params: {
+            ...baseParams,
+            cursor: pageParam != null ? pageParam : pagination == null ? void 0 : pagination.cursor,
+            pageSize: (_a2 = pagination == null ? void 0 : pagination.pageSize) != null ? _a2 : 20,
+            sortBy: pagination == null ? void 0 : pagination.sortBy,
+            sortOrder: pagination == null ? void 0 : pagination.sortOrder
+          },
+          signal,
+          ...options == null ? void 0 : options.axiosConfig
+        });
+        return applyTransform(res.data);
+      },
+      initialPageParam: null,
+      getNextPageParam: (lastPage) => lastPage.hasMore ? lastPage.nextCursor : void 0,
+      staleTime: (_a = options == null ? void 0 : options.staleTime) != null ? _a : defaultStaleTime,
+      enabled: options == null ? void 0 : options.enabled
+    });
+  }
+  function useCreate(mutationOptions) {
+    const qc = (0, import_react_query.useQueryClient)();
+    return (0, import_react_query.useMutation)({
+      mutationFn: async (data) => {
+        const res = await client.post(path, data);
+        return applyTransform(res.data);
+      },
+      onMutate: optimistic ? async (newItem) => {
+        await qc.cancelQueries({ queryKey: [name] });
+        const prev = qc.getQueryData([name]);
+        qc.setQueryData([name], (old = []) => [
+          ...old,
+          newItem
+        ]);
+        return { prev };
+      } : void 0,
+      onError: (error, variables, context) => {
+        var _a;
+        const ctx = context;
+        if (optimistic && (ctx == null ? void 0 : ctx.prev)) qc.setQueryData([name], ctx.prev);
+        (_a = mutationOptions == null ? void 0 : mutationOptions.onError) == null ? void 0 : _a.call(mutationOptions, error, variables);
+      },
+      onSuccess: (data, variables) => {
+        var _a;
+        qc.invalidateQueries({ queryKey: [name] });
+        (_a = mutationOptions == null ? void 0 : mutationOptions.onSuccess) == null ? void 0 : _a.call(mutationOptions, data, variables);
+      },
+      onSettled: mutationOptions == null ? void 0 : mutationOptions.onSettled
+    });
+  }
+  function useUpdate(mutationOptions) {
+    const qc = (0, import_react_query.useQueryClient)();
+    return (0, import_react_query.useMutation)({
+      mutationFn: async ({ id, data }) => {
+        const res = await client.put(`${path}/${id}`, data);
+        return applyTransform(res.data);
+      },
+      onMutate: optimistic ? async ({ id, data }) => {
+        await qc.cancelQueries({ queryKey: [name, id] });
+        const prev = qc.getQueryData([name, id]);
+        qc.setQueryData([name, id], (old) => ({
+          ...old,
+          ...data
+        }));
+        return { prev };
+      } : void 0,
+      onError: (error, variables, context) => {
+        var _a;
+        const ctx = context;
+        if (optimistic && (ctx == null ? void 0 : ctx.prev)) qc.setQueryData([name, variables.id], ctx.prev);
+        (_a = mutationOptions == null ? void 0 : mutationOptions.onError) == null ? void 0 : _a.call(mutationOptions, error, variables);
+      },
+      onSuccess: (data, variables) => {
+        var _a;
+        qc.invalidateQueries({ queryKey: [name] });
+        qc.invalidateQueries({ queryKey: [name, variables.id] });
+        (_a = mutationOptions == null ? void 0 : mutationOptions.onSuccess) == null ? void 0 : _a.call(mutationOptions, data, variables);
+      },
+      onSettled: mutationOptions == null ? void 0 : mutationOptions.onSettled
+    });
+  }
+  function usePatch(mutationOptions) {
+    const qc = (0, import_react_query.useQueryClient)();
+    return (0, import_react_query.useMutation)({
+      mutationFn: async ({ id, data }) => {
+        const res = await client.patch(`${path}/${id}`, data);
+        return applyTransform(res.data);
+      },
+      onMutate: optimistic ? async ({ id, data }) => {
+        await qc.cancelQueries({ queryKey: [name, id] });
+        const prev = qc.getQueryData([name, id]);
+        qc.setQueryData([name, id], (old) => ({
+          ...old,
+          ...data
+        }));
+        return { prev };
+      } : void 0,
+      onError: (error, variables, context) => {
+        var _a;
+        const ctx = context;
+        if (optimistic && (ctx == null ? void 0 : ctx.prev)) qc.setQueryData([name, variables.id], ctx.prev);
+        (_a = mutationOptions == null ? void 0 : mutationOptions.onError) == null ? void 0 : _a.call(mutationOptions, error, variables);
+      },
+      onSuccess: (data, variables) => {
+        var _a;
+        qc.invalidateQueries({ queryKey: [name] });
+        qc.invalidateQueries({ queryKey: [name, variables.id] });
+        (_a = mutationOptions == null ? void 0 : mutationOptions.onSuccess) == null ? void 0 : _a.call(mutationOptions, data, variables);
+      },
+      onSettled: mutationOptions == null ? void 0 : mutationOptions.onSettled
+    });
+  }
+  function useDelete(mutationOptions) {
+    const qc = (0, import_react_query.useQueryClient)();
+    return (0, import_react_query.useMutation)({
+      mutationFn: async (id) => {
+        await client.delete(`${path}/${id}`);
+      },
+      onMutate: optimistic ? async (id) => {
+        await qc.cancelQueries({ queryKey: [name] });
+        const prev = qc.getQueryData([name]);
+        qc.setQueryData(
+          [name],
+          (old = []) => old.filter((item) => item.id !== id)
+        );
+        return { prev };
+      } : void 0,
+      onError: (error, id, context) => {
+        var _a;
+        const ctx = context;
+        if (optimistic && (ctx == null ? void 0 : ctx.prev)) qc.setQueryData([name], ctx.prev);
+        (_a = mutationOptions == null ? void 0 : mutationOptions.onError) == null ? void 0 : _a.call(mutationOptions, error, id);
+      },
+      onSuccess: (_, id) => {
+        var _a;
+        qc.invalidateQueries({ queryKey: [name] });
+        (_a = mutationOptions == null ? void 0 : mutationOptions.onSuccess) == null ? void 0 : _a.call(mutationOptions, void 0, id);
+      },
+      onSettled: mutationOptions == null ? void 0 : mutationOptions.onSettled
+    });
+  }
+  function useBulkDelete(mutationOptions) {
+    const qc = (0, import_react_query.useQueryClient)();
+    return (0, import_react_query.useMutation)({
+      mutationFn: async (ids) => {
+        await client.delete(path, { data: { ids } });
+      },
+      onSuccess: (_, ids) => {
+        var _a;
+        qc.invalidateQueries({ queryKey: [name] });
+        (_a = mutationOptions == null ? void 0 : mutationOptions.onSuccess) == null ? void 0 : _a.call(mutationOptions, void 0, ids);
+      },
+      onError: mutationOptions == null ? void 0 : mutationOptions.onError
+    });
+  }
+  function useBulkUpdate(mutationOptions) {
+    const qc = (0, import_react_query.useQueryClient)();
+    return (0, import_react_query.useMutation)({
+      mutationFn: async ({ ids, data }) => {
+        const res = await client.patch(path, { ids, ...data });
+        return applyTransform(res.data);
+      },
+      onSuccess: (data, variables) => {
+        var _a;
+        qc.invalidateQueries({ queryKey: [name] });
+        (_a = mutationOptions == null ? void 0 : mutationOptions.onSuccess) == null ? void 0 : _a.call(mutationOptions, data, variables);
+      },
+      onError: mutationOptions == null ? void 0 : mutationOptions.onError
+    });
+  }
+  function useUpload(uploadOptions) {
+    const qc = (0, import_react_query.useQueryClient)();
+    return (0, import_react_query.useMutation)({
+      mutationFn: async ({ id, file, extraFields }) => {
+        var _a;
+        const formData = new FormData();
+        const fieldName = (_a = uploadOptions == null ? void 0 : uploadOptions.fieldName) != null ? _a : "file";
+        if (Array.isArray(file)) {
+          file.forEach((f) => formData.append(fieldName, f));
+        } else {
+          formData.append(fieldName, file);
+        }
+        const mergedExtra = { ...uploadOptions == null ? void 0 : uploadOptions.extraFields, ...extraFields };
+        Object.entries(mergedExtra).forEach(([k, v]) => formData.append(k, v));
+        const url = id ? `${path}/${id}/upload` : `${path}/upload`;
+        const res = await client.post(url, formData, {
+          headers: { "Content-Type": "multipart/form-data" },
+          onUploadProgress: (e) => {
+            if ((uploadOptions == null ? void 0 : uploadOptions.onProgress) && e.total) {
+              uploadOptions.onProgress(Math.round(e.loaded * 100 / e.total));
+            }
+          }
+        });
+        return applyTransform(res.data);
+      },
+      onSuccess: () => qc.invalidateQueries({ queryKey: [name] })
+    });
+  }
+  function useFormData(opts) {
+    var _a, _b;
+    const qc = (0, import_react_query.useQueryClient)();
+    const method = (_a = opts == null ? void 0 : opts.method) != null ? _a : "post";
+    const url = (opts == null ? void 0 : opts.id) ? `${path}/${opts.id}` : path;
+    return (0, import_react_query.useMutation)({
+      mutationFn: async (formData) => {
+        const res = await client[method](url, formData, {
+          headers: { "Content-Type": "multipart/form-data" },
+          onUploadProgress: (e) => {
+            if ((opts == null ? void 0 : opts.onProgress) && e.total) {
+              opts.onProgress(Math.round(e.loaded * 100 / e.total));
+            }
+          }
+        });
+        return applyTransform(res.data);
+      },
+      onSuccess: (data, variables) => {
+        var _a2, _b2;
+        qc.invalidateQueries({ queryKey: [name] });
+        (_b2 = (_a2 = opts == null ? void 0 : opts.mutationOptions) == null ? void 0 : _a2.onSuccess) == null ? void 0 : _b2.call(_a2, data, variables);
+      },
+      onError: (_b = opts == null ? void 0 : opts.mutationOptions) == null ? void 0 : _b.onError
+    });
+  }
+  function useDownload(downloadOptions) {
+    return (0, import_react_query.useMutation)({
+      mutationFn: async ({ id, params }) => {
+        var _a, _b;
+        const url = id ? `${path}/${id}/download` : `${path}/download`;
+        const res = await client.get(url, {
+          params,
+          responseType: "blob",
+          onDownloadProgress: (e) => {
+            if ((downloadOptions == null ? void 0 : downloadOptions.onProgress) && e.total) {
+              downloadOptions.onProgress(Math.round(e.loaded * 100 / e.total));
+            }
+          }
+        });
+        if ((downloadOptions == null ? void 0 : downloadOptions.saveAs) !== false) {
+          const filename = (_b = (_a = downloadOptions == null ? void 0 : downloadOptions.filename) != null ? _a : extractFilename(res.headers["content-disposition"])) != null ? _b : `${name}-download`;
+          triggerBrowserDownload(res.data, filename, downloadOptions == null ? void 0 : downloadOptions.mimeType);
+        }
+        return res.data;
+      }
+    });
+  }
+  function useExport(opts) {
+    return (0, import_react_query.useMutation)({
+      mutationFn: async (queryOptions) => {
+        var _a, _b, _c;
+        const params = buildQueryParams(queryOptions, defaultParams);
+        const res = await client.get(`${path}/export`, {
+          params: { ...params, format: (_a = opts == null ? void 0 : opts.format) != null ? _a : "csv" },
+          responseType: "blob",
+          onDownloadProgress: (e) => {
+            if ((opts == null ? void 0 : opts.onProgress) && e.total) {
+              opts.onProgress(Math.round(e.loaded * 100 / e.total));
+            }
+          }
+        });
+        const fmt = (_b = opts == null ? void 0 : opts.format) != null ? _b : "csv";
+        const filename = (_c = opts == null ? void 0 : opts.filename) != null ? _c : `${name}-export.${fmt}`;
+        const mimeMap = {
+          csv: "text/csv",
+          xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+          pdf: "application/pdf"
+        };
+        triggerBrowserDownload(res.data, filename, mimeMap[fmt]);
+        return res.data;
+      }
+    });
+  }
+  function useAction(action, opts) {
+    var _a, _b;
+    const qc = (0, import_react_query.useQueryClient)();
+    const method = (_a = opts == null ? void 0 : opts.method) != null ? _a : "post";
+    const url = (opts == null ? void 0 : opts.id) ? `${path}/${opts.id}/${action}` : `${path}/${action}`;
+    return (0, import_react_query.useMutation)({
+      mutationFn: async (payload) => {
+        const res = await client[method](url, payload);
+        return applyTransform(res.data);
+      },
+      onSuccess: (data, variables) => {
+        var _a2, _b2;
+        if ((opts == null ? void 0 : opts.invalidate) !== false) {
+          qc.invalidateQueries({ queryKey: [name] });
+        }
+        (_b2 = (_a2 = opts == null ? void 0 : opts.mutationOptions) == null ? void 0 : _a2.onSuccess) == null ? void 0 : _b2.call(_a2, data, variables);
+      },
+      onError: (_b = opts == null ? void 0 : opts.mutationOptions) == null ? void 0 : _b.onError
+    });
+  }
+  function useInvalidate() {
+    const qc = (0, import_react_query.useQueryClient)();
+    return (id) => {
+      if (id) {
+        qc.invalidateQueries({ queryKey: [name, id] });
+      } else {
+        qc.invalidateQueries({ queryKey: [name] });
+      }
+    };
+  }
+  function usePrefetch() {
+    const qc = (0, import_react_query.useQueryClient)();
+    return (id) => {
+      if (id) {
+        qc.prefetchQuery({
+          queryKey: [name, id],
+          queryFn: () => client.get(`${path}/${id}`).then((r) => r.data)
+        });
+      } else {
+        qc.prefetchQuery({
+          queryKey: [name],
+          queryFn: () => client.get(path).then((r) => r.data)
+        });
+      }
+    };
+  }
+  function useSetCache() {
+    const qc = (0, import_react_query.useQueryClient)();
+    return (data, id) => {
+      if (id) {
+        qc.setQueryData([name, id], data);
+      } else {
+        qc.setQueryData([name], data);
+      }
+    };
+  }
+  return {
+    // ── Queries ──────────────────────────────────────────────────────────
+    /** Full list — with filters, search, sorting, polling */
+    useList,
+    /** Single item by ID */
+    useGet,
+    /** Page-number pagination */
+    usePaginatedList,
+    /** Offset-based infinite scroll */
+    useInfiniteList,
+    /** Cursor-based infinite scroll (for DB cursor pagination) */
+    useCursorList,
+    // ── Mutations ─────────────────────────────────────────────────────────
+    /** Create — POST /resource */
+    useCreate,
+    /** Full replace — PUT /resource/:id */
+    useUpdate,
+    /** Partial update — PATCH /resource/:id */
+    usePatch,
+    /** Delete — DELETE /resource/:id */
+    useDelete,
+    /** Delete many — DELETE /resource { ids: [...] } */
+    useBulkDelete,
+    /** Update many — PATCH /resource { ids: [...], ...fields } */
+    useBulkUpdate,
+    // ── File Operations ───────────────────────────────────────────────────
+    /** Upload file(s) with progress tracking */
+    useUpload,
+    /** Submit any FormData (mixed files + fields) */
+    useFormData,
+    /** Download blob file with progress + auto "Save As" */
+    useDownload,
+    /** Export list to CSV / XLSX / PDF */
+    useExport,
+    // ── Custom Actions ────────────────────────────────────────────────────
+    /** Arbitrary endpoint action (e.g. /resource/:id/approve) */
+    useAction,
+    // ── Cache Utilities ───────────────────────────────────────────────────
+    /** Manually invalidate cache */
+    useInvalidate,
+    /** Prefetch on hover/navigation */
+    usePrefetch,
+    /** Manually write data into cache (SSR/seed) */
+    useSetCache,
+    // ── Meta ──────────────────────────────────────────────────────────────
+    path,
+    name
+  };
+}
+function extractFilename(contentDisposition) {
+  if (!contentDisposition) return null;
+  const match = contentDisposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/);
+  return match ? match[1].replace(/['"]/g, "").trim() : null;
+}
+
+// src/createApiClient.ts
+function createApiClient(config) {
+  const {
+    baseURL,
+    getToken,
+    onTokenRefresh,
+    onAuthFailure,
+    onError,
+    headers = {},
+    timeout = 3e4,
+    retry = { count: 0, delay: 1e3, statusCodes: [429, 503] }
+  } = config;
+  const client = import_axios.default.create({
+    baseURL,
+    timeout,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    }
+  });
+  client.interceptors.request.use(async (req) => {
+    const token = await (getToken == null ? void 0 : getToken());
+    if (token) {
+      req.headers.Authorization = `Bearer ${token}`;
+    }
+    return req;
+  });
+  let isRefreshing = false;
+  let refreshQueue = [];
+  function processRefreshQueue(token, error = null) {
+    refreshQueue.forEach(({ resolve, reject }) => {
+      if (token) resolve(token);
+      else reject(error);
+    });
+    refreshQueue = [];
+  }
+  client.interceptors.response.use(
+    (res) => res,
+    async (error) => {
+      var _a, _b;
+      const originalRequest = error.config;
+      if (onError) onError(error);
+      if (((_a = error.response) == null ? void 0 : _a.status) === 401 && originalRequest && !originalRequest._retryCount) {
+        if (isRefreshing) {
+          return new Promise((resolve, reject) => {
+            refreshQueue.push({ resolve, reject });
+          }).then((token) => {
+            originalRequest.headers.Authorization = `Bearer ${token}`;
+            return client(originalRequest);
+          });
+        }
+        if (onTokenRefresh) {
+          isRefreshing = true;
+          try {
+            const newToken = await refreshTokenRequest(config);
+            onTokenRefresh(newToken);
+            processRefreshQueue(newToken);
+            isRefreshing = false;
+            originalRequest.headers.Authorization = `Bearer ${newToken}`;
+            return client(originalRequest);
+          } catch (refreshError) {
+            processRefreshQueue(null, refreshError);
+            isRefreshing = false;
+            onAuthFailure == null ? void 0 : onAuthFailure();
+            return Promise.reject(refreshError);
+          }
+        } else {
+          onAuthFailure == null ? void 0 : onAuthFailure();
+        }
+      }
+      if (originalRequest && shouldRetry(error, retry)) {
+        originalRequest._retryCount = ((_b = originalRequest._retryCount) != null ? _b : 0) + 1;
+        if (originalRequest._retryCount <= retry.count) {
+          const delay = retry.delay !== void 0 ? retry.delay * originalRequest._retryCount : 1e3;
+          await sleep(delay);
+          return client(originalRequest);
+        }
+      }
+      return Promise.reject(error);
+    }
+  );
+  return {
+    /** Access the raw axios instance for custom requests */
+    axiosInstance: client,
+    /** Create a resource with CRUD hooks */
+    resource: (name, options) => createResource(client, name, options),
+    /** Raw GET */
+    get: (url, axiosConfig) => client.get(url, axiosConfig).then((r) => r.data),
+    /** Raw POST */
+    post: (url, data, axiosConfig) => client.post(url, data, axiosConfig).then((r) => r.data),
+    /** Raw PUT */
+    put: (url, data, axiosConfig) => client.put(url, data, axiosConfig).then((r) => r.data),
+    /** Raw PATCH */
+    patch: (url, data, axiosConfig) => client.patch(url, data, axiosConfig).then((r) => r.data),
+    /** Raw DELETE */
+    delete: (url, axiosConfig) => client.delete(url, axiosConfig).then((r) => r.data)
+  };
+}
+async function refreshTokenRequest(config) {
+  var _a, _b, _c, _d;
+  const currentToken = await ((_a = config.getToken) == null ? void 0 : _a.call(config));
+  const res = await import_axios.default.post(
+    `${config.baseURL}/auth/refresh`,
+    {},
+    {
+      headers: currentToken ? { Authorization: `Bearer ${currentToken}` } : void 0
+    }
+  );
+  return (_d = (_b = res.data) == null ? void 0 : _b.token) != null ? _d : (_c = res.data) == null ? void 0 : _c.accessToken;
+}
+function shouldRetry(error, retry) {
+  if (!retry.count) return false;
+  if (!error.response) return true;
+  if (retry.statusCodes && retry.statusCodes.length > 0) {
+    return retry.statusCodes.includes(error.response.status);
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createApiClient,
+  createResource
+});