@postalsys/email-text-tools 2.1.16 → 2.2.0

package/benchmark/quick-benchmark.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+'use strict';
+
+const mimeHtml = require('../lib/mime-html');
+
+// Quick performance comparison
+async function quickBenchmark() {
+    const testHtml = `
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <style>
+                body { font-family: Arial, sans-serif; }
+                .container { max-width: 600px; margin: 0 auto; padding: 20px; }
+                h1 { color: #333; }
+                p { line-height: 1.6; }
+                .button { background: #007bff; color: white; padding: 10px 20px; }
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <h1>Test Email</h1>
+                <p>This is a test email with moderate complexity.</p>
+                <a href="#" class="button">Click Here</a>
+            </div>
+        </body>
+        </html>
+    `;
+
+    console.log('Quick Performance Comparison');
+    console.log('============================\n');
+
+    const iterations = 50;
+
+    // Test Sync
+    console.log('Testing Sync version...');
+    const syncTimes = [];
+    for (let i = 0; i < iterations; i++) {
+        const start = process.hrtime.bigint();
+        mimeHtml.sync({ html: testHtml });
+        const end = process.hrtime.bigint();
+        syncTimes.push(Number(end - start) / 1000000);
+    }
+
+    // Test Async with Pool
+    console.log('Testing Async with worker pool...');
+    const asyncPoolTimes = [];
+    for (let i = 0; i < iterations; i++) {
+        const start = process.hrtime.bigint();
+        await mimeHtml.async(
+            { html: testHtml },
+            {
+                useWorkerPool: true,
+                timeout: 5000
+            }
+        );
+        const end = process.hrtime.bigint();
+        asyncPoolTimes.push(Number(end - start) / 1000000);
+    }
+
+    // Test Async without Pool (just first 5 to avoid long wait)
+    console.log('Testing Async without pool (5 iterations only)...');
+    const asyncNoPoolTimes = [];
+    for (let i = 0; i < 5; i++) {
+        const start = process.hrtime.bigint();
+        await mimeHtml.async(
+            { html: testHtml },
+            {
+                useWorkerPool: false,
+                timeout: 5000
+            }
+        );
+        const end = process.hrtime.bigint();
+        asyncNoPoolTimes.push(Number(end - start) / 1000000);
+    }
+
+    // Calculate stats
+    const getStats = times => {
+        const avg = times.reduce((a, b) => a + b, 0) / times.length;
+        times.sort((a, b) => a - b);
+        const median = times[Math.floor(times.length / 2)];
+        const min = times[0];
+        const max = times[times.length - 1];
+        return { avg, median, min, max };
+    };
+
+    const syncStats = getStats(syncTimes);
+    const asyncPoolStats = getStats(asyncPoolTimes);
+    const asyncNoPoolStats = getStats(asyncNoPoolTimes);
+
+    // Display results
+    console.log('\nResults (all times in milliseconds):');
+    console.log('=====================================\n');
+
+    console.log('Sync Version:');
+    console.log(`  Average:   ${syncStats.avg.toFixed(2)} ms`);
+    console.log(`  Median:    ${syncStats.median.toFixed(2)} ms`);
+    console.log(`  Min:       ${syncStats.min.toFixed(2)} ms`);
+    console.log(`  Max:       ${syncStats.max.toFixed(2)} ms`);
+
+    console.log('\nAsync with Worker Pool:');
+    console.log(`  Average:   ${asyncPoolStats.avg.toFixed(2)} ms`);
+    console.log(`  Median:    ${asyncPoolStats.median.toFixed(2)} ms`);
+    console.log(`  Min:       ${asyncPoolStats.min.toFixed(2)} ms`);
+    console.log(`  Max:       ${asyncPoolStats.max.toFixed(2)} ms`);
+
+    console.log('\nAsync without Pool (single worker per call):');
+    console.log(`  Average:   ${asyncNoPoolStats.avg.toFixed(2)} ms`);
+    console.log(`  Median:    ${asyncNoPoolStats.median.toFixed(2)} ms`);
+    console.log(`  Min:       ${asyncNoPoolStats.min.toFixed(2)} ms`);
+    console.log(`  Max:       ${asyncNoPoolStats.max.toFixed(2)} ms`);
+
+    console.log('\nPerformance Summary:');
+    console.log('====================');
+
+    if (asyncPoolStats.avg < syncStats.avg) {
+        const speedup = (syncStats.avg / asyncPoolStats.avg).toFixed(2);
+        console.log(`✓ Async with pool is ${speedup}x faster than sync`);
+    } else {
+        const slowdown = (asyncPoolStats.avg / syncStats.avg).toFixed(2);
+        console.log(`✗ Async with pool is ${slowdown}x slower than sync`);
+    }
+
+    const poolVsNoPool = (asyncNoPoolStats.avg / asyncPoolStats.avg).toFixed(1);
+    console.log(`✓ Worker pool is ${poolVsNoPool}x faster than single workers`);
+
+    // Worker pool stats
+    const poolStats = mimeHtml.getWorkerPoolStats();
+    if (poolStats) {
+        console.log('\nWorker Pool Statistics:');
+        console.log('======================');
+        console.log(`  Total Workers:  ${poolStats.totalWorkers}`);
+        console.log(`  Busy Workers:   ${poolStats.busyWorkers}`);
+        console.log(`  Free Workers:   ${poolStats.freeWorkers}`);
+        console.log(`  Queued Tasks:   ${poolStats.queuedTasks}`);
+        console.log(`  Min Workers:    ${poolStats.minWorkers}`);
+        console.log(`  Max Workers:    ${poolStats.maxWorkers}`);
+    }
+
+    // Test with problematic CSS
+    console.log('\nTesting Problematic CSS Handling:');
+    console.log('=================================');
+
+    const problematicHtml = `
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <style>
+                /* These selectors would cause juice to hang */
+                .item:is(.active, .selected) { background: yellow; }
+                .element:where(.primary) { color: blue; }
+                .parent:has(> .child) { border: 1px solid red; }
+            </style>
+        </head>
+        <body>
+            <div class="item active">Active Item</div>
+            <div class="parent"><div class="child">Child</div></div>
+        </body>
+        </html>
+    `;
+
+    try {
+        console.log('  Sync version... ');
+        const syncStart = process.hrtime.bigint();
+        const _syncResult = mimeHtml.sync({ html: problematicHtml });
+        const syncEnd = process.hrtime.bigint();
+        const syncTime = Number(syncEnd - syncStart) / 1000000;
+        console.log(`    ✓ Success (${syncTime.toFixed(2)} ms) - problematic selectors removed`);
+    } catch (err) {
+        console.log(`    ✗ Failed: ${err.message}`);
+    }
+
+    try {
+        console.log('  Async version...');
+        const asyncStart = process.hrtime.bigint();
+        const _asyncResult = await mimeHtml.async(
+            { html: problematicHtml },
+            {
+                timeout: 2000,
+                logErrors: false
+            }
+        );
+        const asyncEnd = process.hrtime.bigint();
+        const asyncTime = Number(asyncEnd - asyncStart) / 1000000;
+        console.log(`    ✓ Success (${asyncTime.toFixed(2)} ms) - handled with timeout protection`);
+    } catch (err) {
+        console.log(`    ✗ Failed: ${err.message}`);
+    }
+
+    // Clean up
+    await mimeHtml.closeWorkerPool();
+
+    console.log('\n✓ Benchmark complete!');
+}
+
+// Run the benchmark
+quickBenchmark().catch(err => {
+    console.error('Benchmark failed:', err);
+    process.exit(1);
+});

