@checkstack/catalog-frontend 0.10.7 → 0.11.1

package/src/components/browse/filterEntities.logic.ts

@@ -0,0 +1,360 @@
+import type {
+  System,
+  Group,
+  CatalogHealthStatuses,
+} from "@checkstack/catalog-common";
+import {
+  type BrowseState,
+  type Density,
+  UNGROUPED_ID,
+} from "./browseState.logic";
+import { normalizeMetadata } from "../../utils/normalizeMetadata.logic";
+import {
+  computeGroupRollup,
+  matchesHealth,
+  type GroupHealthRollup,
+} from "./healthRollup.logic";
+
+/**
+ * Pure, DOM-free grouping + filtering logic for the catalog browse view.
+ *
+ * Filtering is client-side over the already-loaded `getEntities` set (systems
+ * and groups), matching the command palette's server-side `includes` matching
+ * but reproduced on the client at operator scale (thousands of rows, not
+ * millions — see the plan §5). No new backend endpoint is needed.
+ */
+
+/** A system together with the metadata-derived filter tokens it exposes. */
+export interface SystemView {
+  system: System;
+  /** `"key=value"` and `"key"` tokens for string-valued metadata entries. */
+  tags: string[];
+}
+
+/** One rendered group section: the group (or synthetic Ungrouped) + members. */
+export interface GroupSection {
+  /** Group id, or `UNGROUPED_ID` for the synthetic ungrouped section. */
+  id: string;
+  /** Display name. */
+  name: string;
+  /** `true` for the synthetic "Ungrouped" section. */
+  isUngrouped: boolean;
+  /** Member systems that survived filtering, in input order. */
+  systems: System[];
+  /** Total member count BEFORE filtering (the header count). */
+  totalCount: number;
+  /** Whether this section is open given URL overrides + default policy. */
+  open: boolean;
+  /**
+   * Health rollup for the header, derived from ALL members (pre-filter) and the
+   * reported status map — NOT from the filtered rows or rendered badges. When no
+   * health source filled the slot, `rollup.hasData` is `false` and the header
+   * shows counts only.
+   */
+  rollup: GroupHealthRollup;
+}
+
+/** The fully-derived browse model the page renders. */
+export interface BrowseModel {
+  sections: GroupSection[];
+  /** `true` when every section is empty after filtering (filtered-to-empty). */
+  isFilteredEmpty: boolean;
+  /** `true` when the catalog has no systems and no groups at all. */
+  isEmptyCatalog: boolean;
+  density: Density;
+}
+
+/** Case-insensitive substring match, null-safe. */
+function matchesText(haystack: string | null | undefined, needle: string): boolean {
+  if (!needle) return true;
+  if (!haystack) return false;
+  return haystack.toLowerCase().includes(needle.toLowerCase());
+}
+
+/**
+ * Derive the metadata filter tokens for a system. Only string-valued entries
+ * are surfaced (matching the plan §3.2 / §4.3 metadata rendering), each as
+ * both a bare `"key"` token and a `"key=value"` token so a tag filter can
+ * match either form.
+ */
+export function systemTags(system: System): string[] {
+  const entries = normalizeMetadata(system.metadata);
+  const tags: string[] = [];
+  for (const { key, displayValue } of entries) {
+    tags.push(key);
+    if (displayValue.length > 0) tags.push(`${key}=${displayValue}`);
+  }
+  return tags;
+}
+
+/**
+ * Collect the distinct `key=value` tag tokens across a set of systems, sorted
+ * for stable rendering. Used to populate the browse "Tags" filter dropdown.
+ * Only `key=value` form is offered (the bare-key tokens are matching aliases).
+ */
+export function collectTagOptions(systems: System[]): string[] {
+  const seen = new Set<string>();
+  for (const system of systems) {
+    for (const tag of systemTags(system)) {
+      if (tag.includes("=")) seen.add(tag);
+    }
+  }
+  return [...seen].toSorted((a, b) => a.localeCompare(b));
+}
+
+/** Does a system pass the search-query filter (name OR description)? */
+export function matchesQuery(system: System, query: string): boolean {
+  if (!query) return true;
+  return (
+    matchesText(system.name, query) || matchesText(system.description, query)
+  );
+}
+
+/** Does a system pass the tag filter? */
+export function matchesTag(system: System, tag: string | null): boolean {
+  if (!tag) return true;
+  const lower = tag.toLowerCase();
+  return systemTags(system).some((t) => t.toLowerCase() === lower);
+}
+
+/** Does a group's own name match the search query? (`Group` has no description.) */
+function groupMatchesQuery(group: Group, query: string): boolean {
+  if (!query) return true;
+  return matchesText(group.name, query);
+}
+
+/**
+ * Build the grouped, filtered browse model.
+ *
+ * - Groups partition systems by membership; a system in N groups appears under
+ *   each (matches the management many-to-many model). A synthetic "Ungrouped"
+ *   section collects systems in no group.
+ * - The `group` filter narrows to a single group section (the synthetic
+ *   ungrouped section is selectable via `UNGROUPED_ID`).
+ * - Search + tag + health filters compose (AND) and apply per-system. The health
+ *   filter reads the reported `statuses` map (Phase 4); when the slot is unfilled
+ *   every system is `"unknown"`.
+ * - A query causes groups with zero surviving members to drop out entirely,
+ *   and forces matching groups open (search auto-expand) unless the URL state
+ *   explicitly forced them closed.
+ * - Default-open policy (no query): all-healthy groups (derived from the status
+ *   DATA, not badges) start collapsed so attention goes to what needs it; any
+ *   group with a non-healthy or unknown member starts expanded. With no health
+ *   data at all (slot unfilled) every group starts expanded. The URL `open` state
+ *   always overrides the computed default.
+ */
+export function buildBrowseModel({
+  systems,
+  groups,
+  state,
+  statuses,
+}: {
+  systems: System[];
+  groups: Group[];
+  state: BrowseState;
+  /**
+   * Per-system health from the `CatalogBrowseHealthSlot` filler, or undefined
+   * when no health source is installed (group rollups show counts only and the
+   * health filter resolves everything to `"unknown"`).
+   */
+  statuses?: CatalogHealthStatuses;
+}): BrowseModel {
+  const isEmptyCatalog = systems.length === 0 && groups.length === 0;
+
+  const passesSystemFilters = (system: System): boolean =>
+    matchesQuery(system, state.query) &&
+    matchesTag(system, state.tag) &&
+    matchesHealth({ systemId: system.id, health: state.health, statuses });
+
+  const systemById = new Map<string, System>();
+  for (const system of systems) systemById.set(system.id, system);
+
+  const hasQuery = state.query.trim().length > 0;
+
+  const resolveOpen = ({
+    id,
+    hasMatch,
+    allHealthy,
+  }: {
+    id: string;
+    hasMatch: boolean;
+    allHealthy: boolean;
+  }): boolean => {
+    const override = state.open[id];
+    if (override !== undefined) return override;
+    // Search auto-expands any group with a surviving match.
+    if (hasQuery && hasMatch) return true;
+    // Default policy: all-healthy groups (derived from health DATA) start
+    // collapsed so attention goes to what needs it; everything else (degraded,
+    // unhealthy, unknown, or no health data) starts expanded.
+    return !allHealthy;
+  };
+
+  const sections: GroupSection[] = [];
+
+  // Real group sections.
+  const groupedSystemIds = new Set<string>();
+  for (const group of groups) {
+    const memberIds = group.systemIds ?? [];
+    for (const id of memberIds) groupedSystemIds.add(id);
+
+    // A group filter hides every other group section.
+    if (state.group && state.group !== group.id) continue;
+
+    const members = memberIds
+      .map((id) => systemById.get(id))
+      .filter((s): s is System => s !== undefined);
+
+    const filtered = members.filter((s) => passesSystemFilters(s));
+
+    // Under an active query, drop groups with no surviving member.
+    if (hasQuery && filtered.length === 0) continue;
+
+    // Rollup is over ALL members (pre-filter), from the status DATA.
+    const rollup = computeGroupRollup({
+      memberIds: members.map((s) => s.id),
+      statuses,
+    });
+
+    sections.push({
+      id: group.id,
+      name: group.name,
+      isUngrouped: false,
+      systems: filtered,
+      totalCount: members.length,
+      open: resolveOpen({
+        id: group.id,
+        hasMatch: filtered.length > 0,
+        allHealthy: rollup.allHealthy,
+      }),
+      rollup,
+    });
+  }
+
+  // Synthetic Ungrouped section: systems belonging to no group.
+  const showUngrouped = !state.group || state.group === UNGROUPED_ID;
+  if (showUngrouped) {
+    const ungroupedMembers = systems.filter((s) => !groupedSystemIds.has(s.id));
+    const filtered = ungroupedMembers.filter((s) => passesSystemFilters(s));
+    const include = ungroupedMembers.length > 0 && !(hasQuery && filtered.length === 0);
+    if (include) {
+      const rollup = computeGroupRollup({
+        memberIds: ungroupedMembers.map((s) => s.id),
+        statuses,
+      });
+      sections.push({
+        id: UNGROUPED_ID,
+        name: "Ungrouped",
+        isUngrouped: true,
+        systems: filtered,
+        totalCount: ungroupedMembers.length,
+        open: resolveOpen({
+          id: UNGROUPED_ID,
+          hasMatch: filtered.length > 0,
+          allHealthy: rollup.allHealthy,
+        }),
+        rollup,
+      });
+    }
+  }
+
+  const hasAnyFilter =
+    hasQuery || state.tag !== null || state.group !== null || state.health !== "all";
+  const isFilteredEmpty =
+    !isEmptyCatalog &&
+    hasAnyFilter &&
+    sections.every((section) => section.systems.length === 0);
+
+  return {
+    sections,
+    isFilteredEmpty,
+    isEmptyCatalog,
+    density: state.density,
+  };
+}
+
+/** The filtered flat lists the management page renders. */
+export interface ManagementListsModel {
+  /** Systems surviving the search/tag/group/health filters, in input order. */
+  systems: System[];
+  /** Groups surviving the search/group filters, in input order. */
+  groups: Group[];
+  /** `true` when the catalog has no systems and no groups at all. */
+  isEmptyCatalog: boolean;
+}
+
+/**
+ * Filter the management page's two flat lists (systems + groups) using the SAME
+ * search/tag/group/health state and the SAME per-system matchers as the browse
+ * model — so browse and manage share one filter implementation (plan §2.2). The
+ * management page renders flat draggable/droppable lists rather than collapsible
+ * sections, so this returns plain arrays instead of a `BrowseModel`.
+ *
+ * Semantics:
+ * - **Systems**: pass query+tag, and (no group filter) OR belong to the selected
+ *   group (or are ungrouped when the synthetic `UNGROUPED_ID` is selected).
+ * - **Groups**: pass the group filter (id match, or none / `UNGROUPED_ID` shows
+ *   no real group), and under an active query are kept when the group name
+ *   matches OR the group contains a system that matches query+tag+health.
+ * - The health filter reads the reported `statuses` map (Phase 4); when the slot
+ *   is unfilled every system is `"unknown"` and only `"all"` matches anything.
+ */
+export function filterManagementLists({
+  systems,
+  groups,
+  state,
+  statuses,
+}: {
+  systems: System[];
+  groups: Group[];
+  state: BrowseState;
+  /** Per-system health from the slot filler, or undefined when unfilled. */
+  statuses?: CatalogHealthStatuses;
+}): ManagementListsModel {
+  const isEmptyCatalog = systems.length === 0 && groups.length === 0;
+  const hasQuery = state.query.trim().length > 0;
+
+  const passesSystemFilters = (system: System): boolean =>
+    matchesQuery(system, state.query) &&
+    matchesTag(system, state.tag) &&
+    matchesHealth({ systemId: system.id, health: state.health, statuses });
+
+  // Map each group id to the set of member ids for membership checks.
+  const groupById = new Map<string, Group>();
+  for (const group of groups) groupById.set(group.id, group);
+
+  const groupedSystemIds = new Set<string>();
+  for (const group of groups) {
+    for (const id of group.systemIds ?? []) groupedSystemIds.add(id);
+  }
+
+  const inSelectedGroup = (system: System): boolean => {
+    if (!state.group) return true;
+    if (state.group === UNGROUPED_ID) return !groupedSystemIds.has(system.id);
+    return (groupById.get(state.group)?.systemIds ?? []).includes(system.id);
+  };
+
+  const filteredSystems = systems.filter(
+    (system) => passesSystemFilters(system) && inSelectedGroup(system),
+  );
+
+  const groupContainsMatch = (group: Group): boolean =>
+    (group.systemIds ?? [])
+      .map((id) => systems.find((s) => s.id === id))
+      .filter((s): s is System => s !== undefined)
+      .some((s) => passesSystemFilters(s));
+
+  const filteredGroups = groups.filter((group) => {
+    // The synthetic "Ungrouped" selection hides every real group.
+    if (state.group === UNGROUPED_ID) return false;
+    if (state.group && state.group !== group.id) return false;
+    if (!hasQuery) return true;
+    return groupMatchesQuery(group, state.query) || groupContainsMatch(group);
+  });
+
+  return {
+    systems: filteredSystems,
+    groups: filteredGroups,
+    isEmptyCatalog,
+  };
+}

