feat: add Uptime Kuma, Audiobookshelf, Paperless-ngx, and Navidrome integrations (#5910)

This commit is contained in:
Thomas authored and GitHub committed 2026-06-10 18:27:24 +02:00
1 parent a4db9cf0dc
commit d77c6f8d4e
46 files changed
+2994 -16

No files matched your search

@@ -0,0 +1,121 @@
.root {
container-type: size;
display: flex;
flex-direction: column;
height: 100%;
min-height: 0;
padding: clamp(6px, 3cqi, 14px);
gap: clamp(4px, 2cqi, 10px);
overflow: hidden;
}
.hero {
display: flex;
align-items: center;
justify-content: space-between;
gap: clamp(8px, 3cqi, 18px);
flex-shrink: 0;
padding-bottom: clamp(4px, 2cqi, 10px);
border-bottom: 1px solid light-dark(var(--mantine-color-gray-2), var(--mantine-color-dark-4));
}
.heroExpanded {
flex: 1;
border-bottom: none;
justify-content: center;
padding-bottom: 0;
}
.heroTextOnly {
justify-content: center;
}
.heroTextOnly .heroText {
align-items: center;
text-align: center;
}
.heroTextOnly .heroValue {
font-size: clamp(22px, 10cqi, 36px);
}
.heroText {
display: flex;
flex-direction: column;
gap: clamp(2px, 1cqi, 4px);
min-width: 0;
flex: 1;
}
.heroLabel {
font-size: clamp(9px, 2.8cqi, 13px);
color: var(--mantine-color-dimmed);
line-height: 1.2;
}
.heroValue {
font-size: clamp(18px, 8cqi, 32px);
font-weight: 700;
line-height: 1.1;
}
.ring {
flex-shrink: 0;
}
.statGrid {
display: grid;
flex: 1;
min-height: 0;
gap: clamp(4px, 2cqi, 10px);
grid-template-columns: repeat(var(--stat-cols, 2), minmax(0, 1fr));
grid-auto-rows: 1fr;
align-content: stretch;
}
.statTile {
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
min-height: 0;
min-width: 0;
gap: clamp(2px, 1.5cqi, 5px);
padding: clamp(4px, 2.5cqi, 10px);
border-radius: var(--mantine-radius-md);
background-color: light-dark(var(--mantine-color-gray-0), var(--mantine-color-dark-6));
overflow: hidden;
}
.statIcon {
flex-shrink: 0;
}
.statValue {
font-size: clamp(14px, 5.5cqi, 24px);
font-weight: 700;
line-height: 1.1;
text-align: center;
}
.statLabel {
font-size: clamp(8px, 2.5cqi, 12px);
color: var(--mantine-color-dimmed);
line-height: 1.2;
text-align: center;
max-width: 100%;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.emptyState {
display: flex;
flex: 1;
align-items: center;
justify-content: center;
min-height: 0;
color: var(--mantine-color-dimmed);
font-size: clamp(11px, 3cqi, 14px);
text-align: center;
}
@@ -0,0 +1,245 @@
"use client";
import type { CSSProperties } from "react";
import { RingProgress, Text } from "@mantine/core";
import { IconArrowDown, IconArrowUp, IconClockPause, IconServer } from "@tabler/icons-react";
import { clientApi } from "@homarr/api/client";
import { formatNumber } from "@homarr/common";
import type { UptimeKumaDashboardData } from "@homarr/integrations/types";
import { useScopedI18n } from "@homarr/translation/client";
import type { WidgetComponentProps } from "../definition";
import { NoIntegrationDataError } from "../errors/no-data-integration";
import classes from "./component.module.css";
const emptyDashboard: UptimeKumaDashboardData = {
totalMonitors: 0,
upCount: 0,
downCount: 0,
pausedCount: 0,
averageUptimePercent: 0,
monitors: [],
};
const statVisibilityByOption = {
showTotalMonitors: "totalMonitors",
showUpCount: "upCount",
showDownCount: "downCount",
showPausedCount: "pausedCount",
} as const;
const statIcons = {
totalMonitors: IconServer,
upCount: IconArrowUp,
downCount: IconArrowDown,
pausedCount: IconClockPause,
} as const;
const statColorByKey = {
totalMonitors: "gray",
upCount: "green",
downCount: "red",
pausedCount: "yellow",
} as const;
const uptimeTierByThreshold = [
[99, "excellent"],
[95, "good"],
[0, "poor"],
] as const;
const uptimeColorByTier = {
excellent: "green",
good: "yellow",
poor: "red",
} as const;
const gridColsByWidth = [
{ minWidth: 380, cols: 4 },
{ minWidth: 260, cols: 2 },
{ minWidth: 0, cols: 2 },
] as const;
const ringSizeByWidth = [
{ minWidth: 400, size: 88 },
{ minWidth: 320, size: 72 },
{ minWidth: 220, size: 56 },
{ minWidth: 0, size: 44 },
] as const;
const iconSizeByWidth = [
{ minWidth: 320, size: 22 },
{ minWidth: 200, size: 18 },
{ minWidth: 0, size: 16 },
] as const;
const heroLayoutBySecondaryStats = {
false: classes.heroExpanded,
true: "",
} as const;
const heroVariantByRing = {
true: "",
false: classes.heroTextOnly,
} as const;
export default function UptimeKumaWidget({
integrationIds,
isEditMode,
options,
width,
}: WidgetComponentProps<"uptimeKuma">) {
if (integrationIds.length === 0) {
throw new NoIntegrationDataError();
}
return <UptimeKumaContent integrationIds={integrationIds} isEditMode={isEditMode} options={options} width={width} />;
}
interface UptimeKumaContentProps {
integrationIds: string[];
isEditMode: boolean;
options: WidgetComponentProps<"uptimeKuma">["options"];
width: number;
}
function UptimeKumaContent({ integrationIds, isEditMode, options, width }: UptimeKumaContentProps) {
const t = useScopedI18n("widget.uptimeKuma");
const [dashboardData] = clientApi.widget.uptimeKuma.getDashboard.useSuspenseQuery({ integrationIds });
const utils = clientApi.useUtils();
clientApi.widget.uptimeKuma.subscribeToDashboard.useSubscription(
{ integrationIds },
{
enabled: !isEditMode,
onData(newData) {
utils.widget.uptimeKuma.getDashboard.setData({ integrationIds }, (prevData) => {
if (!prevData) return prevData;
return prevData.map((instance) => {
if (instance.integrationId === newData.integrationId) {
return { ...instance, dashboard: newData.dashboard, updatedAt: newData.timestamp };
}
return instance;
});
});
},
},
);
const combined = dashboardData.reduce<UptimeKumaDashboardData>(
(acc, item) => ({
totalMonitors: acc.totalMonitors + item.dashboard.totalMonitors,
upCount: acc.upCount + item.dashboard.upCount,
downCount: acc.downCount + item.dashboard.downCount,
pausedCount: acc.pausedCount + item.dashboard.pausedCount,
averageUptimePercent: acc.averageUptimePercent + item.dashboard.averageUptimePercent,
monitors: [...acc.monitors, ...item.dashboard.monitors],
}),
emptyDashboard,
);
const instanceCount = dashboardData.length;
const averageUptime = combined.averageUptimePercent / Math.max(instanceCount, 1);
const uptimeValue = clampPercent(averageUptime);
const uptimeColor = getUptimeColor(uptimeValue);
const ringSize = getRingSize(width);
const iconSize = getIconSize(width);
const gridCols = getGridCols(width);
const visibleStatKeys = Object.entries(statVisibilityByOption)
.filter(([optionKey]) => options[optionKey as keyof typeof options])
.map(([, statKey]) => statKey);
const showHero = options.showAverageUptime;
const hasContent = showHero || visibleStatKeys.length > 0;
const heroLayoutClass =
heroLayoutBySecondaryStats[String(visibleStatKeys.length > 0) as keyof typeof heroLayoutBySecondaryStats];
const heroRingClass = heroVariantByRing[String(options.showUptimeRing) as keyof typeof heroVariantByRing];
return (
<div className={classes.root}>
{showHero && (
<div className={`${classes.hero} ${heroLayoutClass} ${heroRingClass}`}>
<div className={classes.heroText}>
<span className={classes.heroLabel}>{t("averageUptime")}</span>
<span className={classes.heroValue}>{formatNumber(uptimeValue, 1)}%</span>
</div>
{options.showUptimeRing && (
<RingProgress
className={classes.ring}
size={ringSize}
thickness={Math.max(4, Math.round(ringSize / 10))}
roundCaps
sections={[{ value: uptimeValue, color: uptimeColor }]}
label={
<Text ta="center" size="xs" fw={700}>
{formatNumber(uptimeValue, 0)}%
</Text>
}
/>
)}
</div>
)}
{!hasContent && (
<div className={classes.emptyState}>
<Text size="sm" c="dimmed">
—
</Text>
</div>
)}
{visibleStatKeys.length > 0 && (
<div className={classes.statGrid} style={{ "--stat-cols": gridCols } as CSSProperties}>
{visibleStatKeys.map((statKey) => {
const Icon = statIcons[statKey];
const color = statColorByKey[statKey];
return (
<div key={statKey} className={classes.statTile}>
<Icon
className={classes.statIcon}
size={iconSize}
stroke={1.5}
color={`var(--mantine-color-${color}-6)`}
/>
<span className={classes.statValue}>{formatNumber(combined[statKey], 0)}</span>
<span className={classes.statLabel}>{t(`stats.${statKey}`)}</span>
</div>
);
})}
</div>
)}
</div>
);
}
function clampPercent(value: number): number {
return Math.min(100, Math.max(0, value));
}
function getUptimeTier(uptime: number): keyof typeof uptimeColorByTier {
const match = uptimeTierByThreshold.find(([min]) => uptime >= min);
const tier = match?.[1] ?? "poor";
return tier;
}
function getUptimeColor(uptime: number): string {
return uptimeColorByTier[getUptimeTier(uptime)];
}
function getGridCols(width: number): number {
const match = gridColsByWidth.find(({ minWidth }) => width >= minWidth);
return match?.cols ?? 2;
}
function getRingSize(width: number): number {
const match = ringSizeByWidth.find(({ minWidth }) => width >= minWidth);
return match?.size ?? 44;
}
function getIconSize(width: number): number {
const match = iconSizeByWidth.find(({ minWidth }) => width >= minWidth);
return match?.size ?? 16;
}
+43
View File
@@ -0,0 +1,43 @@
import { IconHeartbeat, IconServerOff } from "@tabler/icons-react";
import { createWidgetDefinition } from "../definition";
import { optionsBuilder } from "../options";
export const { definition, componentLoader } = createWidgetDefinition("uptimeKuma", {
icon: IconHeartbeat,
createOptions() {
return optionsBuilder.from((factory) => ({
showAverageUptime: factory.switch({
defaultValue: true,
withDescription: true,
}),
showUptimeRing: factory.switch({
defaultValue: true,
withDescription: true,
}),
showTotalMonitors: factory.switch({
defaultValue: true,
withDescription: true,
}),
showUpCount: factory.switch({
defaultValue: true,
withDescription: true,
}),
showDownCount: factory.switch({
defaultValue: true,
withDescription: true,
}),
showPausedCount: factory.switch({
defaultValue: true,
withDescription: true,
}),
}));
},
supportedIntegrations: ["uptimeKuma"],
errors: {
INTERNAL_SERVER_ERROR: {
icon: IconServerOff,
message: (t) => t("widget.uptimeKuma.error.internalServerError"),
},
},
}).withDynamicImport(() => import("./component"));