@rstest/core 0.7.2 → 0.7.4

package/dist/globalSetupWorker.d.ts

@@ -0,0 +1,9 @@
+export declare const runGlobalTeardown: () => Promise<{
+    success: boolean;
+    error?: string;
+}>;
+
+declare function runInPool(options: any): Promise<any>;
+export default runInPool;
+
+export { }

package/dist/globalSetupWorker.js

@@ -0,0 +1,115 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { formatTestError } from "./913.js";
+import "./664.js";
+const source_map_support = __webpack_require__("../../node_modules/.pnpm/source-map-support@0.5.21/node_modules/source-map-support/source-map-support.js");
+const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+let teardownCallbacks = [];
+let initialEnv = {};
+let envChanges = {};
+function trackEnvChanges() {
+    initialEnv = {
+        ...process.env
+    };
+}
+function captureEnvChanges() {
+    const changes = {};
+    for(const key in process.env)if (process.env[key] !== initialEnv[key]) changes[key] = process.env[key];
+    for(const key in initialEnv)if (!(key in process.env) && void 0 !== initialEnv[key]) changes[key] = void 0;
+    return changes;
+}
+const runGlobalSetup = async (data)=>{
+    try {
+        if (0 === data.entries.length) return {
+            success: true,
+            hasTeardown: false
+        };
+        (0, source_map_support.install)({
+            environment: 'node',
+            handleUncaughtExceptions: false,
+            retrieveSourceMap: (source)=>{
+                if (data.sourceMaps[source]) return {
+                    url: source,
+                    map: JSON.parse(data.sourceMaps[source])
+                };
+                return null;
+            }
+        });
+        trackEnvChanges();
+        for (const entry of data.entries){
+            const { distPath, testPath } = entry;
+            const setupCodeContent = data.assetFiles[distPath];
+            const { loadModule } = data.outputModule ? await import("./0~923.js").then((mod)=>({
+                    EsmMode: mod.loadEsModule_EsmMode,
+                    asModule: mod.asModule,
+                    loadModule: mod.loadModule
+                })) : await import("./0~835.js").then((mod)=>({
+                    cacheableLoadModule: mod.cacheableLoadModule,
+                    loadModule: mod.loadModule
+                }));
+            const module = await loadModule({
+                codeContent: setupCodeContent,
+                distPath,
+                testPath,
+                rstestContext: {
+                    global,
+                    console: global.console,
+                    Error
+                },
+                assetFiles: data.assetFiles,
+                interopDefault: data.interopDefault
+            });
+            let teardownCallback;
+            if (module && 'object' == typeof module) {
+                if (module.setup && 'function' == typeof module.setup) {
+                    await module.setup();
+                    if (module.teardown && 'function' == typeof module.teardown) teardownCallback = module.teardown;
+                } else if (module.default && 'function' == typeof module.default) teardownCallback = await module.default();
+            }
+            if (teardownCallback) teardownCallbacks.push(teardownCallback);
+        }
+        envChanges = captureEnvChanges();
+        return {
+            success: true,
+            hasTeardown: teardownCallbacks.length > 0,
+            teardownCount: teardownCallbacks.length,
+            envChanges: envChanges
+        };
+    } catch (error) {
+        return {
+            success: false,
+            hasTeardown: false,
+            errors: formatTestError(error)
+        };
+    }
+};
+async function runInPool(options) {
+    switch(options.type){
+        case 'setup':
+            return runGlobalSetup(options);
+        case 'teardown':
+            return runGlobalTeardown();
+    }
+}
+const runGlobalTeardown = async ()=>{
+    try {
+        const callbacks = [
+            ...teardownCallbacks
+        ];
+        teardownCallbacks = [];
+        for (const teardown of callbacks.reverse())await teardown();
+        return {
+            success: true
+        };
+    } catch (error) {
+        const message = error instanceof Error && error.stack ? error.stack : String(error);
+        console.error(picocolors_default().red(`Error during global teardown: ${message}`));
+        return {
+            success: false
+        };
+    }
+};
+export default runInPool;
+export { runGlobalTeardown };

