refactor: simplify calendar and form state

src/pages/account-income/model/display.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, it } from "vitest";
+
+import type { IncomeAnalytics } from "@/entities/income";
+
+import { resource } from "@/test/resource";
+
+import { toIncomeDisplayModel } from "./display";
+
+const analytics: IncomeAnalytics = {
+	accountId: "account-1",
+	bucketGranularity: "day",
+	buckets: [],
+	calculatedAt: "2026-08-27T00:00:00Z",
+	entries: [],
+	instruments: [],
+	period: { from: "2026-08-01", to: "2026-08-27" },
+	previous: {
+		period: { from: "2026-07-01", to: "2026-07-31" },
+		totalsByCurrency: [comparison("RUB")],
+	},
+	totalsByCurrency: [],
+	yearComparison: null,
+};
+
+function comparison(currency: string) {
+	return {
+		compared: summary(currency, "1", "0"),
+		currency,
+		difference: summary(currency, "9", "2"),
+		selected: summary(currency, "10", "2"),
+	};
+}
+
+function money(currency: string, value: string) {
+	return { currency, value };
+}
+
+function summary(currency: string, coupon: string, dividend: string) {
+	return {
+		coupon: money(currency, coupon),
+		currency,
+		dividend: money(currency, dividend),
+		total: money(currency, String(Number(coupon) + Number(dividend))),
+	};
+}
+
+describe("income comparison display", () => {
+	it.each([
+		["25", "100", "+25 %"],
+		["-25", "100", "-25 %"],
+		["0", "100", "0 %"],
+		["-0.000", "100", "0 %"],
+		["0.0001", "100", "0 %"],
+		["1", "3", "+33,3 %"],
+		["0.01", "0.04", "+25 %"],
+		["123456789012345678.123456789", "123456789012345678.123456789", "+100 %"],
+		[
+			"10",
+			"0",
+			null,
+		],
+		[
+			"0",
+			"0",
+			null,
+		],
+		[
+			"10",
+			"-0.00",
+			null,
+		],
+		[
+			"10",
+			"-100",
+			null,
+		],
+		[
+			"9".repeat(400),
+			"1",
+			null,
+		],
+		[
+			"1",
+			"9".repeat(400),
+			null,
+		],
+	])("formats change %s against base %s", (difference, base, expected) => {
+		const value = comparison("RUB");
+		value.difference.coupon = money("RUB", difference);
+		value.compared.coupon = money("RUB", base);
+
+		const display = toIncomeDisplayModel({
+			...analytics,
+			yearComparison: {
+				period: { from: "2025-08-01", to: "2025-08-27" },
+				totalsByCurrency: [value],
+			},
+		});
+
+		const result = display?.comparison?.values[0];
+		expect(
+			result?.percentages.coupon?.replaceAll("\u{A0}", " ")
+
+			?? null,
+		).toBe(expected);
+		expect(result?.difference.coupon.value).toBe(difference);
+		expect(result?.compared.coupon.value).toBe(base);
+	});
+
+	it("formats calendar ranges across years and preserves separate currencies", () => {
+		const display = toIncomeDisplayModel({
+			...analytics,
+			period: { from: "2025-12-01", to: "2026-01-09" },
+			yearComparison: {
+				period: { from: "2024-12-01", to: "2025-01-09" },
+				totalsByCurrency: [comparison("RUB"), comparison("USD")],
+			},
+		});
+
+		expect(display?.comparison?.selectedPeriod.replaceAll(/\s/g, " ")).toBe(
+			"01.12.2025 – 09.01.2026",
+		);
+		expect(display?.comparison?.comparedPeriod.replaceAll(/\s/g, " ")).toBe(
+			"01.12.2024 – 09.01.2025",
+		);
+		expect(display?.comparison?.values.map(value => value.currency)).toEqual([
+			"RUB",
+			"USD",
+		]);
+	});
+});
+
+it("maps comparison notices by role regardless of dependency order or resource key", () => {
+	const selected = { ...resource(analytics).meta, role: "selected" as const };
+
+	const previous
+		= {
+			...resource(null).meta,
+			resourceKey: "opaque/year-looking-key",
+			role: "previous" as const,
+			sync: {
+				errorCode: "TBANK_UNAVAILABLE",
+				id: null,
+				state: "failed" as const,
+			},
+		};
+
+	const year = {
+		...resource(null).meta,
+		resourceKey: "opaque/previous-looking-key",
+		role: "year" as const,
+		unavailableReason: "CALENDAR_OR_ACCOUNT_HISTORY",
+	};
+
+	for (const dependencies of [
+		[selected, previous, year],
+		[year, selected, previous],
+	]) {
+		const display = toIncomeDisplayModel(analytics, {
+			...resource(analytics).meta,
+			dependencies,
+		});
+
+		expect(display?.previousNotice).toBe("comparisonFailed");
+		expect(display?.yearNotice).toBe("yearUnavailable");
+		expect(display?.previousComparison).not.toBeNull();
+	}
+});

