imapkit 4.0.3 → 4.1.1

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

@@ -0,0 +1,85 @@
+import type { Attribute, IMAPConnection, IMAPError, IMAPServer, Message, MessageRange, ParsedCommand } from '../../types.js';
+/** The type of a search key argument: a type name, or a function that parses the value and throws for an invalid one */
+export type SearchArgumentType = string | ((value: string) => any);
+/** The argument types of a search key, or a function that decides them from the criteria that follow the key */
+export type SearchKeyTypes = SearchArgumentType[] | ((list: Attribute[]) => SearchArgumentType[]);
+/** A node of the query tree that the search builds from the criteria */
+export interface SearchNode {
+    key: string;
+    args: any[];
+    /** the messages of a sequence set (`_SEQ`) or a UID set */
+    set?: Set<Message> | undefined;
+    /** the lower cased string to look for */
+    needle?: string | undefined;
+}
+/** Resolves a sequence set of the criteria */
+export type RangeResolver = (range: string, isUid: boolean) => MessageRange;
+/** The result of a search */
+export interface SearchResult {
+    /** the matching messages */
+    list: Message[];
+    /** sequence numbers by UID */
+    numbers: Record<number, number>;
+    /** the search keys used in the criteria, other than sequence sets */
+    keys: Set<string>;
+    /** checks a message against the same criteria later */
+    matches: (message: Message, index: number) => boolean;
+}
+/**
+ * Creates an error that is reported to the client as BAD
+ */
+declare function badError(message: string): IMAPError;
+/**
+ * Date of a date-time value, disregarding time and timezone, as a comparable YYYY-MM-DD string,
+ * or false when it can not be parsed
+ *
+ * @param {String} dateTime Date-time value, e.g. "14-Sep-2013 21:22:28 -0300"
+ * @return {String|Boolean} date or false
+ */
+declare function getDateKey(dateTime: string): string | false;
+/**
+ * Converts the parsed search criteria of a command to the values the search takes, parenthesized lists stay nested
+ *
+ * @param {Array} attributes Parsed arguments
+ * @return {Array} values
+ * @throws {Error} BAD error for an argument that can not be a search key or its value
+ */
+declare function criteriaValues(attributes: Attribute[]): any[];
+/**
+ * Answers a failed search with NO, or BAD for `err.imapResponse` "BAD": the BADCHARSET response code with the
+ * supported charsets (RFC 3501 section 7.1, RFC 5256 section 3), or the response code a search limit set
+ * (`err.responseCode`), and the text
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} parsed Parsed command
+ * @param {String} data Raw command
+ * @param {Error} err Search error
+ * @param {String} description Description for output handlers
+ */
+declare function sendSearchError(connection: IMAPConnection, parsed: ParsedCommand, data: string, err: IMAPError, description: string): void;
+/**
+ * Checks if SEARCH criteria refer to messages by sequence number (RFC 3501 section 5.5), that is,
+ * if a sequence set is used as a search key. Arguments of search keys, like the UID set of UID
+ * or a string that looks like a number, are not search keys.
+ *
+ * @param {Object} server IMAP server
+ * @param {Array} attributes Parsed SEARCH arguments, nested lists are arrays
+ * @return {Boolean} true if a sequence set key occurs
+ */
+declare function hasSequenceSetKey(server: IMAPServer, attributes: Attribute[]): boolean;
+/**
+ * Searches messages. Errors thrown for the client are answered with BAD when `imapResponse` is "BAD",
+ * otherwise NO. SORT and THREAD send `responseCode` (a list of atoms) as the response code
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Array} messageSource Messages of the selected mailbox, as the session sees them
+ * @param {Array} params Search criteria: strings, and arrays for parenthesized lists
+ * @param {Function} [getMessageRange] Resolves the sequence sets of the criteria, `(range, isUid)`, defaults to
+ *        the selected mailbox of the connection. Used to search a mailbox that is not selected
+ * @return {Object} `{ list, numbers, keys, matches }`, the matching messages, the sequence numbers by UID,
+ *         the set of search keys used in the criteria and a `matches(message, index)` function that checks
+ *         a message against the same criteria later. Sequence sets in the criteria stay as they were resolved
+ *         now, they are not evaluated again
+ */
+export default function searchHandlers(connection: IMAPConnection, messageSource: Message[], params: any, getMessageRange?: RangeResolver | null): SearchResult;
+export { hasSequenceSetKey, getDateKey, badError, criteriaValues, sendSearchError };

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

