swr-openapi/dist/index.cjs

Generate SWR hooks from OpenAPI schemas

'use strict';

const useSWRImmutable = require('swr/immutable');
const react = require('react');
const useSWRInfinite = require('swr/infinite');
const useSWR = require('swr');

function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }

const useSWRImmutable__default = /*#__PURE__*/_interopDefaultCompat(useSWRImmutable);
const useSWRInfinite__default = /*#__PURE__*/_interopDefaultCompat(useSWRInfinite);
const useSWR__default = /*#__PURE__*/_interopDefaultCompat(useSWR);

function configureBaseQueryHook(useHook) {
  return function createQueryBaseHook(client, prefix) {
    return function useQuery(path, ...[init, config]) {
      react.useDebugValue(`${prefix} - ${path}`);
      const key = react.useMemo(() => init !== null ? [prefix, path, init] : null, [prefix, path, init]);
      const fetcher = react.useCallback(
        async ([_, path2, init2]) => {
          const res = await client.GET(path2, init2);
          if (res.error) {
            throw res.error;
          }
          return res.data;
        },
        [client]
      );
      return useHook(key, fetcher, config);
    };
  };
}

const createImmutableHook = configureBaseQueryHook(useSWRImmutable__default);

function createInfiniteHook(client, prefix) {
  return function useInfinite(path, getInit, config) {
    react.useDebugValue(`${prefix} - ${path}`);
    const fetcher = react.useCallback(
      async ([_, path2, init]) => {
        const res = await client.GET(path2, init);
        if (res.error) {
          throw res.error;
        }
        return res.data;
      },
      [client]
    );
    const getKey = (index, previousPageData) => {
      const init = getInit(index, previousPageData);
      if (init === null) {
        return null;
      }
      const key = [prefix, path, init];
      return key;
    };
    return useSWRInfinite__default(getKey, fetcher, config);
  };
}

function createMutateHook(client, prefix, compare) {
  return function useMutate() {
    const { mutate: swrMutate } = useSWR.useSWRConfig();
    react.useDebugValue(prefix);
    return react.useCallback(
      function mutate([path, init], data, opts) {
        return swrMutate(
          (key) => {
            if (
              // Must be array
              !Array.isArray(key) || // Must have 2 or 3 elements (prefix, path, optional init)
              ![2, 3].includes(key.length)
            ) {
              return false;
            }
            const [keyPrefix, keyPath, keyOptions] = key;
            return (
              // Matching prefix
              keyPrefix === prefix && // Matching path
              keyPath === path && // Matching options
              (init ? compare(keyOptions, init) : true)
            );
          },
          data,
          opts
        );
      },
      [swrMutate, prefix, compare]
    );
  };
}

const createQueryHook = configureBaseQueryHook(useSWR__default);

exports.createImmutableHook = createImmutableHook;
exports.createInfiniteHook = createInfiniteHook;
exports.createMutateHook = createMutateHook;
exports.createQueryHook = createQueryHook;
//# sourceMappingURL=index.cjs.map