imapkit 4.0.3 → 4.1.0

package/{lib → dist/esm}/commands/delete.js

@@ -1,42 +1,32 @@
-'use strict';
-
-module.exports = function (connection, parsed, data, callback) {
+export default function deleteCommand(connection, parsed, data, callback) {
     if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0) {
-        connection.send(
-            {
-                tag: parsed.tag,
-                command: 'BAD',
-                attributes: [
-                    {
-                        type: 'TEXT',
-                        value: 'DELETE expects mailbox name'
-                    }
-                ]
-            },
-            'INVALID COMMAND',
-            parsed,
-            data
-        );
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'DELETE expects mailbox name'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
         return callback();
     }
-
     const path = parsed.attributes[0].value;
-
     const mailbox = connection.server.getMailbox(path);
-
     if (!mailbox) {
         connection.sendStatus(parsed, data, 'NO', 'Mailbox does not exist', 'NONEXISTENT', 'DELETE FAILED');
         return callback();
     }
-
     try {
         connection.server.deleteMailbox(path);
-    } catch (E) {
+    }
+    catch (err) {
+        const E = err;
         connection.sendStatus(parsed, data, 'NO', E.message, E.code, 'DELETE FAILED');
         return callback();
     }
     connection.server.mailboxChanged('delete', mailbox.path, { mailbox });
-
     // RFC 2180 section 3.3: the other sessions that have the mailbox selected are disconnected with an untagged
     // BYE (RFC 2683 section 3.1.2), as they can not be told about the deletion in any other way
     connection.server.connections.forEach(other => {
@@ -44,21 +34,15 @@ module.exports = function (connection, parsed, data, callback) {
             other.bye('Selected mailbox was deleted', 'MAILBOX DELETED');
         }
     });
-
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: 'DELETE completed'
-                }
-            ]
-        },
-        'DELETE',
-        parsed,
-        data
-    );
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'DELETE completed'
+            }
+        ]
+    }, 'DELETE', parsed, data);
     return callback();
-};
+}

package/dist/esm/commands/examine.d.ts

@@ -0,0 +1,2 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+export default function examineCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;

package/dist/esm/commands/examine.js

@@ -0,0 +1,4 @@
+import { selectMailbox } from './select.js';
+export default function examineCommand(connection, parsed, data, callback) {
+    return selectMailbox(connection, parsed, data, callback, true);
+}

package/dist/esm/commands/expunge.d.ts

@@ -0,0 +1,2 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+export default function expungeCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;

package/dist/esm/commands/expunge.js

@@ -0,0 +1,17 @@
+export default function expungeCommand(connection, parsed, data, callback) {
+    if (connection.refuseReadOnly(parsed, data, 'EXPUNGE FAILED')) {
+        return callback();
+    }
+    connection.expungeDeleted(connection.selectedMailbox, false, true);
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'EXPUNGE Completed'
+            }
+        ]
+    }, 'EXPUNGE', parsed, data);
+    callback();
+}

package/dist/esm/commands/fetch.d.ts

