@depup/reduxjs__toolkit 2.12.0-depup.28

package/src/query/react/constants.ts

@@ -0,0 +1,2 @@
+export const UNINITIALIZED_VALUE = Symbol()
+export type UninitializedValue = typeof UNINITIALIZED_VALUE

package/src/query/react/index.ts

@@ -0,0 +1,45 @@
+// This must remain here so that the `mangleErrors.cjs` build script
+// does not have to import this into each source file it rewrites.
+import { formatProdErrorMessage } from '@reduxjs/toolkit'
+
+import { buildCreateApi, coreModule } from './rtkqImports'
+import { reactHooksModule, reactHooksModuleName } from './module'
+
+export * from '@reduxjs/toolkit/query'
+export { ApiProvider } from './ApiProvider'
+
+const createApi = /* @__PURE__ */ buildCreateApi(
+  coreModule(),
+  reactHooksModule(),
+)
+
+export type {
+  TypedUseMutationResult,
+  TypedUseQueryHookResult,
+  TypedUseQueryStateResult,
+  TypedUseQuerySubscriptionResult,
+  TypedLazyQueryTrigger,
+  TypedUseLazyQuery,
+  TypedUseMutation,
+  TypedMutationTrigger,
+  TypedQueryStateSelector,
+  TypedUseQueryState,
+  TypedUseQuery,
+  TypedUseQuerySubscription,
+  TypedUseLazyQuerySubscription,
+  TypedUseQueryStateOptions,
+  TypedUseLazyQueryStateResult,
+  TypedUseInfiniteQuery,
+  TypedUseInfiniteQueryHookResult,
+  TypedUseInfiniteQueryStateResult,
+  TypedUseInfiniteQuerySubscriptionResult,
+  TypedUseInfiniteQueryStateOptions,
+  TypedInfiniteQueryStateSelector,
+  TypedUseInfiniteQuerySubscription,
+  TypedUseInfiniteQueryState,
+  TypedLazyInfiniteQueryTrigger,
+  TypedUseQuerySubscriptionOptions,
+  TypedUseMutationStateOptions,
+} from './buildHooks'
+export { UNINITIALIZED_VALUE } from './constants'
+export { createApi, reactHooksModule, reactHooksModuleName }

package/src/query/react/module.ts

