nikcli 0.0.6

package/test/tui-benchmark.test.ts

@@ -0,0 +1,230 @@
+import { describe, expect, it } from "bun:test"
+
+interface TableRow {
+  [key: string]: any
+}
+
+interface ColumnLayout {
+  index: number
+  id: string
+  x: number
+  width: number
+  visibleWidth: number
+}
+
+function buildRowIndexMapOld(rows: TableRow[]): Map<TableRow, number> {
+  const map = new Map()
+  for (let i = 0; i < rows.length; i++) {
+    map.set(rows[i], i)
+  }
+  return map
+}
+
+function getRowIndexOld(rows: TableRow[], row: TableRow): number {
+  return rows.indexOf(row)
+}
+
+function getRowIndexNew(map: Map<TableRow, number>, row: TableRow): number {
+  return map.get(row) ?? -1
+}
+
+function buildColumnLayoutsOld(columns: string[]): ColumnLayout[] {
+  const layouts: ColumnLayout[] = []
+  let currentX = 0
+  for (let i = 0; i < columns.length; i++) {
+    layouts.push({
+      index: i,
+      id: columns[i],
+      x: currentX,
+      width: 10,
+      visibleWidth: 10,
+    })
+    currentX += 10
+  }
+  return layouts
+}
+
+function getColumnByIdOld(layouts: ColumnLayout[], id: string): ColumnLayout | null {
+  return layouts.find((c) => c.id === id) || null
+}
+
+function buildColumnIdMap(columns: string[]): Map<string, ColumnLayout> {
+  const map = new Map()
+  const layouts: ColumnLayout[] = []
+  let currentX = 0
+  for (let i = 0; i < columns.length; i++) {
+    const layout = {
+      index: i,
+      id: columns[i],
+      x: currentX,
+      width: 10,
+      visibleWidth: 10,
+    }
+    layouts.push(layout)
+    map.set(columns[i], layout)
+    currentX += 10
+  }
+  return map
+}
+
+function getColumnByIdNew(map: Map<string, ColumnLayout>, id: string): ColumnLayout | null {
+  return map.get(id) ?? null
+}
+
+describe("TUI Table Performance Optimizations", () => {
+  describe("Row Index Lookup (indexOf → Map)", () => {
+    it("correctness: returns same indices", () => {
+      const rows = [
+        { id: 1, name: "a" },
+        { id: 2, name: "b" },
+        { id: 3, name: "c" },
+      ]
+      const map = buildRowIndexMapOld(rows)
+
+      for (let i = 0; i < rows.length; i++) {
+        expect(getRowIndexNew(map, rows[i])).toBe(i)
+      }
+    })
+
+    it("benchmark: indexOf vs Map lookup", () => {
+      const rowCount = 10000
+      const rows: TableRow[] = []
+      for (let i = 0; i < rowCount; i++) {
+        rows.push({ id: i, name: `row_${i}` })
+      }
+
+      const map = buildRowIndexMapOld(rows)
+      const visibleRows = rows.slice(100, 200)
+      const iterations = 1000
+
+      const startOld = performance.now()
+      let sinkOld = 0
+      for (let iter = 0; iter < iterations; iter++) {
+        for (const row of visibleRows) {
+          sinkOld += getRowIndexOld(rows, row)
+        }
+      }
+      const oldTime = performance.now() - startOld
+      expect(sinkOld).toBeGreaterThan(0)
+
+      const startNew = performance.now()
+      let sinkNew = 0
+      for (let iter = 0; iter < iterations; iter++) {
+        for (const row of visibleRows) {
+          sinkNew += getRowIndexNew(map, row)
+        }
+      }
+      const newTime = performance.now() - startNew
+      expect(sinkNew).toBeGreaterThan(0)
+
+      const improvement = oldTime / newTime
+      const percentReduction = ((oldTime - newTime) / oldTime) * 100
+
+      console.log(`\n📊 Row index lookup (${iterations} iterations x ${visibleRows.length} visible rows):`)
+      console.log(`   Old (indexOf): ${oldTime.toFixed(2)}ms`)
+      console.log(`   New (Map): ${newTime.toFixed(2)}ms`)
+      console.log(`   ⚡ Improvement: ${improvement.toFixed(2)}x faster (${percentReduction.toFixed(1)}% reduction)`)
+
+      expect(newTime).toBeLessThan(oldTime)
+    })
+
+    it("benchmark: full render simulation (worst case O(n²))", () => {
+      const rowCount = 5000
+      const rows: TableRow[] = []
+      for (let i = 0; i < rowCount; i++) {
+        rows.push({ id: i, name: `row_${i}` })
+      }
+
+      const map = buildRowIndexMapOld(rows)
+      const visibleRowCount = 100
+      const iterations = 100
+
+      // "Worst case" for indexOf is when rows are near the end of the array (late match).
+      const visibleRows = rows.slice(rowCount - visibleRowCount)
+
+      const startOld = performance.now()
+      let sinkOld = 0
+      for (let iter = 0; iter < iterations; iter++) {
+        for (let i = 0; i < visibleRows.length; i++) {
+          sinkOld += rows.indexOf(visibleRows[i])
+        }
+      }
+      const oldTime = performance.now() - startOld
+      expect(sinkOld).toBeGreaterThan(0)
+
+      const startNew = performance.now()
+      let sinkNew = 0
+      for (let iter = 0; iter < iterations; iter++) {
+        for (let i = 0; i < visibleRows.length; i++) {
+          sinkNew += map.get(visibleRows[i]) ?? -1
+        }
+      }
+      const newTime = performance.now() - startNew
+      expect(sinkNew).toBeGreaterThan(0)
+
+      const improvement = oldTime / newTime
+      const percentReduction = ((oldTime - newTime) / oldTime) * 100
+
+      console.log(`\n📊 Full render simulation (${iterations} renders x ${visibleRowCount} rows):`)
+      console.log(`   Old (indexOf per row): ${oldTime.toFixed(2)}ms`)
+      console.log(`   New (Map lookup): ${newTime.toFixed(2)}ms`)
+      console.log(`   ⚡ Improvement: ${improvement.toFixed(2)}x faster (${percentReduction.toFixed(1)}% reduction)`)
+
+      expect(newTime).toBeLessThan(oldTime)
+    })
+  })
+
+  describe("Column ID Lookup (find → Map)", () => {
+    it("correctness: returns same results", () => {
+      const columnIds = ["id", "name", "email", "status", "created"]
+      const layouts = buildColumnLayoutsOld(columnIds)
+      const map = buildColumnIdMap(columnIds)
+
+      for (const id of columnIds) {
+        const oldResult = getColumnByIdOld(layouts, id)
+        const newResult = getColumnByIdNew(map, id)
+        expect(newResult?.id).toBe(oldResult?.id)
+        expect(newResult?.index).toBe(oldResult?.index)
+      }
+    })
+
+    it("benchmark: find vs Map.get", () => {
+      const columnCount = 50
+      const columnIds: string[] = []
+      for (let i = 0; i < columnCount; i++) {
+        columnIds.push(`col_${i}`)
+      }
+
+      const layouts = buildColumnLayoutsOld(columnIds)
+      const map = buildColumnIdMap(columnIds)
+
+      const iterations = 10000
+
+      const startOld = performance.now()
+      for (let iter = 0; iter < iterations; iter++) {
+        for (let i = 0; i < columnIds.length; i++) {
+          getColumnByIdOld(layouts, columnIds[i])
+        }
+      }
+      const oldTime = performance.now() - startOld
+
+      const startNew = performance.now()
+      for (let iter = 0; iter < iterations; iter++) {
+        for (let i = 0; i < columnIds.length; i++) {
+          getColumnByIdNew(map, columnIds[i])
+        }
+      }
+      const newTime = performance.now() - startNew
+
+      const improvement = oldTime / newTime
+      const percentReduction = ((oldTime - newTime) / oldTime) * 100
+
+      console.log(`\n📊 Column ID lookup (${iterations} iterations x ${columnCount} columns):`)
+      console.log(`   Old (.find): ${oldTime.toFixed(2)}ms`)
+      console.log(`   New (Map.get): ${newTime.toFixed(2)}ms`)
+      console.log(`   ⚡ Improvement: ${improvement.toFixed(2)}x faster (${percentReduction.toFixed(1)}% reduction)`)
+
+      expect(newTime).toBeLessThan(oldTime)
+    })
+  })
+})

