feat(eslint-config): typescript-eslint 8

configs/eslint-config/eslint.config.mjs

@@ -47,7 +47,7 @@ export default [
       '@typescript-eslint/no-unsafe-member-access': 'warn',
       '@typescript-eslint/no-floating-promises': 'warn',
       '@typescript-eslint/no-unsafe-call': 'warn',
-      '@typescript-eslint/no-throw-literal': 'warn',
+      '@typescript-eslint/only-throw-error': 'warn',
       '@typescript-eslint/no-confusing-void-expression': 'off',
       '@typescript-eslint/restrict-template-expressions': 'off',
       '@typescript-eslint/no-empty-function': 'warn',

configs/eslint-config/package.json

@@ -43,7 +43,7 @@
     "eslint-plugin-prettier": "^5.2.1",
     "eslint-plugin-react-compiler": "0.0.0-experimental-9aef357-20240815",
     "eslint-plugin-react-hooks": "^4.6.2",
-    "typescript-eslint": "^7.18.0"
+    "typescript-eslint": "^8.9.0"
   },
   "devDependencies": {
     "@suspensive/tsconfig": "workspace:*"

configs/eslint-config/src/index.ts

@@ -79,7 +79,7 @@
       '@typescript-eslint/no-unsafe-member-access': 'warn',
       '@typescript-eslint/no-floating-promises': 'warn',
       '@typescript-eslint/no-unsafe-call': 'warn',
-      '@typescript-eslint/no-throw-literal': 'warn',
+      '@typescript-eslint/only-throw-error': 'warn',
       '@typescript-eslint/no-confusing-void-expression': 'off',
       '@typescript-eslint/restrict-template-expressions': 'off',
       '@typescript-eslint/no-empty-function': 'warn',
@@ -94,10 +94,10 @@
     rules: vitest.configs.recommended.rules,
     settings: { vitest: { typecheck: true } },
   },
-  jestDom.configs['flat/recommended'] as unknown as ReturnType<typeof tseslint.config>[number],
+  jestDom.configs['flat/recommended'],
   {
     plugins: {
       import: importPlugin,
     },
     rules: {
       'sort-imports': ['error', { ignoreDeclarationSort: true }],
@@ -113,20 +113,20 @@
       ],
     },
   },
