@dxv-systems/helpdesk 0.0.0-stage → 0.1.0

package/dist/reply-attachments.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_REPLY_ATTACHMENTS = exports.MAX_REPLY_ATTACHMENT_BYTES = void 0;
+exports.pendingReplyAttachments = pendingReplyAttachments;
+exports.startReplyUpload = startReplyUpload;
+exports.addReplyAttachment = addReplyAttachment;
+exports.removeReplyAttachment = removeReplyAttachment;
+exports.placeReplyAttachments = placeReplyAttachments;
+exports.markReplyAttachmentsSent = markReplyAttachmentsSent;
+exports.discardPendingReplyAttachments = discardPendingReplyAttachments;
+const errors_1 = require("./errors");
+const internal_1 = require("./internal");
+const states_1 = require("./states");
+exports.MAX_REPLY_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+exports.MAX_REPLY_ATTACHMENTS = 10;
+function attachmentsOf(deps) {
+    if (!deps.attachments)
+        throw new errors_1.AttachmentsUnavailableError();
+    return deps.attachments;
+}
+async function pendingReplyAttachments(deps, threadId) {
+    if (!deps.attachments)
+        return [];
+    return (await deps.attachments.store.listForThread(threadId)).filter((a) => a.sentIntentId === null);
+}
+function assertAttachable(thread) {
+    if (!(0, states_1.canTransition)(thread.state, "approve") || thread.reviewReason === "delivery_failed") {
+        throw new errors_1.AttachmentsUnavailableError();
+    }
+}
+function assertWithinLimits(pending, size) {
+    if (pending.length >= exports.MAX_REPLY_ATTACHMENTS)
+        throw new errors_1.AttachmentLimitError("count");
+    const total = pending.reduce((sum, a) => sum + a.size, 0);
+    if (size <= 0 || size > exports.MAX_REPLY_ATTACHMENT_BYTES || total + size > exports.MAX_REPLY_ATTACHMENT_BYTES) {
+        throw new errors_1.AttachmentLimitError("size");
+    }
+}
+async function startReplyUpload(deps, input) {
+    const { files } = attachmentsOf(deps);
+    assertAttachable(await (0, internal_1.loadThread)(deps, input.threadId));
+    assertWithinLimits(await pendingReplyAttachments(deps, input.threadId), input.size);
+    return files.createUpload({ staffId: input.staffId, name: input.name, contentType: input.contentType, size: input.size });
+}
+async function addReplyAttachment(deps, input) {
+    const { files, store } = attachmentsOf(deps);
+    const thread = await (0, internal_1.loadThread)(deps, input.threadId);
+    assertAttachable(thread);
+    const file = await files.completeUpload({ staffId: input.staffId, uploadToken: input.uploadToken });
+    try {
+        assertWithinLimits(await pendingReplyAttachments(deps, thread.id), file.size);
+    }
+    catch (err) {
+        await files.remove({ fileId: file.fileId, staffId: input.staffId }).catch(() => undefined);
+        throw err;
+    }
+    const attachment = {
+        id: (0, internal_1.newId)(deps),
+        threadId: thread.id,
+        mailbox: thread.mailbox,
+        fileId: file.fileId,
+        name: file.name,
+        contentType: file.contentType,
+        size: file.size,
+        addedBy: input.staffId,
+        createdAt: (0, internal_1.nowIso)(deps),
+        placedDraftId: null,
+        sentIntentId: null,
+    };
+    await store.add(attachment);
+    return attachment;
+}
+async function removeReplyAttachment(deps, input) {
+    const { files, store } = attachmentsOf(deps);
+    const own = (await store.listForThread(input.threadId)).find((a) => a.id === input.attachmentId);
+    if (!own)
+        throw new errors_1.ReplyAttachmentNotFoundError(input.attachmentId);
+    const removed = await store.removeUnsent(own.id);
+    if (!removed)
+        throw new errors_1.ReplyAttachmentNotFoundError(input.attachmentId);
+    await files.remove({ fileId: removed.fileId, staffId: removed.addedBy }).catch(() => undefined);
+}
+async function placeReplyAttachments(deps, access, threadId, draftId) {
+    const pending = await pendingReplyAttachments(deps, threadId);
+    if (pending.length === 0)
+        return;
+    const { files, store } = attachmentsOf(deps);
+    const gateway = access.gateway();
+    if (!gateway.addAttachment)
+        throw new errors_1.AttachmentsUnavailableError();
+    for (const a of pending) {
+        if (a.placedDraftId === draftId)
+            continue;
+        const content = await files.read({ fileId: a.fileId, staffId: a.addedBy });
+        await gateway.addAttachment(draftId, { name: a.name, contentType: a.contentType, content });
+        await store.update(a.id, { placedDraftId: draftId });
+    }
+}
+async function markReplyAttachmentsSent(deps, threadId, draftId, intentId) {
+    if (!deps.attachments || !draftId)
+        return;
+    for (const a of await pendingReplyAttachments(deps, threadId)) {
+        if (a.placedDraftId === draftId)
+            await deps.attachments.store.update(a.id, { sentIntentId: intentId });
+    }
+}
+async function discardPendingReplyAttachments(deps, threadId) {
+    if (!deps.attachments)
+        return;
+    try {
+        for (const a of await pendingReplyAttachments(deps, threadId)) {
+            const removed = await deps.attachments.store.removeUnsent(a.id);
+            if (removed)
+                await deps.attachments.files.remove({ fileId: removed.fileId, staffId: removed.addedBy }).catch(() => undefined);
+        }
+    }
+    catch {
+    }
+}

