@skyhook-io/k8s-ui 1.10.4 → 1.10.5

package/src/utils/navigation.ts

@@ -1,5 +1,5 @@
 import type { SelectedResource, ResourceRef, APIResource } from '../types/core'
-import { englishPlural } from './pluralize'
+import { englishPlural, englishSingular, isEnglishPlural } from './pluralize'
 
 /**
  * Canonical callback type for navigating to a resource.
@@ -103,6 +103,15 @@ export function kindToPlural(kind: string): string {
   }
   if (aliases[kindLower]) return aliases[kindLower]
 
+  // Keep the idempotence contract alive for CRD plurals that neither map knows
+  // yet: the discovery map arrives one round-trip after a cold direct-URL load,
+  // and English-pluralizing an already-plural slug yields `scheduleses`. An
+  // all-lowercase input is an API resource name rather than a Kind (Kubernetes
+  // Kinds are PascalCase), and isEnglishPlural separates a real plural from a
+  // singular that merely ends in 's' — `ingress` and `nodeclass` must still be
+  // pluralized, `schedules` and `validatingpolicies` must not.
+  if (kind === kindLower && isEnglishPlural(kindLower)) return kindLower
+
   // Fallback: English pluralization rules (shared with pluralize() in
   // utils/pluralize.ts so a rule change updates both call paths).
   return englishPlural(kindLower)
@@ -125,14 +134,7 @@ export function pluralToKind(plural: string): string {
   }
 
   // Fallback: basic de-pluralization + capitalize first letter
-  let singular = lower
-  if (singular.endsWith('ies')) {
-    singular = singular.slice(0, -3) + 'y'
-  } else if (singular.endsWith('ses') || singular.endsWith('xes') || singular.endsWith('ches') || singular.endsWith('shes')) {
-    singular = singular.slice(0, -2)
-  } else if (singular.endsWith('s')) {
-    singular = singular.slice(0, -1)
-  }
+  const singular = englishSingular(lower)
   return singular.charAt(0).toUpperCase() + singular.slice(1)
 }
 

package/src/utils/pluralize.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { englishPlural, pluralNoun, pluralize } from './pluralize'
+import { englishPlural, englishSingular, isEnglishPlural, pluralNoun, pluralize } from './pluralize'
 
 describe('englishPlural', () => {
   describe('default +s', () => {
@@ -96,3 +96,82 @@ describe('pluralize', () => {
     expect(pluralize(2, 'box')).toBe('2 boxes')
   })
 })
+
+describe('englishSingular', () => {
+  it('inverts englishPlural for regular plurals', () => {
+    expect(englishSingular('clusters')).toBe('cluster')
+    expect(englishSingular('policies')).toBe('policy')
+    expect(englishSingular('classes')).toBe('class')
+    expect(englishSingular('boxes')).toBe('box')
+    expect(englishSingular('batches')).toBe('batch')
+  })
+
+  it('leaves nouns with no plural ending alone', () => {
+    expect(englishSingular('cluster')).toBe('cluster')
+    expect(englishSingular('policy')).toBe('policy')
+  })
+
+  // The `-es` strip over-shortens a `*se` singular ('leases' → 'leas', not
+  // 'lease'), but englishPlural's `s → +es` rule inverts it exactly, so the
+  // round trip these two functions are used for still holds. Only the round
+  // trip is contractual — the intermediate stem is not.
+  it('over-strips *se stems but stays round-trip exact', () => {
+    expect(englishSingular('leases')).toBe('leas')
+    expect(englishPlural('leas')).toBe('leases')
+    expect(englishSingular('helmreleases')).toBe('helmreleas')
+    expect(englishPlural('helmreleas')).toBe('helmreleases')
+  })
+})
+
+describe('isEnglishPlural', () => {
+  it('recognizes regular plurals', () => {
+    expect(isEnglishPlural('schedules')).toBe(true)
+    expect(isEnglishPlural('validatingpolicies')).toBe(true)
+    expect(isEnglishPlural('virtualservices')).toBe(true)
+    expect(isEnglishPlural('gatewayclasses')).toBe(true)
+    expect(isEnglishPlural('endpoints')).toBe(true)
+  })
+
+  // Plurals whose singular ends in `se`. The stem englishSingular produces is
+  // wrong, but the round trip is not — see the englishSingular case above.
+  it('recognizes plurals of *se singulars', () => {
+    expect(isEnglishPlural('leases')).toBe(true)
+    expect(isEnglishPlural('helmreleases')).toBe(true)
+    expect(isEnglishPlural('releases')).toBe(true)
+    expect(isEnglishPlural('licenses')).toBe(true)
+    expect(isEnglishPlural('databases')).toBe(true)
+  })
+
+  // KNOWN LIMIT. A singular ending in a lone `s` whose stem doesn't end in
+  // s/x/ch/sh is indistinguishable from a plural by English rules alone
+  // ('status' → 'statu' → 'status' round-trips exactly like 'clusters' →
+  // 'cluster' → 'clusters'). No Kubernetes Kind Radar handles has this shape,
+  // and kindToPlural's discovered-map lookup takes over the moment discovery
+  // lands, so the mistake is confined to the cold window. Pinned so a future
+  // change to these rules surfaces the boundary rather than moving it silently.
+  it('cannot distinguish singulars ending in a lone s', () => {
+    expect(isEnglishPlural('status')).toBe(true)
+    expect(isEnglishPlural('alias')).toBe(true)
+    expect(isEnglishPlural('canvas')).toBe(true)
+  })
+
+  // The reason this predicate exists rather than a bare endsWith('s'): these
+  // are singular Kubernetes kinds that happen to end in 's'.
+  it('rejects singulars that merely end in s', () => {
+    expect(isEnglishPlural('ingress')).toBe(false)
+    expect(isEnglishPlural('nodeclass')).toBe(false)
+    expect(isEnglishPlural('ec2nodeclass')).toBe(false)
+    expect(isEnglishPlural('storageclass')).toBe(false)
+  })
+
+  it('rejects singulars with no plural ending', () => {
+    expect(isEnglishPlural('cluster')).toBe(false)
+    expect(isEnglishPlural('validatingpolicy')).toBe(false)
+  })
+
+  it('agrees with englishPlural on every round trip', () => {
+    for (const singular of ['cluster', 'policy', 'class', 'box', 'batch', 'schedule', 'service']) {
+      expect(isEnglishPlural(englishPlural(singular))).toBe(true)
+    }
+  })
+})

package/src/utils/pluralize.ts

@@ -30,6 +30,40 @@ export function englishPlural(noun: string): string {
   return noun + 's';
 }
 
+/**
+ * Undo englishPlural's regular rules.
+ *
+ *   englishSingular('classes')  → 'class'
+ *   englishSingular('policies') → 'policy'
+ *   englishSingular('clusters') → 'cluster'
+ *
+ * Lossy by construction — a noun that is already singular comes back mangled
+ * ('ingress' → 'ingres'). Use isEnglishPlural to find out which case you have.
+ */
+export function englishSingular(noun: string): string {
+  const lower = noun.toLowerCase();
+  if (lower.endsWith('ies')) return noun.slice(0, -3) + 'y';
+  if (lower.endsWith('ses') || lower.endsWith('xes') || lower.endsWith('ches') || lower.endsWith('shes')) {
+    return noun.slice(0, -2);
+  }
+  if (lower.endsWith('s')) return noun.slice(0, -1);
+  return noun;
+}
+
+/**
+ * Whether a noun is already the regular English plural of its own singular —
+ * i.e. whether englishPlural would reproduce it. Distinguishes a plural from a
+ * singular that merely ends in 's':
+ *
+ *   isEnglishPlural('schedules') → true   ('schedule' → 'schedules')
+ *   isEnglishPlural('policies')  → true   ('policy'   → 'policies')
+ *   isEnglishPlural('ingress')   → false  ('ingres'   → 'ingreses')
+ *   isEnglishPlural('nodeclass') → false  ('nodeclas' → 'nodeclases')
+ */
+export function isEnglishPlural(noun: string): boolean {
+  return englishPlural(englishSingular(noun)) === noun;
+}
+
 /**
  * Count-aware plural noun. Returns the singular when n===1, else the
  * plural form (passed-in or derived via englishPlural).