chore: Refine type interfaces

infinite/index.ts

@@ -4,34 +4,38 @@
 import { useRef, useState, useCallback } from 'react'
 import useSWR, {
   SWRConfig,
-  KeyLoader,
   Fetcher,
   SWRHook,
   MutatorCallback,
   Middleware,
-  ValueKey,
-  Result
+  Arguments
 } from 'swr'
 import { useIsomorphicLayoutEffect } from '../src/utils/env'
 import { serialize } from '../src/utils/serialize'
 import { isUndefined, isFunction, UNDEFINED } from '../src/utils/helper'
 import { withMiddleware } from '../src/utils/with-middleware'
-import { SWRInfiniteConfiguration, SWRInfiniteResponse } from './types'
+import {
+  SWRInfiniteConfiguration,
+  SWRInfiniteResponse,
+  SWRInfiniteHook,
+  InfiniteKeyLoader,
+  InfiniteFetcher
+} from './types'
 
 const INFINITE_PREFIX = '$inf$'
 
-const getFirstPageKey = (getKey: KeyLoader) => {
+const getFirstPageKey = (getKey: InfiniteKeyLoader) => {
   return serialize(getKey ? getKey(0, null) : null)[0]
 }
 
-export const unstable_serialize = (getKey: KeyLoader) => {
+export const unstable_serialize = (getKey: InfiniteKeyLoader) => {
   return INFINITE_PREFIX + getFirstPageKey(getKey)
 }
 
-export const infinite = ((<Data, Error, Args extends ValueKey>(
+export const infinite = ((<Data, Error, Args extends Arguments>(
   useSWRNext: SWRHook
 ) => (
-  getKey: KeyLoader<Args>,
+  getKey: InfiniteKeyLoader<Args>,
   fn: Fetcher<Data> | null,
   config: typeof SWRConfig.default & SWRInfiniteConfiguration<Data, Error, Args>
 ): SWRInfiniteResponse<Data, Error> => {
@@ -250,37 +254,5 @@ export const infinite = ((<Data, Error, Args extends ValueKey>(
   } as SWRInfiniteResponse<Data, Error>
 }) as unknown) as Middleware
 
-export type InfiniteFetcher<
-  Args extends ValueKey = ValueKey,
-  Data = any
-> = Args extends (readonly [...infer K])
-  ? ((...args: [...K]) => Result<Data>)
-  : Args extends null
-  ? never
-  : Args extends (infer T)
-  ? (...args: [T]) => Result<Data>
-  : never
-
-interface SWRInfiniteHook {
-  <Data = any, Error = any, Args extends ValueKey = ValueKey>(
-    getKey: KeyLoader<Args>
-  ): SWRInfiniteResponse<Data, Error>
-  <Data = any, Error = any, Args extends ValueKey = ValueKey>(
-    getKey: KeyLoader<Args>,
-    fn: InfiniteFetcher<Args, Data> | null
-  ): SWRInfiniteResponse<Data, Error>
-  <Data = any, Error = any, Args extends ValueKey = ValueKey>(
-    getKey: KeyLoader<Args>,
-    config: SWRInfiniteConfiguration<Data, Error, Args> | undefined
-  ): SWRInfiniteResponse<Data, Error>
-  <Data = any, Error = any, Args extends ValueKey = ValueKey>(
-    ...args: [
-      KeyLoader<Args>,
-      InfiniteFetcher<Args, Data> | null,
-      SWRInfiniteConfiguration<Data, Error, Args> | undefined
-    ]
-  ): SWRInfiniteResponse<Data, Error>
-}
-
 export default withMiddleware(useSWR, infinite) as SWRInfiniteHook
-export { SWRInfiniteConfiguration, SWRInfiniteResponse }
+export { SWRInfiniteConfiguration, SWRInfiniteResponse, InfiniteFetcher }

infinite/types.ts

@@ -1,10 +1,27 @@
-import { SWRConfiguration, Fetcher, SWRResponse, ValueKey } from 'swr'
+import { SWRConfiguration, SWRResponse, Arguments } from 'swr'
+
+type FetcherReturnValue<Data = unknown> = Data | Promise<Data>
+
+export type InfiniteFetcher<
+  Args extends Arguments = Arguments,
+  Data = any
+> = Args extends (readonly [...infer K])
+  ? ((...args: [...K]) => FetcherReturnValue<Data>)
+  : Args extends null
+  ? never
+  : Args extends (infer T)
+  ? (...args: [T]) => FetcherReturnValue<Data>
+  : never
+
+export type InfiniteKeyLoader<Args extends Arguments = Arguments> =
+  | ((index: number, previousPageData: any | null) => Args)
+  | null
 
 export type SWRInfiniteConfiguration<
   Data = any,
   Error = any,
-  Args extends ValueKey = ValueKey
-> = SWRConfiguration<Data[], Error, Args, Fetcher<Data[], Args>> & {
+  Args extends Arguments = Arguments
+> = SWRConfiguration<Data[], Error, Args> & {
   initialSize?: number
   revalidateAll?: boolean
   persistSize?: boolean
@@ -17,3 +34,26 @@ export interface SWRInfiniteResponse<Data = any, Error = any>
     size: number | ((_size: number) => number)
   ) => Promise<Data[] | undefined>
 }
+
+export interface SWRInfiniteHook {
+  <Data = any, Error = any, SWRInfiniteArguments extends Arguments = Arguments>(
+    getKey: InfiniteKeyLoader<SWRInfiniteArguments>
+  ): SWRInfiniteResponse<Data, Error>
+  <Data = any, Error = any, SWRInfiniteArguments extends Arguments = Arguments>(
+    getKey: InfiniteKeyLoader<SWRInfiniteArguments>,
+    fetcher: InfiniteFetcher<SWRInfiniteArguments, Data> | null
+  ): SWRInfiniteResponse<Data, Error>
+  <Data = any, Error = any, SWRInfiniteArguments extends Arguments = Arguments>(
+    getKey: InfiniteKeyLoader<SWRInfiniteArguments>,
+    config:
+      | SWRInfiniteConfiguration<Data, Error, SWRInfiniteArguments>
+      | undefined
+  ): SWRInfiniteResponse<Data, Error>
+  <Data = any, Error = any, SWRInfiniteArguments extends Arguments = Arguments>(
+    getKey: InfiniteKeyLoader<SWRInfiniteArguments>,
+    fetcher: InfiniteFetcher<SWRInfiniteArguments, Data> | null,
+    config:
+      | SWRInfiniteConfiguration<Data, Error, SWRInfiniteArguments>
+      | undefined
+  ): SWRInfiniteResponse<Data, Error>
+}

src/index.ts

@@ -21,6 +21,5 @@ export {
   Fetcher,
   MutatorCallback,
   Middleware,
-  ValueKey,
-  Result
+  Arguments
 } from './types'

src/types.ts

@@ -1,35 +1,33 @@
 import * as revalidateEvents from './constants/revalidate-events'
 
-export type Result<T = unknown> = T | Promise<T>
+export type FetcherReturnValue<Data = unknown> = Data | Promise<Data>
 
-export type Fetcher<Data = unknown, Args extends Key = Key> =
+export type Fetcher<Data = unknown, SWRKey extends Key = Key> =
   /**
    * () => [{ foo: string }, { bar: number }] | null
-   *
    * () => ( [{ foo: string }, { bar: number } ] as const | null )
    */
-  Args extends (() => readonly [...infer K] | null)
-    ? ((...args: [...K]) => Result<Data>)
-    : /**
-     * [{ foo: string }, { bar: number } ] | null
-     *
-     * [{ foo: string }, { bar: number } ] as const | null
-     */
-    Args extends (readonly [...infer K])
-    ? ((...args: [...K]) => Result<Data>)
-    : /**
-     * () => string | null
-     * () => Record<any, any> | null
-     */
-    Args extends (() => infer T | null)
-    ? (...args: [T]) => Result<Data>
-    : /**
-     *  string | null | Record<any,any>
-     */
-    Args extends null
+  SWRKey extends (() => readonly [...infer Args] | null)
+    ? ((...args: [...Args]) => FetcherReturnValue<Data>)
+      /**
+       * [{ foo: string }, { bar: number } ] | null
+       * [{ foo: string }, { bar: number } ] as const | null
+       */
+    : SWRKey extends (readonly [...infer Args])
+    ? ((...args: [...Args]) => FetcherReturnValue<Data>)
+      /**
+       * () => string | null
+       * () => Record<any, any> | null
+       */
+    : SWRKey extends (() => infer Arg | null)
+    ? (...args: [Arg]) => FetcherReturnValue<Data>
+      /**
+       *  string | null | Record<any,any>
+       */
+    : SWRKey extends null
     ? never
-    : Args extends (infer T)
-    ? (...args: [T]) => Result<Data>
+    : SWRKey extends (infer Arg)
+    ? (...args: [Arg]) => FetcherReturnValue<Data>
     : never
 
 // Configuration types that are only used internally, not exposed to the user.
@@ -41,8 +39,7 @@ export interface InternalConfiguration {
 export interface PublicConfiguration<
   Data = any,
   Error = any,
-  Args extends Key = Key,
-  Fn = Fetcher<Data, Args>
+  SWRKey extends Key = Key
 > {
   errorRetryInterval: number
   errorRetryCount?: number
@@ -59,29 +56,29 @@ export interface PublicConfiguration<
   shouldRetryOnError: boolean
   suspense?: boolean
   fallbackData?: Data
-  fetcher?: Fn
+  fetcher?: Fetcher<Data, SWRKey>
   use?: Middleware[]
   fallback: { [key: string]: any }
 
   isPaused: () => boolean
   onLoadingSlow: (
     key: string,
-    config: Readonly<PublicConfiguration<Data, Error, Args, Fn>>
+    config: Readonly<PublicConfiguration<Data, Error, SWRKey>>
   ) => void
   onSuccess: (
     data: Data,
     key: string,
-    config: Readonly<PublicConfiguration<Data, Error, Args, Fn>>
+    config: Readonly<PublicConfiguration<Data, Error, SWRKey>>
   ) => void
   onError: (
     err: Error,
     key: string,
-    config: Readonly<PublicConfiguration<Data, Error, Args, Fn>>
+    config: Readonly<PublicConfiguration<Data, Error, SWRKey>>
   ) => void
   onErrorRetry: (
     err: Error,
     key: string,
-    config: Readonly<PublicConfiguration<Data, Error, Args, Fn>>,
+    config: Readonly<PublicConfiguration<Data, Error, SWRKey>>,
     revalidate: Revalidator,
     revalidateOpts: Required<RevalidatorOptions>
   ) => void
@@ -94,55 +91,54 @@ export interface PublicConfiguration<
 
 export type FullConfiguration = InternalConfiguration & PublicConfiguration
 
-export type ConfigOptions = {
+export type ProviderConfiguration = {
   initFocus: (callback: () => void) => (() => void) | void
   initReconnect: (callback: () => void) => (() => void) | void
 }
+
 export interface SWRHook {
-  <Data = any, Error = any, Args extends Key = Key>(args: Args): SWRResponse<
+  <Data = any, Error = any, SWRKey extends Key = Key>(key: SWRKey): SWRResponse<
     Data,
     Error
   >
-  <Data = any, Error = any, Args extends Key = Key>(
-    args: Args,
-    fn: Fetcher<Data, Args> | null
+  <Data = any, Error = any, SWRKey extends Key = Key>(
+    key: SWRKey,
+    fetcher: Fetcher<Data, SWRKey> | null
   ): SWRResponse<Data, Error>
-  <Data = any, Error = any, Args extends Key = Key>(
-    args: Args,
-    config: SWRConfiguration<Data, Error, Args, Fetcher<Data, Args>> | undefined
+  <Data = any, Error = any, SWRKey extends Key = Key>(
+    key: SWRKey,
+    config: SWRConfiguration<Data, Error, SWRKey> | undefined
   ): SWRResponse<Data, Error>
-  <Data = any, Error = any, Args extends Key = Key>(
-    args: Args,
-    fn: Fetcher<Data, Args>,
-    config: SWRConfiguration<Data, Error, Args, Fetcher<Data, Args>>
+  <Data = any, Error = any, SWRKey extends Key = Key>(
+    key: SWRKey,
+    fetcher: Fetcher<Data, SWRKey>,
+    config: SWRConfiguration<Data, Error, SWRKey>
   ): SWRResponse<Data, Error>
-  <Data = any, Error = any, Args extends Key = Key>(
+  <Data = any, Error = any, SWRKey extends Key = Key>(
     ...args:
-      | [Args]
-      | [Args, Fetcher<Data, Args> | null]
-      | [
-          Args,
-          SWRConfiguration<Data, Error, Args, Fetcher<Data, Args>> | undefined
-        ]
+      | [SWRKey]
+      | [SWRKey, Fetcher<Data, SWRKey> | null]
+      | [SWRKey, SWRConfiguration<Data, Error, SWRKey> | undefined]
       | [
-          Args,
+          SWRKey,
           Fetcher<Data, Key> | null,
-          SWRConfiguration<Data, Error, Args, Fetcher<Data, Args>>
+          SWRConfiguration<Data, Error, SWRKey>
         ]
   ): SWRResponse<Data, Error>
 }
 
 // Middlewares guarantee that a SWRHook receives a key, fetcher, and config as the argument
-type SWRHookWithMiddleware = <Data = any, Error = any, Args extends Key = Key>(
+export type Middleware = (
+  useSWRNext: SWRHook
+) => <Data = any, Error = any, Args extends Key = Key>(
   key: Args,
   fetcher: Fetcher<Data, Args> | null,
   config: SWRConfiguration<Data, Error>
 ) => SWRResponse<Data, Error>
 
-export type Middleware = (useSWRNext: SWRHook) => SWRHookWithMiddleware
-export type TupleKey = [any, ...unknown[]] | readonly [any, ...unknown[]]
-export type ValueKey = string | null | TupleKey | Record<any, any>
-export type Key = ValueKey | (() => ValueKey)
+type ArgumentsTuple = [any, ...unknown[]] | readonly [any, ...unknown[]]
+export type Arguments = string | null | ArgumentsTuple | Record<any, any>
+export type Key = Arguments | (() => Arguments)
 
 export type MutatorCallback<Data = any> = (
   currentValue?: Data
@@ -195,9 +191,8 @@ export type KeyedMutator<Data> = (
 export type SWRConfiguration<
   Data = any,
   Error = any,
-  Args extends Key = Key,
-  Fn = Fetcher<any, Args>
-> = Partial<PublicConfiguration<Data, Error, Args, Fn>>
+  SWRKey extends Key = Key
+> = Partial<PublicConfiguration<Data, Error, SWRKey>>
 
 export interface SWRResponse<Data, Error> {
   data?: Data
@@ -206,7 +201,7 @@ export interface SWRResponse<Data, Error> {
   isValidating: boolean
 }
 
-export type KeyLoader<Args extends ValueKey = ValueKey> =
+export type KeyLoader<Args extends Arguments = Arguments> =
   | ((index: number, previousPageData: any | null) => Args)
   | null
 

src/utils/cache.ts

@@ -10,7 +10,7 @@ import {
   Cache,
   ScopedMutator,
   RevalidateCallback,
-  ConfigOptions
+  ProviderConfiguration
 } from '../types'
 
 const revalidateAllKeys = (
@@ -24,7 +24,7 @@ const revalidateAllKeys = (
 
 export const initCache = <Data = any>(
   provider: Cache<Data>,
-  options?: Partial<ConfigOptions>
+  options?: Partial<ProviderConfiguration>
 ): [Cache<Data>, ScopedMutator<Data>, () => void] | undefined => {
   // The global state for a specific provider will be used to deduplicate
   // requests and store listeners. As well as a mutate function that bound to

src/utils/config-context.ts

@@ -7,15 +7,15 @@ import { useIsomorphicLayoutEffect } from './env'
 import {
   SWRConfiguration,
   FullConfiguration,
-  ConfigOptions,
+  ProviderConfiguration,
   Cache
 } from '../types'
 
 export const SWRConfigContext = createContext<Partial<FullConfiguration>>({})
 
 const SWRConfig: FC<{
   value?: SWRConfiguration &
-    Partial<ConfigOptions> & {
+    Partial<ProviderConfiguration> & {
       provider?: (cache: Readonly<Cache>) => Cache
     }
 }> = ({ children, value }) => {