Change all let variables to const to comply with prefer-const rule

aryaemami59 · aryaemami59 · commit 367f4bd54bad · 2025-05-17T16:39:05.000-05:00
diff --git a/packages/toolkit/src/configureStore.ts b/packages/toolkit/src/configureStore.ts
@@ -216,7 +216,7 @@ export function configureStore<
     throw new Error('`enhancers` field must be a callback')
   }
 
-  let storeEnhancers =
+  const storeEnhancers =
     typeof enhancers === 'function'
       ? enhancers(getDefaultEnhancers)
       : getDefaultEnhancers()
diff --git a/packages/toolkit/src/createAction.ts b/packages/toolkit/src/createAction.ts
@@ -260,7 +260,7 @@ export function createAction<
 export function createAction(type: string, prepareAction?: Function): any {
   function actionCreator(...args: any[]) {
     if (prepareAction) {
-      let prepared = prepareAction(...args)
+      const prepared = prepareAction(...args)
       if (!prepared) {
         throw new Error('prepareAction did not return an object')
       }
diff --git a/packages/toolkit/src/createReducer.ts b/packages/toolkit/src/createReducer.ts
@@ -149,7 +149,7 @@ export function createReducer<S extends NotFunction<any>>(
     }
   }
 
-  let [actionsMap, finalActionMatchers, finalDefaultCaseReducer] =
+  const [actionsMap, finalActionMatchers, finalDefaultCaseReducer] =
     executeReducerBuilderCallback(mapOrBuilderCallback)
 
   // Ensure the initial state gets frozen either way (if draftable)
diff --git a/packages/toolkit/src/createSlice.ts b/packages/toolkit/src/createSlice.ts
@@ -707,13 +707,13 @@ export function buildCreateSlice({ creators }: BuildCreateSliceConfig = {}) {
       }
 
       return createReducer(options.initialState, (builder) => {
-        for (let key in finalCaseReducers) {
+        for (const key in finalCaseReducers) {
           builder.addCase(key, finalCaseReducers[key] as CaseReducer<any>)
         }
-        for (let sM of context.sliceMatchers) {
+        for (const sM of context.sliceMatchers) {
           builder.addMatcher(sM.matcher, sM.reducer)
         }
-        for (let m of actionMatchers) {
+        for (const m of actionMatchers) {
           builder.addMatcher(m.matcher, m.reducer)
         }
         if (defaultCaseReducer) {
diff --git a/packages/toolkit/src/entities/sorted_state_adapter.ts b/packages/toolkit/src/entities/sorted_state_adapter.ts
@@ -24,7 +24,7 @@ export function findInsertIndex<T>(
   let lowIndex = 0
   let highIndex = sortedItems.length
   while (lowIndex < highIndex) {
-    let middleIndex = (lowIndex + highIndex) >>> 1
+    const middleIndex = (lowIndex + highIndex) >>> 1
     const currentItem = sortedItems[middleIndex]
     const res = comparisonFunction(item, currentItem)
     if (res >= 0) {
@@ -119,7 +119,7 @@ export function createSortedStateAdapter<T, Id extends EntityId>(
     let appliedUpdates = false
     let replacedIds = false
 
-    for (let update of updates) {
+    for (const update of updates) {
       const entity: T | undefined = (state.entities as Record<Id, T>)[update.id]
       if (!entity) {
         continue
diff --git a/packages/toolkit/src/getDefaultEnhancers.ts b/packages/toolkit/src/getDefaultEnhancers.ts
@@ -19,7 +19,7 @@ export const buildGetDefaultEnhancers = <M extends Middlewares<any>>(
   function getDefaultEnhancers(options) {
     const { autoBatch = true } = options ?? {}
 
-    let enhancerArray = new Tuple<StoreEnhancer[]>(middlewareEnhancer)
+    const enhancerArray = new Tuple<StoreEnhancer[]>(middlewareEnhancer)
     if (autoBatch) {
       enhancerArray.push(
         autoBatchEnhancer(
diff --git a/packages/toolkit/src/getDefaultMiddleware.ts b/packages/toolkit/src/getDefaultMiddleware.ts
@@ -59,7 +59,7 @@ export const buildGetDefaultMiddleware = <S = any>(): GetDefaultMiddleware<S> =>
       actionCreatorCheck = true,
     } = options ?? {}
 
-    let middlewareArray = new Tuple<Middleware[]>()
+    const middlewareArray = new Tuple<Middleware[]>()
 
     if (thunk) {
       if (isBoolean(thunk)) {
diff --git a/packages/toolkit/src/immutableStateInvariantMiddleware.ts b/packages/toolkit/src/immutableStateInvariantMiddleware.ts
@@ -83,16 +83,16 @@ function detectMutations(
 
   // Gather all keys from prev (tracked) and after objs
   const keysToDetect: Record<string, boolean> = {}
-  for (let key in trackedProperty.children) {
+  for (const key in trackedProperty.children) {
     keysToDetect[key] = true
   }
-  for (let key in obj) {
+  for (const key in obj) {
     keysToDetect[key] = true
   }
 
   const hasIgnoredPaths = ignoredPaths.length > 0
 
-  for (let key in keysToDetect) {
+  for (const key in keysToDetect) {
     const nestedPath = path ? path + '.' + key : key
 
     if (hasIgnoredPaths) {
@@ -176,7 +176,7 @@ export function createImmutableStateInvariantMiddleware(
       serializer?: EntryProcessor,
       decycler?: EntryProcessor,
     ): EntryProcessor {
-      let stack: any[] = [],
+      const stack: any[] = [],
         keys: any[] = []
 
       if (!decycler)
@@ -189,7 +189,7 @@ export function createImmutableStateInvariantMiddleware(
 
       return function (this: any, key: string, value: any) {
         if (stack.length > 0) {
-          var thisPos = stack.indexOf(this)
+          const thisPos = stack.indexOf(this)
           ~thisPos ? stack.splice(thisPos + 1) : stack.push(this)
           ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key)
           if (~stack.indexOf(value)) value = decycler!.call(this, key, value)
@@ -199,7 +199,7 @@ export function createImmutableStateInvariantMiddleware(
       }
     }
 
-    let {
+    const {
       isImmutable = isImmutableDefault,
       ignoredPaths,
       warnAfter = 32,
diff --git a/packages/toolkit/src/listenerMiddleware/index.ts b/packages/toolkit/src/listenerMiddleware/index.ts
@@ -149,7 +149,7 @@ const createTakePattern = <S>(
 
     const tuplePromise = new Promise<[Action, S, S]>((resolve, reject) => {
       // Inside the Promise, we synchronously add the listener.
-      let stopListening = startListening({
+      const stopListening = startListening({
         predicate: predicate as any,
         effect: (action, listenerApi): void => {
           // One-shot listener that cleans up as soon as the predicate passes
@@ -192,7 +192,8 @@ const createTakePattern = <S>(
 }
 
 const getListenerEntryPropsFrom = (options: FallbackAddListenerOptions) => {
-  let { type, actionCreator, matcher, predicate, effect } = options
+  let { type, predicate } = options
+  const { actionCreator, matcher, effect } = options
 
   if (type) {
     predicate = createAction(type).match
diff --git a/packages/toolkit/src/listenerMiddleware/tests/effectScenarios.test.ts b/packages/toolkit/src/listenerMiddleware/tests/effectScenarios.test.ts
@@ -32,9 +32,9 @@ describe('Saga-style Effects Scenarios', () => {
   })
   const { increment, decrement, incrementByAmount } = counterSlice.actions
 
-  let { reducer } = counterSlice
+  const { reducer } = counterSlice
   let listenerMiddleware = createListenerMiddleware<CounterState>()
-  let { middleware, startListening, stopListening } = listenerMiddleware
+  let { middleware, startListening } = listenerMiddleware
 
   let store = configureStore({
     reducer,
diff --git a/packages/toolkit/src/listenerMiddleware/tests/fork.test.ts b/packages/toolkit/src/listenerMiddleware/tests/fork.test.ts
@@ -266,7 +266,7 @@ describe('fork', () => {
       expected: { status: 'ok', value: 5 },
     },
   ])('$desc', async ({ executor, expected, cancelAfterMs }) => {
-    let deferredResult = deferred()
+    const deferredResult = deferred()
     let forkedTask: any = {}
 
     startListening({
@@ -296,7 +296,7 @@ describe('fork', () => {
 
   describe('forkAPI', () => {
     test('forkApi.delay rejects as soon as the task is cancelled', async () => {
-      let deferredResult = deferred()
+      const deferredResult = deferred()
 
       startListening({
         actionCreator: increment,
@@ -322,7 +322,7 @@ describe('fork', () => {
     })
 
     test('forkApi.delay rejects as soon as the parent listener is cancelled', async () => {
-      let deferredResult = deferred()
+      const deferredResult = deferred()
 
       startListening({
         actionCreator: increment,
@@ -374,7 +374,7 @@ describe('fork', () => {
     ])(
       'signal is $expectedAbortReason when autoJoin: $autoJoin, cancelListener: $cancelListener',
       async ({ autoJoin, cancelListener, expectedAbortReason }) => {
-        let deferredResult = deferred()
+        const deferredResult = deferred()
 
         const unsubscribe = startListening({
           actionCreator: increment,
@@ -406,8 +406,8 @@ describe('fork', () => {
     )
 
     test('fork.delay does not trigger unhandledRejections for completed or cancelled tasks', async () => {
-      let deferredCompletedEvt = deferred()
-      let deferredCancelledEvt = deferred()
+      const deferredCompletedEvt = deferred()
+      const deferredCancelledEvt = deferred()
 
       // Unfortunately we cannot test declaratively unhandleRejections in jest: https://github.com/facebook/jest/issues/5620
       // This test just fails if an `unhandledRejection` occurs.
@@ -453,7 +453,7 @@ describe('fork', () => {
   })
 
   test('forkApi.pause rejects if task is cancelled', async () => {
-    let deferredResult = deferred()
+    const deferredResult = deferred()
     startListening({
       actionCreator: increment,
       effect: async (_, listenerApi) => {
@@ -478,7 +478,7 @@ describe('fork', () => {
   })
 
   test('forkApi.pause rejects as soon as the parent listener is cancelled', async () => {
-    let deferredResult = deferred()
+    const deferredResult = deferred()
 
     startListening({
       actionCreator: increment,
diff --git a/packages/toolkit/src/listenerMiddleware/tests/useCases.test.ts b/packages/toolkit/src/listenerMiddleware/tests/useCases.test.ts
@@ -36,7 +36,7 @@ const { increment, decrement, incrementByAmount } = counterSlice.actions
 
 describe('Saga-style Effects Scenarios', () => {
   let listenerMiddleware = createListenerMiddleware<CounterState>()
-  let { middleware, startListening, stopListening } = listenerMiddleware
+  let { middleware, startListening } = listenerMiddleware
 
   let store = configureStore({
     reducer: counterSlice.reducer,
@@ -78,7 +78,7 @@ describe('Saga-style Effects Scenarios', () => {
     // function by wrapping an event emitter so that every call returns a
     // promise that is resolved the next time an event is emitted.
     // This is the tiniest event emitter I could find to copy-paste in here.
-    let createNanoEvents = () => ({
+    const createNanoEvents = () => ({
       events: {} as Record<string, any>,
       emit(event: string, ...args: any[]) {
         ;(this.events[event] || []).forEach((i: any) => i(...args))
diff --git a/packages/toolkit/src/nanoid.ts b/packages/toolkit/src/nanoid.ts
@@ -1,14 +1,14 @@
 // 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 =
+const urlAlphabet =
   'ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW'
 
 /**
  *
  * @public
  */
-export let nanoid = (size = 21) => {
+export const nanoid = (size = 21) => {
   let id = ''
   // A compact alternative for `for (var i = 0; i < step; i++)`.
   let i = size
diff --git a/packages/toolkit/src/query/core/buildMiddleware/polling.ts b/packages/toolkit/src/query/core/buildMiddleware/polling.ts
@@ -147,7 +147,7 @@ export const buildPollingHandler: InternalHandlerBuilder = ({
   function findLowestPollingInterval(subscribers: Subscribers = {}) {
     let skipPollingIfUnfocused: boolean | undefined = false
     let lowestPollingInterval = Number.POSITIVE_INFINITY
-    for (let key in subscribers) {
+    for (const key in subscribers) {
       if (!!subscribers[key].pollingInterval) {
         lowestPollingInterval = Math.min(
           subscribers[key].pollingInterval!,
diff --git a/packages/toolkit/src/query/core/buildSelectors.ts b/packages/toolkit/src/query/core/buildSelectors.ts
@@ -348,7 +348,7 @@ export function buildSelectors<
         continue
       }
 
-      let invalidateSubscriptions =
+      const invalidateSubscriptions =
         (tag.id !== undefined
           ? // id given: invalidate all queries that provide this type & id
             provided[tag.id]
diff --git a/packages/toolkit/src/query/core/buildSlice.ts b/packages/toolkit/src/query/core/buildSlice.ts
@@ -241,15 +241,18 @@ export function buildSlice({
           // We're already inside an Immer-powered reducer, and the user could just mutate `substate.data`
           // themselves inside of `merge()`. But, they might also want to return a new value.
           // Try to let Immer figure that part out, save the result, and assign it to `substate.data`.
-          let newData = createNextState(substate.data, (draftSubstateData) => {
-            // As usual with Immer, you can mutate _or_ return inside here, but not both
-            return merge(draftSubstateData, payload, {
-              arg: arg.originalArgs,
-              baseQueryMeta,
-              fulfilledTimeStamp,
-              requestId,
-            })
-          })
+          const newData = createNextState(
+            substate.data,
+            (draftSubstateData) => {
+              // As usual with Immer, you can mutate _or_ return inside here, but not both
+              return merge(draftSubstateData, payload, {
+                arg: arg.originalArgs,
+                baseQueryMeta,
+                fulfilledTimeStamp,
+                requestId,
+              })
+            },
+          )
           substate.data = newData
         } else {
           // Presumably a fresh request. Just cache the response data.
diff --git a/packages/toolkit/src/query/fetchBaseQuery.ts b/packages/toolkit/src/query/fetchBaseQuery.ts
@@ -1,7 +1,7 @@
-import { joinUrls } from './utils'
-import { isPlainObject } from './core/rtkImports'
 import type { BaseQueryApi, BaseQueryFn } from './baseQueryTypes'
+import { isPlainObject } from './core/rtkImports'
 import type { MaybePromise, Override } from './tsHelpers'
+import { joinUrls } from './utils'
 
 export type ResponseHandler =
   | 'content-type'
@@ -215,16 +215,19 @@ export function fetchBaseQuery({
   }
   return async (arg, api, extraOptions) => {
     const { getState, extra, endpoint, forced, type } = api
-    let meta: FetchBaseQueryMeta | undefined
-    let {
-      url,
-      headers = new Headers(baseFetchOptions.headers),
+
+    const fetchArgs = typeof arg == 'string' ? { url: arg } : arg
+    let { url, headers = new Headers(baseFetchOptions.headers) } = fetchArgs
+
+    const {
+      url: _url,
+      headers: _headers,
       params = undefined,
       responseHandler = globalResponseHandler ?? ('json' as const),
       validateStatus = globalValidateStatus ?? defaultValidateStatus,
       timeout = defaultTimeout,
       ...rest
-    } = typeof arg == 'string' ? { url: arg } : arg
+    } = fetchArgs
 
     let abortController: AbortController | undefined,
       signal = api.signal
@@ -234,7 +237,7 @@ export function fetchBaseQuery({
       signal = abortController.signal
     }
 
-    let config: RequestInit = {
+    const config: RequestInit = {
       ...baseFetchOptions,
       signal,
       ...rest,
@@ -279,16 +282,16 @@ export function fetchBaseQuery({
 
     const request = new Request(url, config)
     const requestClone = new Request(url, config)
-    meta = { request: requestClone }
-
-    let response,
-      timedOut = false,
-      timeoutId =
-        abortController &&
-        setTimeout(() => {
-          timedOut = true
-          abortController!.abort()
-        }, timeout)
+    const meta: FetchBaseQueryMeta = { request: requestClone }
+
+    let response
+    let timedOut = false
+    const timeoutId =
+      abortController &&
+      setTimeout(() => {
+        timedOut = true
+        abortController!.abort()
+      }, timeout)
     try {
       response = await fetchFn(request)
     } catch (e) {
@@ -311,7 +314,7 @@ export function fetchBaseQuery({
     meta.response = responseClone
 
     let resultData: any
-    let responseText: string = ''
+    let responseText = ''
     try {
       let handleResponseError
       await Promise.all([
@@ -323,7 +326,9 @@ export function fetchBaseQuery({
         // we *have* to "use up" both streams at the same time or they will stop running in node-fetch scenarios
         responseClone.text().then(
           (r) => (responseText = r),
-          () => {},
+          () => {
+            /** No-Op */
+          },
         ),
       ])
       if (handleResponseError) throw handleResponseError
diff --git a/packages/toolkit/src/query/react/buildHooks.ts b/packages/toolkit/src/query/react/buildHooks.ts
diff --git a/packages/toolkit/src/query/tests/buildHooks.test.tsx b/packages/toolkit/src/query/tests/buildHooks.test.tsx
diff --git a/packages/toolkit/src/query/tests/fetchBaseQuery.test.tsx b/packages/toolkit/src/query/tests/fetchBaseQuery.test.tsx
diff --git a/packages/toolkit/src/query/tests/infiniteQueries.test.ts b/packages/toolkit/src/query/tests/infiniteQueries.test.ts
diff --git a/packages/toolkit/src/query/tests/optimisticUpdates.test.tsx b/packages/toolkit/src/query/tests/optimisticUpdates.test.tsx
diff --git a/packages/toolkit/src/query/tests/optimisticUpserts.test.tsx b/packages/toolkit/src/query/tests/optimisticUpserts.test.tsx
diff --git a/packages/toolkit/src/query/tests/useMutation-fixedCacheKey.test.tsx b/packages/toolkit/src/query/tests/useMutation-fixedCacheKey.test.tsx
diff --git a/packages/toolkit/src/tests/immutableStateInvariantMiddleware.test.ts b/packages/toolkit/src/tests/immutableStateInvariantMiddleware.test.ts

Original file line number	Diff line number	Diff line change
`@@ -216,7 +216,7 @@ export function configureStore<`
`216`	`216`	throw new Error('`enhancers` field must be a callback')
`217`	`217`	`}`
`218`	`218`
`219`		`- let storeEnhancers =`
	`219`	`+ const storeEnhancers =`
`220`	`220`	`typeof enhancers === 'function'`
`221`	`221`	`? enhancers(getDefaultEnhancers)`
`222`	`222`	`: getDefaultEnhancers()`
Original file line number	Diff line number	Diff line change
`@@ -260,7 +260,7 @@ export function createAction<`
`260`	`260`	`export function createAction(type: string, prepareAction?: Function): any {`
`261`	`261`	`function actionCreator(...args: any[]) {`
`262`	`262`	`if (prepareAction) {`
`263`		`- let prepared = prepareAction(...args)`
	`263`	`+ const prepared = prepareAction(...args)`
`264`	`264`	`if (!prepared) {`
`265`	`265`	`throw new Error('prepareAction did not return an object')`
`266`	`266`	`}`
Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ export function createReducer<S extends NotFunction<any>>(`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`
`152`		`- let [actionsMap, finalActionMatchers, finalDefaultCaseReducer] =`
	`152`	`+ const [actionsMap, finalActionMatchers, finalDefaultCaseReducer] =`
`153`	`153`	`executeReducerBuilderCallback(mapOrBuilderCallback)`
`154`	`154`
`155`	`155`	`// Ensure the initial state gets frozen either way (if draftable)`
Original file line number	Diff line number	Diff line change
`@@ -707,13 +707,13 @@ export function buildCreateSlice({ creators }: BuildCreateSliceConfig = {}) {`
`707`	`707`	`}`
`708`	`708`
`709`	`709`	`return createReducer(options.initialState, (builder) => {`
`710`		`- for (let key in finalCaseReducers) {`
	`710`	`+ for (const key in finalCaseReducers) {`
`711`	`711`	`builder.addCase(key, finalCaseReducers[key] as CaseReducer<any>)`
`712`	`712`	`}`
`713`		`- for (let sM of context.sliceMatchers) {`
	`713`	`+ for (const sM of context.sliceMatchers) {`
`714`	`714`	`builder.addMatcher(sM.matcher, sM.reducer)`
`715`	`715`	`}`
`716`		`- for (let m of actionMatchers) {`
	`716`	`+ for (const m of actionMatchers) {`
`717`	`717`	`builder.addMatcher(m.matcher, m.reducer)`
`718`	`718`	`}`
`719`	`719`	`if (defaultCaseReducer) {`