@openapi-qraft/react 1.11.0-beta.2 → 1.11.0-beta.3

package/dist/esm/index.js

@@ -1,1220 +1,29 @@
-"use client";
-
-// src/lib/createRecursiveProxy.ts
-function createRecursiveProxy(getCallback, applyCallback, path) {
-  return new Proxy(noop, {
-    get(_obj, key) {
-      if (typeof key !== "string" || key === "then") {
-        return void 0;
-      }
-      return getCallback(path, key) ?? createRecursiveProxy(getCallback, applyCallback, [...path, key]);
-    },
-    apply(_1, _2, args) {
-      const functionName = path[path.length - 1];
-      const isCall = functionName === "call";
-      const isApply = isCall ? false : functionName === "apply";
-      return applyCallback(
-        isApply || isCall ? path.slice(0, -1) : path,
-        isApply ? args.length >= 2 ? args[1] : [] : isCall ? args.slice(1) : args
-      );
-    }
-  });
-}
-function noop() {
-}
-
-// src/qraftAPIClient.ts
-var qraftAPIClient = (services, callbacks, options) => {
-  return createRecursiveProxy(
-    function getCallback(getPath, key) {
-      if (getPath.length !== 2 || key !== "schema") return;
-      const serviceOperation = getByPath(services, getPath);
-      if (!isServiceOperation(serviceOperation))
-        throw new Error(`Service operation not found: ${getPath.join(".")}`);
-      return serviceOperation.schema;
-    },
-    function applyCallback(applyPath, args) {
-      const { path, callbackName } = extractCallbackDetails(applyPath);
-      if (!(callbackName in callbacks))
-        throw new Error(`Function ${callbackName} is not supported`);
-      const serviceOperation = getByPath(services, path);
-      if (!isServiceOperation(serviceOperation))
-        throw new Error(`Service operation not found: ${path.join(".")}`);
-      return callbacks[callbackName](
-        options,
-        serviceOperation.schema,
-        args
-      );
-    },
-    []
-  );
-};
-function extractCallbackDetails(applyPath) {
-  if (applyPath.length === 2) {
-    return {
-      path: applyPath,
-      callbackName: "operationInvokeFn"
-    };
-  } else {
-    return {
-      path: applyPath.slice(0, -1),
-      // The last arg is for instance `.useMutation` or `.useQuery()`
-      callbackName: applyPath[applyPath.length - 1]
-    };
-  }
-}
-function isServiceOperation(input) {
-  return input !== null && typeof input === "object" && "schema" in input;
-}
-function getByPath(obj, path) {
-  return path.reduce((acc, key) => {
-    if (acc && typeof acc === "object" && key in acc)
-      return acc[key];
-  }, obj);
-}
-
-// src/QraftContext.ts
-import { createContext } from "react";
-var QraftContext = createContext(void 0);
-
-// src/lib/requestFn.ts
-async function requestFn(schema, requestInfo, options) {
-  return baseRequestFn(schema, requestInfo, {
-    urlSerializer,
-    bodySerializer,
-    ...options
-  });
-}
-async function baseRequestFn(requestSchema, requestInfo, options) {
-  const { parameters, headers, body, ...requestInfoRest } = requestInfo;
-  const requestBody = options.bodySerializer(requestSchema, requestInfo);
-  const baseFetch = options.fetch ?? fetch;
-  const response = await baseFetch(
-    options.urlSerializer(requestSchema, requestInfo),
-    {
-      method: requestSchema.method.toUpperCase(),
-      body: requestBody,
-      headers: mergeHeaders(
-        {
-          Accept: "application/json",
-          "Content-Type": requestSchema.mediaType ?? getBodyContentType(body)
-        },
-        headers,
-        parameters?.header,
-        requestBody instanceof FormData ? (
-          // remove `Content-Type` if serialized body is FormData; browser will correctly set Content-Type & boundary expression
-          { "Content-Type": null }
-        ) : void 0
-      ),
-      ...requestInfoRest
-    }
-  );
-  const clonedResponse = response.clone();
-  if (!response.ok) {
-    throw await getResponseBody(clonedResponse);
-  }
-  return await getResponseBody(clonedResponse);
-}
-function urlSerializer(schema, info) {
-  const path = schema.url.replace(
-    /{(.*?)}/g,
-    (substring, group) => {
-      if (info.parameters?.path && Object.prototype.hasOwnProperty.call(info.parameters.path, group)) {
-        return encodeURI(String(info.parameters?.path[group]));
-      }
-      return substring;
-    }
-  );
-  const baseUrl = info.baseUrl ?? "";
-  if (info.parameters?.query) {
-    return `${baseUrl}${path}${getQueryString(info.parameters.query)}`;
-  }
-  return `${baseUrl}${path}`;
-}
-function getQueryString(params) {
-  const qs = [];
-  const append = (key, value) => {
-    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
-  };
-  const process2 = (key, value) => {
-    if (typeof value === "undefined" || value === null) return;
-    if (Array.isArray(value)) {
-      value.forEach((v) => {
-        process2(key, v);
-      });
-    } else if (typeof value === "object") {
-      Object.entries(value).forEach(([k, v]) => {
-        process2(`${key}[${k}]`, v);
-      });
-    } else {
-      append(key, value);
-    }
-  };
-  Object.entries(params).forEach(([key, value]) => {
-    process2(key, value);
-  });
-  if (qs.length > 0) {
-    return `?${qs.join("&")}`;
-  }
-  return "";
-}
-function mergeHeaders(...allHeaders) {
-  const headers = new Headers();
-  for (const headerSet of allHeaders) {
-    if (!headerSet || typeof headerSet !== "object") {
-      continue;
-    }
-    const headersIterator = headerSet instanceof Headers ? headerSet.entries() : Object.entries(headerSet);
-    for (const [headerKey, headerValue] of headersIterator) {
-      if (headerValue === null) {
-        headers.delete(headerKey);
-      } else if (headerValue !== void 0) {
-        headers.set(headerKey, headerValue);
-      }
-    }
-  }
-  return headers;
-}
-function bodySerializer(schema, info) {
-  if (info.body === void 0) return;
-  if (schema.method === "get" || schema.method === "head" || schema.method === "options")
-    return;
-  if (schema.mediaType?.includes("/form-data"))
-    return getRequestBodyFormData(info);
-  if (!schema.mediaType?.includes("/json") && (typeof info.body === "string" || info.body instanceof Blob || info.body instanceof FormData)) {
-    return info.body;
-  }
-  return JSON.stringify(info.body);
-}
-function getRequestBodyFormData({
-  body
-}) {
-  if (body instanceof FormData) return body;
-  if (body === null) return;
-  if (body instanceof Blob) throw new Error("Blob not supported in form-data");
-  if (body instanceof ArrayBuffer)
-    throw new Error("ArrayBuffer not supported in form-data");
-  if (body instanceof URLSearchParams)
-    throw new Error("URLSearchParams not supported in form-data");
-  if (body instanceof ReadableStream)
-    throw new Error("ReadableStream not supported in form-data");
-  if (typeof body === "string")
-    throw new Error("String not supported in form-data");
-  if (typeof body !== "object")
-    throw new Error(`Unsupported body type ${typeof body} in form-data.`);
-  const formData = new FormData();
-  const process2 = (key, value) => {
-    if (typeof value === "string" || value instanceof Blob) {
-      formData.append(key, value);
-    } else {
-      formData.append(key, JSON.stringify(value));
-    }
-  };
-  Object.entries(body).filter(([_, value]) => typeof value !== "undefined" && value !== null).forEach(([key, value]) => {
-    if (Array.isArray(value)) {
-      value.forEach((v) => process2(key, v));
-    } else {
-      process2(key, value);
-    }
-  });
-  return formData;
-}
-function getBodyContentType(body) {
-  if (!body) return;
-  if (body instanceof Blob) return body.type || "application/octet-stream";
-  if (typeof body === "string") return "text/plain";
-  if (!(body instanceof FormData)) return "application/json";
-}
-async function getResponseBody(response) {
-  if (response.status === 204 || response.headers.get("Content-Length") === "0")
-    return void 0;
-  const contentType = response.headers.get("Content-Type")?.toLowerCase();
-  const isJSON = contentType?.includes("/json") || contentType?.includes("+json");
-  if (isJSON) {
-    if (response.ok) return response.json();
-    const errorFallbackResponse = response.clone();
-    return response.json().catch(() => {
-      if (process.env.NODE_ENV === "development") {
-        console.warn(
-          "Failed to parse response body as JSON. Falling back to .text()"
-        );
-      }
-      return errorFallbackResponse.text();
-    });
-  }
-  return response.text();
-}
-
-// src/lib/composeBaseQueryKey.ts
-function composeBaseQueryKey(schema, parameters, infinite) {
-  return [
-    typeof infinite === "boolean" ? { ...schema, infinite } : schema,
-    parameters ?? {}
-  ];
-}
-
-// src/lib/composeInfiniteQueryKey.ts
-function composeInfiniteQueryKey(schema, parameters) {
-  return composeBaseQueryKey(schema, parameters, true);
-}
-
-// src/lib/composeQueryKey.ts
-function composeQueryKey(schema, parameters) {
-  return composeBaseQueryKey(schema, parameters, false);
-}
-
-// src/lib/callQueryClientMethodWithQueryKey.ts
-function callQueryClientMethodWithQueryKey(queryFilterMethod, schema, infinite, args) {
-  const parameters = args.length > 1 ? args[0] : void 0;
-  const queryClient = args[args.length - 1];
-  if (!queryClient) throw new Error("queryClient is required");
-  if (!queryClient[queryFilterMethod])
-    throw new Error(
-      `queryClient is invalid, ${queryFilterMethod} method does not exist`
-    );
-  const queryKey = Array.isArray(parameters) ? parameters : infinite ? composeInfiniteQueryKey(schema, parameters) : composeQueryKey(schema, parameters);
-  return queryClient[queryFilterMethod](queryKey, ...args.slice(1, -1));
-}
-
-// src/callbacks/getInfiniteQueryData.ts
-function getInfiniteQueryData(_, schema, args) {
-  return callQueryClientMethodWithQueryKey(
-    "getQueryData",
-    schema,
-    true,
-    args
-  );
-}
-
-// src/callbacks/getInfiniteQueryKey.ts
-var getInfiniteQueryKey = (qraftOptions, schema, args) => {
-  return composeInfiniteQueryKey(schema, args[0]);
-};
-
-// src/lib/composeMutationKey.ts
-function composeMutationKey(schema, parameters) {
-  return parameters === void 0 ? [{ url: schema.url, method: schema.method }, {}] : [
-    {
-      url: schema.url,
-      method: schema.method
-    },
-    omitMutationPayload(parameters)
-  ];
-}
-function omitMutationPayload(params) {
-  if (!params || typeof params !== "object")
-    throw new Error("`params` must be object");
-  if ("body" in params || "requestBody" in params) {
-    const {
-      body: _,
-      requestBody: __,
-      ...paramsRest
-    } = params;
-    return paramsRest;
-  }
-  return params;
-}
-
-// src/callbacks/getMutationKey.ts
-var getMutationKey = (qraftOptions, schema, args) => {
-  return composeMutationKey(schema, args[0]);
-};
-
-// src/callbacks/getQueryData.ts
-function getQueryData(_, schema, args) {
-  return callQueryClientMethodWithQueryKey(
-    "getQueryData",
-    schema,
-    false,
-    args
-  );
-}
-
-// src/lib/composeQueryFilters.ts
-function composeQueryFilters(schema, filters) {
-  if (!filters) {
-    return {
-      queryKey: composeBaseQueryKey(schema, void 0, void 0)
-    };
-  }
-  if ("queryKey" in filters && "parameters" in filters) {
-    throw new Error(
-      `'composeQueryFilters': 'queryKey' and 'parameters' cannot be used together`
-    );
-  }
-  const { infinite, parameters, ...filtersRest } = filters;
-  if ("queryKey" in filtersRest) {
-    return filtersRest;
-  }
-  if (parameters) {
-    Object.assign(filtersRest, {
-      queryKey: infinite ? composeInfiniteQueryKey(schema, parameters) : composeQueryKey(schema, parameters)
-    });
-    return filtersRest;
-  }
-  return {
-    ...filtersRest,
-    queryKey: infinite ? composeInfiniteQueryKey(schema, void 0) : composeQueryKey(schema, void 0)
-  };
-}
-
-// src/lib/callQueryClientMethodWithQueryFilters.ts
-function callQueryClientMethodWithQueryFilters(queryFilterMethod, schema, args) {
-  const filters = args.length > 1 ? args[0] : void 0;
-  const queryClient = args[args.length - 1];
-  if (!queryClient) throw new Error("queryClient is required");
-  if (!queryClient[queryFilterMethod])
-    throw new Error(
-      `queryClient is invalid, ${queryFilterMethod} method does not exist`
-    );
-  return queryClient[queryFilterMethod](
-    composeQueryFilters(schema, filters),
-    ...args.slice(1, -1)
-  );
-}
-
-// src/callbacks/getQueriesData.ts
-function getQueriesData(_, schema, args) {
-  return callQueryClientMethodWithQueryFilters(
-    "getQueriesData",
-    schema,
-    args
-  );
-}
-
-// src/callbacks/getQueryKey.ts
-var getQueryKey = (qraftOptions, schema, args) => {
-  return composeQueryKey(schema, args[0]);
-};
-
-// src/callbacks/mutationFn.ts
-var mutationFn = (qraftOptions, schema, args) => {
-  const [client, options] = args;
-  return client(schema, {
-    parameters: options?.parameters,
-    body: options?.body
-  });
-};
-
-// src/callbacks/queryFn.ts
-var queryFn = (_, schema, args) => {
-  const [options, client] = args;
-  return client(
-    options && "queryKey" in options ? options.queryKey[0] : schema,
-    {
-      parameters: options && "queryKey" in options ? options.queryKey[1] : options.parameters,
-      meta: options.meta,
-      signal: options.signal
-    }
-  );
-};
-
-// src/callbacks/setInfiniteQueryData.ts
-function setInfiniteQueryData(qraftOptions, schema, args) {
-  return callQueryClientMethodWithQueryKey(
-    "setQueryData",
-    schema,
-    true,
-    args
-  );
-}
-
-// src/callbacks/setQueryData.ts
-function setQueryData(_, schema, args) {
-  return callQueryClientMethodWithQueryKey(
-    "setQueryData",
-    schema,
-    false,
-    args
-  );
-}
-
-// src/callbacks/setQueriesData.ts
-function setQueriesData(_, schema, args) {
-  return callQueryClientMethodWithQueryFilters(
-    "setQueriesData",
-    schema,
-    args
-  );
-}
-
-// src/callbacks/useInfiniteQuery.ts
-import {
-  useInfiniteQuery as useInfiniteQueryBase
-} from "@tanstack/react-query";
-
-// src/lib/useComposeUseQueryOptions.ts
-import { useContext as useContext2 } from "react";
-
-// src/lib/shelfMerge.ts
-function shelfMerge(depth = 2, ...args) {
-  return args.reduce((acc, arg) => {
-    if (!arg || typeof arg !== "object") return acc;
-    Object.entries(arg).forEach(([key, value]) => {
-      if (typeof value !== "object") {
-        acc[key] = value;
-        return;
-      }
-      if (Array.isArray(value)) {
-        acc[key] = value;
-        return;
-      }
-      if (depth > 1) {
-        acc[key] = shelfMerge(
-          depth - 1,
-          acc[key],
-          value
-        );
-        return;
-      }
-      acc[key] = value;
-    });
-    return acc;
-  }, {});
-}
-
-// src/lib/useQueryClient.ts
-import { useContext } from "react";
-import {
-  useQueryClient as useQueryClientTanstack
-} from "@tanstack/react-query";
-function useQueryClient(qraftOptions, queryClient) {
-  const queryClientByContext = useContext(
-    qraftOptions?.context ?? QraftContext
-  )?.queryClient;
-  return useQueryClientTanstack(queryClient ?? queryClientByContext);
-}
-
-// src/lib/useComposeUseQueryOptions.ts
-function useComposeUseQueryOptions(qraftOptions, schema, args, infinite) {
-  const [parameters, options, queryClient] = args;
-  const contextValue = useContext2(qraftOptions?.context ?? QraftContext);
-  if (!contextValue?.requestFn)
-    throw new Error(`QraftContext.requestFn not found`);
-  const queryFn2 = options?.queryFn ?? // @ts-expect-error - Too complex to type
-  function({ queryKey: [, queryParams], signal, meta, pageParam }) {
-    return contextValue.requestFn(schema, {
-      // @ts-expect-error - Too complex to type
-      parameters: infinite ? shelfMerge(2, queryParams, pageParam) : queryParams,
-      baseUrl: contextValue.baseUrl,
-      signal,
-      meta
-    });
-  };
-  const queryKey = Array.isArray(parameters) ? parameters : infinite ? composeInfiniteQueryKey(schema, parameters) : composeQueryKey(schema, parameters);
-  return [
-    { ...options, queryFn: queryFn2, queryKey },
-    useQueryClient(qraftOptions, queryClient)
-  ];
-}
-
-// src/callbacks/useInfiniteQuery.ts
-var useInfiniteQuery = (qraftOptions, schema, args) => {
-  return useInfiniteQueryBase(
-    ...useComposeUseQueryOptions(qraftOptions, schema, args, true)
-  );
-};
-
-// src/callbacks/useMutation.ts
-import { useContext as useContext3 } from "react";
-import {
-  useMutation as useMutationBase
-} from "@tanstack/react-query";
-var useMutation = (qraftOptions, schema, args) => {
-  const [parameters, options, queryClientByArg] = args;
-  if (parameters && typeof parameters === "object" && options && "mutationKey" in options)
-    throw new Error(
-      `'useMutation': parameters and 'options.mutationKey' cannot be used together`
-    );
-  const contextValue = useContext3(qraftOptions?.context ?? QraftContext);
-  if (!contextValue?.requestFn)
-    throw new Error(`QraftContext.request not found`);
-  const mutationKey = options && "mutationKey" in options ? options.mutationKey : composeMutationKey(schema, parameters);
-  return useMutationBase(
-    {
-      ...options,
-      mutationKey,
-      mutationFn: options?.mutationFn ?? (parameters ? function(bodyPayload) {
-        return contextValue.requestFn(schema, {
-          parameters,
-          baseUrl: contextValue.baseUrl,
-          body: bodyPayload
-        });
-      } : function(parametersAndBodyPayload) {
-        const { body, ...parameters2 } = parametersAndBodyPayload;
-        return contextValue.requestFn(schema, {
-          parameters: parameters2,
-          baseUrl: contextValue.baseUrl,
-          body
-        });
-      })
-    },
-    useQueryClient(qraftOptions, queryClientByArg)
-  );
-};
-
-// src/callbacks/useQuery.ts
-import {
-  useQuery as useQueryTanstack
-} from "@tanstack/react-query";
-var useQuery = (qraftOptions, schema, args) => {
-  return useQueryTanstack(
-    ...useComposeUseQueryOptions(qraftOptions, schema, args, false)
-  );
-};
-
-// src/callbacks/useSuspenseQuery.ts
-import {
-  useSuspenseQuery as useSuspenseQueryTanstack
-} from "@tanstack/react-query";
-var useSuspenseQuery = (qraftOptions, schema, args) => {
-  return useSuspenseQueryTanstack(
-    ...useComposeUseQueryOptions(qraftOptions, schema, args, false)
-  );
-};
-
-// src/callbacks/useSuspenseInfiniteQuery.ts
-import {
-  useSuspenseInfiniteQuery as useSuspenseInfiniteQueryTanstack
-} from "@tanstack/react-query";
-var useSuspenseInfiniteQuery = (qraftOptions, schema, args) => {
-  return useSuspenseInfiniteQueryTanstack(
-    ...useComposeUseQueryOptions(qraftOptions, schema, args, true)
-  );
-};
-
-// src/callbacks/useMutationState.ts
-import {
-  useMutationState as useMutationStateTanstack
-} from "@tanstack/react-query";
-
-// src/lib/composeMutationFilters.ts
-function composeMutationFilters(schema, filters) {
-  if (!filters) {
-    return {
-      mutationKey: composeMutationKey(schema, void 0)
-    };
-  }
-  if (filters && "mutationKey" in filters && "parameters" in filters) {
-    throw new Error(
-      `'composeMutationFilters': 'mutationKey' and 'parameters' cannot be used together`
-    );
-  }
-  if ("mutationKey" in filters) {
-    return filters;
-  }
-  if ("parameters" in filters) {
-    const { parameters, ...filtersWithoutParameters } = filters;
-    Object.assign(filtersWithoutParameters, {
-      mutationKey: composeMutationKey(schema, parameters)
-    });
-    return filtersWithoutParameters;
-  }
-  return {
-    ...filters,
-    mutationKey: composeMutationKey(schema, void 0)
-  };
-}
-
-// src/callbacks/useMutationState.ts
-var useMutationState = (qraftOptions, schema, args) => {
-  const [options, queryClientByArg] = args;
-  return useMutationStateTanstack(
-    {
-      ...options,
-      filters: composeMutationFilters(schema, options?.filters)
-    },
-    useQueryClient(qraftOptions, queryClientByArg)
-  );
-};
-
-// src/callbacks/useIsMutating.ts
+import { qraftAPIClient } from "./qraftAPIClient.js";
+import { QraftContext } from "./QraftContext.js";
 import {
-  useIsMutating as useIsMutatingStateTanstack
-} from "@tanstack/react-query";
-var useIsMutating = (qraftOptions, schema, args) => {
-  const [filters, queryClientByArg] = args;
-  return useIsMutatingStateTanstack(
-    composeMutationFilters(schema, filters),
-    useQueryClient(qraftOptions, queryClientByArg)
-  );
-};
-
-// src/callbacks/useQueries.ts
-import { useContext as useContext4 } from "react";
-import {
-  useQueries as useQueriesTanstack
-} from "@tanstack/react-query";
-var useQueries = (qraftOptions, schema, args) => {
-  const [options, queryClientByArg] = args;
-  const contextValue = useContext4(qraftOptions?.context ?? QraftContext);
-  if (!contextValue?.requestFn)
-    throw new Error(`QraftContext.requestFn not found`);
-  return useQueriesTanstack(
-    {
-      ...options,
-      queries: options.queries.map((queryOptions) => {
-        const optionsWithQueryKey = "parameters" in queryOptions ? (() => {
-          const queryOptionsCopy = Object.assign(
-            {
-              queryKey: composeQueryKey(schema, queryOptions.parameters)
-            },
-            queryOptions
-          );
-          delete queryOptionsCopy.parameters;
-          return queryOptionsCopy;
-        })() : queryOptions;
-        return {
-          ...optionsWithQueryKey,
-          queryFn: optionsWithQueryKey.queryFn ?? function({ queryKey: [, queryParams], signal, meta }) {
-            return contextValue.requestFn(schema, {
-              parameters: queryParams,
-              baseUrl: contextValue.baseUrl,
-              signal,
-              meta
-            });
-          }
-        };
-      })
-    },
-    useQueryClient(qraftOptions, queryClientByArg)
-  );
-};
-
-// src/callbacks/useSuspenseQueries.ts
-import { useContext as useContext5 } from "react";
-import {
-  useSuspenseQueries as useSuspenseQueriesTanstack
-} from "@tanstack/react-query";
-var useSuspenseQueries = (qraftOptions, schema, args) => {
-  const [options, queryClientByArg] = args;
-  const contextValue = useContext5(qraftOptions?.context ?? QraftContext);
-  if (!contextValue?.requestFn)
-    throw new Error(`QraftContext.requestFn not found`);
-  return useSuspenseQueriesTanstack(
-    {
-      ...options,
-      queries: options.queries.map((queryOptions) => {
-        const optionsWithQueryKey = "parameters" in queryOptions ? (() => {
-          const queryOptionsCopy = Object.assign(
-            {
-              queryKey: composeQueryKey(schema, queryOptions.parameters)
-            },
-            queryOptions
-          );
-          delete queryOptionsCopy.parameters;
-          return queryOptionsCopy;
-        })() : queryOptions;
-        return {
-          ...optionsWithQueryKey,
-          queryFn: optionsWithQueryKey.queryFn ?? function({ queryKey: [, queryParams], signal, meta }) {
-            return contextValue.requestFn(schema, {
-              parameters: queryParams,
-              baseUrl: contextValue.baseUrl,
-              signal,
-              meta
-            });
-          }
-        };
-      })
-    },
-    useQueryClient(qraftOptions, queryClientByArg)
-  );
-};
-
-// src/callbacks/invalidateQueries.ts
-function invalidateQueries(qraftOptions, schema, args) {
-  return callQueryClientMethodWithQueryFilters(
-    "invalidateQueries",
-    schema,
-    args
-  );
-}
-
-// src/callbacks/cancelQueries.ts
-function cancelQueries(qraftOptions, schema, args) {
-  return callQueryClientMethodWithQueryFilters(
-    "cancelQueries",
-    schema,
-    args
-  );
-}
-
-// src/callbacks/resetQueries.ts
-function resetQueries(qraftOptions, schema, args) {
-  return callQueryClientMethodWithQueryFilters(
-    "resetQueries",
-    schema,
-    args
-  );
-}
-
-// src/callbacks/removeQueries.ts
-function removeQueries(_, schema, args) {
-  return callQueryClientMethodWithQueryFilters(
-    "removeQueries",
-    schema,
-    args
-  );
-}
-
-// src/callbacks/refetchQueries.ts
-function refetchQueries(qraftOptions, schema, args) {
-  return callQueryClientMethodWithQueryFilters(
-    "refetchQueries",
-    schema,
-    args
-  );
-}
-
-// src/callbacks/isFetching.ts
-function isFetching(qraftOptions, schema, args) {
-  return callQueryClientMethodWithQueryFilters(
-    "isFetching",
-    schema,
-    args
-  );
-}
-
-// src/lib/callQueryClientMethodWithMutationFilters.ts
-function callQueryClientMethodWithMutationFilters(queryFilterMethod, schema, args) {
-  const filters = args.length > 1 ? args[0] : void 0;
-  const queryClient = args[args.length - 1];
-  if (!queryClient) throw new Error("queryClient is required");
-  if (!queryClient[queryFilterMethod])
-    throw new Error(
-      `queryClient is invalid, ${queryFilterMethod} method does not exist`
-    );
-  return queryClient[queryFilterMethod](
-    composeMutationFilters(schema, filters),
-    ...args.slice(1, -1)
-  );
-}
-
-// src/callbacks/isMutating.ts
-function isMutating(_, schema, args) {
-  return callQueryClientMethodWithMutationFilters(
-    "isMutating",
-    schema,
-    args
-  );
-}
-
-// src/callbacks/useIsFetching.ts
-import { useIsFetching as useIsFetchingTanstack } from "@tanstack/react-query";
-var useIsFetching = (qraftOptions, schema, args) => {
-  const [filters, queryClientByArg] = args;
-  return useIsFetchingTanstack(
-    composeQueryFilters(schema, filters),
-    useQueryClient(qraftOptions, queryClientByArg)
-  );
-};
-
-// src/lib/callQueryClientFetchMethod.ts
-function callQueryClientMethodWithQueryKey2(queryFilterMethod, schema, infinite, args) {
-  const [{ requestFn: requestFn2, baseUrl, parameters, ...options }, queryClient] = args;
-  if (!queryClient) throw new Error("queryClient is required");
-  if (!queryClient[queryFilterMethod])
-    throw new Error(
-      `queryClient is invalid, ${queryFilterMethod} method does not exist`
-    );
-  if (options.queryKey && parameters) {
-    throw new Error(
-      "callQueryClientMethodWithQueryKey: options.queryKey and options.parameters are mutually exclusive"
-    );
-  }
-  if (options.queryFn && requestFn2) {
-    throw new Error(
-      "callQueryClientMethodWithQueryKey: options.queryFn and requestFn are mutually exclusive"
-    );
-  }
-  const queryFn2 = options.queryFn ?? (requestFn2 ? (
-    // @ts-expect-error - Not inferring the correct type for `queryFn`
-    function({ queryKey: [, queryParams], signal, meta, pageParam }) {
-      return requestFn2(schema, {
-        parameters: infinite ? shelfMerge(2, queryParams, pageParam) : queryParams,
-        baseUrl,
-        signal,
-        meta
-      });
-    }
-  ) : void 0);
-  if (parameters) {
-    return queryClient[queryFilterMethod]({
-      ...options,
-      // Event if queryFn is undefined, it will override the default queryFn from `setQueryDefaults(...)`
-      ...queryFn2 ? { queryFn: queryFn2 } : {},
-      queryKey: infinite ? composeInfiniteQueryKey(schema, parameters) : composeQueryKey(schema, parameters)
-    });
-  }
-  return queryClient[queryFilterMethod]({ ...options, queryFn: queryFn2 });
-}
-
-// src/callbacks/fetchQuery.ts
-var fetchQuery = (_, schema, args) => {
-  return callQueryClientMethodWithQueryKey2(
-    "fetchQuery",
-    schema,
-    false,
-    args
-  );
-};
-
-// src/callbacks/prefetchQuery.ts
-var prefetchQuery = (_, schema, args) => {
-  return callQueryClientMethodWithQueryKey2(
-    "prefetchQuery",
-    schema,
-    false,
-    args
-  );
-};
-
-// src/callbacks/fetchInfiniteQuery.ts
-var fetchInfiniteQuery = (_, schema, args) => {
-  return callQueryClientMethodWithQueryKey2(
-    "fetchInfiniteQuery",
-    schema,
-    true,
-    args
-  );
-};
-
-// src/callbacks/prefetchInfiniteQuery.ts
-var prefetchInfiniteQuery = (_, schema, args) => {
-  return callQueryClientMethodWithQueryKey2(
-    "prefetchInfiniteQuery",
-    schema,
-    true,
-    args
-  );
-};
-
-// src/callbacks/getQueryState.ts
-function getQueryState(_, schema, args) {
-  return callQueryClientMethodWithQueryKey(
-    "getQueryState",
-    schema,
-    false,
-    args
-  );
-}
-
-// src/callbacks/getInfiniteQueryState.ts
-function getInfiniteQueryState(_, schema, args) {
-  return callQueryClientMethodWithQueryKey(
-    "getQueryState",
-    schema,
-    true,
-    args
-  );
-}
-
-// src/callbacks/operationInvokeFn.ts
-var operationInvokeFn = (_, schema, args) => {
-  const queryOperationMethods = ["get", "head", "options"];
-  const isQueryOperationType = queryOperationMethods.includes(
-    schema.method
-  );
-  const [options, client] = args;
-  const invokeSchema = isQueryOperationType && "queryKey" in options ? options.queryKey[0] : schema;
-  const invokeParameters = isQueryOperationType && "queryKey" in options ? options.queryKey[1] : "parameters" in options ? options.parameters : void 0;
-  return client(invokeSchema, {
-    ...options,
-    parameters: invokeParameters
-  });
-};
-
-// src/Unstable_QraftSecureRequestFn.ts
-import { createElement, Fragment, useEffect, useMemo } from "react";
+  requestFn,
+  baseRequestFn,
+  urlSerializer,
+  bodySerializer,
+  mergeHeaders
+} from "./lib/requestFn.js";
+import * as callbacks from "./callbacks/index.js";
 import {
-  QueryClient as QueryClient2,
-  useQueries as useQueries2
-} from "@tanstack/react-query";
-
-// src/lib/jwt-decode/index.ts
-var InvalidTokenError = class extends Error {
-};
-InvalidTokenError.prototype.name = "InvalidTokenError";
-function b64DecodeUnicode(data) {
-  if (typeof atob === "function")
-    return decodeURIComponent(Array.from(atob(data), byteToPercent).join(""));
-  return Buffer.from(data, "base64").toString("utf-8");
-}
-function base64UrlDecode(str) {
-  let output = str.replace(/-/g, "+").replace(/_/g, "/");
-  switch (output.length % 4) {
-    case 0:
-      break;
-    case 2:
-      output += "==";
-      break;
-    case 3:
-      output += "=";
-      break;
-    default:
-      throw new Error("base64 string is not of the correct length");
-  }
-  try {
-    return b64DecodeUnicode(output);
-  } catch (err) {
-    return atob(output);
-  }
-}
-function jwtDecode(token, options) {
-  if (typeof token !== "string") {
-    throw new InvalidTokenError("Invalid token specified: must be a string");
-  }
-  options ||= {};
-  const pos = options.header === true ? 0 : 1;
-  const part = token.split(".")[pos];
-  if (typeof part !== "string") {
-    throw new InvalidTokenError(
-      `Invalid token specified: missing part #${pos + 1}`
-    );
-  }
-  let decoded;
-  try {
-    decoded = base64UrlDecode(part);
-  } catch (e) {
-    throw new InvalidTokenError(
-      `Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`
-    );
-  }
-  try {
-    return JSON.parse(decoded);
-  } catch (e) {
-    throw new InvalidTokenError(
-      `Invalid token specified: invalid json for part #${pos + 1} (${e.message})`
-    );
-  }
-}
-function byteToPercent(b) {
-  return `%${`00${b.charCodeAt(0).toString(16)}`.slice(-2)}`;
-}
-
-// src/Unstable_QraftSecureRequestFn.ts
-function QraftSecureRequestFn({
-  children,
-  requestFn: requestFn2,
-  securitySchemes,
-  queryClient: inQueryClient
-}) {
-  const queryClient = useMemo(
-    () => inQueryClient ?? new QueryClient2({
-      defaultOptions: {
-        queries: {
-          staleTime: 3e5,
-          gcTime: 3e5,
-          refetchOnWindowFocus: false,
-          refetchOnMount: false,
-          refetchOnReconnect: false
-        }
-      }
-    }),
-    [inQueryClient]
-  );
-  useEffect(() => {
-    queryClient.mount();
-    return () => {
-      return void queryClient.unmount();
-    };
-  }, [queryClient]);
-  const secureRequestFn = useSecuritySchemeAuth({
-    securitySchemes,
-    requestFn: requestFn2,
-    queryClient
-  });
-  return createElement(Fragment, {
-    children: children(secureRequestFn)
-  });
-}
-var useSecuritySchemeAuth = ({
-  securitySchemes,
-  requestFn: requestFn2,
-  queryClient
-}) => {
-  useQueries2(
-    {
-      queries: Object.entries(securitySchemes).map(([securitySchemeName]) => {
-        const queryKey = [securitySchemeName];
-        return {
-          enabled: Boolean(queryClient.getQueryData(queryKey)),
-          queryKey,
-          queryFn: ({
-            signal
-          }) => {
-            const securitySchemeHandler = securitySchemes[securitySchemeName];
-            return securitySchemeHandler({ signal, isRefreshing: true });
-          }
-        };
-      })
-    },
-    queryClient
-  );
-  return useMemo(
-    () => createSecureRequestFn(securitySchemes, requestFn2, queryClient),
-    [securitySchemes, requestFn2, queryClient]
-  );
-};
-function createSecureRequestFn(securitySchemes, requestFn2, queryClient) {
-  return async function secureRequestFn(schema, requestInfo, options) {
-    const availableSecuritySchemes = Object.keys(securitySchemes);
-    const securitySchemeName = schema.security?.find(
-      (security) => availableSecuritySchemes.includes(security)
-    );
-    if (!securitySchemeName) {
-      return requestFn2(schema, requestInfo, options);
-    }
-    const securitySchemeHandler = securitySchemes[securitySchemeName];
-    return requestFn2(
-      schema,
-      await createSecureRequestInfo(
-        securitySchemeHandler,
-        [securitySchemeName],
-        requestInfo,
-        queryClient
-      ),
-      options
-    );
-  };
-}
-function getJwtTokenRefreshInterval(token) {
-  const parsedToken = jwtDecode(token);
-  if (!parsedToken.iat || !parsedToken.exp) {
-    throw new Error("JWT token must contain both 'iat' and 'exp' fields.");
-  }
-  return (parsedToken.exp - parsedToken.iat) * 1e3;
-}
-async function createSecureRequestInfo(handler, queryKey, requestInfo, queryClient) {
-  const prevSecurityResult = queryClient.getQueryData(queryKey);
-  const securityResult = await queryClient.fetchQuery({
-    queryKey,
-    queryFn: ({ signal }) => handler({
-      signal,
-      isRefreshing: Boolean(prevSecurityResult)
-    })
-  });
-  if (!shallowEqualObjects(securityResult, prevSecurityResult)) {
-    const securityRefreshInterval = getSecurityRefreshInterval(securityResult);
-    if (securityRefreshInterval !== void 0 && securityRefreshInterval > 0) {
-      queryClient.removeQueries({ queryKey, exact: true });
-      setSecurityQueryDefaults(queryClient, queryKey, securityRefreshInterval);
-      queryClient.setQueryData(queryKey, securityResult);
-    }
-  }
-  const securityParameters = createSecureRequestParameters(securityResult);
-  if (!securityParameters) return requestInfo;
-  return {
-    ...requestInfo,
-    parameters: {
-      ...requestInfo.parameters,
-      [securityParameters.in]: {
-        [securityParameters.name]: securityParameters.value,
-        ...requestInfo.parameters?.[securityParameters.in]
-      }
-    }
-  };
-}
-function setSecurityQueryDefaults(queryClient, queryKey, refreshInterval) {
-  queryClient.setQueryDefaults(queryKey, {
-    // stale the token 90% before it expires
-    staleTime: isFinite(refreshInterval) ? refreshInterval * 0.9 : refreshInterval,
-    // garbage collect the token after it expires
-    gcTime: isFinite(refreshInterval) ? refreshInterval : refreshInterval,
-    // refetch the token 80% before it expires
-    refetchInterval: isFinite(refreshInterval) ? refreshInterval * 0.8 : refreshInterval,
-    // always refetch the token, even in the background
-    refetchIntervalInBackground: true
-  });
-}
-function createSecureRequestParameters(securityResult) {
-  if (typeof securityResult === "string" || "token" in securityResult) {
-    return {
-      in: "header",
-      name: "Authorization",
-      value: `Bearer ${typeof securityResult === "string" ? securityResult : securityResult.token}`
-    };
-  }
-  if ("credentials" in securityResult) {
-    return {
-      in: "header",
-      name: "Authorization",
-      value: `Basic ${securityResult.credentials}`
-    };
-  }
-  if ("in" in securityResult && securityResult.in !== "cookie") {
-    return securityResult;
-  }
-  throw new Error(
-    'Security scheme must be a string, an object with a token property, an object with a credentials property, or an object with an in property that is not equal to "cookie".'
-  );
-}
-function getSecurityRefreshInterval(securityResult) {
-  if (typeof securityResult === "string") {
-    return getJwtTokenRefreshInterval(securityResult);
-  }
-  if ("refreshInterval" in securityResult) {
-    return securityResult.refreshInterval;
-  }
-}
-function shallowEqualObjects(newObj, prevObj) {
-  if (typeof newObj !== typeof prevObj) return false;
-  if (typeof newObj === "string") return newObj === prevObj;
-  if (typeof newObj !== "object" || newObj === null || typeof prevObj !== "object" || prevObj === null || prevObj === void 0)
-    return false;
-  if (Object.keys(newObj).length !== Object.keys(prevObj).length) return false;
-  for (const key in newObj) {
-    if (!Object.prototype.hasOwnProperty.call(newObj, key)) return false;
-    if (newObj[key] !== prevObj[key]) return false;
-  }
-  return true;
-}
+  QraftSecureRequestFn,
+  useSecuritySchemeAuth,
+  createSecureRequestFn
+} from "./Unstable_QraftSecureRequestFn.js";
 export {
   QraftContext,
   QraftSecureRequestFn as Unstable_QraftSecureRequestFn,
   baseRequestFn,
   bodySerializer,
-  cancelQueries,
+  callbacks,
   createSecureRequestFn,
-  fetchInfiniteQuery,
-  fetchQuery,
-  getInfiniteQueryData,
-  getInfiniteQueryKey,
-  getInfiniteQueryState,
-  getMutationKey,
-  getQueriesData,
-  getQueryData,
-  getQueryKey,
-  getQueryState,
-  invalidateQueries,
-  isFetching,
-  isMutating,
   mergeHeaders,
-  mutationFn,
-  operationInvokeFn,
-  prefetchInfiniteQuery,
-  prefetchQuery,
   qraftAPIClient,
-  queryFn,
-  refetchQueries,
-  removeQueries,
   requestFn,
-  resetQueries,
-  setInfiniteQueryData,
-  setQueriesData,
-  setQueryData,
   urlSerializer,
-  useInfiniteQuery,
-  useIsFetching,
-  useIsMutating,
-  useMutation,
-  useMutationState,
-  useQueries,
-  useQuery,
-  useSecuritySchemeAuth,
-  useSuspenseInfiniteQuery,
-  useSuspenseQueries,
-  useSuspenseQuery
+  useSecuritySchemeAuth
 };
 //# sourceMappingURL=index.js.map