@@ -0,0 +1,275 @@
+import type {
+  Api,
+  BaseQueryFn,
+  EndpointDefinitions,
+  InfiniteQueryDefinition,
+  Module,
+  MutationDefinition,
+  PrefetchOptions,
+  QueryArgFrom,
+  QueryDefinition,
+  QueryKeys,
+} from '@reduxjs/toolkit/query'
+import {
+  batch as rrBatch,
+  useDispatch as rrUseDispatch,
+  useSelector as rrUseSelector,
+  useStore as rrUseStore,
+} from 'react-redux'
+import type { CreateSelectorFunction } from 'reselect'
+import { createSelector as _createSelector } from 'reselect'
+import {
+  isInfiniteQueryDefinition,
+  isMutationDefinition,
+  isQueryDefinition,
+} from '../endpointDefinitions'
+import { safeAssign } from '../tsHelpers'
+import { capitalize, countObjectKeys } from '../utils'
+import type {
+  InfiniteQueryHooks,
+  MutationHooks,
+  QueryHooks,
+} from './buildHooks'
+import { buildHooks } from './buildHooks'
+import type { HooksWithUniqueNames } from './namedHooks'
+
+export const reactHooksModuleName = /* @__PURE__ */ Symbol()
+export type ReactHooksModule = typeof reactHooksModuleName
+
+declare module '@reduxjs/toolkit/query' {
+  export interface ApiModules<
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    BaseQuery extends BaseQueryFn,
+    Definitions extends EndpointDefinitions,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ReducerPath extends string,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    TagTypes extends string,
+  > {
+    [reactHooksModuleName]: {
+      /**
+       *  Endpoints based on the input endpoints provided to `createApi`, containing `select`, `hooks` and `action matchers`.
+       */
+      endpoints: {
+        [K in keyof Definitions]: Definitions[K] extends QueryDefinition<
+          any,
+          any,
+          any,
+          any,
+          any
+        >
+          ? QueryHooks<Definitions[K]>
+          : Definitions[K] extends MutationDefinition<any, any, any, any, any>
+            ? MutationHooks<Definitions[K]>
+            : Definitions[K] extends InfiniteQueryDefinition<
+                  any,
+                  any,
+                  any,
+                  any,
+                  any
+                >
+              ? InfiniteQueryHooks<Definitions[K]>
+              : never
+      }
+      /**
+       * A hook that accepts a string endpoint name, and provides a callback that when called, pre-fetches the data for that endpoint.
+       */
+      usePrefetch<EndpointName extends QueryKeys<Definitions>>(
+        endpointName: EndpointName,
+        options?: PrefetchOptions,
+      ): (
+        arg: QueryArgFrom<Definitions[EndpointName]>,
+        options?: PrefetchOptions,
+      ) => void
+    } & HooksWithUniqueNames<Definitions>
+  }
+}
+
+type RR = typeof import('react-redux')
+
+export interface ReactHooksModuleOptions {
+  /**
+   * The hooks from React Redux to be used
+   */
+  hooks?: {
+    /**
+     * The version of the `useDispatch` hook to be used
+     */
+    useDispatch: RR['useDispatch']
+    /**
+     * The version of the `useSelector` hook to be used
+     */
+    useSelector: RR['useSelector']
+    /**
+     * The version of the `useStore` hook to be used
+     */
+    useStore: RR['useStore']
+  }
+  /**
+   * The version of the `batchedUpdates` function to be used
+   */
+  batch?: RR['batch']
+  /**
+   * Enables performing asynchronous tasks immediately within a render.
+   *
+   * @example
+   *
+   * ```ts
+   * import {
+   *   buildCreateApi,
+   *   coreModule,
+   *   reactHooksModule
+   * } from '@reduxjs/toolkit/query/react'
+   *
+   * const createApi = buildCreateApi(
+   *   coreModule(),
+   *   reactHooksModule({ unstable__sideEffectsInRender: true })
+   * )
+   * ```
+   */
+  unstable__sideEffectsInRender?: boolean
+  /**
+   * A selector creator (usually from `reselect`, or matching the same signature)
+   */
+  createSelector?: CreateSelectorFunction<any, any, any>
+}
+
+/**
+ * Creates a module that generates react hooks from endpoints, for use with `buildCreateApi`.
+ *
+ *  @example
+ * ```ts
+ * const MyContext = React.createContext<ReactReduxContextValue | null>(null);
+ * const customCreateApi = buildCreateApi(
+ *   coreModule(),
+ *   reactHooksModule({
+ *     hooks: {
+ *       useDispatch: createDispatchHook(MyContext),
+ *       useSelector: createSelectorHook(MyContext),
+ *       useStore: createStoreHook(MyContext)
+ *     }
+ *   })
+ * );
+ * ```
+ *
+ * @returns A module for use with `buildCreateApi`
+ */
+export const reactHooksModule = ({
+  batch = rrBatch,
+  hooks = {
+    useDispatch: rrUseDispatch,
+    useSelector: rrUseSelector,
+    useStore: rrUseStore,
+  },
+  createSelector = _createSelector,
+  unstable__sideEffectsInRender = false,
+  ...rest
+}: ReactHooksModuleOptions = {}): Module<ReactHooksModule> => {
+  if (process.env.NODE_ENV !== 'production') {
+    const hookNames = ['useDispatch', 'useSelector', 'useStore'] as const
+    let warned = false
+    for (const hookName of hookNames) {
+      // warn for old hook options
+      if (countObjectKeys(rest) > 0) {
+        if ((rest as Partial<typeof hooks>)[hookName]) {
+          if (!warned) {
+            console.warn(
+              'As of RTK 2.0, the hooks now need to be specified as one object, provided under a `hooks` key:' +
+                '\n`reactHooksModule({ hooks: { useDispatch, useSelector, useStore } })`',
+            )
+            warned = true
+          }
+        }
+        // migrate
+        // @ts-ignore
+        hooks[hookName] = rest[hookName]
+      }
+      // then make sure we have them all
+      if (typeof hooks[hookName] !== 'function') {
+        throw new Error(
+          `When using custom hooks for context, all ${
+            hookNames.length
+          } hooks need to be provided: ${hookNames.join(
+            ', ',
+          )}.\nHook ${hookName} was either not provided or not a function.`,
+        )
+      }
+    }
+  }
+
+  return {
+    name: reactHooksModuleName,
+    init(api, { serializeQueryArgs }, context) {
+      const anyApi = api as any as Api<
+        any,
+        Record<string, any>,
+        any,
+        any,
+        ReactHooksModule
+      >
+      const {
+        buildQueryHooks,
+        buildInfiniteQueryHooks,
+        buildMutationHook,
+        usePrefetch,
+      } = buildHooks({
+        api,
+        moduleOptions: {
+          batch,
+          hooks,
+          unstable__sideEffectsInRender,
+          createSelector,
+        },
+        serializeQueryArgs,
+        context,
+      })
+      safeAssign(anyApi, { usePrefetch })
+      safeAssign(context, { batch })
+
+      return {
+        injectEndpoint(endpointName, definition) {
+          if (isQueryDefinition(definition)) {
+            const {
+              useQuery,
+              useLazyQuery,
+              useLazyQuerySubscription,
+              useQueryState,
+              useQuerySubscription,
+            } = buildQueryHooks(endpointName)
+            safeAssign(anyApi.endpoints[endpointName], {
+              useQuery,
+              useLazyQuery,
+              useLazyQuerySubscription,
+              useQueryState,
+              useQuerySubscription,
+            })
+            ;(api as any)[`use${capitalize(endpointName)}Query`] = useQuery
+            ;(api as any)[`useLazy${capitalize(endpointName)}Query`] =
+              useLazyQuery
+          }
+          if (isMutationDefinition(definition)) {
+            const useMutation = buildMutationHook(endpointName)
+            safeAssign(anyApi.endpoints[endpointName], {
+              useMutation,
+            })
+            ;(api as any)[`use${capitalize(endpointName)}Mutation`] =
+              useMutation
+          } else if (isInfiniteQueryDefinition(definition)) {
+            const {
+              useInfiniteQuery,
+              useInfiniteQuerySubscription,
+              useInfiniteQueryState,
+            } = buildInfiniteQueryHooks(endpointName)
+            safeAssign(anyApi.endpoints[endpointName], {
+              useInfiniteQuery,
+              useInfiniteQuerySubscription,
+              useInfiniteQueryState,
+            })
+            ;(api as any)[`use${capitalize(endpointName)}InfiniteQuery`] =
+              useInfiniteQuery
+          }
+        },
+      }
+    },
+  }
+}

