@postalsys/email-text-tools 2.4.26 → 2.6.0

package/test/comprehensive.test.js

@@ -1,358 +0,0 @@
-'use strict';
-
-const { describe, it, before: _before, after } = require('node:test');
-const assert = require('node:assert/strict');
-const mimeHtml = require('../lib/mime-html');
-const textToHtml = require('../lib/text-to-html');
-const _fs = require('fs');
-const path = require('path');
-const { Worker } = require('worker_threads');
-
-describe('Comprehensive Test Suite', () => {
-    describe('text-to-html conversion', () => {
-        it('should convert plain text to HTML', () => {
-            const text = 'Hello World\nThis is a test';
-            const html = textToHtml(text);
-
-            assert.ok(html.includes('Hello World'));
-            assert.ok(html.includes('<br'));
-            assert.ok(html.includes('This is a test'));
-        });
-
-        it('should handle quoted text', () => {
-            const text = 'Normal text\n> Quoted text\n> More quoted\nNormal again';
-            const html = textToHtml(text);
-
-            assert.ok(html.includes('blockquote'));
-            assert.ok(html.includes('Quoted text'));
-            assert.ok(html.includes('Normal again'));
-        });
-
-        it('should linkify URLs', () => {
-            const text = 'Visit https://example.com for more info';
-            const html = textToHtml(text);
-
-            assert.ok(html.includes('<a'));
-            assert.ok(html.includes('href='));
-            assert.ok(html.includes('https://example.com'));
-        });
-
-        it('should linkify bare domains without a scheme', () => {
-            // linkify-it 6 stopped doing this by default, which silently dropped
-            // autolinking for plain text emails, so keep it covered
-            const html = textToHtml('Visit example.com and www.example.org today');
-
-            assert.ok(html.includes('<a href="http://example.com">example.com</a>'));
-            assert.ok(html.includes('<a href="http://www.example.org">www.example.org</a>'));
-        });
-
-        it('should handle email addresses', () => {
-            const text = 'Contact me at test@example.com';
-            const html = textToHtml(text);
-
-            assert.ok(html.includes('mailto:'));
-            assert.ok(html.includes('test@example.com'));
-        });
-
-        it('should escape HTML entities', () => {
-            const text = 'Test <script>alert("xss")</script> & special chars';
-            const html = textToHtml(text);
-
-            assert.ok(!html.includes('<script>'));
-            assert.ok(html.includes('&lt;script'));
-            assert.ok(html.includes('&amp;'));
-        });
-
-        it('should handle empty text', () => {
-            const html = textToHtml('');
-            assert.ok(typeof html === 'string');
-        });
-
-        it('should handle null/undefined', () => {
-            const html1 = textToHtml(null);
-            const html2 = textToHtml(undefined);
-            const html3 = textToHtml('');
-
-            // textToHtml returns minimal HTML for empty input
-            assert.ok(typeof html1 === 'string');
-            assert.ok(typeof html2 === 'string');
-            assert.ok(typeof html3 === 'string');
-            // Should return consistent output for all empty inputs
-            assert.equal(html1, html2);
-            assert.equal(html2, html3);
-        });
-    });
-
-    describe('juice-worker.js', () => {
-        it('should process HTML in worker thread', async () => {
-            const worker = new Worker(path.join(__dirname, '../lib/juice-worker.js'));
-
-            const html = '<style>p { color: red; }</style><p>Test</p>';
-
-            const result = await new Promise((resolve, reject) => {
-                worker.on('message', msg => {
-                    worker.terminate();
-                    if (msg.success) {
-                        resolve(msg.result);
-                    } else {
-                        reject(new Error(msg.error));
-                    }
-                });
-
-                worker.on('error', reject);
-                worker.postMessage(html);
-            });
-
-            assert.ok(result.includes('style='));
-            assert.ok(result.includes('Test'));
-        });
-
-        it('should handle worker errors gracefully', async () => {
-            const worker = new Worker(path.join(__dirname, '../lib/juice-worker.js'));
-
-            // Send invalid data that should cause an error
-            const invalidData = null;
-
-            try {
-                await new Promise((resolve, reject) => {
-                    worker.on('message', msg => {
-                        worker.terminate();
-                        if (msg.success) {
-                            resolve(msg.result);
-                        } else {
-                            reject(new Error(msg.error));
-                        }
-                    });
-
-                    worker.on('error', reject);
-                    worker.postMessage(invalidData);
-                });
-
-                // If we get here without error, that's also OK
-                assert.ok(true);
-            } catch (err) {
-                // Expected to error
-                assert.ok(err);
-            }
-        });
-    });
-
-    describe('mime-html with text input', () => {
-        it('should properly convert text to HTML with default styles', () => {
-            const input = {
-                text: 'Hello\nWorld\n\nThis is a test'
-            };
-
-            const result = mimeHtml.sync(input);
-
-            assert.ok(result.includes('Hello'));
-            assert.ok(result.includes('World'));
-            assert.ok(result.includes('font-family')); // Default styles applied
-        });
-
-        it('should handle quoted text in text mode', () => {
-            const input = {
-                text: 'Reply:\n> Original message\n> Second line\n\nMy response'
-            };
-
-            const result = mimeHtml.sync(input);
-
-            assert.ok(result.includes('blockquote'));
-            assert.ok(result.includes('Original message'));
-        });
-    });
-
-    describe('error recovery and edge cases', () => {
-        it('should handle circular references in DOM', () => {
-            // This tests the DOM walking logic
-            const input = {
-                html: '<div><p>Test</p></div>'
-            };
-
-            const result = mimeHtml.sync(input);
-            assert.ok(result.includes('Test'));
-        });
-
-        it('should handle very long attribute values', () => {
-            const longValue = 'x'.repeat(10000);
-            const input = {
-                html: `<div data-test="${longValue}">Content</div>`
-            };
-
-            const result = mimeHtml.sync(input);
-            assert.ok(result.includes('Content'));
-        });
-
-        it('should handle style tags in body', () => {
-            const input = {
-                html: `
-                    <body>
-                        <style>p { color: red; }</style>
-                        <p>Test</p>
-                        <style>div { color: blue; }</style>
-                        <div>More</div>
-                    </body>
-                `
-            };
-
-            const result = mimeHtml.sync(input);
-            assert.ok(result.includes('Test'));
-            assert.ok(result.includes('More'));
-            // Style tags in body should be removed
-            assert.ok(!result.includes('<style'));
-        });
-
-        it('should handle CDATA sections', () => {
-            const input = {
-                html: '<div><![CDATA[Some text]]></div>'
-            };
-
-            const result = mimeHtml.sync(input);
-            assert.ok(typeof result === 'string');
-        });
-
-        it('should handle XML namespaces', () => {
-            const input = {
-                html: '<html xmlns="http://www.w3.org/1999/xhtml"><body><p>Test</p></body></html>'
-            };
-
-            const result = mimeHtml.sync(input);
-            assert.ok(result.includes('Test'));
-        });
-    });
-
-    describe('async version configuration', () => {
-        it('should respect timeout configuration', async () => {
-            const input = {
-                html: '<p>Quick test</p>'
-            };
-
-            const start = Date.now();
-            const result = await mimeHtml.async(input, {
-                timeout: 100,
-                useWorkerPool: false
-            });
-            const elapsed = Date.now() - start;
-
-            assert.ok(result.includes('Quick test'));
-            // Should complete without timing out
-            assert.ok(elapsed < 200);
-        });
-
-        it('should respect logErrors configuration', async () => {
-            const input = {
-                html: null
-            };
-
-            // Capture console.warn
-            const originalWarn = console.warn;
-            let warnCalled = false;
-            console.warn = () => {
-                warnCalled = true;
-            };
-
-            await mimeHtml.async(input, {
-                logErrors: false,
-                fallbackOnError: true
-            });
-
-            console.warn = originalWarn;
-            assert.ok(!warnCalled, 'Should not log errors when logErrors is false');
-        });
-
-        it('should respect fallbackOnError configuration', async () => {
-            const input = {
-                html: '<p>Test</p>'
-            };
-
-            // With fallback
-            const result1 = await mimeHtml.async(input, {
-                fallbackOnError: true,
-                logErrors: false
-            });
-            assert.ok(typeof result1 === 'string');
-        });
-    });
-
-    describe('worker pool configuration', () => {
-        it('should respect min/max worker settings', 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 config test</p>'
-            };
-
-            // First close any existing pool
-            await mimeHtml.closeWorkerPool();
-
-            // Process with custom pool settings
-            await mimeHtml.async(input, {
-                useWorkerPool: true,
-                minWorkers: 1,
-                maxWorkers: 2
-            });
-
-            const stats = mimeHtml.getWorkerPoolStats();
-            assert.ok(stats);
-            assert.equal(stats.minWorkers, 1);
-            assert.equal(stats.maxWorkers, 2);
-        });
-    });
-
-    describe('concurrent stress test', () => {
-        it('should handle rapid concurrent requests without deadlock', async () => {
-            const promises = [];
-
-            // Fire off 50 concurrent requests rapidly
-            for (let i = 0; i < 50; i++) {
-                promises.push(
-                    mimeHtml.async(
-                        {
-                            html: `<p>Stress test ${i}</p>`
-                        },
-                        {
-                            useWorkerPool: true,
-                            timeout: 5000
-                        }
-                    )
-                );
-            }
-
-            const results = await Promise.all(promises);
-
-            assert.equal(results.length, 50);
-            results.forEach((result, i) => {
-                assert.ok(result.includes(`Stress test ${i}`));
-            });
-        });
-    });
-
-    describe('memory leak prevention', () => {
-        it('should clean up workers after timeout', async () => {
-            const input = {
-                // a style sheet, so the juice worker actually runs and times out
-                html: '<style>p { color: red; }</style><p>Timeout test</p>'
-            };
-
-            try {
-                // This should timeout and clean up the worker
-                await mimeHtml.async(input, {
-                    timeout: 1,
-                    useWorkerPool: false,
-                    fallbackOnError: false,
-                    logErrors: false
-                });
-            } catch (err) {
-                assert.ok(err.message.includes('timed out'));
-            }
-
-            // Worker should be cleaned up, no leak
-            const memAfter = process.memoryUsage();
-            assert.ok(memAfter.heapUsed < 500 * 1024 * 1024); // Less than 500MB
-        });
-    });
-
-    // Clean up
-    after(async () => {
-        await mimeHtml.closeWorkerPool();
-    });
-});

