postal-mime 2.0.0 → 2.0.2

package/src/qp-decoder.js

@@ -0,0 +1,96 @@
+import { blobToArrayBuffer } from './decode-strings.js';
+
+export default class QPDecoder {
+    constructor(opts) {
+        opts = opts || {};
+
+        this.decoder = opts.decoder || new TextDecoder();
+
+        this.maxChunkSize = 100 * 1024;
+
+        this.remainder = '';
+
+        this.chunks = [];
+    }
+
+    decodeQPBytes(encodedBytes) {
+        let buf = new ArrayBuffer(encodedBytes.length);
+        let dataView = new DataView(buf);
+        for (let i = 0, len = encodedBytes.length; i < len; i++) {
+            dataView.setUint8(i, parseInt(encodedBytes[i], 16));
+        }
+        return buf;
+    }
+
+    decodeChunks(str) {
+        // unwrap newlines
+        str = str.replace(/=\r?\n/g, '');
+
+        let list = str.split(/(?==)/);
+        let encodedBytes = [];
+        for (let part of list) {
+            if (part.charAt(0) !== '=') {
+                if (encodedBytes.length) {
+                    this.chunks.push(this.decodeQPBytes(encodedBytes));
+                    encodedBytes = [];
+                }
+                this.chunks.push(part);
+                continue;
+            }
+
+            if (part.length === 3) {
+                encodedBytes.push(part.substr(1));
+                continue;
+            }
+
+            if (part.length > 3) {
+                encodedBytes.push(part.substr(1, 2));
+                this.chunks.push(this.decodeQPBytes(encodedBytes));
+                encodedBytes = [];
+
+                part = part.substr(3);
+                this.chunks.push(part);
+            }
+        }
+        if (encodedBytes.length) {
+            this.chunks.push(this.decodeQPBytes(encodedBytes));
+            encodedBytes = [];
+        }
+    }
+
+    update(buffer) {
+        // expect full lines, so add line terminator as well
+        let str = this.decoder.decode(buffer) + '\n';
+
+        str = this.remainder + str;
+
+        if (str.length < this.maxChunkSize) {
+            this.remainder = str;
+            return;
+        }
+
+        this.remainder = '';
+
+        let partialEnding = str.match(/=[a-fA-F0-9]?$/);
+        if (partialEnding) {
+            if (partialEnding.index === 0) {
+                this.remainder = str;
+                return;
+            }
+            this.remainder = str.substr(partialEnding.index);
+            str = str.substr(0, partialEnding.index);
+        }
+
+        this.decodeChunks(str);
+    }
+
+    finalize() {
+        if (this.remainder.length) {
+            this.decodeChunks(this.remainder);
+            this.remainder = '';
+        }
+
+        // convert an array of arraybuffers into a blob and then back into a single arraybuffer
+        return blobToArrayBuffer(new Blob(this.chunks, { type: 'application/octet-stream' }));
+    }
+}

package/src/text-format.js