package/src/components/browse/healthRollup.logic.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, test } from "bun:test";
+import type { CatalogHealthStatuses } from "@checkstack/catalog-common";
+import {
+  computeGroupRollup,
+  matchesHealth,
+  resolveSystemHealth,
+} from "./healthRollup.logic";
+
+describe("resolveSystemHealth", () => {
+  test("returns the reported status", () => {
+    const statuses: CatalogHealthStatuses = { a: "degraded" };
+    expect(resolveSystemHealth({ systemId: "a", statuses })).toBe("degraded");
+  });
+
+  test("absent system is 'unknown', never healthy", () => {
+    expect(resolveSystemHealth({ systemId: "x", statuses: {} })).toBe("unknown");
+    expect(
+      resolveSystemHealth({ systemId: "x", statuses: undefined }),
+    ).toBe("unknown");
+  });
+});
+
+describe("computeGroupRollup", () => {
+  test("all members healthy → allHealthy, derived from data not badges", () => {
+    const statuses: CatalogHealthStatuses = { a: "healthy", b: "healthy" };
+    const rollup = computeGroupRollup({ memberIds: ["a", "b"], statuses });
+    expect(rollup.allHealthy).toBe(true);
+    expect(rollup.hasData).toBe(true);
+    expect(rollup.worst).toBe("healthy");
+    expect(rollup.degraded).toBe(0);
+    expect(rollup.unhealthy).toBe(0);
+  });
+
+  test("one degraded → warning rollup with count, not allHealthy", () => {
+    const statuses: CatalogHealthStatuses = { a: "healthy", b: "degraded" };
+    const rollup = computeGroupRollup({ memberIds: ["a", "b"], statuses });
+    expect(rollup.allHealthy).toBe(false);
+    expect(rollup.worst).toBe("degraded");
+    expect(rollup.degraded).toBe(1);
+    expect(rollup.unhealthy).toBe(0);
+  });
+
+  test("unhealthy outranks degraded for worst-of", () => {
+    const statuses: CatalogHealthStatuses = {
+      a: "degraded",
+      b: "unhealthy",
+      c: "degraded",
+    };
+    const rollup = computeGroupRollup({
+      memberIds: ["a", "b", "c"],
+      statuses,
+    });
+    expect(rollup.worst).toBe("unhealthy");
+    expect(rollup.unhealthy).toBe(1);
+    expect(rollup.degraded).toBe(2);
+  });
+
+  test("no data at all → hasData false, worst unknown, not allHealthy", () => {
+    const rollup = computeGroupRollup({
+      memberIds: ["a", "b"],
+      statuses: undefined,
+    });
+    expect(rollup.hasData).toBe(false);
+    expect(rollup.worst).toBe("unknown");
+    expect(rollup.allHealthy).toBe(false);
+  });
+
+  test("mixed healthy + unknown is NOT allHealthy (absence ≠ healthy)", () => {
+    const statuses: CatalogHealthStatuses = { a: "healthy" };
+    const rollup = computeGroupRollup({ memberIds: ["a", "b"], statuses });
+    expect(rollup.allHealthy).toBe(false);
+    expect(rollup.hasData).toBe(true);
+    // No degraded/unhealthy, but b is unknown → worst is healthy (a), unknown
+    // ranks below healthy.
+    expect(rollup.worst).toBe("healthy");
+  });
+
+  test("empty group is not allHealthy", () => {
+    const rollup = computeGroupRollup({ memberIds: [], statuses: {} });
+    expect(rollup.allHealthy).toBe(false);
+    expect(rollup.hasData).toBe(false);
+  });
+});
+
+describe("matchesHealth", () => {
+  const statuses: CatalogHealthStatuses = {
+    h: "healthy",
+    d: "degraded",
+    u: "unhealthy",
+  };
+
+  test("'all' matches everything", () => {
+    for (const id of ["h", "d", "u", "missing"]) {
+      expect(matchesHealth({ systemId: id, health: "all", statuses })).toBe(
+        true,
+      );
+    }
+  });
+
+  test("'degraded' hides healthy rows, keeps degraded", () => {
+    expect(matchesHealth({ systemId: "d", health: "degraded", statuses })).toBe(
+      true,
+    );
+    expect(matchesHealth({ systemId: "h", health: "degraded", statuses })).toBe(
+      false,
+    );
+  });
+
+  test("'unknown' matches only no-data systems", () => {
+    expect(
+      matchesHealth({ systemId: "missing", health: "unknown", statuses }),
+    ).toBe(true);
+    expect(matchesHealth({ systemId: "h", health: "unknown", statuses })).toBe(
+      false,
+    );
+  });
+
+  test("non-'all' filter with undefined statuses → everything unknown", () => {
+    expect(
+      matchesHealth({ systemId: "h", health: "healthy", statuses: undefined }),
+    ).toBe(false);
+    expect(
+      matchesHealth({ systemId: "h", health: "unknown", statuses: undefined }),
+    ).toBe(true);
+  });
+});

