@remit/data-ports 0.0.83 → 0.0.85

package/dist/interfaces/thread-message.d.ts

@@ -0,0 +1,202 @@
+import type { CreateThreadMessageInput, ResultList, SearchOptions, ThreadMessageFieldTerm, ThreadMessageItem, UpdateThreadMessageInput } from "../types.js";
+export interface IThreadMessageRepository {
+    create(input: CreateThreadMessageInput): Promise<ThreadMessageItem>;
+    get(accountConfigId: string, threadMessageId: string): Promise<ThreadMessageItem>;
+    get(accountConfigId: string, threadMessageIds: string[]): Promise<ThreadMessageItem[]>;
+    update(accountConfigId: string, threadMessageId: string, input: UpdateThreadMessageInput, options?: {
+        composites?: {
+            sentDate?: number;
+            mailboxId?: string;
+            isRead?: boolean;
+            isDeleted?: boolean;
+            hasStars?: boolean;
+            hasAttachment?: boolean;
+        };
+    }): Promise<ThreadMessageItem>;
+    delete(accountConfigId: string, threadMessageId: string): Promise<void>;
+    deleteMany(keys: Array<{
+        accountConfigId: string;
+        threadMessageId: string;
+    }>): Promise<void>;
+    listByAccount(accountConfigId: string, options?: {
+        limit?: number;
+        continuationToken?: string;
+    }): Promise<ResultList<ThreadMessageItem>>;
+    listByDate(accountConfigId: string, options?: {
+        order?: "asc" | "desc";
+        limit?: number;
+        continuationToken?: string;
+        inboxMailboxIds?: Set<string>;
+        excludeDeleted?: boolean;
+        /**
+         * Row criteria applied inside the query, so a page is a page of
+         * matches however rare the criterion is. Filtering the rows a page
+         * returned instead is what makes a listing look empty whenever the
+         * matching mail sits below the newest page (#308).
+         */
+        search?: SearchOptions;
+    }): Promise<ResultList<ThreadMessageItem>>;
+    /**
+     * Search rows for a config across every mailbox in `mailboxIds` — the
+     * cross-account, cross-folder counterpart of `searchByMailbox`. A row whose
+     * From matches any `query` term ranks above one that only mentions the
+     * terms, and each tier runs in date order.
+     *
+     * The caller supplies the mailbox scope, so a search reaching Archive, Sent, Spam and
+     * custom folders is a matter of which set is passed. An empty or absent
+     * `mailboxIds` means no narrowing (every mailbox of the config), which is why
+     * handlers pass an explicitly built set rather than relying on the default.
+     *
+     * Matching follows `searchByMailbox`: `query` splits on whitespace and every
+     * term must match subject OR From, case-insensitively. `limit` is a page size
+     * over MATCHES, clamped server-side, so a short page means the matches ran
+     * out — never that a read window was exhausted.
+     *
+     * Rows are per mailbox, not per conversation: the same mail filed in two
+     * folders is two rows sharing a `threadId`.
+     */
+    searchByDate(accountConfigId: string, search: SearchOptions, options?: {
+        order?: "asc" | "desc";
+        limit?: number;
+        continuationToken?: string;
+        mailboxIds?: Set<string>;
+        excludeDeleted?: boolean;
+    }): Promise<ResultList<ThreadMessageItem>>;
+    /**
+     * Rows of a config whose sender, subject or `List-Id` column matches a set
+     * of substring terms, newest first, across every mailbox — the store-side
+     * narrowing a rule back-apply reads with.
+     *
+     * The terms are evaluated in the query, so `limit` is a page size over
+     * MATCHES and the scan reaches the whole config however old the matching
+     * mail is. Paging a date-ordered listing and filtering the rows it returned
+     * is what makes a rule for a quiet sender report a handful of matches on a
+     * mailbox holding thousands (#459).
+     *
+     * `operator` combines the terms — `"and"` requires every one, `"or"` any.
+     * An empty `terms` narrows nothing under either operator: the whole config,
+     * newest first.
+     *
+     * A term an implementation cannot evaluate faithfully is IGNORED, never
+     * approximated: the result may be wider than the terms asked for and never
+     * narrower, so the caller's own matcher stays the judge.
+     *
+     * Matching follows `searchByMailbox`: accent- and case-insensitive
+     * substring over the same folded columns.
+     *
+     * Rows are per mailbox, not per conversation: the same mail filed in two
+     * folders is two rows sharing a `threadId`. `mailboxIds` narrows the rows
+     * to those folders; omitting it reads every mailbox.
+     */
+    listByFieldTerms(accountConfigId: string, terms: readonly ThreadMessageFieldTerm[], options?: {
+        operator?: "and" | "or";
+        order?: "asc" | "desc";
+        limit?: number;
+        continuationToken?: string;
+        excludeDeleted?: boolean;
+        mailboxIds?: readonly string[];
+    }): Promise<ResultList<ThreadMessageItem>>;
+    /**
+     * List starred rows for a config, newest first, across every mailbox.
+     *
+     * Backed by the `byStarred` index (pk = accountConfigId, sk = hasStars +
+     * sentDate). Starredness is read from `hasStars` — the boolean of record —
+     * never from the presentation-only `star` colour. `mailboxIds` narrows the
+     * result to a caller-supplied set (used to drop muted mailboxes and the
+     * folders a star never surfaces from); omitting it returns every mailbox.
+     *
+     * Rows are per mailbox, not per conversation: the same mail filed in two
+     * folders is two rows sharing a `threadId`. Callers that render one row per
+     * conversation must collapse by `threadId` across the pages they have
+     * accumulated — this cannot be done inside a single page.
+     */
+    listByStarred(accountConfigId: string, options?: {
+        order?: "asc" | "desc";
+        limit?: number;
+        continuationToken?: string;
+        mailboxIds?: Set<string>;
+        excludeDeleted?: boolean;
+        /** Row criteria applied inside the query; see `listByDate`. */
+        search?: SearchOptions;
+    }): Promise<ResultList<ThreadMessageItem>>;
+    /**
+     * COUNT of matching CONVERSATIONS over the same predicate and the same
+     * mailbox scope the three cross-account listing modes read with — the scoped
+     * counterpart of `countByMailbox`.
+     *
+     * A page size bounds the rows a response carries and has no bearing on how
+     * much matches, so a count returns no rows and is answered in full — except
+     * that a count with search text stops at 1000, where walking the matches
+     * further buys a number nobody reads.
+     *
+     * Distinct on `threadId`, unlike `countByMailbox`, because the cross-account
+     * listing is collapsed by thread before it is rendered: a row is per mailbox,
+     * so one message reachable through a real folder and a virtual copy of it is
+     * several rows, and two matching messages of one conversation are two more.
+     */
+    countThreadsInScope(accountConfigId: string, search: SearchOptions, options?: {
+        mailboxIds?: Set<string>;
+        excludeDeleted?: boolean;
+    }): Promise<number>;
+    /**
+     * Every message of a thread, across all mailboxes of the account. A
+     * conversation spans INBOX, Sent and any folder its messages were filed
+     * in, so this listing is deliberately not scoped to a mailbox (#46).
+     *
+     * Ordered by `sentDate` with `threadMessageId` breaking ties, ascending
+     * unless `order` says otherwise — a conversation reads in the order it
+     * happened (#81). Every implementation sorts in the query, so the order
+     * holds across pages and not merely within one page.
+     */
+    listByThread(threadId: string, accountConfigId: string, options?: {
+        order?: "asc" | "desc";
+        limit?: number;
+        continuationToken?: string;
+        excludeDeleted?: boolean;
+    }): Promise<ResultList<ThreadMessageItem>>;
+    findByMessageId(accountConfigId: string, messageId: string): Promise<ThreadMessageItem | null>;
+    findAllByMessageId(accountConfigId: string, messageId: string): Promise<ThreadMessageItem[]>;
+    rekeyThread(accountConfigId: string, fromThreadId: string, toThreadId: string): Promise<{
+        moved: number;
+        dropped: number;
+    }>;
+    getByMessageId(accountConfigId: string, messageId: string): Promise<ThreadMessageItem>;
+    listByMailbox(accountConfigId: string, mailboxId: string, options?: {
+        order?: "asc" | "desc";
+        limit?: number;
+        continuationToken?: string;
+        attributes?: string[];
+        excludeDeleted?: boolean;
+    }): Promise<ResultList<ThreadMessageItem>>;
+    countByThread(accountConfigId: string, threadId: string): Promise<number>;
+    searchByMailbox(accountConfigId: string, mailboxId: string, search: SearchOptions, options?: {
+        order?: "asc" | "desc";
+        count?: number;
+        continuationToken?: string;
+        excludeDeleted?: boolean;
+    }): Promise<ResultList<ThreadMessageItem>>;
+    searchByMailboxWindow(accountConfigId: string, mailboxId: string, search: SearchOptions, options?: {
+        order?: "asc" | "desc";
+        limit?: number;
+        continuationToken?: string;
+        attributes?: string[];
+        excludeDeleted?: boolean;
+    }): Promise<ResultList<ThreadMessageItem>>;
+    /**
+     * COUNT of matching MESSAGES in one mailbox, under the same predicate
+     * `searchByMailboxWindow` reads with — the per-mailbox counterpart of
+     * `countThreadsInScope`, and not distinct on `threadId` because the listing
+     * it answers for renders a row per message.
+     *
+     * The number is over the whole mailbox. No page size bounds it and no cursor
+     * narrows it, so it does not shrink as the caller pages and does not change
+     * when the page size does (#305). A count with search text stops at 1000,
+     * as `countThreadsInScope` does.
+     */
+    countByMailbox(accountConfigId: string, mailboxId: string, search: SearchOptions, options?: {
+        excludeDeleted?: boolean;
+        order?: "asc" | "desc";
+    }): Promise<number>;
+    listAllByAccount(accountConfigId: string): Promise<ThreadMessageItem[]>;
+    deleteAllByAccount(accountConfigId: string): Promise<number>;
+}

