@skyhook-io/k8s-ui 1.13.3 → 1.13.4

package/src/components/resources/printer-columns.test.ts

@@ -0,0 +1,298 @@
+import { describe, expect, it } from 'vitest'
+import {
+  formatPrinterCell,
+  printerTableMatchesKind,
+  parseHumanDuration,
+  printerCellSortValue,
+  printerCellTone,
+  printerColumnKey,
+  printerTableKey,
+  readPrinterCell,
+  sanitizePrinterTable,
+} from './printer-columns'
+
+describe('sanitizePrinterTable', () => {
+  it('keeps a well-formed table and defaults priority to 0', () => {
+    const t = sanitizePrinterTable({
+      columns: [{ name: 'Phase', type: 'string' }, { name: 'Replicas', type: 'integer', priority: 1 }],
+      cells: { a: ['Running', 3] },
+    })
+    expect(t?.columns).toEqual([
+      { name: 'Phase', type: 'string', format: undefined, description: undefined, priority: 0 },
+      { name: 'Replicas', type: 'integer', format: undefined, description: undefined, priority: 1 },
+    ])
+    expect(t?.cells.a).toEqual(['Running', 3])
+  })
+
+  it.each([
+    ['null', null],
+    ['no columns key', { cells: {} }],
+    ['empty columns', { columns: [], cells: {} }],
+    ['columns that are not an array', { columns: 'Phase' }],
+    ['every column malformed', { columns: [{ type: 'string' }, null, { name: '  ' }] }],
+  ])('returns null for %s', (_label, raw) => {
+    expect(sanitizePrinterTable(raw)).toBeNull()
+  })
+
+  // A dropped duplicate must take its cell with it, or every later value
+  // renders one column to the left.
+  it('realigns cells when a column is dropped', () => {
+    const t = sanitizePrinterTable({
+      columns: [{ name: 'Phase' }, { name: 'Phase' }, { name: 'Host' }],
+      cells: { a: ['Running', 'dup', 'example.com'] },
+    })
+    expect(t?.columns.map(c => c.name)).toEqual(['Phase', 'Host'])
+    expect(t?.cells.a).toEqual(['Running', 'example.com'])
+  })
+
+  it('ignores rows that are not arrays', () => {
+    const t = sanitizePrinterTable({ columns: [{ name: 'A' }, { name: 'B' }], cells: { a: 'nope', b: ['1', '2'] } })
+    expect(t?.cells).toEqual({ b: ['1', '2'] })
+  })
+
+  it('tolerates a missing cells map', () => {
+    expect(sanitizePrinterTable({ columns: [{ name: 'A' }] })?.cells).toEqual({})
+  })
+})
+
+describe('printerTableKey', () => {
+  it('is stable across refetches and changes with the column set', () => {
+    const a = { columns: [{ name: 'Phase' }, { name: 'Host' }], cells: {} }
+    const b = { columns: [{ name: 'Phase' }, { name: 'Host' }], cells: { x: ['1'] } }
+    expect(printerTableKey(a)).toBe(printerTableKey(b))
+    expect(printerTableKey(a)).not.toBe(printerTableKey({ columns: [{ name: 'Phase' }], cells: {} }))
+  })
+
+  it('is empty when there is no table', () => {
+    expect(printerTableKey(null)).toBe('')
+    expect(printerTableKey({ columns: [], cells: {} })).toBe('')
+  })
+})
+
+describe('printerColumnKey', () => {
+  // Built-in keys never carry a prefix and custom columns use label:/annotation:,
+  // so this namespace cannot collide with either.
+  it('namespaces the key', () => {
+    expect(printerColumnKey({ name: 'Status' })).toBe('printer:Status')
+    expect(printerColumnKey({ name: 'Status' })).not.toBe('status')
+  })
+})
+
+describe('readPrinterCell', () => {
+  const table = { columns: [{ name: 'A' }, { name: 'B' }], cells: { u1: ['x', 2] } }
+  it('reads by uid and index', () => {
+    expect(readPrinterCell(table, 'u1', 0)).toBe('x')
+    expect(readPrinterCell(table, 'u1', 1)).toBe(2)
+  })
+  it('is undefined for an unknown uid, a missing uid, or an out-of-range index', () => {
+    expect(readPrinterCell(table, 'nope', 0)).toBeUndefined()
+    expect(readPrinterCell(table, undefined, 0)).toBeUndefined()
+    expect(readPrinterCell(table, 'u1', 9)).toBeUndefined()
+  })
+})
+
+describe('formatPrinterCell', () => {
+  it.each([
+    ['string', 'Running', 'Running'],
+    ['zero', 0, '0'],
+    ['number', 3, '3'],
+    ['true', true, 'True'],
+    ['false', false, 'False'],
+    ['null', null, ''],
+    ['undefined', undefined, ''],
+    // The apiserver leaves an unresolvable path null, but a `type` mismatch can
+    // still hand back a structure. Rendering "[object Object]" would be worse
+    // than rendering nothing.
+    ['object', { a: 1 }, ''],
+    ['array', [1, 2], ''],
+  ])('renders %s', (_label, value, want) => {
+    expect(formatPrinterCell(value)).toBe(want)
+  })
+})
+
+describe('printerCellSortValue', () => {
+  // Sorting must use the value, not its rendered text, or 10 sorts before 9.
+  it('sorts numbers numerically', () => {
+    expect([10, 9, 100].map(printerCellSortValue).sort((a, b) => (a as number) - (b as number)))
+      .toEqual([9, 10, 100])
+  })
+  it('sorts booleans by truth and falls back to empty for anything else', () => {
+    expect(printerCellSortValue(true)).toBe(1)
+    expect(printerCellSortValue(false)).toBe(0)
+    expect(printerCellSortValue({ a: 1 })).toBe('')
+    expect(printerCellSortValue(null)).toBe('')
+  })
+})
+
+describe('printerTableMatchesKind', () => {
+  const table = { kind: 'widgets', group: 'example.com', columns: [{ name: 'A' }], cells: {} }
+
+  it('matches its own kind and group', () => {
+    expect(printerTableMatchesKind(table, 'widgets', 'example.com')).toBe(true)
+  })
+
+  // The selected kind changes before the new list resolves, so an unchecked
+  // table can briefly be the PREVIOUS kind's — which the visibility effect
+  // would then persist under the new kind's storage key.
+  it('rejects a table belonging to another kind or another group', () => {
+    expect(printerTableMatchesKind(table, 'gadgets', 'example.com')).toBe(false)
+    expect(printerTableMatchesKind(table, 'widgets', 'other.io')).toBe(false)
+    expect(printerTableMatchesKind(table, 'widgets', undefined)).toBe(false)
+  })
+
+  it('rejects a table with no identity rather than pairing it blindly', () => {
+    expect(printerTableMatchesKind({ columns: [{ name: 'A' }], cells: {} }, 'widgets', 'example.com')).toBe(false)
+    expect(printerTableMatchesKind(null, 'widgets', 'example.com')).toBe(false)
+  })
+
+  it('treats an absent group and an empty group as the same', () => {
+    const noGroup = { kind: 'widgets', columns: [{ name: 'A' }], cells: {} }
+    expect(printerTableMatchesKind(noGroup, 'widgets', '')).toBe(true)
+    expect(printerTableMatchesKind(noGroup, 'widgets', undefined)).toBe(true)
+  })
+})
+
+describe('sanitizePrinterTable identity', () => {
+  it('carries kind and group through', () => {
+    const t = sanitizePrinterTable({ kind: 'widgets', group: 'example.com', columns: [{ name: 'A' }], cells: {} })
+    expect(t).toMatchObject({ kind: 'widgets', group: 'example.com' })
+  })
+
+  it('leaves them undefined when the server sent none', () => {
+    const t = sanitizePrinterTable({ columns: [{ name: 'A' }], cells: {} })
+    expect(t?.kind).toBeUndefined()
+    expect(t?.group).toBeUndefined()
+  })
+})
+
+describe('date sorting', () => {
+  // The table converter hands back humanized ages, so sorting them as text puts
+  // "10m" before "2m".
+  it.each([['5s', 5], ['2m', 120], ['3h', 10800], ['4d', 345600], ['1y', 31536000], ['2d3h', 183600], ['1y64d', 37065600]])(
+    'parses %s', (text, want) => expect(parseHumanDuration(text)).toBe(want))
+
+  it.each([['', null], ['   ', null], ['abc', null], ['5', null], ['5x', null], ['-3m', null], ['<invalid>', null]])(
+    'rejects %s', (text, want) => expect(parseHumanDuration(text)).toBe(want))
+
+  it('orders date cells oldest-first ascending, like the Age column', () => {
+    const def = { name: 'Last Refresh', type: 'date' }
+    const sorted = ['10m', '2m', '1h', '30s']
+      .map(v => ({ v, k: printerCellSortValue(v, def) as number }))
+      .sort((a, b) => a.k - b.k)
+      .map(x => x.v)
+    expect(sorted).toEqual(['1h', '10m', '2m', '30s'])
+  })
+
+  it('leaves a date column that is not a duration sorting as text', () => {
+    expect(printerCellSortValue('<invalid>', { name: 'D', type: 'date' })).toBe('<invalid>')
+  })
+
+  it('does not reinterpret duration-looking values in non-date columns', () => {
+    expect(printerCellSortValue('10m', { name: 'Size', type: 'string' })).toBe('10m')
+    expect(printerCellSortValue('10m')).toBe('10m')
+  })
+})
+
+describe('printerTableKey priority', () => {
+  // Default visibility is derived from priority, so promoting a column out of
+  // the -o wide tier has to re-run the visibility defaults.
+  it('changes when a column priority changes', () => {
+    const wide = { columns: [{ name: 'A' }, { name: 'B', priority: 1 }], cells: {} }
+    const promoted = { columns: [{ name: 'A' }, { name: 'B', priority: 0 }], cells: {} }
+    expect(printerTableKey(wide)).not.toBe(printerTableKey(promoted))
+  })
+})
+
+describe('printerCellTone', () => {
+  // The one place Radar interprets vendor data rather than passing it through.
+  // Deliberately narrow: the vendor NAMED the column, which is a far stronger
+  // signal than inferring health from a value.
+  it.each([
+    ['Ready', true, 'healthy'],
+    ['Ready', false, 'unhealthy'],
+    ['Healthy', 'True', 'healthy'],
+    ['Healthy', 'False', 'unhealthy'],
+    ['Established', 'true', 'healthy'],
+    ['Installed', 'True', 'healthy'],
+    ['Provided', 'True', 'healthy'],
+    ['ReadyToUse', 'False', 'unhealthy'],
+    ['Synced', 'True', 'healthy'],
+  ])('%s=%s tones as %s', (name, value, want) => {
+    expect(printerCellTone({ name }, value)).toBe(want)
+  })
+
+  // Names whose polarity is inverted must not be read as positive.
+  it.each([
+    ['Degraded', 'False', 'healthy'],
+    ['Denied', 'False', 'healthy'],
+  ])('%s=%s tones as %s', (name, value, want) => {
+    expect(printerCellTone({ name }, value)).toBe(want)
+  })
+
+  // A controller that could not evaluate a field it owns has not reported a
+  // failure — but only for a column we have a claim to speak about.
+  it('reports Unknown without calling it a failure, on named columns', () => {
+    expect(printerCellTone({ name: 'Ready' }, 'Unknown')).toBe('unknown')
+    expect(printerCellTone({ name: 'Degraded' }, 'Unknown')).toBe('unknown')
+  })
+
+  // The name decides whether we speak at all. Checking the value first badged
+  // `Mode: Unknown` on a column whose polarity we have no claim to.
+  it('stays silent on an unnamed column even when the value is Unknown', () => {
+    expect(printerCellTone({ name: 'Mode' }, 'Unknown')).toBeNull()
+    expect(printerCellTone({ name: 'Strategy' }, 'Unknown')).toBeNull()
+    expect(printerCellTone({ name: 'Whatever' }, 'Unknown')).toBeNull()
+  })
+
+  // The same condition must not change severity depending on whether it
+  // arrived through the generic Status column or a printer column.
+  it('tones a degraded name amber, matching the generic ladder', () => {
+    expect(printerCellTone({ name: 'Degraded' }, 'True')).toBe('degraded')
+    expect(printerCellTone({ name: 'Warning' }, 'True')).toBe('degraded')
+    expect(printerCellTone({ name: 'ScalingLimited' }, 'True')).toBe('degraded')
+  })
+
+  it('reserves red for genuinely terminal names', () => {
+    expect(printerCellTone({ name: 'Denied' }, 'True')).toBe('unhealthy')
+    expect(printerCellTone({ name: 'Failed' }, 'True')).toBe('unhealthy')
+  })
+
+  it('renders plain text for a column whose polarity we do not know', () => {
+    expect(printerCellTone({ name: 'Mode' }, 'True')).toBeNull()
+    expect(printerCellTone({ name: 'Strategy' }, false)).toBeNull()
+  })
+
+  // A named column holding something other than a truth value is not a badge —
+  // "Ready: 3/5" is a count, not a state.
+  it.each([
+    ['Ready', '3/5'],
+    ['Ready', 'Active'],
+    ['Healthy', 5],
+    ['Ready', null],
+    ['Ready', { a: 1 }],
+  ])('renders %s=%s as plain text', (name, value) => {
+    expect(printerCellTone({ name }, value)).toBeNull()
+  })
+
+  it('matches the column name case-insensitively and ignores padding', () => {
+    expect(printerCellTone({ name: '  READY  ' }, 'true')).toBe('healthy')
+  })
+})
+
+describe('printerTableKey collision safety', () => {
+  // Column names are vendor text and really do contain spaces ("VERIFY IMAGES",
+  // "FAILURE POLICY"). A separator-joined key let two different column sets
+  // produce one string, so the visibility effect would miss a real change.
+  it('distinguishes sets that a separator-joined key would merge', () => {
+    const a = printerTableKey({ columns: [{ name: 'A' }, { name: 'B' }, { name: 'C' }], cells: {} })
+    const b = printerTableKey({ columns: [{ name: 'A:0 B' }, { name: 'C' }], cells: {} })
+    expect(a).not.toBe(b)
+  })
+
+  it('still changes when only a priority changes', () => {
+    const before = printerTableKey({ columns: [{ name: 'Phase', priority: 1 }], cells: {} })
+    const after = printerTableKey({ columns: [{ name: 'Phase', priority: 0 }], cells: {} })
+    expect(before).not.toBe(after)
+  })
+})
+