package/test/containment.test.js

@@ -1,128 +0,0 @@
-'use strict';
-
-const { describe, it } = require('node:test');
-const assert = require('node:assert');
-const { mimeHtml } = require('..');
-
-// The message is shown inside a page that is not the sender's. These tests pin what keeps it there:
-// a clipping wrapper the sender cannot style, links that cannot reach back, no foreign content.
-
-describe('container', () => {
-    it('wraps a message with no body styles in a bare inner element', () => {
-        assert.equal(mimeHtml({ html: '<p>x</p>' }), '<div style="overflow: auto; contain: paint;"><div><p>x</p></div></div>');
-    });
-
-    it('keeps the body styles off the clipping wrapper', () => {
-        const html =
-            '<html><body style="display: contents; margin: -500px; overflow: visible; overflow-x: visible; box-shadow: 0 0 0 9999px red; outline: 9999px solid red; color: red">' +
-            '<div style="transform: translateY(-300px)">x</div></body></html>';
-        const out = mimeHtml({ html });
-        assert.ok(out.endsWith('</div></div>'), out);
-        const inner = /^<div style="overflow: auto; contain: paint;"><div style="([^"]*)">/.exec(out)[1];
-        assert.match(inner, /display: contents/);
-        assert.match(inner, /margin: -500px/);
-        assert.match(inner, /color: red/);
-        assert.match(out, /transform: translateY\(-300px\)/);
-    });
-
-    it('puts a body rule from the stylesheet on the inner element too', () => {
-        const html = '<html><head><style>body { display: contents; margin: -200px; } p { color: red; }</style></head><body><p>x</p></body></html>';
-        const out = mimeHtml({ html });
-        assert.ok(out.startsWith('<div style="overflow: auto; contain: paint;"><div style="'), out);
-        assert.match(out, /display: contents/);
-        assert.match(out, /color: red/);
-    });
-
-    it('drops the dimensions of the body and keeps its other styles', () => {
-        const out = mimeHtml({
-            html: '<html><body style="width: 600px; min-height: 100vh; max-width: 50%; background-color: #fff; color: red">x</body></html>'
-        });
-        assert.doesNotMatch(out, /width|height/);
-        assert.match(out, /background-color: (?:#fff|rgb\(255, 255, 255\))/);
-        assert.match(out, /color: red/);
-    });
-
-    it('drops a body width the CSSOM could not parse', () => {
-        // cssstyle parses nothing from this attribute, a browser reads the width
-        const out = mimeHtml({ html: '<html><body style="background:url(https://example.com/x.gif) no-repeat; width: 5000px">x</body></html>' });
-        assert.equal(out, '<div style="overflow: auto; contain: paint;"><div>x</div></div>');
-    });
-
-    it('keeps body styles the CSSOM could not parse when none of them is forbidden', () => {
-        // the old wrapper lost every body style here, because setting its overflow rewrote the
-        // attribute from a CSSOM that held nothing
-        const out = mimeHtml({ html: '<html><body style="background:url(https://example.com/x.gif) no-repeat; color:red; font:12px serif">x</body></html>' });
-        assert.ok(out.includes('<div style="background:url(https://example.com/x.gif) no-repeat; color:red; font:12px serif">x</div>'), out);
-    });
-
-    it('still removes position everywhere, including the body', () => {
-        const out = mimeHtml({ html: '<html><body style="position: fixed; inset: 0; color: red"><div style="position: sticky; top: 0">x</div></body></html>' });
-        assert.doesNotMatch(out, /position/);
-        assert.match(out, /color: red/);
-        assert.match(out, /top: 0/);
-    });
-
-    it('marks skipped inlining on the outer wrapper', () => {
-        let css = '';
-        for (let i = 0; i <= 5000; i++) {
-            css += `.c${i} { color: red; }\n`;
-        }
-        const out = mimeHtml({ html: `<html><head><style>${css}</style></head><body style="color: blue"><p class="c1">x</p></body></html>` });
-        assert.ok(out.startsWith('<div style="overflow: auto; contain: paint;" data-css-inlining="skipped"><div style="color: blue">'), out.slice(0, 120));
-    });
-});
-
-describe('links', () => {
-    it('opens every link in a new context that gets no opener and no referrer', () => {
-        const out = mimeHtml({ html: '<a href="https://example.com/" rel="opener">x</a><a href="https://example.com/" target="_top" rel="nofollow">y</a>' });
-        assert.equal((out.match(/<a /g) || []).length, 2);
-        assert.doesNotMatch(out, /rel="opener"|rel="nofollow"|_top/);
-        assert.equal((out.match(/target="_blank"/g) || []).length, 2);
-        assert.equal((out.match(/rel="noopener noreferrer"/g) || []).length, 2);
-    });
-
-    it('treats an image map area as a link', () => {
-        const out = mimeHtml({
-            html: '<img src="https://example.com/i.png" usemap="#m"><map name="m"><area shape="rect" coords="0,0,9,9" href="https://example.com/"></map>'
-        });
-        assert.match(out, /<area [^>]*target="_blank"/);
-        assert.match(out, /<area [^>]*rel="noopener noreferrer"/);
-    });
-});
-
-describe('foreign content', () => {
-    it('removes SVG and MathML', () => {
-        const out = mimeHtml({
-            html:
-                '<p>a</p><svg width="20" height="20"><circle cx="10" cy="10" r="8"/></svg><math><mi>x</mi></math>' +
-                '<math><mtext><table><mglyph><style><!--</style><img title="--><img src=1 onerror=alert(1)>"><p>b</p>'
-        });
-        assert.doesNotMatch(out, /<svg|<math|<circle|<mi|onerror/);
-        assert.ok(out.includes('<p>a</p>'), out);
-    });
-});
-
-describe('single sanitization pass for markup without a stylesheet', () => {
-    it('sanitizes the same way', () => {
-        const out = mimeHtml({
-            html: '<p onclick="x()">a</p><script>alert(1)</script><a href="javascript:alert(1)">b</a><iframe src="https://example.com/"></iframe>'
-        });
-        assert.equal(out, '<div style="overflow: auto; contain: paint;"><div><p>a</p><a target="_blank" rel="noopener noreferrer">b</a></div></div>');
-    });
-
-    for (const [label, tag, close] of [
-        ['upper case', '<STYLE>', '</STYLE>'],
-        ['whitespace after the name', '<style\n>', '</style>'],
-        ['a self-closing slash', '<style/>', '</style>']
-    ]) {
-        it(`still inlines a stylesheet whose tag uses ${label}`, () => {
-            const out = mimeHtml({ html: `<html><head>${tag}p { color: red; }${close}</head><body><p>x</p></body></html>` });
-            assert.match(out, /color: red/, out);
-        });
-    }
-
-    it('leaves a style tag that is only text alone', () => {
-        const out = mimeHtml({ html: '<p>write &lt;style&gt; to add rules</p>' });
-        assert.equal(out, '<div style="overflow: auto; contain: paint;"><div><p>write &lt;style&gt; to add rules</p></div></div>');
-    });
-});

