nastech-tui 0.0.1

package/packages/nastech-ink/src/ink/useTerminalNotification.ts

@@ -0,0 +1,110 @@
+import { createContext, useCallback, useContext, useMemo } from 'react'
+
+import { isProgressReportingAvailable, type Progress } from './terminal.js'
+import { BEL } from './termio/ansi.js'
+import { ITERM2, OSC, osc, PROGRESS, wrapForMultiplexer } from './termio/osc.js'
+
+type WriteRaw = (data: string) => void
+
+export const TerminalWriteContext = createContext<WriteRaw | null>(null)
+
+export const TerminalWriteProvider = TerminalWriteContext.Provider
+
+export type TerminalNotification = {
+  notifyITerm2: (opts: { message: string; title?: string }) => void
+  notifyKitty: (opts: { message: string; title: string; id: number }) => void
+  notifyGhostty: (opts: { message: string; title: string }) => void
+  notifyBell: () => void
+  /**
+   * Report progress to the terminal via OSC 9;4 sequences.
+   * Supported terminals: ConEmu, Ghostty 1.2.0+, iTerm2 3.6.6+
+   * Pass state=null to clear progress.
+   */
+  progress: (state: Progress['state'] | null, percentage?: number) => void
+}
+
+export function useTerminalNotification(): TerminalNotification {
+  const writeRaw = useContext(TerminalWriteContext)
+
+  if (!writeRaw) {
+    throw new Error('useTerminalNotification must be used within TerminalWriteProvider')
+  }
+
+  const notifyITerm2 = useCallback(
+    ({ message, title }: { message: string; title?: string }) => {
+      const displayString = title ? `${title}:\n${message}` : message
+      writeRaw(wrapForMultiplexer(osc(OSC.ITERM2, `\n\n${displayString}`)))
+    },
+    [writeRaw]
+  )
+
+  const notifyKitty = useCallback(
+    ({ message, title, id }: { message: string; title: string; id: number }) => {
+      writeRaw(wrapForMultiplexer(osc(OSC.KITTY, `i=${id}:d=0:p=title`, title)))
+      writeRaw(wrapForMultiplexer(osc(OSC.KITTY, `i=${id}:p=body`, message)))
+      writeRaw(wrapForMultiplexer(osc(OSC.KITTY, `i=${id}:d=1:a=focus`, '')))
+    },
+    [writeRaw]
+  )
+
+  const notifyGhostty = useCallback(
+    ({ message, title }: { message: string; title: string }) => {
+      writeRaw(wrapForMultiplexer(osc(OSC.GHOSTTY, 'notify', title, message)))
+    },
+    [writeRaw]
+  )
+
+  const notifyBell = useCallback(() => {
+    // Raw BEL — inside tmux this triggers tmux's bell-action (window flag).
+    // Wrapping would make it opaque DCS payload and lose that fallback.
+    writeRaw(BEL)
+  }, [writeRaw])
+
+  const progress = useCallback(
+    (state: Progress['state'] | null, percentage?: number) => {
+      if (!isProgressReportingAvailable()) {
+        return
+      }
+
+      if (!state) {
+        writeRaw(wrapForMultiplexer(osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.CLEAR, '')))
+
+        return
+      }
+
+      const pct = Math.max(0, Math.min(100, Math.round(percentage ?? 0)))
+
+      switch (state) {
+        case 'completed':
+          writeRaw(wrapForMultiplexer(osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.CLEAR, '')))
+
+          break
+
+        case 'error':
+          writeRaw(wrapForMultiplexer(osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.ERROR, pct)))
+
+          break
+
+        case 'indeterminate':
+          writeRaw(wrapForMultiplexer(osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.INDETERMINATE, '')))
+
+          break
+
+        case 'running':
+          writeRaw(wrapForMultiplexer(osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.SET, pct)))
+
+          break
+
+        case null:
+          // Handled by the if guard above
+          break
+      }
+    },
+    [writeRaw]
+  )
+
+  return useMemo(
+    () => ({ notifyITerm2, notifyKitty, notifyGhostty, notifyBell, progress }),
+    [notifyITerm2, notifyKitty, notifyGhostty, notifyBell, progress]
+  )
+}

