imapkit 4.0.2 → 4.1.0

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

@@ -1,9 +1,6 @@
-'use strict';
-
-const imapHandler = require('imap-handler');
-const { normalizeSystemFlag, checkSystemFlags } = require('./handlers/flags');
-const { restoreNilAtoms, isAstring } = require('../arguments');
-
+import imapHandler from 'imap-handler';
+import { normalizeSystemFlag, checkSystemFlags } from './handlers/flags.js';
+import { restoreNilAtoms, isAstring } from '../arguments.js';
 /**
  * Creates an error that refuses an APPEND like command
  *
@@ -20,9 +17,7 @@ function appendError(text, code, codeArgs, response) {
     err.responseCodeArgs = codeArgs || [];
     return err;
 }
-
-const badArgument = text => appendError(text, false, false, 'BAD');
-
+const badArgument = (text) => appendError(text, false, false, 'BAD');
 /**
  * Parses a flag list, flags are atoms, and \Recent or unknown system flags can not be set (RFC 3501 section 9)
  *
@@ -40,11 +35,11 @@ function parseFlags(connection, list) {
             checkSystemFlags(connection, value);
             return value;
         });
-    } catch {
+    }
+    catch {
         throw badArgument('Invalid flags argument');
     }
 }
-
 /**
  * Parses the messages of an APPEND like command. RFC 3502 and RFC 4466 section 3:
  * append-message = [SP flag-list] [SP date-time] SP append-data, where append-data is a literal
@@ -59,14 +54,11 @@ function parseFlags(connection, list) {
 function parseMessages(connection, args, maxMessages) {
     const server = connection.server;
     const messages = [];
-
     for (let i = 0; i < args.length;) {
         const message = { flags: [], internaldate: false, raw: false };
-
         if (Array.isArray(args[i])) {
             message.flags = parseFlags(connection, args[i++]);
         }
-
         // date-time is always a quoted string, a literal here is the message
         if (args[i] && args[i].type === 'STRING') {
             if (!server.validateInternalDate(args[i].value)) {
@@ -74,36 +66,33 @@ function parseMessages(connection, args, maxMessages) {
             }
             message.internaldate = args[i++].value;
         }
-
         const appendData = args[i++];
         const label = appendData && appendData.type === 'ATOM' ? String(appendData.value).toUpperCase() : '';
         if (appendData && appendData.type === 'LITERAL') {
             message.raw = appendData.value;
-        } else if (appendData && appendData.type === 'LITERAL8' && server.appendLiteral8) {
+        }
+        else if (appendData && appendData.type === 'LITERAL8' && server.appendLiteral8) {
             // RFC 3516 section 4.4: the message as a literal8, server.appendLiteral8 (BINARY) stores it
             message.raw = appendData.value;
             message.literal8 = true;
-        } else if (label && Object.hasOwn(server.appendDataHandlers, label) && i < args.length) {
+        }
+        else if (label && Object.hasOwn(server.appendDataHandlers, label) && i < args.length) {
             message.resolve = server.appendDataHandlers[label](connection, args[i++]);
-        } else {
+        }
+        else {
             throw badArgument('Invalid message source argument');
         }
-
         messages.push(message);
     }
-
     if (!messages.length) {
         throw badArgument('Missing message argument');
     }
-
     if (messages.length > maxMessages) {
         // only a single message unless MULTIAPPEND is supported (RFC 4466 section 3)
         throw badArgument('Only a single message can be appended');
     }
-
     return messages;
 }
-
 /**
  * Sends the response for an error from appendError()
  *
@@ -122,19 +111,12 @@ function sendAppendError(connection, parsed, data, err, description) {
         });
     }
     attributes.push({ type: 'TEXT', value: err.message });
-
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: err.imapResponse,
-            attributes
-        },
-        err.imapResponse === 'BAD' ? 'INVALID COMMAND' : description,
-        parsed,
-        data
-    );
+    connection.send({
+        tag: parsed.tag,
+        command: err.imapResponse,
+        attributes
+    }, err.imapResponse === 'BAD' ? 'INVALID COMMAND' : description, parsed, data);
 }
-
 /**
  * Finds the target mailbox name of an APPEND or REPLACE command when a literal of a message (or of a CATENATE TEXT
  * part) is announced. Only the start of the command up to the mailbox argument is parsed, so the data of earlier
@@ -152,27 +134,25 @@ function getPendingTarget(connection, command, line) {
         return false;
     }
     const mailboxPosition = options.mailboxArguments[0];
-
     // the literal of a CATENATE URL is not a message part
     if (/[ (]URL $/i.test(line.slice(-5))) {
         return false;
     }
-
     // an open CATENATE list is closed for parsing
-    const parse = text => {
+    const parse = (text) => {
         text = text.replace(/ $/, '');
         for (const suffix of ['', ')']) {
             try {
                 const parsed = imapHandler.parser(text + suffix);
-                restoreNilAtoms(parsed, text, path => path.length === 1 && path[0] === mailboxPosition);
+                restoreNilAtoms(parsed, text, (path) => path.length === 1 && path[0] === mailboxPosition);
                 return parsed.attributes || [];
-            } catch {
+            }
+            catch {
                 // try the next suffix
             }
         }
         return [];
     };
-
     // the command up to the first literal, or up to the end of it when that literal is the mailbox name
     const literal = line.match(/(~?)\{(\d+)\+?\}\r\n/);
     let attributes = parse(literal ? line.substr(0, literal.index) : line);
@@ -186,12 +166,12 @@ function getPendingTarget(connection, command, line) {
     }
     try {
         return connection.importMailboxName(pathArg.value);
-    } catch {
+    }
+    catch {
         // the command handler refuses the name
         return false;
     }
 }
-
 /**
  * A literal filter (`server.literalFilters`) that refuses the message of an APPEND or REPLACE to a mailbox that does
  * not exist before the client sends it, by not sending a continuation request (RFC 3502 section 6.3.11 example A004,
@@ -206,7 +186,6 @@ function refuseMissingTarget(connection, command, line) {
     const path = !connection.isBusy() && getPendingTarget(connection, command, line);
     return path !== false && connection.server.targetRefusal(path);
 }
-
 /**
  * Prepares the messages of an APPEND like command (APPEND, REPLACE): parses the arguments, checks
  * the target mailbox, builds the message sources and runs `server.appendChecks` through
@@ -232,28 +211,30 @@ function prepareAppend(connection, parsed, data, pathArg, args, options) {
             throw badArgument('Invalid mailbox argument');
         }
         const messages = parseMessages(connection, args, maxMessages);
-
         // getTargetMailbox sends the NO response itself
         const mailbox = connection.getTargetMailbox(pathArg.value, parsed, data, description);
         if (!mailbox) {
             return false;
         }
-
         messages.forEach(message => {
             if (message.resolve) {
                 message.raw = message.resolve();
-            } else if (message.literal8) {
+            }
+            else if (message.literal8) {
+                // literal8 is only set when server.appendLiteral8 exists, and then raw holds the literal
                 message.raw = connection.server.appendLiteral8(message.raw);
             }
         });
-
+        // every message source is built now
+        const prepared = messages;
         // checkAppend sends the NO response itself
-        if (!connection.checkAppend(mailbox, messages, parsed, data, description, { command: options.command, replaced: options.replaced })) {
+        if (!connection.checkAppend(mailbox, prepared, parsed, data, description, { command: options.command, replaced: options.replaced })) {
             return false;
         }
-
-        return { mailbox, messages };
-    } catch (err) {
+        return { mailbox, messages: prepared };
+    }
+    catch (error) {
+        const err = error;
         if (!err.imapResponse) {
             throw err;
         }
@@ -261,7 +242,6 @@ function prepareAppend(connection, parsed, data, pathArg, args, options) {
         return false;
     }
 }
-
 /**
  * Stores prepared messages. The sessions that have the target mailbox selected get EXISTS updates
  *
@@ -270,44 +250,26 @@ function prepareAppend(connection, parsed, data, pathArg, args, options) {
  * @return {Object} `{ mailbox, message, messages }`, message is the last stored message
  */
 function storeMessages(connection, prepared) {
-    const messages = prepared.messages.map(
-        message => connection.server.appendMessage(prepared.mailbox, message.flags, message.internaldate, message.raw).message
-    );
+    const messages = prepared.messages.map(message => connection.server.appendMessage(prepared.mailbox, message.flags, message.internaldate, message.raw).message);
     return { mailbox: prepared.mailbox, message: messages[messages.length - 1], messages };
 }
