@remit/web-client 0.0.325 → 0.0.327

package/src/lib/organize/organize-model.ts

@@ -1,198 +0,0 @@
-import type {
-	RemitImapCreateFilterInput,
-	RemitImapFilterClause,
-	RemitImapFilterMatchOperator,
-	RemitImapFilterScope,
-	RemitImapOrganizeInput,
-} from "@remit/api-http-client/types.gen.ts";
-import type {
-	MatchDoor,
-	MatchOperator,
-	RuleClause,
-	RuleScope,
-} from "@remit/ui";
-import { pickedDateToExpiresAt } from "./filter-status";
-
-/**
- * The four commit scopes the smart-organize sentence offers (RFC 034 recap):
- *
- * - `just-these` — a one-time action on the current selection. Existing
- *   message-action API, nothing persisted.
- * - `all-like-these` — a one-time retroactive back-apply across the matching
- *   corpus (POST /organize job). Nothing standing persisted.
- * - `standing` — "these and new mail like this": a permanent `Filter`.
- * - `temporary` — "until <date>": a `Filter` that expires on its own.
- */
-export type OrganizeScope =
-	| "just-these"
-	| "all-like-these"
-	| "standing"
-	| "temporary";
-
-/** The `"None"` sentinel the API uses for an absent label / move action. */
-export const NO_ACTION = "None";
-
-/**
- * The predicate a preview counts and a commit acts on: the operator and the
- * literal clauses. The set it previews equals the set every commit scope acts on.
- */
-export type OrganizeMatchPredicate = Pick<
-	RemitImapOrganizeInput,
-	"matchOperator" | "literalClauses"
->;
-
-/**
- * The user's in-progress organize decision, independent of which scope they
- * land on. The predicate drives the match set; `moveMailboxId` and
- * `labelId` are the two committable actions (issue #26) — independent of each
- * other, since a move is exclusive and a label is additive (RFC 034 Decision
- * 3.1).
- */
-export interface OrganizeDraft {
-	/** How `literalClauses` combine. Ignored when there are none. */
-	matchOperator: RemitImapFilterMatchOperator;
-	/** Literal from/subject/has-words clauses (RFC 031). */
-	literalClauses: RemitImapFilterClause[];
-	/**
-	 * Destination the match set is moved into — the exclusive action (RFC 034
-	 * Decision 3.1). Absent means "keep where they are": no move action.
-	 */
-	moveMailboxId?: string;
-	/**
-	 * Label applied to the match set — the additive action (RFC 034 Decision
-	 * 3.1, issue #26). Absent applies no label.
-	 */
-	labelId?: string;
-	/**
-	 * ISO 8601 date-time with zone offset. Present only for the `temporary`
-	 * scope; a plain picked date (RFC 034 non-goal: no event-based expiry).
-	 */
-	expiresAt?: string;
-}
-
-/**
- * Whether the draft carries a committable action — a move destination and/or
- * a label (issue #26), either satisfies this. A draft with neither has
- * nothing to commit; the caller disables the CTA and says why (ux.md).
- */
-export const hasCommittableAction = (draft: OrganizeDraft): boolean =>
-	(draft.moveMailboxId !== undefined && draft.moveMailboxId !== NO_ACTION) ||
-	(draft.labelId !== undefined && draft.labelId !== NO_ACTION);
-
-/**
- * Ask for a saved filter's pass over the inbox. The server reads the filter's
- * own rule and action when the job runs and ignores the predicate fields,
- * which the request shape still requires.
- */
-export const buildRunFilterInput = (
-	filterId: string,
-): RemitImapOrganizeInput => ({
-	filterId,
-	matchOperator: "And",
-	literalClauses: [],
-	actionLabelId: NO_ACTION,
-	actionMailboxId: NO_ACTION,
-});
-
-/**
- * Build the read-only preview / back-apply matcher input. The action fields do
- * not affect which messages match — the preview returns exactly the set a job
- * with the same predicate would apply to — so a preview can pass this before
- * the user has chosen a folder or a label.
- */
-export const buildOrganizeInput = (
-	draft: OrganizeDraft,
-): RemitImapOrganizeInput => ({
-	matchOperator: draft.matchOperator,
-	literalClauses: draft.literalClauses,
-	actionLabelId: draft.labelId ?? NO_ACTION,
-	actionMailboxId: draft.moveMailboxId ?? NO_ACTION,
-});
-
-/**
- * The two independent answers the wizard collects (#477 4.6). Neither is a
- * scope: the door says what the action covers and the scope step says how long
- * it holds, and the four `OrganizeScope` values fall out of the pair.
- */
-export interface WizardCommitAnswers {
-	/**
-	 * The door the match came through. An escalated predicate is not one: it has
-	 * no clauses to build a rule from, so a scope reconstructed for it would be a
-	 * rule matching everything. Typed to the doors so that cannot be written
-	 * rather than merely not written.
-	 */
-	mode: MatchDoor;
-	/** Absent on the verbs that never reach the scope step — those act once. */
-	ruleScope?: RuleScope;
-}
-
-/**
- * Which of the four commit scopes the wizard's answers add up to. Reconstructed
- * here and nowhere else, so a driver cannot invent a fifth: the ticked list at
- * scope once is `just-these`, the properties door at scope once is `all-like-these`,
- * and the two persisting scopes are `standing` and `temporary`.
- */
-export const organizeScopeFor = ({
-	mode,
-	ruleScope,
-}: WizardCommitAnswers): OrganizeScope => {
-	if (ruleScope === "standing") return "standing";
-	if (ruleScope === "until") return "temporary";
-	return mode === "selected" ? "just-these" : "all-like-these";
-};
-
-export interface WizardDraftInput extends WizardCommitAnswers {
-	clauses: readonly RuleClause[];
-	matchOperator: MatchOperator;
-	moveMailboxId?: string;
-	/** ISO 8601 civil date (`YYYY-MM-DD`) the `until` scope stops on. */
-	until?: string;
-}
-
-/**
- * The commit draft for a set of wizard answers. This is where the `until`
- * scope's civil date becomes `expiresAt`, a zoned date-time (#477 5.4): the
- * wizard collects the day the rule stops on, and the day only becomes an
- * instant once there is a draft to carry it.
- */
-export const buildWizardDraft = ({
-	ruleScope,
-	clauses,
-	matchOperator,
-	moveMailboxId,
-	until,
-}: WizardDraftInput): OrganizeDraft => ({
-	matchOperator: matchOperator === "all" ? "And" : "Or",
-	literalClauses: clauses.map((clause) => ({
-		field: clause.field,
-		value: clause.value,
-	})),
-	moveMailboxId,
-	expiresAt:
-		ruleScope === "until" ? pickedDateToExpiresAt(until ?? "") : undefined,
-});
-
-/**
- * Build the `createFilter` body for a standing or temporary filter. `ttl` is
- * derived server-side from `expiresAt`; `expiresAt` is sent only for the
- * temporary scope (RFC 034 Decision 1.3).
- */
-export const buildCreateFilterInput = (
-	draft: OrganizeDraft,
-	scope: Extract<OrganizeScope, "standing" | "temporary">,
-	name: string,
-): RemitImapCreateFilterInput => {
-	const filterScope: RemitImapFilterScope =
-		scope === "standing" ? "Standing" : "Temporary";
-	return {
-		name,
-		scope: filterScope,
-		...(scope === "temporary" && draft.expiresAt
-			? { expiresAt: draft.expiresAt }
-			: {}),
-		matchOperator: draft.matchOperator,
-		literalClauses: draft.literalClauses,
-		actionLabelId: draft.labelId ?? NO_ACTION,
-		actionMailboxId: draft.moveMailboxId ?? NO_ACTION,
-	};
-};