-  eslintPluginPrettierRecommended as unknown as ReturnType<typeof tseslint.config>[number]
+  eslintPluginPrettierRecommended
 )
 
 export const suspensiveReactTypeScriptConfig: ReturnType<typeof tseslint.config> = tseslint.config(
   ...suspensiveTypeScriptConfig,
   {
     files: ['**/*.{ts,tsx}'],
-    ...(pluginReact.configs.recommended as unknown as ReturnType<typeof tseslint.config>[number]),
+    ...pluginReact.configs.recommended,
     ignores: ['**/*.mdx/**/*.{ts,tsx}'],
   },
   {
     plugins: {
       'react-hooks': reactHooks.configs.recommended,
       'react-compiler': reactCompiler,
     },
     languageOptions: {
       globals: {
@@ -146,7 +146,7 @@
 
 export const suspensiveNextTypeScriptConfig: ReturnType<typeof tseslint.config> = [
   ...suspensiveReactTypeScriptConfig,
   { plugins: { 'plugin:@next/next/recommended': next.configs.recommended } },
 ]
 
 export const suspensiveMDXConfig: Linter.Config[] = [

configs/tsconfig/base.json

@@ -15,7 +15,8 @@
     "preserveWatchOutput": true,
     "skipLibCheck": true,
     "strict": true,
-    "resolveJsonModule": true
+    "resolveJsonModule": true,
+    "allowJs": true
   },
   "exclude": ["dist", "esm", "build", "node_modules"]
 }

examples/vite-react-18-suspense-prerender-siblings-problem/src/App.tsx

@@ -6,7 +6,7 @@
   const [isClicked, setIsClicked] = useState(false)
   return (
     <>
       <button onClick={() => setIsClicked(true)}>click to render</button>
       {isClicked ? (
         <Suspense fallback={<Fallback />}>
           {Array.from({ length: 10 }, (_, i) => (
@@ -50,6 +50,7 @@
       queryKey: ['dummy', ms],
       queryFn: async () => {
         console.log({ fetch: `fetch${ms + 1}` })
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return fetch(`https://dummyjson.com/users/${ms + 1}`).then((res) => res.json())
       },
     }),

examples/vite-react-18-suspense-prerender-siblings-problem/tsconfig.json

@@ -18,7 +18,8 @@
     "strict": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true
+    "noFallthroughCasesInSwitch": true,
+    "allowJs": true
   },
   "include": ["src", "eslint.config.mjs", "vite.config.ts"]
 }

knip.json

@@ -24,6 +24,9 @@
     "packages/react-native": {
       "ignoreDependencies": ["expo", "ts-node"],
       "ignore": ["babel.config.cjs"]
+    },
+    "packages/react-dom": {
+      "ignoreDependencies": ["react-dom", "@types/react-dom"]
     }
   }
 }

packages/jotai/src/Atom.test-d.tsx

@@ -15,72 +15,78 @@ const loadableAtom = loadable(asyncAtom)
 
 describe('<Atom/>', () => {
   it('type check', () => {
-    ;() => (
+    ;(() => (
       <Atom atom={countAtom}>
         {(result) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const returnOfJotai = useAtom(countAtom)
           expectTypeOf(result).toEqualTypeOf<typeof returnOfJotai>()
           return <></>
         }}
       </Atom>
-    )
-    ;() => (
+    ))()
+    ;(() => (
       <Atom atom={readOnlyCountAtom}>
         {(result) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const returnOfJotai = useAtom(readOnlyCountAtom)
           expectTypeOf(result).toEqualTypeOf<typeof returnOfJotai>()
           return <></>
         }}
       </Atom>
-    )
-    ;() => (
+    ))()
+    ;(() => (
       <Atom atom={writeOnlyCountAtom}>
         {(result) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const returnOfJotai = useAtom(writeOnlyCountAtom)
           expectTypeOf(result).toEqualTypeOf<typeof returnOfJotai>()
           return <></>
         }}
       </Atom>
-    )
-    ;() => (
+    ))()
+    ;(() => (
       <Atom atom={asyncAtom}>
         {(result) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const returnOfJotai = useAtom(asyncAtom)
           expectTypeOf(result).toEqualTypeOf<typeof returnOfJotai>()
           return <></>
         }}
       </Atom>
-    )
-    ;() => (
+    ))()
+    ;(() => (
       <Atom atom={asyncIncrementAtom}>
         {(result) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const returnOfJotai = useAtom(asyncIncrementAtom)
           expectTypeOf(result).toEqualTypeOf<typeof returnOfJotai>()
           return <></>
         }}
       </Atom>
-    )
-    ;() => (
+    ))()
+    ;(() => (
       <Atom atom={loadableAtom}>
         {(result) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const returnOfJotai = useAtom(loadableAtom)
           expectTypeOf(result).toEqualTypeOf<typeof returnOfJotai>()
           return <></>
         }}
       </Atom>
-    )
+    ))()
 
-    expectTypeOf(<Atom atom={countAtom}>{() => <></>}</Atom>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<Atom atom={countAtom}>{() => <></>}</Atom>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<Atom atom={countAtom}>{() => <></>}</Atom>).not.toEqualTypeOf<ReactNode>()
-    expectTypeOf(<Atom atom={readOnlyCountAtom}>{() => <></>}</Atom>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<Atom atom={readOnlyCountAtom}>{() => <></>}</Atom>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<Atom atom={readOnlyCountAtom}>{() => <></>}</Atom>).not.toEqualTypeOf<ReactNode>()
-    expectTypeOf(<Atom atom={writeOnlyCountAtom}>{() => <></>}</Atom>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<Atom atom={writeOnlyCountAtom}>{() => <></>}</Atom>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<Atom atom={writeOnlyCountAtom}>{() => <></>}</Atom>).not.toEqualTypeOf<ReactNode>()
-    expectTypeOf(<Atom atom={asyncAtom}>{() => <></>}</Atom>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<Atom atom={asyncAtom}>{() => <></>}</Atom>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<Atom atom={asyncAtom}>{() => <></>}</Atom>).not.toEqualTypeOf<ReactNode>()
-    expectTypeOf(<Atom atom={asyncIncrementAtom}>{() => <></>}</Atom>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<Atom atom={asyncIncrementAtom}>{() => <></>}</Atom>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<Atom atom={asyncIncrementAtom}>{() => <></>}</Atom>).not.toEqualTypeOf<ReactNode>()
-    expectTypeOf(<Atom atom={loadableAtom}>{() => <></>}</Atom>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<Atom atom={loadableAtom}>{() => <></>}</Atom>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<Atom atom={loadableAtom}>{() => <></>}</Atom>).not.toEqualTypeOf<ReactNode>()
   })
 })

