@depup/reduxjs__toolkit 2.12.0-depup.28

package/src/query/standardSchema.ts

@@ -0,0 +1,35 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+import { SchemaError } from '@standard-schema/utils'
+import type { SchemaType } from './endpointDefinitions'
+
+export class NamedSchemaError extends SchemaError {
+  constructor(
+    issues: readonly StandardSchemaV1.Issue[],
+    public readonly value: any,
+    public readonly schemaName: `${SchemaType}Schema`,
+    public readonly _bqMeta: any,
+  ) {
+    super(issues)
+  }
+}
+
+export const shouldSkip = (
+  skipSchemaValidation: boolean | SchemaType[] | undefined,
+  schemaName: SchemaType,
+) =>
+  Array.isArray(skipSchemaValidation)
+    ? skipSchemaValidation.includes(schemaName)
+    : !!skipSchemaValidation
+
+export async function parseWithSchema<Schema extends StandardSchemaV1>(
+  schema: Schema,
+  data: unknown,
+  schemaName: `${SchemaType}Schema`,
+  bqMeta: any,
+): Promise<StandardSchemaV1.InferOutput<Schema>> {
+  const result = await schema['~standard'].validate(data)
+  if (result.issues) {
+    throw new NamedSchemaError(result.issues, data, schemaName, bqMeta)
+  }
+  return result.value
+}

package/src/query/tsHelpers.ts

@@ -0,0 +1,48 @@
+export type Id<T> = { [K in keyof T]: T[K] } & {}
+export type WithRequiredProp<T, K extends keyof T> = Omit<T, K> &
+  Required<Pick<T, K>>
+export type Override<T1, T2> = T2 extends any ? Omit<T1, keyof T2> & T2 : never
+export function assertCast<T>(v: any): asserts v is T {}
+
+export function safeAssign<T extends object>(
+  target: T,
+  ...args: Array<Partial<NoInfer<T>>>
+): T {
+  return Object.assign(target, ...args)
+}
+
+/**
+ * Convert a Union type `(A|B)` to an intersection type `(A&B)`
+ */
+export type UnionToIntersection<U> = (
+  U extends any ? (k: U) => void : never
+) extends (k: infer I) => void
+  ? I
+  : never
+
+export type NonOptionalKeys<T> = {
+  [K in keyof T]-?: undefined extends T[K] ? never : K
+}[keyof T]
+
+export type HasRequiredProps<T, True, False> =
+  NonOptionalKeys<T> extends never ? False : True
+
+export type OptionalIfAllPropsOptional<T> = HasRequiredProps<T, T, T | never>
+
+export type NonUndefined<T> = T extends undefined ? never : T
+
+export type UnwrapPromise<T> = T extends PromiseLike<infer V> ? V : T
+
+export type MaybePromise<T> = T | PromiseLike<T>
+
+export type OmitFromUnion<T, K extends keyof T> = T extends any
+  ? Omit<T, K>
+  : never
+
+export type IsAny<T, True, False = never> = true | false extends (
+  T extends never ? true : false
+)
+  ? True
+  : False
+
+export type CastAny<T, CastTo> = IsAny<T, CastTo, T>

package/src/query/utils/capitalize.ts

@@ -0,0 +1,3 @@
+export function capitalize(str: string) {
+  return str.replace(str[0], str[0].toUpperCase())
+}

package/src/query/utils/copyWithStructuralSharing.ts

@@ -0,0 +1,27 @@
+import { isPlainObject as _iPO } from '../core/rtkImports'
+
+// remove type guard
+const isPlainObject: (_: any) => boolean = _iPO
+
+export function copyWithStructuralSharing<T>(oldObj: any, newObj: T): T
+export function copyWithStructuralSharing(oldObj: any, newObj: any): any {
+  if (
+    oldObj === newObj ||
+    !(
+      (isPlainObject(oldObj) && isPlainObject(newObj)) ||
+      (Array.isArray(oldObj) && Array.isArray(newObj))
+    )
+  ) {
+    return newObj
+  }
+  const newKeys = Object.keys(newObj)
+  const oldKeys = Object.keys(oldObj)
+
+  let isSameObject = newKeys.length === oldKeys.length
+  const mergeObj: any = Array.isArray(newObj) ? [] : {}
+  for (const key of newKeys) {
+    mergeObj[key] = copyWithStructuralSharing(oldObj[key], newObj[key])
+    if (isSameObject) isSameObject = oldObj[key] === mergeObj[key]
+  }
+  return isSameObject ? oldObj : mergeObj
+}