@@ -0,0 +1,334 @@
+import htmlEntities from './html-entities.js';
+
+export function decodeHTMLEntities(str) {
+    return str.replace(/&(#\d+|#x[a-f0-9]+|[a-z]+\d*);?/gi, (match, entity) => {
+        if (typeof htmlEntities[match] === 'string') {
+            return htmlEntities[match];
+        }
+
+        if (entity.charAt(0) !== '#' || match.charAt(match.length - 1) !== ';') {
+            // keep as is, invalid or unknown sequence
+            return match;
+        }
+
+        let codePoint;
+        if (entity.charAt(1) === 'x') {
+            // hex
+            codePoint = parseInt(entity.substr(2), 16);
+        } else {
+            // dec
+            codePoint = parseInt(entity.substr(1), 10);
+        }
+
+        var output = '';
+
+        if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
+            // Invalid range, return a replacement character instead
+            return '\uFFFD';
+        }
+
+        if (codePoint > 0xffff) {
+            codePoint -= 0x10000;
+            output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);
+            codePoint = 0xdc00 | (codePoint & 0x3ff);
+        }
+
+        output += String.fromCharCode(codePoint);
+
+        return output;
+    });
+}
+
+export function escapeHtml(str) {
+    return str.trim().replace(/[<>"'?&]/g, c => {
+        let hex = c.charCodeAt(0).toString(16);
+        if (hex.length < 2) {
+            hex = '0' + hex;
+        }
+        return '&#x' + hex.toUpperCase() + ';';
+    });
+}
+
+export function textToHtml(str) {
+    let html = escapeHtml(str).replace(/\n/g, '<br />');
+    return '<div>' + html + '</div>';
+}
+
+export function htmlToText(str) {
+    str = str
+        // we can't process tags on multiple lines so remove newlines first
+        .replace(/\r?\n/g, '\u0001')
+        .replace(/<\!\-\-.*?\-\->/gi, ' ')
+
+        .replace(/<br\b[^>]*>/gi, '\n')
+        .replace(/<\/?(p|div|table|tr|td|th)\b[^>]*>/gi, '\n\n')
+        .replace(/<script\b[^>]*>.*?<\/script\b[^>]*>/gi, ' ')
+        .replace(/^.*<body\b[^>]*>/i, '')
+        .replace(/^.*<\/head\b[^>]*>/i, '')
+        .replace(/^.*<\!doctype\b[^>]*>/i, '')
+        .replace(/<\/body\b[^>]*>.*$/i, '')
+        .replace(/<\/html\b[^>]*>.*$/i, '')
+
+        .replace(/<a\b[^>]*href\s*=\s*["']?([^\s"']+)[^>]*>/gi, ' ($1) ')
+
+        .replace(/<\/?(span|em|i|strong|b|u|a)\b[^>]*>/gi, '')
+
+        .replace(/<li\b[^>]*>[\n\u0001\s]*/gi, '* ')
+
+        .replace(/<hr\b[^>]*>/g, '\n-------------\n')
+
+        .replace(/<[^>]*>/g, ' ')
+
+        // convert linebreak placeholders back to newlines
+        .replace(/\u0001/g, '\n')
+
+        .replace(/[ \t]+/g, ' ')
+
+        .replace(/^\s+$/gm, '')
+
+        .replace(/\n\n+/g, '\n\n')
+        .replace(/^\n+/, '\n')
+        .replace(/\n+$/, '\n');
+
+    str = decodeHTMLEntities(str);
+
+    return str;
+}
+
+function formatTextAddress(address) {
+    return []
+        .concat(address.name || [])
+        .concat(address.name ? `<${address.address}>` : address.address)
+        .join(' ');
+}
+
+function formatTextAddresses(addresses) {
+    let parts = [];
+
+    let processAddress = (address, partCounter) => {
+        if (partCounter) {
+            parts.push(', ');
+        }
+
+        if (address.group) {
+            let groupStart = `${address.name}:`;
+            let groupEnd = `;`;
+
+            parts.push(groupStart);
+            address.group.forEach(processAddress);
+            parts.push(groupEnd);
+        } else {
+            parts.push(formatTextAddress(address));
+        }
+    };
+
+    addresses.forEach(processAddress);
+
+    return parts.join('');
+}
+
+function formatHtmlAddress(address) {
+    return `<a href="mailto:${escapeHtml(address.address)}" class="postal-email-address">${escapeHtml(address.name || `<${address.address}>`)}</a>`;
+}
+
+function formatHtmlAddresses(addresses) {
+    let parts = [];
+
+    let processAddress = (address, partCounter) => {
+        if (partCounter) {
+            parts.push('<span class="postal-email-address-separator">, </span>');
+        }
+
+        if (address.group) {
+            let groupStart = `<span class="postal-email-address-group">${escapeHtml(address.name)}:</span>`;
+            let groupEnd = `<span class="postal-email-address-group">;</span>`;
+
+            parts.push(groupStart);
+            address.group.forEach(processAddress);
+            parts.push(groupEnd);
+        } else {
+            parts.push(formatHtmlAddress(address));
+        }
+    };
+
+    addresses.forEach(processAddress);
+
+    return parts.join(' ');
+}
+
+function foldLines(str, lineLength, afterSpace) {
+    str = (str || '').toString();
+    lineLength = lineLength || 76;
+
+    let pos = 0,
+        len = str.length,
+        result = '',
+        line,
+        match;
+
+    while (pos < len) {
+        line = str.substr(pos, lineLength);
+        if (line.length < lineLength) {
+            result += line;
+            break;
+        }
+        if ((match = line.match(/^[^\n\r]*(\r?\n|\r)/))) {
+            line = match[0];
+            result += line;
+            pos += line.length;
+            continue;
+        } else if ((match = line.match(/(\s+)[^\s]*$/)) && match[0].length - (afterSpace ? (match[1] || '').length : 0) < line.length) {
+            line = line.substr(0, line.length - (match[0].length - (afterSpace ? (match[1] || '').length : 0)));
+        } else if ((match = str.substr(pos + line.length).match(/^[^\s]+(\s*)/))) {
+            line = line + match[0].substr(0, match[0].length - (!afterSpace ? (match[1] || '').length : 0));
+        }
+
+        result += line;
+        pos += line.length;
+        if (pos < len) {
+            result += '\r\n';
+        }
+    }
+
+    return result;
+}
+
+export function formatTextHeader(message) {
+    let rows = [];
+
+    if (message.from) {
+        rows.push({ key: 'From', val: formatTextAddress(message.from) });
+    }
+
+    if (message.subject) {
+        rows.push({ key: 'Subject', val: message.subject });
+    }
+
+    if (message.date) {
+        let dateOptions = {
+            year: 'numeric',
+            month: 'numeric',
+            day: 'numeric',
+            hour: 'numeric',
+            minute: 'numeric',
+            second: 'numeric',
+            hour12: false
+        };
+
+        let dateStr = typeof Intl === 'undefined' ? message.date : new Intl.DateTimeFormat('default', dateOptions).format(new Date(message.date));
+
+        rows.push({ key: 'Date', val: dateStr });
+    }
+
+    if (message.to && message.to.length) {
+        rows.push({ key: 'To', val: formatTextAddresses(message.to) });
+    }
+
+    if (message.cc && message.cc.length) {
+        rows.push({ key: 'Cc', val: formatTextAddresses(message.cc) });
+    }
+
+    if (message.bcc && message.bcc.length) {
+        rows.push({ key: 'Bcc', val: formatTextAddresses(message.bcc) });
+    }
+
+    // Align keys and values by adding space between these two
+    // Also make sure that the separator line is as long as the longest line
+    // Should end up with something like this:
+    /*
+    -----------------------------
+    From:    xx xx <xxx@xxx.com>
+    Subject: Example Subject
+    Date:    16/02/2021, 02:57:06
+    To:      not@found.com
+    -----------------------------
+    */
+
+    let maxKeyLength = rows
+        .map(r => r.key.length)
+        .reduce((acc, cur) => {
+            return cur > acc ? cur : acc;
+        }, 0);
+
+    rows = rows.flatMap(row => {
+        let sepLen = maxKeyLength - row.key.length;
+        let prefix = `${row.key}: ${' '.repeat(sepLen)}`;
+        let emptyPrefix = `${' '.repeat(row.key.length + 1)} ${' '.repeat(sepLen)}`;
+
+        let foldedLines = foldLines(row.val, 80, true)
+            .split(/\r?\n/)
+            .map(line => line.trim());
+
+        return foldedLines.map((line, i) => `${i ? emptyPrefix : prefix}${line}`);
+    });
+
+    let maxLineLength = rows
+        .map(r => r.length)
+        .reduce((acc, cur) => {
+            return cur > acc ? cur : acc;
+        }, 0);
+
+    let lineMarker = '-'.repeat(maxLineLength);
+
+    let template = `
+${lineMarker}
+${rows.join('\n')}
+${lineMarker}
+`;
+
+    return template;
+}
+
+export function formatHtmlHeader(message) {
+    let rows = [];
+
+    if (message.from) {
+        rows.push(`<div class="postal-email-header-key">From</div><div class="postal-email-header-value">${formatHtmlAddress(message.from)}</div>`);
+    }
+
+    if (message.subject) {
+        rows.push(
+            `<div class="postal-email-header-key">Subject</div><div class="postal-email-header-value postal-email-header-subject">${escapeHtml(
+                message.subject
+            )}</div>`
+        );
+    }
+
+    if (message.date) {
+        let dateOptions = {
+            year: 'numeric',
+            month: 'numeric',
+            day: 'numeric',
+            hour: 'numeric',
+            minute: 'numeric',
+            second: 'numeric',
+            hour12: false
+        };
+
+        let dateStr = typeof Intl === 'undefined' ? message.date : new Intl.DateTimeFormat('default', dateOptions).format(new Date(message.date));
+
+        rows.push(
+            `<div class="postal-email-header-key">Date</div><div class="postal-email-header-value postal-email-header-date" data-date="${escapeHtml(
+                message.date
+            )}">${escapeHtml(dateStr)}</div>`
+        );
+    }
+
+    if (message.to && message.to.length) {
+        rows.push(`<div class="postal-email-header-key">To</div><div class="postal-email-header-value">${formatHtmlAddresses(message.to)}</div>`);
+    }
+
+    if (message.cc && message.cc.length) {
+        rows.push(`<div class="postal-email-header-key">Cc</div><div class="postal-email-header-value">${formatHtmlAddresses(message.cc)}</div>`);
+    }
+
+    if (message.bcc && message.bcc.length) {
+        rows.push(`<div class="postal-email-header-key">Bcc</div><div class="postal-email-header-value">${formatHtmlAddresses(message.bcc)}</div>`);
+    }
+
+    let template = `<div class="postal-email-header">${rows.length ? '<div class="postal-email-header-row">' : ''}${rows.join(
+        '</div>\n<div class="postal-email-header-row">'
+    )}${rows.length ? '</div>' : ''}</div>`;
+
+    return template;
+}

package/.github/workflows/release.yaml

@@ -1,37 +0,0 @@
-on:
-    push:
-        branches:
-            - master
-
-permissions:
-    contents: write
-    pull-requests: write
-    id-token: write
-
-name: release
-jobs:
-    release-please:
-        runs-on: ubuntu-latest
-        steps:
-            - uses: google-github-actions/release-please-action@v3
-              id: release
-              with:
-                  release-type: node
-                  package-name: ${{vars.NPM_MODULE_NAME}}
-                  pull-request-title-pattern: 'chore${scope}: release ${version} [skip-ci]'
-            # The logic below handles the npm publication:
-            - uses: actions/checkout@v3
-              # these if statements ensure that a publication only occurs when
-              # a new release is created:
-              if: ${{ steps.release.outputs.release_created }}
-            - uses: actions/setup-node@v3
-              with:
-                  node-version: 18
-                  registry-url: 'https://registry.npmjs.org'
-              if: ${{ steps.release.outputs.release_created }}
-            - run: npm ci
-              if: ${{ steps.release.outputs.release_created }}
-            - run: npm publish --provenance --access public
-              env:
-                  NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}
-              if: ${{ steps.release.outputs.release_created }}