@rspack-canary/test-tools 1.5.6-canary-e598f284-20250921173624 → 1.5.8-canary-e350b761-20250924173613

package/dist/case/builtin.d.ts

@@ -1 +1,3 @@
+import type { ECompilerType, ITestContext, TCompilerOptions } from "../type";
 export declare function createBuiltinCase(name: string, src: string, dist: string): void;
+export declare function defaultOptions<T extends ECompilerType.Rspack>(context: ITestContext): TCompilerOptions<T>;

package/dist/case/builtin.js

@@ -4,16 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBuiltinCase = createBuiltinCase;
+exports.defaultOptions = defaultOptions;
 const node_path_1 = __importDefault(require("node:path"));
+const core_1 = require("@rspack/core");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const webpack_merge_1 = require("webpack-merge");
 const helper_1 = require("../helper");
-const processor_1 = require("../processor");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
-const FILTERS = {
-    "plugin-css": (file) => file.endsWith(".css"),
-    "plugin-css-modules": (file) => file.endsWith(".css") || ((0, helper_1.isJavaScript)(file) && !file.includes("runtime")),
-    "plugin-html": (file) => file.endsWith(".html")
-};
+const common_1 = require("./common");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
@@ -24,12 +22,24 @@ const creator = new creator_1.BasicCaseCreator({
         const cat = node_path_1.default.basename(node_path_1.default.dirname(src));
         const filter = FILTERS[cat];
         return [
-            new processor_1.BuiltinProcessor({
-                name,
-                snapshot: "output.snap.txt",
-                snapshotFileFilter: filter,
-                compilerType: type_1.ECompilerType.Rspack
-            })
+            {
+                config: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    compiler.setOptions(defaultOptions(context));
+                },
+                compiler: async (context) => {
+                    await (0, common_1.compiler)(context, name);
+                },
+                build: async (context) => {
+                    await (0, common_1.build)(context, name);
+                },
+                run: async (env, context) => {
+                    // no need to run, just check snapshot
+                },
+                check: async (env, context) => {
+                    await (0, common_1.checkSnapshot)(env, context, name, "output.snap.txt", filter);
+                }
+            }
         ];
     },
     concurrent: true
