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

package/dist/cjs/index.cjs

@@ -0,0 +1,92 @@
+'use strict';
+
+var qraftAPIClient = require('./qraftAPIClient.cjs');
+var QraftContext = require('./QraftContext.cjs');
+var requestFn = require('./lib/requestFn.cjs');
+var index = require('./callbacks/index.cjs');
+var Unstable_QraftSecureRequestFn = require('./Unstable_QraftSecureRequestFn.cjs');
+var getInfiniteQueryData = require('./callbacks/getInfiniteQueryData.cjs');
+var getInfiniteQueryKey = require('./callbacks/getInfiniteQueryKey.cjs');
+var getMutationKey = require('./callbacks/getMutationKey.cjs');
+var getQueryData = require('./callbacks/getQueryData.cjs');
+var getQueriesData = require('./callbacks/getQueriesData.cjs');
+var getQueryKey = require('./callbacks/getQueryKey.cjs');
+var mutationFn = require('./callbacks/mutationFn.cjs');
+var queryFn = require('./callbacks/queryFn.cjs');
+var setInfiniteQueryData = require('./callbacks/setInfiniteQueryData.cjs');
+var setQueryData = require('./callbacks/setQueryData.cjs');
+var setQueriesData = require('./callbacks/setQueriesData.cjs');
+var useInfiniteQuery = require('./callbacks/useInfiniteQuery.cjs');
+var useMutation = require('./callbacks/useMutation.cjs');
+var useQuery = require('./callbacks/useQuery.cjs');
+var useSuspenseQuery = require('./callbacks/useSuspenseQuery.cjs');
+var useSuspenseInfiniteQuery = require('./callbacks/useSuspenseInfiniteQuery.cjs');
+var useMutationState = require('./callbacks/useMutationState.cjs');
+var useIsMutating = require('./callbacks/useIsMutating.cjs');
+var useQueries = require('./callbacks/useQueries.cjs');
+var useSuspenseQueries = require('./callbacks/useSuspenseQueries.cjs');
+var invalidateQueries = require('./callbacks/invalidateQueries.cjs');
+var cancelQueries = require('./callbacks/cancelQueries.cjs');
+var resetQueries = require('./callbacks/resetQueries.cjs');
+var removeQueries = require('./callbacks/removeQueries.cjs');
+var refetchQueries = require('./callbacks/refetchQueries.cjs');
+var isFetching = require('./callbacks/isFetching.cjs');
+var isMutating = require('./callbacks/isMutating.cjs');
+var useIsFetching = require('./callbacks/useIsFetching.cjs');
+var fetchQuery = require('./callbacks/fetchQuery.cjs');
+var prefetchQuery = require('./callbacks/prefetchQuery.cjs');
+var fetchInfiniteQuery = require('./callbacks/fetchInfiniteQuery.cjs');
+var prefetchInfiniteQuery = require('./callbacks/prefetchInfiniteQuery.cjs');
+var getQueryState = require('./callbacks/getQueryState.cjs');
+var getInfiniteQueryState = require('./callbacks/getInfiniteQueryState.cjs');
+var operationInvokeFn = require('./callbacks/operationInvokeFn.cjs');
+
+
+
+exports.qraftAPIClient = qraftAPIClient.qraftAPIClient;
+exports.QraftContext = QraftContext.QraftContext;
+exports.baseRequestFn = requestFn.baseRequestFn;
+exports.bodySerializer = requestFn.bodySerializer;
+exports.mergeHeaders = requestFn.mergeHeaders;
+exports.requestFn = requestFn.requestFn;
+exports.urlSerializer = requestFn.urlSerializer;
+exports.callbacks = index;
+exports.Unstable_QraftSecureRequestFn = Unstable_QraftSecureRequestFn.QraftSecureRequestFn;
+exports.createSecureRequestFn = Unstable_QraftSecureRequestFn.createSecureRequestFn;
+exports.useSecuritySchemeAuth = Unstable_QraftSecureRequestFn.useSecuritySchemeAuth;
+exports.getInfiniteQueryData = getInfiniteQueryData.getInfiniteQueryData;
+exports.getInfiniteQueryKey = getInfiniteQueryKey.getInfiniteQueryKey;
+exports.getMutationKey = getMutationKey.getMutationKey;
+exports.getQueryData = getQueryData.getQueryData;
+exports.getQueriesData = getQueriesData.getQueriesData;
+exports.getQueryKey = getQueryKey.getQueryKey;
+exports.mutationFn = mutationFn.mutationFn;
+exports.queryFn = queryFn.queryFn;
+exports.setInfiniteQueryData = setInfiniteQueryData.setInfiniteQueryData;
+exports.setQueryData = setQueryData.setQueryData;
+exports.setQueriesData = setQueriesData.setQueriesData;
+exports.useInfiniteQuery = useInfiniteQuery.useInfiniteQuery;
+exports.useMutation = useMutation.useMutation;
+exports.useQuery = useQuery.useQuery;
+exports.useSuspenseQuery = useSuspenseQuery.useSuspenseQuery;
+exports.useSuspenseInfiniteQuery = useSuspenseInfiniteQuery.useSuspenseInfiniteQuery;
+exports.useMutationState = useMutationState.useMutationState;
+exports.useIsMutating = useIsMutating.useIsMutating;
+exports.useQueries = useQueries.useQueries;
+exports.useSuspenseQueries = useSuspenseQueries.useSuspenseQueries;
+exports.invalidateQueries = invalidateQueries.invalidateQueries;
+exports.cancelQueries = cancelQueries.cancelQueries;
+exports.resetQueries = resetQueries.resetQueries;
+exports.removeQueries = removeQueries.removeQueries;
+exports.refetchQueries = refetchQueries.refetchQueries;
+exports.isFetching = isFetching.isFetching;
+exports.isMutating = isMutating.isMutating;
+exports.useIsFetching = useIsFetching.useIsFetching;
+exports.fetchQuery = fetchQuery.fetchQuery;
+exports.prefetchQuery = prefetchQuery.prefetchQuery;
+exports.fetchInfiniteQuery = fetchInfiniteQuery.fetchInfiniteQuery;
+exports.prefetchInfiniteQuery = prefetchInfiniteQuery.prefetchInfiniteQuery;
+exports.getQueryState = getQueryState.getQueryState;
+exports.getInfiniteQueryState = getInfiniteQueryState.getInfiniteQueryState;
+exports.operationInvokeFn = operationInvokeFn.operationInvokeFn;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/lib/callQueryClientFetchMethod.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+var composeInfiniteQueryKey = require('./composeInfiniteQueryKey.cjs');
+var composeQueryKey = require('./composeQueryKey.cjs');
+var shelfMerge = require('./shelfMerge.cjs');
+
+/**
+ * Calls a query client fetch method with parameters and options,
+ * and automatically composes the `QueryKey` based on the schema and parameters.
+ */ function callQueryClientMethodWithQueryKey(queryFilterMethod, schema, infinite, args) {
+    const [{ requestFn, 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 && requestFn) {
+        throw new Error('callQueryClientMethodWithQueryKey: options.queryFn and requestFn are mutually exclusive');
+    }
+    const queryFn = options.queryFn ?? (requestFn ? function({ queryKey: [, queryParams], signal, meta, pageParam }) {
+        return requestFn(schema, {
+            parameters: infinite ? shelfMerge.shelfMerge(2, queryParams, pageParam) : queryParams,
+            baseUrl,
+            signal,
+            meta
+        });
+    } : undefined);
+    if (parameters) {
+        // @ts-expect-error - Too complex union to type
+        return queryClient[queryFilterMethod]({
+            ...options,
+            // Event if queryFn is undefined, it will override the default queryFn from `setQueryDefaults(...)`
+            ...queryFn ? {
+                queryFn
+            } : {},
+            queryKey: infinite ? composeInfiniteQueryKey.composeInfiniteQueryKey(schema, parameters) : composeQueryKey.composeQueryKey(schema, parameters)
+        });
+    }
+    // @ts-expect-error - Too complex union to type
+    return queryClient[queryFilterMethod]({
+        ...options,
+        queryFn
+    });
+}
+
+exports.callQueryClientMethodWithQueryKey = callQueryClientMethodWithQueryKey;
+//# sourceMappingURL=callQueryClientFetchMethod.cjs.map

package/dist/cjs/lib/callQueryClientFetchMethod.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"callQueryClientFetchMethod.cjs","sources":["../../../src/lib/callQueryClientFetchMethod.ts"],"sourcesContent":["import type { QueryClient } from '@tanstack/query-core';\n\nimport { composeInfiniteQueryKey } from './composeInfiniteQueryKey.js';\nimport { composeQueryKey } from './composeQueryKey.js';\nimport type { OperationSchema, RequestFn } from './requestFn.js';\nimport { shelfMerge } from './shelfMerge.js';\n\n/**\n * Calls a query client fetch method with parameters and options,\n * and automatically composes the `QueryKey` based on the schema and parameters.\n */\nexport function callQueryClientMethodWithQueryKey<\n  QFMethod extends QueryKeyMethods,\n>(\n  queryFilterMethod: QFMethod,\n  schema: OperationSchema,\n  infinite: boolean,\n  args: QueryClientMethodArgs<QFMethod>\n): ReturnType<(typeof QueryClient.prototype)[QFMethod]> {\n  const [{ requestFn, baseUrl, parameters, ...options }, queryClient] = args;\n\n  if (!queryClient) throw new Error('queryClient is required');\n  if (!queryClient[queryFilterMethod])\n    throw new Error(\n      `queryClient is invalid, ${queryFilterMethod} method does not exist`\n    );\n\n  if (options.queryKey && parameters) {\n    throw new Error(\n      'callQueryClientMethodWithQueryKey: options.queryKey and options.parameters are mutually exclusive'\n    );\n  }\n\n  if (options.queryFn && requestFn) {\n    throw new Error(\n      'callQueryClientMethodWithQueryKey: options.queryFn and requestFn are mutually exclusive'\n    );\n  }\n\n  const queryFn =\n    options.queryFn ??\n    (requestFn\n      ? // @ts-expect-error - Not inferring the correct type for `queryFn`\n        function ({ queryKey: [, queryParams], signal, meta, pageParam }) {\n          return requestFn(schema, {\n            parameters: infinite\n              ? (shelfMerge(2, queryParams, pageParam) as never)\n              : queryParams,\n            baseUrl,\n            signal,\n            meta,\n          });\n        }\n      : undefined);\n\n  if (parameters) {\n    // @ts-expect-error - Too complex union to type\n    return queryClient[queryFilterMethod]({\n      ...options,\n      // Event if queryFn is undefined, it will override the default queryFn from `setQueryDefaults(...)`\n      ...(queryFn ? { queryFn } : {}),\n      queryKey: infinite\n        ? composeInfiniteQueryKey(schema, parameters)\n        : composeQueryKey(schema, parameters),\n    });\n  }\n\n  // @ts-expect-error - Too complex union to type\n  return queryClient[queryFilterMethod]({ ...options, queryFn });\n}\n\ntype QueryClientMethodArgs<QMethod extends keyof QueryClientPrototype> = [\n  options: Parameters<QueryClientPrototype[QMethod]>[0] & {\n    parameters?: unknown;\n    baseUrl?: string;\n    requestFn?: RequestFn<unknown>;\n  },\n  queryClient: QueryClient,\n];\n\ntype QueryKeyMethods =\n  | QueryKeyMethod<'fetchQuery'>\n  | QueryKeyMethod<'prefetchQuery'>\n  | QueryKeyMethod<'fetchInfiniteQuery'>\n  | QueryKeyMethod<'prefetchInfiniteQuery'>;\n\ntype QueryClientPrototype = typeof QueryClient.prototype;\n\ntype QueryKeyMethod<QFMethod extends keyof typeof QueryClient.prototype> =\n  QFMethod;\n"],"names":["callQueryClientMethodWithQueryKey","queryFilterMethod","schema","infinite","args","requestFn","baseUrl","parameters","options","queryClient","Error","queryKey","queryFn","queryParams","signal","meta","pageParam","shelfMerge","undefined","composeInfiniteQueryKey","composeQueryKey"],"mappings":";;;;;;AAOA;;;IAIO,SAASA,iCAGdC,CAAAA,iBAA2B,EAC3BC,MAAuB,EACvBC,QAAiB,EACjBC,IAAqC,EAAA;AAErC,IAAA,MAAM,CAAC,EAAEC,SAAS,EAAEC,OAAO,EAAEC,UAAU,EAAE,GAAGC,OAAAA,EAAS,EAAEC,WAAAA,CAAY,GAAGL,IAAAA,CAAAA;AAEtE,IAAA,IAAI,CAACK,WAAAA,EAAa,MAAM,IAAIC,KAAM,CAAA,yBAAA,CAAA,CAAA;AAClC,IAAA,IAAI,CAACD,WAAW,CAACR,iBAAAA,CAAkB,EACjC,MAAM,IAAIS,KAAAA,CACR,CAAC,wBAAwB,EAAET,iBAAAA,CAAkB,sBAAsB,CAAC,CAAA,CAAA;IAGxE,IAAIO,OAAAA,CAAQG,QAAQ,IAAIJ,UAAY,EAAA;AAClC,QAAA,MAAM,IAAIG,KACR,CAAA,mGAAA,CAAA,CAAA;AAEJ,KAAA;IAEA,IAAIF,OAAAA,CAAQI,OAAO,IAAIP,SAAW,EAAA;AAChC,QAAA,MAAM,IAAIK,KACR,CAAA,yFAAA,CAAA,CAAA;AAEJ,KAAA;AAEA,IAAA,MAAME,UACJJ,OAAQI,CAAAA,OAAO,KACdP,YAEG,SAAU,EAAEM,QAAU,EAAA,GAAGE,YAAY,EAAEC,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAE,EAAA;AAC9D,QAAA,OAAOX,UAAUH,MAAQ,EAAA;AACvBK,YAAAA,UAAAA,EAAYJ,QACPc,GAAAA,qBAAAA,CAAW,CAAGJ,EAAAA,WAAAA,EAAaG,SAC5BH,CAAAA,GAAAA,WAAAA;AACJP,YAAAA,OAAAA;AACAQ,YAAAA,MAAAA;AACAC,YAAAA,IAAAA;AACF,SAAA,CAAA,CAAA;AACF,KAAA,GACAG,SAAQ,CAAA,CAAA;AAEd,IAAA,IAAIX,UAAY,EAAA;;QAEd,OAAOE,WAAW,CAACR,iBAAAA,CAAkB,CAAC;AACpC,YAAA,GAAGO,OAAO;;AAEV,YAAA,GAAII,OAAU,GAAA;AAAEA,gBAAAA,OAAAA;AAAQ,aAAA,GAAI,EAAE;AAC9BD,YAAAA,QAAAA,EAAUR,QACNgB,GAAAA,+CAAAA,CAAwBjB,MAAQK,EAAAA,UAAAA,CAAAA,GAChCa,gCAAgBlB,MAAQK,EAAAA,UAAAA,CAAAA;AAC9B,SAAA,CAAA,CAAA;AACF,KAAA;;IAGA,OAAOE,WAAW,CAACR,iBAAAA,CAAkB,CAAC;AAAE,QAAA,GAAGO,OAAO;AAAEI,QAAAA,OAAAA;AAAQ,KAAA,CAAA,CAAA;AAC9D;;;;"}

