@skyhook-io/k8s-ui 1.6.1 → 1.7.0

package/src/utils/structure-hash.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect } from 'vitest'
+import { fnv1a32, foldHash } from './structure-hash'
+
+describe('fnv1a32', () => {
+  it('is deterministic', () => {
+    expect(fnv1a32('hello')).toBe(fnv1a32('hello'))
+  })
+
+  it('distinguishes similar strings', () => {
+    expect(fnv1a32('pod/default/a')).not.toBe(fnv1a32('pod/default/b'))
+    expect(fnv1a32('a')).not.toBe(fnv1a32('A'))
+  })
+
+  it('handles empty string', () => {
+    expect(typeof fnv1a32('')).toBe('number')
+  })
+})
+
+describe('foldHash', () => {
+  const id = (s: string) => s
+
+  it('is order-independent', () => {
+    const a = foldHash(['a', 'b', 'c'], id)
+    const b = foldHash(['c', 'a', 'b'], id)
+    expect(a).toBe(b)
+  })
+
+  it('changes when an element is added', () => {
+    const before = foldHash(['a', 'b'], id)
+    const after = foldHash(['a', 'b', 'c'], id)
+    expect(before).not.toBe(after)
+  })
+
+  it('changes when an element is removed', () => {
+    const before = foldHash(['a', 'b', 'c'], id)
+    const after = foldHash(['a', 'b'], id)
+    expect(before).not.toBe(after)
+  })
+
+  it('changes when an element is renamed', () => {
+    const before = foldHash(['a', 'b', 'c'], id)
+    const after = foldHash(['a', 'b', 'd'], id)
+    expect(before).not.toBe(after)
+  })
+
+  it('returns the zero fingerprint for empty input', () => {
+    expect(foldHash([], id)).toBe('0.0')
+  })
+
+  it('works with object items via keyOf', () => {
+    const items = [{ id: 'x' }, { id: 'y' }]
+    expect(foldHash(items, i => i.id)).toBe(foldHash(['x', 'y'], id))
+  })
+
+  it('emits a "<xor>.<sum>" shape', () => {
+    expect(foldHash(['a', 'b'], id)).toMatch(/^\d+\.\d+$/)
+  })
+
+  // The dual accumulator's whole point: a swap that preserves the XOR fold
+  // (a^b stays constant) must still change the fingerprint via the sum fold.
+  // Single-XOR would have collided here. Construct two sets with equal XOR
+  // but different members.
+  it('distinguishes sets that share an XOR but differ in membership', () => {
+    // {x} vs {y, z} where hash(x) === hash(y) ^ hash(z) would collide under
+    // pure XOR. We can't easily force that, so instead verify the additive
+    // fold breaks a known XOR-preserving transform: doubling an element.
+    // ['a','a'] XOR-folds to 0 (a^a), same as [] — but sum differs.
+    expect(foldHash(['a', 'a'], id)).not.toBe(foldHash([], id))
+    expect(foldHash(['a', 'a'], id)).not.toBe(foldHash(['b', 'b'], id))
+  })
+})
+
+// The production guard against skipped relayouts is the *composed* key
+// (count + foldHash), exactly as TopologyGraph builds it. These tests pin that
+// composition, not just the bare fold — a genuine same-count add/remove/rename
+// must change the composed key so the layout effect doesn't short-circuit.
+describe('composed structure key (count + foldHash)', () => {
+  const id = (s: string) => s
+  // Mirrors TopologyGraph's structureKey shape for the node portion.
+  const composed = (nodeIds: string[]) => `n${nodeIds.length}:${foldHash(nodeIds, id)}`
+
+  it('changes on a same-count rename', () => {
+    expect(composed(['a', 'b', 'c'])).not.toBe(composed(['a', 'b', 'x']))
+  })
+
+  it('changes on add and on remove', () => {
+    expect(composed(['a', 'b'])).not.toBe(composed(['a', 'b', 'c']))
+    expect(composed(['a', 'b', 'c'])).not.toBe(composed(['a', 'b']))
+  })
+
+  it('is stable across reorder (no wasted relayout)', () => {
+    expect(composed(['a', 'b', 'c'])).toBe(composed(['c', 'b', 'a']))
+  })
+})

package/src/utils/structure-hash.ts

@@ -0,0 +1,35 @@
+// FNV-1a 32-bit string hash. Cheap, well-distributed, no allocations.
+export function fnv1a32(s: string): number {
+  let h = 0x811c9dc5
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i)
+    h = Math.imul(h, 0x01000193)
+  }
+  return h >>> 0
+}
+
+// foldHash returns an order-independent fingerprint of the given items as a
+// "<xor>.<sum>" string. Used by TopologyGraph's structureKey change-detection
+// — at thousands of nodes, sort+join over IDs allocated tens of KB of string
+// every render; this is O(n) with two uint32 accumulators.
+//
+// Two independent commutative folds (XOR and 32-bit additive sum) are combined
+// because a single collision in the structure key is a false negative on the
+// exact path that serves big, high-churn graphs: the layout effect bails on an
+// unchanged key, so a real shape change would silently skip setNodes/setEdges.
+// A collision now requires BOTH folds to collide simultaneously across the
+// difference set, which is vanishingly unlikely. Combine with element count
+// (caller composes "count.xor.sum") for full structural identity.
+//
+// Order independence is intentional: pure reorders of the same node/edge set
+// produce an identical graph and shouldn't trigger an ELK relayout.
+export function foldHash<T>(items: ArrayLike<T>, keyOf: (item: T) => string): string {
+  let xor = 0
+  let sum = 0
+  for (let i = 0; i < items.length; i++) {
+    const h = fnv1a32(keyOf(items[i]))
+    xor ^= h
+    sum = (sum + h) >>> 0
+  }
+  return `${xor >>> 0}.${sum}`
+}