@@ -0,0 +1,23 @@
+import type { Attribute, Callback, FetchHandler, IMAPConnection, Message, ParsedCommand } from '../types.js';
+declare const macros: Record<string, string[]>;
+/**
+ * Builds the data list of a FETCH response for a message, without any side effects like setting \Seen
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} message Message object
+ * @param {Array} params Fetch items
+ * @param {Array} [handlers] Handlers from getHandlers
+ * @param {Array} [names] Names from responseNames
+ * @return {Array} FETCH data items
+ * @throws {Error} for an unknown item or invalid item arguments
+ */
+declare function fetchResponse(connection: IMAPConnection, message: Message, params: Attribute[], handlers?: FetchHandler[], names?: Attribute[]): Attribute[];
+/**
+ * Shared implementation of FETCH and UID FETCH
+ *
+ * @param {Boolean} isUid If true, the sequence set lists UIDs and UID is always included in the response
+ */
+declare function processFetch(isUid: boolean, connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;
+declare const fetchCommand: (connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback) => void;
+export default fetchCommand;
+export { processFetch, macros, fetchResponse };

package/{lib → dist/esm}/commands/fetch.js

@@ -1,13 +1,9 @@
-'use strict';
-
-const fetchHandlers = require('./handlers/fetch');
-
+import fetchHandlers from './handlers/fetch.js';
 const macros = {
     ALL: ['FLAGS', 'INTERNALDATE', 'RFC822.SIZE', 'ENVELOPE'],
     FAST: ['FLAGS', 'INTERNALDATE', 'RFC822.SIZE'],
     FULL: ['FLAGS', 'INTERNALDATE', 'RFC822.SIZE', 'ENVELOPE', 'BODY']
 };
-
 /**
  * Returns the item names as they appear in a FETCH response, without .PEEK and only with the origin
  * octet of a partial range (RFC 3501 section 7.4.2)
@@ -16,7 +12,7 @@ const macros = {
  * @return {Array} names
  */
 function responseNames(params) {
-    return params.map(param => {
+    return params.map((param) => {
         const name = Object.assign({}, param, { value: param.value.replace(/\.PEEK\b/i, '') });
         if (name.partial) {
             name.partial = name.partial.slice(0, 1);
@@ -24,7 +20,6 @@ function responseNames(params) {
         return name;
     });
 }
-
 /**
  * Returns the handlers of fetch items
  *
@@ -43,7 +38,6 @@ function getHandlers(connection, params) {
         return handler;
     });
 }
-
 /**
  * Builds the data list of a FETCH response for a message, without any side effects like setting \Seen
  *
@@ -56,13 +50,12 @@ function getHandlers(connection, params) {
  * @throws {Error} for an unknown item or invalid item arguments
  */
 function fetchResponse(connection, message, params, handlers, names) {
-    handlers = handlers || getHandlers(connection, params);
-    names = names || responseNames(params);
+    const itemHandlers = handlers || getHandlers(connection, params);
+    const itemNames = names || responseNames(params);
     const response = [];
-    params.forEach((param, i) => response.push(names[i], handlers[i](connection, message, param)));
+    params.forEach((param, i) => response.push(itemNames[i], itemHandlers[i](connection, message, param)));
     return response;
 }
-
 /**
  * Shared implementation of FETCH and UID FETCH
  *
@@ -70,99 +63,76 @@ function fetchResponse(connection, message, params, handlers, names) {
  */
 function processFetch(isUid, connection, parsed, data, callback) {
     const command = isUid ? 'UID FETCH' : 'FETCH';
-
-    if (
-        !parsed.attributes ||
+    if (!parsed.attributes ||
         parsed.attributes.length !== 2 ||
         !parsed.attributes[0] ||
         ['ATOM', 'SEQUENCE'].indexOf(parsed.attributes[0].type) < 0 ||
         !parsed.attributes[1] ||
-        (['ATOM'].indexOf(parsed.attributes[1].type) < 0 && !Array.isArray(parsed.attributes[1]))
-    ) {
-        connection.send(
-            {
-                tag: parsed.tag,
-                command: 'BAD',
-                attributes: [
-                    {
-                        type: 'TEXT',
-                        value: command + ' expects sequence set and message item names'
-                    }
-                ]
-            },
-            'INVALID COMMAND',
-            parsed,
-            data
-        );
+        (['ATOM'].indexOf(parsed.attributes[1].type) < 0 && !Array.isArray(parsed.attributes[1]))) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: command + ' expects sequence set and message item names'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
         return callback();
     }
-
     const range = connection.limitRange(parsed, connection.getCommandRange(parsed.attributes[0].value, isUid));
     let params = [].concat(parsed.attributes[1] || []);
-
     if (parsed.attributes[1].type === 'ATOM' && Object.prototype.hasOwnProperty.call(macros, parsed.attributes[1].value.toUpperCase())) {
         params = macros[parsed.attributes[1].value.toUpperCase()].slice();
     }
-
     // messages that get \Seen set by this FETCH
     const seen = [];
     // untagged FETCH responses and their messages
     const responses = [];
     const messages = [];
-
     try {
         let uidExist = false;
         let flagsExist = false;
         let forceSeen = false;
-
         params.forEach((param, i) => {
             if (!param || (typeof param !== 'string' && param.type !== 'ATOM')) {
                 throw new Error('Invalid FETCH argument #' + (i + 1));
             }
-
             if (typeof param === 'string') {
                 param = params[i] = {
                     type: 'ATOM',
                     value: param
                 };
             }
-
             const key = param.value.toUpperCase();
-
             if (key === 'FLAGS') {
                 flagsExist = true;
             }
-
             if (key === 'UID') {
                 uidExist = true;
             }
-
             // RFC 3501 6.4.5: BODY[<section>] and items whose handler is marked with setsSeen set \Seen
             const handler = connection.server.fetchHandlers[key] || fetchHandlers[key];
             if (connection.canSetSeen() && ((key === 'BODY' && param.section) || (handler && handler.setsSeen))) {
                 forceSeen = true;
             }
         });
-
         if (forceSeen && !flagsExist) {
             params.push({
                 type: 'ATOM',
                 value: 'FLAGS'
             });
         }
-
         if (isUid && !uidExist) {
             params.push({
                 type: 'ATOM',
                 value: 'UID'
             });
         }
-
         const handlers = getHandlers(connection, params);
-
         // item names as they appear in the response
         const names = responseNames(params);
-
         // nothing is sent before every message is done, so a failing item leaves no partial output
         range.forEach(rangeMessage => {
             for (let i = 0, len = connection.server.fetchFilters.length; i < len; i++) {
@@ -170,14 +140,11 @@ function processFetch(isUid, connection, parsed, data, callback) {
                     return;
                 }
             }
-
             if (forceSeen && rangeMessage[1].flags.indexOf('\\Seen') < 0) {
                 rangeMessage[1].flags.push('\\Seen');
                 seen.push(rangeMessage[1]);
             }
-
             const response = fetchResponse(connection, rangeMessage[1], params, handlers, names);
-
             messages.push(rangeMessage[1]);
             responses.push({
                 tag: '*',
@@ -191,39 +158,31 @@ function processFetch(isUid, connection, parsed, data, callback) {
                 ]
             });
         });
-    } catch (E) {
+    }
+    catch (err) {
+        const E = err;
         // the failed FETCH did not set \Seen after all
         seen.forEach(message => connection.server.removeFlag(message.flags, '\\Seen'));
         // a handler can fail with NO and a response code, e.g. NO [UNKNOWN-CTE] (RFC 3516 section 4.3)
         connection.sendStatus(parsed, data, E.imapResponse === 'NO' ? 'NO' : 'BAD', E.message, E.code, command + ' FAILED');
         return callback();
     }
-
     // the message goes with its response, for output handlers
     responses.forEach((response, i) => connection.send(response, command, parsed, data, messages[i]));
-
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: command + ' Completed'
-                }
-            ]
-        },
-        command,
-        parsed,
-        data
-    );
-
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: command + ' Completed'
+            }
+        ]
+    }, command, parsed, data);
     // other sessions that have the mailbox selected learn about the new flags (RFC 3501 section 5.2)
     connection.notifyFlagChanges(seen);
     return callback();
 }
