@rstest/core 0.7.0 → 0.7.2

package/dist/0~923.js

@@ -0,0 +1,149 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { posix, src_logger } from "./946.js";
+import { pathToFileURL } from "./404.js";
+import { node_vm, interopModule, shouldInterop } from "./0~346.js";
+const external_node_path_ = __webpack_require__("node:path");
+var loadEsModule_EsmMode = /*#__PURE__*/ function(EsmMode) {
+    EsmMode[EsmMode["Unknown"] = 0] = "Unknown";
+    EsmMode[EsmMode["Evaluated"] = 1] = "Evaluated";
+    EsmMode[EsmMode["Unlinked"] = 2] = "Unlinked";
+    return EsmMode;
+}({});
+const isRelativePath = (p)=>/^\.\.?\//.test(p);
+const defineRstestDynamicImport = ({ distPath, testPath, assetFiles, interopDefault, returnModule, esmMode })=>async (specifier, importAttributes)=>{
+        const currentDirectory = posix.dirname(distPath);
+        const joinedPath = isRelativePath(specifier) ? posix.join(currentDirectory, specifier) : specifier;
+        const content = assetFiles[joinedPath];
+        if (content) try {
+            return await loadModule({
+                codeContent: content,
+                testPath,
+                distPath: joinedPath,
+                rstestContext: {},
+                assetFiles,
+                interopDefault,
+                esmMode
+            });
+        } catch (err) {
+            src_logger.error(`load file ${joinedPath} failed:\n`, err instanceof Error ? err.message : err);
+        }
+        const resolvedPath = (0, external_node_path_.isAbsolute)(specifier) ? pathToFileURL(specifier) : import.meta.resolve(specifier, pathToFileURL(testPath));
+        const modulePath = 'string' == typeof resolvedPath ? resolvedPath : resolvedPath.pathname;
+        if (importAttributes?.with?.rstest) delete importAttributes.with.rstest;
+        if (modulePath.endsWith('.json')) {
+            const importedModule = await import(modulePath, {
+                with: {
+                    type: 'json'
+                }
+            });
+            return returnModule ? asModule(importedModule.default) : {
+                ...importedModule.default,
+                default: importedModule.default
+            };
+        }
+        const importedModule = await import(modulePath, importAttributes);
+        if (shouldInterop({
+            interopDefault,
+            modulePath,
+            mod: importedModule
+        }) && !modulePath.startsWith('node:')) {
+            const { mod, defaultExport } = interopModule(importedModule);
+            if (returnModule) return asModule(mod);
+            return new Proxy(mod, {
+                get (mod, prop) {
+                    if ('default' === prop) return defaultExport;
+                    return mod[prop] ?? defaultExport?.[prop];
+                },
+                has (mod, prop) {
+                    if ('default' === prop) return void 0 !== defaultExport;
+                    return prop in mod || defaultExport && prop in defaultExport;
+                },
+                getOwnPropertyDescriptor (mod, prop) {
+                    const descriptor = Reflect.getOwnPropertyDescriptor(mod, prop);
+                    if (descriptor) return descriptor;
+                    if ('default' === prop && void 0 !== defaultExport) return {
+                        value: defaultExport,
+                        enumerable: true,
+                        configurable: true
+                    };
+                }
+            });
+        }
+        return importedModule;
+    };
+const asModule = async (something, context, unlinked)=>{
+    const { Module, SyntheticModule } = await import("node:vm");
+    if (something instanceof Module) return something;
+    const exports = [
+        ...new Set([
+            'default',
+            ...Object.keys(something)
+        ])
+    ];
+    const syntheticModule = new SyntheticModule(exports, ()=>{
+        for (const name of exports)syntheticModule.setExport(name, 'default' === name ? something[name] ?? something : something[name]);
+    }, {
+        context
+    });
+    if (unlinked) return syntheticModule;
+    await syntheticModule.link(()=>{});
+    await syntheticModule.evaluate();
+    return syntheticModule;
+};
+const esmCache = new Map();
+const loadModule = async ({ codeContent, distPath, testPath, assetFiles, interopDefault, esmMode = 0 })=>{
+    const code = codeContent;
+    let esm = esmCache.get(distPath);
+    if (!esm) {
+        esm = new node_vm.SourceTextModule(code, {
+            identifier: distPath,
+            lineOffset: 0,
+            columnOffset: 0,
+            initializeImportMeta: (meta)=>{
+                meta.url = pathToFileURL(distPath.endsWith('rstest-runtime.mjs') ? distPath : testPath).toString();
+                meta.__rstest_dynamic_import__ = defineRstestDynamicImport({
+                    assetFiles,
+                    testPath,
+                    distPath: distPath || testPath,
+                    interopDefault,
+                    returnModule: false,
+                    esmMode: 0
+                });
+                meta.readWasmFile = (wasmPath, callback)=>{
+                    const joinedPath = isRelativePath(wasmPath.pathname) ? posix.join(posix.dirname(distPath), wasmPath.pathname) : wasmPath.pathname;
+                    const content = assetFiles[posix.normalize(joinedPath)];
+                    if (content) callback(null, Buffer.from(content, 'base64'));
+                    else callback(new Error(`WASM file ${joinedPath} not found in asset files.`));
+                };
+            },
+            importModuleDynamically: (specifier, _referencer, importAttributes)=>defineRstestDynamicImport({
+                    assetFiles,
+                    testPath,
+                    distPath: distPath || testPath,
+                    interopDefault,
+                    returnModule: true,
+                    esmMode: 2
+                })(specifier, importAttributes)
+        });
+        distPath && esmCache.set(distPath, esm);
+    }
+    if (2 === esmMode) return esm;
+    if ('unlinked' === esm.status) await esm.link(async (specifier, referencingModule)=>{
+        const result = await defineRstestDynamicImport({
+            assetFiles,
+            testPath,
+            distPath: distPath || testPath,
+            interopDefault,
+            returnModule: true,
+            esmMode: 2
+        })(specifier, referencingModule);
+        const linkedModule = await asModule(result, referencingModule.context, true);
+        return linkedModule;
+    });
+    'evaluated' !== esm.status && 'evaluating' !== esm.status && await esm.evaluate();
+    const ns = esm.namespace;
+    return ns.default && ns.default instanceof Promise ? ns.default : ns;
+};
+export { asModule, loadEsModule_EsmMode, loadModule };

