fix(ui): granular sleep sources, viewport-safe tour, one aligned settings language

A night with coarse apple-health samples next to granular watch data
showed only awake and asleep — the per-session source pick now prefers
the source that knows its stages. Tour popovers clamp into the
viewport, wrap their footer and fall back to a bottom sheet on narrow
screens. Settings and admin sections share one alignment rule — icon
column left, everything else flush on the content column — with neutral
header icons, no duplicated section titles under the shell heading, and
every select on the account-style idiom with a visible chevron. The
dashboard's customize icon matches insights, the target-settings link
leaves the home charts, and the mood heatmap adopts the damped fills
the other mood charts already use.
This commit is contained in:
Marc-André Bombeck committed 2026-06-10 21:19:05 +02:00
1 parent 9f2c403f84
commit 024da9fe96
67 files changed
+545 -344

No files matched your search

@@ -1,106 +1,79 @@
import { describe, expect, it } from "vitest";
import { describe, expect, it, vi } from "vitest";
import { renderToStaticMarkup } from "react-dom/server";
// SSR test render has no Next.js app-router context; stub the two
// navigation hooks the bubble uses.
vi.mock("next/navigation", () => ({
useRouter: () => ({ push: vi.fn(), replace: vi.fn() }),
usePathname: () => "/insights",
}));
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { I18nProvider } from "@/lib/i18n/context";
import { CoachLaunchProvider } from "@/lib/insights/coach-launch-context";
import { LayoutCoachFab } from "../layout-coach-fab";
import { isNudgeUnread, LayoutCoachFab } from "../layout-coach-fab";
/**
* v1.4.33 (F15) — layout-level Coach FAB contract.
* v1.16.1 — the layout FAB is nudge-driven now: it renders ONLY while
* an unseen proactive `COACH_NUDGE` exists (per
* `/api/insights/coach/nudge-status` + the device-local seen stamp).
* No permanent launcher remains — the inline pill is the everyday
* entry point.
*
* The FAB sits at the mobile bottom-right. Before v1.4.33 it overlaid
* Recharts tooltips when the user tapped a data point in the chart's
* lower-right corner — the maintainer flagged this as F15 in the
* runtime audit. The fix wires the FAB to `useChartTooltipActive()`
* which reads a singleton MutationObserver of every
* `.recharts-tooltip-wrapper`; while a wrapper is visible the FAB
* fades and drops `pointer-events`.
*
* Project convention is SSR-only tests (no `@testing-library/react`),
* so we pin the initial-paint state — no tooltip can be active before
* hydration, so the FAB renders without the active-flag attribute
* and stays interactive on first paint. The end-to-end auto-hide
* behaviour is exercised in the Playwright mobile suite.
* Project convention is SSR-only tests (no `@testing-library/react`).
* On first paint the nudge-status query has no data, so the bubble
* must render nothing; the unread derivation is pinned through the
* exported pure helper instead.
*/
function render(node: React.ReactNode, locale: "en" | "de" = "en") {
const client = new QueryClient();
return renderToStaticMarkup(
<I18nProvider initialLocale={locale}>{node}</I18nProvider>,
<QueryClientProvider client={client}>
<I18nProvider initialLocale={locale}>{node}</I18nProvider>
</QueryClientProvider>,
);
}
describe("<LayoutCoachFab>", () => {
it("returns nothing when no <CoachLaunchProvider> is mounted", () => {
// The hook returns `null` outside the provider; the FAB then
// renders nothing rather than crashing — same posture as
// `<CoachLaunchButton>`.
const html = render(<LayoutCoachFab />);
expect(html).not.toContain('data-slot="coach-nudge-bubble"');
});
it("renders nothing on first paint (no nudge-status data yet)", () => {
// The bubble only exists for an unseen nudge; before the status
// query resolves there is nothing to show — no permanent FAB.
const html = render(
<CoachLaunchProvider>
<LayoutCoachFab />
</CoachLaunchProvider>,
);
expect(html).not.toContain('data-slot="coach-nudge-bubble"');
expect(html).not.toContain('data-slot="coach-launch-fab"');
});
});
it("mounts the FAB with the launch-fab slot under the provider", () => {
const html = render(
<CoachLaunchProvider>
<LayoutCoachFab />
</CoachLaunchProvider>,
);
expect(html).toMatch(/data-slot="coach-launch-fab"/);
describe("isNudgeUnread", () => {
const nudgedAt = "2026-06-09T05:15:00.000Z";
it("is false without status or without a nudge", () => {
expect(isNudgeUnread(undefined, null)).toBe(false);
expect(isNudgeUnread({ nudgedAt: null, unread: false }, null)).toBe(false);
});
it("renders without the chart-tooltip-active flag on first paint", () => {
// SSR snapshot of `useChartTooltipActive()` is `false` so the
// FAB stays interactive on initial render. The active classes
// (opacity-0 + pointer-events-none) are applied client-side only
// once a Recharts tooltip wrapper flips its inline visibility.
const html = render(
<CoachLaunchProvider>
<LayoutCoachFab />
</CoachLaunchProvider>,
);
// The data attribute is `undefined` when inactive — React drops
// it from the DOM so the rendered markup never carries it.
expect(html).not.toContain('data-chart-tooltip-active="true"');
// The shadcn `<Button>` primitive bakes in
// `disabled:pointer-events-none` and `[&_svg]:pointer-events-none`,
// so we look for the unprefixed token that the fade-out adds.
// Match it as a class atom (preceded by space/start, followed by
// space/end-of-class-list/quote) so the primitive's prefixed
// variants can't false-match.
expect(html).not.toMatch(/(?:^|["\s])pointer-events-none(?=["\s])/);
expect(html).not.toContain("opacity-0");
it("is true for a server-unread nudge the device has not seen", () => {
expect(isNudgeUnread({ nudgedAt, unread: true }, null)).toBe(true);
expect(isNudgeUnread({ nudgedAt, unread: true }, "2026-01-01")).toBe(true);
});
it("carries the transition class so the fade is animated", () => {
// The fade-out + fade-in shouldn't pop visually — the FAB
// animates opacity over 150ms.
const html = render(
<CoachLaunchProvider>
<LayoutCoachFab />
</CoachLaunchProvider>,
);
expect(html).toContain("transition-opacity");
expect(html).toContain("duration-150");
it("is false once the server counts the nudge as read", () => {
// The user sent a Coach message after the nudge.
expect(isNudgeUnread({ nudgedAt, unread: false }, null)).toBe(false);
});
it("hides the FAB above lg via `lg:hidden`", () => {
// The desktop Coach surface is the inline pill; the FAB stays
// mobile-only.
const html = render(
<CoachLaunchProvider>
<LayoutCoachFab />
</CoachLaunchProvider>,
);
expect(html).toContain("lg:hidden");
});
it("renders the localised label in German", () => {
const html = render(
<CoachLaunchProvider>
<LayoutCoachFab />
</CoachLaunchProvider>,
"de",
);
expect(html).toContain("Coach fragen");
it("is false once this device stored the matching seen stamp", () => {
expect(isNudgeUnread({ nudgedAt, unread: true }, nudgedAt)).toBe(false);
});
});
@@ -91,10 +91,10 @@ export function CoachLaunchButton({
);
}
// Inline header-style action on `lg+`. Hidden below `lg` because the
// layout-level FAB (`<LayoutCoachFab>`) covers that breakpoint —
// mounting both at the same time would put two affordances in front
// of the user.
// Inline header-style action. v1.16.1 — visible on every viewport:
// the layout-level FAB is no longer a permanent launcher (it only
// surfaces an unseen proactive nudge), so the pill is the everyday
// Coach entry point on mobile too.
return (
<Button
type="button"
@@ -102,7 +102,7 @@ export function CoachLaunchButton({
size="sm"
data-slot="coach-launch-inline"
onClick={() => launch.askCoach(prefill ?? null)}
className={cn("hidden h-10 gap-2 self-end lg:inline-flex", className)}
className={cn("inline-flex h-10 gap-2 self-end", className)}
>
<Sparkles className="size-4" aria-hidden="true" />
<span>{accessibleLabel}</span>
@@ -60,10 +60,9 @@ export function InsightsLayoutShell({ children }: { children: ReactNode }) {
const advisorEnabled =
isAuthenticated && flags.enabled && flags.briefing;
// v1.12.6 — routes that carry their own purpose-built disclaimer must NOT
// also show the generic footer below (otherwise two disclaimers stack).
// The Coach full page renders its own `composerDisclaimer` under the
// composer, so its segment is excluded here. Every other segment — the
// v1.12.6 — the Coach segment is excluded from the generic disclaimer
// footer (v1.16.1 dropped the in-chat disclaimer line entirely; the
// chat surface stays footer-free by design). Every other segment — the
// overview (null segment), the metric sub-pages, mood, medications, the
// raw values table — keeps the single generic footer.
const segment = useSelectedLayoutSegment();
+105 -51
View File
@@ -1,5 +1,8 @@
"use client";
import { useEffect, useState } from "react";
import { usePathname, useRouter } from "next/navigation";
import { useQuery } from "@tanstack/react-query";
import { Sparkles } from "lucide-react";
import { Button } from "@/components/ui/button";
@@ -8,88 +11,139 @@ import { useTranslations } from "@/lib/i18n/context";
import { useCoachLaunch } from "@/lib/insights/coach-launch-context";
import { useFeatureFlags } from "@/hooks/use-feature-flags";
import { useDisableCoach } from "@/hooks/use-disable-coach";
import { queryKeys } from "@/lib/query-keys";
import { useChartTooltipActive } from "./use-chart-tooltip-active";
/**
* Layout-level mobile Coach launch FAB.
* v1.16.1 — the layout FAB is no longer a permanent launcher. It now
* renders ONLY while an unseen Coach-initiated nudge exists (the
* proactive `COACH_NUDGE` dispatch, surfaced by
* `/api/insights/coach/nudge-status`): a floating circle at the bottom
* right that opens the full-page Coach chat. It disappears once the
* nudge counts as read — the user sent a Coach message after the
* nudge (server-derived), or opened the Coach on this device (local
* seen stamp keyed by the nudge timestamp).
*
* v1.4.28 R3c — promoted out of `<CoachLaunchButton>` (which previously
* rendered both the FAB and the inline pill from a single component;
* each sub-page mount therefore painted a duplicate FAB into the DOM
* before `fixed` positioning collapsed them visually). Mounting the
* FAB once at the layout level keeps the affordance reachable from
* every routed Insights surface while leaving the a11y tree with a
* single button.
* The previous always-on mobile FAB drew attention to nothing; the
* inline "Ask Coach" pill in each page's action row stays the everyday
* entry point.
*
* Hidden on `lg+` viewports — desktop users reach the Coach via the
* inline `<CoachLaunchButton>` pill that each page mounts in its
* action row.
*
* v1.4.33 (F15) — the FAB sits at `bottom-right` and used to overlay
* Recharts tooltips on the bottom-right of any insight chart, so a
* mobile user tapping a data point near the chart's lower-right
* couldn't read the bubble. The button now auto-hides while a chart
* tooltip is active (the wrapper's `visibility: visible` flips us
* to fade-out + pointer-events-none). When the user releases / scrolls
* away the tooltip clears and the FAB fades back in.
* v1.4.33 (F15) — the bubble keeps the chart-tooltip auto-hide so it
* never overlays a Recharts tooltip on the lower right.
*/
const NUDGE_SEEN_STORAGE_KEY = "healthlog-coach-nudge-seen";
export interface CoachNudgeStatus {
nudgedAt: string | null;
unread: boolean;
}
/**
* Pure unread derivation — server signal AND-ed with the local
* seen-stamp. Exported so the unit test pins the contract without a
* QueryClient round-trip.
*/
export function isNudgeUnread(
status: CoachNudgeStatus | undefined,
seenStamp: string | null,
): boolean {
if (!status?.unread || status.nudgedAt === null) return false;
return seenStamp !== status.nudgedAt;
}
export function LayoutCoachFab() {
const { t } = useTranslations();
const router = useRouter();
const pathname = usePathname();
const launch = useCoachLaunch();
const flags = useFeatureFlags();
const disableCoach = useDisableCoach();
const tooltipActive = useChartTooltipActive();
if (!launch) return null;
// v1.4.31 — operator can hide the Coach surface app-wide. The
// FAB returns null when the master OR the coach sub-flag is off.
if (!flags.coach) return null;
// v1.4.47 W3 — per-user opt-out beats the operator's "on" default.
// A privacy-leaning user who toggles "Hide Coach" in Settings → Insights
// gets the FAB short-circuited here, identical to the global-off
// branch above. The hook defaults to `false` in the absence of a
// QueryClient (legacy SSR-only snapshot tests).
if (disableCoach) return null;
const accessibleLabel = t("insights.heroActionAskCoach");
// Local "seen on this device" stamp — the nudge timestamp the user
// last dismissed by opening the chat. Lazy initialiser per the
// `react-hooks/set-state-in-effect` rule.
const [seenStamp, setSeenStamp] = useState<string | null>(() => {
if (typeof window === "undefined") return null;
try {
return window.localStorage.getItem(NUDGE_SEEN_STORAGE_KEY);
} catch {
return null;
}
});
const coachAvailable = !!launch && flags.coach && !disableCoach;
const onCoachPage = pathname?.startsWith("/insights/coach") ?? false;
const { data: status } = useQuery({
queryKey: queryKeys.coachNudgeStatus(),
queryFn: async (): Promise<CoachNudgeStatus> => {
const res = await fetch("/api/insights/coach/nudge-status");
if (!res.ok) throw new Error("coach-nudge-status.failed");
return (await res.json()).data as CoachNudgeStatus;
},
enabled: coachAvailable,
staleTime: 5 * 60 * 1000,
});
const nudgedAt = status?.nudgedAt ?? null;
const unread = isNudgeUnread(status, seenStamp);
// Visiting the Coach page itself counts as reading the nudge on this
// device — persist the stamp so the bubble stays gone after leaving.
useEffect(() => {
if (!onCoachPage || nudgedAt === null) return;
try {
window.localStorage.setItem(NUDGE_SEEN_STORAGE_KEY, nudgedAt);
} catch {
// Storage unavailable (private mode) — the server-side read
// signal still clears the bubble once the user sends a message.
}
}, [onCoachPage, nudgedAt]);
if (!coachAvailable) return null;
if (onCoachPage || !unread) return null;
const accessibleLabel = t("insights.coach.nudgeBubbleLabel");
const handleOpen = () => {
if (nudgedAt !== null) {
setSeenStamp(nudgedAt);
try {
window.localStorage.setItem(NUDGE_SEEN_STORAGE_KEY, nudgedAt);
} catch {
// Best effort — see above.
}
}
router.push("/insights/coach");
};
return (
<Button
type="button"
size="lg"
data-slot="coach-launch-fab"
size="icon"
data-slot="coach-nudge-bubble"
data-chart-tooltip-active={tooltipActive ? "true" : undefined}
onClick={() => launch.askCoach(null)}
onClick={handleOpen}
aria-label={accessibleLabel}
title={accessibleLabel}
// v1.4.33 (F15) — `aria-hidden` + `tabIndex={-1}` while a chart
// tooltip is painted so screen-reader users + keyboard users
// don't trip over a button that's visually faded; pointer-events
// are gone, so a tap can't land on the invisible FAB either.
aria-hidden={tooltipActive ? true : undefined}
tabIndex={tooltipActive ? -1 : undefined}
className={cn(
// Sit above the 64 px bottom-nav + the iPhone home-indicator
// safe-area inset. `calc(env(safe-area-inset-bottom,0)+5rem)`
// keeps the FAB clear of the nav on notched iPhones (where the
// inset is ~34 px) without forcing extra padding into the
// layout grid.
"fixed right-4 z-40 h-12 rounded-full px-4 shadow-lg",
"bottom-[calc(env(safe-area-inset-bottom,0px)+5rem)]",
// safe-area inset on mobile; plain bottom offset on desktop.
"fixed right-4 z-40 size-12 rounded-full shadow-lg",
"bottom-[calc(env(safe-area-inset-bottom,0px)+5rem)] lg:bottom-6",
"from-dracula-purple to-dracula-pink bg-gradient-to-br text-white",
"hover:from-dracula-purple/90 hover:to-dracula-pink/90",
"lg:hidden",
// v1.4.33 (F15) — fade out while a Recharts tooltip is open.
// 150 ms transition matches the rest of the Coach drawer's
// fade timing; `motion-reduce:transition-none` honours user
// preference. `pointer-events-none` keeps the faded FAB from
// intercepting taps that should reach the tooltip behind.
// Fade out while a Recharts tooltip is open (see header note).
"transition-opacity duration-150 motion-reduce:transition-none",
tooltipActive && "pointer-events-none opacity-0",
)}
>
<Sparkles className="size-4" aria-hidden="true" />
<span>{accessibleLabel}</span>
<Sparkles className="size-5" aria-hidden="true" />
</Button>
);
}