package/src/components/browse/healthRollup.logic.ts

@@ -0,0 +1,120 @@
+import type {
+  CatalogHealthStatus,
+  CatalogHealthStatuses,
+} from "@checkstack/catalog-common";
+import type { HealthFilter } from "./browseState.logic";
+
+/**
+ * Pure, DOM-free health-rollup logic for the catalog browse view.
+ *
+ * The group rollup and the health filter are BOTH derived from the per-system
+ * status DATA the `CatalogBrowseHealthSlot` filler reports (a
+ * `CatalogHealthStatuses` map) — NEVER from rendered badge output. This matters
+ * because a healthy system emits no badge (see `SystemHealthBadge`), so the only
+ * way to know a group is "all healthy" is to read every member's reported status
+ * from the data path. A system absent from the map is `"unknown"`, never healthy.
+ */
+
+/** The resolved rollup for one group section's header. */
+export interface GroupHealthRollup {
+  /** Worst status among members, or `"unknown"` when no member has data. */
+  worst: CatalogHealthStatus | "unknown";
+  /** Count of degraded members. */
+  degraded: number;
+  /** Count of unhealthy members. */
+  unhealthy: number;
+  /** `true` when every member reported `"healthy"` (derived from data, not badges). */
+  allHealthy: boolean;
+  /**
+   * `true` when at least one member has a reported status. When `false` the
+   * group header shows counts only (no health source / unfilled slot).
+   */
+  hasData: boolean;
+}
+
+/** Severity ranking: higher = worse. `unknown` ranks below `healthy` (no signal). */
+const SEVERITY: Record<CatalogHealthStatus | "unknown", number> = {
+  unknown: 0,
+  healthy: 1,
+  degraded: 2,
+  unhealthy: 3,
+};
+
+/**
+ * Resolve a single system's effective health from the reported map. A system the
+ * filler did not report is `"unknown"` (NOT healthy).
+ */
+export function resolveSystemHealth({
+  systemId,
+  statuses,
+}: {
+  systemId: string;
+  statuses: CatalogHealthStatuses | undefined;
+}): CatalogHealthStatus | "unknown" {
+  return statuses?.[systemId] ?? "unknown";
+}
+
+/**
+ * Compute the rollup for a group from its member ids and the reported statuses.
+ *
+ * - `worst` is the worst member status by severity (unhealthy > degraded >
+ *   healthy > unknown). When no member has data, `worst` is `"unknown"`.
+ * - `allHealthy` is true only when there is at least one member, every member has
+ *   a reported status, and every reported status is `"healthy"`. Derived purely
+ *   from the data map.
+ */
+export function computeGroupRollup({
+  memberIds,
+  statuses,
+}: {
+  memberIds: string[];
+  statuses: CatalogHealthStatuses | undefined;
+}): GroupHealthRollup {
+  let degraded = 0;
+  let unhealthy = 0;
+  let worst: CatalogHealthStatus | "unknown" = "unknown";
+  let reportedCount = 0;
+  let healthyCount = 0;
+
+  for (const id of memberIds) {
+    const status = resolveSystemHealth({ systemId: id, statuses });
+    if (status !== "unknown") reportedCount += 1;
+    if (status === "healthy") healthyCount += 1;
+    if (status === "degraded") degraded += 1;
+    if (status === "unhealthy") unhealthy += 1;
+    if (SEVERITY[status] > SEVERITY[worst]) worst = status;
+  }
+
+  const hasData = reportedCount > 0;
+  const allHealthy =
+    memberIds.length > 0 &&
+    reportedCount === memberIds.length &&
+    healthyCount === memberIds.length;
+
+  return { worst, degraded, unhealthy, allHealthy, hasData };
+}
+
+/**
+ * Does a system pass the health filter? Derived from the reported status map.
+ *
+ * - `"all"` matches everything.
+ * - `"healthy" | "degraded" | "unhealthy"` match the system's reported status.
+ * - `"unknown"` matches systems with no reported status (no health source / no
+ *   checks wired) — so an absent entry is `"unknown"`, never silently healthy.
+ *
+ * When `statuses` is undefined entirely (slot unfilled), every system resolves to
+ * `"unknown"`; the page disables the filter in that case, but the predicate still
+ * behaves correctly if a non-`all` value lingers in the URL.
+ */
+export function matchesHealth({
+  systemId,
+  health,
+  statuses,
+}: {
+  systemId: string;
+  health: HealthFilter;
+  statuses: CatalogHealthStatuses | undefined;
+}): boolean {
+  if (health === "all") return true;
+  return resolveSystemHealth({ systemId, statuses }) === health;
+}

