@rspack/test-tools 0.6.2 → 0.6.3-canary-e0ce3b5-20240423115333

package/dist/helper/legacy/FakeDocument.d.ts

@@ -1,12 +1,12 @@
-export = FakeDocument;
-declare class FakeDocument {
-    constructor(basePath: any);
+export default class FakeDocument {
+    constructor(basePath: any, options?: {});
     head: FakeElement;
     body: FakeElement;
     baseURI: string;
     _elementsByTagName: Map<string, FakeElement[]>;
     _basePath: any;
     currentScript: any;
+    _options: {};
     createElement(type: any): FakeElement;
     _onElementAttached(element: any): void;
     _onElementRemoved(element: any): void;
@@ -15,7 +15,7 @@ declare class FakeDocument {
         getPropertyValue: (property: any) => any;
     };
 }
-declare class FakeElement {
+export class FakeElement {
     constructor(document: any, type: any, basePath: any);
     _document: any;
     _type: any;
@@ -23,8 +23,10 @@ declare class FakeElement {
     _attributes: any;
     _src: any;
     _href: any;
+    rel: any;
     parentNode: any;
     sheet: FakeSheet | undefined;
+    insertBefore(node: any, before: any): void;
     appendChild(node: any): void;
     removeChild(node: any): void;
     setAttribute(name: any, value: any): void;
@@ -33,10 +35,11 @@ declare class FakeElement {
     _toRealUrl(value: any): any;
     set src(arg: any);
     get src(): any;
+    get children(): any[];
     set href(arg: any);
     get href(): any;
 }
-declare class FakeSheet {
+export class FakeSheet {
     constructor(element: any, basePath: any);
     _element: any;
     _basePath: any;

package/dist/helper/legacy/FakeDocument.js

@@ -1,12 +1,14 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeSheet = exports.FakeElement = void 0;
 // @ts-nocheck
 const fs = require("fs");
 const path = require("path");
 const getPropertyValue = function (property) {
     return this[property];
 };
-module.exports = class FakeDocument {
-    constructor(basePath) {
+class FakeDocument {
+    constructor(basePath, options = {}) {
         this.head = this.createElement("head");
         this.body = this.createElement("body");
         this.baseURI = "https://test.cases/path/index.html";
@@ -16,6 +18,7 @@ module.exports = class FakeDocument {
         ]);
         this._basePath = basePath;
         this.currentScript = undefined;
+        this._options = options || {};
     }
     createElement(type) {
         return new FakeElement(this, type, this._basePath);
@@ -50,7 +53,8 @@ module.exports = class FakeDocument {
         }
         return style;
     }
-};
+}
+exports.default = FakeDocument;
 class FakeElement {
     constructor(document, type, basePath) {
         this._document = document;
@@ -59,9 +63,20 @@ class FakeElement {
         this._attributes = Object.create(null);
         this._src = undefined;
         this._href = undefined;
+        this.rel = undefined;
         this.parentNode = undefined;
         this.sheet = type === "link" ? new FakeSheet(this, basePath) : undefined;
     }
+    insertBefore(node, before) {
+        this._document._onElementAttached(node);
+        node.parentNode = this;
+        this._children.unshift(node);
+        Promise.resolve().then(() => {
+            if (node.onload) {
+                node.onload({ type: "load", target: node });
+            }
+        });
+    }
     appendChild(node) {
         this._document._onElementAttached(node);
         this._children.push(node);
@@ -72,6 +87,24 @@ class FakeElement {
                     node.onload({ type: "load", target: node });
             }, 100);
         }
+        else if (node._type === "script") {
+            Promise.resolve().then(() => {
+                if (typeof this._document._options.onScript === "function") {
+                    this._document._options.onScript(node);
+                }
+                if (node.onload) {
+                    node.onload({
+                        type: "load",
+                        target: node
+                    });
+                }
+            });
+        }
+        else {
+            if (node.onload) {
+                node.onload({ type: "load", target: node });
+            }
+        }
     }
     removeChild(node) {
         const idx = this._children.indexOf(node);
@@ -125,6 +158,9 @@ class FakeElement {
             this._src = this._toRealUrl(value);
         }
     }
+    get children() {
+        return this._children;
+    }
     get src() {
         return this._src;
     }
@@ -137,6 +173,7 @@ class FakeElement {
         return this._href;
     }
 }
+exports.FakeElement = FakeElement;
 class FakeSheet {
     constructor(element, basePath) {
         this._element = element;
@@ -211,3 +248,4 @@ class FakeSheet {
         return rules;
     }
 }
+exports.FakeSheet = FakeSheet;

package/dist/plugin/webpack-module-placeholder-plugin.js

@@ -4,7 +4,6 @@ exports.WebpackModulePlaceholderPlugin = void 0;
 // @ts-nocheck
 const { ConcatSource, RawSource, CachedSource, PrefixSource } = require("webpack-sources");
 const path = require("path");
-const which = require("which-module");
 function createRenderRuntimeModulesFn(Template) {
     return function renderRuntimeModules(runtimeModules, renderContext) {
         const source = new ConcatSource();
@@ -54,19 +53,17 @@ const caches = new WeakMap();
 class WebpackModulePlaceholderPlugin {
     constructor() { }
     apply(compiler) {
-        const webpackLibPath = which(compiler.constructor).path;
-        const Template = require(path.join(webpackLibPath, "Template.js"));
+        const { webpack } = compiler;
+        const { Template, javascript: { JavascriptModulesPlugin } } = webpack;
         Template.renderRuntimeModules = createRenderRuntimeModulesFn(Template);
-        const JavascriptModulesPlugin = require(path.join(webpackLibPath, "javascript/JavascriptModulesPlugin.js"));
         compiler.hooks.compilation.tap("RuntimeDiffPlugin", compilation => {
             const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
             hooks.inlineInRuntimeBailout.tap("RuntimeDiffPlugin", () => "not allow inline startup");
-            hooks.renderModulePackage.tap("RuntimeDiffPlugin", (moduleSource, module, { chunk, chunkGraph, moduleGraph, runtimeTemplate }) => {
-                const { requestShortener } = runtimeTemplate;
+            hooks.renderModulePackage.tap("RuntimeDiffPlugin", (moduleSource, module) => {
                 let cacheEntry;
-                let cache = caches.get(requestShortener);
+                let cache = caches.get(compilation);
                 if (cache === undefined) {
-                    caches.set(requestShortener, (cache = new WeakMap()));
+                    caches.set(compilation, (cache = new WeakMap()));
                     cache.set(module, (cacheEntry = {
                         header: undefined,
                         footer: undefined,
@@ -92,14 +89,10 @@ class WebpackModulePlaceholderPlugin {
                 let header = cacheEntry.header;
                 let footer = cacheEntry.footer;
                 if (header === undefined) {
-                    const req = module.readableIdentifier(requestShortener);
-                    let reqStr = req.replace(/\*\//g, "*_/");
-                    // handle css module identifier
-                    if (reqStr.startsWith("css ")) {
-                        reqStr = reqStr.replace(/^css[\s]+/, "").trim();
-                    }
-                    header = new RawSource(`\n/* start::${reqStr} */\n`);
-                    footer = new RawSource(`\n/* end::${reqStr} */\n`);
+                    const identifier = module.identifier();
+                    const moduleId = compilation.chunkGraph.getModuleId(module);
+                    header = new RawSource(`\n${Template.toNormalComment(`start::${moduleId}::${identifier}`)}\n`);
+                    footer = new RawSource(`\n${Template.toNormalComment(`end::${moduleId}::${identifier}`)}\n`);
                     cacheEntry.header = header;
                     cacheEntry.footer = footer;
                 }

package/dist/processor/hot-step.js

@@ -65,9 +65,20 @@ class RspackHotStepProcessor extends hot_1.RspackHotProcessor {
         for (let entry of ((stats === null || stats === void 0 ? void 0 : stats.compilation.chunks) || []).filter(i => i.hasRuntime())) {
             this.entries[entry.id] = entry.runtime;
         }
-        this.matchStepSnapshot(context, 0, statsJson);
+        let matchFailed = null;
+        try {
+            this.matchStepSnapshot(context, 0, statsJson);
+        }
+        catch (e) {
+            matchFailed = e;
+        }
         this.hashes.push(stats.hash);
-        await super.check(env, context);
+        if (matchFailed) {
+            throw matchFailed;
+        }
+        else {
+            await super.check(env, context);
+        }
     }
     matchStepSnapshot(context, step, stats) {
         const compiler = this.getCompiler(context);
@@ -111,6 +122,7 @@ class RspackHotStepProcessor extends hot_1.RspackHotProcessor {
         };
         const fileList = stats
             .assets.map(i => {
+            var _a, _b, _c;
             const fileName = i.name;
             const renderName = replaceFileName(fileName);
             const content = replaceContent(fs_extra_1.default.readFileSync(context.getDist(fileName), "utf-8"));
@@ -131,20 +143,24 @@ class RspackHotStepProcessor extends hot_1.RspackHotProcessor {
                 return `- Update: ${renderName}, size: ${i.size}`;
             }
             else if (fileName.endsWith("hot-update.json")) {
+                const manifest = JSON.parse(content);
+                (_a = manifest.c) === null || _a === void 0 ? void 0 : _a.sort();
+                (_b = manifest.r) === null || _b === void 0 ? void 0 : _b.sort();
+                (_c = manifest.m) === null || _c === void 0 ? void 0 : _c.sort();
                 hotUpdateManifest.push({
                     name: renderName,
-                    content
+                    content: JSON.stringify(manifest)
                 });
                 return `- Manifest: ${renderName}, size: ${i.size}`;
             }
             else if (fileName.endsWith(".js")) {
-                return `- Bundle: ${renderName}, size: ${i.size}`;
+                return `- Bundle: ${renderName}`;
             }
         })
             .filter(Boolean);
         fileList.sort();
-        hotUpdateManifest.sort();
-        hotUpdateFile.sort();
+        hotUpdateManifest.sort((a, b) => (a.name > b.name ? 1 : -1));
+        hotUpdateFile.sort((a, b) => (a.name > b.name ? 1 : -1));
         let content = `
 # ${title}
 

package/dist/runner/basic.d.ts

@@ -1,9 +1,9 @@
-import { ECompilerType, ITestContext, ITestEnv, ITestRunner, TCompilerOptions, TRunnerFactory } from "../type";
+import { ECompilerType, ITestContext, ITestEnv, ITestRunner, TCompilerOptions, TCompilerStatsCompilation, TRunnerFactory } from "../type";
 export declare class BasicRunnerFactory<T extends ECompilerType> implements TRunnerFactory<T> {
     protected name: string;
     protected context: ITestContext;
     constructor(name: string, context: ITestContext);
     create(file: string, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
     protected getRunnerKey(file: string): string;
-    protected createRunner(file: string, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
+    protected createRunner(file: string, stats: TCompilerStatsCompilation<T>, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
 }

package/dist/runner/basic.js

@@ -14,19 +14,21 @@ class BasicRunnerFactory {
         if (exists) {
             return exists;
         }
-        const runner = this.createRunner(file, compilerOptions, env);
+        const compiler = this.context.getCompiler(this.name);
+        const stats = compiler.getStats().toJson({
+            errorDetails: true
+        });
+        const runner = this.createRunner(file, stats, compilerOptions, env);
         this.context.setRunner(key, runner);
         return runner;
     }
     getRunnerKey(file) {
         return this.name;
     }
-    createRunner(file, compilerOptions, env) {
-        const compiler = this.context.getCompiler(this.name);
-        const stats = compiler.getStats();
+    createRunner(file, stats, compilerOptions, env) {
         const runnerOptions = {
             env,
-            stats: stats,
+            stats,
             name: this.name,
             testConfig: this.context.getTestConfig(),
             source: this.context.getSource(),
@@ -35,7 +37,11 @@ class BasicRunnerFactory {
         };
         if (compilerOptions.target === "web" ||
             compilerOptions.target === "webworker") {
-            return new web_1.WebRunner(runnerOptions);
+            return new web_1.WebRunner({
+                ...runnerOptions,
+                runInNewContext: true,
+                dom: "fake"
+            });
         }
         else {
             return new esm_1.EsmRunner(runnerOptions);

package/dist/runner/hot-step.d.ts

@@ -1,5 +1,5 @@
-import { ECompilerType, ITestEnv, ITestRunner, TCompilerOptions } from "../type";
+import { ECompilerType, ITestEnv, ITestRunner, TCompilerOptions, TCompilerStatsCompilation } from "../type";
 import { HotRunnerFactory } from "./hot";
 export declare class HotStepRunnerFactory<T extends ECompilerType> extends HotRunnerFactory<T> {
-    protected createRunner(file: string, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
+    protected createRunner(file: string, stats: TCompilerStatsCompilation<T>, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
 }

package/dist/runner/hot-step.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HotStepRunnerFactory = void 0;
-const hot_1 = require("./runner/hot");
-const hot_2 = require("./hot");
-class HotStepRunnerFactory extends hot_2.HotRunnerFactory {
-    createRunner(file, compilerOptions, env) {
+const hot_1 = require("./hot");
+const web_1 = require("./runner/web");
+class HotStepRunnerFactory extends hot_1.HotRunnerFactory {
+    createRunner(file, stats, compilerOptions, env) {
         const compiler = this.context.getCompiler(this.name);
         const testConfig = this.context.getTestConfig();
-        const stats = compiler.getStats();
         const source = this.context.getSource();
         const dist = this.context.getDist();
         const hotUpdateContext = this.context.getValue(this.name, "hotUpdateContext");
@@ -20,7 +19,7 @@ class HotStepRunnerFactory extends hot_2.HotRunnerFactory {
                 if (!stats)
                     return callback(new Error("Should generate stats during build"));
                 const jsonStats = stats.toJson({
-                // errorDetails: true
+                    errorDetails: true
                 });
                 try {
                     const checker = this.context.getValue(this.name, ((_a = jsonStats.errors) === null || _a === void 0 ? void 0 : _a.length)
@@ -35,15 +34,24 @@ class HotStepRunnerFactory extends hot_2.HotRunnerFactory {
             })
                 .catch(callback);
         };
-        return new hot_1.HotRunner({
+        return new web_1.WebRunner({
+            dom: "jsdom",
             env,
-            stats: stats,
+            stats,
             name: this.name,
             runInNewContext: false,
-            testConfig,
+            testConfig: {
+                ...testConfig,
+                moduleScope(ms) {
+                    if (typeof testConfig.moduleScope === "function") {
+                        ms = testConfig.moduleScope(ms);
+                    }
+                    ms["NEXT"] = next;
+                    return ms;
+                }
+            },
             source,
             dist,
-            next,
             compilerOptions
         });
     }

package/dist/runner/hot.d.ts

@@ -1,5 +1,5 @@
-import { ECompilerType, ITestEnv, ITestRunner, TCompilerOptions } from "../type";
+import { ECompilerType, ITestEnv, ITestRunner, TCompilerOptions, TCompilerStatsCompilation } from "../type";
 import { BasicRunnerFactory } from "./basic";
 export declare class HotRunnerFactory<T extends ECompilerType> extends BasicRunnerFactory<T> {
-    protected createRunner(file: string, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
+    protected createRunner(file: string, stats: TCompilerStatsCompilation<T>, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
 }

package/dist/runner/hot.js

@@ -6,12 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HotRunnerFactory = void 0;
 const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
 const basic_1 = require("./basic");
-const hot_1 = require("./runner/hot");
+const web_1 = require("./runner/web");
 class HotRunnerFactory extends basic_1.BasicRunnerFactory {
-    createRunner(file, compilerOptions, env) {
+    createRunner(file, stats, compilerOptions, env) {
         const compiler = this.context.getCompiler(this.name);
         const testConfig = this.context.getTestConfig();
-        const stats = compiler.getStats();
         const source = this.context.getSource();
         const dist = this.context.getDist();
         const hotUpdateContext = this.context.getValue(this.name, "hotUpdateContext");
@@ -35,15 +34,24 @@ class HotRunnerFactory extends basic_1.BasicRunnerFactory {
             })
                 .catch(callback);
         };
-        return new hot_1.HotRunner({
+        return new web_1.WebRunner({
+            dom: "fake",
             env,
-            stats: stats,
+            stats,
             name: this.name,
             runInNewContext: false,
-            testConfig,
+            testConfig: {
+                ...testConfig,
+                moduleScope(ms) {
+                    if (typeof testConfig.moduleScope === "function") {
+                        ms = testConfig.moduleScope(ms);
+                    }
+                    ms["NEXT"] = next;
+                    return ms;
+                }
+            },
             source,
             dist,
-            next,
             compilerOptions
         });
     }

package/dist/runner/multiple.d.ts

@@ -1,9 +1,9 @@
-import { ECompilerType, ITestEnv, ITestRunner, TCompilerOptions } from "../type";
+import { ECompilerType, ITestEnv, ITestRunner, TCompilerOptions, TCompilerStatsCompilation } from "../type";
 import { BasicRunnerFactory } from "./basic";
 export declare class MultipleRunnerFactory<T extends ECompilerType> extends BasicRunnerFactory<T> {
     protected runned: Set<string>;
     protected getRunnerKey(file: string): string;
-    protected createRunner(file: string, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
+    protected createRunner(file: string, stats: TCompilerStatsCompilation<T>, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
     protected getFileIndexHandler(file: string): {
         getIndex: () => number[];
         flagIndex: () => Set<string>;

package/dist/runner/multiple.js

@@ -12,11 +12,11 @@ class MultipleRunnerFactory extends basic_1.BasicRunnerFactory {
         const [index, seq] = getIndex();
         return `${this.name}-${index}[${seq}]`;
     }
-    createRunner(file, compilerOptions, env) {
+    createRunner(file, stats, compilerOptions, env) {
         const multiCompilerOptions = this.context.getValue(this.name, "multiCompilerOptions") || [];
         const { getIndex, flagIndex } = this.getFileIndexHandler(file);
         const [index] = getIndex();
-        const runner = super.createRunner(file, multiCompilerOptions[index], env);
+        const runner = super.createRunner(file, stats.children[index], multiCompilerOptions[index], env);
         flagIndex();
         return runner;
     }

package/dist/runner/normal.d.ts

@@ -1,5 +1,5 @@
-import { ECompilerType, ITestEnv, ITestRunner, TCompilerOptions } from "../type";
+import { ECompilerType, ITestEnv, ITestRunner, TCompilerOptions, TCompilerStatsCompilation } from "../type";
 import { BasicRunnerFactory } from "./basic";
 export declare class NormalRunnerFactory<T extends ECompilerType> extends BasicRunnerFactory<T> {
-    protected createRunner(file: string, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
+    protected createRunner(file: string, stats: TCompilerStatsCompilation<T>, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
 }

package/dist/runner/normal.js

@@ -4,7 +4,7 @@ exports.NormalRunnerFactory = void 0;
 const basic_1 = require("./basic");
 const normal_1 = require("./runner/normal");
 class NormalRunnerFactory extends basic_1.BasicRunnerFactory {
-    createRunner(file, compilerOptions, env) {
+    createRunner(file, stats, compilerOptions, env) {
         return new normal_1.NormalRunner({
             env,
             name: this.name,

package/dist/runner/runner/basic.d.ts

@@ -1,6 +1,16 @@
-import { ECompilerType, ITestRunner } from "../../type";
-import { IBasicGlobalContext, IBasicModuleScope, IBasicRunnerOptions, TBasicRunnerFile, TRunnerRequirer } from "../type";
-export declare class BasicRunner<T extends ECompilerType = ECompilerType.Rspack> implements ITestRunner {
+import { ECompilerType, ITestEnv, ITestRunner, TCompilerOptions, TCompilerStatsCompilation, TTestConfig } from "../../type";
+import { IBasicGlobalContext, IBasicModuleScope, TBasicRunnerFile, TModuleObject, TRunnerRequirer } from "../type";
+export interface IBasicRunnerOptions<T extends ECompilerType> {
+    env: ITestEnv;
+    stats?: TCompilerStatsCompilation<T>;
+    name: string;
+    runInNewContext?: boolean;
+    testConfig: TTestConfig<T>;
+    source: string;
+    dist: string;
+    compilerOptions: TCompilerOptions<T>;
+}
+export declare abstract class BasicRunner<T extends ECompilerType = ECompilerType.Rspack> implements ITestRunner {
     protected _options: IBasicRunnerOptions<T>;
     protected globalContext: IBasicGlobalContext | null;
     protected baseModuleScope: IBasicModuleScope | null;
@@ -8,14 +18,10 @@ export declare class BasicRunner<T extends ECompilerType = ECompilerType.Rspack>
     constructor(_options: IBasicRunnerOptions<T>);
     run(file: string): Promise<unknown>;
     getRequire(): TRunnerRequirer;
-    protected createGlobalContext(): IBasicGlobalContext;
-    protected createBaseModuleScope(): IBasicModuleScope;
-    protected createModuleScope(requireFn: TRunnerRequirer, m: {
-        exports: unknown;
-    }, file: TBasicRunnerFile): IBasicModuleScope;
+    protected abstract createGlobalContext(): IBasicGlobalContext;
+    protected abstract createBaseModuleScope(): IBasicModuleScope;
+    protected abstract createModuleScope(requireFn: TRunnerRequirer, m: TModuleObject, file: TBasicRunnerFile): IBasicModuleScope;
     protected getFile(modulePath: string[] | string, currentDirectory: string): TBasicRunnerFile | null;
-    protected createMissRequirer(): TRunnerRequirer;
-    protected createCjsRequirer(): TRunnerRequirer;
     protected preExecute(code: string, file: TBasicRunnerFile): void;
     protected postExecute(m: Object, file: TBasicRunnerFile): void;
     protected createRunner(): void;

package/dist/runner/runner/basic.js

@@ -4,13 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BasicRunner = void 0;
-const vm_1 = __importDefault(require("vm"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
-const define = function (...args) {
-    const factory = args.pop();
-    factory();
-};
 const isRelativePath = (p) => /^\.\.?\//.test(p);
 const getSubPath = (p) => {
     const lastSlash = p.lastIndexOf("/");
@@ -54,51 +49,6 @@ class BasicRunner {
     getRequire() {
         return this.requirers.get("entry");
     }
-    createGlobalContext() {
-        return {
-            console: console,
-            expect: expect,
-            setTimeout: ((cb, ms, ...args) => {
-                let timeout = setTimeout(cb, ms, ...args);
-                timeout.unref();
-                return timeout;
-            }),
-            clearTimeout: clearTimeout
-        };
-    }
-    createBaseModuleScope() {
-        const baseModuleScope = {
-            console: console,
-            it: this._options.env.it,
-            beforeEach: this._options.env.beforeEach,
-            afterEach: this._options.env.afterEach,
-            expect,
-            jest,
-            __STATS__: this._options.stats,
-            nsObj: (m) => {
-                Object.defineProperty(m, Symbol.toStringTag, {
-                    value: "Module"
-                });
-                return m;
-            }
-        };
-        if (this._options.stats) {
-            baseModuleScope["__STATS__"] = this._options.stats;
-        }
-        return baseModuleScope;
-    }
-    createModuleScope(requireFn, m, file) {
-        return {
-            ...this.baseModuleScope,
-            require: requireFn.bind(null, path_1.default.dirname(file.path)),
-            module: m,
-            exports: m.exports,
-            __dirname: path_1.default.dirname(file.path),
-            __filename: file.path,
-            _globalAssign: { expect },
-            define
-        };
-    }
     getFile(modulePath, currentDirectory) {
         if (Array.isArray(modulePath)) {
             return {
@@ -123,62 +73,12 @@ class BasicRunner {
             return null;
         }
     }
-    createMissRequirer() {
-        return (currentDirectory, modulePath, context = {}) => {
-            const modulePathStr = modulePath;
-            const modules = this._options.testConfig.modules;
-            if (modules && modulePathStr in modules) {
-                return modules[modulePathStr];
-            }
-            else {
-                return require(modulePathStr.startsWith("node:")
-                    ? modulePathStr.slice(5)
-                    : modulePathStr);
-            }
-        };
-    }
-    createCjsRequirer() {
-        const requireCache = Object.create(null);
-        return (currentDirectory, modulePath, context = {}) => {
-            let file = context["file"] || this.getFile(modulePath, currentDirectory);
-            if (!file) {
-                return this.requirers.get("miss")(currentDirectory, modulePath);
-            }
-            if (file.path in requireCache) {
-                return requireCache[file.path].exports;
-            }
-            const m = {
-                exports: {}
-            };
-            requireCache[file.path] = m;
-            const currentModuleScope = this.createModuleScope(this.getRequire(), m, file);
-            if (this._options.testConfig.moduleScope) {
-                this._options.testConfig.moduleScope(currentModuleScope);
-            }
-            if (!this._options.runInNewContext) {
-                file.content = `Object.assign(global, _globalAssign);\n ${file.content}`;
-            }
-            const args = Object.keys(currentModuleScope);
-            const argValues = args.map(arg => currentModuleScope[arg]);
-            const code = `(function(${args.join(", ")}) {
-        ${file.content}
-      })`;
-            this.preExecute(code, file);
-            const fn = this._options.runInNewContext
-                ? vm_1.default.runInNewContext(code, this.globalContext, file.path)
-                : vm_1.default.runInThisContext(code, file.path);
-            fn.call(this._options.testConfig.nonEsmThis
-                ? this._options.testConfig.nonEsmThis(modulePath)
-                : m.exports, ...argValues);
-            this.postExecute(m, file);
-            return m.exports;
-        };
-    }
     preExecute(code, file) { }
     postExecute(m, file) { }
     createRunner() {
-        this.requirers.set("miss", this.createMissRequirer());
-        this.requirers.set("entry", this.createCjsRequirer());
+        this.requirers.set("entry", (currentDirectory, modulePath, context = {}) => {
+            throw new Error("Not implement");
+        });
     }
 }
 exports.BasicRunner = BasicRunner;

package/dist/runner/runner/cjs.d.ts

@@ -0,0 +1,11 @@
+import { ECompilerType } from "../../type";
+import { IBasicGlobalContext, IBasicModuleScope, TBasicRunnerFile, TModuleObject, TRunnerRequirer } from "../type";
+import { BasicRunner } from "./basic";
+export declare class CommonJsRunner<T extends ECompilerType = ECompilerType.Rspack> extends BasicRunner<T> {
+    protected createGlobalContext(): IBasicGlobalContext;
+    protected createBaseModuleScope(): IBasicModuleScope;
+    protected createModuleScope(requireFn: TRunnerRequirer, m: TModuleObject, file: TBasicRunnerFile): IBasicModuleScope;
+    protected createRunner(): void;
+    protected createMissRequirer(): TRunnerRequirer;
+    protected createCjsRequirer(): TRunnerRequirer;
+}