elit 3.6.3 → 3.6.5

package/dist/test.cjs

@@ -3290,9 +3290,124 @@ var testPattern = void 0;
 var currentTestFile = void 0;
 var currentSourceMapConsumer = void 0;
 var wrapperLineOffset = 0;
+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: {
+        jsx: "react",
+        jsxFactory: "h",
+        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;
+}
 function createTestFunction(defaultTimeout = 5e3) {
   const testFn = function(name, fn, timeout) {
-    const test2 = {
+    const test = {
       name,
       fn,
       skip: currentSuite.skip,
@@ -3301,10 +3416,10 @@ function createTestFunction(defaultTimeout = 5e3) {
       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,
@@ -3313,11 +3428,11 @@ function createTestFunction(defaultTimeout = 5e3) {
       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,
@@ -3326,10 +3441,10 @@ function createTestFunction(defaultTimeout = 5e3) {
       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,
@@ -3338,7 +3453,7 @@ function createTestFunction(defaultTimeout = 5e3) {
       timeout: timeout ?? defaultTimeout,
       suite: currentSuite
     };
-    currentSuite.tests.push(test2);
+    currentSuite.tests.push(test);
   };
   return testFn;
 }
@@ -3904,29 +4019,7 @@ async function runTests(options) {
     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) {
@@ -3937,99 +4030,15 @@ async function runTests(options) {
       } 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();
@@ -4094,22 +4103,22 @@ async function executeSuite(suite, timeout, bail, parentMatched = false) {
   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,
@@ -4117,9 +4126,9 @@ async function executeSuite(suite, timeout, bail, parentMatched = false) {
       });
       continue;
     }
-    if (test2.todo) {
+    if (test.todo) {
       testResults.push({
-        name: test2.name,
+        name: test.name,
         status: "todo",
         duration: 0,
         suite: suite.name,
@@ -4133,13 +4142,13 @@ async function executeSuite(suite, timeout, bail, parentMatched = false) {
     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,
@@ -4153,7 +4162,7 @@ async function executeSuite(suite, timeout, bail, parentMatched = false) {
         codeSnippet = error.codeSnippet;
       }
       testResults.push({
-        name: test2.name,
+        name: test.name,
         status: "fail",
         duration: Date.now() - startTime,
         error,