@@ -37,3 +47,153 @@ const creator = new creator_1.BasicCaseCreator({
 function createBuiltinCase(name, src, dist) {
     creator.create(name, src, dist);
 }
+function defaultOptions(context) {
+    let defaultOptions = {
+        entry: {
+            main: {
+                import: "./index"
+            }
+        },
+        output: {
+            publicPath: "/",
+            path: context.getDist(),
+            filename: "[name].js",
+            chunkFilename: "[name].js",
+            chunkFormat: "array-push",
+            cssFilename: "[name].css",
+            cssChunkFilename: "[name].css",
+            assetModuleFilename: "[hash][ext][query]",
+            sourceMapFilename: "[file].map",
+            chunkLoadingGlobal: "webpackChunkwebpack",
+            chunkLoading: "jsonp",
+            uniqueName: "__rspack_test__",
+            enabledLibraryTypes: ["system"],
+            strictModuleErrorHandling: false,
+            iife: true,
+            module: false,
+            asyncChunks: true,
+            scriptType: false,
+            globalObject: "self",
+            importFunctionName: "import",
+            wasmLoading: "fetch",
+            webassemblyModuleFilename: "[hash].module.wasm",
+            workerChunkLoading: "import-scripts",
+            workerWasmLoading: "fetch"
+        },
+        module: {
+            rules: [
+                {
+                    test: /\.json$/,
+                    type: "json"
+                },
+                {
+                    test: /\.mjs$/,
+                    type: "javascript/esm"
+                },
+                {
+                    test: /\.cjs$/,
+                    type: "javascript/dynamic"
+                },
+                {
+                    test: /\.js$/,
+                    type: "javascript/auto"
+                },
+                {
+                    test: /\.css$/,
+                    type: "css"
+                },
+                {
+                    test: /\.wasm$/,
+                    type: "webassembly/async"
+                }
+            ]
+        },
+        node: {
+            __dirname: "mock",
+            __filename: "mock",
+            global: "warn"
+        },
+        optimization: {
+            runtimeChunk: {
+                name: "runtime"
+            },
+            minimize: false,
+            removeAvailableModules: true,
+            removeEmptyChunks: true,
+            moduleIds: "named",
+            chunkIds: "named",
+            sideEffects: false,
+            mangleExports: false,
+            usedExports: false,
+            concatenateModules: false,
+            nodeEnv: false
+        },
+        resolve: {
+            extensions: [
+                ".js",
+                ".jsx",
+                ".ts",
+                ".tsx",
+                ".json",
+                ".d.ts",
+                ".css",
+                ".wasm"
+            ]
+        },
+        resolveLoader: {
+            extensions: [".js"]
+        },
+        experiments: {
+            css: true,
+            futureDefaults: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            }
+        },
+        devtool: false,
+        context: context.getSource(),
+        plugins: []
+    };
+    const testConfigFile = context.getSource("rspack.config.js");
+    if (fs_extra_1.default.existsSync(testConfigFile)) {
+        const caseOptions = require(testConfigFile);
+        if (caseOptions.entry) {
+            delete defaultOptions.entry;
+        }
+        defaultOptions = (0, webpack_merge_1.merge)(defaultOptions, caseOptions);
+    }
+    // TODO: remove builtin compatible code
+    const defineOptions = defaultOptions.builtins?.define;
+    if (defineOptions) {
+        defaultOptions.plugins.push(new core_1.rspack.DefinePlugin(defineOptions));
+    }
+    const provideOptions = defaultOptions.builtins?.provide;
+    if (provideOptions) {
+        defaultOptions.plugins.push(new core_1.rspack.ProvidePlugin(provideOptions));
+    }
+    const htmlOptions = defaultOptions.builtins?.html;
+    if (htmlOptions) {
+        if (Array.isArray(htmlOptions)) {
+            for (const item of htmlOptions) {
+                defaultOptions.plugins.push(new core_1.rspack.HtmlRspackPlugin(item));
+            }
+        }
+        else {
+            defaultOptions.plugins.push(new core_1.rspack.HtmlRspackPlugin(htmlOptions));
+        }
+    }
+    delete defaultOptions.builtins;
+    if (!global.printLogger) {
+        defaultOptions.infrastructureLogging = {
+            level: "error"
+        };
+    }
+    return defaultOptions;
+}
+const FILTERS = {
+    "plugin-css": (file) => file.endsWith(".css"),
+    "plugin-css-modules": (file) => file.endsWith(".css") || ((0, helper_1.isJavaScript)(file) && !file.includes("runtime")),
+    "plugin-html": (file) => file.endsWith(".html")
+};

package/dist/case/cache.d.ts

@@ -1,2 +1,2 @@
-import { ECompilerType, type TCompilerOptions } from "../type";
+import { type ECompilerType, type TCompilerOptions } from "../type";
 export declare function createCacheCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"], temp: string): void;

package/dist/case/cache.js

@@ -1,11 +1,55 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCacheCase = createCacheCase;
-const cache_1 = require("../processor/cache");
+const node_path_1 = __importDefault(require("node:path"));
+const core_1 = __importDefault(require("@rspack/core"));
+const helper_1 = require("../helper");
+const hot_update_1 = require("../helper/hot-update");
+const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
-const creators = new Map();
+const common_1 = require("./common");
+const runner_2 = require("./runner");
+const MAX_COMPILER_INDEX = 100;
+function createCacheProcessor(name, src, temp, target) {
+    const updatePlugin = new hot_update_1.HotUpdatePlugin(src, temp);
+    return {
+        before: async (context) => {
+            await updatePlugin.initialize();
+            context.setValue(name, "hotUpdateContext", updatePlugin);
+        },
+        config: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            let options = defaultOptions(context, temp, target);
+            options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"].map(i => node_path_1.default.resolve(temp, i)), options);
+            overrideOptions(options, temp, target, updatePlugin);
+            compiler.setOptions(options);
+        },
+        compiler: async (context) => {
+            await (0, common_1.compiler)(context, name);
+        },
+        build: async (context) => {
+            await (0, common_1.build)(context, name);
+        },
+        run: async (env, context) => {
+            await (0, common_1.run)(env, context, name, context => findBundle(name, target, context));
+        },
+        check: async (env, context) => {
+            await (0, common_1.check)(env, context, name);
+        },
+        afterAll: async (context) => {
+            const updateIndex = updatePlugin.getUpdateIndex();
+            const totalUpdates = updatePlugin.getTotalUpdates();
+            if (updateIndex + 1 !== totalUpdates) {
+                throw new Error(`Should run all hot steps (${updateIndex + 1} / ${totalUpdates}): ${name}`);
+            }
+        }
+    };
+}
 function getCreator(target) {
     if (!creators.has(target)) {
         creators.set(target, new creator_1.BasicCaseCreator({
@@ -13,16 +57,12 @@ function getCreator(target) {
             describe: true,
             target,
             steps: ({ name, src, target, temp }) => [
-                new cache_1.CacheProcessor({
-                    name,
-                    sourceDir: src,
-                    tempDir: temp,
-                    target: target,
-                    compilerType: type_1.ECompilerType.Rspack,
-                    configFiles: ["rspack.config.js", "webpack.config.js"]
-                })
+                createCacheProcessor(name, src, temp, target)
             ],
-            runner: runner_1.CacheRunnerFactory,
+            runner: {
+                key: (context, name, file) => name,
+                runner: createRunner
+            },
             concurrent: true
         }));
     }
@@ -32,3 +72,162 @@ function createCacheCase(name, src, dist, target, temp) {
     const creator = getCreator(target);
     creator.create(name, src, dist, temp);
 }
+const creators = new Map();
+function defaultOptions(context, temp, target) {
+    const options = {
+        context: temp,
+        mode: "production",
+        cache: true,
+        devtool: false,
+        output: {
+            path: context.getDist(),
+            filename: "bundle.js",
+            chunkFilename: "[name].chunk.[fullhash].js",
+            publicPath: "https://test.cases/path/",
+            library: { type: "commonjs2" }
+        },
+        optimization: {
+            moduleIds: "named",
+            emitOnErrors: true
+        },
+        target,
+        experiments: {
+            css: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
+                }
+            },
+            inlineConst: true,
+            lazyBarrel: true
+        }
+    };
+    options.plugins ??= [];
+    options.plugins.push(new core_1.default.HotModuleReplacementPlugin());
+    return options;
+}
+function overrideOptions(options, temp, target, updatePlugin) {
+    if (!options.entry) {
+        options.entry = "./index.js";
+    }
+    // rewrite context to temp dir
+    options.context = temp;
+    options.module ??= {};
+    for (const cssModuleType of ["css/auto", "css/module", "css"]) {
+        options.module.generator ??= {};
+        options.module.generator[cssModuleType] ??= {};
+        options.module.generator[cssModuleType].exportsOnly ??=
+            target === "async-node";
+    }
+    options.plugins ??= [];
+    options.plugins.push(updatePlugin);
+    if (!global.printLogger) {
+        options.infrastructureLogging = {
+            level: "error"
+        };
+    }
+}
+function findBundle(name, target, context) {
+    const files = [];
+    const prefiles = [];
+    const compiler = (0, common_1.getCompiler)(context, name);
+    if (!compiler)
+        throw new Error("Compiler should exists when find bundle");
+    const stats = compiler.getStats();
+    if (!stats)
+        throw new Error("Stats should exists when find bundle");
+    const info = stats.toJson({ all: false, entrypoints: true });
+    if (target === "web" || target === "webworker") {
+        for (const file of info.entrypoints.main.assets) {
+            if ((0, helper_1.isJavaScript)(file.name)) {
+                files.push(file.name);
+            }
+            else {
+                prefiles.push(file.name);
+            }
+        }
+    }
+    else {
+        const assets = info.entrypoints.main.assets.filter(s => (0, helper_1.isJavaScript)(s.name));
+        files.push(assets[assets.length - 1].name);
+    }
+    return [...prefiles, ...files];
+}
+function createRunner(context, name, file, env) {
+    const compiler = context.getCompiler(name);
+    const options = compiler.getOptions();
+    let compilerIndex = 0;
+    const testConfig = context.getTestConfig();
+    const source = context.getSource();
+    const dist = context.getDist();
+    const updatePlugin = context.getValue(name, "hotUpdateContext");
+    const getWebRunner = () => {
+        return new runner_1.WebRunner({
+            dom: context.getValue(name, "documentType") || type_1.EDocumentType.JSDOM,
+            env,
+            stats: (0, runner_2.cachedStats)(context, name),
+            cachable: false,
+            name: name,
+            runInNewContext: false,
+            testConfig: {
+                ...testConfig,
+                moduleScope(ms, stats, options) {
+                    const moduleScope = typeof testConfig.moduleScope === "function"
+                        ? testConfig.moduleScope(ms, stats, options)
+                        : ms;
+                    moduleScope.COMPILER_INDEX = compilerIndex;
+                    moduleScope.NEXT_HMR = nextHmr;
+                    moduleScope.NEXT_START = nextStart;
+                    return moduleScope;
+                }
+            },
+            source,
+            dist,
+            compilerOptions: options
+        });
+    };
+    const nextHmr = async (m, options) => {
+        await updatePlugin.goNext();
+        const stats = await compiler.build();
+        if (!stats) {
+            throw new Error("Should generate stats during build");
+        }
+        const jsonStats = stats.toJson({
+        // errorDetails: true
+        });
+        const compilerOptions = compiler.getOptions();
+        const updateIndex = updatePlugin.getUpdateIndex();
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "error", `errors${updateIndex}`, "Error", compilerOptions);
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "warning", `warnings${updateIndex}`, "Warning", compilerOptions);
+        const updatedModules = await m.hot.check(options || true);
+        if (!updatedModules) {
+            throw new Error("No update available");
+        }
+        return jsonStats;
+    };
+    const nextStart = async () => {
+        await compiler.close();
+        compiler.createCompiler();
+        await updatePlugin.goNext();
+        const stats = await compiler.build();
+        if (!stats) {
+            throw new Error("Should generate stats during build");
+        }
+        const jsonStats = stats.toJson({
+        // errorDetails: true
+        });
+        const compilerOptions = compiler.getOptions();
+        const updateIndex = updatePlugin.getUpdateIndex();
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "error", `errors${updateIndex}`, "Error", compilerOptions);
+        await (0, checkArrayExpectation_1.default)(source, jsonStats, "warning", `warnings${updateIndex}`, "Warning", compilerOptions);
+        env.it(`NEXT_START run with compilerIndex==${compilerIndex + 1}`, async () => {
+            if (compilerIndex > MAX_COMPILER_INDEX) {
+                throw new Error("NEXT_START has been called more than the maximum times");
+            }
+            compilerIndex++;
+            return getWebRunner().run(file);
+        });
+        return jsonStats;
+    };
+    return getWebRunner();
+}

