@joewinke/jatui 0.59.0 → 0.61.0

package/dist/components/stats/uptime.d.ts

@@ -0,0 +1,105 @@
+/**
+ * UptimeBar / StatusHistory layout + keyboard math (jatui-i3vxo). Pure and
+ * DOM-free.
+ *
+ * One thin bar per day over a 90-day (default) window, coloured by status
+ * tone (operational / degraded / partial / outage — `no-data` is never
+ * coloured as up). Days are local calendar dates, keyed "YYYY-MM-DD".
+ *
+ * Uptime % is minute-based: a day with no `downMinutes` uses a default
+ * (outage = full day, partial = half day, degraded = still up), so a feed
+ * that only carries statuses still gets a sensible percentage. `no-data`
+ * days are excluded from the percentage entirely.
+ */
+export type DayStatus = 'operational' | 'degraded' | 'partial' | 'outage' | 'no-data';
+/** Incidents rank worst-first. `no-data` is not an incident — it is the LOWEST rank. */
+export declare const DAY_SEVERITY: readonly DayStatus[];
+export interface UptimeDayInput {
+    date: string | Date;
+    status: DayStatus;
+    /** Minutes down that day. Optional — a default is used per status. */
+    downMinutes?: number;
+    /** Incident note (e.g. "Scheduled maintenance"), shown in the tooltip. */
+    note?: string;
+}
+export interface UptimeBar {
+    /** "YYYY-MM-DD" (local). */
+    date: string;
+    status: DayStatus;
+    /** Minutes down that day (0 when up). */
+    downMinutes: number;
+    /** Incident note, if any. */
+    note?: string;
+}
+export interface UptimeLayout {
+    /** Every day in the window, oldest → newest. */
+    bars: UptimeBar[];
+    /** Window length in days (30 / 90 …). */
+    days: number;
+    /** Days with a status (no-data days excluded). */
+    dataDays: number;
+    /** Fraction of uptime over days with data, 0..1 — null when there is no data. */
+    uptimePct: number | null;
+    /** Worst incident status in the window ('operational' when none). */
+    worst: DayStatus;
+    start: string;
+    end: string;
+}
+export interface BuildUptimeOptions<T> {
+    data: readonly T[];
+    getDate?: (d: T) => string | Date;
+    getStatus?: (d: T) => DayStatus;
+    getDownMinutes?: (d: T) => number | undefined;
+    getNote?: (d: T) => string | undefined;
+    /** Window length in days. Default 90. */
+    days?: number;
+    /** Inclusive window end. Default: today. */
+    end?: string | Date;
+}
+/** Local "YYYY-MM-DD". */
+export declare function isoDay(d: Date): string;
+/** Parse a day as LOCAL noon (DST-safe arithmetic). */
+export declare function parseDay(input: string | Date): Date;
+export declare function addDays(day: string, n: number): string;
+/** Whole days from a to b (b - a). */
+export declare function daysBetween(a: string, b: string): number;
+/** Rank of a status in DAY_SEVERITY (higher = worse). */
+export declare function statusRank(status: DayStatus): number;
+/** The worse of two statuses. */
+export declare function worstStatus(a: DayStatus, b: DayStatus): DayStatus;
+/** Default downtime minutes per status when the feed doesn't carry them. */
+export declare function defaultDownMinutes(status: DayStatus): number;
+/** One-word status: 'Normal' / 'Degraded' / 'Partial' / 'Outage' / 'No data'. */
+export declare function uptimeWord(status: DayStatus): string;
+/**
+ * Format the uptime % for display. TRUNCATED toward zero to 2 decimals — a
+ * status page must never overclaim (99.996% shows as 99.99%, never 100% when
+ * real downtime exists). Formatted with Intl `style: 'percent'` so the locale
+ * places the sign and spacing correctly ("99.99%" in en, "99,99 %" in de).
+ * `downMinutes > 0` forces a 99.99 cap even when the fraction is exactly 1
+ * (defensive: a feed with inconsistent data must not claim perfection).
+ * Returns "No data" for null.
+ */
+export declare function formatUptimePct(pct: number | null, locale?: string, downMinutes?: number): string;
+/** Roll a status up to the banner's three states: operational / degraded / outage. */
+export declare function bannerStatus(status: DayStatus): 'operational' | 'degraded' | 'outage';
+/** Worst of many statuses, rolled up to the banner's three states. */
+export declare function aggregateStatus(statuses: readonly DayStatus[]): 'operational' | 'degraded' | 'outage';
+/**
+ * Build the window: `days` (default 90) ending at `end` (default today).
+ * Days without data become `no-data` bars. Several entries for one day are
+ * merged: worst status wins, downMinutes are summed, the first note kept.
+ */
+export declare function buildUptime<T>(opts: BuildUptimeOptions<T>): UptimeLayout;
+/**
+ * Keyboard move along the 1-row strip. Returns the new focused day clamped
+ * to [start, end], or null for keys it does not handle.
+ *
+ *   ArrowLeft/Right  previous / next day
+ *   PageUp/PageDown  7 days back / forward
+ *   Home / End       first / last day in range
+ */
+export declare function moveUptimeFocus(date: string, key: string, layout: {
+    start: string;
+    end: string;
+}): string | null;