package/packages/nastech-ink/src/ink/warn.ts

@@ -0,0 +1,15 @@
+import { logForDebugging } from '../utils/debug.js'
+
+export function ifNotInteger(value: number | undefined, name: string): void {
+  if (value === undefined) {
+    return
+  }
+
+  if (Number.isInteger(value)) {
+    return
+  }
+
+  logForDebugging(`${name} should be an integer, got ${value}`, {
+    level: 'warn'
+  })
+}

package/packages/nastech-ink/src/ink/widest-line.ts

@@ -0,0 +1,22 @@
+import { lineWidth } from './line-width-cache.js'
+
+export function widestLine(string: string): number {
+  let maxWidth = 0
+  let start = 0
+
+  while (start <= string.length) {
+    const end = string.indexOf('\n', start)
+
+    const line = end === -1 ? string.substring(start) : string.substring(start, end)
+
+    maxWidth = Math.max(maxWidth, lineWidth(line))
+
+    if (end === -1) {
+      break
+    }
+
+    start = end + 1
+  }
+
+  return maxWidth
+}

package/packages/nastech-ink/src/ink/wrap-text.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+
+import wrapText from './wrap-text.js'
+
+describe('wrapText wrap-trim', () => {
+  it('removes a single soft-wrap boundary space', () => {
+    expect(wrapText('Let me', 5, 'wrap-trim')).toBe('Let\nme')
+  })
+
+  it('preserves extra original spacing at soft-wrap boundaries', () => {
+    expect(wrapText('foo  bar', 5, 'wrap-trim')).toBe('foo \nbar')
+  })
+
+  it('preserves leading whitespace on unwrapped source lines', () => {
+    expect(wrapText('  indented', 20, 'wrap-trim')).toBe('  indented')
+  })
+})

package/packages/nastech-ink/src/ink/wrap-text.ts

