@remit/web-client 0.0.93 → 0.0.95

package/src/hooks/useRuleEditorState.ts

@@ -1,182 +0,0 @@
-import type {
-	ClauseEditState,
-	ClauseField,
-	FilterRule,
-	MatchOperator,
-	RuleScope,
-} from "@remit/ui";
-import { useRef, useState } from "react";
-import {
-	normalizeClauseValue,
-	SUPPORTED_CLAUSE_FIELDS,
-} from "@/lib/organize/rule-model";
-
-export interface RuleEditorState {
-	rule: FilterRule;
-	setRule: (updater: (current: FilterRule) => FilterRule) => void;
-	/** The clause-editing and rule-mutation handlers a {@link FilterRuleEditor} binds. */
-	handlers: {
-		clauseEdit: ClauseEditState | undefined;
-		onStartAddClause: () => void;
-		onStartEditClause: (clauseId: string) => void;
-		onRemoveClause: (clauseId: string) => void;
-		onChangeDraftField: (field: ClauseField) => void;
-		onChangeDraftValue: (value: string) => void;
-		onSubmitClause: () => void;
-		onCancelClause: () => void;
-		onAddWiden: () => void;
-		onRemoveWiden: () => void;
-		onChangeMatchOperator: (matchOperator: MatchOperator) => void;
-		onChangeMove: (mailboxId: string) => void;
-		onChangeLabel: (labelId: string) => void;
-		onChangeScope: (scope: RuleScope) => void;
-		onChangeName: (name: string) => void;
-		onChangeUntil: (until: string) => void;
-	};
-}
-
-interface RuleEditorStateInput {
-	/** The rule the editor opens on. */
-	initialRule: FilterRule;
-	/**
-	 * How many anchors a widen the user adds inline should carry. A search-seeded
-	 * rule has no message anchor, so its editor never offers the widen and this is
-	 * unused; the Organize editor passes its selection size.
-	 */
-	widenAnchorCount?: number;
-}
-
-/**
- * The clause-editing and rule-mutation state a filter-rule editor owns, shared by
- * every entry point onto the chip editor (RFC 038 D1) so the Organize and
- * search-derived surfaces edit the rule identically. Preview and commit stay with
- * the caller — they differ by entry point (an anchored widen count and back-apply
- * job for Organize, a literal count for a search-derived rule).
- */
-export const useRuleEditorState = ({
-	initialRule,
-	widenAnchorCount = 1,
-}: RuleEditorStateInput): RuleEditorState => {
-	const [rule, setRuleState] = useState<FilterRule>(initialRule);
-	const [clauseEdit, setClauseEdit] = useState<ClauseEditState | undefined>();
-	const nextClauseId = useRef(0);
-
-	const setRule = (updater: (current: FilterRule) => FilterRule) =>
-		setRuleState(updater);
-
-	const startAddClause = () =>
-		setClauseEdit({
-			mode: "add",
-			draft: { field: SUPPORTED_CLAUSE_FIELDS[0], value: "" },
-		});
-
-	const startEditClause = (clauseId: string) => {
-		const clause = rule.clauses.find((entry) => entry.id === clauseId);
-		if (!clause) return;
-		setClauseEdit({
-			mode: "edit",
-			clauseId,
-			draft: { field: clause.field, value: clause.value },
-		});
-	};
-
-	const changeDraftField = (field: ClauseField) =>
-		setClauseEdit((edit) =>
-			edit ? { ...edit, draft: { ...edit.draft, field } } : edit,
-		);
-
-	const changeDraftValue = (value: string) =>
-		setClauseEdit((edit) =>
-			edit ? { ...edit, draft: { ...edit.draft, value } } : edit,
-		);
-
-	const submitClause = () => {
-		if (!clauseEdit) return;
-		const field = clauseEdit.draft.field;
-		const value = normalizeClauseValue(field, clauseEdit.draft.value);
-		if (value === "") return;
-		setRuleState((current) => {
-			if (clauseEdit.mode === "edit" && clauseEdit.clauseId) {
-				return {
-					...current,
-					clauses: current.clauses.map((clause) =>
-						clause.id === clauseEdit.clauseId
-							? { id: clause.id, field, value }
-							: clause,
-					),
-				};
-			}
-			nextClauseId.current += 1;
-			return {
-				...current,
-				clauses: [
-					...current.clauses,
-					{ id: `clause-${nextClauseId.current}`, field, value },
-				],
-			};
-		});
-		setClauseEdit(undefined);
-	};
-
-	const removeClause = (clauseId: string) =>
-		setRuleState((current) => ({
-			...current,
-			clauses: current.clauses.filter((clause) => clause.id !== clauseId),
-		}));
-
-	const addWiden = () =>
-		setRuleState((current) => ({
-			...current,
-			widen: { anchorCount: Math.max(widenAnchorCount, 1) },
-		}));
-
-	const removeWiden = () =>
-		setRuleState((current) => ({ ...current, widen: undefined }));
-
-	const changeMatchOperator = (matchOperator: MatchOperator) =>
-		setRuleState((current) => ({ ...current, matchOperator }));
-
-	const changeMove = (mailboxId: string) =>
-		setRuleState((current) => ({
-			...current,
-			moveMailboxId: mailboxId || undefined,
-		}));
-
-	const changeLabel = (labelId: string) =>
-		setRuleState((current) => ({
-			...current,
-			labelId: labelId || undefined,
-		}));
-
-	const changeScope = (scope: RuleScope) =>
-		setRuleState((current) => ({ ...current, scope }));
-
-	const changeName = (name: string) =>
-		setRuleState((current) => ({ ...current, name }));
-
-	const changeUntil = (until: string) =>
-		setRuleState((current) => ({ ...current, until }));
-
-	return {
-		rule,
-		setRule,
-		handlers: {
-			clauseEdit,
-			onStartAddClause: startAddClause,
-			onStartEditClause: startEditClause,
-			onRemoveClause: removeClause,
-			onChangeDraftField: changeDraftField,
-			onChangeDraftValue: changeDraftValue,
-			onSubmitClause: submitClause,
-			onCancelClause: () => setClauseEdit(undefined),
-			onAddWiden: addWiden,
-			onRemoveWiden: removeWiden,
-			onChangeMatchOperator: changeMatchOperator,
-			onChangeMove: changeMove,
-			onChangeLabel: changeLabel,
-			onChangeScope: changeScope,
-			onChangeName: changeName,
-			onChangeUntil: changeUntil,
-		},
-	};
-};