package/dist/components/stats/uptime.js

@@ -0,0 +1,213 @@
+/**
+ * UptimeBar / StatusHistory layout + keyboard math (jatui-i3vxo). Pure and
+ * DOM-free.
+ *
+ * One thin bar per day over a 90-day (default) window, coloured by status
+ * tone (operational / degraded / partial / outage — `no-data` is never
+ * coloured as up). Days are local calendar dates, keyed "YYYY-MM-DD".
+ *
+ * Uptime % is minute-based: a day with no `downMinutes` uses a default
+ * (outage = full day, partial = half day, degraded = still up), so a feed
+ * that only carries statuses still gets a sensible percentage. `no-data`
+ * days are excluded from the percentage entirely.
+ */
+/** Incidents rank worst-first. `no-data` is not an incident — it is the LOWEST rank. */
+export const DAY_SEVERITY = ['no-data', 'operational', 'degraded', 'partial', 'outage'];
+const pad = (n) => String(n).padStart(2, '0');
+/** Local "YYYY-MM-DD". */
+export function isoDay(d) {
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+/** Parse a day as LOCAL noon (DST-safe arithmetic). */
+export function parseDay(input) {
+    if (input instanceof Date)
+        return new Date(input.getFullYear(), input.getMonth(), input.getDate(), 12);
+    const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(input);
+    if (m)
+        return new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]), 12);
+    const d = new Date(input);
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate(), 12);
+}
+export function addDays(day, n) {
+    const d = parseDay(day);
+    d.setDate(d.getDate() + n);
+    return isoDay(d);
+}
+/** Whole days from a to b (b - a). */
+export function daysBetween(a, b) {
+    return Math.round((parseDay(b).getTime() - parseDay(a).getTime()) / 86_400_000);
+}
+/** Rank of a status in DAY_SEVERITY (higher = worse). */
+export function statusRank(status) {
+    return DAY_SEVERITY.indexOf(status);
+}
+/** The worse of two statuses. */
+export function worstStatus(a, b) {
+    return statusRank(a) >= statusRank(b) ? a : b;
+}
+/** Default downtime minutes per status when the feed doesn't carry them. */
+export function defaultDownMinutes(status) {
+    switch (status) {
+        case 'outage':
+            return 1440;
+        case 'partial':
+            return 720;
+        default:
+            return 0;
+    }
+}
+/** One-word status: 'Normal' / 'Degraded' / 'Partial' / 'Outage' / 'No data'. */
+export function uptimeWord(status) {
+    switch (status) {
+        case 'operational':
+            return 'Normal';
+        case 'degraded':
+            return 'Degraded';
+        case 'partial':
+            return 'Partial';
+        case 'outage':
+            return 'Outage';
+        default:
+            return 'No data';
+    }
+}
+/**
+ * Format the uptime % for display. TRUNCATED toward zero to 2 decimals — a
+ * status page must never overclaim (99.996% shows as 99.99%, never 100% when
+ * real downtime exists). Formatted with Intl `style: 'percent'` so the locale
+ * places the sign and spacing correctly ("99.99%" in en, "99,99 %" in de).
+ * `downMinutes > 0` forces a 99.99 cap even when the fraction is exactly 1
+ * (defensive: a feed with inconsistent data must not claim perfection).
+ * Returns "No data" for null.
+ */
+export function formatUptimePct(pct, locale, downMinutes = 0) {
+    if (pct == null)
+        return 'No data';
+    // Truncate to 2 decimals — never round up past real downtime.
+    let n = Math.trunc(pct * 10000) / 100;
+    if (downMinutes > 0)
+        n = Math.min(n, 99.99);
+    return new Intl.NumberFormat(locale, { style: 'percent', maximumFractionDigits: 2 }).format(n / 100);
+}
+/** Roll a status up to the banner's three states: operational / degraded / outage. */
+export function bannerStatus(status) {
+    switch (status) {
+        case 'outage':
+            return 'outage';
+        case 'degraded':
+        case 'partial':
+            return 'degraded';
+        default:
+            return 'operational';
+    }
+}
+/** Worst of many statuses, rolled up to the banner's three states. */
+export function aggregateStatus(statuses) {
+    let worst = 'operational';
+    for (const s of statuses) {
+        if (s === 'no-data')
+            continue;
+        worst = worstStatus(worst, s);
+    }
+    return bannerStatus(worst);
+}
+/**
+ * Build the window: `days` (default 90) ending at `end` (default today).
+ * Days without data become `no-data` bars. Several entries for one day are
+ * merged: worst status wins, downMinutes are summed, the first note kept.
+ */
+export function buildUptime(opts) {
+    const getDate = opts.getDate ?? ((d) => d.date);
+    const getStatus = opts.getStatus ?? ((d) => d.status);
+    const getDownMinutes = opts.getDownMinutes ?? ((d) => d.downMinutes);
+    const getNote = opts.getNote ?? ((d) => d.note);
+    const days = Math.max(1, opts.days ?? 90);
+    const end = isoDay(parseDay(opts.end ?? new Date()));
+    const start = addDays(end, -(days - 1));
+    const merged = new Map();
+    for (const d of opts.data) {
+        const key = isoDay(parseDay(getDate(d)));
+        if (daysBetween(start, key) < 0 || daysBetween(key, end) < 0)
+            continue; // outside the window
+        const status = getStatus(d);
+        const minutes = Math.max(0, Number(getDownMinutes(d)) || 0);
+        const note = getNote(d);
+        const prev = merged.get(key);
+        if (!prev) {
+            merged.set(key, { date: key, status, downMinutes: minutes, note });
+        }
+        else {
+            merged.set(key, {
+                date: key,
+                status: worstStatus(prev.status, status),
+                downMinutes: prev.downMinutes + minutes,
+                note: prev.note ?? note
+            });
+        }
+    }
+    const bars = [];
+    const cursor = parseDay(start);
+    for (let i = 0; i < days; i++) {
+        const date = isoDay(cursor);
+        const entry = merged.get(date);
+        bars.push(entry ?? { date, status: 'no-data', downMinutes: 0 });
+        cursor.setDate(cursor.getDate() + 1);
+    }
+    const dataDays = bars.filter((b) => b.status !== 'no-data').length;
+    const totalMinutes = bars.reduce((sum, b) => sum + (b.downMinutes || defaultDownMinutes(b.status)), 0);
+    const cap = dataDays * 1440;
+    let worst = 'operational';
+    for (const b of bars) {
+        if (b.status === 'no-data')
+            continue;
+        worst = worstStatus(worst, b.status);
+    }
+    // No data at all: the card shows the neutral 'No data' state, not 'Normal'.
+    if (dataDays === 0)
+        worst = 'no-data';
+    return {
+        bars,
+        days,
+        dataDays,
+        uptimePct: dataDays === 0 ? null : Math.min(1, Math.max(0, 1 - totalMinutes / cap)),
+        worst,
+        start,
+        end
+    };
+}
+/**
+ * Keyboard move along the 1-row strip. Returns the new focused day clamped
+ * to [start, end], or null for keys it does not handle.
+ *
+ *   ArrowLeft/Right  previous / next day
+ *   PageUp/PageDown  7 days back / forward
+ *   Home / End       first / last day in range
+ */
+export function moveUptimeFocus(date, key, layout) {
+    let next;
+    switch (key) {
+        case 'ArrowLeft':
+            next = addDays(date, -1);
+            break;
+        case 'ArrowRight':
+            next = addDays(date, 1);
+            break;
+        case 'PageUp':
+            next = addDays(date, -7);
+            break;
+        case 'PageDown':
+            next = addDays(date, 7);
+            break;
+        case 'Home':
+            return layout.start;
+        case 'End':
+            return layout.end;
+        default:
+            return null;
+    }
+    if (daysBetween(layout.start, next) < 0)
+        return layout.start;
+    if (daysBetween(next, layout.end) < 0)
+        return layout.end;
+    return next;
+}

