build: Mangle internal export names

_internal/enums.ts

@@ -0,0 +1,29 @@
+export const enum InternalUtils {
+  serialize,
+  useIsomorphicLayoutEffect,
+  UNDEFINED,
+  subscribeCallback,
+  revalidateEvents,
+  cache,
+  mutate,
+  isUndefined,
+  isFunction,
+  SWRConfig,
+  defaultConfig,
+  SWRGlobalState,
+  stableHash,
+  internalMutate,
+  normalize,
+  withArgs,
+  useStateWithDeps,
+  getTimestamp,
+  useSWRConfig,
+  withMiddleware,
+  IS_REACT_LEGACY,
+  IS_SERVER,
+  rAF,
+  OBJECT,
+  isEmptyCache,
+  mergeObjects,
+  createCacheHelper
+}

_internal/index.ts

@@ -1,24 +1,62 @@
 import SWRConfig from './utils/config-context'
 import * as revalidateEvents from './constants'
-
-export { SWRConfig, revalidateEvents }
-
-export { initCache } from './utils/cache'
-export { defaultConfig, cache, mutate, compare } from './utils/config'
-export * from './utils/env'
-export { SWRGlobalState } from './utils/global-state'
-export { stableHash } from './utils/hash'
-export * from './utils/helper'
-export { mergeConfigs } from './utils/merge-config'
-export { internalMutate } from './utils/mutate'
-export { normalize } from './utils/normalize-args'
-export { withArgs } from './utils/resolve-args'
-export { serialize } from './utils/serialize'
-export { useStateWithDeps } from './utils/state'
-export { subscribeCallback } from './utils/subscribe-key'
-export { getTimestamp } from './utils/timestamp'
-export { useSWRConfig } from './utils/use-swr-config'
-export { preset, defaultConfigOptions } from './utils/web-preset'
-export { withMiddleware } from './utils/with-middleware'
+import { subscribeCallback } from './utils/subscribe-key'
+import { defaultConfig, cache, mutate } from './utils/config'
+import { SWRGlobalState } from './utils/global-state'
+import { stableHash } from './utils/hash'
+import { internalMutate } from './utils/mutate'
+import { normalize } from './utils/normalize-args'
+import { withArgs } from './utils/resolve-args'
+import { serialize } from './utils/serialize'
+import { useStateWithDeps } from './utils/state'
+import { getTimestamp } from './utils/timestamp'
+import { useSWRConfig } from './utils/use-swr-config'
+import { withMiddleware } from './utils/with-middleware'
+import {
+  IS_REACT_LEGACY,
+  IS_SERVER,
+  rAF,
+  useIsomorphicLayoutEffect
+} from './utils/env'
+import {
+  UNDEFINED,
+  OBJECT,
+  isUndefined,
+  isFunction,
+  isEmptyCache,
+  mergeObjects,
+  createCacheHelper
+} from './utils/helper'
 
 export * from './types'
+export { InternalUtils } from './enums'
+
+export default [
+  serialize,
+  useIsomorphicLayoutEffect,
+  UNDEFINED,
+  subscribeCallback,
+  revalidateEvents,
+  cache,
+  mutate,
+  isUndefined,
+  isFunction,
+  SWRConfig,
+  defaultConfig,
+  SWRGlobalState,
+  stableHash,
+  internalMutate,
+  normalize,
+  withArgs,
+  useStateWithDeps,
+  getTimestamp,
+  useSWRConfig,
+  withMiddleware,
+  IS_REACT_LEGACY,
+  IS_SERVER,
+  rAF,
+  OBJECT,
+  isEmptyCache,
+  mergeObjects,
+  createCacheHelper
+] as const

_internal/utils/env.ts

@@ -1,7 +1,6 @@
 import React, { useEffect, useLayoutEffect } from 'react'
 import { hasRequestAnimationFrame, isWindowDefined } from './helper'
 
