@rsbuild/plugin-type-check 1.0.1-rc.5 → 1.1.0-beta.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023-present Bytedance, Inc. and its affiliates.
+Copyright (c) 2024 Rspack Contrib
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,19 +1,240 @@
-<p align="center">
-  <a href="https://rsbuild.dev" target="blank"><img src="https://github.com/web-infra-dev/rsbuild/assets/7237365/84abc13e-b620-468f-a90b-dbf28e7e9427" alt="Rsbuild Logo" /></a>
+# @rsbuild/plugin-type-check
+
+An Rsbuild plugin to run TypeScript type checker in a separate process.
+
+<p>
+  <a href="https://npmjs.com/package/@rsbuild/plugin-type-check">
+   <img src="https://img.shields.io/npm/v/@rsbuild/plugin-type-check?style=flat-square&colorA=564341&colorB=EDED91" alt="npm version" />
+  </a>
+  <img src="https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square&colorA=564341&colorB=EDED91" alt="license" />
+  <a href="https://npmcharts.com/compare/@rsbuild/plugin-type-check?minimal=true"><img src="https://img.shields.io/npm/dm/@rsbuild/plugin-type-check.svg?style=flat-square&colorA=564341&colorB=EDED91" alt="downloads" /></a>
 </p>
 
-# Rsbuild
+## Introduction
+
+This plugin internally integrates with [ts-checker-rspack-plugin](https://github.com/rspack-team/ts-checker-rspack-plugin).
+
+The type checking logic of `ts-checker-rspack-plugin` is similar to the native `tsc` command of TypeScript. It automatically reads the configuration options from `tsconfig.json` and can also be modified via the configuration options provided by the Type Check plugin.
+
+The behavior of the plugin differs in the development and production builds:
+
+- In development mode, type errors do not block the build process. They are only logged in the terminal.
+- In production mode, type errors cause the build to fail in order to ensure the stability of the production code.
+
+## Usage
+
+Install:
+
+```bash
+npm add @rsbuild/plugin-type-check -D
+```
+
+Add plugin to your `rsbuild.config.ts`:
+
+```ts
+// rsbuild.config.ts
+import { pluginTypeCheck } from "@rsbuild/plugin-type-check";
+
+export default {
+  plugins: [pluginTypeCheck()],
+};
+```
+
+### Configuring tsconfig.json
+
+The Type Check plugin by default performs checks based on the `tsconfig.json` file in the root directory of the current project. Below is an example of a `tsconfig.json` file, which you can also adjust according to the needs of your project.
+
+```json title="tsconfig.json"
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["DOM", "ES2020"],
+    "module": "ESNext",
+    "strict": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "bundler"
+  },
+  "include": ["src"]
+}
+```
+
+Please note that the fields in `tsconfig.json` will not affect the compilation behavior and output of Rsbuild, but will only affect the results of type checking.
+
+## Options
+
+### enable
+
+Whether to enable TypeScript type checking.
+
+- **Type:** `boolean`
+- **Default:** `true`
+- **Example:**
+
+Disable TypeScript type checking:
+
+```js
+pluginTypeCheck({
+  enable: false,
+});
+```
+
+Enable type checking only in production mode:
+
+```js
+pluginTypeCheck({
+  enable: process.env.NODE_ENV === "production",
+});
+```
+
+Enable type checking only in development mode (it is not recommended to disable type checking in production mode, as it may reduce the stability of the production code):
+
+```js
+pluginTypeCheck({
+  enable: process.env.NODE_ENV === "development",
+});
+```
+
+### forkTsCheckerOptions
+
+To modify the options of `ts-checker-rspack-plugin`, please refer to [ts-checker-rspack-plugin - README](https://github.com/rspack-team/ts-checker-rspack-plugin#readme) to learn about available options.
+
+- **Type:** `Object | Function`
+- **Default:**
+
+```ts
+const defaultOptions = {
+  typescript: {
+    // set 'readonly' to avoid emitting tsbuildinfo,
+    // as the generated tsbuildinfo will break ts-checker-rspack-plugin
+    mode: "readonly",
+    // enable build when using project reference
+    build: useReference,
+    // avoid OOM issue
+    memoryLimit: 8192,
+    // use tsconfig of user project
+    configFile: tsconfigPath,
+    // use typescript of user project
+    typescriptPath: require.resolve("typescript"),
+  },
+  issue: {
+    // ignore types errors from node_modules
+    exclude: [({ file = "" }) => /[\\/]node_modules[\\/]/.test(file)],
+  },
+  logger: {
+    log() {
+      // do nothing
+      // we only want to display error messages
+    },
+    error(message: string) {
+      console.error(message.replace(/ERROR/g, "Type Error"));
+    },
+  },
+};
+```
+
+#### Object Type
+
+When the value of `forkTsCheckerOptions` is an object, it will be deeply merged with the default configuration.
+
+```ts
+pluginTypeCheck({
+  forkTsCheckerOptions: {
+    issue: {
+      exclude: [({ file = "" }) => /[\\/]some-folder[\\/]/.test(file)],
+    },
+  },
+});
+```
+
+#### Function Type
+
+When the value of `forkTsCheckerOptions` is a function, the default configuration will be passed as the first argument. You can directly modify the configuration object or return an object as the final configuration.
+
+```ts
+pluginTypeCheck({
+  forkTsCheckerOptions(options) {
+    options.async = false;
+    return options;
+  },
+});
+```
+
+#### exclude Example
+
+The `exclude` option can filter based on the `code`, `message`, or `file` from TS errors.
+
+For example, the type mismatch error can be excluded using `code: 'TS2345'`:
+
+```ts
+pluginTypeCheck({
+  forkTsCheckerOptions: {
+    issue: {
+      // Ignore "Argument of type 'string' is not assignable to parameter of type 'number'.ts(2345)"
+      exclude: [{ code: "TS2345" }],
+    },
+  },
+});
+```
+
+Or exclude files under `/some-folder/` using `file`:
+
+```ts
+pluginTypeCheck({
+  forkTsCheckerOptions: {
+    issue: {
+      exclude: [({ file = "" }) => /[\\/]some-folder[\\/]/.test(file)],
+    },
+  },
+});
+```
+
+## Notes
+
+- If you have enabled `ts-loader` in your project and manually configured `compileOnly: false`, please disable the Type Check plugin to avoid duplicate type checking.
+- Some errors will be displayed as warnings in IDEs such as VS Code, but they will still be displayed as errors in the `ts-checker-rspack-plugin` check. For details, please refer to: [Why are some errors reported as warnings?](https://code.visualstudio.com/docs/typescript/typescript-compiling#_why-are-some-errors-reported-as-warnings).
+
+## Performance Optimization
+
+Type checking has a significant performance overhead. You can refer to the [Performance Guide](https://github.com/microsoft/TypeScript/wiki/Performance) in the official TypeScript documentation for performance optimization.
+
+For example, properly configuring the `include` and `exclude` scopes in `tsconfig.json` can significantly reduce unnecessary type checking and improve TypeScript performance:
+
+```json title="tsconfig.json"
+{
+  "include": ["src"],
+  "exclude": ["**/node_modules", "**/.*/"]
+}
+```
+
+## Vue Components
+
+`ts-checker-rspack-plugin` does not support checking TypeScript code in `.vue` components. You can check for type issues in `.vue` files in the following ways:
+
+1. Install the [vue-tsc](https://github.com/vuejs/language-tools/tree/master/packages/tsc) package, which provides the ability to check types in `.vue` files.
 
-The Rspack-based build tool. It's fast, out-of-the-box and extensible.
+<PackageManagerTabs command="add vue-tsc -D" />
 
-## Documentation
+2. Add the `vue-tsc --noEmit` command to the `build` script in package.json:
 
-https://rsbuild.dev/
+```diff title="package.json"
+{
+  "scripts": {
+-   "build": "rsbuild build"
++   "build": "vue-tsc --noEmit && rsbuild build"
+  }
+}
+```
 
-## Contributing
+3. Since the production build uses `vue-tsc` for type checking, you can disable the Type Check plugin in production mode to avoid redundant checks.
 
-Please read the [Contributing Guide](https://github.com/web-infra-dev/rsbuild/blob/main/CONTRIBUTING.md).
+```js
+pluginTypeCheck({
+  enable: process.env.NODE_ENV === "development",
+});
+```
 
 ## License
 
-Rsbuild is [MIT licensed](https://github.com/web-infra-dev/rsbuild/blob/main/LICENSE).
+[MIT](./LICENSE).

package/dist/index.cjs

@@ -1,120 +1,141 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  PLUGIN_TYPE_CHECK_NAME: () => PLUGIN_TYPE_CHECK_NAME,
-  pluginTypeCheck: () => pluginTypeCheck
+// The require scope
+var __webpack_require__ = {};
+/************************************************************************/ // webpack/runtime/compat_get_default_export
+(()=>{
+    // getDefaultExport function for compatibility with non-ESM modules
+    __webpack_require__.n = function(module1) {
+        var getter = module1 && module1.__esModule ? function() {
+            return module1['default'];
+        } : function() {
+            return module1;
+        };
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+// webpack/runtime/define_property_getters
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+// webpack/runtime/has_own_property
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+// webpack/runtime/make_namespace_object
+(()=>{
+    // define __esModule on exports
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+/************************************************************************/ var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+    PLUGIN_TYPE_CHECK_NAME: ()=>/* binding */ PLUGIN_TYPE_CHECK_NAME,
+    pluginTypeCheck: ()=>/* binding */ pluginTypeCheck
 });
-module.exports = __toCommonJS(src_exports);
-var import_node_fs = __toESM(require("fs"));
-var import_core = require("@rsbuild/core");
-var import_deepmerge = __toESM(require("deepmerge"));
-var import_reduce_configs = require("reduce-configs");
-var PLUGIN_TYPE_CHECK_NAME = "rsbuild:type-check";
-var pluginTypeCheck = (options = {}) => {
-  return {
-    name: PLUGIN_TYPE_CHECK_NAME,
-    setup(api) {
-      const NODE_MODULES_REGEX = /[\\/]node_modules[\\/]/;
-      const checkedTsconfig = /* @__PURE__ */ new Map();
-      api.modifyBundlerChain(
-        async (chain, { isProd, environment, CHAIN_ID }) => {
-          const { enable = true, forkTsCheckerOptions } = options;
-          const { tsconfigPath } = environment;
-          if (!tsconfigPath || enable === false) {
-            return;
-          }
-          if (checkedTsconfig.has(tsconfigPath) && checkedTsconfig.get(tsconfigPath) !== environment.name) {
-            return;
-          }
-          checkedTsconfig.set(tsconfigPath, environment.name);
-          let typescriptPath;
-          try {
-            typescriptPath = require.resolve("typescript", {
-              paths: [api.context.rootPath]
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_module_namespaceObject = require("node:module");
+const core_namespaceObject = require("@rsbuild/core");
+const external_deepmerge_namespaceObject = require("deepmerge");
+var external_deepmerge_default = /*#__PURE__*/ __webpack_require__.n(external_deepmerge_namespaceObject);
+const external_json5_namespaceObject = require("json5");
+var external_json5_default = /*#__PURE__*/ __webpack_require__.n(external_json5_namespaceObject);
+const external_reduce_configs_namespaceObject = require("reduce-configs");
+const external_ts_checker_rspack_plugin_namespaceObject = require("ts-checker-rspack-plugin");
+const src_require = (0, external_node_module_namespaceObject.createRequire)(/*#__PURE__*/ function() {
+    return 'undefined' == typeof document ? new (module.require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}());
+const PLUGIN_TYPE_CHECK_NAME = 'rsbuild:type-check';
+const pluginTypeCheck = (options = {})=>({
+        name: PLUGIN_TYPE_CHECK_NAME,
+        setup (api) {
+            const NODE_MODULES_REGEX = /[\\/]node_modules[\\/]/;
+            const checkedTsconfig = new Map();
+            api.modifyBundlerChain(async (chain, { isProd, environment, CHAIN_ID })=>{
+                const { enable = true, forkTsCheckerOptions } = options;
+                const { tsconfigPath } = environment;
+                if (!tsconfigPath || false === enable) return;
+                // If there are identical tsconfig.json files,
+                // apply type checker only once to avoid duplicate checks.
+                if (checkedTsconfig.has(tsconfigPath) && checkedTsconfig.get(tsconfigPath) !== environment.name) return;
+                checkedTsconfig.set(tsconfigPath, environment.name);
+                // use typescript of user project
+                let typescriptPath;
+                try {
+                    typescriptPath = src_require.resolve('typescript', {
+                        paths: [
+                            api.context.rootPath
+                        ]
+                    });
+                } catch (err) {
+                    core_namespaceObject.logger.warn('"typescript" is not found in current project, Type checker will not work.');
+                    return;
+                }
+                const { references } = external_json5_default().parse(external_node_fs_default().readFileSync(tsconfigPath, 'utf-8'));
+                const useReference = Array.isArray(references) && references.length > 0;
+                const defaultOptions = {
+                    typescript: {
+                        // set 'readonly' to avoid emitting tsbuildinfo,
+                        // as the generated tsbuildinfo will break ts-checker-rspack-plugin
+                        mode: 'readonly',
+                        // enable build when using project reference
+                        build: useReference,
+                        // avoid OOM issue
+                        memoryLimit: 8192,
+                        // use tsconfig of user project
+                        configFile: tsconfigPath,
+                        // use typescript of user project
+                        typescriptPath
+                    },
+                    issue: {
+                        // ignore types errors from node_modules
+                        exclude: [
+                            ({ file = '' })=>NODE_MODULES_REGEX.test(file)
+                        ]
+                    },
+                    logger: {
+                        log () {
+                        // do nothing
+                        // we only want to display error messages
+                        },
+                        error (message) {
+                            console.error(message.replace(/ERROR/g, 'Type Error'));
+                        }
+                    }
+                };
+                const typeCheckerOptions = (0, external_reduce_configs_namespaceObject.reduceConfigs)({
+                    initial: defaultOptions,
+                    config: forkTsCheckerOptions,
+                    mergeFn: external_deepmerge_default()
+                });
+                if (isProd) core_namespaceObject.logger.info('Type checker is enabled. It may take some time.');
+                chain.plugin(CHAIN_ID.PLUGIN.TS_CHECKER).use(external_ts_checker_rspack_plugin_namespaceObject.TsCheckerRspackPlugin, [
+                    typeCheckerOptions
+                ]);
             });
-          } catch (err) {
-            import_core.logger.warn(
-              '"typescript" is not found in current project, Type checker will not work.'
-            );
-            return;
-          }
-          const { default: ForkTsCheckerWebpackPlugin } = await import("fork-ts-checker-webpack-plugin");
-          const { default: json5 } = await import("json5");
-          const { references } = json5.parse(
-            import_node_fs.default.readFileSync(tsconfigPath, "utf-8")
-          );
-          const useReference = Array.isArray(references) && references.length > 0;
-          const defaultOptions = {
-            typescript: {
-              // set 'readonly' to avoid emitting tsbuildinfo,
-              // as the generated tsbuildinfo will break fork-ts-checker
-              mode: "readonly",
-              // enable build when using project reference
-              build: useReference,
-              // avoid OOM issue
-              memoryLimit: 8192,
-              // use tsconfig of user project
-              configFile: tsconfigPath,
-              // use typescript of user project
-              typescriptPath
-            },
-            issue: {
-              // ignore types errors from node_modules
-              exclude: [({ file = "" }) => NODE_MODULES_REGEX.test(file)]
-            },
-            logger: {
-              log() {
-              },
-              error(message) {
-                console.error(message.replace(/ERROR/g, "Type Error"));
-              }
-            }
-          };
-          const typeCheckerOptions = (0, import_reduce_configs.reduceConfigs)({
-            initial: defaultOptions,
-            config: forkTsCheckerOptions,
-            mergeFn: import_deepmerge.default
-          });
-          if (isProd) {
-            import_core.logger.info("Type checker is enabled. It may take some time.");
-          }
-          chain.plugin(CHAIN_ID.PLUGIN.TS_CHECKER).use(ForkTsCheckerWebpackPlugin, [typeCheckerOptions]);
         }
-      );
-    }
-  };
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PLUGIN_TYPE_CHECK_NAME,
-  pluginTypeCheck
+    });
+var __webpack_export_target__ = exports;
+for(var i in __webpack_exports__)__webpack_export_target__[i] = __webpack_exports__[i];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
 });

package/{dist-types → dist}/index.d.ts

@@ -1,7 +1,7 @@
 import { type RsbuildPlugin } from '@rsbuild/core';
-import type ForkTSCheckerPlugin from 'fork-ts-checker-webpack-plugin';
 import { type ConfigChain } from 'reduce-configs';
-type ForkTsCheckerOptions = NonNullable<ConstructorParameters<typeof ForkTSCheckerPlugin>[0]>;
+import { TsCheckerRspackPlugin } from 'ts-checker-rspack-plugin';
+type ForkTsCheckerOptions = NonNullable<ConstructorParameters<typeof TsCheckerRspackPlugin>[0]>;
 export type PluginTypeCheckerOptions = {
     /**
      * Whether to enable TypeScript type checking.
@@ -9,8 +9,8 @@ export type PluginTypeCheckerOptions = {
      */
     enable?: boolean;
     /**
-     * To modify the options of `fork-ts-checker-webpack-plugin`.
-     * @see https://github.com/TypeStrong/fork-ts-checker-webpack-plugin#readme
+     * To modify the options of `ts-checker-rspack-plugin`.
+     * @see https://github.com/rspack-contrib/ts-checker-rspack-plugin#readme
      */
     forkTsCheckerOptions?: ConfigChain<ForkTsCheckerOptions>;
 };

package/dist/index.js

@@ -1,99 +1,79 @@
-import { createRequire } from 'module';
-var require = createRequire(import.meta['url']);
-
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// ../../node_modules/.pnpm/@modern-js+module-tools@2.58.3_typescript@5.5.2/node_modules/@modern-js/module-tools/shims/esm.js
-import path from "path";
-import { fileURLToPath } from "url";
-
-// src/index.ts
-import fs from "fs";
-import { logger } from "@rsbuild/core";
-import deepmerge from "deepmerge";
-import { reduceConfigs } from "reduce-configs";
-var PLUGIN_TYPE_CHECK_NAME = "rsbuild:type-check";
-var pluginTypeCheck = (options = {}) => {
-  return {
-    name: PLUGIN_TYPE_CHECK_NAME,
-    setup(api) {
-      const NODE_MODULES_REGEX = /[\\/]node_modules[\\/]/;
-      const checkedTsconfig = /* @__PURE__ */ new Map();
-      api.modifyBundlerChain(
-        async (chain, { isProd, environment, CHAIN_ID }) => {
-          const { enable = true, forkTsCheckerOptions } = options;
-          const { tsconfigPath } = environment;
-          if (!tsconfigPath || enable === false) {
-            return;
-          }
-          if (checkedTsconfig.has(tsconfigPath) && checkedTsconfig.get(tsconfigPath) !== environment.name) {
-            return;
-          }
-          checkedTsconfig.set(tsconfigPath, environment.name);
-          let typescriptPath;
-          try {
-            typescriptPath = __require.resolve("typescript", {
-              paths: [api.context.rootPath]
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE_node_module__ from "node:module";
+import * as __WEBPACK_EXTERNAL_MODULE__rsbuild_core__ from "@rsbuild/core";
+import * as __WEBPACK_EXTERNAL_MODULE_deepmerge__ from "deepmerge";
+import * as __WEBPACK_EXTERNAL_MODULE_json5__ from "json5";
+import * as __WEBPACK_EXTERNAL_MODULE_reduce_configs__ from "reduce-configs";
+import * as __WEBPACK_EXTERNAL_MODULE_ts_checker_rspack_plugin__ from "ts-checker-rspack-plugin";
+const src_require = (0, __WEBPACK_EXTERNAL_MODULE_node_module__.createRequire)(import.meta.url);
+const PLUGIN_TYPE_CHECK_NAME = 'rsbuild:type-check';
+const pluginTypeCheck = (options = {})=>({
+        name: PLUGIN_TYPE_CHECK_NAME,
+        setup (api) {
+            const NODE_MODULES_REGEX = /[\\/]node_modules[\\/]/;
+            const checkedTsconfig = new Map();
+            api.modifyBundlerChain(async (chain, { isProd, environment, CHAIN_ID })=>{
+                const { enable = true, forkTsCheckerOptions } = options;
+                const { tsconfigPath } = environment;
+                if (!tsconfigPath || false === enable) return;
+                // If there are identical tsconfig.json files,
+                // apply type checker only once to avoid duplicate checks.
+                if (checkedTsconfig.has(tsconfigPath) && checkedTsconfig.get(tsconfigPath) !== environment.name) return;
+                checkedTsconfig.set(tsconfigPath, environment.name);
+                // use typescript of user project
+                let typescriptPath;
+                try {
+                    typescriptPath = src_require.resolve('typescript', {
+                        paths: [
+                            api.context.rootPath
+                        ]
+                    });
+                } catch (err) {
+                    __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.logger.warn('"typescript" is not found in current project, Type checker will not work.');
+                    return;
+                }
+                const { references } = __WEBPACK_EXTERNAL_MODULE_json5__["default"].parse(__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].readFileSync(tsconfigPath, 'utf-8'));
+                const useReference = Array.isArray(references) && references.length > 0;
+                const defaultOptions = {
+                    typescript: {
+                        // set 'readonly' to avoid emitting tsbuildinfo,
+                        // as the generated tsbuildinfo will break ts-checker-rspack-plugin
+                        mode: 'readonly',
+                        // enable build when using project reference
+                        build: useReference,
+                        // avoid OOM issue
+                        memoryLimit: 8192,
+                        // use tsconfig of user project
+                        configFile: tsconfigPath,
+                        // use typescript of user project
+                        typescriptPath
+                    },
+                    issue: {
+                        // ignore types errors from node_modules
+                        exclude: [
+                            ({ file = '' })=>NODE_MODULES_REGEX.test(file)
+                        ]
+                    },
+                    logger: {
+                        log () {
+                        // do nothing
+                        // we only want to display error messages
+                        },
+                        error (message) {
+                            console.error(message.replace(/ERROR/g, 'Type Error'));
+                        }
+                    }
+                };
+                const typeCheckerOptions = (0, __WEBPACK_EXTERNAL_MODULE_reduce_configs__.reduceConfigs)({
+                    initial: defaultOptions,
+                    config: forkTsCheckerOptions,
+                    mergeFn: __WEBPACK_EXTERNAL_MODULE_deepmerge__["default"]
+                });
+                if (isProd) __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.logger.info('Type checker is enabled. It may take some time.');
+                chain.plugin(CHAIN_ID.PLUGIN.TS_CHECKER).use(__WEBPACK_EXTERNAL_MODULE_ts_checker_rspack_plugin__.TsCheckerRspackPlugin, [
+                    typeCheckerOptions
+                ]);
             });
-          } catch (err) {
-            logger.warn(
-              '"typescript" is not found in current project, Type checker will not work.'
-            );
-            return;
-          }
-          const { default: ForkTsCheckerWebpackPlugin } = await import("fork-ts-checker-webpack-plugin");
-          const { default: json5 } = await import("json5");
-          const { references } = json5.parse(
-            fs.readFileSync(tsconfigPath, "utf-8")
-          );
-          const useReference = Array.isArray(references) && references.length > 0;
-          const defaultOptions = {
-            typescript: {
-              // set 'readonly' to avoid emitting tsbuildinfo,
-              // as the generated tsbuildinfo will break fork-ts-checker
-              mode: "readonly",
-              // enable build when using project reference
-              build: useReference,
-              // avoid OOM issue
-              memoryLimit: 8192,
-              // use tsconfig of user project
-              configFile: tsconfigPath,
-              // use typescript of user project
-              typescriptPath
-            },
-            issue: {
-              // ignore types errors from node_modules
-              exclude: [({ file = "" }) => NODE_MODULES_REGEX.test(file)]
-            },
-            logger: {
-              log() {
-              },
-              error(message) {
-                console.error(message.replace(/ERROR/g, "Type Error"));
-              }
-            }
-          };
-          const typeCheckerOptions = reduceConfigs({
-            initial: defaultOptions,
-            config: forkTsCheckerOptions,
-            mergeFn: deepmerge
-          });
-          if (isProd) {
-            logger.info("Type checker is enabled. It may take some time.");
-          }
-          chain.plugin(CHAIN_ID.PLUGIN.TS_CHECKER).use(ForkTsCheckerWebpackPlugin, [typeCheckerOptions]);
         }
-      );
-    }
-  };
-};
-export {
-  PLUGIN_TYPE_CHECK_NAME,
-  pluginTypeCheck
-};
+    });
+export { PLUGIN_TYPE_CHECK_NAME, pluginTypeCheck };

package/package.json

@@ -1,50 +1,69 @@
 {
   "name": "@rsbuild/plugin-type-check",
-  "version": "1.0.1-rc.5",
-  "description": "TS checker plugin of Rsbuild",
-  "homepage": "https://rsbuild.dev",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/web-infra-dev/rsbuild",
-    "directory": "packages/plugin-type-check"
-  },
+  "version": "1.1.0-beta.1",
+  "repository": "https://github.com/rspack-contrib/rsbuild-plugin-type-check",
   "license": "MIT",
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist-types/index.d.ts",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     }
   },
-  "main": "./dist/index.cjs",
-  "types": "./dist-types/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "files": [
-    "dist",
-    "dist-types"
+    "dist"
   ],
+  "scripts": {
+    "build": "rslib build",
+		"dev": "rslib build --watch",
+    "lint": "biome check .",
+    "lint:write": "biome check . --write",
+    "prepare": "simple-git-hooks && npm run build",
+    "test": "playwright test",
+    "bump": "npx bumpp"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "npx nano-staged"
+  },
+  "nano-staged": {
+    "*.{js,jsx,ts,tsx,mjs,cjs}": [
+      "biome check --write --no-errors-on-unmatched"
+    ]
+  },
   "dependencies": {
     "deepmerge": "^4.3.1",
-    "fork-ts-checker-webpack-plugin": "9.0.2",
+    "ts-checker-rspack-plugin": "^1.0.0",
     "json5": "^2.2.3",
-    "reduce-configs": "^1.0.0",
-    "webpack": "^5.94.0"
+    "reduce-configs": "^1.0.0"
   },
   "devDependencies": {
-    "typescript": "^5.5.2",
-    "@rsbuild/core": "1.0.1-rc.5",
-    "@scripts/test-helper": "1.0.1-rc.5"
+    "@biomejs/biome": "^1.9.4",
+    "@playwright/test": "^1.48.2",
+    "@rsbuild/core": "^1.0.19",
+    "@rslib/core": "^0.0.16",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.8.6",
+    "fs-extra": "^11.2.0",
+    "nano-staged": "^0.8.0",
+    "playwright": "^1.48.2",
+    "simple-git-hooks": "^2.11.1",
+    "typescript": "^5.6.3"
   },
   "peerDependencies": {
-    "@rsbuild/core": "^1.0.1-rc.4"
+    "@rsbuild/core": "1.x"
   },
+  "peerDependenciesMeta": {
+    "@rsbuild/core": {
+      "optional": true
+    }
+  },
+  "packageManager": "pnpm@9.12.3",
   "publishConfig": {
     "access": "public",
-    "provenance": true,
     "registry": "https://registry.npmjs.org/"
-  },
-  "scripts": {
-    "build": "modern build",
-    "dev": "modern build --watch"
   }
-}
+}

package/dist-types/package.json

@@ -1 +0,0 @@
-{"//":"This file is for making TypeScript work with moduleResolution node16+.","version":"1.0.0"}