package/dist/index.d.ts

@@ -401,6 +401,12 @@ export type { BarListItem } from './components/stats/BarList.svelte';
 export { default as ActivityHeatmap } from './components/stats/ActivityHeatmap.svelte';
 export { buildHeatmap, moveHeatFocus, isoDay as heatmapIsoDay, defaultLevelOf as heatmapLevelOf } from './components/stats/heatmap';
 export type { HeatDay, HeatmapLayout, BuildHeatmapOptions } from './components/stats/heatmap';
+export { default as UptimeBar } from './components/stats/UptimeBar.svelte';
+export { default as StatusCard } from './components/stats/StatusCard.svelte';
+export { default as StatusBanner } from './components/stats/StatusBanner.svelte';
+export type { BannerStatus } from './components/stats/StatusBanner.svelte';
+export { buildUptime, formatUptimePct, moveUptimeFocus, isoDay as uptimeIsoDay, aggregateStatus, bannerStatus, defaultDownMinutes, uptimeWord, worstStatus } from './components/stats/uptime';
+export type { DayStatus, UptimeBar as UptimeBarDay, UptimeDayInput, UptimeLayout, BuildUptimeOptions } from './components/stats/uptime';
 export { default as SegmentedControl } from './components/SegmentedControl.svelte';
 export type { SegmentedOption } from './components/SegmentedControl.svelte';
 export { default as SettingsSection } from './components/settings/SettingsSection.svelte';

