@zone-eu/mailsplit 5.4.8 → 5.4.10

package/lib/node-rewriter.js

@@ -5,14 +5,26 @@
 const Transform = require('stream').Transform;
 const FlowedDecoder = require('./flowed-decoder');
 
+/** @typedef {import('..').MimeNode} MimeNode */
+/** @typedef {import('..').RewriterInput} RewriterInput */
+/** @typedef {import('..').FilterFunc} FilterFunc */
+/** @typedef {import('..').RewriterNode} RewriterNode */
+/** @typedef {import('..').DecoderStream} DecoderStream */
+/** @typedef {import('..').ContentStream} ContentStream */
+/** @typedef {import('..').ContinueCallback} ContinueCallback */
+
 /**
  * NodeRewriter Transform stream. Updates content for all nodes with specified mime type
  *
  * @constructor
- * @param {String} mimeType Define the Mime-Type to look for
- * @param {Function} rewriteAction Function to run with the node content
+ * @param {FilterFunc} filterFunc Function to select nodes to rewrite
+ * @param {Function} [rewriteAction] Function to run with the node content
  */
 class NodeRewriter extends Transform {
+    /**
+     * @param {FilterFunc} filterFunc
+     * @param {Function} [rewriteAction]
+     */
     constructor(filterFunc, rewriteAction) {
         let options = {
             readableObjectMode: true,
@@ -23,15 +35,28 @@ class NodeRewriter extends Transform {
         this.filterFunc = filterFunc;
         this.rewriteAction = rewriteAction;
 
+        /** @type {DecoderStream | false} */
         this.decoder = false;
+        /** @type {ContentStream | false} */
         this.encoder = false;
+        /** @type {ContinueCallback | false} */
         this.continue = false;
     }
 
+    /**
+     * @param {RewriterInput} data
+     * @param {BufferEncoding} encoding
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
     _transform(data, encoding, callback) {
         this.processIncoming(data, callback);
     }
 
+    /**
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
     _flush(callback) {
         if (this.decoder) {
             // emit an empty node just in case there is pending data to end
@@ -45,11 +70,17 @@ class NodeRewriter extends Transform {
         return callback();
     }
 
+    /**
+     * @param {RewriterInput} data
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
     processIncoming(data, callback) {
         if (this.decoder && data.type === 'body') {
             // data to parse
             if (!this.decoder.write(data.value)) {
-                return this.decoder.once('drain', callback);
+                this.decoder.once('drain', callback);
+                return;
             } else {
                 return callback();
             }
@@ -64,7 +95,8 @@ class NodeRewriter extends Transform {
                 this.encoder = false;
                 this.processIncoming(data, callback);
             };
-            return this.decoder.end();
+            this.decoder.end();
+            return;
         } else if (data.type === 'node' && this.filterFunc(data)) {
             // found matching node, create new handler
             this.emit('node', this.createDecodePair(data));
@@ -75,19 +107,24 @@ class NodeRewriter extends Transform {
         callback();
     }
 
+    /**
+     * @param {MimeNode} node
+     * @returns {RewriterNode}
+     */
     createDecodePair(node) {
-        this.decoder = node.getDecoder();
+        this.decoder = /** @type {DecoderStream} */ (node.getDecoder());
 
-        if (['base64', 'quoted-printable'].includes(node.encoding)) {
+        if (['base64', 'quoted-printable'].includes(node.encoding || '')) {
             this.encoder = node.getEncoder();
         } else {
             this.encoder = node.getEncoder('quoted-printable');
         }
 
+        /** @type {number | false} */
         let lastByte = false;
 
-        let decoder = this.decoder;
-        let encoder = this.encoder;
+        let decoder = /** @type {DecoderStream} */ (this.decoder);
+        let encoder = /** @type {ContentStream} */ (this.encoder);
         let firstChunk = true;
         decoder.$reading = false;
 
@@ -104,9 +141,6 @@ class NodeRewriter extends Transform {
                 firstChunk = false;
                 if (this.readable) {
                     this.push(node);
-                    if (node.type === 'body') {
-                        lastByte = node.value && node.value.length && node.value[node.value.length - 1];
-                    }
                 }
             }
 
@@ -144,9 +178,6 @@ class NodeRewriter extends Transform {
                 firstChunk = false;
                 if (this.readable) {
                     this.push(node);
-                    if (node.type === 'body') {
-                        lastByte = node.value && node.value.length && node.value[node.value.length - 1];
-                    }
                 }
             }
 
@@ -164,14 +195,14 @@ class NodeRewriter extends Transform {
             }
         });
 
-        if (/^text\//.test(node.contentType) && node.flowed) {
+        if (/^text\//.test(node.contentType || '') && node.flowed) {
             // text/plain; format=flowed is a special case
             let flowDecoder = decoder;
             decoder = new FlowedDecoder({
                 delSp: node.delSp,
-                encoding: node.encoding
+                encoding: node.encoding || false
             });
-            flowDecoder.on('error', err => {
+            flowDecoder.on('error', /** @param {Error} err */ err => {
                 decoder.emit('error', err);
             });
             flowDecoder.pipe(decoder);

package/lib/node-streamer.d.ts

@@ -0,0 +1,18 @@
+import { Transform } from 'node:stream';
+import type { FilterFunc, SplitterChunk, StreamerNode } from './types';
+
+declare class NodeStreamer extends Transform {
+    constructor(filterFunc: FilterFunc, streamAction?: Function);
+    on(event: 'data', listener: (data: SplitterChunk) => void): this;
+    on(event: 'node', listener: (data: StreamerNode) => void): this;
+    once(event: 'data', listener: (data: SplitterChunk) => void): this;
+    once(event: 'node', listener: (data: StreamerNode) => void): this;
+    addListener(event: 'data', listener: (data: SplitterChunk) => void): this;
+    addListener(event: 'node', listener: (data: StreamerNode) => void): this;
+    prependListener(event: 'data', listener: (data: SplitterChunk) => void): this;
+    prependListener(event: 'node', listener: (data: StreamerNode) => void): this;
+    emit(event: 'data', data: SplitterChunk): boolean;
+    emit(event: 'node', data: StreamerNode): boolean;
+}
+
+export = NodeStreamer;

package/lib/node-streamer.js

@@ -5,14 +5,25 @@
 const Transform = require('stream').Transform;
 const FlowedDecoder = require('./flowed-decoder');
 
+/** @typedef {import('..').MimeNode} MimeNode */
+/** @typedef {import('..').RewriterInput} RewriterInput */
+/** @typedef {import('..').FilterFunc} FilterFunc */
+/** @typedef {import('..').StreamerNode} StreamerNode */
+/** @typedef {import('..').DecoderStream} DecoderStream */
+/** @typedef {import('..').ContinueCallback} ContinueCallback */
+
 /**
  * NodeRewriter Transform stream. Updates content for all nodes with specified mime type
  *
  * @constructor
- * @param {String} mimeType Define the Mime-Type to look for
- * @param {Function} streamAction Function to run with the node content
+ * @param {FilterFunc} filterFunc Function to select nodes to stream
+ * @param {Function} [streamAction] Function to run with the node content
  */
 class NodeStreamer extends Transform {
+    /**
+     * @param {FilterFunc} filterFunc
+     * @param {Function} [streamAction]
+     */
     constructor(filterFunc, streamAction) {
         let options = {
             readableObjectMode: true,
@@ -23,15 +34,27 @@ class NodeStreamer extends Transform {
         this.filterFunc = filterFunc;
         this.streamAction = streamAction;
 
+        /** @type {DecoderStream | false} */
         this.decoder = false;
         this.canContinue = false;
+        /** @type {ContinueCallback | false} */
         this.continue = false;
     }
 
+    /**
+     * @param {RewriterInput} data
+     * @param {BufferEncoding} encoding
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
     _transform(data, encoding, callback) {
         this.processIncoming(data, callback);
     }
 
+    /**
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
     _flush(callback) {
         if (this.decoder) {
             // emit an empty node just in case there is pending data to end
@@ -45,12 +68,18 @@ class NodeStreamer extends Transform {
         return callback();
     }
 
+    /**
+     * @param {RewriterInput} data
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
     processIncoming(data, callback) {
         if (this.decoder && data.type === 'body') {
             // data to parse
             this.push(data);
             if (!this.decoder.write(data.value)) {
-                return this.decoder.once('drain', callback);
+                this.decoder.once('drain', callback);
+                return;
             } else {
                 return callback();
             }
@@ -73,7 +102,8 @@ class NodeStreamer extends Transform {
                 this.continue = () => doContinue();
             }
 
-            return this.decoder.end();
+            this.decoder.end();
+            return;
         } else if (data.type === 'node' && this.filterFunc(data)) {
             this.push(data);
             // found matching node, create new handler
@@ -85,18 +115,22 @@ class NodeStreamer extends Transform {
         callback();
     }
 
+    /**
+     * @param {MimeNode} node
+     * @returns {StreamerNode}
+     */
     createDecoder(node) {
-        this.decoder = node.getDecoder();
+        this.decoder = /** @type {DecoderStream} */ (node.getDecoder());
 
-        let decoder = this.decoder;
+        let decoder = /** @type {DecoderStream} */ (this.decoder);
         decoder.$reading = false;
 
-        if (/^text\//.test(node.contentType) && node.flowed) {
+        if (/^text\//.test(node.contentType || '') && node.flowed) {
             let flowDecoder = decoder;
             decoder = new FlowedDecoder({
                 delSp: node.delSp
             });
-            flowDecoder.on('error', err => {
+            flowDecoder.on('error', /** @param {Error} err */ err => {
                 decoder.emit('error', err);
             });
             flowDecoder.pipe(decoder);

package/lib/types.d.ts

@@ -0,0 +1,105 @@
+import type { PassThrough, Transform } from 'node:stream';
+import type Headers = require('./headers');
+
+export type Maybe<T> = T | false;
+export type PartNumberItem = number | 'TEXT';
+export type PartNumber = PartNumberItem[];
+
+export interface LibmimeOptions {
+    Iconv?: unknown;
+}
+
+export interface SplitterOptions extends LibmimeOptions {
+    ignoreEmbedded?: boolean;
+    defaultInlineEmbedded?: boolean;
+    maxHeadSize?: number;
+    maxChildNodes?: number;
+}
+
+export interface ChunkedPassthroughOptions {
+    chunkSize?: number;
+}
+
+export interface FlowedDecoderOptions extends LibmimeOptions {
+    delSp?: boolean;
+    encoding?: string | false;
+}
+
+export interface HeaderLine {
+    key: string;
+    line: string;
+}
+
+export interface DecodedHeader {
+    key: string;
+    value: string;
+}
+
+export interface MimeNode {
+    type: 'node';
+    root: boolean;
+    parentNode: MimeNode | false;
+    _boundary: Buffer | false;
+    _parentBoundary: Buffer | false;
+    _headerlen: number;
+    multipart: string | false;
+    encoding: string | false;
+    headers: Headers | false;
+    contentType: string | false;
+    charset: string | false;
+    disposition: string | false;
+    filename: string | false;
+    flowed: boolean;
+    delSp: boolean;
+    config: SplitterOptions;
+    partNr: PartNumber | false;
+    childPartNumbers: number;
+    rfc822: boolean;
+    messageNode?: boolean;
+
+    getPartNr(provided?: PartNumberItem): PartNumber;
+    addHeaderChunk(line?: Buffer | false): void;
+    parseHeaders(): void;
+    getHeaders(): Buffer;
+    setContentType(contentType?: string | false): void;
+    setCharset(charset?: string | false): void;
+    setFilename(filename?: string | false): void;
+    getDecoder(): Transform | PassThrough;
+    getEncoder(encoding?: string | false): Transform | PassThrough;
+}
+
+export interface MessageChunk {
+    node: MimeNode;
+    type: 'data' | 'body';
+    value: Buffer;
+}
+
+export interface EmptyChunk {
+    type: 'none';
+}
+
+export type SplitterChunk = MimeNode | MessageChunk;
+export type RewriterInput = SplitterChunk | EmptyChunk;
+export type FilterFunc = (node: MimeNode) => boolean;
+export type ErrorWithCode = Error & { code?: string };
+export type ContinueCallback = () => void;
+export type ContentStream = Transform | PassThrough;
+export type DecoderStream = ContentStream & { $reading?: boolean };
+
+export interface SplitterGroup {
+    node?: MimeNode;
+    type: 'none' | 'node' | 'data' | 'body';
+    value?: Buffer;
+}
+
+export interface RewriterNode {
+    node: MimeNode;
+    decoder: Transform;
+    encoder: Transform;
+}
+
+export interface StreamerNode {
+    node: MimeNode;
+    decoder: Transform;
+    done: () => void;
+}

package/package.json

@@ -1,35 +1,45 @@
 {
     "name": "@zone-eu/mailsplit",
-    "version": "5.4.8",
+    "version": "5.4.10",
     "description": "Split email messages into an object stream",
     "main": "index.js",
+    "types": "index.d.ts",
     "directories": {
         "test": "test"
     },
     "scripts": {
         "test": "grunt",
-        "update": "rm -rf node_modules package-lock.json && ncu -u && npm install"
+        "update": "rm -rf node_modules package-lock.json && ncu -u && npm install",
+        "typecheck": "tsc -p tsconfig.json"
     },
     "author": "Andris Reinman",
     "license": "(MIT OR EUPL-1.1+)",
     "dependencies": {
         "libbase64": "1.3.0",
-        "libmime": "5.3.7",
+        "libmime": "5.3.8",
         "libqp": "2.1.1"
     },
     "devDependencies": {
+        "@types/eslint": "9.6.1",
+        "@types/eslint-config-prettier": "6.11.3",
+        "@types/grunt": "0.4.32",
+        "@types/libmime": "5.3.0",
+        "@types/libqp": "1.1.3",
+        "@types/node": "25.7.0",
         "eslint": "8.29.0",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "9.1.0",
-        "grunt": "1.6.1",
+        "grunt": "1.6.2",
         "grunt-cli": "1.5.0",
         "grunt-contrib-nodeunit": "5.0.0",
         "grunt-eslint": "24.0.1",
-        "random-message": "1.1.0"
+        "random-message": "1.1.0",
+        "typescript": "6.0.3"
     },
     "files": [
         "lib",
-        "index.js"
+        "index.js",
+        "index.d.ts"
     ],
     "repository": {
         "type": "git",