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

package/dist/test/creator.d.ts

@@ -1,4 +1,4 @@
-import type { ECompilerType, ITestContext, ITestEnv, ITester, ITestProcessor, TRunnerFactory, TTestConfig } from "../type";
+import type { ECompilerType, ITestContext, ITestEnv, ITester, ITesterConfig, ITestProcessor, TTestConfig, TTestRunnerCreator } from "../type";
 declare global {
     var testFilter: string | undefined;
 }
@@ -19,28 +19,29 @@ export interface IBasicCaseCreatorOptions<T extends ECompilerType> {
     }) => ITestProcessor[];
     testConfig?: (testConfig: TTestConfig<T>) => void;
     description?: (name: string, step: number) => string;
-    runner?: new (name: string, context: ITestContext) => TRunnerFactory<ECompilerType>;
-    [key: string]: unknown;
+    runner?: TTestRunnerCreator;
+    createContext?: (config: ITesterConfig) => ITestContext;
     concurrent?: boolean | number;
+    [key: string]: unknown;
 }
 export declare class BasicCaseCreator<T extends ECompilerType> {
     protected _options: IBasicCaseCreatorOptions<T>;
     protected currentConcurrent: number;
     protected tasks: [string, () => void][];
     constructor(_options: IBasicCaseCreatorOptions<T>);
-    create(name: string, src: string, dist: string, temp?: string): ITester | undefined;
+    create(name: string, src: string, dist: string, temp?: string, caseOptions?: Partial<IBasicCaseCreatorOptions<T>>): ITester | undefined;
     protected shouldRun(name: string): boolean;
-    protected describeConcurrent(name: string, tester: ITester, testConfig: TTestConfig<T>): void;
-    protected describe(name: string, tester: ITester, testConfig: TTestConfig<T>): void;
+    protected describeConcurrent(name: string, tester: ITester, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): void;
+    protected describe(name: string, tester: ITester, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): void;
     protected createConcurrentEnv(): ITestEnv & IConcurrentTestEnv;
-    protected createEnv(testConfig: TTestConfig<T>): ITestEnv;
+    protected createEnv(testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): ITestEnv;
     protected clean(folders: string[]): void;
     protected skip(name: string, reason: string | boolean): void;
     protected readTestConfig(src: string): TTestConfig<T>;
-    protected checkSkipped(src: string, testConfig: TTestConfig<T>): boolean | string;
-    protected createTester(name: string, src: string, dist: string, temp: string | undefined, testConfig: TTestConfig<T>): ITester;
-    protected tryRunTask(): void;
-    protected getMaxConcurrent(): number;
-    protected registerConcurrentTask(name: string, starter: () => void): () => void;
+    protected checkSkipped(src: string, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): boolean | string;
+    protected createTester(name: string, src: string, dist: string, temp: string | undefined, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): ITester;
+    protected tryRunTask(concurrent?: number): void;
+    protected getMaxConcurrent(concurrent?: number): number;
+    protected registerConcurrentTask(name: string, starter: () => void, concurrent?: number): () => void;
 }
 export {};

package/dist/test/creator.js

@@ -16,31 +16,35 @@ class BasicCaseCreator {
         this.currentConcurrent = 0;
         this.tasks = [];
     }