package/benchmark/quick-concurrency.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const mimeHtml = require('../lib/mime-html');
+
+async function quickConcurrencyTest() {
+    console.log('Quick Concurrency Test - Real-World HTML');
+    console.log('='.repeat(60));
+
+    const realWorldHtml = fs.readFileSync(path.join(__dirname, '../examples/failing.html'), 'utf8');
+
+    console.log(`Testing with ${(realWorldHtml.length / 1024).toFixed(1)} KB of problematic HTML\n`);
+
+    const iterations = 30;
+
+    // Test 1: Sequential Sync
+    console.log(`Test 1: Sequential Sync (${iterations} requests)`);
+    const syncStart = process.hrtime.bigint();
+    for (let i = 0; i < iterations; i++) {
+        mimeHtml.sync({ html: realWorldHtml });
+    }
+    const syncTime = Number(process.hrtime.bigint() - syncStart) / 1000000;
+    console.log(`  Time: ${syncTime.toFixed(2)}ms`);
+    console.log(`  Throughput: ${(iterations / (syncTime / 1000)).toFixed(0)} req/s\n`);
+
+    // Test 2: Concurrent Async with Pool (concurrency = 10)
+    console.log(`Test 2: Concurrent Async with Pool (${iterations} requests, concurrency=10)`);
+    const asyncStart = process.hrtime.bigint();
+    const promises = [];
+    for (let i = 0; i < iterations; i++) {
+        promises.push(
+            mimeHtml.async(
+                { html: realWorldHtml },
+                {
+                    useWorkerPool: true,
+                    timeout: 5000,
+                    logErrors: false
+                }
+            )
+        );
+    }
+    await Promise.all(promises);
+    const asyncTime = Number(process.hrtime.bigint() - asyncStart) / 1000000;
+    console.log(`  Time: ${asyncTime.toFixed(2)}ms`);
+    console.log(`  Throughput: ${(iterations / (asyncTime / 1000)).toFixed(0)} req/s\n`);
+
+    // Show speedup
+    const speedup = (syncTime / asyncTime).toFixed(2);
+    console.log('='.repeat(60));
+    console.log('Results:');
+    console.log(`• Concurrent processing is ${speedup}x faster than sequential`);
+    console.log(`• No timeouts occurred (pre-filtering working correctly)`);
+
+    const stats = mimeHtml.getWorkerPoolStats();
+    if (stats) {
+        console.log(`• Worker pool used ${stats.totalWorkers} workers efficiently`);
+    }
+
+    await mimeHtml.closeWorkerPool();
+}
+
+quickConcurrencyTest().catch(console.error);

