chore: eslint no-unnecessary-condition (#3344)

* chore(eslint): turn on no-unnecessary-condition rule

* chore(eslint): turn on no-unnecessary-condition rule

remove unnecessary optional chainings in tests

* chore(eslint): keep the matchMedia check

even though it can never be undefined, except in tests, and I couldn't figure out how to mock that properly

* chore(eslint): remove unnecessary checks in devtools

* chore(eslint): addEventListener should exist on window

if window is defined, which is checked by isServer

* chore(eslint): assign default object to options

instead of re-assigning it. In any case, the optional chaining is unnecessary

* chore(eslint): action.type should always be defined

* chore(eslint): keep the fallback for console

* chore(eslint): one rule always complains

so up-casting false to boolean

* chore(eslint): if we have a behaviour, we also have na onFetch

* chore(eslint): parseFilters always returns an object

as it falls back to an empty object internally, so the falsy check didn't do anything

* chore(eslint): upcast previous result to be potentially undefined

to make the optinal chains necessary

* fix issues after updating to alpha

Author: TkDodo

.eslintrc

@@ -12,6 +12,7 @@
     "es6": true
   },
   "parserOptions": {
+    "project": "./tsconfig.json",
     "sourceType": "module"
   },
   "rules": {
@@ -21,6 +22,7 @@
     "@typescript-eslint/no-empty-interface": "off",
     "@typescript-eslint/no-explicit-any": "off",
     "@typescript-eslint/no-non-null-assertion": "off",
+    "@typescript-eslint/no-unnecessary-condition": "error",
     "@typescript-eslint/no-inferrable-types": [
       "error",
       {

src/broadcastQueryClient-experimental/index.ts

@@ -24,18 +24,15 @@ export function broadcastQueryClient({
   const queryCache = queryClient.getQueryCache()
 
   queryClient.getQueryCache().subscribe(queryEvent => {
-    if (transaction || !queryEvent?.query) {
+    if (transaction) {
       return
     }
 
     const {
       query: { queryHash, queryKey, state },
     } = queryEvent
 
-    if (
-      queryEvent.type === 'updated' &&
-      queryEvent.action?.type === 'success'
-    ) {
+    if (queryEvent.type === 'updated' && queryEvent.action.type === 'success') {
       channel.postMessage({
         type: 'updated',
         queryHash,

src/core/focusManager.ts

@@ -14,7 +14,7 @@ export class FocusManager extends Subscribable {
   constructor() {
     super()
     this.setup = onFocus => {
-      if (!isServer && window?.addEventListener) {
+      if (!isServer) {
         const listener = () => onFocus()
         // Listen to visibillitychange and focus
         window.addEventListener('visibilitychange', listener, false)

src/core/hydration.ts

@@ -75,14 +75,12 @@ function defaultShouldDehydrateQuery(query: Query) {
 
 export function dehydrate(
   client: QueryClient,
-  options?: DehydrateOptions
+  options: DehydrateOptions = {}
 ): DehydratedState {
-  options = options || {}
-
   const mutations: DehydratedMutation[] = []
   const queries: DehydratedQuery[] = []
 
-  if (options?.dehydrateMutations !== false) {
+  if (options.dehydrateMutations !== false) {
     const shouldDehydrateMutation =
       options.shouldDehydrateMutation || defaultShouldDehydrateMutation
 
@@ -96,7 +94,7 @@ export function dehydrate(
       })
   }
 
-  if (options?.dehydrateQueries !== false) {
+  if (options.dehydrateQueries !== false) {
     const shouldDehydrateQuery =
       options.shouldDehydrateQuery || defaultShouldDehydrateQuery
 
@@ -125,7 +123,9 @@ export function hydrate(
   const mutationCache = client.getMutationCache()
   const queryCache = client.getQueryCache()
 
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   const mutations = (dehydratedState as DehydratedState).mutations || []
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   const queries = (dehydratedState as DehydratedState).queries || []
 
   mutations.forEach(dehydratedMutation => {

src/core/onlineManager.ts

@@ -14,7 +14,7 @@ export class OnlineManager extends Subscribable {
   constructor() {
     super()
     this.setup = onOnline => {
-      if (!isServer && window?.addEventListener) {
+      if (!isServer) {
         const listener = () => onOnline()
         // Listen to online
         window.addEventListener('online', listener, false)

src/core/query.ts

@@ -420,9 +420,7 @@ export class Query<
 
     addSignalProperty(context)
 
-    if (this.options.behavior?.onFetch) {
-      this.options.behavior?.onFetch(context)
-    }
+    this.options.behavior?.onFetch(context)
 
     // Store state in case the current fetch needs to be reverted
     this.revertState = this.state
@@ -463,7 +461,7 @@ export class Query<
     // Try to fetch the data
     this.retryer = createRetryer({
       fn: context.fetchFn as () => TData,
-      abort: abortController?.abort?.bind(abortController),
+      abort: abortController?.abort.bind(abortController),
       onSuccess: data => {
         if (typeof data === 'undefined') {
           onError(new Error('Query data cannot be undefined') as any)

src/core/queryClient.ts

@@ -267,12 +267,12 @@ export class QueryClient {
         query.invalidate()
       })
 
-      if (filters?.refetchType === 'none') {
+      if (filters.refetchType === 'none') {
         return Promise.resolve()
       }
       const refetchFilters: RefetchQueryFilters = {
         ...filters,
-        type: filters?.refetchType ?? filters?.type ?? 'active',
+        type: filters.refetchType ?? filters.type ?? 'active',
       }
       return this.refetchQueries(refetchFilters, options)
     })
@@ -302,7 +302,7 @@ export class QueryClient {
           query.fetch(undefined, {
             ...options,
             cancelRefetch: options?.cancelRefetch ?? true,
-            meta: { refetchPage: filters?.refetchPage },
+            meta: { refetchPage: filters.refetchPage },
           })
         )
     )

src/core/queryObserver.ts

@@ -399,7 +399,9 @@ export class QueryObserver<
   ): QueryObserverResult<TData, TError> {
     const prevQuery = this.currentQuery
     const prevOptions = this.options
-    const prevResult = this.currentResult
+    const prevResult = this.currentResult as
+      | QueryObserverResult<TData, TError>
+      | undefined
     const prevResultState = this.currentResultState
     const prevResultOptions = this.currentResultOptions
     const queryChange = query !== prevQuery
@@ -622,7 +624,9 @@ export class QueryObserver<
       return
     }
 
-    const prevQuery = this.currentQuery
+    const prevQuery = this.currentQuery as
+      | Query<TQueryFnData, TError, TQueryData, TQueryKey>
+      | undefined
     this.currentQuery = query
     this.currentQueryInitialState = query.state
     this.previousQueryResult = this.currentResult

src/core/tests/focusManager.test.tsx

@@ -1,9 +1,11 @@
 import { sleep } from '../utils'
 import { FocusManager } from '../focusManager'
+import { setIsServer } from '../../reactjs/tests/utils'
 
 describe('focusManager', () => {
   let focusManager: FocusManager
   beforeEach(() => {
+    jest.resetModules()
     focusManager = new FocusManager()
   })
 
@@ -61,17 +63,14 @@ describe('focusManager', () => {
     globalThis.document = document
   })
 
-  test('cleanup should still be undefined if window.addEventListener is not defined', async () => {
-    const { addEventListener } = globalThis.window
-
-    // @ts-expect-error
-    globalThis.window.addEventListener = undefined
+  test('cleanup should still be undefined if window is not defined', async () => {
+    const restoreIsServer = setIsServer(true)
 
     const unsubscribe = focusManager.subscribe(() => undefined)
     expect(focusManager['cleanup']).toBeUndefined()
 
     unsubscribe()
-    globalThis.window.addEventListener = addEventListener
+    restoreIsServer()
   })
 
   it('should replace default window listener when a new event listener is set', async () => {

src/core/tests/hydration.test.tsx

@@ -196,8 +196,8 @@ describe('dehydration and rehydration', () => {
 
     // This is testing implementation details that can change and are not
     // part of the public API, but is important for keeping the payload small
-    const dehydratedQuery = dehydrated?.queries.find(
-      query => query?.queryKey[0] === 'string'
+    const dehydratedQuery = dehydrated.queries.find(
+      query => query.queryKey[0] === 'string'
     )
     expect(dehydratedQuery).toBeUndefined()