package/dist/sending.d.ts

@@ -0,0 +1,33 @@
+import type { HelpdeskDeps, Paused, SendIntent, Thread, WriteBlocked } from "./types";
+export declare function classifySendError(err: unknown): "not_sent" | "unknown";
+export type SendOutcome = {
+    status: "sent";
+    thread: Thread;
+} | {
+    status: "already_sent";
+} | {
+    status: "in_progress";
+} | {
+    status: "unknown_outcome";
+    intent: SendIntent;
+} | {
+    status: "failed_not_sent";
+    error: string;
+} | Paused | WriteBlocked;
+export declare function approveAndSend(deps: HelpdeskDeps, input: {
+    threadId: string;
+    approvedBy: string;
+    acceptStale?: boolean;
+}): Promise<SendOutcome>;
+export declare function reconcileUnknownSends(deps: HelpdeskDeps, mailbox: string): Promise<number>;
+export declare function resolveUnknownSend(deps: HelpdeskDeps, input: {
+    threadId: string;
+    outcome: "sent" | "not_sent";
+}): Promise<SendIntent>;
+export declare function markRepliedExternally(deps: HelpdeskDeps, threadId: string): Promise<Thread | Paused>;
+export declare function dismissThread(deps: HelpdeskDeps, input: {
+    threadId: string;
+    dismissedBy: string;
+}): Promise<Thread | Paused>;
+export declare function markWaiting(deps: HelpdeskDeps, threadId: string): Promise<Thread>;
+export declare function closeThread(deps: HelpdeskDeps, threadId: string): Promise<Thread>;