package/dist/cjs/lib/callQueryClientMethodWithMutationFilters.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var composeMutationFilters = require('./composeMutationFilters.cjs');
+
+/**
+ * Calls a query client method with mutation filters and options,
+ * and automatically composes the `MutationKey` based on the schema and parameters.
+ */ function callQueryClientMethodWithMutationFilters(queryFilterMethod, schema, args) {
+    const filters = args.length > 1 ? args[0] : undefined;
+    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`);
+    // @ts-expect-error - Too complex to type
+    return queryClient[queryFilterMethod](composeMutationFilters.composeMutationFilters(schema, filters), // @ts-expect-error - Argument types are too complex
+    ...args.slice(1, -1));
+}
+
+exports.callQueryClientMethodWithMutationFilters = callQueryClientMethodWithMutationFilters;
+//# sourceMappingURL=callQueryClientMethodWithMutationFilters.cjs.map

package/dist/cjs/lib/callQueryClientMethodWithMutationFilters.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"callQueryClientMethodWithMutationFilters.cjs","sources":["../../../src/lib/callQueryClientMethodWithMutationFilters.ts"],"sourcesContent":["import type { QueryClient } from '@tanstack/query-core';\n\nimport { composeMutationFilters } from './composeMutationFilters.js';\nimport type { OperationSchema } from './requestFn.js';\n\n/**\n * Calls a query client method with mutation filters and options,\n * and automatically composes the `MutationKey` based on the schema and parameters.\n */\nexport function callQueryClientMethodWithMutationFilters<\n  QFMethod extends QueryFilterMethods,\n>(\n  queryFilterMethod: QFMethod,\n  schema: OperationSchema,\n  args: [...Parameters<(typeof QueryClient.prototype)[QFMethod]>, QueryClient]\n): ReturnType<(typeof QueryClient.prototype)[QFMethod]> {\n  const filters = args.length > 1 ? args[0] : undefined;\n  const queryClient = args[args.length - 1] as QueryClient | undefined;\n\n  if (!queryClient) throw new Error('queryClient is required');\n  if (!queryClient[queryFilterMethod])\n    throw new Error(\n      `queryClient is invalid, ${queryFilterMethod} method does not exist`\n    );\n\n  // @ts-expect-error - Too complex to type\n  return queryClient[queryFilterMethod](\n    composeMutationFilters(schema, filters as never),\n    // @ts-expect-error - Argument types are too complex\n    ...args.slice(1, -1)\n  );\n}\n\ntype QueryFiltersMethod<QFMethod extends keyof typeof QueryClient.prototype> =\n  QFMethod;\n\ntype QueryFilterMethods = QueryFiltersMethod<'isMutating'>;\n"],"names":["callQueryClientMethodWithMutationFilters","queryFilterMethod","schema","args","filters","length","undefined","queryClient","Error","composeMutationFilters","slice"],"mappings":";;;;AAKA;;;AAGC,IACM,SAASA,wCAAAA,CAGdC,iBAA2B,EAC3BC,MAAuB,EACvBC,IAA4E,EAAA;IAE5E,MAAMC,OAAAA,GAAUD,KAAKE,MAAM,GAAG,IAAIF,IAAI,CAAC,EAAE,GAAGG,SAAAA,CAAAA;AAC5C,IAAA,MAAMC,cAAcJ,IAAI,CAACA,IAAKE,CAAAA,MAAM,GAAG,CAAE,CAAA,CAAA;AAEzC,IAAA,IAAI,CAACE,WAAAA,EAAa,MAAM,IAAIC,KAAM,CAAA,yBAAA,CAAA,CAAA;AAClC,IAAA,IAAI,CAACD,WAAW,CAACN,iBAAAA,CAAkB,EACjC,MAAM,IAAIO,KAAAA,CACR,CAAC,wBAAwB,EAAEP,iBAAAA,CAAkB,sBAAsB,CAAC,CAAA,CAAA;;AAIxE,IAAA,OAAOM,WAAW,CAACN,iBAAAA,CAAkB,CACnCQ,6CAAuBP,CAAAA,MAAAA,EAAQE;OAE5BD,IAAKO,CAAAA,KAAK,CAAC,CAAA,EAAG,CAAC,CAAA,CAAA,CAAA,CAAA;AAEtB;;;;"}

package/dist/cjs/lib/callQueryClientMethodWithQueryFilters.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var composeQueryFilters = require('./composeQueryFilters.cjs');
+
+/**
+ * Calls a query client method with query filters and options,
+ * and automatically composes the `QueryKey` based on the schema and parameters.
+ */ function callQueryClientMethodWithQueryFilters(queryFilterMethod, schema, args) {
+    const filters = args.length > 1 ? args[0] : undefined;
+    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`);
+    // @ts-expect-error - Too complex to type
+    return queryClient[queryFilterMethod](composeQueryFilters.composeQueryFilters(schema, filters), // @ts-expect-error - Argument types are too complex
+    ...args.slice(1, -1));
+}
+
+exports.callQueryClientMethodWithQueryFilters = callQueryClientMethodWithQueryFilters;
+//# sourceMappingURL=callQueryClientMethodWithQueryFilters.cjs.map