package/src/components/resources/printer-columns.ts

@@ -0,0 +1,249 @@
+import type { HealthLevel } from './resource-utils'
+import { KNOWN_NEGATIVE_CONDITIONS, KNOWN_POSITIVE_CONDITIONS } from './generic-status'
+
+// Vendor-declared table columns from a CRD's additionalPrinterColumns,
+// evaluated server-side (see internal/server/printer_columns.go) and shipped
+// with the list response. The pure parts live here so they're unit-tested;
+// the JSX render is materialized in ResourcesView.
+
+/** One column definition, as the CRD declared it. */
+export interface PrinterColumnDef {
+  name: string
+  type?: string
+  format?: string
+  /** The vendor's own text. Absent for most CRDs, which declare none. */
+  description?: string
+  /** kubectl's `-o wide` tier. Declared, but not shown by default. */
+  priority?: number
+}
+
+export interface PrinterTable {
+  /** The kind these columns describe, echoed by the server. */
+  kind?: string
+  group?: string
+  columns: PrinterColumnDef[]
+  /** metadata.uid -> one value per entry in `columns`, same order. */
+  cells: Record<string, unknown[]>
+}
+
+/**
+ * Stable identity for a column set. Printer columns are fixed per CRD version,
+ * so this string only changes when the kind changes or an operator is upgraded
+ * mid-session — which is exactly when the visibility defaults should be
+ * recomputed, and never on an ordinary refetch.
+ */
+export function printerTableKey(table: PrinterTable | null | undefined): string {
+  if (!table?.columns?.length) return ''
+  // Priority is part of the identity, not just the name: default visibility is
+  // derived from it, so an operator upgrade that promotes a column out of the
+  // `-o wide` tier has to re-run the visibility defaults. Serialized rather
+  // than concatenated because column names are vendor text that can contain
+  // the separators — real ones already carry spaces ("VERIFY IMAGES").
+  return JSON.stringify(table.columns.map(c => [c.name, c.priority ?? 0]))
+}
+
+/**
+ * Column key. Prefixed so it can never collide with a built-in column key or
+ * with a user-defined `label:`/`annotation:` custom column. Build-only — never
+ * parsed back into a name.
+ */
+export const PRINTER_COLUMN_PREFIX = 'printer:'
+
+export function printerColumnKey(def: PrinterColumnDef): string {
+  return `${PRINTER_COLUMN_PREFIX}${def.name}`
+}
+
+/**
+ * Drops anything malformed. The server owns this shape, but it crosses the
+ * wire, and a bad entry would otherwise produce a dead column or crash a map.
+ */
+export function sanitizePrinterTable(raw: any): PrinterTable | null {
+  if (!raw || !Array.isArray(raw.columns) || raw.columns.length === 0) return null
+  const seen = new Set<string>()
+  const columns: PrinterColumnDef[] = []
+  const keptIdx: number[] = []
+  raw.columns.forEach((c: any, i: number) => {
+    if (!c || typeof c.name !== 'string') return
+    const name = c.name.trim()
+    if (!name || seen.has(name)) return
+    seen.add(name)
+    columns.push({
+      name,
+      type: typeof c.type === 'string' ? c.type : undefined,
+      format: typeof c.format === 'string' ? c.format : undefined,
+      description: typeof c.description === 'string' ? c.description : undefined,
+      priority: typeof c.priority === 'number' ? c.priority : 0,
+    })
+    keptIdx.push(i)
+  })
+  if (!columns.length) return null
+
+  const cells: Record<string, unknown[]> = {}
+  const rawCells = raw.cells && typeof raw.cells === 'object' ? raw.cells : {}
+  for (const uid of Object.keys(rawCells)) {
+    const row = rawCells[uid]
+    if (!Array.isArray(row)) continue
+    // Realign to the surviving columns, or a dropped duplicate would shift
+    // every later value into the wrong column.
+    cells[uid] = keptIdx.map(i => row[i])
+  }
+  return {
+    kind: typeof raw.kind === 'string' ? raw.kind : undefined,
+    group: typeof raw.group === 'string' ? raw.group : undefined,
+    columns,
+    cells,
+  }
+}
+
+/**
+ * Whether a table describes the kind currently selected. The selected kind
+ * changes before the new list resolves, so an unchecked table can briefly be
+ * the PREVIOUS kind's — which the column-visibility effect would then persist
+ * under the new kind's storage key.
+ */
+export function printerTableMatchesKind(
+  table: PrinterTable | null | undefined,
+  kind: string,
+  group: string | undefined,
+): boolean {
+  if (!table) return false
+  // A server that sent no identity cannot be paired safely.
+  if (!table.kind) return false
+  // The server echoes the lowercased request path segment, so compare
+  // case-insensitively rather than relying on the caller's plural already
+  // being lowercase — a deep link that discovery could not resolve isn't.
+  return table.kind.toLowerCase() === kind.toLowerCase() && (table.group ?? '') === (group ?? '')
+}
+
+export function readPrinterCell(table: PrinterTable, uid: string | undefined, index: number): unknown {
+  if (!uid) return undefined
+  const row = table.cells[uid]
+  return Array.isArray(row) ? row[index] : undefined
+}
+
+/**
+ * Display text for one cell. Every value is a scalar by the time it gets here:
+ * the table converter humanizes `date` cells to "5m", coerces the numeric
+ * types, and JSON-encodes a `string` column whose path lands on an object or
+ * array — so a badly-aimed JSONPath arrives as a blob like `{"foo":"bar"}`
+ * rather than as structure. Non-scalars can therefore only come from a
+ * malformed response, and those read as absent.
+ */
+export function formatPrinterCell(value: unknown): string {
+  if (value === null || value === undefined) return ''
+  if (typeof value === 'boolean') return value ? 'True' : 'False'
+  if (typeof value === 'number') return String(value)
+  if (typeof value === 'string') return value
+  return ''
+}
+
+/**
+ * Seconds represented by a Kubernetes human-readable duration ("5m", "2d3h",
+ * "1y64d"), or null if it isn't one. The table converter emits these for `date`
+ * columns, and sorting them as text puts "10m" before "2m".
+ */
+const DURATION_UNIT_SECONDS: Record<string, number> = { s: 1, m: 60, h: 3600, d: 86400, y: 31536000 }
+
+export function parseHumanDuration(text: string): number | null {
+  const trimmed = text.trim()
+  if (!trimmed || !/^(\d+[smhdy])+$/.test(trimmed)) return null
+  let total = 0
+  for (const [, amount, unit] of trimmed.matchAll(/(\d+)([smhdy])/g)) {
+    total += Number(amount) * DURATION_UNIT_SECONDS[unit]
+  }
+  return total
+}
+
+/** Sort key. Numbers and booleans sort by value, not by their rendered text. */
+export function printerCellSortValue(value: unknown, def?: PrinterColumnDef): string | number {
+  if (typeof value === 'number') return value
+  if (typeof value === 'boolean') return value ? 1 : 0
+  if (typeof value === 'string') {
+    if (def?.type === 'date') {
+      const seconds = parseHumanDuration(value)
+      // A date cell holds an age, so a bigger number is an OLDER object —
+      // the reverse of the Age column's timestamp. Negating restores the
+      // shared meaning: ascending puts the oldest first in both.
+      if (seconds !== null) return -seconds
+    }
+    return value
+  }
+  return ''
+}
+
+/**
+ * Width class for a column. Printer columns carry no width hint, so this is
+ * derived from the declared type: scalars are narrow, strings need room.
+ */
+export function printerColumnWidth(def: PrinterColumnDef): string {
+  switch (def.type) {
+    case 'integer':
+    case 'number':
+    case 'boolean':
+      return 'w-24'
+    case 'date':
+      return 'w-28'
+    default:
+      return 'w-40'
+  }
+}
+
+/**
+ * Column names whose polarity is a convention rather than a guess. Shared with
+ * the condition sets in generic-status.ts so the two can't drift, plus the
+ * names CRDs actually use for the same idea in a printer column.
+ *
+ * This is the one place Radar interprets vendor data rather than passing it
+ * through. It is deliberately narrow: the vendor NAMED the column, which is a
+ * much stronger signal than inferring health from a value. Anything not on
+ * these lists renders as plain text with no health claim.
+ */
+const POSITIVE_COLUMN_NAMES = new Set(
+  [...KNOWN_POSITIVE_CONDITIONS, 'ReadyToUse', 'Established', 'Installed', 'Provided']
+    .map(n => n.toLowerCase()),
+)
+// Split by severity, not just polarity. generic-status.ts tones a true
+// KNOWN_NEGATIVE_CONDITION as `degraded` (amber); collapsing these to red here
+// would make the same `Degraded=True` amber in the generic Status column and
+// red in a printer column.
+const DEGRADED_COLUMN_NAMES = new Set(KNOWN_NEGATIVE_CONDITIONS.map(n => n.toLowerCase()))
+const TERMINAL_COLUMN_NAMES = new Set(['denied', 'failed'])
+
+/** The three states a boolean-ish printer cell can hold, however it is typed. */
+function truthiness(value: unknown): 'true' | 'false' | 'unknown' | null {
+  if (typeof value === 'boolean') return value ? 'true' : 'false'
+  if (typeof value !== 'string') return null
+  switch (value.trim().toLowerCase()) {
+    case 'true': return 'true'
+    case 'false': return 'false'
+    case 'unknown': return 'unknown'
+    default: return null
+  }
+}
+
+/**
+ * Health tone for a printer cell, or null to render it as plain text.
+ *
+ * Only fires when the column's NAME carries a known polarity and its VALUE is
+ * True/False/Unknown — the shape a condition-derived printer column has. A
+ * column named `Healthy` holding `True` is the vendor telling us this row is
+ * fine; rendering that as grey text throws away the only scannable signal on
+ * the kinds that have no curated Status column.
+ */
+export function printerCellTone(def: PrinterColumnDef, value: unknown): HealthLevel | null {
+  const state = truthiness(value)
+  if (!state) return null
+  // The NAME decides whether we say anything at all — including for Unknown.
+  // Checking the value first would badge `Mode: Unknown` on a column whose
+  // polarity we have no claim to.
+  const name = def.name.trim().toLowerCase()
+  const positive = POSITIVE_COLUMN_NAMES.has(name)
+  const degraded = DEGRADED_COLUMN_NAMES.has(name)
+  const terminal = TERMINAL_COLUMN_NAMES.has(name)
+  if (!positive && !degraded && !terminal) return null
+  // Unknown is not a failure — the controller could not evaluate it.
+  if (state === 'unknown') return 'unknown'
+  if (positive) return state === 'true' ? 'healthy' : 'unhealthy'
+  if (degraded) return state === 'true' ? 'degraded' : 'healthy'
+  return state === 'true' ? 'unhealthy' : 'healthy'
+}

