@rspack-debug/test-tools 1.3.14

package/dist/case/new-incremental.js

@@ -0,0 +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.createHotNewIncrementalCase = createHotNewIncrementalCase;
+exports.createWatchNewIncrementalCase = createWatchNewIncrementalCase;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const hot_new_incremental_1 = require("../processor/hot-new-incremental");
+const watch_1 = require("../processor/watch");
+const runner_1 = require("../runner");
+const creator_1 = require("../test/creator");
+const type_1 = require("../type");
+const hotCreators = new Map();
+function getHotCreator(target, webpackCases) {
+    const key = JSON.stringify({ target, webpackCases });
+    if (!hotCreators.has(key)) {
+        hotCreators.set(key, new creator_1.BasicCaseCreator({
+            clean: true,
+            describe: true,
+            target,
+            steps: ({ name, target }) => [
+                new hot_new_incremental_1.HotNewIncrementalProcessor({
+                    name,
+                    target: target,
+                    compilerType: type_1.ECompilerType.Rspack,
+                    configFiles: ["rspack.config.js", "webpack.config.js"],
+                    webpackCases
+                })
+            ],
+            runner: runner_1.HotRunnerFactory,
+            concurrent: true
+        }));
+    }
+    return hotCreators.get(key);
+}
+function createHotNewIncrementalCase(name, src, dist, target, webpackCases) {
+    const creator = getHotCreator(target, webpackCases);
+    creator.create(name, src, dist);
+}
+const watchCreators = new Map();
+function getWatchCreator(options) {
+    const key = JSON.stringify(options);
+    if (!watchCreators.has(key)) {
+        watchCreators.set(key, new creator_1.BasicCaseCreator({
+            clean: true,
+            runner: runner_1.WatchRunnerFactory,
+            description: (name, index) => {
+                return index === 0
+                    ? `${name} should compile`
+                    : `should compile step ${index}`;
+            },
+            describe: false,
+            steps: ({ name, src, temp }) => {
+                const watchState = {};
+                const runs = node_fs_1.default
+                    .readdirSync(src)
+                    .sort()
+                    .filter(name => {
+                    return node_fs_1.default.statSync(node_path_1.default.join(src, name)).isDirectory();
+                })
+                    .map(name => ({ name }));
+                return runs.map((run, index) => index === 0
+                    ? new watch_1.WatchProcessor({
+                        name,
+                        stepName: run.name,
+                        tempDir: temp,
+                        runable: true,
+                        compilerType: type_1.ECompilerType.Rspack,
+                        configFiles: ["rspack.config.js", "webpack.config.js"],
+                        defaultOptions(index, context) {
+                            return {
+                                experiments: {
+                                    incremental: "advance"
+                                },
+                                ignoreWarnings: options.ignoreNotFriendlyForIncrementalWarnings
+                                    ? [/is not friendly for incremental/]
+                                    : undefined
+                            };
+                        }
+                    }, watchState)
+                    : new watch_1.WatchStepProcessor({
+                        name,
+                        stepName: run.name,
+                        tempDir: temp,
+                        runable: true,
+                        compilerType: type_1.ECompilerType.Rspack,
+                        configFiles: ["rspack.config.js", "webpack.config.js"]
+                    }, watchState));
+            },
+            concurrent: true
+        }));
+    }
+    return watchCreators.get(key);
+}
+function createWatchNewIncrementalCase(name, src, dist, temp, options = {}) {
+    const creator = getWatchCreator(options);
+    creator.create(name, src, dist, temp);
+}

package/dist/case/normal.d.ts

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

package/dist/case/normal.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNormalCase = createNormalCase;
+const node_path_1 = __importDefault(require("node:path"));
+const normal_1 = require("../processor/normal");
+const runner_1 = require("../runner");
+const creator_1 = require("../test/creator");
+const type_1 = require("../type");
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    steps: ({ name }) => [
+        new normal_1.NormalProcessor({
+            name,
+            root: node_path_1.default.resolve(__dirname, "../../tests/normalCases"),
+            compilerOptions: {}, // do not used in rspack
+            runable: true,
+            compilerType: type_1.ECompilerType.Rspack
+        })
+    ],
+    runner: runner_1.NormalRunnerFactory,
+    concurrent: true
+});
+function createNormalCase(name, src, dist) {
+    creator.create(name, src, dist);
+}

