@rstest/core 0.8.0 → 0.8.2

package/dist/index.d.ts

@@ -312,11 +312,14 @@ declare type BrowserModeConfig = {
  */
 declare type BrowserName = 'chromium' | 'firefox' | 'webkit';
 
-declare type BuiltInReporterNames = keyof typeof reportersMap;
+declare type BuiltInReporterNames = 'default' | 'verbose' | 'md' | 'github-actions' | 'junit';
 
 declare type BuiltinReporterOptions = {
     default: DefaultReporterOptions;
     verbose: VerboseReporterOptions;
+    md: MdReporterOptions;
+    'github-actions': Record<string, unknown>;
+    junit: Record<string, unknown>;
 };
 
 declare type ChaiConfig = Partial<Omit<typeof config, 'useProxy' | 'proxyExcludedKeys' | 'deepEqual'>>;
@@ -359,6 +362,17 @@ declare type CommonOptions = {
     config?: string;
     configLoader?: LoadConfigOptions['loader'];
     globals?: boolean;
+    /**
+     * Pool options.
+     * - `string`: shorthand for `{ type: string }` (from `--pool` flag)
+     * - `object`: detailed pool config (from `--pool.*` options)
+     */
+    pool?: string | {
+        type?: string;
+        maxWorkers?: string | number;
+        minWorkers?: string | number;
+        execArgv?: string[] | string;
+    };
     /**
      * Browser mode options.
      * - `boolean`: shorthand for `{ enabled: boolean }` (from `--browser` flag)
@@ -397,6 +411,7 @@ declare type CommonOptions = {
     hideSkippedTests?: boolean;
     hideSkippedTestFiles?: boolean;
     bail?: number | boolean;
+    shard?: string;
 };
 
 declare type CompareKeys = ((a: string, b: string) => number) | null | undefined;
@@ -422,6 +437,8 @@ declare interface Constructable {
     	new (...args: any[]): any;
 }
 
+declare type Constructor<T = any> = new (...args: any[]) => T;
+
 /**
  * Base class for writing content
  */
@@ -699,40 +716,6 @@ declare class DefaultMap<
     	get(key: K): V;
 }
 
-declare class DefaultReporter implements Reporter {
-    protected rootPath: string;
-    protected config: NormalizedConfig;
-    private options;
-    protected statusRenderer: StatusRenderer | undefined;
-    private testState;
-    constructor({ rootPath, options, config, testState, }: {
-        rootPath: string;
-        config: NormalizedConfig;
-        options: DefaultReporterOptions;
-        testState: RstestTestState;
-    });
-    /**
-     * Lazily create StatusRenderer on first test file start.
-     * This avoids intercepting stdout/stderr before tests actually begin,
-     * ensuring early errors (like missing Playwright browsers) remain visible.
-     */
-    private ensureStatusRenderer;
-    onTestFileStart(): void;
-    onTestFileResult(test: TestFileResult): void;
-    onTestCaseResult(): void;
-    onUserConsoleLog(log: UserConsoleLog): void;
-    onExit(): Promise<void>;
-    onTestRunEnd({ results, testResults, duration, getSourcemap, snapshotSummary, filterRerunTestPaths, unhandledErrors, }: {
-        results: TestFileResult[];
-        testResults: TestResult[];
-        duration: Duration;
-        snapshotSummary: SnapshotSummary;
-        getSourcemap: GetSourcemap;
-        unhandledErrors?: Error[];
-        filterRerunTestPaths?: string[];
-    }): Promise<void>;
-}
-
 declare type DefaultReporterOptions = {
     /**
      * prints out summary of all tests
@@ -1077,26 +1060,6 @@ declare function getMatcherUtils(): {
 
 declare type GetSourcemap = (sourcePath: string) => Promise<SourceMapInput | null>;
 
-declare class GithubActionsReporter {
-    private onWritePath;
-    private rootPath;
-    constructor({ options, rootPath, }: {
-        rootPath: string;
-        options: {
-            onWritePath: (path: string) => string;
-        };
-    });
-    private log;
-    onTestRunEnd({ results, testResults, getSourcemap, }: {
-        results: TestFileResult[];
-        testResults: TestResult[];
-        duration: Duration;
-        snapshotSummary: SnapshotSummary;
-        getSourcemap: GetSourcemap;
-        filterRerunTestPaths?: string[];
-    }): Promise<void>;
-}
-
 declare interface HtmlOptions {
     verbose: boolean;
     skipEmpty: boolean;
@@ -1530,28 +1493,6 @@ declare type JsonOptions = FileOptions;
 
 declare type JsonSummaryOptions = FileOptions;
 
-declare class JUnitReporter implements Reporter {
-    private rootPath;
-    private outputPath?;
-    constructor({ rootPath, options: { outputPath }, }: {
-        rootPath: string;
-        options?: {
-            outputPath?: string;
-        };
-    });
-    private sanitizeXml;
-    private escapeXml;
-    private createJUnitTestCase;
-    private createJUnitTestSuite;
-    private generateJUnitXml;
-    onTestRunEnd({ results, testResults, duration, getSourcemap, }: {
-        getSourcemap: GetSourcemap;
-        results: TestFileResult[];
-        testResults: TestResult[];
-        duration: Duration;
-    }): Promise<void>;
-}
-
 declare interface LcovOnlyOptions extends FileOptions, ProjectOptions {}
 
 declare interface LcovOptions extends FileOptions, ProjectOptions {}
@@ -1650,12 +1591,107 @@ declare interface MatcherState_2 extends MatcherState {
     snapshotState: SnapshotState;
 }
 
+declare type MaybeMockedDeep<T> = T extends Constructor ? MockedClass<T> : T extends MockProcedure ? MockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
+
+declare type MaybePartiallyMocked<T> = T extends Constructor ? MockedClass<T> : T extends MockProcedure ? MockedFunction<T> : T extends object ? MockedObject<T> : T;
+
+declare type MaybePartiallyMockedDeep<T> = T extends Constructor ? MockedClass<T> : T extends MockProcedure ? MockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
+
 declare type MaybePromise<T> = T | Promise<T>;
 
+declare type MdReporterOptions = {
+    /**
+     * Output detail level preset.
+     * - `'normal'`: balanced output with code frames, repro commands, and candidate files
+     * - `'compact'`: minimal output without code frames, candidate files, or full stack traces
+     * - `'full'`: verbose output including console logs and environment info
+     * @default 'normal'
+     */
+    preset?: 'normal' | 'compact' | 'full';
+    /**
+     * Header section controls.
+     * - `false`: omit all header extras (runtime/env)
+     * - `true`: include all default header extras
+     * - object form: toggle individual parts
+     * @default { env: true }
+     */
+    header?: boolean | {
+        env?: boolean;
+    };
+    /**
+     * Reproduction command controls.
+     * - `false`: omit reproduction commands
+     * - `'file'`: only include the test file path
+     * - `'file+name'`: include both file path and `--testNamePattern`
+     * - `true`: same as `'file+name'`
+     * @default 'file+name'
+     */
+    reproduction?: boolean | 'file' | 'file+name';
+    /**
+     * Failure output controls.
+     * @default { max: 50 }
+     */
+    failures?: {
+        max?: number;
+    };
+    /**
+     * Code frame controls.
+     * - `false`: disable code frames
+     * - `true`: enable with default line window
+     * - object form: customize line window
+     * @default { linesAbove: 2, linesBelow: 2 }
+     */
+    codeFrame?: boolean | {
+        linesAbove?: number;
+        linesBelow?: number;
+    };
+    /**
+     * Stack output controls.
+     * - `false`: omit stack info
+     * - `'top'`: include only the top frame
+     * - `number`: include up to N stack frames
+     * - `'full'`: include a large default number of stack frames
+     * @default 'top'
+     */
+    stack?: number | false | 'full' | 'top';
+    /**
+     * Candidate files controls (best-effort files extracted from stack traces).
+     * - `false`: omit candidate files
+     * - `true`: enable with defaults
+     * - object form: customize max items
+     * @default { max: 5 }
+     */
+    candidateFiles?: boolean | {
+        max?: number;
+    };
+    /**
+     * Console output controls.
+     * - `false`: omit console logs
+     * - `true`: include console logs with defaults
+     * - object form: customize limits
+     * @default { maxLogsPerTestPath: 10, maxCharsPerEntry: 500 }
+     */
+    console?: boolean | {
+        maxLogsPerTestPath?: number;
+        maxCharsPerEntry?: number;
+    };
+    /**
+     * Error section controls.
+     * @default { unhandled: true }
+     */
+    errors?: boolean | {
+        unhandled?: boolean;
+    };
+};
+
 export declare const mergeProjectConfig: (...configs: ProjectConfig[]) => ProjectConfig;
 
 export declare const mergeRstestConfig: (...configs: RstestConfig[]) => RstestConfig;
 
+declare type Methods<T> = {
+    [K in keyof T]: T[K] extends MockProcedure ? K : never;
+}[keyof T];
+
 export declare interface Mock<T extends FunctionLike = FunctionLike> extends MockInstance_2<T> {
     new (...args: Parameters<T>): ReturnType<T>;
     (...args: Parameters<T>): ReturnType<T>;
@@ -1804,6 +1840,31 @@ declare type MockContext_2<T extends FunctionLike = FunctionLike> = {
     settledResults: MockSettledResult_2<Awaited<ReturnType<T>>>[];
 };
 
+export declare type Mocked<T> = T extends Constructor ? MockedClass<T> : T extends MockProcedure ? MockedFunction<T> : T extends object ? MockedObject<T> : T;
+
+declare type MockedClass<T extends Constructor> = Mock<(...args: ConstructorParameters<T>) => InstanceType<T>> & {
+    new (...args: ConstructorParameters<T>): InstanceType<T>;
+    prototype: InstanceType<T>;
+};
+
+declare type MockedFunction<T extends MockProcedure> = Mock<T> & {
+    [K in keyof T]: T[K];
+};
+
+declare type MockedFunctionDeep<T extends MockProcedure> = Mock<T> & MockedObjectDeep<T>;
+
+declare type MockedObject<T> = {
+    [K in Methods<T>]: T[K] extends MockProcedure ? MockedFunction<T[K]> : T[K];
+} & {
+    [K in Properties<T>]: T[K];
+};
+
+declare type MockedObjectDeep<T> = {
+    [K in Methods<T>]: T[K] extends MockProcedure ? MockedFunctionDeep<T[K]> : T[K];
+} & {
+    [K in Properties<T>]: MaybeMockedDeep<T[K]>;
+};
+
 declare type MockFactory<T = unknown> = () => MaybePromise<Partial<T>>;
 
 declare type MockFn = <T extends FunctionLike = FunctionLike>(fn?: T) => Mock<T>;
@@ -2030,6 +2091,37 @@ declare interface MockInstance_2<T extends FunctionLike = FunctionLike> {
     mockRejectedValueOnce(error: unknown): this;
 }
 
+/**
+ * Options for rs.mock module mocking.
+ * Supports `{ spy: true }` or `{ mock: true }`.
+ */
+declare type MockModuleOptions = {
+    /**
+     * If `true`, the module will be auto-mocked but the original implementations
+     * will be preserved - all exports will be wrapped in spy functions that track calls.
+     */
+    spy: true;
+} | {
+    /**
+     * If `true`, the module will be auto-mocked with all exports replaced by mock functions.
+     * Original implementations will NOT be preserved.
+     */
+    mock: true;
+};
+
+/**
+ * Options for mockObject
+ */
+declare interface MockOptions {
+    /**
+     * If `true`, the original implementation will be kept.
+     * All methods will call the original implementation, but you can still track the calls.
+     */
+    spy?: boolean;
+}
+
+declare type MockProcedure = (...args: any[]) => any;
+
 declare type MockResult<T> = MockResultReturn<T> | MockResultThrow | MockResultIncomplete;
 
 declare type MockResult_2<T> = MockResultReturn_2<T> | MockResultThrow_2 | MockResultIncomplete_2;
@@ -2174,7 +2266,7 @@ export declare const onTestFinished: Rstest['onTestFinished'];
 
 declare type OnTestFinishedHandler = (ctx: TestContext) => MaybePromise<void>;
 
-declare type OptionalKeys = 'testNamePattern' | 'plugins' | 'source' | 'resolve' | 'output' | 'performance' | 'tools' | 'dev' | 'onConsoleLog' | 'chaiConfig' | 'hideSkippedTestFiles' | 'resolveSnapshotPath' | 'extends';
+declare type OptionalKeys = 'testNamePattern' | 'plugins' | 'source' | 'resolve' | 'output' | 'performance' | 'tools' | 'dev' | 'onConsoleLog' | 'chaiConfig' | 'hideSkippedTestFiles' | 'resolveSnapshotPath' | 'extends' | 'shard';
 
 declare interface Options {
     logger: {
@@ -2241,7 +2333,7 @@ declare type Project = {
     configFilePath?: string;
 };
 
-export declare type ProjectConfig = Omit<RstestConfig, 'projects' | 'reporters' | 'pool' | 'isolate' | 'coverage' | 'resolveSnapshotPath' | 'onConsoleLog' | 'hideSkippedTests' | 'hideSkippedTestFiles' | 'bail'>;
+export declare type ProjectConfig = Omit<RstestConfig, 'projects' | 'reporters' | 'pool' | 'isolate' | 'coverage' | 'resolveSnapshotPath' | 'onConsoleLog' | 'hideSkippedTests' | 'hideSkippedTestFiles' | 'bail' | 'shard'>;
 
 declare type ProjectConfigAsyncFn = () => Promise<ProjectConfig | NestedProjectConfig>;
 
@@ -2273,6 +2365,10 @@ declare type PromisifyAssertion<T> = Promisify<Assertion_2<T>>;
 
 declare type PromisifyAssertion_2<T> = Promisify_2<Assertion<T>>;
 
+declare type Properties<T> = {
+    [K in keyof T]: T[K] extends MockProcedure ? never : K;
+}[keyof T];
+
 declare interface Range_2 {
     start: Location_3;
     end: Location_3;
@@ -2359,13 +2455,6 @@ export declare interface Reporter {
     onExit?: () => void;
 }
 
-declare const reportersMap: {
-    default: typeof DefaultReporter;
-    verbose: typeof VerboseReporter;
-    'github-actions': typeof GithubActionsReporter;
-    junit: typeof JUnitReporter;
-};
-
 declare type ReporterWithOptions<Name extends BuiltInReporterNames = BuiltInReporterNames> = Name extends keyof BuiltinReporterOptions ? [Name, Partial<BuiltinReporterOptions[Name]>] : [Name, Record<string, unknown>];
 
 declare interface ReportOptions {
@@ -2505,6 +2594,14 @@ export declare interface RstestConfig {
      * @default 0
      */
     bail?: number;
+    /**
+     * Split tests into several shards.
+     * This is useful for running tests in parallel on multiple machines.
+     */
+    shard?: {
+        count: number;
+        index: number;
+    };
     /**
      * print console traces when calling any console method.
      *
@@ -2712,6 +2809,74 @@ export declare interface RstestUtilities {
      * Determines if the given function is a mocked function.
      */
     isMockFunction: (fn: any) => fn is MockInstance_2;
+    /**
+     * Deeply mocks properties and methods of a given object
+     * in the same way as `rstest.mock()` mocks module exports.
+     *
+     * @example
+     * ```ts
+     * const original = {
+     *   simple: () => 'value',
+     *   nested: {
+     *     method: () => 'real'
+     *   },
+     *   prop: 'foo',
+     * }
+     *
+     * const mocked = rstest.mockObject(original)
+     * expect(mocked.simple()).toBe(undefined)
+     * expect(mocked.nested.method()).toBe(undefined)
+     * expect(mocked.prop).toBe('foo')
+     *
+     * mocked.simple.mockReturnValue('mocked')
+     * expect(mocked.simple()).toBe('mocked')
+     *
+     * // With spy option to keep original implementations
+     * const spied = rstest.mockObject(original, { spy: true })
+     * expect(spied.simple()).toBe('value')
+     * expect(spied.simple).toHaveBeenCalled()
+     * ```
+     *
+     * @param value - The object to be mocked
+     * @param options - Mock options
+     * @returns A deeply mocked version of the input object
+     */
+    mockObject: <T>(value: T, options?: MockOptions) => MaybeMockedDeep<T>;
+    /**
+     * Type helper for TypeScript. Just returns the object that was passed.
+     *
+     * When `partial` is `true` it will expect a `Partial<T>` as a return value.
+     * By default, this will only make TypeScript believe that the first level values are mocked.
+     * You can pass down `{ deep: true }` as a second argument to tell TypeScript
+     * that the whole object is mocked, if it actually is.
+     *
+     * @example
+     * ```ts
+     * import example from './example.js'
+     *
+     * rstest.mock('./example.js')
+     *
+     * test('1 + 1 equals 10', async () => {
+     *   rstest.mocked(example.calc).mockReturnValue(10)
+     *   expect(example.calc(1, '+', 1)).toBe(10)
+     * })
+     * ```
+     * @param item - Anything that can be mocked
+     * @returns The same item with mocked type
+     */
+    mocked: (<T>(item: T, deep?: false) => Mocked<T>) & (<T>(item: T, deep: true) => MaybeMockedDeep<T>) & (<T>(item: T, options: {
+        partial?: false;
+        deep?: false;
+    }) => Mocked<T>) & (<T>(item: T, options: {
+        partial?: false;
+        deep: true;
+    }) => MaybeMockedDeep<T>) & (<T>(item: T, options: {
+        partial: true;
+        deep?: false;
+    }) => MaybePartiallyMocked<T>) & (<T>(item: T, options: {
+        partial: true;
+        deep: true;
+    }) => MaybePartiallyMockedDeep<T>);
     /**
      * Calls `.mockClear()` on all spies.
      */
@@ -2725,21 +2890,37 @@ export declare interface RstestUtilities {
      */
     restoreAllMocks: () => RstestUtilities;
     /**
-     * Mock a module
+     * Mock a module.
+     *
+     * When called with a factory function, the module will be replaced with the return value of the factory.
+     * When called with `{ spy: true }`, the module will be auto-mocked but the original implementations
+     * will be preserved - all exports will be wrapped in spy functions that track calls.
+     *
+     * @example
+     * ```ts
+     * // Replace module with factory
+     * rs.mock('./module', () => ({ fn: rs.fn() }))
+     *
+     * // Auto-mock with spy mode - keeps original implementations
+     * rs.mock('./module', { spy: true })
+     * ```
      */
-    mock<T = unknown>(moduleName: string | Promise<T>, moduleFactory?: MockFactory<T>): void;
+    mock<T = unknown>(moduleName: string | Promise<T>, factoryOrOptions?: MockFactory<T> | MockModuleOptions): void;
     /**
-     * Mock a module
+     * Mock a module (CommonJS require)
      */
-    mockRequire: <T = unknown>(moduleName: string, moduleFactory?: () => T) => void;
+    mockRequire: <T = unknown>(moduleName: string, factoryOrOptions?: (() => T) | MockModuleOptions) => void;
     /**
      * Mock a module, not hoisted.
+     *
+     * When called with `{ spy: true }`, the module will be auto-mocked but the original implementations
+     * will be preserved - all exports will be wrapped in spy functions that track calls.
      */
-    doMock<T = unknown>(moduleName: string | Promise<T>, moduleFactory?: MockFactory<T>): void;
+    doMock<T = unknown>(moduleName: string | Promise<T>, factoryOrOptions?: MockFactory<T> | MockModuleOptions): void;
     /**
-     * Mock a module, not hoisted.
+     * Mock a module, not hoisted (CommonJS require).
      */
-    doMockRequire: <T = unknown>(moduleName: string, moduleFactory?: () => T) => void;
+    doMockRequire: <T = unknown>(moduleName: string, factoryOrOptions?: (() => T) | MockModuleOptions) => void;
     /**
      * Hoisted mock function.
      */
@@ -3024,19 +3205,6 @@ declare interface SourceMapV3 {
 
 declare type SourcesIndex = number;
 
-declare class StatusRenderer {
-    private rootPath;
-    private renderer;
-    private startTime;
-    private testState;
-    constructor(rootPath: string, state: RstestTestState, logger?: Options['logger']);
-    getContent(): string[];
-    onTestFileStart(): void;
-    onTestCaseResult(): void;
-    onTestFileResult(): void;
-    clear(): void;
-}
-
 declare function stringify(object: unknown, maxDepth?: number, { maxLength,...options }?: StringifyOptions): string;
 
 declare interface StringifyOptions extends PrettyFormatOptions {
@@ -3319,17 +3487,6 @@ declare interface UserConsoleLog {
     type: 'stdout' | 'stderr';
 }
 
-declare class VerboseReporter extends DefaultReporter {
-    private verboseOptions;
-    constructor({ rootPath, options, config, testState, }: {
-        rootPath: string;
-        config: NormalizedConfig;
-        options: VerboseReporterOptions;
-        testState: RstestTestState;
-    });
-    onTestFileResult(test: TestFileResult): void;
-}
-
 declare type VerboseReporterOptions = Omit<DefaultReporterOptions, 'summary'>;
 
 declare interface Visitor<N extends Node_2 = Node_2> {

package/dist/mockRuntimeCode.js

@@ -39,6 +39,32 @@ __webpack_require__.rstest_mock = (id, modFactory)=>{
         __webpack_require__.rstest_original_modules[id] = requiredModule;
         __webpack_require__.rstest_original_module_factories[id] = __webpack_modules__[id];
     }
+    if (modFactory && 'object' == typeof modFactory) {
+        const isSpy = true === modFactory.spy;
+        const isMock = true === modFactory.mock;
+        if (!isSpy && !isMock) throw new Error('[Rstest] rs.mock() options must be { spy: true } or { mock: true }');
+        if (!requiredModule) {
+            const optionName = isSpy ? 'spy' : 'mock';
+            throw new Error(`[Rstest] rs.mock('${id}', { ${optionName}: true }) failed: cannot load original module`);
+        }
+        const originalModule = requiredModule;
+        const isEsModule = true === originalModule.__esModule;
+        const mockedModule = globalThis.RSTEST_API?.rstest?.mockObject(originalModule, {
+            spy: isSpy
+        }) || originalModule;
+        const finalModFactory = function(__unused_webpack_module, __webpack_exports__, __webpack_require__1) {
+            __webpack_require__1.r(__webpack_exports__);
+            for(const key in mockedModule)__webpack_require__1.d(__webpack_exports__, {
+                [key]: ()=>mockedModule[key]
+            });
+            if (!isEsModule && !('default' in mockedModule)) __webpack_require__1.d(__webpack_exports__, {
+                default: ()=>mockedModule
+            });
+        };
+        __webpack_modules__[id] = finalModFactory;
+        delete __webpack_module_cache__[id];
+        return;
+    }
     if ('string' == typeof modFactory || 'number' == typeof modFactory) __webpack_module_cache__[id] = {
         exports: __webpack_require__(modFactory)
     };
@@ -62,6 +88,28 @@ __webpack_require__.rstest_mock_require = (id, modFactory)=>{
         __webpack_require__.rstest_original_modules[id] = requiredModule;
         __webpack_require__.rstest_original_module_factories[id] = __webpack_modules__[id];
     }
+    if (modFactory && 'object' == typeof modFactory) {
+        const isSpy = true === modFactory.spy;
+        const isMock = true === modFactory.mock;
+        if (!isSpy && !isMock) throw new Error('[Rstest] rs.mockRequire() options must be { spy: true } or { mock: true }');
+        if (!requiredModule) {
+            const optionName = isSpy ? 'spy' : 'mock';
+            throw new Error(`[Rstest] rs.mockRequire('${id}', { ${optionName}: true }) failed: cannot load original module`);
+        }
+        const originalModule = requiredModule;
+        const isEsModule = true === originalModule.__esModule;
+        const mockedModule = globalThis.RSTEST_API?.rstest?.mockObject(originalModule, {
+            spy: isSpy
+        }) || originalModule;
+        if (isEsModule) __webpack_require__.r(mockedModule);
+        else if (!('default' in mockedModule)) mockedModule.default = mockedModule;
+        __webpack_module_cache__[id] = {
+            exports: mockedModule,
+            id,
+            loaded: true
+        };
+        return;
+    }
     if ('string' == typeof modFactory || 'number' == typeof modFactory) __webpack_module_cache__[id] = {
         exports: __webpack_require__(modFactory)
     };
@@ -83,6 +131,28 @@ __webpack_require__.rstest_do_mock = (id, modFactory)=>{
         __webpack_require__.rstest_original_modules[id] = requiredModule;
         __webpack_require__.rstest_original_module_factories[id] = __webpack_modules__[id];
     }
+    if (modFactory && 'object' == typeof modFactory) {
+        const isSpy = true === modFactory.spy;
+        const isMock = true === modFactory.mock;
+        if (!isSpy && !isMock) throw new Error('[Rstest] rs.doMock() options must be { spy: true } or { mock: true }');
+        if (!requiredModule) {
+            const optionName = isSpy ? 'spy' : 'mock';
+            throw new Error(`[Rstest] rs.doMock('${id}', { ${optionName}: true }) failed: cannot load original module`);
+        }
+        const originalModule = requiredModule;
+        const isEsModule = true === originalModule.__esModule;
+        const mockedModule = globalThis.RSTEST_API?.rstest?.mockObject(originalModule, {
+            spy: isSpy
+        }) || originalModule;
+        if (isEsModule) __webpack_require__.r(mockedModule);
+        else if (!('default' in mockedModule)) mockedModule.default = mockedModule;
+        __webpack_module_cache__[id] = {
+            exports: mockedModule,
+            id,
+            loaded: true
+        };
+        return;
+    }
     if ('string' == typeof modFactory || 'number' == typeof modFactory) __webpack_module_cache__[id] = {
         exports: __webpack_require__(modFactory)
     };
@@ -104,6 +174,28 @@ __webpack_require__.rstest_do_mock_require = (id, modFactory)=>{
         __webpack_require__.rstest_original_modules[id] = requiredModule;
         __webpack_require__.rstest_original_module_factories[id] = __webpack_modules__[id];
     }
+    if (modFactory && 'object' == typeof modFactory) {
+        const isSpy = true === modFactory.spy;
+        const isMock = true === modFactory.mock;
+        if (!isSpy && !isMock) throw new Error('[Rstest] rs.doMockRequire() options must be { spy: true } or { mock: true }');
+        if (!requiredModule) {
+            const optionName = isSpy ? 'spy' : 'mock';
+            throw new Error(`[Rstest] rs.doMockRequire('${id}', { ${optionName}: true }) failed: cannot load original module`);
+        }
+        const originalModule = requiredModule;
+        const isEsModule = true === originalModule.__esModule;
+        const mockedModule = globalThis.RSTEST_API?.rstest?.mockObject(originalModule, {
+            spy: isSpy
+        }) || originalModule;
+        if (isEsModule) __webpack_require__.r(mockedModule);
+        else if (!('default' in mockedModule)) mockedModule.default = mockedModule;
+        __webpack_module_cache__[id] = {
+            exports: mockedModule,
+            id,
+            loaded: true
+        };
+        return;
+    }
     if ('string' == typeof modFactory || 'number' == typeof modFactory) __webpack_module_cache__[id] = {
         exports: __webpack_require__(modFactory)
     };

package/dist/rslib-runtime.js

@@ -29,33 +29,6 @@ __webpack_require__.m = __webpack_modules__;
         return getter;
     };
 })();
-(()=>{
-    var getProto = Object.getPrototypeOf ? (obj)=>Object.getPrototypeOf(obj) : (obj)=>obj.__proto__;
-    var leafPrototypes;
-    __webpack_require__.t = function(value, mode) {
-        if (1 & mode) value = this(value);
-        if (8 & mode) return value;
-        if ('object' == typeof value && value) {
-            if (4 & mode && value.__esModule) return value;
-            if (16 & mode && 'function' == typeof value.then) return value;
-        }
-        var ns = Object.create(null);
-        __webpack_require__.r(ns);
-        var def = {};
-        leafPrototypes = leafPrototypes || [
-            null,
-            getProto({}),
-            getProto([]),
-            getProto(getProto)
-        ];
-        for(var current = 2 & mode && value; ('object' == typeof current || 'function' == typeof current) && !~leafPrototypes.indexOf(current); current = getProto(current))Object.getOwnPropertyNames(current).forEach((key)=>{
-            def[key] = ()=>value[key];
-        });
-        def['default'] = ()=>value;
-        __webpack_require__.d(ns, def);
-        return ns;
-    };
-})();
 (()=>{
     __webpack_require__.d = (exports, definition)=>{
         for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {