imapflow 1.7.8 → 2.0.0

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

@@ -1,34 +1,21 @@
-'use strict';
-
-const {
-    decodePath,
-    encodePath,
-    normalizePath,
-    enhanceCommandError,
-    hasCapability,
-    isRev2Active,
-    buildStatusQueryAttributes,
-    getStringList
-} = require('../tools.js');
-const { parseStatusList } = require('./status-fields.js');
-const { specialUse } = require('../special-use');
-
+import { decodePath, encodePath, normalizePath, enhanceCommandError, hasCapability, isRev2Active, buildStatusQueryAttributes, getStringList } from '../tools.js';
+import { parseStatusList } from './status-fields.js';
+import { specialUse } from '../special-use.js';
 /**
  * Lists mailboxes from the server, including subscription status and special-use flags.
  *
- * @param {Object} connection - IMAP connection instance
- * @param {string} reference - Reference name (namespace prefix)
- * @param {string} mailbox - Mailbox name pattern with possible wildcards
- * @param {Object} [options] - List options
- * @param {boolean} [options.listOnly] - If true, return entries after LIST without LSUB or status queries
- * @param {Object} [options.statusQuery] - Status data items to query for each listed mailbox
- * @param {Object} [options.specialUseHints] - Hints mapping mailbox paths to special-use types (sent, junk, trash, drafts, archive)
- * @returns {Promise<Object[]>} Array of mailbox entries sorted by special-use flags and name
- * @throws {Error} If the LIST command fails
+ * @param connection - IMAP connection instance
+ * @param reference - Reference name (namespace prefix)
+ * @param mailbox - Mailbox name pattern with possible wildcards
+ * @param options - List options
+ * @param options.listOnly - If true, return entries after LIST without LSUB or status queries
+ * @param options.statusQuery - Status data items to query for each listed mailbox
+ * @param options.specialUseHints - Hints mapping mailbox paths to special-use types (sent, junk, trash, drafts, archive)
+ * @returns Array of mailbox entries sorted by special-use flags and name
+ * @throws If the LIST command fails
  */
