imapkit 4.0.3 → 4.1.1

package/dist/cjs/threading.js

@@ -0,0 +1,318 @@
+"use strict";
+// THREAD and UID THREAD (RFC 5256 section 3) and the ORDEREDSUBJECT and REFERENCES algorithms
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addThreadAlgorithm = addThreadAlgorithm;
+const command_states_js_1 = require("./command-states.js");
+const mimeparser_js_1 = require("./mimeparser.js");
+const sorting_js_1 = require("./sorting.js");
+/**
+ * Creates a thread tree node. A node without a message is a dummy
+ */
+function createNode(entry) {
+    return { entry: entry || null, parent: null, children: [] };
+}
+// Sent date order with the sequence number as tie-breaker (RFC 5256 section 2.2). A dummy is
+// ordered by its first child
+function compareNodes(a, b) {
+    while (!a.entry && a.children.length) {
+        a = a.children[0];
+    }
+    while (!b.entry && b.children.length) {
+        b = b.children[0];
+    }
+    // pruning leaves no dummy without children, so both have an entry here
+    return a.entry.date - b.entry.date || a.entry.seq - b.entry.seq;
+}
+/**
+ * Lists the nodes of trees in pre-order (parents before their children). Iterative, as message
+ * references can make a thread as deep as the mailbox is large.
+ *
+ * @param {Array} nodes Top level nodes
+ * @return {Array} All nodes
+ */
+function preOrder(nodes) {
+    const list = [];
+    const stack = nodes.slice().reverse();
+    while (stack.length) {
+        const node = stack.pop();
+        list.push(node);
+        for (let i = node.children.length - 1; i >= 0; i--) {
+            stack.push(node.children[i]);
+        }
+    }
+    return list;
+}
+/**
+ * Serializes thread nodes (RFC 5256 section 5): every thread is a thread-list, a node is followed by its
+ * only child, or by one thread-list per child when it has more. A dummy has no number of its own.
+ *
+ * @param {Array} roots Top level nodes
+ * @param {Boolean} isUid If true, list UIDs instead of sequence numbers
+ * @return {String} thread-data without the "THREAD" keyword
+ */
+function formatThreads(roots, isUid) {
+    const output = [];
+    // strings to write and nodes to expand, the next one is at the end
+    const stack = [];
+    const pushLists = (nodes) => {
+        for (let i = nodes.length - 1; i >= 0; i--) {
+            stack.push(')', nodes[i], '(');
+        }
+    };
+    pushLists(roots);
+    while (stack.length) {
+        const item = stack.pop();
+        if (typeof item === 'string') {
+            output.push(item);
+            continue;
+        }
+        const children = item.children;
+        if (children.length === 1) {
+            stack.push(children[0]);
+        }
+        else {
+            pushLists(children);
+        }
+        if (item.entry) {
+            if (children.length) {
+                stack.push(' ');
+            }
+            output.push(isUid ? item.entry.message.uid : item.entry.seq);
+        }
+    }
+    return output.join('');
+}
+/**
+ * ORDEREDSUBJECT (RFC 5256 section 3): messages grouped by base subject, every thread is its first
+ * message with the others as children, threads ordered by the sent date of their first message
+ *
+ * @param {Array} entries Searched messages as `{ message, seq, date, subject }`
+ * @return {Array} Top level nodes
+ */
+function orderedSubject(entries) {
+    const compareSubjects = (a, b) => (a.subject.id < b.subject.id ? -1 : a.subject.id > b.subject.id ? 1 : 0);
+    const sorted = entries.slice().sort((a, b) => compareSubjects(a, b) || a.date - b.date || a.seq - b.seq);
+    const threads = [];
+    let current = null;
+    for (const entry of sorted) {
+        if (current && current.entry.subject.id === entry.subject.id) {
+            current.children.push(createNode(entry));
+        }
+        else {
+            current = createNode(entry);
+            threads.push(current);
+        }
+    }
+    return threads.sort(compareNodes);
+}
+/**
+ * REFERENCES (RFC 5256 section 3), steps 1 to 6
+ *
+ * @param {Array} entries Searched messages in mailbox order as `{ message, seq, date, subject }`
+ * @return {Array} Top level nodes
+ */
+function references(entries) {
+    const byId = new Map();
+    const all = [];
+    const getNode = (id) => {
+        if (!byId.has(id)) {
+            const node = createNode();
+            byId.set(id, node);
+            all.push(node);
+        }
+        return byId.get(id);
+    };
+    const isDescendant = (node, ancestor) => {
+        for (let current = node; current; current = current.parent) {
+            if (current === ancestor) {
+                return true;
+            }
+        }
+        return false;
+    };
+    const unlink = (node) => {
+        if (node.parent) {
+            node.parent.children.splice(node.parent.children.indexOf(node), 1);
+            node.parent = null;
+        }
+    };
+    // links a parent and a child, unless that would introduce a loop. Only a node with children can have
+    // the parent as a descendant, so the walk up from the parent is skipped for the others
+    const link = (parent, child) => {
+        if (parent !== child && (!child.children.length || !isDescendant(parent, child))) {
+            parent.children.push(child);
+            child.parent = parent;
+        }
+    };
+    // (1) link the messages by their references
+    for (const entry of entries) {
+        const header = (0, mimeparser_js_1.getMessageData)(entry.message).tree.parsedHeader;
+        // (1.A) a message without a valid Message-ID, or with one that an earlier message already has, gets a unique one
+        const messageId = (0, sorting_js_1.parseMessageIds)(header['message-id'])[0];
+        let node = messageId !== undefined && getNode(messageId);
+        if (!node || node.entry) {
+            node = createNode();
+            all.push(node);
+        }
+        node.entry = entry;
+        // the References header, or else the first Message ID of In-Reply-To
+        let refs = (0, sorting_js_1.parseMessageIds)(header.references);
+        if (!refs.length) {
+            refs = (0, sorting_js_1.parseMessageIds)(header['in-reply-to']).slice(0, 1);
+        }
+        // (1.A) each reference is the parent of the next one, existing links are kept
+        const refNodes = refs.map(getNode);
+        for (let i = 1; i < refNodes.length; i++) {
+            if (!refNodes[i].parent) {
+                link(refNodes[i - 1], refNodes[i]);
+            }
+        }
+        // (1.B) the last reference is the parent of the message, replacing an existing link
+        const parent = refNodes[refNodes.length - 1] || null;
+        if (node.parent !== parent) {
+            unlink(node);
+            if (parent) {
+                link(parent, node);
+            }
+        }
+    }
+    // (2) messages without a parent are the top level
+    const roots = all.filter(node => !node.parent);
+    // (3) prune dummies: drop the ones without children, put the children of the others in their place,
+    // but not at the top level if there is more than one child
+    const replacement = (node, topLevel) => {
+        if (node.entry) {
+            return [node];
+        }
+        if (!node.children.length) {
+            return [];
+        }
+        return topLevel && node.children.length > 1 ? [node] : node.children;
+    };
+    // children before their parents, so a dummy is replaced by children that are already pruned
+    for (const node of preOrder(roots).reverse()) {
+        node.children = node.children.flatMap(child => replacement(child, false));
+        node.children.forEach(child => {
+            child.parent = node;
+        });
+    }
+    let top = roots.flatMap(node => replacement(node, true));
+    top.forEach(node => {
+        node.parent = null;
+    });
+    // (4) sort the top level by sent date, a dummy by its first child
+    top.forEach(node => {
+        if (!node.entry) {
+            node.children.sort(compareNodes);
+        }
+    });
+    top.sort(compareNodes);
+    // (5) gather threads with the same base subject, the subject of a dummy is the one of its first child
+    const threadSubject = (node) => (node.entry ? node.entry.subject : node.children[0].entry.subject);
+    const isReply = (node) => !!node.entry && node.entry.subject.isReply;
+    const table = new Map();
+    // (5.B) one message per base subject, a dummy or a message that is not a reply or forward is preferred
+    for (const node of top) {
+        const subject = threadSubject(node);
+        if (!subject.id) {
+            continue;
+        }
+        const old = table.get(subject.id);
+        if (!old || (old.entry && (!node.entry || (isReply(old) && !isReply(node))))) {
+            table.set(subject.id, node);
+        }
+    }
+    // (5.C) merge the other threads with the same subject into the one in the table
+    const removed = new Set();
+    for (const node of top) {
+        const subject = threadSubject(node);
+        if (!subject.id) {
+            continue;
+        }
+        // (5.B) put a node for every subject in the table
+        const other = table.get(subject.id);
+        if (other === node) {
+            continue;
+        }
+        removed.add(node);
+        if (!other.entry && !node.entry) {
+            node.children.forEach(child => link(other, child));
+        }
+        else if (!other.entry || (isReply(node) && !isReply(other))) {
+            link(other, node);
+        }
+        else {
+            // both become children of a new dummy that takes the place of the message in the table
+            const dummy = createNode();
+            top[top.indexOf(other)] = dummy;
+            link(dummy, other);
+            link(dummy, node);
+            table.set(subject.id, dummy);
+        }
+    }
+    top = top.filter(node => !removed.has(node));
+    // (6) sort all sets of siblings by sent date, the deepest ones first
+    for (const node of preOrder(top).reverse()) {
+        node.children.sort(compareNodes);
+    }
+    top.sort(compareNodes);
+    return top;
+}
+const ALGORITHMS = {
+    ORDEREDSUBJECT: orderedSubject,
+    REFERENCES: references
+};
+/**
+ * Adds the THREAD and UID THREAD commands, unless another algorithm plugin did already, and the
+ * THREAD=<algorithm> capability
+ *
+ * @param {Object} server IMAP server
+ * @param {String} algorithm "ORDEREDSUBJECT" or "REFERENCES"
+ */
+function addThreadAlgorithm(server, algorithm) {
+    server.registerCapability('THREAD=' + algorithm);
+    if (server.threadAlgorithms) {
+        server.threadAlgorithms[algorithm] = ALGORITHMS[algorithm];
+        return;
+    }
+    server.threadAlgorithms = { [algorithm]: ALGORITHMS[algorithm] };
+    const threadHandler = (isUid, connection, parsed, data, callback) => {
+        const command = isUid ? 'UID THREAD' : 'THREAD';
+        const attributes = parsed.attributes || [];
+        // RFC 5256 section 5: thread-alg = "ORDEREDSUBJECT" / "REFERENCES" / thread-alg-ext, an atom
+        const name = attributes[0] && attributes[0].type === 'ATOM' ? attributes[0].value.toUpperCase() : '';
+        if (!Object.hasOwn(server.threadAlgorithms, name)) {
+            connection.sendStatus(parsed, data, 'BAD', name ? 'Unsupported threading algorithm ' + name : command + ' expects a threading algorithm atom', false, command + ' FAILED');
+            return callback();
+        }
+        const result = (0, sorting_js_1.searchMessages)(connection, parsed, data, attributes.slice(1));
+        if (!result) {
+            return callback();
+        }
+        // base subjects are compared with the collation (RFC 5256 sections 3 and 7)
+        const entries = result.list.map((message) => {
+            const base = (0, sorting_js_1.baseSubject)((0, mimeparser_js_1.getMessageData)(message).tree.parsedHeader.subject);
+            return {
+                message,
+                seq: result.numbers[message.uid],
+                date: (0, sorting_js_1.sentTime)(message),
+                // a binary string of the collation key, these compare like the octets of the key
+                subject: { id: (0, sorting_js_1.collationKey)(base.subject).toString('binary'), isReply: base.isReply }
+            };
+        });
+        connection.send({
+            tag: '*',
+            command: 'THREAD',
+            // thread-data has no SP between thread-lists, so it can not be built from nested arrays
+            attributes: entries.length ? [{ type: 'TEXT', value: formatThreads(server.threadAlgorithms[name](entries), isUid) }] : []
+        }, command, parsed, data, 
+        // the search result, so CONDSTORE knows about a MODSEQ search key (RFC 7162 section 3.1.9)
+        result);
+        connection.sendStatus(parsed, data, 'OK', command + ' completed', false, command);
+        return callback();
+    };
+    // RFC 5256 section 3: EXPUNGE responses are not permitted while responding to THREAD, but are during UID THREAD.
+    // The search criteria start after the algorithm and the charset
+    server.setCommandHandler('THREAD', threadHandler.bind(null, false), { states: command_states_js_1.states.SELECTED, searchCriteria: 2, noExpunge: true });
+    server.setCommandHandler('UID THREAD', threadHandler.bind(null, true), { states: command_states_js_1.states.SELECTED, searchCriteria: 2 });
+}

