imapkit 4.0.3 → 4.1.0

package/{lib → dist/esm}/plugins/quota.js

@@ -1,15 +1,11 @@
-'use strict';
-
-const { states } = require('../command-states');
-const { normalizeLineBreaks } = require('../mimeparser');
-const { MAX_NUMBER64, isNumber } = require('../numbers');
-const { isAstring } = require('../arguments');
-
+import { states } from '../command-states.js';
+import { normalizeLineBreaks } from '../mimeparser.js';
+import { MAX_NUMBER64, isNumber } from '../numbers.js';
+import { isAstring } from '../arguments.js';
 // Resource types of RFC 9208 section 5 that can be counted. ANNOTATION-STORAGE is left out,
 // as there is no ANNOTATE support
 const RESOURCES = ['STORAGE', 'MESSAGE', 'MAILBOX'];
 const DEFAULT_ROOT = 'User quota';
-
 /**
  * @help Adds QUOTA [RFC9208] capability with the STORAGE, MESSAGE and MAILBOX
  * @help resources and SETQUOTA. All personal mailboxes share one quota root, set
@@ -26,14 +22,13 @@ const DEFAULT_ROOT = 'User quota';
  * Additional STATUS items:
  * - DELETED, DELETED-STORAGE
  */
-module.exports = function (server) {
+export default function quotaPlugin(server) {
     const config = server.options.quota || {};
     const root = {
         name: typeof config.root === 'string' ? config.root : DEFAULT_ROOT,
         soft: !!config.soft,
         limits: {}
     };
-
     RESOURCES.forEach(resource => {
         if (config[resource] === undefined || config[resource] === null) {
             return;
@@ -44,21 +39,16 @@ module.exports = function (server) {
         }
         root.limits[resource] = limit;
     });
-
     // RFC 9208 sections 3.1.1 and 5: every supported resource is advertised, SETQUOTA needs QUOTASET
     server.registerCapability('QUOTA');
     RESOURCES.forEach(resource => server.registerCapability('QUOTA=RES-' + resource));
     server.registerCapability('QUOTASET');
-
     // Personal mailboxes, INBOX included, belong to the quota root. Other namespaces have no quota root. A mailbox
     // that does not exist yet belongs to the namespace of its prefix
-    const inRoot = path => server.isPersonal(path);
-
-    const isSelectable = mailbox => mailbox.flags.indexOf('\\Noselect') < 0;
-
+    const inRoot = (path) => server.isPersonal(path);
+    const isSelectable = (mailbox) => mailbox.flags.indexOf('\\Noselect') < 0;
     // RFC822.SIZE, the message with CRLF line breaks
-    const totalSize = messages => messages.reduce((total, message) => total + normalizeLineBreaks(message.raw).length, 0);
-
+    const totalSize = (messages) => messages.reduce((total, message) => total + normalizeLineBreaks(message.raw).length, 0);
     const getUsage = () => {
         const usage = { MESSAGE: 0, MAILBOX: 0, bytes: 0 };
         Object.keys(server.folderCache).forEach(path => {
@@ -72,7 +62,6 @@ module.exports = function (server) {
         });
         return usage;
     };
-
     // RFC 9208 section 4.2.1: quota-list, resources that are not listed are not limited
     const sendQuota = (connection, parsed, data) => {
         const usage = getUsage();
@@ -84,32 +73,25 @@ module.exports = function (server) {
                 list.push({ type: 'ATOM', value: resource }, usage[resource], root.limits[resource]);
             }
         });
-        connection.send(
-            {
-                tag: '*',
-                command: 'QUOTA',
-                attributes: [{ type: 'STRING', value: root.name }, list]
-            },
-            'QUOTA',
-            parsed,
-            data
-        );
+        connection.send({
+            tag: '*',
+            command: 'QUOTA',
+            attributes: [{ type: 'STRING', value: root.name }, list]
+        }, 'QUOTA', parsed, data);
     };
-
     /**
      * Checks if adding to the quota root goes over a limit
      *
      * @param {Object} added Added amounts, `{ MESSAGE, MAILBOX, bytes }`
      * @return {Object|undefined} `{ code, text, soft }` for IMAPConnection#checkAppend, or nothing if within limits
      */
-    const checkLimits = added => {
+    const checkLimits = (added) => {
         const limited = (added.MESSAGE && 'MESSAGE' in root.limits) || (added.bytes && 'STORAGE' in root.limits) || (added.MAILBOX && 'MAILBOX' in root.limits);
         if (!limited) {
             return;
         }
         const usage = getUsage();
-        const over =
-            (added.MESSAGE && 'MESSAGE' in root.limits && usage.MESSAGE + added.MESSAGE > root.limits.MESSAGE) ||
+        const over = (added.MESSAGE && 'MESSAGE' in root.limits && usage.MESSAGE + added.MESSAGE > root.limits.MESSAGE) ||
             (added.bytes && 'STORAGE' in root.limits && usage.bytes + added.bytes > root.limits.STORAGE * 1024) ||
             (added.MAILBOX && 'MAILBOX' in root.limits && usage.MAILBOX + added.MAILBOX > root.limits.MAILBOX);
         if (!over) {
@@ -118,7 +100,6 @@ module.exports = function (server) {
         // RFC 9208 section 4.3.1 and RFC 5530 section 3
         return root.soft ? { code: 'OVERQUOTA', text: 'Soft quota has been exceeded', soft: true } : { code: 'OVERQUOTA', text: 'Quota exceeded' };
     };
-
     // APPEND, COPY, MOVE and REPLACE
     server.appendChecks.push((connection, mailbox, messages, options) => {
         if (!messages.length || !inRoot(mailbox)) {
@@ -136,9 +117,8 @@ module.exports = function (server) {
         }
         return checkLimits(added);
     });
-
     // Number of mailboxes that CREATE adds, missing parent mailboxes are created as well
-    const countNewMailboxes = path => {
+    const countNewMailboxes = (path) => {
         const target = server.getMailbox(server.stripSeparator(path, server.getSeparator(path)));
         let count = !target || !isSelectable(target) ? 1 : 0;
         for (let parent = server.getParentPath(path); parent; parent = server.getParentPath(parent)) {
@@ -148,132 +128,106 @@ module.exports = function (server) {
         }
         return count;
     };
-
     // The MAILBOX resource limits CREATE and RENAME INBOX (which creates a mailbox)
     const wrapCreate = (command, getPath) => {
+        // CREATE and RENAME are core commands, so the handler exists
         const prevHandler = server.getCommandHandler(command);
         server.setCommandHandler(command, (connection, parsed, data, callback) => {
             const path = getPath(parsed.attributes);
-            if (
-                typeof path === 'string' &&
+            if (typeof path === 'string' &&
                 path.toUpperCase() !== 'INBOX' &&
                 inRoot(path) &&
-                !connection.applyChecks([checkLimits({ MAILBOX: countNewMailboxes(path) })], parsed, data, command + ' FAILED')
-            ) {
+                !connection.applyChecks([checkLimits({ MAILBOX: countNewMailboxes(path) })], parsed, data, command + ' FAILED')) {
                 return callback();
             }
             prevHandler(connection, parsed, data, callback);
         });
     };
-
     const argValue = (attributes, i) => isAstring((attributes || [])[i]) && attributes[i].value;
-
-    wrapCreate('CREATE', attributes => (attributes && attributes.length === 1 ? argValue(attributes, 0) : false));
-    wrapCreate('RENAME', attributes => {
+    wrapCreate('CREATE', (attributes) => (attributes && attributes.length === 1 ? argValue(attributes, 0) : false));
+    wrapCreate('RENAME', (attributes) => {
         const source = argValue(attributes, 0);
         // only RENAME INBOX adds a mailbox, other renames keep the count (RFC 3501 section 6.3.5)
         return attributes && attributes.length === 2 && typeof source === 'string' && source.toUpperCase() === 'INBOX' ? argValue(attributes, 1) : false;
     });
-
     // RFC 9208 section 4.1.1: GETQUOTA quota-root-name
-    server.setCommandHandler(
-        'GETQUOTA',
-        (connection, parsed, data, callback) => {
-            if (!parsed.attributes || parsed.attributes.length !== 1 || !isAstring(parsed.attributes[0])) {
-                connection.sendStatus(parsed, data, 'BAD', 'GETQUOTA expects a quota root name');
-                return callback();
-            }
-            if (parsed.attributes[0].value !== root.name) {
-                connection.sendStatus(parsed, data, 'NO', 'Quota root does not exist', 'NONEXISTENT');
-                return callback();
-            }
-            sendQuota(connection, parsed, data);
-            connection.sendStatus(parsed, data, 'OK', 'GETQUOTA completed');
+    server.setCommandHandler('GETQUOTA', (connection, parsed, data, callback) => {
+        if (!parsed.attributes || parsed.attributes.length !== 1 || !isAstring(parsed.attributes[0])) {
+            connection.sendStatus(parsed, data, 'BAD', 'GETQUOTA expects a quota root name');
             return callback();
-        },
-        // quota-root = astring (RFC 9208 section 9)
-        { states: states.AUTHENTICATED, astringArguments: [0] }
-    );
-
+        }
+        if (parsed.attributes[0].value !== root.name) {
+            connection.sendStatus(parsed, data, 'NO', 'Quota root does not exist', 'NONEXISTENT');
+            return callback();
+        }
+        sendQuota(connection, parsed, data);
+        connection.sendStatus(parsed, data, 'OK', 'GETQUOTA completed');
+        return callback();
+    }, 
+    // quota-root = astring (RFC 9208 section 9)
+    { states: states.AUTHENTICATED, astringArguments: [0] });
     // RFC 9208 section 4.1.2: GETQUOTAROOT mailbox, the mailbox does not have to exist
-    server.setCommandHandler(
-        'GETQUOTAROOT',
-        (connection, parsed, data, callback) => {
-            if (!parsed.attributes || parsed.attributes.length !== 1 || !isAstring(parsed.attributes[0])) {
-                connection.sendStatus(parsed, data, 'BAD', 'GETQUOTAROOT expects a mailbox name');
-                return callback();
-            }
-            let path = parsed.attributes[0].value;
-            if (path.toUpperCase() === 'INBOX') {
-                path = 'INBOX';
-            }
-            const hasRoot = inRoot(path);
-            connection.send(
-                {
-                    tag: '*',
-                    command: 'QUOTAROOT',
-                    attributes: [{ type: 'MAILBOX', value: path }].concat(hasRoot ? { type: 'STRING', value: root.name } : [])
-                },
-                'QUOTAROOT',
-                parsed,
-                data
-            );
-            if (hasRoot) {
-                sendQuota(connection, parsed, data);
-            }
-            connection.sendStatus(parsed, data, 'OK', 'GETQUOTAROOT completed');
+    server.setCommandHandler('GETQUOTAROOT', (connection, parsed, data, callback) => {
+        if (!parsed.attributes || parsed.attributes.length !== 1 || !isAstring(parsed.attributes[0])) {
+            connection.sendStatus(parsed, data, 'BAD', 'GETQUOTAROOT expects a mailbox name');
             return callback();
-        },
-        { states: states.AUTHENTICATED, mailboxArguments: [0] }
-    );
-
+        }
+        let path = parsed.attributes[0].value;
+        if (path.toUpperCase() === 'INBOX') {
+            path = 'INBOX';
+        }
+        const hasRoot = inRoot(path);
+        connection.send({
+            tag: '*',
+            command: 'QUOTAROOT',
+            attributes: [{ type: 'MAILBOX', value: path }].concat(hasRoot ? { type: 'STRING', value: root.name } : [])
+        }, 'QUOTAROOT', parsed, data);
+        if (hasRoot) {
+            sendQuota(connection, parsed, data);
+        }
+        connection.sendStatus(parsed, data, 'OK', 'GETQUOTAROOT completed');
+        return callback();
+    }, { states: states.AUTHENTICATED, mailboxArguments: [0] });
     // RFC 9208 section 4.1.3: SETQUOTA quota-root-name setquota-list, the new limits replace all earlier ones
-    server.setCommandHandler(
-        'SETQUOTA',
-        (connection, parsed, data, callback) => {
-            const list = parsed.attributes && parsed.attributes[1];
-            if (!parsed.attributes || parsed.attributes.length !== 2 || !isAstring(parsed.attributes[0]) || !Array.isArray(list) || list.length % 2) {
-                connection.sendStatus(parsed, data, 'BAD', 'SETQUOTA expects a quota root name and a list of resource limits');
+    server.setCommandHandler('SETQUOTA', (connection, parsed, data, callback) => {
+        const list = parsed.attributes && parsed.attributes[1];
+        if (!parsed.attributes || parsed.attributes.length !== 2 || !isAstring(parsed.attributes[0]) || !Array.isArray(list) || list.length % 2) {
+            connection.sendStatus(parsed, data, 'BAD', 'SETQUOTA expects a quota root name and a list of resource limits');
+            return callback();
+        }
+        const limits = {};
+        for (let i = 0; i < list.length; i += 2) {
+            const name = list[i];
+            const limit = list[i + 1];
+            // setquota-resource = resource-name SP resource-limit, resource-limit = number64
+            if (!name || name.type !== 'ATOM' || !limit || limit.type !== 'ATOM' || !isNumber(limit.value, MAX_NUMBER64)) {
+                connection.sendStatus(parsed, data, 'BAD', 'Invalid resource limit');
                 return callback();
             }
-
-            const limits = {};
-            for (let i = 0; i < list.length; i += 2) {
-                const name = list[i];
-                const limit = list[i + 1];
-                // setquota-resource = resource-name SP resource-limit, resource-limit = number64
-                if (!name || name.type !== 'ATOM' || !limit || limit.type !== 'ATOM' || !isNumber(limit.value, MAX_NUMBER64)) {
-                    connection.sendStatus(parsed, data, 'BAD', 'Invalid resource limit');
-                    return callback();
-                }
-                const resource = name.value.toUpperCase();
-                if (RESOURCES.indexOf(resource) < 0 || resource in limits) {
-                    connection.sendStatus(parsed, data, 'NO', 'Can not set a limit for ' + resource, 'CANNOT');
-                    return callback();
-                }
-                const value = Number(limit.value);
-                if (!Number.isSafeInteger(value)) {
-                    connection.sendStatus(parsed, data, 'NO', 'Limit is too large for ' + resource, 'LIMIT');
-                    return callback();
-                }
-                limits[resource] = value;
+            const resource = name.value.toUpperCase();
+            if (RESOURCES.indexOf(resource) < 0 || resource in limits) {
+                connection.sendStatus(parsed, data, 'NO', 'Can not set a limit for ' + resource, 'CANNOT');
+                return callback();
             }
-
-            // new quota roots can not be created
-            if (parsed.attributes[0].value !== root.name) {
-                connection.sendStatus(parsed, data, 'NO', 'Quota root does not exist', 'NONEXISTENT');
+            const value = Number(limit.value);
+            if (!Number.isSafeInteger(value)) {
+                connection.sendStatus(parsed, data, 'NO', 'Limit is too large for ' + resource, 'LIMIT');
                 return callback();
             }
-
-            root.limits = limits;
-            sendQuota(connection, parsed, data);
-            connection.sendStatus(parsed, data, 'OK', 'SETQUOTA completed');
+            limits[resource] = value;
+        }
+        // new quota roots can not be created
+        if (parsed.attributes[0].value !== root.name) {
+            connection.sendStatus(parsed, data, 'NO', 'Quota root does not exist', 'NONEXISTENT');
             return callback();
-        },
-        // quota-root = astring (RFC 9208 section 9)
-        { states: states.AUTHENTICATED, astringArguments: [0] }
-    );
-
+        }
+        root.limits = limits;
+        sendQuota(connection, parsed, data);
+        connection.sendStatus(parsed, data, 'OK', 'SETQUOTA completed');
+        return callback();
+    }, 
+    // quota-root = astring (RFC 9208 section 9)
+    { states: states.AUTHENTICATED, astringArguments: [0] });
     // RFC 9208 section 4.1.4: DELETED (the built-in item, required with QUOTA=RES-MESSAGE) and DELETED-STORAGE
     // (required with QUOTA=RES-STORAGE), the storage EXPUNGE would free as the sum of RFC822.SIZE
     ['DELETED', 'DELETED-STORAGE'].forEach(item => {
@@ -282,4 +236,4 @@ module.exports = function (server) {
         }
     });
     server.statusHandlers['DELETED-STORAGE'] = (connection, mailbox) => totalSize(mailbox.messages.filter(message => message.flags.indexOf('\\Deleted') >= 0));
-};
+}

package/dist/esm/plugins/replace.d.ts

@@ -0,0 +1,14 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds REPLACE [RFC8508] capability (REPLACE and UID REPLACE commands)
+ *
+ * REPLACE: https://www.rfc-editor.org/rfc/rfc8508
+ *
+ * Additional commands:
+ * - REPLACE
+ * - UID REPLACE
+ *
+ * The new message is appended and the old one expunged as a single action. With UIDPLUS the
+ * APPENDUID response code is sent in an untagged OK before the EXPUNGE. Works with CATENATE.
+ */
+export default function replacePlugin(server: IMAPServer): void;

package/{lib → dist/esm}/plugins/replace.js

@@ -1,12 +1,8 @@
-'use strict';
-
-const { prepareAppend, storeMessages } = require('../commands/append');
-const { states } = require('../command-states');
-const { isNzNumber } = require('../numbers');
-
+import { prepareAppend, storeMessages } from '../commands/append.js';
+import { states } from '../command-states.js';
+import { isNzNumber } from '../numbers.js';
 // RFC 8508 section 5 and RFC 3501 section 9: seq-number = nz-number / "*"
-const isSeqNumber = value => value === '*' || isNzNumber(value);
-
+const isSeqNumber = (value) => value === '*' || isNzNumber(value);
 /**
  * @help Adds REPLACE [RFC8508] capability (REPLACE and UID REPLACE commands)
  *
@@ -19,72 +15,50 @@ const isSeqNumber = value => value === '*' || isNzNumber(value);
  * The new message is appended and the old one expunged as a single action. With UIDPLUS the
  * APPENDUID response code is sent in an untagged OK before the EXPUNGE. Works with CATENATE.
  */
-module.exports = function (server) {
+export default function replacePlugin(server) {
     server.registerCapability('REPLACE');
-
     const replaceHandler = function (uidMode, connection, parsed, data, callback) {
         const command = uidMode ? 'UID REPLACE' : 'REPLACE';
         const args = [].concat(parsed.attributes || []);
         const id = args.shift();
         const pathArg = args.shift();
-
         // RFC 8508 section 5: replace = "REPLACE" SP seq-number SP mailbox append-message
         if (!id || ['ATOM', 'SEQUENCE'].indexOf(id.type) < 0 || !isSeqNumber(String(id.value))) {
             connection.sendStatus(parsed, data, 'BAD', command + ' expects a message number, a mailbox name and a message', false, 'INVALID COMMAND');
             return callback();
         }
-
         const found = findMessage(connection, uidMode, id.value);
         if (found.error) {
-            connection.sendStatus(
-                parsed,
-                data,
-                found.error.command,
-                found.error.text,
-                found.error.code || false,
-                found.error.command === 'BAD' ? 'INVALID COMMAND' : command + ' FAILED'
-            );
+            connection.sendStatus(parsed, data, found.error.command, found.error.text, found.error.code || false, found.error.command === 'BAD' ? 'INVALID COMMAND' : command + ' FAILED');
             return callback();
         }
         const message = found.message;
-
         // RFC 8508 section 4.7: REPLACE takes a single message even with MULTIAPPEND. Nothing is
         // changed if the new message can not be appended (section 3.4)
         const prepared = prepareAppend(connection, parsed, data, pathArg, args, { command, maxMessages: 1, replaced: message });
         if (!prepared) {
             return callback();
         }
-
         const result = storeMessages(connection, prepared);
-
         // Hook for UIDPLUS to send APPENDUID in an untagged OK before the EXPUNGE
         // (RFC 8508 section 4.3). If UIDPLUS is not loaded, this is not sent
-        connection.send(
-            {
-                tag: '*',
-                command: 'OK',
-                attributes: [
-                    {
-                        type: 'TEXT',
-                        value: 'Replacement message saved'
-                    }
-                ],
-                skipResponse: true
-            },
-            'REPLACE APPENDUID',
-            parsed,
-            data,
-            result
-        );
-
+        connection.send({
+            tag: '*',
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'Replacement message saved'
+                }
+            ],
+            skipResponse: true
+        }, 'REPLACE APPENDUID', parsed, data, result);
         // only the replaced message is expunged, not every \Deleted message (RFC 8508 section 3.4).
         // When the new message went to the selected mailbox, it was already announced with EXISTS
         connection.expungeSpecificMessages(connection.selectedMailbox, [message], false, true);
-
         connection.sendStatus(parsed, data, 'OK', command + ' completed', false, command);
         callback();
     };
-
     // Refuse the literal of the new message when the message to replace is already known to be
     // invalid, unless earlier commands are still running and could change the selected mailbox
     server.literalFilters.push((connection, command, line) => {
@@ -94,7 +68,6 @@ module.exports = function (server) {
         const match = line.match(/^\S+ (?:UID )?REPLACE ([^ ]+) /i);
         return (match && isSeqNumber(match[1]) && findMessage(connection, command === 'UID REPLACE', match[1]).error) || false;
     });
-
     // RFC 8508 section 3.5: valid only in the selected state, the second argument is the target mailbox
     // the message can be a literal8 with BINARY: RFC 8508 section 6 uses append-message, whose append-data
     // is a literal8 too (RFC 4466 section 2.7)
@@ -102,8 +75,7 @@ module.exports = function (server) {
     const options = { states: states.SELECTED, mailboxArguments: [1], literal8: 'BINARY', appendMessage: true };
     server.setCommandHandler('REPLACE', replaceHandler.bind(null, false), Object.assign({ sequenceSet: 0 }, options));
     server.setCommandHandler('UID REPLACE', replaceHandler.bind(null, true), options);
-};
-
+}
 /**
  * Finds the message to replace in the selected mailbox
  *
@@ -119,8 +91,9 @@ function findMessage(connection, uidMode, value) {
     if (uidMode) {
         // "*" is the UID of the last message (RFC 3501 section 9, seq-number)
         const uid = value === '*' ? (messages.length ? messages[messages.length - 1].uid : 0) : Number(value);
-        message = messages.find(item => item.uid === uid);
-    } else {
+        message = messages.find((item) => item.uid === uid);
+    }
+    else {
         const seq = value === '*' ? messages.length : Number(value);
         // RFC 3501 section 9, seq-number: a sequence number greater than the number of messages
         // (or "*" in an empty mailbox) gets a tagged BAD
@@ -129,17 +102,14 @@ function findMessage(connection, uidMode, value) {
         }
         message = messages[seq - 1];
     }
-
     // RFC 8508 section 3.2: NO - can't remove specified message
     if (!message || message.ghost) {
         return { error: { command: 'NO', text: 'No such message' } };
     }
-
     // the old message is expunged, which is not allowed after EXAMINE
     const readOnly = connection.readOnlyRefusal();
     if (readOnly) {
         return { error: readOnly };
     }
-
     return { message };
 }

package/dist/esm/plugins/sasl-ir.d.ts

@@ -0,0 +1,5 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Enables SASL-IR [RFC4959] capability
+ */
+export default function saslIrPlugin(server: IMAPServer): void;

package/{lib → dist/esm}/plugins/sasl-ir.js

@@ -1,12 +1,9 @@
-'use strict';
-
 /**
  * @help Enables SASL-IR [RFC4959] capability
  */
-
-module.exports = function (server) {
+export default function saslIrPlugin(server) {
     // Register capability, usable for non authenticated users
-    server.registerCapability('SASL-IR', connection => {
+    server.registerCapability('SASL-IR', (connection) => {
         return connection.state === 'Not Authenticated';
     });
-};
+}

package/dist/esm/plugins/savedate.d.ts

@@ -0,0 +1,17 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds SAVEDATE [RFC8514] capability
+ * @help Every message gets a save date when it is added to a mailbox (APPEND,
+ * @help COPY, MOVE, and when the storage is loaded), messages in storage can
+ * @help set it with a "SAVEDATE" value. A mailbox with "SAVEDATE": false in
+ * @help storage does not support save dates, FETCH returns NIL for its messages
+ *
+ * SAVEDATE: https://www.rfc-editor.org/rfc/rfc8514.txt
+ *
+ * Additional FETCH items:
+ * - SAVEDATE
+ *
+ * Additional SEARCH keys:
+ * - SAVEDBEFORE, SAVEDON, SAVEDSINCE, SAVEDATESUPPORTED
+ */
+export default function savedatePlugin(server: IMAPServer): void;

package/{lib → dist/esm}/plugins/savedate.js

@@ -1,7 +1,4 @@
-'use strict';
-
-const { getDateKey } = require('../commands/handlers/search');
-
+import { getDateKey } from '../commands/handlers/search.js';
 /**
  * @help Adds SAVEDATE [RFC8514] capability
  * @help Every message gets a save date when it is added to a mailbox (APPEND,
@@ -17,12 +14,10 @@ const { getDateKey } = require('../commands/handlers/search');
  * Additional SEARCH keys:
  * - SAVEDBEFORE, SAVEDON, SAVEDSINCE, SAVEDATESUPPORTED
  */
-module.exports = function (server) {
+export default function savedatePlugin(server) {
     server.registerCapability('SAVEDATE');
-
     // RFC 8514 section 3: storage may lack save dates for some mailboxes
-    const isSupported = mailbox => !!mailbox && mailbox.SAVEDATE !== false;
-
+    const isSupported = (mailbox) => !!mailbox && mailbox.SAVEDATE !== false;
     // RFC 8514 section 3: the save date is the current time when the message is saved in a mailbox, it is
     // never copied from the source message. Messages from storage may bring their own value.
     server.messageHandlers.push((server, message, mailbox) => {
@@ -30,17 +25,14 @@ module.exports = function (server) {
             delete message.SAVEDATE;
             return;
         }
-
         const savedate = server.normalizeDateTime(message.SAVEDATE || new Date());
         if (!server.validateInternalDate(savedate)) {
             throw new Error('Invalid SAVEDATE value ' + JSON.stringify(savedate) + ' in mailbox ' + mailbox.path);
         }
         message.SAVEDATE = savedate;
     });
-
     // RFC 8514 section 4.2: date-time, or NIL if the mailbox does not support save dates
     server.fetchHandlers.SAVEDATE = (connection, message) => message.SAVEDATE || null;
-
     const dateKey = (name, compare) => {
         const handler = (connection, message, index, date) => {
             // RFC 8514 section 4.3: without save dates the internal date is used instead
@@ -50,10 +42,8 @@ module.exports = function (server) {
         handler.argumentTypes = () => ['date'];
         server.searchHandlers[name] = handler;
     };
-
     dateKey('SAVEDBEFORE', (saved, date) => saved < date);
     dateKey('SAVEDON', (saved, date) => saved === date);
     dateKey('SAVEDSINCE', (saved, date) => saved >= date);
-
-    server.searchHandlers.SAVEDATESUPPORTED = connection => isSupported(connection.selectedMailbox);
-};
+    server.searchHandlers.SAVEDATESUPPORTED = (connection) => isSupported(connection.selectedMailbox);
+}

package/dist/esm/plugins/savelimit.d.ts

@@ -0,0 +1,10 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Adds SAVELIMIT [RFC9738] capability, advertised as SAVELIMIT=<n>
+ * @help Server option "messageLimit" sets n (default 1000). COPY and APPEND (MULTIAPPEND)
+ * @help of more messages fail with NO [MESSAGELIMIT ...], other commands are not limited.
+ * @help Can not be loaded with MESSAGELIMIT
+ *
+ * SAVELIMIT: https://www.rfc-editor.org/rfc/rfc9738
+ */
+export default function savelimitPlugin(server: IMAPServer): void;

package/{lib → dist/esm}/plugins/savelimit.js

@@ -1,7 +1,4 @@
-'use strict';
-
-const { getLimit, addSaveLimit } = require('./messagelimit');
-
+import { getLimit, addSaveLimit } from './messagelimit.js';
 /**
  * @help Adds SAVELIMIT [RFC9738] capability, advertised as SAVELIMIT=<n>
  * @help Server option "messageLimit" sets n (default 1000). COPY and APPEND (MULTIAPPEND)
@@ -10,9 +7,9 @@ const { getLimit, addSaveLimit } = require('./messagelimit');
  *
  * SAVELIMIT: https://www.rfc-editor.org/rfc/rfc9738
  */
-module.exports = function (server) {
+export default function savelimitPlugin(server) {
     // RFC 9738 section 3: a server that only limits COPY and APPEND (and their UID variants) advertises SAVELIMIT
     const limit = getLimit(server, 'SAVELIMIT');
     server.registerCapability('SAVELIMIT=' + limit);
     addSaveLimit(server, limit);
-};
+}

package/dist/esm/plugins/searchres.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @help Adds SEARCHRES [RFC5182] capability, loads ESEARCH as well
+ * @help SEARCH RETURN (SAVE) stores the result, "$" refers to it in place of a sequence set
+ */
+import type { IMAPServer } from '../types.js';
+export default function searchresPlugin(server: IMAPServer): void;