@postalsys/email-text-tools 2.4.25 → 2.5.0

package/benchmark/concurrency-benchmark.js

@@ -1,176 +0,0 @@
-#!/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

@@ -1,200 +0,0 @@
-#!/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

@@ -1,64 +0,0 @@
-#!/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);