feat(status-page): four selectable themes for the public status page

Adds four fully-designed visual themes for the public status page
(refined | modern | bold | editorial) with a light/dark mode selector,
admin preview in a mock browser frame, and a shared theme provider
that keeps the component tree unified while letting each theme own
its visual identity.

## Selectable themes
- Refined — clean, flat cards, soft shadows, colored status dot.
- Modern — flat surfaces with a pulsing status dot and staggered
  fade-in cards.
- Bold — conic-gradient logo, 34px hero title with a check disc,
  subtle dual-radial glow on dark mode, accent-green hover border.
- Editorial — serif headings, narrow newspaper column, 'Service
  Report' eyebrow + title, flat rectangular badges and dateline.

## Architecture
- Single `StatusPageThemeProvider` hosts CSS custom-property tokens
  per theme and resolves light/dark based on admin-forced mode,
  falling back to `prefers-color-scheme` with a matchMedia listener.
- Each theme owns only its `*StatusPage.tsx` + scoped CSS file.
  The heatmap, histogram, and infrastructure renderers are shared
  across all four themes (parameterized by a `classPrefix`) to avoid
  the 12-file duplication the initial draft had.
- Renderer lookup table in `Status/index.tsx` replaces a 4-way
  ternary chain; unknown themes fall through to the legacy renderer.
- `resolveOverallStatus`, `statusBadgeKey`, `monoFirstChar`, and
  `monitorBadgeTone` are extracted to `themes/shared/overallStatus.tsx`.

## Admin UX
- `ThemePicker` uses the project's `RadioWithDescription` and
  `Select` components — one radio card per theme plus an Auto/
  Light-only/Dark-only mode dropdown.
- `BrowserFrame` wraps the preview in the admin panel with a mock
  chrome (traffic lights + URL bar) that adopts the status page's
  theme tokens. Edge-to-edge fill with no gray bleed.
- Public route renders the theme directly on the viewport with the
  document body painted to the theme background, reverted on unmount.

## Performance & polish
- Histogram's derived stats (padded array, max, avg, peak) are
  memoized on `checks`; `max` is reused for `peak` instead of
  computing twice.
- Editorial's dateline is wrapped in `useMemo` so the 10s poll
  doesn't rerender "April 23, 2026" as a changing string.
- Provider's `setSystemMode` reconciliation uses the updater form
  to avoid an extra render when the value is unchanged.
- `monoFirstChar` no longer uses a non-null assertion.

## Form plumbing
- `useStatusPageForm` defaults include `theme` + `themeMode`.
- `Validation/statusPage.ts` accepts both as optional zod enums.
- `Pages/StatusPage/Create/index.tsx` appends both to FormData on
  create and update.

## CLAUDE.md
- Dev port note: local client runs on 10001 (5173 is used by a
  different local project); server `CLIENT_HOST` is set to match.
This commit is contained in:
gorkem-bwl committed 2026-04-23 22:51:40 -04:00
1 parent ad964446de
commit 944ee74a1d
28 files changed
+3967 -114

No files matched your search

