refactor(leiden): extract makePartition's inline getters to cut cyclomatic complexity

refactor(leiden): extract makePartition's inline getters to cut cyclomatic complexity

makePartition (cyc=10, threshold 10) built its returned Partition object with
several getter closures containing their own inline bounds-check ternaries and
`|| 0` fallbacks. Extracted fgetOrZero/igetOrZero to typed-array-helpers.ts and
a named buildCommunityMembers function, matching the file's existing extraction
style. Greptile gave this a 5/5 "safe to merge" review with no actionable comments.

The Pre-publish benchmark gate failed once (the routine flaky "1-file rebuild"
timing gate seen on prior PRs) and passed clean on rerun with no code changes.

Author: carlos-alm

src/graph/algorithms/leiden/partition.ts

@@ -9,7 +9,7 @@
 
 import type { GraphAdapter } from './adapter.js';
 import { accumulateInternalEdgeWeights, accumulateNodeAggregates } from './aggregate-helpers.js';
-import { fget, iget, u8get } from './typed-array-helpers.js';
+import { fget, fgetOrZero, iget, igetOrZero, u8get } from './typed-array-helpers.js';
 
 export interface CompactOptions {
   keepOldOrder?: boolean;
@@ -367,6 +367,22 @@ function compactIds(s: PartitionState, opts: CompactOptions = {}): void {
   s.communityTotalInStrength = newTotalInStrength;
 }
 
+/* ------------------------------------------------------------------ */
+/*  Extracted: community membership listing                            */
+/* ------------------------------------------------------------------ */
+
+/** Group node indices [0, n) by their current community id. */
+function buildCommunityMembers(
+  s: PartitionState,
+  n: number,
+  nodeCommunity: Int32Array,
+): number[][] {
+  const comms: number[][] = new Array(s.communityCount);
+  for (let i = 0; i < s.communityCount; i++) comms[i] = [];
+  for (let i = 0; i < n; i++) comms[iget(nodeCommunity, i)]!.push(i);
+  return comms;
+}
+
 /* ------------------------------------------------------------------ */
 /*  Factory: thin wrapper that wires state to extracted functions      */
 /* ------------------------------------------------------------------ */
@@ -435,21 +451,14 @@ export function makePartition(graph: GraphAdapter, options: MakePartitionOptions
     accumulateNeighborCommunityEdgeWeights: (v: number) => accumulateNeighborWeights(s, v),
     getCandidateCommunityAt: (i: number): number => iget(s.candidateCommunities, i),
     getNeighborEdgeWeightToCommunity: (c: number): number =>
-      fget(s.neighborEdgeWeightToCommunity, c) || 0,
-    getOutEdgeWeightToCommunity: (c: number): number => fget(s.outEdgeWeightToCommunity, c) || 0,
-    getInEdgeWeightFromCommunity: (c: number): number => fget(s.inEdgeWeightFromCommunity, c) || 0,
+      fgetOrZero(s.neighborEdgeWeightToCommunity, c),
+    getOutEdgeWeightToCommunity: (c: number): number => fgetOrZero(s.outEdgeWeightToCommunity, c),
+    getInEdgeWeightFromCommunity: (c: number): number => fgetOrZero(s.inEdgeWeightFromCommunity, c),
     moveNodeToCommunity: (v: number, newC: number) => moveNode(s, v, newC),
     compactCommunityIds: (opts?: CompactOptions) => compactIds(s, opts),
-    getCommunityMembers(): number[][] {
-      const comms: number[][] = new Array(s.communityCount);
-      for (let i = 0; i < s.communityCount; i++) comms[i] = [];
-      for (let i = 0; i < n; i++) comms[iget(nodeCommunity, i)]!.push(i);
-      return comms;
-    },
-    getCommunityTotalSize: (c: number): number =>
-      c < s.communityTotalSize.length ? fget(s.communityTotalSize, c) : 0,
-    getCommunityNodeCount: (c: number): number =>
-      c < s.communityNodeCount.length ? iget(s.communityNodeCount, c) : 0,
+    getCommunityMembers: () => buildCommunityMembers(s, n, nodeCommunity),
+    getCommunityTotalSize: (c: number): number => fgetOrZero(s.communityTotalSize, c),
+    getCommunityNodeCount: (c: number): number => igetOrZero(s.communityNodeCount, c),
     graph: undefined,
   };
 }

src/graph/algorithms/leiden/typed-array-helpers.ts