package/dist/cjs/lib/callQueryClientMethodWithQueryFilters.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"callQueryClientMethodWithQueryFilters.cjs","sources":["../../../src/lib/callQueryClientMethodWithQueryFilters.ts"],"sourcesContent":["import type { QueryClient } from '@tanstack/query-core';\n\nimport { composeQueryFilters } from './composeQueryFilters.js';\nimport type { OperationSchema } from './requestFn.js';\n\n/**\n * Calls a query client method with query filters and options,\n * and automatically composes the `QueryKey` based on the schema and parameters.\n */\nexport function callQueryClientMethodWithQueryFilters<\n  QFMethod extends QueryFilterMethods,\n>(\n  queryFilterMethod: QFMethod,\n  schema: OperationSchema,\n  args: [...Parameters<(typeof QueryClient.prototype)[QFMethod]>, QueryClient]\n): ReturnType<(typeof QueryClient.prototype)[QFMethod]> {\n  const filters = args.length > 1 ? args[0] : undefined;\n  const queryClient = args[args.length - 1] as QueryClient | undefined;\n\n  if (!queryClient) throw new Error('queryClient is required');\n  if (!queryClient[queryFilterMethod])\n    throw new Error(\n      `queryClient is invalid, ${queryFilterMethod} method does not exist`\n    );\n\n  // @ts-expect-error - Too complex to type\n  return queryClient[queryFilterMethod](\n    composeQueryFilters(schema, filters as never),\n    // @ts-expect-error - Argument types are too complex\n    ...args.slice(1, -1)\n  );\n}\n\ntype QueryFiltersMethod<QFMethod extends keyof typeof QueryClient.prototype> =\n  QFMethod;\n\ntype QueryFilterMethods =\n  | QueryFiltersMethod<'isFetching'>\n  | QueryFiltersMethod<'getQueriesData'>\n  | QueryFiltersMethod<'setQueriesData'>\n  | QueryFiltersMethod<'removeQueries'>\n  | QueryFiltersMethod<'resetQueries'>\n  | QueryFiltersMethod<'cancelQueries'>\n  | QueryFiltersMethod<'invalidateQueries'>\n  | QueryFiltersMethod<'refetchQueries'>;\n"],"names":["callQueryClientMethodWithQueryFilters","queryFilterMethod","schema","args","filters","length","undefined","queryClient","Error","composeQueryFilters","slice"],"mappings":";;;;AAKA;;;AAGC,IACM,SAASA,qCAAAA,CAGdC,iBAA2B,EAC3BC,MAAuB,EACvBC,IAA4E,EAAA;IAE5E,MAAMC,OAAAA,GAAUD,KAAKE,MAAM,GAAG,IAAIF,IAAI,CAAC,EAAE,GAAGG,SAAAA,CAAAA;AAC5C,IAAA,MAAMC,cAAcJ,IAAI,CAACA,IAAKE,CAAAA,MAAM,GAAG,CAAE,CAAA,CAAA;AAEzC,IAAA,IAAI,CAACE,WAAAA,EAAa,MAAM,IAAIC,KAAM,CAAA,yBAAA,CAAA,CAAA;AAClC,IAAA,IAAI,CAACD,WAAW,CAACN,iBAAAA,CAAkB,EACjC,MAAM,IAAIO,KAAAA,CACR,CAAC,wBAAwB,EAAEP,iBAAAA,CAAkB,sBAAsB,CAAC,CAAA,CAAA;;AAIxE,IAAA,OAAOM,WAAW,CAACN,iBAAAA,CAAkB,CACnCQ,uCAAoBP,CAAAA,MAAAA,EAAQE;OAEzBD,IAAKO,CAAAA,KAAK,CAAC,CAAA,EAAG,CAAC,CAAA,CAAA,CAAA,CAAA;AAEtB;;;;"}

