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

package/dist/processor/normal.js

@@ -1,170 +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.NormalProcessor = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const basic_1 = require("./basic");
-class NormalProcessor extends basic_1.BasicProcessor {
-    constructor(_normalOptions) {
-        super({
-            findBundle: (context, options) => {
-                const testConfig = context.getTestConfig();
-                if (typeof testConfig.findBundle === "function") {
-                    return testConfig.findBundle(0, options);
-                }
-                const filename = options.output?.filename;
-                return typeof filename === "string" ? filename : undefined;
-            },
-            defaultOptions: NormalProcessor.defaultOptions,
-            ..._normalOptions
-        });
-        this._normalOptions = _normalOptions;
-    }
-    static defaultOptions(context) {
-        let testConfig = {};
-        const testConfigPath = node_path_1.default.join(context.getSource(), "test.config.js");
-        if (node_fs_1.default.existsSync(testConfigPath)) {
-            testConfig = require(testConfigPath);
-        }
-        const TerserPlugin = require("terser-webpack-plugin");
-        const terserForTesting = new TerserPlugin({
-            parallel: false
-        });
-        const { root, compilerOptions } = this._normalOptions;
-        return {
-            amd: {},
-            context: root,
-            entry: `./${node_path_1.default.relative(root, context.getSource())}/`,
-            target: compilerOptions?.target || "async-node",
-            devtool: compilerOptions?.devtool,
-            mode: compilerOptions?.mode || "none",
-            optimization: compilerOptions?.mode
-                ? {
-                    // emitOnErrors: true,
-                    minimizer: [terserForTesting],
-                    ...testConfig.optimization
-                }
-                : {
-                    removeAvailableModules: true,
-                    removeEmptyChunks: true,
-                    mergeDuplicateChunks: true,
-                    // CHANGE: rspack does not support `flagIncludedChunks` yet.
-                    // flagIncludedChunks: true,
-                    sideEffects: true,
-                    providedExports: true,
-                    usedExports: true,
-                    mangleExports: true,
-                    // CHANGE: rspack does not support `emitOnErrors` yet.
-                    // emitOnErrors: true,
-                    concatenateModules: !!testConfig?.optimization?.concatenateModules,
-                    innerGraph: true,
-                    // CHANGE: size is not supported yet
-                    // moduleIds: "size",
-                    // chunkIds: "size",
-                    moduleIds: "named",
-                    chunkIds: "named",
-                    minimizer: [terserForTesting],
-                    ...compilerOptions?.optimization
-                },
-            // CHANGE: rspack does not support `performance` yet.
-            // performance: {
-            // 	hints: false
-            // },
-            node: {
-                __dirname: "mock",
-                __filename: "mock"
-            },
-            cache: compilerOptions?.cache && {
-                // cacheDirectory,
-                ...compilerOptions.cache
-            },
-            output: {
-                pathinfo: "verbose",
-                path: context.getDist(),
-                filename: compilerOptions?.module ? "bundle.mjs" : "bundle.js"
-            },
-            resolve: {
-                modules: ["web_modules", "node_modules"],
-                mainFields: ["webpack", "browser", "web", "browserify", "main"],
-                aliasFields: ["browser"],
-                extensions: [".webpack.js", ".web.js", ".js", ".json"]
-            },
-            resolveLoader: {
-                modules: ["web_loaders", "web_modules", "node_loaders", "node_modules"],
-                mainFields: ["webpackLoader", "webLoader", "loader", "main"],
-                extensions: [
-                    ".webpack-loader.js",
-                    ".web-loader.js",
-                    ".loader.js",
-                    ".js"
-                ]
-            },
-            module: {
-                rules: [
-                    {
-                        test: /\.coffee$/,
-                        loader: "coffee-loader"
-                    },
-                    {
-                        test: /\.pug/,
-                        loader: "@webdiscus/pug-loader"
-                    },
-                    {
-                        test: /\.wat$/i,
-                        loader: "wast-loader",
-                        type: "webassembly/async"
-                    }
-                ]
-            },
-            plugins: (compilerOptions?.plugins || [])
-                .concat(testConfig.plugins || [])
-                .concat(function () {
-                this.hooks.compilation.tap("TestCasesTest", compilation => {
-                    const hooks = [
-                    // CHANGE: the following hooks are not supported yet, so comment it out
-                    // "optimize",
-                    // "optimizeModules",
-                    // "optimizeChunks",
-                    // "afterOptimizeTree",
-                    // "afterOptimizeAssets"
-                    ];
-                    for (const hook of hooks) {
-                        compilation.hooks[hook].tap("TestCasesTest", () => compilation.checkConstraints());
-                    }
-                });
-            }),
-            experiments: {
-                css: false,
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                },
-                asyncWebAssembly: true,
-                topLevelAwait: true,
-                inlineConst: true,
-                lazyBarrel: true,
-                // CHANGE: rspack does not support `backCompat` yet.
-                // backCompat: false,
-                // CHANGE: Rspack enables `css` by default.
-                // Turning off here to fallback to webpack's default css processing logic.
-                ...(compilerOptions?.module ? { outputModule: true } : {})
-            }
-            // infrastructureLogging: compilerOptions?.cache && {
-            //   debug: true,
-            //   console: createLogger(infraStructureLog)
-            // }
-        };
-    }
-    static overrideOptions(options) {
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-    }
-}
-exports.NormalProcessor = NormalProcessor;

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?: (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(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(context, instance);
-        }
-    }
-    async build(context) {
-        const compiler = this.getCompiler(context);
-        if (typeof this._options.build === "function") {
-            await this._options.build(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(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,66 +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 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(file))
-            .map(([file, source]) => {
-            const tag = node_path_1.default.extname(file).slice(1) || "txt";
-            let content = this.serializeEachFile(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 content;
-    }
-}
-exports.SnapshotProcessor = SnapshotProcessor;

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

@@ -1,18 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, TCompiler, TCompilerOptions, TCompilerStats } from "../type";
-import { SimpleTaskProcessor } from "./simple";
-export interface IStatsAPIProcessorOptions<T extends ECompilerType> {
-    options?: (context: ITestContext) => TCompilerOptions<T>;
-    name: string;
-    compilerType: T;
-    snapshotName?: string;
-    compiler?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
-    build?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
-    check?: (stats: TCompilerStats<T>, compiler: TCompiler<T>) => Promise<void>;
-}
-export declare class StatsAPIProcessor<T extends ECompilerType> extends SimpleTaskProcessor<T> {
-    protected _statsAPIOptions: IStatsAPIProcessorOptions<T>;
-    constructor(_statsAPIOptions: IStatsAPIProcessorOptions<T>);
-    compiler(context: ITestContext): Promise<void>;
-    run(env: ITestEnv, context: ITestContext): Promise<void>;
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-}

package/dist/processor/stats-api.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StatsAPIProcessor = void 0;
-const memfs_1 = require("memfs");
-const simple_1 = require("./simple");
-class StatsAPIProcessor extends simple_1.SimpleTaskProcessor {
-    constructor(_statsAPIOptions) {
-        super({
-            options: context => {
-                const res = (_statsAPIOptions.options?.(context) ||
-                    {});
-                res.experiments ??= {};
-                res.experiments.css ??= true;
-                res.experiments.rspackFuture ??= {};
-                res.experiments.rspackFuture.bundlerInfo ??= {};
-                res.experiments.rspackFuture.bundlerInfo.force ??= false;
-                if (!global.printLogger) {
-                    res.infrastructureLogging = {
-                        level: "error"
-                    };
-                }
-                return res;
-            },
-            build: _statsAPIOptions.build,
-            compilerType: _statsAPIOptions.compilerType,
-            name: _statsAPIOptions.name,
-            compiler: _statsAPIOptions.compiler
-        });
-        this._statsAPIOptions = _statsAPIOptions;
-    }
-    async compiler(context) {
-        await super.compiler(context);
-        const compiler = this.getCompiler(context).getCompiler();
-        if (compiler) {
-            compiler.outputFileSystem = (0, memfs_1.createFsFromVolume)(new memfs_1.Volume());
-        }
-    }
-    async run(env, context) {
-        // do nothing
-    }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const stats = compiler.getStats();
-        env.expect(typeof stats).toBe("object");
-        await this._statsAPIOptions.check?.(stats, compiler.getCompiler());
-    }
-}
-exports.StatsAPIProcessor = StatsAPIProcessor;

package/dist/processor/stats.d.ts

@@ -1,18 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
-import { type IMultiTaskProcessorOptions, MultiTaskProcessor } from "./multi";
-export interface IStatsProcessorOptions<T extends ECompilerType> extends Omit<IMultiTaskProcessorOptions<T>, "runable"> {
-    snapshotName: string;
-    writeStatsOuptut?: boolean;
-}
-export declare class StatsProcessor<T extends ECompilerType> extends MultiTaskProcessor<T> {
-    private stderr;
-    private snapshotName;
-    private writeStatsOuptut?;
-    constructor(_statsOptions: IStatsProcessorOptions<T>);
-    before(context: ITestContext): Promise<void>;
-    after(context: ITestContext): Promise<void>;
-    compiler(context: ITestContext): Promise<void>;
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-    static defaultOptions<T extends ECompilerType>(index: number, context: ITestContext): TCompilerOptions<T>;
-    static overrideOptions<T extends ECompilerType>(index: number, context: ITestContext, options: TCompilerOptions<T>): void;
-}

package/dist/processor/stats.js

@@ -1,206 +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.StatsProcessor = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const placeholder_1 = require("../helper/expect/placeholder");
-const captureStdio_1 = __importDefault(require("../helper/legacy/captureStdio"));
-const multi_1 = require("./multi");
-const REG_ERROR_CASE = /error$/;
-class RspackStats {
-    constructor(value) {
-        this.value = value;
-    }
-}
-class StatsProcessor extends multi_1.MultiTaskProcessor {
-    constructor(_statsOptions) {
-        super({
-            defaultOptions: (StatsProcessor.defaultOptions),
-            overrideOptions: (StatsProcessor.overrideOptions),
-            runable: false,
-            ..._statsOptions
-        });
-        this.snapshotName = _statsOptions.snapshotName;
-        this.writeStatsOuptut = _statsOptions.writeStatsOuptut;
-    }
-    async before(context) {
-        this.stderr = (0, captureStdio_1.default)(process.stderr, true);
-    }
-    async after(context) {
-        this.stderr.restore();
-    }
-    async compiler(context) {
-        await super.compiler(context);
-        const instance = this.getCompiler(context).getCompiler();
-        const compilers = instance.compilers
-            ? instance.compilers
-            : [instance];
-        for (const compiler of compilers) {
-            if (!compiler.inputFileSystem) {
-                continue;
-            }
-            const ifs = compiler.inputFileSystem;
-            const inputFileSystem = Object.create(ifs);
-            compiler.inputFileSystem = inputFileSystem;
-            inputFileSystem.readFile = (...args) => {
-                const callback = args.pop();
-                ifs.readFile.apply(ifs, args.concat([
-                    (err, result) => {
-                        if (err)
-                            return callback(err);
-                        if (!/\.(js|json|txt)$/.test(args[0]))
-                            return callback(null, result);
-                        callback(null, (0, placeholder_1.normalizePlaceholder)(result.toString("utf-8")));
-                    }
-                ]));
-            };
-            // CHANGE: The checkConstraints() function is currently not implemented in rspack
-            // compiler.hooks.compilation.tap("StatsTestCasesTest", compilation => {
-            // 	[
-            // 		"optimize",
-            // 		"optimizeModules",
-            // 		"optimizeChunks",
-            // 		"afterOptimizeTree",
-            // 		"afterOptimizeAssets",
-            // 		"beforeHash"
-            // 	].forEach(hook => {
-            // 		compilation.hooks[hook].tap("TestCasesTest", () =>
-            // 			compilation.checkConstraints()
-            // 		);
-            // 	});
-            // });
-        }
-    }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const stats = compiler.getStats();
-        const c = compiler.getCompiler();
-        if (!stats || !c)
-            return;
-        for (const compilation of []
-            .concat(stats.stats || stats)
-            .map((s) => s.compilation)) {
-            compilation.logging.delete("webpack.Compilation.ModuleProfile");
-        }
-        if (REG_ERROR_CASE.test(this._options.name)) {
-            env.expect(stats.hasErrors()).toBe(true);
-        }
-        else if (stats.hasErrors()) {
-            throw new Error(stats.toString({
-                all: false,
-                errors: true
-                // errorStack: true,
-                // errorDetails: true
-            }));
-        }
-        else if (this.writeStatsOuptut) {
-            node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
-                preset: "verbose",
-                // context: context.getSource(),
-                colors: false
-            }), "utf-8");
-        }
-        let toStringOptions = {
-            context: context.getSource(),
-            colors: false
-        };
-        let hasColorSetting = false;
-        if (typeof c.options.stats !== "undefined") {
-            toStringOptions = c.options.stats;
-            if (toStringOptions === null || typeof toStringOptions !== "object")
-                toStringOptions = { preset: toStringOptions };
-            if (!toStringOptions.context)
-                toStringOptions.context = context.getSource();
-            hasColorSetting = typeof toStringOptions.colors !== "undefined";
-        }
-        if (Array.isArray(c.options) && !toStringOptions.children) {
-            toStringOptions.children = c.options.map(o => o.stats);
-        }
-        // mock timestamps
-        for (const { compilation: s } of [].concat(stats.stats || stats)) {
-            env.expect(s.startTime).toBeGreaterThan(0);
-            env.expect(s.endTime).toBeGreaterThan(0);
-            s.endTime = new Date("04/20/1970, 12:42:42 PM").getTime();
-            s.startTime = s.endTime - 1234;
-        }
-        let actual = stats.toString(toStringOptions);
-        env.expect(typeof actual).toBe("string");
-        actual = this.stderr.toString() + actual;
-        if (!hasColorSetting) {
-            actual = actual
-                .replace(/\u001b\[[0-9;]*m/g, "")
-                // CHANGE: The time unit display in Rspack is second
-                .replace(/[.0-9]+(\s?s)/g, "X$1")
-                // CHANGE: Replace bundle size, since bundle sizes may differ between platforms
-                .replace(/[0-9]+\.?[0-9]+ KiB/g, "xx KiB");
-        }
-        const snapshotPath = node_path_1.default.isAbsolute(this.snapshotName)
-            ? this.snapshotName
-            : node_path_1.default.resolve(context.getSource(), `./__snapshots__/${this.snapshotName}`);
-        env.expect(new RspackStats(actual)).toMatchFileSnapshot(snapshotPath);
-        const testConfig = context.getTestConfig();
-        if (typeof testConfig?.validate === "function") {
-            testConfig.validate(stats, this.stderr.toString());
-        }
-    }
-    static defaultOptions(index, context) {
-        if (node_fs_1.default.existsSync(node_path_1.default.join(context.getSource(), "rspack.config.js"))) {
-            return {
-                experiments: {
-                    css: true,
-                    rspackFuture: {
-                        bundlerInfo: {
-                            force: false
-                        }
-                    }
-                }
-            };
-        }
-        return {
-            context: context.getSource(),
-            mode: "development",
-            entry: "./index.js",
-            output: {
-                filename: "bundle.js",
-                path: context.getDist()
-            },
-            optimization: {
-                minimize: false
-            },
-            experiments: {
-                css: true,
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                },
-                inlineConst: true,
-                lazyBarrel: true
-            }
-        };
-    }
-    static overrideOptions(index, context, options) {
-        if (!options.context)
-            options.context = context.getSource();
-        if (!options.output)
-            options.output = options.output || {};
-        if (!options.output.path)
-            options.output.path = context.getDist();
-        if (!options.plugins)
-            options.plugins = [];
-        if (!options.optimization)
-            options.optimization = {};
-        if (options.optimization.minimize === undefined) {
-            options.optimization.minimize = false;
-        }
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-    }
-}
-exports.StatsProcessor = StatsProcessor;

