@rspack/test-tools 0.5.0 → 0.5.1

package/dist/case/diff.d.ts

@@ -0,0 +1 @@
+export declare function createDiffCase(name: string, src: string, dist: string): void;

package/dist/case/diff.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDiffCase = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const __1 = require("../");
+const rimraf_1 = __importDefault(require("rimraf"));
+const DEFAULT_CASE_CONFIG = {
+    webpackPath: require.resolve("webpack"),
+    rspackPath: require.resolve("@rspack/core"),
+    files: ["bundle.js"],
+    bootstrap: true,
+    detail: true
+};
+function createDiffCase(name, src, dist) {
+    const caseConfigFile = path_1.default.join(src, "test.config.js");
+    if (!fs_extra_1.default.existsSync(caseConfigFile)) {
+        return;
+    }
+    const caseConfig = Object.assign({}, DEFAULT_CASE_CONFIG, require(caseConfigFile));
+    const [processor, compareMap] = createDiffProcessor(caseConfig);
+    const tester = new __1.Tester({
+        name,
+        src,
+        dist,
+        steps: [processor]
+    });
+    describe(name, () => {
+        beforeAll(async () => {
+            rimraf_1.default.sync(dist);
+            await tester.prepare();
+        });
+        do {
+            const prefix = `[${name}][${tester.step + 1}]:`;
+            describe(`${prefix}build`, () => {
+                beforeAll(async () => {
+                    await tester.compile();
+                });
+                checkBundleFiles("webpack", path_1.default.join(dist, "webpack"), caseConfig.files);
+                checkBundleFiles("rspack", path_1.default.join(dist, "rspack"), caseConfig.files);
+            });
+            describe(`${prefix}check`, () => {
+                beforeAll(async () => {
+                    compareMap.clear();
+                    await tester.check();
+                });
+                for (let file of caseConfig.files) {
+                    describe(`Comparing "${file}"`, () => {
+                        let moduleResults = [];
+                        let runtimeResults = [];
+                        beforeAll(() => {
+                            const fileResult = compareMap.get(file);
+                            if (!fileResult) {
+                                throw new Error(`File ${file} has no results`);
+                            }
+                            moduleResults = fileResult.modules;
+                            runtimeResults = fileResult.runtimeModules;
+                        });
+                        if (caseConfig.modules) {
+                            checkCompareResults("modules", () => moduleResults);
+                        }
+                        if (caseConfig.runtimeModules) {
+                            checkCompareResults("runtime modules", () => runtimeResults);
+                        }
+                    });
+                }
+            });
+        } while (tester.next());
+        afterAll(async () => {
+            await tester.resume();
+        });
+    });
+}
+exports.createDiffCase = createDiffCase;
+function createDiffProcessor(config) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const fileCompareMap = new Map();
+    const createCompareResultHandler = (type) => {
+        return (file, results) => {
+            const fileResult = fileCompareMap.get(file) || {
+                modules: [],
+                runtimeModules: []
+            };
+            fileResult[type] = results;
+            fileCompareMap.set(file, fileResult);
+        };
+    };
+    const processor = new __1.DiffProcessor({
+        webpackPath: config.webpackPath,
+        rspackPath: config.rspackPath,
+        files: config.files,
+        modules: config.modules,
+        runtimeModules: config.runtimeModules,
+        ignoreModuleId: (_a = config.ignoreModuleId) !== null && _a !== void 0 ? _a : true,
+        ignoreModuleArguments: (_b = config.ignoreModuleArguments) !== null && _b !== void 0 ? _b : true,
+        ignorePropertyQuotationMark: (_c = config.ignorePropertyQuotationMark) !== null && _c !== void 0 ? _c : true,
+        ignoreBlockOnlyStatement: (_d = config.ignoreBlockOnlyStatement) !== null && _d !== void 0 ? _d : true,
+        ignoreSwcHelpersPath: (_e = config.ignoreSwcHelpersPath) !== null && _e !== void 0 ? _e : true,
+        ignoreObjectPropertySequence: (_f = config.ignoreObjectPropertySequence) !== null && _f !== void 0 ? _f : true,
+        ignoreCssFilePath: (_g = config.ignoreCssFilePath) !== null && _g !== void 0 ? _g : true,
+        onCompareModules: createCompareResultHandler("modules"),
+        onCompareRuntimeModules: createCompareResultHandler("runtimeModules"),
+        bootstrap: (_h = config.bootstrap) !== null && _h !== void 0 ? _h : true,
+        detail: (_j = config.detail) !== null && _j !== void 0 ? _j : true
+    });
+    return [processor, fileCompareMap];
+}
+function checkBundleFiles(name, dist, files) {
+    describe(`Checking ${name} dist files`, () => {
+        for (let file of files) {
+            it(`${name}: ${file} should be generated`, () => {
+                expect(fs_extra_1.default.existsSync(path_1.default.join(dist, file))).toBeTruthy();
+            });
+        }
+    });
+}
+function checkCompareResults(name, getResults) {
+    describe(`Comparing ${name}`, () => {
+        it("should not miss any module", () => {
+            expect(getResults()
+                .filter(i => i.type === __1.ECompareResultType.Missing)
+                .map(i => i.name)).toEqual([]);
+        });
+        it("should not have any respack-only module", () => {
+            expect(getResults()
+                .filter(i => i.type === __1.ECompareResultType.OnlySource)
+                .map(i => i.name)).toEqual([]);
+        });
+        it("should not have any webpack-only module", () => {
+            expect(getResults()
+                .filter(i => i.type === __1.ECompareResultType.OnlyDist)
+                .map(i => i.name)).toEqual([]);
+        });
+        it(`all modules should be the same`, () => {
+            for (let result of getResults().filter(i => i.type === __1.ECompareResultType.Different)) {
+                console.log(`${result.name}:\n${result.detail}`);
+            }
+            expect(getResults().every(i => i.type === __1.ECompareResultType.Same)).toEqual(true);
+        });
+    });
+}