packages/jotai/src/AtomValue.test-d.tsx

@@ -15,72 +15,78 @@ const loadableAtom = loadable(asyncAtom)
 
 describe('<AtomValue/>', () => {
   it('type check', () => {
-    ;() => (
+    ;(() => (
       <AtomValue atom={countAtom}>
         {(value) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const valueOfJotai = useAtomValue(countAtom)
           expectTypeOf(value).toEqualTypeOf<typeof valueOfJotai>()
           return <></>
         }}
       </AtomValue>
-    )
-    ;() => (
+    ))()
+    ;(() => (
       <AtomValue atom={readOnlyCountAtom}>
         {(value) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const valueOfJotai = useAtomValue(readOnlyCountAtom)
           expectTypeOf(value).toEqualTypeOf<typeof valueOfJotai>()
           return <></>
         }}
       </AtomValue>
-    )
-    ;() => (
+    ))()
+    ;(() => (
       <AtomValue atom={writeOnlyCountAtom}>
         {(value) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const valueOfJotai = useAtomValue(writeOnlyCountAtom)
           expectTypeOf(value).toEqualTypeOf<typeof valueOfJotai>()
           return <></>
         }}
       </AtomValue>
-    )
-    ;() => (
+    ))()
+    ;(() => (
       <AtomValue atom={asyncAtom}>
         {(value) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const valueOfJotai = useAtomValue(asyncAtom)
           expectTypeOf(value).toEqualTypeOf<typeof valueOfJotai>()
           return <></>
         }}
       </AtomValue>
-    )
-    ;() => (
+    ))()
+    ;(() => (
       <AtomValue atom={asyncIncrementAtom}>
         {(value) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const valueOfJotai = useAtomValue(asyncIncrementAtom)
           expectTypeOf(value).toEqualTypeOf<typeof valueOfJotai>()
           return <></>
         }}
       </AtomValue>
-    )
-    ;() => (
+    ))()
+    ;(() => (
       <AtomValue atom={loadableAtom}>
         {(value) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const valueOfJotai = useAtomValue(loadableAtom)
           expectTypeOf(value).toEqualTypeOf<typeof valueOfJotai>()
           return <></>
         }}
       </AtomValue>
-    )
+    ))()
 
-    expectTypeOf(<AtomValue atom={countAtom}>{() => <></>}</AtomValue>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<AtomValue atom={countAtom}>{() => <></>}</AtomValue>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<AtomValue atom={countAtom}>{() => <></>}</AtomValue>).not.toEqualTypeOf<ReactNode>()
-    expectTypeOf(<AtomValue atom={readOnlyCountAtom}>{() => <></>}</AtomValue>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<AtomValue atom={readOnlyCountAtom}>{() => <></>}</AtomValue>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<AtomValue atom={readOnlyCountAtom}>{() => <></>}</AtomValue>).not.toEqualTypeOf<ReactNode>()
-    expectTypeOf(<AtomValue atom={writeOnlyCountAtom}>{() => <></>}</AtomValue>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<AtomValue atom={writeOnlyCountAtom}>{() => <></>}</AtomValue>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<AtomValue atom={writeOnlyCountAtom}>{() => <></>}</AtomValue>).not.toEqualTypeOf<ReactNode>()
-    expectTypeOf(<AtomValue atom={asyncAtom}>{() => <></>}</AtomValue>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<AtomValue atom={asyncAtom}>{() => <></>}</AtomValue>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<AtomValue atom={asyncAtom}>{() => <></>}</AtomValue>).not.toEqualTypeOf<ReactNode>()
-    expectTypeOf(<AtomValue atom={asyncIncrementAtom}>{() => <></>}</AtomValue>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<AtomValue atom={asyncIncrementAtom}>{() => <></>}</AtomValue>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<AtomValue atom={asyncIncrementAtom}>{() => <></>}</AtomValue>).not.toEqualTypeOf<ReactNode>()
-    expectTypeOf(<AtomValue atom={loadableAtom}>{() => <></>}</AtomValue>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<AtomValue atom={loadableAtom}>{() => <></>}</AtomValue>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<AtomValue atom={loadableAtom}>{() => <></>}</AtomValue>).not.toEqualTypeOf<ReactNode>()
   })
 })