package/dist/case/serial.d.ts

@@ -0,0 +1,3 @@
+import { ECompilerType, type TTestConfig } from "../type";
+export type TSerialCaseConfig = Omit<TTestConfig<ECompilerType.Rspack>, "validate">;
+export declare function createSerialCase(name: string, src: string, dist: string): void;

package/dist/case/serial.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSerialCase = createSerialCase;
+const config_1 = require("../processor/config");
+const runner_1 = require("../runner");
+const creator_1 = require("../test/creator");
+const type_1 = require("../type");
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    testConfig: testConfig => {
+        const oldModuleScope = testConfig.moduleScope;
+        testConfig.moduleScope = (ms, stats) => {
+            let res = ms;
+            // TODO: modify runner module scope based on stats here
+            if (typeof oldModuleScope === "function") {
+                res = oldModuleScope(ms, stats);
+            }
+            return res;
+        };
+    },
+    steps: ({ name }) => [
+        new config_1.ConfigProcessor({
+            name,
+            runable: true,
+            compilerType: type_1.ECompilerType.Rspack,
+            configFiles: ["rspack.config.js", "webpack.config.js"]
+        })
+    ],
+    runner: runner_1.MultipleRunnerFactory
+});
+function createSerialCase(name, src, dist) {
+    creator.create(name, src, dist);
+}

package/dist/case/stats-api.d.ts

@@ -0,0 +1,6 @@
+import { type IStatsAPIProcessorOptions } from "../processor";
+import { ECompilerType } from "../type";
+export type TStatsAPICaseConfig = Omit<IStatsAPIProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
+    description: string;
+};
+export declare function createStatsAPICase(name: string, src: string, dist: string, testConfig: string): void;

package/dist/case/stats-api.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatsAPICase = createStatsAPICase;
+const processor_1 = require("../processor");
+const simple_1 = require("../test/simple");
+const type_1 = require("../type");
+let addedSerializer = false;
+function createStatsAPICase(name, src, dist, testConfig) {
+    if (!addedSerializer) {
+        addedSerializer = true;
+    }
+    const caseConfig = require(testConfig);
+    const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
+    it(caseConfig.description, async () => {
+        await runner(name, new processor_1.StatsAPIProcessor({
+            name: name,
+            compilerType: type_1.ECompilerType.Rspack,
+            ...caseConfig
+        }));
+    });
+}

package/dist/case/stats-output.d.ts

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

package/dist/case/stats-output.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatsOutputCase = createStatsOutputCase;
+const stats_1 = require("../processor/stats");
+const creator_1 = require("../test/creator");
+const type_1 = require("../type");
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    steps: ({ name }) => [
+        new stats_1.StatsProcessor({
+            name,
+            writeStatsOuptut: false,
+            compilerType: type_1.ECompilerType.Rspack,
+            configFiles: ["rspack.config.js", "webpack.config.js"]
+        })
+    ],
+    description: () => "should print correct stats for"
+});
+function createStatsOutputCase(name, src, dist) {
+    creator.create(name, src, dist);
+}

package/dist/case/treeshaking.d.ts

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

package/dist/case/treeshaking.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTreeShakingCase = createTreeShakingCase;
+const treeshaking_1 = require("../processor/treeshaking");
+const creator_1 = require("../test/creator");
+const type_1 = require("../type");
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    description(name, step) {
+        return `${name} with newTreeshaking should match snapshot`;
+    },
+    steps: ({ name }) => [
+        new treeshaking_1.TreeShakingProcessor({
+            name,
+            snapshot: "treeshaking.snap.txt",
+            compilerType: type_1.ECompilerType.Rspack
+        })
+    ]
+});
+function createTreeShakingCase(name, src, dist) {
+    creator.create(name, src, dist);
+}

