imapkit 4.0.3 → 4.1.1

package/dist/esm/commands/select.js

@@ -0,0 +1,214 @@
+export default function selectCommand(connection, parsed, data, callback) {
+    return selectMailbox(connection, parsed, data, callback, false);
+}
+/**
+ * Starts a SELECT or EXAMINE, also one that is going to fail: ENABLE is not allowed once a mailbox has been selected
+ * (RFC 5161 section 3.1), and the selected mailbox gets closed. CLOSED marks where the responses for the new mailbox
+ * start (RFC 7162 section 3.2.11, RFC 9051 sections 6.3.2 and 7.1)
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} parsed Parsed command
+ * @param {String} data Raw command
+ */
+function beginSelect(connection, parsed, data) {
+    connection.everSelected = true;
+    if (connection.state === 'Selected' && connection.server.closedChecks.some(check => check(connection))) {
+        connection.send({
+            tag: '*',
+            command: 'OK',
+            attributes: [
+                { type: 'SECTION', section: [{ type: 'ATOM', value: 'CLOSED' }] },
+                { type: 'TEXT', value: 'Previous mailbox closed' }
+            ]
+        }, 'CLOSED', parsed, data);
+    }
+}
+/**
+ * Shared implementation of SELECT and EXAMINE
+ *
+ * @param {Boolean} readOnly If true, the mailbox is opened read-only (EXAMINE)
+ */
+function selectMailbox(connection, parsed, data, callback, readOnly) {
+    const command = readOnly ? 'EXAMINE' : 'SELECT';
+    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: command + ' expects 1 mailbox argument'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
+        return callback();
+    }
+    const path = parsed.attributes[0].value;
+    beginSelect(connection, parsed, data);
+    const mailbox = connection.server.getMailbox(path);
+    if (!mailbox || mailbox.flags.indexOf('\\Noselect') >= 0) {
+        // a failed SELECT leaves no mailbox selected (RFC 3501 section 6.3.1)
+        connection.closeMailbox();
+        connection.sendStatus(parsed, data, 'NO', 'Mailbox does not exist', 'NONEXISTENT', command + ' FAILED');
+        return callback();
+    }
+    connection.state = 'Selected';
+    connection.selectedMailbox = mailbox;
+    connection.readOnly = readOnly;
+    connection.notificationQueue = [];
+    // \Recent is a session flag: a read-write session takes over the messages
+    // that no other session has seen yet (RFC 3501 section 2.3.2)
+    const recent = new Set();
+    connection.recent = recent;
+    mailbox.messages.forEach((message) => {
+        if (message.recent) {
+            recent.add(message);
+            if (!readOnly) {
+                delete message.recent;
+            }
+        }
+    });
+    const status = connection.server.getStatus(mailbox);
+    const permanentFlags = status.permanentFlags.map((flag) => {
+        return {
+            type: 'ATOM',
+            value: flag
+        };
+    });
+    connection.send({
+        tag: '*',
+        command: 'FLAGS',
+        attributes: [permanentFlags]
+    }, command + ' FLAGS', parsed, data);
+    if (mailbox.allowPermanentFlags) {
+        permanentFlags.push({
+            type: 'TEXT',
+            value: '\\*'
+        });
+    }
+    connection.send({
+        tag: '*',
+        command: 'OK',
+        attributes: [
+            {
+                type: 'SECTION',
+                section: [
+                    {
+                        type: 'ATOM',
+                        value: 'PERMANENTFLAGS'
+                    },
+                    // nothing can be changed in a read-only mailbox
+                    readOnly ? [] : permanentFlags
+                ]
+            },
+            {
+                type: 'TEXT',
+                value: readOnly ? 'No permanent flags permitted' : 'Flags permitted'
+            }
+        ]
+    }, command + ' PERMANENTFLAGS', parsed, data);
+    connection.send({
+        tag: '*',
+        attributes: [
+            mailbox.messages.length,
+            {
+                type: 'ATOM',
+                value: 'EXISTS'
+            }
+        ]
+    }, command + ' EXISTS', parsed, data);
+    connection.send({
+        tag: '*',
+        attributes: [
+            connection.recent.size,
+            {
+                type: 'ATOM',
+                value: 'RECENT'
+            }
+        ]
+    }, command + ' RECENT', parsed, data);
+    const firstUnseen = mailbox.messages.findIndex((message) => message.flags.indexOf('\\Seen') < 0);
+    if (firstUnseen >= 0) {
+        connection.send({
+            tag: '*',
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'SECTION',
+                    section: [
+                        {
+                            type: 'ATOM',
+                            value: 'UNSEEN'
+                        },
+                        firstUnseen + 1
+                    ]
+                },
+                {
+                    type: 'TEXT',
+                    value: 'First unseen message'
+                }
+            ]
+        }, command + ' UNSEEN', parsed, data);
+    }
+    connection.send({
+        tag: '*',
+        command: 'OK',
+        attributes: [
+            {
+                type: 'SECTION',
+                section: [
+                    {
+                        type: 'ATOM',
+                        value: 'UIDVALIDITY'
+                    },
+                    mailbox.uidvalidity
+                ]
+            },
+            {
+                type: 'TEXT',
+                value: 'UIDs valid'
+            }
+        ]
+    }, command + ' UIDVALIDITY', parsed, data);
+    connection.send({
+        tag: '*',
+        command: 'OK',
+        attributes: [
+            {
+                type: 'SECTION',
+                section: [
+                    {
+                        type: 'ATOM',
+                        value: 'UIDNEXT'
+                    },
+                    mailbox.uidnext
+                ]
+            },
+            {
+                type: 'TEXT',
+                value: 'Predicted next UID'
+            }
+        ]
+    }, command + ' UIDNEXT', parsed, data);
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'SECTION',
+                section: [
+                    {
+                        type: 'ATOM',
+                        value: readOnly ? 'READ-ONLY' : 'READ-WRITE'
+                    }
+                ]
+            },
+            {
+                type: 'TEXT',
+                value: 'Completed'
+            }
+        ]
+    }, command, parsed, data);
+    return callback();
+}
+export { selectMailbox, beginSelect };

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

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

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

