@rspack-canary/test-tools 1.5.7-canary-a3406c0a-20250922173625 → 1.5.8-canary-6c1a40e3-20250925175235

package/dist/processor/diff.js

@@ -1,140 +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.DiffProcessor = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const compare_1 = require("../compare");
-const plugin_1 = require("../plugin");
-const type_1 = require("../type");
-const basic_1 = require("./basic");
-class DiffProcessor {
-    constructor(options) {
-        this.options = options;
-        this.hashes = [];
-        this.webpack = null;
-        if (global.updateSnapshot) {
-            this.webpack = new basic_1.BasicProcessor({
-                defaultOptions: context => this.getDefaultOptions(type_1.ECompilerType.Webpack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Webpack)),
-                compilerType: type_1.ECompilerType.Webpack,
-                name: type_1.ECompilerType.Webpack,
-                configFiles: ["webpack.config.js", "rspack.config.js"],
-                runable: false
-            });
-        }
-        this.rspack = new basic_1.BasicProcessor({
-            defaultOptions: context => this.getDefaultOptions(type_1.ECompilerType.Rspack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Rspack)),
-            compilerType: type_1.ECompilerType.Rspack,
-            name: type_1.ECompilerType.Rspack,
-            configFiles: ["rspack.config.js", "webpack.config.js"],
-            runable: false
-        });
-    }
-    async config(context) {
-        if (this.webpack) {
-            await this.webpack.config(context);
-        }
-        await this.rspack.config(context);
-    }
-    async compiler(context) {
-        if (this.webpack) {
-            await this.webpack.compiler(context);
-        }
-        await this.rspack.compiler(context);
-    }
-    async build(context) {
-        if (this.webpack) {
-            await this.webpack.build(context);
-        }
-        await this.rspack.build(context);
-    }
-    async check(env, context) {
-        if (this.webpack) {
-            const webpackCompiler = context.getCompiler(type_1.ECompilerType.Webpack);
-            const webpackStats = webpackCompiler.getStats();
-            //TODO: handle chunk hash and content hash
-            webpackStats?.hash && this.hashes.push(webpackStats?.hash);
-            if (!this.options.errors) {
-                env.expect(webpackStats?.hasErrors()).toBe(false);
-            }
-        }
-        const rspackCompiler = context.getCompiler(type_1.ECompilerType.Rspack);
-        const rspackStats = rspackCompiler.getStats();
-        //TODO: handle chunk hash and content hash
-        rspackStats?.hash && this.hashes.push(rspackStats?.hash);
-        if (!this.options.errors) {
-            env.expect(rspackStats?.hasErrors()).toBe(false);
-        }
-        const dist = context.getDist();
-        const snapshot = context.getSource("__snapshot__");
-        for (const file of this.options.files) {
-            const rspackDist = node_path_1.default.join(dist, type_1.ECompilerType.Rspack, file);
-            const webpackDist = node_path_1.default.join(dist, type_1.ECompilerType.Webpack, file);
-            const snapshotDist = node_path_1.default.join(snapshot, file.replace(/\.js$/, ".json"));
-            const result = (0, compare_1.compareFile)(rspackDist, webpackDist, {
-                modules: this.options.modules,
-                runtimeModules: this.options.runtimeModules,
-                format: this.createFormatOptions(),
-                renameModule: this.options.renameModule,
-                bootstrap: this.options.bootstrap,
-                detail: this.options.detail,
-                snapshot: snapshotDist
-            });
-            if (typeof this.options.onCompareFile === "function") {
-                this.options.onCompareFile(file, result);
-            }
-            if (typeof this.options.onCompareModules === "function" &&
-                result.modules.modules) {
-                this.options.onCompareModules(file, result.modules.modules);
-            }
-            if (typeof this.options.onCompareRuntimeModules === "function" &&
-                result.modules.runtimeModules) {
-                this.options.onCompareRuntimeModules(file, result.modules.runtimeModules);
-            }
-        }
-    }
-    getDefaultOptions(type, src, dist) {
-        return {
-            entry: node_path_1.default.join(src, "./src/index.js"),
-            context: src,
-            output: {
-                path: dist,
-                filename: "bundle.js",
-                chunkFilename: "[name].chunk.js"
-            },
-            plugins: [
-                type === type_1.ECompilerType.Webpack && new plugin_1.WebpackDiffConfigPlugin(),
-                type === type_1.ECompilerType.Rspack && new plugin_1.RspackDiffConfigPlugin()
-            ].filter(Boolean),
-            experiments: type === type_1.ECompilerType.Rspack
-                ? {
-                    css: true,
-                    rspackFuture: {
-                        bundlerInfo: {
-                            force: false
-                        }
-                    }
-                }
-                : {}
-        };
-    }
-    createFormatOptions() {
-        const formatOptions = {
-            ignoreModuleArguments: this.options.ignoreModuleArguments,
-            ignoreModuleId: this.options.ignoreModuleId,
-            ignorePropertyQuotationMark: this.options.ignorePropertyQuotationMark,
-            ignoreBlockOnlyStatement: this.options.ignoreBlockOnlyStatement,
-            ignoreIfCertainCondition: this.options.ignoreIfCertainCondition,
-            ignoreSwcHelpersPath: this.options.ignoreSwcHelpersPath,
-            ignoreObjectPropertySequence: this.options.ignoreObjectPropertySequence,
-            ignoreCssFilePath: this.options.ignoreCssFilePath,
-            replacements: this.options.replacements || []
-        };
-        for (const hash of this.hashes) {
-            formatOptions.replacements.push({ from: hash, to: "fullhash" });
-        }
-        return formatOptions;
-    }
-}
-exports.DiffProcessor = DiffProcessor;