package/src/hooks/useSearchFilterSeed.render.test.ts

@@ -1,118 +0,0 @@
-/**
- * Opening the filter-from-search editor: the seed count comes from the converted
- * literal predicate in one request, under the account the filter targets. No
- * capability probe — the deployment's semantic reach is read from the search's
- * own results on the surface, so a seed success is never blocked by a probe.
- */
-
-import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
-import { createElement } from "react";
-import type { OrganizeMatchPredicate } from "@/lib/organize/sender-fallback";
-import { createDomHarness, type DomHarness } from "../test-support/dom";
-import {
-	type HttpCall,
-	type HttpMock,
-	httpError,
-	mockFetch,
-} from "../test-support/http";
-import { useSearchFilterSeed } from "./useSearchFilterSeed";
-
-let harness: DomHarness | undefined;
-let http: HttpMock | undefined;
-
-afterEach(() => {
-	harness?.close();
-	harness = undefined;
-	http?.restore();
-	http = undefined;
-});
-
-const COUNTABLE: OrganizeMatchPredicate = {
-	matchOperator: "And",
-	literalClauses: [{ field: "From", value: "receipts@shop.example" }],
-};
-
-/**
- * A free-text search converts to a body-content clause, which the vector-free
- * matcher refuses. The seed must not ask.
- */
-const UNCOUNTABLE: OrganizeMatchPredicate = {
-	matchOperator: "And",
-	literalClauses: [{ field: "HasWords", value: "receipts" }],
-};
-
-function probeFor(predicate: OrganizeMatchPredicate) {
-	return function Probe() {
-		const seed = useSearchFilterSeed("acc-1", predicate);
-		return createElement(
-			"div",
-			null,
-			JSON.stringify({
-				seedCount: seed.seedCount ?? null,
-				isPending: seed.isPending,
-				isError: seed.isError,
-				uncountable: seed.uncountable,
-			}),
-		);
-	};
-}
-
-const mount = (
-	responder: (call: HttpCall) => unknown,
-	predicate: OrganizeMatchPredicate = COUNTABLE,
-): DomHarness => {
-	http = mockFetch(responder);
-	harness = createDomHarness();
-	harness.renderApp(createElement(probeFor(predicate)));
-	return harness;
-};
-
-const state = (dom: DomHarness) => JSON.parse(dom.text());
-
-describe("useSearchFilterSeed", () => {
-	it("seeds the count from the literal predicate in a single preview", async () => {
-		const dom = mount((call) =>
-			call.path.endsWith("/organize/preview")
-				? { matchedCount: 12, messageIds: [] }
-				: {},
-		);
-		await dom.flush();
-		await dom.flush();
-		assert.equal(state(dom).seedCount, 12);
-		// One preview, carrying the literal clauses and no anchor.
-		const previews = http?.to("/organize/preview") ?? [];
-		assert.equal(previews.length, 1);
-		assert.equal(previews[0].body?.anchorMessageId, undefined);
-		assert.deepEqual(previews[0].body?.literalClauses, [
-			{ field: "From", value: "receipts@shop.example" },
-		]);
-	});
-
-	it("surfaces the seed error so the caller can offer a retry", async () => {
-		const dom = mount(() => httpError(500));
-		await dom.flush();
-		await dom.flush();
-		assert.equal(state(dom).isError, true);
-	});
-
-	it("never asks for a count the matcher cannot produce", async () => {
-		const dom = mount(
-			(call) =>
-				call.path.endsWith("/organize/preview")
-					? { matchedCount: 12, messageIds: [] }
-					: {},
-			UNCOUNTABLE,
-		);
-		await dom.flush();
-		await dom.flush();
-		assert.equal(http?.to("/organize/preview").length, 0);
-		// Not pending and not an error — the editor opens, it just has no number.
-		assert.deepEqual(state(dom), {
-			seedCount: null,
-			isPending: false,
-			isError: false,
-			uncountable: true,
-		});
-	});
-});