package/dist/processor/treeshaking.d.ts

@@ -1,10 +0,0 @@
-import type { ECompilerType, ITestContext, TCompilerOptions } from "../type";
-import { type ISnapshotProcessorOptions, SnapshotProcessor } from "./snapshot";
-export interface ITreeShakingProcessorOptions<T extends ECompilerType> extends Omit<ISnapshotProcessorOptions<T>, "runable"> {
-}
-export declare class TreeShakingProcessor<T extends ECompilerType> extends SnapshotProcessor<T> {
-    protected _treeShakingOptions: ITreeShakingProcessorOptions<T>;
-    constructor(_treeShakingOptions: ITreeShakingProcessorOptions<T>);
-    static overrideOptions<T extends ECompilerType>(context: ITestContext, options: TCompilerOptions<T>): void;
-    serializeEachFile(content: string): string;
-}

package/dist/processor/treeshaking.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeShakingProcessor = void 0;
-const placeholder_1 = require("../helper/expect/placeholder");
-const builtin_1 = require("./builtin");
-const snapshot_1 = require("./snapshot");
-class TreeShakingProcessor extends snapshot_1.SnapshotProcessor {
-    constructor(_treeShakingOptions) {
-        super({
-            defaultOptions: builtin_1.BuiltinProcessor.defaultOptions,
-            overrideOptions: (TreeShakingProcessor.overrideOptions),
-            runable: false,
-            ..._treeShakingOptions
-        });
-        this._treeShakingOptions = _treeShakingOptions;
-    }
-    static overrideOptions(context, options) {
-        options.target = options.target || ["web", "es2022"];
-        options.optimization ??= {};
-        options.optimization.providedExports = true;
-        options.optimization.innerGraph = true;
-        options.optimization.usedExports = true;
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-    }
-    serializeEachFile(content) {
-        return (0, placeholder_1.normalizePlaceholder)(content);
-    }
-}
-exports.TreeShakingProcessor = TreeShakingProcessor;