1237 lines
47 KiB
TypeScript
1237 lines
47 KiB
TypeScript
import { create } from "zustand";
|
|
import type { FolderRef } from "@/lib/sieveFolders";
|
|
import { SPAM_HEADER_PROPS } from "@/lib/spamScore";
|
|
import { groupByArchivePath, archivePath, type ArchiveGranularity } from "@/lib/archiveDate";
|
|
import { JmapMethodError, chunk, client, setErrorMessage } from "@/jmap/client";
|
|
import type {
|
|
Comparator,
|
|
Email,
|
|
EmailFilter,
|
|
GetResponse,
|
|
Id,
|
|
Identity,
|
|
Mailbox,
|
|
MailboxRole,
|
|
QueryResponse,
|
|
Quota,
|
|
SetError,
|
|
SetResponse,
|
|
Thread,
|
|
VacationResponse,
|
|
ChangesResponse,
|
|
} from "@/jmap/types";
|
|
import { toast } from "@/ui/toast";
|
|
import { settings, useSettings } from "./settings";
|
|
import { useSession } from "./session";
|
|
import { mailboxDisplayName } from "@/lib/mailboxName";
|
|
import { plural, t } from "@/lib/i18n";
|
|
|
|
/*
|
|
* Named explicitly so `shareWith` comes back, which it does not otherwise --
|
|
* see the note on CALENDAR_PROPS and the KNOWN-ISSUES entry. Mailboxes were the
|
|
* third and last store fetching everything by asking for nothing.
|
|
*
|
|
* It matters here for one narrow but real case. Sharing a mail folder is
|
|
* withdrawn because Stalwart stores the share and never delivers it, and the
|
|
* only way left to clear one already made is the "Stop sharing" entry, which
|
|
* appears only when a folder looks shared. Without this it never looked shared,
|
|
* so the escape hatch for the exact situation it was built for was invisible.
|
|
*/
|
|
export const MAILBOX_PROPS = [
|
|
"id",
|
|
"name",
|
|
"parentId",
|
|
"role",
|
|
"sortOrder",
|
|
"totalEmails",
|
|
"unreadEmails",
|
|
"totalThreads",
|
|
"unreadThreads",
|
|
"myRights",
|
|
"isSubscribed",
|
|
"shareWith",
|
|
];
|
|
|
|
export const LIST_PROPS = [
|
|
"id",
|
|
"blobId",
|
|
"threadId",
|
|
"mailboxIds",
|
|
"keywords",
|
|
"hasAttachment",
|
|
"from",
|
|
"to",
|
|
"subject",
|
|
"receivedAt",
|
|
"sentAt",
|
|
"size",
|
|
"preview",
|
|
];
|
|
|
|
export const FULL_PROPS = [
|
|
...LIST_PROPS,
|
|
"messageId",
|
|
"inReplyTo",
|
|
"references",
|
|
"sender",
|
|
"cc",
|
|
"bcc",
|
|
"replyTo",
|
|
"bodyStructure",
|
|
"bodyValues",
|
|
"textBody",
|
|
"htmlBody",
|
|
"attachments",
|
|
"header:List-Unsubscribe:asText",
|
|
"header:List-Unsubscribe-Post:asText",
|
|
"header:List-Id:asText",
|
|
"header:Disposition-Notification-To:asAddresses",
|
|
"header:X-Priority:asText",
|
|
"header:Importance:asText",
|
|
"header:Auto-Submitted:asText",
|
|
"header:Precedence:asText",
|
|
"header:Authentication-Results:asText",
|
|
...SPAM_HEADER_PROPS,
|
|
];
|
|
|
|
export const BODY_PROPS = ["partId", "blobId", "size", "name", "type", "charset", "disposition", "cid", "language", "location", "subParts", "headers"];
|
|
|
|
export interface ListQuery {
|
|
key: string;
|
|
filter: EmailFilter;
|
|
sort: Comparator[];
|
|
collapseThreads: boolean;
|
|
mailboxId: string | null;
|
|
label?: string;
|
|
}
|
|
|
|
export interface ListState extends ListQuery {
|
|
ids: Id[];
|
|
total: number;
|
|
queryState: string | null;
|
|
loading: boolean;
|
|
loadingMore: boolean;
|
|
error: string | null;
|
|
exhausted: boolean;
|
|
}
|
|
|
|
export interface MailState {
|
|
accountId: Id | null;
|
|
mailboxes: Record<Id, Mailbox>;
|
|
mailboxState: string | null;
|
|
mailboxesLoaded: boolean;
|
|
emails: Record<Id, Email>;
|
|
fullIds: Record<Id, true>;
|
|
emailState: string | null;
|
|
threads: Record<Id, Thread>;
|
|
identities: Identity[];
|
|
quotas: Quota[];
|
|
vacation: VacationResponse | null;
|
|
list: ListState | null;
|
|
selected: Record<Id, true>;
|
|
anchorId: Id | null;
|
|
loadingThreads: Record<Id, true>;
|
|
lastSeenInboxEmailIds: Id[] | null;
|
|
openThreadId: Id | null;
|
|
setOpenThread(id: Id | null): void;
|
|
|
|
setAccount(accountId: Id | null): void;
|
|
loadMailboxes(): Promise<void>;
|
|
roleId(role: MailboxRole): Id | null;
|
|
mailboxPath(id: Id): string;
|
|
childrenOf(parentId: Id | null): Mailbox[];
|
|
|
|
query(q: ListQuery, opts?: { reset?: boolean }): Promise<void>;
|
|
loadMore(): Promise<void>;
|
|
refreshList(): Promise<void>;
|
|
|
|
getEmails(ids: Id[], full?: boolean): Promise<Email[]>;
|
|
loadThread(threadId: Id): Promise<Email[]>;
|
|
threadEmails(threadId: Id): Email[];
|
|
threadIdsIn(threadId: Id, mailboxId: Id | null): Id[];
|
|
|
|
setKeyword(ids: Id[], keyword: string, value: boolean): Promise<void>;
|
|
markRead(ids: Id[], read: boolean): Promise<void>;
|
|
star(ids: Id[], on: boolean): Promise<void>;
|
|
move(ids: Id[], toMailboxId: Id, opts?: { fromMailboxId?: Id | null; silent?: boolean; label?: string }): Promise<void>;
|
|
addToMailbox(ids: Id[], mailboxId: Id, add: boolean): Promise<void>;
|
|
trash(ids: Id[]): Promise<void>;
|
|
destroy(ids: Id[]): Promise<void>;
|
|
archive(ids: Id[]): Promise<void>;
|
|
/** Archive into a dated subfolder of Archive, creating the folders as needed. */
|
|
archiveByDate(ids: Id[], granularity: ArchiveGranularity): Promise<void>;
|
|
spam(ids: Id[], isSpam: boolean): Promise<void>;
|
|
emptyMailbox(mailboxId: Id): Promise<void>;
|
|
/** Mark every unread message in a mailbox read; optionally its subfolders too. */
|
|
markMailboxRead(mailboxId: Id, includeChildren?: boolean): Promise<void>;
|
|
/** The mailbox plus all of its descendants. */
|
|
descendantMailboxIds(mailboxId: Id): Id[];
|
|
|
|
createMailbox(name: string, parentId: Id | null): Promise<Id>;
|
|
updateMailbox(id: Id, patch: Partial<Mailbox>): Promise<void>;
|
|
destroyMailbox(id: Id, removeEmails?: boolean): Promise<void>;
|
|
|
|
loadIdentities(): Promise<Identity[]>;
|
|
/** The user's preferred identity (falls back to the first one). */
|
|
defaultIdentity(): Identity | undefined;
|
|
setDefaultIdentity(id: Id): void;
|
|
saveIdentity(id: Id | null, patch: Partial<Identity>): Promise<void>;
|
|
destroyIdentity(id: Id): Promise<void>;
|
|
loadVacation(): Promise<void>;
|
|
saveVacation(patch: Partial<VacationResponse>): Promise<void>;
|
|
loadQuota(): Promise<void>;
|
|
|
|
select(ids: Id[], on: boolean): void;
|
|
clearSelection(): void;
|
|
selectAll(): void;
|
|
setAnchor(id: Id | null): void;
|
|
|
|
applyChanges(types: Set<string>): Promise<void>;
|
|
importEml(blobId: Id, mailboxId: Id, keywords?: Record<string, boolean>): Promise<Id | null>;
|
|
}
|
|
|
|
function listKey(q: { filter: EmailFilter; sort: Comparator[]; collapseThreads: boolean }): string {
|
|
return JSON.stringify([q.filter, q.sort, q.collapseThreads]);
|
|
}
|
|
|
|
export const DEFAULT_SORT: Comparator[] = [{ property: "receivedAt", isAscending: false }];
|
|
|
|
export const useMail = create<MailState>((set, get) => ({
|
|
accountId: null,
|
|
mailboxes: {},
|
|
mailboxState: null,
|
|
mailboxesLoaded: false,
|
|
emails: {},
|
|
fullIds: {},
|
|
emailState: null,
|
|
threads: {},
|
|
identities: [],
|
|
quotas: [],
|
|
vacation: null,
|
|
list: null,
|
|
selected: {},
|
|
anchorId: null,
|
|
loadingThreads: {},
|
|
lastSeenInboxEmailIds: null,
|
|
openThreadId: null,
|
|
|
|
setOpenThread(id) {
|
|
set({ openThreadId: id });
|
|
},
|
|
|
|
setAccount(accountId) {
|
|
if (accountId === get().accountId) return;
|
|
set({
|
|
accountId,
|
|
mailboxes: {},
|
|
mailboxState: null,
|
|
mailboxesLoaded: false,
|
|
emails: {},
|
|
fullIds: {},
|
|
emailState: null,
|
|
threads: {},
|
|
identities: [],
|
|
quotas: [],
|
|
vacation: null,
|
|
list: null,
|
|
selected: {},
|
|
anchorId: null,
|
|
lastSeenInboxEmailIds: null,
|
|
});
|
|
},
|
|
|
|
async loadMailboxes() {
|
|
const accountId = get().accountId;
|
|
if (!accountId) return;
|
|
const res = await client.call<GetResponse<Mailbox>>("Mailbox/get", { accountId, ids: null, properties: MAILBOX_PROPS });
|
|
const mailboxes: Record<Id, Mailbox> = {};
|
|
for (const m of res.list) mailboxes[m.id] = m;
|
|
set({ mailboxes, mailboxState: res.state, mailboxesLoaded: true });
|
|
},
|
|
|
|
roleId(role) {
|
|
for (const m of Object.values(get().mailboxes)) if (m.role === role) return m.id;
|
|
return null;
|
|
},
|
|
|
|
mailboxPath(id) {
|
|
const mbs = get().mailboxes;
|
|
const parts: string[] = [];
|
|
let cur: Mailbox | undefined = mbs[id];
|
|
let guard = 0;
|
|
while (cur && guard++ < 20) {
|
|
parts.unshift(cur.role === "inbox" ? "INBOX" : cur.name);
|
|
cur = cur.parentId ? mbs[cur.parentId] : undefined;
|
|
}
|
|
return parts.join("/");
|
|
},
|
|
|
|
childrenOf(parentId) {
|
|
return Object.values(get().mailboxes)
|
|
.filter((m) => (m.parentId ?? null) === parentId)
|
|
.sort((a, b) => a.sortOrder - b.sortOrder || a.name.localeCompare(b.name));
|
|
},
|
|
|
|
async query(q, opts = {}) {
|
|
const accountId = get().accountId;
|
|
if (!accountId) return;
|
|
const key = listKey(q);
|
|
const cur = get().list;
|
|
const reuse = cur && cur.key === key && !opts.reset;
|
|
if (reuse && cur.ids.length && !cur.error) {
|
|
// Already showing; just refresh in background.
|
|
void get().refreshList();
|
|
return;
|
|
}
|
|
set({
|
|
list: { ...q, key, ids: reuse ? cur.ids : [], total: reuse ? cur.total : 0, queryState: null, loading: true, loadingMore: false, error: null, exhausted: false },
|
|
selected: {},
|
|
anchorId: null,
|
|
});
|
|
try {
|
|
const { ids, total, queryState } = await runQuery(accountId, q, 0, settings().pageSize);
|
|
if (get().list?.key !== key) return;
|
|
set((s) => ({ list: s.list ? { ...s.list, ids, total, queryState, loading: false, exhausted: ids.length >= total } : s.list }));
|
|
} catch (err) {
|
|
if (get().list?.key !== key) return;
|
|
set((s) => ({ list: s.list ? { ...s.list, loading: false, error: (err as Error).message } : s.list }));
|
|
}
|
|
},
|
|
|
|
async loadMore() {
|
|
const accountId = get().accountId;
|
|
const l = get().list;
|
|
if (!accountId || !l || l.loading || l.loadingMore || l.exhausted) return;
|
|
set({ list: { ...l, loadingMore: true } });
|
|
try {
|
|
const { ids, total, queryState } = await runQuery(accountId, l, l.ids.length, settings().pageSize);
|
|
const cur = get().list;
|
|
if (!cur || cur.key !== l.key) return;
|
|
const merged = [...cur.ids];
|
|
const seen = new Set(merged);
|
|
for (const id of ids) if (!seen.has(id)) merged.push(id);
|
|
set({ list: { ...cur, ids: merged, total, queryState, loadingMore: false, exhausted: ids.length === 0 || merged.length >= total } });
|
|
} catch (err) {
|
|
const cur = get().list;
|
|
if (cur && cur.key === l.key) set({ list: { ...cur, loadingMore: false, error: (err as Error).message } });
|
|
}
|
|
},
|
|
|
|
async refreshList() {
|
|
const accountId = get().accountId;
|
|
const l = get().list;
|
|
if (!accountId || !l) return;
|
|
try {
|
|
const limit = Math.max(settings().pageSize, l.ids.length);
|
|
const { ids, total, queryState } = await runQuery(accountId, l, 0, limit);
|
|
const cur = get().list;
|
|
if (!cur || cur.key !== l.key) return;
|
|
set({ list: { ...cur, ids, total, queryState, loading: false, error: null, exhausted: ids.length >= total } });
|
|
} catch {
|
|
/* keep old list */
|
|
}
|
|
},
|
|
|
|
async getEmails(ids, full = false) {
|
|
const accountId = get().accountId;
|
|
if (!accountId || !ids.length) return [];
|
|
const { emails, fullIds } = get();
|
|
const missing = ids.filter((id) => !emails[id] || (full && !fullIds[id]));
|
|
if (missing.length) {
|
|
const results = await Promise.all(
|
|
chunk(missing, client.maxObjectsInGet).map((part) =>
|
|
client.call<GetResponse<Email>>("Email/get", {
|
|
accountId,
|
|
ids: part,
|
|
properties: full ? FULL_PROPS : LIST_PROPS,
|
|
...(full ? { fetchHTMLBodyValues: true, fetchTextBodyValues: true, maxBodyValueBytes: 2 * 1024 * 1024, bodyProperties: BODY_PROPS } : {}),
|
|
}),
|
|
),
|
|
);
|
|
set((s) => {
|
|
const next = { ...s.emails };
|
|
const nextFull = { ...s.fullIds };
|
|
let state = s.emailState;
|
|
for (const r of results) {
|
|
state = r.state;
|
|
for (const e of r.list) {
|
|
next[e.id] = { ...next[e.id], ...e };
|
|
if (full) nextFull[e.id] = true;
|
|
}
|
|
}
|
|
return { emails: next, fullIds: nextFull, emailState: s.emailState ?? state };
|
|
});
|
|
}
|
|
const now = get().emails;
|
|
return ids.map((id) => now[id]).filter((e): e is Email => Boolean(e));
|
|
},
|
|
|
|
async loadThread(threadId) {
|
|
const accountId = get().accountId;
|
|
if (!accountId) return [];
|
|
set((s) => ({ loadingThreads: { ...s.loadingThreads, [threadId]: true } }));
|
|
try {
|
|
const res = await client.chain([
|
|
["Thread/get", { accountId, ids: [threadId] }, "t"],
|
|
[
|
|
"Email/get",
|
|
{
|
|
accountId,
|
|
"#ids": { resultOf: "t", name: "Thread/get", path: "/list/*/emailIds" },
|
|
properties: FULL_PROPS,
|
|
fetchHTMLBodyValues: true,
|
|
fetchTextBodyValues: true,
|
|
maxBodyValueBytes: 2 * 1024 * 1024,
|
|
bodyProperties: BODY_PROPS,
|
|
},
|
|
"e",
|
|
],
|
|
]);
|
|
const thread = (res.get("t")?.[0] as unknown as GetResponse<Thread>).list[0];
|
|
const emailsRes = res.get("e")?.[0] as unknown as GetResponse<Email>;
|
|
if (!thread) return [];
|
|
set((s) => {
|
|
const next = { ...s.emails };
|
|
const nextFull = { ...s.fullIds };
|
|
for (const e of emailsRes.list) {
|
|
next[e.id] = { ...next[e.id], ...e };
|
|
nextFull[e.id] = true;
|
|
}
|
|
const { [threadId]: _drop, ...rest } = s.loadingThreads;
|
|
return { emails: next, fullIds: nextFull, threads: { ...s.threads, [threadId]: thread }, loadingThreads: rest };
|
|
});
|
|
return get().threadEmails(threadId);
|
|
} catch (err) {
|
|
set((s) => {
|
|
const { [threadId]: _drop, ...rest } = s.loadingThreads;
|
|
return { loadingThreads: rest };
|
|
});
|
|
throw err;
|
|
}
|
|
},
|
|
|
|
threadEmails(threadId) {
|
|
const { threads, emails } = get();
|
|
const t = threads[threadId];
|
|
if (!t) return [];
|
|
return t.emailIds.map((id) => emails[id]).filter((e): e is Email => Boolean(e));
|
|
},
|
|
|
|
threadIdsIn(threadId, mailboxId) {
|
|
const t = get().threads[threadId];
|
|
if (!t) return [];
|
|
if (!mailboxId) return [...t.emailIds];
|
|
const { emails } = get();
|
|
return t.emailIds.filter((id) => emails[id]?.mailboxIds[mailboxId]);
|
|
},
|
|
|
|
async setKeyword(ids, keyword, value) {
|
|
const accountId = get().accountId;
|
|
if (!accountId || !ids.length) return;
|
|
// optimistic
|
|
set((s) => {
|
|
const next = { ...s.emails };
|
|
for (const id of ids) {
|
|
const e = next[id];
|
|
if (!e) continue;
|
|
const kw = { ...e.keywords };
|
|
if (value) kw[keyword] = true;
|
|
else delete kw[keyword];
|
|
next[id] = { ...e, keywords: kw };
|
|
}
|
|
return { emails: next };
|
|
});
|
|
const update: Record<Id, Record<string, unknown>> = {};
|
|
for (const id of ids) update[id] = { [`keywords/${keyword}`]: value ? true : null };
|
|
try {
|
|
await setEmails(accountId, update);
|
|
} catch (err) {
|
|
toast.error(t("Could not update: {error}", { error: (err as Error).message }));
|
|
void get().getEmails(ids);
|
|
}
|
|
},
|
|
|
|
markRead(ids, read) {
|
|
return get().setKeyword(ids, "$seen", read);
|
|
},
|
|
|
|
star(ids, on) {
|
|
return get().setKeyword(ids, "$flagged", on);
|
|
},
|
|
|
|
async move(ids, toMailboxId, opts = {}) {
|
|
const accountId = get().accountId;
|
|
if (!accountId || !ids.length) return;
|
|
const { emails, mailboxes } = get();
|
|
const prev: Record<Id, Record<Id, boolean>> = {};
|
|
const update: Record<Id, Record<string, unknown>> = {};
|
|
for (const id of ids) {
|
|
const e = emails[id];
|
|
prev[id] = e?.mailboxIds ?? {};
|
|
update[id] = { mailboxIds: { [toMailboxId]: true } };
|
|
}
|
|
// optimistic
|
|
set((s) => {
|
|
const next = { ...s.emails };
|
|
for (const id of ids) if (next[id]) next[id] = { ...next[id]!, mailboxIds: { [toMailboxId]: true } };
|
|
return { emails: next, selected: {} };
|
|
});
|
|
removeFromList(ids, set, get, toMailboxId);
|
|
try {
|
|
await setEmails(accountId, update);
|
|
if (!opts.silent) {
|
|
// The folder's own name, because that is what the user is looking at
|
|
// in the sidebar. A hardcoded word here told people their mail had
|
|
// moved to "Trash" or "Spam" on a server whose folders are called
|
|
// "Deleted Items" and "Junk Mail" -- naming somewhere that does not
|
|
// exist, in the one message whose job is saying where it went.
|
|
// Through the display name, so the message names the folder the reader
|
|
// is looking at in the sidebar rather than the server's own word for it.
|
|
const name = mailboxDisplayName(mailboxes[toMailboxId]) || opts.label || t("folder");
|
|
toast.show(`${ids.length === 1 ? "Conversation" : `${ids.length} conversations`} moved to ${name}`, {
|
|
action: {
|
|
label: "Undo",
|
|
onClick: async () => {
|
|
const undo: Record<Id, Record<string, unknown>> = {};
|
|
for (const id of ids) undo[id] = { mailboxIds: prev[id] };
|
|
await setEmails(accountId, undo);
|
|
set((s) => {
|
|
const next = { ...s.emails };
|
|
for (const id of ids) if (next[id]) next[id] = { ...next[id]!, mailboxIds: prev[id]! };
|
|
return { emails: next };
|
|
});
|
|
void get().refreshList();
|
|
void get().loadMailboxes();
|
|
},
|
|
},
|
|
});
|
|
}
|
|
void get().loadMailboxes();
|
|
} catch (err) {
|
|
toast.error(t("Move failed: {error}", { error: (err as Error).message }));
|
|
void get().getEmails(ids);
|
|
void get().refreshList();
|
|
}
|
|
},
|
|
|
|
async addToMailbox(ids, mailboxId, add) {
|
|
const accountId = get().accountId;
|
|
if (!accountId || !ids.length) return;
|
|
const update: Record<Id, Record<string, unknown>> = {};
|
|
for (const id of ids) update[id] = { [`mailboxIds/${mailboxId}`]: add ? true : null };
|
|
set((s) => {
|
|
const next = { ...s.emails };
|
|
for (const id of ids) {
|
|
const e = next[id];
|
|
if (!e) continue;
|
|
const mb = { ...e.mailboxIds };
|
|
if (add) mb[mailboxId] = true;
|
|
else delete mb[mailboxId];
|
|
next[id] = { ...e, mailboxIds: mb };
|
|
}
|
|
return { emails: next };
|
|
});
|
|
try {
|
|
await setEmails(accountId, update);
|
|
void get().loadMailboxes();
|
|
} catch (err) {
|
|
toast.error(t("Could not update labels: {error}", { error: (err as Error).message }));
|
|
void get().getEmails(ids);
|
|
}
|
|
},
|
|
|
|
async trash(ids) {
|
|
const { roleId, emails } = get();
|
|
const trashId = roleId("trash");
|
|
const inTrash = ids.filter((id) => (trashId && emails[id]?.mailboxIds[trashId]) || (roleId("junk") && emails[id]?.mailboxIds[roleId("junk")!]));
|
|
const toMove = ids.filter((id) => !inTrash.includes(id));
|
|
if (inTrash.length) await get().destroy(inTrash);
|
|
if (toMove.length && trashId) await get().move(toMove, trashId, { label: "Deleted Items" });
|
|
else if (toMove.length) await get().destroy(toMove);
|
|
},
|
|
|
|
async destroy(ids) {
|
|
const accountId = get().accountId;
|
|
if (!accountId || !ids.length) return;
|
|
removeFromList(ids, set, get, null);
|
|
set((s) => {
|
|
const next = { ...s.emails };
|
|
for (const id of ids) delete next[id];
|
|
return { emails: next, selected: {} };
|
|
});
|
|
try {
|
|
const { notDestroyed } = await destroyEmails(accountId, ids);
|
|
const failed = Object.keys(notDestroyed);
|
|
if (failed.length) toast.error(plural(failed.length, { one: "{n} message could not be deleted", other: "{n} messages could not be deleted" }));
|
|
else toast.show(`${ids.length === 1 ? "Message" : `${ids.length} messages`} deleted forever`);
|
|
void get().loadMailboxes();
|
|
} catch (err) {
|
|
toast.error(t("Delete failed: {error}", { error: (err as Error).message }));
|
|
void get().refreshList();
|
|
}
|
|
},
|
|
|
|
async archive(ids) {
|
|
const archiveId = get().roleId("archive") ?? get().roleId("all");
|
|
if (!archiveId) {
|
|
toast.error(t("No Archive folder found. Create one named “Archive” first."));
|
|
return;
|
|
}
|
|
await get().move(ids, archiveId, { label: "Archive" });
|
|
},
|
|
|
|
async archiveByDate(ids, granularity) {
|
|
const accountId = get().accountId;
|
|
const archiveId = get().roleId("archive") ?? get().roleId("all");
|
|
if (!accountId || !ids.length) return;
|
|
if (!archiveId) {
|
|
toast.error(t("No Archive folder found. Create one named “Archive” first."));
|
|
return;
|
|
}
|
|
const { emails } = get();
|
|
const groups = groupByArchivePath(ids.map((id) => ({ id, receivedAt: emails[id]?.receivedAt })), granularity);
|
|
|
|
// Where everything came from, captured before anything moves, so one Undo
|
|
// can put back a selection that went to several folders.
|
|
const prev: Record<Id, Record<Id, boolean>> = {};
|
|
for (const id of ids) prev[id] = emails[id]?.mailboxIds ?? {};
|
|
|
|
const moved: string[] = [];
|
|
try {
|
|
for (const group of groups) {
|
|
const target = await ensureFolderPath(get, archiveId, group.segments);
|
|
// Silent: each group would otherwise raise its own toast with its own
|
|
// Undo, and undoing one third of a move is not what anybody meant.
|
|
await get().move(group.ids, target, { silent: true });
|
|
moved.push(group.segments.length ? `Archive/${archivePath(group.segments)}` : "Archive");
|
|
}
|
|
} catch (err) {
|
|
toast.error(t("Archive failed: {error}", { error: (err as Error).message }));
|
|
void get().getEmails(ids);
|
|
void get().refreshList();
|
|
return;
|
|
}
|
|
|
|
// One message naming every destination, because a selection that split
|
|
// across months should say so rather than claiming a single folder.
|
|
const where = moved.length === 1 ? moved[0]! : t("{count} folders", { count: String(moved.length) });
|
|
toast.show(
|
|
ids.length === 1
|
|
? t("Conversation moved to {folder}", { folder: where })
|
|
: t("{count} conversations moved to {folder}", { count: String(ids.length), folder: where }),
|
|
{
|
|
action: {
|
|
label: "Undo",
|
|
onClick: async () => {
|
|
const undo: Record<Id, Record<string, unknown>> = {};
|
|
for (const id of ids) undo[id] = { mailboxIds: prev[id] };
|
|
await setEmails(accountId, undo);
|
|
set((st) => {
|
|
const next = { ...st.emails };
|
|
for (const id of ids) if (next[id]) next[id] = { ...next[id]!, mailboxIds: prev[id]! };
|
|
return { emails: next };
|
|
});
|
|
void get().refreshList();
|
|
void get().loadMailboxes();
|
|
},
|
|
},
|
|
},
|
|
);
|
|
void get().loadMailboxes();
|
|
},
|
|
|
|
async spam(ids, isSpam) {
|
|
const { roleId } = get();
|
|
const target = isSpam ? roleId("junk") : roleId("inbox");
|
|
if (!target) return;
|
|
const kw: Record<Id, Record<string, unknown>> = {};
|
|
for (const id of ids) kw[id] = { "keywords/$junk": isSpam ? true : null, "keywords/$notjunk": isSpam ? null : true };
|
|
const accountId = get().accountId!;
|
|
try {
|
|
await setEmails(accountId, kw);
|
|
} catch {
|
|
/* keyword may be rejected; still move */
|
|
}
|
|
await get().move(ids, target, { label: isSpam ? "Junk Mail" : "Inbox" });
|
|
},
|
|
|
|
async emptyMailbox(mailboxId) {
|
|
const accountId = get().accountId;
|
|
if (!accountId) return;
|
|
// Emptying is permanent and covers the whole folder at once, so it is
|
|
// offered only for the two folders whose whole purpose is holding what you
|
|
// did not want. The menus hide it elsewhere; this is the guard that makes
|
|
// that true of the action itself, whatever calls it.
|
|
//
|
|
// Junk Mail is destroyed outright rather than moved to Deleted Items —
|
|
// there is no point routing spam through the bin on its way out, and it is
|
|
// what "delete all spam" means everywhere else. The dialogs say so.
|
|
if (mailboxId !== get().roleId("trash") && mailboxId !== get().roleId("junk")) {
|
|
toast.error(t("Only Deleted Items and Junk Mail can be emptied."));
|
|
return;
|
|
}
|
|
// A folder can hold far more messages than the server will destroy in one
|
|
// call, so walk it a page at a time instead of back-referencing one huge
|
|
// query into one Email/set. Each pass re-runs the filter, so the next page
|
|
// is simply whatever is still in the folder.
|
|
const page = client.maxObjectsInSet;
|
|
let deleted = 0;
|
|
let progress: number | null = null;
|
|
try {
|
|
for (;;) {
|
|
const q = await client.call<QueryResponse>("Email/query", { accountId, filter: { inMailbox: mailboxId }, limit: page });
|
|
if (!q.ids.length) break;
|
|
if (progress === null && (q.total ?? q.ids.length) > page) {
|
|
progress = toast.show(t("Emptying folder…"), { duration: 0 });
|
|
}
|
|
const { destroyed, notDestroyed } = await destroyEmails(accountId, q.ids);
|
|
deleted += destroyed.length;
|
|
// Nothing went through: the rest is undeletable, and looping again
|
|
// would ask for the same ids forever.
|
|
if (!destroyed.length) {
|
|
const [, err] = Object.entries(notDestroyed)[0] ?? [];
|
|
throw new Error(err ? setErrorMessage(err) : "the server refused to delete these messages");
|
|
}
|
|
}
|
|
toast.show(plural(deleted, { one: "Deleted {n} message", other: "Deleted {n} messages" }));
|
|
set({ list: get().list ? { ...get().list!, ids: get().list!.mailboxId === mailboxId ? [] : get().list!.ids, total: 0 } : null });
|
|
} catch (err) {
|
|
toast.error(t("Could not empty folder: {error}", { error: (err as Error).message })
|
|
+ (deleted ? " " + plural(deleted, { one: "({n} deleted first)", other: "({n} deleted first)" }) : ""));
|
|
} finally {
|
|
if (progress !== null) toast.dismiss(progress);
|
|
void get().loadMailboxes();
|
|
void get().refreshList();
|
|
}
|
|
},
|
|
|
|
descendantMailboxIds(mailboxId) {
|
|
const all = Object.values(get().mailboxes);
|
|
const out: Id[] = [mailboxId];
|
|
const walk = (parent: Id) => {
|
|
for (const m of all) {
|
|
if ((m.parentId ?? null) === parent) {
|
|
out.push(m.id);
|
|
walk(m.id);
|
|
}
|
|
}
|
|
};
|
|
walk(mailboxId);
|
|
return out;
|
|
},
|
|
|
|
async markMailboxRead(mailboxId, includeChildren = false) {
|
|
const accountId = get().accountId;
|
|
if (!accountId) return;
|
|
const boxes = includeChildren ? get().descendantMailboxIds(mailboxId) : [mailboxId];
|
|
// The ids the query returns are all we need; asking Email/get to echo them
|
|
// back only risks blowing past maxObjectsInGet on a very full folder.
|
|
const page = client.maxObjectsInSet;
|
|
const unreadIn = async (filter: EmailFilter): Promise<Id[]> => {
|
|
const res = await client.call<QueryResponse>("Email/query", { accountId, filter, limit: page });
|
|
return res.ids;
|
|
};
|
|
const nextUnread = async (): Promise<Id[]> => {
|
|
if (boxes.length === 1) return unreadIn({ inMailbox: boxes[0]!, notKeyword: "$seen" });
|
|
try {
|
|
return await unreadIn({ operator: "AND", conditions: [{ notKeyword: "$seen" }, { operator: "OR", conditions: boxes.map((id) => ({ inMailbox: id })) }] });
|
|
} catch {
|
|
// Server without filter-operator support: one query per folder.
|
|
const per = await Promise.all(boxes.map((id) => unreadIn({ inMailbox: id, notKeyword: "$seen" }).catch(() => [] as Id[])));
|
|
return [...new Set(per.flat())];
|
|
}
|
|
};
|
|
try {
|
|
// One page per pass; the ones just marked drop out of the filter, so a
|
|
// repeated head id means the last pass changed nothing and we stop.
|
|
let marked = 0;
|
|
let lastHead: Id | null = null;
|
|
for (;;) {
|
|
const ids = await nextUnread();
|
|
if (!ids.length || ids[0] === lastHead) break;
|
|
lastHead = ids[0]!;
|
|
await get().markRead(ids, true);
|
|
marked += ids.length;
|
|
}
|
|
if (!marked) {
|
|
toast.show(t("Nothing unread here"));
|
|
return;
|
|
}
|
|
toast.success(
|
|
plural(marked, { one: "Marked {n} message as read", other: "Marked {n} messages as read" })
|
|
+ (includeChildren && boxes.length > 1 ? " " + plural(boxes.length, { one: "in {n} folder", other: "in {n} folders" }) : ""),
|
|
);
|
|
void get().loadMailboxes();
|
|
} catch (err) {
|
|
toast.error(t("Could not mark as read: {error}", { error: (err as Error).message }));
|
|
}
|
|
},
|
|
|
|
async createMailbox(name, parentId) {
|
|
const accountId = get().accountId!;
|
|
const res = await client.call<SetResponse<Mailbox>>("Mailbox/set", { accountId, create: { n: { name, parentId, isSubscribed: true } } });
|
|
const err = res.notCreated?.n;
|
|
if (err) throw new Error(setErrorMessage(err));
|
|
await get().loadMailboxes();
|
|
return res.created!.n!.id;
|
|
},
|
|
|
|
async updateMailbox(id, patch) {
|
|
const accountId = get().accountId!;
|
|
// Paths as the filter rules currently spell them, before the move.
|
|
const before = patch.name !== undefined || patch.parentId !== undefined ? folderRefs(get(), id) : [];
|
|
const res = await client.call<SetResponse>("Mailbox/set", { accountId, update: { [id]: patch } });
|
|
const err = res.notUpdated?.[id];
|
|
if (err) throw new Error(setErrorMessage(err));
|
|
await get().loadMailboxes();
|
|
// Awaited, not fired and forgotten: the folder operation is not really done
|
|
// until the rules pointing at it agree, and a page that navigates away
|
|
// mid-save would leave the script half-written.
|
|
if (before.length) await followFolders(before);
|
|
},
|
|
|
|
async destroyMailbox(id, removeEmails = true) {
|
|
const accountId = get().accountId!;
|
|
const before = folderRefs(get(), id);
|
|
const res = await client.call<SetResponse>("Mailbox/set", { accountId, destroy: [id], onDestroyRemoveEmails: removeEmails });
|
|
const err = res.notDestroyed?.[id];
|
|
if (err) throw new Error(setErrorMessage(err));
|
|
await get().loadMailboxes();
|
|
await followFolders(before);
|
|
},
|
|
|
|
async loadIdentities() {
|
|
const accountId = get().accountId;
|
|
if (!accountId) return [];
|
|
const res = await client.call<GetResponse<Identity>>("Identity/get", { accountId, ids: null });
|
|
set({ identities: sortIdentities(res.list, accountId) });
|
|
// Long signatures live in Files; swap the stored marker for the full HTML.
|
|
const { markerOf } = await import("@/lib/signatureHtml");
|
|
const pending = res.list.filter((i) => markerOf(i.htmlSignature));
|
|
if (pending.length) {
|
|
const { loadStoredSignature } = await import("@/lib/signatureImages");
|
|
const full = await Promise.all(pending.map(async (i) => { const m = markerOf(i.htmlSignature)!; try { return [i.id, await loadStoredSignature(m.blobId, m.type)] as const; } catch { return [i.id, null] as const; } }));
|
|
if (get().accountId === accountId) {
|
|
set((s) => ({ identities: s.identities.map((i) => { const f = full.find(([id]) => id === i.id)?.[1]; return f ? { ...i, htmlSignature: f } : i; }) }));
|
|
}
|
|
}
|
|
return get().identities;
|
|
},
|
|
|
|
defaultIdentity() {
|
|
const { identities, accountId } = get();
|
|
const pref = accountId ? settings().defaultIdentityByAccount[accountId] : undefined;
|
|
return identities.find((i) => i.id === pref) ?? identities[0];
|
|
},
|
|
|
|
setDefaultIdentity(id) {
|
|
const accountId = get().accountId;
|
|
if (!accountId) return;
|
|
useSettings.getState().update({ defaultIdentityByAccount: { ...settings().defaultIdentityByAccount, [accountId]: id } });
|
|
set({ identities: sortIdentities(get().identities, accountId) });
|
|
},
|
|
|
|
async saveIdentity(id, patch) {
|
|
const accountId = get().accountId!;
|
|
const res = id
|
|
? await client.call<SetResponse<Identity>>("Identity/set", { accountId, update: { [id]: patch } })
|
|
: await client.call<SetResponse<Identity>>("Identity/set", { accountId, create: { n: patch } });
|
|
const err = id ? res.notUpdated?.[id] : res.notCreated?.n;
|
|
if (err) throw new Error(setErrorMessage(err));
|
|
await get().loadIdentities();
|
|
},
|
|
|
|
async destroyIdentity(id) {
|
|
const accountId = get().accountId!;
|
|
const res = await client.call<SetResponse>("Identity/set", { accountId, destroy: [id] });
|
|
const err = res.notDestroyed?.[id];
|
|
if (err) throw new Error(setErrorMessage(err));
|
|
await get().loadIdentities();
|
|
},
|
|
|
|
async loadVacation() {
|
|
const accountId = get().accountId;
|
|
if (!accountId) return;
|
|
try {
|
|
const res = await client.call<GetResponse<VacationResponse>>("VacationResponse/get", { accountId, ids: null });
|
|
set({ vacation: res.list[0] ?? null });
|
|
} catch {
|
|
set({ vacation: null });
|
|
}
|
|
},
|
|
|
|
async saveVacation(patch) {
|
|
const accountId = get().accountId!;
|
|
const res = await client.call<SetResponse>("VacationResponse/set", { accountId, update: { singleton: patch } });
|
|
const err = res.notUpdated?.singleton;
|
|
if (err) throw new Error(setErrorMessage(err));
|
|
await get().loadVacation();
|
|
},
|
|
|
|
async loadQuota() {
|
|
const accountId = get().accountId;
|
|
if (!accountId || !client.hasCapability("urn:ietf:params:jmap:quota")) return;
|
|
try {
|
|
const res = await client.call<GetResponse<Quota>>("Quota/get", { accountId, ids: null });
|
|
set({ quotas: res.list });
|
|
} catch {
|
|
set({ quotas: [] });
|
|
}
|
|
},
|
|
|
|
select(ids, on) {
|
|
set((s) => {
|
|
const next = { ...s.selected };
|
|
for (const id of ids) {
|
|
if (on) next[id] = true;
|
|
else delete next[id];
|
|
}
|
|
return { selected: next };
|
|
});
|
|
},
|
|
clearSelection() {
|
|
set({ selected: {} });
|
|
},
|
|
selectAll() {
|
|
const l = get().list;
|
|
if (!l) return;
|
|
const next: Record<Id, true> = {};
|
|
for (const id of l.ids) next[id] = true;
|
|
set({ selected: next });
|
|
},
|
|
setAnchor(id) {
|
|
set({ anchorId: id });
|
|
},
|
|
|
|
async applyChanges(types) {
|
|
const accountId = get().accountId;
|
|
if (!accountId) return;
|
|
if (types.has("Mailbox")) void get().loadMailboxes();
|
|
if (types.has("Email")) {
|
|
const state = get().emailState;
|
|
if (state) {
|
|
try {
|
|
let since = state;
|
|
let guard = 0;
|
|
const updated = new Set<Id>();
|
|
const created = new Set<Id>();
|
|
const destroyed = new Set<Id>();
|
|
// Page through Email/changes.
|
|
while (guard++ < 10) {
|
|
const ch = await client.call<ChangesResponse>("Email/changes", { accountId, sinceState: since, maxChanges: 500 });
|
|
ch.created.forEach((id) => created.add(id));
|
|
ch.updated.forEach((id) => updated.add(id));
|
|
ch.destroyed.forEach((id) => destroyed.add(id));
|
|
since = ch.newState;
|
|
if (!ch.hasMoreChanges) break;
|
|
}
|
|
set((s) => {
|
|
const next = { ...s.emails };
|
|
const nextFull = { ...s.fullIds };
|
|
for (const id of destroyed) {
|
|
delete next[id];
|
|
delete nextFull[id];
|
|
}
|
|
/*
|
|
* The full copy of an updated email is deliberately kept.
|
|
*
|
|
* This used to drop it so the next read would fetch it again. But
|
|
* the reading pane renders only the emails it holds in full, so
|
|
* dropping one took the message out of the open thread until the
|
|
* refetch at the end of this function put it back. The pane emptied
|
|
* and refilled -- on an HTML message, a flash to the app's own
|
|
* background and out again, which is what was left of #100 after
|
|
* the message view stopped rebuilding its body.
|
|
*
|
|
* Marking as read causes exactly this: the server echoes our own
|
|
* change back as an update.
|
|
*
|
|
* Nothing is lost by keeping it. RFC 8621 makes every property of
|
|
* an Email immutable except `keywords` and `mailboxIds` -- the id
|
|
* is derived from the content, so a body cannot change beneath one
|
|
* -- and both are in LIST_PROPS, which the refresh immediately
|
|
* below merges over the cached copy. The eviction only ever cost
|
|
* the message its place in the thread.
|
|
*/
|
|
return { emails: next, fullIds: nextFull, emailState: since };
|
|
});
|
|
// Refresh the list-level props of updated/cached emails.
|
|
const cached = [...updated].filter((id) => get().emails[id]);
|
|
if (cached.length) {
|
|
const results = await Promise.all(
|
|
chunk(cached, client.maxObjectsInGet).map((part) => client.call<GetResponse<Email>>("Email/get", { accountId, ids: part, properties: LIST_PROPS })),
|
|
);
|
|
set((s) => {
|
|
const next = { ...s.emails };
|
|
for (const r of results) for (const e of r.list) next[e.id] = { ...next[e.id], ...e };
|
|
return { emails: next };
|
|
});
|
|
}
|
|
if (created.size) await notifyNewMail([...created], get);
|
|
} catch (err) {
|
|
if (err instanceof JmapMethodError && err.type === "cannotCalculateChanges") {
|
|
set({ emailState: null });
|
|
}
|
|
}
|
|
}
|
|
void get().refreshList();
|
|
void get().loadMailboxes();
|
|
}
|
|
if (types.has("Thread") || types.has("Email")) {
|
|
const open = get().openThreadId;
|
|
if (open) void get().loadThread(open).catch(() => undefined);
|
|
}
|
|
if (types.has("Identity")) void get().loadIdentities();
|
|
if (types.has("VacationResponse")) void get().loadVacation();
|
|
if (types.has("Quota")) void get().loadQuota();
|
|
},
|
|
|
|
async importEml(blobId, mailboxId, keywords = {}) {
|
|
const accountId = get().accountId;
|
|
if (!accountId) return null;
|
|
const res = await client.call<{ created?: Record<string, Email>; notCreated?: Record<string, { type: string; description?: string }> }>("Email/import", {
|
|
accountId,
|
|
emails: { i: { blobId, mailboxIds: { [mailboxId]: true }, keywords } },
|
|
});
|
|
if (res.notCreated?.i) throw new Error(setErrorMessage(res.notCreated.i));
|
|
void get().refreshList();
|
|
void get().loadMailboxes();
|
|
return res.created?.i?.id ?? null;
|
|
},
|
|
}));
|
|
|
|
function sortIdentities(list: Identity[], accountId: Id): Identity[] {
|
|
const pref = settings().defaultIdentityByAccount[accountId];
|
|
return [...list].sort((a, b) => (a.id === pref ? -1 : b.id === pref ? 1 : a.email.localeCompare(b.email)));
|
|
}
|
|
|
|
async function runQuery(accountId: Id, q: ListQuery, position: number, limit: number) {
|
|
const calls: Array<[string, Record<string, unknown>, string]> = [
|
|
["Email/query", { accountId, filter: q.filter, sort: q.sort, collapseThreads: q.collapseThreads, position, limit, calculateTotal: true }, "q"],
|
|
["Email/get", { accountId, "#ids": { resultOf: "q", name: "Email/query", path: "/ids" }, properties: LIST_PROPS }, "e"],
|
|
];
|
|
if (q.collapseThreads) {
|
|
calls.push(["Thread/get", { accountId, "#ids": { resultOf: "e", name: "Email/get", path: "/list/*/threadId" } }, "t"]);
|
|
calls.push(["Email/get", { accountId, "#ids": { resultOf: "t", name: "Thread/get", path: "/list/*/emailIds" }, properties: LIST_PROPS }, "te"]);
|
|
}
|
|
const res = await client.chain(calls);
|
|
const query = res.get("q")?.[0] as unknown as QueryResponse;
|
|
const emailsRes = res.get("e")?.[0] as unknown as GetResponse<Email>;
|
|
const threadsRes = res.get("t")?.[0] as unknown as GetResponse<Thread> | undefined;
|
|
const threadEmails = res.get("te")?.[0] as unknown as GetResponse<Email> | undefined;
|
|
useMail.setState((s) => {
|
|
const emails = { ...s.emails };
|
|
for (const e of emailsRes.list) emails[e.id] = { ...emails[e.id], ...e };
|
|
for (const e of threadEmails?.list ?? []) emails[e.id] = { ...emails[e.id], ...e };
|
|
const threads = { ...s.threads };
|
|
for (const t of threadsRes?.list ?? []) threads[t.id] = t;
|
|
return { emails, threads, emailState: s.emailState ?? emailsRes.state };
|
|
});
|
|
return { ids: query.ids, total: query.total ?? query.ids.length, queryState: query.queryState };
|
|
}
|
|
|
|
/**
|
|
* Destroy emails in batches the server will accept.
|
|
*
|
|
* Handing Email/set more ids than `maxObjectsInSet` fails the whole call with
|
|
* requestTooLarge — nothing is deleted — so split first and merge the results.
|
|
*/
|
|
async function destroyEmails(accountId: Id, ids: Id[]): Promise<{ destroyed: Id[]; notDestroyed: Record<Id, SetError> }> {
|
|
const destroyed: Id[] = [];
|
|
const notDestroyed: Record<Id, SetError> = {};
|
|
for (const part of chunk(ids, client.maxObjectsInSet)) {
|
|
const res = await client.call<SetResponse>("Email/set", { accountId, destroy: part });
|
|
destroyed.push(...(res.destroyed ?? []));
|
|
Object.assign(notDestroyed, res.notDestroyed ?? {});
|
|
}
|
|
return { destroyed, notDestroyed };
|
|
}
|
|
|
|
async function setEmails(accountId: Id, update: Record<Id, Record<string, unknown>>) {
|
|
const ids = Object.keys(update);
|
|
for (const part of chunk(ids, client.maxObjectsInSet)) {
|
|
const sub: Record<Id, Record<string, unknown>> = {};
|
|
for (const id of part) sub[id] = update[id]!;
|
|
const res = await client.call<SetResponse>("Email/set", { accountId, update: sub });
|
|
const failed = Object.entries(res.notUpdated ?? {});
|
|
if (failed.length) {
|
|
const [, err] = failed[0]!;
|
|
throw new Error(`${err.type}${err.description ? `: ${err.description}` : ""}${failed.length > 1 ? ` (+${failed.length - 1} more)` : ""}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Remove given email ids (and threads they represent) from the current list optimistically. */
|
|
function removeFromList(ids: Id[], set: (fn: (s: MailState) => Partial<MailState>) => void, get: () => MailState, targetMailboxId: Id | null) {
|
|
const l = get().list;
|
|
if (!l) return;
|
|
// If the list is showing the mailbox we're moving into, don't remove.
|
|
if (targetMailboxId && l.mailboxId === targetMailboxId) return;
|
|
const idSet = new Set(ids);
|
|
const { emails, threads } = get();
|
|
const removeRow = (rowId: Id): boolean => {
|
|
if (idSet.has(rowId)) return true;
|
|
if (!l.collapseThreads) return false;
|
|
const e = emails[rowId];
|
|
if (!e) return false;
|
|
const t = threads[e.threadId];
|
|
if (!t) return false;
|
|
// Row goes away if no email of the thread remains in this mailbox after the move.
|
|
if (l.mailboxId) {
|
|
const remaining = t.emailIds.filter((id) => !idSet.has(id) && emails[id]?.mailboxIds[l.mailboxId!]);
|
|
return remaining.length === 0;
|
|
}
|
|
return t.emailIds.every((id) => idSet.has(id));
|
|
};
|
|
const nextIds = l.ids.filter((id) => !removeRow(id));
|
|
if (nextIds.length !== l.ids.length) {
|
|
set((s) => ({ list: s.list ? { ...s.list, ids: nextIds, total: Math.max(0, s.list.total - (l.ids.length - nextIds.length)) } : s.list }));
|
|
}
|
|
}
|
|
|
|
async function notifyNewMail(created: Id[], get: () => MailState) {
|
|
const s = settings();
|
|
const inbox = get().roleId("inbox");
|
|
if (!inbox) return;
|
|
const emails = await get().getEmails(created);
|
|
const fresh = emails.filter((e) => e.mailboxIds[inbox] && !e.keywords.$seen && !e.keywords.$draft);
|
|
if (!fresh.length) return;
|
|
const { showNotification, playNewMailSound } = await import("@/lib/notify");
|
|
if (s.notificationSound) playNewMailSound();
|
|
if (s.desktopNotifications) {
|
|
for (const e of fresh.slice(0, 3)) {
|
|
const from = e.from?.[0];
|
|
showNotification(from?.name || from?.email || "New message", {
|
|
body: `${e.subject || "(no subject)"}\n${e.preview ?? ""}`.trim(),
|
|
tag: e.id,
|
|
onClick: () => {
|
|
window.location.hash = "";
|
|
window.history.pushState({}, "", `/mail/${inbox}/${e.threadId}`);
|
|
window.dispatchEvent(new PopStateEvent("popstate"));
|
|
},
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Keep the store bound to the selected account. */
|
|
useSession.subscribe((s) => {
|
|
useMail.getState().setAccount(s.status === "authenticated" ? s.accountId : null);
|
|
});
|
|
|
|
export function mailboxIcon(role: MailboxRole): string {
|
|
switch (role) {
|
|
case "inbox":
|
|
return "inbox";
|
|
case "drafts":
|
|
return "file";
|
|
case "sent":
|
|
return "send";
|
|
case "trash":
|
|
return "trash";
|
|
case "junk":
|
|
return "alert";
|
|
case "archive":
|
|
return "archive";
|
|
case "all":
|
|
return "mail";
|
|
case "flagged":
|
|
return "star";
|
|
case "important":
|
|
return "tag";
|
|
default:
|
|
return "folder";
|
|
}
|
|
}
|
|
|
|
export const ROLE_ORDER: Record<string, number> = { inbox: 0, flagged: 1, important: 2, drafts: 3, sent: 4, archive: 5, all: 6, junk: 7, trash: 8 };
|
|
|
|
/**
|
|
* Resolve `parentId/segments...` to a mailbox id, creating what is missing.
|
|
*
|
|
* Reuses a folder that is already there rather than making a second one beside
|
|
* it, so archiving by month twice in the same month files into the same place
|
|
* -- including a folder somebody made by hand, or one another client made
|
|
* first, which is the usual way `Archive/2026` already exists.
|
|
*
|
|
* Sequential on purpose: each level is the next level's parent, and
|
|
* `createMailbox` reloads the tree, so the lookup for `09` can see the `2026`
|
|
* that was just created.
|
|
*/
|
|
async function ensureFolderPath(state: () => MailState, parentId: Id, segments: string[]): Promise<Id> {
|
|
let current = parentId;
|
|
for (const name of segments) {
|
|
const existing = Object.values(state().mailboxes).find((m) => m.parentId === current && m.name === name);
|
|
current = existing ? existing.id : await state().createMailbox(name, current);
|
|
}
|
|
return current;
|
|
}
|
|
|
|
/**
|
|
* A folder and everything under it, with the paths they have right now.
|
|
*
|
|
* Taken before a rename or a move, because renaming a parent silently rewrites
|
|
* the path of every folder beneath it, and the rules filing into those children
|
|
* name the old path just as much as the rules filing into the folder itself.
|
|
*/
|
|
function folderRefs(state: MailState, id: Id): FolderRef[] {
|
|
const all = Object.values(state.mailboxes);
|
|
const ids = new Set<Id>([id]);
|
|
// Walk down as far as the tree goes; depth is small and bounded by the server.
|
|
for (let pass = 0; pass < 20; pass++) {
|
|
const before = ids.size;
|
|
for (const m of all) if (m.parentId && ids.has(m.parentId)) ids.add(m.id);
|
|
if (ids.size === before) break;
|
|
}
|
|
return [...ids].map((i) => ({ id: i, path: state.mailboxPath(i) }));
|
|
}
|
|
|
|
/**
|
|
* Keeps the Sieve rules pointing at the folders they were aimed at.
|
|
*
|
|
* Called after the mailbox list has reloaded: anything in `before` that still
|
|
* exists has its rules retargeted to the new path, and anything that has gone
|
|
* takes its rules with it. Rules are server-side and invisible from here, so
|
|
* both outcomes are reported rather than done quietly.
|
|
*
|
|
* Deliberately never throws. The folder operation has already succeeded by this
|
|
* point, and failing to tidy the rules must not make it look otherwise.
|
|
*/
|
|
async function followFolders(before: FolderRef[]): Promise<void> {
|
|
try {
|
|
const { useSieve } = await import("./sieve");
|
|
const sieve = useSieve.getState();
|
|
if (!sieve.available) return;
|
|
if (!sieve.scripts.length) await sieve.load();
|
|
// Only the script the rule editor manages can be rewritten safely; a
|
|
// hand-written one is nobody's business but its author's.
|
|
const { rules } = useSieve.getState().rules();
|
|
if (!rules?.length) return;
|
|
|
|
const state = useMail.getState();
|
|
const moves: Array<FolderRef & { newPath: string }> = [];
|
|
const gone: FolderRef[] = [];
|
|
for (const ref of before) {
|
|
if (state.mailboxes[ref.id]) moves.push({ ...ref, newPath: state.mailboxPath(ref.id) });
|
|
else gone.push(ref);
|
|
}
|
|
|
|
const { retargetRules, detachFolders } = await import("@/lib/sieveFolders");
|
|
const retargeted = retargetRules(rules, moves);
|
|
const detached = detachFolders(retargeted.rules, gone);
|
|
if (!retargeted.changed && !detached.edited.length && !detached.removed.length) return;
|
|
|
|
await useSieve.getState().saveRules(detached.rules);
|
|
const { toast } = await import("@/ui/toast");
|
|
const plural = (n: number) => (n === 1 ? "" : "s");
|
|
const said: string[] = [];
|
|
if (retargeted.changed) said.push(`${retargeted.changed} filter rule${plural(retargeted.changed)} updated`);
|
|
if (detached.edited.length) said.push(`${detached.edited.length} filter rule${plural(detached.edited.length)} no longer file${detached.edited.length === 1 ? "s" : ""} there`);
|
|
if (detached.removed.length) said.push(`${detached.removed.length} filter rule${plural(detached.removed.length)} removed, having nothing left to do: ${detached.removed.map((r) => `“${r.name}”`).join(", ")}`);
|
|
toast.show(said.join(" · "), { duration: 8000 });
|
|
} catch (err) {
|
|
const { toast } = await import("@/ui/toast");
|
|
toast.error(t("Folder changed, but its filter rules could not be updated: {error}", { error: (err as Error).message }));
|
|
}
|
|
}
|