nastech-tui 0.0.1

package/src/hooks/useGitBranch.ts

@@ -0,0 +1,72 @@
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+
+import { useEffect, useState } from 'react'
+
+const TTL_MS = 15_000
+const TIMEOUT_MS = 500
+
+const pexec = promisify(execFile)
+const cache = new Map<string, { at: number; branch: null | string }>()
+const inflight = new Map<string, Promise<null | string>>()
+
+const resolveBranch = async (cwd: string): Promise<null | string> => {
+  try {
+    const { stdout } = await pexec('git', ['-C', cwd, 'rev-parse', '--abbrev-ref', 'HEAD'], { timeout: TIMEOUT_MS })
+    const b = stdout.trim()
+
+    return !b || b === 'HEAD' ? null : b
+  } catch {
+    return null
+  }
+}
+
+const fetchBranch = (cwd: string): Promise<null | string> => {
+  const pending = inflight.get(cwd)
+
+  if (pending) {
+    return pending
+  }
+
+  const p = resolveBranch(cwd).finally(() => inflight.delete(cwd))
+  inflight.set(cwd, p)
+
+  return p
+}
+
+export function useGitBranch(cwd: string): null | string {
+  const [branch, setBranch] = useState<null | string>(() => cache.get(cwd)?.branch ?? null)
+
+  useEffect(() => {
+    let cancelled = false
+
+    const tick = async () => {
+      const hit = cache.get(cwd)
+
+      if (hit && Date.now() - hit.at < TTL_MS) {
+        if (!cancelled) {
+          setBranch(hit.branch)
+        }
+
+        return
+      }
+
+      const b = await fetchBranch(cwd)
+      cache.set(cwd, { at: Date.now(), branch: b })
+
+      if (!cancelled) {
+        setBranch(b)
+      }
+    }
+
+    void tick()
+    const id = setInterval(() => void tick(), TTL_MS)
+
+    return () => {
+      cancelled = true
+      clearInterval(id)
+    }
+  }, [cwd])
+
+  return branch
+}

package/src/hooks/useInputHistory.ts

@@ -0,0 +1,11 @@
+import { useRef, useState } from 'react'
+
+import * as inputHistory from '../lib/history.js'
+
+export function useInputHistory() {
+  const historyRef = useRef<string[]>(inputHistory.load())
+  const [historyIdx, setHistoryIdx] = useState<number | null>(null)
+  const historyDraftRef = useRef('')
+
+  return { historyRef, historyIdx, setHistoryIdx, historyDraftRef, pushHistory: inputHistory.append }
+}

package/src/hooks/useQueue.ts

@@ -0,0 +1,76 @@
+import { useCallback, useRef, useState } from 'react'
+
+// Mutates `arr` in place; returned reference is the same input array, kept
+// so callers can chain. Use `Array.prototype.toSpliced` if you need a copy.
+export function removeAtInPlace<T>(arr: T[], i: number): T[] {
+  if (i < 0 || i >= arr.length) {
+    return arr
+  }
+
+  arr.splice(i, 1)
+
+  return arr
+}
+
+export function useQueue() {
+  const queueRef = useRef<string[]>([])
+  const [queuedDisplay, setQueuedDisplay] = useState<string[]>([])
+  const queueEditRef = useRef<number | null>(null)
+  const [queueEditIdx, setQueueEditIdx] = useState<number | null>(null)
+
+  const syncQueue = useCallback(() => setQueuedDisplay([...queueRef.current]), [])
+
+  const setQueueEdit = useCallback((idx: number | null) => {
+    queueEditRef.current = idx
+    setQueueEditIdx(idx)
+  }, [])
+
+  const enqueue = useCallback(
+    (text: string) => {
+      queueRef.current.push(text)
+      syncQueue()
+    },
+    [syncQueue]
+  )
+
+  const dequeue = useCallback(() => {
+    const head = queueRef.current.shift()
+    syncQueue()
+
+    return head
+  }, [syncQueue])
+
+  const replaceQ = useCallback(
+    (i: number, text: string) => {
+      queueRef.current[i] = text
+      syncQueue()
+    },
+    [syncQueue]
+  )
+
+  const removeQ = useCallback(
+    (i: number) => {
+      const before = queueRef.current.length
+
+      removeAtInPlace(queueRef.current, i)
+
+      if (queueRef.current.length !== before) {
+        syncQueue()
+      }
+    },
+    [syncQueue]
+  )
+
+  return {
+    dequeue,
+    enqueue,
+    queueEditIdx,
+    queueEditRef,
+    queueRef,
+    queuedDisplay,
+    removeQ,
+    replaceQ,
+    setQueueEdit,
+    syncQueue
+  }
+}