package/dist/sending.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifySendError = classifySendError;
+exports.approveAndSend = approveAndSend;
+exports.reconcileUnknownSends = reconcileUnknownSends;
+exports.resolveUnknownSend = resolveUnknownSend;
+exports.markRepliedExternally = markRepliedExternally;
+exports.dismissThread = dismissThread;
+exports.markWaiting = markWaiting;
+exports.closeThread = closeThread;
+const cleanup_1 = require("./cleanup");
+const controls_1 = require("./controls");
+const draft_body_1 = require("./draft-body");
+const errors_1 = require("./errors");
+const drafting_1 = require("./drafting");
+const internal_1 = require("./internal");
+const reply_attachments_1 = require("./reply-attachments");
+const states_1 = require("./states");
+const NOT_SENT_STATUSES = new Set([400, 401, 403, 429]);
+function classifySendError(err) {
+    const status = err?.status;
+    return typeof status === "number" && NOT_SENT_STATUSES.has(status) ? "not_sent" : "unknown";
+}
+const SEND_IN_FLIGHT_MS = 2 * 60 * 1000;
+async function markSent(deps, thread, intent) {
+    const fresh = await (0, internal_1.loadThread)(deps, thread.id);
+    const sent = await deps.store.transitionSendIntent(intent.id, ["sending", "unknown"], {
+        status: "sent",
+        updatedAt: (0, internal_1.nowIso)(deps),
+        error: null,
+    });
+    if (!sent)
+        return fresh;
+    if (fresh.state !== "review")
+        return fresh;
+    return (0, internal_1.applyEvents)(deps, fresh, ["approve"], { reviewReason: null });
+}
+async function surfaceUnknown(deps, thread, intent) {
+    const unknown = (await deps.store.transitionSendIntent(intent.id, ["sending", "unknown"], {
+        status: "unknown",
+        updatedAt: (0, internal_1.nowIso)(deps),
+    })) ?? intent;
+    await (0, internal_1.notify)(deps, {
+        type: "send_outcome_unknown",
+        threadId: thread.id,
+        mailbox: thread.mailbox,
+        subject: thread.subject,
+        draftId: intent.draftId,
+    });
+    return { status: "unknown_outcome", intent: unknown };
+}
+async function sendingElsewhereOrLost(deps, thread, intent) {
+    if (intent.status === "sent")
+        return { status: "already_sent" };
+    const age = deps.clock.now().getTime() - Date.parse(intent.updatedAt);
+    if (intent.status !== "unknown" && (intent.status !== "sending" || age < SEND_IN_FLIGHT_MS)) {
+        return { status: "in_progress" };
+    }
+    return surfaceUnknown(deps, thread, intent);
+}
+async function prepareAppDraft(deps, access, run, intent) {
+    const gateway = access.gateway();
+    let current = run;
+    if (!intent.draftId || run.placedDraftId !== intent.draftId || run.placedBodyHtml === null) {
+        const draft = await gateway.createReply(run.inboundMessageId);
+        current = await deps.store.updateDraftRun(run.idempotencyKey, {
+            placedDraftId: draft.id,
+            placedBodyHtml: draft.body.content,
+            placementError: null,
+        });
+        await deps.store.transitionSendIntent(intent.id, ["sending"], { draftId: draft.id });
+    }
+    const draftId = current.placedDraftId;
+    const text = current.commentText ?? current.text ?? "";
+    const body = (0, draft_body_1.prependToDraftBody)(current.placedBodyHtml, text);
+    await gateway.updateDraftBody(draftId, { contentType: "html", content: body });
+    return draftId;
+}
+async function approveAndSend(deps, input) {
+    const controls = await (0, controls_1.loadControls)(deps);
+    if (controls.paused)
+        return (0, controls_1.paused)();
+    const thread = await (0, internal_1.loadThread)(deps, input.threadId);
+    const access = (0, controls_1.mailboxAccess)(deps, controls, thread.mailbox);
+    if (access.mode === "read_only")
+        return { status: "write_blocked", mode: access.mode };
+    const inApp = access.mode === "drafts_in_app";
+    const run = (0, drafting_1.currentReplyRun)(deps, thread, await deps.store.getLatestDraftRunForThread(thread.id));
+    if (!run || (inApp ? run.status !== "succeeded" : !run.placedDraftId)) {
+        throw new errors_1.DraftNotReadyError(thread.id, inApp ? "no approved draft text" : "no placed draft");
+    }
+    const ids = (0, cleanup_1.sendIntentIds)(run);
+    for (const id of [ids.perRun, ids.perDraft]) {
+        const prior = id ? await deps.store.getSendIntent(id) : null;
+        if (prior?.status === "sent")
+            return { status: "already_sent" };
+        if (prior?.status === "unknown")
+            return surfaceUnknown(deps, thread, prior);
+        if (prior?.status === "sending")
+            return sendingElsewhereOrLost(deps, thread, prior);
+    }
+    (0, states_1.transition)(thread.state, "approve");
+    if ((run.commentText ?? run.text ?? "").trim() === "")
+        throw new errors_1.EmptyReplyError(thread.id);
+    if (thread.latestInboundId !== run.inboundMessageId && !input.acceptStale) {
+        throw new errors_1.StaleDraftError(thread.id);
+    }
+    const now = (0, internal_1.nowIso)(deps);
+    const { intent } = await deps.store.createSendIntentIfAbsent({
+        id: inApp ? ids.perRun : ids.perDraft,
+        mailbox: thread.mailbox,
+        threadId: thread.id,
+        draftId: inApp ? null : run.placedDraftId,
+        approvedBy: input.approvedBy,
+        status: "intended",
+        createdAt: now,
+        updatedAt: now,
+        error: null,
+    });
+    if (intent.status === "sent")
+        return { status: "already_sent" };
+    const claimed = await deps.store.transitionSendIntent(intent.id, ["intended", "failed"], {
+        status: "sending",
+        updatedAt: now,
+        error: null,
+    });
+    if (!claimed) {
+        const current = (await deps.store.getSendIntent(intent.id)) ?? intent;
+        if (current.status === "sent")
+            return { status: "already_sent" };
+        return sendingElsewhereOrLost(deps, thread, current);
+    }
+    if ((await (0, internal_1.loadThread)(deps, thread.id)).state !== "review") {
+        await failNotSent(deps, intent.id, new Error("ticket changed before sending"));
+        throw new errors_1.StaleThreadError(thread.id);
+    }
+    let draftId = run.placedDraftId;
+    try {
+        if (inApp)
+            draftId = await prepareAppDraft(deps, access, run, claimed);
+        await (0, reply_attachments_1.placeReplyAttachments)(deps, access, thread.id, draftId);
+    }
+    catch (err) {
+        return failNotSent(deps, intent.id, err);
+    }
+    try {
+        await access.gateway().sendDraft(draftId);
+    }
+    catch (err) {
+        if (classifySendError(err) === "unknown") {
+            return surfaceUnknown(deps, thread, { ...claimed, draftId });
+        }
+        return failNotSent(deps, intent.id, err);
+    }
+    await (0, reply_attachments_1.markReplyAttachmentsSent)(deps, thread.id, draftId, intent.id).catch(() => undefined);
+    return { status: "sent", thread: await markSent(deps, thread, claimed) };
+}
+async function failNotSent(deps, intentId, err) {
+    await deps.store.transitionSendIntent(intentId, ["sending"], {
+        status: "failed",
+        updatedAt: (0, internal_1.nowIso)(deps),
+        error: (0, internal_1.errorText)(err),
+    });
+    return { status: "failed_not_sent", error: (0, internal_1.errorText)(err) };
+}
+async function reconcileUnknownSends(deps, mailbox) {
+    if (!deps.store.listSendIntentsByStatus)
+        return 0;
+    const controls = await (0, controls_1.loadControls)(deps);
+    if (controls.paused)
+        return 0;
+    const gateway = (0, controls_1.mailboxAccess)(deps, controls, mailbox).gateway();
+    const unknown = await deps.store.listSendIntentsByStatus(mailbox, "unknown");
+    let resolved = 0;
+    for (const intent of unknown) {
+        if (!intent.draftId)
+            continue;
+        const age = deps.clock.now().getTime() - Date.parse(intent.updatedAt);
+        if (age < SEND_IN_FLIGHT_MS)
+            continue;
+        let draft;
+        try {
+            draft = await gateway.getMessage(intent.draftId);
+        }
+        catch {
+            return resolved;
+        }
+        if (draft?.isDraft !== true)
+            continue;
+        const reset = await deps.store.transitionSendIntent(intent.id, ["unknown"], {
+            status: "failed",
+            updatedAt: (0, internal_1.nowIso)(deps),
+            error: "not sent: the draft was still in Drafts",
+        });
+        if (reset)
+            resolved++;
+    }
+    return resolved;
+}
+async function resolveUnknownSend(deps, input) {
+    const thread = await (0, internal_1.loadThread)(deps, input.threadId);
+    const run = await deps.store.getLatestDraftRunForThread(thread.id);
+    if (!run)
+        throw new errors_1.DraftNotReadyError(thread.id, "no draft run");
+    const ids = (0, cleanup_1.sendIntentIds)(run);
+    let current = null;
+    for (const id of [ids.perRun, ids.perDraft]) {
+        const found = id ? await deps.store.getSendIntent(id) : null;
+        if (found?.status === "unknown")
+            current = found;
+    }
+    if (!current)
+        throw new errors_1.DraftNotReadyError(thread.id, "no unknown send to resolve");
+    const id = current.id;
+    if (input.outcome === "not_sent") {
+        const reset = await deps.store.transitionSendIntent(id, ["unknown"], {
+            status: "failed",
+            updatedAt: (0, internal_1.nowIso)(deps),
+            error: "confirmed not sent by staff",
+        });
+        return reset ?? current;
+    }
+    await (0, reply_attachments_1.markReplyAttachmentsSent)(deps, thread.id, current.draftId, id).catch(() => undefined);
+    await markSent(deps, thread, current);
+    return (await deps.store.getSendIntent(id)) ?? current;
+}
+async function markRepliedExternally(deps, threadId) {
+    const controls = await (0, controls_1.loadControls)(deps);
+    if (controls.paused)
+        return (0, controls_1.paused)();
+    const thread = await (0, internal_1.loadThread)(deps, threadId);
+    const access = (0, controls_1.mailboxAccess)(deps, controls, thread.mailbox);
+    const updated = await (0, internal_1.applyEvents)(deps, thread, ["approve"], { reviewReason: null });
+    await (0, reply_attachments_1.discardPendingReplyAttachments)(deps, thread.id);
+    const run = await deps.store.getLatestDraftRunForThread(thread.id).catch(() => null);
+    if (run)
+        await (0, cleanup_1.discardPlacedDraft)(deps, run, access, thread.id);
+    return updated;
+}
+async function dismissThread(deps, input) {
+    const controls = await (0, controls_1.loadControls)(deps);
+    if (controls.paused)
+        return (0, controls_1.paused)();
+    const thread = await (0, internal_1.loadThread)(deps, input.threadId);
+    const access = (0, controls_1.mailboxAccess)(deps, controls, thread.mailbox);
+    (0, states_1.transition)(thread.state, "dismiss");
+    const run = await deps.store.getLatestDraftRunForThread(thread.id);
+    for (const id of run ? Object.values((0, cleanup_1.sendIntentIds)(run)) : []) {
+        const intent = id ? await deps.store.getSendIntent(id) : null;
+        if (intent?.status === "sending") {
+            const seen = await sendingElsewhereOrLost(deps, thread, intent);
+            throw new errors_1.SendPendingError(thread.id, seen.status === "unknown_outcome" ? "unknown" : "sending");
+        }
+        if (intent?.status === "unknown")
+            throw new errors_1.SendPendingError(thread.id, "unknown");
+    }
+    const updated = await (0, internal_1.applyEvents)(deps, thread, ["dismiss"], {
+        reviewReason: null,
+        dismissedBy: input.dismissedBy,
+    });
+    await stopDrafting(deps, access, thread.id);
+    await (0, reply_attachments_1.discardPendingReplyAttachments)(deps, thread.id);
+    return updated;
+}
+async function stopDrafting(deps, access, threadId) {
+    try {
+        let latest = await deps.store.getLatestDraftRunForThread(threadId);
+        if (!latest)
+            return;
+        if (latest.status === "requested" || latest.status === "started") {
+            latest = await deps.store.updateDraftRun(latest.idempotencyKey, {
+                status: "failed",
+                error: "stopped: staff marked the ticket as needing no reply",
+            });
+        }
+        const previous = latest.generation > 1
+            ? await deps.store.getDraftRunGeneration(latest.mailbox, latest.inboundMessageId, latest.generation - 1)
+            : null;
+        for (const run of previous ? [latest, previous] : [latest]) {
+            await (0, cleanup_1.discardPlacedDraft)(deps, run, access, threadId);
+        }
+    }
+    catch {
+    }
+}
+async function markWaiting(deps, threadId) {
+    return (0, internal_1.applyEvents)(deps, await (0, internal_1.loadThread)(deps, threadId), ["settle"]);
+}
+async function closeThread(deps, threadId) {
+    return (0, internal_1.applyEvents)(deps, await (0, internal_1.loadThread)(deps, threadId), ["close"]);
+}