package/src/hooks/useSearchFilterSeed.ts

@@ -1,79 +0,0 @@
-import { organizeOperationsPreviewOrganizeMutation } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import { useMutation } from "@tanstack/react-query";
-import { useCallback, useEffect } from "react";
-import { buildOrganizeInput } from "@/lib/organize/organize-model";
-import { isEvaluablePredicate } from "@/lib/organize/rule-model";
-import type { OrganizeMatchPredicate } from "@/lib/organize/sender-fallback";
-
-interface SearchFilterSeed {
-	/** The live count for the converted literal predicate, seeding the editor. */
-	seedCount?: number;
-	/**
-	 * The converted predicate is one the vector-free matcher refuses — a free-text
-	 * search kept as a `HasWords` clause. There is no count to seed and no request
-	 * to make.
-	 */
-	uncountable: boolean;
-	isPending: boolean;
-	isError: boolean;
-	error: unknown;
-	retry: () => void;
-}
-
-/**
- * Open the filter-from-search editor: seed the live count from the converted
- * literal predicate. One `POST /organize/preview` under the account the filter
- * targets — the count on screen is the set a literal-only filter applies to.
- *
- * A search whose terms convert to a `HasWords` clause has no count to seed: the
- * vector-free matcher reads no message bodies and rejects the predicate outright
- * (`assertNoBodyContentClause`), so asking is a 500 and a 500 is not a count.
- * That search is still a legitimate standing filter — the index-time matcher
- * does read bodies — so the editor opens on the uncountable reason and holds only
- * the one-time apply, the same way {@link useRulePreview} handles the clause
- * being added by hand.
- *
- * The deployment's semantic reach is not probed here; it is read from the
- * search's own "Related" results on the surface that opens the editor (RFC 038
- * D5), a direct signal that needs no request and cannot hit the wrong account.
- */
-export const useSearchFilterSeed = (
-	accountId: string | undefined,
-	literalPredicate: OrganizeMatchPredicate,
-): SearchFilterSeed => {
-	const seed = useMutation(organizeOperationsPreviewOrganizeMutation());
-	const { mutate, reset } = seed;
-	const countable = isEvaluablePredicate(literalPredicate);
-
-	const run = useCallback(() => {
-		if (!accountId || !countable) return;
-		reset();
-		mutate({
-			path: { accountId },
-			body: buildOrganizeInput({
-				matchOperator: literalPredicate.matchOperator,
-				literalClauses: literalPredicate.literalClauses,
-			}),
-		});
-	}, [
-		accountId,
-		countable,
-		literalPredicate.matchOperator,
-		literalPredicate.literalClauses,
-		mutate,
-		reset,
-	]);
-
-	useEffect(() => {
-		run();
-	}, [run]);
-
-	return {
-		seedCount: seed.data?.matchedCount,
-		uncountable: !countable,
-		isPending: countable && (seed.isPending || seed.data === undefined),
-		isError: countable && seed.isError,
-		error: seed.error,
-		retry: run,
-	};
-};