@postalsys/email-text-tools 2.4.26 → 2.5.0

package/dist/cjs/lib/text-to-html.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = textToHtml;
+const linkify_it_1 = __importDefault(require("linkify-it"));
+const he_1 = __importDefault(require("he"));
+const commonjs_cjs_1 = require("./commonjs.cjs");
+const linkify = new linkify_it_1.default()
+    .tlds(commonjs_cjs_1.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,
+            type,
+            lines: [],
+            children: []
+        };
+        parent.children.push(node);
+        return node;
+    };
+    let walkNode = (curNode, lines, depth) => {
+        for (let line of lines) {
+            if (depth < MAX_QUOTE_DEPTH && /^>/.test(line)) {
+                if (curNode.type !== 'quote') {
+                    curNode = createNode(curNode.parent, 'quote');
+                }
+                curNode.lines.push(line.replace(/^> ?/, ''));
+            }
+            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 {
+                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 text Text content to HTML escape
+ * @returns HTML escaped content
+ */
+function linkifyAndHtmlEscape(text) {
+    try {
+        let links = linkify.match(text);
+        if (links && links.length) {
+            let parts = [];
+            let cursor = 0;
+            for (let link of links) {
+                if (cursor < link.index) {
+                    parts.push({
+                        type: 'text',
+                        content: text.substring(cursor, link.index)
+                    });
+                    cursor = link.index;
+                }
+                parts.push(Object.assign({ type: 'link' }, link));
+                cursor = link.lastIndex;
+            }
+            if (cursor < text.length) {
+                parts.push({
+                    type: 'text',
+                    content: text.slice(cursor)
+                });
+            }
+            return parts
+                .map(part => {
+                switch (part.type) {
+                    case 'text': {
+                        // normal text, escape HTML
+                        return he_1.default.encode(part.content, { useNamedReferences: true });
+                    }
+                    case 'link':
+                        // URL with html escaped text content and URL
+                        return `<a href="${he_1.default.encode(part.url, { useNamedReferences: true })}">${he_1.default.encode(part.text, {
+                            useNamedReferences: true
+                        })}</a>`;
+                }
+                return '';
+            })
+                .join('');
+        }
+    }
+    catch (_err) {
+        // ignore?
+    }
+    // No links or exception, so HTML escape everything
+    return he_1.default.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()) {
+            let escaped = linkifyAndHtmlEscape(line);
+            if (/^[ \t]*[-_]{2,}[ \t]*$/.test(escaped)) {
+                textparts.push(`<hr />`);
+            }
+            else {
+                textparts.push(`${escaped}<br />`);
+            }
+        }
+        else {
+            let escaped = linkifyAndHtmlEscape(line);
+            if (/^[ \t]*[-_]{2,}[ \t]*$/.test(escaped)) {
+                escaped = `<hr />`;
+            }
+            textparts.push(escaped);
+        }
+    }
+    return textparts.join('\n') + '</p>';
+}
+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);
+                if (typeof content === 'string') {
+                    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-->`);
+                }
+            }
+        }
+        if (entries.length) {
+            return entries.join('\n');
+        }
+        return undefined;
+    }
+    let generatedHtml = processQuotedNode(tree);
+    return generatedHtml;
+}
+module.exports = exports.default;
+Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/dist/cjs/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/dist/cjs/lib/worker-pool.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_events_1 = require("node:events");
+const node_worker_threads_1 = require("node:worker_threads");
+const commonjs_cjs_1 = require("./commonjs.cjs");
+class WorkerPool extends node_events_1.EventEmitter {
+    constructor(options = {}) {
+        super();
+        this.workerPath = options.workerPath || commonjs_cjs_1.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;
+        const worker = new node_worker_threads_1.Worker(this.workerPath);
+        const workerInfo = {
+            worker,
+            busy: false,
+            lastUsed: Date.now(),
+            timeoutHandle: null,
+            currentTask: null
+        };
+        worker.on('message', (msg) => {
+            if (workerInfo.currentTask) {
+                const { resolve, reject, timeoutHandle } = workerInfo.currentTask;
+                clearTimeout(timeoutHandle);
+                if (msg.success) {
+                    resolve(msg.result);
+                }
+                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) => {
+            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);
+        }
+        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) {
+                // 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) {
+                // Queue the task
+                this.queue.push(task);
+            }
+            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
+            this.workers.forEach(workerInfo => {
+                if (!workerInfo.busy && !this.freeWorkers.includes(workerInfo)) {
+                    this.freeWorkers.push(workerInfo);
+                    if (this.workers.length > this.minWorkers) {
+                        this._setupIdleTimeout(workerInfo);
+                    }
+                }
+            });
+            return;
+        }
+        const workerInfo = this.freeWorkers.shift();
+        if (workerInfo) {
+            const task = this.queue.shift();
+            if (task) {
+                this._executeTask(workerInfo, task);
+            }
+        }
+    }
+    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) {
+                clearTimeout(workerInfo.timeoutHandle);
+            }
+            return workerInfo.worker.terminate();
+        });
+        await Promise.all(terminatePromises);
+        this.workers = [];
+        this.freeWorkers = [];
+    }
+    getStats() {
+        return {
+            totalWorkers: this.workers.length,
+            busyWorkers: this.workers.filter(w => w.busy).length,
+            freeWorkers: this.freeWorkers.length,
+            queuedTasks: this.queue.length,
+            minWorkers: this.minWorkers,
+            maxWorkers: this.maxWorkers
+        };
+    }
+}
+exports.default = WorkerPool;
+module.exports = exports.default;
+Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/dist/cjs/package.json

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

package/dist/esm/index.d.ts

@@ -0,0 +1,18 @@
+import textToHtml from './lib/text-to-html.js';
+import htmlToText from './lib/html-to-text.js';
+import inlineHtml from './lib/inline-html.js';
+import inlineText from './lib/inline-text.js';
+import mimeHtml from './lib/mime-html.js';
+export type { FormatDateOptions } from './lib/format-date.js';
+export type { InlineAction, MessageAddress, QuotedMessage } from './lib/inline-html.js';
+export type { MimeHtmlAsyncOptions, MimeHtmlMessage } from './lib/mime-html.js';
+export type { WorkerPoolOptions, WorkerPoolStats } from './lib/worker-pool.js';
+export { textToHtml, htmlToText, inlineHtml, inlineText, mimeHtml };
+declare const textTools: {
+    textToHtml: typeof textToHtml;
+    htmlToText: typeof htmlToText;
+    inlineHtml: typeof inlineHtml;
+    inlineText: typeof inlineText;
+    mimeHtml: typeof mimeHtml;
+};
+export default textTools;

package/dist/esm/index.js

@@ -0,0 +1,12 @@
+// The ES module entry point and the source of the type declarations of both builds. The
+// CommonJS entry point is index.cts: it has the same exports but loads mimeHtml, and with it
+// jsdom, only on first access. An ES module can not defer a synchronous import, so here
+// mimeHtml is loaded with the rest.
+import textToHtml from './lib/text-to-html.js';
+import htmlToText from './lib/html-to-text.js';
+import inlineHtml from './lib/inline-html.js';
+import inlineText from './lib/inline-text.js';
+import mimeHtml from './lib/mime-html.js';
+export { textToHtml, htmlToText, inlineHtml, inlineText, mimeHtml };
+const textTools = { textToHtml, htmlToText, inlineHtml, inlineText, mimeHtml };
+export default textTools;

package/dist/esm/lib/commonjs.cjs

@@ -0,0 +1,17 @@
+"use strict";
+// What an ES module can not do the same way in both builds. This file compiles to
+// commonjs.cjs in dist/cjs and in dist/esm alike, so __dirname is the directory of the
+// build that loaded it and require() is available to both.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TLDS = exports.JUICE_WORKER_PATH = void 0;
+// A plain require() keeps the call below in the literal path.join(__dirname, '...') form, the
+// one form @yao-pkg/pkg recognizes when it collects the files a binary needs (a default import
+// compiles to path_1.default.join, which it does not). Without it the worker script is left out
+// of an EmailEngine binary
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const path = require('node:path');
+/** The worker script that runs juice off the main thread, the one of the same build */
+exports.JUICE_WORKER_PATH = path.join(__dirname, 'juice-worker.js');
+/** The top level domain list of the tlds package, which only ships it as index.json */
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+exports.TLDS = require('tlds');

package/dist/esm/lib/commonjs.d.cts

@@ -0,0 +1,4 @@
+/** The worker script that runs juice off the main thread, the one of the same build */
+export declare const JUICE_WORKER_PATH: string;
+/** The top level domain list of the tlds package, which only ships it as index.json */
+export declare const TLDS: string[];

package/dist/esm/lib/format-date.d.ts

@@ -0,0 +1,15 @@
+export interface FormatDateOptions {
+    /** BCP 47 language tag, defaults to 'en' */
+    locale?: string | undefined;
+    /** IANA time zone, defaults to the local time zone */
+    tz?: string | undefined;
+}
+/**
+ * Formats the date of a quoted message for the reply/forward header, for example
+ * "Sat, Jun 15, 2024, 2:30 PM" in English.
+ *
+ * @param value Date to format
+ * @param options Locale and time zone
+ * @returns Formatted date, or the input as text when it is not a valid date
+ */
+export default function formatDate(value: Date | string | number, options?: FormatDateOptions | null): string;

package/{lib → dist/esm/lib}/format-date.js

@@ -1,5 +1,3 @@
-'use strict';
-
 const DATE_FORMAT = {
     weekday: 'short',
     year: 'numeric',
@@ -8,7 +6,6 @@ const DATE_FORMAT = {
     hour: 'numeric',
     minute: '2-digit'
 };
-
 // An unsupported locale would silently fall back to the host's default locale, and a Node build
 // with only English ICU data (pkg binaries use small-icu) renders other locales as broken
 // placeholders such as "M09 28, Mon", so anything not actually supported becomes 'en'.
@@ -19,35 +16,33 @@ function resolveLocale(locale) {
             if (supported.length) {
                 return supported[0];
             }
-        } catch (_err) {
+        }
+        catch (_err) {
             // structurally invalid language tag
         }
     }
     return 'en';
 }
-
 /**
  * Formats the date of a quoted message for the reply/forward header, for example
  * "Sat, Jun 15, 2024, 2:30 PM" in English.
  *
- * @param {Date|String|Number} value Date to format
- * @param {Object} [options]
- * @param {String} [options.locale] BCP 47 language tag, defaults to 'en'
- * @param {String} [options.tz] IANA time zone, defaults to the local time zone
- * @returns {String} Formatted date, or the input as text when it is not a valid date
+ * @param value Date to format
+ * @param options Locale and time zone
+ * @returns Formatted date, or the input as text when it is not a valid date
  */
-function formatDate(value, options) {
+export default function formatDate(value, options) {
     options = options || {};
     const date = value instanceof Date ? value : new Date(value);
     if (isNaN(date.getTime())) {
         return String(value);
     }
-
     const locale = resolveLocale(options.locale);
     let formatter;
     try {
         formatter = new Intl.DateTimeFormat(locale, Object.assign({ timeZone: options.tz || undefined }, DATE_FORMAT));
-    } catch (err) {
+    }
+    catch (err) {
         if (!(err instanceof RangeError)) {
             throw err;
         }
@@ -55,9 +50,6 @@ function formatDate(value, options) {
         formatter = new Intl.DateTimeFormat(locale, Object.assign({ timeZone: 'UTC' }, DATE_FORMAT));
     }
     const formatted = formatter.format(date);
-
     // ICU puts a narrow no-break space before "PM", which older mail clients show as a box
     return formatted.replace(/[\u00a0\u202f]/g, ' ');
 }
-
-module.exports = formatDate;

package/dist/esm/lib/html-guard.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_NESTING_DEPTH = 1000;
+export declare function exceedsNestingDepth(html: string, maxDepth: number): boolean;
+export declare function fallbackText(html: string): string;