elit 3.6.3 → 3.6.5

package/dist/test-runtime.js

@@ -34,7 +34,7 @@
 
   // node_modules/esbuild/lib/main.js
   var require_main = __commonJS({
-    "node_modules/esbuild/lib/main.js"(exports, module2) {
+    "node_modules/esbuild/lib/main.js"(exports, module) {
       "use strict";
       var __defProp2 = Object.defineProperty;
       var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -69,7 +69,7 @@
         transformSync: () => transformSync2,
         version: () => version
       });
-      module2.exports = __toCommonJS(node_exports);
+      module.exports = __toCommonJS(node_exports);
       function encodePacket(packet) {
         let visit = (value) => {
           if (value === null) {
@@ -2578,9 +2578,9 @@ error: ${text}`);
 
   // node_modules/source-map/lib/url.js
   var require_url = __commonJS({
-    "node_modules/source-map/lib/url.js"(exports, module2) {
+    "node_modules/source-map/lib/url.js"(exports, module) {
       "use strict";
-      module2.exports = typeof URL === "function" ? URL : __require("url").URL;
+      module.exports = typeof URL === "function" ? URL : __require("url").URL;
     }
   });
 
@@ -3363,11 +3363,11 @@ error: ${text}`);
 
   // node_modules/source-map/lib/read-wasm.js
   var require_read_wasm = __commonJS({
-    "node_modules/source-map/lib/read-wasm.js"(exports, module2) {
+    "node_modules/source-map/lib/read-wasm.js"(exports, module) {
       "use strict";
       var fs2 = __require("fs");
       var path = __require("path");
-      module2.exports = function readWasm() {
+      module.exports = function readWasm() {
         return new Promise((resolve, reject) => {
           const wasmPath = path.join(__dirname, "mappings.wasm");
           fs2.readFile(wasmPath, null, (error, data) => {
@@ -3379,7 +3379,7 @@ error: ${text}`);
           });
         });
       };
-      module2.exports.initialize = (_) => {
+      module.exports.initialize = (_) => {
         console.debug(
           "SourceMapConsumer.initialize is a no-op when running in node.js"
         );
@@ -3389,7 +3389,7 @@ error: ${text}`);
 
   // node_modules/source-map/lib/wasm.js
   var require_wasm = __commonJS({
-    "node_modules/source-map/lib/wasm.js"(exports, module2) {
+    "node_modules/source-map/lib/wasm.js"(exports, module) {
       "use strict";
       var readWasm = require_read_wasm();
       function Mapping() {
@@ -3402,7 +3402,7 @@ error: ${text}`);
         this.name = null;
       }
       var cachedWasm = null;
-      module2.exports = function wasm() {
+      module.exports = function wasm() {
         if (cachedWasm) {
           return cachedWasm;
         }
@@ -4698,6 +4698,52 @@ error: ${text}`);
     }
     throw new Error("Unsupported runtime");
   }
+  function existsSync(path) {
+    try {
+      statSync(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function statSync(path) {
+    if (isNode || isBun) {
+      return fs.statSync(path);
+    } else if (isDeno) {
+      const info = Deno.statSync(path);
+      return createStatsFromDenoFileInfo(info);
+    }
+    throw new Error("Unsupported runtime");
+  }
+  function createStatsFromDenoFileInfo(info) {
+    return {
+      isFile: () => info.isFile,
+      isDirectory: () => info.isDirectory,
+      isBlockDevice: () => false,
+      isCharacterDevice: () => false,
+      isSymbolicLink: () => info.isSymlink || false,
+      isFIFO: () => false,
+      isSocket: () => false,
+      dev: info.dev || 0,
+      ino: info.ino || 0,
+      mode: info.mode || 0,
+      nlink: info.nlink || 1,
+      uid: info.uid || 0,
+      gid: info.gid || 0,
+      rdev: 0,
+      size: info.size,
+      blksize: info.blksize || 4096,
+      blocks: info.blocks || Math.ceil(info.size / 512),
+      atimeMs: info.atime?.getTime() || Date.now(),
+      mtimeMs: info.mtime?.getTime() || Date.now(),
+      ctimeMs: info.birthtime?.getTime() || Date.now(),
+      birthtimeMs: info.birthtime?.getTime() || Date.now(),
+      atime: info.atime || /* @__PURE__ */ new Date(),
+      mtime: info.mtime || /* @__PURE__ */ new Date(),
+      ctime: info.birthtime || /* @__PURE__ */ new Date(),
+      birthtime: info.birthtime || /* @__PURE__ */ new Date()
+    };
+  }
 
   // src/path.ts
   function getSeparator(isWin) {
@@ -4945,12 +4991,16 @@ error: ${text}`);
   var currentTestFile = void 0;
   var currentSourceMapConsumer = void 0;
   var wrapperLineOffset = 0;
-  async function transpileFile(filePath) {
-    const source = await readFile(filePath, "utf-8");
-    const result = (0, import_esbuild.transformSync)(source, {
-      loader: filePath.endsWith(".ts") || filePath.endsWith(".tsx") ? "ts" : "js",
-      format: "esm",
-      sourcemap: "inline",
+  var TEST_MODULE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".json"];
+  function resolveTestLoader(filePath) {
+    return /\.(?:ts|tsx|mts|cts)$/i.test(filePath) ? "ts" : "js";
+  }
+  function createTestTransformOptions(filePath, format, sourcemap) {
+    return {
+      loader: resolveTestLoader(filePath),
+      format,
+      sourcemap,
+      sourcefile: filePath,
       target: "es2020",
       tsconfigRaw: {
         compilerOptions: {
@@ -4959,7 +5009,106 @@ error: ${text}`);
           jsxFragmentFactory: "Fragment"
         }
       }
-    });
+    };
+  }
+  function resolveExistingTestModulePath(basePath) {
+    const nodePath = __require("path");
+    if (existsSync(basePath) && statSync(basePath).isFile()) {
+      return basePath;
+    }
+    for (const extension of TEST_MODULE_EXTENSIONS) {
+      const candidatePath = `${basePath}${extension}`;
+      if (existsSync(candidatePath) && statSync(candidatePath).isFile()) {
+        return candidatePath;
+      }
+    }
+    if (existsSync(basePath) && statSync(basePath).isDirectory()) {
+      const packageJsonPath = nodePath.join(basePath, "package.json");
+      if (existsSync(packageJsonPath) && statSync(packageJsonPath).isFile()) {
+        try {
+          const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+          for (const candidateEntry of [packageJson.main, packageJson.module]) {
+            if (typeof candidateEntry !== "string" || candidateEntry.trim().length === 0) {
+              continue;
+            }
+            try {
+              return resolveExistingTestModulePath(nodePath.resolve(basePath, candidateEntry));
+            } catch {
+              continue;
+            }
+          }
+        } catch {
+        }
+      }
+      for (const extension of TEST_MODULE_EXTENSIONS) {
+        const candidatePath = nodePath.join(basePath, `index${extension}`);
+        if (existsSync(candidatePath) && statSync(candidatePath).isFile()) {
+          return candidatePath;
+        }
+      }
+    }
+    return basePath;
+  }
+  function resolveTestModulePath(fromFilePath, specifier) {
+    if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+      return specifier;
+    }
+    const nodePath = __require("path");
+    const basePath = specifier.startsWith(".") ? nodePath.resolve(dirname(fromFilePath), specifier) : specifier;
+    return resolveExistingTestModulePath(basePath);
+  }
+  function shouldTranspileTestModule(filePath) {
+    return /\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$/i.test(filePath);
+  }
+  function createTestModuleRequire(fromFilePath, moduleCache) {
+    return (specifier) => {
+      if (specifier.startsWith("elit/") || specifier === "elit") {
+        return __require(specifier);
+      }
+      const resolvedPath = resolveTestModulePath(fromFilePath, specifier);
+      if (resolvedPath === specifier) {
+        return __require(specifier);
+      }
+      if (!existsSync(resolvedPath) || !statSync(resolvedPath).isFile()) {
+        return __require(resolvedPath);
+      }
+      if (!shouldTranspileTestModule(resolvedPath)) {
+        return __require(resolvedPath);
+      }
+      return loadTranspiledTestModule(resolvedPath, moduleCache);
+    };
+  }
+  function loadTranspiledTestModule(modulePath, moduleCache) {
+    const cached = moduleCache.get(modulePath);
+    if (cached) {
+      return cached.exports;
+    }
+    const source = readFileSync(modulePath, "utf-8");
+    let transpiled;
+    try {
+      transpiled = (0, import_esbuild.transformSync)(source, createTestTransformOptions(modulePath, "cjs", false));
+    } catch (error) {
+      throw new Error(`Failed to transpile test dependency ${modulePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const moduleRecord = { exports: {} };
+    const moduleObj = { exports: moduleRecord.exports };
+    moduleCache.set(modulePath, moduleRecord);
+    try {
+      const fn = new Function("module", "exports", "require", "__filename", "__dirname", transpiled.code);
+      const requireFn = createTestModuleRequire(modulePath, moduleCache);
+      fn(moduleObj, moduleObj.exports, requireFn, modulePath, dirname(modulePath));
+    } catch (error) {
+      throw new Error(`Failed to execute test dependency ${modulePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    moduleRecord.exports = moduleObj.exports;
+    if (!modulePath.includes(".test.") && !modulePath.includes(".spec.")) {
+      coveredFiles.add(modulePath);
+    }
+    return moduleRecord.exports;
+  }
+  async function transpileFile(filePath) {
+    const source = await readFile(filePath, "utf-8");
+    const result = (0, import_esbuild.transformSync)(source, createTestTransformOptions(filePath, "esm", "inline"));
     let sourceMap;
     const sourceMapMatch = result.code.match(/\/\/# sourceMappingURL=data:application\/json;base64,(.+)/);
     if (sourceMapMatch) {
@@ -4971,7 +5120,7 @@ error: ${text}`);
   }
   function createTestFunction(defaultTimeout = 5e3) {
     const testFn = function(name, fn, timeout) {
-      const test2 = {
+      const test = {
         name,
         fn,
         skip: currentSuite.skip,
@@ -4980,10 +5129,10 @@ error: ${text}`);
         timeout: timeout ?? defaultTimeout,
         suite: currentSuite
       };
-      currentSuite.tests.push(test2);
+      currentSuite.tests.push(test);
     };
     testFn.skip = (name, fn, timeout) => {
-      const test2 = {
+      const test = {
         name,
         fn,
         skip: true,
@@ -4992,11 +5141,11 @@ error: ${text}`);
         timeout: timeout ?? defaultTimeout,
         suite: currentSuite
       };
-      currentSuite.tests.push(test2);
+      currentSuite.tests.push(test);
     };
     testFn.only = (name, fn, timeout) => {
       hasOnly = true;
-      const test2 = {
+      const test = {
         name,
         fn,
         skip: false,
@@ -5005,10 +5154,10 @@ error: ${text}`);
         timeout: timeout ?? defaultTimeout,
         suite: currentSuite
       };
-      currentSuite.tests.push(test2);
+      currentSuite.tests.push(test);
     };
     testFn.todo = (name, fn, timeout) => {
-      const test2 = {
+      const test = {
         name,
         fn,
         skip: false,
@@ -5017,7 +5166,7 @@ error: ${text}`);
         timeout: timeout ?? defaultTimeout,
         suite: currentSuite
       };
-      currentSuite.tests.push(test2);
+      currentSuite.tests.push(test);
     };
     return testFn;
   }
@@ -5583,29 +5732,7 @@ error: ${text}`);
       try {
         const source = await readFile(file, "utf-8");
         const testFileDir = dirname(file);
-        const importRegex = /import\s+{\s*([^}]+)\s*}\s+from\s+['"]([^'"]+)['"]/g;
-        const imports = {};
-        let importIndex = 0;
-        let codeWithoutImports = source.replace(importRegex, (_, named, path) => {
-          const varName = `__import_${importIndex++}`;
-          const trimmedNamed = named.trim();
-          imports[varName] = { path, named: trimmedNamed };
-          return `// ${trimmedNamed} import injected later
-`;
-        });
-        const result = (0, import_esbuild.transformSync)(codeWithoutImports, {
-          loader: file.endsWith(".ts") || file.endsWith(".tsx") ? "ts" : "js",
-          format: "iife",
-          sourcemap: "inline",
-          target: "es2020",
-          tsconfigRaw: {
-            compilerOptions: {
-              jsx: "react",
-              jsxFactory: "h",
-              jsxFragmentFactory: "Fragment"
-            }
-          }
-        });
+        const result = (0, import_esbuild.transformSync)(source, createTestTransformOptions(file, "cjs", "inline"));
         let code = result.code;
         const sourceMapMatch = code.match(/\/\/# sourceMappingURL=data:application\/json;base64,(.+)/);
         if (sourceMapMatch) {
@@ -5616,99 +5743,15 @@ error: ${text}`);
         } else {
           currentSourceMapConsumer = void 0;
         }
-        const importedValues = {};
-        const importParamNames = [];
-        const importAssignments = [];
-        if (Object.keys(imports).length > 0) {
-          for (const [, { path, named }] of Object.entries(imports)) {
-            let resolvedPath = path;
-            if (path.startsWith(".")) {
-              const nodePath = __require("path");
-              resolvedPath = nodePath.resolve(testFileDir, path);
-            }
-            if (!resolvedPath.endsWith(".ts") && !resolvedPath.endsWith(".js") && !resolvedPath.endsWith(".mjs") && !resolvedPath.endsWith(".cjs")) {
-              resolvedPath += ".ts";
-            }
-            if (resolvedPath.endsWith(".ts")) {
-              try {
-                const importSource = await readFile(resolvedPath, "utf-8");
-                const transpiled = (0, import_esbuild.transformSync)(importSource, {
-                  loader: "ts",
-                  format: "cjs",
-                  target: "es2020",
-                  tsconfigRaw: {
-                    compilerOptions: {
-                      jsx: "react",
-                      jsxFactory: "h",
-                      jsxFragmentFactory: "Fragment"
-                    }
-                  }
-                });
-                const moduleExports = {};
-                const moduleObj = { exports: moduleExports };
-                const fn2 = new Function("module", "exports", "require", "__filename", "__dirname", transpiled.code);
-                const requireFn = (id) => {
-                  if (id.startsWith("elit/") || id === "elit") {
-                    return __require(id);
-                  }
-                  if (id.startsWith(".")) {
-                    const nodePath = __require("path");
-                    const absPath = nodePath.resolve(dirname(resolvedPath), id);
-                    return __require(absPath);
-                  }
-                  return __require(id);
-                };
-                fn2(moduleObj, moduleExports, requireFn, resolvedPath, dirname(resolvedPath));
-                if (!resolvedPath.includes(".test.") && !resolvedPath.includes(".spec.")) {
-                  coveredFiles.add(resolvedPath);
-                }
-                let exportedValue = moduleObj.exports[named];
-                if (exportedValue === void 0 && moduleObj.exports.default) {
-                  exportedValue = moduleObj.exports.default[named];
-                }
-                if (exportedValue === void 0 && typeof moduleObj.exports === "object") {
-                  exportedValue = moduleObj.exports[named];
-                }
-                const paramKey = `__import_${Math.random().toString(36).substring(2, 11)}`;
-                importedValues[paramKey] = exportedValue;
-                importParamNames.push(paramKey);
-                importAssignments.push(`const ${named} = ${paramKey};`);
-              } catch (err) {
-                const paramKey = `__import_${Math.random().toString(36).substring(2, 11)}`;
-                importedValues[paramKey] = null;
-                importParamNames.push(paramKey);
-                importAssignments.push(`const ${named} = ${paramKey}; /* Error importing ${resolvedPath}: ${err} */`);
-              }
-            } else {
-              const requiredModule = __require(resolvedPath);
-              const exportedValue = requiredModule[named];
-              const paramKey = `__import_${Math.random().toString(36).substring(2, 11)}`;
-              importedValues[paramKey] = exportedValue;
-              importParamNames.push(paramKey);
-              importAssignments.push(`const ${named} = ${paramKey};`);
-            }
-          }
-        }
-        let preamble = "";
-        if (Object.keys(imports).length > 0) {
-          const iifeStartMatch = code.match(/^(\s*(?:var\s+\w+\s*=\s*)?\(\(\)\s*=>\s*\{\n)/);
-          if (iifeStartMatch) {
-            const iifePrefix = iifeStartMatch[1];
-            const assignments = `${importAssignments.join("\n")}
-`;
-            preamble = iifePrefix;
-            code = iifePrefix + assignments + code.slice(iifeStartMatch[1].length);
-          } else {
-            preamble = importAssignments.join("\n") + "\n";
-            code = preamble + code;
-          }
-        }
-        wrapperLineOffset = preamble.split("\n").length;
+        wrapperLineOffset = 0;
         setupGlobals();
-        const allParams = ["describe", "it", "test", "expect", "beforeAll", "afterAll", "beforeEach", "afterEach", "vi", "require", "module", "__filename", "__dirname", ...importParamNames];
-        const allArgs = [describe, it, test, expect, beforeAll, afterAll, beforeEach, afterEach, vi, __require, module, file, testFileDir, ...importParamNames.map((p) => importedValues[p])];
-        const fn = new Function(...allParams, code);
-        await fn(...allArgs);
+        const moduleCache = /* @__PURE__ */ new Map();
+        const moduleRecord = { exports: {} };
+        const moduleObj = { exports: moduleRecord.exports };
+        moduleCache.set(file, moduleRecord);
+        const fn = new Function("module", "exports", "require", "__filename", "__dirname", code);
+        const requireFn = createTestModuleRequire(file, moduleCache);
+        await fn(moduleObj, moduleObj.exports, requireFn, file, testFileDir);
         await executeSuite(currentSuite, timeout, bail);
         if (currentSourceMapConsumer) {
           currentSourceMapConsumer.destroy();
@@ -5773,22 +5816,22 @@ error: ${text}`);
     for (const hook of beforeAllHooks) {
       await hook();
     }
-    for (const test2 of suite.tests) {
-      if (hasOnly && !test2.only && !suite.only) {
+    for (const test of suite.tests) {
+      if (hasOnly && !test.only && !suite.only) {
         continue;
       }
       let testMatches = true;
       if (testPattern) {
         const escapedPattern = escapeRegex(testPattern);
         const regex = new RegExp(escapedPattern, "i");
-        testMatches = regex.test(test2.name);
+        testMatches = regex.test(test.name);
       }
       if (!testMatches) {
         continue;
       }
-      if (test2.skip || suite.skip) {
+      if (test.skip || suite.skip) {
         testResults.push({
-          name: test2.name,
+          name: test.name,
           status: "skip",
           duration: 0,
           suite: suite.name,
@@ -5796,9 +5839,9 @@ error: ${text}`);
         });
         continue;
       }
-      if (test2.todo) {
+      if (test.todo) {
         testResults.push({
-          name: test2.name,
+          name: test.name,
           status: "todo",
           duration: 0,
           suite: suite.name,
@@ -5812,13 +5855,13 @@ error: ${text}`);
       const startTime = Date.now();
       try {
         await Promise.race([
-          test2.fn(),
+          test.fn(),
           new Promise(
-            (_, reject) => setTimeout(() => reject(new Error(`Test timed out after ${test2.timeout}ms`)), test2.timeout)
+            (_, reject) => setTimeout(() => reject(new Error(`Test timed out after ${test.timeout}ms`)), test.timeout)
           )
         ]);
         testResults.push({
-          name: test2.name,
+          name: test.name,
           status: "pass",
           duration: Date.now() - startTime,
           suite: suite.name,
@@ -5832,7 +5875,7 @@ error: ${text}`);
           codeSnippet = error.codeSnippet;
         }
         testResults.push({
-          name: test2.name,
+          name: test.name,
           status: "fail",
           duration: Date.now() - startTime,
           error,