package/src/lib/organize/organize-poll.test.ts

@@ -1,37 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { isTerminalJobState, nextPollDelayMs } from "./organize-poll";
-
-describe("isTerminalJobState", () => {
-	it("stops on Complete and Failed", () => {
-		assert.equal(isTerminalJobState("Complete"), true);
-		assert.equal(isTerminalJobState("Failed"), true);
-	});
-
-	it("keeps polling on Pending and Running", () => {
-		assert.equal(isTerminalJobState("Pending"), false);
-		assert.equal(isTerminalJobState("Running"), false);
-	});
-
-	it("keeps polling while the state is unknown", () => {
-		assert.equal(isTerminalJobState(undefined), false);
-	});
-});
-
-describe("nextPollDelayMs", () => {
-	it("backs off exponentially from 1s", () => {
-		assert.equal(nextPollDelayMs(0), 1_000);
-		assert.equal(nextPollDelayMs(1), 2_000);
-		assert.equal(nextPollDelayMs(2), 4_000);
-		assert.equal(nextPollDelayMs(3), 8_000);
-	});
-
-	it("caps the delay at 15s", () => {
-		assert.equal(nextPollDelayMs(10), 15_000);
-		assert.equal(nextPollDelayMs(100), 15_000);
-	});
-
-	it("treats a negative attempt as the first delay", () => {
-		assert.equal(nextPollDelayMs(-5), 1_000);
-	});
-});