@@ -0,0 +1,83 @@
import Tooltip from "@mui/material/Tooltip";
import Box from "@mui/material/Box";
import Stack from "@mui/material/Stack";
import Typography from "@mui/material/Typography";
import { useTranslation } from "react-i18next";
import type { CheckSnapshot } from "@/Types/Check";
import { formatCheckTimestamp } from "./timeFormat";
const CELLS = 25;
interface Props {
checks: CheckSnapshot[];
classPrefix: string;
}
const classify = (check: CheckSnapshot): "fast" | "med" | "slow" | "down" => {
if (!check.status) return "down";
const rt = check.responseTime ?? 0;
if (rt > 500) return "slow";
if (rt > 250) return "med";
return "fast";
};
export const ThemedHeatmap = ({ checks, classPrefix }: Props) => {
const { t } = useTranslation();
const source = checks.slice(0, CELLS).reverse();
const padded: (CheckSnapshot | null)[] = [
...Array.from({ length: Math.max(0, CELLS - source.length) }, () => null),
...source,
];
return (
<Box
className={`${classPrefix}-heatmap`}
role="img"
aria-label={t("pages.statusPages.monitorsList.chart.heatmapAria")}
>
{padded.map((check, i) => {
if (!check) {
return (
<Box
key={`empty-${i}`}
className={`${classPrefix}-heatmap-cell ${classPrefix}-empty`}
/>
);
}
const cls = classify(check);
const tooltipContent = (
<Stack gap={0.25}>
<Typography
variant="caption"
fontWeight={600}
>
{check.status
? `${check.responseTime} ms`
: t("pages.statusPages.monitorsList.chart.downTooltip")}
</Typography>
<Typography
variant="caption"
sx={{ opacity: 0.8 }}
>
{formatCheckTimestamp(check.createdAt as unknown as string)}
</Typography>
</Stack>
);
return (
<Tooltip
key={check.id ?? i}
title={tooltipContent}
arrow
placement="top"
>
<Box
className={`${classPrefix}-heatmap-cell ${classPrefix}-${cls}`}
aria-label={`${check.responseTime} ms, ${check.status ? "up" : "down"}`}
/>
</Tooltip>
);
})}
</Box>
);
};
@@ -0,0 +1,99 @@
import { useMemo } from "react";
import Tooltip from "@mui/material/Tooltip";
import Box from "@mui/material/Box";
import Stack from "@mui/material/Stack";
import Typography from "@mui/material/Typography";
import { useTranslation } from "react-i18next";
import type { CheckSnapshot } from "@/Types/Check";
import { formatCheckTimestamp } from "./timeFormat";
const CELLS = 25;
const MIN_HEIGHT_PCT = 6;
interface Props {
checks: CheckSnapshot[];
classPrefix: string;
statsGap?: number;
}
const tone = (check: CheckSnapshot): "up" | "down" => (check.status ? "up" : "down");
export const ThemedHistogram = ({ checks, classPrefix, statsGap = 1 }: Props) => {
const { t } = useTranslation();
const { padded, max, avg, peak } = useMemo(() => {
const source = checks.slice(0, CELLS).reverse();
const out: (CheckSnapshot | null)[] = [
...Array.from({ length: Math.max(0, CELLS - source.length) }, () => null),
...source,
];
const valid = out.filter((c): c is CheckSnapshot => c !== null && c.responseTime > 0);
const maxRt = valid.length ? Math.max(...valid.map((c) => c.responseTime)) : 1;
const avgRt = valid.length
? Math.round(valid.reduce((s, c) => s + c.responseTime, 0) / valid.length)
: 0;
return { padded: out, max: maxRt, avg: avgRt, peak: valid.length ? maxRt : 0 };
}, [checks]);
return (
<Stack gap={statsGap}>
<Box className={`${classPrefix}-histogram`}>
{padded.map((check, i) => {
if (!check) {
return (
<Box
key={`empty-${i}`}
className={`${classPrefix}-bar ${classPrefix}-empty`}
style={{ height: `${MIN_HEIGHT_PCT}%` }}
/>
);
}
const height = Math.max(
MIN_HEIGHT_PCT,
Math.round((check.responseTime / max) * 100)
);
const tooltipContent = (
<Stack gap={0.25}>
<Typography
variant="caption"
fontWeight={600}
>
{check.status
? `${check.responseTime} ms`
: t("pages.statusPages.monitorsList.chart.downTooltip")}
</Typography>
<Typography
variant="caption"
sx={{ opacity: 0.8 }}
>
{formatCheckTimestamp(check.createdAt as unknown as string)}
</Typography>
</Stack>
);
return (
<Tooltip
key={check.id ?? i}
title={tooltipContent}
arrow
placement="top"
>
<Box
className={`${classPrefix}-bar ${classPrefix}-${tone(check)}`}
style={{ height: `${height}%` }}
aria-label={`${check.responseTime} ms`}
/>
</Tooltip>
);
})}
</Box>
<Stack
direction="row"
justifyContent="space-between"
className={`${classPrefix}-chart-stats`}
>
<span>{t("pages.statusPages.monitorsList.chart.avg", { value: avg })}</span>
<span>{t("pages.statusPages.monitorsList.chart.max", { value: peak })}</span>
</Stack>
</Stack>
);
};
@@ -0,0 +1,102 @@
import Box from "@mui/material/Box";
import prettyBytes from "pretty-bytes";
import { useTranslation } from "react-i18next";
import type { Monitor } from "@/Types/Monitor";
interface Props {
monitor: Monitor & { checks?: Monitor["recentChecks"] };
classPrefix: string;
}
interface Gauge {
key: string;
label: string;
value: number;
sub: string;
}
const PCT = 100;
export const ThemedInfrastructure = ({ monitor, classPrefix }: Props) => {
const { t } = useTranslation();
const latest = monitor.recentChecks?.[0] ?? monitor.checks?.[0];
if (!latest) {
return (
<Box className={`${classPrefix}-infra-empty`}>
{t("pages.statusPages.monitorsList.noData")}
</Box>
);
}
const gauges: Gauge[] = [];
if (typeof latest.cpu?.usage_percent === "number") {
const pct = latest.cpu.usage_percent * PCT;
gauges.push({
key: "cpu",
label: t("pages.statusPages.monitorsList.infrastructure.cpu"),
value: pct,
sub: `${pct.toFixed(0)}%`,
});
}
if (
typeof latest.memory?.usage_percent === "number" &&
typeof latest.memory?.used_bytes === "number" &&
typeof latest.memory?.total_bytes === "number"
) {
gauges.push({
key: "memory",
label: t("pages.statusPages.monitorsList.infrastructure.memory"),
value: latest.memory.usage_percent * PCT,
sub: `${prettyBytes(latest.memory.used_bytes)} / ${prettyBytes(latest.memory.total_bytes)}`,
});
}
if (latest.disk && latest.disk.length > 0) {
const disks = latest.disk;
const avg =
(disks.reduce((acc, d) => acc + (d?.usage_percent ?? 0), 0) / disks.length) * PCT;
const used = disks.reduce((acc, d) => acc + (d?.used_bytes ?? 0), 0);
const total = disks.reduce((acc, d) => acc + (d?.total_bytes ?? 0), 0);
gauges.push({
key: "disk",
label: t("pages.statusPages.monitorsList.infrastructure.disk"),
value: avg,
sub: `${prettyBytes(used)} / ${prettyBytes(total)}`,
});
}
if (gauges.length === 0) {
return (
<Box className={`${classPrefix}-infra-empty`}>
{t("pages.statusPages.monitorsList.noData")}
</Box>
);
}
return (
<Box className={`${classPrefix}-infra`}>
{gauges.map((g) => {
const heatClass =
g.value > 85 ? `${classPrefix}-hot` : g.value > 70 ? `${classPrefix}-warm` : "";
return (
<Box
key={g.key}
className={`${classPrefix}-gauge`}
>
<Box className={`${classPrefix}-gauge-label`}>{g.label}</Box>
<Box className={`${classPrefix}-gauge-value`}>{g.value.toFixed(0)}%</Box>
<Box className={`${classPrefix}-gauge-bar`}>
<Box
className={`${classPrefix}-gauge-fill ${heatClass}`}
style={{ width: `${Math.min(100, g.value)}%` }}
/>
</Box>
<Box className={`${classPrefix}-gauge-sub`}>{g.sub}</Box>
</Box>
);
})}
</Box>
);
};
@@ -0,0 +1,160 @@
import type { ReactNode } from "react";
import {
AlertTriangle,
CircleCheck,
CircleX,
Loader,
PauseCircle,
ShieldAlert,
Wrench,
} from "lucide-react";
import type { Monitor, MonitorStatus } from "@/Types/Monitor";
export type OverallTone = "up" | "warn" | "down";
export interface OverallStatus {
tone: OverallTone;
message: string;
icon: ReactNode;
}
type StatusPageMonitor = Pick<Monitor, "status">;
interface Options {
iconSize?: number;
// Optional override for the `allUp` message key (editorial uses a more
// formal sentence).
allUpKey?: string;
}
export const resolveOverallStatus = (
monitors: StatusPageMonitor[],
t: (key: string) => string,
options: Options = {}
): OverallStatus => {
const size = options.iconSize ?? 18;
const allUpMessage = t(options.allUpKey ?? "pages.statusPages.statusBar.allUp");
if (monitors.length === 0) {
return {
tone: "warn",
message: t("pages.statusPages.statusBar.noMonitors"),
icon: <CircleX size={size} />,
};
}
const allOf = (...statuses: MonitorStatus[]) =>
monitors.every((m) => statuses.includes(m.status));
const someOf = (...statuses: MonitorStatus[]) =>
monitors.some((m) => statuses.includes(m.status));
const noneOf = (...statuses: MonitorStatus[]) =>
monitors.every((m) => !statuses.includes(m.status));
if (allOf("up")) {
return { tone: "up", message: allUpMessage, icon: <CircleCheck size={size} /> };
}
if (allOf("breached")) {
return {
tone: "down",
message: t("pages.statusPages.statusBar.allBreached"),
icon: <ShieldAlert size={size} />,
};
}
if (allOf("maintenance")) {
return {
tone: "warn",
message: t("pages.statusPages.statusBar.allMaintenance"),
icon: <Wrench size={size} />,
};
}
if (allOf("down")) {
return {
tone: "down",
message: t("pages.statusPages.statusBar.allDown"),
icon: <CircleX size={size} />,
};
}
if (allOf("paused")) {
return {
tone: "warn",
message: t("pages.statusPages.statusBar.allPaused"),
icon: <PauseCircle size={size} />,
};
}
if (allOf("initializing")) {
return {
tone: "warn",
message: t("pages.statusPages.statusBar.allInitializing"),
icon: <Loader size={size} />,
};
}
if (someOf("breached") && someOf("down")) {
return {
tone: "down",
message: t("pages.statusPages.statusBar.breachedAndDown"),
icon: <ShieldAlert size={size} />,
};
}
if (someOf("breached")) {
return {
tone: "down",
message: t("pages.statusPages.statusBar.breached"),
icon: <ShieldAlert size={size} />,
};
}
if (someOf("maintenance") && someOf("down")) {
return {
tone: "down",
message: t("pages.statusPages.statusBar.maintenanceAndDown"),
icon: <Wrench size={size} />,
};
}
if (someOf("maintenance") && noneOf("down")) {
return {
tone: "warn",
message: t("pages.statusPages.statusBar.maintenance"),
icon: <Wrench size={size} />,
};
}
if (someOf("down")) {
return {
tone: "warn",
message: t("pages.statusPages.statusBar.degraded"),
icon: <AlertTriangle size={size} />,
};
}
if (someOf("paused")) {
return {
tone: "warn",
message: t("pages.statusPages.statusBar.partiallyPaused"),
icon: <PauseCircle size={size} />,
};
}
if (someOf("initializing")) {
return {
tone: "up",
message: t("pages.statusPages.statusBar.initializing"),
icon: <Loader size={size} />,
};
}
return {
tone: "warn",
message: t("pages.statusPages.statusBar.unknown"),
icon: <AlertTriangle size={size} />,
};
};
export const statusBadgeKey: Record<MonitorStatus, string> = {
up: "pages.statusPages.monitorsList.status.up",
down: "pages.statusPages.monitorsList.status.down",
breached: "pages.statusPages.monitorsList.status.breached",
maintenance: "pages.statusPages.monitorsList.status.maintenance",
paused: "pages.statusPages.monitorsList.status.paused",
initializing: "pages.statusPages.monitorsList.status.initializing",
};
export const monoFirstChar = (s?: string): string =>
(s?.trim().charAt(0) || "?").toUpperCase();
export const monitorBadgeTone = (status: MonitorStatus): OverallTone =>
status === "up" ? "up" : status === "down" || status === "breached" ? "down" : "warn";
@@ -0,0 +1,12 @@
export const formatCheckTimestamp = (iso?: string): string => {
if (!iso) return "—";
const d = new Date(iso);
if (Number.isNaN(d.getTime())) return "—";
return d.toLocaleString(undefined, {
hour: "2-digit",
minute: "2-digit",
second: "2-digit",
month: "short",
day: "numeric",
});
};