@postalsys/email-text-tools 2.1.16 → 2.3.3

package/benchmark/concurrency-benchmark.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const mimeHtml = require('../lib/mime-html');
+
+async function concurrencyBenchmark() {
+    console.log('Concurrency Benchmark - Real-World HTML');
+    console.log('='.repeat(80));
+    console.log('Testing concurrent processing with problematic HTML\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('Testing different concurrency levels...\n');
+
+    const concurrencyLevels = [1, 5, 10, 20, 50];
+    const totalRequests = 100;
+
+    const results = [];
+
+    for (const concurrency of concurrencyLevels) {
+        console.log(`Testing with concurrency level: ${concurrency}`);
+        console.log('-'.repeat(40));
+
+        // Test sync (sequential only)
+        if (concurrency === 1) {
+            console.log('  Sync version (sequential)...');
+            const syncStart = process.hrtime.bigint();
+            for (let i = 0; i < totalRequests; i++) {
+                mimeHtml.sync({ html: realWorldHtml });
+                if ((i + 1) % 20 === 0) {
+                    process.stdout.write(`    Progress: ${i + 1}/${totalRequests}\r`);
+                }
+            }
+            const syncEnd = process.hrtime.bigint();
+            const syncTime = Number(syncEnd - syncStart) / 1000000;
+            process.stdout.write(`    Progress: ${totalRequests}/${totalRequests} - Done!\n`);
+
+            results.push({
+                method: 'Sync (sequential)',
+                concurrency: 1,
+                totalRequests,
+                totalTime: syncTime.toFixed(2),
+                avgTime: (syncTime / totalRequests).toFixed(2),
+                reqPerSec: (totalRequests / (syncTime / 1000)).toFixed(0)
+            });
+        }
+
+        // Test async with pool
+        console.log('  Async with pool...');
+        const asyncPoolStart = process.hrtime.bigint();
+        const poolPromises = [];
+
+        for (let i = 0; i < totalRequests; i++) {
+            poolPromises.push(
+                mimeHtml.async(
+                    { html: realWorldHtml },
+                    {
+                        useWorkerPool: true,
+                        timeout: 5000,
+                        minWorkers: 2,
+                        maxWorkers: 4,
+                        logErrors: false
+                    }
+                )
+            );
+
+            // Control concurrency
+            if (poolPromises.length >= concurrency) {
+                await Promise.race(poolPromises).then(() => {
+                    const index = poolPromises.findIndex(
+                        p => p.constructor.name !== 'Promise' || Promise.race([p, Promise.resolve('done')]).then(v => v === 'done')
+                    );
+                    if (index > -1) poolPromises.splice(index, 1);
+                });
+            }
+
+            if ((i + 1) % 20 === 0) {
+                process.stdout.write(`    Progress: ${i + 1}/${totalRequests}\r`);
+            }
+        }
+
+        // Wait for remaining promises
+        await Promise.all(poolPromises);
+        const asyncPoolEnd = process.hrtime.bigint();
+        const asyncPoolTime = Number(asyncPoolEnd - asyncPoolStart) / 1000000;
+        process.stdout.write(`    Progress: ${totalRequests}/${totalRequests} - Done!\n`);
+
+        results.push({
+            method: 'Async (pool)',
+            concurrency,
+            totalRequests,
+            totalTime: asyncPoolTime.toFixed(2),
+            avgTime: (asyncPoolTime / totalRequests).toFixed(2),
+            reqPerSec: (totalRequests / (asyncPoolTime / 1000)).toFixed(0)
+        });
+
+        // Show worker pool stats at peak concurrency
+        if (concurrency === 20) {
+            const stats = mimeHtml.getWorkerPoolStats();
+            console.log(`    Worker pool stats: ${stats.totalWorkers} workers, ${stats.busyWorkers} busy`);
+        }
+
+        console.log();
+    }
+
+    // Display results table
+    console.log('='.repeat(80));
+    console.log('RESULTS');
+    console.log('='.repeat(80) + '\n');
+
+    console.table(
+        results.map(r => ({
+            Method: r.method,
+            Concurrency: r.concurrency,
+            'Total Time': `${r.totalTime}ms`,
+            'Avg per Request': `${r.avgTime}ms`,
+            Throughput: `${r.reqPerSec} req/s`
+        }))
+    );
+
+    // Analysis
+    console.log('Performance Analysis:');
+    console.log('-'.repeat(40));
+
+    const syncResult = results.find(r => r.method === 'Sync (sequential)');
+    const bestAsync = results.filter(r => r.method === 'Async (pool)').sort((a, b) => parseFloat(a.totalTime) - parseFloat(b.totalTime))[0];
+
+    if (syncResult && bestAsync) {
+        const speedup = (parseFloat(syncResult.totalTime) / parseFloat(bestAsync.totalTime)).toFixed(2);
+        console.log(`• Best async configuration: Concurrency ${bestAsync.concurrency}`);
+        console.log(`• Async is ${speedup}x faster than sync for batch processing`);
+        console.log(`• Sync throughput: ${syncResult.reqPerSec} req/s`);
+        console.log(`• Best async throughput: ${bestAsync.reqPerSec} req/s`);
+    }
+
+    // Throughput graph
+    console.log('\nThroughput by Concurrency Level:');
+    console.log('-'.repeat(40));
+
+    const asyncResults = results.filter(r => r.method === 'Async (pool)');
+    const maxThroughput = Math.max(...asyncResults.map(r => parseInt(r.reqPerSec)));
+
+    asyncResults.forEach(r => {
+        const barLength = Math.round((parseInt(r.reqPerSec) / maxThroughput) * 30);
+        const bar = '█'.repeat(barLength);
+        console.log(`  ${String(r.concurrency).padStart(2)}: ${bar} ${r.reqPerSec} req/s`);
+    });
+
+    // Memory usage
+    const memUsage = process.memoryUsage();
+    console.log('\nFinal Memory 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`);
+
+    // Cleanup
+    await mimeHtml.closeWorkerPool();
+
+    console.log('\n' + '='.repeat(80));
+    console.log('Summary:');
+    console.log('• Async with worker pool provides significant speedup for concurrent processing');
+    console.log('• Pre-filtering prevents timeouts even under high load');
+    console.log('• Worker pool efficiently handles concurrent requests');
+    console.log('• Optimal concurrency depends on CPU cores and workload');
+    console.log('='.repeat(80));
+}
+
+// Run benchmark
+concurrencyBenchmark().catch(err => {
+    console.error('Benchmark failed:', err);
+    process.exit(1);
+});

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);