-
 export const IS_REACT_LEGACY = !React.useId
 
 export const IS_SERVER = !isWindowDefined || 'Deno' in window

_internal/utils/helper.ts

@@ -1,5 +1,6 @@
 import { SWRGlobalState } from './global-state'
 import { Key, Cache, CacheValue, GlobalState } from '../types'
+
 export const noop = () => {}
 
 // Using noop() as the undefined value as undefined can possibly be replaced

core/index.ts

@@ -1,11 +1,12 @@
+// @ts-nocheck
+
 // useSWR
 import useSWR from './use-swr'
 export default useSWR
 
 // Core APIs
 export { SWRConfig, unstable_serialize } from './use-swr'
-export { useSWRConfig } from 'swr/_internal'
-export { mutate } from 'swr/_internal'
+export { mutate, useSWRConfig } from './utils'
 
 // Types
 export type {

core/use-swr.ts

@@ -1,39 +1,40 @@
 import { useCallback, useRef, useDebugValue } from 'react'
 import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector'
-
+import type {
+  Key,
+  Fetcher,
+  GlobalState,
+  SWRConfiguration,
+  StateDependencies,
+  CacheValue,
+  State,
+  RevalidatorOptions,
+  SWRResponse,
+  RevalidateEvent,
+  FullConfiguration,
+  SWRHook
+} from 'swr/_internal'
 import {
   defaultConfig,
-  IS_REACT_LEGACY,
-  IS_SERVER,
-  rAF,
-  useIsomorphicLayoutEffect,
   SWRGlobalState,
-  GlobalState,
   serialize,
+  createCacheHelper,
   isUndefined,
+  isEmptyCache,
+  IS_REACT_LEGACY,
+  IS_SERVER,
   UNDEFINED,
   OBJECT,
+  getTimestamp,
   isFunction,
-  createCacheHelper,
-  isEmptyCache,
-  SWRConfig as ConfigProvider,
   withArgs,
-  subscribeCallback,
-  getTimestamp,
   internalMutate,
   revalidateEvents,
-  State,
-  Fetcher,
-  Key,
-  SWRResponse,
-  RevalidatorOptions,
-  FullConfiguration,
-  SWRConfiguration,
-  SWRHook,
-  RevalidateEvent,
-  CacheValue,
-  StateDependencies
-} from 'swr/_internal'
+  useIsomorphicLayoutEffect,
+  subscribeCallback,
+  rAF,
+  ConfigProvider
+} from './utils'
 
 const WITH_DEDUPE = { dedupe: true }
 

core/utils.ts

@@ -0,0 +1,71 @@
+import utils, { InternalUtils } from 'swr/_internal'
+
+const [
+  defaultConfig,
+  SWRGlobalState,
+  serialize,
+  createCacheHelper,
+  isEmptyCache,
+  IS_REACT_LEGACY,
+  IS_SERVER,
+  UNDEFINED,
+  OBJECT,
+  getTimestamp,
+  isUndefined,
+  isFunction,
+  withArgs,
+  internalMutate,
+  revalidateEvents,
+  useIsomorphicLayoutEffect,
+  subscribeCallback,
+  rAF,
+  ConfigProvider,
+  mutate,
+  useSWRConfig
+] = [
+  utils[InternalUtils.defaultConfig],
+  utils[InternalUtils.SWRGlobalState],
+  utils[InternalUtils.serialize],
+  utils[InternalUtils.createCacheHelper],
+  utils[InternalUtils.isEmptyCache],
+  utils[InternalUtils.IS_REACT_LEGACY],
+  utils[InternalUtils.IS_SERVER],
+  utils[InternalUtils.UNDEFINED],
+  utils[InternalUtils.OBJECT],
+  utils[InternalUtils.getTimestamp],
+  utils[InternalUtils.isUndefined],
+  utils[InternalUtils.isFunction],
+  utils[InternalUtils.withArgs],
+  utils[InternalUtils.internalMutate],
+  utils[InternalUtils.revalidateEvents],
+  utils[InternalUtils.useIsomorphicLayoutEffect],
+  utils[InternalUtils.subscribeCallback],
+  utils[InternalUtils.rAF],
+  utils[InternalUtils.SWRConfig],
+  utils[InternalUtils.mutate],
+  utils[InternalUtils.useSWRConfig]
+] as const
+
+export {
+  defaultConfig,
+  SWRGlobalState,
+  serialize,
+  createCacheHelper,
+  isUndefined,
+  isEmptyCache,
+  IS_REACT_LEGACY,
+  IS_SERVER,
+  UNDEFINED,
+  OBJECT,
+  getTimestamp,
+  isFunction,
+  withArgs,
+  internalMutate,
+  revalidateEvents,
+  useIsomorphicLayoutEffect,
+  subscribeCallback,
+  rAF,
+  ConfigProvider,
+  mutate,
+  useSWRConfig
+}

