801 lines
22 KiB
TypeScript
801 lines
22 KiB
TypeScript
export interface DashboardRefreshPauseState {
|
|
visibilityState: DocumentVisibilityState;
|
|
online: boolean;
|
|
}
|
|
|
|
export type DashboardTileReference =
|
|
| { kind: "telemetry"; id: string }
|
|
| { kind: "service"; groupId: string; id: string }
|
|
| { kind: "module"; id: string }
|
|
| { kind: "status"; stripId: string; id: string };
|
|
|
|
type SnapshotMetricValue = Record<string, unknown>;
|
|
|
|
export type DashboardTileSnapshotItem = {
|
|
detail?: string;
|
|
id: string;
|
|
label?: string;
|
|
severity?: string;
|
|
value?: SnapshotMetricValue | string;
|
|
} & Record<string, unknown>;
|
|
|
|
export type DashboardTileSnapshotResponse =
|
|
| {
|
|
state: "ready";
|
|
tile: DashboardTileReference;
|
|
item: DashboardTileSnapshotItem;
|
|
}
|
|
| {
|
|
state: "not_found";
|
|
tile: DashboardTileReference;
|
|
message: string;
|
|
}
|
|
| {
|
|
state: "disabled";
|
|
tile: DashboardTileReference;
|
|
message: string;
|
|
};
|
|
|
|
export function shouldPauseDashboardRefresh(
|
|
state: DashboardRefreshPauseState,
|
|
): boolean {
|
|
return state.visibilityState !== "visible" || !state.online;
|
|
}
|
|
|
|
export function createDashboardRequestAborter() {
|
|
let shellController: AbortController | undefined;
|
|
let tileController: AbortController | undefined;
|
|
|
|
function abortController(controller: AbortController | undefined) {
|
|
if (controller && !controller.signal.aborted) {
|
|
controller.abort();
|
|
}
|
|
}
|
|
|
|
return {
|
|
beginShellRun(): AbortSignal {
|
|
abortController(shellController);
|
|
abortController(tileController);
|
|
shellController = new AbortController();
|
|
tileController = undefined;
|
|
return shellController.signal;
|
|
},
|
|
beginTileRun(): AbortSignal {
|
|
abortController(tileController);
|
|
tileController = new AbortController();
|
|
return tileController.signal;
|
|
},
|
|
abortActiveRequests(): void {
|
|
abortController(shellController);
|
|
abortController(tileController);
|
|
shellController = undefined;
|
|
tileController = undefined;
|
|
},
|
|
};
|
|
}
|
|
|
|
type DashboardRefreshEventTarget = Pick<
|
|
EventTarget,
|
|
"addEventListener" | "removeEventListener"
|
|
>;
|
|
|
|
export interface DashboardRefreshLifecycleOptions {
|
|
documentTarget: DashboardRefreshEventTarget;
|
|
windowTarget: DashboardRefreshEventTarget;
|
|
loadDashboard: () => void | Promise<void>;
|
|
pauseRefreshes: () => void;
|
|
refreshPaused: () => boolean;
|
|
}
|
|
|
|
export function attachDashboardRefreshLifecycle(
|
|
options: DashboardRefreshLifecycleOptions,
|
|
): () => void {
|
|
function handleRefreshLifecycleChange() {
|
|
if (options.refreshPaused()) {
|
|
options.pauseRefreshes();
|
|
return;
|
|
}
|
|
|
|
void options.loadDashboard();
|
|
}
|
|
|
|
function handlePageHide() {
|
|
options.pauseRefreshes();
|
|
}
|
|
|
|
options.documentTarget.addEventListener(
|
|
"visibilitychange",
|
|
handleRefreshLifecycleChange,
|
|
);
|
|
options.windowTarget.addEventListener("online", handleRefreshLifecycleChange);
|
|
options.windowTarget.addEventListener("offline", handleRefreshLifecycleChange);
|
|
options.windowTarget.addEventListener("pagehide", handlePageHide);
|
|
|
|
return () => {
|
|
options.documentTarget.removeEventListener(
|
|
"visibilitychange",
|
|
handleRefreshLifecycleChange,
|
|
);
|
|
options.windowTarget.removeEventListener("online", handleRefreshLifecycleChange);
|
|
options.windowTarget.removeEventListener("offline", handleRefreshLifecycleChange);
|
|
options.windowTarget.removeEventListener("pagehide", handlePageHide);
|
|
};
|
|
}
|
|
|
|
export interface DashboardHydrationQueueOptions<TItem> {
|
|
concurrency: number;
|
|
hydrate: (item: TItem) => Promise<void> | void;
|
|
items: TItem[];
|
|
signal: AbortSignal;
|
|
}
|
|
|
|
export async function runDashboardHydrationQueue<TItem>(
|
|
options: DashboardHydrationQueueOptions<TItem>,
|
|
): Promise<void> {
|
|
const concurrency = Math.max(1, Math.floor(options.concurrency));
|
|
let nextIndex = 0;
|
|
|
|
async function worker() {
|
|
while (!options.signal.aborted) {
|
|
const item = options.items[nextIndex];
|
|
nextIndex += 1;
|
|
if (item === undefined) return;
|
|
|
|
await options.hydrate(item);
|
|
}
|
|
}
|
|
|
|
const workerCount = Math.min(concurrency, options.items.length);
|
|
await Promise.all(
|
|
Array.from({ length: workerCount }, () => worker()),
|
|
);
|
|
}
|
|
|
|
export interface DashboardViewportHydrationQueueOptions<TItem> {
|
|
collectVisibleModelIds: () => Promise<ReadonlySet<string>>;
|
|
concurrency: number;
|
|
getModelId: (item: TItem) => string;
|
|
hydrate: (item: TItem) => Promise<void> | void;
|
|
items: TItem[];
|
|
onAllItemsSettled?: () => void;
|
|
onVisibleItemsSettled?: () => void;
|
|
signal: AbortSignal;
|
|
waitForIdle: () => Promise<void>;
|
|
}
|
|
|
|
export async function runViewportAwareDashboardHydrationQueue<TItem>(
|
|
options: DashboardViewportHydrationQueueOptions<TItem>,
|
|
): Promise<void> {
|
|
const visibleModelIds = await options.collectVisibleModelIds();
|
|
if (options.signal.aborted) return;
|
|
|
|
const { visible, deferred } = splitDashboardHydrationItemsByVisibility({
|
|
getModelId: options.getModelId,
|
|
items: options.items,
|
|
visibleModelIds,
|
|
});
|
|
|
|
await runDashboardHydrationQueue({
|
|
concurrency: options.concurrency,
|
|
hydrate: options.hydrate,
|
|
items: visible,
|
|
signal: options.signal,
|
|
});
|
|
if (options.signal.aborted) return;
|
|
options.onVisibleItemsSettled?.();
|
|
|
|
if (!deferred.length) {
|
|
options.onAllItemsSettled?.();
|
|
return;
|
|
}
|
|
|
|
await options.waitForIdle();
|
|
if (options.signal.aborted) return;
|
|
|
|
await runDashboardHydrationQueue({
|
|
concurrency: options.concurrency,
|
|
hydrate: options.hydrate,
|
|
items: deferred,
|
|
signal: options.signal,
|
|
});
|
|
options.onAllItemsSettled?.();
|
|
}
|
|
|
|
export function splitDashboardHydrationItemsByVisibility<TItem>(options: {
|
|
getModelId: (item: TItem) => string;
|
|
items: TItem[];
|
|
visibleModelIds: ReadonlySet<string>;
|
|
}): {
|
|
deferred: TItem[];
|
|
visible: TItem[];
|
|
} {
|
|
const visible: TItem[] = [];
|
|
const deferred: TItem[] = [];
|
|
|
|
for (const item of options.items) {
|
|
if (options.visibleModelIds.has(options.getModelId(item))) {
|
|
visible.push(item);
|
|
} else {
|
|
deferred.push(item);
|
|
}
|
|
}
|
|
|
|
return { visible, deferred };
|
|
}
|
|
|
|
export interface DashboardModelElement {
|
|
getAttribute(name: string): string | null;
|
|
}
|
|
|
|
export interface DashboardViewportElementSource {
|
|
querySelectorAll(selector: string): ArrayLike<DashboardModelElement>;
|
|
}
|
|
|
|
export interface DashboardIntersectionEntry {
|
|
intersectionRatio?: number;
|
|
isIntersecting: boolean;
|
|
target: DashboardModelElement;
|
|
}
|
|
|
|
export interface DashboardIntersectionObserver {
|
|
disconnect(): void;
|
|
observe(element: DashboardModelElement): void;
|
|
}
|
|
|
|
export type DashboardIntersectionObserverFactory = (
|
|
callback: (entries: DashboardIntersectionEntry[]) => void,
|
|
) => DashboardIntersectionObserver;
|
|
|
|
type DashboardTimerHandle = ReturnType<typeof setTimeout>;
|
|
|
|
export interface DashboardVisibleModelIdCollectorOptions {
|
|
clearTimeout?: (handle: DashboardTimerHandle) => void;
|
|
createObserver?: DashboardIntersectionObserverFactory;
|
|
documentTarget: DashboardViewportElementSource;
|
|
modelIds: Iterable<string>;
|
|
setTimeout?: (callback: () => void, timeoutMs: number) => DashboardTimerHandle;
|
|
signal: AbortSignal;
|
|
timeoutMs?: number;
|
|
}
|
|
|
|
export async function collectVisibleDashboardModelIds(
|
|
options: DashboardVisibleModelIdCollectorOptions,
|
|
): Promise<Set<string>> {
|
|
const targetIds = new Set(options.modelIds);
|
|
if (!targetIds.size || options.signal.aborted) return new Set();
|
|
|
|
const elements = Array.from(
|
|
options.documentTarget.querySelectorAll("[data-model-id]"),
|
|
).filter((element) => {
|
|
const modelId = element.getAttribute("data-model-id");
|
|
return modelId ? targetIds.has(modelId) : false;
|
|
});
|
|
|
|
if (!elements.length) return new Set();
|
|
if (!options.createObserver) return targetIds;
|
|
const createObserver = options.createObserver;
|
|
|
|
const setTimer =
|
|
options.setTimeout ||
|
|
((callback: () => void, timeoutMs: number) =>
|
|
globalThis.setTimeout(callback, timeoutMs));
|
|
const clearTimer =
|
|
options.clearTimeout ||
|
|
((handle: DashboardTimerHandle) => globalThis.clearTimeout(handle));
|
|
const timeoutMs = options.timeoutMs ?? 80;
|
|
|
|
return new Promise((resolve) => {
|
|
const visibleModelIds = new Set<string>();
|
|
let settled = false;
|
|
let timeoutHandle: DashboardTimerHandle | undefined;
|
|
let observer: DashboardIntersectionObserver | undefined;
|
|
|
|
function cleanup() {
|
|
if (timeoutHandle !== undefined) {
|
|
clearTimer(timeoutHandle);
|
|
}
|
|
observer?.disconnect();
|
|
options.signal.removeEventListener("abort", finish);
|
|
}
|
|
|
|
function finish() {
|
|
if (settled) return;
|
|
settled = true;
|
|
cleanup();
|
|
resolve(visibleModelIds);
|
|
}
|
|
|
|
observer = createObserver((entries) => {
|
|
for (const entry of entries) {
|
|
const modelId = entry.target.getAttribute("data-model-id");
|
|
if (
|
|
modelId &&
|
|
targetIds.has(modelId) &&
|
|
(entry.isIntersecting || (entry.intersectionRatio ?? 0) > 0)
|
|
) {
|
|
visibleModelIds.add(modelId);
|
|
}
|
|
}
|
|
});
|
|
|
|
for (const element of elements) {
|
|
observer.observe(element);
|
|
}
|
|
|
|
options.signal.addEventListener("abort", finish, { once: true });
|
|
timeoutHandle = setTimer(finish, timeoutMs);
|
|
});
|
|
}
|
|
|
|
export interface DashboardHydrationIdleOptions {
|
|
cancelIdleCallback?: (handle: number) => void;
|
|
clearTimeout?: (handle: DashboardTimerHandle) => void;
|
|
requestIdleCallback?: (
|
|
callback: () => void,
|
|
options?: { timeout?: number },
|
|
) => number;
|
|
setTimeout?: (callback: () => void, timeoutMs: number) => DashboardTimerHandle;
|
|
signal: AbortSignal;
|
|
timeoutMs?: number;
|
|
}
|
|
|
|
export async function waitForDashboardHydrationIdle(
|
|
options: DashboardHydrationIdleOptions,
|
|
): Promise<void> {
|
|
if (options.signal.aborted) return;
|
|
|
|
const setTimer =
|
|
options.setTimeout ||
|
|
((callback: () => void, timeoutMs: number) =>
|
|
globalThis.setTimeout(callback, timeoutMs));
|
|
const clearTimer =
|
|
options.clearTimeout ||
|
|
((handle: DashboardTimerHandle) => globalThis.clearTimeout(handle));
|
|
|
|
await new Promise<void>((resolve) => {
|
|
let settled = false;
|
|
let idleHandle: number | undefined;
|
|
let timeoutHandle: DashboardTimerHandle | undefined;
|
|
|
|
function cleanup() {
|
|
if (idleHandle !== undefined) {
|
|
options.cancelIdleCallback?.(idleHandle);
|
|
}
|
|
if (timeoutHandle !== undefined) {
|
|
clearTimer(timeoutHandle);
|
|
}
|
|
options.signal.removeEventListener("abort", finish);
|
|
}
|
|
|
|
function finish() {
|
|
if (settled) return;
|
|
settled = true;
|
|
cleanup();
|
|
resolve();
|
|
}
|
|
|
|
options.signal.addEventListener("abort", finish, { once: true });
|
|
if (options.requestIdleCallback) {
|
|
idleHandle = options.requestIdleCallback(finish, {
|
|
timeout: options.timeoutMs ?? 1_000,
|
|
});
|
|
} else {
|
|
timeoutHandle = setTimer(finish, 0);
|
|
}
|
|
});
|
|
}
|
|
|
|
export interface DashboardRefreshDelayOptions {
|
|
failureMultiplierLimit?: number;
|
|
jitterRatio?: number;
|
|
random?: () => number;
|
|
}
|
|
|
|
export function createDashboardRefreshDelay(
|
|
options: DashboardRefreshDelayOptions = {},
|
|
) {
|
|
const random = options.random || Math.random;
|
|
const jitterRatio = options.jitterRatio ?? 0.1;
|
|
const failureMultiplierLimit = options.failureMultiplierLimit ?? 8;
|
|
let consecutiveFailures = 0;
|
|
|
|
return {
|
|
nextDelayMs(baseDelayMs: number): number {
|
|
const failureMultiplier = consecutiveFailures
|
|
? Math.min(2 ** consecutiveFailures, failureMultiplierLimit)
|
|
: 1;
|
|
const jitterFactor = 1 + ((random() * 2) - 1) * jitterRatio;
|
|
return Math.max(0, Math.round(baseDelayMs * failureMultiplier * jitterFactor));
|
|
},
|
|
recordFailure(): void {
|
|
consecutiveFailures += 1;
|
|
},
|
|
recordSuccess(): void {
|
|
consecutiveFailures = 0;
|
|
},
|
|
};
|
|
}
|
|
|
|
export interface DashboardPerformanceMarkOptions {
|
|
mark?: (name: string) => void;
|
|
}
|
|
|
|
export const dashboardPerformanceMarks = {
|
|
allTilesSettled: "dashboard:all-tiles-settled",
|
|
firstTileReady: "dashboard:first-tile-ready",
|
|
shellLoad: "dashboard:shell-load",
|
|
visibleTilesReady: "dashboard:visible-tiles-ready",
|
|
} as const;
|
|
|
|
export function createDashboardPerformanceMarks(
|
|
options: DashboardPerformanceMarkOptions = {},
|
|
) {
|
|
const mark = options.mark ||
|
|
globalThis.performance?.mark?.bind(globalThis.performance);
|
|
let firstTileReadyMarked = false;
|
|
|
|
function safeMark(name: string) {
|
|
try {
|
|
mark?.(name);
|
|
} catch {
|
|
// Performance marks are diagnostics only.
|
|
}
|
|
}
|
|
|
|
return {
|
|
markAllTilesSettled(): void {
|
|
safeMark(dashboardPerformanceMarks.allTilesSettled);
|
|
},
|
|
markFirstTileReady(): void {
|
|
if (firstTileReadyMarked) return;
|
|
firstTileReadyMarked = true;
|
|
safeMark(dashboardPerformanceMarks.firstTileReady);
|
|
},
|
|
markShellLoad(): void {
|
|
firstTileReadyMarked = false;
|
|
safeMark(dashboardPerformanceMarks.shellLoad);
|
|
},
|
|
markVisibleTilesReady(): void {
|
|
safeMark(dashboardPerformanceMarks.visibleTilesReady);
|
|
},
|
|
};
|
|
}
|
|
|
|
const dashboardTileBackoffDelaysMs = [15_000, 30_000, 60_000, 120_000];
|
|
|
|
export function createDashboardTileBackoff() {
|
|
const failures = new Map<string, { attempts: number; nextAttemptAt: number }>();
|
|
|
|
return {
|
|
canAttempt(key: string, now = Date.now()): boolean {
|
|
const failure = failures.get(key);
|
|
return !failure || now >= failure.nextAttemptAt;
|
|
},
|
|
recordFailure(key: string, now = Date.now()): void {
|
|
const previousAttempts = failures.get(key)?.attempts || 0;
|
|
const attempts = previousAttempts + 1;
|
|
const delay =
|
|
dashboardTileBackoffDelaysMs[
|
|
Math.min(attempts - 1, dashboardTileBackoffDelaysMs.length - 1)
|
|
];
|
|
failures.set(key, {
|
|
attempts,
|
|
nextAttemptAt: now + delay,
|
|
});
|
|
},
|
|
recordSuccess(key: string): void {
|
|
failures.delete(key);
|
|
},
|
|
};
|
|
}
|
|
|
|
interface DashboardTileSnapshotRecord {
|
|
item: DashboardTileSnapshotItem;
|
|
savedAt: number;
|
|
tile: DashboardTileReference;
|
|
}
|
|
|
|
interface DashboardTileSnapshotPayload {
|
|
currentRevisionId: string;
|
|
schemaVersion: string;
|
|
tiles: DashboardTileSnapshotRecord[];
|
|
version: 1;
|
|
}
|
|
|
|
export interface DashboardTileSnapshotStoreContext {
|
|
currentRevisionId: string;
|
|
schemaVersion: string;
|
|
}
|
|
|
|
export interface DashboardTileSnapshotStoreOptions {
|
|
now?: () => number;
|
|
}
|
|
|
|
export interface RestoredDashboardTileSnapshot {
|
|
ageMs: number;
|
|
response: Extract<DashboardTileSnapshotResponse, { state: "ready" }>;
|
|
}
|
|
|
|
const dashboardTileSnapshotStorageKey = "dimensionlab.dashboard.tiles.v1";
|
|
|
|
export function createDashboardTileSnapshotStore(
|
|
storage: Storage | undefined,
|
|
options: DashboardTileSnapshotStoreOptions = {},
|
|
) {
|
|
const now = options.now || Date.now;
|
|
|
|
function read(): DashboardTileSnapshotPayload | null {
|
|
if (!storage) return null;
|
|
|
|
try {
|
|
const serialized = storage.getItem(dashboardTileSnapshotStorageKey);
|
|
if (!serialized) return null;
|
|
|
|
const payload = JSON.parse(serialized) as Partial<DashboardTileSnapshotPayload>;
|
|
if (
|
|
payload.version !== 1 ||
|
|
typeof payload.currentRevisionId !== "string" ||
|
|
typeof payload.schemaVersion !== "string" ||
|
|
!Array.isArray(payload.tiles)
|
|
) {
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
currentRevisionId: payload.currentRevisionId,
|
|
schemaVersion: payload.schemaVersion,
|
|
tiles: payload.tiles.filter(isDashboardTileSnapshotRecord),
|
|
version: 1,
|
|
};
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function write(payload: DashboardTileSnapshotPayload): void {
|
|
if (!storage) return;
|
|
|
|
try {
|
|
storage.setItem(dashboardTileSnapshotStorageKey, JSON.stringify(payload));
|
|
} catch {
|
|
// Best-effort warm-start cache; quota and privacy failures are non-fatal.
|
|
}
|
|
}
|
|
|
|
function matchingPayload(
|
|
context: DashboardTileSnapshotStoreContext,
|
|
): DashboardTileSnapshotPayload {
|
|
const payload = read();
|
|
if (
|
|
payload &&
|
|
payload.currentRevisionId === context.currentRevisionId &&
|
|
payload.schemaVersion === context.schemaVersion
|
|
) {
|
|
return payload;
|
|
}
|
|
|
|
return {
|
|
currentRevisionId: context.currentRevisionId,
|
|
schemaVersion: context.schemaVersion,
|
|
tiles: [],
|
|
version: 1,
|
|
};
|
|
}
|
|
|
|
function saveReadyTile(
|
|
input: DashboardTileSnapshotStoreContext & {
|
|
response: Extract<DashboardTileSnapshotResponse, { state: "ready" }>;
|
|
},
|
|
): void {
|
|
const payload = matchingPayload(input);
|
|
const key = dashboardTileSnapshotKey(input.response.tile);
|
|
const nextRecord: DashboardTileSnapshotRecord = {
|
|
item: input.response.item,
|
|
savedAt: now(),
|
|
tile: input.response.tile,
|
|
};
|
|
payload.tiles = [
|
|
nextRecord,
|
|
...payload.tiles.filter((record) =>
|
|
dashboardTileSnapshotKey(record.tile) !== key
|
|
),
|
|
];
|
|
write(payload);
|
|
}
|
|
|
|
return {
|
|
restore(context: DashboardTileSnapshotStoreContext): RestoredDashboardTileSnapshot[] {
|
|
const payload = read();
|
|
if (
|
|
!payload ||
|
|
payload.currentRevisionId !== context.currentRevisionId ||
|
|
payload.schemaVersion !== context.schemaVersion
|
|
) {
|
|
return [];
|
|
}
|
|
|
|
const restoredAt = now();
|
|
return payload.tiles.map((record) => ({
|
|
ageMs: Math.max(0, restoredAt - record.savedAt),
|
|
response: {
|
|
state: "ready",
|
|
tile: record.tile,
|
|
item: {
|
|
...record.item,
|
|
detail: staleDashboardTileDetail(record.item.detail, restoredAt - record.savedAt),
|
|
severity: "stale",
|
|
},
|
|
},
|
|
}));
|
|
},
|
|
saveReadyTile,
|
|
saveTile(input: DashboardTileSnapshotStoreContext & {
|
|
response: DashboardTileSnapshotResponse;
|
|
}): void {
|
|
if (input.response.state === "ready") {
|
|
saveReadyTile({
|
|
currentRevisionId: input.currentRevisionId,
|
|
response: input.response,
|
|
schemaVersion: input.schemaVersion,
|
|
});
|
|
}
|
|
},
|
|
};
|
|
}
|
|
|
|
function dashboardTileSnapshotKey(tile: DashboardTileReference): string {
|
|
return JSON.stringify(tile);
|
|
}
|
|
|
|
function isDashboardTileSnapshotRecord(
|
|
value: unknown,
|
|
): value is DashboardTileSnapshotRecord {
|
|
if (!isSnapshotRecord(value)) return false;
|
|
|
|
return (
|
|
typeof value.savedAt === "number" &&
|
|
Number.isFinite(value.savedAt) &&
|
|
isDashboardTileReference(value.tile) &&
|
|
isDashboardTileSnapshotItem(value.tile, value.item)
|
|
);
|
|
}
|
|
|
|
function isDashboardTileReference(
|
|
value: unknown,
|
|
): value is DashboardTileReference {
|
|
if (!isSnapshotRecord(value) || typeof value.kind !== "string") return false;
|
|
|
|
switch (value.kind) {
|
|
case "telemetry":
|
|
case "module":
|
|
return typeof value.id === "string";
|
|
case "service":
|
|
return typeof value.groupId === "string" && typeof value.id === "string";
|
|
case "status":
|
|
return typeof value.stripId === "string" && typeof value.id === "string";
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function isDashboardTileSnapshotItem(
|
|
tile: DashboardTileReference,
|
|
value: unknown,
|
|
): value is DashboardTileSnapshotItem {
|
|
if (!isSnapshotRecord(value) || value.id !== tile.id) return false;
|
|
|
|
switch (tile.kind) {
|
|
case "telemetry":
|
|
return (
|
|
typeof value.label === "string" &&
|
|
isMetricValue(value.value) &&
|
|
isSeverity(value.severity) &&
|
|
isOptionalString(value.detail) &&
|
|
isOptionalString(value.description) &&
|
|
isOptionalString(value.icon) &&
|
|
isOptionalNumberArray(value.sparkline)
|
|
);
|
|
case "service":
|
|
return (
|
|
typeof value.label === "string" &&
|
|
typeof value.description === "string" &&
|
|
isSeverity(value.severity) &&
|
|
isOptionalString(value.detail) &&
|
|
isOptionalString(value.icon) &&
|
|
isOptionalLink(value.link)
|
|
);
|
|
case "module":
|
|
return (
|
|
(value.kind === "summary" ||
|
|
value.kind === "weather" ||
|
|
value.kind === "custom") &&
|
|
isOptionalString(value.title) &&
|
|
isOptionalString(value.label) &&
|
|
isOptionalString(value.value) &&
|
|
isOptionalString(value.detail) &&
|
|
isOptionalString(value.icon) &&
|
|
(value.severity === undefined || isSeverity(value.severity))
|
|
);
|
|
case "status":
|
|
return (
|
|
typeof value.label === "string" &&
|
|
typeof value.value === "string" &&
|
|
isOptionalLink(value.link) &&
|
|
(value.severity === undefined || isSeverity(value.severity))
|
|
);
|
|
}
|
|
}
|
|
|
|
function isSnapshotRecord(value: unknown): value is Record<string, unknown> {
|
|
return typeof value === "object" && value !== null;
|
|
}
|
|
|
|
function isMetricValue(value: unknown): boolean {
|
|
if (!isSnapshotRecord(value) || typeof value.kind !== "string") return false;
|
|
|
|
if (value.kind === "text") {
|
|
return (
|
|
typeof value.value === "string" &&
|
|
isOptionalString(value.unit)
|
|
);
|
|
}
|
|
|
|
const numericKinds = ["bytes", "latency", "number", "percent", "temperature"];
|
|
if (!numericKinds.includes(value.kind)) return false;
|
|
if (typeof value.value !== "number" || !Number.isFinite(value.value)) return false;
|
|
if (value.kind === "percent" && (value.value < 0 || value.value > 100)) {
|
|
return false;
|
|
}
|
|
|
|
const precision = value.precision;
|
|
return (
|
|
isOptionalString(value.unit) &&
|
|
(precision === undefined ||
|
|
(typeof precision === "number" &&
|
|
Number.isInteger(precision) &&
|
|
precision >= 0 &&
|
|
precision <= 4))
|
|
);
|
|
}
|
|
|
|
function isSeverity(value: unknown): boolean {
|
|
return (
|
|
value === "neutral" ||
|
|
value === "ok" ||
|
|
value === "warning" ||
|
|
value === "danger" ||
|
|
value === "stale" ||
|
|
value === "unavailable"
|
|
);
|
|
}
|
|
|
|
function isOptionalString(value: unknown): boolean {
|
|
return value === undefined || typeof value === "string";
|
|
}
|
|
|
|
function isOptionalNumberArray(value: unknown): boolean {
|
|
return (
|
|
value === undefined ||
|
|
(Array.isArray(value) &&
|
|
value.every((item) => typeof item === "number" && Number.isFinite(item)))
|
|
);
|
|
}
|
|
|
|
function isOptionalLink(value: unknown): boolean {
|
|
return (
|
|
value === undefined ||
|
|
(isSnapshotRecord(value) &&
|
|
typeof value.href === "string" &&
|
|
isOptionalString(value.label) &&
|
|
(value.external === undefined || typeof value.external === "boolean"))
|
|
);
|
|
}
|
|
|
|
function staleDashboardTileDetail(
|
|
detail: string | undefined,
|
|
ageMs: number,
|
|
): string | undefined {
|
|
if (!detail) return detail;
|
|
const ageSeconds = Math.max(0, Math.floor(ageMs / 1_000));
|
|
return ageSeconds > 0 ? `${detail} - stale ${ageSeconds}s` : detail;
|
|
}
|