-
-module.exports = function (connection, parsed, data, callback) {
+export default function appendCommand(connection, parsed, data, callback) {
     const args = [].concat(parsed.attributes || []);
-
     const prepared = prepareAppend(connection, parsed, data, args.shift(), args, { command: 'APPEND' });
     if (!prepared) {
         return callback();
     }
-
     const appendResult = storeMessages(connection, prepared);
-
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: 'APPEND Completed'
-                }
-            ]
-        },
-        'APPEND',
-        parsed,
-        data,
-        appendResult
-    );
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'APPEND Completed'
+            }
+        ]
+    }, 'APPEND', parsed, data, appendResult);
     callback();
-};
-
-module.exports.appendError = appendError;
-module.exports.badArgument = badArgument;
-module.exports.prepareAppend = prepareAppend;
-module.exports.storeMessages = storeMessages;
-module.exports.getPendingTarget = getPendingTarget;
-module.exports.refuseMissingTarget = refuseMissingTarget;
+}
+export { appendError, badArgument, prepareAppend, storeMessages, getPendingTarget, refuseMissingTarget };

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

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

package/dist/esm/commands/capability.js

@@ -0,0 +1,29 @@
+export default function capabilityCommand(connection, parsed, data, callback) {
+    const capabilities = ['IMAP4rev1'];
+    Object.keys(connection.server.capabilities).forEach(key => {
+        if (connection.server.capabilities[key](connection)) {
+            capabilities.push(key);
+        }
+    });
+    connection.send({
+        tag: '*',
+        command: 'CAPABILITY',
+        attributes: capabilities.map(capability => {
+            return {
+                type: 'TEXT',
+                value: capability
+            };
+        })
+    }, 'CAPABILITY LIST', parsed, data, capabilities);
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'Completed'
+            }
+        ]
+    }, 'CAPABILITY COMPLETED', parsed, data, capabilities);
+    callback();
+}

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

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

