@postalsys/email-text-tools 2.4.26 → 2.6.0

package/{lib → dist/esm/lib}/text-to-html.js

@@ -1,28 +1,21 @@
-'use strict';
-
-const linkifyIt = require('linkify-it');
-const tlds = require('tlds');
-const he = require('he');
-
-const linkify = linkifyIt()
-    .tlds(tlds) // Reload with full tlds list
+import LinkifyIt from 'linkify-it';
+import he from 'he';
+import { TLDS } from './commonjs.cjs';
+const linkify = new LinkifyIt()
+    .tlds(TLDS) // Reload with full tlds list
     .tlds('onion', true) // Add unofficial `.onion` domain
     .add('git:', 'http:') // Add `git:` protocol as "alias"
     .set({ fuzzyIP: true });
-
 // Quote levels deeper than this are kept as literal "> " text. Every level costs a few stack
 // frames here and a nested <blockquote> later, so hostile input with thousands of leading ">"
 // used to overflow the stack.
 const MAX_QUOTE_DEPTH = 100;
-
 function generateQuotedTree(text) {
     let lines = text.split(/\r?\n/);
-
     let tree = {
         type: 'text',
         children: []
     };
-
     let createNode = (parent, type) => {
         let node = {
             parent,
@@ -33,7 +26,6 @@ function generateQuotedTree(text) {
         parent.children.push(node);
         return node;
     };
-
     let walkNode = (curNode, lines, depth) => {
         for (let line of lines) {
             if (depth < MAX_QUOTE_DEPTH && /^>/.test(line)) {
@@ -41,41 +33,34 @@ function generateQuotedTree(text) {
                     curNode = createNode(curNode.parent, 'quote');
                 }
                 curNode.lines.push(line.replace(/^> ?/, ''));
-            } else if (curNode.type === 'quote') {
+            }
+            else if (curNode.type === 'quote') {
                 // process child
-
                 let quoteNode = curNode;
-
                 let childNode = createNode(curNode, 'text');
                 walkNode(childNode, quoteNode.lines, depth + 1);
-
                 curNode = createNode(curNode.parent, 'text');
                 curNode.lines.push(line);
-            } else {
+            }
+            else {
                 curNode.lines.push(line);
             }
         }
-
         if (curNode.type === 'quote') {
             // process child
-
             let quoteNode = curNode;
-
             let childNode = createNode(curNode, 'text');
             walkNode(childNode, quoteNode.lines, depth + 1);
         }
     };
-
     let rootNode = createNode(tree, 'text');
     walkNode(rootNode, lines, 0);
-
     return tree;
 }
-
 /**
  * Return HTML escaped text with clickable links
- * @param {String} text Text content to HTML escape
- * @returns {String} HTML escaped content
+ * @param text Text content to HTML escape
+ * @returns HTML escaped content
  */
 function linkifyAndHtmlEscape(text) {
     try {
@@ -94,56 +79,55 @@ function linkifyAndHtmlEscape(text) {
                 parts.push(Object.assign({ type: 'link' }, link));
                 cursor = link.lastIndex;
             }
-
             if (cursor < text.length) {
                 parts.push({
                     type: 'text',
-                    content: text.substr(cursor)
+                    content: text.slice(cursor)
                 });
             }
-
             return parts
                 .map(part => {
-                    switch (part.type) {
-                        case 'text': {
-                            // normal text, escape HTML
-                            return he.encode(part.content, { useNamedReferences: true });
-                        }
-                        case 'link':
-                            // URL with html escaped text content and URL
-                            return `<a href="${he.encode(part.url, { useNamedReferences: true })}">${he.encode(part.text, {
-                                useNamedReferences: true
-                            })}</a>`;
+                switch (part.type) {
+                    case 'text': {
+                        // normal text, escape HTML
+                        return he.encode(part.content, { useNamedReferences: true });
                     }
-                    return '';
-                })
+                    case 'link':
+                        // URL with html escaped text content and URL
+                        return `<a href="${he.encode(part.url, { useNamedReferences: true })}">${he.encode(part.text, {
+                            useNamedReferences: true
+                        })}</a>`;
+                }
+                return '';
+            })
                 .join('');
         }
-    } catch (_err) {
+    }
+    catch (_err) {
         // ignore?
     }
-
     // No links or exception, so HTML escape everything
     return he.encode(text, { useNamedReferences: true });
 }