package/dist/index.js

@@ -449,6 +449,10 @@ export { default as ChartCard } from './components/stats/ChartCard.svelte';
 export { default as BarList } from './components/stats/BarList.svelte';
 export { default as ActivityHeatmap } from './components/stats/ActivityHeatmap.svelte';
 export { buildHeatmap, moveHeatFocus, isoDay as heatmapIsoDay, defaultLevelOf as heatmapLevelOf } from './components/stats/heatmap';
+export { default as UptimeBar } from './components/stats/UptimeBar.svelte';
+export { default as StatusCard } from './components/stats/StatusCard.svelte';
+export { default as StatusBanner } from './components/stats/StatusBanner.svelte';
+export { buildUptime, formatUptimePct, moveUptimeFocus, isoDay as uptimeIsoDay, aggregateStatus, bannerStatus, defaultDownMinutes, uptimeWord, worstStatus } from './components/stats/uptime';
 export { default as SegmentedControl } from './components/SegmentedControl.svelte';
 export { default as SettingsSection } from './components/settings/SettingsSection.svelte';
 export { default as SettingsRow } from './components/settings/SettingsRow.svelte';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joewinke/jatui",
-  "version": "0.59.0",
+  "version": "0.61.0",
   "private": false,
   "description": "Shared Svelte 5 component library for JAT projects",
   "type": "module",