@oneuptime/common 14.0.1 → 14.0.3

package/build/dist/Utils/Monitor/MonitorOverviewPresentationUtil.js

@@ -0,0 +1,1259 @@
+import OneUptimeDate from "../../Types/Date";
+import { CheckOn } from "../../Types/Monitor/CriteriaFilter";
+import MonitorType from "../../Types/Monitor/MonitorType";
+import { formatDurationCompact } from "../Slo/SloDuration";
+import MonitorCheckScheduleUtil, { MonitorCheckFreshness, } from "./MonitorCheckScheduleUtil";
+import MonitorOverviewCriteriaUtil from "./MonitorOverviewCriteriaUtil";
+import MonitorOverviewFamilyUtil, { MonitorOverviewFamily, } from "./MonitorOverviewFamily";
+import MonitorStatusHistoryUtil from "./MonitorStatusHistoryUtil";
+import MonitorOverviewTargetUtil from "./MonitorOverviewTargetUtil";
+/*
+ * The monitor overview's hero, facts, pulse and section switches, decided in
+ * one pure function so every per-type and per-state rule is unit-tested
+ * without React.
+ *
+ * The rule it is built around: never claim health that was not measured. A
+ * paused monitor, one nobody is checking, one with no criteria and one still
+ * waiting for its first result are never shown as Good, and never lead with
+ * the stored status name (which only describes the last thing that was
+ * recorded). Unknown is never rendered as zero.
+ */
+export var MonitorOverviewRunState;
+(function (MonitorOverviewRunState) {
+    MonitorOverviewRunState["Manual"] = "Manual";
+    MonitorOverviewRunState["Paused"] = "Paused";
+    MonitorOverviewRunState["NotChecking"] = "NotChecking";
+    MonitorOverviewRunState["NotConfigured"] = "NotConfigured";
+    MonitorOverviewRunState["AwaitingFirstData"] = "AwaitingFirstData";
+    MonitorOverviewRunState["Overdue"] = "Overdue";
+    MonitorOverviewRunState["Running"] = "Running";
+})(MonitorOverviewRunState || (MonitorOverviewRunState = {}));
+const MAX_FACTS = 4;
+/*
+ * ServerMonitor/CheckOnlineStatus judges an agent that has not reported for
+ * three minutes, counting from creation when it never has.
+ */
+const AGENT_MISSING_MINUTES = 3;
+const PAUSED_EXPLANATION = {
+    disabled: "No checks run while monitoring is off, so the status stays at the last one recorded.",
+    incident: "Checks resume when the incident that paused this monitor is resolved.",
+    maintenance: "Checks resume automatically when the maintenance event ends.",
+};
+const MANUAL_EXPLANATION = "Manual monitor: OneUptime runs no checks. The status changes when someone sets it, or when an incident or scheduled maintenance event changes it.";
+/*
+ * What an empty evaluation log says once the monitor is older than the
+ * log keeps rows (MONITOR_LOG_MINIMUM_RETENTION_SECONDS): not "never".
+ */
+const NOT_EVALUATED_IN_LOG_TEXT = "Not evaluated in the last day";
+const pluralize = (count, singular, plural) => {
+    return `${count} ${count === 1 ? singular : plural}`;
+};
+const lowerFirst = (text) => {
+    return text ? text.charAt(0).toLowerCase() + text.slice(1) : text;
+};
+const secondsSince = (now, then) => {
+    return Math.max(0, Math.floor((now.getTime() - then.getTime()) / 1000));
+};
+const HOUR_MS = 3600 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+const DAY_SECONDS = 24 * 3600;
+/*
+ * The evaluation log (MonitorLog) keeps each row for at least
+ * MonitorLogUtil.DEFAULT_RETENTION_DAYS, one day, unless an admin has
+ * raised GlobalConfig.monitorLogRetentionInDays. So an empty log proves
+ * only that nothing was evaluated in the last day and, for a monitor
+ * younger than that, that nothing ever was. The copy that says "in the
+ * last day" follows this.
+ */
+export const MONITOR_LOG_MINIMUM_RETENTION_SECONDS = DAY_SECONDS;
+/*
+ * A row can also outlive that by up to about a day: the TTL ("retentionDate
+ * DELETE", ttl_only_drop_parts) drops a whole daily partition
+ * (toYYYYMMDD(time)) only once its newest row has expired too. So a run
+ * between two days and one day ago may or may not still be in the log, and
+ * its absence proves nothing. An empty log is therefore judged from one day
+ * ago, the guaranteed retention: a schedule that was due after that point
+ * would still have its row, so Stale from there really means a missed run.
+ * Judging from the two-day maximum instead flagged gapped schedules
+ * (weekday business hours) as overdue every weekend.
+ */
+// "3 hours", or "20 minutes" under an hour. Never "0 minutes".
+const describeUnderADay = (ms) => {
+    const hours = Math.floor(ms / HOUR_MS);
+    if (hours >= 1) {
+        return pluralize(hours, "hour", "hours");
+    }
+    return pluralize(Math.max(1, Math.floor(ms / 60000)), "minute", "minutes");
+};
+/*
+ * Calendar days from `earlier` to `later` in the zone dates are printed in.
+ * Only called for times at least a day apart, so it is at least 1 (a
+ * 25-hour daylight-saving day could otherwise make it 0).
+ */
+const getCalendarDaysBetween = (earlier, later) => {
+    const timezone = OneUptimeDate.getCurrentTimezone();
+    const days = Math.round((OneUptimeDate.getStartOfDay(later, timezone).getTime() -
+        OneUptimeDate.getStartOfDay(earlier, timezone).getTime()) /
+        DAY_MS);
+    return Math.max(1, days);
+};
+const isFutureOf = (date, now) => {
+    return Boolean(date && date.getTime() > now.getTime());
+};
+export default class MonitorOverviewPresentationUtil {
+    static build(input) {
+        const context = MonitorOverviewPresentationUtil.getContext(input);
+        const hero = MonitorOverviewPresentationUtil.getHero(input, context);
+        return Object.assign(Object.assign({ family: context.family, runState: context.runState }, hero), { pulse: MonitorOverviewPresentationUtil.getPulse(input, context), freshness: context.freshness.freshness, isNeverReported: MonitorOverviewPresentationUtil.isNeverReported(context), facts: MonitorOverviewPresentationUtil.getFacts(input, context), target: MonitorOverviewTargetUtil.getTarget({
+                monitorType: input.monitorType,
+                monitorSteps: input.monitorSteps,
+                serverHostname: input.agent.hostname,
+            }), sections: MonitorOverviewPresentationUtil.getSections(context) });
+    }
+    /*
+     * First match wins: Manual, Paused, NotChecking (probe checks only),
+     * NotConfigured, AwaitingFirstData, Overdue, Running.
+     */
+    static getRunState(input) {
+        return MonitorOverviewPresentationUtil.getContext(input).runState;
+    }
+    /*
+     * What the uptime tiles must add about time the status timeline counts
+     * but nothing measured: its open row keeps the last status while
+     * monitoring is paused, while nothing checks, and before the first check
+     * completes. A manual monitor has no checks to pause, so it never gets
+     * one.
+     */
+    static getUptimeCaveat(presentation) {
+        if (presentation.family === MonitorOverviewFamily.Manual) {
+            return null;
+        }
+        switch (presentation.runState) {
+            case MonitorOverviewRunState.Paused:
+                return "paused";
+            case MonitorOverviewRunState.NotChecking:
+            case MonitorOverviewRunState.NotConfigured:
+                return "not-checking";
+            case MonitorOverviewRunState.Overdue:
+                return presentation.isNeverReported ? "no-results" : null;
+            default:
+                return null;
+        }
+    }
+    static getStatusTone(status) {
+        if (!status) {
+            return "neutral";
+        }
+        // Offline first: a status flagged both ways must never read as good.
+        if (status.isOfflineState) {
+            return "danger";
+        }
+        if (status.isOperationalState) {
+            return "good";
+        }
+        return "warning";
+    }
+    static getExpiryFact(data) {
+        const label = data.key === "certificate-expiry"
+            ? "Certificate expires"
+            : "Domain expires";
+        const secondary = data.expiresAt
+            ? OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(data.expiresAt, true)
+            : undefined;
+        if (data.isValidCertificate === false) {
+            return {
+                key: data.key,
+                label: label,
+                value: "Not valid",
+                secondary: secondary,
+                tone: "danger",
+            };
+        }
+        if (!data.expiresAt) {
+            return { key: data.key, label: label, value: "—", isMuted: true };
+        }
+        const msLeft = data.expiresAt.getTime() - data.now.getTime();
+        /*
+         * Within a day either way, hours say it exactly. Beyond that, days are
+         * counted on the calendar of the zone the date below is printed in, so
+         * "in 2 days" and the printed date agree: 36 hours from noon is two
+         * calendar days away, not the one day a floor would give.
+         */
+        if (msLeft < 0) {
+            return {
+                key: data.key,
+                label: label,
+                value: -msLeft < DAY_MS
+                    ? `Expired ${describeUnderADay(-msLeft)} ago`
+                    : `Expired ${pluralize(getCalendarDaysBetween(data.expiresAt, data.now), "day", "days")} ago`,
+                secondary: secondary,
+                tone: "danger",
+            };
+        }
+        if (msLeft < DAY_MS) {
+            return {
+                key: data.key,
+                label: label,
+                value: `Expires in ${describeUnderADay(msLeft)}`,
+                secondary: secondary,
+                tone: "danger",
+            };
+        }
+        // The tone keeps counting whole days left, as it always has.
+        const wholeDays = Math.floor(msLeft / DAY_MS);
+        let tone = "neutral";
+        if (wholeDays <= 7) {
+            tone = "danger";
+        }
+        else if (wholeDays <= 30) {
+            tone = "warning";
+        }
+        return {
+            key: data.key,
+            label: label,
+            value: `in ${pluralize(getCalendarDaysBetween(data.now, data.expiresAt), "day", "days")}`,
+            secondary: secondary,
+            tone: tone,
+        };
+    }
+    static getContext(input) {
+        const layout = MonitorOverviewFamilyUtil.getLayout(input.monitorType);
+        const family = layout.family;
+        const cadenceSeconds = MonitorCheckScheduleUtil.resolveCadenceSeconds({
+            monitoringInterval: input.monitoringInterval,
+            from: input.now,
+        });
+        const intervalText = MonitorCheckScheduleUtil.describeInterval(input.monitoringInterval);
+        const stepCount = MonitorOverviewCriteriaUtil.getStepCount(input.monitorSteps);
+        const networkDeviceId = MonitorOverviewCriteriaUtil.getNetworkDeviceId(input.monitorSteps);
+        const isPaused = input.pause.isDisabled ||
+            input.pause.byManualIncident ||
+            input.pause.byScheduledMaintenance;
+        const isProbeCheck = family === MonitorOverviewFamily.ProbeCheck;
+        /*
+         * The server keeps these flags on the Monitor row; the probe rows, when
+         * they could be read, say the same thing sooner.
+         */
+        const isNoProbeEnabled = isProbeCheck &&
+            (input.probeFlags.isNoProbeEnabled ||
+                (input.probes !== null && input.probes.enabledCount === 0));
+        const isAllProbesDisconnected = isProbeCheck &&
+            (input.probeFlags.isAllProbesDisconnected ||
+                (input.probes !== null &&
+                    input.probes.enabledCount > 0 &&
+                    input.probes.disconnectedCount === input.probes.enabledCount));
+        const isNotChecking = isNoProbeEnabled || isAllProbesDisconnected;
+        const evaluationStatus = MonitorOverviewPresentationUtil.getEvaluationStatus(input);
+        const evaluationLog = MonitorOverviewPresentationUtil.readEvaluationLog({
+            input: input,
+            family: family,
+            evaluationStatus: evaluationStatus,
+        });
+        const isScheduled = !isPaused && !isNotChecking;
+        const telemetry = MonitorOverviewPresentationUtil.isTelemetryFamily(family)
+            ? MonitorOverviewPresentationUtil.getTelemetryTiming({
+                input: input,
+                evaluationLog: evaluationLog,
+                cadenceSeconds: cadenceSeconds,
+                isScheduled: isScheduled,
+            })
+            : null;
+        const freshness = telemetry
+            ? telemetry.freshness
+            : MonitorOverviewPresentationUtil.getFreshness({
+                input: input,
+                family: family,
+                cadenceSeconds: cadenceSeconds,
+                isScheduled: isScheduled,
+            });
+        let runState = MonitorOverviewRunState.Running;
+        if (family === MonitorOverviewFamily.Manual) {
+            runState = MonitorOverviewRunState.Manual;
+        }
+        else if (isPaused) {
+            runState = MonitorOverviewRunState.Paused;
+        }
+        else if (isNotChecking) {
+            runState = MonitorOverviewRunState.NotChecking;
+        }
+        else if (stepCount === 0 ||
+            (family === MonitorOverviewFamily.NetworkDevice && !networkDeviceId)) {
+            runState = MonitorOverviewRunState.NotConfigured;
+        }
+        else if (MonitorOverviewPresentationUtil.isAwaitingFirstData({
+            input: input,
+            family: family,
+            freshness: freshness.freshness,
+            evaluationLog: evaluationLog,
+            telemetry: telemetry,
+        })) {
+            runState = MonitorOverviewRunState.AwaitingFirstData;
+        }
+        else if (freshness.freshness === MonitorCheckFreshness.Stale) {
+            runState = MonitorOverviewRunState.Overdue;
+        }
+        return {
+            family: family,
+            layout: layout,
+            cadenceSeconds: cadenceSeconds,
+            intervalText: intervalText,
+            intervalPhrase: lowerFirst(intervalText),
+            stepCount: stepCount,
+            networkDeviceId: networkDeviceId,
+            isPaused: isPaused,
+            isNoProbeEnabled: isNoProbeEnabled,
+            isAllProbesDisconnected: isAllProbesDisconnected,
+            isNotChecking: isNotChecking,
+            evaluationStatus: evaluationStatus,
+            evaluationLog: evaluationLog,
+            telemetry: telemetry,
+            freshness: freshness,
+            runState: runState,
+            hasPushVerdict: runState === MonitorOverviewRunState.AwaitingFirstData &&
+                MonitorOverviewPresentationUtil.hasPushVerdict({
+                    input: input,
+                    family: family,
+                }),
+        };
+    }
+    /*
+     * Without an explicit status (callers from before evaluationStatus), a
+     * time means the log was read; its absence says nothing.
+     */
+    static getEvaluationStatus(input) {
+        if (input.evaluationStatus) {
+            return input.evaluationStatus;
+        }
+        return input.latestEvaluationAt ? "loaded" : null;
+    }
+    static isTelemetryFamily(family) {
+        return (family === MonitorOverviewFamily.TelemetrySignal ||
+            family === MonitorOverviewFamily.Infrastructure);
+    }
+    /*
+     * An empty log means "never evaluated" only while it would still hold
+     * every evaluation the monitor could have had. Past that, its rows may
+     * simply have expired.
+     */
+    static readEvaluationLog(data) {
+        const input = data.input;
+        if (data.evaluationStatus !== "loaded") {
+            return "unread";
+        }
+        if (input.latestEvaluationAt) {
+            return "evaluated";
+        }
+        const isYoungerThanLog = !input.createdAt ||
+            input.now.getTime() - input.createdAt.getTime() <
+                MONITOR_LOG_MINIMUM_RETENTION_SECONDS * 1000;
+        /*
+         * The telemetry worker stamps a monitor each time it queues an
+         * evaluation, so one it has never stamped has never been evaluated,
+         * however old it is.
+         */
+        const isNeverQueued = MonitorOverviewPresentationUtil.isTelemetryFamily(data.family) &&
+            !input.telemetry.lastScheduledAt &&
+            !input.telemetry.lastEvaluatedAt;
+        return isYoungerThanLog || isNeverQueued ? "never" : "expired";
+    }
+    /*
+     * With a row in the evaluation log, its time. Without the log, the
+     * scheduler's stamp, named for what it is. With a log that is empty only
+     * because its rows expired, the log still says nothing was evaluated in
+     * the last day: that is overdue when the schedule should have left a row
+     * there, and otherwise (a weekly schedule, say) expected, so the stamp is
+     * all there is, as without the log.
+     */
+    static getTelemetryTiming(data) {
+        const input = data.input;
+        const scheduledAt = input.telemetry.lastScheduledAt || input.telemetry.lastEvaluatedAt;
+        const judge = (lastResultAt, createdAt) => {
+            return MonitorCheckScheduleUtil.getCheckFreshness({
+                isScheduled: data.isScheduled,
+                isKnown: true,
+                lastResultAt: lastResultAt,
+                nextCheckAt: input.telemetry.nextEvaluationAt,
+                cadenceSeconds: data.cadenceSeconds,
+                createdAt: createdAt,
+                now: input.now,
+                monitoringInterval: input.monitoringInterval,
+            });
+        };
+        const fromScheduler = () => {
+            return {
+                lastAt: scheduledAt,
+                isScheduledTime: true,
+                isMissingFromLog: false,
+                freshness: judge(scheduledAt, input.createdAt),
+            };
+        };
+        switch (data.evaluationLog) {
+            case "evaluated":
+                return {
+                    lastAt: input.latestEvaluationAt,
+                    isScheduledTime: false,
+                    isMissingFromLog: false,
+                    freshness: judge(input.latestEvaluationAt, input.createdAt),
+                };
+            case "never":
+                return {
+                    lastAt: undefined,
+                    isScheduledTime: false,
+                    isMissingFromLog: false,
+                    freshness: judge(undefined, input.createdAt),
+                };
+            case "expired": {
+                // The log only reads as expired for a monitor with a creation time.
+                const createdAt = input.createdAt || input.now;
+                const horizonStart = new Date(Math.max(createdAt.getTime(), input.now.getTime() - MONITOR_LOG_MINIMUM_RETENTION_SECONDS * 1000));
+                if (judge(undefined, horizonStart).freshness !==
+                    MonitorCheckFreshness.Stale) {
+                    return fromScheduler();
+                }
+                /*
+                 * How long ago the last evaluation ran, and so how late the next
+                 * one is, is unknown: the log only says it was before the last day.
+                 */
+                return {
+                    lastAt: undefined,
+                    isScheduledTime: false,
+                    isMissingFromLog: true,
+                    freshness: {
+                        freshness: MonitorCheckFreshness.Stale,
+                        overdueSeconds: null,
+                        resultAgeSeconds: null,
+                    },
+                };
+            }
+            default:
+                return fromScheduler();
+        }
+    }
+    /*
+     * A push monitor's missing-signal check counts from creation when nothing
+     * has arrived yet, so the server judges it once this window has passed.
+     * Null when its criteria have no such check.
+     */
+    static getPushMissingMinutes(data) {
+        const monitorSteps = data.input.monitorSteps;
+        if (data.family === MonitorOverviewFamily.Agent) {
+            return MonitorOverviewCriteriaUtil.hasFilterOn({
+                monitorSteps: monitorSteps,
+                checkOn: CheckOn.IsOnline,
+            })
+                ? AGENT_MISSING_MINUTES
+                : null;
+        }
+        if (data.family !== MonitorOverviewFamily.Heartbeat) {
+            return null;
+        }
+        return MonitorOverviewCriteriaUtil.getMissingSignalMinutes({
+            monitorSteps: monitorSteps,
+            checkOn: data.input.monitorType === MonitorType.IncomingEmail
+                ? CheckOn.EmailReceivedAt
+                : CheckOn.IncomingRequest,
+        });
+    }
+    static hasPushVerdict(data) {
+        if (data.family !== MonitorOverviewFamily.Heartbeat &&
+            data.family !== MonitorOverviewFamily.Agent) {
+            return false;
+        }
+        if (MonitorOverviewPresentationUtil.isJudgedStatus(data.input)) {
+            return true;
+        }
+        const minutes = MonitorOverviewPresentationUtil.getPushMissingMinutes(data);
+        const createdAt = data.input.createdAt;
+        return (minutes !== null &&
+            createdAt !== undefined &&
+            data.input.now.getTime() - createdAt.getTime() > minutes * 60 * 1000);
+    }
+    /*
+     * A status that is not operational was set by something: for a push
+     * monitor that never reported, the server's missing-signal check.
+     */
+    static isJudgedStatus(input) {
+        const tone = MonitorOverviewPresentationUtil.getStatusTone(input.currentStatus);
+        return tone === "danger" || tone === "warning";
+    }
+    /*
+     * Freshness is only judged for the families that run on a schedule we can
+     * see: probe checks here, and the worker-evaluated telemetry and
+     * infrastructure monitors in getTelemetryTiming. Push-based monitors
+     * decide "missing" in their own criteria.
+     */
+    static getFreshness(data) {
+        var _a, _b, _c;
+        const input = data.input;
+        if (data.family === MonitorOverviewFamily.ProbeCheck) {
+            return MonitorCheckScheduleUtil.getCheckFreshness({
+                isScheduled: data.isScheduled,
+                isKnown: input.probes !== null,
+                lastResultAt: (_a = input.probes) === null || _a === void 0 ? void 0 : _a.lastResultAt,
+                /*
+                 * Behind schedule only when every probe that is checking is: a
+                 * summary from before latestNextCheckAt existed has only the
+                 * earliest.
+                 */
+                nextCheckAt: ((_b = input.probes) === null || _b === void 0 ? void 0 : _b.latestNextCheckAt) || ((_c = input.probes) === null || _c === void 0 ? void 0 : _c.nextCheckAt),
+                cadenceSeconds: data.cadenceSeconds,
+                createdAt: input.createdAt,
+                now: input.now,
+                monitoringInterval: input.monitoringInterval,
+            });
+        }
+        return MonitorCheckScheduleUtil.getCheckFreshness({
+            isScheduled: false,
+            isKnown: true,
+            lastResultAt: undefined,
+            nextCheckAt: undefined,
+            cadenceSeconds: data.cadenceSeconds,
+            createdAt: input.createdAt,
+            now: input.now,
+        });
+    }
+    static isAwaitingFirstData(data) {
+        var _a;
+        const input = data.input;
+        switch (data.family) {
+            case MonitorOverviewFamily.ProbeCheck:
+                return (input.probes !== null &&
+                    input.probes.enabledCount > 0 &&
+                    data.freshness === MonitorCheckFreshness.AwaitingFirstResult);
+            case MonitorOverviewFamily.Heartbeat:
+                return input.monitorType === MonitorType.IncomingEmail
+                    ? !input.email.lastReceivedAt
+                    : !input.heartbeat.lastReceivedAt;
+            case MonitorOverviewFamily.Agent:
+                return !input.agent.lastReportAt;
+            case MonitorOverviewFamily.TelemetrySignal:
+            case MonitorOverviewFamily.Infrastructure:
+                /*
+                 * Without the evaluation log, the scheduler's stamp is all there
+                 * is. With it, "waiting" needs a log that says nothing was ever
+                 * evaluated, and, like a probe check, lasts only while the monitor
+                 * is young: past that, no evaluation is overdue (6b).
+                 */
+                if (data.evaluationLog === "unread") {
+                    return !((_a = data.telemetry) === null || _a === void 0 ? void 0 : _a.lastAt);
+                }
+                return (data.evaluationLog === "never" &&
+                    data.freshness === MonitorCheckFreshness.AwaitingFirstResult);
+            case MonitorOverviewFamily.NetworkDevice:
+                /*
+                 * A device is evaluated on its polls and traps, which leave no
+                 * trace on the monitor row: only an empty log that would still hold
+                 * every evaluation says none has happened yet. For an older
+                 * monitor, it says only that none happened in the last day.
+                 */
+                return data.evaluationLog === "never";
+            default:
+                // Manual monitors are never evaluated.
+                return false;
+        }
+    }
+    static getHero(input, context) {
+        const status = input.currentStatus;
+        const statusTone = MonitorOverviewPresentationUtil.getStatusTone(status);
+        const lastKnownStatus = status
+            ? `Last recorded status: ${status.name}`
+            : undefined;
+        // The badge and headline for the states that lead with the status.
+        const statusBadge = status
+            ? {
+                text: status.name,
+                tone: statusTone,
+                statusColor: MonitorStatusHistoryUtil.normalizeColor(status.color),
+            }
+            : { text: "Unknown status", tone: "neutral" };
+        const statusHeadline = status
+            ? { text: status.name, since: input.statusSince }
+            : { text: "No status recorded yet" };
+        switch (context.runState) {
+            case MonitorOverviewRunState.Manual:
+                return {
+                    tone: statusTone,
+                    badge: statusBadge,
+                    secondaryBadges: [{ text: "Manual", tone: "neutral" }],
+                    headline: statusHeadline,
+                    explanation: MANUAL_EXPLANATION,
+                    callToAction: { text: "Change status", linkKey: "statusTimeline" },
+                };
+            case MonitorOverviewRunState.Paused: {
+                const secondaryBadges = [];
+                /*
+                 * Pausing does not fix a probe problem, and the problem is still
+                 * there when monitoring resumes, so it stays visible.
+                 */
+                if (context.isNoProbeEnabled) {
+                    secondaryBadges.push({ text: "Probes Not Enabled", tone: "danger" });
+                }
+                else if (context.isAllProbesDisconnected) {
+                    secondaryBadges.push({
+                        text: "Probes Disconnected",
+                        tone: "danger",
+                    });
+                }
+                if (input.pause.isDisabled) {
+                    return {
+                        tone: "neutral",
+                        badge: { text: "Disabled", tone: "neutral" },
+                        secondaryBadges: secondaryBadges,
+                        headline: { text: "Monitoring is turned off" },
+                        explanation: PAUSED_EXPLANATION.disabled,
+                        lastKnownStatus: lastKnownStatus,
+                        callToAction: { text: "Open settings", linkKey: "settings" },
+                    };
+                }
+                if (input.pause.byManualIncident) {
+                    return {
+                        tone: "neutral",
+                        badge: { text: "Paused", tone: "neutral" },
+                        secondaryBadges: secondaryBadges,
+                        headline: { text: "Monitoring is paused by an incident" },
+                        explanation: PAUSED_EXPLANATION.incident,
+                        lastKnownStatus: lastKnownStatus,
+                        callToAction: { text: "View incidents", linkKey: "incidents" },
+                    };
+                }
+                return {
+                    tone: "neutral",
+                    badge: { text: "Paused", tone: "neutral" },
+                    secondaryBadges: secondaryBadges,
+                    headline: { text: "Monitoring is paused for scheduled maintenance" },
+                    explanation: PAUSED_EXPLANATION.maintenance,
+                    lastKnownStatus: lastKnownStatus,
+                };
+            }
+            case MonitorOverviewRunState.NotChecking:
+                return MonitorOverviewPresentationUtil.getNotCheckingHero({
+                    input: input,
+                    context: context,
+                    lastKnownStatus: lastKnownStatus,
+                });
+            case MonitorOverviewRunState.NotConfigured: {
+                const isMissingDevice = context.family === MonitorOverviewFamily.NetworkDevice &&
+                    context.stepCount > 0;
+                return {
+                    tone: "neutral",
+                    badge: { text: "Not set up", tone: "neutral" },
+                    secondaryBadges: [],
+                    headline: {
+                        text: isMissingDevice
+                            ? "No network device is selected"
+                            : "This monitor has no criteria yet",
+                    },
+                    explanation: isMissingDevice
+                        ? "Choose the device this monitor alerts on."
+                        : "Add criteria to tell this monitor what to check.",
+                    callToAction: {
+                        text: isMissingDevice ? "Choose a device" : "Set up criteria",
+                        linkKey: "criteria",
+                    },
+                };
+            }
+            case MonitorOverviewRunState.AwaitingFirstData:
+                return MonitorOverviewPresentationUtil.getAwaitingHero({
+                    input: input,
+                    context: context,
+                    lastKnownStatus: lastKnownStatus,
+                });
+            case MonitorOverviewRunState.Overdue: {
+                const isProbeCheck = context.family === MonitorOverviewFamily.ProbeCheck;
+                /*
+                 * Nothing has ever been measured (6b), so the stored status is only
+                 * the default the monitor was created with: it is not the headline,
+                 * and it has not "held" for any length of time.
+                 */
+                const isNeverReported = MonitorOverviewPresentationUtil.isNeverReported(context);
+                return {
+                    // A late check cannot vouch for "good"; danger stays danger.
+                    tone: statusTone === "danger" ? "danger" : "warning",
+                    badge: isNeverReported
+                        ? { text: "No results yet", tone: "warning" }
+                        : statusBadge,
+                    secondaryBadges: [{ text: "Checks overdue", tone: "warning" }],
+                    headline: isNeverReported
+                        ? {
+                            text: isProbeCheck
+                                ? "No check has completed yet"
+                                : "No evaluation has completed yet",
+                        }
+                        : statusHeadline,
+                    explanation: MonitorOverviewPresentationUtil.getOverdueExplanation({
+                        input: input,
+                        context: context,
+                    }),
+                    lastKnownStatus: isNeverReported ? lastKnownStatus : undefined,
+                    callToAction: isProbeCheck
+                        ? { text: "Check probes", linkKey: "probes" }
+                        : undefined,
+                };
+            }
+            default: {
+                const running = {
+                    tone: statusTone,
+                    badge: statusBadge,
+                    secondaryBadges: [],
+                    headline: statusHeadline,
+                };
+                /*
+                 * A device's polling interval is not known here, so a quiet log is
+                 * not called overdue, but the status is not presented as fresh
+                 * either.
+                 */
+                if (context.family === MonitorOverviewFamily.NetworkDevice &&
+                    context.evaluationLog === "expired") {
+                    running.explanation =
+                        "No poll or trap from this device has been evaluated in the last day, so the status shown is the last one recorded.";
+                }
+                return running;
+            }
+        }
+    }
+    static getNotCheckingHero(data) {
+        const probes = data.input.probes;
+        if (!data.context.isNoProbeEnabled) {
+            return {
+                tone: "danger",
+                badge: { text: "Probes Disconnected", tone: "danger" },
+                secondaryBadges: [],
+                headline: { text: "Every probe checking this monitor is disconnected" },
+                explanation: "Checks stopped when the probes lost their connection. The status shown is the last one recorded.",
+                lastKnownStatus: data.lastKnownStatus,
+                callToAction: { text: "Check probes", linkKey: "probes" },
+            };
+        }
+        const badge = {
+            text: "Probes Not Enabled",
+            tone: "danger",
+        };
+        // Unknown probes must never be described as "no probes attached".
+        if (probes === null) {
+            return {
+                tone: "danger",
+                badge: badge,
+                secondaryBadges: [],
+                headline: { text: "Nothing is checking this monitor" },
+                explanation: "No probe is enabled for this monitor, so no checks run.",
+                lastKnownStatus: data.lastKnownStatus,
+                callToAction: { text: "Manage probes", linkKey: "probes" },
+            };
+        }
+        if (probes.attachedCount === 0) {
+            return {
+                tone: "danger",
+                badge: badge,
+                secondaryBadges: [],
+                headline: { text: "No probes are attached to this monitor" },
+                explanation: "Add a probe to start checking this resource.",
+                lastKnownStatus: data.lastKnownStatus,
+                callToAction: { text: "Add a probe", linkKey: "probes" },
+            };
+        }
+        return {
+            tone: "danger",
+            badge: badge,
+            secondaryBadges: [],
+            headline: { text: "Every probe is turned off for this monitor" },
+            explanation: `${probes.attachedCount === 1
+                ? "1 probe is"
+                : `${probes.attachedCount} probes are`} attached but switched off, so nothing is checking this resource.`,
+            lastKnownStatus: data.lastKnownStatus,
+            callToAction: { text: "Manage probes", linkKey: "probes" },
+        };
+    }
+    static getAwaitingHero(data) {
+        var _a;
+        const input = data.input;
+        const context = data.context;
+        let headline = "Waiting for the first evaluation";
+        let explanation = `This monitor is evaluated ${context.intervalPhrase} once saved.`;
+        let hasSetup = false;
+        // What has never arrived, for a push monitor the server has judged.
+        let missingSince = null;
+        if (context.family === MonitorOverviewFamily.ProbeCheck) {
+            const enabledCount = ((_a = input.probes) === null || _a === void 0 ? void 0 : _a.enabledCount) || 0;
+            headline = "Waiting for the first check";
+            explanation = `${enabledCount === 1 ? "1 probe checks" : `${enabledCount} probes check`} this ${context.intervalPhrase}. The first result usually arrives within a few minutes.`;
+        }
+        else if (context.family === MonitorOverviewFamily.NetworkDevice) {
+            headline = "Waiting for the first poll";
+            explanation =
+                "No poll or trap from this device has been evaluated yet. Check that a probe is assigned to poll it.";
+        }
+        else if (input.monitorType === MonitorType.IncomingRequest) {
+            headline = "Waiting for the first heartbeat";
+            explanation =
+                "Send a GET or POST request to this monitor's heartbeat URL to start tracking it.";
+            hasSetup = true;
+            missingSince = "No heartbeat has arrived";
+        }
+        else if (input.monitorType === MonitorType.IncomingEmail) {
+            headline = "Waiting for the first email";
+            explanation =
+                "Send an email to this monitor's address to start tracking it.";
+            hasSetup = true;
+            missingSince = "No email has arrived";
+        }
+        else if (context.family === MonitorOverviewFamily.Agent) {
+            headline = "Waiting for the agent to report";
+            explanation = "Install the server agent to start sending reports.";
+            hasSetup = true;
+            missingSince = "The agent has not reported";
+        }
+        const callToAction = hasSetup
+            ? { text: "Setup instructions", linkKey: "documentation" }
+            : undefined;
+        const status = input.currentStatus;
+        /*
+         * The server judges a push monitor that never reported as if its last
+         * signal arrived at creation, so it can be Offline, with an incident
+         * open, while the page is still "waiting". Lead with that verdict's
+         * tone and keep the setup steps: sending the first signal is still the
+         * fix.
+         */
+        if (missingSince !== null &&
+            status &&
+            MonitorOverviewPresentationUtil.isJudgedStatus(input)) {
+            const statusTone = MonitorOverviewPresentationUtil.getStatusTone(status);
+            return {
+                tone: statusTone,
+                badge: { text: "Waiting for data", tone: "info" },
+                secondaryBadges: [{ text: status.name, tone: statusTone }],
+                headline: {
+                    text: input.createdAt
+                        ? `${missingSince} since this monitor was created ${formatDurationCompact(secondsSince(input.now, input.createdAt))} ago`
+                        : headline,
+                },
+                explanation: explanation,
+                callToAction: callToAction,
+            };
+        }
+        return {
+            tone: "info",
+            badge: { text: "Waiting for data", tone: "info" },
+            secondaryBadges: [],
+            headline: { text: headline },
+            explanation: explanation,
+            lastKnownStatus: data.lastKnownStatus,
+            callToAction: callToAction,
+        };
+    }
+    static isNeverReported(context) {
+        var _a;
+        return (context.runState === MonitorOverviewRunState.Overdue &&
+            context.freshness.resultAgeSeconds === null &&
+            !((_a = context.telemetry) === null || _a === void 0 ? void 0 : _a.isMissingFromLog));
+    }
+    /*
+     * "No result for 12m" states how long it has been since the last result -
+     * the same age the pulse's "Last checked" shows - so the two never
+     * disagree. The pulse's "Overdue by" line carries how late that is.
+     */
+    static getOverdueExplanation(data) {
+        var _a;
+        const input = data.input;
+        const context = data.context;
+        const isProbeCheck = context.family === MonitorOverviewFamily.ProbeCheck;
+        const resultAgeSeconds = context.freshness.resultAgeSeconds;
+        if ((_a = context.telemetry) === null || _a === void 0 ? void 0 : _a.isMissingFromLog) {
+            return `No evaluation recorded in the last day, but this monitor is evaluated ${context.intervalPhrase}.`;
+        }
+        if (resultAgeSeconds === null) {
+            const createdAgo = input.createdAt
+                ? formatDurationCompact(secondsSince(input.now, input.createdAt))
+                : formatDurationCompact(context.freshness.overdueSeconds || 0);
+            return isProbeCheck
+                ? `No check result has arrived since this monitor was created ${createdAgo} ago.`
+                : `No evaluation has run since this monitor was created ${createdAgo} ago.`;
+        }
+        const age = formatDurationCompact(resultAgeSeconds);
+        return isProbeCheck
+            ? `No result for ${age}, but this monitor checks ${context.intervalPhrase}. A probe may be overloaded or offline.`
+            : `No evaluation for ${age}, but this monitor is evaluated ${context.intervalPhrase}.`;
+    }
+    static getPulse(input, context) {
+        var _a, _b, _c, _d;
+        const isScheduled = context.runState !== MonitorOverviewRunState.Paused &&
+            context.runState !== MonitorOverviewRunState.NotChecking &&
+            context.runState !== MonitorOverviewRunState.NotConfigured;
+        const overdueSeconds = context.runState === MonitorOverviewRunState.Overdue &&
+            context.freshness.overdueSeconds !== null
+            ? context.freshness.overdueSeconds
+            : undefined;
+        switch (context.family) {
+            case MonitorOverviewFamily.ProbeCheck: {
+                const nextAt = (_a = input.probes) === null || _a === void 0 ? void 0 : _a.nextCheckAt;
+                return {
+                    label: "Last checked",
+                    at: (_b = input.probes) === null || _b === void 0 ? void 0 : _b.lastResultAt,
+                    emptyText: "Not checked yet",
+                    // A paused or unchecked monitor has no cadence to promise.
+                    cadenceText: isScheduled ? context.intervalText : undefined,
+                    nextAt: isScheduled && isFutureOf(nextAt, input.now) ? nextAt : undefined,
+                    overdueSeconds: overdueSeconds,
+                    isUnavailable: input.probes === null,
+                };
+            }
+            case MonitorOverviewFamily.Heartbeat: {
+                const isEmail = input.monitorType === MonitorType.IncomingEmail;
+                /*
+                 * No cadence line: the missing-request check time is already the
+                 * "Last missing-request check" fact, and a push-based monitor has no
+                 * schedule of its own to promise.
+                 */
+                return {
+                    label: isEmail ? "Last email" : "Last request",
+                    at: isEmail
+                        ? input.email.lastReceivedAt
+                        : input.heartbeat.lastReceivedAt,
+                    emptyText: isEmail ? "No email yet" : "No request yet",
+                    isUnavailable: false,
+                };
+            }
+            case MonitorOverviewFamily.Agent:
+                return {
+                    label: "Last report",
+                    at: input.agent.lastReportAt,
+                    emptyText: "No report yet",
+                    isUnavailable: false,
+                };
+            case MonitorOverviewFamily.TelemetrySignal:
+            case MonitorOverviewFamily.Infrastructure: {
+                const nextAt = input.telemetry.nextEvaluationAt;
+                /*
+                 * Without a time from the evaluation log, the only time is the
+                 * worker's stamp, which it writes when it queues an evaluation: it
+                 * is named for what it is.
+                 */
+                const isScheduledTime = Boolean((_c = context.telemetry) === null || _c === void 0 ? void 0 : _c.isScheduledTime);
+                let emptyText = "Not evaluated yet";
+                if (isScheduledTime) {
+                    emptyText = "Not scheduled yet";
+                }
+                else if (context.evaluationLog === "expired") {
+                    emptyText = NOT_EVALUATED_IN_LOG_TEXT;
+                }
+                return {
+                    label: isScheduledTime ? "Last scheduled" : "Last evaluated",
+                    at: (_d = context.telemetry) === null || _d === void 0 ? void 0 : _d.lastAt,
+                    emptyText: emptyText,
+                    cadenceText: isScheduled ? context.intervalText : undefined,
+                    nextAt: isScheduled && isFutureOf(nextAt, input.now) ? nextAt : undefined,
+                    overdueSeconds: overdueSeconds,
+                    isUnavailable: false,
+                };
+            }
+            case MonitorOverviewFamily.NetworkDevice: {
+                let emptyText = "Not evaluated yet";
+                if (context.evaluationStatus === "loading") {
+                    emptyText = "Loading…";
+                }
+                else if (context.evaluationLog === "expired") {
+                    emptyText = NOT_EVALUATED_IN_LOG_TEXT;
+                }
+                // The time only comes from the evaluation log, so it follows its read.
+                return {
+                    label: "Last evaluated",
+                    at: context.evaluationStatus === "loaded"
+                        ? input.latestEvaluationAt
+                        : undefined,
+                    emptyText: emptyText,
+                    isUnavailable: context.evaluationStatus === "error" ||
+                        context.evaluationStatus === "forbidden",
+                };
+            }
+            default:
+                return {
+                    label: null,
+                    emptyText: "No automated checks",
+                    isUnavailable: false,
+                };
+        }
+    }
+    static getFacts(input, context) {
+        var _a, _b, _c;
+        const facts = [];
+        switch (context.family) {
+            case MonitorOverviewFamily.ProbeCheck:
+                facts.push(MonitorOverviewPresentationUtil.getLatestResultFact(input));
+                if (input.monitorType === MonitorType.SSLCertificate) {
+                    facts.push(input.probes === null
+                        ? {
+                            key: "certificate-expiry",
+                            label: "Certificate expires",
+                            value: "Unavailable",
+                            isMuted: true,
+                        }
+                        : MonitorOverviewPresentationUtil.getExpiryFact({
+                            key: "certificate-expiry",
+                            expiresAt: (_a = input.probes.latestResult) === null || _a === void 0 ? void 0 : _a.sslExpiresAt,
+                            isValidCertificate: (_b = input.probes.latestResult) === null || _b === void 0 ? void 0 : _b.isValidCertificate,
+                            now: input.now,
+                        }));
+                }
+                if (input.monitorType === MonitorType.Domain) {
+                    facts.push(input.probes === null
+                        ? {
+                            key: "domain-expiry",
+                            label: "Domain expires",
+                            value: "Unavailable",
+                            isMuted: true,
+                        }
+                        : MonitorOverviewPresentationUtil.getExpiryFact({
+                            key: "domain-expiry",
+                            expiresAt: (_c = input.probes.latestResult) === null || _c === void 0 ? void 0 : _c.domainExpiresAt,
+                            now: input.now,
+                        }));
+                }
+                facts.push(MonitorOverviewPresentationUtil.getProbesFact(input, context));
+                break;
+            case MonitorOverviewFamily.Heartbeat: {
+                const isEmail = input.monitorType === MonitorType.IncomingEmail;
+                const minutes = MonitorOverviewCriteriaUtil.getMissingSignalMinutes({
+                    monitorSteps: input.monitorSteps,
+                    checkOn: isEmail
+                        ? CheckOn.EmailReceivedAt
+                        : CheckOn.IncomingRequest,
+                });
+                const lastCheckedAt = isEmail
+                    ? input.email.lastCheckedAt
+                    : input.heartbeat.lastCheckedAt;
+                facts.push(minutes === null
+                    ? {
+                        key: "missing-window",
+                        label: isEmail
+                            ? "Missing-email window"
+                            : "Missing-request window",
+                        value: "Set in Criteria",
+                        linkKey: "criteria",
+                    }
+                    : {
+                        key: "missing-window",
+                        label: isEmail
+                            ? "Missing-email window"
+                            : "Missing-request window",
+                        value: pluralize(minutes, "minute", "minutes"),
+                        secondary: "From this monitor's criteria",
+                    });
+                facts.push(lastCheckedAt
+                    ? {
+                        key: "heartbeat-check",
+                        label: isEmail
+                            ? "Last missing-email check"
+                            : "Last missing-request check",
+                        value: "",
+                        valueDate: lastCheckedAt,
+                    }
+                    : {
+                        key: "heartbeat-check",
+                        label: isEmail
+                            ? "Last missing-email check"
+                            : "Last missing-request check",
+                        value: "Not run yet",
+                        isMuted: true,
+                    });
+                break;
+            }
+            case MonitorOverviewFamily.Agent: {
+                const hostname = (input.agent.hostname || "").trim();
+                facts.push(hostname
+                    ? { key: "host", label: "Host", value: hostname, isMono: true }
+                    : {
+                        key: "host",
+                        label: "Host",
+                        value: "Not reported yet",
+                        isMuted: true,
+                    });
+                facts.push(MonitorOverviewPresentationUtil.getPercentFact({
+                    key: "cpu",
+                    label: "CPU",
+                    percent: input.agent.cpuPercent,
+                }));
+                facts.push(MonitorOverviewPresentationUtil.getPercentFact({
+                    key: "memory",
+                    label: "Memory",
+                    percent: input.agent.memoryPercent,
+                }));
+                break;
+            }
+            case MonitorOverviewFamily.TelemetrySignal:
+            case MonitorOverviewFamily.Infrastructure:
+                facts.push({
+                    key: "evaluates",
+                    label: "Evaluates",
+                    value: context.intervalText,
+                });
+                facts.push({
+                    key: "criteria",
+                    label: "Criteria",
+                    value: pluralize(context.stepCount, "step", "steps"),
+                    linkKey: "criteria",
+                });
+                break;
+            case MonitorOverviewFamily.NetworkDevice:
+                facts.push(context.networkDeviceId
+                    ? {
+                        key: "device",
+                        label: "Device",
+                        value: "View device",
+                        linkKey: "networkDevice",
+                        linkId: context.networkDeviceId,
+                    }
+                    : {
+                        key: "device",
+                        label: "Device",
+                        value: "Not selected",
+                        isMuted: true,
+                    });
+                facts.push({
+                    key: "evaluated",
+                    label: "Evaluated",
+                    value: "On every poll and matching trap",
+                });
+                break;
+            default:
+                facts.push({
+                    key: "checks",
+                    label: "Checks",
+                    value: "None",
+                    secondary: "Status is set by hand or by incidents",
+                });
+                break;
+        }
+        /*
+         * Owners always close the band; the component renders them from the
+         * owners section, so the value here is empty.
+         */
+        return [
+            ...facts.slice(0, MAX_FACTS - 1),
+            { key: "owners", label: "Owners", value: "" },
+        ];
+    }
+    static getLatestResultFact(input) {
+        const base = {
+            key: "latest-result",
+            label: "Latest result",
+        };
+        if (input.probes === null) {
+            return Object.assign(Object.assign({}, base), { value: "Unavailable", isMuted: true });
+        }
+        const result = input.probes.latestResult;
+        if (!result) {
+            return Object.assign(Object.assign({}, base), { value: "—", secondary: "No results yet", isMuted: true });
+        }
+        const isScripted = input.monitorType === MonitorType.SyntheticMonitor ||
+            input.monitorType === MonitorType.CustomJavaScriptCode;
+        const upCount = input.probes.upCount || 0;
+        const downCount = input.probes.downCount || 0;
+        /*
+         * When the probes disagree, the newest single result is just whichever
+         * probe reported last, and would flip between Up and Down from one poll
+         * to the next. Say they disagree instead.
+         */
+        if (upCount > 0 && downCount > 0) {
+            return Object.assign(Object.assign({}, base), { value: isScripted
+                    ? `Mixed · ${upCount} passed, ${downCount} failed`
+                    : `Mixed · ${upCount} up, ${downCount} down`, tone: "warning" });
+        }
+        let value = "Reported";
+        let tone = "neutral";
+        if (result.isOnline === true) {
+            value = isScripted ? "Passed" : "Up";
+            tone = "good";
+        }
+        else if (result.isOnline === false) {
+            value = isScripted ? "Failed" : "Down";
+            tone = "danger";
+        }
+        if (result.responseTimeInMs !== undefined) {
+            value += ` · ${Math.round(result.responseTimeInMs)} ms`;
+        }
+        if (result.responseCode !== undefined &&
+            (input.monitorType === MonitorType.API ||
+                input.monitorType === MonitorType.Website)) {
+            value += ` · HTTP ${result.responseCode}`;
+        }
+        return Object.assign(Object.assign({}, base), { value: value, secondary: result.isOnline === false && result.failureCause
+                ? result.failureCause
+                : `from ${result.probeName}`, tone: tone });
+    }
+    static getProbesFact(input, context) {
+        const base = { key: "probes", label: "Probes", linkKey: "probes" };
+        if (input.probes === null) {
+            return Object.assign(Object.assign({}, base), { value: "Unavailable", isMuted: true });
+        }
+        const probes = input.probes;
+        const downCount = probes.downCount || 0;
+        const connectionParts = [];
+        if (probes.disabledCount > 0) {
+            connectionParts.push(`${probes.disabledCount} disabled`);
+        }
+        if (probes.disconnectedCount > 0) {
+            connectionParts.push(`${probes.disconnectedCount} disconnected`);
+        }
+        const joinParts = (parts) => {
+            return parts.length > 0 ? parts.join(" · ") : undefined;
+        };
+        if (probes.enabledCount === 0) {
+            return Object.assign(Object.assign({}, base), { value: "None enabled", secondary: joinParts(connectionParts), tone: "danger" });
+        }
+        /*
+         * No probe is meant to report while monitoring is paused, so a
+         * reporting ratio would read as a probe fault that does not exist.
+         */
+        if (context.isPaused) {
+            return Object.assign(Object.assign({}, base), { value: `${probes.enabledCount} enabled`, secondary: joinParts(["Checks paused", ...connectionParts]), tone: "neutral" });
+        }
+        let tone = "neutral";
+        if (probes.reportingCount === 0 || downCount >= probes.reportingCount) {
+            // Nothing reporting, or every probe that reports sees it down.
+            tone = "danger";
+        }
+        else if (downCount > 0 || probes.reportingCount < probes.enabledCount) {
+            tone = "warning";
+        }
+        const isScripted = input.monitorType === MonitorType.SyntheticMonitor ||
+            input.monitorType === MonitorType.CustomJavaScriptCode;
+        // A probe that reports Down is reporting, but it is not fine.
+        const downPart = `${downCount} ${isScripted ? "failing" : "down"}`;
+        return Object.assign(Object.assign({}, base), { value: `${probes.reportingCount} of ${probes.enabledCount} reporting`, secondary: joinParts(downCount > 0 ? [downPart, ...connectionParts] : connectionParts), tone: tone });
+    }
+    static getPercentFact(data) {
+        if (data.percent === undefined || !Number.isFinite(data.percent)) {
+            return { key: data.key, label: data.label, value: "—", isMuted: true };
+        }
+        return {
+            key: data.key,
+            label: data.label,
+            value: `${Math.round(data.percent)}%`,
+        };
+    }
+    static getSections(context) {
+        const isAwaiting = context.runState === MonitorOverviewRunState.AwaitingFirstData;
+        const layout = context.layout;
+        const isPushFamily = context.family === MonitorOverviewFamily.Heartbeat ||
+            context.family === MonitorOverviewFamily.Agent;
+        return {
+            /*
+             * Bars for a monitor that has never reported would all be "No data",
+             * unless the server has already judged it: then its history (and what
+             * is open now) is the point.
+             */
+            showUptime: !isAwaiting || context.hasPushVerdict,
+            setup: isAwaiting ? layout.setupKind : null,
+            connection: isAwaiting ? null : layout.setupKind,
+            summary: {
+                isShown: layout.summaryDescription !== null && !(isAwaiting && isPushFamily),
+                description: layout.summaryDescription || "",
+            },
+            // The connection card only makes sense once something has connected.
+            sideCard: layout.sideCard === "connection" && isAwaiting ? null : layout.sideCard,
+            responseTimeMetric: isAwaiting ? null : layout.responseTimeMetric,
+            telemetryPreview: context.stepCount > 0 ? layout.telemetryPreview : null,
+            stepCount: context.stepCount,
+        };
+    }
+}
+//# sourceMappingURL=MonitorOverviewPresentationUtil.js.map