@@ -26,3 +26,20 @@ export function u8get(a: Uint8Array, i: number): number {
 export function taAdd(a: Float64Array, i: number, v: number): void {
   a[i] = fget(a, i) + v;
 }
+
+/**
+ * Bounds-safe zero-fallback read: collapses both an out-of-range index and a
+ * falsy (0/NaN) in-range value to `0`. Typed arrays already return `undefined`
+ * for an out-of-range index, and `undefined || 0` lands on the same `0` as a
+ * falsy in-range read, so this single helper replaces the two hand-rolled
+ * guards previously duplicated at call sites: `i < a.length ? fget(a, i) : 0`
+ * and `fget(a, i) || 0`.
+ */
+export function fgetOrZero(a: Float64Array, i: number): number {
+  return (a[i] as number) || 0;
+}
+
+/** `fgetOrZero`, for `Int32Array`. */
+export function igetOrZero(a: Int32Array, i: number): number {
+  return (a[i] as number) || 0;
+}

tests/graph/algorithms/leiden-partition.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it } from 'vitest';
+import type { GraphAdapter } from '../../../src/graph/algorithms/leiden/adapter.js';
+import { makePartition } from '../../../src/graph/algorithms/leiden/partition.js';
+
+/**
+ * Minimal 3-node undirected adapter: 0-1 (w=4), 1-2 (w=6), no self-loops.
+ * Hand-built (not via makeGraphAdapter) to keep this a focused unit test of
+ * partition.ts's own bookkeeping, independent of adapter.ts.
+ */
+function makeTestAdapter(): GraphAdapter {
+  const outEdges: GraphAdapter['outEdges'] = [
+    [{ to: 1, w: 4 }],
+    [
+      { to: 0, w: 4 },
+      { to: 2, w: 6 },
+    ],
+    [{ to: 1, w: 6 }],
+  ];
+  const inEdges: GraphAdapter['inEdges'] = [
+    [{ from: 1, w: 4 }],
+    [
+      { from: 0, w: 4 },
+      { from: 2, w: 6 },
+    ],
+    [{ from: 1, w: 6 }],
+  ];
+  return {
+    n: 3,
+    nodeIds: ['0', '1', '2'],
+    idToIndex: new Map([
+      ['0', 0],
+      ['1', 1],
+      ['2', 2],
+    ]),
+    size: new Float64Array([1, 1, 1]),
+    selfLoop: new Float64Array(3),
+    strengthOut: new Float64Array([4, 10, 6]),
+    strengthIn: new Float64Array([4, 10, 6]),
+    outEdges,
+    inEdges,
+    directed: false,
+    totalWeight: 20,
+    forEachNeighbor: (i, cb) => {
+      for (const e of outEdges[i] as { to: number; w: number }[]) cb(e.to, e.w);
+    },
+  };
+}
+
+describe('makePartition', () => {
+  it('starts with each node in its own singleton community', () => {
+    const p = makePartition(makeTestAdapter());
+    p.initializeAggregates();
+    expect(p.communityCount).toBe(3);
+    expect(Array.from(p.nodeCommunity)).toEqual([0, 1, 2]);
+    expect(p.getCommunityTotalSize(0)).toBe(1);
+    expect(p.getCommunityTotalSize(1)).toBe(1);
+    expect(p.getCommunityTotalSize(2)).toBe(1);
+    expect(p.getCommunityNodeCount(0)).toBe(1);
+  });
+
+  it('getCommunityTotalSize/getCommunityNodeCount return 0 for an out-of-range id', () => {
+    const p = makePartition(makeTestAdapter());
+    p.initializeAggregates();
+    expect(p.getCommunityTotalSize(99)).toBe(0);
+    expect(p.getCommunityNodeCount(99)).toBe(0);
+    expect(p.getCommunityTotalSize(-1)).toBe(0);
+    expect(p.getCommunityNodeCount(-1)).toBe(0);
+  });
+
+  it('moveNodeToCommunity updates size/count for old and new communities', () => {
+    const p = makePartition(makeTestAdapter());
+    p.initializeAggregates();
+    const moved = p.moveNodeToCommunity(0, 1);
+    expect(moved).toBe(true);
+    expect(p.getCommunityTotalSize(0)).toBe(0);
+    expect(p.getCommunityNodeCount(0)).toBe(0);
+    expect(p.getCommunityTotalSize(1)).toBe(2);
+    expect(p.getCommunityNodeCount(1)).toBe(2);
+    expect(Array.from(p.nodeCommunity)).toEqual([1, 1, 2]);
+  });
+
+  it('moveNodeToCommunity is a no-op when the node is already in that community', () => {
+    const p = makePartition(makeTestAdapter());
+    p.initializeAggregates();
+    expect(p.moveNodeToCommunity(0, 0)).toBe(false);
+  });
+
+  it('accumulateNeighborCommunityEdgeWeights/getNeighborEdgeWeightToCommunity report per-community edge weight, and 0 for untouched or out-of-range ids', () => {
+    const p = makePartition(makeTestAdapter());
+    p.initializeAggregates();
+    p.moveNodeToCommunity(0, 1);
+
+    const candidateCount = p.accumulateNeighborCommunityEdgeWeights(1);
+    // node 1's neighbors are 0 (now community 1) and 2 (community 2), plus its
+    // own community 1 is always touched -- so 2 distinct candidate communities.
+    expect(candidateCount).toBe(2);
+    expect(p.getNeighborEdgeWeightToCommunity(1)).toBe(4);
+    expect(p.getNeighborEdgeWeightToCommunity(2)).toBe(6);
+    // Community 0 has no members and received no edge weight -- in-range zero.
+    expect(p.getNeighborEdgeWeightToCommunity(0)).toBe(0);
+    // Out-of-range id -- must not throw, must fall back to 0.
+    expect(p.getNeighborEdgeWeightToCommunity(50)).toBe(0);
+    expect(p.getOutEdgeWeightToCommunity(50)).toBe(0);
+    expect(p.getInEdgeWeightFromCommunity(50)).toBe(0);
+  });
+
+  it('getCommunityMembers groups node indices by current community', () => {
+    const p = makePartition(makeTestAdapter());
+    p.initializeAggregates();
+    p.moveNodeToCommunity(0, 1);
+    const members = p.getCommunityMembers();
+    expect(members[0]).toEqual([]);
+    expect(members[1]).toEqual([0, 1]);
+    expect(members[2]).toEqual([2]);
+  });
+
+  it('compactCommunityIds removes empty communities and remaps the rest', () => {
+    const p = makePartition(makeTestAdapter());
+    p.initializeAggregates();
+    p.moveNodeToCommunity(0, 1);
+    p.compactCommunityIds();
+    expect(p.communityCount).toBe(2);
+    // Both remaining communities' sizes should be 2 and 1, in descending-size order.
+    const sizes = [p.getCommunityTotalSize(0), p.getCommunityTotalSize(1)].sort((a, b) => b - a);
+    expect(sizes).toEqual([2, 1]);
+  });
+
+  it('respects a custom capacityGrowthFactor option', () => {
+    const p = makePartition(makeTestAdapter(), { capacityGrowthFactor: 2 });
+    p.initializeAggregates();
+    p.resizeCommunities(10);
+    expect(p.communityCount).toBe(10);
+    expect(p.communityTotalSize.length).toBeGreaterThanOrEqual(10);
+  });
+});

