types: infer provider type as cache type

src/index.ts

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

src/types.ts

@@ -31,11 +31,10 @@ export type Fetcher<Data = unknown, SWRKey extends Key = Key> =
     : never
 
 // Configuration types that are only used internally, not exposed to the user.
-export interface InternalConfiguration {
-  cache: Cache
+export interface InternalConfiguration<P> {
+  cache: P
   mutate: ScopedMutator
 }
-
 export interface PublicConfiguration<
   Data = any,
   Error = any,
@@ -89,7 +88,10 @@ export interface PublicConfiguration<
   isVisible: () => boolean
 }
 
-export type FullConfiguration = InternalConfiguration & PublicConfiguration
+export type FullConfiguration<Provider = Cache> = InternalConfiguration<
+  Provider
+> &
+  PublicConfiguration
 
 export type ProviderConfiguration = {
   initFocus: (callback: () => void) => (() => void) | void
@@ -160,7 +162,7 @@ export type State<Data, Error> = {
 }
 
 export type Mutator<Data = any> = (
-  cache: Cache,
+  cache: Cache<Data>,
   key: Key,
   data?: Data | Promise<Data> | MutatorCallback<Data>,
   shouldRevalidate?: boolean
@@ -234,8 +236,16 @@ export type StateUpdateCallback<Data = any, Error = any> = (
   isValidating?: boolean
 ) => void
 
-export interface Cache<Data = any> {
+export interface ICache<Data = any> {
   get(key: Key): Data | null | undefined
   set(key: Key, value: Data): void
   delete(key: Key): void
 }
+
+export type DefaultProvider = Map<string | null, any>
+
+export type Cache<T = DefaultProvider, Data = any> = T extends ICache<Data>
+  ? T
+  : never
+
+export type CacheProvider<Data = any> = (cache: Cache<Data>) => Cache<Data>

src/utils/cache.ts

@@ -23,9 +23,9 @@ const revalidateAllKeys = (
 }
 
 export const initCache = <Data = any>(
-  provider: Cache<Data>,
+  provider: Cache,
   options?: Partial<ProviderConfiguration>
-): [Cache<Data>, ScopedMutator<Data>, () => void] | undefined => {
+): [Cache, 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
   // the cache.

src/utils/config-context.ts

@@ -1,4 +1,10 @@
-import { createContext, createElement, useContext, useState, FC } from 'react'
+import {
+  createContext,
+  createElement,
+  useContext,
+  useState,
+  ReactElement
+} from 'react'
 import { cache as defaultCache } from './config'
 import { initCache } from './cache'
 import { mergeConfigs } from './merge-config'
@@ -8,33 +14,38 @@ import {
   SWRConfiguration,
   FullConfiguration,
   ProviderConfiguration,
-  Cache
+  Cache,
+  CacheProvider
 } from '../types'
 
 export const SWRConfigContext = createContext<Partial<FullConfiguration>>({})
 
-const SWRConfig: FC<{
-  value?: SWRConfiguration &
-    Partial<ProviderConfiguration> & {
-      provider?: (cache: Readonly<Cache>) => Cache
-    }
-}> = ({ children, value }) => {
+type SWRConfigValue = SWRConfiguration &
+  Partial<ProviderConfiguration> & {
+    provider?: CacheProvider<any>
+  }
+
+const SWRConfig = ({
+  value,
+  children
+}: {
+  value?: SWRConfigValue
+  children?: React.ReactNode
+}): ReactElement | null => {
   // Extend parent context values and middleware.
   const extendedConfig = mergeConfigs(useContext(SWRConfigContext), value)
-
+  const cache = extendedConfig.cache || defaultCache
   // Should not use the inherited provider.
   const provider = value && value.provider
 
   // Use a lazy initialized state to create the cache on first access.
   const [cacheContext] = useState(() =>
-    provider
-      ? initCache(provider(extendedConfig.cache || defaultCache), value)
-      : UNDEFINED
+    provider ? initCache(provider(cache), value) : UNDEFINED
   )
 
   // Override the cache if a new provider is given.
   if (cacheContext) {
-    extendedConfig.cache = cacheContext[0]
+    extendedConfig.cache = cacheContext[0] as Cache
     extendedConfig.mutate = cacheContext[1]
   }
 

src/utils/config.ts

@@ -8,7 +8,7 @@ import {
   RevalidatorOptions,
   Revalidator,
   ScopedMutator,
-  Cache
+  DefaultProvider
 } from '../types'
 import { isUndefined, noop, mergeObjects } from './helper'
 
@@ -44,7 +44,7 @@ const onErrorRetry = (
 
 // Default cache provider
 const [cache, mutate] = initCache(new Map()) as [
-  Cache<any>,
+  DefaultProvider,
   ScopedMutator<any>,
   () => {}
 ]

src/utils/use-swr-config.ts

@@ -2,8 +2,10 @@ import { useContext } from 'react'
 import { defaultConfig } from './config'
 import { SWRConfigContext } from './config-context'
 import { mergeObjects } from './helper'
-import { FullConfiguration } from '../types'
+import { FullConfiguration, Cache } from '../types'
 
-export const useSWRConfig = (): FullConfiguration => {
+export const useSWRConfig = <Provider = Cache>(): FullConfiguration<
+  Provider
+> => {
   return mergeObjects(defaultConfig, useContext(SWRConfigContext))
 }

test/type/provider.tsx

@@ -0,0 +1,45 @@
+import React from 'react'
+import { useEffect } from 'react'
+import { DefaultProvider, SWRConfig, useSWRConfig } from 'swr'
+
+export function test1() {
+  function useCacheClear() {
+    const { cache: defaultCache } = useSWRConfig()
+    const { cache } = useSWRConfig<DefaultProvider>()
+
+    useEffect(() => {
+      return () => {
+        cache.clear() // infer DefaultProvider
+        defaultCache.clear() // infer DefaultProvider
+      }
+    }, [])
+    return null
+  }
+
+  return useCacheClear
+}
+
+export function test2() {
+  const provider2 = new Map([['k1', 'v1']])
+  function Inner() {
+    // infer Map<string, string>
+    const { cache } = useSWRConfig<typeof provider2>()
+
+    useEffect(() => {
+      return () => cache.clear()
+    }, [])
+    return null
+  }
+
+  function useCustomCache2() {
+    return (
+      <SWRConfig value={{ provider: () => provider2 }}>
+        <SWRConfig value={{ provider: (c: typeof provider2) => c }}>
+          <Inner />
+        </SWRConfig>
+      </SWRConfig>
+    )
+  }
+
+  return useCustomCache2
+}