package/dist/server.d.ts

@@ -0,0 +1,6 @@
+export { createHelpdeskHandlers } from "./inbox/handlers";
+export type { HelpdeskHandlers, HelpdeskHandlersConfig, HelpdeskInboxQueries, InboxThreadQuery, } from "./inbox/handlers";
+export { HELPDESK_BASE_PATH, INBOX_ERROR_MESSAGES } from "./inbox/messages";
+export type { InboxErrorCode } from "./inbox/messages";
+export { htmlToPlainText } from "./inbox/plain-text";
+export type * from "./inbox/types";

package/dist/server.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.htmlToPlainText = exports.INBOX_ERROR_MESSAGES = exports.HELPDESK_BASE_PATH = exports.createHelpdeskHandlers = void 0;
+var handlers_1 = require("./inbox/handlers");
+Object.defineProperty(exports, "createHelpdeskHandlers", { enumerable: true, get: function () { return handlers_1.createHelpdeskHandlers; } });
+var messages_1 = require("./inbox/messages");
+Object.defineProperty(exports, "HELPDESK_BASE_PATH", { enumerable: true, get: function () { return messages_1.HELPDESK_BASE_PATH; } });
+Object.defineProperty(exports, "INBOX_ERROR_MESSAGES", { enumerable: true, get: function () { return messages_1.INBOX_ERROR_MESSAGES; } });
+var plain_text_1 = require("./inbox/plain-text");
+Object.defineProperty(exports, "htmlToPlainText", { enumerable: true, get: function () { return plain_text_1.htmlToPlainText; } });

