@social-mail/shared 1.1.3 → 1.1.5

package/src/mime-parser/HeaderEmailAddress.ts

@@ -0,0 +1,38 @@
+import MimeAddressParser from "./MimeEmailAddressParser.js";
+
+export default class HeaderEmailAddress {
+
+    static parse(text: string) {
+        if (/(\<|\>)/i.test(text)) {
+            for(const g of MimeAddressParser.parseContactAddressList(text)) {
+                const e1 = new HeaderEmailAddress(g.address, g.name);
+                return e1;
+            }
+        }
+        const e = new HeaderEmailAddress(text);
+        return e;
+    }
+
+    /**
+     * Username (part before the @ sign)
+     */
+    public readonly username: string;
+
+    /**
+     * Domain name part of the email address
+     */
+    public readonly domain: string;
+
+    constructor(public emailAddress: string, public name?: string) {
+        const r = MimeAddressParser.parseEmailAddress(emailAddress);
+        this.domain = r?.domain;
+        this.username = r?.user;
+    }
+
+    toString() {
+        if (this.name) {
+            return `${this.name} <${this.emailAddress}>`;
+        }
+        return `<${this.emailAddress}>`;
+    }
+}

package/src/mime-parser/HeaderLinks.ts

@@ -0,0 +1,48 @@
+export default class HeaderLinks {
+
+    static parse(value: string) {
+        const h = new HeaderLinks();
+        const { urls, mailTos, rawLinks } = h;
+        for(const line of value.split(/\[\,\;]/g)) {
+            if (!line) {
+                continue;
+            }
+            const a = /\<([^\>]+)\>/.exec(line.trim());
+            if(!a) {
+                continue;
+            }
+            const s = a[1];
+            rawLinks.push(s);
+            if(/https?\:\/\//i.test(s)) {
+                try {
+                    urls.push(new URL(s));
+                } catch {
+                    // do nothing...
+                }
+                continue;
+            }
+            if(/mailto\:/i.test(s)) {
+                try {           
+                    mailTos.push(new URL(s));
+                } catch {
+                    // do nothing..
+                }
+            }
+        }
+        return h;
+    }
+
+    public readonly urls = [] as URL[];
+
+    public readonly mailTos = [] as URL[];
+
+    public readonly rawLinks = [] as string[];
+
+    constructor() {
+
+    }
+
+    toString() {
+        return this.rawLinks.join(",");
+    }
+}

package/src/mime-parser/MimeEmailAddressParser.ts