package/dist/esm/commands/check.js

@@ -0,0 +1,13 @@
+export default function checkCommand(connection, parsed, data, callback) {
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'Completed'
+            }
+        ]
+    }, 'CHECK', parsed, data);
+    callback();
+}

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

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

package/dist/esm/commands/close.js

@@ -0,0 +1,20 @@
+export default function closeCommand(connection, parsed, data, callback) {
+    // a read-only mailbox is closed without removing anything
+    if (connection.canExpunge()) {
+        connection.expungeDeleted(connection.selectedMailbox, true);
+    }
+    // CLOSE does not send pending EXPUNGE or EXISTS responses (RFC 3501 section 6.4.2)
+    connection.notificationQueue = [];
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'Mailbox closed'
+            }
+        ]
+    }, 'CLOSE', parsed, data);
+    connection.closeMailbox();
+    return callback();
+}

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

@@ -0,0 +1,30 @@
+import type { Callback, IMAPConnection, Mailbox, Message, ParsedCommand } from '../types.js';
+/** The result of copyToMailbox(), the extra context of the tagged OK (UIDPLUS) */
+export interface CopyResult {
+    mailbox: Mailbox;
+    sourceUids: number[];
+    targetUids: number[];
+    /** the copied source messages */
+    messages: Message[];
+}
+export default function copyCommand(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;
+/**
+ * Shared implementation of COPY and UID COPY
+ *
+ * @param {Boolean} isUid If true, the sequence set holds UID values
+ */
+declare function copyMessages(connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback, isUid: boolean): void;
+/**
+ * Copies messages from the selected mailbox to another one, the copy step of COPY and MOVE.
+ * Sends a tagged NO and returns false if the target mailbox can not be used.
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} parsed Parsed command, with the sequence set and the mailbox name as arguments
+ * @param {String} data Raw command
+ * @param {Boolean} isUid If true, the sequence set holds UID values
+ * @param {String} failDescription Description for the failure response
+ * @param {Boolean} [isMove] If true, the messages are moved, the caller expunges them afterwards
+ * @return {Object|false} `{ mailbox, sourceUids, targetUids, messages }`, where messages lists the copied source messages
+ */
+declare function copyToMailbox(connection: IMAPConnection, parsed: ParsedCommand, data: string, isUid: boolean, failDescription: string, isMove?: boolean): CopyResult | false;
+export { copyMessages, copyToMailbox };

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

@@ -1,9 +1,6 @@
-'use strict';
-
-module.exports = function (connection, parsed, data, callback) {
+export default function copyCommand(connection, parsed, data, callback) {
     return copyMessages(connection, parsed, data, callback, false);
-};
-
+}
 /**
  * Shared implementation of COPY and UID COPY
  *
@@ -11,58 +8,41 @@ module.exports = function (connection, parsed, data, callback) {
  */
 function copyMessages(connection, parsed, data, callback, isUid) {
     const command = isUid ? 'UID COPY' : 'COPY';
-
-    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', 'STRING', 'LITERAL'].indexOf(parsed.attributes[1].type) < 0
-    ) {
-        connection.send(
-            {
-                tag: parsed.tag,
-                command: 'BAD',
-                attributes: [
-                    {
-                        type: 'TEXT',
-                        value: command + ' expects sequence set and a mailbox name'
-                    }
-                ]
-            },
-            'INVALID COMMAND',
-            parsed,
-            data
-        );
+        ['ATOM', 'STRING', 'LITERAL'].indexOf(parsed.attributes[1].type) < 0) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: command + ' expects sequence set and a mailbox name'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
         return callback();
     }