package/dist/states.d.ts

@@ -0,0 +1,13 @@
+import type { TicketState } from "./types";
+export declare const TICKET_STATES: readonly TicketState[];
+export type TicketEvent = "ignore" | "draft" | "needs_review" | "auto_send" | "approve" | "redraft" | "settle" | "customer_reply" | "close" | "unignore" | "dismiss" | "bounce";
+export declare const TICKET_EVENTS: readonly TicketEvent[];
+export declare function transition(from: TicketState, event: TicketEvent): TicketState;
+export declare function canTransition(from: TicketState, event: TicketEvent): boolean;
+export type ReplyOutcome = {
+    kind: "append";
+    next: TicketState;
+} | {
+    kind: "new_thread";
+};
+export declare function onCustomerReply(state: TicketState): ReplyOutcome;

package/dist/states.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TICKET_EVENTS = exports.TICKET_STATES = void 0;
+exports.transition = transition;
+exports.canTransition = canTransition;
+exports.onCustomerReply = onCustomerReply;
+const errors_1 = require("./errors");
+exports.TICKET_STATES = [
+    "new",
+    "ignored",
+    "drafted",
+    "review",
+    "sent",
+    "waiting",
+    "closed",
+];
+exports.TICKET_EVENTS = [
+    "ignore",
+    "draft",
+    "needs_review",
+    "auto_send",
+    "approve",
+    "redraft",
+    "settle",
+    "customer_reply",
+    "close",
+    "unignore",
+    "dismiss",
+    "bounce",
+];
+const TABLE = {
+    new: { ignore: "ignored", draft: "drafted", dismiss: "ignored" },
+    ignored: { unignore: "new" },
+    drafted: { needs_review: "review", auto_send: "sent", dismiss: "ignored" },
+    review: { approve: "sent", redraft: "drafted", dismiss: "ignored" },
+    sent: { settle: "waiting", bounce: "review" },
+    waiting: { customer_reply: "new", close: "closed", bounce: "review" },
+    closed: {},
+};
+function transition(from, event) {
+    const to = TABLE[from][event];
+    if (!to)
+        throw new errors_1.InvalidTransitionError(from, event);
+    return to;
+}
+function canTransition(from, event) {
+    return TABLE[from][event] !== undefined;
+}
+function onCustomerReply(state) {
+    switch (state) {
+        case "new":
+        case "drafted":
+        case "review":
+            return { kind: "append", next: state };
+        case "sent":
+            return { kind: "append", next: transition(transition("sent", "settle"), "customer_reply") };
+        case "waiting":
+            return { kind: "append", next: transition("waiting", "customer_reply") };
+        case "ignored":
+        case "closed":
+            return { kind: "new_thread" };
+    }
+}