package/src/lib/organize/organize-poll.ts

@@ -1,28 +0,0 @@
-import type { RemitImapOrganizeJobState } from "@remit/api-http-client/types.gen.ts";
-
-/** States a back-apply job stops at — polling ends here (RFC 034, #1278). */
-const TERMINAL_STATES: ReadonlySet<RemitImapOrganizeJobState> = new Set([
-	"Complete",
-	"Failed",
-]);
-
-export const isTerminalJobState = (
-	state: RemitImapOrganizeJobState | undefined,
-): boolean => state !== undefined && TERMINAL_STATES.has(state);
-
-const BASE_POLL_MS = 1_000;
-const MAX_POLL_MS = 15_000;
-
-/**
- * Exponential backoff for job polling: 1s, 2s, 4s, 8s, capped at 15s. `attempt`
- * is the number of polls already made (0 for the first delay). Backoff keeps a
- * long-running back-apply from hammering the job endpoint while staying
- * responsive for the common fast case — and there is never a client-side loop
- * over message pages (remit is data-heavy; the corpus is queried once, server
- * side, by the job itself).
- */
-export const nextPollDelayMs = (attempt: number): number => {
-	const clampedAttempt = Math.max(0, attempt);
-	const delay = BASE_POLL_MS * 2 ** clampedAttempt;
-	return Math.min(delay, MAX_POLL_MS);
-};

package/src/lib/organize/rule-model.test.ts

