elit 3.6.4 → 3.6.6

package/dist/test.mjs

@@ -3269,9 +3269,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 = 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,
@@ -3280,10 +3395,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,
@@ -3292,11 +3407,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,
@@ -3305,10 +3420,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,
@@ -3317,7 +3432,7 @@ function createTestFunction(defaultTimeout = 5e3) {
       timeout: timeout ?? defaultTimeout,
       suite: currentSuite
     };
-    currentSuite.tests.push(test2);
+    currentSuite.tests.push(test);
   };
   return testFn;
 }
@@ -3883,29 +3998,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 = 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 = transformSync(source, createTestTransformOptions(file, "cjs", "inline"));
       let code = result.code;
       const sourceMapMatch = code.match(/\/\/# sourceMappingURL=data:application\/json;base64,(.+)/);
       if (sourceMapMatch) {
@@ -3916,99 +4009,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 = 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();
@@ -4073,22 +4082,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,
@@ -4096,9 +4105,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,
@@ -4112,13 +4121,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,
@@ -4132,7 +4141,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,

package/dist/types.d.ts

@@ -1,7 +1,9 @@
 import { EventEmitter } from 'node:events';
 import { EventEmitter as EventEmitter$1 } from 'events';
-import { Server } from 'http';
+import { Server as Server$1 } from 'http';
 import { WebSocketServer } from 'ws';
+import { Server, AddressInfo } from 'net';
+import { SMTPServerOptions, SMTPServer } from 'smtp-server';
 
 /**
  * HTTP module with unified API across runtimes
@@ -238,6 +240,28 @@ declare class StateManager$1 {
     clear(): void;
 }
 
+/**
+ * SMTP server helpers built on top of the smtp-server package.
+ */
+
+interface ElitSMTPServerConfig extends SMTPServerOptions {
+    port?: number;
+    host?: string;
+    label?: string;
+}
+interface ResolvedElitSMTPServerConfig extends SMTPServerOptions {
+    port: number;
+    host: string;
+    label?: string;
+}
+interface ElitSMTPServerHandle {
+    server: SMTPServer;
+    config: ResolvedElitSMTPServerConfig;
+    listen(callback?: () => void): Server;
+    address(): AddressInfo | string | null;
+    close(): Promise<void>;
+}
+
 /**
  * Elit - Types and Interfaces
  */
@@ -342,6 +366,8 @@ interface ClientConfig {
     api?: Router;
     /** WebSocket endpoints specific to this client */
     ws?: WebSocketEndpointConfig[];
+    /** SMTP listeners specific to this client */
+    smtp?: ElitSMTPServerConfig | ElitSMTPServerConfig[];
     /** Server mode: 'dev' uses source files, 'preview' uses built files (default: 'dev') */
     mode?: 'dev' | 'preview';
 }
@@ -400,6 +426,8 @@ interface DevServerOptions {
     api?: Router;
     /** WebSocket endpoints */
     ws?: WebSocketEndpointConfig[];
+    /** SMTP listeners started alongside the HTTP server */
+    smtp?: ElitSMTPServerConfig | ElitSMTPServerConfig[];
     /** SSR render function - returns HTML VNode or string */
     ssr?: () => Child | string;
     /** Proxy configuration for API requests */
@@ -417,9 +445,11 @@ interface DevServerOptions {
 }
 interface DevServer {
     /** HTTP server instance */
-    server: Server;
+    server: Server$1;
     /** WebSocket server for HMR */
     wss: WebSocketServer;
+    /** Managed SMTP listeners started from dev or preview config */
+    smtpServers: ElitSMTPServerHandle[];
     /** Server URL */
     url: string;
     /** Shared state manager */
@@ -517,6 +547,8 @@ interface PreviewOptions {
     api?: Router;
     /** WebSocket endpoints */
     ws?: WebSocketEndpointConfig[];
+    /** SMTP listeners started alongside the preview server */
+    smtp?: ElitSMTPServerConfig | ElitSMTPServerConfig[];
     /** SSR render function - returns HTML VNode or string */
     ssr?: () => Child | string;
     /** Proxy configuration for API requests */

package/dist/universal.d.ts

@@ -3,6 +3,8 @@ import 'node:events';
 import 'events';
 import 'http';
 import 'ws';
+import 'net';
+import 'smtp-server';
 
 type UniversalPayload = string | number | boolean | null | UniversalPayload[] | {
     [key: string]: UniversalPayload;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elit",
-  "version": "3.6.4",
+  "version": "3.6.6",
   "description": "Optimized lightweight library for creating DOM elements with reactive state",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -95,6 +95,12 @@
       "import": "./dist/https.mjs",
       "require": "./dist/https.cjs"
     },
+    "./smtp-server": {
+      "types": "./dist/smtp-server.d.ts",
+      "browser": "./dist/smtp-server.js",
+      "import": "./dist/smtp-server.mjs",
+      "require": "./dist/smtp-server.cjs"
+    },
     "./ws": {
       "types": "./dist/ws.d.ts",
       "browser": "./dist/ws.js",
@@ -257,12 +263,14 @@
     "esbuild": "^0.27.3",
     "esbuild-obfuscator-plugin": "^0.0.5",
     "open": "^11.0.0",
+    "smtp-server": "^3.18.4",
     "source-map": "^0.7.6"
   },
   "devDependencies": {
     "@types/bun": "^1.3.6",
     "@types/mime-types": "^2.1.4",
     "@types/node": "^25.0.10",
+    "@types/smtp-server": "^3.5.13",
     "@types/ws": "^8.5.13",
     "copyfiles": "^2.4.1",
     "elysia": "^1.4.19",