@social-mail/shared 1.0.3

package/src/QueryIterator.js

@@ -0,0 +1,33 @@
+export default class QueryIterator {
+
+    /**
+     * @template T
+     * @returns {T}
+    */
+    static first(
+        /** @type {IterableIterator<T>} */ source,
+        /** @type {(item: T) => boolean} */ fx
+    ) {
+        for (const iterator of source) {
+            if (fx(iterator)) {
+                return iterator;
+            }
+        }
+    }
+
+    /**
+     * @template T
+     * @returns {T | null}
+    */
+    firstOrFail(
+        /** @type {IterableIterator<T>} */ source,
+        /** @type {(item: T) => boolean} */ fx
+    ) {
+        for (const iterator of source) {
+            if (fx(iterator)) {
+                return iterator;
+            }
+        }
+
+    }
+}

package/src/mime-parser/AttachmentFile.js

@@ -0,0 +1,29 @@
+import { MimeNode } from "./MimeNode.js";
+
+
+
+export class AttachmentFile extends File {
+
+    /** @type {"inline" | "attachment"} */
+    disposition;
+
+    /** @type {string} */
+    contentId;
+
+    /**
+     * Associated mime node if any
+     * @type {MimeNode}
+     */
+    node;
+
+    constructor(
+        /** @type {BlobPart[]} */ fileBits,
+        /** @type {string} */ fileName,
+        /** @type {FilePropertyBag & { disposition?: "inline" | "attachment"; contentId?: string; }} */
+        options) {
+        super(fileBits, fileName, options);
+        this.contentId = options.contentId;
+        this.disposition = options.disposition;
+    }
+
+}

package/src/mime-parser/HeaderContentDisposition.js

@@ -0,0 +1,32 @@
+import { wordEncoding } from "./encoder/word-encoding.js";
+import { parsePairs } from "./parsePairs.js";
+
+
+export class HeaderContentDisposition {
+
+    /** @type {string} */ type;
+    /** @type {string} */ filename;
+    /** @type {string} */ name;
+
+    constructor(
+        /** @type {string} */ type,
+        /** @type {string} */ filename,
+        /** @type {string} */ name
+    ) {
+        this.type = type;
+        this.filename = filename;
+        this.name = name;
+    }
+
+    parse(/** @type {string} */ text) {
+        const items = parsePairs(text, "type");
+        this.type = items.type;
+        this.filename = items.filename;
+        this.name = items.name;
+    }
+
+    toString() {
+        return `${this.type};\r\n\t\tfilename="${wordEncoding.encode( this.filename)}";`;
+    }
+
+}

package/src/mime-parser/HeaderContentType.js

@@ -0,0 +1,34 @@
+import { parsePairs } from "./parsePairs.js";
+
+
+export class HeaderContentType {
+
+    /** @type {string} */ type;
+    /** @type {string} */ charset;
+    /** @type {string} */ boundary;
+
+    constructor(
+        /** @type {string} */ type,
+        /** @type {string} */ charset = "UTF-8",
+        /** @type {string} */ boundary
+    ) {
+        this.type = type;
+        this.charset = charset;
+        this.boundary = boundary;
+    }
+
+    parse( /** @type {string} */ text) {
+        const items = parsePairs(text, "type");
+        this.type = items.type;
+        this.charset = items.charset;
+        this.boundary = items.boundary;
+    }
+
+    toString() {
+        if (this.boundary) {
+            return `${this.type}; charset="${this.charset}"; boundary="${this.boundary}";`;
+        }
+        return `${this.type}; charset="${this.charset}";`;
+    }
+}
+

package/src/mime-parser/MimeMessage.js