-
-module.exports = (connection, parsed, data, callback) => processFetch(false, connection, parsed, data, callback);
-module.exports.processFetch = processFetch;
-module.exports.macros = macros;
-module.exports.fetchResponse = fetchResponse;
+const fetchCommand = (connection, parsed, data, callback) => processFetch(false, connection, parsed, data, callback);
+export default fetchCommand;
+export { processFetch, macros, fetchResponse };

package/dist/esm/commands/handlers/fetch.d.ts

@@ -0,0 +1,12 @@
+import type { FetchHandler } from '../../types.js';
+declare const fetchHandlers: Record<string, FetchHandler>;
+export default fetchHandlers;
+/**
+ * Applies the partial range of a BODY[]<start.length> or BINARY[]<start.length> item
+ *
+ * @param {String} value Section contents
+ * @param {Array} [partial] Parsed partial range
+ * @return {String} The requested slice, or the whole value without a range
+ */
+declare function applyPartial(value: string, partial: number[] | null | undefined): string;
+export { applyPartial };

package/{lib → dist/esm}/commands/handlers/fetch.js

@@ -1,20 +1,13 @@
-'use strict';
-
+import { getMessageData, resolveNode, embeddedMessage, headerSection, render } from '../../mimeparser.js';
+import bodystructure from '../../bodystructure.js';
+import envelope from '../../envelope.js';
 const fetchHandlers = {};
-const mimeParser = require('../../mimeparser');
-const bodystructure = require('../../bodystructure');
-const envelope = require('../../envelope');
-
-const { getMessageData, resolveNode, embeddedMessage, headerSection, render } = mimeParser;
-
-module.exports = fetchHandlers;
+export default fetchHandlers;
 // not an IMAP item, so not enumerable among the handlers
 Object.defineProperty(fetchHandlers, 'applyPartial', { value: applyPartial });
-
 fetchHandlers.UID = function (connection, message) {
     return message.uid;
 };
