initial commit

This commit is contained in:
Alex Holliday committed 2025-11-13 13:47:26 -08:00
1 parent 7cb985116e
commit 75acf7b38f
955 files changed
+37333 -87054

No files matched your search

@@ -0,0 +1,49 @@
import React, { useState } from "react";
import Menu from "@mui/material/Menu";
import MenuItem from "@mui/material/MenuItem";
import IconButton from "@mui/material/IconButton";
import { Settings } from "lucide-react";
export type ActionMenuItem = {
id: number | string;
label: React.ReactNode;
action: Function;
closeMenu?: boolean;
};
export const ActionsMenu = ({ items }: { items: ActionMenuItem[] }) => {
const [anchorEl, setAnchorEl] = useState<null | any>(null);
const open = Boolean(anchorEl);
const handleClick = (e: React.MouseEvent<any>) => {
e.stopPropagation();
setAnchorEl(e.currentTarget);
};
const handleClose = (e: React.MouseEvent<any>) => {
e.stopPropagation();
setAnchorEl(null);
};
return (
<div>
<IconButton onClick={handleClick}>
<Settings size={20} strokeWidth={1.5} />
</IconButton>
<Menu anchorEl={anchorEl} open={open} onClose={handleClose}>
{items.map((item) => (
<MenuItem
key={item.id}
onClick={(e: React.MouseEvent<HTMLLIElement>) => {
e.stopPropagation();
if (item.closeMenu) handleClose(e);
item.action();
}}
>
{item.label}
</MenuItem>
))}
</Menu>
</div>
);
};
@@ -0,0 +1,21 @@
import { ChevronLeft, ChevronsLeft, MoveLeft } from "lucide-react";
export const ArrowLeft = ({
type,
color = "#667085",
size = 24,
...props
}: {
type?: string,
color?: string | undefined,
size?: number,
[key: string]: any,
}) => {
if (type === "double") {
return <ChevronsLeft color={color} size={size} strokeWidth={1.5} {...props} />;
} else if (type === "long") {
return <MoveLeft color={color} size={size} strokeWidth={1.5} {...props} />;
} else {
return <ChevronLeft color={color} size={size} strokeWidth={1.5} {...props} />;
}
};
@@ -0,0 +1,19 @@
import { ChevronRight, ChevronsRight } from "lucide-react";
export const ArrowRight = ({
type,
color = "#667085",
size = 24,
...props
}: {
type?: string;
color?: string | undefined;
size?: number;
[key: string]: any;
}) => {
if (type === "double") {
return <ChevronsRight color={color} size={size} strokeWidth={1.5} {...props} />;
} else {
return <ChevronRight color={color} size={size} strokeWidth={1.5} {...props} />;
}
};
@@ -0,0 +1,57 @@
import { useAppDispatch } from "@/hooks/AppHooks";
import type { ApiResponse } from "@/hooks/UseApi";
import type { IUser } from "@/types/user";
import {
setAuthenticated,
setUser,
logout,
setSelectedTeamId,
} from "@/features/authSlice";
import { useEffect, useState } from "react";
import { useAppSelector } from "@/hooks/AppHooks";
import type { ReactNode } from "react";
import { get } from "@/utils/ApiClient";
import { useLocation } from "react-router-dom";
export const AuthVerifier = ({ children }: { children: ReactNode }) => {
const location = useLocation();
const isAuthRoute =
["/login", "/register"].includes(location.pathname) ||
location.pathname.startsWith("/recovery");
const isPublicRoute = location.pathname.startsWith("/status-pages/public");
const [isVerifying, setIsVerifying] = useState(true);
const dispatch = useAppDispatch();
const selectedTeamId = useAppSelector((state) => state.auth.selectedTeamId);
useEffect(() => {
if (isAuthRoute || isPublicRoute) {
setIsVerifying(false);
return;
}
const verify = async () => {
try {
const res = await get<ApiResponse<IUser>>("/auth/me");
const user: IUser = res.data.data;
dispatch(setAuthenticated(true));
dispatch(setUser(user));
if (
!selectedTeamId ||
!user.teams.find((t) => t.id === selectedTeamId)
) {
dispatch(setSelectedTeamId(user.teams[0].id));
}
} catch (error) {
console.error(error);
dispatch(logout());
} finally {
setIsVerifying(false);
}
};
verify();
}, [dispatch]);
if (isVerifying) return null;
return <>{children}</>;
};
@@ -0,0 +1,41 @@
import Stack from "@mui/material/Stack";
import Box from "@mui/material/Box";
import { HeaderAuth } from "@/components/auth";
import Logo from "@/assets/icons/checkmate-icon.svg?react";
import type { StackProps } from "@mui/material/Stack";
import { useTheme } from "@mui/material/styles";
import { Typography } from "@mui/material";
interface AuthBasePageProps extends StackProps {
title?: string;
subtitle?: string;
children: React.ReactNode;
}
export const AuthBasePage: React.FC<AuthBasePageProps> = ({
children,
title,
subtitle,
...props
}) => {
const theme = useTheme();
return (
<Stack gap={theme.spacing(10)} minHeight="100vh" {...props}>
<HeaderAuth />
<Stack
alignItems="center"
margin="auto"
width="100%"
gap={theme.spacing(4)}
>
<Box width={{ xs: 60, sm: 70, md: 80 }} mb={theme.spacing(10)}>
<Logo style={{ width: "100%", height: "100%" }} />
</Box>
<Typography variant="h1">{title}</Typography>
<Typography variant="h1">{subtitle}</Typography>
{children}
</Stack>
</Stack>
);
};
+22
View File
@@ -0,0 +1,22 @@
import Stack from "@mui/material/Stack";
import { useTheme } from "@mui/material/styles";
import { LanguageSelector, ThemeSwitch } from "@/components/inputs";
export const HeaderAuth = () => {
const theme = useTheme();
return (
<Stack
width={"100%"}
direction="row"
alignItems="center"
justifyContent="flex-end"
py={theme.spacing(4)}
px={theme.spacing(12)}
gap={theme.spacing(4)}
>
<LanguageSelector />
<ThemeSwitch />
</Stack>
);
};
+2
View File
@@ -0,0 +1,2 @@
export { HeaderAuth } from "./HeaderAuth";
export { AuthBasePage } from "./AuthBasePage";
@@ -0,0 +1,62 @@
import Stack from "@mui/material/Stack";
import { ButtonGroup, Button } from "@/components/inputs";
import { useTheme } from "@mui/material/styles";
import Typography from "@mui/material/Typography";
import useMediaQuery from "@mui/material/useMediaQuery";
export const HeaderRange = ({
range,
setRange,
loading,
}: {
range: string;
setRange: Function;
loading: boolean;
}) => {
const theme = useTheme();
const isSmall = useMediaQuery(theme.breakpoints.down("md"));
return (
<Stack
gap={theme.spacing(9)}
direction={isSmall ? "column" : "row"}
alignItems={"center"}
justifyContent="flex-end"
>
<Typography variant="body2">{`Showing statistics for past ${range}`}</Typography>
<ButtonGroup
orientation={isSmall ? "vertical" : "horizontal"}
fullWidth={isSmall}
variant="contained"
color={"primary"}
>
<Button
color={range === "2h" ? "secondary" : "primary"}
onClick={() => setRange("2h")}
loading={loading}
>
Recent
</Button>
<Button
color={range === "24h" ? "secondary" : "primary"}
onClick={() => setRange("24h")}
loading={loading}
>
Day
</Button>
<Button
color={range === "7d" ? "secondary" : "primary"}
onClick={() => setRange("7d")}
loading={loading}
>
7 days
</Button>
<Button
color={range === "30d" ? "secondary" : "primary"}
onClick={() => setRange("30d")}
loading={loading}
>
30 days
</Button>
</ButtonGroup>
</Stack>
);
};
@@ -0,0 +1,23 @@
import Box from "@mui/material/Box";
import { useTheme } from "@mui/material/styles";
import type { SxProps } from "@mui/material/styles";
type BaseBoxProps = React.PropsWithChildren<{ sx?: SxProps }>;
export const BaseBox: React.FC<BaseBoxProps> = ({ children, sx }) => {
const theme = useTheme();
return (
<Box
sx={{
backgroundColor: theme.palette.primary.main,
border: 1,
borderStyle: "solid",
borderColor: theme.palette.primary.lowContrast,
borderRadius: theme.shape.borderRadius,
...sx,
}}
>
{children}
</Box>
);
};
@@ -0,0 +1,138 @@
import Stack from "@mui/material/Stack";
import { ErrorFallback, EmptyFallback, EmptyMonitorFallback } from "./Fallback";
import { Breadcrumb } from "./Breadcrumb";
import type { StackProps } from "@mui/material/Stack";
import { useTheme } from "@mui/material/styles";
import { useTranslation } from "react-i18next";
interface BasePageProps extends StackProps {
children: React.ReactNode;
breadcrumbOverride?: string[];
}
export const BasePage: React.FC<BasePageProps> = ({
children,
breadcrumbOverride,
...props
}: {
children: React.ReactNode;
breadcrumbOverride?: string[];
}) => {
const theme = useTheme();
return (
<Stack spacing={theme.spacing(10)} {...props}>
<Breadcrumb breadcrumbOverride={breadcrumbOverride} />
{children}
</Stack>
);
};
interface BasePageWithStatesProps extends StackProps {
loading: boolean;
error: any;
items: any[];
bullets: string[] | unknown;
page: string;
actionButtonText: string;
actionLink: string;
children: React.ReactNode;
}
export const BasePageWithStates: React.FC<BasePageWithStatesProps> = ({
loading,
error,
items,
page,
bullets,
actionButtonText,
actionLink,
children,
...props
}: BasePageWithStatesProps) => {
const showLoading = loading && (!items || items.length === 0);
if (showLoading) {
return null;
}
if (error) {
return (
<ErrorFallback
title="Something went wrong..."
subtitle="Please try again later"
/>
);
}
if (isEmpty(items)) {
return (
<EmptyFallback
bullets={bullets}
title={page}
actionButtonText={actionButtonText}
actionLink={actionLink}
/>
);
}
return <BasePage {...props}>{children}</BasePage>;
};
interface MonitorBasePageWithStatesProps extends StackProps {
loading: boolean;
error: any;
items: any[];
page: string;
actionLink?: string;
children: React.ReactNode;
}
const isEmpty = (items: any[]) => {
if (!items) return true;
if (Array.isArray(items) && items.length === 0) return true;
return false;
};
export const MonitorBasePageWithStates: React.FC<
MonitorBasePageWithStatesProps
> = ({
loading,
error,
items,
page,
actionLink,
children,
...props
}: MonitorBasePageWithStatesProps) => {
const { t } = useTranslation();
const showLoading = loading && (!items || items.length === 0);
if (showLoading) {
return null;
}
if (error) {
return (
<ErrorFallback
title="Something went wrong..."
subtitle="Please try again later"
/>
);
}
if (isEmpty(items)) {
return (
<EmptyMonitorFallback
page={page}
title={t(`${page}Monitor.fallback.title`)}
bullets={t(`${page}Monitor.fallback.checks`, { returnObjects: true })}
actionButtonText={t(`${page}Monitor.fallback.actionButton`)}
actionLink={actionLink || ""}
/>
);
}
return <BasePage {...props}>{children}</BasePage>;
};
@@ -0,0 +1,126 @@
import MuiBreadcrumbs from "@mui/material/Breadcrumbs";
import Typography from "@mui/material/Typography";
import { Link, useLocation } from "react-router";
import { useTheme } from "@mui/material/styles";
import { ChevronRight, Home } from "lucide-react";
const pathNameMap: Record<string, string> = {
uptime: "Uptime Monitors",
pagespeed: "PageSpeed Monitors",
infrastructure: "Infrastructure Monitors",
diagnostics: "Diagnostics",
incidents: "Incidents",
maintenance: "Maintenance",
"notification-channels": "Notification Channels",
"status-pages": "Status Pages",
teams: "Teams",
settings: "Settings",
create: "Create",
configure: "Configure",
invite: "Invite",
"team-members": "Team Members",
};
export const Breadcrumb = ({
breadcrumbOverride,
}: {
breadcrumbOverride?: string[];
}) => {
const theme = useTheme();
const location = useLocation();
// Don't show breadcrumb on dashboard
if (location.pathname === "/" || location.pathname === "/uptime") {
return null;
}
const pathnames =
breadcrumbOverride || location.pathname.split("/").filter((x) => x);
// Don't show if only one level (e.g., /uptime)
if (pathnames.length === 0) {
return null;
}
return (
<MuiBreadcrumbs
separator={<ChevronRight size={16} strokeWidth={1.5} />}
sx={{
fontSize: "14px",
marginBottom: theme.spacing(6),
"& .MuiBreadcrumbs-separator": {
color: theme.palette.primary.contrastTextTertiary,
},
}}
>
<Link
to="/uptime"
style={{
display: "flex",
alignItems: "center",
gap: theme.spacing(2),
textDecoration: "none",
color: theme.palette.primary.contrastTextTertiary,
}}
>
<Home size={16} strokeWidth={1.5} />
<Typography
sx={{
fontSize: "14px",
color: theme.palette.primary.contrastTextTertiary,
"&:hover": {
color: theme.palette.accent.main,
},
}}
>
Home
</Typography>
</Link>
{pathnames.map((value, index) => {
const last = index === pathnames.length - 1;
const to = `/${pathnames.slice(0, index + 1).join("/")}`;
let displayName =
pathNameMap[value] || value.charAt(0).toUpperCase() + value.slice(1);
// Paths that are IDs should be detail pages
if (value.length === 24 || value.match(/^[a-f0-9-]{36}$/)) {
displayName = "Details";
}
return last ? (
<Typography
key={to}
sx={{
fontSize: "14px",
fontWeight: 600,
color: theme.palette.accent.main,
}}
>
{displayName}
</Typography>
) : (
<Link
key={to}
to={to}
style={{
textDecoration: "none",
}}
>
<Typography
sx={{
fontSize: "14px",
color: theme.palette.primary.contrastTextTertiary,
"&:hover": {
color: theme.palette.accent.main,
},
}}
>
{displayName}
</Typography>
</Link>
);
})}
</MuiBreadcrumbs>
);
};
@@ -0,0 +1,52 @@
import Stack from "@mui/material/Stack";
import Typography from "@mui/material/Typography";
import { Check } from "lucide-react";
import { useTheme } from "@mui/material/styles";
export const BulletPointCheck = ({
text,
variant = "info",
}: {
text: string;
noHighlightText?: string;
variant?: "success" | "error" | "info";
}) => {
const theme = useTheme();
const colors: Record<string, string | undefined> = {
success: theme.palette.success.main,
error: theme.palette.error.main,
info: theme.palette.primary.contrastTextSecondary,
};
return (
<Stack
direction="row"
className="check"
gap={theme.spacing(6)}
alignItems="center"
>
<Check
size={16}
strokeWidth={1.5}
style={{
flexShrink: 0,
}}
/>
<Typography
component="span"
color={
variant === "info"
? theme.palette.primary.contrastTextSecondary
: colors[variant]
}
fontWeight={450}
sx={{
opacity: 0.9,
whiteSpace: 'nowrap',
}}
>
{text}
</Typography>
</Stack>
);
};
@@ -0,0 +1,23 @@
export const Dot = ({
color = "gray",
size = "4px",
style,
}: {
color?: string;
size?: string;
style?: React.CSSProperties;
}) => {
return (
<span
style={{
content: '""',
width: size,
height: size,
borderRadius: "50%",
backgroundColor: color,
opacity: 0.8,
...style,
}}
/>
);
};
@@ -0,0 +1,199 @@
import Box from "@mui/material/Box";
import Stack from "@mui/material/Stack";
import SkeletonCard from "@/components/design-elements/SkeletonCard";
import Typography from "@mui/material/Typography";
import { BulletPointCheck } from "@/components/design-elements";
import { Button } from "@/components/inputs";
import { useNavigate } from "react-router";
import useMediaQuery from "@mui/material/useMediaQuery";
import { useTheme } from "@mui/material/styles";
import type { BoxProps } from "@mui/material";
interface BaseFallbackProps extends BoxProps {
children: React.ReactNode;
}
export const BaseFallback: React.FC<BaseFallbackProps> = ({
children,
...props
}) => {
const theme = useTheme();
const isSmall = useMediaQuery(theme.breakpoints.down("md"));
return (
<Box
margin={isSmall ? "inherit" : "auto"}
marginTop={isSmall ? "33%" : "10%"}
width={{
sm: "90%",
md: "70%",
lg: "50%",
xl: "40%",
}}
padding={theme.spacing(16)}
bgcolor={theme.palette.primary.main}
position="relative"
border={1}
borderColor={theme.palette.primary.lowContrast}
borderRadius={theme.shape.borderRadius}
overflow="hidden"
sx={{
borderStyle: "dashed",
}}
{...props}
>
<Box sx={{ marginTop: "100px" }}>
<Stack
alignItems="center"
gap={theme.spacing(20)}
sx={{
width: "fit-content",
margin: "auto",
marginTop: 0,
}}
>
<Box
sx={{
zIndex: 1,
display: "flex",
justifyContent: "center",
alignItems: "center",
width: "100%",
}}
>
<SkeletonCard showHalo={true} />
</Box>
<Stack
gap={theme.spacing(4)}
alignItems="center"
maxWidth={"300px"}
zIndex={1}
>
{children}
</Stack>
</Stack>
</Box>
</Box>
);
};
export const ErrorFallback = ({
title,
subtitle,
}: {
title: string;
subtitle: string;
}) => {
const theme = useTheme();
return (
<BaseFallback>
<Typography
variant="h1"
marginY={theme.spacing(4)}
color={theme.palette.primary.contrastTextTertiary}
>
{title}
</Typography>
<Typography>{subtitle}</Typography>
</BaseFallback>
);
};
export const EmptyFallback = ({
title,
bullets,
actionButtonText,
actionLink,
}: {
title: string;
bullets: any;
actionButtonText: string;
actionLink: string;
}) => {
const theme = useTheme();
const navigate = useNavigate();
return (
<BaseFallback>
<Stack gap={theme.spacing(10)} zIndex={1} alignItems="center">
<Typography component="h1" color={theme.palette.primary.contrastText}>
{title}
</Typography>
<Stack
sx={{
flexWrap: "wrap",
gap: theme.spacing(2),
maxWidth: "1100px",
width: "100%",
}}
>
{bullets?.map((bullet: string) => (
<BulletPointCheck
text={bullet}
key={`${bullet}-${Math.random()}`}
/>
))}
</Stack>
<Stack>
<Button
variant="contained"
color="accent"
onClick={() => navigate(actionLink)}
>
{actionButtonText}
</Button>
</Stack>
</Stack>
</BaseFallback>
);
};
export const EmptyMonitorFallback = ({
page,
title,
bullets,
actionButtonText,
actionLink,
}: {
page: string;
title: string;
bullets: any;
actionButtonText: string;
actionLink: string;
}) => {
const theme = useTheme();
const navigate = useNavigate();
return (
<BaseFallback>
<Stack gap={theme.spacing(10)} zIndex={1} alignItems="center">
<Typography component="h1" color={theme.palette.primary.contrastText}>
{title}
</Typography>
<Stack
sx={{
flexWrap: "wrap",
gap: theme.spacing(2),
maxWidth: "1100px",
width: "100%",
}}
>
{bullets?.map((bullet: string, index: number) => (
<BulletPointCheck
text={bullet}
key={`${(page + "Monitors").trim().split(" ")[0]}-${index}`}
/>
))}
</Stack>
<Stack>
<Button
variant="contained"
color="accent"
onClick={() => navigate(actionLink)}
>
{actionButtonText}
</Button>
</Stack>
</Stack>
</BaseFallback>
);
};
@@ -0,0 +1,109 @@
import Box from "@mui/material/Box";
import Typography from "@mui/material/Typography";
import { useTheme } from "@mui/material/styles";
import { useMemo, useState, useEffect } from "react";
import { getInfraGaugeColor } from "@/utils/MonitorUtils";
const MINIMUM_VALUE = 0;
const MAXIMUM_VALUE = 100;
export const Gauge = ({
isLoading = false,
progress = 0,
radius = 70,
strokeWidth = 15,
precision = 1,
unit = "%",
}: {
isLoading?: boolean;
progress?: number;
radius?: number;
strokeWidth?: number;
precision?: number;
unit?: string;
}) => {
const theme = useTheme();
const progressWithinRange = Math.max(
MINIMUM_VALUE,
Math.min(progress, MAXIMUM_VALUE)
);
// Calculate the length of the stroke for the circle
const { circumference, totalSize, strokeLength } = useMemo(
() => ({
circumference: 2 * Math.PI * radius,
totalSize: radius * 2 + strokeWidth * 2,
strokeLength: (progress / 100) * (2 * Math.PI * radius),
}),
[radius, strokeWidth, progress]
);
const [offset, setOffset] = useState(circumference);
useEffect(() => {
setOffset(circumference);
const timer = setTimeout(() => {
setOffset(circumference - strokeLength);
}, 100);
return () => clearTimeout(timer);
}, [progress, circumference, strokeLength]);
const fillColor = getInfraGaugeColor(progressWithinRange, theme);
if (isLoading) {
return;
}
return (
<Box
display={"inline-block"}
position={"relative"}
width={radius}
height={radius}
bgcolor={theme.palette.primary.main}
borderRadius={"50%"}
>
<svg
viewBox={`0 0 ${totalSize} ${totalSize}`}
width={radius}
height={radius}
>
<circle
stroke={theme.palette.secondary.main}
strokeWidth={strokeWidth}
fill="none"
cx={totalSize / 2}
cy={totalSize / 2}
r={radius}
/>
<circle
stroke={fillColor}
strokeWidth={strokeWidth}
strokeDasharray={`${circumference} ${circumference}`}
strokeDashoffset={offset}
fill="none"
cx={totalSize / 2}
cy={totalSize / 2}
r={radius}
style={{
transform: "rotate(-90deg)",
transformOrigin: "center",
transition: "stroke-dashoffset 1.5s ease-in-out",
}}
/>
</svg>
<Typography
style={{
position: "absolute",
top: "50%",
left: "50%",
transform: "translate(-50%, -50%)",
}}
>
{`${progressWithinRange.toFixed(precision)}${unit}`}
</Typography>
</Box>
);
};
@@ -0,0 +1,53 @@
import Stack from "@mui/material/Stack";
import Typography from "@mui/material/Typography";
import { useTheme } from "@mui/material/styles";
import { Info } from "lucide-react";
interface InfoBoxProps {
title: string;
description: string;
}
export const InfoBox: React.FC<InfoBoxProps> = ({ title, description }) => {
const theme = useTheme();
return (
<Stack
direction="row"
spacing={theme.spacing(4)}
sx={{
padding: theme.spacing(6),
backgroundColor:
theme.palette.mode === "dark"
? "rgba(59, 130, 246, 0.1)"
: "rgba(59, 130, 246, 0.05)",
borderRadius: theme.shape.borderRadius,
borderLeft: `4px solid ${theme.palette.accent.main}`,
}}
>
<Info
size={24}
strokeWidth={1.5}
style={{
color: theme.palette.accent.main,
flexShrink: 0,
marginTop: theme.spacing(1),
}}
/>
<Stack spacing={theme.spacing(4)}>
<Typography variant="h2" sx={{ color: theme.palette.accent.main }}>
{title}
</Typography>
<Typography
variant="body1"
sx={{
lineHeight: 1.7,
color: theme.palette.primary.contrastTextSecondary,
}}
>
{description}
</Typography>
</Stack>
</Stack>
);
};
@@ -0,0 +1,44 @@
import Stack from "@mui/material/Stack";
import Box from "@mui/material/Box";
import { useTheme } from "@mui/material/styles";
export const PulseDot = ({ color }: { color: string }) => {
const theme = useTheme();
return (
<Stack
width="26px"
height="24px"
alignItems="center"
justifyContent="center"
>
<Box
minWidth="18px"
minHeight="18px"
sx={{
position: "relative",
backgroundColor: color,
borderRadius: "50%",
"&::before": {
content: `""`,
position: "absolute",
width: "100%",
height: "100%",
backgroundColor: "inherit",
borderRadius: "50%",
animation: "ripple 1.8s ease-out infinite",
},
"&::after": {
content: `""`,
position: "absolute",
width: "7px",
height: "7px",
borderRadius: "50%",
backgroundColor: theme.palette.accent.contrastText,
top: "50%",
left: "50%",
transform: "translate(-50%, -50%)",
},
}}
/>
</Stack>
);
};
@@ -0,0 +1,151 @@
import React from "react";
import { Box, Stack, useTheme } from "@mui/material";
interface SkeletonCardProps {
width?: number | string;
showHalo?: boolean;
}
/**
* Skeleton card stack component for empty states
* Shows an animated stacked card design with pulsing skeleton elements
* Default size is 60% of original design
*/
const SkeletonCard: React.FC<SkeletonCardProps> = ({
width = 216,
showHalo = true,
}) => {
const theme = useTheme();
const pulseAnimation = {
"@keyframes pulse": {
"0%, 100%": { opacity: 1 },
"50%": { opacity: 0.72 },
},
};
const floatAnimation = {
"@keyframes float": {
"0%, 100%": { transform: "rotate(5deg) translate(12px, -20px)" },
"50%": { transform: "rotate(5deg) translate(12px, -24px)" },
},
};
const cardStyle = {
width: width,
height: 57,
borderRadius: theme.shape.borderRadius,
background:
theme.palette.mode === "dark" ? "#222222" : theme.palette.primary.main,
boxShadow:
theme.palette.mode === "dark"
? "0 8px 30px rgba(0,0,0,.3), 0 0 0 1px rgba(255,255,255,.05) inset"
: "0 8px 30px rgba(0,0,0,.08), 0 0 0 1px rgba(0,0,0,.05) inset",
display: "flex",
gap: theme.spacing(5),
alignItems: "center",
padding: theme.spacing(5),
};
const blockStyle = {
width: 55,
height: 34,
borderRadius: theme.shape.borderRadius,
background: theme.palette.secondary.main,
border: `1px solid ${theme.palette.primary.lowContrast}`,
animation: "pulse 1.6s ease-in-out infinite",
...pulseAnimation,
};
const lineStyle = {
height: 7,
borderRadius: theme.shape.borderRadius,
background: theme.palette.secondary.main,
border: `1px solid ${theme.palette.primary.lowContrast}`,
animation: "pulse 1.6s ease-in-out infinite",
...pulseAnimation,
};
return (
<Box sx={{ position: "relative" }}>
{showHalo && (
<Box
sx={{
position: "absolute",
inset: 0,
display: "grid",
placeItems: "center",
pointerEvents: "none",
"&::before": {
content: '""',
width: "260px",
height: "260px",
borderRadius: "999px",
background:
theme.palette.mode === "dark"
? "rgba(255, 255, 255, 0.05)"
: "#fff",
filter: "blur(60px)",
opacity: 0.9,
},
}}
aria-hidden="true"
/>
)}
{/* Card stack */}
<Box sx={{ position: "relative", zIndex: 1 }}>
{/* Front card (now at bottom) */}
<Box sx={cardStyle}>
<Box sx={blockStyle} />
<Stack sx={{ flex: 1, gap: "12px" }}>
{/* Empty space to maintain card height */}
</Stack>
</Box>
{/* Back card A */}
<Box
sx={{
...cardStyle,
transform: "rotate(-4deg) translate(-12px, -12px)",
filter: "blur(.2px)",
position: "absolute",
left: 0,
top: 0,
}}
aria-hidden="true"
>
<Box sx={blockStyle} />
<Stack sx={{ flex: 1, gap: "12px" }}>
<Box sx={{ ...lineStyle, width: "60%" }} />
<Box sx={{ ...lineStyle, width: "80%" }} />
<Box sx={{ ...lineStyle, width: "40%" }} />
</Stack>
</Box>
{/* Back card B */}
<Box
sx={{
...cardStyle,
transform: "rotate(5deg) translate(12px, -20px)",
filter: "blur(.3px)",
position: "absolute",
left: 0,
top: 0,
animation: "float 3s ease-in-out 5",
...floatAnimation,
}}
aria-hidden="true"
>
<Box sx={blockStyle} />
<Stack sx={{ flex: 1, gap: "12px" }}>
<Box sx={{ ...lineStyle, width: "60%" }} />
<Box sx={{ ...lineStyle, width: "80%" }} />
<Box sx={{ ...lineStyle, width: "40%" }} />
</Stack>
</Box>
</Box>
</Box>
);
};
export default SkeletonCard;
@@ -0,0 +1,68 @@
import { Fragment } from "react";
import Stack from "@mui/material/Stack";
import Box from "@mui/material/Box";
import Typography from "@mui/material/Typography";
import { useTheme } from "@mui/material/styles";
import useMediaQuery from "@mui/material/useMediaQuery";
export const SplitBox = ({
left,
right,
}: {
left: React.ReactNode;
right: React.ReactNode;
}) => {
const theme = useTheme();
const isSmall = useMediaQuery(theme.breakpoints.down("md"));
return (
<Stack
direction={isSmall ? "column" : "row"}
bgcolor={theme.palette.primary.main}
border={1}
borderColor={theme.palette.primary.lowContrast}
borderRadius={theme.spacing(2)}
>
<Box
padding={theme.spacing(15)}
borderRight={isSmall ? 0 : 1}
borderBottom={isSmall ? 1 : 0}
borderColor={theme.palette.primary.lowContrast}
flex={0.7}
sx={{
background:
theme.palette.mode === "dark"
? "linear-gradient(135deg, rgba(255, 255, 255, 0.01) 0%, rgba(255, 255, 255, 0.02) 100%)"
: "linear-gradient(135deg, rgba(0, 0, 0, 0.01) 0%, rgba(0, 0, 0, 0.02) 100%)",
}}
>
{left}
</Box>
<Box flex={1} padding={theme.spacing(15)}>
{right}
</Box>
</Stack>
);
};
export const ConfigBox = ({
title,
subtitle,
rightContent,
}: {
title: string;
subtitle: string;
rightContent: React.ReactNode;
}) => {
return (
<SplitBox
left={
<Fragment>
<Typography textTransform={"capitalize"} component="h2" variant="h2">
{title}
</Typography>
<Typography component="p">{subtitle}</Typography>
</Fragment>
}
right={rightContent}
/>
);
};
@@ -0,0 +1,82 @@
import Stack from "@mui/material/Stack";
import Typography from "@mui/material/Typography";
import Box from "@mui/material/Box";
import { useTheme } from "@mui/material/styles";
import useMediaQuery from "@mui/material/useMediaQuery";
import type { PaletteKey } from "@/theme/theme";
import { BaseBox, TooltipWithInfo } from "@/components/design-elements";
import type { SxProps } from "@mui/material";
type GradientBox = React.PropsWithChildren<{
palette?: PaletteKey;
sx?: SxProps;
}>;
export const GradientBox: React.FC<GradientBox> = ({
children,
palette,
sx,
}) => {
const theme = useTheme();
const isSmall = useMediaQuery(theme.breakpoints.down("md"));
const bg = palette
? `linear-gradient(to bottom right, ${theme.palette[palette].main} 30%, ${theme.palette[palette].lowContrast} 70%)`
: `linear-gradient(340deg, ${theme.palette.tertiary.main} 10%, ${theme.palette.primary.main} 45%)`;
return (
<BaseBox
sx={{
padding: `${theme.spacing(4)} ${theme.spacing(8)}`,
width: isSmall
? `calc(50% - (1 * ${theme.spacing(8)} / 2))`
: `calc(25% - (3 * ${theme.spacing(8)} / 4))`,
background: bg,
...sx,
}}
>
{children}
</BaseBox>
);
};
type StatBoxProps = React.PropsWithChildren<{
title: string;
subtitle: string;
palette?: PaletteKey;
sx?: SxProps;
tooltip?: string;
}>;
export const StatBox: React.FC<StatBoxProps> = ({
title,
subtitle,
palette,
children,
sx,
tooltip,
}) => {
const theme = useTheme();
const textColor = palette ? theme.palette[palette].contrastText : "inherit";
return (
<GradientBox palette={palette} sx={sx}>
<Stack>
<Box
sx={{ display: "flex", alignItems: "center", gap: theme.spacing(2) }}
>
<Typography color={textColor}>{title}</Typography>
{tooltip && (
<TooltipWithInfo
title={tooltip}
iconColor={textColor as string}
iconSize={14}
/>
)}
</Box>
<Typography color={textColor}>{subtitle}</Typography>
{children}
</Stack>
</GradientBox>
);
};
@@ -0,0 +1,93 @@
import Stack from "@mui/material/Stack";
import Typography from "@mui/material/Typography";
import Box from "@mui/material/Box";
import { BaseBox } from "@/components/design-elements";
import Background from "@/assets/images/background-grid.svg?react";
import { useTranslation } from "react-i18next";
import { useTheme } from "@mui/material/styles";
type StatusBoxProps = React.PropsWithChildren<{ children: React.ReactNode }>;
export const BGBox: React.FC<StatusBoxProps> = ({ children }) => {
const theme = useTheme();
return (
<BaseBox
sx={{
overflow: "hidden",
position: "relative",
flex: 1,
padding: theme.spacing(4),
}}
>
<Box position="absolute" top="-10%" left="5%">
<Background />
</Box>
{children}
</BaseBox>
);
};
const StatusBox = ({
label,
n,
color,
}: {
label: string;
n: number;
color: string | undefined;
}) => {
const theme = useTheme();
return (
<BGBox>
<Stack spacing={theme.spacing(4)}>
<Typography
variant={"h2"}
textTransform="uppercase"
color={theme.palette.primary.contrastTextTertiary}
>
{label}
</Typography>
<Typography variant="h1" color={color}>
{n}
</Typography>
</Stack>
</BGBox>
);
};
export const UpStatusBox = ({ n }: { n: number }) => {
const theme = useTheme();
const { t } = useTranslation();
return (
<StatusBox
label={t("monitorStatus.up")}
n={n}
color={theme.palette.success.lowContrast}
/>
);
};
export const DownStatusBox = ({ n }: { n: number }) => {
const theme = useTheme();
const { t } = useTranslation();
return (
<StatusBox
label={t("monitorStatus.down")}
n={n}
color={theme.palette.error.lowContrast}
/>
);
};
export const PausedStatusBox = ({ n }: { n: number }) => {
const theme = useTheme();
const { t } = useTranslation();
return (
<StatusBox
label={t("monitorStatus.paused")}
n={n}
color={theme.palette.warning.lowContrast}
/>
);
};
@@ -0,0 +1,87 @@
import Box from "@mui/material/Box";
import { BaseBox } from "@/components/design-elements";
import type { MonitorStatus } from "@/types/monitor";
import { getStatusPalette, getValuePalette } from "@/utils/MonitorUtils";
import { useTheme } from "@mui/material/styles";
export const ValueTypes = ["positive", "negative", "neutral"] as const;
export type ValueType = (typeof ValueTypes)[number];
export const StatusLabel = ({
status,
isActive,
}: {
status: MonitorStatus;
isActive?: boolean;
}) => {
const theme = useTheme();
const palette = getStatusPalette(status);
const transformedText =
status.charAt(0).toUpperCase() + status.slice(1).toLowerCase();
return (
<BaseBox
sx={{
display: "inline-flex",
flexDirection: "row",
alignItems: "center",
justifyContent: "center",
padding: theme.spacing(3, 5),
color: theme.palette[palette].main,
borderColor:
theme.palette.mode === "dark"
? "rgba(255, 255, 255, 0.08)"
: "rgba(0, 0, 0, 0.08)",
}}
>
<Box
width={7}
height={7}
bgcolor={theme.palette[palette].lowContrast}
borderRadius="50%"
marginRight="5px"
/>
{isActive === false ? "Paused" : transformedText}
</BaseBox>
);
};
export const ValueLabel = ({
value,
text,
}: {
value: ValueType;
text: string;
}) => {
const theme = useTheme();
const palette = getValuePalette(value);
const transformedText =
text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
return (
<BaseBox
sx={{
display: "inline-flex",
flexDirection: "row",
alignItems: "center",
justifyContent: "center",
padding: theme.spacing(3, 5),
color: theme.palette[palette].main,
borderColor:
theme.palette.mode === "dark"
? "rgba(255, 255, 255, 0.08)"
: "rgba(0, 0, 0, 0.08)",
}}
>
<Box
width={7}
height={7}
bgcolor={theme.palette[palette].lowContrast}
borderRadius="50%"
marginRight="5px"
/>
{transformedText}
</BaseBox>
);
};
@@ -0,0 +1,37 @@
import MuiTab from "@mui/material/Tab";
import type { TabProps } from "@mui/material/Tab";
import { useTheme } from "@mui/material/styles";
interface CustomTabProps extends TabProps {}
export const Tab = (props: CustomTabProps) => {
const theme = useTheme();
return (
<MuiTab
disableRipple
iconPosition="start"
sx={{
textTransform: "none",
fontSize: 14,
fontWeight: 500,
minHeight: 34,
padding: theme.spacing(1, 0),
paddingBottom: 0,
minWidth: "auto",
alignItems: "flex-start",
color: theme.palette.primary.contrastTextTertiary,
"&.Mui-selected": {
color: theme.palette.accent.main,
fontWeight: 600,
},
"&:hover": {
color: theme.palette.primary.contrastTextSecondary,
},
"& .MuiTab-iconWrapper": {
marginRight: theme.spacing(2),
marginBottom: 0,
},
}}
{...props}
/>
);
};
@@ -0,0 +1,373 @@
import Stack from "@mui/material/Stack";
import Grid from "@mui/material/Grid";
import Box from "@mui/material/Box";
import Typography from "@mui/material/Typography";
import Paper from "@mui/material/Paper";
import Table from "@mui/material/Table";
import TableBody from "@mui/material/TableBody";
import TableCell from "@mui/material/TableCell";
import TableContainer from "@mui/material/TableContainer";
import TableHead from "@mui/material/TableHead";
import TableRow from "@mui/material/TableRow";
import Collapse from "@mui/material/Collapse";
import IconButton from "@mui/material/IconButton";
import {
ChevronsLeft,
ChevronsRight,
ChevronLeft,
ChevronRight,
} from "lucide-react";
import TablePagination from "@mui/material/TablePagination";
import type { TablePaginationProps } from "@mui/material/TablePagination";
import { useState, Fragment } from "react";
import { useTheme } from "@mui/material/styles";
import useMediaQuery from "@mui/material/useMediaQuery";
export type Header<T> = {
id: number | string;
content: React.ReactNode;
onClick?: (
event: React.MouseEvent<HTMLTableCellElement | null>,
row: T
) => void;
render: (row: T) => React.ReactNode;
};
type DataTableProps<T extends { id?: string | number; _id?: string | number }> =
{
headers: Header<T>[];
data: T[];
onRowClick?: (row: T) => void;
cardsOnSmallScreens?: boolean;
expandableRows?: boolean;
renderExpandedContent?: (row: T) => React.ReactNode;
};
export function DataTable<
T extends {
id?: string | number;
_id?: string | number;
onRowClick?: (row: T) => void;
}
>({
headers,
data,
onRowClick,
cardsOnSmallScreens = true,
expandableRows = false,
renderExpandedContent,
}: DataTableProps<T>) {
const theme = useTheme();
const [expanded, setExpanded] = useState<(string | number) | null>(null);
const handleExpand = (row: T) => {
const key = row.id || row._id || null;
setExpanded(expanded === key ? null : key);
};
const isSmall = useMediaQuery(theme.breakpoints.down("md"));
if (data.length === 0 || headers.length === 0) return <EmptyView />;
const keys = [];
// Return stack of cards for small screens
if (isSmall && cardsOnSmallScreens) {
return (
<Stack spacing={theme.spacing(4)}>
{data.map((row) => {
const key = row.id || row._id || Math.random();
keys.push(key);
return (
<Stack
onClick={() => (onRowClick ? onRowClick(row) : null)}
spacing={theme.spacing(4)}
sx={{
borderStyle: "solid",
borderWidth: 1,
borderColor: theme.palette.primary.lowContrast,
borderRadius: theme.shape.borderRadius,
padding: theme.spacing(4),
cursor: onRowClick ? "pointer" : "default",
}}
key={key}
>
{headers.map((header) => {
return (
<Grid container key={header.id}>
<Grid size={3} display={"flex"} alignItems={"center"}>
<Typography color={theme.palette.text.primary}>
{header.content}
</Typography>
</Grid>
<Grid size={9} display="flex" alignItems={"center"}>
{header.render(row)}{" "}
</Grid>
</Grid>
);
})}
{expandableRows &&
renderExpandedContent &&
renderExpandedContent(row) && (
<Grid size={12}>{renderExpandedContent(row)}</Grid>
)}
</Stack>
);
})}
</Stack>
);
}
return (
<TableContainer component={Paper} elevation={0} sx={{ boxShadow: "none" }}>
<Table
sx={{
"&.MuiTable-root :is(.MuiTableHead-root, .MuiTableBody-root) :is(th, td)":
{
paddingLeft: theme.spacing(8),
},
"& .MuiTableHead-root .MuiTableRow-root": {
height: "28px",
},
"& :is(th)": {
backgroundColor: theme.palette.tertiary.main,
color: theme.palette.secondary.contrastText,
fontWeight: 500,
textTransform: "uppercase",
padding: `${theme.spacing(2)} ${theme.spacing(8)}`,
fontSize: theme.typography.fontSize,
},
"& :is(td)": {
backgroundColor: theme.palette.primary.main,
color: theme.palette.primary.contrastTextSecondary,
padding: `${theme.spacing(7)} ${theme.spacing(8)}`,
fontSize: theme.typography.fontSize,
},
"& .MuiTableBody-root .MuiTableRow-root:last-child .MuiTableCell-root":
{
borderBottom: "none",
},
}}
>
<TableHead>
<TableRow>
{headers.map((header, idx) => {
return (
<TableCell
align={idx === 0 ? "left" : "center"}
key={header.id}
>
{header.content}
</TableCell>
);
})}
</TableRow>
</TableHead>
<TableBody>
{data.map((row) => {
const key = row.id || row._id || Math.random();
const isExpanded = expanded === key;
return (
<Fragment key={key}>
<TableRow
sx={{
cursor: onRowClick ? "pointer" : "default",
}}
onClick={() => {
if (expandableRows) handleExpand(row);
else if (onRowClick) onRowClick(row);
}}
>
{headers.map((header, index) => {
return (
<TableCell
align={index === 0 ? "left" : "center"}
key={header.id}
onClick={
header.onClick
? (e) => header.onClick!(e, row)
: undefined
}
>
{header.render(row)}
</TableCell>
);
})}
</TableRow>
{expandableRows &&
renderExpandedContent &&
renderExpandedContent(row) && (
<TableRow>
<TableCell
colSpan={headers.length}
style={{
borderBottom: isExpanded ? undefined : "none",
paddingTop: 0,
paddingBottom: 0,
}}
>
<Collapse in={isExpanded} timeout="auto" unmountOnExit>
<Box sx={{ pt: 4, pb: 4 }}>
{renderExpandedContent(row)}
</Box>
</Collapse>
</TableCell>
</TableRow>
)}
</Fragment>
);
})}
</TableBody>
</Table>
</TableContainer>
);
}
interface TablePaginationActionsProps {
count: number;
page: number;
rowsPerPage: number;
onPageChange: (
event: React.MouseEvent<HTMLButtonElement>,
newPage: number
) => void;
}
function TablePaginationActions(props: TablePaginationActionsProps) {
const theme = useTheme();
const { count, page, rowsPerPage, onPageChange } = props;
const handleFirstPageButtonClick = (
event: React.MouseEvent<HTMLButtonElement>
) => {
onPageChange(event, 0);
};
const handleBackButtonClick = (
event: React.MouseEvent<HTMLButtonElement>
) => {
onPageChange(event, page - 1);
};
const handleNextButtonClick = (
event: React.MouseEvent<HTMLButtonElement>
) => {
onPageChange(event, page + 1);
};
const handleLastPageButtonClick = (
event: React.MouseEvent<HTMLButtonElement>
) => {
onPageChange(event, Math.max(0, Math.ceil(count / rowsPerPage) - 1));
};
return (
<Box sx={{ flexShrink: 0, ml: 2.5 }} className="table-pagination-actions">
<IconButton
onClick={handleFirstPageButtonClick}
disabled={page === 0}
aria-label="first page"
>
{theme.direction === "rtl" ? (
<ChevronsRight size={20} strokeWidth={1.5} />
) : (
<ChevronsLeft size={20} strokeWidth={1.5} />
)}
</IconButton>
<IconButton
onClick={handleBackButtonClick}
disabled={page === 0}
aria-label="previous page"
>
{theme.direction === "rtl" ? (
<ChevronRight size={20} strokeWidth={1.5} />
) : (
<ChevronLeft size={20} strokeWidth={1.5} />
)}
</IconButton>
<IconButton
onClick={handleNextButtonClick}
disabled={page >= Math.ceil(count / rowsPerPage) - 1}
aria-label="next page"
>
{theme.direction === "rtl" ? (
<ChevronLeft size={20} strokeWidth={1.5} />
) : (
<ChevronRight size={20} strokeWidth={1.5} />
)}
</IconButton>
<IconButton
onClick={handleLastPageButtonClick}
disabled={page >= Math.ceil(count / rowsPerPage) - 1}
aria-label="last page"
>
{theme.direction === "rtl" ? (
<ChevronsLeft size={20} strokeWidth={1.5} />
) : (
<ChevronsRight size={20} strokeWidth={1.5} />
)}
</IconButton>
</Box>
);
}
export const Pagination: React.FC<TablePaginationProps> = ({ ...props }) => {
const isSmall = useMediaQuery((theme: any) => theme.breakpoints.down("sm"));
const theme = useTheme();
return (
<TablePagination
ActionsComponent={TablePaginationActions}
rowsPerPageOptions={[5, 10, 25]}
{...props}
sx={{
"& .MuiTablePagination-toolbar": {
display: isSmall ? "grid" : "flex",
},
"& .MuiTablePagination-selectLabel": {
gridColumn: "1",
gridRow: "1",
justifySelf: "center",
},
"& .MuiTablePagination-select": {
gridColumn: "2",
gridRow: "1",
justifySelf: "center",
},
"& .MuiTablePagination-displayedRows": {
gridColumn: "2",
gridRow: "2",
justifySelf: "center ",
},
"& .table-pagination-actions": {
gridColumn: "1",
gridRow: "2",
justifySelf: "center",
},
"& .MuiSelect-select": {
border: 1,
borderColor: theme.palette.primary.lowContrast,
borderRadius: theme.shape.borderRadius,
},
}}
/>
);
};
const EmptyView = () => {
const theme = useTheme();
return (
<Stack
alignItems={"center"}
sx={{
p: theme.spacing(4),
borderWidth: 1,
borderStyle: "solid",
borderColor: theme.palette.primary.lowContrast,
borderRadius: theme.shape.borderRadius,
}}
>
<Typography>No data</Typography>
</Stack>
);
};
@@ -0,0 +1,27 @@
import MuiTabs from "@mui/material/Tabs";
import type { TabsProps } from "@mui/material/Tabs";
import { useTheme } from "@mui/material/styles";
interface CustomTabsProps extends TabsProps {}
export const Tabs = (props: CustomTabsProps) => {
const theme = useTheme();
return (
<MuiTabs
sx={{
minHeight: 34,
borderBottom: `1px solid ${theme.palette.primary.lowContrast}`,
"& .MuiTabs-indicator": {
backgroundColor: theme.palette.accent.main,
height: 2,
bottom: 0,
},
"& .MuiTabs-flexContainer": {
gap: theme.spacing(16),
},
}}
{...props}
>
{props.children}
</MuiTabs>
);
};
@@ -0,0 +1,83 @@
import MuiTooltip from "@mui/material/Tooltip";
import { useTheme } from "@mui/material/styles";
import { Info } from "lucide-react";
import type { TooltipProps } from "@mui/material/Tooltip";
type StyledTooltipProps = TooltipProps;
export const Tooltip: React.FC<StyledTooltipProps> = ({
placement = "top",
...props
}) => {
const theme = useTheme();
return (
<MuiTooltip
title={props.title}
placement={placement}
slotProps={{
tooltip: {
sx: {
background:
theme.palette.mode === "dark"
? "linear-gradient(135deg, #1a1a2e 0%, #16213e 100%)"
: "linear-gradient(135deg, #2c3e50 0%, #1a252f 100%)",
backgroundColor: "transparent",
color: "#ffffff",
fontSize: "13px",
padding: `${theme.spacing(4)} ${theme.spacing(5)}`,
borderRadius: `${theme.shape.borderRadius}px`,
boxShadow: "0 8px 24px rgba(0, 0, 0, 0.4)",
},
},
}}
>
{props.children}
</MuiTooltip>
);
};
export interface TooltipWithInfoProps
extends Omit<StyledTooltipProps, "children"> {
iconSize?: number;
iconColor?: string;
}
export const TooltipWithInfo: React.FC<TooltipWithInfoProps> = ({
iconSize = 14,
iconColor,
...props
}) => {
const theme = useTheme();
const defaultColor = theme.palette.primary.contrastTextTertiary;
return (
<Tooltip {...props}>
<span
style={{
display: "inline-flex",
alignItems: "center",
cursor: "help",
}}
>
<Info
size={iconSize}
strokeWidth={1.5}
style={{
opacity: 0.7,
color: iconColor || defaultColor,
transition: "opacity 0.2s ease",
}}
onMouseEnter={(e) => {
e.currentTarget.style.opacity = "1";
}}
onMouseLeave={(e) => {
e.currentTarget.style.opacity = "0.7";
}}
/>
</span>
</Tooltip>
);
};
@@ -0,0 +1,31 @@
export { SplitBox as HorizontalSplitBox, ConfigBox } from "./SplitBox";
export {
BasePage,
MonitorBasePageWithStates,
BasePageWithStates,
} from "./BasePage";
export {
BGBox,
UpStatusBox,
DownStatusBox,
PausedStatusBox,
} from "./StatusBox";
export { DataTable as Table, Pagination } from "./Table";
export { GradientBox, StatBox } from "./StatBox";
export { BaseBox } from "./BaseBox";
export { StatusLabel, ValueLabel } from "./StatusLabel";
export {
BaseFallback,
ErrorFallback,
EmptyFallback,
EmptyMonitorFallback,
} from "./Fallback";
export { BulletPointCheck } from "./BulletPointCheck";
export { PulseDot } from "./PulseDot";
export { Dot } from "./Dot";
export { Gauge } from "./Gauge";
export { Tab } from "./Tab";
export { Tabs } from "./Tabs";
export { Breadcrumb } from "./Breadcrumb";
export { InfoBox } from "./InfoBox";
export { Tooltip, TooltipWithInfo } from "./Tooltip";
@@ -0,0 +1,14 @@
import i18n from "@/utils/i18n.js";
import { useAppSelector } from "@/hooks/AppHooks";
import { useEffect } from "react";
export const I18nLoader = () => {
const language = useAppSelector((state) => state.ui.language);
useEffect(() => {
if (language && i18n.language !== language) {
i18n.changeLanguage(language);
}
}, [language]);
return null;
};
@@ -0,0 +1,81 @@
import Autocomplete from "@mui/material/Autocomplete";
import type { AutocompleteProps } from "@mui/material/Autocomplete";
import { TextInput, Checkbox } from "@/components/inputs";
import ListItem from "@mui/material/ListItem";
import Stack from "@mui/material/Stack";
import { useTheme } from "@mui/material/styles";
import { FieldLabel } from "./FieldLabel";
import { ChevronDown } from "lucide-react";
type AutoCompleteInputProps = Omit<
AutocompleteProps<any, boolean, boolean, boolean>,
"renderInput"
> & {
renderInput?: AutocompleteProps<
any,
boolean,
boolean,
boolean
>["renderInput"];
fieldLabel?: string;
required?: boolean;
};
export const AutoCompleteInput: React.FC<AutoCompleteInputProps> = ({
fieldLabel,
required,
renderInput,
...props
}) => {
const theme = useTheme();
const multiple = props.multiple;
const defaultRenderInput = (params: any) => (
<TextInput {...params} placeholder="Type to search" />
);
const autocomplete = (
<Autocomplete
{...props}
disableCloseOnSelect={!!multiple}
popupIcon={
<ChevronDown
size={18}
strokeWidth={1.5}
style={{ marginRight: theme.spacing(3) }}
/>
}
renderInput={renderInput || defaultRenderInput}
getOptionKey={(option) => option._id}
renderTags={() => null}
renderOption={(props, option, { selected }) => {
const { key, ...optionProps } = props;
return (
<ListItem key={key} {...optionProps}>
{multiple && <Checkbox checked={selected} />}
{option.name}
</ListItem>
);
}}
sx={{
"&.MuiAutocomplete-root .MuiAutocomplete-input": {
padding: `0 ${theme.spacing(5)}`,
},
"& .MuiInputBase-root .MuiAutocomplete-endAdornment": {
right: theme.spacing(3),
},
}}
/>
);
if (fieldLabel) {
return (
<Stack spacing={theme.spacing(2)}>
<FieldLabel required={required}>{fieldLabel}</FieldLabel>
{autocomplete}
</Stack>
);
}
return autocomplete;
};
+29
View File
@@ -0,0 +1,29 @@
import Button from "@mui/material/Button";
import type { ButtonProps } from "@mui/material/Button";
import { useTheme } from "@mui/material/styles";
export const ButtonInput = ({ sx, ...props }: ButtonProps) => {
const theme = useTheme();
return (
<Button
{...props}
sx={{
textTransform: "none",
height: 34,
fontWeight: 400,
borderRadius: 2,
whiteSpace: "nowrap",
textOverflow: "ellipsis",
overflow: "hidden",
boxShadow: "none",
"&:hover": {
boxShadow: "none",
backgroundColor: props.color === "primary"
? theme.palette.tertiary.main
: undefined,
},
...sx,
}}
/>
);
};
@@ -0,0 +1,18 @@
import ButtonGroup from "@mui/material/ButtonGroup";
import type { ButtonGroupProps } from "@mui/material/ButtonGroup";
export const ButtonGroupInput: React.FC<ButtonGroupProps> = ({
orientation,
...props
}) => {
return (
<ButtonGroup
orientation={orientation}
{...props}
sx={{
height: orientation === "horizontal" ? 34 : "auto",
boxShadow: "none",
}}
/>
);
};
+46
View File
@@ -0,0 +1,46 @@
import { forwardRef } from "react";
import Checkbox from "@mui/material/Checkbox";
import type { CheckboxProps } from "@mui/material/Checkbox";
import { Square, SquareCheck } from "lucide-react";
import { useTheme } from "@mui/material/styles";
type CheckboxInputProps = CheckboxProps & {
label?: string;
};
export const CheckboxInput = forwardRef<HTMLInputElement, CheckboxInputProps>(
function CheckboxInput({ sx, ...props }: CheckboxInputProps, ref: React.Ref<HTMLInputElement>) {
const theme = useTheme();
return (
<Checkbox
{...props}
aria-label={props.label}
slotProps={{
input: {
ref: ref,
},
}}
icon={<Square size={16} strokeWidth={1.5} />}
checkedIcon={<SquareCheck size={16} strokeWidth={1.5} />}
sx={{
padding: 0,
color: theme.palette.primary.contrastTextTertiary,
"&.Mui-checked": {
color: theme.palette.accent.main,
},
"&:hover": { backgroundColor: "transparent" },
"& svg": {
stroke: "currentColor",
},
"& svg path, & svg line, & svg polyline, & svg rect": {
stroke: "currentColor",
fill: "none",
},
"&.Mui-checked svg rect": {
fill: theme.palette.accent.main,
},
...sx,
}}
/>
);
}
);
@@ -0,0 +1,67 @@
import { DateTimePicker as MuiDateTimePicker } from "@mui/x-date-pickers/DateTimePicker";
import { LocalizationProvider } from "@mui/x-date-pickers/LocalizationProvider";
import { AdapterDayjs } from "@mui/x-date-pickers/AdapterDayjs";
import { forwardRef } from "react";
import { useTheme } from "@mui/material/styles";
import type { DateTimePickerProps } from "@mui/x-date-pickers/DateTimePicker";
import Stack from "@mui/material/Stack";
import { FieldLabel } from "./FieldLabel";
import { Calendar } from "lucide-react";
interface CustomDateTimePickerProps extends Omit<DateTimePickerProps<any>, "label"> {
fieldLabel?: string;
required?: boolean;
}
export const DateTimePicker = forwardRef<HTMLDivElement, CustomDateTimePickerProps>(
function DateTimePicker({ fieldLabel, required, ...props }, ref) {
const theme = useTheme();
const picker = (
<LocalizationProvider dateAdapter={AdapterDayjs}>
<MuiDateTimePicker
{...props}
ref={ref as any}
slots={{
openPickerIcon: () => <Calendar size={18} strokeWidth={1.5} />,
}}
sx={{
"& .MuiPickersOutlinedInput-root ": {
height: 34,
borderRadius: theme.shape.borderRadius,
borderColor: theme.palette.primary.lowContrast,
},
"& .MuiPickersOutlinedInput-notchedOutline": {
borderColor: theme.palette.primary.lowContrast,
},
"&:hover .MuiPickersOutlinedInput-notchedOutline": {
borderColor: theme.palette.primary.lowContrast,
},
"& .MuiPickersInputBase-root.MuiPickersOutlinedInput-root.Mui-focused:not(.Mui-error) .MuiPickersOutlinedInput-notchedOutline":
{
borderColor: theme.palette.accent.main,
},
"& .MuiFormHelperText-root": {
marginLeft: 0,
marginRight: 0,
marginTop: theme.spacing(1),
},
}}
/>
</LocalizationProvider>
);
if (fieldLabel) {
return (
<Stack spacing={theme.spacing(2)}>
<FieldLabel required={required}>{fieldLabel}</FieldLabel>
{picker}
</Stack>
);
}
return picker;
}
);
(DateTimePicker as any).displayName = "DateTimePicker";
+42
View File
@@ -0,0 +1,42 @@
import Dialog from "@mui/material/Dialog";
import DialogActions from "@mui/material/DialogActions";
import DialogContent from "@mui/material/DialogContent";
import DialogContentText from "@mui/material/DialogContentText";
import DialogTitle from "@mui/material/DialogTitle";
import { Button } from "@/components/inputs";
import { typographyLevels } from "@/theme/palette";
export const DialogInput = ({
open,
title,
content,
onConfirm,
onCancel,
confirmColor = "accent",
cancelColor = "error",
}: {
open: boolean;
title?: string;
content?: string;
onConfirm?(item: any): any;
onCancel?(item: any): any;
confirmColor?: "error" | "accent";
cancelColor?: "error" | "accent";
}) => {
return (
<Dialog open={open}>
<DialogTitle sx={{ fontSize: typographyLevels.l }}>{title}</DialogTitle>
<DialogContent>
<DialogContentText>{content}</DialogContentText>
</DialogContent>
<DialogActions>
<Button variant="contained" color={cancelColor} onClick={onCancel}>
Cancel
</Button>
<Button variant="contained" color={confirmColor} onClick={onConfirm}>
Confirm
</Button>
</DialogActions>
</Dialog>
);
};
@@ -0,0 +1,42 @@
import Typography from "@mui/material/Typography";
import { useTheme } from "@mui/material/styles";
interface FieldLabelProps {
children: React.ReactNode;
required?: boolean;
htmlFor?: string;
}
export const FieldLabel: React.FC<FieldLabelProps> = ({
children,
required = false,
htmlFor,
}) => {
const theme = useTheme();
return (
<Typography
component="label"
htmlFor={htmlFor}
sx={{
fontSize: "14px",
fontWeight: 500,
color: theme.palette.primary.contrastTextSecondary,
marginBottom: theme.spacing(2),
display: "block",
}}
>
{children}
{required && (
<span
style={{
color: theme.palette.error.main,
marginLeft: theme.spacing(2),
}}
>
*
</span>
)}
</Typography>
);
};
@@ -0,0 +1,17 @@
import MuiFormControlLabel from "@mui/material/FormControlLabel";
import type { FormControlLabelProps } from "@mui/material/FormControlLabel";
export const FormControlLabel: React.FC<FormControlLabelProps> = ({
...props
}) => {
return (
<MuiFormControlLabel
{...props}
sx={{
"& .MuiFormControlLabel-label": {
lineHeight: 1,
},
}}
/>
);
};
@@ -0,0 +1,30 @@
import Stack from "@mui/material/Stack";
import { FieldLabel } from "./FieldLabel";
import { useTheme } from "@mui/material/styles";
interface FormFieldProps {
label?: string;
required?: boolean;
children: React.ReactNode;
htmlFor?: string;
}
export const FormField: React.FC<FormFieldProps> = ({
label,
required = false,
children,
htmlFor,
}) => {
const theme = useTheme();
return (
<Stack spacing={theme.spacing(2)}>
{label && (
<FieldLabel required={required} htmlFor={htmlFor}>
{label}
</FieldLabel>
)}
{children}
</Stack>
);
};
@@ -0,0 +1,53 @@
import "flag-icons/css/flag-icons.min.css";
import { Select } from "@/components/inputs";
import MenuItem from "@mui/material/MenuItem";
import Stack from "@mui/material/Stack";
import Typography from "@mui/material/Typography";
import { useTranslation } from "react-i18next";
import { useTheme } from "@mui/material/styles";
import { useAppDispatch, useAppSelector } from "@/hooks/AppHooks";
import { setLanguage } from "@/features/uiSlice";
export const LanguageSelector = () => {
const { i18n } = useTranslation();
const theme = useTheme();
const dispatch = useAppDispatch();
const language = useAppSelector((state: any) => state.ui.language);
const languages = Object.keys(i18n.options.resources || {});
const languageMap: Record<string, string> = {
cs: "cz",
ja: "jp",
uk: "ua",
vi: "vn",
};
const handleChange = (event: any) => {
const newLang = event.target.value;
dispatch(setLanguage(newLang));
};
const languagesForDisplay = languages.map((l) => {
let formattedLanguage = l === "en" ? "gb" : l;
formattedLanguage = formattedLanguage.includes("-")
? formattedLanguage.split("-")[1].toLowerCase()
: formattedLanguage;
formattedLanguage = languageMap[formattedLanguage] || formattedLanguage;
const flag = formattedLanguage ? `fi fi-${formattedLanguage}` : null;
return (
<MenuItem key={l} value={l}>
<Stack direction="row" gap={theme.spacing(4)}>
{flag && <span className={flag} />}
<Typography textTransform={"uppercase"}>{l}</Typography>
</Stack>
</MenuItem>
);
});
return (
<Select value={language} onChange={handleChange}>
{languagesForDisplay}
</Select>
);
};
@@ -0,0 +1,76 @@
import Radio from "@mui/material/Radio";
import type { RadioProps } from "@mui/material/Radio";
import { useTheme } from "@mui/material/styles";
import { Circle, CircleDot } from "lucide-react";
import FormControlLabel from "@mui/material/FormControlLabel";
import Typography from "@mui/material/Typography";
interface RadioInputProps extends RadioProps {}
export const RadioInput: React.FC<RadioInputProps> = ({ ...props }) => {
const theme = useTheme();
return (
<Radio
{...props}
icon={<Circle size={16} strokeWidth={1.5} />}
checkedIcon={<CircleDot size={14} strokeWidth={1.5} />}
sx={{
padding: 0,
mt: theme.spacing(0.5),
color: theme.palette.primary.contrastTextTertiary,
"&.Mui-checked": {
color: theme.palette.accent.main,
"& svg circle": {
fill: theme.palette.accent.main,
},
},
"& .MuiSvgIcon-root": {
fontSize: 16,
},
"& svg": {
stroke: "currentColor",
},
"& svg path, & svg line, & svg polyline, & svg rect, & svg circle": {
stroke: "currentColor",
fill: "none",
},
}}
/>
);
};
export const RadioWithDescription: React.FC<
RadioInputProps & { label: string; description: string }
> = ({ label, description, ...props }) => {
const theme = useTheme();
return (
<FormControlLabel
control={<RadioInput {...props} />}
label={
<>
<Typography component="p">{label}</Typography>
<Typography
component="h6"
color={theme.palette.primary.contrastTextSecondary}
>
{description}
</Typography>
</>
}
sx={{
alignItems: "flex-start",
p: theme.spacing(2.5),
m: theme.spacing(-2.5),
borderRadius: theme.shape.borderRadius,
"&:hover": {
backgroundColor: theme.palette.tertiary.main,
},
"& .MuiButtonBase-root": {
p: 0,
mr: theme.spacing(6),
},
}}
/>
);
};
+53
View File
@@ -0,0 +1,53 @@
import Select from "@mui/material/Select";
import { useTheme } from "@mui/material/styles";
import type { SelectProps } from "@mui/material/Select";
import Stack from "@mui/material/Stack";
import { FieldLabel } from "./FieldLabel";
import { ChevronDown } from "lucide-react";
interface SelectInputProps<T> extends Omit<SelectProps<T>, "label"> {
fieldLabel?: string;
required?: boolean;
}
export const SelectInput = <T,>({ fieldLabel, required, ...props }: SelectInputProps<T>) => {
const theme = useTheme();
const select = (
<Select<T>
{...props}
IconComponent={() => (
<ChevronDown
size={18}
strokeWidth={1.5}
style={{ marginRight: theme.spacing(3) }}
/>
)}
sx={{
height: "34px",
"& .MuiSelect-icon": {
right: theme.spacing(3),
},
"& .MuiOutlinedInput-notchedOutline": {
borderRadius: theme.shape.borderRadius,
borderColor: theme.palette.primary.lowContrast,
},
"&:hover .MuiOutlinedInput-notchedOutline": {
borderColor: theme.palette.primary.lowContrast,
},
...props.sx,
}}
/>
);
if (fieldLabel) {
return (
<Stack spacing={theme.spacing(2)}>
<FieldLabel required={required}>{fieldLabel}</FieldLabel>
{select}
</Stack>
);
}
return select;
};
@@ -0,0 +1,40 @@
import { LogOut } from "lucide-react";
import IconButton from "@mui/material/IconButton";
import { useAppDispatch } from "@/hooks/AppHooks";
import { logout } from "@/features/authSlice";
import { usePost } from "@/hooks/UseApi";
import { useNavigate } from "react-router";
import { useTheme } from "@mui/material/styles";
import { Tooltip } from "@/components/design-elements";
export const LogoutSwitch = () => {
const dispatch = useAppDispatch();
const { post } = usePost();
const navigate = useNavigate();
const theme = useTheme();
const handleClick = async () => {
await post("/auth/logout", {});
navigate("/login");
dispatch(logout());
};
return (
<Tooltip title="Logout" placement="top">
<IconButton
onClick={handleClick}
sx={{
"& svg": {
transition: "stroke 0.2s ease",
},
"&:hover svg path, &:hover svg line, &:hover svg polyline, &:hover svg rect, &:hover svg circle":
{
stroke: theme.palette.accent.main,
},
}}
>
<LogOut size={16} strokeWidth={1.5} />
</IconButton>
</Tooltip>
);
};
@@ -0,0 +1,91 @@
import MenuItem from "@mui/material/MenuItem";
import Menu from "@mui/material/Menu";
import Typography from "@mui/material/Typography";
import { Settings } from "lucide-react";
import IconButton from "@mui/material/IconButton";
import { useNavigate } from "react-router";
import { useAppSelector } from "@/hooks/AppHooks";
import { useState } from "react";
import { useTheme } from "@mui/material/styles";
import { Tooltip } from "@/components/design-elements";
export const SettingsSwitch = () => {
const navigate = useNavigate();
const theme = useTheme();
const [anchorEl, setAnchorEl] = useState<null | HTMLElement>(null);
const open = Boolean(anchorEl);
const handleOpen = (event: React.MouseEvent<HTMLElement>) => {
setAnchorEl(event.currentTarget);
};
const handleClose = () => {
setAnchorEl(null);
};
const handleClick = (path: string) => {
navigate(path);
handleClose();
};
const user = useAppSelector((state) => state.auth.user);
const orgPermissions = user?.org?.permissions || [];
const hasTeamEdit =
orgPermissions.includes("teams.*") ||
orgPermissions.includes("teams.write") ||
orgPermissions.includes("*");
const hasInvite =
orgPermissions.includes("invite.*") ||
orgPermissions.includes("invite.write") ||
orgPermissions.includes("*");
return (
<>
<Tooltip title="Settings" placement="top">
<IconButton
onClick={handleOpen}
sx={{
"& svg": {
transition: "stroke 0.2s ease",
},
"&:hover svg path, &:hover svg line, &:hover svg polyline, &:hover svg rect, &:hover svg circle":
{
stroke: theme.palette.accent.main,
},
}}
>
<Settings size={16} strokeWidth={1.5} />
</IconButton>
</Tooltip>
<Menu
anchorEl={anchorEl}
open={open}
onClose={handleClose}
anchorOrigin={{
vertical: "top",
horizontal: "right",
}}
>
<MenuItem onClick={() => handleClick("profile")}>
<Typography>Profile</Typography>
</MenuItem>
<MenuItem onClick={() => handleClick("settings")}>
<Typography>General settings</Typography>
</MenuItem>
{hasTeamEdit && (
<MenuItem onClick={() => handleClick("teams")}>
<Typography>Teams</Typography>
</MenuItem>
)}
{hasInvite && (
<MenuItem onClick={() => handleClick("invite")}>
<Typography>Invite</Typography>
</MenuItem>
)}
</Menu>
</>
);
};
@@ -0,0 +1,98 @@
import MenuItem from "@mui/material/MenuItem";
import Menu from "@mui/material/Menu";
import Typography from "@mui/material/Typography";
import { Users, Check } from "lucide-react";
import IconButton from "@mui/material/IconButton";
import Stack from "@mui/material/Stack";
import { Tooltip } from "@/components/design-elements";
import { useState, useEffect } from "react";
import { useAppSelector, useAppDispatch } from "@/hooks/AppHooks";
import { setSelectedTeamId } from "@/features/authSlice";
import { useNavigate } from "react-router";
import { useGet } from "@/hooks/UseApi";
import type { ApiResponse } from "@/hooks/UseApi";
import { useTheme } from "@mui/material/styles";
export const TeamSwitch = () => {
const navigate = useNavigate();
const dispatch = useAppDispatch();
const theme = useTheme();
const [anchorEl, setAnchorEl] = useState<null | HTMLElement>(null);
const open = Boolean(anchorEl);
const { response } = useGet<ApiResponse<any>>("/teams/joined");
const selectedTeamId = useAppSelector((state) => state.auth.selectedTeamId);
const user = useAppSelector((state) => state.auth.user);
const teams = response?.data || [];
// If the selected team is not in the list of joined teams, reset it
// This can happen if a user is on a team and it is deleted or they are removed from it
useEffect(() => {
if (teams.length > 0 && !teams.find((t: any) => t._id === selectedTeamId)) {
dispatch(setSelectedTeamId(user?.teams[0]?.id || null));
}
}, [teams, selectedTeamId, dispatch]);
const handleMenu = (teamId: string) => {
dispatch(setSelectedTeamId(teamId));
navigate("/");
handleClose();
};
const handleOpen = (event: React.MouseEvent<HTMLElement>) => {
setAnchorEl(event.currentTarget);
};
const handleClose = () => {
setAnchorEl(null);
};
return (
<>
<Tooltip title="Teams" placement="top">
<IconButton
onClick={handleOpen}
sx={{
"& svg": {
transition: "stroke 0.2s ease",
},
"&:hover svg path, &:hover svg line, &:hover svg polyline, &:hover svg rect, &:hover svg circle":
{
stroke: theme.palette.accent.main,
},
}}
>
<Users size={16} strokeWidth={1.5} />
</IconButton>
</Tooltip>
<Menu
anchorEl={anchorEl}
open={open}
onClose={handleClose}
anchorOrigin={{
vertical: "top",
horizontal: "right",
}}
>
{teams.map((t: any) => {
return (
<MenuItem key={t._id} onClick={() => handleMenu(t._id)}>
<Stack
width={"100%"}
direction={"row"}
justifyContent={"space-between"}
>
<Typography mr={2}>{t.name}</Typography>
<Stack width={16} alignItems="center" justifyContent={"center"}>
{selectedTeamId === t._id && (
<Check size={16} strokeWidth={1.5} />
)}
</Stack>
</Stack>
</MenuItem>
);
})}
</Menu>
</>
);
};
@@ -0,0 +1,45 @@
import IconButton from "@mui/material/IconButton";
import { useAppDispatch, useAppSelector } from "@/hooks/AppHooks";
import { setMode } from "@/features/uiSlice.js";
import { useTranslation } from "react-i18next";
import { Moon, Sun } from "lucide-react";
import { useTheme } from "@mui/material/styles";
import { Tooltip } from "@/components/design-elements";
export const ThemeSwitch = () => {
const mode = useAppSelector((state: any) => state.ui.mode);
const dispatch = useAppDispatch();
const { t } = useTranslation();
const theme = useTheme();
const handleChange = () => {
dispatch(setMode(mode === "light" ? "dark" : "light"));
};
return (
<Tooltip title={t("common.buttons.toggleTheme")} placement="top">
<IconButton
id="theme-toggle"
onClick={handleChange}
sx={{
display: "flex",
alignItems: "center",
justifyContent: "center",
"& svg": {
transition: "stroke 0.2s ease",
},
"&:hover svg path, &:hover svg line, &:hover svg polyline, &:hover svg rect, &:hover svg circle":
{
stroke: theme.palette.accent.main,
},
}}
>
{mode === "light" ? (
<Moon size={16} strokeWidth={1.5} />
) : (
<Sun size={16} strokeWidth={1.5} />
)}
</IconButton>
</Tooltip>
);
};
@@ -0,0 +1,55 @@
import { forwardRef } from "react";
import TextField from "@mui/material/TextField";
import type { TextFieldProps } from "@mui/material";
import { typographyLevels } from "@/theme/palette";
import { useTheme } from "@mui/material/styles";
import Stack from "@mui/material/Stack";
import { FieldLabel } from "./FieldLabel";
interface TextInputProps extends Omit<TextFieldProps, "label"> {
fieldLabel?: string;
required?: boolean;
}
export const TextInput = forwardRef<HTMLInputElement, TextInputProps>(
function TextInput({ fieldLabel, required, ...props }, ref) {
const theme = useTheme();
const input = (
<TextField
{...props}
inputRef={ref}
sx={{
"& .MuiOutlinedInput-root": {
borderRadius: theme.shape.borderRadius,
height: 34,
fontSize: typographyLevels.base,
},
"& .MuiOutlinedInput-notchedOutline": {
borderColor: theme.palette.primary.lowContrast,
},
"&:hover .MuiOutlinedInput-notchedOutline": {
borderColor: theme.palette.primary.lowContrast,
},
"& .MuiFormHelperText-root": {
marginLeft: 0,
marginRight: 0,
marginTop: theme.spacing(1),
},
}}
/>
);
if (fieldLabel) {
return (
<Stack spacing={theme.spacing(2)}>
<FieldLabel required={required}>{fieldLabel}</FieldLabel>
{input}
</Stack>
);
}
return input;
}
);
TextInput.displayName = "TextInput";
+29
View File
@@ -0,0 +1,29 @@
import Typography from "@mui/material/Typography";
import Stack from "@mui/material/Stack";
import Link from "@mui/material/Link";
import { Link as RouterLink } from "react-router-dom";
import { useTheme } from "@mui/material/styles";
export const TextLink = ({
text,
linkText,
href,
target = "_self",
}: {
text: string;
linkText: string;
href: string;
target?: string;
}) => {
const theme = useTheme();
return (
<Stack direction="row" gap={theme.spacing(4)}>
<Typography>{text}</Typography>
<Link color="accent" to={href} component={RouterLink} target={target}>
{linkText}
</Link>
</Stack>
);
};
+18
View File
@@ -0,0 +1,18 @@
export { ButtonInput as Button } from "./Button";
export { ButtonGroupInput as ButtonGroup } from "./ButtonGroup";
export { TextInput } from "./TextInput";
export { SelectInput as Select } from "./Select";
export { LanguageSelector } from "./LanguageSelector";
export { ThemeSwitch } from "./SwitchTheme";
export { SettingsSwitch } from "./SwitchSettings";
export { TextLink } from "./TextLink";
export { CheckboxInput as Checkbox } from "./Checkbox";
export { AutoCompleteInput as AutoComplete } from "./AutoComplete";
export { RadioInput as Radio, RadioWithDescription } from "./RadioInput";
export { TeamSwitch } from "./SwitchTeam";
export { LogoutSwitch } from "./SwitchLogout";
export { DialogInput as Dialog } from "./Dialog";
export { DateTimePicker } from "./DateTimePicker";
export { FormControlLabel } from "./FormControlLabel";
export { FieldLabel } from "./FieldLabel";
export { FormField } from "./FormField";
@@ -0,0 +1,30 @@
import { Outlet } from "react-router";
import Stack from "@mui/material/Stack";
import { SideBar } from "@/components/layouts/sidebar";
import { useTheme } from "@mui/material/styles";
const RootLayout = () => {
const theme = useTheme();
return (
<Stack direction="row" minHeight="100vh">
<SideBar />
<Stack
flex={1}
padding={theme.spacing(12)}
overflow={"hidden"}
sx={{
backgroundColor: theme.palette.mode === 'dark'
? 'rgba(255, 255, 255, 0.01)'
: 'rgba(0, 0, 0, 0.01)',
display: 'flex',
alignItems: 'center'
}}
>
<Stack maxWidth={1280} width="100%" paddingY={theme.spacing(6)}>
<Outlet />
</Stack>
</Stack>
</Stack>
);
};
export default RootLayout;
@@ -0,0 +1,30 @@
import Stack from "@mui/material/Stack";
import {
TeamSwitch,
ThemeSwitch,
LogoutSwitch,
SettingsSwitch,
} from "@/components/inputs";
import { useTheme } from "@mui/material/styles";
import { useAppSelector } from "@/hooks/AppHooks";
export const BottomControls = () => {
const theme = useTheme();
const sidebarOpen = useAppSelector((state) => state.ui.sidebarOpen);
return (
<Stack
alignItems={sidebarOpen ? "flex-start" : "center"}
justifyContent={"center"}
direction={sidebarOpen ? "row" : "column"}
py={theme.spacing(4)}
px={theme.spacing(8)}
gap={theme.spacing(2)}
>
<TeamSwitch />
<ThemeSwitch />
<LogoutSwitch />
<SettingsSwitch />
</Stack>
);
};
@@ -0,0 +1,50 @@
import IconButton from "@mui/material/IconButton";
import { ArrowRight } from "@/components/arrows/ArrowRight";
import { ArrowLeft } from "@/components/arrows/ArrowLeft";
import { useTheme } from "@mui/material/styles";
import { setSidebarOpen } from "@/features/uiSlice";
import { useAppDispatch } from "@/hooks/AppHooks";
export const CollapseButton = ({ sidebarOpen }: { sidebarOpen: boolean }) => {
const theme = useTheme();
const dispatch = useAppDispatch();
const arrowIcon = sidebarOpen ? (
<ArrowLeft
height={theme.spacing(8)}
width={theme.spacing(8)}
color={theme.palette.primary.contrastTextSecondary}
/>
) : (
<ArrowRight
height={theme.spacing(8)}
width={theme.spacing(8)}
color={theme.palette.primary.contrastTextSecondary}
/>
);
return (
<IconButton
sx={{
position: "absolute",
/* TODO 60 is a magic number. if logo chnges size this might break */
top: 60,
right: 0,
transform: `translate(50%, 0)`,
backgroundColor: theme.palette.tertiary.main,
border: `1px solid ${theme.palette.primary.lowContrast}`,
p: theme.spacing(2.5),
"&:focus": { outline: "none" },
"&:hover": {
backgroundColor: theme.palette.primary.lowContrast,
borderColor: theme.palette.primary.lowContrast,
},
}}
onClick={() => {
dispatch(setSidebarOpen(!sidebarOpen));
}}
>
{arrowIcon}
</IconButton>
);
};
@@ -0,0 +1,59 @@
import Stack from "@mui/material/Stack";
import Box from "@mui/material/Box";
import Typography from "@mui/material/Typography";
import { useTheme } from "@mui/material/styles";
import { useNavigate } from "react-router";
import { useTranslation } from "react-i18next";
export const Logo = ({ sidebarOpen }: { sidebarOpen: boolean }) => {
const { t } = useTranslation();
const theme = useTheme();
const navigate = useNavigate();
return (
<Stack
pt={theme.spacing(6)}
pb={theme.spacing(12)}
pl={theme.spacing(11)}
direction="row"
alignItems="center"
gap={theme.spacing(4)}
onClick={() => navigate("/")}
sx={{ cursor: "pointer" }}
>
<Typography
pl={theme.spacing("1px")}
minWidth={theme.spacing(16)}
minHeight={theme.spacing(16)}
display={"flex"}
justifyContent={"center"}
alignItems={"center"}
bgcolor={theme.palette.accent.main}
borderRadius={theme.shape.borderRadius}
color={theme.palette.accent.contrastText}
fontSize={18}
>
C
</Typography>
<Box
overflow={"hidden"}
sx={{
transition: "opacity 900ms ease, width 900ms ease",
opacity: sidebarOpen ? 1 : 0,
whiteSpace: "nowrap",
width: sidebarOpen ? "100%" : 0,
}}
>
{" "}
<Typography
lineHeight={1}
mt={theme.spacing(2)}
color={theme.palette.primary.contrastText}
variant="h2"
>
{t("common.appName")}
</Typography>
</Box>
</Stack>
);
};
@@ -0,0 +1,68 @@
import {
Bell,
Monitor,
Gauge,
Server,
AlertTriangle,
LayoutList,
Wrench,
Activity,
LifeBuoy,
MessageSquare,
FileText,
ScrollText
} from "lucide-react";
export const getMenu = (t: Function) => [
{ name: t("menu.uptime"), path: "uptime", icon: <Monitor size={20} strokeWidth={1.5} /> },
{ name: t("menu.pagespeed"), path: "pagespeed", icon: <Gauge size={20} strokeWidth={1.5} /> },
{
name: t("menu.infrastructure"),
path: "infrastructure",
icon: <Server size={20} strokeWidth={1.5} />,
},
{
name: t("menu.notifications"),
path: "notification-channels",
icon: <Bell size={20} strokeWidth={1.5} />,
},
{ name: t("menu.incidents"), path: "incidents", icon: <AlertTriangle size={20} strokeWidth={1.5} /> },
{ name: t("menu.statusPages"), path: "status-pages", icon: <LayoutList size={20} strokeWidth={1.5} /> },
{ name: t("menu.maintenance"), path: "maintenance", icon: <Wrench size={20} strokeWidth={1.5} /> },
{ name: t("menu.diagnostics"), path: "diagnostics", icon: <Activity size={20} strokeWidth={1.5} /> },
// {
// name: t("menu.settings"),
// icon: <Settings />,
// path: "settings",
// },
];
export const getBottomMenu = (t: Function) => [
{
name: t("menu.support"),
path: "support",
icon: <LifeBuoy size={20} strokeWidth={1.5} />,
url: "https://discord.com/invite/NAb6H3UTjK",
},
{
name: t("menu.discussions"),
path: "discussions",
icon: <MessageSquare size={20} strokeWidth={1.5} />,
url: "https://github.com/bluewave-labs/checkmate/discussions",
},
{
name: t("menu.docs"),
path: "docs",
icon: <FileText size={20} strokeWidth={1.5} />,
url: "https://bluewavelabs.gitbook.io/checkmate",
},
{
name: t("menu.changelog"),
path: "changelog",
icon: <ScrollText size={20} strokeWidth={1.5} />,
url: "https://github.com/bluewave-labs/checkmate/releases",
},
];
@@ -0,0 +1,117 @@
import Tooltip from "@mui/material/Tooltip";
import ListItemButton from "@mui/material/ListItemButton";
import ListItemIcon from "@mui/material/ListItemIcon";
import Box from "@mui/material/Box";
import Typography from "@mui/material/Typography";
import { useTheme } from "@mui/material/styles";
export interface NavData {
name: string;
icon: React.ReactElement;
}
export const NavItem = ({
item,
sidebarOpen,
selected,
onClick,
}: {
item: NavData;
sidebarOpen: boolean;
selected: boolean;
onClick: (event: React.MouseEvent) => void;
}) => {
const theme = useTheme();
const iconStroke = selected
? theme.palette.accent.main
: theme.palette.primary.contrastTextTertiary;
const buttonBgColor = selected ? theme.palette.secondary.main : "transparent";
const buttonBgHoverColor = selected
? theme.palette.secondary.main
: theme.palette.tertiary.main;
const fontWeight = selected ? 600 : 400;
return (
<Tooltip
placement="right"
title={sidebarOpen ? "" : item.name}
slotProps={{
popper: {
modifiers: [
{
name: "offset",
options: {
offset: [0, -16],
},
},
],
},
}}
disableInteractive
>
<ListItemButton
sx={{
backgroundColor: buttonBgColor,
backgroundImage: selected
? `linear-gradient(135deg, ${theme.palette.secondary.main} 0%, ${theme.palette.secondary.dark} 100%)`
: "none",
border: 1,
borderColor: selected ? theme.palette.primary.veryLowContrast : "transparent",
"&:hover": {
backgroundColor: buttonBgHoverColor,
backgroundImage: selected
? `linear-gradient(135deg, ${theme.palette.secondary.main} 0%, ${theme.palette.secondary.dark} 100%)`
: "none",
},
height: 32,
gap: theme.spacing(4),
borderRadius: theme.shape.borderRadius,
px: theme.spacing(4),
pl: theme.spacing(5),
}}
onClick={onClick}
>
<ListItemIcon
sx={{
minWidth: 0,
"& svg": {
height: 16,
width: 16,
opacity: 0.81,
transition: "stroke 0.2s ease",
},
"& svg path, & svg line, & svg polyline, & svg rect, & svg circle": {
stroke: iconStroke,
},
".MuiListItemButton-root:hover &": {
"& svg path, & svg line, & svg polyline, & svg rect, & svg circle": {
stroke: theme.palette.accent.main,
},
},
}}
>
{item.icon}
</ListItemIcon>
<Box
sx={{
overflow: "hidden",
transition: "opacity 900ms ease",
opacity: sidebarOpen ? 1 : 0,
whiteSpace: "nowrap",
}}
>
<Typography
variant="body1"
color={theme.palette.primary.contrastText}
sx={{
fontWeight: fontWeight,
opacity: 0.9,
}}
>
{item.name}
</Typography>
</Box>
</ListItemButton>
</Tooltip>
);
};
@@ -0,0 +1,108 @@
import { useEffect } from "react";
import useMediaQuery from "@mui/material/useMediaQuery";
import { useTheme } from "@mui/material/styles";
import { useTranslation } from "react-i18next";
import { useNavigate, useLocation } from "react-router-dom";
import { useAppSelector, useAppDispatch } from "@/hooks/AppHooks";
import { CollapseButton } from "@/components/layouts/sidebar/CollapseButton";
import Stack from "@mui/material/Stack";
import List from "@mui/material/List";
import Divider from "@mui/material/Divider";
import { Logo } from "@/components/layouts/sidebar/Logo";
import { getMenu, getBottomMenu } from "@/components/layouts/sidebar/Menu";
import { NavItem } from "@/components/layouts/sidebar/NavItem";
import { BottomControls } from "@/components/layouts/sidebar/BottomControls";
import { setSidebarOpen } from "@/features/uiSlice";
export const COLLAPSED_WIDTH = 64;
export const EXPANDED_WIDTH = 200;
export const SideBar = () => {
const theme = useTheme();
const isSmall = useMediaQuery(theme.breakpoints.down("md"));
const sideBarOpen = useAppSelector((state) => state.ui.sidebarOpen);
const { t } = useTranslation();
const navigate = useNavigate();
const location = useLocation();
const menu = getMenu(t);
const bottomMenu = getBottomMenu(t);
const dispatch = useAppDispatch();
useEffect(() => {
dispatch(setSidebarOpen(!isSmall));
}, [isSmall, dispatch]);
return (
<Stack
component="aside"
position="sticky"
top={0}
minHeight={"100vh"}
maxHeight={"100vh"}
paddingTop={theme.spacing(6)}
paddingBottom={theme.spacing(6)}
gap={theme.spacing(6)}
borderRight={`1px solid ${theme.palette.primary.lowContrast}`}
width={sideBarOpen ? EXPANDED_WIDTH : COLLAPSED_WIDTH}
sx={{
transition: "width 650ms cubic-bezier(0.36, -0.01, 0, 0.77)",
}}
>
<CollapseButton sidebarOpen={sideBarOpen} />
<Logo sidebarOpen={sideBarOpen} />
<List
component="nav"
disablePadding
sx={{
px: theme.spacing(6),
height: "100%",
}}
>
{menu.map((item) => {
const selected = location.pathname.startsWith(`/${item.path}`);
return (
<NavItem
key={item.path}
item={item}
sidebarOpen={sideBarOpen}
selected={selected}
onClick={() => navigate(`/${item.path}`)}
/>
);
})}
</List>
<List
component="nav"
disablePadding
sx={{
px: theme.spacing(6),
}}
>
{bottomMenu.map((item) => {
const selected = location.pathname.startsWith(`/${item.path}`);
return (
<NavItem
key={item.path}
item={item}
sidebarOpen={sideBarOpen}
selected={selected}
onClick={async () => {
if (item.url) {
window.open(item.url, "_blank", "noreferrer");
} else {
navigate(`/${item.path}`);
}
}}
/>
);
})}
</List>
<Divider
sx={{ mt: "auto", borderColor: theme.palette.primary.lowContrast }}
/>
<BottomControls />
</Stack>
);
};
+63
View File
@@ -0,0 +1,63 @@
import { BaseBox } from "../design-elements";
import Stack from "@mui/material/Stack";
import Box from "@mui/material/Box";
import Typography from "@mui/material/Typography";
import { useTheme } from "@mui/material/styles";
type BaseChartProps = React.PropsWithChildren<{
icon: React.ReactNode;
title: string;
width?: number | string;
maxWidth?: number | string;
}>;
export const BaseChart: React.FC<BaseChartProps> = ({
children,
icon,
title,
width = "100%",
maxWidth = "100%",
}) => {
const theme = useTheme();
return (
<BaseBox
sx={{
padding: theme.spacing(8),
display: "flex",
flex: 1,
width: width,
maxWidth: maxWidth,
}}
>
<Stack gap={theme.spacing(8)} flex={1}>
<Stack direction="row" alignItems={"center"} gap={theme.spacing(4)}>
{icon && (
<BaseBox
sx={{
display: "flex",
alignItems: "center",
justifyContent: "center",
width: 34,
height: 34,
backgroundColor: theme.palette.primary.veryLowContrast,
"& svg": {
width: 20,
height: 20,
"& path": {
stroke: theme.palette.primary.contrastTextTertiary,
},
},
}}
>
{icon}
</BaseBox>
)}
<Typography variant="h2">{title}</Typography>
</Stack>
<Box flex={1}>{children}</Box>
</Stack>
</BaseBox>
);
};
@@ -0,0 +1,74 @@
import { BaseChart } from "@/components/monitors/Chart";
import Stack from "@mui/material/Stack";
import Typography from "@mui/material/Typography";
import { Gauge } from "lucide-react";
import { Cell, RadialBarChart, RadialBar, ResponsiveContainer } from "recharts";
import { getResponseTimeColor } from "@/utils/MonitorUtils";
import { useTheme } from "@mui/material/styles";
export const ChartAvgResponse = ({
avg,
max,
}: {
avg: number;
max: number;
}) => {
const theme = useTheme();
const chartData = [
{ name: "max", value: max - avg, color: "transparent" },
{ name: "avg", value: avg, color: "red" },
];
const palette = getResponseTimeColor(avg);
const msg: Record<string, string> = {
success: "Excellent",
warning: "Average",
danger: "Poor",
};
return (
<BaseChart icon={<Gauge size={20} strokeWidth={1.5} />} title={"Average response time"}>
<Stack height="100%" position={"relative"} justifyContent={"flex-end"}>
<ResponsiveContainer width="100%" height={155}>
<RadialBarChart
cy="100%"
data={chartData}
startAngle={180}
endAngle={0}
innerRadius={"120%"}
outerRadius={"200%"}
>
<RadialBar
dataKey="value"
background={{ fill: theme.palette[palette].lowContrast }}
>
<Cell visibility={"hidden"} />
<Cell fill={theme.palette[palette].main} />
</RadialBar>
</RadialBarChart>
</ResponsiveContainer>
<Stack direction={"row"} justifyContent={"space-between"}>
<Typography variant="body2">Low</Typography>
<Typography variant="body2">High</Typography>
</Stack>
<Stack
position="absolute"
top={"50%"}
right={"50%"}
sx={{
transform: "translate(50%, 0%)",
}}
>
<Typography variant="h6" textAlign={"center"}>
{msg[palette]}
</Typography>
<Typography
variant="h6"
textAlign={"center"}
>{`${avg?.toFixed()}ms`}</Typography>
</Stack>
</Stack>
</BaseChart>
);
};
@@ -0,0 +1,92 @@
import { BaseChart } from "@/components/monitors/Chart";
import { FileText } from "lucide-react";
import { Pie, PieChart, ResponsiveContainer, Label } from "recharts";
import Typography from "@mui/material/Typography";
import { getPageSpeedPalette } from "@/utils/MonitorUtils";
import { useTheme } from "@mui/material/styles";
import { alpha } from "@mui/material/styles";
const CenterLabel = ({ viewBox, value }: any) => {
const { cx, cy } = viewBox;
return (
<foreignObject x={cx - 25} y={cy - 10} width={50} height={50}>
<Typography variant="h1" align="center">
{value}
</Typography>
</foreignObject>
);
};
export const ChartPageSpeedReport = ({ latestCheck }: { latestCheck: any }) => {
const theme = useTheme();
const metrics = [
{ key: "fcp", color: alpha("#1DE9B6", 0.6), weight: 0.1 },
{ key: "si", color: alpha("#7C4DFF", 0.6), weight: 0.1 },
{ key: "lcp", color: alpha("#FFB200", 0.6), weight: 0.25 },
{ key: "tbt", color: alpha("#00AFFE", 0.6), weight: 0.3 },
{ key: "cls", color: alpha("#FF4181", 0.6), weight: 0.25 },
];
const scores = metrics.flatMap(({ key, color, weight }) => {
const val = Math.floor((latestCheck?.[key] ?? 0) * 100);
const inverse = 100 - val;
return [
{
name: `${key.toUpperCase()} Inverse`,
value: inverse * weight,
fill: "transparent",
stroke: color,
weight,
},
{
name: key.toUpperCase(),
value: val * weight,
fill: color,
stroke: color,
weight,
},
];
});
const totalScore =
(latestCheck?.fcp || 0) * 0.1 +
(latestCheck?.si || 0) * 0.1 +
(latestCheck?.lcp || 0) * 0.25 +
(latestCheck?.tbt || 0) * 0.3 +
(latestCheck?.cls || 0) * 0.25;
const pageSpeedPalette = getPageSpeedPalette(Math.floor(totalScore * 100));
const score = [
{
value: 100,
fill: alpha(
theme.palette[pageSpeedPalette].lowContrast || "#ffffff",
0.6
),
stroke: "none",
},
];
return (
<BaseChart icon={<FileText size={20} strokeWidth={1.5} />} title="Average PageSpeed score">
<ResponsiveContainer width="100%" height={250}>
<PieChart>
<Pie data={score} dataKey="value" cx="50%" cy="50%" outerRadius="65%">
<Label
position={"center"}
content={<CenterLabel value={Math.floor(totalScore * 100)} />}
/>
</Pie>
<Pie
data={scores}
innerRadius="70%"
outerRadius="80%"
label={({ name, value }) => `${name}: ${Math.round(value)}`}
dataKey="value"
/>
</PieChart>
</ResponsiveContainer>
</BaseChart>
);
};
@@ -0,0 +1,87 @@
import Stack from "@mui/material/Stack";
import Box from "@mui/material/Box";
import { BarChart3 } from "lucide-react";
import { BaseChart } from "@/components/monitors/Chart";
import Typography from "@mui/material/Typography";
import { getPageSpeedPalette } from "@/utils/MonitorUtils";
import { useTheme } from "@mui/material/styles";
const MetricBox = ({
label,
value,
weight,
}: {
label: string;
value: number;
weight: number;
}) => {
const theme = useTheme();
const palette = getPageSpeedPalette(value);
return (
<Stack
direction={"row"}
sx={{
border: 1,
borderStyle: "solid",
borderColor: theme.palette.primary.lowContrast,
borderRadius: theme.shape.borderRadius,
}}
>
<Stack flex={1} p={theme.spacing(4)}>
<Typography textTransform={"uppercase"}>{label}</Typography>
<Stack direction="row" justifyContent={"space-between"}>
<Typography>{`${value}%`}</Typography>
<Typography>{`Weight: ${weight}%`}</Typography>
</Stack>
</Stack>
<Box
width={4}
bgcolor={theme.palette[palette].lowContrast}
sx={{
borderTopRightRadius: theme.shape.borderRadius,
borderBottomRightRadius: theme.shape.borderRadius,
}}
/>
</Stack>
);
};
export const ChartPageSpeedReportLegend = ({
latestCheck,
}: {
latestCheck: any;
}) => {
const theme = useTheme();
return (
<BaseChart icon={<BarChart3 size={20} strokeWidth={1.5} />} title="PageSpeed report">
<Stack gap={theme.spacing(4)}>
<MetricBox
label="Speed index (SI)"
value={Math.floor(latestCheck?.si * 100 || 0 * 100)}
weight={10}
/>
<MetricBox
label="First contentful paint (FCP)"
value={Math.floor(latestCheck?.fcp * 100 || 0 * 100)}
weight={10}
/>
<MetricBox
label="Cumulative layout shift (CLS)"
value={Math.floor(latestCheck?.cls * 100 || 0 * 100)}
weight={25}
/>
<MetricBox
label="Total blocking time (TBT)"
value={Math.floor(latestCheck?.tbt * 100 || 0 * 100)}
weight={30}
/>
<MetricBox
label="Largest contentful paint (LCP)"
value={Math.floor(latestCheck?.lcp * 100 || 0 * 100)}
weight={25}
/>
</Stack>
</BaseChart>
);
};
@@ -0,0 +1,148 @@
import { BaseChart } from "@/components/monitors/Chart";
import { BaseBox } from "@/components/design-elements";
import { Clock } from "lucide-react";
import { normalizeResponseTimes } from "@/utils/DataUtils";
import {
AreaChart,
Area,
XAxis,
Tooltip,
CartesianGrid,
ResponsiveContainer,
Text,
} from "recharts";
import Typography from "@mui/material/Typography";
import {
formatDateWithTz,
tickDateFormatLookup,
tooltipDateFormatLookup,
} from "@/utils/TimeUtils";
import { useTheme } from "@mui/material/styles";
import type { GroupedCheck } from "@/types/check";
import { useAppSelector } from "@/hooks/AppHooks";
type XTickProps = {
x: number;
y: number;
payload: { value: any };
range: string;
};
export const XTick: React.FC<XTickProps> = ({ x, y, payload, range }) => {
const format = tickDateFormatLookup(range);
const theme = useTheme();
const uiTimezone = useAppSelector((state: any) => state.ui.timezone);
return (
<Text
x={x}
y={y + 10}
textAnchor="middle"
fill={theme.palette.primary.contrastTextTertiary}
fontSize={11}
fontWeight={400}
>
{formatDateWithTz(payload?.value, format, uiTimezone)}
</Text>
);
};
type ResponseTimeToolTipProps = {
active?: boolean | undefined;
payload?: any[];
label?: string | number;
range: string;
theme: any;
uiTimezone: string;
};
const ResponseTimeToolTip: React.FC<ResponseTimeToolTipProps> = ({
active,
payload,
label,
range,
theme,
uiTimezone,
}) => {
if (!label) return null;
if (!payload) return null;
if (!active) return null;
const format = tooltipDateFormatLookup(range);
const responseTime = Math.floor(payload?.[0]?.payload?.avgResponseTime || 0);
return (
<BaseBox sx={{ py: theme.spacing(2), px: theme.spacing(4) }}>
<Typography>
{formatDateWithTz(String(label), format, uiTimezone)}
</Typography>
<Typography>Response time: {responseTime} ms</Typography>
</BaseBox>
);
};
export const ChartResponseTime = ({
checks,
range,
}: {
checks: GroupedCheck[];
range: string;
}) => {
const theme = useTheme();
const uiTimezone = useAppSelector((state: any) => state.ui.timezone);
const normalized = normalizeResponseTimes<GroupedCheck, "avgResponseTime">(
checks,
"avgResponseTime"
);
return (
<BaseChart icon={<Clock size={20} strokeWidth={1.5} />} title="Response times">
<ResponsiveContainer width="100%" height={300}>
<AreaChart data={normalized?.slice().reverse()}>
<CartesianGrid
stroke={theme.palette.primary.lowContrast}
strokeWidth={1}
strokeOpacity={1}
fill="transparent"
vertical={false}
/>
<defs>
<linearGradient id="colorUv" x1="0" y1="0" x2="0" y2="1">
<stop
offset="0%"
stopColor={theme.palette.accent.main}
stopOpacity={0.8}
/>
<stop
offset="100%"
stopColor={theme.palette.accent.light}
stopOpacity={0}
/>
</linearGradient>
</defs>
<XAxis
axisLine={false}
tickLine={false}
dataKey="_id"
tick={(props) => <XTick {...props} range={range} />}
/>
<Tooltip
content={(props) => (
<ResponseTimeToolTip
{...props}
range={range}
theme={theme}
uiTimezone={uiTimezone}
/>
)}
/>
<Area
type="monotone"
dataKey="normalResponseTime"
stroke={theme.palette.accent.main}
fill="url(#colorUv)"
/>
</AreaChart>
</ResponsiveContainer>
</BaseChart>
);
};
@@ -0,0 +1,93 @@
import Stack from "@mui/material/Stack";
import { MonitorStatus } from "@/components/monitors/MonitorStatus";
import { ButtonGroup, Button } from "@/components/inputs";
import { Settings, Pause, Play, Mail, Bug } from "lucide-react";
import useMediaQuery from "@mui/material/useMediaQuery";
import { useTranslation } from "react-i18next";
import { useTheme } from "@mui/material/styles";
import { useNavigate } from "react-router";
import type { IMonitor } from "@/types/monitor";
import { usePost } from "@/hooks/UseApi";
export const HeaderControls = ({
monitor,
patch,
isPatching,
refetch,
path,
}: {
monitor: IMonitor;
patch: Function;
isPatching: boolean;
refetch: Function;
path: string;
}) => {
const { t } = useTranslation();
const theme = useTheme();
const isSmall = useMediaQuery(theme.breakpoints.down("md"));
const navigate = useNavigate();
const { post, loading: isPosting } = usePost<any, any>();
const hasNotificationChannels = monitor?.notificationChannels.length > 0;
return (
<Stack
direction={isSmall ? "column" : "row"}
spacing={isSmall ? theme.spacing(4) : 0}
justifyContent={"space-between"}
>
<MonitorStatus monitor={monitor} />
<Stack direction={"row"} spacing={theme.spacing(2)}>
<ButtonGroup
orientation={isSmall ? "vertical" : "horizontal"}
fullWidth={isSmall}
variant="contained"
color="secondary"
>
{hasNotificationChannels && (
<Button
loading={isPosting || isPatching}
startIcon={<Mail size={20} strokeWidth={1.5} />}
onClick={async () => {
await post(`/monitors/${monitor._id}/notifications/test`, {});
}}
>
{t("sendTestNotifications")}
</Button>
)}
<Button
startIcon={<Bug size={20} strokeWidth={1.5} />}
onClick={() => {
navigate(`/incidents/${monitor._id}`);
}}
>
{t("menu.incidents")}
</Button>
<Button
loading={isPatching || isPosting}
onClick={async () => {
await patch(`/monitors/${monitor._id}/active`);
refetch();
}}
startIcon={
monitor?.isActive ? (
<Pause size={20} strokeWidth={1.5} />
) : (
<Play size={20} strokeWidth={1.5} />
)
}
>
{monitor?.isActive ? t("pause") : t("resume")}
</Button>
<Button
startIcon={<Settings size={20} strokeWidth={1.5} />}
onClick={() => {
navigate(`${path}/${monitor._id}/configure`);
}}
>
{t("configure")}
</Button>
</ButtonGroup>
</Stack>
</Stack>
);
};
@@ -0,0 +1,35 @@
import Stack from "@mui/material/Stack";
import { Button } from "@/components/inputs";
import { useTheme } from "@mui/material/styles";
import { useTranslation } from "react-i18next";
import { useNavigate } from "react-router";
export const HeaderCreate = ({
label,
isLoading,
path,
}: {
label?: string;
isLoading: boolean;
path: string;
}) => {
const theme = useTheme();
const { t } = useTranslation();
const navigate = useNavigate();
return (
<Stack
direction="row"
justifyContent="end"
alignItems="center"
gap={theme.spacing(6)}
>
<Button
loading={isLoading}
variant="contained"
color="accent"
onClick={() => navigate(path)}
>
{label || t("createNew")}
</Button>
</Stack>
);
};
@@ -0,0 +1,179 @@
import { BaseChart } from "@/components/monitors/Chart";
import {
AreaChart,
Area,
XAxis,
YAxis,
CartesianGrid,
ResponsiveContainer,
} from "recharts";
import { Fragment, useId } from "react";
import { XTick } from "./ChartResponseTime";
import { useTheme } from "@mui/material/styles";
import type { IInfraCheck } from "@/types/check";
const AREA_COLORS = [
// Blues
"#3182bd", // Deep blue
"#6baed6", // Medium blue
"#9ecae1", // Light blue
// Greens
"#74c476", // Soft green
"#a1d99b", // Light green
"#c7e9c0", // Pale green
// Oranges
"#fdae6b", // Warm orange
"#fdd0a2", // Light orange
"#feedde", // Pale orange
// Purples
"#9467bd", // Lavender
"#a55194", // Deep magenta
"#c994c7", // Soft magenta
// Reds
"#ff9896", // Soft red
"#de2d26", // Deep red
"#fc9272", // Medium red
// Cyans/Teals
"#17becf", // Cyan
"#7fcdbb", // Teal
"#a1dab4", // Light teal
// Yellows
"#fec44f", // Mustard
"#fee391", // Light yellow
"#ffffd4", // Pale yellow
// Additional colors
"#e377c2", // Soft pink
"#bcbd22", // Olive
"#2ca02c", // Vibrant green
];
const createGradient = ({
id,
startColor,
endColor,
startOpacity = 0.8,
endOpacity = 0,
direction = "vertical",
}: {
id: string;
startColor: string;
endColor: string;
startOpacity?: number;
endOpacity?: number;
direction?: "vertical" | "horizontal";
}) => (
<defs>
<linearGradient
id={id}
x1={direction === "vertical" ? "0" : "0"}
y1={direction === "vertical" ? "0" : "0"}
x2={direction === "vertical" ? "0" : "1"}
y2={direction === "vertical" ? "1" : "0"}
>
<stop offset="0%" stopColor={startColor} stopOpacity={startOpacity} />
<stop offset="100%" stopColor={endColor} stopOpacity={endOpacity} />
</linearGradient>
</defs>
);
export const HistogramInfrastructure = ({
range,
title,
idx,
checks,
xKey,
yDomain,
dataKeys,
gradient = false,
gradientDirection = "vertical",
gradientStartColor,
gradientEndColor,
strokeColor,
fillColor,
}: {
range: string;
title: string;
idx: number | null;
checks: IInfraCheck[];
xKey: string;
yDomain?: number[];
dataKeys: string[];
gradient?: boolean;
gradientDirection?: "vertical" | "horizontal";
gradientStartColor?: string;
gradientEndColor?: string;
strokeColor: string;
fillColor?: string;
}) => {
const theme = useTheme();
const uniqueId = useId();
let avgTemps: { _id: string; avg_temp: number | null }[] = [];
let tempYDomain: number[] = [];
if (title === "temp") {
avgTemps = checks.map((check) => {
const temps = check.cpu.temperature || [];
if (temps.length === 0) return { ...check, avg_temp: null };
const totalTemp = temps.reduce((sum, temp) => sum + (temp || 0), 0);
const avgTemp = totalTemp / temps.length;
return { _id: check._id, avg_temp: avgTemp };
});
const maxTemp: number = avgTemps.reduce((max, item) => {
return item.avg_temp && item.avg_temp > max ? item.avg_temp : max;
}, 0);
tempYDomain = [0, Math.ceil((maxTemp * 1.3) / 10) * 10];
}
return (
<BaseChart icon={null} title={idx !== null ? title + ` ${idx}` : title}>
<ResponsiveContainer width="100%" height={200}>
<AreaChart data={title === "temp" ? avgTemps : checks}>
<XAxis
dataKey={xKey}
tick={(props) => <XTick {...props} range={range} />}
/>
<YAxis domain={title === "temp" ? tempYDomain : yDomain} />
<CartesianGrid
stroke={theme.palette.primary.lowContrast}
strokeWidth={1}
strokeOpacity={1}
fill="transparent"
vertical={false}
/>
{dataKeys?.map((dataKey, index) => {
const gradientId = `gradient-${uniqueId}-${index}`;
return (
<Fragment key={dataKey}>
{gradient === true &&
createGradient({
id: gradientId,
startColor: gradientStartColor || AREA_COLORS[index],
endColor: gradientEndColor || "transparent",
direction: gradientDirection,
})}
<Area
key={dataKey}
type="monotone"
dataKey={dataKey}
stroke={strokeColor || AREA_COLORS[index]}
fill={gradient === true ? `url(#${gradientId})` : fillColor}
/>
</Fragment>
);
})}
</AreaChart>
</ResponsiveContainer>
</BaseChart>
);
};
@@ -0,0 +1,103 @@
import Stack from "@mui/material/Stack";
import {
Area,
AreaChart,
CartesianGrid,
ResponsiveContainer,
Tooltip,
} from "recharts";
import { HistogramPageSpeedTooltip } from "@/components/monitors/HistogramPageSpeedTooltip";
import { useTheme } from "@mui/material/styles";
import type { ICheck } from "@/types/check";
import type { MonitorStatus } from "@/types/monitor";
import { getStatusColor } from "@/utils/MonitorUtils";
const processData = (checks: ICheck[]) => {
if (checks.length === 0) return [];
const formattedData: { score: number; date: string }[] = [];
const calculateScore = (entry: ICheck) => {
const accessibility = entry?.lighthouse?.accessibility || 0;
const bestPractices = entry?.lighthouse?.bestPractices || 0;
const performance = entry?.lighthouse?.performance || 0;
const seo = entry?.lighthouse?.seo || 0;
return Math.floor(
((accessibility + bestPractices + performance + seo) / 4) * 100
);
};
checks.forEach((entry) => {
const score = calculateScore(entry);
const date = entry.createdAt;
formattedData.push({ score, date });
});
return formattedData;
};
export const HistogramPageSpeed = ({
checks,
status,
}: {
checks: ICheck[];
status: MonitorStatus;
}) => {
const theme = useTheme();
const scores = processData(checks);
const color = getStatusColor(status, theme);
return (
<Stack
direction="row"
flexWrap="nowrap"
gap={theme.spacing(1.5)}
height="100px"
width="400px"
onClick={(event) => event.stopPropagation()}
overflow={"hidden"}
sx={{
cursor: "default",
position: "relative",
}}
>
<ResponsiveContainer width="100%" height={"100%"}>
<AreaChart
data={scores}
margin={{ top: 10, bottom: -5 }}
style={{ cursor: "pointer" }}
>
<CartesianGrid
stroke={theme.palette.primary.lowContrast}
strokeWidth={1}
strokeOpacity={1}
fill="transparent"
vertical={false}
/>
<Tooltip
cursor={{ stroke: theme.palette.primary.lowContrast }}
content={<HistogramPageSpeedTooltip />}
/>
<defs>
<linearGradient
id={`pagespeed-chart-${status}`}
x1="0"
y1="0"
x2="0"
y2="1"
>
<stop offset="0%" stopColor={color} stopOpacity={0.8} />
<stop offset="100%" stopColor={color} stopOpacity={0} />
</linearGradient>
</defs>
<Area
type="monotone"
dataKey="score"
stroke={color}
fill={`url(#pagespeed-chart-${status})`}
/>
</AreaChart>
</ResponsiveContainer>
</Stack>
);
};
@@ -0,0 +1,104 @@
import { BaseChart } from "@/components/monitors/Chart";
import { TrendingUp } from "lucide-react";
import {
AreaChart,
Area,
Tooltip,
CartesianGrid,
ResponsiveContainer,
} from "recharts";
import { HistogramPageSpeedScoresTooltip } from "./HistogramPageSpeedScoresTooltip";
import { useTheme } from "@mui/material/styles";
import type { GroupedCheck } from "@/types/check";
import type { Palette } from "@mui/material/styles";
type PaletteColorKey = Extract<
keyof Palette,
"primary" | "secondary" | "success" | "warning" | "accent"
>;
export interface ConfigItem {
id: string;
text: string;
palette: PaletteColorKey;
}
const config: Record<string, ConfigItem> = {
seo: {
id: "seo",
text: "SEO",
palette: "secondary",
},
performance: {
id: "performance",
text: "performance",
palette: "success",
},
bestPractices: {
id: "bestPractices",
text: "best practices",
palette: "warning",
},
accessibility: {
id: "accessibility",
text: "accessibility",
palette: "accent",
},
};
export const HistogramPageSpeedScores = ({
checks,
}: {
checks: GroupedCheck[];
}) => {
const theme = useTheme();
return (
<BaseChart icon={<TrendingUp size={20} strokeWidth={1.5} />} title="Score history">
<ResponsiveContainer width="100%" minWidth={25} height={215}>
<AreaChart data={checks}>
<CartesianGrid
stroke={theme.palette.primary.lowContrast}
strokeWidth={1}
strokeOpacity={1}
fill="transparent"
vertical={false}
/>
<Tooltip
cursor={{ stroke: theme.palette.primary.lowContrast }}
content={<HistogramPageSpeedScoresTooltip config={config} />}
/>
<defs>
{Object.values(config).map(({ id, palette }) => {
const startColor = theme.palette[palette].main;
const endColor = theme.palette[palette].lowContrast;
return (
<linearGradient id={id} x1="0" y1="0" x2="0" y2="1" key={id}>
<stop offset="0%" stopColor={startColor} stopOpacity={0.8} />
<stop offset="100%" stopColor={endColor} stopOpacity={0} />
</linearGradient>
);
})}
</defs>
{Object.keys(config).map((key) => {
const { palette } = config[key];
const strokeColor = theme.palette[palette].main;
const bgColor = theme.palette.primary.main;
return (
<Area
connectNulls
key={key}
dataKey={key}
stackId={1}
stroke={strokeColor}
fill={`url(#${config[key].id})`}
activeDot={{ stroke: bgColor, fill: strokeColor, r: 4.5 }}
/>
);
})}
</AreaChart>
</ResponsiveContainer>
</BaseChart>
);
};
@@ -0,0 +1,76 @@
import Box from "@mui/material/Box";
import Stack from "@mui/material/Stack";
import Typography from "@mui/material/Typography";
import { useTheme } from "@mui/material/styles";
import { useAppSelector } from "@/hooks/AppHooks";
import { formatDateWithTz } from "@/utils/TimeUtils";
import type { ConfigItem } from "@/components/monitors/HistogramPageSpeedScores";
import type { TooltipProps } from "recharts";
interface HistogramPageSpeedScoresTooltipProps
extends Partial<TooltipProps<number, string>> {
config: Record<string, ConfigItem>;
}
export const HistogramPageSpeedScoresTooltip = ({
active,
payload,
label,
config,
}: HistogramPageSpeedScoresTooltipProps) => {
const theme = useTheme();
const uiTimezone = useAppSelector((state: any) => state.ui.timezone);
if (active && payload && payload.length) {
return (
<Box
sx={{
backgroundColor: theme.palette.primary.main,
border: 1,
borderColor: theme.palette.primary.lowContrast,
borderRadius: theme.shape.borderRadius,
py: theme.spacing(2),
px: theme.spacing(4),
}}
>
<Typography
sx={{
color: theme.palette.primary.contrastTextTertiary,
fontSize: 12,
fontWeight: 500,
}}
>
{formatDateWithTz(label, "ddd, MMMM D, YYYY, h:mm A", uiTimezone)}
</Typography>
{Object.keys(config)
.reverse()
.map((key) => {
const { palette } = config[key];
const dotColor = theme.palette[palette].main;
return (
<Stack
key={`${key}-tooltip`}
direction="row"
alignItems="center"
gap={theme.spacing(3)}
mt={theme.spacing(1)}
>
<Box
width={theme.spacing(4)}
height={theme.spacing(4)}
sx={{ borderRadius: "50%", backgroundColor: dotColor }}
/>
<Typography textTransform="capitalize" sx={{ opacity: 0.8 }}>
{config[key].text}
</Typography>
<Typography>
{Math.floor(payload[0].payload[key] * 100)}
</Typography>
</Stack>
);
})}
</Box>
);
}
return null;
};
@@ -0,0 +1,39 @@
import Stack from "@mui/material/Stack";
import Typography from "@mui/material/Typography";
import { formatDateWithTz } from "@/utils/TimeUtils";
import { useAppSelector } from "@/hooks/AppHooks";
import type { TooltipProps } from "recharts";
import { useTheme } from "@mui/material/styles";
export const HistogramPageSpeedTooltip = ({
payload,
}: TooltipProps<string | number, string>) => {
const uiTimezone = useAppSelector((state: any) => state.ui.timezone);
const theme = useTheme();
return (
<Stack
alignItems={"flex-start"}
top={0}
left={0}
zIndex={10}
sx={{
backgroundColor: theme.palette.secondary.main,
border: 1,
borderColor: theme.palette.primary.lowContrast,
borderRadius: theme.shape.borderRadius,
p: theme.spacing(4),
}}
>
<Typography color={theme.palette.primary.contrastText}>
{formatDateWithTz(
payload?.[0]?.payload?.date ?? 0,
"MMMM D, YYYY, HH:mm A",
uiTimezone
)}
</Typography>
<Typography color={theme.palette.primary.contrastText}>
Score: {payload?.[0]?.payload?.score}
</Typography>
</Stack>
);
};
@@ -0,0 +1,87 @@
import Stack from "@mui/material/Stack";
import Box from "@mui/material/Box";
import { useTheme } from "@mui/material/styles";
import type { ICheck } from "@/types/check";
import { HistogramResponseTimeTooltip } from "@/components/monitors/HistogramResponseTimeTooltip";
import { normalizeResponseTimes } from "@/utils/DataUtils";
export const HistogramResponseTime = ({ checks }: { checks: ICheck[] }) => {
const theme = useTheme();
const normalChecks = normalizeResponseTimes(checks, "responseTime");
const BAR_WIDTH = { xs: theme.spacing(2.5), md: theme.spacing(4.5) };
let data = Array<any>();
if (!normalChecks || normalChecks.length === 0) {
return null;
}
if (normalChecks.length !== 25) {
const placeholders = Array(25 - normalChecks.length).fill("placeholder");
data = [...normalChecks, ...placeholders];
} else {
data = normalChecks;
}
return (
<Stack
direction="row"
flexWrap="nowrap"
gap={theme.spacing(1.5)}
height="50px"
width="fit-content"
onClick={(event) => event.stopPropagation()}
sx={{
cursor: "default",
}}
>
{data.map((check, index) => {
if (check === "placeholder") {
return (
<Box
key={`${check}-${index}`}
position="relative"
width={BAR_WIDTH}
height="100%"
bgcolor={theme.palette.primary.veryLowContrast}
sx={{
borderRadius: theme.spacing(1.5),
}}
/>
);
} else {
return (
<HistogramResponseTimeTooltip
key={`${check}-${index}`}
check={check}
>
<Box
position="relative"
height="100%"
bgcolor={theme.palette.primary.veryLowContrast}
width={BAR_WIDTH}
sx={{
borderRadius: theme.spacing(1.5),
}}
>
<Box
position="absolute"
bottom={0}
width="100%"
height={`${check.normalResponseTime}%`}
bgcolor={
check.status === "up"
? theme.palette.success.lowContrast
: theme.palette.error.lowContrast
}
sx={{
borderRadius: theme.spacing(1.5),
transition: "height 600ms cubic-bezier(0.4, 0, 0.2, 1)",
}}
/>
</Box>
</HistogramResponseTimeTooltip>
);
}
})}
</Stack>
);
};
@@ -0,0 +1,56 @@
import Stack from "@mui/material/Stack";
import Tooltip from "@mui/material/Tooltip";
import Typography from "@mui/material/Typography";
import { formatDateWithTz } from "@/utils/TimeUtils";
import { useAppSelector } from "@/hooks/AppHooks";
import type { LatestCheck } from "@/types/check";
import { useTheme } from "@mui/material/styles";
export const HistogramResponseTimeTooltip: React.FC<{
children: React.ReactElement;
check: LatestCheck;
}> = ({ children, check }) => {
const uiTimezone = useAppSelector((state: any) => state.ui.timezone);
const theme = useTheme();
if (check.status === "placeholder") {
return children;
}
return (
<Tooltip
slotProps={{
tooltip: {
sx: {
backgroundColor: "transparent",
color: "inherit",
boxShadow: "none",
},
},
}}
title={
<Stack
sx={{
backgroundColor: theme.palette.secondary.main,
border: 1,
borderColor: theme.palette.primary.lowContrast,
borderRadius: theme.shape.borderRadius,
p: theme.spacing(4),
}}
>
<Typography>
{formatDateWithTz(
check?.checkedAt,
"ddd, MMMM D, YYYY, HH:mm A",
uiTimezone
)}
</Typography>
{check?.responseTime && (
<Typography>Response Time: {check.responseTime} ms</Typography>
)}
</Stack>
}
>
{children}
</Tooltip>
);
};
@@ -0,0 +1,156 @@
import Stack from "@mui/material/Stack";
import Typography from "@mui/material/Typography";
import { BaseChart } from "@/components/monitors/Chart";
import { ResponsiveContainer, BarChart, XAxis, Bar, Cell } from "recharts";
import { TrendingUp, AlertTriangle } from "lucide-react";
import type { GroupedCheck } from "@/types/check";
import type { MonitorStatus } from "@/types/monitor";
import { normalizeResponseTimes } from "@/utils/DataUtils";
import { useState } from "react";
import { formatDateWithTz } from "@/utils/TimeUtils";
import { useAppSelector } from "@/hooks/AppHooks";
import { useTheme } from "@mui/material/styles";
import { getResponseTimeColor } from "@/utils/MonitorUtils";
const XLabel = ({
p1,
p2,
range,
}: {
p1: GroupedCheck;
p2: GroupedCheck;
range: string;
}) => {
const theme = useTheme();
const uiTimezone = useAppSelector((state: any) => state.ui.timezone);
const dateFormat = range === "day" ? "MMM D, h:mm A" : "MMM D";
return (
<>
<text
x={0}
y="100%"
dy={-3}
textAnchor="start"
fontSize={11}
fill={theme.palette.primary.contrastTextTertiary}
>
{formatDateWithTz(p1._id, dateFormat, uiTimezone)}
</text>
<text
x="100%"
y="100%"
dy={-3}
textAnchor="end"
fontSize={11}
fill={theme.palette.primary.contrastTextTertiary}
>
{formatDateWithTz(p2._id, dateFormat, uiTimezone)}
</text>
</>
);
};
export const HistogramStatus = ({
checks,
status,
range,
title,
}: {
checks: GroupedCheck[];
status: MonitorStatus;
range: string;
title: string;
}) => {
const uiTimezone = useAppSelector((state: any) => state.ui.timezone);
const icon = status === "up" ? <TrendingUp size={20} strokeWidth={1.5} /> : <AlertTriangle size={20} strokeWidth={1.5} />;
const theme = useTheme();
const [idx, setIdx] = useState<number | null>(null);
const dateFormat = range === "1d" || range === "2h" ? "MMM D, h A" : "MMM D";
const normalChecks = normalizeResponseTimes(checks, "avgResponseTime");
if (normalChecks.length === 0) {
return (
<BaseChart icon={icon} title={title}>
<Stack height={"100%"} alignItems={"center"} justifyContent={"center"}>
<Typography variant="h2">
{status === "up" ? "No checks yet" : "Great, no downtime yet!"}
</Typography>
</Stack>
</BaseChart>
);
}
const totalChecks = normalChecks.reduce((count, check) => {
return count + check.count;
}, 0);
return (
<BaseChart icon={icon} title={title}>
<Stack gap={theme.spacing(8)}>
<Stack
position="relative"
direction="row"
justifyContent="space-between"
>
<Stack>
<Typography>Total checks</Typography>
{idx ? (
<Stack>
<Typography variant="h2">
{normalChecks?.[idx]?.count}
</Typography>
<Typography position={"absolute"} top={"100%"}>
{formatDateWithTz(
normalChecks?.[idx]?._id,
dateFormat,
uiTimezone
)}
</Typography>
</Stack>
) : (
<Typography variant="h2">{totalChecks}</Typography>
)}
</Stack>
</Stack>
<ResponsiveContainer width="100%" height={155}>
<BarChart data={normalChecks}>
<XAxis
stroke={theme.palette.primary.lowContrast}
height={15}
tick={false}
label={
<XLabel
p1={normalChecks[0]}
p2={normalChecks[normalChecks.length - 1]}
range={range}
/>
}
/>
<Bar
dataKey="normalResponseTime"
maxBarSize={7}
background={{ fill: "transparent" }}
>
{normalChecks?.map((groupedCheck, idx) => {
const fillColor = getResponseTimeColor(
groupedCheck.normalResponseTime
);
return (
<Cell
onMouseEnter={() => setIdx(idx)}
onMouseLeave={() => setIdx(null)}
key={groupedCheck._id}
fill={theme.palette[fillColor].main}
/>
);
})}
</Bar>
</BarChart>
</ResponsiveContainer>
</Stack>
</BaseChart>
);
};
@@ -0,0 +1,60 @@
import type { IMonitor } from "@/types/monitor";
import Stack from "@mui/material/Stack";
import Typography from "@mui/material/Typography";
import { PulseDot, Dot } from "@/components/design-elements";
import { getStatusColor, formatUrl } from "@/utils/MonitorUtils";
import { useTheme } from "@mui/material/styles";
import prettyMilliseconds from "pretty-ms";
import { typographyLevels } from "@/theme/palette";
import useMediaQuery from "@mui/material/useMediaQuery";
export const MonitorStatus = ({ monitor }: { monitor: IMonitor }) => {
const theme = useTheme();
const isSmall = useMediaQuery(theme.breakpoints.down("md"));
if (!monitor) {
return null;
}
return (
<Stack>
<Typography
fontSize={typographyLevels.xl}
fontWeight={500}
color={theme.palette.primary.contrastText}
overflow={"hidden"}
textOverflow={"ellipsis"}
whiteSpace={"nowrap"}
maxWidth={
isSmall ? "100%" : "calc((100vw - var(--env-var-width-2)) / 2)"
}
>
{monitor.name}
</Typography>
<Stack direction="row" alignItems={"center"} gap={theme.spacing(4)}>
<PulseDot color={getStatusColor(monitor.status, theme)} />
<Typography
color={theme.palette.primary.contrastTextSecondary}
fontSize={typographyLevels.l}
fontWeight={"bolder"}
fontFamily={"monospace"}
overflow={"hidden"}
textOverflow={"ellipsis"}
whiteSpace={"nowrap"}
maxWidth={
isSmall ? "100%" : "calc((100vw - var(--env-var-width-2)) / 2)"
}
>
{formatUrl(monitor?.url)}
</Typography>
{!isSmall && (
<>
<Dot />
<Typography>
Checking every{" "}
{prettyMilliseconds(monitor?.interval, { verbose: true })}
</Typography>
</>
)}
</Stack>
</Stack>
);
};
+9
View File
@@ -0,0 +1,9 @@
export { HeaderCreate } from "./HeaderCreate";
export { HistogramStatus } from "./HistogramStatus";
export { ChartAvgResponse } from "./ChartAvgResponse";
export { HeaderRange } from "../common/HeaderRange";
export { HeaderControls } from "./HeaderControls";
export { ChartResponseTime } from "./ChartResponseTime";
export { HistogramResponseTime } from "./HistogramResponseTime";
export { HistogramPageSpeed } from "./HistogramPageSpeed";
export { HistogramInfrastructure } from "./HistogramInfrastructure";
@@ -0,0 +1 @@
export { HeaderCreate } from "@/components/monitors/HeaderCreate";
@@ -0,0 +1,18 @@
import { useAppSelector } from "@/hooks/AppHooks";
import { Navigate } from "react-router";
export const ProtectedRoute: React.FC<React.PropsWithChildren> = ({
children,
}) => {
const isAuthenticated = useAppSelector((state) => state.auth.isAuthenticated);
if (!isAuthenticated) {
return <Navigate to="/login" replace />;
}
if (!isAuthenticated) {
return null;
}
return <>{children}</>;
};
@@ -0,0 +1,72 @@
import Stack from "@mui/material/Stack";
import Box from "@mui/material/Box";
import { useTheme } from "@mui/material/styles";
import type { ICheck } from "@/types/check";
import { HistogramResponseTimeTooltip } from "@/components/monitors/HistogramResponseTimeTooltip";
import { normalizeResponseTimes } from "@/utils/DataUtils";
const BAR_HEIGHT = "50px";
export const HistogramStatusPage = ({ checks }: { checks: ICheck[] }) => {
const theme = useTheme();
const normalChecks = normalizeResponseTimes(checks, "responseTime");
let data = Array<any>();
if (!normalChecks || normalChecks.length === 0) {
return null;
}
if (normalChecks.length !== 25) {
const placeholders = Array(25 - normalChecks.length).fill({
status: "placeholder",
});
data = [...normalChecks, ...placeholders];
} else {
data = normalChecks;
}
return (
<Stack
direction="row"
spacing={"auto"}
height={BAR_HEIGHT}
onClick={(event) => event.stopPropagation()}
sx={{
cursor: "default",
}}
>
{data.map((check, index) => {
return (
<HistogramResponseTimeTooltip key={`${check}-${index}`} check={check}>
<Box
position="relative"
width={{
xs: theme.spacing(2),
sm: theme.spacing(6),
}}
bgcolor={theme.palette.primary.lowContrast}
sx={{
borderRadius: theme.spacing(1.5),
}}
>
<Box
position="absolute"
bottom={0}
width="100%"
height={`${check.normalResponseTime}%`}
bgcolor={
check.status === "up"
? theme.palette.success.lowContrast
: theme.palette.error.lowContrast
}
sx={{
borderRadius: theme.spacing(1.5),
transition: "height 600ms cubic-bezier(0.4, 0, 0.2, 1)",
}}
/>
</Box>
</HistogramResponseTimeTooltip>
);
})}
</Stack>
);
};
@@ -0,0 +1,33 @@
import Typography from "@mui/material/Typography";
import Stack from "@mui/material/Stack";
import { ExternalLink } from "lucide-react";
import type { IStatusPageWithMonitors } from "@/types/status-page";
import { useTheme } from "@mui/material/styles";
const HOST = import.meta.env.VITE_APP_HOST;
export const NameHeader = ({
statusPage,
}: {
statusPage: IStatusPageWithMonitors;
}) => {
const theme = useTheme();
return (
<Stack direction={"row"} alignItems={"flex-end"} spacing={theme.spacing(4)}>
<Typography variant="h1">{statusPage?.name}</Typography>
{statusPage?.isPublished && (
<Stack
component={"a"}
href={`${HOST}/status-pages/public/${statusPage?.url}`}
target="_blank"
rel="noopener noreferrer"
direction={"row"}
sx={{ textDecoration: "none", color: "inherit" }}
>
<Typography>Public link</Typography>
<ExternalLink size={16} strokeWidth={1.5} />
</Stack>
)}
</Stack>
);
};
@@ -0,0 +1,28 @@
import Typography from "@mui/material/Typography";
import Stack from "@mui/material/Stack";
import { getStatusPageHeaderConfig } from "@/utils/MonitorUtils";
import type { IStatusPageWithMonitors } from "@/types/status-page";
import { useTheme } from "@mui/material/styles";
export const StatusHeader = ({
statusPage,
}: {
statusPage: IStatusPageWithMonitors;
}) => {
const theme = useTheme();
const headerConfig = getStatusPageHeaderConfig(statusPage?.monitors || []);
return (
<Stack
width={"100%"}
bgcolor={theme.palette[headerConfig.paletteKey].lowContrast}
borderRadius={theme.shape.borderRadius}
padding={theme.spacing(4)}
>
<Typography variant="h2" alignSelf={"center"}>
{headerConfig.message}
</Typography>
</Stack>
);
};
@@ -0,0 +1,30 @@
import Grid from "@mui/material/Grid";
import Typography from "@mui/material/Typography";
import { HistogramStatusPage } from "./HistogramStatusPage";
import { StatusLabel } from "@/components/design-elements";
import type { IMonitor } from "@/types/monitor";
import { useTheme } from "@mui/material/styles";
export const StatusPageRow = ({ monitor }: { monitor: IMonitor }) => {
const theme = useTheme();
return (
<Grid container>
<Grid size={12}>
<Typography>{monitor?.name}</Typography>
</Grid>
<Grid size={{ xs: 8, sm: 10 }}>
<HistogramStatusPage checks={monitor?.latestChecks} />
</Grid>
<Grid
size={{ xs: 4, sm: 2 }}
paddingLeft={theme.spacing(10)}
display={"flex"}
alignItems={"center"}
justifyContent={"flex-start"}
>
<StatusLabel status={monitor?.status} />
</Grid>
</Grid>
);
};
@@ -0,0 +1 @@
export { HeaderCreate } from "@/components/monitors/HeaderCreate";