package/src/components/resources/renderers/EventRenderer.test.tsx

@@ -1,7 +1,23 @@
 import { renderToString } from 'react-dom/server'
-import { describe, expect, it } from 'vitest'
+import type { ReactElement, ReactNode } from 'react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 
 import { EventRenderer } from './EventRenderer'
+import { initNavigationMap, resetNavigationMap } from '../../../utils/navigation'
+
+afterEach(resetNavigationMap)
+
+function findButton(node: ReactNode): ReactElement<{ onClick: () => void }> | undefined {
+  if (!node || typeof node !== 'object' || !('props' in node)) return undefined
+  const element = node as ReactElement<{ children?: ReactNode; onClick?: () => void }>
+  if (element.type === 'button') return element as ReactElement<{ onClick: () => void }>
+  const children = element.props.children
+  for (const child of Array.isArray(children) ? children : [children]) {
+    const button = findButton(child)
+    if (button) return button
+  }
+  return undefined
+}
 
 describe('EventRenderer', () => {
   it.each([
@@ -20,4 +36,37 @@ describe('EventRenderer', () => {
     expect(html).not.toMatch(/text-(?:amber|blue)-(?:200|300|400)/)
     expect(html).not.toContain('opacity-')
   })
+
+  it('navigates to the group-qualified native PodGroup resource', () => {
+    initNavigationMap([{
+      group: 'scheduling.k8s.io',
+      version: 'v1beta1',
+      kind: 'PodGroup',
+      name: 'podgroups',
+      namespaced: true,
+      isCrd: false,
+      verbs: ['get', 'list'],
+    }])
+    const onNavigate = vi.fn()
+    const tree = EventRenderer({
+      data: {
+        involvedObject: {
+          apiVersion: 'scheduling.k8s.io/v1beta1',
+          kind: 'PodGroup',
+          namespace: 'default',
+          name: 'batch',
+        },
+      },
+      onNavigate,
+    })
+
+    findButton(tree)?.props.onClick()
+
+    expect(onNavigate).toHaveBeenCalledWith({
+      kind: 'podgroups',
+      namespace: 'default',
+      name: 'batch',
+      group: 'scheduling.k8s.io',
+    })
+  })
 })

package/src/components/resources/renderers/EventRenderer.tsx

@@ -4,7 +4,7 @@ import { Badge } from '../../ui/Badge'
 import { Section, PropertyList, Property } from '../../ui/drawer-components'
 import { formatAge } from '../resource-utils'
 import type { NavigateToResource } from '../../../utils/navigation'
-import { kindToPlural } from '../../../utils/navigation'
+import { apiVersionToGroup, kindToPluralWithGroup } from '../../../utils/navigation'
 
 interface EventRendererProps {
   data: any
@@ -75,11 +75,9 @@ export function EventRenderer({ data, onNavigate }: EventRendererProps) {
               {onNavigate ? (
                 <button
                   onClick={() => {
-                    // Parse API group from apiVersion (format: "group/version" or "v1" for core)
-                    const apiVersion = involvedObject.apiVersion || ''
-                    const group = apiVersion.includes('/') ? apiVersion.split('/')[0] : undefined
+                    const group = apiVersionToGroup(involvedObject.apiVersion) || undefined
                     onNavigate({
-                      kind: kindToPlural(involvedObject.kind),
+                      kind: kindToPluralWithGroup(involvedObject.kind, group ?? ''),
                       namespace: involvedObject.namespace || '',
                       name: involvedObject.name,
                       group,