@rspack/test-tools 1.5.6 → 1.5.8

package/dist/runner/type.d.ts

@@ -1,42 +0,0 @@
-import type { ITestEnv } from "../type";
-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 THotStepRuntimeLangData = {
-    outdatedModules: string[];
-    outdatedDependencies: Record<string, string[]>;
-    updatedModules: string[];
-    updatedRuntime: string[];
-    acceptedModules: string[];
-    disposedModules: string[];
-};
-export type THotStepRuntimeData = {
-    javascript: THotStepRuntimeLangData;
-    css: THotStepRuntimeLangData;
-    statusPath: string[];
-};

package/dist/runner/type.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EEsmMode = void 0;
-var EEsmMode;
-(function (EEsmMode) {
-    EEsmMode[EEsmMode["Unknown"] = 0] = "Unknown";
-    EEsmMode[EEsmMode["Evaluated"] = 1] = "Evaluated";
-    EEsmMode[EEsmMode["Unlinked"] = 2] = "Unlinked";
-})(EEsmMode || (exports.EEsmMode = EEsmMode = {}));

package/dist/runner/watch.d.ts

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

package/dist/runner/watch.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WatchRunnerFactory = void 0;
-const type_1 = require("../type");
-const basic_1 = require("./basic");
-const runner_1 = require("./runner");
-class WatchRunnerFactory extends basic_1.BasicRunnerFactory {
-    getRunnerKey(file) {
-        const stepName = this.context.getValue(this.name, "watchStepName");
-        return `${this.name}-${stepName}`;
-    }
-    createStatsGetter() {
-        const compiler = this.context.getCompiler(this.name);
-        const stepName = this.context.getValue(this.name, "watchStepName");
-        const statsGetter = (() => {
-            const cached = {};
-            return () => {
-                if (cached[stepName]) {
-                    return cached[stepName];
-                }
-                cached[stepName] = compiler.getStats().toJson({
-                    errorDetails: true
-                });
-                return cached[stepName];
-            };
-        })();
-        return statsGetter;
-    }
-    createRunner(file, stats, compilerOptions, env) {
-        this.context.getCompiler(this.name);
-        const stepName = this.context.getValue(this.name, "watchStepName");
-        if (!stepName) {
-            throw new Error("Can not get watch step name from context");
-        }
-        const state = this.context.getValue(this.name, "watchState");
-        if (!state) {
-            throw new Error("Can not get watch state from context");
-        }
-        const isWeb = Array.isArray(compilerOptions)
-            ? compilerOptions.some(option => {
-                return option.target === "web" || option.target === "webworker";
-            })
-            : compilerOptions.target === "web" ||
-                compilerOptions.target === "webworker";
-        const testConfig = this.context.getTestConfig();
-        const documentType = this.context.getValue(this.name, "documentType") || type_1.EDocumentType.Fake;
-        return new runner_1.WebRunner({
-            dom: documentType,
-            env,
-            stats,
-            name: this.name,
-            runInNewContext: isWeb,
-            cachable: false,
-            testConfig: {
-                ...(testConfig || {}),
-                moduleScope: (ms, stats, options) => {
-                    ms.STATE = state;
-                    ms.WATCH_STEP = stepName;
-                    if (typeof testConfig.moduleScope === "function") {
-                        return testConfig.moduleScope(ms, stats, options);
-                    }
-                    return ms;
-                }
-            },
-            source: this.context.getSource(),
-            dist: this.context.getDist(),
-            compilerOptions
-        });
-    }
-}
-exports.WatchRunnerFactory = WatchRunnerFactory;

package/dist/test/simple.d.ts

@@ -1,5 +0,0 @@
-import type { ITestContext, ITestEnv, ITestProcessor } from "../type";
-export declare function getSimpleProcessorRunner(src: string, dist: string, options?: {
-    env?: () => ITestEnv;
-    context?: (src: string, dist: string) => ITestContext;
-}): (name: string, processor: ITestProcessor) => Promise<void>;

package/dist/test/simple.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSimpleProcessorRunner = getSimpleProcessorRunner;
-const context_1 = require("./context");
-const CONTEXT_MAP = new Map();
-function getSimpleProcessorRunner(src, dist, options = {}) {
-    const createEnv = options.env || (() => ({ expect, it, beforeEach, afterEach, jest }));
-    const createContext = options.context ||
-        ((src, dist) => new context_1.TestContext({ src, dist }));
-    const key = `src: ${src}, dist: ${dist}`;
-    if (!CONTEXT_MAP.has(key)) {
-        const context = createContext(src, dist);
-        const runner = async function run(name, processor) {
-            try {
-                await processor.beforeAll?.(context);
-                await processor.before?.(context);
-                await processor.config?.(context);
-                await processor.compiler?.(context);
-                await processor.build?.(context);
-            }
-            catch (e) {
-                context.emitError(name, e);
-            }
-            finally {
-                if (!context.hasError()) {
-                    await processor.run?.(createEnv(), context);
-                }
-                await processor.check?.(createEnv(), context);
-                await processor.after?.(context);
-                await processor.afterAll?.(context);
-            }
-            if (context.hasError()) {
-                const errors = context
-                    .getError()
-                    .map(i => `${i.stack}`.split("\n").join("\t\n"))
-                    .join("\n\n");
-                throw new Error(`Case "${name}" failed:\n${errors}`);
-            }
-        };
-        CONTEXT_MAP.set(key, runner);
-    }
-    return CONTEXT_MAP.get(key);
-}