package/dist/cjs/lib/callQueryClientMethodWithQueryKey.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var composeInfiniteQueryKey = require('./composeInfiniteQueryKey.cjs');
+var composeQueryKey = require('./composeQueryKey.cjs');
+
+/**
+ * Calls a query client method with parameters and options,
+ * and automatically composes the `QueryKey` based on the schema and parameters.
+ */ function callQueryClientMethodWithQueryKey(queryFilterMethod, schema, infinite, args) {
+    const parameters = args.length > 1 ? args[0] : undefined;
+    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.composeInfiniteQueryKey(schema, parameters) : composeQueryKey.composeQueryKey(schema, parameters);
+    // @ts-expect-error - Too complex to type
+    return queryClient[queryFilterMethod](queryKey, ...args.slice(1, -1));
+}
+
+exports.callQueryClientMethodWithQueryKey = callQueryClientMethodWithQueryKey;
+//# sourceMappingURL=callQueryClientMethodWithQueryKey.cjs.map

package/dist/cjs/lib/callQueryClientMethodWithQueryKey.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"callQueryClientMethodWithQueryKey.cjs","sources":["../../../src/lib/callQueryClientMethodWithQueryKey.ts"],"sourcesContent":["import type { QueryClient } from '@tanstack/query-core';\n\nimport { composeInfiniteQueryKey } from './composeInfiniteQueryKey.js';\nimport { composeQueryKey } from './composeQueryKey.js';\nimport type { OperationSchema } from './requestFn.js';\n\n/**\n * Calls a query client method with parameters and options,\n * and automatically composes the `QueryKey` based on the schema and parameters.\n */\nexport function callQueryClientMethodWithQueryKey<\n  QFMethod extends QueryKeyMethods,\n>(\n  queryFilterMethod: QFMethod,\n  schema: OperationSchema,\n  infinite: boolean,\n  args: [...Parameters<(typeof QueryClient.prototype)[QFMethod]>, QueryClient]\n): ReturnType<(typeof QueryClient.prototype)[QFMethod]> {\n  const parameters = args.length > 1 ? args[0] : undefined;\n  const queryClient = args[args.length - 1] as QueryClient | undefined;\n\n  if (!queryClient) throw new Error('queryClient is required');\n  if (!queryClient[queryFilterMethod])\n    throw new Error(\n      `queryClient is invalid, ${queryFilterMethod} method does not exist`\n    );\n\n  const queryKey = Array.isArray(parameters)\n    ? parameters\n    : infinite\n      ? composeInfiniteQueryKey(schema, parameters)\n      : composeQueryKey(schema, parameters);\n\n  // @ts-expect-error - Too complex to type\n  return queryClient[queryFilterMethod](queryKey, ...args.slice(1, -1));\n}\n\ntype QueryKeyMethod<QFMethod extends keyof typeof QueryClient.prototype> =\n  QFMethod;\n\ntype QueryKeyMethods =\n  | QueryKeyMethod<'setQueryData'>\n  | QueryKeyMethod<'getQueryData'>\n  | QueryKeyMethod<'getQueryState'>\n  | QueryKeyMethod<'setQueryDefaults'>\n  | QueryKeyMethod<'getQueryDefaults'>;\n"],"names":["callQueryClientMethodWithQueryKey","queryFilterMethod","schema","infinite","args","parameters","length","undefined","queryClient","Error","queryKey","Array","isArray","composeInfiniteQueryKey","composeQueryKey","slice"],"mappings":";;;;;AAMA;;;IAIO,SAASA,iCAGdC,CAAAA,iBAA2B,EAC3BC,MAAuB,EACvBC,QAAiB,EACjBC,IAA4E,EAAA;IAE5E,MAAMC,UAAAA,GAAaD,KAAKE,MAAM,GAAG,IAAIF,IAAI,CAAC,EAAE,GAAGG,SAAAA,CAAAA;AAC/C,IAAA,MAAMC,cAAcJ,IAAI,CAACA,IAAKE,CAAAA,MAAM,GAAG,CAAE,CAAA,CAAA;AAEzC,IAAA,IAAI,CAACE,WAAAA,EAAa,MAAM,IAAIC,KAAM,CAAA,yBAAA,CAAA,CAAA;AAClC,IAAA,IAAI,CAACD,WAAW,CAACP,iBAAAA,CAAkB,EACjC,MAAM,IAAIQ,KAAAA,CACR,CAAC,wBAAwB,EAAER,iBAAAA,CAAkB,sBAAsB,CAAC,CAAA,CAAA;IAGxE,MAAMS,QAAAA,GAAWC,KAAMC,CAAAA,OAAO,CAACP,UAAAA,CAAAA,GAC3BA,UACAF,GAAAA,QAAAA,GACEU,+CAAwBX,CAAAA,MAAAA,EAAQG,UAChCS,CAAAA,GAAAA,+BAAAA,CAAgBZ,MAAQG,EAAAA,UAAAA,CAAAA,CAAAA;;IAG9B,OAAOG,WAAW,CAACP,iBAAkB,CAAA,CAACS,aAAaN,IAAKW,CAAAA,KAAK,CAAC,CAAA,EAAG,CAAC,CAAA,CAAA,CAAA,CAAA;AACpE;;;;"}

package/dist/cjs/lib/composeBaseQueryKey.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+function composeBaseQueryKey(schema, parameters, infinite) {
+    return [
+        typeof infinite === 'boolean' ? {
+            ...schema,
+            infinite
+        } : schema,
+        parameters ?? {}
+    ];
+}
+
+exports.composeBaseQueryKey = composeBaseQueryKey;
+//# sourceMappingURL=composeBaseQueryKey.cjs.map

package/dist/cjs/lib/composeBaseQueryKey.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"composeBaseQueryKey.cjs","sources":["../../../src/lib/composeBaseQueryKey.ts"],"sourcesContent":["import type {\n  ServiceOperationInfiniteQueryKey,\n  ServiceOperationQueryKey,\n} from '../service-operation/ServiceOperationKey.js';\nimport type { OperationSchema } from './requestFn.js';\n\nexport function composeBaseQueryKey<TSchema extends OperationSchema, TParams>(\n  schema: TSchema,\n  parameters: TParams | undefined,\n  infinite: undefined\n): [TSchema, TParams];\nexport function composeBaseQueryKey<TSchema extends OperationSchema, TParams>(\n  schema: TSchema,\n  parameters: TParams | undefined,\n  infinite: true\n): ServiceOperationInfiniteQueryKey<TSchema, TParams>;\nexport function composeBaseQueryKey<TSchema extends OperationSchema, TParams>(\n  schema: TSchema,\n  parameters: TParams | undefined,\n  infinite: false\n): ServiceOperationQueryKey<TSchema, TParams>;\nexport function composeBaseQueryKey<TSchema extends OperationSchema, TParams>(\n  schema: TSchema,\n  parameters: TParams | undefined,\n  infinite: boolean | undefined\n):\n  | ServiceOperationQueryKey<TSchema, TParams>\n  | ServiceOperationInfiniteQueryKey<TSchema, TParams>\n  | [TSchema, TParams] {\n  return [\n    typeof infinite === 'boolean' ? { ...schema, infinite } : schema,\n    parameters ?? ({} as TParams),\n  ];\n}\n"],"names":["composeBaseQueryKey","schema","parameters","infinite"],"mappings":";;AAqBO,SAASA,mBACdC,CAAAA,MAAe,EACfC,UAA+B,EAC/BC,QAA6B,EAAA;IAK7B,OAAO;AACL,QAAA,OAAOA,aAAa,SAAY,GAAA;AAAE,YAAA,GAAGF,MAAM;AAAEE,YAAAA,QAAAA;SAAaF,GAAAA,MAAAA;AAC1DC,QAAAA,UAAAA,IAAe,EAAC;AACjB,KAAA,CAAA;AACH;;;;"}