@@ -1,63 +1,42 @@
-'use strict';
-
-const { parseStatusItems, sendStatus } = require('./handlers/status');
-
-module.exports = function (connection, parsed, data, callback) {
-    if (
-        !parsed.attributes ||
+import { parseStatusItems, sendStatus } from './handlers/status.js';
+export default function statusCommand(connection, parsed, data, callback) {
+    if (!parsed.attributes ||
         parsed.attributes.length !== 2 ||
         !parsed.attributes[0] ||
         ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0 ||
         !Array.isArray(parsed.attributes[1]) ||
-        !parsed.attributes[1].length
-    ) {
-        connection.send(
-            {
-                tag: parsed.tag,
-                command: 'BAD',
-                attributes: [
-                    {
-                        type: 'TEXT',
-                        value: 'STATUS expects mailbox argument and a list of status items'
-                    }
-                ]
-            },
-            'INVALID COMMAND',
-            parsed,
-            data
-        );
+        !parsed.attributes[1].length) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'STATUS expects mailbox argument and a list of status items'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
         return callback();
     }
-
     const path = parsed.attributes[0].value;
-
     // invalid arguments are BAD even for a mailbox that does not exist
     let items;
     try {
         items = parseStatusItems(connection.server, parsed.attributes[1], connection);
-    } catch (err) {
+    }
+    catch (err) {
         connection.sendStatus(parsed, data, 'BAD', err.message, false, 'STATUS FAILED');
         return callback();
     }
-
     const mailbox = connection.server.getMailbox(path);
-
     if (!mailbox || mailbox.flags.indexOf('\\Noselect') >= 0) {
         connection.sendStatus(parsed, data, 'NO', 'Mailbox does not exist', 'NONEXISTENT', 'STATUS FAILED');
         return callback();
     }
-
     sendStatus(connection, path, mailbox, items, parsed, data);
-
     // RFC 3501 section 6.3.10 and RFC 9051 section 6.3.11: STATUS SHOULD NOT be used on the selected mailbox. It
     // works, but the client gets the CLIENTBUG response code (RFC 5530 section 3) like RFC 9051 section 7.1 shows
     const clientBug = connection.state === 'Selected' && connection.selectedMailbox === mailbox;
-    connection.sendStatus(
-        parsed,
-        data,
-        'OK',
-        clientBug ? 'Status completed, STATUS SHOULD NOT be used on the selected mailbox' : 'Status completed',
-        clientBug && 'CLIENTBUG'
-    );
+    connection.sendStatus(parsed, data, 'OK', clientBug ? 'Status completed, STATUS SHOULD NOT be used on the selected mailbox' : 'Status completed', clientBug && 'CLIENTBUG');
     return callback();
-};
+}

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

@@ -0,0 +1,10 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+/**
+ * Shared implementation of STORE and UID STORE
+ *
+ * @param {Boolean} isUid If true, the sequence set lists UIDs
+ */
+declare function processStore(isUid: boolean, connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback): void;
+declare const storeCommand: (connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback) => void;
+export default storeCommand;
+export { processStore };

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