package/src/query/react/namedHooks.ts

@@ -0,0 +1,59 @@
+import type {
+  DefinitionType,
+  EndpointDefinitions,
+  MutationDefinition,
+  QueryDefinition,
+  InfiniteQueryDefinition,
+} from '@reduxjs/toolkit/query'
+import type {
+  UseInfiniteQuery,
+  UseLazyQuery,
+  UseMutation,
+  UseQuery,
+} from './buildHooks'
+
+type QueryHookNames<Definitions extends EndpointDefinitions> = {
+  [K in keyof Definitions as Definitions[K] extends {
+    type: DefinitionType.query
+  }
+    ? `use${Capitalize<K & string>}Query`
+    : never]: UseQuery<
+    Extract<Definitions[K], QueryDefinition<any, any, any, any>>
+  >
+}
+
+type LazyQueryHookNames<Definitions extends EndpointDefinitions> = {
+  [K in keyof Definitions as Definitions[K] extends {
+    type: DefinitionType.query
+  }
+    ? `useLazy${Capitalize<K & string>}Query`
+    : never]: UseLazyQuery<
+    Extract<Definitions[K], QueryDefinition<any, any, any, any>>
+  >
+}
+
+type InfiniteQueryHookNames<Definitions extends EndpointDefinitions> = {
+  [K in keyof Definitions as Definitions[K] extends {
+    type: DefinitionType.infinitequery
+  }
+    ? `use${Capitalize<K & string>}InfiniteQuery`
+    : never]: UseInfiniteQuery<
+    Extract<Definitions[K], InfiniteQueryDefinition<any, any, any, any, any>>
+  >
+}
+
+type MutationHookNames<Definitions extends EndpointDefinitions> = {
+  [K in keyof Definitions as Definitions[K] extends {
+    type: DefinitionType.mutation
+  }
+    ? `use${Capitalize<K & string>}Mutation`
+    : never]: UseMutation<
+    Extract<Definitions[K], MutationDefinition<any, any, any, any>>
+  >
+}
+
+export type HooksWithUniqueNames<Definitions extends EndpointDefinitions> =
+  QueryHookNames<Definitions> &
+    LazyQueryHookNames<Definitions> &
+    InfiniteQueryHookNames<Definitions> &
+    MutationHookNames<Definitions>

package/src/query/react/reactImports.ts

@@ -0,0 +1,10 @@
+export {
+  useEffect,
+  useRef,
+  useMemo,
+  useContext,
+  useCallback,
+  useDebugValue,
+  useLayoutEffect,
+  useState,
+} from 'react'

package/src/query/react/reactReduxImports.ts

@@ -0,0 +1 @@
+export { shallowEqual, Provider, ReactReduxContext } from 'react-redux'

package/src/query/react/rtkqImports.ts