package/dist/compare/comparator.d.ts

@@ -8,6 +8,7 @@ export interface IDiffComparatorOptions {
     runtimeModules?: TCompareModules;
     reporters: ITestReporter<unknown>[];
     formatOptions?: IFormatCodeOptions;
+    bootstrap?: boolean;
 }
 export declare class DiffComparator {
     private options;

package/dist/compare/comparator.js

@@ -28,7 +28,8 @@ class DiffComparator {
                         ignoreObjectPropertySequence: true,
                         ignoreCssFilePath: true
                     }, this.options.formatOptions || {}),
-                    renameModule: replace_runtime_module_name_1.replaceRuntimeModuleName
+                    renameModule: replace_runtime_module_name_1.replaceRuntimeModuleName,
+                    bootstrap: this.options.bootstrap
                 });
                 for (let reporter of this.options.reporters) {
                     reporter.increment(file, result.modules["modules"] || []);
@@ -38,6 +39,7 @@ class DiffComparator {
                 }
             }
             catch (e) {
+                console.error(e);
                 for (let reporter of this.options.reporters) {
                     reporter.failure(file);
                 }

package/dist/compare/compare.d.ts

@@ -5,7 +5,9 @@ export interface ICompareOptions {
     runtimeModules?: TCompareModules;
     format: IFormatCodeOptions;
     renameModule?: (name: string) => string;
+    bootstrap?: boolean;
+    detail?: boolean;
 }
 export declare function compareFile(sourceFile: string, distFile: string, compareOptions: ICompareOptions): TFileCompareResult;
-export declare function compareModules(modules: string[], sourceModules: Map<string, string>, distModules: Map<string, string>, formatOptions: IFormatCodeOptions): TModuleCompareResult[];
-export declare function compareContent(sourceContent: string | false, distContent: string | false): TCompareResult;
+export declare function compareModules(modules: string[], sourceModules: Map<string, string>, distModules: Map<string, string>, compareOptions: ICompareOptions): TModuleCompareResult[];
+export declare function compareContent(sourceContent: string | false, distContent: string | false, compareOptions: ICompareOptions): TCompareResult;

package/dist/compare/compare.js

@@ -39,8 +39,12 @@ function compareFile(sourceFile, distFile, compareOptions) {
     // result.detail = compareContentResult.detail;
     // result.lines = compareContentResult.lines;
     result.type = type_1.ECompareResultType.Different;
-    const sourceModules = (0, helper_1.parseModules)(sourceContent);
-    const distModules = (0, helper_1.parseModules)(distContent);
+    const sourceModules = (0, helper_1.parseModules)(sourceContent, {
+        bootstrap: compareOptions.bootstrap
+    });
+    const distModules = (0, helper_1.parseModules)(distContent, {
+        bootstrap: compareOptions.bootstrap
+    });
     for (let type of ["modules", "runtimeModules"]) {
         const t = type;
         let moduleList = [];
@@ -59,28 +63,28 @@ function compareFile(sourceFile, distFile, compareOptions) {
         if (typeof compareOptions.renameModule === "function") {
             moduleList = moduleList.map(compareOptions.renameModule);
         }
-        result.modules[t] = compareModules(moduleList, sourceModules[t], distModules[t], compareOptions.format);
+        result.modules[t] = compareModules(moduleList, sourceModules[t], distModules[t], compareOptions);
     }
     return result;
 }
 exports.compareFile = compareFile;
-function compareModules(modules, sourceModules, distModules, formatOptions) {
+function compareModules(modules, sourceModules, distModules, compareOptions) {
     const compareResults = [];
     for (let name of modules) {
         const renamed = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(name);
         const sourceContent = sourceModules.has(renamed) &&
-            (0, format_code_1.formatCode)(name, sourceModules.get(renamed), formatOptions);
+            (0, format_code_1.formatCode)(name, sourceModules.get(renamed), compareOptions.format);
         const distContent = distModules.has(renamed) &&
-            (0, format_code_1.formatCode)(name, distModules.get(renamed), formatOptions);
+            (0, format_code_1.formatCode)(name, distModules.get(renamed), compareOptions.format);
         compareResults.push({
-            ...compareContent(sourceContent, distContent),
+            ...compareContent(sourceContent, distContent, compareOptions),
             name
         });
     }
     return compareResults;
 }
 exports.compareModules = compareModules;
-function compareContent(sourceContent, distContent) {
+function compareContent(sourceContent, distContent, compareOptions) {
     if (sourceContent) {
         if (distContent) {
             if (sourceContent === distContent) {
@@ -97,7 +101,9 @@ function compareContent(sourceContent, distContent) {
                 };
             }
             else {
-                const difference = (0, jest_diff_1.diffStringsUnified)(sourceContent.trim(), distContent.trim());
+                const difference = compareOptions.detail
+                    ? (0, jest_diff_1.diffStringsUnified)(sourceContent.trim(), distContent.trim())
+                    : undefined;
                 const diffLines = (0, jest_diff_1.diffLinesRaw)(sourceContent.trim().split("\n"), distContent.trim().split("\n"));
                 return {
                     type: type_1.ECompareResultType.Different,

package/dist/helper/parse-modules.d.ts

@@ -1,4 +1,6 @@
-export declare function parseModules(content: string): {
+export declare function parseModules(content: string, options?: {
+    bootstrap?: boolean;
+}): {
     modules: Map<string, string>;
     runtimeModules: Map<string, string>;
 };

package/dist/helper/parse-modules.js

@@ -25,30 +25,40 @@ function getStringBetween(raw, position, start, end) {
         remain: endFlagIndex + end.length
     };
 }
-function parseModules(content) {
+function isValidModule(name) {
+    if (name.startsWith("data:")) {
+        return false;
+    }
+    if (name.startsWith("https:")) {
+        return false;
+    }
+    return true;
+}
+function parseModules(content, options = {}) {
     const modules = new Map();
     const runtimeModules = new Map();
     let currentPosition = 0;
-    // parse bootstrap code
-    const bootstrap = getStringBetween(content, 0, BOOTSTRAP_SPLIT_LINE, BOOTSTRAP_SPLIT_LINE);
-    if (bootstrap.result) {
-        runtimeModules.set("webpack/runtime/bootstrap", bootstrap.result);
+    if (options.bootstrap) {
+        // parse bootstrap code
+        const bootstrap = getStringBetween(content, 0, BOOTSTRAP_SPLIT_LINE, BOOTSTRAP_SPLIT_LINE);
+        if (bootstrap.result) {
+            runtimeModules.set("webpack/runtime/bootstrap", bootstrap.result);
+        }
     }
     // parse module & runtime module code
     let moduleName = getStringBetween(content, currentPosition, MODULE_START_FLAG, MODULE_FLAG_END).result;
-    let totalLength = 0;
     while (moduleName) {
         const moduleContent = getStringBetween(content, currentPosition, `${MODULE_START_FLAG}${moduleName}${MODULE_FLAG_END}`, `${MODULE_END_FLAG}${moduleName}${MODULE_FLAG_END}`);
         if (!moduleContent.result) {
             throw new Error(`Module code parsed error: ${moduleName}`);
         }
         if (moduleName.startsWith("webpack/runtime")) {
-            totalLength += moduleContent.result.length;
             runtimeModules.set(moduleName, moduleContent.result);
         }
         else {
-            totalLength += moduleContent.result.length;
-            modules.set(moduleName, moduleContent.result);
+            if (isValidModule(moduleName)) {
+                modules.set(moduleName, moduleContent.result);
+            }
         }
         currentPosition = moduleContent.remain;
         moduleName = getStringBetween(content, currentPosition, MODULE_START_FLAG, MODULE_FLAG_END).result;

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export * from "./processor";
 export * from "./reporter";
 export * from "./compare";
 export * from "./plugin";
+export * from "./helper";

package/dist/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./processor"), exports);
 __exportStar(require("./reporter"), exports);
 __exportStar(require("./compare"), exports);
 __exportStar(require("./plugin"), exports);
+__exportStar(require("./helper"), exports);

package/dist/plugin/rspack-diff-config-plugin.d.ts

@@ -1,7 +1,7 @@
-import { Compiler, RspackPluginInstance } from "@rspack/core";
+import { Compiler, RspackOptionsNormalized, RspackPluginInstance } from "@rspack/core";
 export declare class RspackDiffConfigPlugin implements RspackPluginInstance {
-    private rspackPath;
+    private modifier?;
     name: string;
-    constructor(rspackPath: string);
+    constructor(modifier?: ((options: RspackOptionsNormalized) => RspackOptionsNormalized) | undefined);
     apply(compiler: Compiler): void;
 }

package/dist/plugin/rspack-diff-config-plugin.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RspackDiffConfigPlugin = void 0;
 const PLUGIN_NAME = "RspackDiffConfigPlugin";
 class RspackDiffConfigPlugin {
-    constructor(rspackPath) {
-        this.rspackPath = rspackPath;
+    constructor(modifier) {
+        this.modifier = modifier;
         this.name = PLUGIN_NAME;
         process.env["RSPACK_DIFF"] = "true"; // enable rspack diff
     }
@@ -21,6 +21,9 @@ class RspackDiffConfigPlugin {
         options.optimization.mangleExports = false;
         (_b = options.experiments) !== null && _b !== void 0 ? _b : (options.experiments = {});
         (_c = (_d = options.experiments).rspackFuture) !== null && _c !== void 0 ? _c : (_d.rspackFuture = {});
+        if (typeof this.modifier === "function") {
+            this.modifier(compiler.options);
+        }
     }
 }
 exports.RspackDiffConfigPlugin = RspackDiffConfigPlugin;

package/dist/plugin/webpack-diff-config-plugin.d.ts

@@ -1,7 +1,7 @@
-import { Compiler } from "webpack";
+import { Compiler, WebpackOptionsNormalized } from "webpack";
 export declare class WebpackDiffConfigPlugin {
-    private webpackPath;
+    private modifier?;
     name: string;
-    constructor(webpackPath: string);
+    constructor(modifier?: ((options: WebpackOptionsNormalized) => WebpackOptionsNormalized) | undefined);
     apply(compiler: Compiler): void;
 }

package/dist/plugin/webpack-diff-config-plugin.js

@@ -4,8 +4,8 @@ exports.WebpackDiffConfigPlugin = void 0;
 const webpack_module_placeholder_plugin_1 = require("./webpack-module-placeholder-plugin");
 const PLUGIN_NAME = "WebpackDiffConfigPlugin";
 class WebpackDiffConfigPlugin {
-    constructor(webpackPath) {
-        this.webpackPath = webpackPath;
+    constructor(modifier) {
+        this.modifier = modifier;
         this.name = PLUGIN_NAME;
     }
     apply(compiler) {
@@ -34,7 +34,10 @@ class WebpackDiffConfigPlugin {
         options.output.environment.module = false;
         options.output.environment.optionalChaining = false;
         options.output.environment.templateLiteral = false;
-        new webpack_module_placeholder_plugin_1.WebpackModulePlaceholderPlugin(this.webpackPath).apply(compiler);
+        if (typeof this.modifier === "function") {
+            this.modifier(compiler.options);
+        }
+        new webpack_module_placeholder_plugin_1.WebpackModulePlaceholderPlugin().apply(compiler);
     }
 }
 exports.WebpackDiffConfigPlugin = WebpackDiffConfigPlugin;

package/dist/plugin/webpack-module-placeholder-plugin.d.ts

@@ -1,5 +1,4 @@
 export declare class WebpackModulePlaceholderPlugin {
-    private webpackPath;
-    constructor(webpackPath: string);
+    constructor();
     apply(compiler: any): void;
 }

package/dist/plugin/webpack-module-placeholder-plugin.js

@@ -4,6 +4,7 @@ exports.WebpackModulePlaceholderPlugin = void 0;
 // @ts-nocheck
 const { ConcatSource, RawSource, CachedSource, PrefixSource } = require("webpack-sources");
 const path = require("path");
+const which = require("which-module");
 function createRenderRuntimeModulesFn(Template) {
     return function renderRuntimeModules(runtimeModules, renderContext) {
         const source = new ConcatSource();
@@ -51,13 +52,12 @@ function createRenderRuntimeModulesFn(Template) {
 }
 const caches = new WeakMap();
 class WebpackModulePlaceholderPlugin {
-    constructor(webpackPath) {
-        this.webpackPath = webpackPath;
-        const Template = require(path.join(path.dirname(this.webpackPath), "Template.js"));
-        Template.renderRuntimeModules = createRenderRuntimeModulesFn(Template);
-    }
+    constructor() { }
     apply(compiler) {
-        const JavascriptModulesPlugin = require(path.join(path.dirname(this.webpackPath), "javascript/JavascriptModulesPlugin.js"));
+        const webpackLibPath = which(compiler.constructor).path;
+        const Template = require(path.join(webpackLibPath, "Template.js"));
+        Template.renderRuntimeModules = createRenderRuntimeModulesFn(Template);
+        const JavascriptModulesPlugin = require(path.join(webpackLibPath, "javascript/JavascriptModulesPlugin.js"));
         compiler.hooks.compilation.tap("RuntimeDiffPlugin", compilation => {
             const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
             hooks.inlineInRuntimeBailout.tap("RuntimeDiffPlugin", () => "not allow inline startup");

package/dist/processor/diff.d.ts

@@ -6,6 +6,8 @@ export interface IDiffProcessorOptions extends IFormatCodeOptions {
     files?: string[];
     modules?: TCompareModules;
     runtimeModules?: TCompareModules;
+    bootstrap?: boolean;
+    detail?: boolean;
     onCompareFile?: (file: string, result: TFileCompareResult) => void;
     onCompareModules?: (file: string, results: TModuleCompareResult[]) => void;
     onCompareRuntimeModules?: (file: string, results: TModuleCompareResult[]) => void;

package/dist/processor/diff.js

@@ -41,7 +41,9 @@ class DiffProcessor {
                 modules: this.options.modules,
                 runtimeModules: this.options.runtimeModules,
                 format: this.createFormatOptions(),
-                renameModule: compare_1.replaceRuntimeModuleName
+                renameModule: compare_1.replaceRuntimeModuleName,
+                bootstrap: this.options.bootstrap,
+                detail: this.options.detail
             });
             if (typeof this.options.onCompareFile === "function") {
                 this.options.onCompareFile(file, result);
@@ -72,10 +74,8 @@ class DiffProcessor {
                 chunkFilename: "[name].chunk.js"
             },
             plugins: [
-                type === type_1.ECompilerType.Webpack &&
-                    new plugin_1.WebpackDiffConfigPlugin(this.options.webpackPath),
-                type === type_1.ECompilerType.Rspack &&
-                    new plugin_1.RspackDiffConfigPlugin(this.options.rspackPath)
+                type === type_1.ECompilerType.Webpack && new plugin_1.WebpackDiffConfigPlugin(),
+                type === type_1.ECompilerType.Rspack && new plugin_1.RspackDiffConfigPlugin()
             ].filter(Boolean)
         }, {
             arrayMerge: (a, b) => [...a, ...b]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/test-tools",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "license": "MIT",
   "description": "Test tools for rspack",
   "main": "dist/index.js",
@@ -36,41 +36,40 @@
     "csv-to-markdown-table": "^1.3.0",
     "deepmerge": "^4.3.1",
     "fs-extra": "^11.1.1",
+    "glob": "^10.3.10",
     "jest-diff": "^29.7.0",
+    "webpack": "5.89.0",
     "webpack-sources": "3.2.3",
-    "@rspack/core": "0.5.0"
+    "which-module": "2.0.1",
+    "@rspack/core": "0.5.1"
   },
   "devDependencies": {
     "@arco-design/web-react": "^2.56.1",
     "@monaco-editor/react": "^4.6.0",
+    "@swc/jest": "^0.2.29",
     "@types/prettier": "^2.7.2",
     "@types/react": "^18.0.25",
     "@types/react-dom": "^18.0.8",
     "@types/webpack": "5.28.3",
     "@types/webpack-sources": "3.2.0",
     "core-js": "3.25.0",
-    "monaco-editor": "^0.34.1",
+    "jest-serializer-path": "^0.1.15",
+    "monaco-editor": "0.45.0",
+    "monaco-editor-webpack-plugin": "7.1.0",
     "normalize.css": "^8.0.0",
     "prettier": "^2.8.3",
     "react": "18.0.0",
     "react-dom": "18.0.0",
     "react-refresh": "0.13.0",
     "typescript": "5.1.6",
-    "webpack": "5.89.0",
-    "@rspack/cli": "0.5.0"
+    "@rspack/cli": "0.5.1"
   },
   "peerDependenciesMeta": {},
-  "jest": {
-    "watchPathIgnorePatterns": [
-      "<rootDir>/dist",
-      "<rootDir>/tests/dist"
-    ],
-    "testEnvironment": "../../scripts/test/patch-node-env.cjs"
-  },
   "scripts": {
     "build": "tsc -b ./tsconfig.build.json",
     "build:viewer": "rspack build",
     "dev:viewer": "rspack serve",
-    "dev": "tsc -b -w"
+    "dev": "tsc -b -w",
+    "test:diff": "cross-env RSPACK_DIFF=true NO_COLOR=1 RSPACK_DEP_WARNINGS=false node --expose-gc --max-old-space-size=8192 --experimental-vm-modules ../../node_modules/jest-cli/bin/jest --runInBand --logHeapUsage --testPathPattern \".diff.test.ts\""
   }
 }