package/dist/index.d.ts

@@ -20,11 +20,7 @@ declare type AfterAllListener = (ctx: SuiteContext) => MaybePromise<void>;
 
 export declare const afterEach: Rstest['afterEach'];
 
-declare type AfterEachListener = (params: {
-    task: {
-        result: Readonly<TestResult>;
-    };
-}) => MaybePromise<void>;
+declare type AfterEachListener = (ctx: TestContext) => MaybePromise<void>;
 
 export declare const assert: Rstest['assert'];
 
@@ -259,7 +255,7 @@ declare type BeforeAllListener = (ctx: SuiteContext) => MaybePromise<void | Afte
 
 export declare const beforeEach: Rstest['beforeEach'];
 
-declare type BeforeEachListener = () => MaybePromise<void | AfterEachListener>;
+declare type BeforeEachListener = (ctx: TestContext) => MaybePromise<void | AfterEachListener>;
 
 declare interface BranchMapping {
     loc: Range_2;
@@ -364,6 +360,59 @@ declare interface Constructable {
     	new (...args: any[]): any;
 }
 
+/**
+ * Base class for writing content
+ */
+declare class ContentWriter {
+    /**
+     * returns the colorized version of a string. Typically,
+     * content writers that write to files will return the
+     * same string and ones writing to a tty will wrap it in
+     * appropriate escape sequences.
+     */
+    colorize(str: string, clazz?: string): string;
+    /**
+     * writes a string appended with a newline to the destination
+     */
+    println(str: string): void;
+    /**
+     * closes this content writer. Should be called after all writes are complete.
+     */
+    close(): void;
+}
+
+declare interface Context {
+    data: any;
+    dir: string;
+    sourceFinder(filepath: string): string;
+    watermarks: Watermarks;
+    writer: FileWriter;
+    /**
+     * returns the coverage class given a coverage
+     * types and a percentage value.
+     */
+    classForPercent(type: keyof Watermarks, value: number): string;
+    /**
+     * returns the source code for the specified file path or throws if
+     * the source could not be found.
+     */
+    getSource(filepath: string): string;
+    getTree(summarizer?: Summarizers): Tree;
+    /**
+     * returns a full visitor given a partial one.
+     */
+    getVisitor<N extends Node_2 = Node_2>(visitor: Partial<Visitor<N>>): Visitor<N>;
+    /**
+     * returns a FileWriter implementation for reporting use. Also available
+     * as the `writer` property on the context.
+     */
+    getWriter(): FileWriter;
+    /**
+     * returns an XML writer for the supplied content writer
+     */
+    getXmlWriter(contentWriter: ContentWriter): XmlWriter;
+}
+
 declare class CounterMap<K> extends DefaultMap<K, number> {
     	constructor();
     	// compat for jest-image-snapshot https://github.com/vitest-dev/vitest/issues/7322
@@ -435,7 +484,7 @@ export declare type CoverageOptions = {
      * The reporters to use for coverage collection.
      * @default ['text', 'html', 'clover', 'json']
      */
-    reporters?: (keyof ReportOptions | ReportWithOptions)[];
+    reporters?: (keyof ReportOptions | ReportWithOptions | ReportBase)[];
     /**
      * The directory to store coverage reports.
      * @default './coverage'
@@ -591,12 +640,13 @@ declare class DefaultReporter implements Reporter {
     onTestCaseResult(): void;
     onUserConsoleLog(log: UserConsoleLog): void;
     onExit(): Promise<void>;
-    onTestRunEnd({ results, testResults, duration, getSourcemap, snapshotSummary, filterRerunTestPaths, }: {
+    onTestRunEnd({ results, testResults, duration, getSourcemap, snapshotSummary, filterRerunTestPaths, unhandledErrors, }: {
         results: TestFileResult[];
         testResults: TestResult[];
         duration: Duration;
         snapshotSummary: SnapshotSummary;
         getSourcemap: GetSourcemap;
+        unhandledErrors?: Error[];
         filterRerunTestPaths?: string[];
     }): Promise<void>;
 }
@@ -848,6 +898,29 @@ declare interface FileOptions {
     file: string;
 }
 
+/**
+ * utility for writing files under a specific directory
+ */
+declare class FileWriter {
+    constructor(baseDir: string);
+    static startCapture(): void;
+    static stopCapture(): void;
+    static getOutput(): string;
+    static resetOutput(): void;
+    /**
+     * returns a FileWriter that is rooted at the supplied subdirectory
+     */
+    writeForDir(subdir: string): FileWriter;
+    /**
+     * copies a file from a source directory to a destination name
+     */
+    copyFile(source: string, dest: string, header?: string): void;
+    /**
+     * returns a content writer for writing content to the supplied file.
+     */
+    writeFile(file: string | null): ContentWriter;
+}
+
 declare type Fixture<T, K extends keyof T, ExtraContext = object> = ((...args: any) => any) extends T[K] ? T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never : T[K] | (T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never);
 
 declare type FixtureFn<T, K extends keyof T, ExtraContext> = (context: Omit<T, K> & ExtraContext, use: Use<T[K]>) => Promise<void>;
@@ -1394,6 +1467,15 @@ declare interface LinkMapper {
 declare type ListCommandOptions = {
     filesOnly?: boolean;
     json?: boolean | string;
+    includeSuites?: boolean;
+    printLocation?: boolean;
+};
+
+declare type ListCommandResult = {
+    tests: Test_2[];
+    testPath: string;
+    project: string;
+    errors?: FormattedError[];
 };
 
 export declare function loadConfig({ cwd, path, envMode, configLoader, }: {
@@ -1406,7 +1488,12 @@ export declare function loadConfig({ cwd, path, envMode, configLoader, }: {
     filePath: string | null;
 }>;
 
-declare interface Location_2 {
+declare type Location_2 = {
+    line: number;
+    column: number;
+};
+
+declare interface Location_3 {
     line: number;
     column: number;
 }
@@ -1463,6 +1550,8 @@ declare interface MatcherState_2 extends MatcherState {
 
 declare type MaybePromise<T> = T | Promise<T>;
 
+export declare const mergeProjectConfig: (...configs: ProjectConfig[]) => ProjectConfig;
+
 export declare const mergeRstestConfig: (...configs: RstestConfig[]) => RstestConfig;
 
 export declare interface Mock<T extends FunctionLike = FunctionLike> extends MockInstance_2<T> {
@@ -1925,10 +2014,11 @@ declare interface Node_2 {
     visit(visitor: Visitor, state: any): void;
 }
 
-declare type NormalizedConfig = Required<Omit<RstestConfig, OptionalKeys | 'pool' | 'projects' | 'coverage' | 'setupFiles' | 'exclude'>> & Partial<Pick<RstestConfig, OptionalKeys>> & {
+declare type NormalizedConfig = Required<Omit<RstestConfig, OptionalKeys | 'pool' | 'projects' | 'coverage' | 'setupFiles' | 'globalSetup' | 'exclude'>> & Partial<Pick<RstestConfig, OptionalKeys>> & {
     pool: RstestPoolOptions;
     coverage: NormalizedCoverageOptions;
     setupFiles: string[];
+    globalSetup: string[];
     exclude: {
         patterns: string[];
         override?: boolean;
@@ -1940,12 +2030,22 @@ export declare type NormalizedCoverageOptions = Required<Omit<CoverageOptions, '
     include?: string[];
 };
 
+declare type NormalizedFixture = {
+    isFn: boolean;
+    deps?: string[];
+    value: FixtureFn<any, any, any> | any;
+    options?: FixtureOptions;
+};
+
+declare type NormalizedFixtures = Record<string, NormalizedFixture>;
+
 declare type NormalizedProcedure<T extends Procedure> = (...args: Parameters<T>) => ReturnType<T>;
 
 declare type NormalizedProcedure_2<T extends Procedure_2> = (...args: Parameters<T>) => ReturnType<T>;
 
-declare type NormalizedProjectConfig = Required<Omit<NormalizedConfig, OptionalKeys | 'projects' | 'reporters' | 'pool' | 'setupFiles'>> & Pick<NormalizedConfig, OptionalKeys> & {
+declare type NormalizedProjectConfig = Required<Omit<NormalizedConfig, OptionalKeys | 'projects' | 'reporters' | 'pool' | 'setupFiles' | 'globalSetup'>> & Pick<NormalizedConfig, OptionalKeys> & {
     setupFiles: string[];
+    globalSetup: string[];
 };
 
 declare interface OldPlugin {
@@ -1955,19 +2055,11 @@ declare interface OldPlugin {
 
 export declare const onTestFailed: Rstest['onTestFailed'];
 
-declare type OnTestFailedHandler = (params: {
-    task: {
-        result: Readonly<TestResult>;
-    };
-}) => MaybePromise<void>;
+declare type OnTestFailedHandler = (ctx: TestContext) => MaybePromise<void>;
 
 export declare const onTestFinished: Rstest['onTestFinished'];
 
-declare type OnTestFinishedHandler = (params: {
-    task: {
-        result: Readonly<TestResult>;
-    };
-}) => MaybePromise<void>;
+declare type OnTestFinishedHandler = (ctx: TestContext) => MaybePromise<void>;
 
 declare type OptionalKeys = 'testNamePattern' | 'plugins' | 'source' | 'resolve' | 'output' | 'performance' | 'tools' | 'dev' | 'onConsoleLog' | 'chaiConfig' | 'resolveSnapshotPath';
 
@@ -2051,6 +2143,7 @@ declare type ProjectContext = {
     outputModule: boolean;
     configFilePath?: string;
     normalizedConfig: NormalizedProjectConfig;
+    _globalSetups: boolean;
 };
 
 declare interface ProjectOptions {
@@ -2068,8 +2161,8 @@ declare type PromisifyAssertion<T> = Promisify<Assertion_2<T>>;
 declare type PromisifyAssertion_2<T> = Promisify_2<Assertion<T>>;
 
 declare interface Range_2 {
-    start: Location_2;
-    end: Location_2;
+    start: Location_3;
+    end: Location_3;
 }
 
 declare interface RawMatcherFn<
@@ -2087,11 +2180,24 @@ declare interface RawSnapshotInfo {
 
 declare type Refs = Array<unknown>;
 
+declare class ReportBase {
+    constructor(options?: Partial<ReportBaseOptions>);
+    execute(context: Context): void;
+}
+
+declare interface ReportBaseOptions {
+    summarizer: Summarizers;
+}
+
 export declare interface Reporter {
     /**
      * Called before test file run.
      */
     onTestFileStart?: (test: TestFileInfo) => void;
+    /**
+     * Called after tests in file collected.
+     */
+    onTestFileReady?: (test: TestFileInfo) => void;
     /**
      * Called when the test file has finished running.
      */
@@ -2117,11 +2223,12 @@ export declare interface Reporter {
     /**
      * Called after all tests have finished running.
      */
-    onTestRunEnd?: ({ results, testResults, duration, getSourcemap, snapshotSummary, }: {
+    onTestRunEnd?: ({ results, testResults, duration, getSourcemap, snapshotSummary, unhandledErrors, }: {
         results: TestFileResult[];
         testResults: TestResult[];
         duration: Duration;
         getSourcemap: GetSourcemap;
+        unhandledErrors?: Error[];
         snapshotSummary: SnapshotSummary;
         filterRerunTestPaths?: string[];
     }) => MaybePromise<void>;
@@ -2231,6 +2338,12 @@ export declare interface RstestConfig {
      * Path to setup files. They will be run before each test file.
      */
     setupFiles?: string[] | string;
+    /**
+     * Path to global setup files, relative to project root.
+     * A global setup file can either export named functions `setup` and `teardown`
+     * or a `default` function that returns a teardown function.
+     */
+    globalSetup?: string[] | string;
     /**
      * Retry the test specific number of times if it fails.
      * @default 0
@@ -2376,6 +2489,10 @@ export declare interface RstestConfig {
      * chai configuration options
      */
     chaiConfig?: ChaiConfig;
+    /**
+     * Include `location` property in `TestInfo` received by reporters
+     */
+    includeTaskLocation?: boolean;
     plugins?: RsbuildConfig['plugins'];
     source?: Pick<NonNullable<RsbuildConfig['source']>, 'define' | 'tsconfigPath' | 'decorators' | 'include' | 'exclude'>;
     performance?: Pick<NonNullable<RsbuildConfig['performance']>, 'bundleAnalyze'>;
@@ -2428,7 +2545,7 @@ declare type RstestContext = {
 declare type RstestInstance = {
     context: RstestContext;
     runTests: () => Promise<void>;
-    listTests: (options: ListCommandOptions) => Promise<void>;
+    listTests: (options: ListCommandOptions) => Promise<ListCommandResult[]>;
 };
 
 declare type RstestPoolOptions = {
@@ -2490,6 +2607,10 @@ export declare interface RstestUtilities {
      * Mock a module, not hoisted.
      */
     doMockRequire: <T = unknown>(moduleName: string, moduleFactory?: () => T) => void;
+    /**
+     * Hoisted mock function.
+     */
+    hoisted: <T = unknown>(fn: () => T) => T;
     /**
      * Removes module from the mocked registry.
      */
@@ -2596,7 +2717,7 @@ declare type RunningModules = Map<string, {
     results: TestResult[];
 }>;
 
-declare type RuntimeConfig = Pick<RstestContext['normalizedConfig'], 'testTimeout' | 'testNamePattern' | 'globals' | 'passWithNoTests' | 'retry' | 'clearMocks' | 'resetMocks' | 'restoreMocks' | 'unstubEnvs' | 'unstubGlobals' | 'maxConcurrency' | 'printConsoleTrace' | 'disableConsoleIntercept' | 'testEnvironment' | 'isolate' | 'hookTimeout' | 'coverage' | 'snapshotFormat' | 'env' | 'logHeapUsage' | 'bail' | 'chaiConfig'>;
+declare type RuntimeConfig = Pick<RstestContext['normalizedConfig'], 'testTimeout' | 'testNamePattern' | 'globals' | 'passWithNoTests' | 'retry' | 'clearMocks' | 'resetMocks' | 'restoreMocks' | 'unstubEnvs' | 'unstubGlobals' | 'maxConcurrency' | 'printConsoleTrace' | 'disableConsoleIntercept' | 'testEnvironment' | 'isolate' | 'hookTimeout' | 'coverage' | 'snapshotFormat' | 'env' | 'logHeapUsage' | 'bail' | 'chaiConfig' | 'includeTaskLocation'>;
 
 declare type RuntimeOptions = Partial<Pick<RuntimeConfig, 'testTimeout' | 'hookTimeout' | 'clearMocks' | 'resetMocks' | 'restoreMocks' | 'maxConcurrency' | 'retry'>>;
 
@@ -2793,6 +2914,8 @@ declare type SuiteContext = {
     filepath: TestPath;
 };
 
+declare type Summarizers = "flat" | "nested" | "pkg" | "defaultSummarizer";
+
 declare interface SyncExpectationResult {
     	pass: boolean;
     	message: () => string;
@@ -2800,6 +2923,23 @@ declare interface SyncExpectationResult {
     	expected?: any;
 }
 
+declare interface TaskResult {
+    /**
+     * State of the task. Inherits the `task.mode` during collection.
+     * When the task has finished, it will be changed to `pass` or `fail`.
+     * - **pass**: task ran successfully
+     * - **fail**: task failed
+     */
+    state: TaskState;
+    /**
+     * Errors that occurred during the task execution. It is possible to have several errors
+     * if `expect.soft()` failed multiple times or `retry` was triggered.
+     */
+    errors?: FormattedError[];
+}
+
+declare type TaskState = 'pass' | 'fail';
+
 declare interface TeamcityOptions extends FileOptions {
     blockName: string;
 }
@@ -2808,6 +2948,8 @@ declare type Test = (arg0: any) => boolean;
 
 export declare const test: Rstest['test'];
 
+declare type Test_2 = TestSuite | TestCase;
+
 declare type TestAPI<ExtraContext = object> = TestFn<ExtraContext> & {
     each: TestEachFn;
     for: TestForFn<ExtraContext>;
@@ -2829,6 +2971,34 @@ declare type TestAPIs<ExtraContext = object> = TestAPI<ExtraContext> & {
 
 declare type TestCallbackFn<ExtraContext = object> = (context: TestContext & ExtraContext) => MaybePromise<void>;
 
+declare type TestCase = TestCaseInfo & {
+    originalFn?: (context: TestContext) => void | Promise<void>;
+    fn?: (context: TestContext) => void | Promise<void>;
+    runMode: TestRunMode;
+    fails?: boolean;
+    each?: boolean;
+    fixtures?: NormalizedFixtures;
+    concurrent?: boolean;
+    sequential?: boolean;
+    inTestEach?: boolean;
+    context: TestContext;
+    only?: boolean;
+    onFinished: OnTestFinishedHandler[];
+    onFailed: OnTestFailedHandler[];
+    /**
+     * Store promises (from async expects) to wait for them before finishing the test
+     */
+    promises?: Promise<any>[];
+    /**
+     * Store stack trace error created when test is registered, used for trace original position
+     */
+    stackTraceError: Error;
+    /**
+     * Result of the task. if `expect.soft()` failed multiple times or `retry` was triggered.
+     */
+    result?: TaskResult;
+};
+
 export declare type TestCaseInfo = {
     testId: string;
     testPath: TestPath;
@@ -2837,9 +3007,21 @@ export declare type TestCaseInfo = {
     parentNames?: string[];
     project: string;
     startTime?: number;
+    /** Only included when `includeTaskLocation` config is enabled */
+    location?: Location_2;
+    type: 'case';
 };
 
 declare type TestContext = {
+    /**
+     * Metadata of the current test
+     */
+    task: {
+        /** Test name provided by user */
+        name: string;
+        /** Result of the current test, undefined if the test is not run yet */
+        result?: TestResult;
+    };
     expect: Expect;
     onTestFinished: RunnerAPI['onTestFinished'];
     onTestFailed: RunnerAPI['onTestFailed'];
@@ -2859,6 +3041,7 @@ declare interface TesterContext {
 
 export declare type TestFileInfo = {
     testPath: TestPath;
+    tests: TestInfo[];
 };
 
 export declare type TestFileResult = TestResult & {
@@ -2871,6 +3054,10 @@ declare type TestFn<ExtraContext = object> = (description: string, fn?: TestCall
 
 declare type TestForFn<ExtraContext = object> = <T>(cases: readonly T[]) => (description: string, fn?: (param: T, context: TestContext & ExtraContext) => MaybePromise<void>, timeout?: number) => void;
 
+export declare type TestInfo = TestCaseInfo | (TestSuiteInfo & {
+    tests: TestInfo[];
+});
+
 /** The test file original path */
 declare type TestPath = string;
 
@@ -2891,6 +3078,8 @@ export declare type TestResult = {
 
 declare type TestResultStatus = 'skip' | 'pass' | 'fail' | 'todo';
 
+declare type TestRunMode = 'run' | 'skip' | 'todo' | 'only';
+
 declare class TestStateManager {
     runningModules: Map<string, {
         runningTests: TestCaseInfo[];
@@ -2905,12 +3094,29 @@ declare class TestStateManager {
     reset(): void;
 }
 
+declare type TestSuite = TestSuiteInfo & {
+    runMode: TestRunMode;
+    each?: boolean;
+    inTestEach?: boolean;
+    concurrent?: boolean;
+    sequential?: boolean;
+    /** nested cases and suite could in a suite */
+    tests: Test_2[];
+    afterAllListeners?: AfterAllListener[];
+    beforeAllListeners?: BeforeAllListener[];
+    afterEachListeners?: AfterEachListener[];
+    beforeEachListeners?: BeforeEachListener[];
+};
+
 export declare type TestSuiteInfo = {
     testId: string;
     name: string;
     parentNames?: string[];
     testPath: TestPath;
     project: string;
+    type: 'suite';
+    /** Only included when `includeTaskLocation` config is enabled */
+    location?: Location_2;
 };
 
 declare type TextLcovOptions = ProjectOptions;
@@ -2956,6 +3162,11 @@ declare class TraceMap implements SourceMap {
     constructor(map: Ro<SourceMapInput>, mapUrl?: string | null);
 }
 
+declare interface Tree<N extends Node_2 = Node_2> {
+    getRoot(): N;
+    visit(visitor: Partial<Visitor<N>>, state: any): void;
+}
+
 declare interface UncheckedSnapshot {
     	filePath: string;
     	keys: Array<string>;
@@ -2988,10 +3199,39 @@ declare type VitestAssertion<
 	T
 > = { [K in keyof A] : A[K] extends Chai.Assertion ? Assertion_2<T> : A[K] extends (...args: any[]) => any ? A[K] : VitestAssertion<A[K], T> } & ((type: string, message?: string) => Assertion_2);
 
+declare type Watermark = [number, number];
+
+declare interface Watermarks {
+    statements: Watermark;
+    functions: Watermark;
+    branches: Watermark;
+    lines: Watermark;
+}
+
 declare type WithAsymmetricMatcher<T> = T | AsymmetricMatcher<unknown>;
 
 declare type XInput = {
     x_google_ignoreList?: SourceMapV3['ignoreList'];
 };
 
+declare interface XmlWriter {
+    indent(str: string): string;
+    /**
+     * writes the opening XML tag with the supplied attributes
+     */
+    openTag(name: string, attrs?: any): void;
+    /**
+     * closes an open XML tag.
+     */
+    closeTag(name: string): void;
+    /**
+     * writes a tag and its value opening and closing it at the same time
+     */
+    inlineTag(name: string, attrs?: any, content?: string): void;
+    /**
+     * closes all open tags and ends the document
+     */
+    closeAll(): void;
+}
+
 export { }

package/dist/index.js

@@ -1,3 +1,3 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
-export { afterAll, afterEach, assert, beforeAll, beforeEach, createRstest, defineConfig, defineProject, describe, expect, initCli, it, loadConfig, mergeRstestConfig, onTestFailed, onTestFinished, rs, rstest, runCLI, test } from "./131.js";
+export { afterAll, afterEach, assert, beforeAll, beforeEach, createRstest, defineConfig, defineProject, describe, expect, initCli, it, loadConfig, mergeProjectConfig, mergeRstestConfig, onTestFailed, onTestFinished, rs, rstest, runCLI, test } from "./131.js";

package/dist/mockRuntimeCode.js

@@ -123,3 +123,4 @@ __webpack_require__.rstest_reset_modules = ()=>{
         if (!mockedIds.includes(id)) delete __webpack_module_cache__[id];
     });
 };
+__webpack_require__.rstest_hoisted = (fn)=>fn();