@rsbuild/plugin-type-check 1.0.1 → 1.1.0

package/README.md

@@ -12,9 +12,9 @@ An Rsbuild plugin to run TypeScript type checker in a separate process.
 
 ## Introduction
 
-This plugin internally integrates with [fork-ts-checker-webpack-plugin](https://github.com/TypeStrong/fork-ts-checker-webpack-plugin).
+This plugin internally integrates with [ts-checker-rspack-plugin](https://github.com/rspack-contrib/ts-checker-rspack-plugin).
 
-The type checking logic of `fork-ts-checker-webpack-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 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:
 
@@ -96,9 +96,9 @@ pluginTypeCheck({
 });
 ```
 
-### forkTsCheckerOptions
+### tsCheckerOptions
 
-To modify the options of `fork-ts-checker-webpack-plugin`, please refer to [fork-ts-checker-webpack-plugin - README](https://github.com/TypeStrong/fork-ts-checker-webpack-plugin#readme) to learn about available options.
+Modify the options of `ts-checker-rspack-plugin`, please refer to [ts-checker-rspack-plugin - README](https://github.com/rspack-contrib/ts-checker-rspack-plugin#readme) to learn about available options.
 
 - **Type:** `Object | Function`
 - **Default:**
@@ -107,7 +107,7 @@ To modify the options of `fork-ts-checker-webpack-plugin`, please refer to [fork
 const defaultOptions = {
   typescript: {
     // set 'readonly' to avoid emitting tsbuildinfo,
-    // as the generated tsbuildinfo will break fork-ts-checker
+    // as the generated tsbuildinfo will break ts-checker-rspack-plugin
     mode: "readonly",
     // enable build when using project reference
     build: useReference,
@@ -136,11 +136,11 @@ const defaultOptions = {
 
 #### Object Type
 
-When the value of `forkTsCheckerOptions` is an object, it will be deeply merged with the default configuration.
+When the value of `tsCheckerOptions` is an object, it will be deeply merged with the default configuration.
 
 ```ts
 pluginTypeCheck({
-  forkTsCheckerOptions: {
+  tsCheckerOptions: {
     issue: {
       exclude: [({ file = "" }) => /[\\/]some-folder[\\/]/.test(file)],
     },
@@ -150,11 +150,11 @@ pluginTypeCheck({
 
 #### 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.
+When the value of `tsCheckerOptions` 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) {
+  tsCheckerOptions(options) {
     options.async = false;
     return options;
   },
@@ -169,7 +169,7 @@ For example, the type mismatch error can be excluded using `code: 'TS2345'`:
 
 ```ts
 pluginTypeCheck({
-  forkTsCheckerOptions: {
+  tsCheckerOptions: {
     issue: {
       // Ignore "Argument of type 'string' is not assignable to parameter of type 'number'.ts(2345)"
       exclude: [{ code: "TS2345" }],
@@ -182,7 +182,7 @@ Or exclude files under `/some-folder/` using `file`:
 
 ```ts
 pluginTypeCheck({
-  forkTsCheckerOptions: {
+  tsCheckerOptions: {
     issue: {
       exclude: [({ file = "" }) => /[\\/]some-folder[\\/]/.test(file)],
     },
@@ -193,7 +193,7 @@ pluginTypeCheck({
 ## 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 `fork-ts-checker-webpack-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).
+- 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
 
@@ -210,7 +210,7 @@ For example, properly configuring the `include` and `exclude` scopes in `tsconfi
 
 ## Vue Components
 
-`fork-ts-checker-webpack-plugin` does not support checking TypeScript code in `.vue` components. You can check for type issues in `.vue` files in the following ways:
+`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.
 

package/dist/index.cjs

@@ -1,128 +1,145 @@
 "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
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return 'undefined' == typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+// The require scope
+var __webpack_require__ = {};
+/************************************************************************/ // webpack/runtime/compat_get_default_export
+(()=>{
+    // getDefaultExport function for compatibility with non-ESM modules
+    __webpack_require__.n = function(module) {
+        var getter = module && module.__esModule ? function() {
+            return module['default'];
+        } : function() {
+            return module;
+        };
+        __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);
-
-// node_modules/.pnpm/tsup@8.2.4_postcss@8.4.38_typescript@5.5.4/node_modules/tsup/assets/cjs_shims.js
-var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
-var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
-
-// src/index.ts
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_module = require("module");
-var import_core = require("@rsbuild/core");
-var import_deepmerge = __toESM(require("deepmerge"), 1);
-var import_fork_ts_checker_webpack_plugin = __toESM(require("fork-ts-checker-webpack-plugin"), 1);
-var import_json5 = __toESM(require("json5"), 1);
-var import_reduce_configs = require("reduce-configs");
-var require2 = (0, import_node_module.createRequire)(importMetaUrl);
-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 = require2.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)(__rslib_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;
+                let { tsCheckerOptions } = options;
+                const { tsconfigPath } = environment;
+                // compatible with the legacy option
+                if (void 0 === tsCheckerOptions && void 0 !== forkTsCheckerOptions) tsCheckerOptions = forkTsCheckerOptions;
+                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 mergedOptions = (0, external_reduce_configs_namespaceObject.reduceConfigs)({
+                    initial: defaultOptions,
+                    config: tsCheckerOptions,
+                    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, [
+                    mergedOptions
+                ]);
             });
-          } catch (err) {
-            import_core.logger.warn(
-              '"typescript" is not found in current project, Type checker will not work.'
-            );
-            return;
-          }
-          const { references } = import_json5.default.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(import_fork_ts_checker_webpack_plugin.default, [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/index.d.ts

@@ -1,21 +1,23 @@
-import { RsbuildPlugin } from '@rsbuild/core';
-import ForkTSCheckerPlugin from 'fork-ts-checker-webpack-plugin';
-import { ConfigChain } from 'reduce-configs';
-
-type ForkTsCheckerOptions = NonNullable<ConstructorParameters<typeof ForkTSCheckerPlugin>[0]>;
-type PluginTypeCheckerOptions = {
+import { type RsbuildPlugin } from '@rsbuild/core';
+import { type ConfigChain } from 'reduce-configs';
+import { TsCheckerRspackPlugin } from 'ts-checker-rspack-plugin';
+type TsCheckerOptions = NonNullable<ConstructorParameters<typeof TsCheckerRspackPlugin>[0]>;
+export type PluginTypeCheckerOptions = {
     /**
      * Whether to enable TypeScript type checking.
      * @default true
      */
     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>;
+    tsCheckerOptions?: ConfigChain<TsCheckerOptions>;
+    /**
+     * @deprecated use `tsCheckerOptions` instead.
+     */
+    forkTsCheckerOptions?: ConfigChain<TsCheckerOptions>;
 };
-declare const PLUGIN_TYPE_CHECK_NAME = "rsbuild:type-check";
-declare const pluginTypeCheck: (options?: PluginTypeCheckerOptions) => RsbuildPlugin;
-
-export { PLUGIN_TYPE_CHECK_NAME, type PluginTypeCheckerOptions, pluginTypeCheck };
+export declare const PLUGIN_TYPE_CHECK_NAME = "rsbuild:type-check";
+export declare const pluginTypeCheck: (options?: PluginTypeCheckerOptions) => RsbuildPlugin;
+export {};

package/dist/index.js

@@ -1,86 +1,82 @@
-// src/index.ts
-import fs from "node:fs";
-import { createRequire } from "node:module";
-import { logger } from "@rsbuild/core";
-import deepmerge from "deepmerge";
-import ForkTSCheckerPlugin from "fork-ts-checker-webpack-plugin";
-import json5 from "json5";
-import { reduceConfigs } from "reduce-configs";
-var require2 = createRequire(import.meta.url);
-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 = require2.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;
+                let { tsCheckerOptions } = options;
+                const { tsconfigPath } = environment;
+                // compatible with the legacy option
+                if (void 0 === tsCheckerOptions && void 0 !== forkTsCheckerOptions) tsCheckerOptions = forkTsCheckerOptions;
+                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 mergedOptions = (0, __WEBPACK_EXTERNAL_MODULE_reduce_configs__.reduceConfigs)({
+                    initial: defaultOptions,
+                    config: tsCheckerOptions,
+                    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, [
+                    mergedOptions
+                ]);
             });
-          } catch (err) {
-            logger.warn(
-              '"typescript" is not found in current project, Type checker will not work.'
-            );
-            return;
-          }
-          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(ForkTSCheckerPlugin, [typeCheckerOptions]);
         }
-      );
-    }
-  };
-};
-export {
-  PLUGIN_TYPE_CHECK_NAME,
-  pluginTypeCheck
-};
+    });
+export { PLUGIN_TYPE_CHECK_NAME, pluginTypeCheck };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/plugin-type-check",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "repository": "https://github.com/rspack-contrib/rsbuild-plugin-type-check",
   "license": "MIT",
   "type": "module",
@@ -17,6 +17,15 @@
   "files": [
     "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"
   },
@@ -27,41 +36,34 @@
   },
   "dependencies": {
     "deepmerge": "^4.3.1",
-    "fork-ts-checker-webpack-plugin": "9.0.2",
+    "ts-checker-rspack-plugin": "^1.0.1",
     "json5": "^2.2.3",
-    "reduce-configs": "^1.0.0",
-    "webpack": "^5.94.0"
+    "reduce-configs": "^1.0.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "^1.8.3",
-    "@playwright/test": "^1.46.1",
-    "@rsbuild/core": "^1.0.1-rc.5",
+    "@biomejs/biome": "^1.9.4",
+    "@playwright/test": "^1.48.2",
+    "@rsbuild/core": "^1.1.5",
+    "@rslib/core": "^0.1.0",
     "@types/fs-extra": "^11.0.4",
-    "@types/node": "^20.16.2",
+    "@types/node": "^22.8.6",
     "fs-extra": "^11.2.0",
     "nano-staged": "^0.8.0",
-    "playwright": "^1.46.1",
+    "playwright": "^1.48.2",
     "simple-git-hooks": "^2.11.1",
-    "tsup": "^8.2.4",
-    "typescript": "^5.5.4"
+    "typescript": "^5.6.3"
   },
   "peerDependencies": {
-    "@rsbuild/core": "1.x || ^1.0.1-beta.0"
+    "@rsbuild/core": "1.x"
   },
   "peerDependenciesMeta": {
     "@rsbuild/core": {
       "optional": true
     }
   },
+  "packageManager": "pnpm@9.12.3",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "lint": "biome check .",
-    "lint:write": "biome check . --write",
-    "test": "playwright test"
   }
-}
+}

package/dist/index.d.cts

@@ -1,21 +0,0 @@
-import { RsbuildPlugin } from '@rsbuild/core';
-import ForkTSCheckerPlugin from 'fork-ts-checker-webpack-plugin';
-import { ConfigChain } from 'reduce-configs';
-
-type ForkTsCheckerOptions = NonNullable<ConstructorParameters<typeof ForkTSCheckerPlugin>[0]>;
-type PluginTypeCheckerOptions = {
-    /**
-     * Whether to enable TypeScript type checking.
-     * @default true
-     */
-    enable?: boolean;
-    /**
-     * To modify the options of `fork-ts-checker-webpack-plugin`.
-     * @see https://github.com/TypeStrong/fork-ts-checker-webpack-plugin#readme
-     */
-    forkTsCheckerOptions?: ConfigChain<ForkTsCheckerOptions>;
-};
-declare const PLUGIN_TYPE_CHECK_NAME = "rsbuild:type-check";
-declare const pluginTypeCheck: (options?: PluginTypeCheckerOptions) => RsbuildPlugin;
-
-export { PLUGIN_TYPE_CHECK_NAME, type PluginTypeCheckerOptions, pluginTypeCheck };