package/dist/{155.js → 131.js}

@@ -2,8 +2,8 @@ import 'module';
 /*#__PURE__*/ import.meta.url;
 import { __webpack_require__ } from "./rslib-runtime.js";
 import { EventEmitter } from "events";
-import { createRsbuild, loadConfig, logger, mergeRsbuildConfig } from "@rsbuild/core";
-import { basename, DEFAULT_CONFIG_EXTENSIONS, TS_CONFIG_FILE, isTTY, dirname, posix, resolve as pathe_M_eThtNZ_resolve, pathe_M_eThtNZ_relative, DEFAULT_CONFIG_NAME, globalApis, formatTestPath, getAbsolutePath, filterProjects, join, formatRootStr, isDynamicPattern, glob, writeFile, castArray, src_logger, prettyTestPath, prettyTime, isDebug, isAbsolute, getTaskNameWithPrefix, formatError, normalize, TEMP_RSTEST_OUTPUT_DIR_GLOB } from "./946.js";
+import { createRsbuild, loadConfig, logger as core_logger, mergeRsbuildConfig } from "@rsbuild/core";
+import { DEFAULT_CONFIG_NAME, posix, globalApis, resolve as pathe_M_eThtNZ_resolve, pathe_M_eThtNZ_relative, filterProjects, join, glob, prettyTestPath, prettyTime, isAbsolute, TEMP_RSTEST_OUTPUT_DIR_GLOB, formatTestPath, TS_CONFIG_FILE, basename, isTTY, dirname, getAbsolutePath, bgColor, formatRootStr, isDynamicPattern, writeFile, castArray, src_logger, isDebug, getTaskNameWithPrefix, DEFAULT_CONFIG_EXTENSIONS, formatError, normalize } from "./946.js";
 import { decode } from "./397.js";
 function toArr(any) {
     return null == any ? [] : Array.isArray(any) ? any : [
@@ -500,7 +500,7 @@ function prepareCli() {
     if (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) console.log();
 }
 function showRstest() {
-    src_logger.greet("  Rstest v0.7.0");
+    src_logger.greet("  Rstest v0.7.2");
     src_logger.log('');
 }
 const applyCommonOptions = (cli)=>{
@@ -544,7 +544,7 @@ const runRest = async ({ options, filters, command })=>{
 function setupCommands() {
     const cli = dist('rstest');
     cli.help();
-    cli.version("0.7.0");
+    cli.version("0.7.2");
     applyCommonOptions(cli);
     cli.command('[...filters]', 'run tests').option('-w, --watch', 'Run tests in watch mode').action(async (filters, options)=>{
         showRstest();
@@ -1443,7 +1443,7 @@ const printSummaryErrorLogs = async ({ testResults, results, rootPath, getSource
     for (const test of failedTests){
         const relativePath = posix.relative(rootPath, test.testPath);
         const nameStr = getTaskNameWithPrefix(test);
-        src_logger.log(`${picocolors_default().bgRed(' FAIL ')} ${prettyTestPath(relativePath)} ${nameStr.length ? `${picocolors_default().dim(">")} ${nameStr}` : ''}`);
+        src_logger.log(`${bgColor('bgRed', ' FAIL ')} ${prettyTestPath(relativePath)} ${nameStr.length ? `${picocolors_default().dim(">")} ${nameStr}` : ''}`);
         if (test.errors) {
             const { printError } = await Promise.resolve().then(()=>({
                     printError: error_printError
@@ -1575,11 +1575,11 @@ class StatusRenderer {
     renderer;
     startTime = void 0;
     testState;
-    constructor(rootPath, state){
+    constructor(rootPath, state, logger){
         this.rootPath = rootPath;
         this.renderer = new WindowRenderer({
             getWindow: ()=>this.getContent(),
-            logger: {
+            logger: logger ?? {
                 outputStream: process.stdout,
                 errorStream: process.stderr,
                 getColumns: ()=>'columns' in process.stdout ? process.stdout.columns : 80
@@ -1596,7 +1596,7 @@ class StatusRenderer {
         const shouldDisplayRunningTests = (runningTests)=>runningTests[0]?.startTime && now - runningTests[0].startTime > 2000;
         for (const [module, { runningTests }] of runningModules.entries()){
             const relativePath = pathe_M_eThtNZ_relative(this.rootPath, module);
-            summary.push(`${picocolors_default().bgYellow(picocolors_default().bold(' RUNS '))} ${prettyTestPath(relativePath)}`);
+            summary.push(`${bgColor('bgYellow', ' RUNS ')} ${prettyTestPath(relativePath)}`);
             if (runningTests.length && shouldDisplayRunningTests(runningTests)) {
                 let caseLog = ` ${picocolors_default().gray("➜")} ${getTaskNameWithPrefix(runningTests[0])} ${picocolors_default().magenta(prettyTime(now - runningTests[0].startTime))}`;
                 if (runningTests.length > 1) caseLog += picocolors_default().gray(` and ${runningTests.length - 1} more cases`);
@@ -1667,7 +1667,7 @@ class DefaultReporter {
         this.rootPath = rootPath;
         this.config = config;
         this.options = options;
-        if (isTTY()) this.statusRenderer = new StatusRenderer(rootPath, testState);
+        if (isTTY() || options.logger) this.statusRenderer = new StatusRenderer(rootPath, testState, options.logger);
     }
     onTestFileStart() {
         this.statusRenderer?.onTestFileStart();
@@ -2175,7 +2175,7 @@ const stackIgnores = [
 ];
 async function error_parseErrorStacktrace({ stack, getSourcemap, fullStack = isDebug() }) {
     const stackFrames = await Promise.all(stack_trace_parser_esm_parse(stack).filter((frame)=>fullStack ? true : frame.file && !stackIgnores.some((entry)=>frame.file?.match(entry))).map(async (frame)=>{
-        const sourcemap = await getSourcemap(frame.file);
+        const sourcemap = await getSourcemap?.(frame.file);
         if (sourcemap) {
             const traceMap = new TraceMap(sourcemap);
             const { line, column, source, name } = originalPositionFor(traceMap, {
@@ -2428,7 +2428,7 @@ class Rstest {
         });
         this.reporters = reporters;
         this.snapshotManager = snapshotManager;
-        this.version = "0.7.0";
+        this.version = "0.7.2";
         this.rootPath = rootPath;
         this.originalConfig = userConfig;
         this.normalizedConfig = rstestConfig;
@@ -2448,6 +2448,7 @@ class Rstest {
                 configFilePath: project.configFilePath,
                 rootPath: config.root,
                 name: config.name,
+                outputModule: config.output?.module ?? 'true' === process.env.RSTEST_OUTPUT_MODULE,
                 environmentName: formatEnvironmentName(config.name),
                 normalizedConfig: config
             };
@@ -2456,6 +2457,7 @@ class Rstest {
                 configFilePath,
                 rootPath,
                 name: rstestConfig.name,
+                outputModule: rstestConfig.output?.module ?? 'true' === process.env.RSTEST_OUTPUT_MODULE,
                 environmentName: formatEnvironmentName(rstestConfig.name),
                 normalizedConfig: rstestConfig
             }
@@ -2569,4 +2571,4 @@ function defineConfig(config) {
 function defineProject(config) {
     return config;
 }
-export { EventEmitter, afterAll, afterEach, assert, beforeAll, beforeEach, config_loadConfig as loadConfig, core_createRstest as createRstest, createRsbuild, defineConfig, defineProject, describe, error_printError, expect, init_initCli as initCli, it, logger, mergeRstestConfig, onTestFailed, onTestFinished, public_rstest as rstest, public_test as test, rs, runCLI, runRest };
+export { EventEmitter, afterAll, afterEach, assert, beforeAll, beforeEach, config_loadConfig as loadConfig, core_createRstest as createRstest, core_logger, createRsbuild, defineConfig, defineProject, describe, error_printError, expect, init_initCli as initCli, it, mergeRstestConfig, onTestFailed, onTestFinished, public_rstest as rstest, public_test as test, rs, runCLI, runRest };

package/dist/404.js

@@ -0,0 +1,210 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { fileURLToPath, pathToFileURL } from "node:url";
+import node_v8 from "node:v8";
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
+const DEFAULT_TIMEOUT = 6e4;
+function defaultSerialize(i) {
+    return i;
+}
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout: dist_clearTimeout, setTimeout: dist_setTimeout } = globalThis;
+const random = Math.random.bind(Math);
+function createBirpc($functions, options) {
+    const { post, on, off = ()=>{}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT } = options;
+    let $closed = false;
+    const _rpcPromiseMap = /* @__PURE__ */ new Map();
+    let _promiseInit;
+    let rpc;
+    async function _call(method, args, event, optional) {
+        if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+        const req = {
+            m: method,
+            a: args,
+            t: TYPE_REQUEST
+        };
+        if (optional) req.o = true;
+        const send = async (_req)=>post(serialize(_req));
+        if (event) return void await send(req);
+        if (_promiseInit) try {
+            await _promiseInit;
+        } finally{
+            _promiseInit = void 0;
+        }
+        let { promise, resolve, reject } = createPromiseWithResolvers();
+        const id = nanoid();
+        req.i = id;
+        let timeoutId;
+        async function handler(newReq = req) {
+            if (timeout >= 0) {
+                timeoutId = dist_setTimeout(()=>{
+                    try {
+                        const handleResult = options.onTimeoutError?.call(rpc, method, args);
+                        if (true !== handleResult) throw new Error(`[birpc] timeout on calling "${method}"`);
+                    } catch (e) {
+                        reject(e);
+                    }
+                    _rpcPromiseMap.delete(id);
+                }, timeout);
+                if ("object" == typeof timeoutId) timeoutId = timeoutId.unref?.();
+            }
+            _rpcPromiseMap.set(id, {
+                resolve,
+                reject,
+                timeoutId,
+                method
+            });
+            await send(newReq);
+            return promise;
+        }
+        try {
+            if (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);
+            else await handler();
+        } catch (e) {
+            if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+            return;
+        } finally{
+            dist_clearTimeout(timeoutId);
+            _rpcPromiseMap.delete(id);
+        }
+        return promise;
+    }
+    const $call = (method, ...args)=>_call(method, args, false);
+    const $callOptional = (method, ...args)=>_call(method, args, false, true);
+    const $callEvent = (method, ...args)=>_call(method, args, true);
+    const $callRaw = (options2)=>_call(options2.method, options2.args, options2.event, options2.optional);
+    const builtinMethods = {
+        $call,
+        $callOptional,
+        $callEvent,
+        $callRaw,
+        $rejectPendingCalls,
+        get $closed () {
+            return $closed;
+        },
+        get $meta () {
+            return options.meta;
+        },
+        $close,
+        $functions
+    };
+    rpc = new Proxy({}, {
+        get (_, method) {
+            if (Object.prototype.hasOwnProperty.call(builtinMethods, method)) return builtinMethods[method];
+            if ("then" === method && !eventNames.includes("then") && !("then" in $functions)) return;
+            const sendEvent = (...args)=>_call(method, args, true);
+            if (eventNames.includes(method)) {
+                sendEvent.asEvent = sendEvent;
+                return sendEvent;
+            }
+            const sendCall = (...args)=>_call(method, args, false);
+            sendCall.asEvent = sendEvent;
+            return sendCall;
+        }
+    });
+    function $close(customError) {
+        $closed = true;
+        _rpcPromiseMap.forEach(({ reject, method })=>{
+            const error = new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+            if (customError) {
+                customError.cause ??= error;
+                return reject(customError);
+            }
+            reject(error);
+        });
+        _rpcPromiseMap.clear();
+        off(onMessage);
+    }
+    function $rejectPendingCalls(handler) {
+        const entries = Array.from(_rpcPromiseMap.values());
+        const handlerResults = entries.map(({ method, reject })=>{
+            if (!handler) return reject(new Error(`[birpc]: rejected pending call "${method}".`));
+            return handler({
+                method,
+                reject
+            });
+        });
+        _rpcPromiseMap.clear();
+        return handlerResults;
+    }
+    async function onMessage(data, ...extra) {
+        let msg;
+        try {
+            msg = deserialize(data);
+        } catch (e) {
+            if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+            return;
+        }
+        if (msg.t === TYPE_REQUEST) {
+            const { m: method, a: args, o: optional } = msg;
+            let result, error;
+            let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
+            if (optional) fn ||= ()=>void 0;
+            if (fn) try {
+                result = await fn.apply("rpc" === bind ? rpc : $functions, args);
+            } catch (e) {
+                error = e;
+            }
+            else error = new Error(`[birpc] function "${method}" not found`);
+            if (msg.i) {
+                if (error && options.onError) options.onError.call(rpc, error, method, args);
+                if (error && options.onFunctionError) {
+                    if (true === options.onFunctionError.call(rpc, error, method, args)) return;
+                }
+                if (!error) try {
+                    await post(serialize({
+                        t: TYPE_RESPONSE,
+                        i: msg.i,
+                        r: result
+                    }), ...extra);
+                    return;
+                } catch (e) {
+                    error = e;
+                    if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+                }
+                try {
+                    await post(serialize({
+                        t: TYPE_RESPONSE,
+                        i: msg.i,
+                        e: error
+                    }), ...extra);
+                } catch (e) {
+                    if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+                }
+            }
+        } else {
+            const { i: ack, r: result, e: error } = msg;
+            const promise = _rpcPromiseMap.get(ack);
+            if (promise) {
+                dist_clearTimeout(promise.timeoutId);
+                if (error) promise.reject(error);
+                else promise.resolve(result);
+            }
+            _rpcPromiseMap.delete(ack);
+        }
+    }
+    _promiseInit = on(onMessage);
+    return rpc;
+}
+function createPromiseWithResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        promise,
+        resolve,
+        reject
+    };
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+    let id = "";
+    let i = size;
+    while(i--)id += urlAlphabet[64 * random() | 0];
+    return id;
+}
+export { createBirpc, fileURLToPath, node_v8, pathToFileURL };