-module.exports = async (connection, reference, mailbox, options) => {
+export default async function list(connection, reference, mailbox, options) {
     options = options || {};
-
     // Special-use flags sorted by display priority (INBOX first, Trash last).
     // Used in the final sort to group special-use mailboxes at the top of the list.
     const FLAG_SORT_ORDER = ['\\Inbox', '\\Flagged', '\\Sent', '\\Drafts', '\\All', '\\Archive', '\\Junk', '\\Trash'];
@@ -41,27 +28,23 @@ module.exports = async (connection, reference, mailbox, options) => {
     // "name-guess" is an internal precedence tier only. It is reported as "name" so
     // that specialUseSource keeps its documented set of values for consumers.
     const PUBLIC_SOURCE = { 'name-guess': 'name' };
-    const isNameSource = source => source === 'name' || source === 'name-guess';
-
+    const isNameSource = (source) => source === 'name' || source === 'name-guess';
     // Prefer XLIST (legacy Gmail extension) only if SPECIAL-USE (RFC 6154) is unavailable.
     // Both provide special-use flags, but SPECIAL-USE is the standardized approach.
     // SPECIAL-USE is checked with rev2 folding - a rev2 session implies SPECIAL-USE,
     // so LIST is preferred even if a rev2 server also advertised legacy XLIST.
     let listCommand = connection.capabilities.has('XLIST') && !hasCapability(connection, 'SPECIAL-USE') ? 'XLIST' : 'LIST';
-
     try {
         // Accumulators filled by the untagged LIST/STATUS handlers below. statusMap
         // caches STATUS responses received inline via LIST-STATUS extension, keyed by
         // normalized mailbox path (avoids separate STATUS commands per mailbox), and
         // specialUseMatches tracks candidate mailboxes for each special-use type.
         // (Re)initialized at the start of each retry stage of the main listing.
-        let entries;
-        let statusMap;
-        let specialUseMatches;
-
+        let entries = [];
+        let statusMap = new Map();
+        let specialUseMatches = {};
         // STATUS data items to request (MESSAGES, UIDNEXT, etc.)
         let statusQueryAttributes = buildStatusQueryAttributes(connection, options.statusQuery);
-
         // Extended LIST syntax (RETURN options) is understood by servers advertising
         // LIST-EXTENDED (RFC 5258) or IMAP4rev2 (RFC 9051). Deliberately keyed on the
         // advertisement alone (not hasCapability/isRev2Active): the staged retry below
@@ -69,33 +52,27 @@ module.exports = async (connection, reference, mailbox, options) => {
         // is safe for anything it covers, while gates without a retry ladder stay
         // conservative.
         let supportsExtendedList = connection.capabilities.has('LIST-EXTENDED') || connection.capabilities.has('IMAP4rev2');
-
         // RETURN options for the LIST command. Servers occasionally advertise the
         // extensions but still reject RETURN options - the staged retry below then
         // re-runs the LIST with fewer options and latches a skip flag for the option
         // group the server proved to reject, keeping later listings efficient.
-
         // LIST-STATUS (RFC 5819, folded into base IMAP4rev2): request STATUS data
         // inline with LIST, avoiding a separate STATUS command for each mailbox.
-        let canRequestStatus =
-            listCommand === 'LIST' && !connection.skipListStatusArgs && hasCapability(connection, 'LIST-STATUS') && !!statusQueryAttributes.length;
-
+        let canRequestStatus = listCommand === 'LIST' && !connection.skipListStatusArgs && hasCapability(connection, 'LIST-STATUS') && !!statusQueryAttributes.length;
         // RETURN (SUBSCRIBED): request subscription state inline instead of a separate
         // LSUB command. IMAP4rev2 removed LSUB entirely, and some servers (e.g.
         // Exchange in IMAP4rev2 mode) reject it with BAD even while still advertising
         // IMAP4rev1.
         let canRequestSubscribed = listCommand === 'LIST' && !options.listOnly && !connection.skipListSubscribedArg && supportsExtendedList;
-
         // Auxiliary RETURN options (SPECIAL-USE/CHILDREN) that ride along with the
         // STATUS/SUBSCRIBED option groups. When RETURN options are present, servers
         // may report only what was explicitly requested (verified against Dovecot
         // 2.4: special-use and child attributes disappear from such responses), so
         // request everything a plain LIST would have provided.
         let auxArgsAvailable = hasCapability(connection, 'SPECIAL-USE') || connection.capabilities.has('CHILDREN') || supportsExtendedList;
-        let stageHasAuxArgs = stage => (stage.status || stage.subscribed) && stage.aux !== false && !connection.skipListAuxArgs && auxArgsAvailable;
-
+        let stageHasAuxArgs = (stage) => (stage.status || stage.subscribed) && stage.aux !== false && !connection.skipListAuxArgs && auxArgsAvailable;
         // Builds the RETURN (...) argument list for one retry stage
-        let buildListArgs = stage => {
+        let buildListArgs = (stage) => {
             let args = [];
             if (stage.status) {
                 args.push({ type: 'ATOM', value: 'STATUS' }, statusQueryAttributes);
@@ -113,7 +90,6 @@ module.exports = async (connection, reference, mailbox, options) => {
             }
             return args;
         };
-
         // Multiple mailboxes may claim the same special-use type (e.g., \\Sent) via
         // different sources (user hint, server extension, name match). After listing,
         // the best match wins.
@@ -123,14 +99,13 @@ module.exports = async (connection, reference, mailbox, options) => {
             }
             specialUseMatches[type].push({ entry, source });
         };
-
         // RFC 5258: the \NonExistent attribute implies \Noselect. Some servers only
         // return \NonExistent for phantom folders, so add \Noselect as well to keep
         // the flags consistent for consumers that only check \Noselect.
         // RETURN (SUBSCRIBED) - and some LSUB implementations - report subscription
         // state as a \Subscribed attribute. Move it to the subscribed property so the
         // output shape is the same however the state was delivered.
-        let normalizeFlags = entry => {
+        let normalizeFlags = (entry) => {
             if (entry.flags.has('\\NonExistent')) {
                 entry.flags.add('\\Noselect');
             }
@@ -139,7 +114,6 @@ module.exports = async (connection, reference, mailbox, options) => {
                 entry.subscribed = true;
             }
         };
-
         // User-provided hints map mailbox paths to special-use types (e.g., {sent: "Sent Items"}).
         // These override server-reported flags and name-based guesses. Converted to a
         // path-keyed lookup: { "Sent Items" => "\\Sent" }
@@ -148,52 +122,43 @@ module.exports = async (connection, reference, mailbox, options) => {
         let specialUseHints = Object.create(null);
         if (options.specialUseHints && typeof options.specialUseHints === 'object') {
             for (let type of Object.keys(options.specialUseHints)) {
-                if (
-                    ['sent', 'junk', 'trash', 'drafts', 'archive'].includes(type) &&
+                if (['sent', 'junk', 'trash', 'drafts', 'archive'].includes(type) &&
                     options.specialUseHints[type] &&
-                    typeof options.specialUseHints[type] === 'string'
-                ) {
+                    typeof options.specialUseHints[type] === 'string') {
                     // Capitalize first letter: "sent" -> "\\Sent"
                     specialUseHints[normalizePath(connection, options.specialUseHints[type])] = `\\${type.replace(/^./, c => c.toUpperCase())}`;
                 }
             }
         }
-
         // Executes a LIST (or XLIST) command and collects mailbox entries.
         // Called once for the main listing and optionally again for INBOX if a
         // namespace prefix was used (INBOX may live outside the namespace).
         let runList = async (reference, mailbox, returnArgs) => {
             const cmdArgs = [encodePath(connection, reference), encodePath(connection, mailbox)];
-
             if (returnArgs.length) {
                 cmdArgs.push({ type: 'ATOM', value: 'RETURN' }, returnArgs);
             }
-
             let response = await connection.exec(listCommand, cmdArgs, {
                 untagged: {
                     // Each untagged LIST response: * LIST (<flags>) "<delimiter>" "<mailbox name>"
                     // attributes[0] = flags array, attributes[1] = delimiter, attributes[2] = mailbox name
-                    [listCommand]: async untagged => {
+                    [listCommand]: async (untagged) => {
                         if (!untagged.attributes || !untagged.attributes.length) {
                             return;
                         }
-
                         let entry = {
                             // Decode from modified UTF-7 wire format and normalize the path
-                            path: normalizePath(connection, decodePath(connection, (untagged.attributes[2] && untagged.attributes[2].value) || '')),
-                            pathAsListed: (untagged.attributes[2] && untagged.attributes[2].value) || '',
+                            path: normalizePath(connection, decodePath(connection, ((untagged.attributes[2] && untagged.attributes[2].value) || ''))),
+                            pathAsListed: ((untagged.attributes[2] && untagged.attributes[2].value) || ''),
                             flags: new Set(getStringList(untagged.attributes[0])),
-                            delimiter: untagged.attributes[1] && untagged.attributes[1].value,
+                            delimiter: (untagged.attributes[1] && untagged.attributes[1].value),
                             listed: true
                         };
-
                         normalizeFlags(entry);
-
                         // Check user-provided hints first (highest priority)
                         if (specialUseHints[entry.path]) {
                             addSpecialUseMatch(entry, specialUseHints[entry.path], 'user');
                         }
-
                         // XLIST marks INBOX with a \\Inbox flag. Remove it from flags
                         // (it's not a standard flag) and register as special-use match.
                         // XLIST may also use a localised name (e.g., "Posteingang" for German INBOX).
@@ -203,31 +168,23 @@ module.exports = async (connection, reference, mailbox, options) => {
                                 addSpecialUseMatch(entry, '\\Inbox', 'extension');
                             }
                         }
-
                         // Name-based INBOX detection: any mailbox named "INBOX" (case-insensitive)
                         // is the inbox per RFC 3501. Phantom \NonExistent entries (subscribed
                         // leftovers of deleted mailboxes) must not claim the slot by name.
                         if (entry.path.toUpperCase() === 'INBOX' && !entry.flags.has('\\NonExistent')) {
                             addSpecialUseMatch(entry, '\\Inbox', 'name');
                         }
-
                         // Strip leading delimiter (some servers prepend it to paths)
                         if (entry.delimiter && entry.path.charAt(0) === entry.delimiter) {
                             entry.path = entry.path.slice(1);
                         }
-
                         // Build parent path hierarchy for tree construction and sorting
                         entry.parentPath = entry.delimiter && entry.path ? entry.path.substr(0, entry.path.lastIndexOf(entry.delimiter)) : '';
                         entry.parent = entry.delimiter ? entry.path.split(entry.delimiter) : [entry.path];
                         entry.name = entry.parent.pop();
-
                         // Try to detect special-use from server flags or well-known names
                         // (e.g., "Sent", "Drafts", "Junk", "Trash")
-                        let { flag: specialUseFlag, source: flagSource } = specialUse(
-                            connection.capabilities.has('XLIST') || hasCapability(connection, 'SPECIAL-USE'),
-                            entry
-                        );
-
+                        let { flag: specialUseFlag, source: flagSource } = specialUse(connection.capabilities.has('XLIST') || hasCapability(connection, 'SPECIAL-USE'), entry);
                         // A name-based match for a \NonExistent phantom entry could win the
                         // special-use slot over the real folder - only server-provided flags
                         // are trusted for nonexistent entries. Covers every name-derived
@@ -235,34 +192,28 @@ module.exports = async (connection, reference, mailbox, options) => {
                         if (specialUseFlag && (!isNameSource(flagSource) || !entry.flags.has('\\NonExistent'))) {
                             addSpecialUseMatch(entry, specialUseFlag, flagSource);
                         }
-
                         entries.push(entry);
                     },
-
                     // Inline STATUS response from LIST-STATUS extension (RFC 5819).
                     // Parses alternating key-value pairs (i % 2 pattern).
-                    STATUS: async untagged => {
-                        let statusPath = normalizePath(connection, decodePath(connection, (untagged.attributes[0] && untagged.attributes[0].value) || ''));
+                    STATUS: async (untagged) => {
+                        let statusPath = normalizePath(connection, decodePath(connection, ((untagged.attributes[0] && untagged.attributes[0].value) || '')));
                         let statusList = untagged.attributes && Array.isArray(untagged.attributes[1]) ? untagged.attributes[1] : false;
                         if (!statusList || !statusPath) {
                             return;
                         }
-
                         let map = { path: statusPath };
                         parseStatusList(statusList, (key, value) => {
                             map[key] = value;
                         });
-
                         statusMap.set(statusPath, map);
                     }
                 }
             });
             response.next();
         };
-
         let normalizedReference = normalizePath(connection, reference || '');
         let normalizedMailbox = normalizePath(connection, mailbox || '', true);
-
         // Retry stages for the main listing: start with all applicable RETURN options
         // and drop one option group per retry. Consecutive stages differ by exactly one
         // group, so a success right after a rejection identifies the offending group
@@ -276,29 +227,25 @@ module.exports = async (connection, reference, mailbox, options) => {
         }
         if (canRequestStatus) {
             stages.push({ status: true, subscribed: false });
-        } else if (canRequestSubscribed) {
+        }
+        else if (canRequestSubscribed) {
             stages.push({ status: false, subscribed: true });
         }
         stages.push({ status: false, subscribed: false });
-
         // A tagged BAD is how servers reject unrecognized RETURN options (RFC 9051
         // section 6.3.9). A tagged NO is an operational failure, and throttling
         // errors (code ETHROTTLE) also surface with a BAD status - neither says
         // anything about the RETURN options, so they propagate to the caller.
-        let isRejectedCommand = err => err.responseStatus === 'BAD' && err.code !== 'ETHROTTLE';
-
+        let isRejectedCommand = (err) => err.responseStatus === 'BAD' && err.code !== 'ETHROTTLE';
         // Stage of the successful attempt - reused by the INBOX fixup and the LSUB
         // decision below
         let successStage = null;
-
         // Whether any source actually reported subscription state. RETURN (SUBSCRIBED)
         // and LSUB are the only two, and a server can refuse both
         let subscriptionStateKnown = false;
-
         // A server may also volunteer \Subscribed on a plain LIST, which normalizeFlags
         // folds into the entry - that counts as the state having been reported
         let anyEntrySubscribed = () => entries.some(entry => entry.subscribed);
-
         let lastRejectedStage = null;
         let auxRetryInserted = false;
         for (let i = 0; i < stages.length; i++) {
@@ -322,12 +269,10 @@ module.exports = async (connection, reference, mailbox, options) => {
                     if (lastRejectedStage.status && !stage.status) {
                         connection.skipListStatusArgs = true;
                     }
-                    if (
-                        stageHasAuxArgs(lastRejectedStage) &&
+                    if (stageHasAuxArgs(lastRejectedStage) &&
                         stage.aux === false &&
                         lastRejectedStage.status === stage.status &&
-                        lastRejectedStage.subscribed === stage.subscribed
-                    ) {
+                        lastRejectedStage.subscribed === stage.subscribed) {
                         // Same option groups, only the auxiliary args dropped - the
                         // auxiliaries are proven to be what the server rejects
                         connection.skipListAuxArgs = true;
@@ -336,7 +281,8 @@ module.exports = async (connection, reference, mailbox, options) => {
                 successStage = stage;
                 subscriptionStateKnown = !!stage.subscribed;
                 break;
-            } catch (err) {
+            }
+            catch (err) {
                 if (i === stages.length - 1 || !isRejectedCommand(err)) {
                     throw err;
                 }
@@ -351,11 +297,9 @@ module.exports = async (connection, reference, mailbox, options) => {
                 connection.log.warn({ msg: 'LIST RETURN options rejected, retrying with reduced options', err, cid: connection.id });
             }
         }
-
         if (options.listOnly) {
             return entries;
         }
-
         // When listing with a namespace prefix (e.g., "INBOX."), INBOX itself may
         // not appear in results. Run a separate LIST for INBOX to ensure it's included.
         if (normalizedReference && !specialUseMatches['\\Inbox']) {
@@ -371,7 +315,8 @@ module.exports = async (connection, reference, mailbox, options) => {
             }
             try {
                 await runList('', 'INBOX', returnArgs);
-            } catch (err) {
+            }
+            catch (err) {
                 // The main listing just succeeded with the same RETURN options, so a
                 // rejection here says nothing about the options themselves - retry
                 // this one call plain without latching any skip flags. Accepted edge:
@@ -384,7 +329,8 @@ module.exports = async (connection, reference, mailbox, options) => {
                 for (let type of Object.keys(specialUseMatches)) {
                     if (!(type in specialUseCountsBefore)) {
                         delete specialUseMatches[type];
-                    } else {
+                    }
+                    else {
                         specialUseMatches[type].length = specialUseCountsBefore[type];
                     }
                 }
@@ -392,7 +338,6 @@ module.exports = async (connection, reference, mailbox, options) => {
                 await runList('', 'INBOX', []);
             }
         }
-
         // Attach STATUS data to each selectable mailbox. If LIST-STATUS was used,
         // data is already in statusMap; otherwise, fall back to individual STATUS commands.
         if (options.statusQuery) {
@@ -408,18 +353,19 @@ module.exports = async (connection, reference, mailbox, options) => {
                         if (syntheticRecent) {
                             entry.status.recent = 0;
                         }
-                    } else if (!statusMap.size) {
+                    }
+                    else if (!statusMap.size) {
                         // Server didn't support LIST-STATUS; fall back to per-mailbox STATUS
                         try {
                             entry.status = await connection.run('STATUS', entry.path, options.statusQuery);
-                        } catch (err) {
+                        }
+                        catch (err) {
                             entry.status = { error: err };
                         }
                     }
                 }
             }
         }
-
         // LSUB (RFC 3501 6.3.9): queries which mailboxes the user is subscribed to.
         // We merge subscription info into the entries already collected from LIST.
         // Subscribed-only mailboxes that weren't in LIST are intentionally ignored
@@ -427,31 +373,26 @@ module.exports = async (connection, reference, mailbox, options) => {
         let runLsub = async () => {
             let response = await connection.exec('LSUB', [encodePath(connection, normalizedReference), encodePath(connection, normalizedMailbox)], {
                 untagged: {
-                    LSUB: async untagged => {
+                    LSUB: async (untagged) => {
                         if (!untagged.attributes || !untagged.attributes.length) {
                             return;
                         }
-
                         let entry = {
-                            path: normalizePath(connection, decodePath(connection, (untagged.attributes[2] && untagged.attributes[2].value) || '')),
-                            pathAsListed: (untagged.attributes[2] && untagged.attributes[2].value) || '',
+                            path: normalizePath(connection, decodePath(connection, ((untagged.attributes[2] && untagged.attributes[2].value) || ''))),
+                            pathAsListed: ((untagged.attributes[2] && untagged.attributes[2].value) || ''),
                             flags: new Set(getStringList(untagged.attributes[0])),
-                            delimiter: untagged.attributes[1] && untagged.attributes[1].value,
+                            delimiter: (untagged.attributes[1] && untagged.attributes[1].value),
                             subscribed: true
                         };
-
                         if (entry.path.toUpperCase() === 'INBOX') {
                             addSpecialUseMatch(entry, '\\Inbox', 'name');
                         }
-
                         if (entry.delimiter && entry.path.charAt(0) === entry.delimiter) {
                             entry.path = entry.path.slice(1);
                         }
-
                         entry.parentPath = entry.delimiter && entry.path ? entry.path.substr(0, entry.path.lastIndexOf(entry.delimiter)) : '';
                         entry.parent = entry.delimiter ? entry.path.split(entry.delimiter) : [entry.path];
                         entry.name = entry.parent.pop();
-
                         // Merge LSUB data into existing LIST entry if found
                         let existing = entries.find(existing => existing.path === entry.path);
                         if (existing) {
@@ -466,7 +407,6 @@ module.exports = async (connection, reference, mailbox, options) => {
             });
             response.next();
         };
-
         // Never sent on a rev2 session - LSUB is not part of that protocol version, and
         // some servers break the rest of the session over the rejection, so this is
         // decided up front rather than left to the skipLsub latch below. On rev1 it is
@@ -485,12 +425,14 @@ module.exports = async (connection, reference, mailbox, options) => {
             try {
                 await runLsub();
                 subscriptionStateKnown = true;
-            } catch (err) {
+            }
+            catch (err) {
                 if (isRejectedCommand(err)) {
                     // Tagged BAD: the server does not implement LSUB despite advertising
                     // rev1 - skip it for the rest of this connection
                     connection.skipLsub = true;
-                } else if (err.responseStatus !== 'NO' || err.code === 'ETHROTTLE') {
+                }
+                else if (err.responseStatus !== 'NO' || err.code === 'ETHROTTLE') {
                     // Transport failures and throttling: rethrow, every follow-up
                     // command would fail too or the caller needs to back off
                     throw err;
@@ -500,7 +442,6 @@ module.exports = async (connection, reference, mailbox, options) => {
                 connection.log.warn({ msg: 'Failed to request subscription info', err, cid: connection.id });
             }
         }
-
         // Resolve special-use conflicts: for each type, pick the best candidate
         // based on source priority (user > extension > name), then alphabetically.
         // Only the winning entry gets the specialUse property set.
@@ -513,14 +454,12 @@ module.exports = async (connection, reference, mailbox, options) => {
                 }
                 return aSource - bSource;
             });
-
             if (!sortedEntries[0].entry.specialUse) {
                 let source = sortedEntries[0].source;
                 sortedEntries[0].entry.specialUse = type;
                 sortedEntries[0].entry.specialUseSource = PUBLIC_SOURCE[source] || source;
             }
         }
-
         // No source answered, so "not subscribed" was never actually reported for any of
         // these folders - the state is unknown, not false. Reporting the whole listing as
         // unsubscribed would hide every folder from a client that filters on subscription
@@ -535,13 +474,11 @@ module.exports = async (connection, reference, mailbox, options) => {
                 }
             }
         }
-
         // INBOX should always appear as subscribed regardless of LSUB results
         let inboxEntry = entries.find(entry => entry.specialUse === '\\Inbox');
         if (inboxEntry && !inboxEntry.subscribed) {
             inboxEntry.subscribed = true;
         }
-
         // Sort: special-use mailboxes first (in FLAG_SORT_ORDER), then alphabetically
         // by path segments for a natural folder hierarchy ordering.
         return entries.sort((a, b) => {
@@ -554,10 +491,8 @@ module.exports = async (connection, reference, mailbox, options) => {
             if (a.specialUse && b.specialUse) {
                 return FLAG_SORT_ORDER.indexOf(a.specialUse) - FLAG_SORT_ORDER.indexOf(b.specialUse);
             }
-
             let aList = [].concat(a.parent).concat(a.name);
             let bList = [].concat(b.parent).concat(b.name);
-
             for (let i = 0; i < aList.length; i++) {
                 let aPart = aList[i];
                 let bPart = bList[i];
@@ -565,14 +500,14 @@ module.exports = async (connection, reference, mailbox, options) => {
                     return aPart.localeCompare(bPart || '');
                 }
             }
-
             return a.path.localeCompare(b.path);
         });
-    } catch (err) {
+    }
+    catch (err) {
         // Rewrite the parsed err.response into the response text and set
         // serverResponseCode, same as the other command modules
         await enhanceCommandError(err);
         connection.log.warn({ msg: 'Failed to list folders', err, cid: connection.id });
         throw err;
     }
-};
+}

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

@@ -0,0 +1,11 @@
+import type { ImapFlow } from '../imap-flow.js';
+/**
+ * Authenticates user using the IMAP LOGIN command.
+ *
+ * @param connection - IMAP connection instance
+ * @param username - The username to authenticate with
+ * @param password - The password to authenticate with
+ * @returns The authenticated username, or undefined if already authenticated
+ * @throws If authentication fails, with authenticationFailed and serverResponseCode properties set
+ */
+export default function login(connection: ImapFlow, username: string, password: string): Promise<string | undefined>;

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

@@ -1,22 +1,18 @@
-'use strict';
-
-const { getStatusCode, getErrorText } = require('../tools.js');
-
+import { getStatusCode, getErrorText } from '../tools.js';
 /**
  * Authenticates user using the IMAP LOGIN command.
  *
- * @param {Object} connection - IMAP connection instance
- * @param {string} username - The username to authenticate with
- * @param {string} password - The password to authenticate with
- * @returns {Promise<string|undefined>} The authenticated username, or undefined if already authenticated
- * @throws {Error} If authentication fails, with authenticationFailed and serverResponseCode properties set
+ * @param connection - IMAP connection instance
+ * @param username - The username to authenticate with
+ * @param password - The password to authenticate with
+ * @returns The authenticated username, or undefined if already authenticated
+ * @throws If authentication fails, with authenticationFailed and serverResponseCode properties set
  */
-module.exports = async (connection, username, password) => {
+export default async function login(connection, username, password) {
     if (connection.state !== connection.states.NOT_AUTHENTICATED) {
         // nothing to do here
         return;
     }
-
     try {
         let response = await connection.exec('LOGIN', [
             { type: 'STRING', value: username },
@@ -24,13 +20,12 @@ module.exports = async (connection, username, password) => {
             { type: 'STRING', value: password, sensitive: true }
         ]);
         response.next();
-
         // Record that LOGIN was the method used, so the connection knows which
         // auth mechanism succeeded (used for reconnection and diagnostics).
         connection.authCapabilities.set('LOGIN', true);
-
         return username;
-    } catch (err) {
+    }
+    catch (err) {
         let errorCode = getStatusCode(err.response);
         if (errorCode) {
             err.serverResponseCode = errorCode;
@@ -39,4 +34,4 @@ module.exports = async (connection, username, password) => {
         err.response = await getErrorText(err.response);
         throw err;
     }
-};
+}

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

@@ -0,0 +1,8 @@
+import type { ImapFlow } from '../imap-flow.js';
+/**
+ * Logs out the user and closes the connection.
+ *
+ * @param connection - IMAP connection instance
+ * @returns True if logout command succeeded, false otherwise
+ */
+export default function logout(connection: ImapFlow): Promise<boolean>;

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

@@ -1,29 +1,26 @@
-'use strict';
-
 /**
  * Logs out the user and closes the connection.
  *
- * @param {Object} connection - IMAP connection instance
- * @returns {Promise<boolean>} True if logout command succeeded, false otherwise
+ * @param connection - IMAP connection instance
+ * @returns True if logout command succeeded, false otherwise
  */
-module.exports = async connection => {
+export default async function logout(connection) {
     if (connection.state === connection.states.LOGOUT) {
         // nothing to do here
         return false;
     }
-
     if (connection.state === connection.states.NOT_AUTHENTICATED) {
-        // Not yet authenticated -- no LOGOUT command needed; just close the socket.
+        // Not yet authenticated, no LOGOUT command needed; just close the socket.
         connection.state = connection.states.LOGOUT;
         connection.close();
         return false;
     }
-
     let response;
     try {
         response = await connection.exec('LOGOUT');
         return true;
-    } catch (err) {
+    }
+    catch (err) {
         // If the connection is already gone, treat as successful logout
         if (err.code === 'NoConnection') {
             return true;
@@ -31,7 +28,8 @@ module.exports = async connection => {
         connection.log.warn({ err, cid: connection.id });
         return false;
         /* c8 ignore next */ // the catch above is exhaustive (never re-throws), so finally is only ever reached via normal completion
-    } finally {
+    }
+    finally {
         // Set state to LOGOUT before closing to prevent any further commands from
         // being queued. The socket is closed unconditionally in this finally block
         // regardless of whether the LOGOUT command succeeded or failed.
@@ -41,4 +39,4 @@ module.exports = async connection => {
         }
         connection.close();
     }
-};
+}