package/dist/interfaces/thread-message.js

@@ -0,0 +1 @@
+export {};

package/dist/mailbox-name.d.ts

@@ -0,0 +1,35 @@
+export interface MailboxPath {
+    fullPath: string;
+    hierarchyDelimiter: string;
+}
+export interface MailboxNameCandidate extends MailboxPath {
+    mailboxId: string;
+}
+/**
+ * The folder's own name: the last segment of its path under the delimiter its
+ * own server reports (`INBOX/Spam` → `Spam`, `INBOX.Projects.Q3` → `Q3`).
+ */
+export declare const mailboxLeafName: (mailbox: MailboxPath) => string;
+/**
+ * Where a path under a renamed folder lands, or `undefined` when the rename did
+ * not move it. IMAP RENAME moves the whole subtree in one command, so a path
+ * inside the renamed branch moves exactly as far as its prefix does, and a path
+ * merely starting with the same characters (`Workshop` beside `Work`) does not
+ * move at all.
+ *
+ * Sliced rather than replaced. `String.prototype.replace` with a string pattern
+ * expands `$&`, `` $` ``, `$'` and `$$` in the replacement, so a rename to a
+ * folder whose name contains one of those wrote a different path locally from
+ * the one the RENAME carried to the server — the row and the server diverge and
+ * the next sweep inserts a second row for the real path.
+ */
+export declare const rebaseMailboxPath: (recorded: string, oldPath: string, newPath: string, delimiter: string) => string | undefined;
+/**
+ * A special-use folder by conventional name, for servers that advertise no
+ * special-use flag for it. Matches the folder's own leaf segment against its
+ * mailbox's own hierarchy delimiter, so it resolves at any depth under any
+ * prefix (`INBOX/Spam`, `Mail.Junk E-mail`, `[Gmail]/Spam`) without knowing
+ * which prefixes a server uses. `names` is ordered best-first and must be
+ * lower case.
+ */
+export declare const resolveMailboxByLeafName: <T extends MailboxNameCandidate>(mailboxes: readonly T[], names: readonly string[]) => T | null;