package/src/query/utils/countObjectKeys.ts

@@ -0,0 +1,14 @@
+// Fast method for counting an object's keys
+// without resorting to `Object.keys(obj).length
+// Will this make a big difference in perf? Probably not
+// But we can save a few allocations.
+
+export function countObjectKeys(obj: Record<any, any>) {
+  let count = 0
+
+  for (const _key in obj) {
+    count++
+  }
+
+  return count
+}

package/src/query/utils/filterMap.ts

@@ -0,0 +1,27 @@
+// Preserve type guard predicate behavior when passing to mapper
+export function filterMap<T, U, S extends T = T>(
+  array: readonly T[],
+  predicate: (item: T, index: number) => item is S,
+  mapper: (item: S, index: number) => U | U[],
+): U[]
+
+export function filterMap<T, U>(
+  array: readonly T[],
+  predicate: (item: T, index: number) => boolean,
+  mapper: (item: T, index: number) => U | U[],
+): U[]
+
+export function filterMap<T, U>(
+  array: readonly T[],
+  predicate: (item: T, index: number) => boolean,
+  mapper: (item: T, index: number) => U | U[],
+): U[] {
+  return array
+    .reduce<(U | U[])[]>((acc, item, i) => {
+      if (predicate(item as any, i)) {
+        acc.push(mapper(item as any, i))
+      }
+      return acc
+    }, [])
+    .flat() as U[]
+}

package/src/query/utils/getCurrent.ts

@@ -0,0 +1,6 @@
+import type { Draft } from 'immer'
+import { current, isDraft } from '../utils/immerImports'
+
+export function getCurrent<T>(value: T | Draft<T>): T {
+  return (isDraft(value) ? current(value) : value) as T
+}

package/src/query/utils/getOrInsert.ts

@@ -0,0 +1,41 @@
+// Duplicate some of the utils in `/src/utils` to ensure
+// we don't end up dragging in larger chunks of the RTK core
+// into the RTKQ bundle
+
+export function getOrInsert<K extends object, V>(
+  map: WeakMap<K, V>,
+  key: K,
+  value: V,
+): V
+export function getOrInsert<K, V>(map: Map<K, V>, key: K, value: V): V
+export function getOrInsert<K extends object, V>(
+  map: Map<K, V> | WeakMap<K, V>,
+  key: K,
+  value: V,
+): V {
+  if (map.has(key)) return map.get(key) as V
+
+  return map.set(key, value).get(key) as V
+}
+
+export function getOrInsertComputed<K extends object, V>(
+  map: WeakMap<K, V>,
+  key: K,
+  compute: (key: K) => V,
+): V
+export function getOrInsertComputed<K, V>(
+  map: Map<K, V>,
+  key: K,
+  compute: (key: K) => V,
+): V
+export function getOrInsertComputed<K extends object, V>(
+  map: Map<K, V> | WeakMap<K, V>,
+  key: K,
+  compute: (key: K) => V,
+): V {
+  if (map.has(key)) return map.get(key) as V
+
+  return map.set(key, compute(key)).get(key) as V
+}
+
+export const createNewMap = () => new Map()

package/src/query/utils/immerImports.ts

@@ -0,0 +1,9 @@
+export {
+  current,
+  isDraft,
+  applyPatches,
+  original,
+  isDraftable,
+  produceWithPatches,
+  enablePatches,
+} from 'immer'

package/src/query/utils/index.ts

@@ -0,0 +1,11 @@
+export * from './capitalize'
+export * from './copyWithStructuralSharing'
+export * from './countObjectKeys'
+export * from './filterMap'
+export * from './isAbsoluteUrl'
+export * from './isDocumentVisible'
+export * from './isNotNullish'
+export * from './isOnline'
+export * from './isValidUrl'
+export * from './joinUrls'
+export * from './getOrInsert'

package/src/query/utils/isAbsoluteUrl.ts

@@ -0,0 +1,9 @@
+/**
+ * If either :// or // is present consider it to be an absolute url
+ *
+ * @param url string
+ */
+
+export function isAbsoluteUrl(url: string) {
+  return new RegExp(`(^|:)//`).test(url)
+}

package/src/query/utils/isDocumentVisible.ts

@@ -0,0 +1,12 @@
+/**
+ * Assumes true for a non-browser env, otherwise makes a best effort
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/Document/visibilityState
+ */
+export function isDocumentVisible(): boolean {
+  // `document` may not exist in non-browser envs (like RN)
+  if (typeof document === 'undefined') {
+    return true
+  }
+  // Match true for visible, prerender, undefined
+  return document.visibilityState !== 'hidden'
+}

package/src/query/utils/isNotNullish.ts

@@ -0,0 +1,7 @@
+export function isNotNullish<T>(v: T | null | undefined): v is T {
+  return v != null
+}
+
+export function filterNullishValues<T>(map?: Map<any, T>) {
+  return [...(map?.values() ?? [])].filter(isNotNullish) as NonNullable<T>[]
+}

package/src/query/utils/isOnline.ts

@@ -0,0 +1,12 @@
+/**
+ * Assumes a browser is online if `undefined`, otherwise makes a best effort
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/NavigatorOnLine/onLine
+ */
+export function isOnline() {
+  // We set the default config value in the store, so we'd need to check for this in a SSR env
+  return typeof navigator === 'undefined'
+    ? true
+    : navigator.onLine === undefined
+      ? true
+      : navigator.onLine
+}

package/src/query/utils/isValidUrl.ts

@@ -0,0 +1,9 @@
+export function isValidUrl(string: string) {
+  try {
+    new URL(string)
+  } catch (_) {
+    return false
+  }
+
+  return true
+}

package/src/query/utils/joinUrls.ts

