eml-parser-qaap 1.1.15

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Bean
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# eml-parse-vqaap
+
+# srjikMou
+
+[RFC 822](https://www.w3.org/Protocols/rfc822/) EML file format parser and builder, Can be used in browser environment
+
+> fork from `eml-parse-vqaap`(used in Browser env) & `eml-format` (used in NodeJs env)
+
+1. fix `eml-parse-vqaap` for parsing html from the eml with `quoted-printable`
+2. add `data` with `base64` in attachment
+
+## start guide
+
+```javascript
+import { parseEml, readEml, GBKUTF8, decode } from 'eml-parse-vqaap';
+
+// const eml = await axios(http | ajax).get()
+// `.eml` file
+readEml(eml, (err, ReadEmlJson) => {});
+```
+
+## @types
+
+```typescript
+interface Attachment {
+	name: string;
+	contentType: string;
+	inline: boolean;
+	data: string | Uint8Array;
+	data64: string;
+	filename?: string;
+	mimeType?: string;
+	id?: string;
+	cid?: string;
+}
+
+interface ReadEmlJson {
+	attachments: Attachment;
+	date: Date | string;
+	subject: string;
+	from: EmailAddress | EmailAddress[] | null;
+	to: EmailAddress | EmailAddress[] | null;
+	cc?: EmailAddress | EmailAddress[] | null;
+	headers: EmlHeaders;
+	multipartAlternative?: {
+		'Content-Type': string;
+	};
+	text?: string;
+	textheaders?: BoundaryHeaders;
+	html?: string; // email html data
+	htmlheaders?: BoundaryHeaders;
+	attachments?: Attachment[];
+	data?: string;
+}
+```

package/dist/addressparser.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Creates a Tokenizer object for tokenizing address field strings
+ *
+ * @constructor
+ * @param {String} str Address field string
+ */
+export declare class Tokenizer {
+    str: string;
+    operatorCurrent: string;
+    operatorExpecting: string;
+    node: any;
+    escaped: boolean;
+    list: any[];
+    operators: any;
+    constructor(str: any);
+    /**
+     * Tokenizes the original input string
+     *
+     * @return {Array} An array of operator|text tokens
+     */
+    tokenize(): any[];
+    /**
+     * Checks if a character is an operator or text and acts accordingly
+     *
+     * @param {String} chr Character from the address field
+     */
+    checkChar(chr: any): void;
+}
+/**
+ * Parses structured e-mail addresses from an address field
+ *
+ * Example:
+ *
+ *    'Name <address@domain>'
+ *
+ * will be converted to
+ *
+ *     [{name: 'Name', address: 'address@domain'}]
+ *
+ * @param {String} str Address field
+ * @return {Array} An array of address objects
+ */
+export declare function addressparser(str: any, options?: any): {
+    name?: string;
+    address?: string;
+}[];

package/dist/charset.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Encodes an unicode string into an Uint8Array object as UTF-8
+ *
+ * @param {String} str String to be encoded
+ * @return {Uint8Array} UTF-8 encoded typed array
+ */
+export declare const encode: (str: string, fromCharset?: string) => Uint8Array;
+export declare const arr2str: (arr: Uint8Array) => string;
+/**
+ * Decodes a string from Uint8Array to an unicode string using specified encoding
+ *
+ * @param {Uint8Array} buf Binary data to be decoded
+ * @param {String} Binary data is decoded into string using this charset
+ * @return {String} Decoded string
+ */
+export declare function decode(buf: Uint8Array, fromCharset?: string): string;
+/**
+ * Convert a string from specific encoding to UTF-8 Uint8Array
+ *
+ * @param {String|Uint8Array} data Data to be encoded
+ * @param {String} Source encoding for the string (optional for data of type String)
+ * @return {Uint8Array} UTF-8 encoded typed array
+ */
+export declare const convert: (data: string | Uint8Array, fromCharset?: string | undefined) => Uint8Array;

package/dist/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @author superchow
+ * @emil superchow@live.cn
+ */
+import { Base64 } from 'js-base64';
+import { convert, decode, encode } from './charset';
+import { GB2312UTF8, mimeDecode, getBoundary } from './utils';
+import { EmailAddress, ParsedEmlJson, ReadedEmlJson, BuildOptions, CallbackFn, OptionOrNull, BoundaryRawData, BoundaryConvertedData } from './interface';
+/**
+ * create a boundary
+ */
+declare function createBoundary(): string;
+/**
+ * Builds e-mail address string, e.g. { name: 'PayPal', email: 'noreply@paypal.com' } => 'PayPal' <noreply@paypal.com>
+ * @param {String|EmailAddress|EmailAddress[]|null} data
+ */
+declare function toEmailAddress(data?: string | EmailAddress | EmailAddress[] | null): string;
+/**
+ * Gets character set name, e.g. contentType='.....charset='iso-8859-2'....'
+ * @param {String} contentType
+ * @returns {String|undefined}
+ */
+declare function getCharset(contentType: string): string | undefined;
+/**
+ * Gets name and e-mail address from a string, e.g. 'PayPal' <noreply@paypal.com> => { name: 'PayPal', email: 'noreply@paypal.com' }
+ * @param {String} raw
+ * @returns { EmailAddress | EmailAddress[] | null}
+ */
+declare function getEmailAddress(rawStr: string): EmailAddress | EmailAddress[] | null;
+/**
+ * decode section
+ * @param {String} str
+ * @returns {String}
+ */
+declare function unquoteString(str: string): string;
+/**
+ * Decodes 'quoted-printable'
+ * @param {String} value
+ * @param {String} charset
+ * @param {String} qEncoding whether the encoding is RFC-2047’s Q-encoding, meaning special handling of underscores.
+ * @returns {String}
+ */
+declare function unquotePrintable(value: string, charset?: string, qEncoding?: boolean): string;
+/**
+ * Parses EML file content and returns object-oriented representation of the content.
+ * @param {String} eml
+ * @param {OptionOrNull | CallbackFn<ParsedEmlJson>} options
+ * @param {CallbackFn<ParsedEmlJson>} callback
+ * @returns {string | Error | ParsedEmlJson}
+ */
+declare function parse(eml: string, options?: OptionOrNull | CallbackFn<ParsedEmlJson>, callback?: CallbackFn<ParsedEmlJson>): string | Error | ParsedEmlJson;
+/**
+ * Convert BoundaryRawData to BoundaryConvertedData
+ * @param {BoundaryRawData} boundary
+ * @returns {BoundaryConvertedData} Obj
+ */
+declare function completeBoundary(boundary: BoundaryRawData): BoundaryConvertedData | null;
+/**
+ * buid EML file by ReadedEmlJson or EML file content
+ * @param {ReadedEmlJson} data
+ * @param {BuildOptions | CallbackFn<string> | null} options
+ * @param {CallbackFn<string>} callback
+ */
+declare function build(data: ReadedEmlJson | string, options?: BuildOptions | CallbackFn<string> | null, callback?: CallbackFn<string>): string | Error;
+/**
+ * Parses EML file content and return user-friendly object.
+ * @param {String | ParsedEmlJson} eml EML file content or object from 'parse'
+ * @param { OptionOrNull | CallbackFn<ReadedEmlJson>} options EML parse options
+ * @param {CallbackFn<ReadedEmlJson>} callback Callback function(error, data)
+ */
+declare function read(eml: string | ParsedEmlJson, options?: OptionOrNull | CallbackFn<ReadedEmlJson>, callback?: CallbackFn<ReadedEmlJson>): ReadedEmlJson | Error | string;
+/**
+ * if you need
+ * eml-format all api
+ */
+export { getEmailAddress, toEmailAddress, createBoundary, getBoundary, getCharset, unquoteString, unquotePrintable, mimeDecode, Base64, convert, encode, decode, completeBoundary, parse as parseEml, read as readEml, build as buildEml, GB2312UTF8 as GBKUTF8, };

package/dist/interface.d.ts

@@ -0,0 +1,103 @@
+export interface KeyValue extends Object {
+    [k: string]: any;
+}
+export interface EmailAddress {
+    name: string;
+    email: string;
+}
+/**
+ * parse result
+ */
+export interface ParsedEmlJson {
+    headers: EmlHeaders;
+    body?: string | (BoundaryConvertedData | null)[];
+}
+/**
+ * read result
+ */
+export interface ReadedEmlJson {
+    date: Date | string;
+    subject: string;
+    from: EmailAddress | EmailAddress[] | null;
+    to: EmailAddress | EmailAddress[] | null;
+    cc?: EmailAddress | EmailAddress[] | null;
+    headers: EmlHeaders;
+    multipartAlternative?: {
+        'Content-Type': string;
+    };
+    text?: string;
+    textheaders?: BoundaryHeaders;
+    html?: string;
+    htmlheaders?: BoundaryHeaders;
+    attachments?: Attachment[];
+    data?: string;
+}
+/**
+ * Attachment file
+ */
+export interface Attachment {
+    name: string;
+    contentType: string;
+    inline: boolean;
+    data: string | Uint8Array;
+    data64: string;
+    filename?: string;
+    mimeType?: string;
+    id?: string;
+    qaapId?: string;
+    cid?: string;
+}
+/**
+ * EML headers
+ * @description `MIME-Version`, `Accept-Language`, `Content-Language` and `Content-Type` shuld Must exist when to build a EML file
+ */
+export interface EmlHeaders extends KeyValue {
+    Date?: string;
+    Subject?: string;
+    From?: string;
+    To?: string;
+    Cc?: string;
+    CC?: string;
+    'Content-Disposition'?: string | null;
+    'Content-Type'?: string | null;
+    'Content-Transfer-Encoding'?: string;
+    'MIME-Version'?: string;
+    'Content-ID'?: string;
+    'Accept-Language'?: string;
+    'Content-Language'?: string;
+    'Content-type'?: string | null;
+    'Content-transfer-encoding'?: string;
+}
+export interface Options {
+    headersOnly: boolean;
+}
+/**
+ * encode is not realized yet
+ */
+export interface BuildOptions extends Options {
+    encode?: boolean;
+}
+export declare type CallbackFn<T> = (error: any, result?: T) => void;
+export declare type OptionOrNull = Options | null;
+/**
+ * BoundaryRawData
+ */
+export interface BoundaryRawData {
+    boundary: string;
+    lines: string[];
+}
+/**
+ * Convert BoundaryRawData result
+ */
+export interface BoundaryConvertedData {
+    boundary: string;
+    part: {
+        headers: BoundaryHeaders;
+        body: string | Array<BoundaryConvertedData | string>;
+    };
+}
+export interface BoundaryHeaders extends KeyValue {
+    'Content-Type': string;
+    'Content-Transfer-Encoding'?: string;
+    'Content-Disposition'?: string;
+}

package/dist/utils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Gets the boundary name
+ * @param contentType - string
+ */
+export declare function getBoundary(contentType: string): string | undefined;
+export declare function getCharsetName(charset: string): string;
+export declare function guid(): string;
+export declare function wrap(s: string, i: number): string;
+/**
+ * Decodes mime encoded string to an unicode string
+ *
+ * @param {String} str Mime encoded string
+ * @param {String} [fromCharset='UTF-8'] Source encoding
+ * @return {String} Decoded unicode string
+ */
+export declare function mimeDecode(str?: string, fromCharset?: string): string;
+/**
+ * adjust string Or Error
+ * @param param
+ */
+export declare function isStringOrError(param: any): boolean;
+/**
+ * converting strings from gbk to utf-8
+ */
+export declare const GB2312UTF8: {
+    Dig2Dec: (s: string) => number;
+    Hex2Utf8: (s: string) => string;
+    Dec2Dig: (n1: number) => string;
+    Str2Hex: (s: string) => string;
+    GB2312ToUTF8: (s1: string) => string;
+    UTF8ToGB2312: (str1: string) => string;
+};