package/dist/case/common.d.ts

@@ -0,0 +1,10 @@
+import { ECompilerType, type ITestCompilerManager, type ITestContext, type ITestEnv, type TCompiler, type TCompilerOptions } from "../type";
+export declare function getCompiler<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string): ITestCompilerManager<T>;
+export declare function config<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, configFiles: string[], defaultOptions?: TCompilerOptions<T>): Promise<TCompilerOptions<T>>;
+export declare function compiler<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string): Promise<TCompiler<T>>;
+export declare function build<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string): Promise<TCompiler<T>>;
+export declare function run<T extends ECompilerType = ECompilerType.Rspack>(env: ITestEnv, context: ITestContext, name: string, findBundle: (context: ITestContext, options: TCompilerOptions<T>) => string[] | string | void): Promise<void>;
+export declare function check<T extends ECompilerType = ECompilerType.Rspack>(env: ITestEnv, context: ITestContext, name: string): Promise<void>;
+export declare function checkSnapshot<T extends ECompilerType = ECompilerType.Rspack>(env: ITestEnv, context: ITestContext, name: string, snapshot: string, filter?: (file: string) => boolean): Promise<void>;
+export declare function findMultiCompilerBundle<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, multiFindBundle: (index: number, context: ITestContext, options: TCompilerOptions<T>) => string[] | string | void): string[];
+export declare function configMultiCompiler<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, configFiles: string[], defaultOptions: (index: number, context: ITestContext) => TCompilerOptions<T>, overrideOptions: (index: number, context: ITestContext, options: TCompilerOptions<T>) => void): void;