@@ -1,11 +1,8 @@
-'use strict';
-
-const { isUtf8 } = require('buffer');
-const { getMessageData, render } = require('../../mimeparser');
-const { monthIndex, dateKey, parseDateTime, parseHeaderDate } = require('../../dates');
-const { MAX_NUMBER, MAX_NUMBER64, isNumber } = require('../../numbers');
-const { decodeHeader, decodeUtf8 } = require('../../encoded-words');
-
+import { isUtf8 } from 'node:buffer';
+import { getMessageData, render } from '../../mimeparser.js';
+import { monthIndex, dateKey, parseDateTime, parseHeaderDate } from '../../dates.js';
+import { MAX_NUMBER, MAX_NUMBER64, isNumber } from '../../numbers.js';
+import { decodeHeader, decodeUtf8 } from '../../encoded-words.js';
 // RFC 3501 6.4.4 search keys and their arguments
 const searchKeys = {
     ALL: [],
@@ -44,10 +41,8 @@ const searchKeys = {
     UNKEYWORD: ['string'],
     UNSEEN: []
 };
-
 // Charsets accepted for the CHARSET argument (RFC 3501 6.4.4: US-ASCII must be supported)
 const charsets = ['US-ASCII', 'UTF-8'];
-
 /**
  * Creates an error that is reported to the client as BAD
  */
@@ -56,7 +51,6 @@ function badError(message) {
     err.imapResponse = 'BAD';
     return err;
 }
-
 /**
  * Parses an RFC 3501 date argument (date-day "-" date-month "-" date-year) to a comparable YYYY-MM-DD string
  */
@@ -68,7 +62,6 @@ function parseQueryDate(value) {
     }
     return date;
 }
-
 /**
  * Date of a date-time value, disregarding time and timezone, as a comparable YYYY-MM-DD string,
  * or false when it can not be parsed
@@ -80,14 +73,12 @@ function getDateKey(dateTime) {
     const date = parseDateTime(dateTime);
     return date ? dateKey(date.day, date.month, date.year) : false;
 }
-
 /**
  * Date of the internal date of a message, disregarding time and timezone, or false when it can not be parsed
  */
 function getInternalDate(message) {
     return getDateKey(message.internaldate);
 }