package/dist/case/watch.d.ts

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

package/dist/case/watch.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWatchCase = createWatchCase;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const watch_1 = require("../processor/watch");
+const runner_1 = require("../runner");
+const creator_1 = require("../test/creator");
+const type_1 = require("../type");
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    runner: runner_1.WatchRunnerFactory,
+    description: (name, index) => {
+        return index === 0
+            ? `${name} should compile`
+            : `should compile step ${index}`;
+    },
+    describe: false,
+    steps: ({ name, src, temp }) => {
+        const watchState = {};
+        const runs = node_fs_1.default
+            .readdirSync(src)
+            .sort()
+            .filter(name => {
+            return node_fs_1.default.statSync(node_path_1.default.join(src, name)).isDirectory();
+        })
+            .map(name => ({ name }));
+        return runs.map((run, index) => index === 0
+            ? new watch_1.WatchProcessor({
+                name,
+                stepName: run.name,
+                tempDir: temp,
+                runable: true,
+                compilerType: type_1.ECompilerType.Rspack,
+                configFiles: ["rspack.config.js", "webpack.config.js"]
+            }, watchState)
+            : new watch_1.WatchStepProcessor({
+                name,
+                stepName: run.name,
+                tempDir: temp,
+                runable: true,
+                compilerType: type_1.ECompilerType.Rspack,
+                configFiles: ["rspack.config.js", "webpack.config.js"]
+            }, watchState));
+    },
+    concurrent: true
+});
+function createWatchCase(name, src, dist, temp) {
+    creator.create(name, src, dist, temp);
+}

package/dist/compare/comparator.d.ts

@@ -0,0 +1,17 @@
+import type { ITestReporter, TCompareModules } from "../type";
+import type { IFormatCodeOptions } from "./format-code";
+export interface IDiffComparatorOptions {
+    rspackDist: string;
+    webpackDist: string;
+    files: string[];
+    modules?: TCompareModules;
+    runtimeModules?: TCompareModules;
+    reporters: ITestReporter<unknown>[];
+    formatOptions?: IFormatCodeOptions;
+    bootstrap?: boolean;
+}
+export declare class DiffComparator {
+    private options;
+    constructor(options: IDiffComparatorOptions);
+    compare(): Promise<void>;
+}

package/dist/compare/comparator.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffComparator = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const compare_1 = require("./compare");
+const replace_runtime_module_name_1 = require("./replace-runtime-module-name");
+class DiffComparator {
+    constructor(options) {
+        this.options = options;
+    }
+    async compare() {
+        for (const file of this.options.files) {
+            try {
+                const result = (0, compare_1.compareFile)(node_path_1.default.join(this.options.rspackDist, file), node_path_1.default.join(this.options.webpackDist, file), {
+                    modules: this.options.modules,
+                    runtimeModules: this.options.runtimeModules,
+                    format: (0, deepmerge_1.default)({
+                        replacements: {},
+                        ignorePropertyQuotationMark: true,
+                        ignoreModuleId: true,
+                        ignoreModuleArguments: true,
+                        ignoreBlockOnlyStatement: true,
+                        ignoreIfCertainCondition: true,
+                        ignoreSwcHelpersPath: true,
+                        ignoreObjectPropertySequence: true,
+                        ignoreCssFilePath: true
+                    }, this.options.formatOptions || {}),
+                    renameModule: replace_runtime_module_name_1.replaceRuntimeModuleName,
+                    bootstrap: this.options.bootstrap
+                });
+                for (const reporter of this.options.reporters) {
+                    reporter.increment(file, result.modules.modules || []);
+                }
+                for (const reporter of this.options.reporters) {
+                    reporter.increment(file, result.modules.runtimeModules || []);
+                }
+            }
+            catch (e) {
+                console.error(e);
+                for (const reporter of this.options.reporters) {
+                    reporter.failure(file);
+                }
+            }
+        }
+        await Promise.all(this.options.reporters.map(r => r.output()));
+    }
+}
+exports.DiffComparator = DiffComparator;