@@ -0,0 +1,144 @@
+import sliceAnsi from '../utils/sliceAnsi.js'
+
+import { lruEvict } from './lru.js'
+import { stringWidth } from './stringWidth.js'
+import type { Styles } from './styles.js'
+import { wrapAnsi } from './wrapAnsi.js'
+
+const ELLIPSIS = '…'
+
+// CPU profile (Apr 2026) showed `wrap-ansi` → `string-width` consuming 30% of
+// total runtime during fast scroll: every layout pass re-wraps every visible
+// line via wrap-ansi, which calls string-width once per grapheme. The output
+// is pure of (text, maxWidth, wrapType), so memoize it. LRU-bounded so long
+// sessions don't accrete unbounded cache.
+const WRAP_CACHE_LIMIT = 4096
+const wrapCache = new Map<string, string>()
+
+function memoizedWrap(text: string, maxWidth: number, wrapType: Styles['textWrap']): string {
+  // Key folds maxWidth + wrapType into the prefix so the same text re-wrapped
+  // at a different width doesn't collide. Width prefix bounded by viewport
+  // (~10 distinct widths in a session); wrapType bounded by enum (~6 values).
+  const key = `${maxWidth}|${wrapType}|${text}`
+  const cached = wrapCache.get(key)
+
+  if (cached !== undefined) {
+    // LRU touch
+    wrapCache.delete(key)
+    wrapCache.set(key, cached)
+
+    return cached
+  }
+
+  const result = computeWrap(text, maxWidth, wrapType)
+
+  if (wrapCache.size >= WRAP_CACHE_LIMIT) {
+    wrapCache.delete(wrapCache.keys().next().value!)
+  }
+
+  wrapCache.set(key, result)
+
+  return result
+}
+
+// sliceAnsi may include a boundary-spanning wide char (e.g. CJK at position
+// end-1 with width 2 overshoots by 1). Retry with a tighter bound once.
+function sliceFit(text: string, start: number, end: number): string {
+  const s = sliceAnsi(text, start, end)
+
+  return stringWidth(s) > end - start ? sliceAnsi(text, start, end - 1) : s
+}
+
+function truncate(text: string, columns: number, position: 'start' | 'middle' | 'end'): string {
+  if (columns < 1) {
+    return ''
+  }
+
+  if (columns === 1) {
+    return ELLIPSIS
+  }
+
+  const length = stringWidth(text)
+
+  if (length <= columns) {
+    return text
+  }
+
+  if (position === 'start') {
+    return ELLIPSIS + sliceFit(text, length - columns + 1, length)
+  }
+
+  if (position === 'middle') {
+    const half = Math.floor(columns / 2)
+
+    return sliceFit(text, 0, half) + ELLIPSIS + sliceFit(text, length - (columns - half) + 1, length)
+  }
+
+  return sliceFit(text, 0, columns - 1) + ELLIPSIS
+}
+
+function trimSoftWrapBoundaries(text: string, maxWidth: number): string {
+  return text
+    .split('\n')
+    .map(line => {
+      const pieces = wrapAnsi(line, maxWidth, { trim: false, hard: true }).split('\n')
+
+      if (pieces.length === 1) {
+        return pieces[0]!
+      }
+
+      for (let index = 0; index < pieces.length - 1; index++) {
+        const current = pieces[index]!
+        const next = pieces[index + 1]!
+
+        if (/\s$/.test(current)) {
+          pieces[index] = current.replace(/\s$/, '')
+        } else if (/^\s/.test(next)) {
+          pieces[index + 1] = next.replace(/^\s/, '')
+        }
+      }
+
+      return pieces.join('\n')
+    })
+    .join('\n')
+}
+
+function computeWrap(text: string, maxWidth: number, wrapType: Styles['textWrap']): string {
+  if (wrapType === 'wrap') {
+    return wrapAnsi(text, maxWidth, { trim: false, hard: true })
+  }
+
+  if (wrapType === 'wrap-char') {
+    return wrapAnsi(text, maxWidth, { trim: false, hard: true, wordWrap: false })
+  }
+
+  if (wrapType === 'wrap-trim') {
+    return trimSoftWrapBoundaries(text, maxWidth)
+  }
+
+  if (wrapType!.startsWith('truncate')) {
+    const position: 'end' | 'middle' | 'start' =
+      wrapType === 'truncate-middle' ? 'middle' : wrapType === 'truncate-start' ? 'start' : 'end'
+
+    return truncate(text, maxWidth, position)
+  }
+
+  return text
+}
+
+export default function wrapText(text: string, maxWidth: number, wrapType: Styles['textWrap']): string {
+  // Skip cache for trivial inputs (faster than Map lookup).
+  if (!text || maxWidth <= 0) {
+    return computeWrap(text, maxWidth, wrapType)
+  }
+
+  return memoizedWrap(text, maxWidth, wrapType)
+}
+
+export function wrapCacheSize(): number {
+  return wrapCache.size
+}
+
+export function evictWrapCache(keepRatio = 0): void {
+  lruEvict(wrapCache, keepRatio)
+}

package/packages/nastech-ink/src/ink/wrapAnsi.ts

@@ -0,0 +1,13 @@
+import wrapAnsiNpm from 'wrap-ansi'
+
+type WrapAnsiOptions = {
+  hard?: boolean
+  wordWrap?: boolean
+  trim?: boolean
+}
+
+const wrapAnsiBun = typeof Bun !== 'undefined' && typeof Bun.wrapAnsi === 'function' ? Bun.wrapAnsi : null
+
+const wrapAnsi: (input: string, columns: number, options?: WrapAnsiOptions) => string = wrapAnsiBun ?? wrapAnsiNpm
+
+export { wrapAnsi }