package/dist/mailbox-name.js

@@ -0,0 +1,68 @@
+// A flat mailbox namespace reports no delimiter at all — ImapFlow gives `""`
+// for a NIL LIST delimiter — and splitting on "" returns single characters, so
+// the path is its own leaf.
+const segments = (mailbox) => mailbox.hierarchyDelimiter.length === 0
+    ? [mailbox.fullPath]
+    : mailbox.fullPath.split(mailbox.hierarchyDelimiter);
+/**
+ * The folder's own name: the last segment of its path under the delimiter its
+ * own server reports (`INBOX/Spam` → `Spam`, `INBOX.Projects.Q3` → `Q3`).
+ */
+export const mailboxLeafName = (mailbox) => {
+    const parts = segments(mailbox);
+    return parts[parts.length - 1] || mailbox.fullPath;
+};
+/**
+ * Where a path under a renamed folder lands, or `undefined` when the rename did
+ * not move it. IMAP RENAME moves the whole subtree in one command, so a path
+ * inside the renamed branch moves exactly as far as its prefix does, and a path
+ * merely starting with the same characters (`Workshop` beside `Work`) does not
+ * move at all.
+ *
+ * Sliced rather than replaced. `String.prototype.replace` with a string pattern
+ * expands `$&`, `` $` ``, `$'` and `$$` in the replacement, so a rename to a
+ * folder whose name contains one of those wrote a different path locally from
+ * the one the RENAME carried to the server — the row and the server diverge and
+ * the next sweep inserts a second row for the real path.
+ */
+export const rebaseMailboxPath = (recorded, oldPath, newPath, delimiter) => {
+    if (recorded === oldPath)
+        return newPath;
+    if (delimiter.length === 0)
+        return undefined;
+    if (!recorded.startsWith(`${oldPath}${delimiter}`))
+        return undefined;
+    return `${newPath}${recorded.slice(oldPath.length)}`;
+};
+const rank = (mailbox, names) => {
+    const parts = segments(mailbox);
+    const nameIndex = names.indexOf(mailboxLeafName(mailbox).toLowerCase());
+    if (nameIndex < 0)
+        return null;
+    // Depth outranks the name: a "Spam" buried under Trash or an archive must
+    // never beat the account's real "Junk" one level up.
+    return parts.length * names.length + nameIndex;
+};
+/**
+ * A special-use folder by conventional name, for servers that advertise no
+ * special-use flag for it. Matches the folder's own leaf segment against its
+ * mailbox's own hierarchy delimiter, so it resolves at any depth under any
+ * prefix (`INBOX/Spam`, `Mail.Junk E-mail`, `[Gmail]/Spam`) without knowing
+ * which prefixes a server uses. `names` is ordered best-first and must be
+ * lower case.
+ */
+export const resolveMailboxByLeafName = (mailboxes, names) => {
+    let best = null;
+    for (const mailbox of mailboxes) {
+        const candidate = rank(mailbox, names);
+        if (candidate === null)
+            continue;
+        if (!best ||
+            candidate < best.rank ||
+            (candidate === best.rank &&
+                mailbox.fullPath.localeCompare(best.mailbox.fullPath) < 0)) {
+            best = { mailbox, rank: candidate };
+        }
+    }
+    return best?.mailbox ?? null;
+};

