@rstest/core 0.7.8 → 0.7.9

package/dist/4899.js

@@ -0,0 +1,11 @@
+import __rslib_shim_module__ from 'module';
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(import.meta.url);
+import { __webpack_require__ } from "./rslib-runtime.js";
+__webpack_require__.add({
+    timers (module) {
+        module.exports = require("timers");
+    },
+    "timers/promises" (module) {
+        module.exports = require("timers/promises");
+    }
+});

package/dist/5734.js

@@ -1,7 +1,7 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
 import { __webpack_require__ } from "./rslib-runtime.js";
-import "./5693.js";
+import "./2672.js";
 import { createRequire } from "./4881.js";
 import { pathToFileURL } from "./6198.js";
 import "./1157.js";

package/dist/{0~6151.js → 6151.js}

@@ -1,14 +1,13 @@
-/*! For license information please see 0~6151.js.LICENSE.txt */
+/*! For license information please see 6151.js.LICENSE.txt */
 import 'module';
 /*#__PURE__*/ import.meta.url;
 import { __webpack_require__ } from "./rslib-runtime.js";
-import "./5693.js";
-import { getRealTimers, TestRegisterError, formatTestError, formatName } from "./7913.js";
-import { resolve as pathe_M_eThtNZ_resolve } from "./3278.js";
-import { getTaskNameWithPrefix, isObject as helper_isObject, castArray, ROOT_SUITE_NAME } from "./1157.js";
-import { fileURLToPath } from "./6198.js";
+import { getTaskNameWithPrefix, isObject as helper_isObject, castArray, resolve as pathe_M_eThtNZ_resolve, normalize } from "./2672.js";
+import { getRealTimers, TestRegisterError, formatTestError, formatName } from "./1294.js";
+import { ROOT_SUITE_NAME } from "./1157.js";
 import { parse } from "./1672.js";
