elit 3.3.3 → 3.3.5

package/src/test.ts

@@ -0,0 +1,368 @@
+/**
+ * Jest-compatible Test Runner powered by esbuild
+ *
+ * Main entry point for running tests with Jest-like API.
+ */
+
+import { readdirSync } from './fs';
+import { join, relative } from './path';
+import { runTests, setupGlobals, clearGlobals, resetCoveredFiles, getCoveredFiles } from './test-runtime';
+import { TestReporter, DotReporter, JsonReporter, VerboseReporter } from './test-reporter';
+
+export interface TestOptions {
+    files?: string[];
+    include?: string[];
+    exclude?: string[];
+    reporter?: 'default' | 'dot' | 'json' | 'verbose';
+    timeout?: number;
+    bail?: boolean;
+    run?: boolean;
+    watch?: boolean;
+    endToEnd?: boolean;
+    colors?: boolean;
+    globals?: boolean;
+    describePattern?: string;
+    testPattern?: string;
+    coverage?: {
+        enabled: boolean;
+        provider: 'v8' | 'istanbul';
+        reporter?: ('text' | 'html' | 'lcov' | 'json' | 'coverage-final.json' | 'clover')[];
+        include?: string[];
+        exclude?: string[];
+    };
+}
+
+/**
+ * Convert glob pattern to regex (safe from ReDoS)
+ */
+function globToRegex(pattern: string): RegExp {
+    // Handle brace expansion: {ts,js} -> (ts|js)
+    // Use string operations instead of regex to avoid ReDoS
+    let expanded = pattern;
+    const openBraceIndex = pattern.indexOf('{');
+    if (openBraceIndex !== -1) {
+        const closeBraceIndex = pattern.indexOf('}', openBraceIndex);
+        if (closeBraceIndex !== -1) {
+            const options = pattern.slice(openBraceIndex + 1, closeBraceIndex).split(',');
+            const before = pattern.slice(0, openBraceIndex);
+            const after = pattern.slice(closeBraceIndex + 1);
+            expanded = before + '(' + options.join('|') + ')' + after;
+        }
+    }
+
+    // Convert to regex using character-by-character processing
+    // This avoids using .replace() with regex on user input
+    let regexStr = '^';
+    for (let i = 0; i < expanded.length; i++) {
+        const char = expanded[i];
+        switch (char) {
+            case '.':
+                regexStr += '\\.';
+                break;
+            case '*':
+                regexStr += '.*';
+                break;
+            case '?':
+                regexStr += '.';
+                break;
+            case '+':
+            case '^':
+            case '$':
+            case '|':
+            case '(':
+            case ')':
+            case '[':
+            case ']':
+            case '{':
+            case '}':
+            case '\\':
+                regexStr += '\\' + char;
+                break;
+            default:
+                regexStr += char;
+        }
+    }
+    regexStr += '$';
+
+    return new RegExp(regexStr);
+}
+
+/**
+ * Check if a file path matches a pattern (safe from ReDoS)
+ */
+function matchesPattern(relativePath: string, pattern: string): boolean {
+    // Handle brace expansion: {test,spec} or {ts,js,tsx,etc}
+    // Use string operations instead of regex to avoid ReDoS
+    const openBraceIndex = pattern.indexOf('{');
+
+    if (openBraceIndex !== -1) {
+        const closeBraceIndex = pattern.indexOf('}', openBraceIndex);
+        if (closeBraceIndex !== -1) {
+            // Expand braces to multiple patterns
+            const options = pattern.slice(openBraceIndex + 1, closeBraceIndex).split(',');
+            const before = pattern.slice(0, openBraceIndex);
+            const after = pattern.slice(closeBraceIndex + 1);
+
+            for (const option of options) {
+                const testPattern = before + option + after;
+                if (matchesPattern(relativePath, testPattern)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+
+    // Simple glob to regex conversion
+    const regex = globToRegex(pattern);
+    return regex.test(relativePath);
+}
+
+/**
+ * Find all test files matching patterns
+ */
+function findTestFiles(
+    root: string,
+    include: string[],
+    exclude: string[]
+): string[] {
+    const files: string[] = [];
+
+    // Normalize path to use forward slashes for pattern matching
+    // This ensures cross-platform compatibility
+    function normalizePathForPattern(path: string): string {
+        return path.replace(/\\/g, '/');
+    }
+
+    function scanDir(dir: string) {
+        try {
+            const entries = readdirSync(dir, { withFileTypes: true });
+
+            for (const entry of entries) {
+                if (typeof entry === 'string') continue;
+
+                const fullPath = join(dir, entry.name);
+
+                if (entry.isDirectory()) {
+                    // Check if directory should be excluded
+                    const relativePath = normalizePathForPattern(relative(root, fullPath));
+                    if (exclude.some(pattern => matchesPattern(relativePath, pattern))) {
+                        continue;
+                    }
+                    scanDir(fullPath);
+                } else if (entry.isFile()) {
+                    // Check if file matches include patterns
+                    const relativePath = normalizePathForPattern(relative(root, fullPath));
+                    // First check if file should be excluded
+                    if (exclude.some(pattern => matchesPattern(relativePath, pattern))) {
+                        continue;
+                    }
+                    for (const pattern of include) {
+                        if (matchesPattern(relativePath, pattern)) {
+                            files.push(fullPath);
+                            break;
+                        }
+                    }
+                }
+            }
+        } catch (error) {
+            // Ignore permission errors
+        }
+    }
+
+    scanDir(root);
+    return files;
+}
+
+/**
+ * Run tests with Jest-compatible interface
+ */
+export async function runJestTests(options: TestOptions = {}) {
+    const {
+        include = ['**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+        exclude = ['**/node_modules/**', '**/dist/**', '**/coverage/**', '**/.elit-tests-temp/**'],
+        reporter = 'default',
+        timeout = 5000,
+        bail = false,
+        globals = true,
+    } = options;
+
+    const root = process.cwd();
+    const files = options.files || findTestFiles(root, include, exclude);
+
+    if (files.length === 0) {
+        console.log('\n No test files found\n');
+        return {
+            success: true,
+            passed: 0,
+            failed: 0,
+            total: 0,
+        };
+    }
+
+    // Setup globals if enabled
+    if (globals) {
+        setupGlobals();
+    }
+
+    // Create reporter
+    let testReporter;
+    switch (reporter) {
+        case 'dot':
+            testReporter = new DotReporter();
+            break;
+        case 'json':
+            testReporter = new JsonReporter();
+            break;
+        case 'verbose':
+            testReporter = new VerboseReporter();
+            break;
+        default:
+            testReporter = new TestReporter({ colors: true });
+    }
+
+    // Notify start
+    if ('onRunStart' in testReporter) {
+        testReporter.onRunStart(files);
+    }
+
+    // Reset coverage tracking before running tests
+    resetCoveredFiles();
+
+    // Run tests
+    const results = await runTests({
+        files,
+        timeout,
+        bail,
+        describePattern: options.describePattern,
+        testPattern: options.testPattern,
+    });
+    // Notify individual test results
+    if ('onTestResult' in testReporter) {
+        for (const result of results.results) {
+            testReporter.onTestResult(result);
+        }
+    }
+
+    // Notify end
+    if ('onRunEnd' in testReporter) {
+        testReporter.onRunEnd(results.results);
+    }
+
+    // Clear globals
+    if (globals) {
+        clearGlobals();
+    }
+
+    // Generate coverage if enabled
+    if (options.coverage?.enabled) {
+        await generateCoverage(options.coverage, results.results);
+    }
+
+    return {
+        success: results.failed === 0,
+        passed: results.passed,
+        failed: results.failed,
+        total: results.passed + results.failed + results.skipped + results.todo,
+    };
+}
+
+/**
+ * Generate coverage report
+ */
+async function generateCoverage(
+    options: {
+        provider: 'v8' | 'istanbul';
+        reporter?: ('text' | 'html' | 'lcov' | 'json' | 'coverage-final.json' | 'clover')[];
+        include?: string[];
+        exclude?: string[];
+    },
+    testResults?: any[]
+) {
+    const { processCoverage, generateTextReport, generateHtmlReport, generateCoverageFinalJson, generateCloverXml } = await import('./coverage');
+
+    // Get covered files from test execution
+    const coveredFilesForCoverage = getCoveredFiles();
+
+    const coverageMap = await processCoverage({
+        reportsDirectory: './coverage',
+        include: options.include || ['**/*.ts', '**/*.js'],
+        exclude: options.exclude || ['**/*.test.ts', '**/*.spec.ts', '**/node_modules/**'],
+        reporter: options.reporter || ['text', 'html'],
+        coveredFiles: coveredFilesForCoverage,
+    });
+
+    const reporters = options.reporter || ['text', 'html'];
+    if (reporters.includes('text')) {
+        console.log('\n' + generateTextReport(coverageMap, testResults));
+    }
+
+    if (reporters.includes('html')) {
+        generateHtmlReport(coverageMap, './coverage');
+        console.log(`\n Coverage report: coverage/index.html\n`);
+    }
+
+    if (reporters.includes('coverage-final.json')) {
+        generateCoverageFinalJson(coverageMap, './coverage');
+        console.log(`\n Coverage report: coverage/coverage-final.json\n`);
+    }
+
+    if (reporters.includes('clover')) {
+        generateCloverXml(coverageMap, './coverage');
+        console.log(`\n Coverage report: coverage/clover.xml\n`);
+    }
+}
+
+// ============================================================================
+// Watch Mode
+// ============================================================================
+
+export async function runWatchMode(options: TestOptions = {}) {
+    const chokidar = await import('chokidar');
+
+    console.log('\n � watch mode - files will be re-run on change\n');
+
+    let isRunning = false;
+    let needsRerun = false;
+
+    const runTests = async () => {
+        if (isRunning) {
+            needsRerun = true;
+            return;
+        }
+
+        isRunning = true;
+        needsRerun = false;
+
+        console.clear();
+        await runJestTests(options);
+
+        isRunning = false;
+
+        if (needsRerun) {
+            await runTests();
+        }
+    };
+
+    // Initial run
+    await runTests();
+
+    const { include, exclude } = options;
+    const watchPatterns = include || ['**/*.test.ts', '**/*.test.js', '**/*.spec.ts', '**/*.spec.js'];
+    const ignoredPatterns = exclude || ['**/node_modules/**', '**/dist/**', '**/coverage/**'];
+
+    const watcher = chokidar.default.watch(watchPatterns, {
+        ignored: ignoredPatterns,
+        persistent: true,
+    });
+
+    watcher.on('change', async (path) => {
+        console.log(`\n 📄 ${path} changed\n`);
+        await runTests();
+    });
+
+    watcher.on('add', async (path) => {
+        console.log(`\n 📄 ${path} added\n`);
+        await runTests();
+    });
+}

package/src/types.ts

@@ -268,3 +268,62 @@ export interface PreviewOptions {
     /** Environment variables to inject (prefix with VITE_ for client access) */
     env?: Record<string, string>;
 }
+
+// ===== Test Types =====
+
+export type TestEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
+
+export type TestCoverageProvider = 'v8' | 'istanbul';
+
+export type TestCoverageReporter = 'text' | 'json' | 'html' | 'lcov' | 'lcovonly' | 'coverage-final.json' | 'clover';
+
+export interface TestCoverageOptions {
+    provider?: TestCoverageProvider;
+    reporter?: TestCoverageReporter[];
+    dir?: string;
+    include?: string[];
+    exclude?: string[];
+    thresholds?: {
+        lines?: number;
+        functions?: number;
+        branches?: number;
+        statements?: number;
+    };
+    all?: boolean;
+}
+
+export interface TestOptions {
+    environment?: TestEnvironment;
+    globals?: boolean;
+    setupFiles?: string[];
+    include?: string[];
+    exclude?: string[];
+    testTimeout?: number;
+    isolate?: boolean;
+    pool?: string;
+    poolOptions?: {
+        threads?: {
+            singleThread?: boolean;
+            minThreads?: number;
+            maxThreads?: number;
+            isolate?: boolean;
+        };
+        forks?: {
+            singleFork?: boolean;
+            minForks?: number;
+            maxForks?: number;
+            isolate?: boolean;
+        };
+    };
+    coverage?: TestCoverageOptions;
+    watch?: boolean;
+    ui?: boolean;
+    reporter?: 'verbose' | 'dot' | 'json' | 'tap';
+    bail?: number | boolean;
+    pattern?: string | RegExp;
+    colors?: boolean;
+    retry?: number;
+    includeSrc?: string[];
+    excludeSrc?: string[];
+    env?: Record<string, string>;
+}

package/src/ws.ts

@@ -348,15 +348,45 @@ export class WebSocketServer extends EventEmitter {
     });
 
     socket.on('error', (error: Error) => {
+      // Silently ignore connection errors (ECONNABORTED, ECONNRESET, etc.)
+      // These are normal when clients disconnect during HMR
+      const errorCode = (error as any).code;
+      if (errorCode === 'ECONNABORTED' || errorCode === 'ECONNRESET' || errorCode === 'EPIPE') {
+        // Silently ignore - connection was closed by client
+        return;
+      }
+      // Only emit other errors
       client.emit('error', error);
     });
 
     // Override send method
     client.send = (data: Data, _options?: any, callback?: (err?: Error) => void) => {
+      // Check if socket is still writable
+      if (!socket.writable || client.readyState !== ReadyState.OPEN) {
+        const err = new Error('WebSocket is not open');
+        (err as any).code = 'WS_NOT_OPEN';
+        queueCallback(callback, err);
+        return;
+      }
+
       try {
         const frame = this._createFrame(data);
-        socket.write(frame);
-        queueCallback(callback);
+        socket.write(frame, (err?: Error) => {
+          // Handle async write errors (ECONNABORTED, ECONNRESET, etc.)
+          if (err) {
+            const errorCode = (err as any).code;
+            // Silently ignore connection errors - these are normal during HMR
+            if (errorCode !== 'ECONNABORTED' && errorCode !== 'ECONNRESET' && errorCode !== 'EPIPE') {
+              queueCallback(callback, err);
+            } else {
+              // Connection closed - mark client as closed
+              client.readyState = ReadyState.CLOSED;
+              queueCallback(callback); // Call without error for graceful handling
+            }
+          } else {
+            queueCallback(callback);
+          }
+        });
       } catch (error) {
         queueCallback(callback, error as Error);
       }