@depup/reduxjs__toolkit 2.12.0-depup.28

package/src/nanoid.ts

@@ -0,0 +1,20 @@
+// Borrowed from https://github.com/ai/nanoid/blob/3.0.2/non-secure/index.js
+// This alphabet uses `A-Za-z0-9_-` symbols. A genetic algorithm helped
+// optimize the gzip compression for this alphabet.
+let urlAlphabet =
+  'ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW'
+
+/**
+ *
+ * @public
+ */
+export let nanoid = (size = 21) => {
+  let id = ''
+  // A compact alternative for `for (var i = 0; i < step; i++)`.
+  let i = size
+  while (i--) {
+    // `| 0` is more compact and faster than `Math.floor()`.
+    id += urlAlphabet[(Math.random() * 64) | 0]
+  }
+  return id
+}

package/src/query/HandledError.ts

@@ -0,0 +1,6 @@
+export class HandledError {
+  constructor(
+    public readonly value: any,
+    public readonly meta: any = undefined,
+  ) {}
+}

package/src/query/apiTypes.ts

@@ -0,0 +1,120 @@
+import type { UnknownAction } from '@reduxjs/toolkit'
+import type { BaseQueryFn } from './baseQueryTypes'
+import type { CombinedState, CoreModule } from './core/index'
+import type { ApiModules } from './core/module'
+import type { CreateApiOptions } from './createApi'
+import type {
+  EndpointBuilder,
+  EndpointDefinition,
+  EndpointDefinitions,
+  UpdateDefinitions,
+} from './endpointDefinitions'
+import type { UnionToIntersection, WithRequiredProp } from './tsHelpers'
+
+export type ModuleName = keyof ApiModules<any, any, any, any>
+
+export type Module<Name extends ModuleName> = {
+  name: Name
+  init<
+    BaseQuery extends BaseQueryFn,
+    Definitions extends EndpointDefinitions,
+    ReducerPath extends string,
+    TagTypes extends string,
+  >(
+    api: Api<BaseQuery, EndpointDefinitions, ReducerPath, TagTypes, ModuleName>,
+    options: WithRequiredProp<
+      CreateApiOptions<BaseQuery, Definitions, ReducerPath, TagTypes>,
+      | 'reducerPath'
+      | 'serializeQueryArgs'
+      | 'keepUnusedDataFor'
+      | 'refetchOnMountOrArgChange'
+      | 'refetchOnFocus'
+      | 'refetchOnReconnect'
+      | 'invalidationBehavior'
+      | 'tagTypes'
+    >,
+    context: ApiContext<Definitions>,
+  ): {
+    injectEndpoint(
+      endpointName: string,
+      definition: EndpointDefinition<any, any, any, any>,
+    ): void
+  }
+}
+
+export interface ApiContext<Definitions extends EndpointDefinitions> {
+  apiUid: string
+  endpointDefinitions: Definitions
+  batch(cb: () => void): void
+  extractRehydrationInfo: (
+    action: UnknownAction,
+  ) => CombinedState<any, any, any> | undefined
+  hasRehydrationInfo: (action: UnknownAction) => boolean
+}
+
+export const getEndpointDefinition = <
+  Definitions extends EndpointDefinitions,
+  EndpointName extends keyof Definitions,
+>(
+  context: ApiContext<Definitions>,
+  endpointName: EndpointName,
+) => context.endpointDefinitions[endpointName]
+
+export type Api<
+  BaseQuery extends BaseQueryFn,
+  Definitions extends EndpointDefinitions,
+  ReducerPath extends string,
+  TagTypes extends string,
+  Enhancers extends ModuleName = CoreModule,
+> = UnionToIntersection<
+  ApiModules<BaseQuery, Definitions, ReducerPath, TagTypes>[Enhancers]
+> & {
+  /**
+   * A function to inject the endpoints into the original API, but also give you that same API with correct types for these endpoints back. Useful with code-splitting.
+   */
+  injectEndpoints<NewDefinitions extends EndpointDefinitions>(_: {
+    endpoints: (
+      build: EndpointBuilder<BaseQuery, TagTypes, ReducerPath>,
+    ) => NewDefinitions
+    /**
+     * Optionally allows endpoints to be overridden if defined by multiple `injectEndpoints` calls.
+     *
+     * If set to `true`, will override existing endpoints with the new definition.
+     * If set to `'throw'`, will throw an error if an endpoint is redefined with a different definition.
+     * If set to `false` (or unset), will not override existing endpoints with the new definition, and log a warning in development.
+     */
+    overrideExisting?: boolean | 'throw'
+  }): Api<
+    BaseQuery,
+    Definitions & NewDefinitions,
+    ReducerPath,
+    TagTypes,
+    Enhancers
+  >
+  /**
+   *A function to enhance a generated API with additional information. Useful with code-generation.
+   */
+  enhanceEndpoints<
+    NewTagTypes extends string = never,
+    NewDefinitions extends EndpointDefinitions = never,
+  >(_: {
+    addTagTypes?: readonly NewTagTypes[]
+    endpoints?: UpdateDefinitions<
+      Definitions,
+      TagTypes | NoInfer<NewTagTypes>,
+      NewDefinitions
+    > extends infer NewDefinitions
+      ? {
+          [K in keyof NewDefinitions]?:
+            | Partial<NewDefinitions[K]>
+            | ((definition: NewDefinitions[K]) => void)
+        }
+      : never
+  }): Api<
+    BaseQuery,
+    UpdateDefinitions<Definitions, TagTypes | NewTagTypes, NewDefinitions>,
+    ReducerPath,
+    TagTypes | NewTagTypes,
+    Enhancers
+  >
+}

