react-query-kit/build/umd/index.development.js

🕊️ A toolkit for ReactQuery that make ReactQuery hooks more reusable and typesafe

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@tanstack/react-query')) :
  typeof define === 'function' && define.amd ? define(['exports', '@tanstack/react-query'], factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactQueryKit = {}, global.ReactQuery));
})(this, (function (exports, TanstackReactQuery) { 'use strict';

  function _interopNamespace(e) {
    if (e && e.__esModule) return e;
    var n = Object.create(null);
    if (e) {
      Object.keys(e).forEach(function (k) {
        if (k !== 'default') {
          var d = Object.getOwnPropertyDescriptor(e, k);
          Object.defineProperty(n, k, d.get ? d : {
            enumerable: true,
            get: function () { return e[k]; }
          });
        }
      });
    }
    n["default"] = e;
    return Object.freeze(n);
  }

  var TanstackReactQuery__namespace = /*#__PURE__*/_interopNamespace(TanstackReactQuery);

  const ReactQuery = TanstackReactQuery__namespace;
  const isV5 = !!ReactQuery.useSuspenseQuery;
  const suspenseOptions = {
    enabled: true,
    suspense: true,
    keepPreviousData: undefined,
    useErrorBoundary: (_error, query) => query.state.data === undefined
  };
  const withMiddleware = (hook, defaultOptions, type) => {
    return function useMiddleware(options, queryClient) {
      const [uses, opts] = [ReactQuery.useQueryClient( // @ts-ignore Compatible with ReactQuery v4
      isV5 ? queryClient : options).getDefaultOptions()[type], defaultOptions, options].reduce(([u1, o1], {
        use: u2 = [],
        ...o2
      } = {}) => [[...u1, ...u2], { ...o1,
        ...o2
      }], [[]]);
      return uses.reduceRight((next, use) => use(next), hook)(opts, queryClient);
    };
  };
  const getKey = (queryKey, variables) => {
    return variables === undefined ? queryKey : [...queryKey, variables];
  };

  const createBaseQuery = (defaultOptions, useRQHook, overrideOptions) => {
    {
      // @ts-ignore
      if (defaultOptions.useDefaultOptions) {
        console.error('[Bug] useDefaultOptions is not supported, please use middleware instead.');
      } // @ts-ignore


      if (defaultOptions.queryFn) {
        console.error('[Bug] queryFn is not supported, please use fetcher instead.');
      }
    }

    const getQueryOptions = (fetcherFn, variables) => {
      return {
        queryFn: variables && variables === ReactQuery.skipToken ? ReactQuery.skipToken : context => fetcherFn(variables, context),
        queryKey: getKey(defaultOptions.queryKey, variables)
      };
    };

    const getKey$1 = variables => getKey(defaultOptions.queryKey, variables);

    const getOptions = variables => {
      return { ...defaultOptions,
        ...getQueryOptions(defaultOptions.fetcher, variables)
      };
    };

    const getFetchOptions = variables => {
      return { ...getQueryOptions(defaultOptions.fetcher, variables),
        queryKeyHashFn: defaultOptions.queryKeyHashFn,
        getPreviousPageParam: defaultOptions.getPreviousPageParam,
        getNextPageParam: defaultOptions.getNextPageParam,
        initialPageParam: defaultOptions.initialPageParam,
        staleTime: defaultOptions.staleTime,
        gcTime: defaultOptions.gcTime
      };
    };

    const useBaseHook = (options, queryClient) => {
      return useRQHook({ ...options,
        ...getQueryOptions(options.fetcher, options.variables),
        ...overrideOptions
      }, queryClient);
    };

    return Object.assign(withMiddleware(useBaseHook, defaultOptions, 'queries'), {
      fetcher: defaultOptions.fetcher,
      getKey: getKey$1,
      getOptions,
      getFetchOptions
    });
  };

  function createQuery(options) {
    return createBaseQuery(options, ReactQuery.useQuery);
  }

  function createSuspenseQuery(options) {
    return isV5 ? createBaseQuery(options, ReactQuery.useSuspenseQuery) : createBaseQuery(options, ReactQuery.useQuery, suspenseOptions);
  }

  function createInfiniteQuery(options) {
    return createBaseQuery(options, ReactQuery.useInfiniteQuery);
  }

  function createSuspenseInfiniteQuery(options) {
    return isV5 ? createBaseQuery(options, ReactQuery.useSuspenseInfiniteQuery) : createBaseQuery(options, ReactQuery.useInfiniteQuery, suspenseOptions);
  }

  function createMutation(defaultOptions) {
    return Object.assign(withMiddleware(ReactQuery.useMutation, defaultOptions, 'mutations'), {
      getKey: () => defaultOptions.mutationKey,
      getOptions: () => defaultOptions,
      mutationFn: defaultOptions.mutationFn
    });
  }

  const isRouterLeaf = value => {
    return !!value && typeof value._routerType === 'string';
  };

  const buildRouter = (keys, config) => {
    return Object.entries(config).reduce((acc, [key, opts]) => {
      if (!isRouterLeaf(opts)) {
        acc[key] = buildRouter([...keys, key], opts);
      } else {
        const type = opts._routerType;
        const options = { ...opts,
          [type === "m" ? "mutationKey" : "queryKey"]: [...keys, key]
        };

        if (type === "m") {
          acc[key] = {
            useMutation: createMutation(options),
            ...createMutation(options)
          };
          return acc;
        }

        acc[key] = type === "q" ? {
          useQuery: createQuery(options),
          useSuspenseQuery: createSuspenseQuery(options),
          ...createQuery(options)
        } : {
          useInfiniteQuery: createInfiniteQuery(options),
          useSuspenseInfiniteQuery: createSuspenseInfiniteQuery(options),
          ...createInfiniteQuery(options)
        };
      }

      return acc;
    }, {
      getKey: () => keys
    });
  };

  const router = (key, config) => {
    return buildRouter(Array.isArray(key) ? key : [key], config);
  };

  function query(options) {
    return { ...options,
      _routerType: 'q'
    };
  }

  function infiniteQuery(options) {
    return { ...options,
      _routerType: 'inf'
    };
  }

  function mutation(options) {
    return { ...options,
      _routerType: 'm'
    };
  }

  router.query = query;
  router.infiniteQuery = infiniteQuery;
  router.mutation = mutation;

  exports.createInfiniteQuery = createInfiniteQuery;
  exports.createMutation = createMutation;
  exports.createQuery = createQuery;
  exports.createSuspenseInfiniteQuery = createSuspenseInfiniteQuery;
  exports.createSuspenseQuery = createSuspenseQuery;
  exports.getKey = getKey;
  exports.router = router;

  Object.defineProperty(exports, '__esModule', { value: true });

}));
//# sourceMappingURL=index.development.js.map