-import "./554.js";
+import "./4899.js";
+import "./721.js";
 __webpack_require__.add({
     "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/called-in-order.js" (module, __unused_rspack_exports, __webpack_require__) {
         var every = __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/array.js").every;
@@ -12581,7 +12580,22 @@ class TestRunner {
         if (true === isExpectingAssertions && 0 === assertionCalls) throw isExpectingAssertionsError;
     }
 }
-const external_node_path_ = __webpack_require__("node:path");
+const url_extras_isWindows = globalThis.process?.platform === 'win32';
+function fileURLToPath(url, options) {
+    if ('string' != typeof url && !(url instanceof URL)) throw new TypeError(`Expected \`string\` or \`URL\`, got \`${typeof url}\``);
+    const useWindowsRules = options?.windows ?? url_extras_isWindows;
+    const urlObject = new URL(url);
+    if ('file:' !== urlObject.protocol) throw new TypeError('The URL must be a file URL');
+    const { hostname, pathname } = urlObject;
+    if (/%2[Ff]/.test(pathname)) throw new TypeError('File URL path must not include encoded / characters');
+    const path = decodeURIComponent(pathname);
+    if (useWindowsRules && /^\/[A-Za-z]:/.test(path)) return path.slice(1).replaceAll('/', '\\');
+    if (hostname && 'localhost' !== hostname) {
+        if (!useWindowsRules) throw new TypeError('File URL host must be "localhost" or empty');
+        return `\\\\${hostname}${path.replaceAll('/', '\\')}`;
+    }
+    return path;
+}
 class RunnerRuntime {
     tests = [];
     _currentTest = [];
@@ -12835,7 +12849,7 @@ const createRuntimeAPI = ({ testPath, runtimeConfig, project })=>{
             for (const frame of frames){
                 let filename = frame.file ?? '';
                 if (filename.startsWith('file://')) filename = fileURLToPath(filename);
-                filename = filename.replaceAll(external_node_path_["default"].sep, '/');
+                filename = normalize(filename);
                 if (filename === testPath) {
                     const line = frame.lineNumber;
                     const column = frame.column;
@@ -13181,6 +13195,151 @@ class FakeTimers {
         return this._fakingTime;
     }
 }
+const spy_isMockFunction = (fn)=>'function' == typeof fn && '_isMockFunction' in fn && fn._isMockFunction;
+const initSpy = ()=>{
+    let callOrder = 0;
+    const mocks = new Set();
+    const wrapSpy = (obj, methodName, mockFn)=>{
+        const spyImpl = M(obj, methodName, mockFn);
+        const spyFn = spyImpl;
+        let mockImplementationOnce = [];
+        let implementation = mockFn;
+        let mockName = mockFn?.name;
+        const initMockState = ()=>({
+                instances: [],
+                contexts: [],
+                invocationCallOrder: []
+            });
+        let mockState = initMockState();
+        const spyState = T(spyImpl);
+        spyFn.getMockName = ()=>mockName || methodName;
+        spyFn.mockName = (name)=>{
+            mockName = name;
+            return spyFn;
+        };
+        spyFn.getMockImplementation = ()=>mockImplementationOnce.length ? mockImplementationOnce[mockImplementationOnce.length - 1] : implementation;
+        function withImplementation(fn, cb) {
+            const originalImplementation = implementation;
+            const originalMockImplementationOnce = mockImplementationOnce;
+            implementation = fn;
+            mockImplementationOnce = [];
+            spyState.willCall(willCall);
+            const reset = ()=>{
+                implementation = originalImplementation;
+                mockImplementationOnce = originalMockImplementationOnce;
+            };
+            const result = cb();
+            if (result instanceof Promise) return result.then(()=>{
+                reset();
+            });
+            reset();
+        }
+        spyFn.withImplementation = withImplementation;
+        spyFn.mockImplementation = (fn)=>{
+            implementation = fn;
+            return spyFn;
+        };
+        spyFn.mockImplementationOnce = (fn)=>{
+            mockImplementationOnce.push(fn);
+            return spyFn;
+        };
+        spyFn.mockReturnValue = (value)=>spyFn.mockImplementation(()=>value);
+        spyFn.mockReturnValueOnce = (value)=>spyFn.mockImplementationOnce(()=>value);
+        spyFn.mockResolvedValue = (value)=>spyFn.mockImplementation(()=>Promise.resolve(value));
+        spyFn.mockResolvedValueOnce = (value)=>spyFn.mockImplementationOnce(()=>Promise.resolve(value));
+        spyFn.mockRejectedValue = (value)=>spyFn.mockImplementation(()=>Promise.reject(value));
+        spyFn.mockRejectedValueOnce = (value)=>spyFn.mockImplementationOnce(()=>Promise.reject(value));
+        spyFn.mockReturnThis = ()=>spyFn.mockImplementation(function() {
+                return this;
+            });
+        function willCall(...args) {
+            let impl = implementation || spyState.getOriginal();
+            mockState.instances.push(this);
+            mockState.contexts.push(this);
+            mockState.invocationCallOrder.push(++callOrder);
+            if (mockImplementationOnce.length) impl = mockImplementationOnce.shift();
+            return impl?.apply(this, args);
+        }
+        spyState.willCall(willCall);
+        Object.defineProperty(spyFn, 'mock', {
+            get: ()=>({
+                    get calls () {
+                        return spyState.calls;
+                    },
+                    get lastCall () {
+                        return spyState.calls[spyState.callCount - 1];
+                    },
+                    get instances () {
+                        return mockState.instances;
+                    },
+                    get contexts () {
+                        return mockState.contexts;
+                    },
+                    get invocationCallOrder () {
+                        return mockState.invocationCallOrder;
+                    },
+                    get results () {
+                        return spyState.results.map(([resultType, value])=>{
+                            const type = 'error' === resultType ? 'throw' : 'return';
+                            return {
+                                type: type,
+                                value
+                            };
+                        });
+                    },
+                    get settledResults () {
+                        return spyState.resolves.map(([resultType, value])=>{
+                            const type = 'error' === resultType ? 'rejected' : 'fulfilled';
+                            return {
+                                type,
+                                value
+                            };
+                        });
+                    }
+                })
+        });
+        spyFn.mockClear = ()=>{
+            mockState = initMockState();
+            spyState.reset();
+            return spyFn;
+        };
+        spyFn.mockReset = ()=>{
+            spyFn.mockClear();
+            implementation = mockFn;
+            mockImplementationOnce = [];
+            return spyFn;
+        };
+        spyFn.mockRestore = ()=>{
+            spyFn.mockReset();
+            spyState.restore();
+            mockName = mockFn?.name;
+        };
+        mocks.add(spyFn);
+        return spyFn;
+    };
+    const fn = (mockFn)=>{
+        const defaultName = 'rstest.fn()';
+        return wrapSpy({
+            [defaultName]: mockFn
+        }, defaultName, mockFn);
+    };
+    const spyOn = (obj, methodName, accessType)=>{
+        const accessTypeMap = {
+            get: 'getter',
+            set: 'setter'
+        };
+        const method = accessType ? {
+            [accessTypeMap[accessType]]: methodName
+        } : methodName;
+        return wrapSpy(obj, method);
+    };
+    return {
+        isMockFunction: spy_isMockFunction,
+        spyOn,
+        fn,
+        mocks
+    };
+};
 const createRstestUtilities = async (workerState)=>{
     const originalEnvValues = new Map();
     const originalGlobalValues = new Map();
@@ -13192,9 +13351,6 @@ const createRstestUtilities = async (workerState)=>{
         });
         return _timers;
     };
-    const { initSpy } = await import("./0~8957.js").then((mod)=>({
-            initSpy: mod.initSpy
-        }));
     const { fn, spyOn, isMockFunction, mocks } = initSpy();
     const rstest = {
         fn,
@@ -13365,4 +13521,4 @@ const createRstestRuntime = async (workerState)=>{
     globalThis.RSTEST_API = runtime.api;
     return runtime;
 };
-export { M, T, createRstestRuntime };
+export { createRstestRuntime };

package/dist/{0~6973.js → 6973.js}

@@ -1,16 +1,16 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
 import { __webpack_require__ } from "./rslib-runtime.js";
-import "./5693.js";
+import { getAbsolutePath } from "./2672.js";
 import { fileURLToPath } from "./6198.js";
-import { rspack } from "./9131.js";
-import { getAbsolutePath, formatTestEntryName } from "./1157.js";
+import { rsbuild as __rspack_external__rsbuild_core_1b356efc } from "./4484.js";
+import { formatTestEntryName } from "./1157.js";
 import { posix } from "./3278.js";
-const external_node_fs_ = __webpack_require__("node:fs");
+const external_node_fs_ = __webpack_require__("fs");
 const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
 var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
 const tryResolve = (request, rootPath)=>{
-    const { resolver } = rspack.experiments;
+    const { resolver } = __rspack_external__rsbuild_core_1b356efc.rspack.experiments;
     const esmFirstResolver = new resolver.ResolverFactory({
         conditionNames: [
             'node',

package/dist/721.js

@@ -0,0 +1,9 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import * as __rspack_external_node_util_1b29d436 from "node:util";
+import { __webpack_require__ } from "./rslib-runtime.js";
+__webpack_require__.add({
+    "node:util" (module) {
+        module.exports = __rspack_external_node_util_1b29d436;
+    }
+});