@depup/reduxjs__toolkit 2.12.0-depup.28

package/src/tsHelpers.ts

@@ -0,0 +1,214 @@
+import type { Middleware, StoreEnhancer } from 'redux'
+import type { Tuple } from './utils'
+
+export function safeAssign<T extends object>(
+  target: T,
+  ...args: Array<Partial<NoInfer<T>>>
+) {
+  Object.assign(target, ...args)
+}
+
+/**
+ * return True if T is `any`, otherwise return False
+ * taken from https://github.com/joonhocho/tsdef
+ *
+ * @internal
+ */
+export type IsAny<T, True, False = never> =
+  // test if we are going the left AND right path in the condition
+  true | false extends (T extends never ? true : false) ? True : False
+
+export type CastAny<T, CastTo> = IsAny<T, CastTo, T>
+
+/**
+ * return True if T is `unknown`, otherwise return False
+ * taken from https://github.com/joonhocho/tsdef
+ *
+ * @internal
+ */
+export type IsUnknown<T, True, False = never> = unknown extends T
+  ? IsAny<T, False, True>
+  : False
+
+export type FallbackIfUnknown<T, Fallback> = IsUnknown<T, Fallback, T>
+
+/**
+ * @internal
+ */
+export type IfMaybeUndefined<P, True, False> = [undefined] extends [P]
+  ? True
+  : False
+
+/**
+ * @internal
+ */
+export type IfVoid<P, True, False> = [void] extends [P] ? True : False
+
+/**
+ * @internal
+ */
+export type IsEmptyObj<T, True, False = never> = T extends any
+  ? keyof T extends never
+    ? IsUnknown<T, False, IfMaybeUndefined<T, False, IfVoid<T, False, True>>>
+    : False
+  : never
+
+/**
+ * returns True if TS version is above 3.5, False if below.
+ * uses feature detection to detect TS version >= 3.5
+ * * versions below 3.5 will return `{}` for unresolvable interference
+ * * versions above will return `unknown`
+ *
+ * @internal
+ */
+export type AtLeastTS35<True, False> = [True, False][IsUnknown<
+  ReturnType<<T>() => T>,
+  0,
+  1
+>]
+
+/**
+ * @internal
+ */
+export type IsUnknownOrNonInferrable<T, True, False> = AtLeastTS35<
+  IsUnknown<T, True, False>,
+  IsEmptyObj<T, True, IsUnknown<T, True, False>>
+>
+
+/**
+ * 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
+
+// Appears to have a convenient side effect of ignoring `never` even if that's not what you specified
+export type ExcludeFromTuple<T, E, Acc extends unknown[] = []> = T extends [
+  infer Head,
+  ...infer Tail,
+]
+  ? ExcludeFromTuple<Tail, E, [...Acc, ...([Head] extends [E] ? [] : [Head])]>
+  : Acc
+
+type ExtractDispatchFromMiddlewareTuple<
+  MiddlewareTuple extends readonly any[],
+  Acc extends {},
+> = MiddlewareTuple extends [infer Head, ...infer Tail]
+  ? ExtractDispatchFromMiddlewareTuple<
+      Tail,
+      Acc & (Head extends Middleware<infer D> ? IsAny<D, {}, D> : {})
+    >
+  : Acc
+
+export type ExtractDispatchExtensions<M> =
+  M extends Tuple<infer MiddlewareTuple>
+    ? ExtractDispatchFromMiddlewareTuple<MiddlewareTuple, {}>
+    : M extends ReadonlyArray<Middleware>
+      ? ExtractDispatchFromMiddlewareTuple<[...M], {}>
+      : never
+
+type ExtractStoreExtensionsFromEnhancerTuple<
+  EnhancerTuple extends readonly any[],
+  Acc extends {},
+> = EnhancerTuple extends [infer Head, ...infer Tail]
+  ? ExtractStoreExtensionsFromEnhancerTuple<
+      Tail,
+      Acc & (Head extends StoreEnhancer<infer Ext> ? IsAny<Ext, {}, Ext> : {})
+    >
+  : Acc
+
+export type ExtractStoreExtensions<E> =
+  E extends Tuple<infer EnhancerTuple>
+    ? ExtractStoreExtensionsFromEnhancerTuple<EnhancerTuple, {}>
+    : E extends ReadonlyArray<StoreEnhancer>
+      ? UnionToIntersection<
+          E[number] extends StoreEnhancer<infer Ext>
+            ? Ext extends {}
+              ? IsAny<Ext, {}, Ext>
+              : {}
+            : {}
+        >
+      : never
+
+type ExtractStateExtensionsFromEnhancerTuple<
+  EnhancerTuple extends readonly any[],
+  Acc extends {},
+> = EnhancerTuple extends [infer Head, ...infer Tail]
+  ? ExtractStateExtensionsFromEnhancerTuple<
+      Tail,
+      Acc &
+        (Head extends StoreEnhancer<any, infer StateExt>
+          ? IsAny<StateExt, {}, StateExt>
+          : {})
+    >
+  : Acc
+
+export type ExtractStateExtensions<E> =
+  E extends Tuple<infer EnhancerTuple>
+    ? ExtractStateExtensionsFromEnhancerTuple<EnhancerTuple, {}>
+    : E extends ReadonlyArray<StoreEnhancer>
+      ? UnionToIntersection<
+          E[number] extends StoreEnhancer<any, infer StateExt>
+            ? StateExt extends {}
+              ? IsAny<StateExt, {}, StateExt>
+              : {}
+            : {}
+        >
+      : never
+
+export type NonUndefined<T> = T extends undefined ? never : T
+
+export type WithRequiredProp<T, K extends keyof T> = Omit<T, K> &
+  Required<Pick<T, K>>
+
+export type WithOptionalProp<T, K extends keyof T> = Omit<T, K> &
+  Partial<Pick<T, K>>
+
+export interface TypeGuard<T> {
+  (value: any): value is T
+}
+
+export interface HasMatchFunction<T> {
+  match: TypeGuard<T>
+}
+
+export const hasMatchFunction = <T>(
+  v: Matcher<T>,
+): v is HasMatchFunction<T> => {
+  return v && typeof (v as HasMatchFunction<T>).match === 'function'
+}
+
+/** @public */
+export type Matcher<T> = HasMatchFunction<T> | TypeGuard<T>
+
+/** @public */
+export type ActionFromMatcher<M extends Matcher<any>> =
+  M extends Matcher<infer T> ? T : never
+
+export type Id<T> = { [K in keyof T]: T[K] } & {}
+
+export type Tail<T extends any[]> = T extends [any, ...infer Tail]
+  ? Tail
+  : never
+
+export type UnknownIfNonSpecific<T> = {} extends T ? unknown : T
+
+/**
+ * A Promise that will never reject.
+ * @see https://github.com/reduxjs/redux-toolkit/issues/4101
+ */
+export type SafePromise<T> = Promise<T> & {
+  __linterBrands: 'SafePromise'
+}
+
+/**
+ * Properly wraps a Promise as a {@link SafePromise} with .catch(fallback).
+ */
+export function asSafePromise<Resolved, Rejected>(
+  promise: Promise<Resolved>,
+  fallback: (error: unknown) => Rejected,
+) {
+  return promise.catch(fallback) as SafePromise<Resolved | Rejected>
+}