@@ -1,211 +0,0 @@
-/**
- * The rule ↔ predicate wiring behind the Organize chip editor (RFC 038 D1). The
- * load-bearing contract lives here: the predicate the editor previews is exactly
- * the predicate a commit applies, so the count on screen is the set that moves.
- */
-
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { FilterRule } from "@remit/ui";
-import { buildOrganizeInput } from "./organize-model";
-import {
-	derivePreview,
-	isEvaluablePredicate,
-	normalizeClauseValue,
-	normalizeListId,
-	predicateSignature,
-	rulePredicate,
-	ruleToDraft,
-} from "./rule-model";
-
-describe("normalizeListId", () => {
-	it("strips the bracketed identifier, trims, and case-folds — matching the backend", () => {
-		assert.equal(
-			normalizeListId("<Weekly.News.Example.com>"),
-			"weekly.news.example.com",
-		);
-		assert.equal(normalizeListId("  Weekly.News  "), "weekly.news");
-		assert.equal(normalizeListId(""), "");
-	});
-
-	it("only normalizes the ListId field, trimming the rest", () => {
-		assert.equal(
-			normalizeClauseValue("ListId", "<List.Example.COM>"),
-			"list.example.com",
-		);
-		assert.equal(normalizeClauseValue("From", "  a@x.com  "), "a@x.com");
-		assert.equal(
-			normalizeClauseValue("FromDomain", " github.com "),
-			"github.com",
-		);
-	});
-});
-
-const rule: FilterRule = {
-	clauses: [{ id: "c1", field: "Subject", value: "receipt" }],
-	matchOperator: "all",
-	moveMailboxId: "mbx-archive",
-	scope: "once",
-};
-
-describe("rulePredicate", () => {
-	it("carries the operator and the literal clauses", () => {
-		const predicate = rulePredicate(rule);
-		assert.equal(predicate.matchOperator, "And");
-		assert.deepEqual(predicate.literalClauses, [
-			{ field: "Subject", value: "receipt" },
-		]);
-	});
-
-	it("maps the any operator to Or", () => {
-		const predicate = rulePredicate({ ...rule, matchOperator: "any" });
-		assert.equal(predicate.matchOperator, "Or");
-	});
-});
-
-describe("predicateSignature", () => {
-	it("is stable across identical predicates", () => {
-		assert.equal(
-			predicateSignature(rulePredicate(rule)),
-			predicateSignature(rulePredicate(rule)),
-		);
-	});
-
-	it("changes when a clause value changes", () => {
-		const changed: FilterRule = {
-			...rule,
-			clauses: [{ id: "c1", field: "Subject", value: "invoice" }],
-		};
-		assert.notEqual(
-			predicateSignature(rulePredicate(rule)),
-			predicateSignature(rulePredicate(changed)),
-		);
-	});
-});
-
-describe("the previewed set equals the applied set", () => {
-	it("carries exactly the previewed predicate into the commit draft", () => {
-		const preview = buildOrganizeInput({
-			...rulePredicate(rule),
-			matchOperator: rulePredicate(rule).matchOperator,
-			literalClauses: rulePredicate(rule).literalClauses,
-		});
-		const apply = buildOrganizeInput(ruleToDraft(rule));
-		assert.equal(apply.matchOperator, preview.matchOperator);
-		assert.deepEqual(apply.literalClauses, preview.literalClauses);
-	});
-
-	it("adds the expiry only for the until scope, never touching the match set", () => {
-		const once = ruleToDraft(rule);
-		assert.equal(once.expiresAt, undefined);
-
-		const until = ruleToDraft({
-			...rule,
-			scope: "until",
-			until: "2999-01-02",
-		});
-		assert.ok(until.expiresAt?.startsWith("2999-01-02"));
-		assert.deepEqual(until.literalClauses, once.literalClauses);
-	});
-
-	it("carries the move destination into the draft", () => {
-		assert.equal(ruleToDraft(rule).moveMailboxId, "mbx-archive");
-	});
-
-	it("carries the label target into the draft (issue #26)", () => {
-		const labeled = { ...rule, labelId: "lbl-receipts" };
-		assert.equal(ruleToDraft(labeled).labelId, "lbl-receipts");
-	});
-});
-
-describe("derivePreview", () => {
-	const signature = "sig-current";
-
-	it("is loading before the first count lands", () => {
-		assert.deepEqual(derivePreview({}, signature), { status: "loading" });
-	});
-
-	it("is ready when the count was counted for the current predicate", () => {
-		assert.deepEqual(
-			derivePreview({ count: 42, previewedSignature: signature }, signature),
-			{ status: "ready", count: 42 },
-		);
-	});
-
-	it("goes stale — never blank — when the predicate has moved past the count", () => {
-		assert.deepEqual(
-			derivePreview({ count: 42, previewedSignature: "sig-old" }, signature),
-			{ status: "ready", count: 42, stale: true },
-		);
-	});
-
-	it("surfaces an error raised for the current predicate", () => {
-		assert.deepEqual(
-			derivePreview(
-				{ count: 1, error: "boom", errorSignature: signature },
-				signature,
-			),
-			{ status: "error", reason: "boom" },
-		);
-	});
-
-	it("ignores an error raised for a predicate already moved past", () => {
-		assert.deepEqual(
-			derivePreview(
-				{
-					count: 5,
-					previewedSignature: signature,
-					error: "boom",
-					errorSignature: "sig-old",
-				},
-				signature,
-			),
-			{ status: "ready", count: 5 },
-		);
-	});
-});
-
-describe("isEvaluablePredicate", () => {
-	it("accepts literal clauses the matcher can read off the thread rows", () => {
-		assert.equal(
-			isEvaluablePredicate({
-				matchOperator: "And",
-				literalClauses: [
-					{ field: "From", value: "npm@github.com" },
-					{ field: "Subject", value: "Invoice" },
-				],
-			}),
-			true,
-		);
-	});
-
-	it("rejects a body clause — the shape that answered 500", () => {
-		assert.equal(
-			isEvaluablePredicate({
-				matchOperator: "And",
-				literalClauses: [{ field: "HasWords", value: "receipt" }],
-			}),
-			false,
-		);
-	});
-
-	it("rejects it however it is mixed in with clauses that are evaluable", () => {
-		assert.equal(
-			isEvaluablePredicate({
-				matchOperator: "Or",
-				literalClauses: [
-					{ field: "From", value: "npm@github.com" },
-					{ field: "HasWords", value: "receipt" },
-				],
-			}),
-			false,
-		);
-	});
-
-	it("accepts an empty predicate", () => {
-		assert.equal(
-			isEvaluablePredicate({ matchOperator: "And", literalClauses: [] }),
-			true,
-		);
-	});
-});

package/src/lib/organize/rule-model.ts