package/test/edge-cases.test.js

@@ -1,62 +0,0 @@
-'use strict';
-
-const { describe, it, after } = require('node:test');
-const assert = require('node:assert/strict');
-const mimeHtml = require('../lib/mime-html');
-const fs = require('fs');
-const path = require('path');
-
-describe('Edge Cases', () => {
-    describe('large HTML', () => {
-        it('should handle large HTML', async () => {
-            const largeContent = '<p>' + 'x'.repeat(10000) + '</p>';
-            const result = await mimeHtml.async({ html: largeContent });
-            assert.ok(result.length > 0);
-        });
-    });
-
-    describe('special characters', () => {
-        it('should handle UTF-8', () => {
-            const result = mimeHtml.sync({ html: '<p>Hello 世界</p>' });
-            assert.ok(result.includes('Hello'));
-        });
-
-        it('should handle entities', () => {
-            const result = mimeHtml.sync({ html: '<p>&lt;&gt;&amp;</p>' });
-            assert.ok(result.includes('&lt;') || result.includes('<'));
-        });
-    });
-
-    describe('problematic CSS', () => {
-        it('should handle modern selectors', () => {
-            const html = `
-                <style>
-                    .test:is(.a) { color: red; }
-                </style>
-                <p class="test a">Test</p>
-            `;
-            const result = mimeHtml.sync({ html });
-            assert.ok(result.includes('Test'));
-        });
-    });
-
-    describe('real-world HTML', () => {
-        it('should process failing.html quickly', async () => {
-            const failingPath = path.join(__dirname, '../examples/failing.html');
-            if (fs.existsSync(failingPath)) {
-                const html = fs.readFileSync(failingPath, 'utf8');
-
-                const start = Date.now();
-                const result = await mimeHtml.async({ html });
-                const elapsed = Date.now() - start;
-
-                assert.ok(result.length > 0);
-                assert.ok(elapsed < 2000, `Took ${elapsed}ms`);
-            }
-        });
-    });
-
-    after(async () => {
-        await mimeHtml.closeWorkerPool();
-    });
-});