package/dist/cjs/types.d.ts

@@ -0,0 +1,327 @@
+import type { IMAPServer, IMAPConnection } from './server.js';
+export type { IMAPServer, IMAPConnection };
+/**
+ * A value of the parsed command or of a response, as imap-handler parses and compiles it: an
+ * `{ type, value, section?, partial? }` node, a list (array), a string, a number or null (NIL).
+ * Commands and plugins walk these trees freely, so the type is left open.
+ */
+export type Attribute = any;
+/** A parsed client command, see imap-handler. Plugins add their own properties (e.g. `searchReturn`) */
+export interface ParsedCommand {
+    tag: string;
+    command: string;
+    attributes?: Attribute[] | undefined;
+    [key: string]: any;
+}
+/**
+ * The command a response answers, as `connection.send()` and `connection.sendStatus()` take it: a parsed
+ * command, or only the tag for input that could not be parsed (or `{ tag: '*' }` for an untagged response)
+ */
+export type CommandContext = ParsedCommand | {
+    tag: string;
+    command?: undefined;
+    attributes?: undefined;
+    [key: string]: any;
+};
+/** A response written to the client through `connection.send()` */
+export interface IMAPResponse {
+    tag: string;
+    command?: string | undefined;
+    attributes?: Attribute | Attribute[] | undefined;
+    /** set by an output handler to drop the response */
+    skipResponse?: boolean | undefined;
+    /** an unsolicited response from the notification queue, it does not flush the queue */
+    notification?: boolean | undefined;
+    [key: string]: any;
+}
+/**
+ * An untagged response distributed with `server.notify()`, queued per session in
+ * `connection.notificationQueue` until it can be sent
+ */
+export interface Notification extends IMAPResponse {
+    /** the session whose command caused the change, null for changes from SMTP */
+    origin?: IMAPConnection | null | undefined;
+    /** the new message of an EXISTS, or the removed message of an EXPUNGE */
+    message?: Message | undefined;
+    /** the removed messages of a VANISHED response (QRESYNC) */
+    messages?: Message[] | undefined;
+    /** the message list as it was before an expunge, for sessions that were not told about it yet */
+    mailboxCopy?: Message[] | undefined;
+    /** messages whose flags changed, sent as unsolicited FETCH responses */
+    flagUpdate?: Message[] | undefined;
+}
+/** The `notify` event of the server, see `server.notify()` */
+export interface NotifyEvent {
+    command: Notification;
+    /** the mailbox the change is about, false or null for changes that are not about the selected mailbox */
+    mailbox: Mailbox | string | false | null | undefined;
+    /** the session that does not get the notification */
+    ignoreConnection: IMAPConnection | false | null | undefined;
+    /** only connections for which it returns true get the notification */
+    filter: ((connection: IMAPConnection) => boolean) | false | null | undefined;
+    /** the session whose command caused the change, null for changes from outside (e.g. SMTP) */
+    origin: IMAPConnection | null;
+    [key: string]: any;
+}
+/** The `mailbox` event of the server, see `server.mailboxChanged()` */
+export interface MailboxChangeEvent {
+    /** "create", "delete", "rename", "subscribe" or "unsubscribe" */
+    type: string;
+    path: string;
+    oldPath: string | null;
+    mailbox: Mailbox | null;
+    origin: IMAPConnection | null;
+}
+export type Callback = (err?: any, ...args: any[]) => void;
+/** Handler of an IMAP command, it must send a tagged response and then call the callback */
+export type CommandHandler = (connection: IMAPConnection, parsed: ParsedCommand, data: string, callback: Callback) => void;
+/** Options of a command, see `server.setCommandHandler()` and command-states.ts */
+export interface CommandOptions {
+    states?: string[] | string | false | undefined;
+    noArguments?: boolean | undefined;
+    mailboxArguments?: number[] | number | undefined;
+    astringArguments?: number[] | number | undefined;
+    searchCriteria?: number | false | undefined;
+    sequenceSet?: number | false | undefined;
+    noExpunge?: boolean | undefined;
+    /** also the name of the capability that allows literal8 (`'BINARY'`) */
+    literal8?: boolean | string | undefined;
+    noPipelining?: boolean | undefined;
+    appendMessage?: boolean | undefined;
+}
+/** A plugin, given as a function in `options.plugins` or built in */
+export interface Plugin {
+    (server: IMAPServer): void;
+    /** plugins that are loaded before this one, by name */
+    requires?: string[] | undefined;
+}
+/** An error that carries the response a command fails with */
+export interface IMAPError extends Error {
+    code?: string | undefined;
+    imapResponse?: string | undefined;
+    responseCode?: Attribute;
+    responseCodeArgs?: Attribute;
+    [key: string]: any;
+}
+/** Connection states of RFC 3501 section 3, "Logout" after LOGOUT or BYE */
+export type ConnectionState = 'Not Authenticated' | 'Authenticated' | 'Selected' | 'Logout';
+/** A message in a mailbox, plugins keep their own properties on it (MODSEQ, X-GM-LABELS ...) */
+export interface Message {
+    uid: number;
+    flags: string[];
+    internaldate: string;
+    /** the message source as a binary string (one char per octet) */
+    raw: string;
+    recent?: boolean | undefined;
+    /** expunged by another session but not yet reported to this one */
+    ghost?: boolean | undefined;
+    [key: string]: any;
+}
+/** Resolved messages of a sequence set, `[sequence number, message]` pairs */
+export type MessageRange = [number, Message][];
+/** A mailbox, plugins keep their own properties on it (acl, metadata, HIGHESTMODSEQ ...) */
+export interface Mailbox {
+    path: string;
+    namespace: string;
+    uid: number;
+    uidvalidity: number;
+    uidnext: number;
+    flags: string[];
+    permanentFlags: string[];
+    allowPermanentFlags: boolean;
+    messages: Message[];
+    /** flags that messages of the mailbox had, they stay in FLAGS and PERMANENTFLAGS, see server.rememberFlags() */
+    knownFlags?: string[] | undefined;
+    folders?: Record<string, Mailbox> | undefined;
+    separator?: string | undefined;
+    /** an accessor of `server.subscriptions`, see server.trackSubscription() */
+    subscribed?: boolean | undefined;
+    [key: string]: any;
+}
+/**
+ * A name that getSubscriptionTree() lists without a mailbox: a subscribed name that is not a mailbox, or a
+ * superior hierarchy level of a subscribed name
+ */
+export interface SubscriptionStandIn {
+    path: string;
+    namespace: string | false;
+    flags: string[];
+    subscribed: boolean;
+}
+/** The fields of a mailbox (or a stand-in) that LIST pattern matching needs, see server.matchFolders() */
+export interface ListedMailbox {
+    path: string;
+    namespace: string | false;
+    flags: string[];
+}
+/** A message as the storage option gives it, the server fills in the rest. A string is the message source */
+export interface StorageMessage {
+    uid?: number | undefined;
+    /** a single flag can be given as a string */
+    flags?: string | string[] | undefined;
+    /** a Date or a date-time string, the current time if not set */
+    internaldate?: string | Date | false | undefined;
+    raw?: string | Uint8Array | undefined;
+    recent?: boolean | undefined;
+    [key: string]: any;
+}
+/** A mailbox as the storage option gives it, the server fills in the rest */
+export interface StorageMailbox {
+    uid?: number | undefined;
+    uidvalidity?: number | undefined;
+    uidnext?: number | undefined;
+    flags?: string[] | undefined;
+    permanentFlags?: string[] | undefined;
+    allowPermanentFlags?: boolean | undefined;
+    subscribed?: boolean | undefined;
+    messages?: (StorageMessage | string)[] | undefined;
+    folders?: Record<string, StorageMailbox> | undefined;
+    separator?: string | undefined;
+    [key: string]: any;
+}
+export type NamespaceType = 'personal' | 'user' | 'shared';
+/** A namespace of the storage option, keyed by its prefix (`"INBOX"`, `""`, `"INBOX."`, ...) */
+export interface StorageNamespace extends StorageMailbox {
+    separator?: string | undefined;
+    type?: NamespaceType | undefined;
+}
+/** A namespace in `server.storage`, with every key set by the server */
+export interface Namespace {
+    separator: string;
+    type: NamespaceType;
+    folders: Record<string, Mailbox>;
+    [key: string]: any;
+}
+/** `server.storage`: the namespaces by prefix, and INBOX, which is a mailbox of its own */
+export type ServerStorage = {
+    INBOX: Mailbox;
+} & Record<string, Namespace>;
+/** Mailbox counters of `server.getStatus()` */
+export interface MailboxStatus {
+    /** number of messages by flag */
+    flags: Record<string, number>;
+    seen: number;
+    unseen: number;
+    recent: number;
+    permanentFlags: string[];
+}
+export interface UserData {
+    password?: string | undefined;
+    xoauth2?: {
+        accessToken?: string | undefined;
+        sessionTimeout?: number | undefined;
+    } | undefined;
+    [key: string]: any;
+}
+/** Options of `imapkit(options)` */
+export interface IMAPServerOptions {
+    /** the mailbox tree, keyed by namespace */
+    storage?: Record<string, StorageNamespace> | undefined;
+    /** plugin names (`"IDLE"`, `"LITERAL+"`, ...) or plugin functions */
+    plugins?: (string | Plugin)[] | string | Plugin | undefined;
+    users?: Record<string, UserData> | undefined;
+    secureConnection?: boolean | undefined;
+    credentials?: {
+        key: string | Buffer;
+        cert: string | Buffer;
+    } | undefined;
+    debug?: boolean | undefined;
+    systemFlags?: string[] | undefined;
+    /** largest literal accepted after login, in octets */
+    maxLiteralSize?: number | undefined;
+    [key: string]: any;
+}
+/**
+ * A layer between the socket and the IMAP protocol, such as COMPRESS=DEFLATE. It passes data on with
+ * `connection.writeRaw()` and `connection.onData()`
+ */
+export interface Transport {
+    write(data: Buffer): void;
+    receive(chunk: Buffer): void;
+    end(callback: () => void): void;
+    destroy(): void;
+}
+/** A response code, or a list for a code with arguments (`['MESSAGELIMIT', 1000]`) */
+export type ResponseCode = string | (string | number)[];
+/** The refusal of a command or a literal, sent as a tagged `command [code] text` */
+export interface Refusal {
+    command: string;
+    code?: string | undefined;
+    text: string;
+}
+/** A refusal of `server.commandChecks`, `command` defaults to BAD */
+export interface CommandRefusal {
+    command?: string | undefined;
+    code?: ResponseCode | undefined;
+    text: string;
+}
+/** A result of `server.appendChecks` (or other checks reported with `connection.applyChecks()`) */
+export interface CheckResult {
+    code?: ResponseCode | undefined;
+    text: string;
+    /** only a warning, sent as an untagged NO */
+    soft?: boolean | undefined;
+}
+/** A message that APPEND, REPLACE, COPY or MOVE is about to add to a mailbox */
+export interface AppendMessage {
+    raw: string;
+    flags?: string[] | undefined;
+    internaldate?: string | Date | false | undefined;
+    [key: string]: any;
+}
+/** Options of `server.appendChecks`: `{ move, source }` for COPY and MOVE, `{ command, replaced }` for APPEND and REPLACE */
+export interface AppendCheckOptions {
+    move?: boolean | undefined;
+    source?: Mailbox | false | undefined;
+    command?: string | undefined;
+    replaced?: Message | null | undefined;
+    [key: string]: any;
+}
+type BivariantCallback<T extends (...args: any[]) => any> = {
+    bivarianceHack(...args: Parameters<T>): ReturnType<T>;
+}['bivarianceHack'];
+/**
+ * `server.outputHandlers`: called with the arguments of every `connection.send()`, can change the response or set
+ * `skipResponse`. Handlers may declare narrower parameter types for the responses they act on
+ */
+export type OutputHandler = BivariantCallback<(connection: IMAPConnection, response: IMAPResponse, description: string | undefined, parsed: CommandContext | null | undefined, data: string | null | undefined, ...extra: any[]) => void>;
+/** `server.fetchHandlers`: the value of a FETCH item */
+export interface FetchHandler {
+    (connection: IMAPConnection, message: Message, query?: Attribute, ...args: any[]): any;
+    /** fetching the item sets \Seen like BODY[] */
+    setsSeen?: boolean | undefined;
+}
+/** `server.searchHandlers`: checks a message against a search key, the arguments follow the index */
+export interface SearchHandler {
+    (connection: IMAPConnection, message: Message, index: number, ...args: any[]): any;
+    /** decides the argument types of the key instead of one string per handler parameter */
+    argumentTypes?: ((list: Attribute[]) => any[]) | undefined;
+}
+/** `server.storeHandlers`: applies a STORE item to a message */
+export interface StoreHandler {
+    (connection: IMAPConnection, message: Message, values: any, index: number, parsed: ParsedCommand, data: string): any;
+    /** the values are astrings (X-GM-LABELS), NIL atoms are kept and literals accepted */
+    astringValues?: boolean | undefined;
+}
+/** `server.statusHandlers`: the value of a STATUS item */
+export type StatusHandler = (connection: IMAPConnection, mailbox: Mailbox, status: MailboxStatus) => any;
+/** `server.fetchFilters` and `server.storeFilters`: false leaves a message out */
+export type MessageFilter = (connection: IMAPConnection, message: Message, parsed: ParsedCommand, index: number) => unknown;
+/** `server.appendDataHandlers`: parses an append-data extension and returns the function that builds the message source */
+export type AppendDataHandler = (connection: IMAPConnection, value: Attribute) => () => string;
+export type CapabilityCheck = (connection: IMAPConnection) => boolean;
+export type ConnectionHandler = (connection: IMAPConnection) => void;
+export type MessageHandler = (server: IMAPServer, message: Message, mailbox: Mailbox) => void;
+export type MailboxHandler = (server: IMAPServer, mailbox: Mailbox) => void;
+export type CopyHandler = (server: IMAPServer, source: Message, properties: Record<string, any>, mailbox: Mailbox) => void;
+export type NotifyFilter = (connection: IMAPConnection, event: NotifyEvent) => boolean;
+export type AppendCheck = (connection: IMAPConnection, mailbox: Mailbox, messages: AppendMessage[], options: AppendCheckOptions) => CheckResult | false | null | undefined | void;
+export type LiteralFilter = (connection: IMAPConnection, command: string, line: string, size: number) => Refusal | false | null | undefined;
+export type UrlAccessCheck = (connection: IMAPConnection, mailbox: Mailbox, url: any) => {
+    text: string;
+} | false | null | undefined;
+export type SearchAccessCheck = (connection: IMAPConnection, mailbox: Mailbox, named: boolean) => boolean;
+export type CommandCheck = (connection: IMAPConnection, parsed: ParsedCommand) => CommandRefusal | false | null | undefined;
+export type RangeLimit = (connection: IMAPConnection, parsed: ParsedCommand, range: MessageRange) => MessageRange | false | null | undefined;
+export type SearchLimit = (connection: IMAPConnection, messages: Message[], query: any) => Message[] | false | null | undefined;
+export type ClosedCheck = (connection: IMAPConnection) => boolean;