@@ -0,0 +1,8 @@
+export {
+  buildCreateApi,
+  coreModule,
+  copyWithStructuralSharing,
+  setupListeners,
+  QueryStatus,
+  skipToken,
+} from '@reduxjs/toolkit/query'

package/src/query/react/useSerializedStableValue.ts

@@ -0,0 +1,17 @@
+import { useEffect, useRef, useMemo } from './reactImports'
+import { copyWithStructuralSharing } from './rtkqImports'
+
+export function useStableQueryArgs<T>(queryArgs: T) {
+  const cache = useRef(queryArgs)
+  const copy = useMemo(
+    () => copyWithStructuralSharing(cache.current, queryArgs),
+    [queryArgs],
+  )
+  useEffect(() => {
+    if (cache.current !== copy) {
+      cache.current = copy
+    }
+  }, [copy])
+
+  return copy
+}

package/src/query/react/useShallowStableValue.ts

@@ -0,0 +1,13 @@
+import { useEffect, useRef } from './reactImports'
+import { shallowEqual } from './reactReduxImports'
+
+export function useShallowStableValue<T>(value: T) {
+  const cache = useRef(value)
+  useEffect(() => {
+    if (!shallowEqual(cache.current, value)) {
+      cache.current = value
+    }
+  }, [value])
+
+  return shallowEqual(cache.current, value) ? cache.current : value
+}

package/src/query/retry.ts