-    create(name, src, dist, temp) {
+    create(name, src, dist, temp, caseOptions) {
+        const options = {
+            ...this._options,
+            ...caseOptions
+        };
         const testConfig = this.readTestConfig(src);
-        if (typeof this._options.testConfig === "function") {
-            this._options.testConfig(testConfig);
+        if (typeof options.testConfig === "function") {
+            options.testConfig(testConfig);
         }
-        const skipped = this.checkSkipped(src, testConfig);
+        const skipped = this.checkSkipped(src, testConfig, options);
         if (skipped) {
             this.skip(name, skipped);
             return;
         }
-        if (this._options.clean) {
+        if (options.clean) {
             this.clean([dist, temp || ""].filter(Boolean));
         }
         const run = this.shouldRun(name);
-        const tester = this.createTester(name, src, dist, temp, testConfig);
+        const tester = this.createTester(name, src, dist, temp, testConfig, options);
         const concurrent = process.env.WASM
             ? false
-            : testConfig.concurrent || this._options.concurrent;
-        if (this._options.describe) {
+            : testConfig.concurrent || options.concurrent;
+        if (options.describe) {
             if (run) {
                 if (concurrent) {
-                    describe(name, () => this.describeConcurrent(name, tester, testConfig));
+                    describe(name, () => this.describeConcurrent(name, tester, testConfig, options));
                 }
                 else {
-                    describe(name, () => this.describe(name, tester, testConfig));
+                    describe(name, () => this.describe(name, tester, testConfig, options));
                 }
             }
             else {
@@ -52,10 +56,10 @@ class BasicCaseCreator {
         else {
             if (run) {
                 if (concurrent) {
-                    this.describeConcurrent(name, tester, testConfig);
+                    this.describeConcurrent(name, tester, testConfig, options);
                 }
                 else {
-                    this.describe(name, tester, testConfig);
+                    this.describe(name, tester, testConfig, options);
                 }
             }
             else {
@@ -71,7 +75,7 @@ class BasicCaseCreator {
         }
         return name.includes(global.testFilter);
     }
-    describeConcurrent(name, tester, testConfig) {
+    describeConcurrent(name, tester, testConfig, options) {
         beforeAll(async () => {
             await tester.prepare();
         });
@@ -79,7 +83,7 @@ class BasicCaseCreator {
         let chain = new Promise((resolve, reject) => {
             starter = resolve;
         });
-        const ender = this.registerConcurrentTask(name, starter);
+        const ender = this.registerConcurrentTask(name, starter, options.concurrent);
         const env = this.createConcurrentEnv();
         for (let index = 0; index < tester.total; index++) {
             let stepSignalResolve = null;
@@ -88,8 +92,8 @@ class BasicCaseCreator {
             }).catch(() => {
                 // prevent unhandled rejection
             });
-            const description = typeof this._options.description === "function"
-                ? this._options.description(name, index)
+            const description = typeof options.description === "function"
+                ? options.description(name, index)
                 : index
                     ? `step [${index}] should pass`
                     : "should pass";
@@ -97,7 +101,7 @@ class BasicCaseCreator {
                 stepSignal.then((e) => {
                     cb(e);
                 });
-            }, this._options.timeout || 180000);
+            }, options.timeout || 180000);
             chain = chain.then(async () => {
                 try {
                     env.clear();
@@ -136,22 +140,28 @@ class BasicCaseCreator {
             await tester.resume();
         });
     }
-    describe(name, tester, testConfig) {
+    describe(name, tester, testConfig, options) {
         beforeAll(async () => {
             await tester.prepare();
         });
         let bailout = false;
         for (let index = 0; index < tester.total; index++) {
-            const description = typeof this._options.description === "function"
-                ? this._options.description(name, index)
-                : `step ${index ? `[${index}]` : ""} should pass`;
+            const description = typeof options.description === "function"
+                ? options.description(name, index)
+                : `step [${index}] should pass`;
             it(description, async () => {
                 if (bailout) {
                     throw `Case "${name}" step ${index + 1} bailout because ${tester.step + 1} failed`;
                 }
-                await tester.compile();
-                await tester.check(env);
                 const context = tester.getContext();
+                try {
+                    await tester.compile();
+                }
+                catch (e) {
+                    bailout = true;
+                    context.emitError(name, e);
+                }
+                await tester.check(env);
                 if (!tester.next() && context.hasError()) {
                     bailout = true;
                     const errors = context
@@ -160,8 +170,8 @@ class BasicCaseCreator {
                         .join("\n\n");
                     throw new Error(`Case "${name}" failed at step ${tester.step + 1}:\n${errors}`);
                 }
-            }, this._options.timeout || 30000);
-            const env = this.createEnv(testConfig);
+            }, options.timeout || 30000);
+            const env = this.createEnv(testConfig, options);
         }
         afterAll(async () => {
             await tester.resume();
@@ -230,8 +240,8 @@ class BasicCaseCreator {
             jest
         };
     }
-    createEnv(testConfig) {
-        if (typeof this._options.runner === "function" && !testConfig.noTests) {
+    createEnv(testConfig, options) {
+        if (options.runner && !testConfig.noTests) {
             return (0, createLazyTestEnv_1.default)(10000);
         }
         return {
@@ -257,30 +267,31 @@ class BasicCaseCreator {
         const testConfigFile = node_path_1.default.join(src, "test.config.js");
         return node_fs_1.default.existsSync(testConfigFile) ? require(testConfigFile) : {};
     }
-    checkSkipped(src, testConfig) {
+    checkSkipped(src, testConfig, options) {
         const filterPath = node_path_1.default.join(src, "test.filter.js");
         // no test.filter.js, should not skip
         if (!node_fs_1.default.existsSync(filterPath)) {
             return false;
         }
         // test.filter.js exists, skip if it returns false|string|array
-        const filtered = require(filterPath)(this._options, testConfig);
+        const filtered = require(filterPath)(options, testConfig);
         if (typeof filtered === "string" || Array.isArray(filtered)) {
             return true;
         }
         return !filtered;
     }
-    createTester(name, src, dist, temp, testConfig) {
+    createTester(name, src, dist, temp, testConfig, options) {
         return new tester_1.Tester({
             name,
             src,
             dist,
             temp,
             testConfig,
-            contextValue: this._options.contextValue,
-            runnerFactory: this._options.runner,
-            steps: this._options.steps({
-                ...this._options,
+            contextValue: options.contextValue,
+            runnerCreator: options.runner,
+            createContext: options.createContext,
+            steps: options.steps({
+                ...options,
                 name,
                 src,
                 dist,
@@ -288,25 +299,23 @@ class BasicCaseCreator {
             })
         });
     }
-    tryRunTask() {
+    tryRunTask(concurrent) {
         while (this.tasks.length !== 0 &&
-            this.currentConcurrent < this.getMaxConcurrent()) {
+            this.currentConcurrent < this.getMaxConcurrent(concurrent)) {
             const [_name, starter] = this.tasks.shift();
             this.currentConcurrent++;
             starter();
         }
     }
-    getMaxConcurrent() {
-        return typeof this._options.concurrent === "number"
-            ? this._options.concurrent
-            : DEFAULT_MAX_CONCURRENT;
+    getMaxConcurrent(concurrent) {
+        return typeof concurrent === "number" ? concurrent : DEFAULT_MAX_CONCURRENT;
     }
-    registerConcurrentTask(name, starter) {
+    registerConcurrentTask(name, starter, concurrent) {
         this.tasks.push([name, starter]);
-        this.tryRunTask();
+        this.tryRunTask(concurrent);
         return () => {
             this.currentConcurrent--;
-            this.tryRunTask();
+            this.tryRunTask(concurrent);
         };
     }
 }

package/dist/test/tester.js

@@ -12,7 +12,9 @@ class Tester {
         this.steps = [];
         this.step = 0;
         this.total = 0;
-        this.context = new context_1.TestContext(config);
+        this.context = config.createContext
+            ? config.createContext(config)
+            : new context_1.TestContext(config);
         this.steps = config.steps || [];
         this.step = 0;
         this.total = config.steps?.length || 0;
@@ -69,6 +71,7 @@ class Tester {
         for (const i of this.steps) {
             if (typeof i.afterAll === "function") {
                 await i.afterAll(this.context);
+                await this.context.closeCompiler(this.config.name);
             }
         }
     }

package/dist/type.d.ts

@@ -1,16 +1,14 @@
 import type EventEmitter from "node:events";
 import type { Compilation as RspackCompilation, Compiler as RspackCompiler, MultiStats as RspackMultiStats, RspackOptions, Stats as RspackStats, StatsCompilation as RspackStatsCompilation } from "@rspack/core";
 import type { Compilation as WebpackCompilation, Compiler as WebpackCompiler, MultiStats as WebpackMultiStats, Configuration as WebpackOptions, Stats as WebpackStats, StatsCompilation as WebpackStatsCompilation } from "webpack";
-import type { IModuleScope, TRunnerRequirer } from "./runner/type";
 export interface ITestContext {
     getSource(sub?: string): string;
     getDist(sub?: string): string;
     getTemp(sub?: string): string | null;
     getCompiler<T extends ECompilerType>(name: string, type: T | void): ITestCompilerManager<T>;
+    closeCompiler(name: string): Promise<void>;
     getTestConfig<T extends ECompilerType>(): TTestConfig<T>;
-    getRunnerFactory<T extends ECompilerType>(name: string): TRunnerFactory<T> | null;
-    getRunner(key: string): ITestRunner | null;
-    setRunner(key: string, runner: ITestRunner): void;
+    getRunner(name: string, file: string, env: ITestEnv): ITestRunner;
     setValue<T>(name: string, key: string, value: T): void;
     getValue<T>(name: string, key: string): T | void;
     getNames(): string[];
@@ -55,7 +53,8 @@ export interface ITesterConfig {
     testConfig?: TTestConfig<ECompilerType>;
     compilerFactories?: TCompilerFactories<ECompilerType>;
     contextValue?: Record<string, unknown>;
-    runnerFactory?: new (name: string, context: ITestContext) => TRunnerFactory<ECompilerType>;
+    runnerCreator?: TTestRunnerCreator;
+    createContext?: (config: ITesterConfig) => ITestContext;
 }
 export interface ITester {
     step: number;
@@ -72,11 +71,11 @@ export interface ITestProcessor {
     afterAll?(context: ITestContext): Promise<void>;
     before?(context: ITestContext): Promise<void>;
     after?(context: ITestContext): Promise<void>;
-    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<unknown>;
+    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<unknown>;
 }
 export interface ITestReporter<T> {
     init(data?: T): Promise<void>;
@@ -163,9 +162,41 @@ export type TCompilerFactory<T extends ECompilerType> = (options: TCompilerOptio
 export interface TRunnerFactory<T extends ECompilerType> {
     create(file: string, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
 }
-export type TUpdateOptions = {
+export type THotUpdateContext = {
     updateIndex: number;
     totalUpdates: number;
     changedFiles: string[];
 };
 export type TCompilerFactories<T extends ECompilerType> = Record<T, TCompilerFactory<T>>;
+export type TRunnerRequirer = (currentDirectory: string, modulePath: string[] | string, context?: {
+    file?: TRunnerFile;
+    esmMode?: EEsmMode;
+}) => Object | Promise<Object>;
+export type TRunnerFile = {
+    path: string;
+    content: string;
+    subPath: string;
+};
+export declare enum EEsmMode {
+    Unknown = 0,
+    Evaluated = 1,
+    Unlinked = 2
+}
+export interface IModuleScope extends ITestEnv {
+    console: Record<string, (...args: any[]) => void>;
+    expect: jest.Expect;
+    [key: string]: any;
+}
+export interface IGlobalContext {
+    console: Record<string, (...args: any[]) => void>;
+    setTimeout: typeof setTimeout;
+    clearTimeout: typeof clearTimeout;
+    [key: string]: any;
+}
+export type TModuleObject = {
+    exports: unknown;
+};
+export type TTestRunnerCreator = {
+    key: (context: ITestContext, name: string, file: string) => string;
+    runner: (context: ITestContext, name: string, file: string, env: ITestEnv) => ITestRunner;
+};

package/dist/type.js

@@ -1,7 +1,7 @@
 "use strict";
 /// <reference types="../jest.d.ts" />
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EDocumentType = exports.ECompareResultType = exports.ECompilerType = void 0;
+exports.EEsmMode = exports.EDocumentType = exports.ECompareResultType = exports.ECompilerType = void 0;
 var ECompilerType;
 (function (ECompilerType) {
     ECompilerType["Rspack"] = "rspack";
@@ -20,3 +20,9 @@ var EDocumentType;
     EDocumentType["Fake"] = "fake";
     EDocumentType["JSDOM"] = "jsdom";
 })(EDocumentType || (exports.EDocumentType = EDocumentType = {}));
+var EEsmMode;
+(function (EEsmMode) {
+    EEsmMode[EEsmMode["Unknown"] = 0] = "Unknown";
+    EEsmMode[EEsmMode["Evaluated"] = 1] = "Evaluated";
+    EEsmMode[EEsmMode["Unlinked"] = 2] = "Unlinked";
+})(EEsmMode || (exports.EEsmMode = EEsmMode = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack-canary/test-tools",
-  "version": "1.5.6-canary-e598f284-20250921173624",
+  "version": "1.5.8-canary-e350b761-20250924173613",
   "license": "MIT",
   "description": "Test tools for rspack",
   "main": "dist/index.js",
@@ -100,10 +100,10 @@
     "wast-loader": "^1.14.1",
     "worker-rspack-loader": "^3.1.2",
     "exports-loader": "^5.0.0",
-    "@rspack/cli": "npm:@rspack-canary/cli@1.5.6-canary-e598f284-20250921173624",
-    "@rspack/core": "npm:@rspack-canary/core@1.5.6-canary-e598f284-20250921173624",
-    "@rspack/binding-testing": "1.4.1",
-    "@rspack/test-tools": "npm:@rspack-canary/test-tools@1.5.6-canary-e598f284-20250921173624"
+    "@rspack/cli": "npm:@rspack-canary/cli@1.5.8-canary-e350b761-20250924173613",
+    "@rspack/core": "npm:@rspack-canary/core@1.5.8-canary-e350b761-20250924173613",
+    "@rspack/test-tools": "npm:@rspack-canary/test-tools@1.5.8-canary-e350b761-20250924173613",
+    "@rspack/binding-testing": "1.4.1"
   },
   "peerDependencies": {
     "@rspack/core": ">=1.0.0"

package/dist/processor/basic.d.ts

@@ -1,24 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, ITestProcessor, TCompilerOptions } from "../type";
-export interface IBasicProcessorOptions<T extends ECompilerType> {
-    defaultOptions?: (context: ITestContext) => TCompilerOptions<T>;
-    configFiles?: string[];
-    overrideOptions?: (context: ITestContext, options: TCompilerOptions<T>) => void;
-    findBundle?: (context: ITestContext, options: TCompilerOptions<T>) => string[] | string | void;
-    compilerType: T;
-    runable: boolean;
-    name: string;
-}
-export declare class BasicProcessor<T extends ECompilerType> implements ITestProcessor {
-    protected _options: IBasicProcessorOptions<T>;
-    constructor(_options: IBasicProcessorOptions<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/basic.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.BasicProcessor = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const helper_1 = require("../helper");
-const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
-class BasicProcessor {
-    constructor(_options) {
-        this._options = _options;
-    }
-    async config(context) {
-        const compiler = this.getCompiler(context);
-        if (typeof this._options.defaultOptions === "function") {
-            compiler.setOptions(this._options.defaultOptions.apply(this, [context]));
-        }
-        if (Array.isArray(this._options.configFiles)) {
-            const fileOptions = (0, helper_1.readConfigFile)(this._options.configFiles.map(i => context.getSource(i)))[0];
-            compiler.mergeOptions(fileOptions);
-        }
-        if (typeof this._options.overrideOptions === "function") {
-            const compilerOptions = compiler.getOptions();
-            this._options.overrideOptions.apply(this, [context, compilerOptions]);
-        }
-    }
-    async compiler(context) {
-        const compiler = this.getCompiler(context);
-        compiler.createCompiler();
-    }
-    async build(context) {
-        const compiler = this.getCompiler(context);
-        await compiler.build();
-    }
-    async run(env, context) {
-        if (!this._options.runable)
-            return;
-        const testConfig = context.getTestConfig();
-        if (testConfig.noTests)
-            return;
-        if (testConfig.documentType) {
-            context.setValue(this._options.name, "documentType", testConfig.documentType);
-        }
-        const compiler = this.getCompiler(context);
-        if (typeof testConfig.beforeExecute === "function") {
-            testConfig.beforeExecute(compiler.getOptions());
-        }
-        let bundles;
-        if (testConfig.bundlePath) {
-            bundles = testConfig.bundlePath;
-        }
-        else if (typeof this._options.findBundle === "function") {
-            bundles = this._options.findBundle.apply(this, [
-                context,
-                compiler.getOptions()
-            ]);
-        }
-        else {
-            bundles = [];
-        }
-        if (typeof bundles === "string") {
-            bundles = [bundles];
-        }
-        if (!bundles || !bundles.length) {
-            return;
-        }
-        for (const bundle of bundles) {
-            if (!bundle) {
-                continue;
-            }
-            const runnerFactory = context.getRunnerFactory(this._options.name);
-            if (!runnerFactory) {
-                throw new Error(`Test case ${this._options.name} is not runable`);
-            }
-            const runner = runnerFactory.create(bundle, compiler.getOptions(), env);
-            const mod = runner.run(bundle);
-            const result = context.getValue(this._options.name, "modules") || [];
-            result.push(mod);
-            context.setValue(this._options.name, "modules", result);
-        }
-        const results = context.getValue(this._options.name, "modules") || [];
-        await Promise.all(results);
-        if (typeof testConfig.afterExecute === "function") {
-            testConfig.afterExecute(compiler.getOptions());
-        }
-    }
-    async check(env, context) {
-        const testConfig = context.getTestConfig();
-        if (testConfig.noTests)
-            return;
-        const errors = (context.getError(this._options.name) || []).map(e => ({
-            message: e.message,
-            stack: e.stack
-        }));
-        const warnings = [];
-        const compiler = this.getCompiler(context);
-        const stats = compiler.getStats();
-        const options = compiler.getOptions();
-        if (stats) {
-            if (testConfig.writeStatsOuptut) {
-                node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
-                    preset: "verbose",
-                    colors: false
-                }), "utf-8");
-            }
-            if (testConfig.writeStatsJson) {
-                const jsonStats = stats.toJson({
-                    errorDetails: true
-                });
-                node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.json"), JSON.stringify(jsonStats, null, 2), "utf-8");
-            }
-            if (node_fs_1.default.existsSync(context.getSource("errors.js")) ||
-                node_fs_1.default.existsSync(context.getSource("warnings.js")) ||
-                stats.hasErrors() ||
-                stats.hasWarnings()) {
-                const statsJson = stats.toJson({
-                    errorDetails: true
-                });
-                if (statsJson.errors) {
-                    errors.push(...statsJson.errors);
-                }
-                if (statsJson.warnings) {
-                    warnings.push(...statsJson.warnings);
-                }
-            }
-        }
-        await (0, checkArrayExpectation_1.default)(context.getSource(), { errors }, "error", "errors", "Error", options);
-        await (0, checkArrayExpectation_1.default)(context.getSource(), { warnings }, "warning", "warnings", "Warning", options);
-        // clear error if checked
-        if (node_fs_1.default.existsSync(context.getSource("errors.js"))) {
-            context.clearError(this._options.name);
-        }
-    }
-    async before(context) { }
-    async after(context) { }
-    async beforeAll(context) { }
-    async afterAll(context) {
-        const compiler = this.getCompiler(context);
-        await compiler.close();
-    }
-    getCompiler(context) {
-        return context.getCompiler(this._options.name, this._options.compilerType);
-    }
-}
-exports.BasicProcessor = BasicProcessor;

package/dist/processor/builtin.d.ts

@@ -1,9 +0,0 @@
-import { ECompilerType, type ITestContext, type TCompilerOptions } from "../type";
-import { type ISnapshotProcessorOptions, SnapshotProcessor } from "./snapshot";
-export interface IBuiltinProcessorOptions<T extends ECompilerType> extends Omit<ISnapshotProcessorOptions<T>, "runable"> {
-}
-export declare class BuiltinProcessor<T extends ECompilerType> extends SnapshotProcessor<T> {
-    protected _builtinOptions: IBuiltinProcessorOptions<T>;
-    constructor(_builtinOptions: IBuiltinProcessorOptions<T>);
-    static defaultOptions<T extends ECompilerType>(this: BuiltinProcessor<T>, context: ITestContext): TCompilerOptions<T>;
-}