@@ -0,0 +1,100 @@
+import { MimeNode } from "./MimeNode.js";
+import { AttachmentFile } from "./AttachmentFile.js";
+import { ReadableLineStream, StringLineStream } from "./stream/LineStream.js";
+import { BlobWriter } from "./stream/TextWriter.js";
+
+export default class MimeMessage {
+
+    static async load(
+        /** @type {ReadableStream | string} */ reader,
+        /** @type {string} */ name,
+        /** @type {boolean} */ inline
+    ) {
+        const node = new MimeNode();
+        if (name) {
+            node.setHeader("X-Name", name);
+        }
+        await node.parse( typeof reader === "string"
+            ? new StringLineStream(reader)
+            : new ReadableLineStream(reader));
+        const attachments = await node.attachments();
+
+        // we should inline the images and remove them from attachments array for simplicity
+        // this should be done when templates are imported from somewhere else
+
+        const msg = new MimeMessage(node, attachments);
+        if (inline) {
+            await msg.inlineImages();
+        }
+        return msg;
+    }
+
+    get name() {
+        return this.node.header("x-name");
+    }
+
+    get html() {
+        const alternative = this.node.getFirstChild("multipart/alternative");
+        return alternative?.getFirstChild("text/html")?.text ?? "";
+    }
+
+    set html(/** @type {string} */ v) {
+        const alternative = this.node.getFirstChild("multipart/alternative", true);
+        const htmlMime = alternative.getFirstChild("text/html", true);
+        htmlMime.contentTransferEncoding = "quoted-printable";
+        htmlMime.text = v;
+        htmlMime.contentType.charset = "UTF-8";
+    }
+
+    get text() {
+        const alternative = this.node.getFirstChild("multipart/alternative");
+        return alternative?.getFirstChild("text/plain")?.text ?? "";
+    }
+
+    set text(/** @type {string} */ v) {
+        const alternative = this.node.getFirstChild("multipart/alternative", true);
+        const htmlMime = alternative.getFirstChild("text/plain", true);
+        htmlMime.contentTransferEncoding = "quoted-printable";
+        htmlMime.text = v;
+        htmlMime.contentType.charset = "UTF-8";
+    }
+
+    get subject() {
+        return this.node.header("subject") ?? "";
+    }
+
+    set subject(/** @type {string} */ v) {
+        this.node.setHeader("subject", v);
+    }
+
+    /** @type {MimeNode} */ node;
+    /** @type {AttachmentFile[]} */ attachments;
+
+    constructor(
+        /** @type {MimeNode} */ node = new MimeNode("multipart/mixed"),
+        /** @type {AttachmentFile[]} */ attachments = []) {
+        this.node = node;
+        this.attachments = attachments;
+    }
+
+    async save() {
+        const blobWriter = new BlobWriter();
+        await this.node.save(blobWriter);
+        return blobWriter.toBlob();
+    }
+
+    async inlineImages() {
+        let text = this.html;
+        if (!text) {
+            return;
+        }
+
+        for (const iterator of this.attachments) {
+            if (iterator.contentId) {
+                const encoded = iterator.node.encoded;
+                text = text.split(`cid:${iterator.contentId}`).join(`data://${iterator.type},${encoded}`);
+            }
+        }
+    }
+
+}

package/src/mime-parser/MimeNode.js