-
 function textLinesToHtml(lines) {
     let textparts = ['<p>'];
     for (let i = 0; i < lines.length; i++) {
         let line = lines[i];
-
         if (!line.trim()) {
             if (i && lines[i - 1].trim()) {
                 textparts.push('</p><p>');
             }
-        } else if (i < lines.length - 1 && lines[i + 1].trim()) {
+        }
+        else if (i < lines.length - 1 && lines[i + 1].trim()) {
             let escaped = linkifyAndHtmlEscape(line);
             if (/^[ \t]*[-_]{2,}[ \t]*$/.test(escaped)) {
                 textparts.push(`<hr />`);
-            } else {
+            }
+            else {
                 textparts.push(`${escaped}<br />`);
             }
-        } else {
+        }
+        else {
             let escaped = linkifyAndHtmlEscape(line);
             if (/^[ \t]*[-_]{2,}[ \t]*$/.test(escaped)) {
                 escaped = `<hr />`;
@@ -151,19 +135,15 @@ function textLinesToHtml(lines) {
             textparts.push(escaped);
         }
     }
-
     return textparts.join('\n') + '</p>';
 }
-
-function textToHtml(text) {
+export default function textToHtml(text) {
     text = (text || '').toString();
     let tree = generateQuotedTree(text);
-
     let blockQuoteCounter = 0;
     function processQuotedNode(curNode, level) {
         let entries = [];
         level = (level || 0) + 1;
-
         if (curNode.type === 'text') {
             for (let child of curNode.children) {
                 let content = processQuotedNode(child);
@@ -171,32 +151,24 @@ function textToHtml(text) {
                     entries.push(content);
                 }
             }
-
             if (curNode.lines && curNode.lines.length) {
                 entries.push(textLinesToHtml(curNode.lines));
             }
         }
-
         if (curNode.type === 'quote') {
             for (let child of curNode.children) {
                 let content = processQuotedNode(child, level);
                 if (typeof content === 'string') {
                     let id = ++blockQuoteCounter;
-                    entries.push(
-                        `<blockquote type="cite" class="ee-block-${level}"><!-- blocquote ${id} start-->${content}</blockquote><!-- blocquote ${id} end-->`
-                    );
+                    entries.push(`<blockquote type="cite" class="ee-block-${level}"><!-- blocquote ${id} start-->${content}</blockquote><!-- blocquote ${id} end-->`);
                 }
             }
         }
-
         if (entries.length) {
             return entries.join('\n');
         }
+        return undefined;
     }
-
     let generatedHtml = processQuotedNode(tree);
-
     return generatedHtml;
 }
-
-module.exports = textToHtml;

package/dist/esm/lib/worker-pool.d.ts

@@ -0,0 +1,61 @@
+import { EventEmitter } from 'node:events';
+import { Worker } from 'node:worker_threads';
+export interface WorkerPoolOptions {
+    /** Worker script, defaults to the juice worker */
+    workerPath?: string | URL | undefined;
+    minWorkers?: number | undefined;
+    maxWorkers?: number | undefined;
+    maxQueueSize?: number | undefined;
+    /** Default task timeout in milliseconds */
+    workerTimeout?: number | undefined;
+    /** How long a worker above the minimum may stay idle, in milliseconds */
+    idleTimeout?: number | undefined;
+}
+export interface WorkerPoolStats {
+    totalWorkers: number;
+    busyWorkers: number;
+    freeWorkers: number;
+    queuedTasks: number;
+    minWorkers: number;
+    maxWorkers: number;
+}
+interface Task {
+    data: unknown;
+    resolve: (result: any) => void;
+    reject: (err: Error) => void;
+    timeout: number;
+}
+interface WorkerInfo {
+    worker: Worker;
+    busy: boolean;
+    lastUsed: number;
+    timeoutHandle: NodeJS.Timeout | null;
+    currentTask: (Task & {
+        timeoutHandle: NodeJS.Timeout;
+    }) | null;
+}
+export default class WorkerPool extends EventEmitter {
+    workerPath: string | URL;
+    minWorkers: number;
+    maxWorkers: number;
+    maxQueueSize: number;
+    workerTimeout: number;
+    idleTimeout: number;
+    workers: WorkerInfo[];
+    freeWorkers: WorkerInfo[];
+    queue: Task[];
+    closing: boolean;
+    constructor(options?: WorkerPoolOptions);
+    _initWorkers(): void;
+    _createWorker(): WorkerInfo | null;
+    _setupIdleTimeout(workerInfo: WorkerInfo): void;
+    _removeWorker(workerInfo: WorkerInfo): void;
+    process(data: unknown, options?: {
+        timeout?: number | undefined;
+    }): Promise<any>;
+    _executeTask(workerInfo: WorkerInfo, task: Task): void;
+    _processQueue(): void;
+    close(): Promise<void>;
+    getStats(): WorkerPoolStats;
+}
+export {};

package/{lib → dist/esm/lib}/worker-pool.js

@@ -1,38 +1,30 @@
-'use strict';
-
-const { Worker } = require('worker_threads');
-const path = require('path');
-const { EventEmitter } = require('events');
-
-class WorkerPool extends EventEmitter {
+import { EventEmitter } from 'node:events';
+import { Worker } from 'node:worker_threads';
+import { JUICE_WORKER_PATH } from './commonjs.cjs';
+export default class WorkerPool extends EventEmitter {
     constructor(options = {}) {
         super();
-
-        this.workerPath = options.workerPath || path.join(__dirname, 'juice-worker.js');
+        this.workerPath = options.workerPath || JUICE_WORKER_PATH;
         this.minWorkers = options.minWorkers || 2;
         this.maxWorkers = options.maxWorkers || 4;
         this.maxQueueSize = options.maxQueueSize || 100;
         this.workerTimeout = options.workerTimeout || 10000;
         this.idleTimeout = options.idleTimeout || 30000;
-
         this.workers = [];
         this.freeWorkers = [];
         this.queue = [];
         this.closing = false;
-
         // Initialize minimum number of workers
         this._initWorkers();
     }
-
     _initWorkers() {
         for (let i = 0; i < this.minWorkers; i++) {
             this._createWorker();
         }
     }
-
     _createWorker() {
-        if (this.closing) return null;
-
+        if (this.closing)
+            return null;
         const worker = new Worker(this.workerPath);
         const workerInfo = {
             worker,
@@ -41,174 +33,145 @@ class WorkerPool extends EventEmitter {
             timeoutHandle: null,
             currentTask: null
         };
-
-        worker.on('message', msg => {
+        worker.on('message', (msg) => {
             if (workerInfo.currentTask) {
                 const { resolve, reject, timeoutHandle } = workerInfo.currentTask;
                 clearTimeout(timeoutHandle);
-
                 if (msg.success) {
                     resolve(msg.result);
-                } else {
+                }
+                else {
                     reject(new Error(msg.error));
                 }
-
                 workerInfo.currentTask = null;
                 workerInfo.busy = false;
                 workerInfo.lastUsed = Date.now();
-
                 // Add worker back to free list if not already there
                 if (!this.freeWorkers.includes(workerInfo)) {
                     this.freeWorkers.push(workerInfo);
                 }
-
                 // Process next item in queue
                 this._processQueue();
             }
         });
-
-        worker.on('error', err => {
+        worker.on('error', (err) => {
             if (workerInfo.currentTask) {
                 const { reject, timeoutHandle } = workerInfo.currentTask;
                 clearTimeout(timeoutHandle);
                 reject(err);
                 workerInfo.currentTask = null;
             }
-
             // Remove failed worker
             const index = this.workers.indexOf(workerInfo);
             if (index > -1) {
                 this.workers.splice(index, 1);
             }
-
             const freeIndex = this.freeWorkers.indexOf(workerInfo);
             if (freeIndex > -1) {
                 this.freeWorkers.splice(freeIndex, 1);
             }
-
             // Create replacement if below minimum
             if (this.workers.length < this.minWorkers && !this.closing) {
                 this._createWorker();
             }
-
             // Process queue with remaining workers
             this._processQueue();
         });
-
         worker.on('exit', () => {
             // Clean up worker references
             const index = this.workers.indexOf(workerInfo);
             if (index > -1) {
                 this.workers.splice(index, 1);
             }
-
             const freeIndex = this.freeWorkers.indexOf(workerInfo);
             if (freeIndex > -1) {
                 this.freeWorkers.splice(freeIndex, 1);
             }
         });
-
         this.workers.push(workerInfo);
         this.freeWorkers.push(workerInfo);
-
         // Set up idle timeout for workers above minimum
         if (this.workers.length > this.minWorkers) {
             this._setupIdleTimeout(workerInfo);
         }
-
         return workerInfo;
     }
-
     _setupIdleTimeout(workerInfo) {
         if (workerInfo.timeoutHandle) {
             clearTimeout(workerInfo.timeoutHandle);
         }
-
         workerInfo.timeoutHandle = setTimeout(() => {
             if (!workerInfo.busy && this.workers.length > this.minWorkers) {
                 this._removeWorker(workerInfo);
             }
         }, this.idleTimeout);
     }
-
     _removeWorker(workerInfo) {
         const index = this.workers.indexOf(workerInfo);
         if (index > -1) {
             this.workers.splice(index, 1);
         }
-
         const freeIndex = this.freeWorkers.indexOf(workerInfo);
         if (freeIndex > -1) {
             this.freeWorkers.splice(freeIndex, 1);
         }
-
         if (workerInfo.timeoutHandle) {
             clearTimeout(workerInfo.timeoutHandle);
         }
-
-        workerInfo.worker.terminate();
+        void workerInfo.worker.terminate();
     }
-
     async process(data, options = {}) {
         if (this.closing) {
             throw new Error('Worker pool is closing');
         }
-
         const timeout = options.timeout || this.workerTimeout;
-
         return new Promise((resolve, reject) => {
             const task = { data, resolve, reject, timeout };
-
             // Try to get a free worker
             const workerInfo = this.freeWorkers.shift();
-
             if (workerInfo) {
                 this._executeTask(workerInfo, task);
-            } else if (this.workers.length < this.maxWorkers) {
+            }
+            else if (this.workers.length < this.maxWorkers) {
                 // Create new worker if below max
                 const newWorker = this._createWorker();
                 if (newWorker) {
                     this.freeWorkers.shift(); // Remove from free list
                     this._executeTask(newWorker, task);
                 }
-            } else if (this.queue.length < this.maxQueueSize) {
+            }
+            else if (this.queue.length < this.maxQueueSize) {
                 // Queue the task
                 this.queue.push(task);
-            } else {
+            }
+            else {
                 reject(new Error('Worker pool queue is full'));
             }
         });
     }
-
     _executeTask(workerInfo, task) {
         workerInfo.busy = true;
         workerInfo.lastUsed = Date.now();
-
         // Clear idle timeout while working
         if (workerInfo.timeoutHandle) {
             clearTimeout(workerInfo.timeoutHandle);
             workerInfo.timeoutHandle = null;
         }
-
         // Set up task timeout
         const timeoutHandle = setTimeout(() => {
             task.reject(new Error(`Worker task timed out after ${task.timeout}ms`));
             workerInfo.currentTask = null;
             workerInfo.busy = false;
-
             // Terminate and replace the worker
             this._removeWorker(workerInfo);
             if (this.workers.length < this.minWorkers && !this.closing) {
                 this._createWorker();
             }
-
             this._processQueue();
         }, task.timeout);
-
         workerInfo.currentTask = { ...task, timeoutHandle };
         workerInfo.worker.postMessage(task.data);
     }
-
     _processQueue() {
         if (this.queue.length === 0) {
             // Mark free workers and set up idle timeouts
@@ -222,7 +185,6 @@ class WorkerPool extends EventEmitter {
             });
             return;
         }
-
         const workerInfo = this.freeWorkers.shift();
         if (workerInfo) {
             const task = this.queue.shift();
@@ -231,16 +193,13 @@ class WorkerPool extends EventEmitter {
             }
         }
     }
-
     async close() {
         this.closing = true;
-
         // Clear the queue
         while (this.queue.length > 0) {
             const task = this.queue.shift();
             task.reject(new Error('Worker pool is closing'));
         }
-
         // Terminate all workers
         const terminatePromises = this.workers.map(workerInfo => {
             if (workerInfo.timeoutHandle) {
@@ -248,13 +207,10 @@ class WorkerPool extends EventEmitter {
             }
             return workerInfo.worker.terminate();
         });
-
         await Promise.all(terminatePromises);
-
         this.workers = [];
         this.freeWorkers = [];
     }
-
     getStats() {
         return {
             totalWorkers: this.workers.length,
@@ -266,5 +222,3 @@ class WorkerPool extends EventEmitter {
         };
     }
 }
-
-module.exports = WorkerPool;

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/package.json

@@ -1,18 +1,69 @@
 {
     "name": "@postalsys/email-text-tools",
-    "version": "2.4.26",
+    "version": "2.6.0",
     "description": "Email text tools",
-    "main": "index.js",
+    "type": "module",
+    "main": "./dist/cjs/index.js",
+    "types": "./dist/cjs/index.d.ts",
+    "typesVersions": {
+        "*": {
+            "lib/*": [
+                "dist/cjs/lib/*"
+            ],
+            "index": [
+                "dist/cjs/index.d.ts"
+            ],
+            "index.js": [
+                "dist/cjs/index.d.ts"
+            ]
+        }
+    },
+    "exports": {
+        ".": {
+            "import": "./dist/esm/index.js",
+            "require": "./dist/cjs/index.js"
+        },
+        "./index": {
+            "import": "./dist/esm/index.js",
+            "require": "./dist/cjs/index.js"
+        },
+        "./index.js": {
+            "import": "./dist/esm/index.js",
+            "require": "./dist/cjs/index.js"
+        },
+        "./lib/*.js": {
+            "import": "./dist/esm/lib/*.js",
+            "require": "./dist/cjs/lib/*.js"
+        },
+        "./lib/*": {
+            "import": "./dist/esm/lib/*.js",
+            "require": "./dist/cjs/lib/*.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE",
+        "CHANGELOG.md",
+        "SECURITY.md"
+    ],
     "scripts": {
-        "test": "node --test test/*.test.js",
-        "test:coverage": "node --test --experimental-test-coverage test/*.test.js",
-        "test:watch": "node --test --watch test/*.test.js",
-        "lint": "eslint .",
+        "build": "node scripts/build.js",
+        "typecheck": "tsc -p tsconfig.json",
+        "pretest": "npm run build",
+        "test": "node --test test/*.test.cjs test/package/*.test.cjs test/package/*.test.mjs",
+        "pretest:coverage": "npm run build",
+        "test:coverage": "node --test --experimental-test-coverage test/*.test.cjs",
+        "test:watch": "node --test --watch test/*.test.cjs",
+        "pretest:cjs": "npm run build",
+        "test:cjs": "NODE_OPTIONS=--no-experimental-require-module node --test test/*.test.cjs test/package/*.test.cjs",
+        "lint": "npm run typecheck && eslint .",
         "lint:fix": "eslint . --fix",
         "format": "prettier --write .",
         "format:check": "prettier --check .",
-        "update": "rm -rf node_modules package-lock.json && ncu -u && npm install",
-        "test:cjs": "NODE_OPTIONS=--no-experimental-require-module npm test"
+        "prepare": "npm run build",
+        "update": "rm -rf node_modules package-lock.json && ncu -u && npm install"
     },
     "repository": {
         "type": "git",
@@ -29,11 +80,17 @@
     },
     "homepage": "https://github.com/postalsys/email-text-tools#readme",
     "devDependencies": {
-        "@eslint/js": "10.0.1",
+        "@types/he": "1.2.3",
+        "@types/html-to-text": "9.0.4",
+        "@types/jsdom": "27.0.0",
+        "@types/linkify-it": "5.0.0",
+        "@types/node": "20.19.43",
         "eslint": "10.13.0",
         "eslint-config-prettier": "10.1.8",
         "globals": "17.13.0",
-        "prettier": "3.9.10"
+        "prettier": "3.9.10",
+        "typescript": "6.0.3",
+        "typescript-eslint": "8.71.2"
     },
     "dependencies": {
         "@postalsys/email-content": "0.1.17",