src/pages/account-income/model/display.ts

@@ -0,0 +1,173 @@
+import type { IncomeAnalytics, useIncomeAnalytics } from "@/entities/income";
+
+import { formatDate } from "@/shared/lib";
+
+import type { IncomePeriod } from "./period";
+
+type ComparisonNotice
+	= | "comparisonFailed"
+		| "comparisonPending"
+		| "previousUnavailable"
+		| "yearUnavailable";
+
+type IncomeDisplayModel = {
+	comparison: null
+		| {
+			comparedPeriod: string;
+			selectedPeriod: string;
+			values: (NonNullable<
+				IncomeAnalytics["yearComparison"]
+			>["totalsByCurrency"][number] & {
+				percentages: Record<"coupon"
+				| "dividend"
+				| "total", null | string>;
+			})[];
+		};
+	entries: { key: string; operation: IncomeAnalytics["entries"][number] }[];
+	previousComparison: IncomeDisplayModel["comparison"];
+	previousNotice: ComparisonNotice;
+	yearNotice: ComparisonNotice;
+};
+
+type IncomeMeta = ReturnType<typeof useIncomeAnalytics>["meta"];
+
+function comparisonDisplay(
+	period: IncomePeriod,
+	comparison: IncomeAnalytics["yearComparison"],
+): IncomeDisplayModel["comparison"] {
+	if (!comparison)
+		return null;
+
+	return {
+		comparedPeriod: formatComparisonPeriod(comparison.period),
+		selectedPeriod: formatComparisonPeriod(period),
+		values: comparison.totalsByCurrency.map(value => ({
+			...value,
+			percentages: {
+				coupon: formatIncomeChange(
+					value.difference.coupon.value,
+					value.compared.coupon.value,
+				),
+				dividend: formatIncomeChange(
+					value.difference.dividend.value,
+					value.compared.dividend.value,
+				),
+				total: formatIncomeChange(
+					value.difference.total.value,
+					value.compared.total.value,
+				),
+			},
+		})),
+	};
+}
+
+function comparisonNotice(
+	dependency:
+		NonNullable<NonNullable<IncomeMeta>["dependencies"]>[number] | undefined,
+	unavailable: "previousUnavailable" | "yearUnavailable",
+): ComparisonNotice {
+	if (!dependency || dependency.unavailableReason) return unavailable;
+
+	return dependency.sync.state === "failed"
+		? "comparisonFailed"
+		: "comparisonPending";
+}
+
+function formatComparisonPeriod(period: IncomePeriod): string {
+	return `${formatDate(period.from)} – ${formatDate(period.to)}`;
+}
+
+function formatIncomeChange(
+	difference: string,
+	compared: string,
+): null | string {
+	// Display-only ratio; server-provided Money values remain exact decimal strings.
+	const base = Number(compared);
+	if (!Number.isFinite(base) || base <= 0)
+		return null;
+	const ratio = Number(difference) / base;
+	if (!Number.isFinite(ratio))
+		return null;
+
+	return new Intl.NumberFormat("ru-RU", {
+		maximumFractionDigits: 1,
+		signDisplay: "exceptZero",
+		style: "percent",
+	}).format(ratio);
+}
+
+function toIncomeDisplayModel(
+	analytics: IncomeAnalytics,
+	meta?: IncomeMeta,
+): IncomeDisplayModel | null {
+	const instruments = new Map<
+		string,
+		{
+			currency: string;
+			includedCount: number;
+			receiptCount: number;
+		}
+	>();
+
+	const currencies = new Set(
+		analytics.totalsByCurrency.map(({ currency }) => currency),
+	);
+
+	for (const instrument of analytics.instruments) {
+		if (
+			typeof instrument.key !== "string"
+			|| !instrument.key.trim()
+			|| instruments.has(instrument.key)
+			|| !currencies.has(instrument.total.currency)
+		)
+
+			return null;
+		instruments.set(instrument.key, {
+			currency: instrument.total.currency,
+			includedCount: 0,
+			receiptCount: instrument.receiptCount,
+		});
+	}
+
+	const entries: IncomeDisplayModel["entries"] = [];
+	const occurrences = new Map<string, number>();
+
+	for (const entry of analytics.entries) {
+		if (typeof entry.instrumentKey !== "string" || !entry.instrumentKey.trim())
+			return null;
+		const instrument = instruments.get(entry.instrumentKey);
+		if (!instrument || entry.payment?.currency !== instrument.currency)
+			return null;
+		const occurrenceKey = JSON.stringify([entry.instrumentKey, entry.id]);
+		const occurrence = occurrences.get(occurrenceKey) ?? 0;
+		occurrences.set(occurrenceKey, occurrence + 1);
+		instrument.includedCount += 1;
+		entries.push({
+			key: JSON.stringify([
+				entry.instrumentKey,
+				entry.id,
+				occurrence,
+				entry.logoName,
+			]),
+			operation: entry,
+		});
+	}
+
+	for (const instrument of instruments.values()) {
+		if (instrument.includedCount !== instrument.receiptCount)
+			return null;
+	}
+
+	const previous = meta?.dependencies?.find(({ role }) => role === "previous");
+	const year = meta?.dependencies?.find(({ role }) => role === "year");
+
+	return {
+		comparison: comparisonDisplay(analytics.period, analytics.yearComparison),
+		entries,
+		previousComparison: comparisonDisplay(analytics.period, analytics.previous),
+		previousNotice: comparisonNotice(previous, "previousUnavailable"),
+		yearNotice: comparisonNotice(year, "yearUnavailable"),
+	};
+}
+
+export { type IncomeDisplayModel, toIncomeDisplayModel };