package/dist/processor/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./basic";
-export * from "./diff";
-export * from "./multi";
-export * from "./simple";
-export * from "./snapshot";
-export * from "./watch";

package/dist/processor/index.js

@@ -1,22 +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("./diff"), exports);
-__exportStar(require("./multi"), exports);
-__exportStar(require("./simple"), exports);
-__exportStar(require("./snapshot"), exports);
-__exportStar(require("./watch"), exports);

package/dist/processor/multi.d.ts

@@ -1,19 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, ITestProcessor, TCompiler, TCompilerMultiStats, TCompilerOptions, TCompilerStats } 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;
-    compiler?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
-    check?: (env: ITestEnv, context: ITestContext, compiler: TCompiler<T>, stats: TCompilerStats<T> | TCompilerMultiStats<T> | null) => Promise<void>;
-}
-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,75 +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;
-            },
-            check: _multiOptions.check,
-            compiler: _multiOptions.compiler,
-            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/simple.d.ts

@@ -1,24 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, ITestProcessor, TCompiler, TCompilerOptions, TCompilerStats } from "../type";
-export interface ISimpleProcessorOptions<T extends ECompilerType> {
-    options?: (context: ITestContext) => TCompilerOptions<T>;
-    compilerCallback?: (error: Error | null, stats: TCompilerStats<T> | null) => void;
-    compilerType: T;
-    name: string;
-    build?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
-    compiler?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
-    check?: (env: ITestEnv, context: ITestContext, compiler: TCompiler<T>, stats: TCompilerStats<T>) => Promise<void>;
-}
-export declare class SimpleTaskProcessor<T extends ECompilerType> implements ITestProcessor {
-    protected _options: ISimpleProcessorOptions<T>;
-    constructor(_options: ISimpleProcessorOptions<T>);
-    config(context: ITestContext): Promise<void>;
-    compiler(context: ITestContext): Promise<void>;
-    build(context: ITestContext): Promise<void>;
-    run(env: ITestEnv, context: ITestContext): Promise<void>;
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-    before(context: ITestContext): Promise<void>;
-    after(context: ITestContext): Promise<void>;
-    beforeAll(context: ITestContext): Promise<void>;
-    afterAll(context: ITestContext): Promise<void>;
-    protected getCompiler(context: ITestContext): import("../type").ITestCompilerManager<T>;
-}

package/dist/processor/simple.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleTaskProcessor = void 0;
-class SimpleTaskProcessor {
-    constructor(_options) {
-        this._options = _options;
-    }
-    async config(context) {
-        const compiler = this.getCompiler(context);
-        if (typeof this._options.options === "function") {
-            compiler.setOptions(this._options.options.call(this, context));
-        }
-    }
-    async compiler(context) {
-        const compiler = this.getCompiler(context);
-        const instance = this._options.compilerCallback
-            ? compiler.createCompilerWithCallback(this._options.compilerCallback)
-            : compiler.createCompiler();
-        if (typeof this._options.compiler === "function") {
-            await this._options.compiler.call(this, context, instance);
-        }
-    }
-    async build(context) {
-        const compiler = this.getCompiler(context);
-        if (typeof this._options.build === "function") {
-            await this._options.build.call(this, context, compiler.getCompiler());
-        }
-        else {
-            await compiler.build();
-        }
-    }
-    async run(env, context) { }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const stats = compiler.getStats();
-        if (typeof this._options.check === "function") {
-            await this._options.check.call(this, env, context, compiler.getCompiler(), stats);
-        }
-    }
-    async before(context) { }
-    async after(context) {
-        const compiler = this.getCompiler(context);
-        await compiler.close();
-    }
-    async beforeAll(context) { }
-    async afterAll(context) { }
-    getCompiler(context) {
-        return context.getCompiler(this._options.name, this._options.compilerType);
-    }
-}
-exports.SimpleTaskProcessor = SimpleTaskProcessor;

package/dist/processor/snapshot.d.ts

@@ -1,12 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv } from "../type";
-import { BasicProcessor, type IBasicProcessorOptions } from "./basic";
-export interface ISnapshotProcessorOptions<T extends ECompilerType> extends IBasicProcessorOptions<T> {
-    snapshot: string;
-    snapshotFileFilter?: (file: string) => boolean;
-}
-export declare class SnapshotProcessor<T extends ECompilerType> extends BasicProcessor<T> {
-    protected _snapshotOptions: ISnapshotProcessorOptions<T>;
-    constructor(_snapshotOptions: ISnapshotProcessorOptions<T>);
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-    serializeEachFile(content: string): string;
-}