-
     const result = copyToMailbox(connection, parsed, data, isUid, command + ' FAIL');
     if (!result) {
         return callback();
     }
-
     // the result is the extra context info for UIDPLUS
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: command + ' Completed'
-                }
-            ]
-        },
-        command,
-        parsed,
-        data,
-        result
-    );
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: command + ' Completed'
+            }
+        ]
+    }, command, parsed, data, result);
     callback();
 }
-
 /**
  * Copies messages from the selected mailbox to another one, the copy step of COPY and MOVE.
  * Sends a tagged NO and returns false if the target mailbox can not be used.
@@ -76,33 +56,31 @@ function copyMessages(connection, parsed, data, callback, isUid) {
  * @return {Object|false} `{ mailbox, sourceUids, targetUids, messages }`, where messages lists the copied source messages
  */
 function copyToMailbox(connection, parsed, data, isUid, failDescription, isMove) {
-    const range = connection.limitRange(parsed, connection.getCommandRange(parsed.attributes[0].value, isUid));
-    const mailbox = connection.getTargetMailbox(parsed.attributes[1].value, parsed, data, failDescription);
+    // the command handler checked the arguments
+    const attributes = parsed.attributes;
+    const range = connection.limitRange(parsed, connection.getCommandRange(attributes[0].value, isUid));
+    const mailbox = connection.getTargetMailbox(attributes[1].value, parsed, data, failDescription);
     if (!mailbox) {
         return false;
     }
-
     const messages = range.map(rangeMessage => rangeMessage[1]);
-    if (messages.some(message => message.ghost)) {
+    if (messages.some((message) => message.ghost)) {
         // RFC 2180 section 4.4.1: nothing is copied when the set includes a message that another session expunged,
         // the pending EXPUNGE responses go out before the NO
         connection.sendStatus(parsed, data, 'NO', 'Some of the requested messages no longer exist', 'EXPUNGEISSUED', failDescription);
         return false;
     }
-
     if (!connection.checkAppend(mailbox, messages, parsed, data, failDescription, { move: !!isMove, source: connection.selectedMailbox })) {
         return false;
     }
-
     const sourceUids = [];
     const targetUids = [];
     // a range that is processed from the highest UID down (parsed.highestFirst) is still copied in UID order,
     // so the new UIDs follow the order of the source UIDs (RFC 9738 section 3.1 MOVE example)
-    (parsed.highestFirst ? messages.slice().reverse() : messages).forEach(message => {
+    (parsed.highestFirst ? messages.slice().reverse() : messages).forEach((message) => {
         sourceUids.push(message.uid);
         targetUids.push(connection.server.copyMessage(mailbox, message).message.uid);
     });
-
     return {
         mailbox,
         sourceUids,
@@ -110,6 +88,4 @@ function copyToMailbox(connection, parsed, data, isUid, failDescription, isMove)
         messages
     };
 }
-
-module.exports.copyMessages = copyMessages;
-module.exports.copyToMailbox = copyToMailbox;
+export { copyMessages, copyToMailbox };

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

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

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

@@ -1,52 +1,38 @@
-'use strict';
-
-module.exports = function (connection, parsed, data, callback) {
+export default function createCommand(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: 'CREATE expects mailbox name'
-                    }
-                ]
-            },
-            'INVALID COMMAND',
-            parsed,
-            data
-        );
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'CREATE expects mailbox name'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
         return callback();
     }
-
     const path = parsed.attributes[0].value;
-
     let mailbox;
     try {
         mailbox = connection.server.createMailbox(path);
-    } catch (E) {
+    }
+    catch (err) {
+        const E = err;
         // RFC 5530 response codes, e.g. [ALREADYEXISTS]
         connection.sendStatus(parsed, data, 'NO', E.message, E.code, 'CREATE FAILED');
         return callback();
     }
     connection.server.mailboxChanged('create', mailbox.path);
-
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: 'CREATE completed'
-                }
-            ]
-        },
-        'CREATE',
-        parsed,
-        data,
-        mailbox
-    );
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'CREATE completed'
+            }
+        ]
+    }, 'CREATE', parsed, data, mailbox);
     return callback();
-};
+}

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

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