src/pages/account-income/model/income.schema.ts

@@ -1,8 +1,9 @@
 import { z } from "zod";
 
 import { validationMessage } from "@/shared/i18n";
+import { moscowDate } from "@/shared/lib";
 
-import { moscowDate, parseDraftDate } from "./period";
+import { parseDraftDate } from "./period";
 
 const draftDate = z
 	.string()

src/pages/account-income/model/period.ts

@@ -1,47 +1,22 @@
-const ISO_DATE_LENGTH = 10;
+import { calendarDate } from "@/shared/lib";
+
 const DATE_PART_COUNT = 3;
 
 type IncomePeriod = { from: string; to: string };
 
-const datePattern = /^\d{4}-\d{2}-\d{2}$/;
-
 function formatDraftDate(value: string): string {
 	const [year, month, day] = value.split("-", DATE_PART_COUNT);
 
 	return `${day}.${month}.${year}`;
 }
 
-function isDate(value: string): boolean {
-	if (!datePattern.test(value)) return false;
-	const parsed = new Date(`${value}T00:00:00Z`);
-
-	return (
-		Number.isFinite(parsed.valueOf())
-		&& parsed.toISOString().slice(0, ISO_DATE_LENGTH) === value
-	);
-}
-
-function moscowDate(value: Date): string {
-	const parts = new Intl.DateTimeFormat("en-CA", {
-		day: "2-digit",
-		month: "2-digit",
-		timeZone: "Europe/Moscow",
-		year: "numeric",
-	}).formatToParts(value);
-
-	const part = (type: string) =>
-		parts.find(item => item.type === type)?.value;
-
-	return `${part("year")}-${part("month")}-${part("day")}`;
-}
-
 function parseDraftDate(value: string): null | string {
 	if (!/^\d{2}\.\d{2}\.\d{4}$/.test(value))
 		return null;
 	const [day, month, year] = value.split(".", DATE_PART_COUNT);
 	const date = `${year}-${month}-${day}`;
 
-	return isDate(date)
+	return calendarDate.safeParse(date).success
 		? date
 		: null;
 }
@@ -50,8 +25,5 @@ export {
 	formatDraftDate,
 	type IncomePeriod as IncomeForm,
 	type IncomePeriod,
-	isDate,
-	ISO_DATE_LENGTH,
-	moscowDate,
 	parseDraftDate,
 };