@@ -1,8 +1,5 @@
-'use strict';
-
-const storeHandlers = require('./handlers/store');
-const { restoreNilAtoms, isAtom } = require('../arguments');
-
+import storeHandlers from './handlers/store.js';
+import { restoreNilAtoms, isAtom } from '../arguments.js';
 /**
  * Returns the handler of a STORE data item, plugins first
  *
@@ -14,7 +11,6 @@ function getStoreHandler(connection, name) {
     name = String(name).toUpperCase();
     return connection.server.storeHandlers[name] || storeHandlers[name];
 }
-
 /**
  * Shared implementation of STORE and UID STORE
  *
@@ -22,7 +18,6 @@ function getStoreHandler(connection, name) {
  */
 function processStore(isUid, connection, parsed, data, callback) {
     const command = isUid ? 'UID STORE' : 'STORE';
-
     // a store handler with `astringValues` takes astrings, like the labels of X-GM-LABELS: these can be literals,
     // and NIL is a name there. Flags are atoms (RFC 3501 section 9: flag-list)
     const itemArgument = parsed.attributes && parsed.attributes[1];
@@ -30,122 +25,93 @@ function processStore(isUid, connection, parsed, data, callback) {
     const astringValues = !!(itemHandler && itemHandler.astringValues);
     const valueTypes = astringValues ? ['ATOM', 'STRING', 'LITERAL'] : ['ATOM', 'STRING'];
     if (astringValues) {
-        restoreNilAtoms(parsed, data, path => path[0] === 2);
+        restoreNilAtoms(parsed, data, (path) => path[0] === 2);
     }
-
-    if (
-        !parsed.attributes ||
+    if (!parsed.attributes ||
         parsed.attributes.length !== 3 ||
         !parsed.attributes[0] ||
         ['ATOM', 'SEQUENCE'].indexOf(parsed.attributes[0].type) < 0 ||
         !parsed.attributes[1] ||
         ['ATOM'].indexOf(parsed.attributes[1].type) < 0 ||
         !parsed.attributes[2] ||
-        !(valueTypes.indexOf(parsed.attributes[2].type) >= 0 || Array.isArray(parsed.attributes[2]))
-    ) {
-        connection.send(
-            {
-                tag: parsed.tag,
-                command: 'BAD',
-                attributes: [
-                    {
-                        type: 'TEXT',
-                        value: command + ' expects sequence set, item name and item value'
-                    }
-                ]
-            },
-            'INVALID COMMAND',
-            parsed,
-            data
-        );
+        !(valueTypes.indexOf(parsed.attributes[2].type) >= 0 || Array.isArray(parsed.attributes[2]))) {
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: command + ' expects sequence set, item name and item value'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
         return callback();
     }
-
     // A mailbox opened with EXAMINE is read-only (RFC 3501 6.3.2), so its flags can not be changed
     if (connection.refuseReadOnly(parsed, data, command + ' FAILED')) {
         return callback();
     }
-
     const range = connection.limitRange(parsed, connection.getCommandRange(parsed.attributes[0].value, isUid));
     const itemName = (parsed.attributes[1].value || '').toUpperCase();
     const itemValue = [].concat(parsed.attributes[2] || []);
     const affected = [];
     // if the sequence set includes a message that another session expunged without this session being told yet
     let hasExpunged = false;
-
     try {
         itemValue.forEach((item, i) => {
             if (!item || valueTypes.indexOf(item.type) < 0) {
                 throw new Error('Invalid item value #' + (i + 1));
             }
         });
-
         const handler = itemHandler || getStoreHandler(connection, itemName);
         if (!handler) {
             throw new Error('Invalid STORE argument ' + itemName);
         }
-
         range.forEach(rangeMessage => {
             if (rangeMessage[1].ghost) {
                 // RFC 2180 section 4.2: the flags of an expunged message are not stored
                 hasExpunged = true;
                 return;
             }
-
             for (let i = 0, len = connection.server.storeFilters.length; i < len; i++) {
                 if (!connection.server.storeFilters[i](connection, rangeMessage[1], parsed, rangeMessage[0])) {
                     return;
                 }
             }
-
             handler(connection, rangeMessage[1], itemValue, rangeMessage[0], parsed, data);
-
             affected.push(rangeMessage[1]);
         });
-    } catch (E) {
-        connection.send(
-            {
-                tag: parsed.tag,
-                command: 'BAD',
-                attributes: [
-                    {
-                        type: 'TEXT',
-                        value: E.message
-                    }
-                ]
-            },
-            command + ' FAILED',
-            parsed,
-            data
-        );
+    }
+    catch (err) {
+        const E = err;
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: E.message
+                }
+            ]
+        }, command + ' FAILED', parsed, data);
         return callback();
     }
