Fix lint and formatting issues

Author: aryaemami59

packages/toolkit/.size-limit.cjs

@@ -5,9 +5,9 @@ const esmSuffixes = ['modern.mjs' /*, 'browser.mjs', 'legacy-esm.js'*/]
 const cjsSuffixes = [/*'development.cjs',*/ 'production.min.cjs']
 
 /**
-   * @param {string} suffix
-   * @param {boolean} cjs
-   */
+ * @param {string} suffix
+ * @param {boolean} cjs
+ */
 function withRtkPath(suffix, cjs = false) {
   /**
    * @param {string} name

packages/toolkit/src/entities/sorted_state_adapter.ts

@@ -10,9 +10,9 @@ import { createStateOperator } from './state_adapter'
 import { createUnsortedStateAdapter } from './unsorted_state_adapter'
 import {
   ensureEntitiesArray,
+  getCurrent,
   selectIdValue,
   splitAddedUpdatedEntities,
-  getCurrent,
 } from './utils'
 
 // Borrowed from Replay
@@ -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) {

packages/toolkit/src/query/tests/buildHooks.test.tsx

@@ -773,8 +773,8 @@ describe('hooks tests', () => {
         endpoints: (builder) => ({
           getTest: builder.query<string, number>({
             async queryFn() {
-              await new Promise((resolve) => setTimeout(resolve, 1000));
-              return { data: "data!" };
+              await new Promise((resolve) => setTimeout(resolve, 1000))
+              return { data: 'data!' }
             },
             keepUnusedDataFor: 0,
           }),
@@ -786,13 +786,13 @@ describe('hooks tests', () => {
       })
 
       const checkNumQueries = (count: number) => {
-        const cacheEntries = Object.keys((storeRef.store.getState()).api.queries)
+        const cacheEntries = Object.keys(storeRef.store.getState().api.queries)
         const queries = cacheEntries.length
 
         expect(queries).toBe(count)
       }
 
-      let i = 0;
+      let i = 0
 
       function User() {
         const [fetchTest, { isFetching, isUninitialized }] =
@@ -820,7 +820,7 @@ describe('hooks tests', () => {
       })
 
       // There should only be one stored query once they have had time to resolve
-      checkNumQueries( 1)
+      checkNumQueries(1)
     })
 
     // See https://github.com/reduxjs/redux-toolkit/issues/3182

packages/toolkit/src/tests/createSlice.test-d.ts

@@ -660,38 +660,43 @@ describe('type tests', () => {
               expectTypeOf(action.error).toEqualTypeOf<'error'>()
             },
           ),
-          testInferVoid: create.asyncThunk(() => {}, {
-            pending(state, action) {
-              expectTypeOf(state).toEqualTypeOf<TestState>()
-
-              expectTypeOf(action.meta.arg).toBeVoid()
+          testInferVoid: create.asyncThunk(
+            () => {
+              /* empty */
             },
-            fulfilled(state, action) {
-              expectTypeOf(state).toEqualTypeOf<TestState>()
-
-              expectTypeOf(action.meta.arg).toBeVoid()
+            {
+              pending(state, action) {
+                expectTypeOf(state).toEqualTypeOf<TestState>()
 
-              expectTypeOf(action.payload).toBeVoid()
-            },
-            rejected(state, action) {
-              expectTypeOf(state).toEqualTypeOf<TestState>()
+                expectTypeOf(action.meta.arg).toBeVoid()
+              },
+              fulfilled(state, action) {
+                expectTypeOf(state).toEqualTypeOf<TestState>()
 
-              expectTypeOf(action.meta.arg).toBeVoid()
+                expectTypeOf(action.meta.arg).toBeVoid()
 
-              expectTypeOf(action.error).toEqualTypeOf<SerializedError>()
-            },
-            settled(state, action) {
-              expectTypeOf(state).toEqualTypeOf<TestState>()
+                expectTypeOf(action.payload).toBeVoid()
+              },
+              rejected(state, action) {
+                expectTypeOf(state).toEqualTypeOf<TestState>()
 
-              expectTypeOf(action.meta.arg).toBeVoid()
+                expectTypeOf(action.meta.arg).toBeVoid()
 
-              if (isRejected(action)) {
                 expectTypeOf(action.error).toEqualTypeOf<SerializedError>()
-              } else {
-                expectTypeOf(action.payload).toBeVoid()
-              }
+              },
+              settled(state, action) {
+                expectTypeOf(state).toEqualTypeOf<TestState>()
+
+                expectTypeOf(action.meta.arg).toBeVoid()
+
+                if (isRejected(action)) {
+                  expectTypeOf(action.error).toEqualTypeOf<SerializedError>()
+                } else {
+                  expectTypeOf(action.payload).toBeVoid()
+                }
+              },
             },
-          }),
+          ),
           testInfer: create.asyncThunk(
             function payloadCreator(arg: TestArg, api) {
               return Promise.resolve<TestReturned>({ payload: 'foo' })