@postalsys/email-text-tools 2.4.26 → 2.5.0

package/test/mime-html-extra.test.js

@@ -1,39 +0,0 @@
-'use strict';
-
-const { describe, it, after } = require('node:test');
-const assert = require('node:assert/strict');
-const mimeHtml = require('../lib/mime-html');
-
-describe('mime-html additional coverage', () => {
-    after(async () => {
-        await mimeHtml.closeWorkerPool();
-    });
-
-    describe('getWorkerPoolStats', () => {
-        it('should return null when no pool is initialized', async () => {
-            await mimeHtml.closeWorkerPool();
-            const stats = mimeHtml.getWorkerPoolStats();
-            assert.equal(stats, null);
-        });
-    });
-
-    describe('pool fallback to single worker', () => {
-        it('should still return result when pool times out and falls back', async () => {
-            await mimeHtml.closeWorkerPool();
-
-            // Use timeout: 1 to force pool timeout, triggering fallback to single worker
-            // Both may time out, but fallbackOnError defaults to true so processing continues
-            const result = await mimeHtml.async(
-                // a style sheet, so the juice worker actually runs
-                { html: '<style>p { color: red; }</style><p>Fallback test</p>' },
-                {
-                    timeout: 1,
-                    useWorkerPool: true
-                }
-            );
-
-            // Should still get a result (with or without inlined CSS)
-            assert.ok(result.includes('Fallback test'));
-        });
-    });
-});

package/test/mime-html.test.js

