@kernhq/module-tracker 0.10.0 → 0.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kernhq/module-tracker",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "Kern tracker module: projects, work item types, custom fields, workflows, issues, KQL, cycles, views, reports, intake, time tracking (server + client skeleton)",
   "homepage": "https://kernaio.com",
   "license": "AGPL-3.0-only",

package/src/client/rank.test.ts

@@ -0,0 +1,78 @@
+/**
+ * The ordering invariants manual ranking depends on.
+ *
+ * There was no test for this file, which is how a loop that hangs the tab survived: dragging a
+ * sixth card to the top of one list was enough to reach it, and every other test passed.
+ */
+import { describe, expect, it } from 'vitest'
+import { initialRank, isValidRank, rankBetween, rankSequence } from './rank.js'
+
+describe('rankBetween', () => {
+  it('lands strictly between its neighbours', () => {
+    const a = initialRank()
+    const c = rankBetween(a, null)
+    const b = rankBetween(a, c)
+    expect(a < b).toBe(true)
+    expect(b < c).toBe(true)
+  })
+
+  it('opens either end', () => {
+    const first = initialRank()
+    expect(rankBetween(null, first) < first).toBe(true)
+    expect(rankBetween(first, null) > first).toBe(true)
+  })
+
+  it('refuses neighbours that are the wrong way round', () => {
+    const a = initialRank()
+    const b = rankBetween(a, null)
+    expect(() => rankBetween(b, a)).toThrow()
+  })
+
+  it('keeps finding room when the same gap is split over and over', () => {
+    let lo = initialRank()
+    const hi = rankBetween(lo, null)
+    const seen = new Set<string>([lo, hi])
+    for (let i = 0; i < 200; i++) {
+      const mid = rankBetween(lo, hi)
+      expect(lo < mid, `${lo} < ${mid} failed at split ${i}`).toBe(true)
+      expect(mid < hi, `${mid} < ${hi} failed at split ${i}`).toBe(true)
+      expect(seen.has(mid), `collision at split ${i}`).toBe(false)
+      seen.add(mid)
+      lo = mid
+    }
+  })
+})
+
+describe('dragging to the top, over and over', () => {
+  it('keeps finding room instead of looping until the tab dies', () => {
+    // The regression: an absent lower bound was treated as "below digit 0", so the fifth insertion
+    // at the top minted '0' and the sixth searched below it for ever.
+    let first = initialRank()
+    const seen = new Set<string>([first])
+    for (let i = 0; i < 200; i++) {
+      const next = rankBetween(null, first)
+      expect(next < first, `${next} < ${first} failed at insertion ${i}`).toBe(true)
+      expect(isValidRank(next), `${next} is not canonical at insertion ${i}`).toBe(true)
+      expect(seen.has(next), `collision at insertion ${i}`).toBe(false)
+      seen.add(next)
+      first = next
+    }
+  })
+
+  it('never mints a key with no room below it', () => {
+    let first = initialRank()
+    for (let i = 0; i < 50; i++) {
+      first = rankBetween(null, first)
+      expect(first.endsWith('0'), `${first} ends in the lowest digit`).toBe(false)
+    }
+  })
+})
+
+describe('rankSequence', () => {
+  it('produces keys that already sort into the order they were asked for', () => {
+    const keys = rankSequence(25)
+    expect(keys).toHaveLength(25)
+    expect([...keys].sort()).toEqual(keys)
+    expect(new Set(keys).size).toBe(25)
+  })
+})

package/src/client/rank.ts

@@ -45,10 +45,19 @@ export function rankBetween(before: string | null, after: string | null): string
   for (let i = 0; ; i++) {
     const da = i < lo.length ? indexOfDigit(lo[i] as string) : -1
     const db = free ? BASE : i < hi.length ? indexOfDigit(hi[i] as string) : 0
-    if (db - da > 1) return prefix + DIGITS[Math.floor((da + db) / 2)]
-    const kept = da >= 0 ? da : 0
-    prefix += DIGITS[kept]
-    if (!free && kept < db) free = true
+    /**
+     * An absent lower bound is digit 0, not "below 0".
+     *
+     * Digit 0 can never be the last digit of a key: nothing sorts strictly between `''` and `'0'`,
+     * so a key ending in 0 leaves no room to insert in front of it. Treating the absent bound as -1
+     * made the midpoint of (nothing, '2') come out as '0', and the next insertion at the front then
+     * searched for a key below '0' for ever, appending a digit each pass until the tab ran out of
+     * memory. Five cards dragged to the top of one list was enough to reach it.
+     */
+    const low = da >= 0 ? da : 0
+    if (db - low > 1) return prefix + DIGITS[Math.floor((low + db) / 2)]
+    prefix += DIGITS[low]
+    if (!free && low < db) free = true
   }
 }