@rspack/test-tools 2.0.1 → 2.0.3

package/dist/test/debug.js

@@ -1,14 +1,48 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEBUG_SCOPES = void 0;
-exports.generateDebugReport = generateDebugReport;
-const node_path_1 = __importDefault(require("node:path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const javascript_stringify_1 = require("javascript-stringify");
-const stringify_config_1 = __importDefault(require("../helper/stringify-config"));
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (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_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DEBUG_SCOPES: ()=>DEBUG_SCOPES,
+    generateDebugReport: ()=>generateDebugReport
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_fs_extra_namespaceObject = require("fs-extra");
+var external_fs_extra_default = /*#__PURE__*/ __webpack_require__.n(external_fs_extra_namespaceObject);
+const external_javascript_stringify_namespaceObject = require("javascript-stringify");
+const stringify_config_js_namespaceObject = require("../helper/stringify-config.js");
+var stringify_config_js_default = /*#__PURE__*/ __webpack_require__.n(stringify_config_js_namespaceObject);
 function generateDebugReport(context) {
     const report = `
 ## Case Meta
@@ -49,8 +83,8 @@ ${generateRunErrorsReport(context)}
 
   `;
     const dist = context.getDist('debug.md');
-    fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(dist));
-    fs_extra_1.default.writeFileSync(dist, report);
+    external_fs_extra_default().ensureDirSync(external_node_path_default().dirname(dist));
+    external_fs_extra_default().writeFileSync(dist, report);
 }
 function generateCaseMetaPathReport(context) {
     return `
@@ -66,21 +100,20 @@ function generateCaseMetaTestConfigReport(context) {
 ### Test Config
 
 \`\`\`js
-// ${node_path_1.default.resolve(context.getSource(), './test.config.js')}
-${(0, javascript_stringify_1.stringify)(context.getTestConfig(), null, 2)}
+// ${external_node_path_default().resolve(context.getSource(), './test.config.js')}
+${(0, external_javascript_stringify_namespaceObject.stringify)(context.getTestConfig(), null, 2)}
 \`\`\`
   `;
 }
 function generateReadConfigFileReport(context) {
-    const configFileInfo = context.getValue(exports.DEBUG_SCOPES.CompilerOptionsReadConfigFile);
-    if (!configFileInfo)
-        return '';
+    const configFileInfo = context.getValue(DEBUG_SCOPES.CompilerOptionsReadConfigFile);
+    if (!configFileInfo) return '';
     return `
 ### Read Config File
 
 \`\`\`js
 // ${configFileInfo.file}
-${(0, stringify_config_1.default)(configFileInfo.config)}
+${stringify_config_js_default()(configFileInfo.config)}
 \`\`\`
   `;
 }
@@ -90,14 +123,13 @@ function generateFinalOptionsReport(context) {
 ### Final Options
 
 \`\`\`js
-${(0, stringify_config_1.default)(finalOptions)}
+${stringify_config_js_default()(finalOptions)}
 \`\`\`
 `;
 }
 function generateCreateCompilerInstanceReport(context) {
-    const instanceInfo = context.getValue(exports.DEBUG_SCOPES.CreateCompilerInstance);
-    if (!instanceInfo)
-        return '';
+    const instanceInfo = context.getValue(DEBUG_SCOPES.CreateCompilerInstance);
+    if (!instanceInfo) return '';
     return `
 ### Create Compiler Instance
 
@@ -106,91 +138,81 @@ function generateCreateCompilerInstanceReport(context) {
 `;
 }
 function generateCreateCompilerSetPropertiesReport(context) {
-    const setPropertiesInfo = context.getValue(exports.DEBUG_SCOPES.CreateCompilerSetProperties);
-    if (!setPropertiesInfo || setPropertiesInfo.length === 0)
-        return '';
+    const setPropertiesInfo = context.getValue(DEBUG_SCOPES.CreateCompilerSetProperties);
+    if (!setPropertiesInfo || 0 === setPropertiesInfo.length) return '';
     return `
 ### Set Properties
 
-${setPropertiesInfo.map((p) => `- ${p}`).join('\n')}
+${setPropertiesInfo.map((p)=>`- ${p}`).join('\n')}
 `;
 }
 function generateBuildMethodReport(context) {
-    const buildMethod = context.getValue(exports.DEBUG_SCOPES.BuildMethod);
-    if (!buildMethod)
-        return '';
+    const buildMethod = context.getValue(DEBUG_SCOPES.BuildMethod);
+    if (!buildMethod) return '';
     return `
 ### Build Method
 
 - Method: \`compiler.${buildMethod.method}()\`
-${buildMethod.options ? `- Options:\n\`\`\`js\n${(0, javascript_stringify_1.stringify)(buildMethod.options, null, 2)}\n\`\`\`` : ''}
+${buildMethod.options ? `- Options:\n\`\`\`js\n${(0, external_javascript_stringify_namespaceObject.stringify)(buildMethod.options, null, 2)}\n\`\`\`` : ''}
 `;
 }
 function generateBuildErrorReport(context) {
-    const buildError = context.getValue(exports.DEBUG_SCOPES.BuildError);
-    if (!buildError)
-        return '';
+    const buildError = context.getValue(DEBUG_SCOPES.BuildError);
+    if (!buildError) return '';
     return `
 ### Build Error
 
 type: ${buildError.type}
 
-${buildError.errors.map((e) => `\`\`\`\n// message:\n${e.message}\n// stack:\n${e.stack}\n\`\`\``).join('\n\n')}
+${buildError.errors.map((e)=>`\`\`\`\n// message:\n${e.message}\n// stack:\n${e.stack}\n\`\`\``).join('\n\n')}
 `;
 }
 function generateBuildWarningReport(context) {
-    const buildWarning = context.getValue(exports.DEBUG_SCOPES.BuildWarning);
-    if (!buildWarning)
-        return '';
+    const buildWarning = context.getValue(DEBUG_SCOPES.BuildWarning);
+    if (!buildWarning) return '';
     return `
 ### Build Warning
 
-${buildWarning.map((w) => `\`\`\`\n// message:\n${w.message}\n// stack:\n${w.stack}\n\`\`\``).join('\n\n')}
+${buildWarning.map((w)=>`\`\`\`\n// message:\n${w.message}\n// stack:\n${w.stack}\n\`\`\``).join('\n\n')}
 `;
 }
 function generateRunFindBundleReport(context) {
-    const runFindBundle = context.getValue(exports.DEBUG_SCOPES.RunFindBundle);
-    if (!runFindBundle)
-        return '';
+    const runFindBundle = context.getValue(DEBUG_SCOPES.RunFindBundle);
+    if (!runFindBundle) return '';
     return `
 ### Find Bundle
 
-${runFindBundle.map((b) => `- ${context.getDist(b)}`).join('\n')}
+${runFindBundle.map((b)=>`- ${context.getDist(b)}`).join('\n')}
 `;
 }
 function generateRunGetRunnerReport(context) {
-    const getRunnerInfo = context.getValue(exports.DEBUG_SCOPES.RunGetRunner);
-    if (!getRunnerInfo)
-        return '';
+    const getRunnerInfo = context.getValue(DEBUG_SCOPES.RunGetRunner);
+    if (!getRunnerInfo) return '';
     return `
 ### Get Runner
 
-${Object.entries(getRunnerInfo)
-        .map(([file, info]) => `- ${file}: ${info.runnerKey} (Reused: ${info.reused}, Type: \`${info.runnerType}\`)`)
-        .join('\n')}
+${Object.entries(getRunnerInfo).map(([file, info])=>`- ${file}: ${info.runnerKey} (Reused: ${info.reused}, Type: \`${info.runnerType}\`)`).join('\n')}
 `;
 }
 function generateRunLogsReport(context) {
-    const runLogs = context.getValue(exports.DEBUG_SCOPES.RunLogs);
-    if (!runLogs)
-        return '';
+    const runLogs = context.getValue(DEBUG_SCOPES.RunLogs);
+    if (!runLogs) return '';
     return `
 ### Run Logs
 
-${runLogs.map((l) => `- ${l}`).join('\n')}
+${runLogs.map((l)=>`- ${l}`).join('\n')}
 `;
 }
 function generateRunErrorsReport(context) {
-    const runErrors = context.getValue(exports.DEBUG_SCOPES.RunErrors);
-    if (!runErrors)
-        return '';
+    const runErrors = context.getValue(DEBUG_SCOPES.RunErrors);
+    if (!runErrors) return '';
     return `
 ### Run Errors
 
-${runErrors.map((e) => `\`\`\`\n// message:\n${e.message}\n// stack:\n${e.stack}\n\`\`\``).join('\n\n')}
+${runErrors.map((e)=>`\`\`\`\n// message:\n${e.message}\n// stack:\n${e.stack}\n\`\`\``).join('\n\n')}
 `;
 }
-exports.DEBUG_SCOPES = {
+const DEBUG_SCOPES = {
     CompilerOptionsReadConfigFile: 'compiler-options:read-config-file',
     CompilerOptionsFinalOptions: 'compiler-options:final-options',
     CreateCompilerInstance: 'create-compiler:instance',
@@ -201,5 +223,14 @@ exports.DEBUG_SCOPES = {
     RunFindBundle: 'run:find-bundle',
     RunGetRunner: 'run:get-runner',
     RunLogs: 'run:logs',
-    RunErrors: 'run:errors',
+    RunErrors: 'run:errors'
 };
+exports.DEBUG_SCOPES = __webpack_exports__.DEBUG_SCOPES;
+exports.generateDebugReport = __webpack_exports__.generateDebugReport;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEBUG_SCOPES",
+    "generateDebugReport"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/test/tester.js

@@ -1,72 +1,100 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tester = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const context_1 = require("./context");
-const debug_1 = require("./debug");
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (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_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    Tester: ()=>Tester
+});
+const external_fs_extra_namespaceObject = require("fs-extra");
+var external_fs_extra_default = /*#__PURE__*/ __webpack_require__.n(external_fs_extra_namespaceObject);
+const external_context_js_namespaceObject = require("./context.js");
+const external_debug_js_namespaceObject = require("./debug.js");
 class Tester {
-    constructor(config) {
+    config;
+    context;
+    steps = [];
+    step = 0;
+    total = 0;
+    constructor(config){
         this.config = config;
-        this.steps = [];
-        this.step = 0;
-        this.total = 0;
-        this.context = config.createContext
-            ? config.createContext(config)
-            : new context_1.TestContext(config);
+        this.context = config.createContext ? config.createContext(config) : new external_context_js_namespaceObject.TestContext(config);
         this.steps = config.steps || [];
         this.step = 0;
         this.total = config.steps?.length || 0;
-        if (config.contextValue) {
-            for (const [key, value] of Array.from(Object.entries(config.contextValue))) {
-                this.context.setValue(key, value);
-            }
-        }
+        if (config.contextValue) for (const [key, value] of Array.from(Object.entries(config.contextValue)))this.context.setValue(key, value);
     }
     getContext() {
         return this.context;
     }
     async prepare() {
-        fs_extra_1.default.mkdirSync(this.context.getDist(), { recursive: true });
+        external_fs_extra_default().mkdirSync(this.context.getDist(), {
+            recursive: true
+        });
         const tempDir = this.context.getTemp();
-        if (tempDir) {
-            fs_extra_1.default.mkdirSync(tempDir, { recursive: true });
-        }
-        for (const i of this.steps) {
-            if (typeof i.beforeAll === 'function') {
-                await i.beforeAll(this.context);
-            }
-        }
+        if (tempDir) external_fs_extra_default().mkdirSync(tempDir, {
+            recursive: true
+        });
+        for (const i of this.steps)if ('function' == typeof i.beforeAll) await i.beforeAll(this.context);
     }
     async compile() {
         const currentStep = this.steps[this.step];
-        if (!currentStep)
-            return;
+        if (!currentStep) return;
         await this.runStepMethods(currentStep, [
             'before',
             'config',
             'compiler',
-            'build',
+            'build'
         ]);
     }
     async check(env) {
         const currentStep = this.steps[this.step];
-        if (!currentStep)
-            return;
-        await this.runCheckStepMethods(currentStep, env, this.context.hasError() ? ['check'] : ['run', 'check']);
+        if (!currentStep) return;
+        await this.runCheckStepMethods(currentStep, env, this.context.hasError() ? [
+            'check'
+        ] : [
+            'run',
+            'check'
+        ]);
     }
     async after() {
         const currentStep = this.steps[this.step];
-        if (!currentStep)
-            return;
-        await this.runStepMethods(currentStep, ['after'], true);
+        if (!currentStep) return;
+        await this.runStepMethods(currentStep, [
+            'after'
+        ], true);
     }
     next() {
-        if (this.context.hasError()) {
-            return false;
-        }
+        if (this.context.hasError()) return false;
         if (this.steps[this.step + 1]) {
             this.step++;
             return true;
@@ -74,53 +102,45 @@ class Tester {
         return false;
     }
     async resume() {
-        for (const i of this.steps) {
-            if (typeof i.afterAll === 'function') {
-                await i.afterAll(this.context);
-            }
-        }
+        for (const i of this.steps)if ('function' == typeof i.afterAll) await i.afterAll(this.context);
         try {
             await this.context.closeCompiler();
-        }
-        catch (e) {
+        } catch (e) {
             console.warn(`Error occured while closing compilers of '${this.config.name}':\n${e.stack}`);
         }
-        if (__DEBUG__) {
-            try {
-                (0, debug_1.generateDebugReport)(this.context);
-            }
-            catch (e) {
-                console.warn(`Generate debug report failed: ${e.message}`);
-            }
+        if (__DEBUG__) try {
+            (0, external_debug_js_namespaceObject.generateDebugReport)(this.context);
+        } catch (e) {
+            console.warn(`Generate debug report failed: ${e.message}`);
         }
     }
     async runStepMethods(step, methods, force = false) {
-        for (const i of methods) {
-            if (!force && this.context.hasError())
-                return;
-            if (typeof step[i] === 'function') {
-                try {
-                    await step[i](this.context);
-                }
-                catch (e) {
-                    this.context.emitError(e);
-                }
+        for (const i of methods){
+            if (!force && this.context.hasError()) return;
+            if ('function' == typeof step[i]) try {
+                await step[i](this.context);
+            } catch (e) {
+                this.context.emitError(e);
             }
         }
     }
     async runCheckStepMethods(step, env, methods) {
         try {
-            for (const i of methods) {
-                if (typeof step[i] === 'function') {
-                    await step[i](env, this.context);
-                }
-            }
-        }
-        catch (e) {
+            for (const i of methods)if ('function' == typeof step[i]) await step[i](env, this.context);
+        } catch (e) {
             const errors = this.context.getError();
-            console.error(new Error([...errors, e].map((e) => e.message).join('\n')));
+            console.error(new Error([
+                ...errors,
+                e
+            ].map((e)=>e.message).join('\n')));
             throw e;
         }
     }
 }
-exports.Tester = Tester;
+exports.Tester = __webpack_exports__.Tester;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Tester"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/type.d.ts

@@ -32,6 +32,7 @@ export interface ITestLoader {
     walk(): Promise<void>;
 }
 export type TTestRunResult = Record<string, any>;
+export type MaybePromise<T> = T | Promise<T>;
 export interface ITesterConfig {
     name: string;
     src: string;
@@ -55,15 +56,15 @@ export interface ITester {
     resume(): Promise<void>;
 }
 export interface ITestProcessor {
-    beforeAll?(context: ITestContext): Promise<void>;
-    afterAll?(context: ITestContext): Promise<void>;
-    before?(context: ITestContext): Promise<void>;
-    after?(context: ITestContext): Promise<void>;
-    config(context: ITestContext): Promise<void>;
-    compiler(context: ITestContext): Promise<void>;
-    build(context: ITestContext): Promise<void>;
-    run(env: ITestEnv, context: ITestContext): Promise<void>;
-    check(env: ITestEnv, context: ITestContext): Promise<unknown>;
+    beforeAll?(context: ITestContext): MaybePromise<void>;
+    afterAll?(context: ITestContext): MaybePromise<void>;
+    before?(context: ITestContext): MaybePromise<void>;
+    after?(context: ITestContext): MaybePromise<void>;
+    config(context: ITestContext): MaybePromise<void>;
+    compiler(context: ITestContext): MaybePromise<void>;
+    build(context: ITestContext): MaybePromise<void>;
+    run(env: ITestEnv, context: ITestContext): MaybePromise<void>;
+    check(env: ITestEnv, context: ITestContext): MaybePromise<unknown>;
 }
 export interface ITestReporter {
     init<T>(data?: T): Promise<void>;

package/dist/type.js

@@ -1,18 +1,52 @@
 "use strict";
-/// <reference types="../rstest.d.ts" />
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EEsmMode = exports.ECompareResultType = void 0;
-var ECompareResultType;
-(function (ECompareResultType) {
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (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_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ECompareResultType: ()=>ECompareResultType,
+    EEsmMode: ()=>EEsmMode
+});
+var ECompareResultType = /*#__PURE__*/ function(ECompareResultType) {
     ECompareResultType["Same"] = "same";
     ECompareResultType["Missing"] = "missing";
     ECompareResultType["OnlyDist"] = "only-dist";
     ECompareResultType["OnlySource"] = "only-source";
     ECompareResultType["Different"] = "different";
-})(ECompareResultType || (exports.ECompareResultType = ECompareResultType = {}));
-var EEsmMode;
-(function (EEsmMode) {
+    return ECompareResultType;
+}({});
+var EEsmMode = /*#__PURE__*/ function(EEsmMode) {
     EEsmMode[EEsmMode["Unknown"] = 0] = "Unknown";
     EEsmMode[EEsmMode["Evaluated"] = 1] = "Evaluated";
     EEsmMode[EEsmMode["Unlinked"] = 2] = "Unlinked";
-})(EEsmMode || (exports.EEsmMode = EEsmMode = {}));
+    return EEsmMode;
+}({});
+exports.ECompareResultType = __webpack_exports__.ECompareResultType;
+exports.EEsmMode = __webpack_exports__.EEsmMode;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ECompareResultType",
+    "EEsmMode"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "@rspack/test-tools",
-  "version": "2.0.1",
-  "license": "MIT",
+  "version": "2.0.3",
   "description": "Test tools for rspack",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "homepage": "https://rspack.rs",
+  "bugs": "https://github.com/web-infra-dev/rspack/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/web-infra-dev/rspack",
+    "directory": "packages/rspack-test-tools"
+  },
+  "license": "MIT",
   "exports": {
     ".": {
       "default": "./dist/index.js"
@@ -19,61 +24,57 @@
     "./reporter": "./dist/reporter/index.js",
     "./reporter/*": "./dist/reporter/*.js"
   },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
     "client",
     "dist",
     "template",
     "rstest.d.ts"
   ],
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
-  },
-  "homepage": "https://rspack.rs",
-  "bugs": "https://github.com/web-infra-dev/rspack/issues",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/web-infra-dev/rspack",
-    "directory": "packages/rspack-test-tools"
-  },
   "dependencies": {
     "@babel/generator": "7.29.1",
-    "@babel/parser": "7.29.2",
+    "@babel/parser": "7.29.3",
     "@babel/traverse": "7.29.0",
     "@babel/types": "7.29.0",
     "chalk": "^4.1.2",
     "cross-env": "^10.1.0",
     "filenamify": "4.3.0",
-    "fs-extra": "^11.3.4",
+    "fs-extra": "^11.3.5",
     "iconv-lite": "^0.7.2",
     "javascript-stringify": "^2.1.0",
     "jest-diff": "^30.3.0",
     "jest-snapshot": "29.7.0",
     "jsdom": "^26.1.0",
-    "memfs": "4.53.0",
+    "memfs": "4.57.2",
     "path-serializer": "0.6.0",
     "pretty-format": "30.3.0",
     "rimraf": "^5.0.10",
+    "rspack-merge": "0.1.1",
     "source-map": "^0.7.6",
-    "terser-webpack-plugin": "^5.4.0",
+    "terser-webpack-plugin": "^5.5.0",
     "wast-loader": "^1.14.1",
     "webpack": "5.104.1",
-    "webpack-merge": "6.0.1",
     "webpack-sources": "3.3.4"
   },
   "devDependencies": {
+    "@rslib/core": "^0.21.4",
     "@types/babel__generator": "7.27.0",
     "@types/babel__traverse": "7.28.0",
     "@types/fs-extra": "11.0.4",
     "@types/jsdom": "^21.1.7",
     "typescript": "^6.0.3",
-    "@rspack/core": "2.0.1"
+    "@rspack/core": "2.0.3"
   },
   "peerDependencies": {
     "@rspack/core": ">=1.0.0"
   },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "scripts": {
-    "build": "tsc -b ./tsconfig.build.json",
-    "dev": "tsc -b -w"
+    "build": "rslib",
+    "dev": "rslib -w"
   }
 }