package/dist/cjs/lib/composeInfiniteQueryKey.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var composeBaseQueryKey = require('./composeBaseQueryKey.cjs');
+
+function composeInfiniteQueryKey(schema, parameters) {
+    return composeBaseQueryKey.composeBaseQueryKey(schema, parameters, true);
+}
+
+exports.composeInfiniteQueryKey = composeInfiniteQueryKey;
+//# sourceMappingURL=composeInfiniteQueryKey.cjs.map

package/dist/cjs/lib/composeInfiniteQueryKey.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"composeInfiniteQueryKey.cjs","sources":["../../../src/lib/composeInfiniteQueryKey.ts"],"sourcesContent":["import type { ServiceOperationInfiniteQueryKey } from '../service-operation/ServiceOperationKey.js';\nimport { composeBaseQueryKey } from './composeBaseQueryKey.js';\nimport type { OperationSchema } from './requestFn.js';\n\nexport function composeInfiniteQueryKey<\n  TSchema extends OperationSchema,\n  TParams,\n>(\n  schema: TSchema,\n  parameters: TParams | undefined\n): ServiceOperationInfiniteQueryKey<TSchema, TParams> {\n  return composeBaseQueryKey(schema, parameters, true);\n}\n"],"names":["composeInfiniteQueryKey","schema","parameters","composeBaseQueryKey"],"mappings":";;;;AAIO,SAASA,uBAAAA,CAIdC,MAAe,EACfC,UAA+B,EAAA;IAE/B,OAAOC,uCAAAA,CAAoBF,QAAQC,UAAY,EAAA,IAAA,CAAA,CAAA;AACjD;;;;"}

package/dist/cjs/lib/composeMutationFilters.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var composeMutationKey = require('./composeMutationKey.cjs');
+
+/**
+ * Replaces the `parameters` field in the filters with a `mutationKey` field based on the schema.
+ * If no filters are provided, a `mutationKey` will be composed schema's base query key.
+ * @param schema
+ * @param filters
+ */ function composeMutationFilters(schema, filters) {
+    if (!filters) {
+        return {
+            mutationKey: composeMutationKey.composeMutationKey(schema, undefined)
+        };
+    }
+    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.composeMutationKey(schema, parameters)
+        });
+        return filtersWithoutParameters;
+    }
+    return {
+        ...filters,
+        mutationKey: composeMutationKey.composeMutationKey(schema, undefined)
+    };
+}
+
+exports.composeMutationFilters = composeMutationFilters;
+//# sourceMappingURL=composeMutationFilters.cjs.map

package/dist/cjs/lib/composeMutationFilters.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"composeMutationFilters.cjs","sources":["../../../src/lib/composeMutationFilters.ts"],"sourcesContent":["import { composeMutationKey } from './composeMutationKey.js';\nimport type { OperationSchema } from './requestFn.js';\n\n/**\n * Replaces the `parameters` field in the filters with a `mutationKey` field based on the schema.\n * If no filters are provided, a `mutationKey` will be composed schema's base query key.\n * @param schema\n * @param filters\n */\nexport function composeMutationFilters<Filters extends object>(\n  schema: OperationSchema,\n  filters: Filters | undefined\n) {\n  if (!filters) {\n    return {\n      mutationKey: composeMutationKey(schema, undefined),\n    };\n  }\n\n  if (filters && 'mutationKey' in filters && 'parameters' in filters) {\n    throw new Error(\n      `'composeMutationFilters': 'mutationKey' and 'parameters' cannot be used together`\n    );\n  }\n\n  if ('mutationKey' in filters) {\n    return filters;\n  }\n\n  if ('parameters' in filters) {\n    const { parameters, ...filtersWithoutParameters } = filters;\n\n    Object.assign(filtersWithoutParameters, {\n      mutationKey: composeMutationKey(schema, parameters),\n    });\n\n    return filtersWithoutParameters;\n  }\n\n  return {\n    ...filters,\n    mutationKey: composeMutationKey(schema, undefined),\n  };\n}\n"],"names":["composeMutationFilters","schema","filters","mutationKey","composeMutationKey","undefined","Error","parameters","filtersWithoutParameters","Object","assign"],"mappings":";;;;AAGA;;;;;AAKC,IACM,SAASA,sBACdC,CAAAA,MAAuB,EACvBC,OAA4B,EAAA;AAE5B,IAAA,IAAI,CAACA,OAAS,EAAA;QACZ,OAAO;AACLC,YAAAA,WAAAA,EAAaC,sCAAmBH,MAAQI,EAAAA,SAAAA,CAAAA;AAC1C,SAAA,CAAA;AACF,KAAA;AAEA,IAAA,IAAIH,OAAW,IAAA,aAAA,IAAiBA,OAAW,IAAA,YAAA,IAAgBA,OAAS,EAAA;AAClE,QAAA,MAAM,IAAII,KAAAA,CACR,CAAC,gFAAgF,CAAC,CAAA,CAAA;AAEtF,KAAA;AAEA,IAAA,IAAI,iBAAiBJ,OAAS,EAAA;QAC5B,OAAOA,OAAAA,CAAAA;AACT,KAAA;AAEA,IAAA,IAAI,gBAAgBA,OAAS,EAAA;AAC3B,QAAA,MAAM,EAAEK,UAAU,EAAE,GAAGC,0BAA0B,GAAGN,OAAAA,CAAAA;QAEpDO,MAAOC,CAAAA,MAAM,CAACF,wBAA0B,EAAA;AACtCL,YAAAA,WAAAA,EAAaC,sCAAmBH,MAAQM,EAAAA,UAAAA,CAAAA;AAC1C,SAAA,CAAA,CAAA;QAEA,OAAOC,wBAAAA,CAAAA;AACT,KAAA;IAEA,OAAO;AACL,QAAA,GAAGN,OAAO;AACVC,QAAAA,WAAAA,EAAaC,sCAAmBH,MAAQI,EAAAA,SAAAA,CAAAA;AAC1C,KAAA,CAAA;AACF;;;;"}