-
     // RFC 2180 sections 4.2.2 and 4.2.3: when the set includes expunged messages, the others are stored and get
     // their FETCH responses, and the tagged NO tells the client to issue NOOP. With .SILENT the result is OK as
     // long as the other messages were stored (section 4.2.1)
     const failed = hasExpunged && !/\.SILENT$/.test(itemName);
-
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: failed ? 'NO' : 'OK',
-            attributes: [].concat(failed ? { type: 'SECTION', section: [{ type: 'ATOM', value: 'EXPUNGEISSUED' }] } : [], {
-                type: 'TEXT',
-                value: failed ? 'Some of the messages no longer exist' : command + ' completed'
-            })
-        },
-        command + (failed ? ' FAILED' : ' COMPLETE'),
-        parsed,
-        data,
-        affected
-    );
-
+    connection.send({
+        tag: parsed.tag,
+        command: failed ? 'NO' : 'OK',
+        attributes: [].concat(failed ? { type: 'SECTION', section: [{ type: 'ATOM', value: 'EXPUNGEISSUED' }] } : [], {
+            type: 'TEXT',
+            value: failed ? 'Some of the messages no longer exist' : command + ' completed'
+        })
+    }, command + (failed ? ' FAILED' : ' COMPLETE'), parsed, data, affected);
     // other sessions that have the mailbox selected learn about the new flags (RFC 3501 section 5.2)
     connection.notifyFlagChanges(affected);
-
     callback();
 }
-
-module.exports = (connection, parsed, data, callback) => processStore(false, connection, parsed, data, callback);
-module.exports.processStore = processStore;
+const storeCommand = (connection, parsed, data, callback) => processStore(false, connection, parsed, data, callback);
+export default storeCommand;
+export { processStore };

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

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

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

@@ -1,53 +1,36 @@
-'use strict';
-
-module.exports = function (connection, parsed, data, callback) {
+export default function subscribeCommand(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: 'SUBSCRIBE expects mailbox name'
-                    }
-                ]
-            },
-            'INVALID COMMAND',
-            parsed,
-            data
-        );
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'SUBSCRIBE expects mailbox name'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
         return callback();
     }
-
     const path = parsed.attributes[0].value;
-
     const mailbox = connection.server.getMailbox(path);
-
     if (!mailbox || mailbox.flags.indexOf('\\Noselect') >= 0) {
         connection.sendStatus(parsed, data, 'NO', 'Mailbox does not exist', 'NONEXISTENT', 'SUBSCRIBE FAILED');
         return callback();
     }
-
     if (!mailbox.subscribed) {
         mailbox.subscribed = true;
         connection.server.mailboxChanged('subscribe', mailbox.path);
     }
-
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: 'SUBSCRIBE completed'
-                }
-            ]
-        },
-        'SUBSCRIBE',
-        parsed,
-        data
-    );
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'SUBSCRIBE completed'
+            }
+        ]
+    }, 'SUBSCRIBE', parsed, data);
     return callback();
-};
+}

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

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

package/dist/esm/commands/uid-copy.js

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

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

@@ -0,0 +1,3 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+declare const uidFetchCommand: (connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback) => void;
+export default uidFetchCommand;

package/dist/esm/commands/uid-fetch.js

@@ -0,0 +1,3 @@
+import { processFetch } from './fetch.js';
+const uidFetchCommand = (connection, parsed, data, callback) => processFetch(true, connection, parsed, data, callback);
+export default uidFetchCommand;

package/dist/esm/commands/uid-search.d.ts

@@ -0,0 +1,3 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+declare const uidSearchCommand: (connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback) => void;
+export default uidSearchCommand;

package/dist/esm/commands/uid-search.js

@@ -0,0 +1,3 @@
+import { processSearch } from './search.js';
+const uidSearchCommand = (connection, parsed, data, callback) => processSearch(true, connection, parsed, data, callback);
+export default uidSearchCommand;

package/dist/esm/commands/uid-store.d.ts

@@ -0,0 +1,3 @@
+import type { Callback, IMAPConnection, ParsedCommand } from '../types.js';
+declare const uidStoreCommand: (connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback) => void;
+export default uidStoreCommand;

package/dist/esm/commands/uid-store.js

@@ -0,0 +1,3 @@
+import { processStore } from './store.js';
+const uidStoreCommand = (connection, parsed, data, callback) => processStore(true, connection, parsed, data, callback);
+export default uidStoreCommand;

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

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