@@ -0,0 +1,233 @@
+import type {
+  BaseQueryApi,
+  BaseQueryArg,
+  BaseQueryEnhancer,
+  BaseQueryError,
+  BaseQueryExtraOptions,
+  BaseQueryFn,
+  BaseQueryMeta,
+} from './baseQueryTypes'
+import type { FetchBaseQueryError } from './fetchBaseQuery'
+import { HandledError } from './HandledError'
+
+/**
+ * Exponential backoff based on the attempt number.
+ *
+ * @remarks
+ * 1. 600ms * random(0.4, 1.4)
+ * 2. 1200ms * random(0.4, 1.4)
+ * 3. 2400ms * random(0.4, 1.4)
+ * 4. 4800ms * random(0.4, 1.4)
+ * 5. 9600ms * random(0.4, 1.4)
+ *
+ * @param attempt - Current attempt
+ * @param maxRetries - Maximum number of retries
+ */
+async function defaultBackoff(
+  attempt: number = 0,
+  maxRetries: number = 5,
+  signal?: AbortSignal,
+) {
+  const attempts = Math.min(attempt, maxRetries)
+
+  const timeout = ~~((Math.random() + 0.4) * (300 << attempts)) // Force a positive int in the case we make this an option
+
+  await new Promise<void>((resolve, reject) => {
+    const timeoutId = setTimeout(() => resolve(), timeout)
+
+    // If signal is provided and gets aborted, clear timeout and reject
+    if (signal) {
+      const abortHandler = () => {
+        clearTimeout(timeoutId)
+        reject(new Error('Aborted'))
+      }
+
+      // Check if already aborted
+      if (signal.aborted) {
+        clearTimeout(timeoutId)
+        reject(new Error('Aborted'))
+      } else {
+        signal.addEventListener('abort', abortHandler, { once: true })
+      }
+    }
+  })
+}
+
+type RetryConditionFunction = (
+  error: BaseQueryError<BaseQueryFn>,
+  args: BaseQueryArg<BaseQueryFn>,
+  extraArgs: {
+    attempt: number
+    baseQueryApi: BaseQueryApi
+    extraOptions: BaseQueryExtraOptions<BaseQueryFn> & RetryOptions
+  },
+) => boolean
+
+export type RetryOptions = {
+  /**
+   * Function used to determine delay between retries
+   */
+  backoff?: (
+    attempt: number,
+    maxRetries: number,
+    signal?: AbortSignal,
+  ) => Promise<void>
+} & (
+  | {
+      /**
+       * How many times the query will be retried (default: 5)
+       */
+      maxRetries?: number
+      retryCondition?: undefined
+    }
+  | {
+      /**
+       * Callback to determine if a retry should be attempted.
+       * Return `true` for another retry and `false` to quit trying prematurely.
+       */
+      retryCondition?: RetryConditionFunction
+      maxRetries?: undefined
+    }
+)
+
+function fail<BaseQuery extends BaseQueryFn = BaseQueryFn>(
+  error: BaseQueryError<BaseQuery>,
+  meta?: BaseQueryMeta<BaseQuery>,
+): never {
+  throw Object.assign(new HandledError({ error, meta }), {
+    throwImmediately: true,
+  })
+}
+
+/**
+ * Checks if the abort signal is aborted and fails immediately if so.
+ * Used to exit retry loops cleanly when a request is aborted.
+ */
+function failIfAborted(signal: AbortSignal): void {
+  if (signal.aborted) {
+    fail({ status: 'CUSTOM_ERROR', error: 'Aborted' })
+  }
+}
+
+const EMPTY_OPTIONS = {}
+
+const retryWithBackoff: BaseQueryEnhancer<
+  unknown,
+  RetryOptions,
+  RetryOptions | void
+> = (baseQuery, defaultOptions) => async (args, api, extraOptions) => {
+  // We need to figure out `maxRetries` before we define `defaultRetryCondition.
+  // This is probably goofy, but ought to work.
+  // Put our defaults in one array, filter out undefineds, grab the last value.
+  const possibleMaxRetries: number[] = [
+    5,
+    ((defaultOptions as any) || EMPTY_OPTIONS).maxRetries,
+    ((extraOptions as any) || EMPTY_OPTIONS).maxRetries,
+  ].filter((x) => x !== undefined)
+  const [maxRetries] = possibleMaxRetries.slice(-1)
+
+  const defaultRetryCondition: RetryConditionFunction = (_, __, { attempt }) =>
+    attempt <= maxRetries
+
+  const options: {
+    maxRetries: number
+    backoff: typeof defaultBackoff
+    retryCondition: typeof defaultRetryCondition
+  } = {
+    maxRetries,
+    backoff: defaultBackoff,
+    retryCondition: defaultRetryCondition,
+    ...defaultOptions,
+    ...extraOptions,
+  }
+  let retry = 0
+
+  while (true) {
+    // Check if aborted before each attempt
+    failIfAborted(api.signal)
+
+    try {
+      const result = await baseQuery(args, api, extraOptions)
+      // baseQueries _should_ return an error property, so we should check for that and throw it to continue retrying
+      if (result.error) {
+        throw new HandledError(result)
+      }
+      return result
+    } catch (e: any) {
+      retry++
+
+      if (e.throwImmediately) {
+        if (e instanceof HandledError) {
+          return e.value
+        }
+
+        // We don't know what this is, so we have to rethrow it
+        throw e
+      }
+
+      if (e instanceof HandledError) {
+        if (
+          !options.retryCondition(e.value.error as FetchBaseQueryError, args, {
+            attempt: retry,
+            baseQueryApi: api,
+            extraOptions,
+          })
+        ) {
+          return e.value // Max retries for expected error
+        }
+      } else {
+        // For unexpected errors, respect maxRetries
+        if (retry > options.maxRetries) {
+          // Return the error as a proper error response instead of throwing
+          return { error: e }
+        }
+      }
+
+      // Check if aborted before backoff
+      failIfAborted(api.signal)
+
+      try {
+        await options.backoff(retry, options.maxRetries, api.signal)
+      } catch (backoffError) {
+        // If backoff was aborted, exit the retry loop
+        failIfAborted(api.signal)
+        // Otherwise, rethrow the backoff error
+        throw backoffError
+      }
+    }
+  }
+}
+
+/**
+ * A utility that can wrap `baseQuery` in the API definition to provide retries with a basic exponential backoff.
+ *
+ * @example
+ *
+ * ```ts
+ * // codeblock-meta title="Retry every request 5 times by default"
+ * import { createApi, fetchBaseQuery, retry } from '@reduxjs/toolkit/query/react'
+ * interface Post {
+ *   id: number
+ *   name: string
+ * }
+ * type PostsResponse = Post[]
+ *
+ * // maxRetries: 5 is the default, and can be omitted. Shown for documentation purposes.
+ * const staggeredBaseQuery = retry(fetchBaseQuery({ baseUrl: '/' }), { maxRetries: 5 });
+ * export const api = createApi({
+ *   baseQuery: staggeredBaseQuery,
+ *   endpoints: (build) => ({
+ *     getPosts: build.query<PostsResponse, void>({
+ *       query: () => ({ url: 'posts' }),
+ *     }),
+ *     getPost: build.query<PostsResponse, string>({
+ *       query: (id) => ({ url: `post/${id}` }),
+ *       extraOptions: { maxRetries: 8 }, // You can override the retry behavior on each endpoint
+ *     }),
+ *   }),
+ * });
+ *
+ * export const { useGetPostsQuery, useGetPostQuery } = api;
+ * ```
+ */
+export const retry = /* @__PURE__ */ Object.assign(retryWithBackoff, { fail })