package/dist/cjs/lib/composeMutationKey.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+function composeMutationKey(schema, parameters) {
+    return parameters === undefined ? [
+        {
+            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;
+}
+
+exports.composeMutationKey = composeMutationKey;
+exports.omitMutationPayload = omitMutationPayload;
+//# sourceMappingURL=composeMutationKey.cjs.map

package/dist/cjs/lib/composeMutationKey.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"composeMutationKey.cjs","sources":["../../../src/lib/composeMutationKey.ts"],"sourcesContent":["import type { ServiceOperationMutationKey } from '../service-operation/ServiceOperationKey.js';\nimport type { OperationSchema } from './requestFn.js';\n\n/**\n * Omit `body` or `requestBody` from mutation parameters if exists\n * and return the rest of the parameters\n */\nexport function composeMutationKey<TSchema extends OperationSchema>(\n  schema: TSchema,\n  parameters: undefined\n): ServiceOperationMutationKey<TSchema, undefined>;\nexport function composeMutationKey<TSchema extends OperationSchema, TParams>(\n  schema: TSchema,\n  parameters: TParams\n): ServiceOperationMutationKey<TSchema, TParams>;\nexport function composeMutationKey<\n  TSchema extends OperationSchema,\n  TParams = unknown,\n>(schema: TSchema, parameters: TParams | undefined) {\n  return parameters === undefined\n    ? [{ url: schema.url, method: schema.method }, {}]\n    : [\n        {\n          url: schema.url,\n          method: schema.method,\n        },\n        omitMutationPayload(parameters),\n      ];\n}\n\nexport function omitMutationPayload<T>(params: T) {\n  if (!params || typeof params !== 'object')\n    throw new Error('`params` must be object');\n\n  if ('body' in params || 'requestBody' in params) {\n    const {\n      body: _,\n      requestBody: __,\n      ...paramsRest\n    } = params as Record<'body' | 'requestBody', unknown>;\n    return paramsRest;\n  }\n\n  return params as Omit<T, 'body' | 'requestBody'>;\n}\n"],"names":["composeMutationKey","schema","parameters","undefined","url","method","omitMutationPayload","params","Error","body","_","requestBody","__","paramsRest"],"mappings":";;AAeO,SAASA,kBAAAA,CAGdC,MAAe,EAAEC,UAA+B,EAAA;AAChD,IAAA,OAAOA,eAAeC,SAClB,GAAA;AAAC,QAAA;AAAEC,YAAAA,GAAAA,EAAKH,OAAOG,GAAG;AAAEC,YAAAA,MAAAA,EAAQJ,OAAOI,MAAM;AAAC,SAAA;QAAG,EAAC;KAAE,GAChD;AACE,QAAA;AACED,YAAAA,GAAAA,EAAKH,OAAOG,GAAG;AACfC,YAAAA,MAAAA,EAAQJ,OAAOI,MAAM;AACvB,SAAA;QACAC,mBAAoBJ,CAAAA,UAAAA,CAAAA;AACrB,KAAA,CAAA;AACP,CAAA;AAEO,SAASI,oBAAuBC,MAAS,EAAA;AAC9C,IAAA,IAAI,CAACA,MAAU,IAAA,OAAOA,WAAW,QAC/B,EAAA,MAAM,IAAIC,KAAM,CAAA,yBAAA,CAAA,CAAA;IAElB,IAAI,MAAA,IAAUD,MAAU,IAAA,aAAA,IAAiBA,MAAQ,EAAA;QAC/C,MAAM,EACJE,MAAMC,CAAC,EACPC,aAAaC,EAAE,EACf,GAAGC,UAAAA,EACJ,GAAGN,MAAAA,CAAAA;QACJ,OAAOM,UAAAA,CAAAA;AACT,KAAA;IAEA,OAAON,MAAAA,CAAAA;AACT;;;;;"}

package/dist/cjs/lib/composeQueryFilters.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var composeBaseQueryKey = require('./composeBaseQueryKey.cjs');
+var composeInfiniteQueryKey = require('./composeInfiniteQueryKey.cjs');
+var composeQueryKey = require('./composeQueryKey.cjs');
+
+/**
+ * Replaces the `parameters` field in the filters with a `queryKey` field based on the schema.
+ * If no filters are provided, a `queryKey` will be composed schema's base query key.
+ * @param schema
+ * @param filters
+ */ function composeQueryFilters(schema, filters) {
+    if (!filters) {
+        return {
+            queryKey: composeBaseQueryKey.composeBaseQueryKey(schema, undefined, undefined)
+        };
+    }
+    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.composeInfiniteQueryKey(schema, parameters) : composeQueryKey.composeQueryKey(schema, parameters)
+        });
+        return filtersRest;
+    }
+    return {
+        ...filtersRest,
+        queryKey: infinite ? composeInfiniteQueryKey.composeInfiniteQueryKey(schema, undefined) : composeQueryKey.composeQueryKey(schema, undefined)
+    };
+}
+
+exports.composeQueryFilters = composeQueryFilters;
+//# sourceMappingURL=composeQueryFilters.cjs.map

package/dist/cjs/lib/composeQueryFilters.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"composeQueryFilters.cjs","sources":["../../../src/lib/composeQueryFilters.ts"],"sourcesContent":["import { composeBaseQueryKey } from './composeBaseQueryKey.js';\nimport { composeInfiniteQueryKey } from './composeInfiniteQueryKey.js';\nimport { composeQueryKey } from './composeQueryKey.js';\nimport type { OperationSchema } from './requestFn.js';\n\n/**\n * Replaces the `parameters` field in the filters with a `queryKey` field based on the schema.\n * If no filters are provided, a `queryKey` will be composed schema's base query key.\n * @param schema\n * @param filters\n */\nexport function composeQueryFilters<\n  Filters extends {\n    infinite: boolean;\n    parameters?: object;\n  } & Record<string, unknown>,\n>(schema: OperationSchema, filters: Filters | undefined) {\n  if (!filters) {\n    return {\n      queryKey: composeBaseQueryKey(schema, undefined, undefined),\n    };\n  }\n\n  if ('queryKey' in filters && 'parameters' in filters) {\n    throw new Error(\n      `'composeQueryFilters': 'queryKey' and 'parameters' cannot be used together`\n    );\n  }\n\n  const { infinite, parameters, ...filtersRest } = filters;\n\n  if ('queryKey' in filtersRest) {\n    return filtersRest;\n  }\n\n  if (parameters) {\n    Object.assign(filtersRest, {\n      queryKey: infinite\n        ? composeInfiniteQueryKey(schema, parameters)\n        : composeQueryKey(schema, parameters),\n    });\n\n    return filtersRest;\n  }\n\n  return {\n    ...filtersRest,\n    queryKey: infinite\n      ? composeInfiniteQueryKey(schema, undefined)\n      : composeQueryKey(schema, undefined),\n  };\n}\n"],"names":["composeQueryFilters","schema","filters","queryKey","composeBaseQueryKey","undefined","Error","infinite","parameters","filtersRest","Object","assign","composeInfiniteQueryKey","composeQueryKey"],"mappings":";;;;;;AAKA;;;;;AAKC,IACM,SAASA,mBAKdC,CAAAA,MAAuB,EAAEC,OAA4B,EAAA;AACrD,IAAA,IAAI,CAACA,OAAS,EAAA;QACZ,OAAO;YACLC,QAAUC,EAAAA,uCAAAA,CAAoBH,QAAQI,SAAWA,EAAAA,SAAAA,CAAAA;AACnD,SAAA,CAAA;AACF,KAAA;IAEA,IAAI,UAAA,IAAcH,OAAW,IAAA,YAAA,IAAgBA,OAAS,EAAA;AACpD,QAAA,MAAM,IAAII,KAAAA,CACR,CAAC,0EAA0E,CAAC,CAAA,CAAA;AAEhF,KAAA;AAEA,IAAA,MAAM,EAAEC,QAAQ,EAAEC,UAAU,EAAE,GAAGC,aAAa,GAAGP,OAAAA,CAAAA;AAEjD,IAAA,IAAI,cAAcO,WAAa,EAAA;QAC7B,OAAOA,WAAAA,CAAAA;AACT,KAAA;AAEA,IAAA,IAAID,UAAY,EAAA;QACdE,MAAOC,CAAAA,MAAM,CAACF,WAAa,EAAA;AACzBN,YAAAA,QAAAA,EAAUI,QACNK,GAAAA,+CAAAA,CAAwBX,MAAQO,EAAAA,UAAAA,CAAAA,GAChCK,gCAAgBZ,MAAQO,EAAAA,UAAAA,CAAAA;AAC9B,SAAA,CAAA,CAAA;QAEA,OAAOC,WAAAA,CAAAA;AACT,KAAA;IAEA,OAAO;AACL,QAAA,GAAGA,WAAW;AACdN,QAAAA,QAAAA,EAAUI,QACNK,GAAAA,+CAAAA,CAAwBX,MAAQI,EAAAA,SAAAA,CAAAA,GAChCQ,gCAAgBZ,MAAQI,EAAAA,SAAAA,CAAAA;AAC9B,KAAA,CAAA;AACF;;;;"}