package/test/wildcard-benchmark.test.ts

@@ -0,0 +1,180 @@
+import { describe, expect, it } from "bun:test"
+
+const CACHE_MAX_SIZE = 100
+
+function getRegexOld(pattern: string): RegExp {
+  let escaped = pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, ".*")
+    .replace(/\?/g, ".")
+
+  if (escaped.endsWith(" .*")) {
+    escaped = escaped.slice(0, -3) + "( .*)?"
+  }
+
+  return new RegExp("^" + escaped + "$", "s")
+}
+
+function matchOld(str: string, pattern: string): boolean {
+  return getRegexOld(pattern).test(str)
+}
+
+const regexCache = new Map<string, RegExp>()
+
+function getRegexNew(pattern: string): RegExp {
+  const escaped = pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, ".*")
+    .replace(/\?/g, ".")
+
+  let escapedWithOptional = escaped
+  if (escaped.endsWith(" .*")) {
+    escapedWithOptional = escaped.slice(0, -3) + "( .*)?"
+  }
+
+  let regex = regexCache.get(escapedWithOptional)
+  if (!regex) {
+    if (regexCache.size >= CACHE_MAX_SIZE) {
+      const firstKey = regexCache.keys().next().value
+      if (firstKey) regexCache.delete(firstKey)
+    }
+    regex = new RegExp("^" + escapedWithOptional + "$", "s")
+    regexCache.set(escapedWithOptional, regex)
+  }
+
+  return regex
+}
+
+function matchNew(str: string, pattern: string): boolean {
+  return getRegexNew(pattern).test(str)
+}
+
+describe("Wildcard Regex Caching Optimization", () => {
+  describe("Correctness", () => {
+    it("produces same results as uncached version", () => {
+      const patterns = [
+        "*.ts",
+        "*.js",
+        "src/**/*",
+        "test/**/*.test.ts",
+        "src/**/*.ts",
+        "?ile.txt",
+        "file?.txt",
+        "*.{ts,js}",
+        "**/*.json",
+        "src/{foo,bar}/*",
+      ]
+
+      const strings = [
+        "file.ts",
+        "file.js",
+        "src/index.ts",
+        "src/utils/helper.ts",
+        "test/unit.test.ts",
+        "test/integration/api.test.ts",
+        "1ile.txt",
+        "file1.txt",
+        "data.json",
+        "config.json",
+        "src/foo/file.ts",
+        "src/bar/file.ts",
+      ]
+
+      for (const pattern of patterns) {
+        regexCache.clear()
+        for (const str of strings) {
+          const oldResult = matchOld(str, pattern)
+          const newResult = matchNew(str, pattern)
+          expect(newResult).toBe(oldResult)
+        }
+      }
+    })
+
+    it("handles edge cases", () => {
+      expect(matchNew("", "")).toBe(true)
+      expect(matchNew("a", "")).toBe(false)
+      expect(matchNew("test", "*")).toBe(true)
+      expect(matchNew("test", "tes?")).toBe(true)
+    })
+  })
+
+  describe("Performance Benchmark", () => {
+    it("uncached vs cached regex", () => {
+      const iterations = 100000
+      const patterns = ["*.ts", "src/**/*.ts", "test/**/*.test.ts", "**/*.json", "?ile.txt", "**/*"]
+      const strings = [
+        "file.ts",
+        "src/index.ts",
+        "src/utils/helper.ts",
+        "test/unit.test.ts",
+        "config.json",
+        "data.json",
+        "1ile.txt",
+        "anything.txt",
+      ]
+
+      regexCache.clear()
+      const startOld = performance.now()
+      for (let i = 0; i < iterations; i++) {
+        for (const pattern of patterns) {
+          for (const str of strings) {
+            matchOld(str, pattern)
+          }
+        }
+      }
+      const oldTime = performance.now() - startOld
+
+      regexCache.clear()
+      const startNew = performance.now()
+      for (let i = 0; i < iterations; i++) {
+        for (const pattern of patterns) {
+          for (const str of strings) {
+            matchNew(str, pattern)
+          }
+        }
+      }
+      const newTime = performance.now() - startNew
+
+      const improvement = oldTime / newTime
+      const percentReduction = ((oldTime - newTime) / oldTime) * 100
+
+      console.log(
+        `\n📊 Wildcard regex (${iterations} iterations x ${patterns.length} patterns x ${strings.length} strings):`,
+      )
+      console.log(`   Uncached (new RegExp each call): ${oldTime.toFixed(2)}ms`)
+      console.log(`   Cached (Map cache): ${newTime.toFixed(2)}ms`)
+      console.log(`   ⚡ Improvement: ${improvement.toFixed(2)}x faster (${percentReduction.toFixed(1)}% reduction)`)
+
+      expect(newTime).toBeLessThan(oldTime)
+    })
+
+    it("cache hit rate impact", () => {
+      const iterations = 100000
+      const patterns = ["*.ts", "*.js", "**/*.json", "src/**/*", "test/**/*"]
+      const strings = ["file.ts", "file.js", "config.json", "src/index.ts", "test/test.ts"]
+
+      const startOld = performance.now()
+      for (let i = 0; i < iterations; i++) {
+        for (let j = 0; j < patterns.length; j++) {
+          matchOld(strings[j % strings.length], patterns[j])
+        }
+      }
+      const oldTime = performance.now() - startOld
+
+      const startNew = performance.now()
+      for (let i = 0; i < iterations; i++) {
+        for (let j = 0; j < patterns.length; j++) {
+          matchNew(strings[j % strings.length], patterns[j])
+        }
+      }
+      const newTime = performance.now() - startNew
+
+      const improvement = oldTime / newTime
+
+      console.log(`\n📊 Cache hit rate test (${iterations} iterations):`)
+      console.log(`   Uncached: ${oldTime.toFixed(2)}ms`)
+      console.log(`   Cached: ${newTime.toFixed(2)}ms`)
+      console.log(`   ⚡ Improvement: ${improvement.toFixed(2)}x faster`)
+    })
+  })
+})

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@tsconfig/bun/tsconfig.json",
+  "compilerOptions": {
+    "jsx": "preserve",
+    "jsxImportSource": "@opentui/solid",
+    "lib": [
+      "ESNext",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "types": [],
+    "noUncheckedIndexedAccess": false,
+    "customConditions": [
+      "browser"
+    ],
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ],
+      "@tui/*": [
+        "./src/cli/cmd/tui/*"
+      ]
+    }
+  }
+}