@@ -1,302 +0,0 @@
-'use strict';
-
-const { describe, it, before: _before, after, beforeEach: _beforeEach, afterEach: _afterEach } = require('node:test');
-const assert = require('node:assert/strict');
-const mimeHtml = require('../lib/mime-html');
-
-describe('mime-html', () => {
-    describe('sync version', () => {
-        it('should process simple HTML', () => {
-            const input = {
-                html: '<html><body><p>Hello World</p></body></html>'
-            };
-            const result = mimeHtml.sync(input);
-
-            assert.ok(result.includes('Hello World'));
-            assert.ok(result.includes('<div'));
-            assert.ok(result.includes('</div>'));
-        });
-
-        it('should convert text to HTML when no HTML provided', () => {
-            const input = {
-                text: 'Hello World\nThis is a test'
-            };
-            const result = mimeHtml.sync(input);
-
-            assert.ok(result.includes('Hello World'));
-            assert.ok(result.includes('This is a test'));
-            assert.ok(result.includes('<br'));
-        });
-
-        it('should handle HTML with CSS styles', () => {
-            const input = {
-                html: `
-                    <html>
-                    <head>
-                        <style>
-                            p { color: red; }
-                            .test { font-weight: bold; }
-                        </style>
-                    </head>
-                    <body>
-                        <p class="test">Styled text</p>
-                    </body>
-                    </html>
-                `
-            };
-            const result = mimeHtml.sync(input);
-
-            assert.ok(result.includes('Styled text'));
-            assert.ok(result.includes('style='));
-        });
-
-        it('should sanitize dangerous HTML', () => {
-            const input = {
-                html: `
-                    <html>
-                    <body>
-                        <p>Safe content</p>
-                        <script>alert('XSS')</script>
-                        <img src=x onerror="alert('XSS')">
-                    </body>
-                    </html>
-                `
-            };
-            const result = mimeHtml.sync(input);
-
-            assert.ok(result.includes('Safe content'));
-            assert.ok(!result.includes('<script'));
-            assert.ok(!result.includes('onerror'));
-        });
-
-        it('should add target="_blank" to links', () => {
-            const input = {
-                html: '<a href="https://example.com">Link</a>'
-            };
-            const result = mimeHtml.sync(input);
-
-            assert.ok(result.includes('target="_blank"'));
-            assert.ok(result.includes('Link'));
-        });
-
-        it('should remove problematic CSS selectors', () => {
-            const input = {
-                html: `
-                    <html>
-                    <head>
-                        <style>
-                            .item:is(.active, .selected) { background: yellow; }
-                            .element:where(.primary) { color: blue; }
-                            .parent:has(> .child) { border: 1px solid red; }
-                            p { color: green; }
-                        </style>
-                    </head>
-                    <body>
-                        <p class="item active">Test</p>
-                    </body>
-                    </html>
-                `
-            };
-
-            // Should complete without hanging
-            const result = mimeHtml.sync(input);
-            assert.ok(result.includes('Test'));
-            assert.ok(result.includes('color'));
-        });
-
-        it('should remove forbidden style properties', () => {
-            const input = {
-                html: `
-                    <html>
-                    <body style="position: fixed; width: 100%; height: 100%;">
-                        <div style="position: absolute; top: 0;">Content</div>
-                    </body>
-                    </html>
-                `
-            };
-            const result = mimeHtml.sync(input);
-
-            assert.ok(result.includes('Content'));
-            assert.ok(!result.includes('position'));
-            assert.ok(!result.includes('width'));
-            assert.ok(!result.includes('height'));
-        });
-
-        it('should handle empty input gracefully', () => {
-            const input = { html: '' };
-            const result = mimeHtml.sync(input);
-
-            assert.ok(typeof result === 'string');
-            assert.ok(result.includes('<div'));
-        });
-
-        it('should handle malformed HTML', () => {
-            const input = {
-                html: '<p>Unclosed paragraph <div>Nested content</p></div>'
-            };
-            const result = mimeHtml.sync(input);
-
-            assert.ok(result.includes('Unclosed paragraph'));
-            assert.ok(result.includes('Nested content'));
-        });
-
-        it('should preserve HTML entities', () => {
-            const input = {
-                html: '<p>&lt;script&gt; &amp; &quot;quotes&quot;</p>'
-            };
-            const result = mimeHtml.sync(input);
-
-            assert.ok(result.includes('&lt;'));
-            assert.ok(result.includes('&amp;'));
-            assert.ok(result.includes('&quot;') || result.includes('"'));
-        });
-    });
-
-    describe('async version', () => {
-        it('should process simple HTML', async () => {
-            const input = {
-                html: '<html><body><p>Hello Async</p></body></html>'
-            };
-            const result = await mimeHtml.async(input);
-
-            assert.ok(result.includes('Hello Async'));
-            assert.ok(result.includes('<div'));
-        });
-
-        it('should handle timeout option', async () => {
-            const input = {
-                html: '<p>Quick test</p>'
-            };
-            const result = await mimeHtml.async(input, { timeout: 1000 });
-
-            assert.ok(result.includes('Quick test'));
-        });
-
-        it('should use worker pool by default', async () => {
-            const input = {
-                // juice, and with it the pool, only runs when there is a style sheet to inline
-                html: '<style>p { color: red; }</style><p>Pool test</p>'
-            };
-
-            const promises = [];
-            for (let i = 0; i < 5; i++) {
-                promises.push(mimeHtml.async(input));
-            }
-
-            const results = await Promise.all(promises);
-            assert.equal(results.length, 5);
-            results.forEach(result => {
-                assert.ok(result.includes('Pool test'));
-            });
-
-            const stats = mimeHtml.getWorkerPoolStats();
-            assert.ok(stats);
-            assert.ok(stats.totalWorkers >= 2);
-        });
-
-        it('should work without worker pool when disabled', async () => {
-            const input = {
-                html: '<p>No pool test</p>'
-            };
-            const result = await mimeHtml.async(input, { useWorkerPool: false });
-
-            assert.ok(result.includes('No pool test'));
-        });
-
-        it('should handle errors with fallback', async () => {
-            const input = {
-                html: '<p>Error test</p>'
-            };
-
-            // Even with errors, should return result with fallback
-            const result = await mimeHtml.async(input, {
-                fallbackOnError: true,
-                logErrors: false
-            });
-
-            assert.ok(typeof result === 'string');
-        });
-
-        it('should throw errors when fallback disabled', async () => {
-            // Create intentionally problematic scenario
-            const input = {
-                html: null // This will cause issues
-            };
-
-            try {
-                await mimeHtml.async(input, {
-                    fallbackOnError: false,
-                    logErrors: false
-                });
-                assert.fail('Should have thrown an error');
-            } catch (err) {
-                assert.ok(err);
-            }
-        });
-    });
-
-    describe('backward compatibility', () => {
-        it('should maintain default export compatibility', () => {
-            const input = {
-                html: '<p>Compatibility test</p>'
-            };
-
-            // Default export should work
-            const result = mimeHtml(input);
-            assert.ok(result.includes('Compatibility test'));
-        });
-
-        it('should have sync and async methods available', () => {
-            assert.equal(typeof mimeHtml.sync, 'function');
-            assert.equal(typeof mimeHtml.async, 'function');
-        });
-
-        it('should have worker pool management methods', () => {
-            assert.equal(typeof mimeHtml.closeWorkerPool, 'function');
-            assert.equal(typeof mimeHtml.getWorkerPoolStats, 'function');
-        });
-    });
-
-    describe('concurrent processing', () => {
-        it('should handle multiple concurrent requests', async () => {
-            const htmls = [];
-            for (let i = 0; i < 10; i++) {
-                htmls.push({
-                    html: `<p>Request ${i}</p>`
-                });
-            }
-
-            const promises = htmls.map((input, i) =>
-                mimeHtml.async(input).then(result => {
-                    assert.ok(result.includes(`Request ${i}`));
-                    return i;
-                })
-            );
-
-            const results = await Promise.all(promises);
-            assert.equal(results.length, 10);
-            assert.deepEqual(results, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-        });
-
-        it('should handle mixed content types concurrently', async () => {
-            const inputs = [
-                { html: '<p>HTML content</p>' },
-                { text: 'Plain text content' },
-                { html: '<div>Another HTML</div>' },
-                { text: 'More text\nWith newlines' }
-            ];
-
-            const results = await Promise.all(inputs.map(input => mimeHtml.async(input)));
-
-            assert.ok(results[0].includes('HTML content'));
-            assert.ok(results[1].includes('Plain text content'));
-            assert.ok(results[2].includes('Another HTML'));
-            assert.ok(results[3].includes('More text'));
-        });
-    });
-
-    // Clean up worker pool after all tests
-    after(async () => {
-        await mimeHtml.closeWorkerPool();
-    });
-});

package/test/text-to-html-extra.test.js

@@ -1,42 +0,0 @@
-'use strict';
-
-const { describe, it } = require('node:test');
-const assert = require('node:assert/strict');
-const textToHtml = require('../lib/text-to-html');
-
-describe('text-to-html additional coverage', () => {
-    describe('trailing quoted lines', () => {
-        it('should handle text ending with quoted lines', () => {
-            const result = textToHtml('Normal line\n> Quoted at end\n> Still quoted');
-            assert.ok(result.includes('<blockquote'));
-            assert.ok(result.includes('Quoted at end'));
-            assert.ok(result.includes('Still quoted'));
-            assert.ok(result.includes('Normal line'));
-        });
-    });
-
-    describe('horizontal rule detection', () => {
-        it('should convert --- to <hr /> when followed by non-empty line', () => {
-            const result = textToHtml('Before\n---\nAfter');
-            assert.ok(result.includes('<hr />'));
-            assert.ok(result.includes('Before'));
-            assert.ok(result.includes('After'));
-        });
-
-        it('should convert --- to <hr /> when it is the last line', () => {
-            const result = textToHtml('Before\n---');
-            assert.ok(result.includes('<hr />'));
-            assert.ok(result.includes('Before'));
-        });
-
-        it('should convert ___ to <hr />', () => {
-            const result = textToHtml('Before\n___\nAfter');
-            assert.ok(result.includes('<hr />'));
-        });
-
-        it('should convert --- to <hr /> when followed by empty line', () => {
-            const result = textToHtml('Before\n---\n');
-            assert.ok(result.includes('<hr />'));
-        });
-    });
-});

package/test/worker-pool-extra.test.js

@@ -1,132 +0,0 @@
-'use strict';
-
-const { describe, it, before, after, afterEach } = require('node:test');
-const assert = require('node:assert/strict');
-const path = require('path');
-const fs = require('fs');
-const WorkerPool = require('../lib/worker-pool');
-
-const crashWorkerPath = path.join(__dirname, 'crash-test-worker.js');
-const crashWorkerCode = `
-'use strict';
-const { parentPort } = require('worker_threads');
-parentPort.on('message', (data) => {
-    if (data === 'crash') {
-        setTimeout(() => { throw new Error('intentional crash'); }, 0);
-    } else if (data === 'slow') {
-        setTimeout(() => {
-            parentPort.postMessage({ success: true, result: 'slow: ' + data });
-        }, 50);
-    } else {
-        parentPort.postMessage({ success: true, result: 'ok: ' + data });
-    }
-});
-`;
-
-describe('WorkerPool additional coverage', () => {
-    let pool;
-
-    before(() => {
-        fs.writeFileSync(crashWorkerPath, crashWorkerCode);
-    });
-
-    after(() => {
-        try {
-            fs.unlinkSync(crashWorkerPath);
-        } catch (_err) {
-            // ignore cleanup errors
-        }
-    });
-
-    afterEach(async () => {
-        if (pool) {
-            await pool.close();
-            pool = null;
-        }
-    });
-
-    describe('worker error handling', () => {
-        it('should replace a crashed worker and remain functional', async () => {
-            pool = new WorkerPool({
-                workerPath: crashWorkerPath,
-                minWorkers: 2,
-                maxWorkers: 3
-            });
-
-            // Verify initial state
-            let stats = pool.getStats();
-            assert.equal(stats.totalWorkers, 2);
-
-            // Trigger a crash
-            try {
-                await pool.process('crash');
-                assert.fail('Should have rejected');
-            } catch (err) {
-                assert.ok(err);
-            }
-
-            // Wait for replacement worker to be created
-            await new Promise(r => setTimeout(r, 300));
-
-            // Pool should have replaced the crashed worker
-            stats = pool.getStats();
-            assert.ok(stats.totalWorkers >= 2, `Expected >= 2 workers but got ${stats.totalWorkers}`);
-
-            // Pool should still be functional
-            const result = await pool.process('hello');
-            assert.equal(result, 'ok: hello');
-        });
-    });
-
-    describe('idle timeout', () => {
-        it('should terminate idle worker above minimum via _setupIdleTimeout', async () => {
-            pool = new WorkerPool({
-                workerPath: crashWorkerPath,
-                minWorkers: 1,
-                maxWorkers: 3,
-                idleTimeout: 200
-            });
-
-            assert.equal(pool.getStats().totalWorkers, 1);
-
-            // Manually create an extra worker above minWorkers (without a task).
-            // This triggers _setupIdleTimeout in _createWorker.
-            pool._createWorker();
-
-            assert.equal(pool.getStats().totalWorkers, 2);
-
-            // Wait for idle timeout to fire and remove the extra worker
-            await new Promise(r => setTimeout(r, 400));
-
-            assert.equal(pool.getStats().totalWorkers, 1);
-        });
-    });
-
-    describe('close with active idle timeouts', () => {
-        it('should close cleanly when workers have pending idle timeouts', async () => {
-            pool = new WorkerPool({
-                workerPath: crashWorkerPath,
-                minWorkers: 1,
-                maxWorkers: 3,
-                idleTimeout: 10000
-            });
-
-            // Scale up
-            const promises = [];
-            for (let i = 0; i < 3; i++) {
-                promises.push(pool.process(`task-${i}`));
-            }
-            await Promise.all(promises);
-
-            // Workers above min should have idle timeouts set
-            let stats = pool.getStats();
-            assert.ok(stats.totalWorkers > 1);
-
-            // Close immediately before idle timeout fires
-            await pool.close();
-            pool = null;
-
-            // Should not throw or leak timers
-        });
-    });
-});

package/test/worker-pool-regression.test.js

@@ -1,128 +0,0 @@
-'use strict';
-
-const { describe, it, after: _after } = require('node:test');
-const assert = require('node:assert/strict');
-const WorkerPool = require('../lib/worker-pool');
-const path = require('path');
-
-// Test for the worker pool free list regression fix
-describe('Worker Pool Regression Tests', () => {
-    describe('free workers list management', () => {
-        it('should properly return workers to free list after completion', async () => {
-            // Create a simple test worker
-            const fs = require('fs');
-            const workerPath = path.join(__dirname, 'test-regression-worker.js');
-            const workerCode = `
-                const { parentPort } = require('worker_threads');
-                parentPort.on('message', (data) => {
-                    setTimeout(() => {
-                        parentPort.postMessage({ success: true, result: data });
-                    }, 10);
-                });
-            `;
-            fs.writeFileSync(workerPath, workerCode);
-
-            try {
-                const pool = new WorkerPool({
-                    workerPath,
-                    minWorkers: 2,
-                    maxWorkers: 4
-                });
-
-                // Initial state check
-                let stats = pool.getStats();
-                assert.equal(stats.totalWorkers, 2);
-                assert.equal(stats.freeWorkers, 2);
-                assert.equal(stats.busyWorkers, 0);
-
-                // Process multiple tasks concurrently
-                const promises = [];
-                for (let i = 0; i < 10; i++) {
-                    promises.push(pool.process(`task ${i}`));
-                }
-
-                // Wait for all to complete
-                const results = await Promise.all(promises);
-
-                // All tasks should complete successfully
-                assert.equal(results.length, 10);
-                results.forEach((result, i) => {
-                    assert.equal(result, `task ${i}`);
-                });
-
-                // After completion, all workers should be free
-                stats = pool.getStats();
-                assert.equal(stats.busyWorkers, 0);
-                assert.equal(stats.freeWorkers, stats.totalWorkers);
-
-                // Process another batch to ensure workers are reusable
-                const secondBatch = [];
-                for (let i = 0; i < 5; i++) {
-                    secondBatch.push(pool.process(`second ${i}`));
-                }
-
-                const secondResults = await Promise.all(secondBatch);
-                assert.equal(secondResults.length, 5);
-
-                // Workers should still be properly managed
-                stats = pool.getStats();
-                assert.equal(stats.busyWorkers, 0);
-                assert.equal(stats.freeWorkers, stats.totalWorkers);
-
-                await pool.close();
-            } finally {
-                // Clean up test worker
-                const fs = require('fs');
-                try {
-                    fs.unlinkSync(workerPath);
-                } catch (_err) {
-                    // Ignore cleanup errors
-                }
-            }
-        });
-
-        it('should not have duplicate workers in free list', async () => {
-            const fs = require('fs');
-            const workerPath = path.join(__dirname, 'test-dup-worker.js');
-            const workerCode = `
-                const { parentPort } = require('worker_threads');
-                parentPort.on('message', (data) => {
-                    setTimeout(() => {
-                        parentPort.postMessage({ success: true, result: data });
-                    }, 5);
-                });
-            `;
-            fs.writeFileSync(workerPath, workerCode);
-
-            try {
-                const pool = new WorkerPool({
-                    workerPath,
-                    minWorkers: 1,
-                    maxWorkers: 2
-                });
-
-                // Process tasks to trigger worker management
-                const results = await Promise.all([pool.process('A'), pool.process('B'), pool.process('C')]);
-
-                assert.equal(results.length, 3);
-
-                // Check that free workers count matches actual workers
-                const stats = pool.getStats();
-                assert.ok(stats.freeWorkers <= stats.totalWorkers);
-                assert.equal(stats.busyWorkers, 0);
-
-                // The sum should always equal total
-                assert.equal(stats.busyWorkers + stats.freeWorkers, stats.totalWorkers);
-
-                await pool.close();
-            } finally {
-                const fs = require('fs');
-                try {
-                    fs.unlinkSync(workerPath);
-                } catch (_err) {
-                    // Ignore
-                }
-            }
-        });
-    });
-});