@social-mail/shared 1.0.29 → 1.1.4

package/src/mime-parser/{MimeNode.js → MimeNode.ts}

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
 // import QueryIterator from "../../common/QueryIterator";
 import { AttachmentFile } from "./AttachmentFile.js";
 import { HeaderContentType } from "./HeaderContentType.js";
@@ -9,32 +8,15 @@ 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 interface IContentTypeObject {
-//     type: string;
-//     boundary?: string;
-//     charset?: string
-// };
+export class CIMap extends Map<string, any> {
+    private ci = new Map<string, 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) {
+    set(key: string, value: any): this {
         if (typeof key === "string") {
             let ck = this.ci.get(key);
-            if (ck === void 0) {
+            if (ck === undefined) {
                 ck = key.toLocaleLowerCase();
                 this.ci.set(ck, key);
             } else {
@@ -44,26 +26,29 @@ export class CIMap extends Map {
         return super.set(key, value);
     }
 
-    get(key) {
+    get(key: string): any {
         if (typeof key === "string") {
             const ck = key.toLocaleLowerCase();
-            key = this.ci.get(ck);
+            key = this.ci.get(ck) || key;
         }
         return super.get(key);
     }
-
 }
 
-
 export class MimeNode {
-
     static createMessage({
         html,
         subject,
         text = "",
         name = "",
         attachments = []
-    }) {
+    }: {
+        html?: string;
+        subject: string;
+        text?: string;
+        name?: string;
+        attachments?: any[];
+    }): MimeNode {
         const root = new MimeNode("multipart/mixed");
         root.setHeader("Subject", subject);
         if (name) {
@@ -87,11 +72,12 @@ export class MimeNode {
     }
 
     static create(
-        /** @type {string | File} */ text,
-        /** @type {string} */ type,
-        /** @type {string} */id) {
+        text: string | File,
+        type?: string,
+        id?: string
+    ): MimeNode {
         if (typeof text === "string") {
-            const node = new MimeNode(type);
+            const node = new MimeNode(type || "");
             node.text = text;
             return node;
         }
@@ -106,23 +92,36 @@ export class MimeNode {
         return fileNode;
     }
 
-    /** @type {string} */ encoded;
+    encoded?: string;
+    children?: MimeNode[];
+    get contentType() {
+        return this.headers.first("content-type").as(HeaderContentType);
+    }
+    get contentDisposition() {
+        return this.headers.first("content-disposition")?.as(HeaderContentDisposition);
+    }
 
-    /** @type {MimeNode[]} */ children;
+    set contentDisposition(v: HeaderContentDisposition) {
+        this.headers.set("content-disposition", v.toString());
+    }
 
-    /** @type {HeaderContentType} */ contentType;
+    textContent?: string;
+    blobData?: Blob;
+    headers: MimeHeaders;
 
-    /** @type {HeaderContentDisposition} */ contentDisposition;
+    constructor(type?: string) {
+        this.headers = new MimeHeaders();
+        this.headers.append("Content-Type", type);
+    }
 
-    /** @returns {string} */
-    get text() {
+    get text(): string {
         let tc = this.textContent;
         if (tc) {
             return tc;
         }
         let { encoded } = this;
         if (!encoded) {
-            return;
+            return "";
         }
         // we need to convert byte array to utf8
         const cte = this.contentTransferEncoding?.toLowerCase();
@@ -145,118 +144,69 @@ export class MimeNode {
         return tc;
     }
 
-    set text( /** @type {string} */ v) {
+    set text(v: string) {
         this.contentTransferEncoding = "quoted-printable";
         this.textContent = v;
     }
 
-    /** @returns {Blob} */
-    get blob() {
+    get blob(): Blob {
         // this will create blob..
         if (this.contentTransferEncoding?.toLocaleLowerCase() !== "base64") {
             throw new Error("Not supported");
         }
-        return this.blobData ??= base64toBlob(this.encoded, this.contentType.type);
+        return this.blobData ??= base64toBlob(this.encoded!, this.contentType.type);
     }
 
-    set blob( /** @type {Blob} */ v) {
+    set blob(v: Blob) {
         this.blobData = v;
     }
 
-    /** @returns {string} */
-    get contentTransferEncoding() {
-        return this.header("Content-Transfer-Encoding");
+    get contentTransferEncoding(): string | undefined {
+        return this.firstHeaderString("Content-Transfer-Encoding");
     }
 
-    set contentTransferEncoding( /** @type {string} */ v) {
-        this.setHeader("Content-Transfer-Encoding", v);
+    set contentTransferEncoding(v: string | undefined) {
+        this.headers.set("Content-Transfer-Encoding", v);
     }
 
-    /** @returns {string} */
-    get boundary() {
+    get boundary(): string | undefined {
         return this.contentType.boundary;
     }
 
-    /** @returns {IterableIterator<MimeNode>} */
-    get descendent() {
+    get descendent(): IterableIterator<MimeNode> {
         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;
+    firstHeaderString(name: string): any {
+        return this.headers.first(name)?.value;
     }
 
-    header(/** @type {string} */ name) {
-        return this.headers.get(name);
+    firstHeaderObject(name: string) {
+        return this.headers.first(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;
-        // }
-
+    setHeader(name: string, value: any): void {
         this.headers.set(name, value);
     }
 
-    async asFile() {
-        const text = this.encoded.split("\n").map((x) => x.trim()).join("");
+    async asFile(): Promise<AttachmentFile> {
+        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,
+            this.contentDisposition!.filename!,
             {
                 type: this.contentType.type,
-                contentId: this.header("Content-Id"),
-                disposition: this.contentDisposition.type
+                contentId: this.firstHeaderString("Content-Id"),
+                disposition: this.contentDisposition!.type as any
             });
         af.node = this;
         return af;
     }
 
-    async attachments(
-        /** @type {AttachmentFile[]} */ files = []) {
-        for (const iterator of this.children) {
+    async attachments(files: AttachmentFile[] = []): Promise<AttachmentFile[]> {
+        for (const iterator of this.children || []) {
             if (iterator.children) {
                 await iterator.attachments(files);
                 continue;
@@ -268,11 +218,7 @@ export class MimeNode {
         return files;
     }
 
-    async parse(
-        /** @type {LineStream} */ lines,
-        last = ""
-    ) {
-
+    async parse(lines: LineStream, last = ""): Promise<boolean> {
         await this.parseHeaders(lines);
 
         const end = last + "--";
@@ -319,15 +265,12 @@ export class MimeNode {
             this.children.push(child);
 
             if (isLast) {
-                return;
+                return true;
             }
         }
     }
 
-    async parseHeaders(
-        /** @type {LineStream} */ lines
-    ) {
-
+    async parseHeaders(lines: LineStream): Promise<void> {
         let headerName = "";
         let headerValue = "";
 
@@ -353,21 +296,9 @@ 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(/** @type {TextWriter} */ writer) {
-
+    async save(writer: TextWriter): Promise<void> {
         if (this.textContent) {
             this.contentType.charset = "UTF-8";
         }
@@ -376,26 +307,14 @@ 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("");
 
         // check if we have any children...
         if (this.children?.length) {
-
             const boundary = `--${this.contentType.boundary}`;
 
             for (const iterator of this.children) {
@@ -404,8 +323,6 @@ export class MimeNode {
             }
 
             writer.writeLine(boundary + "--");
-
-
             return;
         }
 
@@ -416,7 +333,7 @@ export class MimeNode {
             let start = 0;
             const max = 80;
             for (;;) {
-                if ( start + max > base64.length) {
+                if (start + max > base64.length) {
                     writer.writeLine(base64.substring(start));
                     break;
                 }
@@ -429,23 +346,20 @@ export class MimeNode {
         let text = this.text;
         switch(this.contentTransferEncoding) {
             case "quoted-printable":
-                text = quotedPrintable.encode( RawBuffer.encode(text));
+                text = quotedPrintable.encode(RawBuffer.encode(text));
                 writer.writeLine(text);
                 break;
             case "base64":
-                text = btoa( RawBuffer.encode(text, this.contentType.charset));
-                writer.writeLine(text);
+                text = btoa(RawBuffer.encode(text, this.contentType.charset));
+                writer.writeLineMax80Chars(text);
                 break;
             default:
-                writer.writeLine(text);
+                writer.writeLineMax80Chars(text);
                 break;
         }
-        // writer.writeLine("");
-        return;
 }
 
-    /** @returns {IterableIterator<MimeNode>} */
-    *enumerate() {
+    *enumerate(): IterableIterator<MimeNode> {
         yield this;
         if (!this.children) {
             return;
@@ -454,4 +368,23 @@ export class MimeNode {
             yield* iterator.enumerate();
         }
     }
+
+    getFirstChild(contentType: string, create = false): MimeNode | undefined {
+        contentType = contentType.toLocaleLowerCase();
+        // const child = QueryIterator.first(this.descendent, (x) => x.contentType.type === contentType);
+        // The QueryIterator.first is not available, so we'll implement it manually:
+        let child: MimeNode | undefined;
+        for (const node of this.descendent) {
+            if (node.contentType.type === contentType) {
+                child = node;
+                break;
+            }
+        }
+        
+        if (!child && create) {
+            child = new MimeNode(contentType);
+            (this.children ??= []).push(child);
+        }
+        return child;
+    }
 }

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/encoder/{RawBuffer.js → RawBuffer.ts}

@@ -1,6 +1,4 @@
-const toBuffer = (
-    /** @type {string} */ text
-    ) => {
+const toBuffer = (text: string): ArrayBuffer => {
     const bytes = new Uint8Array(text.length);
     for (let index = 0; index < text.length; index++) {
         bytes[index] = text.charCodeAt(index);
@@ -9,10 +7,10 @@ const toBuffer = (
 };
 
 export const RawBuffer = {
-    decode: (
-        /** @type {string} */ bytesAsString,
-        /** @type {string} */ encoding = "utf-8"
-    ) => {
+    decode(
+        bytesAsString: string,
+        encoding: string = "utf-8"
+    ): string {
         if (!encoding) {
             return bytesAsString;
         }
@@ -20,16 +18,16 @@ export const RawBuffer = {
         return te.decode(toBuffer(bytesAsString));
     },
 
-    encode: (
-        /** @type {string} */ text,
-        /** @type {string} */ encoding = "utf-8"
-    ) => {
-        if (!(/utf\-?8/i.test(encoding))) {
+    encode(
+        text: string,
+        encoding: string = "utf-8"
+    ): string {
+        if (!/utf\-?8/i.test(encoding)) {
             throw new Error(`Encoding ${encoding} not supported`);
         }
         const te = new TextEncoder();
         const array = te.encode(text);
-        const a = [];
+        const a: string[] = [];
         for (const iterator of array) {
             a.push(String.fromCharCode(iterator));
         }
@@ -37,16 +35,16 @@ export const RawBuffer = {
     },
 
     toBase64Async(
-        /** @type {Blob} */ blob,
-        asDataUrl = false
-    ) {
+        blob: Blob,
+        asDataUrl: boolean = false
+    ): Promise<string> {
         return new Promise<string>((resolve, reject) => {
         const reader = new FileReader();
         reader.onerror = () => {
             reject(reader.error);
         };
         reader.onload = () => {
-            const /** @type {string} */ text = reader.result;
+                const text: string = reader.result as string;
             if (asDataUrl) {
                 resolve(text);
                 return;

package/src/mime-parser/encoder/{base64-to-blob.js → base64-to-blob.ts}

@@ -1,26 +1,26 @@
 /**
- * 
- * @param {string} base64Data 
- * @param {string} contentType 
- * @returns 
+ * Converts a base64 string to a Blob
+ * @param {string} base64Data - The base64 encoded data
+ * @param {string} contentType - The content type of the blob
+ * @returns {Blob} - The resulting Blob object
  */
-export function base64toBlob(base64Data, contentType) {
+export function base64toBlob(base64Data: string, contentType: string): Blob {
     contentType = contentType || '';
     const sliceSize = 1024;
     const byteCharacters = atob(base64Data);
     const bytesLength = byteCharacters.length;
     const slicesCount = Math.ceil(bytesLength / sliceSize);
-    const byteArrays = new Array(slicesCount);
+    const byteArrays: Uint8Array[] = new Array(slicesCount);
 
     for (let sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {
         const begin = sliceIndex * sliceSize;
         const end = Math.min(begin + sliceSize, bytesLength);
 
-        const bytes = new Array(end - begin);
+        const bytes: number[] = new Array(end - begin);
         for (let offset = begin, i = 0; offset < end; ++i, ++offset) {
             bytes[i] = byteCharacters[offset].charCodeAt(0);
         }
         byteArrays[sliceIndex] = new Uint8Array(bytes);
     }
-    return new Blob(byteArrays, { type: contentType });
+    return new Blob(byteArrays as any, { type: contentType });
 }

package/src/mime-parser/encoder/{quoted-printable.js → quoted-printable.ts}

@@ -1,8 +1,8 @@
 // Original Source Code: https://github.com/mathiasbynens/quoted-printable/blob/master/quoted-printable.js
 
-
 const stringFromCharCode = String.fromCharCode;
-const decode = function(input) {
+
+const decode = function(input: string): string {
     return input
         // https://tools.ietf.org/html/rfc2045#section-6.7, rule 3:
         // “Therefore, when decoding a `Quoted-Printable` body, any trailing white
@@ -17,26 +17,23 @@ const decode = function(input) {
         // combination of two hexidecimal digits. For optimal compatibility,
         // lowercase hexadecimal digits are supported as well. See
         // https://tools.ietf.org/html/rfc2045#section-6.7, note 1.
-        .replace(/=([a-fA-F0-9]{2})/g, function($0, $1) {
+        .replace(/=([a-fA-F0-9]{2})/g, function($0: string, $1: string): string {
             const codePoint = parseInt($1, 16);
             return stringFromCharCode(codePoint);
         });
 };
 
-const handleTrailingCharacters =
-    function(
-        /** @type {string} */
-        text) {
+const handleTrailingCharacters = function(text: string): string {
     return text
         .replace(/\x20$/, '=20') // Handle trailing space.
         .replace(/\t$/, '=09'); // Handle trailing tab.
 };
 
 const regexUnsafeSymbols = /[\0-\x08\n-\x1F=\x7F-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
-const encode = function(text) {
 
+const encode = function(text: string): string {
     // Encode symbols that are definitely unsafe (i.e. unsafe in any context).
-    const encoded = text.replace(regexUnsafeSymbols, function(symbol) {
+    const encoded = text.replace(regexUnsafeSymbols, function(symbol: string): string {
         if (symbol > '\xFF') {
             throw RangeError(
                 '`quotedPrintable.encode()` expects extended ASCII input only. ' +
@@ -55,8 +52,9 @@ const encode = function(text) {
     const lines = encoded.split(/\r\n?|\n/g);
     let lineIndex = -1;
     const lineCount = lines.length;
-    const result = [];
-    let buffer;
+    const result: string[] = [];
+    let buffer: string;
+    
     while (++lineIndex < lineCount) {
         const line = lines[lineIndex];
         // Leave room for the trailing `=` for soft line breaks.

package/src/mime-parser/encoder/{word-encoding.js → word-encoding.ts}

@@ -5,20 +5,20 @@ const isEncodedRegEx = /\=\?([^\?\s]+)\?([^\?\s]{1})\?([^\s\?]+)\?\=\s*/gm;
 const hexToUnicode = /(\=([0-9a-f]{2}))|(\_)/gmi;
 
 const decode = (
-    /** @type {string} */ text
-    ) => {
-    return text.replace(isEncodedRegEx, (matched, encoding, format, /** @type {string} */ buffer) => {
+    text: string
+): string => {
+    return text.replace(isEncodedRegEx, (matched: string, encoding: string, format: string, buffer: string): string => {
         if (/b/i.test(format)) {
             return RawBuffer.decode(atob(buffer), encoding);
         }
         if (/q/i.test(format)) {
-            const replaced = buffer.replace(hexToUnicode, (m, group, /** @type {string} */ code, ) => {
+            const replaced = buffer.replace(hexToUnicode, (m: string, group: string, code: string): string => {
                 if (m === "_") {
                     return " ";
                 }
                 return String.fromCharCode(parseInt(code, 16));
             });
-            return RawBuffer.decode( replaced, encoding);
+            return RawBuffer.decode(replaced, encoding);
         }
         return matched;
     });
@@ -29,7 +29,7 @@ const isSimpleText = /[0-9a-zA-Z\x20]/;
 export const wordEncoding = {
     decode,
 
-    encode: (/** @type {string} */ word, ifNeeded = false) => {
+    encode: (word: string, ifNeeded: boolean = false): string => {
 
         if(ifNeeded) {
             if(isSimpleText.test(word)) {

package/src/mime-parser/{parsePairs.js → parsePairs.ts}

@@ -1,14 +1,15 @@
 import { tokenize, tokenizeMax } from "./tokenizer.js";
 
-
 export const parsePairs = (
-    /** @type {string} */ text,
-    /** @type {string} */ emptyName) => {
+    text: string,
+    emptyName?: string
+): Record<string, string> & { toString(): string } => {
     const pairs = {
         toString() {
             return text;
         }
-    };
+    } as Record<string, string> & { toString(): string };
+    
     for (const iterator of tokenize(text, ";")) {
         const trimmed = iterator.trim();
         if (!trimmed) {