package/dist/cjs/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// Shared types of the server, the commands and the plugins
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utf8-session.d.ts

@@ -0,0 +1,17 @@
+import type { IMAPConnection } from './types.js';
+/**
+ * Sets the UTF-8 options of a session from the extensions it has enabled. Run it when the session starts,
+ * after ENABLE and after UNAUTHENTICATE (once the ENABLE plugin has cleared `connection.enabled`).
+ *
+ * - With the UTF8=ACCEPT plugin, quoted strings may hold UTF-8 even before ENABLE (RFC 9755 section 3) and
+ *   modified UTF-7 names must decode to Net-Unicode. Without it, 8-bit quoted strings are a syntax error until
+ *   ENABLE IMAP4rev2, like RFC 3501 says
+ * - ENABLE UTF8=ACCEPT or IMAP4rev2: mailbox names are UTF-8 in both directions and strings that are valid
+ *   UTF-8 are sent quoted (RFC 9755 section 3, RFC 9051 sections 4.3 and 5.1)
+ * - ENABLE UTF8=ACCEPT: SEARCH strings are UTF-8 and CHARSET is refused (RFC 9755 section 3)
+ * - ENABLE IMAP4rev2: SEARCH strings are UTF-8 unless a CHARSET says otherwise (RFC 9051 section 6.4.4)
+ *
+ * @param {Object} connection IMAP connection
+ */
+declare function updateSession(connection: IMAPConnection): void;
+export { updateSession };