Add RegExp support to immutability middleware

docs/api/immutabilityMiddleware.mdx

@@ -29,11 +29,11 @@ interface ImmutableStateInvariantMiddlewareOptions {
    */
   isImmutable?: IsImmutableFunc
   /** 
-    An array of dot-separated path strings that match named nodes from 
+    An array of dot-separated path strings or RegExps that match named nodes from 
     the root state to ignore when checking for immutability.
     Defaults to undefined
    */
-  ignoredPaths?: string[]
+  ignoredPaths?: (string | RegExp)[]
   /** Print a warning if checks take longer than N ms. Default: 32ms */
   warnAfter?: number
   // @deprecated. Use ignoredPaths

packages/toolkit/src/immutableStateInvariantMiddleware.ts

@@ -72,7 +72,7 @@ export function isImmutableDefault(value: unknown): boolean {
 
 export function trackForMutations(
   isImmutable: IsImmutableFunc,
-  ignorePaths: string[] | undefined,
+  ignorePaths: IgnorePaths | undefined,
   obj: any
 ) {
   const trackedProperties = trackProperties(isImmutable, ignorePaths, obj)
@@ -116,11 +116,11 @@ function trackProperties(
   return tracked as TrackedProperty
 }
 
-type IgnorePaths = readonly string[]
+type IgnorePaths = readonly (string | RegExp)[]
 
 function detectMutations(
   isImmutable: IsImmutableFunc,
-  ignorePaths: IgnorePaths = [],
+  ignoredPaths: IgnorePaths = [],
   trackedProperty: TrackedProperty,
   obj: any,
   sameParentRef: boolean = false,
@@ -147,19 +147,30 @@ function detectMutations(
     keysToDetect[key] = true
   }
 
+  const hasIgnoredPaths = ignoredPaths.length > 0
+
   for (let key in keysToDetect) {
-    const childPath = path ? path + '.' + key : key
-    if (ignorePaths.length && ignorePaths.indexOf(childPath) !== -1) {
-      continue
+    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
+      }
     }
 
     const result = detectMutations(
       isImmutable,
-      ignorePaths,
+      ignoredPaths,
       trackedProperty.children[key],
       obj[key],
       sameRef,
-      childPath
+      nestedPath
     )
 
     if (result.wasMutated) {
@@ -189,7 +200,7 @@ export interface ImmutableStateInvariantMiddlewareOptions {
     the root state to ignore when checking for immutability.
     Defaults to undefined
    */
-  ignoredPaths?: string[]
+  ignoredPaths?: IgnorePaths
   /** Print a warning if checks take longer than N ms. Default: 32ms */
   warnAfter?: number
   // @deprecated. Use ignoredPaths

packages/toolkit/src/serializableStateInvariantMiddleware.ts

@@ -28,6 +28,8 @@ interface NonSerializableValue {
   value: unknown
 }
 
+type IgnorePaths = readonly (string | RegExp)[]
+
 /**
  * @public
  */
@@ -36,7 +38,7 @@ export function findNonSerializableValue(
   path: string = '',
   isSerializable: (value: unknown) => boolean = isPlain,
   getEntries?: (value: unknown) => [string, any][],
-  ignoredPaths: readonly (string | RegExp)[] = []
+  ignoredPaths: IgnorePaths = []
 ): NonSerializableValue | false {
   let foundNestedSerializable: NonSerializableValue | false
 
@@ -59,7 +61,7 @@ export function findNonSerializableValue(
     const nestedPath = path ? path + '.' + key : key
 
     if (hasIgnoredPaths) {
-      const hasMatches = ignoredPaths.some(ignored => {
+      const hasMatches = ignoredPaths.some((ignored) => {
         if (ignored instanceof RegExp) {
           return ignored.test(nestedPath)
         }

packages/toolkit/src/tests/immutableStateInvariantMiddleware.test.ts

@@ -121,10 +121,16 @@ describe('createImmutableStateInvariantMiddleware', () => {
       return action
     }
 
-    const dispatch = middleware({ ignoredPaths: ['foo.bar'] })(next)
+    const dispatch1 = middleware({ ignoredPaths: ['foo.bar'] })(next)
 
     expect(() => {
-      dispatch({ type: 'SOME_ACTION' })
+      dispatch1({ type: 'SOME_ACTION' })
+    }).not.toThrow()
+
+    const dispatch2 = middleware({ ignoredPaths: [/^foo/] })(next)
+
+    expect(() => {
+      dispatch2({ type: 'SOME_ACTION' })
     }).not.toThrow()
   })