@@ -1,140 +0,0 @@
-import type {
-	ClauseField,
-	FilterRule,
-	MatchOperator,
-	PreviewCount,
-} from "@remit/ui";
-import { pickedDateToExpiresAt } from "./filter-status";
-import type { OrganizeDraft, OrganizeMatchPredicate } from "./organize-model";
-
-/**
- * The clause fields the Organize editor may offer (RFC 038 D2). Gated on what
- * the backend matcher evaluates, not on what the generated enum carries: every
- * one of these is honored by the literal matcher and the back-apply corpus
- * projection (match.ts), so a chip never previews a set the apply can't
- * reproduce. `ListId` and `FromDomain` joined once their matcher shipped (#262).
- */
-export const SUPPORTED_CLAUSE_FIELDS: ClauseField[] = [
-	"From",
-	"Subject",
-	"HasWords",
-	"ListId",
-	"FromDomain",
-];
-
-/**
- * Canonical form of a `ListId` clause value, matching the backend's
- * `normalizeListId` (list-id.ts): the bracketed identifier when present,
- * otherwise the whole value, trimmed and case-folded. Normalizing at input keeps
- * the chip the user sees identical to the value the matcher compares, so
- * `<weekly.news.example.com>` and `Weekly.News.Example.com` are one list.
- */
-export const normalizeListId = (value: string): string => {
-	const trimmed = value.trim();
-	const bracketed = trimmed.match(/<([^>]+)>/);
-	return (bracketed ? bracketed[1] : trimmed).trim().toLowerCase();
-};
-
-/** Canonicalize a clause value for its field before it becomes a chip. */
-export const normalizeClauseValue = (
-	field: ClauseField,
-	value: string,
-): string => (field === "ListId" ? normalizeListId(value) : value.trim());
-
-const toApiOperator = (operator: MatchOperator): "And" | "Or" =>
-	operator === "all" ? "And" : "Or";
-
-/**
- * The match-relevant projection of a rule — the operator and the literal
- * clauses. Preview and apply
- * both derive from this, so the set the editor counts is the set a commit acts
- * on. Fields that do not change the match set (folder, scope, name, date) are
- * deliberately absent.
- */
-export const rulePredicate = (rule: FilterRule): OrganizeMatchPredicate => ({
-	matchOperator: toApiOperator(rule.matchOperator),
-	literalClauses: rule.clauses.map((clause) => ({
-		field: clause.field,
-		value: clause.value,
-	})),
-});
-
-/**
- * Whether the matcher behind `/organize/preview` can evaluate this predicate at
- * all. It reads no message body and rejects a `HasWords` clause rather than
- * narrowing the match silently (`bodyContentRejection`, backend/service/organize.ts). Asking it
- * anyway is refused with a 400, on preview and on a back-apply alike, so the
- * caller must not ask.
- */
-export const isEvaluablePredicate = (
-	predicate: OrganizeMatchPredicate,
-): boolean =>
-	!predicate.literalClauses.some((clause) => clause.field === "HasWords");
-
-/**
- * A stable key for a predicate's match set. Two predicates with the same key
- * match the same messages; a change to the key is what marks the live count
- * stale and schedules the next preview.
- */
-export const predicateSignature = (predicate: OrganizeMatchPredicate): string =>
-	JSON.stringify({
-		operator: predicate.matchOperator,
-		clauses: predicate.literalClauses.map(
-			(clause) => `${clause.field} ${clause.value}`,
-		),
-	});
-
-/**
- * The commit draft for a rule. The match fields are exactly
- * {@link rulePredicate}'s — the previewed predicate — with the folder action
- * and, for the `until` scope, the derived expiry added. The expiry never enters
- * the match set, so preview and apply still count and act on the same messages.
- */
-export const ruleToDraft = (rule: FilterRule): OrganizeDraft => {
-	const predicate = rulePredicate(rule);
-	return {
-		matchOperator: predicate.matchOperator,
-		literalClauses: predicate.literalClauses,
-		moveMailboxId: rule.moveMailboxId,
-		labelId: rule.labelId,
-		expiresAt:
-			rule.scope === "until"
-				? pickedDateToExpiresAt(rule.until ?? "")
-				: undefined,
-	};
-};
-
-export interface PreviewState {
-	/** The last count that came back, `undefined` before the first lands. */
-	count?: number;
-	/** The ids that count was counted over, as the server bounded them. */
-	matchedIds?: readonly string[];
-	/** The signature the {@link count} was counted for. */
-	previewedSignature?: string;
-	/** The signature the last error was raised for. */
-	errorSignature?: string;
-	error?: string;
-}
-
-/**
- * The live count for the rule on screen. The count is `ready` only when it was
- * counted for the current predicate; a predicate change since then reads
- * `stale` (recounting, never blank) so the commit gate can hold apply until it
- * settles.
- */
-export const derivePreview = (
-	state: PreviewState,
-	currentSignature: string,
-): PreviewCount => {
-	if (state.error !== undefined && state.errorSignature === currentSignature) {
-		return { status: "error", reason: state.error };
-	}
-	if (state.count === undefined) return { status: "loading" };
-	if (state.previewedSignature === currentSignature) {
-		return { status: "ready", count: state.count };
-	}
-	return { status: "ready", count: state.count, stale: true };
-};
-
-/** How long a rule change settles before the next preview fires. */
-export const PREVIEW_DEBOUNCE_MS = 350;