package/dist/cjs/lib/composeQueryKey.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var composeBaseQueryKey = require('./composeBaseQueryKey.cjs');
+
+function composeQueryKey(schema, parameters) {
+    return composeBaseQueryKey.composeBaseQueryKey(schema, parameters, false);
+}
+
+exports.composeQueryKey = composeQueryKey;
+//# sourceMappingURL=composeQueryKey.cjs.map

package/dist/cjs/lib/composeQueryKey.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"composeQueryKey.cjs","sources":["../../../src/lib/composeQueryKey.ts"],"sourcesContent":["import type { ServiceOperationQueryKey } from '../service-operation/ServiceOperationKey.js';\nimport { composeBaseQueryKey } from './composeBaseQueryKey.js';\nimport type { OperationSchema } from './requestFn.js';\n\nexport function composeQueryKey<TSchema extends OperationSchema, TParams>(\n  schema: TSchema,\n  parameters: TParams | undefined\n): ServiceOperationQueryKey<TSchema, TParams> {\n  return composeBaseQueryKey(schema, parameters, false);\n}\n"],"names":["composeQueryKey","schema","parameters","composeBaseQueryKey"],"mappings":";;;;AAIO,SAASA,eAAAA,CACdC,MAAe,EACfC,UAA+B,EAAA;IAE/B,OAAOC,uCAAAA,CAAoBF,QAAQC,UAAY,EAAA,KAAA,CAAA,CAAA;AACjD;;;;"}

