Files
Checkmate/client/src/Pages/StatusPage/Status/themes/StatusPageThemeProvider.tsx
T
gorkem-bwl 1458cf4e4a fix(status-page): use operator-configured timezone on public pages
Anonymous visitors to a public status page have no persisted Redux
state, so ThemedHeatmap and ThemedHistogram tooltips always rendered
timestamps in the hardcoded "America/Toronto" default — regardless of
the timezone the operator configured. Even on the same domain,
ThemedHeatmap and ThemedHistogram had no code path to consume the
operator-configured statusPage.timezone returned by the API.

- Add SYSTEM_TIMEZONE module constant and a small resolveTimezone()
  helper to TimeUtils.ts. formatDateWithTz's timezone parameter is now
  optional and defaults to the system tz, so callers don't need to
  rebuild the prop -> browser -> UTC chain inline.
- Add a `timezone` field to StatusPageThemeContextValue so any themed
  component on the public page can read the page-wide tz without prop
  drilling (parallels how `theme` and `mode` are already exposed).
- Wire statusPage.timezone into StatusPageThemeProvider from
  Pages/StatusPage/Status/index.tsx (both the public route and the
  admin preview).
- ThemedHeatmap and ThemedHistogram now read tz from the context
  instead of useSelector(state.ui.timezone) — that selector was
  unreliable for anonymous visitors and removing it cuts a Redux
  subscription on the public page.
- Replace the inline `data?.timezone || Intl.DateTimeFormat()...`
  expression in useStatusPageForm.ts with resolveTimezone().

Closes #3628.
2026-05-01 22:28:12 -04:00

154 lines
4.4 KiB
TypeScript

import {
createContext,
useContext,
useEffect,
useMemo,
useState,
type ReactNode,
} from "react";
import {
DEFAULT_STATUS_PAGE_THEME,
resolveStatusPageTheme,
resolveStatusPageThemeMode,
type StatusPageTheme,
type StatusPageThemeMode,
} from "@/Types/StatusPage";
import { resolveTimezone } from "@/Utils/TimeUtils";
import { themeTokens, type StatusPageThemeTokens } from "./tokens";
type ResolvedMode = "light" | "dark";
interface StatusPageThemeContextValue {
theme: StatusPageTheme;
mode: ResolvedMode;
tokens: StatusPageThemeTokens;
timezone: string;
}
const StatusPageThemeContext = createContext<StatusPageThemeContextValue | null>(null);
const resolveSystemMode = (): ResolvedMode => {
if (typeof window === "undefined" || !window.matchMedia) return "light";
return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
};
interface Props {
theme?: StatusPageTheme;
themeMode?: StatusPageThemeMode;
timezone?: string;
/**
* When true, paint the document body with the theme background so it
* covers beyond the provider's wrapper (useful on the public route
* where no admin shell sits behind). Defaults to false for admin
* previews that already have an app background.
*/
paintBody?: boolean;
/**
* When true, the provider's wrapper div does NOT paint its own
* background or set a min-height. Use this when the wrapper is
* inside a clipped container (e.g. BrowserFrame) that already sets
* the visible background, so the wrapper's bg doesn't bleed past the
* container's rounded corners.
*/
transparent?: boolean;
children: ReactNode;
}
export const StatusPageThemeProvider = ({
theme,
themeMode,
timezone,
paintBody = false,
transparent = false,
children,
}: Props) => {
const resolvedTheme = resolveStatusPageTheme(theme);
const resolvedThemeMode = resolveStatusPageThemeMode(themeMode);
const resolvedTimezone = resolveTimezone(timezone);
const [systemMode, setSystemMode] = useState<ResolvedMode>(resolveSystemMode);
useEffect(() => {
if (resolvedThemeMode !== "auto") return;
if (typeof window === "undefined" || !window.matchMedia) return;
const mq = window.matchMedia("(prefers-color-scheme: dark)");
// Reconcile on first paint whenever we (re-)enter auto mode — only
// when it disagrees with the stored value, so we don't trigger an
// extra render on the common hot path.
const next: ResolvedMode = mq.matches ? "dark" : "light";
setSystemMode((prev) => (prev === next ? prev : next));
const handler = (e: MediaQueryListEvent) =>
setSystemMode(e.matches ? "dark" : "light");
mq.addEventListener("change", handler);
return () => mq.removeEventListener("change", handler);
}, [resolvedThemeMode]);
useEffect(() => {
if (!paintBody || typeof document === "undefined") return;
const html = document.documentElement;
const body = document.body;
const prev = {
htmlBg: html.style.background,
bodyBg: body.style.background,
bodyMargin: body.style.margin,
htmlColorScheme: html.style.colorScheme,
};
const resolvedMode = resolvedThemeMode === "auto" ? systemMode : resolvedThemeMode;
const bg = themeTokens[resolvedTheme][resolvedMode].bg;
html.style.background = bg;
body.style.background = bg;
body.style.margin = "0";
html.style.colorScheme = resolvedMode;
return () => {
html.style.background = prev.htmlBg;
body.style.background = prev.bodyBg;
body.style.margin = prev.bodyMargin;
html.style.colorScheme = prev.htmlColorScheme;
};
}, [paintBody, resolvedTheme, resolvedThemeMode, systemMode]);
const resolvedMode: ResolvedMode =
resolvedThemeMode === "auto" ? systemMode : resolvedThemeMode;
const tokens = themeTokens[resolvedTheme][resolvedMode];
const value = useMemo(
() => ({
theme: resolvedTheme,
mode: resolvedMode,
tokens,
timezone: resolvedTimezone,
}),
[resolvedTheme, resolvedMode, tokens, resolvedTimezone]
);
return (
<StatusPageThemeContext.Provider value={value}>
<div
style={
transparent
? undefined
: {
background: tokens.bg,
minHeight: "100vh",
}
}
>
{children}
</div>
</StatusPageThemeContext.Provider>
);
};
export const useStatusPageTheme = (): StatusPageThemeContextValue => {
const ctx = useContext(StatusPageThemeContext);
if (!ctx) {
return {
theme: DEFAULT_STATUS_PAGE_THEME,
mode: resolveSystemMode(),
tokens: themeTokens[DEFAULT_STATUS_PAGE_THEME][resolveSystemMode()],
timezone: resolveTimezone(),
};
}
return ctx;
};