package/dist/subject.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeSubject(subject: string | undefined | null): string;
+export declare function isForwardSubject(subject: string | undefined | null): boolean;

package/dist/subject.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSubject = normalizeSubject;
+exports.isForwardSubject = isForwardSubject;
+const GATEWAY_TAG = /^\s*\[(?:extern(?:al)?|external email|ext|caution)[^\]]*\]\s*/i;
+const PREFIX = /^\s*(re|aw|antw|antwoord|sv|vs|fw|fwd|wg|tr|rv|enc|vl|doorgestuurd)\s*(?:\[\d+\]|\(\d+\))?\s*[:：]\s*/i;
+const FORWARD_TOKENS = new Set(["fw", "fwd", "wg", "tr", "rv", "enc", "vl", "doorgestuurd"]);
+function peel(subject) {
+    let rest = subject.normalize("NFKC");
+    const prefixes = [];
+    for (let i = 0; i < 20; i++) {
+        const tag = GATEWAY_TAG.exec(rest);
+        if (tag) {
+            rest = rest.slice(tag[0].length);
+            continue;
+        }
+        const p = PREFIX.exec(rest);
+        if (!p)
+            break;
+        prefixes.push((p[1] ?? "").toLowerCase());
+        rest = rest.slice(p[0].length);
+    }
+    return { rest, prefixes };
+}
+function normalizeSubject(subject) {
+    return peel(subject ?? "").rest.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function isForwardSubject(subject) {
+    return peel(subject ?? "").prefixes.some((p) => FORWARD_TOKENS.has(p));
+}

package/dist/testing/index.d.ts

@@ -0,0 +1,99 @@
+import type { AttachmentKind, Clock, DeltaOptions, DraftRequest, DraftRun, Drafter, HelpdeskConfig, HelpdeskControls, HelpdeskDeps, HelpdeskStore, MailboxGateway, Message, ReplyAttachment, ReplyAttachmentStore, ReplyFiles, SendIntent, StoredMessage, SyncState, Thread } from "../types";
+export interface ManualClock extends Clock {
+    advance(ms: number): void;
+    set(iso: string): void;
+}
+export declare function createManualClock(startIso?: string): ManualClock;
+export interface MemoryStore extends HelpdeskStore {
+    threads: Map<string, Thread>;
+    messages: Map<string, StoredMessage>;
+    draftRuns: DraftRun[];
+    sendIntents: Map<string, SendIntent>;
+    syncStates: Map<string, SyncState>;
+}
+export declare function createMemoryStore(): MemoryStore;
+export interface FakeMail {
+    id: string;
+    from?: string;
+    subject?: string;
+    conversationId?: string;
+    internetMessageId?: string;
+    inReplyTo?: string;
+    references?: string[];
+    replyTo?: string[];
+    receivedDateTime?: string;
+    headers?: Record<string, string>;
+    isDraft?: boolean;
+    bodyText?: string;
+    attachments?: FakeAttachment[];
+}
+export interface FakeAttachment {
+    id: string;
+    name: string;
+    contentType?: string;
+    isInline?: boolean;
+    kind?: AttachmentKind;
+    content?: Uint8Array;
+    size?: number;
+}
+export type SendBehaviour = {
+    kind: "ok";
+} | {
+    kind: "reject";
+    error: Error;
+} | {
+    kind: "lost_response";
+    error: Error;
+};
+export interface FakeMailbox extends MailboxGateway {
+    deliver(mail: FakeMail): void;
+    touch(id: string): void;
+    remove(id: string, reason?: string): void;
+    expireLinks(): void;
+    sendBehaviour: SendBehaviour;
+    sent: string[];
+    drafts: Map<string, Message>;
+    deleteCalls: string[];
+    draftAttachments: Map<string, Array<{
+        name: string;
+        contentType: string;
+        size: number;
+    }>>;
+    addAttachmentError: Error | null;
+    deleteError: Error | null;
+    outage: Error | null;
+    getMessageCalls: number;
+    deltaCalls: DeltaOptions[];
+    calls: string[];
+    readonly writeCalls: string[];
+}
+export declare function createFakeMailbox(address: string): FakeMailbox;
+export interface FakeDrafter extends Drafter {
+    requests: DraftRequest[];
+    runs: Map<string, string>;
+    failStart: Error | null;
+}
+export declare function createFakeDrafter(): FakeDrafter;
+export interface MemoryReplyAttachments {
+    store: ReplyAttachmentStore & {
+        rows: Map<string, ReplyAttachment>;
+    };
+    files: ReplyFiles & {
+        upload(uploadToken: string, content: Uint8Array): void;
+        stored: Map<string, Uint8Array>;
+        removed: string[];
+    };
+}
+export declare function createMemoryReplyAttachments(): MemoryReplyAttachments;
+export interface TestWorld {
+    deps: HelpdeskDeps;
+    store: MemoryStore;
+    clock: ManualClock;
+    drafter: FakeDrafter;
+    mailboxes: Record<string, FakeMailbox>;
+}
+export declare function createTestWorld(options?: {
+    mailboxes?: string[];
+    config?: Partial<HelpdeskConfig>;
+    controls?: HelpdeskControls;
+}): TestWorld;