package/dist/processor/snapshot.js

@@ -1,67 +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.SnapshotProcessor = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const placeholder_1 = require("../helper/expect/placeholder");
-const basic_1 = require("./basic");
-class SnapshotProcessor extends basic_1.BasicProcessor {
-    constructor(_snapshotOptions) {
-        super(_snapshotOptions);
-        this._snapshotOptions = _snapshotOptions;
-        if (node_path_1.default.extname(_snapshotOptions.snapshot) === ".snap") {
-            throw new Error("Snapshot with `.snap` will be managed by jest, please use `.snap.txt` instead in SnapshotProcessor");
-        }
-    }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const stats = compiler.getStats();
-        const c = compiler.getCompiler();
-        if (!stats || !c)
-            return;
-        if (stats.hasErrors()) {
-            const errors = [];
-            if (stats.stats) {
-                for (const s of stats.stats) {
-                    if (s.hasErrors()) {
-                        errors.push(...s.compilation.errors);
-                    }
-                }
-            }
-            else {
-                const s = stats;
-                errors.push(...s.compilation.errors);
-            }
-            throw new Error(`Failed to compile in fixture ${this._options.name}, Errors: ${errors
-                ?.map(i => `${i.message}\n${i.stack}`)
-                .join("\n\n")}`);
-        }
-        const compilation = c._lastCompilation ||
-            c._lastCompilation;
-        const snapshotFileFilter = this._snapshotOptions.snapshotFileFilter ||
-            ((file) => file.endsWith(".js") && !file.includes("runtime.js"));
-        const fileContents = Object.entries(compilation.assets)
-            .filter(([file]) => snapshotFileFilter.call(this, file))
-            .map(([file, source]) => {
-            const tag = node_path_1.default.extname(file).slice(1) || "txt";
-            let content = (0, placeholder_1.normalizePlaceholder)(source.source().toString());
-            const testConfig = context.getTestConfig();
-            if (testConfig.snapshotContent) {
-                content = testConfig.snapshotContent(content);
-            }
-            return `\`\`\`${tag} title=${file}\n${content}\n\`\`\``;
-        });
-        fileContents.sort();
-        const content = fileContents.join("\n\n");
-        const snapshotPath = node_path_1.default.isAbsolute(this._snapshotOptions.snapshot)
-            ? this._snapshotOptions.snapshot
-            : node_path_1.default.resolve(context.getSource(), `./__snapshots__/${this._snapshotOptions.snapshot}`);
-        env.expect(content).toMatchFileSnapshot(snapshotPath);
-    }
-    serializeEachFile(content) {
-        return (0, placeholder_1.normalizePlaceholder)(content);
-    }
-}
-exports.SnapshotProcessor = SnapshotProcessor;

package/dist/processor/watch.d.ts

@@ -1,30 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
-import { type IMultiTaskProcessorOptions, MultiTaskProcessor } from "./multi";
-export interface IWatchProcessorOptions<T extends ECompilerType> extends IMultiTaskProcessorOptions<T> {
-    stepName: string;
-    tempDir: string;
-    nativeWatcher?: boolean;
-}
-export declare class WatchProcessor<T extends ECompilerType> extends MultiTaskProcessor<T> {
-    protected _watchOptions: IWatchProcessorOptions<T>;
-    protected _watchState: Record<string, any>;
-    protected currentTriggerFilename: string | null;
-    protected lastHash: string | null;
-    constructor(_watchOptions: IWatchProcessorOptions<T>, _watchState: Record<string, any>);
-    compiler(context: ITestContext): Promise<void>;
-    build(context: ITestContext): Promise<void>;
-    run(env: ITestEnv, context: ITestContext): Promise<void>;
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-    config(context: ITestContext): Promise<void>;
-    static overrideOptions<T extends ECompilerType>({ tempDir, nativeWatcher }: IWatchProcessorOptions<T>): (index: number, context: ITestContext, options: TCompilerOptions<ECompilerType>) => void;
-    static findBundle<T extends ECompilerType>(this: IWatchProcessorOptions<T>, index: number, context: ITestContext, options: TCompilerOptions<T>): string | string[];
-}
-export interface IWatchStepProcessorOptions<T extends ECompilerType> extends Omit<IWatchProcessorOptions<T>, "experiments" | "optimization"> {
-}
-export declare class WatchStepProcessor<T extends ECompilerType> extends WatchProcessor<T> {
-    protected _watchOptions: IWatchStepProcessorOptions<T>;
-    protected _watchState: Record<string, any>;
-    constructor(_watchOptions: IWatchStepProcessorOptions<T>, _watchState: Record<string, any>);
-    compiler(context: ITestContext): Promise<void>;
-    build(context: ITestContext): Promise<void>;
-}