package/src/uncheckedindexed.ts

@@ -0,0 +1,16 @@
+// inlined from https://github.com/EskiMojo14/uncheckedindexed
+// relies on remaining as a TS file, not .d.ts
+type IfMaybeUndefined<T, True, False> = [undefined] extends [T] ? True : False
+
+const testAccess = ({} as Record<string, 0>)['a']
+
+export type IfUncheckedIndexedAccess<True, False> = IfMaybeUndefined<
+  typeof testAccess,
+  True,
+  False
+>
+
+export type UncheckedIndexedAccess<T> = IfUncheckedIndexedAccess<
+  T | undefined,
+  T
+>

package/src/utils.ts

@@ -0,0 +1,125 @@
+import { createNextState, isDraftable } from './immerImports'
+
+export function getTimeMeasureUtils(maxDelay: number, fnName: string) {
+  let elapsed = 0
+  return {
+    measureTime<T>(fn: () => T): T {
+      const started = Date.now()
+      try {
+        return fn()
+      } finally {
+        const finished = Date.now()
+        elapsed += finished - started
+      }
+    },
+    warnIfExceeded() {
+      if (elapsed > maxDelay) {
+        console.warn(`${fnName} took ${elapsed}ms, which is more than the warning threshold of ${maxDelay}ms. 
+If your state or actions are very large, you may want to disable the middleware as it might cause too much of a slowdown in development mode. See https://redux-toolkit.js.org/api/getDefaultMiddleware for instructions.
+It is disabled in production builds, so you don't need to worry about that.`)
+      }
+    },
+  }
+}
+
+export function delay(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+export class Tuple<Items extends ReadonlyArray<unknown> = []> extends Array<
+  Items[number]
+> {
+  constructor(length: number)
+  constructor(...items: Items)
+  constructor(...items: any[]) {
+    super(...items)
+    Object.setPrototypeOf(this, Tuple.prototype)
+  }
+
+  static override get [Symbol.species]() {
+    return Tuple as any
+  }
+
+  override concat<AdditionalItems extends ReadonlyArray<unknown>>(
+    items: Tuple<AdditionalItems>,
+  ): Tuple<[...Items, ...AdditionalItems]>
+  override concat<AdditionalItems extends ReadonlyArray<unknown>>(
+    items: AdditionalItems,
+  ): Tuple<[...Items, ...AdditionalItems]>
+  override concat<AdditionalItems extends ReadonlyArray<unknown>>(
+    ...items: AdditionalItems
+  ): Tuple<[...Items, ...AdditionalItems]>
+  override concat(...arr: any[]) {
+    return super.concat.apply(this, arr)
+  }
+
+  prepend<AdditionalItems extends ReadonlyArray<unknown>>(
+    items: Tuple<AdditionalItems>,
+  ): Tuple<[...AdditionalItems, ...Items]>
+  prepend<AdditionalItems extends ReadonlyArray<unknown>>(
+    items: AdditionalItems,
+  ): Tuple<[...AdditionalItems, ...Items]>
+  prepend<AdditionalItems extends ReadonlyArray<unknown>>(
+    ...items: AdditionalItems
+  ): Tuple<[...AdditionalItems, ...Items]>
+  prepend(...arr: any[]) {
+    if (arr.length === 1 && Array.isArray(arr[0])) {
+      return new Tuple(...arr[0].concat(this))
+    }
+    return new Tuple(...arr.concat(this))
+  }
+}
+
+export function freezeDraftable<T>(val: T) {
+  return isDraftable(val) ? createNextState(val, () => {}) : val
+}
+
+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 function promiseWithResolvers<T>(): {
+  promise: Promise<T>
+  resolve: (value: T | PromiseLike<T>) => void
+  reject: (reason?: any) => void
+} {
+  let resolve: any
+  let reject: any
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res
+    reject = rej
+  })
+  return { promise, resolve, reject }
+}