@@ -0,0 +1,435 @@
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
+// import QueryIterator from "../../common/QueryIterator";
+import { AttachmentFile } from "./AttachmentFile.js";
+import { HeaderContentType } from "./HeaderContentType.js";
+import { HeaderContentDisposition } from "./HeaderContentDisposition.js";
+import { RawBuffer } from "./encoder/RawBuffer.js";
+import { base64toBlob } from "./encoder/base64-to-blob.js";
+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";
+
+// export interface IContentTypeObject {
+//     type: string;
+//     boundary?: string;
+//     charset?: string
+// };
+
+// export type IContentType = string | IContentTypeObject;
+
+// export interface IContentDispositionObject {
+//     type: string;
+//     filename?: string;
+// };
+
+// export type IContentDisposition = string | IContentDispositionObject;
+
+
+
+export class CIMap extends Map {
+
+    ci = new Map();
+
+    set(key, value) {
+        if (typeof key === "string") {
+            let ck = this.ci.get(key);
+            if (ck === void 0) {
+                ck = key.toLocaleLowerCase();
+                this.ci.set(ck, key);
+            } else {
+                key = ck;
+            }
+        }
+        return super.set(key, value);
+    }
+
+    get(key) {
+        if (typeof key === "string") {
+            const ck = key.toLocaleLowerCase();
+            key = this.ci.get(ck);
+        }
+        return super.get(key);
+    }
+
+}
+
+
+export class MimeNode {
+
+    static createMessage({
+        html,
+        subject,
+        text = "",
+        name = "",
+        attachments = []
+    }) {
+        const root = new MimeNode("multipart/mixed");
+        root.setHeader("Subject", subject);
+        if (name) {
+            root.setHeader("X-Name", name);
+        }
+        const body = new MimeNode("multipart/alternative");
+        body.children = [];
+        if (html) {
+            body.children.push(this.create(html, "text/html"));
+        }
+        if (text) {
+            body.children.push(this.create(text, "text/plain"));
+        }
+        root.children = [body];
+        if (attachments) {
+            for (const iterator of attachments) {
+                root.children.push(this.create(iterator));
+            }
+        }
+        return root;
+    }
+
+    static create(
+        /** @type {string | File} */ text,
+        /** @type {string} */ type,
+        /** @type {string} */id) {
+        if (typeof text === "string") {
+            const node = new MimeNode(type);
+            node.text = text;
+            return node;
+        }
+        const fileNode = new MimeNode(text.type);
+        fileNode.blobData = text;
+        fileNode.contentDisposition = new HeaderContentDisposition(type || "attachment");
+        fileNode.contentDisposition.filename = text.name;
+        fileNode.setHeader("Content-Disposition", fileNode.contentDisposition);
+        if (id) {
+            fileNode.setHeader("Content-Id", id);
+        }
+        return fileNode;
+    }
+
+    /** @type {string} */ encoded;
+
+    /** @type {MimeNode[]} */ children;
+
+    /** @type {HeaderContentType} */ contentType;
+
+    /** @type {HeaderContentDisposition} */ contentDisposition;
+
+    /** @returns {string} */
+    get text() {
+        let { encoded } = this;
+        if (!encoded) {
+            return;
+        }
+        // we need to convert byte array to utf8
+        const cte = this.contentTransferEncoding?.toLowerCase();
+        switch (cte) {
+            case "quoted-printable":
+                encoded = quotedPrintable.decode(encoded);
+                break;
+            case "base64":
+                encoded = btoa(encoded);
+                break;
+        }
+        return this.textContent ??= RawBuffer.decode(encoded, this.contentType?.charset);
+    }
+
+    set text( /** @type {string} */ v) {
+        this.contentTransferEncoding = "quoted-printable";
+        this.textContent = v;
+    }
+
+    /** @returns {Blob} */
+    get blob() {
+        // this will create blob..
+        if (this.contentTransferEncoding?.toLocaleLowerCase() !== "base64") {
+            throw new Error("Not supported");
+        }
+        return this.blobData ??= base64toBlob(this.encoded, this.contentType.type);
+    }
+
+    set blob( /** @type {Blob} */ v) {
+        this.blobData = v;
+    }
+
+    /** @returns {string} */
+    get contentTransferEncoding() {
+        return this.header("Content-Transfer-Encoding");
+    }
+
+    set contentTransferEncoding( /** @type {string} */ v) {
+        this.setHeader("Content-Transfer-Encoding", v);
+    }
+
+    /** @returns {string} */
+    get boundary() {
+        return this.contentType.boundary;
+    }
+
+    /** @returns {IterableIterator<MimeNode>} */
+    get descendent() {
+        return this.enumerate();
+    }
+
+    /** @type {Blob} */ blobData;
+    /** @type {string} */ textContent;
+
+    /** @type {Map<string, string | any>} */ headers;
+
+    constructor( /** @type {string} */ type) {
+        this.headers = new CIMap();
+        this.contentType = new HeaderContentType(type);
+        this.headers.set("Content-Type", this.contentType);
+    }
+
+    getFirstChild(
+        /** @type {string} */ contentType,
+        create = false
+    ) {
+        contentType = contentType.toLocaleLowerCase();
+        let child = QueryIterator.first(this.descendent, (x) => x.contentType.type === contentType);
+        if (!child && create) {
+            child = new MimeNode(contentType);
+            (this.children ??= []).push(child);
+        }
+        return child;
+    }
+
+    header(/** @type {string} */ name) {
+        return this.headers.get(name);
+    }
+
+    setHeader(
+        /** @type {string} */name,
+        /** @type {string} */ value
+    ) {
+        // name = name.toLocaleLowerCase();
+        // for (const [key] of this.headers.keys()) {
+        //     if (key.toLocaleLowerCase() === name) {
+        //         this.headers.set(key, value);
+        //         return;
+        //     }
+        // }
+
+        // // change name...
+        // switch(name.toLocaleLowerCase()) {
+        //     case "content-type":
+        //         name = "Content-Type";
+        //         break;
+        //     case "content-transfer-encoding":
+        //         name = "Content-Transfer-Encoding";
+        //         break;
+        //     case "content-disposition":
+        //         name = "Content-Disposition";
+        //         break;
+        // }
+
+        this.headers.set(name, value);
+    }
+
+    async asFile() {
+        const text = this.encoded.split("\n").map((x) => x.trim()).join("");
+        const url = `data:${this.contentType.type};base64,${text}`;
+        const blob = await fetch(url);
+        const af = new AttachmentFile(
+            [await blob.blob()],
+            this.contentDisposition.filename,
+            {
+                type: this.contentType.type,
+                contentId: this.header("Content-Id"),
+                disposition: this.contentDisposition.type
+            });
+        af.node = this;
+        return af;
+    }
+
+    async attachments(
+        /** @type {AttachmentFile[]} */ files = []) {
+        for (const iterator of this.children) {
+            if (iterator.children) {
+                await iterator.attachments(files);
+                continue;
+            }
+            if (iterator.contentDisposition?.type) {
+                files.push(await iterator.asFile());
+            }
+        }
+        return files;
+    }
+
+    async parse(
+        /** @type {LineStream} */ lines,
+        last = ""
+    ) {
+
+        await this.parseHeaders(lines);
+
+        let boundary = this.contentType.boundary;
+        if (!boundary) {
+            const data = [];
+
+            // parse data till end of the boundary
+            for await (const line of lines.read()) {
+                const trimmed = line.trimEnd();
+                if (trimmed.length === 0) {
+                    break;
+                }
+                if (trimmed === last) {
+                    break;
+                }
+                data.push(line);
+            }
+
+            this.encoded = data.join("\n");
+            return;
+        }
+
+        boundary = "--" + boundary;
+        const end = boundary + "--";
+
+        for (; ;) {
+            let boundaryFound = false;
+            // skip till boundary
+            for await (const line of lines.read()) {
+                if (line === boundary) {
+                    boundaryFound = true;
+                    break;
+                }
+                if (line === end) {
+                    return;
+                }
+            }
+
+            if (!boundaryFound) {
+                break;
+            }
+
+            // begin a new child..
+            const child = new MimeNode("");
+            await child.parse(lines, end);
+
+            (this.children ??= []).push(child);
+        }
+    }
+
+    async parseHeaders(
+        /** @type {LineStream} */ lines
+    ) {
+
+        let headerName = "";
+        let headerValue = "";
+
+        for await (const iterator of lines.read()) {
+            const value = iterator.trim();
+            if (value.length === 0) {
+                break;
+            }
+            if (/^[\x20\t]/.test(iterator)) {
+                headerValue += wordEncoding.decode(value);
+                continue;
+            }
+            if (headerValue) {
+                this.setHeader(headerName, headerValue);
+            }
+            const index = value.indexOf(":");
+            headerName = value.substring(0, index);
+            headerValue = wordEncoding.decode(value.substring(index+1).trim());
+        }
+
+        if (headerValue) {
+            this.setHeader(headerName, headerValue);
+        }
+
+        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(/** @type {TextWriter} */ writer) {
+
+        if (this.textContent) {
+            this.contentType.charset = "UTF-8";
+        }
+
+        if (this.children?.length) {
+            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}`);
+        }
+
+        writer.writeLine("");
+
+        // check if we have any children...
+        if (this.children?.length) {
+
+            const boundary = `--${this.contentType.boundary}`;
+
+            for (const iterator of this.children) {
+                writer.writeLine(boundary);
+                await iterator.save(writer);
+                writer.writeLine("");
+            }
+
+            writer.writeLine(boundary + "--");
+
+
+            return;
+        }
+
+        // check if we have text or binary
+        if (this.blobData) {
+            // convert to base64
+            const base64 = await RawBuffer.toBase64Async(this.blobData);
+            let start = 0;
+            const max = 80;
+            for (;;) {
+                if ( start + max > base64.length) {
+                    writer.writeLine(base64.substring(start));
+                    break;
+                }
+                writer.writeLine(base64.substring(start, start + max));
+                start += max;
+            }
+            writer.writeLine("");
+            return;
+        }
+
+        let text = this.text;
+        if (this.contentTransferEncoding === "quoted-printable") {
+            text = quotedPrintable.encode( RawBuffer.encode(text));
+        }
+        writer.writeLine(RawBuffer.encode(text));
+        writer.writeLine("");
+        return;
+}
+
+    /** @returns {IterableIterator<MimeNode>} */
+    *enumerate() {
+        yield this;
+        if (!this.children) {
+            return;
+        }
+        for (const iterator of this.children) {
+            yield* iterator.enumerate();
+        }
+    }
+}