package/src/components/browse/healthStatuses.logic.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from "bun:test";
+import type { CatalogHealthStatuses } from "@checkstack/catalog-common";
+import { healthStatusesEqual } from "./healthStatuses.logic";
+
+describe("healthStatusesEqual", () => {
+  test("first report (prev null) is always a change", () => {
+    expect(healthStatusesEqual(null, {})).toBe(false);
+    expect(healthStatusesEqual(null, { a: "healthy" })).toBe(false);
+  });
+
+  test("same values in same shape are equal (ignores object identity)", () => {
+    const prev: CatalogHealthStatuses = { a: "healthy", b: "degraded" };
+    const next: CatalogHealthStatuses = { a: "healthy", b: "degraded" };
+    expect(prev).not.toBe(next);
+    expect(healthStatusesEqual(prev, next)).toBe(true);
+  });
+
+  test("two empty maps are equal", () => {
+    expect(healthStatusesEqual({}, {})).toBe(true);
+  });
+
+  test("a changed status value is not equal", () => {
+    expect(
+      healthStatusesEqual({ a: "healthy" }, { a: "unhealthy" }),
+    ).toBe(false);
+  });
+
+  test("an added system is not equal", () => {
+    expect(
+      healthStatusesEqual({ a: "healthy" }, { a: "healthy", b: "healthy" }),
+    ).toBe(false);
+  });
+
+  test("a removed system is not equal", () => {
+    expect(
+      healthStatusesEqual({ a: "healthy", b: "healthy" }, { a: "healthy" }),
+    ).toBe(false);
+  });
+});

package/src/components/browse/healthStatuses.logic.ts

@@ -0,0 +1,29 @@
+import type { CatalogHealthStatuses } from "@checkstack/catalog-common";
+
+/**
+ * Value-equality for two {@link CatalogHealthStatuses} maps.
+ *
+ * The browse health filler (e.g. healthcheck-frontend) re-reports a freshly
+ * built statuses object on every render/poll - a new object identity even when
+ * the per-system values are unchanged. If the browse page stored every report,
+ * the derived browse model (and therefore every system row) would re-render and
+ * remount continuously, making the list impossible to interact with. The page
+ * uses this comparison to ignore no-op reports and keep a stable state object.
+ *
+ * `prev` is `null` until the first report; a first report (even an empty map,
+ * meaning "a health source is installed but nothing to report") is always a
+ * real change.
+ */
+export function healthStatusesEqual(
+  prev: CatalogHealthStatuses | null,
+  next: CatalogHealthStatuses,
+): boolean {
+  if (prev === null) return false;
+  const prevKeys = Object.keys(prev);
+  const nextKeys = Object.keys(next);
+  if (prevKeys.length !== nextKeys.length) return false;
+  for (const key of prevKeys) {
+    if (prev[key] !== next[key]) return false;
+  }
+  return true;
+}