@@ -0,0 +1,26 @@
+import { isAbsoluteUrl } from './isAbsoluteUrl'
+
+const withoutTrailingSlash = (url: string) => url.replace(/\/$/, '')
+const withoutLeadingSlash = (url: string) => url.replace(/^\//, '')
+
+export function joinUrls(
+  base: string | undefined,
+  url: string | undefined,
+): string {
+  if (!base) {
+    return url!
+  }
+  if (!url) {
+    return base
+  }
+
+  if (isAbsoluteUrl(url)) {
+    return url
+  }
+
+  const delimiter = base.endsWith('/') || !url.startsWith('?') ? '/' : ''
+  base = withoutTrailingSlash(base)
+  url = withoutLeadingSlash(url)
+
+  return `${base}${delimiter}${url}`
+}

package/src/query/utils/signals.ts

@@ -0,0 +1,33 @@
+// AbortSignal.timeout() is currently baseline 2024
+export const timeoutSignal = (milliseconds: number) => {
+  const abortController = new AbortController()
+  setTimeout(() => {
+    const message = 'signal timed out'
+    const name = 'TimeoutError'
+    abortController.abort(
+      // some environments (React Native, Node) don't have DOMException
+      typeof DOMException !== 'undefined'
+        ? new DOMException(message, name)
+        : Object.assign(new Error(message), { name }),
+    )
+  }, milliseconds)
+  return abortController.signal
+}
+
+// AbortSignal.any() is currently baseline 2024
+export const anySignal = (...signals: AbortSignal[]) => {
+  // if any are already aborted, return an already aborted signal
+  for (const signal of signals)
+    if (signal.aborted) return AbortSignal.abort(signal.reason)
+
+  // otherwise, create a new signal that aborts when any of the given signals abort
+  const abortController = new AbortController()
+  for (const signal of signals) {
+    signal.addEventListener(
+      'abort',
+      () => abortController.abort(signal.reason),
+      { signal: abortController.signal, once: true },
+    )
+  }
+  return abortController.signal
+}

package/src/react/index.ts

@@ -0,0 +1,7 @@
+// 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'
+export * from '@reduxjs/toolkit'
+
+export { createDynamicMiddleware } from '../dynamicMiddleware/react'
+export type { CreateDispatchWithMiddlewareHook } from '../dynamicMiddleware/react/index'

package/src/reduxImports.ts

@@ -0,0 +1,8 @@
+export {
+  createStore,
+  combineReducers,
+  applyMiddleware,
+  compose,
+  isPlainObject,
+  isAction,
+} from 'redux'

package/src/reselectImports.ts

@@ -0,0 +1 @@
+export { createSelectorCreator, weakMapMemoize } from 'reselect'

package/src/serializableStateInvariantMiddleware.ts

@@ -0,0 +1,285 @@
+import type { Middleware } from 'redux'
+import { isAction, isPlainObject } from './reduxImports'
+import { getTimeMeasureUtils } from './utils'
+
+/**
+ * Returns true if the passed value is "plain", i.e. a value that is either
+ * directly JSON-serializable (boolean, number, string, array, plain object)
+ * or `undefined`.
+ *
+ * @param val The value to check.
+ *
+ * @public
+ */
+export function isPlain(val: any) {
+  const type = typeof val
+  return (
+    val == null ||
+    type === 'string' ||
+    type === 'boolean' ||
+    type === 'number' ||
+    Array.isArray(val) ||
+    isPlainObject(val)
+  )
+}
+
+interface NonSerializableValue {
+  keyPath: string
+  value: unknown
+}
+
+export type IgnoredPaths = readonly (string | RegExp)[]
+
+/**
+ * @public
+ */
+export function findNonSerializableValue(
+  value: unknown,
+  path: string = '',
+  isSerializable: (value: unknown) => boolean = isPlain,
+  getEntries?: (value: unknown) => [string, any][],
+  ignoredPaths: IgnoredPaths = [],
+  cache?: WeakSet<object>,
+): NonSerializableValue | false {
+  let foundNestedSerializable: NonSerializableValue | false
+
+  if (!isSerializable(value)) {
+    return {
+      keyPath: path || '<root>',
+      value: value,
+    }
+  }
+
+  if (typeof value !== 'object' || value === null) {
+    return false
+  }
+
+  if (cache?.has(value)) return false
+
+  const entries = getEntries != null ? getEntries(value) : Object.entries(value)
+
+  const hasIgnoredPaths = ignoredPaths.length > 0
+
+  for (const [key, nestedValue] of entries) {
+    const nestedPath = path ? path + '.' + key : key
+
+    if (hasIgnoredPaths) {
+      const hasMatches = ignoredPaths.some((ignored) => {
+        if (ignored instanceof RegExp) {
+          return ignored.test(nestedPath)
+        }
+        return nestedPath === ignored
+      })
+      if (hasMatches) {
+        continue
+      }
+    }
+
+    if (!isSerializable(nestedValue)) {
+      return {
+        keyPath: nestedPath,
+        value: nestedValue,
+      }
+    }
+
+    if (typeof nestedValue === 'object') {
+      foundNestedSerializable = findNonSerializableValue(
+        nestedValue,
+        nestedPath,
+        isSerializable,
+        getEntries,
+        ignoredPaths,
+        cache,
+      )
+
+      if (foundNestedSerializable) {
+        return foundNestedSerializable
+      }
+    }
+  }
+
+  if (cache && isNestedFrozen(value)) cache.add(value)
+
+  return false
+}
+
+export function isNestedFrozen(value: object) {
+  if (!Object.isFrozen(value)) return false
+
+  for (const nestedValue of Object.values(value)) {
+    if (typeof nestedValue !== 'object' || nestedValue === null) continue
+
+    if (!isNestedFrozen(nestedValue)) return false
+  }
+
+  return true
+}
+
+/**
+ * Options for `createSerializableStateInvariantMiddleware()`.
+ *
+ * @public
+ */
+export interface SerializableStateInvariantMiddlewareOptions {
+  /**
+   * The function to check if a value is considered serializable. This
+   * function is applied recursively to every value contained in the
+   * state. Defaults to `isPlain()`.
+   */
+  isSerializable?: (value: any) => boolean
+  /**
+   * The function that will be used to retrieve entries from each
+   * value.  If unspecified, `Object.entries` will be used. Defaults
+   * to `undefined`.
+   */
+  getEntries?: (value: any) => [string, any][]
+
+  /**
+   * An array of action types to ignore when checking for serializability.
+   * Defaults to []
+   */
+  ignoredActions?: string[]
+
+  /**
+   * An array of dot-separated path strings or regular expressions to ignore
+   * when checking for serializability, Defaults to
+   * ['meta.arg', 'meta.baseQueryMeta']
+   */
+  ignoredActionPaths?: (string | RegExp)[]
+
+  /**
+   * An array of dot-separated path strings or regular expressions to ignore
+   * when checking for serializability, Defaults to []
+   */
+  ignoredPaths?: (string | RegExp)[]
+  /**
+   * Execution time warning threshold. If the middleware takes longer
+   * than `warnAfter` ms, a warning will be displayed in the console.
+   * Defaults to 32ms.
+   */
+  warnAfter?: number
+
+  /**
+   * Opt out of checking state. When set to `true`, other state-related params will be ignored.
+   */
+  ignoreState?: boolean
+
+  /**
+   * Opt out of checking actions. When set to `true`, other action-related params will be ignored.
+   */
+  ignoreActions?: boolean
+
+  /**
+   * Opt out of caching the results. The cache uses a WeakSet and speeds up repeated checking processes.
+   * The cache is automatically disabled if no browser support for WeakSet is present.
+   */
+  disableCache?: boolean
+}
+
+/**
+ * Creates a middleware that, after every state change, checks if the new
+ * state is serializable. If a non-serializable value is found within the
+ * state, an error is printed to the console.
+ *
+ * @param options Middleware options.
+ *
+ * @public
+ */
+export function createSerializableStateInvariantMiddleware(
+  options: SerializableStateInvariantMiddlewareOptions = {},
+): Middleware {
+  if (process.env.NODE_ENV === 'production') {
+    return () => (next) => (action) => next(action)
+  } else {
+    const {
+      isSerializable = isPlain,
+      getEntries,
+      ignoredActions = [],
+      ignoredActionPaths = ['meta.arg', 'meta.baseQueryMeta'],
+      ignoredPaths = [],
+      warnAfter = 32,
+      ignoreState = false,
+      ignoreActions = false,
+      disableCache = false,
+    } = options
+
+    const cache: WeakSet<object> | undefined =
+      !disableCache && WeakSet ? new WeakSet() : undefined
+
+    return (storeAPI) => (next) => (action) => {
+      if (!isAction(action)) {
+        return next(action)
+      }
+
+      const result = next(action)
+
+      const measureUtils = getTimeMeasureUtils(
+        warnAfter,
+        'SerializableStateInvariantMiddleware',
+      )
+
+      if (
+        !ignoreActions &&
+        !(
+          ignoredActions.length &&
+          ignoredActions.indexOf(action.type as any) !== -1
+        )
+      ) {
+        measureUtils.measureTime(() => {
+          const foundActionNonSerializableValue = findNonSerializableValue(
+            action,
+            '',
+            isSerializable,
+            getEntries,
+            ignoredActionPaths,
+            cache,
+          )
+
+          if (foundActionNonSerializableValue) {
+            const { keyPath, value } = foundActionNonSerializableValue
+
+            console.error(
+              `A non-serializable value was detected in an action, in the path: \`${keyPath}\`. Value:`,
+              value,
+              '\nTake a look at the logic that dispatched this action: ',
+              action,
+              '\n(See https://redux.js.org/faq/actions#why-should-type-be-a-string-or-at-least-serializable-why-should-my-action-types-be-constants)',
+              '\n(To allow non-serializable values see: https://redux-toolkit.js.org/usage/usage-guide#working-with-non-serializable-data)',
+            )
+          }
+        })
+      }
+
+      if (!ignoreState) {
+        measureUtils.measureTime(() => {
+          const state = storeAPI.getState()
+
+          const foundStateNonSerializableValue = findNonSerializableValue(
+            state,
+            '',
+            isSerializable,
+            getEntries,
+            ignoredPaths,
+            cache,
+          )
+
+          if (foundStateNonSerializableValue) {
+            const { keyPath, value } = foundStateNonSerializableValue
+
+            console.error(
+              `A non-serializable value was detected in the state, in the path: \`${keyPath}\`. Value:`,
+              value,
+              `
+Take a look at the reducer(s) handling this action type: ${action.type}.
+(See https://redux.js.org/faq/organizing-state#can-i-put-functions-promises-or-other-non-serializable-items-in-my-store-state)`,
+            )
+          }
+        })
+
+        measureUtils.warnIfExceeded()
+      }
+
+      return result
+    }
+  }
+}