@@ -0,0 +1,22 @@
+import RegexGenerator from "./RegexGenerator.js";
+
+export const emailAddressHeaderRegex = /(?<name>(("(("")|[^"])+")|([^\<]+)))?\s*\<(?<address>[^\>]+)\>/g;
+
+export const emailAddressRegex = /(?<user>(("(""|[^"])+")|([^\@])+))\@(?<domain>[^\s\,\;]*)$/g;
+
+export default class MimeAddressParser {
+
+    public static parseEmailAddress(text: string) {
+        const r = emailAddressRegex.exec(text);
+        return r?.groups as { user: string, domain: string } ;
+    }
+
+    public static *parseContactAddressList(text: string) {
+        const rg = new RegexGenerator(emailAddressHeaderRegex);
+        for(const g of rg.groups(text)) {
+            const { name, address } = g.groups;
+            yield { name, address };
+        }
+    }
+
+}

package/src/mime-parser/MimeHeaders.ts

@@ -0,0 +1,62 @@
+export class MimeHeader {
+
+    public readonly keyLowerCase: string;
+
+    private lastParsed: { c, value };
+
+    constructor(public readonly key: string, public readonly value: string) {
+        this.keyLowerCase = key.toLowerCase();
+    }
+
+    as<Parsable>(c: { parse(text: string): Parsable }): Parsable {
+        const { lastParsed } = this;
+        if (lastParsed?.c === c) {
+            return lastParsed.value;
+        }
+        const value = c.parse(this.value);
+        this.lastParsed = { c, value };
+        return value as Parsable;
+    }
+}
+
+/**
+ * This class holds the headers in the way they were received.
+ * It has different methods to retrive headers.
+ * `first` will only display first header.
+ * `last` will only display last header in the order.
+ */
+export default class MimeHeaders {
+
+    private headers = [] as MimeHeader[];
+
+    private map = new Map<string, MimeHeader[]>()
+
+    public entries() {
+        return this.headers[Symbol.iterator]();
+    }
+
+    public append(key: string, value: string) {
+        const h = new MimeHeader(key, value);
+        this.headers.push(h);
+        const lowerKey = key.toLowerCase();
+        let existing = this.map.get(lowerKey);
+        if (!existing) {
+            existing = [];
+            this.map.set(lowerKey, existing);
+        }
+        existing.push(h);
+        return h;
+    }
+
+    public set(key: string, value: string) {
+        const lowerkey = key.toLowerCase();
+        this.headers = this.headers.filter((x) => x.keyLowerCase !== lowerkey);
+        this.map.delete(lowerkey);
+        this.append(key, value);
+    }
+
+    public first(key: string) {
+        return this.map.get(key.toLowerCase())?.[0];
+    }
+
+}

package/src/mime-parser/MimeMessage.ts

@@ -2,12 +2,11 @@ import { MimeNode } from "./MimeNode.js";
 import { AttachmentFile } from "./AttachmentFile.js";
 import LineStream, { ReadableLineStream, StringLineStream } from "./stream/LineStream.js";
 import { BlobWriter } from "./stream/TextWriter.js";
+import HeaderLinks from "./HeaderLinks.js";
+import HeaderEmailAddress from "./HeaderEmailAddress.js";
+import HeaderContactList from "./HeaderContactList.js";
 
 export default class MimeMessage {
-    constructor(
-        private node: MimeNode = new MimeNode("multipart/mixed"),
-        private attachments: AttachmentFile[] = []
-    ) {}
 
     static async load(
         reader: ReadableStream | LineStream | string,
@@ -36,7 +35,7 @@ export default class MimeMessage {
     }
 
     get name(): string {
-        return this.node.header("x-name") || "";
+        return this.node.firstHeaderString("x-name") || "";
     }
 
     get html(): string {
@@ -44,6 +43,10 @@ export default class MimeMessage {
         return alternative?.getFirstChild("text/html")?.text || "";
     }
 
+    get listUnsubscribe() {
+        return this.node.firstHeaderObject("list-unsubscribe")?.as(HeaderLinks);
+    }
+
     set html(v: string) {
         const alternative = this.node.getFirstChild("multipart/alternative", true);
         const htmlMime = alternative.getFirstChild("text/html", true);
@@ -66,12 +69,49 @@ export default class MimeMessage {
     }
 
     get subject(): string {
-        return this.node.header("subject") || "";
+        return this.node.firstHeaderString("subject") || "";
     }
 
     set subject(v: string) {
-        this.node.setHeader("subject", v);
+        this.node.setHeader("Subject", v);
+    }
+
+    get from(): HeaderEmailAddress {
+        return this.node.firstHeaderObject("from")?.as(HeaderEmailAddress);
+    }
+    set from(v: string | { name: string, emailAddress: string }) {
+        if (typeof v === "string") {
+            this.node.setHeader("From", v);
+            return;
+        }
+        this.node.setHeader("From", new HeaderEmailAddress(v.emailAddress, v.name).toString());
+    }
+
+    get to(): HeaderContactList {
+        return this.node.firstHeaderObject("to")?.as(HeaderContactList);
     }
+    set to(v: string | { name: string, emailAddress: string } | { name: string, emailAddress: string }[]) {
+        this.node.setHeader("To", HeaderContactList.from(v).toString());
+    }
+
+    get cc(): HeaderContactList {
+        return this.node.firstHeaderObject("cc")?.as(HeaderContactList);
+    }
+    set cc(v: string | { name: string, emailAddress: string } | { name: string, emailAddress: string }[]) {
+        this.node.setHeader("Cc", HeaderContactList.from(v).toString());
+    }
+
+    get bcc(): HeaderContactList {
+        return this.node.firstHeaderObject("bcc")?.as(HeaderContactList);
+    }
+    set bcc(v: string | { name: string, emailAddress: string } | { name: string, emailAddress: string }[]) {
+        this.node.setHeader("Bcc", HeaderContactList.from(v).toString());
+    }
+
+    constructor(
+        private node: MimeNode = new MimeNode("multipart/mixed"),
+        private attachments: AttachmentFile[] = []
+    ) {}
 
     async save(): Promise<Blob> {
         const blobWriter = new BlobWriter();

package/src/mime-parser/MimeNode.ts

@@ -8,6 +8,7 @@ import { quotedPrintable } from "./encoder/quoted-printable.js";
 import { wordEncoding } from "./encoder/word-encoding.js";
 import LineStream from "./stream/LineStream.js";
 import TextWriter from "./stream/TextWriter.js";
+import MimeHeaders from "./MimeHeaders.js";
 
 export class CIMap extends Map<string, any> {
     private ci = new Map<string, string>();
@@ -93,16 +94,24 @@ export class MimeNode {
 
     encoded?: string;
     children?: MimeNode[];
-    contentType: HeaderContentType;
-    contentDisposition?: HeaderContentDisposition;
+    get contentType() {
+        return this.headers.first("content-type").as(HeaderContentType);
+    }
+    get contentDisposition() {
+        return this.headers.first("content-disposition")?.as(HeaderContentDisposition);
+    }
+
+    set contentDisposition(v: HeaderContentDisposition) {
+        this.headers.set("content-disposition", v.toString());
+    }
+
     textContent?: string;
     blobData?: Blob;
-    headers: CIMap;
+    headers: MimeHeaders;
 
     constructor(type?: string) {
-        this.headers = new CIMap();
-        this.contentType = new HeaderContentType(type);
-        this.headers.set("Content-Type", this.contentType);
+        this.headers = new MimeHeaders();
+        this.headers.append("Content-Type", type);
     }
 
     get text(): string {
@@ -153,11 +162,11 @@ export class MimeNode {
     }
 
     get contentTransferEncoding(): string | undefined {
-        return this.header("Content-Transfer-Encoding");
+        return this.firstHeaderString("Content-Transfer-Encoding");
     }
 
     set contentTransferEncoding(v: string | undefined) {
-        this.setHeader("Content-Transfer-Encoding", v);
+        this.headers.set("Content-Transfer-Encoding", v);
     }
 
     get boundary(): string | undefined {
@@ -168,8 +177,12 @@ export class MimeNode {
         return this.enumerate();
     }
 
-    header(name: string): any {
-        return this.headers.get(name);
+    firstHeaderString(name: string): any {
+        return this.headers.first(name)?.value;
+    }
+
+    firstHeaderObject(name: string) {
+        return this.headers.first(name);
     }
 
     setHeader(name: string, value: any): void {
@@ -185,7 +198,7 @@ export class MimeNode {
             this.contentDisposition!.filename!,
             {
                 type: this.contentType.type,
-                contentId: this.header("Content-Id"),
+                contentId: this.firstHeaderString("Content-Id"),
                 disposition: this.contentDisposition!.type as any
             });
         af.node = this;
@@ -283,17 +296,6 @@ export class MimeNode {
         } else {
             return;
         }
-
-        const ct = this.header("Content-Type");
-        this.contentType.parse(ct);
-        this.setHeader("Content-Type", ct);
-
-        const cd = this.header("Content-Disposition");
-        if (cd) {
-            this.contentDisposition ??= new HeaderContentDisposition();
-            this.contentDisposition.parse(cd);
-            this.setHeader("Content-Disposition", cd);
-        }
     }
 
     async save(writer: TextWriter): Promise<void> {
@@ -305,19 +307,8 @@ export class MimeNode {
             this.contentType.boundary ||= `${Date.now()}-${Date.now()}-${Date.now()}`;
         }
 
-        for (const [key, element] of this.headers.entries()) {
-            switch(key) {
-                case "content-disposition":
-                    writer.writeLine(`Content-Disposition: ${this.contentDisposition}`);
-                    continue;
-                case "content-type":
-                    writer.writeLine(`Content-Type:${this.contentType.toString()}`);
-                    continue;
-                case "subject":
-                    writer.writeLine(`${key}: ${wordEncoding.encode(element, true)}`);
-                    continue;
-            }
-            writer.writeLine(`${key}: ${element}`);
+        for (const h of this.headers.entries()) {
+            writer.writeLineMax80Chars(`${h.key}: ${wordEncoding.encode(h.value, true)}`);
         }
 
         writer.writeLine("");
@@ -360,10 +351,10 @@ export class MimeNode {
                 break;
             case "base64":
                 text = btoa(RawBuffer.encode(text, this.contentType.charset));
-                writer.writeLine(text);
+                writer.writeLineMax80Chars(text);
                 break;
             default:
-                writer.writeLine(text);
+                writer.writeLineMax80Chars(text);
                 break;
         }
 }

package/src/mime-parser/RegexGenerator.ts

@@ -0,0 +1,42 @@
+export default class RegexGenerator{
+
+    constructor(public readonly regex: RegExp) {
+
+    }
+
+    *groups(text: string) {
+        if (!text) {
+            return;
+        }
+        const { regex } = this;
+        regex.lastIndex = 0;
+        let m;
+        while((m = regex.exec(text)) !== null) {
+            if (m.index === regex.lastIndex) {
+                regex.lastIndex++;
+            }
+            if (m?.length) {
+                yield m as RegExpExecArray;
+            }
+        }
+    }
+
+    *all(text: string) {
+        if (!text) {
+            return;
+        }
+        const { regex } = this;
+        regex.lastIndex = 0;
+        let m;
+        while((m = regex.exec(text)) !== null) {
+            if (m.index === regex.lastIndex) {
+                regex.lastIndex++;
+            }
+            if (m?.length) {
+                yield { matched: m as RegExpExecArray };
+                continue;
+            }
+        }
+    }
+
+};

package/src/mime-parser/stream/TextWriter.ts

@@ -2,6 +2,20 @@ export default class TextWriter {
     writeLine(line: string): void {
         throw new Error("Not Implemented");
     }
+
+    writeLineMax80Chars(line: string, padPrefix = "") {
+        let prefix = "";
+        for(;;) {
+            if (line.length <= 80) {
+                this.writeLine(prefix + line);
+                break;
+            }
+            const firstSegment = line.substring(0, 80);
+            this.writeLine(prefix + firstSegment);
+            line = line.substring(80);
+            prefix = padPrefix;
+        }
+    }
 }
 
 export class BlobWriter extends TextWriter {