packages/jotai/src/SetAtom.test-d.tsx

@@ -11,39 +11,42 @@ const asyncIncrementAtom = atom(null, async (get, set) => {
 
 describe('<SetAtom/>', () => {
   it('type check', () => {
-    ;() => (
+    ;(() => (
       <SetAtom atom={countAtom}>
         {(value) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const valueOfJotai = useSetAtom(countAtom)
           expectTypeOf(value).toEqualTypeOf<typeof valueOfJotai>()
           return <></>
         }}
       </SetAtom>
-    )
-    ;() => (
+    ))()
+    ;(() => (
       <SetAtom atom={writeOnlyCountAtom}>
         {(value) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const valueOfJotai = useSetAtom(writeOnlyCountAtom)
           expectTypeOf(value).toEqualTypeOf<typeof valueOfJotai>()
           return <></>
         }}
       </SetAtom>
-    )
-    ;() => (
+    ))()
+    ;(() => (
       <SetAtom atom={asyncIncrementAtom}>
         {(value) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
           const valueOfJotai = useSetAtom(asyncIncrementAtom)
           expectTypeOf(value).toEqualTypeOf<typeof valueOfJotai>()
           return <></>
         }}
       </SetAtom>
-    )
+    ))()
 
-    expectTypeOf(<SetAtom atom={countAtom}>{() => <></>}</SetAtom>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<SetAtom atom={countAtom}>{() => <></>}</SetAtom>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<SetAtom atom={countAtom}>{() => <></>}</SetAtom>).not.toEqualTypeOf<ReactNode>()
-    expectTypeOf(<SetAtom atom={writeOnlyCountAtom}>{() => <></>}</SetAtom>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<SetAtom atom={writeOnlyCountAtom}>{() => <></>}</SetAtom>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<SetAtom atom={writeOnlyCountAtom}>{() => <></>}</SetAtom>).not.toEqualTypeOf<ReactNode>()
-    expectTypeOf(<SetAtom atom={asyncIncrementAtom}>{() => <></>}</SetAtom>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<SetAtom atom={asyncIncrementAtom}>{() => <></>}</SetAtom>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<SetAtom atom={asyncIncrementAtom}>{() => <></>}</SetAtom>).not.toEqualTypeOf<ReactNode>()
   })
 })

packages/react-dom/src/test-utils/index.ts

@@ -1,5 +1,4 @@
-import * as React from 'react'
-import * as DeprecatedReactTestUtils from 'react-dom/test-utils'
+import { act } from 'react'
 
 declare global {
   // eslint-disable-next-line no-var
@@ -8,8 +7,6 @@ declare global {
   var jest: { fn: typeof vi.fn } | undefined
 }
 
-const act = typeof React.act === 'function' ? React.act : DeprecatedReactTestUtils.act
-
 type Item = {
   callback: IntersectionObserverCallback
   elements: Set<Element>

packages/react-query-4/src/Mutation.test-d.tsx

@@ -7,16 +7,16 @@ const mutationFn = () => Promise.resolve(5)
 
 describe('<Mutation/>', () => {
   it('type check', () => {
-    ;() => (
+    ;(() => (
       <Mutation mutationFn={mutationFn}>
         {(mutation) => {
           expectTypeOf(mutation).toEqualTypeOf<UseMutationResult<number, unknown, void>>()
           return <></>
         }}
       </Mutation>
-    )
+    ))()
 
-    expectTypeOf(<Mutation mutationFn={mutationFn}>{() => <></>}</Mutation>).toEqualTypeOf<JSX.Element>()
+    expectTypeOf(<Mutation mutationFn={mutationFn}>{() => <></>}</Mutation>).toEqualTypeOf<React.JSX.Element>()
     expectTypeOf(<Mutation mutationFn={mutationFn}>{() => <></>}</Mutation>).not.toEqualTypeOf<ReactNode>()
   })
 })