package/dist/message-parts.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Which body parts belong to which message.
+ *
+ * A message/rfc822 (or message/global) part is a forwarded message carried
+ * whole. Its own parts are stored under its path — `<partPath>.0` is its root —
+ * and they belong to the forwarded message: the carrying message neither
+ * renders them as its body nor lists them as its attachments.
+ */
+export interface MessagePart {
+    partPath: string;
+    mediaType: string;
+    mediaSubtype: string;
+}
+export declare const isEncapsulatedMessage: (part: Pick<MessagePart, "mediaType" | "mediaSubtype">) => boolean;
+/** Whether `part` sits inside the forwarded message at `messagePath`. */
+export declare const isWithinMessage: (part: Pick<MessagePart, "partPath">, messagePath: string) => boolean;
+/** The forwarded messages a message carries itself, not those nested in them. */
+export declare const outermostMessages: <T extends MessagePart>(parts: readonly T[]) => T[];
+/** The parts that belong to the message itself, not to a message it carries. */
+export declare const ownParts: <T extends MessagePart>(parts: readonly T[]) => T[];
+/** Every part of the forwarded message at `messagePath`, nested ones included. */
+export declare const encapsulatedParts: <T extends MessagePart>(parts: readonly T[], messagePath: string) => T[];

package/dist/message-parts.js

