Export internal types

[nfroidure]

Hi people!

I use SWR with my SDK generated with open-ts-sdk-builder (API calls looks like API.getUser({ userId })).

I wrote a wrapper that allows to use SWR with it but I have some minor types issues that could, I think, be solved by exposing the SWR internal types (especially ConfigInterface and responseInterface, see comments) :

import useSWR from 'swr';
import type { PromiseValue } from 'type-fest';
import API from './api';

type Handler<I, O> = (input: I) => Promise<O>;
type HandlerInput<T> = T extends Handler<infer I, unknown> ? I : never;
type HandlerOutput<T> = T extends Handler<unknown, infer I> ? I : never;

const API_KEYS: Record<any, string> = Object.keys(API).reduce((hash, key) => {
  hash[API[key]] = key;
  return hash;
}, {});

export default function useAPISWR<T extends Handler<any, any>>(
  swrCouple: [T, HandlerInput<T>],
  options?: Parameters<typeof useSWR>[2],
) { // Cannot put the return type easily here, would like to have responseInterface to do so
  const uniqueKey = swrCouple
    ? Object.keys(swrCouple[1]).reduce(
        (finalKey, key) => finalKey + key + JSON.stringify(swrCouple[1][key]),
        // Sadly, here, we cannot rely on `swrCouple[0].name` to
        // build the unicity key since the build destroys it
        API_KEYS[swrCouple[0]] + '-',
      )
    : null;

  return useSWR<
    PromiseValue<HandlerOutput<T>> extends { body: infer D } ? D : never
  >(
    uniqueKey,
    async () => (await swrCouple[0](swrCouple[1])).body,
    options as any, // Had to do this but ConfigInterface<D, any, any> would be best I guess
  );
}

It works like that so no emergency, but let me know what you think ;).

[vvo]

In general, are any swr types exported?

Right now I need to do:

import type { mutateInterface } from "swr/dist/types.d";

but seems like a hack