-
 /**
  * Date of the Date header of a message, disregarding time and timezone (RFC 3501 section 6.4.4, unlike the
  * sent date of SORT it is not adjusted to UTC). Falls back to the internal date
@@ -96,7 +87,6 @@ function getSentDate(message) {
     const date = parseHeaderDate(getMessageData(message).tree.parsedHeader.date);
     return date ? dateKey(date.day, date.month, date.year) : getInternalDate(message);
 }
-
 /**
  * Converts the parsed search criteria of a command to the values the search takes, parenthesized lists stay nested
  *
@@ -116,7 +106,6 @@ function criteriaValues(attributes) {
     };
     return attributes.map(convert);
 }
-
 /**
  * Answers a failed search with NO, or BAD for `err.imapResponse` "BAD": the BADCHARSET response code with the
  * supported charsets (RFC 3501 section 7.1, RFC 5256 section 3), or the response code a search limit set
@@ -133,15 +122,15 @@ function sendSearchError(connection, parsed, data, err, description) {
     if (err.code === 'BADCHARSET') {
         attributes.push({
             type: 'SECTION',
-            section: [{ type: 'ATOM', value: 'BADCHARSET' }, err.charsets.map(value => ({ type: 'ATOM', value }))]
+            section: [{ type: 'ATOM', value: 'BADCHARSET' }, err.charsets.map((value) => ({ type: 'ATOM', value }))]
         });
-    } else if (err.responseCode) {
-        attributes.push({ type: 'SECTION', section: err.responseCode.map(value => ({ type: 'ATOM', value: String(value) })) });
+    }
+    else if (err.responseCode) {
+        attributes.push({ type: 'SECTION', section: err.responseCode.map((value) => ({ type: 'ATOM', value: String(value) })) });
     }
     attributes.push({ type: 'TEXT', value: err.message });
     connection.send({ tag: parsed.tag, command: err.imapResponse === 'BAD' ? 'BAD' : 'NO', attributes }, description, parsed, data);
 }
-
 /**
  * Lower cases ASCII letters only, so that 8-bit octets in binary strings stay intact. RFC 9051
  * section 6.4.4 asks for case insensitive matching only within the ASCII range
@@ -149,7 +138,6 @@ function sendSearchError(connection, parsed, data, err, description) {
 function asciiLowerCase(str) {
     return str.replace(/[A-Z]+/g, chars => chars.toLowerCase());
 }
-
 /**
  * Checks if a string contains another one, ignoring ASCII case
  *
@@ -159,7 +147,6 @@ function asciiLowerCase(str) {
 function contains(haystack, needle) {
     return asciiLowerCase(haystack).indexOf(needle) >= 0;
 }
-
 /**
  * Returns the search keys with the types of their arguments, including the keys that plugins
  * define in `server.searchHandlers`. If a plugin handler takes more than 3 params
@@ -182,7 +169,6 @@ function getSearchKeys(server) {
     });
     return keys;
 }
-
 /**
  * Checks if SEARCH criteria refer to messages by sequence number (RFC 3501 section 5.5), that is,
  * if a sequence set is used as a search key. Arguments of search keys, like the UID set of UID
@@ -194,7 +180,7 @@ function getSearchKeys(server) {
  */
 function hasSequenceSetKey(server, attributes) {
     const keys = getSearchKeys(server);
-    const walk = list => {
+    const walk = (list) => {
         // arguments of the previous key that are values, not keys
         let skip = 0;
         return list.some((item, i) => {
@@ -209,14 +195,16 @@ function hasSequenceSetKey(server, attributes) {
             const key = value.toUpperCase();
             if (key === 'CHARSET' && i === 0) {
                 skip = 1;
-            } else if (Object.hasOwn(keys, key)) {
+            }
+            else if (Object.hasOwn(keys, key)) {
                 // NOT and OR take keys as arguments, these are checked as keys
                 let types = keys[key];
                 if (typeof types === 'function') {
                     types = types(list.slice(i + 1).map(next => (Array.isArray(next) ? next : ((next && next.value) || '').toString())));
                 }
-                skip = types.filter(type => type !== 'key').length;
-            } else if (/^[\d*][\d*,:]*$/.test(value)) {
+                skip = types.filter((type) => type !== 'key').length;
+            }
+            else if (/^[\d*][\d*,:]*$/.test(value)) {
                 return true;
             }
             return false;
@@ -224,7 +212,6 @@ function hasSequenceSetKey(server, attributes) {
     };
     return walk([].concat(attributes || []));
 }
-
 /**
  * Searches messages. Errors thrown for the client are answered with BAD when `imapResponse` is "BAD",
  * otherwise NO. SORT and THREAD send `responseCode` (a list of atoms) as the response code
@@ -239,21 +226,18 @@ function hasSequenceSetKey(server, attributes) {
  *         a message against the same criteria later. Sequence sets in the criteria stay as they were resolved
  *         now, they are not evaluated again
  */
-module.exports = function (connection, messageSource, params, getMessageRange) {
+export default function searchHandlers(connection, messageSource, params, getMessageRange) {
     const resolveRange = getMessageRange || ((range, isUid) => connection.getMessageRange(range, isUid));
     const numbers = {};
     // search keys used in the criteria, other than sequence sets
     const usedKeys = new Set();
     const keys = getSearchKeys(connection.server);
     const pluginHandlers = connection.server.searchHandlers;
-
     params = [].concat(params || []);
-
     // IMAP4rev1 search strings are US-ASCII unless a CHARSET is given (RFC 3501 6.4.4). A plugin can
     // fix the charset of a session with connection.searchCharset, e.g. UTF-8 after ENABLE UTF8=ACCEPT,
     // or change the default with connection.defaultSearchCharset (IMAP4rev2 assumes UTF-8, RFC 9051 6.4.4)
     let searchCharset = connection.searchCharset || connection.defaultSearchCharset || 'US-ASCII';
-
     if (typeof params[0] === 'string' && params[0].toUpperCase() === 'CHARSET') {
         if (connection.searchCharset) {
             // RFC 9755 section 3: a CHARSET conflicts with the charset of the session
@@ -273,7 +257,6 @@ module.exports = function (connection, messageSource, params, getMessageRange) {
         }
         searchCharset = charset.toUpperCase();
     }
-
     // strings must be valid in the declared charset, a client must not send 8-bit text as US-ASCII
     const checkString = (key, value) => {
         if (searchCharset === 'US-ASCII' && /[\u0080-\u00ff]/.test(value)) {
@@ -284,49 +267,42 @@ module.exports = function (connection, messageSource, params, getMessageRange) {
         }
         return value;
     };
-
     if (!params.length) {
         throw badError('SEARCH expects search criteria, empty query given');
     }
-
     // Parses one search key and its arguments from a list of criteria into a node of the query tree
-    const parseKey = list => {
+    const parseKey = (list) => {
         if (!list.length) {
             throw badError('Unexpected end of search criteria');
         }
-
         const param = list.shift();
-
         if (Array.isArray(param)) {
             // a parenthesized list of keys that all must match
             return { key: 'AND', args: parseList([].concat(param)) };
         }
-
         const key = param.toUpperCase();
-
         // a plugin can remove keys from a session, e.g. NEW, OLD and RECENT are not in the IMAP4rev2 grammar
         if (!Object.prototype.hasOwnProperty.call(keys, key) || (connection.disabledSearchKeys && connection.disabledSearchKeys.has(key))) {
             // a sequence set, plugins may support other forms of it than numbers
             let range;
             try {
                 range = resolveRange(param, false);
-            } catch (E) {
+            }
+            catch (E) {
                 throw /^[\d,:*]+$/.test(param) ? E : badError('Invalid search key ' + param);
             }
             return { key: '_SEQ', args: [range] };
         }
-
         usedKeys.add(key);
-        const types = typeof keys[key] === 'function' ? keys[key](list) : keys[key];
-        const args = types.map(type => {
+        const keyTypes = keys[key];
+        const types = typeof keyTypes === 'function' ? keyTypes(list) : keyTypes;
+        const args = types.map((type) => {
             if (type === 'key') {
                 return parseKey(list);
             }
-
             if (!list.length || typeof list[0] !== 'string') {
                 throw badError(key + ' expects ' + types.length + ' argument' + (types.length > 1 ? 's' : ''));
             }
-
             const value = list.shift();
             if (typeof type === 'function') {
                 return type(value);
@@ -350,11 +326,9 @@ module.exports = function (connection, messageSource, params, getMessageRange) {
                     return checkString(key, value);
             }
         });
-
         return { key, args };
     };
-
-    const parseList = list => {
+    const parseList = (list) => {
         if (!list.length) {
             throw badError('Empty search criteria list');
         }
@@ -364,12 +338,10 @@ module.exports = function (connection, messageSource, params, getMessageRange) {
         }
         return nodes;
     };
-
     const query = { key: 'AND', args: parseList(params) };
-
     // a sequence set argument resolves to [number, message] pairs, turn these into a lookup set
-    const toMessageSet = range => new Set(range.map(item => item[1]));
-    const prepare = node => {
+    const toMessageSet = (range) => new Set(range.map(item => item[1]));
+    const prepare = (node) => {
         if (node.key === '_SEQ' || node.key === 'UID') {
             node.set = toMessageSet(node.args[0]);
         }
@@ -378,40 +350,38 @@ module.exports = function (connection, messageSource, params, getMessageRange) {
         // decoded too (RFC 9051 section 6.4.4)
         if (['BODY', 'TEXT'].indexOf(node.key) >= 0) {
             node.needle = asciiLowerCase(node.args[0]);
-        } else if (['BCC', 'CC', 'FROM', 'HEADER', 'SUBJECT', 'TO'].indexOf(node.key) >= 0) {
+        }
+        else if (['BCC', 'CC', 'FROM', 'HEADER', 'SUBJECT', 'TO'].indexOf(node.key) >= 0) {
             node.needle = asciiLowerCase(decodeUtf8(node.args[node.key === 'HEADER' ? 1 : 0]));
         }
-        node.args.forEach(arg => {
+        node.args.forEach((arg) => {
             if (arg && typeof arg === 'object' && arg.key) {
                 prepare(arg);
             }
         });
     };
     prepare(query);
-
     const hasFlag = (message, flag) => message.flags.indexOf(flag) >= 0;
-
     // compares the unfolded values of the header lines with that name, after decoding their encoded
     // words. RFC 3501 and RFC 9051 section 6.4.4: [MIME-HDRS] strings in headers MUST be decoded before comparing text
     const matchHeader = (message, name, needle) => {
         name = name.toLowerCase();
-        return (getMessageData(message).tree.header || []).some(line => {
+        return (getMessageData(message).tree.header || []).some((line) => {
             const colon = line.indexOf(':');
             const lineName = (colon < 0 ? line : line.substr(0, colon)).trim().toLowerCase();
             const value = colon < 0 ? '' : line.substr(colon + 1).replace(/\r?\n(?=[ \t])/g, '');
             return lineName === name && contains(decodeHeader(value), needle);
         });
     };
-
     const matches = (node, message, index) => {
         const args = node.args;
         if (Object.prototype.hasOwnProperty.call(pluginHandlers, node.key)) {
             // plugin defined search key, which may also override a built-in one
-            return !!pluginHandlers[node.key].apply(null, [connection, message, index].concat(args));
+            return !!pluginHandlers[node.key](connection, message, index, ...args);
         }
         switch (node.key) {
             case 'AND':
-                return args.every(arg => matches(arg, message, index));
+                return args.every((arg) => matches(arg, message, index));
             case '_SEQ':
             case 'UID':
                 return node.set.has(message);
@@ -492,11 +462,9 @@ module.exports = function (connection, messageSource, params, getMessageRange) {
                 return false;
         }
     };
-
     // plugins can narrow down the messages that are looked at (server.searchLimits), sequence numbers stay as they are
     const searched = connection.server.searchLimits.reduce((messages, limit) => limit(connection, messages, query) || messages, messageSource);
     const searchedSet = searched !== messageSource && new Set(searched);
-
     const list = [];
     messageSource.forEach((message, i) => {
         if (searchedSet && !searchedSet.has(message)) {
@@ -507,17 +475,11 @@ module.exports = function (connection, messageSource, params, getMessageRange) {
             list.push(message);
         }
     });
-
     return {
         list,
         numbers,
         keys: usedKeys,
         matches: (message, index) => matches(query, message, index)
     };
-};
-
-module.exports.hasSequenceSetKey = hasSequenceSetKey;
-module.exports.getDateKey = getDateKey;
-module.exports.badError = badError;
-module.exports.criteriaValues = criteriaValues;
-module.exports.sendSearchError = sendSearchError;
+}
+export { hasSequenceSetKey, getDateKey, badError, criteriaValues, sendSearchError };

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

@@ -0,0 +1,34 @@
+import type { Attribute, IMAPConnection, IMAPResponse, IMAPServer, Mailbox, ParsedCommand } from '../../types.js';
+/**
+ * Validates a list of STATUS data item names (RFC 3501 section 9, "(" status-att *(SP status-att) ")")
+ *
+ * @param {Object} server IMAPServer instance
+ * @param {Array} list Parsed list of status items
+ * @param {Object} [connection] IMAP connection, its `disabledStatusItems` set lists items the session can not use,
+ *   `addedStatusItems` the items only this session can use (DELETED after ENABLE IMAP4rev2)
+ * @return {Array} upper case item names
+ * @throws {Error} if the list is empty or has an invalid item, the message is for the BAD response
+ */
+declare function parseStatusItems(server: IMAPServer, list: Attribute, connection?: IMAPConnection | null): string[];
+/**
+ * Sends an untagged STATUS response
+ *
+ * @param {Object} connection IMAPConnection instance
+ * @param {String} path Storage name of the mailbox
+ * @param {Object} mailbox Mailbox object
+ * @param {Array} items Upper case item names from parseStatusItems
+ * @param {Object} parsed Parsed command
+ * @param {Object} data Command data
+ */
+declare function sendStatus(connection: IMAPConnection, path: string, mailbox: Mailbox, items: string[], parsed: ParsedCommand, data: string): void;
+/**
+ * Builds an untagged STATUS response
+ *
+ * @param {Object} connection IMAPConnection instance
+ * @param {String} path Storage name of the mailbox
+ * @param {Object} mailbox Mailbox object
+ * @param {Array} items Upper case item names
+ * @return {Object} STATUS response
+ */
+declare function statusResponse(connection: IMAPConnection, path: string, mailbox: Mailbox, items: string[]): IMAPResponse;
+export { parseStatusItems, sendStatus, statusResponse };

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

@@ -1,12 +1,9 @@
-'use strict';
-
 /**
  * STATUS data items, shared by the STATUS command and the STATUS return option of LIST (LIST-STATUS,
  * RFC 5819). A STATUS item can only be requested when it is listed in `server.allowedStatus`.
  * Plugins add their items to `server.statusHandlers` (consulted before the built-in items) and to
  * `server.allowedStatus`.
  */
-
 const statusHandlers = {
     MESSAGES: (connection, mailbox) => mailbox.messages.length,
     RECENT: (connection, mailbox, status) => status.recent,
@@ -16,9 +13,7 @@ const statusHandlers = {
     // RFC 9051 section 6.3.11. Not in RFC 3501, QUOTA lists it in allowedStatus, IMAP4rev2 allows it per session
     DELETED: (connection, mailbox, status) => status.flags['\\Deleted'] || 0
 };
-
 // RFC 3501 section 9 atom = 1*ATOM-CHAR
-
 /**
  * Validates a list of STATUS data item names (RFC 3501 section 9, "(" status-att *(SP status-att) ")")
  *
@@ -43,7 +38,6 @@ function parseStatusItems(server, list, connection) {
         return name;
     });
 }
-
 /**
  * Sends an untagged STATUS response
  *
@@ -57,7 +51,6 @@ function parseStatusItems(server, list, connection) {
 function sendStatus(connection, path, mailbox, items, parsed, data) {
     connection.send(statusResponse(connection, path, mailbox, items), 'STATUS', parsed, data);
 }
-
 /**
  * Builds an untagged STATUS response
  *
@@ -81,5 +74,4 @@ function statusResponse(connection, path, mailbox, items) {
         attributes: [{ type: 'MAILBOX', value: path }, list]
     };
 }
-
-module.exports = { parseStatusItems, sendStatus, statusResponse };
+export { parseStatusItems, sendStatus, statusResponse };

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

@@ -0,0 +1,3 @@
+import type { StoreHandler } from '../../types.js';
+declare const storeHandlers: Record<string, StoreHandler>;
+export default storeHandlers;

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

@@ -1,52 +1,43 @@
-'use strict';
-
-const { normalizeSystemFlag, checkSystemFlags } = require('./flags');
-
+import { normalizeSystemFlag, checkSystemFlags } from './flags.js';
 const storeHandlers = {};
-
-module.exports = storeHandlers;
-
+export default storeHandlers;
 function setFlags(connection, message, flags) {
+    // STORE runs in the Selected state
+    const mailbox = connection.selectedMailbox;
     const messageFlags = [];
     [].concat(flags).forEach(flag => {
         flag = normalizeSystemFlag(typeof flag === 'string' ? flag : String(flag.value || ''));
         checkSystemFlags(connection, flag);
-
         // Ignore if it is not in allowed list and only permament flags are allowed to use
-        if (connection.selectedMailbox.permanentFlags.indexOf(flag) < 0 && !connection.selectedMailbox.allowPermanentFlags) {
+        if (mailbox.permanentFlags.indexOf(flag) < 0 && !mailbox.allowPermanentFlags) {
             return;
         }
-
         if (messageFlags.indexOf(flag) < 0) {
             messageFlags.push(flag);
         }
     });
     message.flags = messageFlags;
-    connection.server.rememberFlags(connection.selectedMailbox, messageFlags);
+    connection.server.rememberFlags(mailbox, messageFlags);
 }
-
 function addFlags(connection, message, flags) {
+    const mailbox = connection.selectedMailbox;
     [].concat(flags).forEach(flag => {
         flag = normalizeSystemFlag(typeof flag === 'string' ? flag : String(flag.value || ''));
         checkSystemFlags(connection, flag);
-
         // Ignore if it is not in allowed list and only permament flags are allowed to use
-        if (connection.selectedMailbox.permanentFlags.indexOf(flag) < 0 && !connection.selectedMailbox.allowPermanentFlags) {
+        if (mailbox.permanentFlags.indexOf(flag) < 0 && !mailbox.allowPermanentFlags) {
             return;
         }
-
         if (message.flags.indexOf(flag) < 0) {
             message.flags.push(flag);
         }
     });
-    connection.server.rememberFlags(connection.selectedMailbox, message.flags);
+    connection.server.rememberFlags(mailbox, message.flags);
 }
-
 function removeFlags(connection, message, flags) {
     [].concat(flags).forEach(flag => {
         flag = normalizeSystemFlag(typeof flag === 'string' ? flag : String(flag.value || ''));
         checkSystemFlags(connection, flag);
-
         if (message.flags.indexOf(flag) >= 0) {
             for (let i = 0; i < message.flags.length; i++) {
                 if (message.flags[i] === flag) {
@@ -57,7 +48,6 @@ function removeFlags(connection, message, flags) {
         }
     });
 }
-
 function sendUpdate(connection, parsed, data, index, message) {
     const resp = [
         {
@@ -71,7 +61,6 @@ function sendUpdate(connection, parsed, data, index, message) {
             };
         })
     ];
-
     if ((parsed.command || '').toUpperCase() === 'UID STORE') {
         resp.push({
             type: 'ATOM',
@@ -79,49 +68,36 @@ function sendUpdate(connection, parsed, data, index, message) {
         });
         resp.push(message.uid);
     }
-
-    connection.send(
-        {
-            tag: '*',
-            attributes: [
-                index,
-                {
-                    type: 'ATOM',
-                    value: 'FETCH'
-                },
-                resp
-            ]
-        },
-        'FLAG UPDATE',
-        parsed,
-        data,
-        message
-    );
+    connection.send({
+        tag: '*',
+        attributes: [
+            index,
+            {
+                type: 'ATOM',
+                value: 'FETCH'
+            },
+            resp
+        ]
+    }, 'FLAG UPDATE', parsed, data, message);
 }
-
 storeHandlers.FLAGS = function (connection, message, flags, index, parsed, data) {
     setFlags(connection, message, flags);
     sendUpdate(connection, parsed, data, index, message);
 };
-
 storeHandlers['+FLAGS'] = function (connection, message, flags, index, parsed, data) {
     addFlags(connection, message, flags);
     sendUpdate(connection, parsed, data, index, message);
 };
-
 storeHandlers['-FLAGS'] = function (connection, message, flags, index, parsed, data) {
     removeFlags(connection, message, flags);
     sendUpdate(connection, parsed, data, index, message);
 };
-
 storeHandlers['FLAGS.SILENT'] = function (connection, message, flags) {
     setFlags(connection, message, flags);
 };
-
 storeHandlers['+FLAGS.SILENT'] = function (connection, message, flags) {
     addFlags(connection, message, flags);
 };
-
 storeHandlers['-FLAGS.SILENT'] = function (connection, message, flags) {
     removeFlags(connection, message, flags);
 };

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

@@ -0,0 +1,2 @@
+import type { CommandHandler } from '../types.js';
+export declare const commands: Record<string, CommandHandler>;