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

package/dist/processor/hot-step.js

@@ -1,307 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HotSnapshotProcessor = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const placeholder_1 = require("../helper/expect/placeholder");
-const win_1 = require("../helper/win");
-const hot_1 = require("./hot");
-const NOOP_SET = new Set();
-const escapeLocalName = (str) => str.split(/[-<>:"/|?*.]/).join("_");
-const SELF_HANDLER = (file, options) => {
-    let res = [];
-    const hotUpdateGlobal = (_, modules) => {
-        res = Object.keys(modules);
-    };
-    const hotUpdateGlobalKey = escapeLocalName(`${options.output?.hotUpdateGlobal || "webpackHotUpdate"}${options.output?.uniqueName || ""}`);
-    global.self ??= {};
-    global.self[hotUpdateGlobalKey] = hotUpdateGlobal;
-    require(file);
-    delete global.self[hotUpdateGlobalKey];
-    if (!Object.keys(global.self).length) {
-        delete global.self;
-    }
-    return res;
-};
-const NODE_HANDLER = (file) => {
-    return Object.keys(require(file).modules) || [];
-};
-const GET_MODULE_HANDLER = {
-    web: SELF_HANDLER,
-    webworker: SELF_HANDLER,
-    "async-node": NODE_HANDLER,
-    node: NODE_HANDLER
-};
-class HotSnapshotProcessor extends hot_1.HotProcessor {
-    constructor(_hotOptions) {
-        super(_hotOptions);
-        this._hotOptions = _hotOptions;
-        this.hashes = [];
-        this.entries = {};
-    }
-    async run(env, context) {
-        context.setValue(this._options.name, "hotUpdateStepChecker", (hotUpdateContext, stats, runtime) => {
-            const statsJson = stats.toJson({
-                assets: true,
-                chunks: true
-            });
-            const chunks = Array.from(
-            // Some chunk fields are missing from rspack
-            stats?.compilation.chunks || NOOP_SET);
-            for (const entry of chunks.filter(i => i.hasRuntime())) {
-                if (!this.entries[entry.id] && entry.runtime) {
-                    this.entries[entry.id] =
-                        // Webpack uses `string | SortableSet<string>` for `entry.runtime`
-                        typeof entry.runtime === "string"
-                            ? [entry.runtime]
-                            : Array.from(entry.runtime);
-                }
-            }
-            this.matchStepSnapshot(env, context, hotUpdateContext.updateIndex, statsJson, runtime);
-            this.hashes.push(stats.hash);
-        });
-        context.setValue(this._options.name, "hotUpdateStepErrorChecker", (_, stats, runtime) => {
-            this.hashes.push(stats.hash);
-        });
-        await super.run(env, context);
-    }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const stats = compiler.getStats();
-        if (!stats || !stats.hash) {
-            env.expect(false);
-            return;
-        }
-        const statsJson = stats.toJson({ assets: true, chunks: true });
-        const chunks = Array.from(
-        // Some chunk fields are missing from rspack
-        stats?.compilation.chunks || NOOP_SET);
-        for (const entry of chunks.filter(i => i.hasRuntime())) {
-            if (entry.runtime) {
-                this.entries[entry.id] =
-                    // Webpack uses `string | SortableSet<string>` for `entry.runtime`
-                    typeof entry.runtime === "string"
-                        ? [entry.runtime]
-                        : Array.from(entry.runtime);
-            }
-        }
-        let matchFailed = null;
-        try {
-            this.matchStepSnapshot(env, context, 0, statsJson);
-        }
-        catch (e) {
-            matchFailed = e;
-        }
-        this.hashes.push(stats.hash);
-        if (matchFailed) {
-            throw matchFailed;
-        }
-    }
-    matchStepSnapshot(env, context, step, stats, runtime) {
-        const compiler = this.getCompiler(context);
-        const compilerOptions = compiler.getOptions();
-        const getModuleHandler = this._hotOptions.getModuleHandler ||
-            GET_MODULE_HANDLER[compilerOptions.target];
-        env.expect(typeof getModuleHandler).toBe("function");
-        const lastHash = this.hashes[this.hashes.length - 1];
-        const snapshotPath = context.getSource(`${this._hotOptions.snapshot || `__snapshots__/${compilerOptions.target}`}/${step}.snap.txt`);
-        const title = `Case ${node_path_1.default.basename(this._options.name)}: Step ${step}`;
-        const hotUpdateFile = [];
-        const hotUpdateManifest = [];
-        const changedFiles = this.updateOptions.updateIndex === 0
-            ? []
-            : this.updateOptions.changedFiles.map((i) => (0, win_1.escapeSep)(node_path_1.default.relative(context.getSource(), i)));
-        changedFiles.sort();
-        const hashes = {
-            [lastHash || "LAST_HASH"]: "LAST_HASH",
-            [stats.hash]: "CURRENT_HASH"
-        };
-        // TODO: find a better way
-        // replace [runtime] to [runtime of id] to prevent worker hash
-        const runtimes = {};
-        for (const [id, runtime] of Object.entries(this.entries)) {
-            if (typeof runtime === "string") {
-                if (runtime !== id) {
-                    runtimes[runtime] = `[runtime of ${id}]`;
-                }
-            }
-            else if (Array.isArray(runtime)) {
-                for (const r of runtime) {
-                    if (r !== id) {
-                        runtimes[r] = `[runtime of ${id}]`;
-                    }
-                }
-            }
-        }
-        const replaceContent = (rawStr) => {
-            let str = rawStr;
-            const replaceContentConfig = context.getTestConfig().snapshotContent;
-            if (replaceContentConfig) {
-                str = replaceContentConfig(str);
-            }
-            return (0, placeholder_1.normalizePlaceholder)(Object.entries(hashes)
-                .reduce((str, [raw, replacement]) => {
-                return str.split(raw).join(replacement);
-            }, str)
-                .replace(/\/\/ (\d+)\s+(?=var cssReload)/, "")
-                .replaceAll(/var data = "(?:.*)"/g, match => {
-                return decodeURIComponent(match).replaceAll(/\\/g, "/");
-            }));
-        };
-        const replaceFileName = (str) => {
-            return Object.entries({
-                ...hashes,
-                ...runtimes
-            }).reduce((str, [raw, replacement]) => {
-                return str.split(raw).join(replacement);
-            }, str);
-        };
-        const fileList = stats
-            .assets.map(i => {
-            const fileName = i.name;
-            const renderName = replaceFileName(fileName);
-            const content = replaceContent(fs_extra_1.default.readFileSync(context.getDist(fileName), "utf-8"));
-            if (fileName.endsWith("hot-update.js")) {
-                const modules = getModuleHandler(context.getDist(fileName), compilerOptions);
-                const runtime = [];
-                for (const i of content.matchAll(/\/\/ (webpack\/runtime\/[\w_-]+)\s*\n/g)) {
-                    runtime.push(i[1]);
-                }
-                modules.sort();
-                runtime.sort();
-                hotUpdateFile.push({
-                    name: renderName,
-                    content,
-                    modules,
-                    runtime
-                });
-                return `- Update: ${renderName}, size: ${content.length}`;
-            }
-            if (fileName.endsWith("hot-update.json")) {
-                const manifest = JSON.parse(content);
-                manifest.c?.sort();
-                manifest.r?.sort();
-                manifest.m?.sort();
-                hotUpdateManifest.push({
-                    name: renderName,
-                    content: JSON.stringify(manifest)
-                });
-                return `- Manifest: ${renderName}, size: ${i.size}`;
-            }
-            if (fileName.endsWith(".js")) {
-                return `- Bundle: ${renderName}`;
-            }
-        })
-            .filter(Boolean);
-        fileList.sort();
-        hotUpdateManifest.sort((a, b) => (a.name > b.name ? 1 : -1));
-        hotUpdateFile.sort((a, b) => (a.name > b.name ? 1 : -1));
-        if (runtime?.javascript) {
-            runtime.javascript.outdatedModules.sort();
-            runtime.javascript.updatedModules.sort();
-            runtime.javascript.updatedRuntime.sort();
-            runtime.javascript.acceptedModules.sort();
-            runtime.javascript.disposedModules.sort();
-            for (const value of Object.values(runtime.javascript.outdatedDependencies)) {
-                value.sort();
-            }
-        }
-        const content = `
-# ${title}
-
-## Changed Files
-${changedFiles.map(i => `- ${i}`).join("\n")}
-
-## Asset Files
-${fileList.join("\n")}
-
-## Manifest
-${hotUpdateManifest
-            .map(i => `
-### ${i.name}
-
-\`\`\`json
-${i.content}
-\`\`\`
-`)
-            .join("\n\n")}
-
-## Update
-
-${hotUpdateFile
-            .map(i => `
-### ${i.name}
-
-#### Changed Modules
-${i.modules.map(i => `- ${i}`).join("\n")}
-
-#### Changed Runtime Modules
-${i.runtime.map(i => `- ${i}`).join("\n")}
-
-#### Changed Content
-\`\`\`js
-${i.content}
-\`\`\`
-`)
-            .join("\n\n")}
-
-
-${runtime
-            ? `
-## Runtime
-### Status
-
-\`\`\`txt
-${runtime.statusPath.join(" => ")}
-\`\`\`
-
-${runtime.javascript
-                ? `
-
-### JavaScript
-
-#### Outdated
-
-Outdated Modules:
-${runtime.javascript.outdatedModules.map(i => `- ${i}`).join("\n")}
-
-
-Outdated Dependencies:
-\`\`\`json
-${JSON.stringify(runtime.javascript.outdatedDependencies || {}, null, 2)}
-\`\`\`
-
-#### Updated
-
-Updated Modules:
-${runtime.javascript.updatedModules.map(i => `- ${i}`).join("\n")}
-
-Updated Runtime:
-${runtime.javascript.updatedRuntime.map(i => `- \`${i}\``).join("\n")}
-
-
-#### Callback
-
-Accepted Callback:
-${runtime.javascript.acceptedModules.map(i => `- ${i}`).join("\n")}
-
-Disposed Callback:
-${runtime.javascript.disposedModules.map(i => `- ${i}`).join("\n")}
-`
-                : ""}
-
-`
-            : ""}
-
-				`
-            .replaceAll(/%3A(\d+)%2F/g, (match, capture) => {
-            return match.replace(capture, "PORT");
-        })
-            .trim();
-        env.expect(content).toMatchFileSnapshot(snapshotPath);
-    }
-}
-exports.HotSnapshotProcessor = HotSnapshotProcessor;

package/dist/processor/hot.d.ts

@@ -1,17 +0,0 @@
-import { ECompilerType, type ITestContext, type ITestEnv, type ITestRunner, type TCompilerOptions, type TUpdateOptions } from "../type";
-import { BasicProcessor, type IBasicProcessorOptions } from "./basic";
-export interface IHotProcessorOptions<T extends ECompilerType> extends Omit<IBasicProcessorOptions<T>, "runable"> {
-    target: TCompilerOptions<T>["target"];
-    checkSteps?: boolean;
-}
-export declare class HotProcessor<T extends ECompilerType> extends BasicProcessor<T> {
-    protected _hotOptions: IHotProcessorOptions<T>;
-    protected updateOptions: TUpdateOptions;
-    protected runner: ITestRunner | null;
-    constructor(_hotOptions: IHotProcessorOptions<T>);
-    run(env: ITestEnv, context: ITestContext): Promise<void>;
-    static findBundle<T extends ECompilerType>(this: HotProcessor<T>, context: ITestContext): string | string[];
-    afterAll(context: ITestContext): Promise<void>;
-    static defaultOptions<T extends ECompilerType>(this: HotProcessor<T>, context: ITestContext): TCompilerOptions<T>;
-    static overrideOptions<T extends ECompilerType>(this: HotProcessor<T>, context: ITestContext, options: TCompilerOptions<T>): void;
-}

package/dist/processor/hot.js

@@ -1,147 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HotProcessor = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const core_1 = require("@rspack/core");
-const helper_1 = require("../helper");
-const plugins_1 = require("../helper/plugins");
-const plugin_1 = require("../plugin");
-const type_1 = require("../type");
-const basic_1 = require("./basic");
-class HotProcessor extends basic_1.BasicProcessor {
-    constructor(_hotOptions) {
-        const fakeUpdateLoaderOptions = {
-            updateIndex: 0,
-            totalUpdates: 1,
-            changedFiles: []
-        };
-        super({
-            defaultOptions: HotProcessor.defaultOptions,
-            overrideOptions: HotProcessor.overrideOptions,
-            findBundle: HotProcessor.findBundle,
-            runable: true,
-            ..._hotOptions
-        });
-        this._hotOptions = _hotOptions;
-        this.runner = null;
-        this.updateOptions = fakeUpdateLoaderOptions;
-    }
-    async run(env, context) {
-        context.setValue(this._options.name, "hotUpdateContext", this.updateOptions);
-        await super.run(env, context);
-    }
-    static findBundle(context) {
-        const compiler = context.getCompiler(this._hotOptions.name);
-        if (!compiler)
-            throw new Error("Compiler should exists when find bundle");
-        const testConfig = context.getTestConfig();
-        if (typeof testConfig.findBundle === "function") {
-            return testConfig.findBundle(this.updateOptions.updateIndex, compiler.getOptions());
-        }
-        const files = [];
-        const prefiles = [];
-        const stats = compiler.getStats();
-        if (!stats)
-            throw new Error("Stats should exists when find bundle");
-        const info = stats.toJson({ all: false, entrypoints: true });
-        if (this._hotOptions.target === "web" ||
-            this._hotOptions.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];
-    }
-    async afterAll(context) {
-        await super.afterAll(context);
-        if (context.getTestConfig().checkSteps === false) {
-            return;
-        }
-        if (this.updateOptions.updateIndex + 1 !==
-            this.updateOptions.totalUpdates) {
-            throw new Error(`Should run all hot steps (${this.updateOptions.updateIndex + 1} / ${this.updateOptions.totalUpdates}): ${this._options.name}`);
-        }
-    }
-    static defaultOptions(context) {
-        const options = {
-            context: context.getSource(),
-            mode: "development",
-            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"
-            },
-            target: this._hotOptions.target,
-            experiments: {
-                css: true,
-                // test incremental: "safe" here, we test default incremental in Incremental-*.test.js
-                incremental: "safe",
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                },
-                inlineConst: true,
-                lazyBarrel: true
-            }
-        };
-        if (this._hotOptions.compilerType === type_1.ECompilerType.Rspack) {
-            options.plugins ??= [];
-            options.plugins.push(new core_1.rspack.HotModuleReplacementPlugin(), new plugins_1.TestHotUpdatePlugin(this.updateOptions));
-        }
-        return options;
-    }
-    static overrideOptions(context, options) {
-        if (!options.entry) {
-            options.entry = "./index.js";
-        }
-        options.module ??= {};
-        for (const cssModuleType of ["css/auto", "css/module", "css"]) {
-            options.module.generator ??= {};
-            options.module.generator[cssModuleType] ??= {};
-            options.module.generator[cssModuleType].exportsOnly ??=
-                this._hotOptions.target === "async-node";
-        }
-        options.module.rules ??= [];
-        options.module.rules.push({
-            use: [
-                {
-                    loader: node_path_1.default.resolve(__dirname, "../helper/loaders/hot-update.js"),
-                    options: this.updateOptions
-                }
-            ],
-            enforce: "pre"
-        });
-        if (this._hotOptions.compilerType === type_1.ECompilerType.Rspack) {
-            options.plugins ??= [];
-            options.plugins.push(new core_1.rspack.LoaderOptionsPlugin(this.updateOptions));
-        }
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-        if (options.lazyCompilation) {
-            options.plugins.push(new plugin_1.LazyCompilationTestPlugin());
-        }
-    }
-}
-exports.HotProcessor = HotProcessor;

package/dist/processor/index.d.ts

@@ -1,20 +0,0 @@
-export * from "./basic";
-export * from "./builtin";
-export * from "./cache";
-export * from "./config";
-export * from "./defaults";
-export * from "./diagnostic";
-export * from "./diff";
-export * from "./error";
-export * from "./hash";
-export * from "./hook";
-export * from "./hot";
-export * from "./hot-incremental";
-export * from "./hot-step";
-export * from "./multi";
-export * from "./normal";
-export * from "./simple";
-export * from "./snapshot";
-export * from "./stats";
-export * from "./stats-api";
-export * from "./watch";

package/dist/processor/index.js

@@ -1,36 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./basic"), exports);
-__exportStar(require("./builtin"), exports);
-__exportStar(require("./cache"), exports);
-__exportStar(require("./config"), exports);
-__exportStar(require("./defaults"), exports);
-__exportStar(require("./diagnostic"), exports);
-__exportStar(require("./diff"), exports);
-__exportStar(require("./error"), exports);
-__exportStar(require("./hash"), exports);
-__exportStar(require("./hook"), exports);
-__exportStar(require("./hot"), exports);
-__exportStar(require("./hot-incremental"), exports);
-__exportStar(require("./hot-step"), exports);
-__exportStar(require("./multi"), exports);
-__exportStar(require("./normal"), exports);
-__exportStar(require("./simple"), exports);
-__exportStar(require("./snapshot"), exports);
-__exportStar(require("./stats"), exports);
-__exportStar(require("./stats-api"), exports);
-__exportStar(require("./watch"), exports);

package/dist/processor/multi.d.ts

@@ -1,17 +0,0 @@
-import type { ECompilerType, ITestContext, ITestProcessor, TCompilerOptions } from "../type";
-import { BasicProcessor } from "./basic";
-export interface IMultiTaskProcessorOptions<T extends ECompilerType> {
-    defaultOptions?: (index: number, context: ITestContext) => TCompilerOptions<T>;
-    overrideOptions?: (index: number, context: ITestContext, options: TCompilerOptions<T>) => void;
-    findBundle?: (index: number, context: ITestContext, options: TCompilerOptions<T>) => string[] | string | void;
-    compilerType: T;
-    name: string;
-    configFiles?: string[];
-    runable: boolean;
-}
-export declare class MultiTaskProcessor<T extends ECompilerType> extends BasicProcessor<T> implements ITestProcessor {
-    protected _multiOptions: IMultiTaskProcessorOptions<T>;
-    protected multiCompilerOptions: TCompilerOptions<T>[];
-    constructor(_multiOptions: IMultiTaskProcessorOptions<T>);
-    config(context: ITestContext): Promise<void>;
-}

package/dist/processor/multi.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiTaskProcessor = void 0;
-const webpack_merge_1 = require("webpack-merge");
-const helper_1 = require("../helper");
-const basic_1 = require("./basic");
-class MultiTaskProcessor extends basic_1.BasicProcessor {
-    constructor(_multiOptions) {
-        super({
-            runable: _multiOptions.runable,
-            compilerType: _multiOptions.compilerType,
-            findBundle: (context, _) => {
-                if (typeof _multiOptions.findBundle !== "function") {
-                    return [];
-                }
-                const result = [];
-                const multiFileIndexMap = context.getValue(_multiOptions.name, "multiFileIndexMap") || {};
-                for (const [index, compilerOptions] of this.multiCompilerOptions.entries()) {
-                    const curBundles = _multiOptions.findBundle(index, context, compilerOptions);
-                    const bundles = Array.isArray(curBundles)
-                        ? curBundles
-                        : curBundles
-                            ? [curBundles]
-                            : [];
-                    for (const bundle of bundles) {
-                        if (multiFileIndexMap[bundle]) {
-                            multiFileIndexMap[bundle].push(index);
-                        }
-                        else {
-                            multiFileIndexMap[bundle] = [index];
-                        }
-                    }
-                    result.push(...bundles);
-                }
-                context.setValue(_multiOptions.name, "multiFileIndexMap", multiFileIndexMap);
-                return result;
-            },
-            name: _multiOptions.name
-        });
-        this._multiOptions = _multiOptions;
-        this.multiCompilerOptions = [];
-    }
-    async config(context) {
-        this.multiCompilerOptions = [];
-        const caseOptions = Array.isArray(this._multiOptions.configFiles)
-            ? (0, helper_1.readConfigFile)(this._multiOptions.configFiles.map(i => context.getSource(i)), configs => {
-                return configs.flatMap(c => {
-                    if (typeof c === "function") {
-                        const options = {
-                            testPath: context.getDist(),
-                            env: undefined
-                        };
-                        return c(options.env, options);
-                    }
-                    return c;
-                });
-            })
-            : [{}];
-        for (const [index, options] of caseOptions.entries()) {
-            const compilerOptions = (0, webpack_merge_1.merge)(typeof this._multiOptions.defaultOptions === "function"
-                ? this._multiOptions.defaultOptions(index, context)
-                : {}, options);
-            if (typeof this._multiOptions.overrideOptions === "function") {
-                this._multiOptions.overrideOptions(index, context, compilerOptions);
-            }
-            this.multiCompilerOptions.push(compilerOptions);
-        }
-        const compiler = this.getCompiler(context);
-        compiler.setOptions(this.multiCompilerOptions);
-        context.setValue(this._options.name, "multiCompilerOptions", this.multiCompilerOptions);
-    }
-}
-exports.MultiTaskProcessor = MultiTaskProcessor;

package/dist/processor/normal.d.ts

@@ -1,12 +0,0 @@
-import type { ECompilerType, ITestContext, TCompilerOptions } from "../type";
-import { BasicProcessor, type IBasicProcessorOptions } from "./basic";
-export interface INormalProcessorOptions<T extends ECompilerType> extends IBasicProcessorOptions<T> {
-    compilerOptions?: TCompilerOptions<T>;
-    root: string;
-}
-export declare class NormalProcessor<T extends ECompilerType> extends BasicProcessor<T> {
-    protected _normalOptions: INormalProcessorOptions<T>;
-    constructor(_normalOptions: INormalProcessorOptions<T>);
-    static defaultOptions<T extends ECompilerType>(this: NormalProcessor<T>, context: ITestContext): TCompilerOptions<T>;
-    static overrideOptions<T extends ECompilerType>(options: TCompilerOptions<T>): void;
-}