package/src/query/baseQueryTypes.ts

@@ -0,0 +1,101 @@
+import type { ThunkDispatch } from '@reduxjs/toolkit'
+import type { MaybePromise, UnwrapPromise } from './tsHelpers'
+
+export interface BaseQueryApi {
+  signal: AbortSignal
+  abort: (reason?: string) => void
+  dispatch: ThunkDispatch<any, any, any>
+  getState: () => unknown
+  extra: unknown
+  endpoint: string
+  type: 'query' | 'mutation'
+  /**
+   * Only available for queries: indicates if a query has been forced,
+   * i.e. it would have been fetched even if there would already be a cache entry
+   * (this does not mean that there is already a cache entry though!)
+   *
+   * This can be used to for example add a `Cache-Control: no-cache` header for
+   * invalidated queries.
+   */
+  forced?: boolean
+  /**
+   * Only available for queries: the cache key that was used to store the query result
+   */
+  queryCacheKey?: string
+}
+
+export type QueryReturnValue<T = unknown, E = unknown, M = unknown> =
+  | {
+      error: E
+      data?: undefined
+      meta?: M
+    }
+  | {
+      error?: undefined
+      data: T
+      meta?: M
+    }
+
+export type BaseQueryFn<
+  Args = any,
+  Result = unknown,
+  Error = unknown,
+  DefinitionExtraOptions = {},
+  Meta = {},
+> = (
+  args: Args,
+  api: BaseQueryApi,
+  extraOptions: DefinitionExtraOptions,
+) => MaybePromise<QueryReturnValue<Result, Error, Meta>>
+
+export type BaseQueryEnhancer<
+  AdditionalArgs = unknown,
+  AdditionalDefinitionExtraOptions = unknown,
+  Config = void,
+> = <BaseQuery extends BaseQueryFn>(
+  baseQuery: BaseQuery,
+  config: Config,
+) => BaseQueryFn<
+  BaseQueryArg<BaseQuery> & AdditionalArgs,
+  BaseQueryResult<BaseQuery>,
+  BaseQueryError<BaseQuery>,
+  BaseQueryExtraOptions<BaseQuery> & AdditionalDefinitionExtraOptions,
+  NonNullable<BaseQueryMeta<BaseQuery>>
+>
+
+/**
+ * @public
+ */
+export type BaseQueryResult<BaseQuery extends BaseQueryFn> =
+  UnwrapPromise<ReturnType<BaseQuery>> extends infer Unwrapped
+    ? Unwrapped extends { data: any }
+      ? Unwrapped['data']
+      : never
+    : never
+
+/**
+ * @public
+ */
+export type BaseQueryMeta<BaseQuery extends BaseQueryFn> = UnwrapPromise<
+  ReturnType<BaseQuery>
+>['meta']
+
+/**
+ * @public
+ */
+export type BaseQueryError<BaseQuery extends BaseQueryFn> = Exclude<
+  UnwrapPromise<ReturnType<BaseQuery>>,
+  { error?: undefined }
+>['error']
+
+/**
+ * @public
+ */
+export type BaseQueryArg<T extends (arg: any, ...args: any[]) => any> =
+  T extends (arg: infer A, ...args: any[]) => any ? A : any
+
+/**
+ * @public
+ */
+export type BaseQueryExtraOptions<BaseQuery extends BaseQueryFn> =
+  Parameters<BaseQuery>[2]