@@ -0,0 +1,18 @@
+const ENCAPSULATED_MESSAGE_SUBTYPES = new Set([
+    "rfc822",
+    "global",
+]);
+export const isEncapsulatedMessage = (part) => part.mediaType.toUpperCase() === "MESSAGE" &&
+    ENCAPSULATED_MESSAGE_SUBTYPES.has(part.mediaSubtype.toLowerCase());
+/** Whether `part` sits inside the forwarded message at `messagePath`. */
+export const isWithinMessage = (part, messagePath) => part.partPath.startsWith(`${messagePath}.`);
+/** The forwarded messages a message carries itself, not those nested in them. */
+export const outermostMessages = (parts) => parts.filter((part) => isEncapsulatedMessage(part) &&
+    !parts.some((outer) => isEncapsulatedMessage(outer) && isWithinMessage(part, outer.partPath)));
+/** The parts that belong to the message itself, not to a message it carries. */
+export const ownParts = (parts) => {
+    const messages = parts.filter(isEncapsulatedMessage);
+    return parts.filter((part) => !messages.some((message) => isWithinMessage(part, message.partPath)));
+};
+/** Every part of the forwarded message at `messagePath`, nested ones included. */
+export const encapsulatedParts = (parts, messagePath) => parts.filter((part) => isWithinMessage(part, messagePath));

package/dist/message-settlement.d.ts

@@ -0,0 +1,35 @@
+import type { MessageItem } from "./types.js";
+export type MessageSettlementFields = Pick<MessageItem, "status" | "syncStatus" | "abandonedMutation">;
+/**
+ * Which mutation gave up on this row, and `none` where none did.
+ *
+ * `syncStatus: abandoned` is the gate and the only gate: it is the give-up
+ * value of the placement state model (docs/architecture/imap-mutations.md R3),
+ * written only after the row has been put back on a placement the mail server
+ * confirmed. Every settle overwrites it, and the settle in `updateUid` clears
+ * `abandonedMutation` alongside it. A transient attempt writes
+ * `failed` and re-throws for redelivery, so `failed` never reaches here.
+ *
+ * `abandonedMutation` behind that gate says WHICH mutation, which the row
+ * otherwise cannot say: the hand-back sets `status` back to `active`, and
+ * `status` was the field naming the mutation that was outstanding. Reading the
+ * pair without it is how a move that handed back came to be reported to the
+ * user as a failed delete, under a "Delete again" button (issue #1229).
+ *
+ * Outside the gate the field is `none` and says nothing, exactly as
+ * `originalUid` says nothing once a placement has settled. Reading it
+ * unconditionally would resurrect a give-up a later mutation has settled.
+ *
+ * Two give-ups this deliberately does not name. `flag-push` never writes a
+ * placement at all — its give-up lives on its own marker row and in an
+ * operator alert. `placement-move-push` does restore the row when its push is
+ * exhausted, and drops its marker with it, but leaves this field at `none`:
+ * Remit's own classification move is not a mutation the user asked for, so a
+ * per-message treatment for it would report a failure against an intent nobody
+ * formed.
+ */
+export declare const abandonedMutationOf: (message: MessageSettlementFields) => MessageItem["abandonedMutation"];
+/** A delete Remit refused to run or gave up on, having removed it locally first. */
+export declare const hasAbandonedDelete: (message: MessageSettlementFields) => boolean;
+/** A move Remit gave up on, having already pointed the row at the destination. */
+export declare const hasAbandonedMove: (message: MessageSettlementFields) => boolean;

package/{src/message-settlement.ts → dist/message-settlement.js}

@@ -1,11 +1,4 @@
 import { MessageMutation, MessageSyncStatus } from "@remit/domain-enums";
-import type { MessageItem } from "./types.js";
-
-export type MessageSettlementFields = Pick<
-	MessageItem,
-	"status" | "syncStatus" | "abandonedMutation"
->;
-
 /**
  * Which mutation gave up on this row, and `none` where none did.
  *
@@ -34,17 +27,10 @@ export type MessageSettlementFields = Pick<
  * per-message treatment for it would report a failure against an intent nobody
  * formed.
  */