package/dist/cjs/lib/createRecursiveProxy.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+// todo::rename to `qraftRecursiveProxy` with deprecated `createRecursiveProxy`
+/**
+ * Creates a recursive proxy that calls the `getCallback` and `applyCallback` functions
+ * @param getCallback The callback to call when a proxy property is accessed
+ * @param applyCallback The callback to call when a proxy is called as a function
+ * @param path The current path of the proxy
+ */ function createRecursiveProxy(getCallback, applyCallback, path) {
+    return new Proxy(noop, {
+        get (_obj, key) {
+            if (typeof key !== 'string' || key === 'then') {
+                // special case for if the proxy is accidentally treated
+                // like a PromiseLike (like in `Promise.resolve(proxy)`)
+                return undefined;
+            }
+            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() {
+// noop
+}
+
+exports.createRecursiveProxy = createRecursiveProxy;
+//# sourceMappingURL=createRecursiveProxy.cjs.map

package/dist/cjs/lib/createRecursiveProxy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRecursiveProxy.cjs","sources":["../../../src/lib/createRecursiveProxy.ts"],"sourcesContent":["type ProxyApplyCallback = (path: string[], args: unknown[]) => unknown;\n/**\n * @internal\n * If returns `undefined | null`, the proxy will continue to create a new proxy for the next key.\n */\ntype ProxyGetCallback = (path: string[], key: string) => unknown | undefined;\n\n// todo::rename to `qraftRecursiveProxy` with deprecated `createRecursiveProxy`\n/**\n * Creates a recursive proxy that calls the `getCallback` and `applyCallback` functions\n * @param getCallback The callback to call when a proxy property is accessed\n * @param applyCallback The callback to call when a proxy is called as a function\n * @param path The current path of the proxy\n */\nexport function createRecursiveProxy(\n  getCallback: ProxyGetCallback,\n  applyCallback: ProxyApplyCallback,\n  path: string[]\n): unknown {\n  return new Proxy(noop, {\n    get(_obj, key) {\n      if (typeof key !== 'string' || key === 'then') {\n        // special case for if the proxy is accidentally treated\n        // like a PromiseLike (like in `Promise.resolve(proxy)`)\n        return undefined;\n      }\n\n      return (\n        getCallback(path, key) ??\n        createRecursiveProxy(getCallback, applyCallback, [...path, key])\n      );\n    },\n    apply(_1, _2, args) {\n      const functionName = path[path.length - 1];\n\n      const isCall = functionName === 'call';\n      const isApply = isCall ? false : functionName === 'apply';\n\n      return applyCallback(\n        isApply || isCall ? path.slice(0, -1) : path,\n        isApply\n          ? args.length >= 2\n            ? args[1]\n            : []\n          : isCall\n            ? args.slice(1)\n            : args\n      );\n    },\n  });\n}\n\nfunction noop() {\n  // noop\n}\n"],"names":["createRecursiveProxy","getCallback","applyCallback","path","Proxy","noop","get","_obj","key","undefined","apply","_1","_2","args","functionName","length","isCall","isApply","slice"],"mappings":";;AAOA;AACA;;;;;AAKC,IACM,SAASA,oBAAAA,CACdC,WAA6B,EAC7BC,aAAiC,EACjCC,IAAc,EAAA;IAEd,OAAO,IAAIC,MAAMC,IAAM,EAAA;QACrBC,GAAIC,CAAAA,CAAAA,IAAI,EAAEC,GAAG,EAAA;AACX,YAAA,IAAI,OAAOA,GAAAA,KAAQ,QAAYA,IAAAA,GAAAA,KAAQ,MAAQ,EAAA;;;gBAG7C,OAAOC,SAAAA,CAAAA;AACT,aAAA;AAEA,YAAA,OACER,WAAYE,CAAAA,IAAAA,EAAMK,GAClBR,CAAAA,IAAAA,oBAAAA,CAAqBC,aAAaC,aAAe,EAAA;AAAIC,gBAAAA,GAAAA,IAAAA;AAAMK,gBAAAA,GAAAA;AAAI,aAAA,CAAA,CAAA;AAEnE,SAAA;AACAE,QAAAA,KAAAA,CAAAA,CAAMC,EAAE,EAAEC,EAAE,EAAEC,IAAI,EAAA;AAChB,YAAA,MAAMC,eAAeX,IAAI,CAACA,IAAKY,CAAAA,MAAM,GAAG,CAAE,CAAA,CAAA;AAE1C,YAAA,MAAMC,SAASF,YAAiB,KAAA,MAAA,CAAA;YAChC,MAAMG,OAAAA,GAAUD,MAAS,GAAA,KAAA,GAAQF,YAAiB,KAAA,OAAA,CAAA;YAElD,OAAOZ,aAAAA,CACLe,OAAWD,IAAAA,MAAAA,GAASb,IAAKe,CAAAA,KAAK,CAAC,CAAG,EAAA,CAAC,CAAKf,CAAAA,GAAAA,IAAAA,EACxCc,OACIJ,GAAAA,IAAAA,CAAKE,MAAM,IAAI,CAAA,GACbF,IAAI,CAAC,CAAE,CAAA,GACP,EAAE,GACJG,MACEH,GAAAA,IAAAA,CAAKK,KAAK,CAAC,CACXL,CAAAA,GAAAA,IAAAA,CAAAA,CAAAA;AAEV,SAAA;AACF,KAAA,CAAA,CAAA;AACF,CAAA;AAEA,SAASR,IAAAA,GAAAA;AACP;AACF;;;;"}

package/dist/cjs/lib/jwt-decode/index.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+class InvalidTokenError extends Error {
+}
+InvalidTokenError.prototype.name = 'InvalidTokenError';
+/**
+ * Decode a base64 string to a UTF-8 string.
+ * Could be used in Node.js or in the browser.
+ */ 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)}`;
+}
+
+exports.InvalidTokenError = InvalidTokenError;
+exports.b64DecodeUnicode = b64DecodeUnicode;
+exports.jwtDecode = jwtDecode;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/lib/jwt-decode/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../../../src/lib/jwt-decode/index.ts"],"sourcesContent":["export interface JwtDecodeOptions {\n  header?: boolean;\n}\n\nexport interface JwtHeader {\n  typ?: string;\n  alg?: string;\n  kid?: string;\n}\n\nexport interface JwtPayload {\n  iss?: string;\n  sub?: string;\n  aud?: string[] | string;\n  exp?: number;\n  nbf?: number;\n  iat?: number;\n  jti?: string;\n}\n\nexport class InvalidTokenError extends Error {}\n\nInvalidTokenError.prototype.name = 'InvalidTokenError';\n\n/**\n * Decode a base64 string to a UTF-8 string.\n * Could be used in Node.js or in the browser.\n */\nexport function b64DecodeUnicode(data: string): string {\n  if (typeof atob === 'function')\n    return decodeURIComponent(Array.from(atob(data), byteToPercent).join(''));\n\n  return Buffer.from(data, 'base64').toString('utf-8');\n}\n\nfunction base64UrlDecode(str: string) {\n  let output = str.replace(/-/g, '+').replace(/_/g, '/');\n  switch (output.length % 4) {\n    case 0:\n      break;\n    case 2:\n      output += '==';\n      break;\n    case 3:\n      output += '=';\n      break;\n    default:\n      throw new Error('base64 string is not of the correct length');\n  }\n\n  try {\n    return b64DecodeUnicode(output);\n  } catch (err) {\n    return atob(output);\n  }\n}\n\nexport function jwtDecode<T = JwtHeader>(\n  token: string,\n  options: JwtDecodeOptions & { header: true }\n): T;\nexport function jwtDecode<T = JwtPayload>(\n  token: string,\n  options?: JwtDecodeOptions\n): T;\nexport function jwtDecode<T = JwtHeader | JwtPayload>(\n  token: string,\n  options?: JwtDecodeOptions\n): T {\n  if (typeof token !== 'string') {\n    throw new InvalidTokenError('Invalid token specified: must be a string');\n  }\n\n  options ||= {};\n\n  const pos = options.header === true ? 0 : 1;\n  const part = token.split('.')[pos];\n\n  if (typeof part !== 'string') {\n    throw new InvalidTokenError(\n      `Invalid token specified: missing part #${pos + 1}`\n    );\n  }\n\n  let decoded: string;\n  try {\n    decoded = base64UrlDecode(part);\n  } catch (e) {\n    throw new InvalidTokenError(\n      `Invalid token specified: invalid base64 for part #${pos + 1} (${(e as Error).message})`\n    );\n  }\n\n  try {\n    return JSON.parse(decoded) as T;\n  } catch (e) {\n    throw new InvalidTokenError(\n      `Invalid token specified: invalid json for part #${pos + 1} (${(e as Error).message})`\n    );\n  }\n}\n\nfunction byteToPercent(b: string) {\n  return `%${`00${b.charCodeAt(0).toString(16)}`.slice(-2)}`;\n}\n"],"names":["InvalidTokenError","Error","prototype","name","b64DecodeUnicode","data","atob","decodeURIComponent","Array","from","byteToPercent","join","Buffer","toString","base64UrlDecode","str","output","replace","length","err","jwtDecode","token","options","pos","header","part","split","decoded","e","message","JSON","parse","b","charCodeAt","slice"],"mappings":";;AAoBO,MAAMA,iBAA0BC,SAAAA,KAAAA,CAAAA;AAAO,CAAA;AAE9CD,iBAAkBE,CAAAA,SAAS,CAACC,IAAI,GAAG,mBAAA,CAAA;AAEnC;;;IAIO,SAASC,gBAAAA,CAAiBC,IAAY,EAAA;AAC3C,IAAA,IAAI,OAAOC,IAAAA,KAAS,UAClB,EAAA,OAAOC,kBAAmBC,CAAAA,KAAAA,CAAMC,IAAI,CAACH,IAAKD,CAAAA,IAAAA,CAAAA,EAAOK,aAAeC,CAAAA,CAAAA,IAAI,CAAC,EAAA,CAAA,CAAA,CAAA;AAEvE,IAAA,OAAOC,OAAOH,IAAI,CAACJ,IAAM,EAAA,QAAA,CAAA,CAAUQ,QAAQ,CAAC,OAAA,CAAA,CAAA;AAC9C,CAAA;AAEA,SAASC,gBAAgBC,GAAW,EAAA;IAClC,IAAIC,MAAAA,GAASD,IAAIE,OAAO,CAAC,MAAM,GAAKA,CAAAA,CAAAA,OAAO,CAAC,IAAM,EAAA,GAAA,CAAA,CAAA;IAClD,OAAQD,MAAAA,CAAOE,MAAM,GAAG,CAAA;QACtB,KAAK,CAAA;AACH,YAAA,MAAA;QACF,KAAK,CAAA;YACHF,MAAU,IAAA,IAAA,CAAA;AACV,YAAA,MAAA;QACF,KAAK,CAAA;YACHA,MAAU,IAAA,GAAA,CAAA;AACV,YAAA,MAAA;AACF,QAAA;AACE,YAAA,MAAM,IAAIf,KAAM,CAAA,4CAAA,CAAA,CAAA;AACpB,KAAA;IAEA,IAAI;AACF,QAAA,OAAOG,gBAAiBY,CAAAA,MAAAA,CAAAA,CAAAA;AAC1B,KAAA,CAAE,OAAOG,GAAK,EAAA;AACZ,QAAA,OAAOb,IAAKU,CAAAA,MAAAA,CAAAA,CAAAA;AACd,KAAA;AACF,CAAA;AAUO,SAASI,SAAAA,CACdC,KAAa,EACbC,OAA0B,EAAA;IAE1B,IAAI,OAAOD,UAAU,QAAU,EAAA;AAC7B,QAAA,MAAM,IAAIrB,iBAAkB,CAAA,2CAAA,CAAA,CAAA;AAC9B,KAAA;AAEAsB,IAAAA,OAAAA,KAAY,EAAC,CAAA;AAEb,IAAA,MAAMC,GAAMD,GAAAA,OAAAA,CAAQE,MAAM,KAAK,OAAO,CAAI,GAAA,CAAA,CAAA;AAC1C,IAAA,MAAMC,OAAOJ,KAAMK,CAAAA,KAAK,CAAC,GAAA,CAAI,CAACH,GAAI,CAAA,CAAA;IAElC,IAAI,OAAOE,SAAS,QAAU,EAAA;AAC5B,QAAA,MAAM,IAAIzB,iBACR,CAAA,CAAC,uCAAuC,EAAEuB,GAAAA,GAAM,EAAE,CAAC,CAAA,CAAA;AAEvD,KAAA;IAEA,IAAII,OAAAA,CAAAA;IACJ,IAAI;AACFA,QAAAA,OAAAA,GAAUb,eAAgBW,CAAAA,IAAAA,CAAAA,CAAAA;AAC5B,KAAA,CAAE,OAAOG,CAAG,EAAA;AACV,QAAA,MAAM,IAAI5B,iBAAAA,CACR,CAAC,kDAAkD,EAAEuB,GAAM,GAAA,CAAA,CAAE,EAAE,EAAE,CAACK,CAAYC,OAAO,CAAC,CAAC,CAAC,CAAA,CAAA;AAE5F,KAAA;IAEA,IAAI;QACF,OAAOC,IAAAA,CAAKC,KAAK,CAACJ,OAAAA,CAAAA,CAAAA;AACpB,KAAA,CAAE,OAAOC,CAAG,EAAA;AACV,QAAA,MAAM,IAAI5B,iBAAAA,CACR,CAAC,gDAAgD,EAAEuB,GAAM,GAAA,CAAA,CAAE,EAAE,EAAE,CAACK,CAAYC,OAAO,CAAC,CAAC,CAAC,CAAA,CAAA;AAE1F,KAAA;AACF,CAAA;AAEA,SAASnB,cAAcsB,CAAS,EAAA;AAC9B,IAAA,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAEA,EAAEC,UAAU,CAAC,GAAGpB,QAAQ,CAAC,IAAI,CAAC,CAACqB,KAAK,CAAC,CAAC,GAAG,CAAC,CAAA;AAC5D;;;;;;"}