package/src/query/core/apiState.ts

@@ -0,0 +1,377 @@
+import type { SerializedError } from '@reduxjs/toolkit'
+import type { BaseQueryError } from '../baseQueryTypes'
+import type {
+  BaseEndpointDefinition,
+  EndpointDefinitions,
+  FullTagDescription,
+  InfiniteQueryDefinition,
+  MutationDefinition,
+  PageParamFrom,
+  QueryArgFromAnyQuery,
+  QueryDefinition,
+  ResultTypeFrom,
+} from '../endpointDefinitions'
+import type { Id, WithRequiredProp } from '../tsHelpers'
+
+export type QueryCacheKey = string & { _type: 'queryCacheKey' }
+export type QuerySubstateIdentifier = { queryCacheKey: QueryCacheKey }
+export type MutationSubstateIdentifier =
+  | { requestId: string; fixedCacheKey?: string }
+  | { requestId?: string; fixedCacheKey: string }
+
+export type RefetchConfigOptions = {
+  refetchOnMountOrArgChange: boolean | number
+  refetchOnReconnect: boolean
+  refetchOnFocus: boolean
+}
+
+export type InfiniteQueryConfigOptions<DataType, PageParam, QueryArg> = {
+  /**
+   * The initial page parameter to use for the first page fetch.
+   */
+  initialPageParam: PageParam
+  /**
+   * This function is required to automatically get the next cursor for infinite queries.
+   * The result will also be used to determine the value of `hasNextPage`.
+   */
+  getNextPageParam: (
+    lastPage: DataType,
+    allPages: Array<DataType>,
+    lastPageParam: PageParam,
+    allPageParams: Array<PageParam>,
+    queryArg: QueryArg,
+  ) => PageParam | undefined | null
+  /**
+   * This function can be set to automatically get the previous cursor for infinite queries.
+   * The result will also be used to determine the value of `hasPreviousPage`.
+   */
+  getPreviousPageParam?: (
+    firstPage: DataType,
+    allPages: Array<DataType>,
+    firstPageParam: PageParam,
+    allPageParams: Array<PageParam>,
+    queryArg: QueryArg,
+  ) => PageParam | undefined | null
+  /**
+   * If specified, only keep this many pages in cache at once.
+   * If additional pages are fetched, older pages in the other
+   * direction will be dropped from the cache.
+   */
+  maxPages?: number
+  /**
+   * Defaults to `true`. When this is `true` and an infinite query endpoint is refetched
+   * (due to tag invalidation, polling, arg change configuration, or manual refetching),
+   * RTK Query will try to sequentially refetch all pages currently in the cache.
+   * When `false` only the first page will be refetched.
+   */
+  refetchCachedPages?: boolean
+}
+
+export type InfiniteData<DataType, PageParam> = {
+  pages: Array<DataType>
+  pageParams: Array<PageParam>
+}
+
+// NOTE: DO NOT import and use this for runtime comparisons internally,
+// except in the RTKQ React package. Use the string versions just below this.
+// ESBuild auto-inlines TS enums, which bloats our bundle with many repeated
+// constants like "initialized":
+// https://github.com/evanw/esbuild/releases/tag/v0.14.7
+// We still have to use this in the React package since we don't publicly export
+// the string constants below.
+/**
+ * Strings describing the query state at any given time.
+ */
+export enum QueryStatus {
+  uninitialized = 'uninitialized',
+  pending = 'pending',
+  fulfilled = 'fulfilled',
+  rejected = 'rejected',
+}
+
+// Use these string constants for runtime comparisons internally
+export const STATUS_UNINITIALIZED = QueryStatus.uninitialized
+export const STATUS_PENDING = QueryStatus.pending
+export const STATUS_FULFILLED = QueryStatus.fulfilled
+export const STATUS_REJECTED = QueryStatus.rejected
+
+export type RequestStatusFlags =
+  | {
+      status: QueryStatus.uninitialized
+      isUninitialized: true
+      isLoading: false
+      isSuccess: false
+      isError: false
+    }
+  | {
+      status: QueryStatus.pending
+      isUninitialized: false
+      isLoading: true
+      isSuccess: false
+      isError: false
+    }
+  | {
+      status: QueryStatus.fulfilled
+      isUninitialized: false
+      isLoading: false
+      isSuccess: true
+      isError: false
+    }
+  | {
+      status: QueryStatus.rejected
+      isUninitialized: false
+      isLoading: false
+      isSuccess: false
+      isError: true
+    }
+
+export function getRequestStatusFlags(status: QueryStatus): RequestStatusFlags {
+  return {
+    status,
+    isUninitialized: status === STATUS_UNINITIALIZED,
+    isLoading: status === STATUS_PENDING,
+    isSuccess: status === STATUS_FULFILLED,
+    isError: status === STATUS_REJECTED,
+  } as any
+}
+
+/**
+ * @public
+ */
+export type SubscriptionOptions = {
+  /**
+   * How frequently to automatically re-fetch data (in milliseconds). Defaults to `0` (off).
+   */
+  pollingInterval?: number
+  /**
+   *  Defaults to 'false'. This setting allows you to control whether RTK Query will continue polling if the window is not focused.
+   *
+   *  If pollingInterval is not set or set to 0, this **will not be evaluated** until pollingInterval is greater than 0.
+   *
+   *  Note: requires [`setupListeners`](./setupListeners) to have been called.
+   */
+  skipPollingIfUnfocused?: boolean
+  /**
+   * Defaults to `false`. This setting allows you to control whether RTK Query will try to refetch all subscribed queries after regaining a network connection.
+   *
+   * If you specify this option alongside `skip: true`, this **will not be evaluated** until `skip` is false.
+   *
+   * Note: requires [`setupListeners`](./setupListeners) to have been called.
+   */
+  refetchOnReconnect?: boolean
+  /**
+   * Defaults to `false`. This setting allows you to control whether RTK Query will try to refetch all subscribed queries after the application window regains focus.
+   *
+   * If you specify this option alongside `skip: true`, this **will not be evaluated** until `skip` is false.
+   *
+   * Note: requires [`setupListeners`](./setupListeners) to have been called.
+   */
+  refetchOnFocus?: boolean
+}
+export type SubscribersInternal = Map<string, SubscriptionOptions>
+export type Subscribers = { [requestId: string]: SubscriptionOptions }
+export type QueryKeys<Definitions extends EndpointDefinitions> = {
+  [K in keyof Definitions]: Definitions[K] extends QueryDefinition<
+    any,
+    any,
+    any,
+    any
+  >
+    ? K
+    : never
+}[keyof Definitions]
+
+export type InfiniteQueryKeys<Definitions extends EndpointDefinitions> = {
+  [K in keyof Definitions]: Definitions[K] extends InfiniteQueryDefinition<
+    any,
+    any,
+    any,
+    any,
+    any
+  >
+    ? K
+    : never
+}[keyof Definitions]
+
+export type MutationKeys<Definitions extends EndpointDefinitions> = {
+  [K in keyof Definitions]: Definitions[K] extends MutationDefinition<
+    any,
+    any,
+    any,
+    any
+  >
+    ? K
+    : never
+}[keyof Definitions]
+
+type BaseQuerySubState<
+  D extends BaseEndpointDefinition<any, any, any, any>,
+  DataType = ResultTypeFrom<D>,
+> = {
+  /**
+   * The argument originally passed into the hook or `initiate` action call
+   */
+  originalArgs: QueryArgFromAnyQuery<D>
+  /**
+   * A unique ID associated with the request
+   */
+  requestId: string
+  /**
+   * The received data from the query
+   */
+  data?: DataType
+  /**
+   * The received error if applicable
+   */
+  error?:
+    | SerializedError
+    | (D extends QueryDefinition<any, infer BaseQuery, any, any>
+        ? BaseQueryError<BaseQuery>
+        : never)
+  /**
+   * The name of the endpoint associated with the query
+   */
+  endpointName: string
+  /**
+   * Time that the latest query started
+   */
+  startedTimeStamp: number
+  /**
+   * Time that the latest query was fulfilled
+   */
+  fulfilledTimeStamp?: number
+}
+
+export type QuerySubState<
+  D extends BaseEndpointDefinition<any, any, any, any>,
+  DataType = ResultTypeFrom<D>,
+> = Id<
+  | ({ status: QueryStatus.fulfilled } & WithRequiredProp<
+      BaseQuerySubState<D, DataType>,
+      'data' | 'fulfilledTimeStamp'
+    > & { error: undefined })
+  | ({ status: QueryStatus.pending } & BaseQuerySubState<D, DataType>)
+  | ({ status: QueryStatus.rejected } & WithRequiredProp<
+      BaseQuerySubState<D, DataType>,
+      'error'
+    >)
+  | {
+      status: QueryStatus.uninitialized
+      originalArgs?: undefined
+      data?: undefined
+      error?: undefined
+      requestId?: undefined
+      endpointName?: string
+      startedTimeStamp?: undefined
+      fulfilledTimeStamp?: undefined
+    }
+>
+
+export type InfiniteQueryDirection = 'forward' | 'backward'
+
+export type InfiniteQuerySubState<
+  D extends BaseEndpointDefinition<any, any, any, any>,
+> =
+  D extends InfiniteQueryDefinition<any, any, any, any, any>
+    ? QuerySubState<D, InfiniteData<ResultTypeFrom<D>, PageParamFrom<D>>> & {
+        direction?: InfiniteQueryDirection
+      }
+    : never
+
+type BaseMutationSubState<
+  D extends BaseEndpointDefinition<any, any, any, any>,
+> = {
+  requestId: string
+  data?: ResultTypeFrom<D>
+  error?:
+    | SerializedError
+    | (D extends MutationDefinition<any, infer BaseQuery, any, any>
+        ? BaseQueryError<BaseQuery>
+        : never)
+  endpointName: string
+  startedTimeStamp: number
+  fulfilledTimeStamp?: number
+}
+
+export type MutationSubState<
+  D extends BaseEndpointDefinition<any, any, any, any>,
+> =
+  | (({
+      status: QueryStatus.fulfilled
+    } & WithRequiredProp<
+      BaseMutationSubState<D>,
+      'data' | 'fulfilledTimeStamp'
+    >) & { error: undefined })
+  | (({ status: QueryStatus.pending } & BaseMutationSubState<D>) & {
+      data?: undefined
+    })
+  | ({ status: QueryStatus.rejected } & WithRequiredProp<
+      BaseMutationSubState<D>,
+      'error'
+    >)
+  | {
+      requestId?: undefined
+      status: QueryStatus.uninitialized
+      data?: undefined
+      error?: undefined
+      endpointName?: string
+      startedTimeStamp?: undefined
+      fulfilledTimeStamp?: undefined
+    }
+
+export type CombinedState<
+  D extends EndpointDefinitions,
+  E extends string,
+  ReducerPath extends string,
+> = {
+  queries: QueryState<D>
+  mutations: MutationState<D>
+  provided: InvalidationState<E>
+  subscriptions: SubscriptionState
+  config: ConfigState<ReducerPath>
+}
+
+export type InvalidationState<TagTypes extends string> = {
+  tags: {
+    [_ in TagTypes]: {
+      [id: string]: Array<QueryCacheKey>
+      [id: number]: Array<QueryCacheKey>
+    }
+  }
+  keys: Record<QueryCacheKey, Array<FullTagDescription<any>>>
+}
+
+export type QueryState<D extends EndpointDefinitions> = {
+  [queryCacheKey: string]:
+    | QuerySubState<D[string]>
+    | InfiniteQuerySubState<D[string]>
+    | undefined
+}
+
+export type SubscriptionInternalState = Map<string, SubscribersInternal>
+
+export type SubscriptionState = {
+  [queryCacheKey: string]: Subscribers | undefined
+}
+
+export type ConfigState<ReducerPath> = RefetchConfigOptions & {
+  reducerPath: ReducerPath
+  online: boolean
+  focused: boolean
+  middlewareRegistered: boolean | 'conflict'
+} & ModifiableConfigState
+
+export type ModifiableConfigState = {
+  keepUnusedDataFor: number
+  invalidationBehavior: 'delayed' | 'immediately'
+} & RefetchConfigOptions
+
+export type MutationState<D extends EndpointDefinitions> = {
+  [requestId: string]: MutationSubState<D[string]> | undefined
+}
+
+export type RootState<
+  Definitions extends EndpointDefinitions,
+  TagTypes extends string,
+  ReducerPath extends string,
+> = { [P in ReducerPath]: CombinedState<Definitions, TagTypes, P> }