package/benchmark/real-world-benchmark.js

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const mimeHtml = require('../lib/mime-html');
+
+class RealWorldBenchmark {
+    constructor() {
+        this.results = [];
+    }
+
+    async runTest(name, fn, iterations = 50) {
+        const times = [];
+        const errors = [];
+
+        // Warmup
+        console.log(`  Warming up ${name}...`);
+        for (let i = 0; i < 3; i++) {
+            try {
+                await fn();
+            } catch (_err) {
+                // Ignore warmup errors
+            }
+        }
+
+        // Actual test
+        console.log(`  Running ${name} (${iterations} iterations)...`);
+        for (let i = 0; i < iterations; i++) {
+            if (i % 10 === 0) {
+                process.stdout.write(`    Progress: ${i}/${iterations}\r`);
+            }
+            const start = process.hrtime.bigint();
+            try {
+                await fn();
+                const end = process.hrtime.bigint();
+                times.push(Number(end - start) / 1000000); // Convert to milliseconds
+            } catch (err) {
+                errors.push(err.message);
+            }
+        }
+        process.stdout.write(`    Progress: ${iterations}/${iterations} - Done!\n`);
+
+        if (times.length > 0) {
+            times.sort((a, b) => a - b);
+            const avg = times.reduce((a, b) => a + b, 0) / times.length;
+            const median = times[Math.floor(times.length / 2)];
+            const min = times[0];
+            const max = times[times.length - 1];
+            const p95 = times[Math.floor(times.length * 0.95)];
+            const p99 = times[Math.floor(times.length * 0.99)];
+
+            return {
+                name,
+                iterations,
+                successful: times.length,
+                failed: errors.length,
+                avg: avg.toFixed(2),
+                median: median.toFixed(2),
+                min: min.toFixed(2),
+                max: max.toFixed(2),
+                p95: p95.toFixed(2),
+                p99: p99.toFixed(2),
+                errors: errors.length > 0 ? errors[0] : null
+            };
+        } else {
+            return {
+                name,
+                iterations,
+                successful: 0,
+                failed: errors.length,
+                errors: errors[0] || 'All iterations failed'
+            };
+        }
+    }
+
+    formatTable(results) {
+        const table = [];
+        results.forEach(test => {
+            if (test.successful > 0) {
+                table.push({
+                    Method: test.name,
+                    Success: `${test.successful}/${test.iterations}`,
+                    Avg: `${test.avg}ms`,
+                    Median: `${test.median}ms`,
+                    Min: `${test.min}ms`,
+                    Max: `${test.max}ms`,
+                    P95: `${test.p95}ms`,
+                    P99: `${test.p99}ms`
+                });
+            } else {
+                table.push({
+                    Method: test.name,
+                    Success: `${test.successful}/${test.iterations}`,
+                    Error: test.errors
+                });
+            }
+        });
+
+        console.table(table);
+    }
+
+    async runBenchmarks() {
+        console.log('Real-World HTML Benchmark');
+        console.log('='.repeat(80));
+        console.log('Testing with actual problematic HTML that contains :is(), :where(), :has() selectors');
+        console.log('Both sync and async versions now pre-filter these selectors\n');
+
+        // Load the real-world HTML
+        const realWorldHtml = fs.readFileSync(path.join(__dirname, '../examples/failing.html'), 'utf8');
+
+        console.log(`HTML size: ${(realWorldHtml.length / 1024).toFixed(1)} KB`);
+        console.log(`Contains modern CSS selectors that would cause juice to hang\n`);
+
+        const results = [];
+
+        // Test 1: Sync version
+        console.log('Test 1: Sync Version');
+        console.log('-'.repeat(40));
+        results.push(
+            await this.runTest(
+                'Sync',
+                () => {
+                    return Promise.resolve(mimeHtml.sync({ html: realWorldHtml }));
+                },
+                50
+            )
+        );
+
+        // Test 2: Async with worker pool
+        console.log('\nTest 2: Async with Worker Pool');
+        console.log('-'.repeat(40));
+        results.push(
+            await this.runTest(
+                'Async (pool)',
+                async () => {
+                    return await mimeHtml.async(
+                        { html: realWorldHtml },
+                        {
+                            useWorkerPool: true,
+                            timeout: 5000,
+                            minWorkers: 2,
+                            maxWorkers: 4,
+                            logErrors: false
+                        }
+                    );
+                },
+                50
+            )
+        );
+
+        // Test 3: Async without pool (fewer iterations due to overhead)
+        console.log('\nTest 3: Async without Worker Pool');
+        console.log('-'.repeat(40));
+        results.push(
+            await this.runTest(
+                'Async (no pool)',
+                async () => {
+                    return await mimeHtml.async(
+                        { html: realWorldHtml },
+                        {
+                            useWorkerPool: false,
+                            timeout: 5000,
+                            logErrors: false
+                        }
+                    );
+                },
+                10
+            )
+        );
+
+        // Display results
+        console.log('\n' + '='.repeat(80));
+        console.log('RESULTS');
+        console.log('='.repeat(80) + '\n');
+
+        this.formatTable(results);
+
+        // Performance comparison
+        console.log('\nPerformance Analysis:');
+        console.log('-'.repeat(40));
+
+        const sync = results.find(r => r.name === 'Sync');
+        const asyncPool = results.find(r => r.name === 'Async (pool)');
+        const asyncNoPool = results.find(r => r.name === 'Async (no pool)');
+
+        if (sync && asyncPool && sync.successful > 0 && asyncPool.successful > 0) {
+            const overhead = (((parseFloat(asyncPool.avg) - parseFloat(sync.avg)) / parseFloat(sync.avg)) * 100).toFixed(1);
+            if (overhead > 0) {
+                console.log(`• Async with pool adds ${overhead}% overhead vs sync`);
+            } else {
+                console.log(`• Async with pool is ${Math.abs(overhead)}% faster than sync`);
+            }
+        }
+
+        if (asyncPool && asyncNoPool && asyncPool.successful > 0 && asyncNoPool.successful > 0) {
+            const poolAdvantage = (parseFloat(asyncNoPool.avg) / parseFloat(asyncPool.avg)).toFixed(1);
+            console.log(`• Worker pool is ${poolAdvantage}x faster than creating workers per request`);
+        }
+
+        if (sync && sync.successful > 0) {
+            console.log(`• Sync processes at ~${(1000 / parseFloat(sync.avg)).toFixed(0)} requests/second`);
+        }
+
+        if (asyncPool && asyncPool.successful > 0) {
+            console.log(`• Async with pool processes at ~${(1000 / parseFloat(asyncPool.avg)).toFixed(0)} requests/second`);
+        }
+
+        // Check if any timeouts occurred
+        const anyTimeouts = results.some(r => r.failed > 0);
+        if (!anyTimeouts) {
+            console.log('\n✅ No timeouts occurred - pre-filtering is working correctly!');
+        } else {
+            console.log('\n⚠️ Some timeouts occurred:');
+            results
+                .filter(r => r.failed > 0)
+                .forEach(r => {
+                    console.log(`  - ${r.name}: ${r.failed} failures`);
+                });
+        }
+
+        // Worker pool stats
+        const stats = mimeHtml.getWorkerPoolStats();
+        if (stats) {
+            console.log('\nWorker Pool Final Stats:');
+            console.log('-'.repeat(40));
+            console.log(`• Total Workers: ${stats.totalWorkers}`);
+            console.log(`• Busy Workers: ${stats.busyWorkers}`);
+            console.log(`• Free Workers: ${stats.freeWorkers}`);
+            console.log(`• Queued Tasks: ${stats.queuedTasks}`);
+        }
+
+        // Memory usage
+        const memUsage = process.memoryUsage();
+        console.log('\nMemory Usage:');
+        console.log('-'.repeat(40));
+        console.log(`• RSS: ${(memUsage.rss / 1024 / 1024).toFixed(1)} MB`);
+        console.log(`• Heap Used: ${(memUsage.heapUsed / 1024 / 1024).toFixed(1)} MB`);
+        console.log(`• External: ${(memUsage.external / 1024 / 1024).toFixed(1)} MB`);
+
+        // Cleanup
+        await mimeHtml.closeWorkerPool();
+
+        console.log('\n' + '='.repeat(80));
+        console.log('Benchmark Complete!');
+        console.log('='.repeat(80));
+
+        // Summary
+        console.log('\nKey Takeaways:');
+        console.log('• Both versions successfully handle problematic CSS by pre-filtering');
+        console.log('• No timeouts needed when selectors are filtered before processing');
+        console.log('• Worker pool provides efficient concurrent processing');
+        console.log('• Async timeout serves as safety net for unknown edge cases');
+    }
+}
+
+// Run benchmark
+const benchmark = new RealWorldBenchmark();
+benchmark
+    .runBenchmarks()
+    .then(() => {
+        process.exit(0);
+    })
+    .catch(err => {
+        console.error('Benchmark failed:', err);
+        process.exit(1);
+    });