-export const abandonedMutationOf = (
-	message: MessageSettlementFields,
-): MessageItem["abandonedMutation"] =>
-	message.syncStatus === MessageSyncStatus.abandoned
-		? message.abandonedMutation
-		: MessageMutation.none;
-
+export const abandonedMutationOf = (message) => message.syncStatus === MessageSyncStatus.abandoned
+    ? message.abandonedMutation
+    : MessageMutation.none;
 /** A delete Remit refused to run or gave up on, having removed it locally first. */
-export const hasAbandonedDelete = (message: MessageSettlementFields): boolean =>
-	abandonedMutationOf(message) === MessageMutation.delete;
-
+export const hasAbandonedDelete = (message) => abandonedMutationOf(message) === MessageMutation.delete;
 /** A move Remit gave up on, having already pointed the row at the destination. */
-export const hasAbandonedMove = (message: MessageSettlementFields): boolean =>
-	abandonedMutationOf(message) === MessageMutation.move;
+export const hasAbandonedMove = (message) => abandonedMutationOf(message) === MessageMutation.move;

package/dist/mutation-events.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The contract version the mail-destroying queue events are minted under.
+ *
+ * It lives here because the producer (`MessageMoveService`) and the consumer
+ * (the imap-worker's handlers) sit in packages that cannot import each other,
+ * and a version the two sides disagree about is worse than no version at all.
+ * Bump it whenever a handler starts relying on a field an older producer never
+ * set.
+ */
+export declare const MUTATION_EVENT_SCHEMA_VERSION = 2;
+export declare const PATHLESS_MUTATION_EVENT_SCHEMA_VERSION = 3;
+/**
+ * Queue payloads are `JSON.parse`d and cast with no validation, so the declared
+ * type is a promise the queue cannot keep. A handler that cannot vouch for an
+ * event's shape abandons it — treating a missing field as "skip the check"
+ * makes the unverified expunge the default for every event we cannot vouch for,
+ * including any future producer that forgets the field.
+ */
+export declare const isAcceptedSchemaVersion: (value: unknown) => boolean;

package/{src/mutation-events.ts → dist/mutation-events.js}

@@ -8,9 +8,7 @@
  * set.
  */
 export const MUTATION_EVENT_SCHEMA_VERSION = 2;
-
 export const PATHLESS_MUTATION_EVENT_SCHEMA_VERSION = 3;
-
 /**
  * Queue payloads are `JSON.parse`d and cast with no validation, so the declared
  * type is a promise the queue cannot keep. A handler that cannot vouch for an
@@ -18,6 +16,5 @@ export const PATHLESS_MUTATION_EVENT_SCHEMA_VERSION = 3;
  * makes the unverified expunge the default for every event we cannot vouch for,
  * including any future producer that forgets the field.
  */
-export const isAcceptedSchemaVersion = (value: unknown): boolean =>
-	value === MUTATION_EVENT_SCHEMA_VERSION ||
-	value === PATHLESS_MUTATION_EVENT_SCHEMA_VERSION;
+export const isAcceptedSchemaVersion = (value) => value === MUTATION_EVENT_SCHEMA_VERSION ||
+    value === PATHLESS_MUTATION_EVENT_SCHEMA_VERSION;

package/dist/sender-mute.d.ts

@@ -0,0 +1,26 @@
+import type { FilterItem } from "./types.js";
+/**
+ * The `Filter` model's sentinel for "this rule takes no such action" — the
+ * value `actionLabelId` and `actionMailboxId` hold when a filter applies no
+ * label and moves nothing (RFC 034 Decision 3.1).
+ */
+export declare const FILTER_NO_ACTION = "None";
+/**
+ * A standing rule that names senders and does nothing else.
+ *
+ * That combination has exactly one meaning. The index-time filter pipeline
+ * skips a filter with no label and no move, so such a rule changes nothing
+ * about where mail lands or how it is tagged; the only thing it can express is
+ * the user saying "not from this sender". `dismiss{muteSender:true}` writes
+ * one, and the calendar-suggestion producer reads it.
+ *
+ * Structural, never name-matching: the rule is recognised by its shape, so a
+ * rename in the settings UI cannot quietly un-mute a sender.
+ */
+export declare const isSenderMuteFilter: (filter: Pick<FilterItem, "scope" | "literalClauses" | "actionLabelId" | "actionMailboxId">) => boolean;
+/**
+ * Whether one of these rules mutes an address. Compared case-insensitively and
+ * whole: a mail address is one value, and a substring match would let a rule
+ * about `ada@example.com` silence `not-ada@example.com.evil.test`.
+ */
+export declare const isSenderMuted: (filters: readonly Pick<FilterItem, "scope" | "literalClauses" | "actionLabelId" | "actionMailboxId">[], sender: string) => boolean;

package/{src/sender-mute.ts → dist/sender-mute.js}

@@ -1,13 +1,10 @@
 import { FilterClauseField, FilterScope } from "@remit/domain-enums";
-import type { FilterItem } from "./types.js";
-
 /**
  * The `Filter` model's sentinel for "this rule takes no such action" — the
  * value `actionLabelId` and `actionMailboxId` hold when a filter applies no
  * label and moves nothing (RFC 034 Decision 3.1).
  */
 export const FILTER_NO_ACTION = "None";
-
 /**
  * A standing rule that names senders and does nothing else.
  *
@@ -20,40 +17,21 @@ export const FILTER_NO_ACTION = "None";
  * Structural, never name-matching: the rule is recognised by its shape, so a
  * rename in the settings UI cannot quietly un-mute a sender.
  */
-export const isSenderMuteFilter = (
-	filter: Pick<
-		FilterItem,
-		"scope" | "literalClauses" | "actionLabelId" | "actionMailboxId"
-	>,
-): boolean =>
-	filter.scope === FilterScope.Standing &&
-	filter.actionLabelId === FILTER_NO_ACTION &&
-	filter.actionMailboxId === FILTER_NO_ACTION &&
-	filter.literalClauses.length > 0 &&
-	filter.literalClauses.every(
-		(clause) =>
-			clause.field === FilterClauseField.From && clause.value.trim() !== "",
-	);
-
-const fold = (value: string): string => value.trim().toLowerCase();
-
+export const isSenderMuteFilter = (filter) => filter.scope === FilterScope.Standing &&
+    filter.actionLabelId === FILTER_NO_ACTION &&
+    filter.actionMailboxId === FILTER_NO_ACTION &&
+    filter.literalClauses.length > 0 &&
+    filter.literalClauses.every((clause) => clause.field === FilterClauseField.From && clause.value.trim() !== "");
+const fold = (value) => value.trim().toLowerCase();
 /**
  * Whether one of these rules mutes an address. Compared case-insensitively and
  * whole: a mail address is one value, and a substring match would let a rule
  * about `ada@example.com` silence `not-ada@example.com.evil.test`.
  */
-export const isSenderMuted = (
-	filters: readonly Pick<
-		FilterItem,
-		"scope" | "literalClauses" | "actionLabelId" | "actionMailboxId"
-	>[],
-	sender: string,
-): boolean => {
-	const wanted = fold(sender);
-	if (wanted === "") return false;
-	return filters.some(
-		(filter) =>
-			isSenderMuteFilter(filter) &&
-			filter.literalClauses.some((clause) => fold(clause.value) === wanted),
-	);
+export const isSenderMuted = (filters, sender) => {
+    const wanted = fold(sender);
+    if (wanted === "")
+        return false;
+    return filters.some((filter) => isSenderMuteFilter(filter) &&
+        filter.literalClauses.some((clause) => fold(clause.value) === wanted));
 };

package/dist/sync-warning-state.d.ts

@@ -0,0 +1,3 @@
+import { SyncWarningStage, SyncWarningState } from "@remit/domain-enums";
+export declare const SYNC_WARNING_SURFACE_ATTEMPTS = 3;
+export declare const syncWarningState: (stage: (typeof SyncWarningStage)[keyof typeof SyncWarningStage], attempts: number) => (typeof SyncWarningState)[keyof typeof SyncWarningState];

package/dist/sync-warning-state.js

@@ -0,0 +1,5 @@
+import { SyncWarningStage, SyncWarningState } from "@remit/domain-enums";
+export const SYNC_WARNING_SURFACE_ATTEMPTS = 3;
+export const syncWarningState = (stage, attempts) => stage === SyncWarningStage.Body && attempts >= SYNC_WARNING_SURFACE_ATTEMPTS
+    ? SyncWarningState.GaveUp
+    : SyncWarningState.Retrying;