immutable/index.ts

@@ -1,5 +1,5 @@
 import useSWR, { Middleware } from 'swr'
-import { withMiddleware } from 'swr/_internal'
+import { withMiddleware } from './utils'
 
 export const immutable: Middleware = useSWRNext => (key, fetcher, config) => {
   // Always override all revalidate options.

immutable/utils.ts

@@ -0,0 +1,5 @@
+import utils, { InternalUtils } from 'swr/_internal'
+
+const [withMiddleware] = [utils[InternalUtils.withMiddleware]] as const
+
+export { withMiddleware }

infinite/index.ts

@@ -4,19 +4,22 @@
 import { useRef, useCallback } from 'react'
 import useSWR, { SWRConfig } from 'swr'
 
+import type {
+  SWRHook,
+  MutatorCallback,
+  Middleware,
+  BareFetcher
+} from 'swr/_internal'
+
 import {
   isUndefined,
   isFunction,
   UNDEFINED,
   createCacheHelper,
-  SWRHook,
-  MutatorCallback,
-  Middleware,
-  BareFetcher,
   useIsomorphicLayoutEffect,
   serialize,
   withMiddleware
-} from 'swr/_internal'
+} from './utils'
 
 import type {
   SWRInfiniteConfiguration,

infinite/types.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   SWRConfiguration,
   SWRResponse,
   Arguments,

infinite/utils.ts

@@ -0,0 +1,29 @@
+import utils, { InternalUtils } from 'swr/_internal'
+
+const [
+  isUndefined,
+  isFunction,
+  UNDEFINED,
+  createCacheHelper,
+  useIsomorphicLayoutEffect,
+  serialize,
+  withMiddleware
+] = [
+  utils[InternalUtils.isUndefined],
+  utils[InternalUtils.isFunction],
+  utils[InternalUtils.UNDEFINED],
+  utils[InternalUtils.createCacheHelper],
+  utils[InternalUtils.useIsomorphicLayoutEffect],
+  utils[InternalUtils.serialize],
+  utils[InternalUtils.withMiddleware]
+] as const
+
+export {
+  isUndefined,
+  isFunction,
+  UNDEFINED,
+  createCacheHelper,
+  useIsomorphicLayoutEffect,
+  serialize,
+  withMiddleware
+}

mutation/index.ts

@@ -1,16 +1,17 @@
 import { useCallback, useRef } from 'react'
 import useSWR, { useSWRConfig } from 'swr'
+
 import {
   serialize,
   useStateWithDeps,
   withMiddleware,
   useIsomorphicLayoutEffect,
   UNDEFINED,
-  getTimestamp,
-  Middleware,
-  Key
-} from 'swr/_internal'
-import {
+  getTimestamp
+} from './utils'
+
+import type { Middleware, Key } from 'swr/_internal'
+import type {
   SWRMutationConfiguration,
   SWRMutationResponse,
   SWRMutationHook,