-
 fetchHandlers.FLAGS = function (connection, message) {
     return connection.getFlags(message).map(flag => {
         return {
@@ -23,7 +16,6 @@ fetchHandlers.FLAGS = function (connection, message) {
         };
     });
 };
-
 fetchHandlers.BODYSTRUCTURE = function (connection, message) {
     return bodystructure(getMessageData(message).tree, {
         upperCaseKeys: true,
@@ -31,18 +23,15 @@ fetchHandlers.BODYSTRUCTURE = function (connection, message) {
         messageGlobal: connection.messageGlobal
     });
 };
-
 fetchHandlers.ENVELOPE = function (connection, message) {
     return envelope(getMessageData(message).tree.parsedHeader);
 };
-
 fetchHandlers['BODY.PEEK'] = function (connection, message, query) {
     if (!query.section) {
         throw new Error('BODY.PEEK requires ans argument list');
     }
     return fetchHandlers.BODY(connection, message, query);
 };
-
 /**
  * Lists the header field names of a HEADER.FIELDS or HEADER.FIELDS.NOT section
  */
@@ -50,7 +39,7 @@ function getFieldNames(query, key) {
     if (query.section.length !== 2 || !Array.isArray(query.section[1]) || !query.section[1].length) {
         throw new Error(key + ' expects a list of header fields');
     }
-    return query.section[1].map(queryKey => {
+    return query.section[1].map((queryKey) => {
         if (['ATOM', 'STRING', 'LITERAL'].indexOf(queryKey.type) < 0) {
             throw new Error('Invalid header field name in list');
         }
@@ -58,7 +47,6 @@ function getFieldNames(query, key) {
         return queryKey.value.toUpperCase();
     });
 }
-
 /**
  * Returns the contents of a BODY[<section>]
  *
@@ -71,11 +59,9 @@ function getSection(data, query, global) {
     if (!query.section.length) {
         return data.raw;
     }
-
     if (query.section[0].type !== 'ATOM') {
         throw new Error('Invalid BODY[<section>] identifier' + (query.section[0].value ? ' ' + query.section[0].type : ''));
     }
-
     // RFC 3501 9: section-part = nz-number *("." nz-number), optionally followed by a section-msgtext
     // (or MIME for a part)
     const match = (query.section[0].value || '')
@@ -84,41 +70,33 @@ function getSection(data, query, global) {
     if (!match || (match[2] === 'MIME' && !match[1])) {
         throw new Error('Invalid BODY[<section>] identifier ' + query.section[0].value);
     }
-
     const path = match[1] || '';
     const key = match[2] || '';
-    let fields;
-
+    let fields = [];
     if (['HEADER.FIELDS', 'HEADER.FIELDS.NOT'].indexOf(key) >= 0) {
         fields = getFieldNames(query, key);
-    } else if (query.section.length > 1) {
+    }
+    else if (query.section.length > 1) {
         throw new Error((key || 'Part number') + ' does not take any arguments');
     }
-
     // RFC 3501 6.4.5: a part that does not exist is returned as an empty string
     const node = path ? resolveNode(data.tree, path, global) : data.tree;
     if (!node) {
         return '';
     }
-
     // HEADER and TEXT with a part number refer to the encapsulated message of a message/rfc822 part
     // (and message/global in IMAP4rev2, RFC 9051 section 6.4.5.1), not to the part itself
     const message = path ? embeddedMessage(node, global) : node;
-
     switch (key) {
         case '':
             // BODY[1.2.3] is a part without its MIME header
             return render(node, true);
-
         case 'MIME':
             return headerSection(node);
-
         case 'TEXT':
             return message ? render(message, true) : '';
-
         case 'HEADER':
             return message ? headerSection(message) : '';
-
         default: {
             // HEADER.FIELDS and HEADER.FIELDS.NOT
             if (!message) {
@@ -126,8 +104,8 @@ function getSection(data, query, global) {
             }
             const wanted = key === 'HEADER.FIELDS';
             let value = '';
-            (message.header || []).forEach(line => {
-                const name = line.split(':').shift().toUpperCase().trim();
+            (message.header || []).forEach((line) => {
+                const name = line.split(':')[0].toUpperCase().trim();
                 if (fields.indexOf(name) >= 0 === wanted) {
                     value += line + '\r\n';
                 }
@@ -136,7 +114,6 @@ function getSection(data, query, global) {
         }
     }
 }
-
 /**
  * Applies the partial range of a BODY[]<start.length> or BINARY[]<start.length> item
  *
@@ -154,10 +131,8 @@ function applyPartial(value, partial) {
     }
     return value.substr(partial[0], partial[1]);
 }
-
 fetchHandlers.BODY = function (connection, message, query) {
     const data = getMessageData(message);
-
     if (!query.section) {
         if (query.partial) {
             throw new Error('BODY without a section does not take a partial range');
@@ -168,38 +143,31 @@ fetchHandlers.BODY = function (connection, message, query) {
             messageGlobal: connection.messageGlobal
         });
     }
-
     return {
         type: 'LITERAL',
         value: applyPartial(getSection(data, query, connection.messageGlobal), query.partial)
     };
 };
-
 fetchHandlers.INTERNALDATE = function (connection, message) {
     return message.internaldate;
 };
-
 fetchHandlers.RFC822 = function (connection, message) {
     return {
         type: 'LITERAL',
         value: getMessageData(message).raw
     };
 };
-
 // RFC 3501 6.4.5: RFC822 and RFC822.TEXT set \Seen, RFC822.HEADER is BODY.PEEK[HEADER] and does not
 fetchHandlers.RFC822.setsSeen = true;
-
 fetchHandlers['RFC822.SIZE'] = function (connection, message) {
     return getMessageData(message).raw.length;
 };
-
 fetchHandlers['RFC822.HEADER'] = function (connection, message) {
     return {
         type: 'LITERAL',
         value: headerSection(getMessageData(message).tree)
     };
 };
-
 fetchHandlers['RFC822.TEXT'] = function (connection, message) {
     return {
         type: 'LITERAL',
@@ -207,3 +175,4 @@ fetchHandlers['RFC822.TEXT'] = function (connection, message) {
     };
 };
 fetchHandlers['RFC822.TEXT'].setsSeen = true;
+export { applyPartial };

package/dist/esm/commands/handlers/flags.d.ts

@@ -0,0 +1,17 @@
+import type { IMAPConnection } from '../../types.js';
+declare const INVALID_KEYWORD_CHAR: RegExp;
+/**
+ * System flags are case-insensitive, so "\seen" becomes "\Seen"
+ *
+ * @param {String} flag Flag value
+ * @return {String} Normalized flag
+ */
+declare function normalizeSystemFlag(flag: string): string;
+/**
+ * Throws if a flag can not be stored: an unknown system flag (including \Recent) or an invalid keyword
+ *
+ * @param {Object} connection IMAP connection
+ * @param {String} flag Normalized flag value
+ */
+declare function checkSystemFlags(connection: IMAPConnection, flag: string): void;
+export { INVALID_KEYWORD_CHAR, normalizeSystemFlag, checkSystemFlags };

package/{lib → dist/esm}/commands/handlers/flags.js

@@ -1,11 +1,8 @@
-'use strict';
-
 // RFC 3501 9: flag-keyword = atom = 1*ATOM-CHAR, so a keyword can not contain atom-specials:
 // "(" / ")" / "{" / SP / CTL / list-wildcards / quoted-specials / resp-specials. 8-bit octets are
 // allowed, the parser accepts them in atoms as well
 // eslint-disable-next-line no-control-regex
 const INVALID_KEYWORD_CHAR = /[\x00-\x1f\x7f (){%*"\\\]]/;
-
 /**
  * System flags are case-insensitive, so "\seen" becomes "\Seen"
  *
@@ -18,7 +15,6 @@ function normalizeSystemFlag(flag) {
     }
     return flag;
 }
-
 /**
  * Throws if a flag can not be stored: an unknown system flag (including \Recent) or an invalid keyword
  *
@@ -30,13 +26,9 @@ function checkSystemFlags(connection, flag) {
         if (connection.server.systemFlags.indexOf(flag) < 0) {
             throw new Error('Invalid system flag ' + flag);
         }
-    } else if (!flag || INVALID_KEYWORD_CHAR.test(flag)) {
+    }
+    else if (!flag || INVALID_KEYWORD_CHAR.test(flag)) {
         throw new Error('Invalid flag keyword ' + JSON.stringify(flag));
     }
 }
-
-module.exports = {
-    INVALID_KEYWORD_CHAR,
-    normalizeSystemFlag,
-    checkSystemFlags
-};
+export { INVALID_KEYWORD_CHAR, normalizeSystemFlag, checkSystemFlags };