tests/graph/algorithms/leiden-typed-array-helpers.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import {
+  fgetOrZero,
+  igetOrZero,
+} from '../../../src/graph/algorithms/leiden/typed-array-helpers.js';
+
+describe('fgetOrZero', () => {
+  it('returns the in-range value when it is truthy', () => {
+    const a = new Float64Array([1, 2.5, -3]);
+    expect(fgetOrZero(a, 0)).toBe(1);
+    expect(fgetOrZero(a, 1)).toBe(2.5);
+    expect(fgetOrZero(a, 2)).toBe(-3);
+  });
+
+  it('collapses an in-range zero to 0', () => {
+    const a = new Float64Array([0, 5]);
+    expect(fgetOrZero(a, 0)).toBe(0);
+  });
+
+  it('collapses an out-of-range index (positive or negative) to 0', () => {
+    const a = new Float64Array([1, 2]);
+    expect(fgetOrZero(a, 2)).toBe(0);
+    expect(fgetOrZero(a, 99)).toBe(0);
+    expect(fgetOrZero(a, -1)).toBe(0);
+  });
+
+  it('matches the two guards it replaces: `i < a.length ? fget(a, i) : 0` and `fget(a, i) || 0`', () => {
+    const a = new Float64Array([0, 7, 0]);
+    for (let i = -1; i <= a.length; i++) {
+      const boundsGuard = i < a.length && i >= 0 ? (a[i] as number) : 0;
+      const orZeroGuard = ((a[i] as number) || 0) as number;
+      expect(fgetOrZero(a, i)).toBe(boundsGuard);
+      expect(fgetOrZero(a, i)).toBe(orZeroGuard);
+    }
+  });
+});
+
+describe('igetOrZero', () => {
+  it('returns the in-range value when it is truthy', () => {
+    const a = new Int32Array([4, -6, 0]);
+    expect(igetOrZero(a, 0)).toBe(4);
+    expect(igetOrZero(a, 1)).toBe(-6);
+  });
+
+  it('collapses an in-range zero to 0', () => {
+    const a = new Int32Array([0, 3]);
+    expect(igetOrZero(a, 0)).toBe(0);
+  });
+
+  it('collapses an out-of-range index to 0', () => {
+    const a = new Int32Array([1, 2]);
+    expect(igetOrZero(a, 5)).toBe(0);
+    expect(igetOrZero(a, -1)).toBe(0);
+  });
+});