package/packages/nastech-ink/src/native-ts/yoga-layout/enums.ts

@@ -0,0 +1,112 @@
+export const Align = {
+  Auto: 0,
+  FlexStart: 1,
+  Center: 2,
+  FlexEnd: 3,
+  Stretch: 4,
+  Baseline: 5,
+  SpaceBetween: 6,
+  SpaceAround: 7,
+  SpaceEvenly: 8
+} as const
+export type Align = (typeof Align)[keyof typeof Align]
+export const BoxSizing = {
+  BorderBox: 0,
+  ContentBox: 1
+} as const
+export type BoxSizing = (typeof BoxSizing)[keyof typeof BoxSizing]
+export const Dimension = {
+  Width: 0,
+  Height: 1
+} as const
+export type Dimension = (typeof Dimension)[keyof typeof Dimension]
+export const Direction = {
+  Inherit: 0,
+  LTR: 1,
+  RTL: 2
+} as const
+export type Direction = (typeof Direction)[keyof typeof Direction]
+export const Display = {
+  Flex: 0,
+  None: 1,
+  Contents: 2
+} as const
+export type Display = (typeof Display)[keyof typeof Display]
+export const Edge = {
+  Left: 0,
+  Top: 1,
+  Right: 2,
+  Bottom: 3,
+  Start: 4,
+  End: 5,
+  Horizontal: 6,
+  Vertical: 7,
+  All: 8
+} as const
+export type Edge = (typeof Edge)[keyof typeof Edge]
+export const Errata = {
+  None: 0,
+  StretchFlexBasis: 1,
+  AbsolutePositionWithoutInsetsExcludesPadding: 2,
+  AbsolutePercentAgainstInnerSize: 4,
+  All: 2147483647,
+  Classic: 2147483646
+} as const
+export type Errata = (typeof Errata)[keyof typeof Errata]
+export const ExperimentalFeature = {
+  WebFlexBasis: 0
+} as const
+export type ExperimentalFeature = (typeof ExperimentalFeature)[keyof typeof ExperimentalFeature]
+export const FlexDirection = {
+  Column: 0,
+  ColumnReverse: 1,
+  Row: 2,
+  RowReverse: 3
+} as const
+export type FlexDirection = (typeof FlexDirection)[keyof typeof FlexDirection]
+export const Gutter = {
+  Column: 0,
+  Row: 1,
+  All: 2
+} as const
+export type Gutter = (typeof Gutter)[keyof typeof Gutter]
+export const Justify = {
+  FlexStart: 0,
+  Center: 1,
+  FlexEnd: 2,
+  SpaceBetween: 3,
+  SpaceAround: 4,
+  SpaceEvenly: 5
+} as const
+export type Justify = (typeof Justify)[keyof typeof Justify]
+export const MeasureMode = {
+  Undefined: 0,
+  Exactly: 1,
+  AtMost: 2
+} as const
+export type MeasureMode = (typeof MeasureMode)[keyof typeof MeasureMode]
+export const Overflow = {
+  Visible: 0,
+  Hidden: 1,
+  Scroll: 2
+} as const
+export type Overflow = (typeof Overflow)[keyof typeof Overflow]
+export const PositionType = {
+  Static: 0,
+  Relative: 1,
+  Absolute: 2
+} as const
+export type PositionType = (typeof PositionType)[keyof typeof PositionType]
+export const Unit = {
+  Undefined: 0,
+  Point: 1,
+  Percent: 2,
+  Auto: 3
+} as const
+export type Unit = (typeof Unit)[keyof typeof Unit]
+export const Wrap = {
+  NoWrap: 0,
+  Wrap: 1,
+  WrapReverse: 2
+} as const
+export type Wrap = (typeof Wrap)[keyof typeof Wrap]