@withbuddi/buddi 0.1.0-pre.19 → 0.1.0-pre.21

package/node_modules/imapflow/dist/cjs/commands/fetch.js

@@ -12,23 +12,23 @@ const tools_js_1 = require("../tools.js");
  * @returns Object with message count and list, or undefined if not in SELECTED state
  */
 async function fetch(connection, range, query, options) {
-    if (connection.state !== connection.states.SELECTED || !range) {
+    let mailbox = (0, tools_js_1.getSelectedMailbox)(connection);
+    if (!mailbox || !range) {
         // nothing to do here
         return;
     }
     options = options || {};
-    let mailbox = connection.mailbox;
     // Use BINARY extension for fetching if supported and requested, otherwise fall back to BODY.
     // RFC 9051 folds the FETCH side of the BINARY extension into base IMAP4rev2, so an active
     // rev2 session can use it even without the BINARY capability token (the APPEND side is NOT
     // folded in and stays gated on the token in append.ts)
     const canUseBinary = connection.capabilities.has('BINARY') || (0, tools_js_1.isRev2Active)(connection);
     const commandKey = canUseBinary && options.binary && !connection.disableBinary ? 'BINARY' : 'BODY';
-    // Retry logic for ETHROTTLE errors (server rate limiting) with exponential backoff
-    let retryCount = 0;
+    // Retry logic for ETHROTTLE errors (server rate limiting) with exponential backoff.
+    // Every pass returns or throws: the last throttled attempt throws instead of retrying.
     const maxRetries = 4;
     const baseDelay = 1000; // Start with 1 second delay
-    while (retryCount < maxRetries) {
+    for (let retryCount = 0;; retryCount++) {
         let messages = {
             count: 0,
             list: []
@@ -205,15 +205,18 @@ async function fetch(connection, range, query, options) {
             return messages;
         }
         catch (err) {
-            if (err.code === 'ETHROTTLE') {
+            // The last throttled attempt falls through and throws, so running out of retries
+            // is never mistaken for an empty result
+            if (err.code === 'ETHROTTLE' && retryCount < maxRetries - 1) {
                 // Server returned a throttle error (rate limiting). Retry with exponential backoff.
-                // Delay doubles each retry: 1s, 2s, 4s, 8s (capped at 30s).
+                // Delay doubles each retry: 1s, 2s, 4s.
                 // If server provides a throttleReset hint, use that if longer.
                 const backoffDelay = Math.min(baseDelay * Math.pow(2, retryCount), 30000); // Cap at 30 seconds
                 // Use throttle reset time if provided and longer than backoff. The hint is
                 // server-controlled, so the wait goes through connection.throttleWait(), which caps
-                // it and keeps the timer tracked and abortable.
-                const delay = err.throttleReset && err.throttleReset > backoffDelay ? err.throttleReset : backoffDelay;
+                // it and keeps the timer tracked and abortable. The connection already waited
+                // part of the back-off before rejecting (throttleWaited), so only the rest is left.
+                const delay = Math.max(err.throttleReset || 0, backoffDelay) - (err.throttleWaited || 0);
                 connection.log.warn({
                     msg: 'Retrying throttled request with exponential backoff',
                     cid: connection.id,
@@ -229,7 +232,6 @@ async function fetch(connection, range, query, options) {
                 if (aborted) {
                     throw connection.createNoConnectionError(connection.byeReason, { rejectedFrom: 'throttleAbort', command: 'FETCH' });
                 }
-                retryCount++;
                 continue;
             }
             connection.log.warn({ err, cid: connection.id });

package/node_modules/imapflow/dist/cjs/commands/idle.js

@@ -124,7 +124,11 @@ async function runIdle(connection) {
     }
     catch (err) {
         (0, tools_js_1.logConnectionError)(connection, 'IDLE session failed', err);
-        if (preCheckWaitQueue.length) {
+        // A tagged NO or BAD only means the server refused IDLE; the connection is still usable,
+        // so the waiters are released by the finally block below and their own commands run.
+        // Anything else (close, lost socket, parser failure) fails the waiters too.
+        let refusedByServer = ['NO', 'BAD'].includes(err.responseStatus);
+        if (preCheckWaitQueue.length && !refusedByServer) {
             // One error for the whole queue: every waiter failed at the same site, for the same
             // reason. Built inside the guard so a teardown with nothing queued - the common case -
             // does not pay for an Error and its stack capture.
@@ -240,7 +244,7 @@ async function runPollingFallback(connection, maxIdleTime) {
                     return;
                 }
                 // The transport or the mailbox may be gone by the time the timer fires
-                if (!connection.socket || connection.socket.destroyed || connection.state !== connection.states.SELECTED || !connection.mailbox) {
+                if (!connection.socket || connection.socket.destroyed || !(0, tools_js_1.getSelectedMailbox)(connection)) {
                     return cancel();
                 }
                 pollOnce(connection, session)

package/node_modules/imapflow/dist/cjs/commands/list.js

@@ -184,7 +184,7 @@ async function list(connection, reference, mailbox, options) {
                             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.parentPath = entry.delimiter && entry.path ? entry.path.substring(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
@@ -395,7 +395,7 @@ async function list(connection, reference, mailbox, options) {
                         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.parentPath = entry.delimiter && entry.path ? entry.path.substring(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
@@ -447,23 +447,27 @@ async function list(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.
-        for (let type of Object.keys(specialUseMatches)) {
-            let sortedEntries = specialUseMatches[type].sort((a, b) => {
-                let aSource = SOURCE_SORT_ORDER.indexOf(a.source);
-                let bSource = SOURCE_SORT_ORDER.indexOf(b.source);
-                if (aSource === bSource) {
-                    return a.entry.path.localeCompare(b.entry.path);
-                }
-                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;
+        // Resolve special-use conflicts. Each type goes to one mailbox and each mailbox gets
+        // at most one type. Candidates are taken in priority order across all types (user >
+        // extension > name, then alphabetically), so a mailbox claimed by a stronger match
+        // leaves its other type to that type's next candidate instead of to nobody.
+        let candidates = Object.entries(specialUseMatches).flatMap(([type, matches]) => matches.map(match => ({ type, ...match })));
+        candidates.sort((a, b) => {
+            let aSource = SOURCE_SORT_ORDER.indexOf(a.source);
+            let bSource = SOURCE_SORT_ORDER.indexOf(b.source);
+            if (aSource === bSource) {
+                return a.entry.path.localeCompare(b.entry.path);
+            }
+            return aSource - bSource;
+        });
+        let assignedTypes = new Set();
+        for (let { type, entry, source } of candidates) {
+            if (assignedTypes.has(type) || entry.specialUse) {
+                continue;
             }
+            entry.specialUse = type;
+            entry.specialUseSource = PUBLIC_SOURCE[source] || source;
+            assignedTypes.add(type);
         }
         // 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

package/node_modules/imapflow/dist/cjs/commands/move.js

@@ -14,7 +14,8 @@ const copyuid_parser_js_1 = require("./copyuid-parser.js");
  * @returns Move result with UID mapping if available, false on failure, or undefined if preconditions not met
  */
 async function move(connection, range, destination, options) {
-    if (connection.state !== connection.states.SELECTED || !range || !destination) {
+    let mailbox = (0, tools_js_1.getSelectedMailbox)(connection);
+    if (!mailbox || !range || !destination) {
         // nothing to do here
         return;
     }
@@ -24,13 +25,18 @@ async function move(connection, range, destination, options) {
         { type: 'SEQUENCE', value: range },
         { type: 'ATOM', value: (0, tools_js_1.encodePath)(connection, destination) }
     ];
-    let map = { path: connection.mailbox.path, destination };
+    let map = { path: mailbox.path, destination };
     // Fallback for servers without the MOVE extension (RFC 6851):
     // emulate MOVE using COPY + flag as \Deleted + EXPUNGE.
     if (!(0, tools_js_1.hasCapability)(connection, 'MOVE')) {
         let result = await connection.messageCopy(range, destination, options);
-        await connection.messageDelete(range, Object.assign({ silent: true }, options));
-        return result;
+        if (!result) {
+            // The source must stay untouched when the copy failed, otherwise the messages are lost
+            return result;
+        }
+        let deleted = await connection.messageDelete(range, Object.assign({ silent: true }, options));
+        // Messages that were copied but not removed from the source mean the move did not complete
+        return deleted ? result : false;
     }
     let response;
     try {
@@ -48,8 +54,7 @@ async function move(connection, range, destination, options) {
         return map;
     }
     catch (err) {
-        await (0, tools_js_1.enhanceCommandError)(err);
-        connection.log.warn({ err, cid: connection.id });
+        await (0, tools_js_1.reportCommandError)(connection, err);
         return false;
     }
 }

package/node_modules/imapflow/dist/cjs/commands/namespace.js

@@ -9,7 +9,7 @@ const tools_js_1 = require("../tools.js");
  * @returns The primary personal namespace, or an error object on failure
  */
 async function namespace(connection) {
-    if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
+    if (!(0, tools_js_1.isAuthenticatedState)(connection)) {
         // nothing to do here
         return;
     }

package/node_modules/imapflow/dist/cjs/commands/quota.js

@@ -10,7 +10,7 @@ const tools_js_1 = require("../tools.js");
  * @returns Quota information object, false if QUOTA not supported or on failure, or undefined if preconditions not met
  */
 async function quota(connection, path) {
-    if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state) || !path) {
+    if (!(0, tools_js_1.isAuthenticatedState)(connection) || !path) {
         // nothing to do here
         return;
     }
@@ -50,19 +50,21 @@ async function quota(connection, path) {
             if ((0, tools_js_1.isUnsafeKey)(key) || key === 'path' || key === 'quotaroot') {
                 return;
             }
-            if (!map[key]) {
-                map[key] = {};
+            let resource = map[key];
+            if (typeof resource !== 'object') {
+                resource = {};
+                map[key] = resource;
             }
             // Storage quota is reported in KB by IMAP; convert to bytes for consistency
             const multiplier = key === 'storage' ? 1024 : 1;
             if (position === 1) {
-                map[key].usage = value * multiplier;
+                resource.usage = value * multiplier;
             }
             else if (position === 2) {
-                map[key].limit = value * multiplier;
+                resource.limit = value * multiplier;
                 // Calculate usage percentage for convenient display
-                if (map[key].limit) {
-                    map[key].status = Math.round(((map[key].usage || 0) / map[key].limit) * 100) + '%';
+                if (resource.limit) {
+                    resource.status = Math.round(((resource.usage || 0) / resource.limit) * 100) + '%';
                 }
             }
         });
@@ -110,8 +112,7 @@ async function quota(connection, path) {
         return map;
     }
     catch (err) {
-        await (0, tools_js_1.enhanceCommandError)(err);
-        connection.log.warn({ err, cid: connection.id });
+        await (0, tools_js_1.reportCommandError)(connection, err);
         return false;
     }
 }

package/node_modules/imapflow/dist/cjs/commands/rename.js

@@ -12,7 +12,7 @@ const tools_js_1 = require("../tools.js");
  * @throws If the RENAME command fails
  */
 async function rename(connection, path, newPath) {
-    if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
+    if (!(0, tools_js_1.isAuthenticatedState)(connection)) {
         // nothing to do here
         return;
     }
@@ -22,7 +22,8 @@ async function rename(connection, path, newPath) {
     newPath = (0, tools_js_1.normalizePath)(connection, newPath);
     // Must close/deselect the mailbox before renaming if it's currently selected,
     // as IMAP servers will not rename an active mailbox.
-    if (connection.state === connection.states.SELECTED && connection.mailbox.path === path) {
+    let selected = (0, tools_js_1.getSelectedMailbox)(connection);
+    if (selected && selected.path === path) {
         await connection.run('CLOSE');
     }
     let response;
@@ -39,8 +40,7 @@ async function rename(connection, path, newPath) {
         return map;
     }
     catch (err) {
-        await (0, tools_js_1.enhanceCommandError)(err);
-        connection.log.warn({ err, cid: connection.id });
+        await (0, tools_js_1.reportCommandError)(connection, err);
         throw err;
     }
 }

package/node_modules/imapflow/dist/cjs/commands/search.js

@@ -34,7 +34,8 @@ const stripEsearchPrefix = (attrs) => {
  *   When server lacks ESEARCH, falls back to plain SEARCH and returns number[].
  */
 async function search(connection, query, options) {
-    if (connection.state !== connection.states.SELECTED) {
+    const mailbox = (0, tools_js_1.getSelectedMailbox)(connection);
+    if (!mailbox) {
         // nothing to do here
         return false;
     }
@@ -92,8 +93,7 @@ async function search(connection, query, options) {
                 return esearchResult;
             }
             catch (err) {
-                await (0, tools_js_1.enhanceCommandError)(err);
-                connection.log.warn({ err, cid: connection.id });
+                await (0, tools_js_1.reportCommandError)(connection, err);
                 return false;
             }
         }
@@ -163,7 +163,7 @@ async function search(connection, query, options) {
                         // for message sequence numbers, while server-sent UID sets may
                         // not contain '*' at all (RFC 9051 section 4.1.1), so UID
                         // parts with '*' are dropped
-                        let existsCount = () => (connection.mailbox && connection.mailbox.exists) || 0;
+                        let existsCount = () => mailbox.exists || 0;
                         // The mailbox EXISTS count is itself server-supplied and can be
                         // absurdly large, so the budget is additionally capped at the same
                         // absolute ceiling expandRange() uses - a hostile server cannot
@@ -188,8 +188,8 @@ async function search(connection, query, options) {
                                 results.add(value);
                                 continue;
                             }
-                            let first = resolveId(part.substr(0, colon));
-                            let second = resolveId(part.substr(colon + 1));
+                            let first = resolveId(part.substring(0, colon));
+                            let second = resolveId(part.slice(colon + 1));
                             if (!(0, tools_js_1.isValidSequenceValue)(first) || !(0, tools_js_1.isValidSequenceValue)(second)) {
                                 discarded = true;
                                 continue;
@@ -219,8 +219,7 @@ async function search(connection, query, options) {
         return Array.from(results).sort((a, b) => a - b);
     }
     catch (err) {
-        await (0, tools_js_1.enhanceCommandError)(err);
-        connection.log.warn({ err, cid: connection.id });
+        await (0, tools_js_1.reportCommandError)(connection, err);
         return false;
     }
 }

package/node_modules/imapflow/dist/cjs/commands/select.js

@@ -59,7 +59,7 @@ const VALUED_RESPONSE_CODES = Object.assign(Object.create(null), {
  * @throws If the SELECT/EXAMINE command fails
  */
 async function select(connection, pathInput, options) {
-    if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
+    if (!(0, tools_js_1.isAuthenticatedState)(connection)) {
         // nothing to do here
         return;
     }
@@ -95,12 +95,16 @@ async function select(connection, pathInput, options) {
         // QRESYNC (RFC 7162): allows efficient mailbox resynchronization by sending
         // the last known UIDVALIDITY and HIGHESTMODSEQ. Server responds with only
         // the changes (new flags, expunged UIDs) since that point.
+        // The caller may pass UIDVALIDITY as a bigint, a number or a string. It is parsed once,
+        // so the value that is sent is also the one checked against the server's below, and a
+        // value that is not a plain decimal skips QRESYNC instead of reaching the server.
+        let uidValidity = options.uidValidity !== undefined ? (0, tools_js_1.parseBigIntValue)(String(options.uidValidity)) : false;
         let extraArgs = [];
-        if (connection.enabled.has('QRESYNC') && options.changedSince && options.uidValidity) {
+        if (connection.enabled.has('QRESYNC') && options.changedSince && uidValidity) {
             extraArgs.push([
                 { type: 'ATOM', value: 'QRESYNC' },
                 [
-                    { type: 'ATOM', value: options.uidValidity?.toString() },
+                    { type: 'ATOM', value: uidValidity.toString() },
                     { type: 'ATOM', value: options.changedSince.toString() }
                 ]
             ]);
@@ -205,7 +209,7 @@ async function select(connection, pathInput, options) {
         // QRESYNC results are only valid if UIDVALIDITY matches, HIGHESTMODSEQ is
         // present, and the mailbox supports mod-sequences. If any condition fails,
         // the client cannot trust the incremental updates and must do a full resync.
-        if (map.qresync && (options.uidValidity !== map.uidValidity || !map.highestModseq || map.noModseq)) {
+        if (map.qresync && (uidValidity !== map.uidValidity || !map.highestModseq || map.noModseq)) {
             map.qresync = false;
         }
         // Transition mailbox state: save previous mailbox reference, temporarily
@@ -215,7 +219,7 @@ async function select(connection, pathInput, options) {
         // Emit mailboxClose if we're switching from a different mailbox.
         // Re-selecting the same mailbox (e.g., for resync) does not trigger close/open.
         if (currentMailbox && currentMailbox.path !== path) {
-            connection.emit('mailboxClose', currentMailbox);
+            (0, tools_js_1.emitSafe)(connection, 'mailboxClose', currentMailbox);
         }
         connection.mailbox = map;
         // Save the SELECT command for potential re-use (e.g., NOOP fallback polling
@@ -223,13 +227,13 @@ async function select(connection, pathInput, options) {
         connection.currentSelectCommand = selectCommand;
         connection.state = connection.states.SELECTED;
         if (!currentMailbox || currentMailbox.path !== path) {
-            connection.emit('mailboxOpen', connection.mailbox);
+            (0, tools_js_1.emitSafe)(connection, 'mailboxOpen', connection.mailbox);
         }
         response.next();
         return map;
     }
     catch (err) {
-        await (0, tools_js_1.enhanceCommandError)(err);
+        await (0, tools_js_1.reportCommandError)(connection, err);
         // If SELECT/EXAMINE fails while a mailbox was already selected, we must
         // reset to AUTHENTICATED state since the server has implicitly deselected
         // the previous mailbox on failure (RFC 3501 Section 6.3.1).
@@ -239,10 +243,9 @@ async function select(connection, pathInput, options) {
             connection.currentSelectCommand = false;
             connection.state = connection.states.AUTHENTICATED;
             if (currentMailbox) {
-                connection.emit('mailboxClose', currentMailbox);
+                (0, tools_js_1.emitSafe)(connection, 'mailboxClose', currentMailbox);
             }
         }
-        connection.log.warn({ err, cid: connection.id });
         throw err;
     }
 }

package/node_modules/imapflow/dist/cjs/commands/status.js

@@ -6,19 +6,18 @@ const status_fields_js_1 = require("./status-fields.js");
 // STATUS fields that also refresh the live mailbox state when the queried mailbox is the
 // currently selected one. Keyed by the output property name parseStatusList() reports.
 const MAILBOX_UPDATERS = {
-    messages: (value, connection, path) => {
-        let mailbox = connection.mailbox;
+    messages: (value, mailbox, connection, path) => {
         let prevCount = mailbox.exists;
         if (prevCount !== value) {
             mailbox.exists = value;
-            connection.emit('exists', { path, count: value, prevCount });
+            (0, tools_js_1.emitSafe)(connection, 'exists', { path, count: value, prevCount });
         }
     },
-    uidNext: (value, connection) => {
-        connection.mailbox.uidNext = value;
+    uidNext: (value, mailbox) => {
+        mailbox.uidNext = value;
     },
-    highestModseq: (value, connection) => {
-        connection.mailbox.highestModseq = value;
+    highestModseq: (value, mailbox) => {
+        mailbox.highestModseq = value;
     }
 };
 /**
@@ -31,7 +30,7 @@ const MAILBOX_UPDATERS = {
  * @throws {Error} If the mailbox does not exist
  */
 async function status(connection, path, query) {
-    if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state) || !path) {
+    if (!(0, tools_js_1.isAuthenticatedState)(connection) || !path) {
         // nothing to do here
         return false;
     }
@@ -62,7 +61,8 @@ async function status(connection, path, query) {
                 STATUS: async (untagged) => {
                     // If querying the currently selected mailbox, also update the
                     // connection's live mailbox state and emit events for changes.
-                    let updateCurrent = connection.state === connection.states.SELECTED && path === connection.mailbox.path;
+                    let selected = (0, tools_js_1.getSelectedMailbox)(connection);
+                    let currentMailbox = selected && selected.path === path ? selected : false;
                     let list = untagged.attributes && Array.isArray(untagged.attributes[1]) ? untagged.attributes[1] : false;
                     if (!list) {
                         return;
@@ -70,8 +70,8 @@ async function status(connection, path, query) {
                     (0, status_fields_js_1.parseStatusList)(list, (key, value) => {
                         map[key] = value;
                         let updater = MAILBOX_UPDATERS[key];
-                        if (updateCurrent && updater) {
-                            updater(value, connection, path);
+                        if (currentMailbox && updater) {
+                            updater(value, currentMailbox, connection, path);
                         }
                     });
                 }

package/node_modules/imapflow/dist/cjs/commands/store.js

@@ -12,7 +12,8 @@ const tools_js_1 = require("../tools.js");
  * @returns True on success, false on failure or if nothing to do
  */
 async function store(connection, range, flags, options) {
-    if (connection.state !== connection.states.SELECTED || !range || (options.useLabels && !connection.capabilities.has('X-GM-EXT-1'))) {
+    let mailbox = (0, tools_js_1.getSelectedMailbox)(connection);
+    if (!mailbox || !range || (options.useLabels && !connection.capabilities.has('X-GM-EXT-1'))) {
         // nothing to do here
         return false;
     }
@@ -48,7 +49,7 @@ async function store(connection, range, flags, options) {
     flags = (Array.isArray(flags) ? flags : [].concat(flags || []))
         .map(flag => {
         let formatted = (0, tools_js_1.formatFlag)(flag);
-        if (!(0, tools_js_1.canUseFlag)(connection.mailbox, formatted) && options.operation !== 'remove') {
+        if (!(0, tools_js_1.canUseFlag)(mailbox, formatted) && options.operation !== 'remove') {
             return false;
         }
         return formatted;
@@ -65,7 +66,7 @@ async function store(connection, range, flags, options) {
     ];
     // CONDSTORE (RFC 7162): UNCHANGEDSINCE modifier prevents updating messages whose
     // mod-sequence is higher than the specified value, avoiding overwriting concurrent changes.
-    if (options.unchangedSince && connection.enabled.has('CONDSTORE') && !connection.mailbox.noModseq) {
+    if (options.unchangedSince && connection.enabled.has('CONDSTORE') && !mailbox.noModseq) {
         attributes.push([
             {
                 type: 'ATOM',
@@ -84,8 +85,7 @@ async function store(connection, range, flags, options) {
         return true;
     }
     catch (err) {
-        await (0, tools_js_1.enhanceCommandError)(err);
-        connection.log.warn({ err, cid: connection.id });
+        await (0, tools_js_1.reportCommandError)(connection, err);
         return false;
     }
 }

package/node_modules/imapflow/dist/cjs/commands/subscribe.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = subscribe;
-const tools_js_1 = require("../tools.js");
+const subscription_js_1 = require("./subscription.js");
 /**
  * Subscribes to a mailbox.
  *
@@ -10,22 +10,7 @@ const tools_js_1 = require("../tools.js");
  * @returns True on success, false on failure, or undefined if preconditions not met
  */
 async function subscribe(connection, path) {
-    if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
-        // nothing to do here
-        return;
-    }
-    path = (0, tools_js_1.normalizePath)(connection, path);
-    let response;
-    try {
-        response = await connection.exec('SUBSCRIBE', [{ type: 'ATOM', value: (0, tools_js_1.encodePath)(connection, path) }]);
-        response.next();
-        return true;
-    }
-    catch (err) {
-        await (0, tools_js_1.enhanceCommandError)(err);
-        connection.log.warn({ err, cid: connection.id });
-        return false;
-    }
+    return await (0, subscription_js_1.setSubscription)(connection, 'SUBSCRIBE', path);
 }
 module.exports = exports.default;
 Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/node_modules/imapflow/dist/cjs/commands/subscription.d.ts

@@ -0,0 +1,10 @@
+import type { ImapFlow } from '../imap-flow.js';
+/**
+ * Runs SUBSCRIBE or UNSUBSCRIBE for a mailbox, the shared body of the two commands.
+ *
+ * @param connection - IMAP connection instance
+ * @param command - SUBSCRIBE or UNSUBSCRIBE
+ * @param path - Mailbox path
+ * @returns True on success, false on failure, or undefined if preconditions not met
+ */
+export declare function setSubscription(connection: ImapFlow, command: 'SUBSCRIBE' | 'UNSUBSCRIBE', path: string | string[]): Promise<boolean | undefined>;

package/node_modules/imapflow/dist/cjs/commands/subscription.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSubscription = setSubscription;
+const tools_js_1 = require("../tools.js");
+/**
+ * Runs SUBSCRIBE or UNSUBSCRIBE for a mailbox, the shared body of the two commands.
+ *
+ * @param connection - IMAP connection instance
+ * @param command - SUBSCRIBE or UNSUBSCRIBE
+ * @param path - Mailbox path
+ * @returns True on success, false on failure, or undefined if preconditions not met
+ */
+async function setSubscription(connection, command, path) {
+    if (!(0, tools_js_1.isAuthenticatedState)(connection)) {
+        // nothing to do here
+        return;
+    }
+    path = (0, tools_js_1.normalizePath)(connection, path);
+    let response;
+    try {
+        response = await connection.exec(command, [{ type: 'ATOM', value: (0, tools_js_1.encodePath)(connection, path) }]);
+        response.next();
+        return true;
+    }
+    catch (err) {
+        await (0, tools_js_1.reportCommandError)(connection, err);
+        return false;
+    }
+}

package/node_modules/imapflow/dist/cjs/commands/unsubscribe.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = unsubscribe;
-const tools_js_1 = require("../tools.js");
+const subscription_js_1 = require("./subscription.js");
 /**
  * Unsubscribes from a mailbox.
  *
@@ -10,22 +10,7 @@ const tools_js_1 = require("../tools.js");
  * @returns True on success, false on failure, or undefined if preconditions not met
  */
 async function unsubscribe(connection, path) {
-    if (![connection.states.AUTHENTICATED, connection.states.SELECTED].includes(connection.state)) {
-        // nothing to do here
-        return;
-    }
-    path = (0, tools_js_1.normalizePath)(connection, path);
-    let response;
-    try {
-        response = await connection.exec('UNSUBSCRIBE', [{ type: 'ATOM', value: (0, tools_js_1.encodePath)(connection, path) }]);
-        response.next();
-        return true;
-    }
-    catch (err) {
-        await (0, tools_js_1.enhanceCommandError)(err);
-        connection.log.warn({ err, cid: connection.id });
-        return false;
-    }
+    return await (0, subscription_js_1.setSubscription)(connection, 'UNSUBSCRIBE', path);
 }
 module.exports = exports.default;
 Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/node_modules/imapflow/dist/cjs/download.d.ts

@@ -0,0 +1,22 @@
+import type { ImapFlow } from './imap-flow.js';
+import type { DownloadManyOptions, DownloadManyResult, DownloadNotFound, DownloadObject, DownloadOptions, SequenceString } from './types.js';
+/**
+ * Implements ImapFlow.download(), see its documentation
+ *
+ * @param client - Connection to download from
+ * @param range - UID or sequence number of the message
+ * @param part - Body part to download, the whole message when not set
+ * @param options - Download options
+ * @returns The download, or an empty object when there is nothing to download
+ */
+export declare function downloadMessage(client: ImapFlow, range: SequenceString, part?: string | undefined, options?: DownloadOptions | undefined): Promise<DownloadObject | DownloadNotFound>;
+/**
+ * Implements ImapFlow.downloadMany(), see its documentation
+ *
+ * @param client - Connection to download from
+ * @param range - UID or sequence number of the message
+ * @param parts - Body parts to download
+ * @param options - Download options
+ * @returns Downloaded parts keyed by part number
+ */
+export declare function downloadMessageParts(client: ImapFlow, range: SequenceString, parts: string[], options?: DownloadManyOptions | undefined): Promise<DownloadManyResult>;