package/dist/compare/compare.d.ts

@@ -0,0 +1,17 @@
+import { type TCompareModules, type TCompareResult, type TFileCompareResult, type TModuleCompareResult } from "../type";
+import { type IFormatCodeOptions } from "./format-code";
+declare global {
+    var updateSnapshot: boolean;
+}
+export interface ICompareOptions {
+    modules?: TCompareModules;
+    runtimeModules?: TCompareModules;
+    format: IFormatCodeOptions;
+    renameModule?: (name: string) => string;
+    bootstrap?: boolean;
+    detail?: boolean;
+    snapshot?: string;
+}
+export declare function compareFile(sourceFile: string, distFile: string, compareOptions: ICompareOptions): TFileCompareResult;
+export declare function compareModules(modules: string[], sourceModules: Record<string, string>, distModules: Record<string, string>, compareOptions: ICompareOptions): TModuleCompareResult[];
+export declare function compareContent(sourceContent: string | false, distContent: string | false, compareOptions: ICompareOptions): TCompareResult;

package/dist/compare/compare.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareFile = compareFile;
+exports.compareModules = compareModules;
+exports.compareContent = compareContent;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const jest_diff_1 = require("jest-diff");
+const node_path_1 = __importDefault(require("node:path"));
+const helper_1 = require("../helper");
+const type_1 = require("../type");
+const format_code_1 = require("./format-code");
+const replace_runtime_module_name_1 = require("./replace-runtime-module-name");
+const WORKSPACE = node_path_1.default.resolve(__dirname, "../../../..");
+function compareFile(sourceFile, distFile, compareOptions) {
+    const result = {
+        type: type_1.ECompareResultType.Same,
+        file: {
+            source: sourceFile,
+            dist: distFile
+        },
+        modules: {}
+    };
+    const sourceExists = fs_extra_1.default.existsSync(sourceFile);
+    const distExists = compareOptions.snapshot
+        ? fs_extra_1.default.existsSync(compareOptions.snapshot)
+        : fs_extra_1.default.existsSync(distFile);
+    if (!sourceExists && !distExists) {
+        result.type = type_1.ECompareResultType.Missing;
+        return result;
+    }
+    if (!sourceExists && distExists) {
+        result.type = type_1.ECompareResultType.OnlyDist;
+        return result;
+    }
+    if (sourceExists && !distExists) {
+        result.type = type_1.ECompareResultType.OnlySource;
+        return result;
+    }
+    function formatModules(modules) {
+        const res = {};
+        for (const [name, content] of Object.entries(modules)) {
+            const renamed = name.replaceAll(node_path_1.default.win32.sep, node_path_1.default.posix.sep);
+            if (!renamed.includes("node_modules/css-loader/dist")) {
+                res[renamed] = (0, format_code_1.formatCode)(renamed, content, compareOptions.format);
+            }
+        }
+        return res;
+    }
+    const sourceContent = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(fs_extra_1.default.readFileSync(sourceFile, "utf-8").replaceAll(WORKSPACE, "__WORKSPACE__"));
+    const sourceModules = (0, helper_1.parseModules)(sourceContent, {
+        bootstrap: compareOptions.bootstrap,
+        renameModule: compareOptions.renameModule
+    });
+    sourceModules.modules = formatModules(sourceModules.modules);
+    sourceModules.runtimeModules = formatModules(sourceModules.runtimeModules);
+    let distModules = {
+        modules: {},
+        runtimeModules: {}
+    };
+    if (!global.updateSnapshot &&
+        compareOptions.snapshot &&
+        fs_extra_1.default.existsSync(compareOptions.snapshot)) {
+        distModules = JSON.parse(fs_extra_1.default.readFileSync(compareOptions.snapshot, "utf-8"));
+    }
+    else {
+        const distContent = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(fs_extra_1.default.readFileSync(distFile, "utf-8").replaceAll(WORKSPACE, "__WORKSPACE__"));
+        distModules = (0, helper_1.parseModules)(distContent, {
+            bootstrap: compareOptions.bootstrap,
+            renameModule: compareOptions.renameModule
+        });
+        distModules.modules = formatModules(distModules.modules);
+        distModules.runtimeModules = formatModules(distModules.runtimeModules);
+        if (compareOptions.snapshot) {
+            fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(compareOptions.snapshot));
+            fs_extra_1.default.writeFileSync(compareOptions.snapshot, JSON.stringify(distModules, null, 2));
+        }
+    }
+    result.type = type_1.ECompareResultType.Different;
+    for (const type of ["modules", "runtimeModules"]) {
+        const t = type;
+        let moduleList = [];
+        if (compareOptions[t] === true) {
+            moduleList = [
+                ...Object.keys(sourceModules[t]),
+                ...Object.keys(distModules[t])
+            ].filter((i, idx, arr) => arr.indexOf(i) === idx);
+        }
+        else if (Array.isArray(compareOptions[t])) {
+            moduleList = compareOptions[t];
+        }
+        else {
+            continue;
+        }
+        result.modules[t] = compareModules(moduleList, sourceModules[t], distModules[t], compareOptions);
+    }
+    return result;
+}
+function compareModules(modules, sourceModules, distModules, compareOptions) {
+    const compareResults = [];
+    for (const name of modules) {
+        const renamed = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(name).replaceAll(node_path_1.default.win32.sep, node_path_1.default.posix.sep);
+        const sourceContent = sourceModules[renamed];
+        const distContent = distModules[renamed];
+        compareResults.push({
+            ...compareContent(sourceContent, distContent, compareOptions),
+            name
+        });
+    }
+    return compareResults;
+}
+function compareContent(sourceContent, distContent, compareOptions) {
+    if (sourceContent) {
+        if (distContent) {
+            if (sourceContent === distContent) {
+                const lines = sourceContent.trim().split("\n").length;
+                return {
+                    type: type_1.ECompareResultType.Same,
+                    source: sourceContent,
+                    dist: distContent,
+                    lines: {
+                        source: 0,
+                        common: lines,
+                        dist: 0
+                    }
+                };
+            }
+            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,
+                detail: difference,
+                source: sourceContent,
+                dist: distContent,
+                lines: {
+                    source: diffLines.filter(l => l[0] < 0).length,
+                    common: diffLines.filter(l => l[0] === 0).length,
+                    dist: diffLines.filter(l => l[0] > 0).length
+                }
+            };
+        }
+        return {
+            type: type_1.ECompareResultType.OnlySource,
+            source: sourceContent,
+            lines: {
+                source: sourceContent.trim().split("\n").length,
+                common: 0,
+                dist: 0
+            }
+        };
+    }
+    if (distContent) {
+        return {
+            type: type_1.ECompareResultType.OnlyDist,
+            dist: distContent,
+            lines: {
+                source: 0,
+                common: 0,
+                dist: distContent.trim().split("\n").length
+            }
+        };
+    }
+    return {
+        type: type_1.ECompareResultType.Missing,
+        lines: {
+            source: 0,
+            common: 0,
+            dist: 0
+        }
+    };
+}

package/dist/compare/format-code.d.ts

@@ -0,0 +1,16 @@
+export interface IFormatCodeOptions {
+    replacements?: IFormatCodeReplacement[];
+    ignorePropertyQuotationMark: boolean;
+    ignoreModuleId: boolean;
+    ignoreModuleArguments: boolean;
+    ignoreBlockOnlyStatement: boolean;
+    ignoreSwcHelpersPath: boolean;
+    ignoreObjectPropertySequence: boolean;
+    ignoreCssFilePath: boolean;
+    ignoreIfCertainCondition: boolean;
+}
+export interface IFormatCodeReplacement {
+    from: string | RegExp;
+    to: string;
+}
+export declare function formatCode(name: string, raw: string, options: IFormatCodeOptions): string;