@openapi-qraft/react 1.10.1 → 1.11.0-beta.1

package/dist/cjs/index.cjs

@@ -0,0 +1,1267 @@
+"use client";
+"use strict";
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  QraftContext: () => QraftContext,
+  Unstable_QraftSecureRequestFn: () => QraftSecureRequestFn,
+  baseRequestFn: () => baseRequestFn,
+  bodySerializer: () => bodySerializer,
+  cancelQueries: () => cancelQueries,
+  createSecureRequestFn: () => createSecureRequestFn,
+  fetchInfiniteQuery: () => fetchInfiniteQuery,
+  fetchQuery: () => fetchQuery,
+  getInfiniteQueryData: () => getInfiniteQueryData,
+  getInfiniteQueryKey: () => getInfiniteQueryKey,
+  getInfiniteQueryState: () => getInfiniteQueryState,
+  getMutationKey: () => getMutationKey,
+  getQueriesData: () => getQueriesData,
+  getQueryData: () => getQueryData,
+  getQueryKey: () => getQueryKey,
+  getQueryState: () => getQueryState,
+  invalidateQueries: () => invalidateQueries,
+  isFetching: () => isFetching,
+  isMutating: () => isMutating,
+  mergeHeaders: () => mergeHeaders,
+  mutationFn: () => mutationFn,
+  operationInvokeFn: () => operationInvokeFn,
+  prefetchInfiniteQuery: () => prefetchInfiniteQuery,
+  prefetchQuery: () => prefetchQuery,
+  qraftAPIClient: () => qraftAPIClient,
+  queryFn: () => queryFn,
+  refetchQueries: () => refetchQueries,
+  removeQueries: () => removeQueries,
+  requestFn: () => requestFn,
+  resetQueries: () => resetQueries,
+  setInfiniteQueryData: () => setInfiniteQueryData,
+  setQueriesData: () => setQueriesData,
+  setQueryData: () => setQueryData,
+  urlSerializer: () => urlSerializer,
+  useInfiniteQuery: () => useInfiniteQuery,
+  useIsFetching: () => useIsFetching,
+  useIsMutating: () => useIsMutating,
+  useMutation: () => useMutation,
+  useMutationState: () => useMutationState,
+  useQueries: () => useQueries,
+  useQuery: () => useQuery,
+  useSecuritySchemeAuth: () => useSecuritySchemeAuth,
+  useSuspenseInfiniteQuery: () => useSuspenseInfiniteQuery,
+  useSuspenseQueries: () => useSuspenseQueries,
+  useSuspenseQuery: () => useSuspenseQuery
+});
+module.exports = __toCommonJS(src_exports);
+
+// 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
+var import_react = require("react");
+var QraftContext = (0, import_react.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
+var import_react_query2 = require("@tanstack/react-query");
+
+// src/lib/useComposeUseQueryOptions.ts
+var import_react3 = require("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
+var import_react2 = require("react");
+var import_react_query = require("@tanstack/react-query");
+function useQueryClient(qraftOptions, queryClient) {
+  const queryClientByContext = (0, import_react2.useContext)(
+    qraftOptions?.context ?? QraftContext
+  )?.queryClient;
+  return (0, import_react_query.useQueryClient)(queryClient ?? queryClientByContext);
+}
+
+// src/lib/useComposeUseQueryOptions.ts
+function useComposeUseQueryOptions(qraftOptions, schema, args, infinite) {
+  const [parameters, options, queryClient] = args;
+  const contextValue = (0, import_react3.useContext)(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 (0, import_react_query2.useInfiniteQuery)(
+    ...useComposeUseQueryOptions(qraftOptions, schema, args, true)
+  );
+};
+
+// src/callbacks/useMutation.ts
+var import_react4 = require("react");
+var import_react_query3 = require("@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 = (0, import_react4.useContext)(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 (0, import_react_query3.useMutation)(
+    {
+      ...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
+var import_react_query4 = require("@tanstack/react-query");
+var useQuery = (qraftOptions, schema, args) => {
+  return (0, import_react_query4.useQuery)(
+    ...useComposeUseQueryOptions(qraftOptions, schema, args, false)
+  );
+};
+
+// src/callbacks/useSuspenseQuery.ts
+var import_react_query5 = require("@tanstack/react-query");
+var useSuspenseQuery = (qraftOptions, schema, args) => {
+  return (0, import_react_query5.useSuspenseQuery)(
+    ...useComposeUseQueryOptions(qraftOptions, schema, args, false)
+  );
+};
+
+// src/callbacks/useSuspenseInfiniteQuery.ts
+var import_react_query6 = require("@tanstack/react-query");
+var useSuspenseInfiniteQuery = (qraftOptions, schema, args) => {
+  return (0, import_react_query6.useSuspenseInfiniteQuery)(
+    ...useComposeUseQueryOptions(qraftOptions, schema, args, true)
+  );
+};
+
+// src/callbacks/useMutationState.ts
+var import_react_query7 = require("@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 (0, import_react_query7.useMutationState)(
+    {
+      ...options,
+      filters: composeMutationFilters(schema, options?.filters)
+    },
+    useQueryClient(qraftOptions, queryClientByArg)
+  );
+};
+
+// src/callbacks/useIsMutating.ts
+var import_react_query8 = require("@tanstack/react-query");
+var useIsMutating = (qraftOptions, schema, args) => {
+  const [filters, queryClientByArg] = args;
+  return (0, import_react_query8.useIsMutating)(
+    composeMutationFilters(schema, filters),
+    useQueryClient(qraftOptions, queryClientByArg)
+  );
+};
+
+// src/callbacks/useQueries.ts
+var import_react5 = require("react");
+var import_react_query9 = require("@tanstack/react-query");
+var useQueries = (qraftOptions, schema, args) => {
+  const [options, queryClientByArg] = args;
+  const contextValue = (0, import_react5.useContext)(qraftOptions?.context ?? QraftContext);
+  if (!contextValue?.requestFn)
+    throw new Error(`QraftContext.requestFn not found`);
+  return (0, import_react_query9.useQueries)(
+    {
+      ...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
+var import_react6 = require("react");
+var import_react_query10 = require("@tanstack/react-query");
+var useSuspenseQueries = (qraftOptions, schema, args) => {
+  const [options, queryClientByArg] = args;
+  const contextValue = (0, import_react6.useContext)(qraftOptions?.context ?? QraftContext);
+  if (!contextValue?.requestFn)
+    throw new Error(`QraftContext.requestFn not found`);
+  return (0, import_react_query10.useSuspenseQueries)(
+    {
+      ...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
+var import_react_query11 = require("@tanstack/react-query");
+var useIsFetching = (qraftOptions, schema, args) => {
+  const [filters, queryClientByArg] = args;
+  return (0, import_react_query11.useIsFetching)(
+    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
+var import_react7 = require("react");
+var import_react_query12 = require("@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 = (0, import_react7.useMemo)(
+    () => inQueryClient ?? new import_react_query12.QueryClient({
+      defaultOptions: {
+        queries: {
+          staleTime: 3e5,
+          gcTime: 3e5,
+          refetchOnWindowFocus: false,
+          refetchOnMount: false,
+          refetchOnReconnect: false
+        }
+      }
+    }),
+    [inQueryClient]
+  );
+  (0, import_react7.useEffect)(() => {
+    queryClient.mount();
+    return () => {
+      return void queryClient.unmount();
+    };
+  }, [queryClient]);
+  const secureRequestFn = useSecuritySchemeAuth({
+    securitySchemes,
+    requestFn: requestFn2,
+    queryClient
+  });
+  return (0, import_react7.createElement)(import_react7.Fragment, {
+    children: children(secureRequestFn)
+  });
+}
+var useSecuritySchemeAuth = ({
+  securitySchemes,
+  requestFn: requestFn2,
+  queryClient
+}) => {
+  (0, import_react_query12.useQueries)(
+    {
+      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 (0, import_react7.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QraftContext,
+  Unstable_QraftSecureRequestFn,
+  baseRequestFn,
+  bodySerializer,
+  cancelQueries,
+  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
+});
+//# sourceMappingURL=index.cjs.map