@kaynooo/cli-kit 0.0.0-stage → 0.7.3

package/src/style.ts

@@ -0,0 +1,73 @@
+import process from 'node:process'
+import { createColors } from '@kaynooo/utils/tools/colors'
+
+export type Colors = ReturnType<typeof createColors>
+
+export type Mark = 'ok' | 'warn' | 'problem' | 'note'
+
+// The symbol each mark draws on a terminal, and the word it prints as anywhere else, so a log stays greppable.
+const MARKS: Record<Mark, { symbol: string, word: string, paint: (colors: Colors) => (text: string) => string }> = {
+  ok: { symbol: '✓', word: 'ok:', paint: colors => colors.green },
+  warn: { symbol: '!', word: 'warning:', paint: colors => colors.yellow },
+  problem: { symbol: '✗', word: 'error:', paint: colors => colors.red },
+  note: { symbol: '·', word: 'note:', paint: colors => colors.dim },
+}
+
+// A terminal that draws in place: not a log or a pipe, and not asked for plain output by `NO_COLOR` or a dumb `TERM`.
+export function takesControlCodes(stream: { isTTY?: boolean }, env: Record<string, string | undefined> = process.env): boolean {
+  return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== 'dumb'
+}
+
+// Colours that write escapes only to a stream taking control codes.
+export function paint(stream: { isTTY?: boolean }, env: Record<string, string | undefined> = process.env): Colors {
+  return createColors({ stream: { isTTY: takesControlCodes(stream, env) }, env })
+}
+
+// `✓ text` on a terminal, `ok: text` elsewhere; `detail` follows dimmed.
+export function marked(mark: Mark, text: string, stream: { isTTY?: boolean }, detail?: string, env: Record<string, string | undefined> = process.env): string {
+  const colors = paint(stream, env)
+  const { symbol, word, paint: tint } = MARKS[mark]
+  const head = takesControlCodes(stream, env) ? tint(colors)(symbol) : word
+
+  return `${head} ${text}${detail === undefined ? '' : ` ${colors.dim(detail)}`}`
+}
+
+export function ok(text: string, detail?: string): void {
+  console.log(marked('ok', text, process.stdout, detail))
+}
+
+export function note(text: string, detail?: string): void {
+  console.log(marked('note', text, process.stdout, detail))
+}
+
+export function warn(text: string, detail?: string): void {
+  console.error(marked('warn', text, process.stderr, detail))
+}
+
+export function problem(text: string, detail?: string): void {
+  console.error(marked('problem', text, process.stderr, detail))
+}
+
+export type Role = 'accent' | 'id' | 'path' | 'label' | 'value'
+
+// The tint each kind of data is drawn in, so every CLI colours the same things the same way.
+const ROLES: Record<Role, (colors: Colors) => (text: string) => string> = {
+  accent: colors => colors.cyan,
+  id: colors => colors.yellow,
+  path: colors => colors.blue,
+  label: colors => colors.dim,
+  value: colors => colors.bold,
+}
+
+// `role('id', process.stdout)('#49')`: plain text on a stream that takes no control codes.
+export function role(name: Role, stream: { isTTY?: boolean }, env: Record<string, string | undefined> = process.env): (text: string) => string {
+  return ROLES[name](paint(stream, env))
+}
+
+// A clickable OSC 8 link on a terminal; elsewhere `text (url)`, or the text alone when it is the url.
+export function link(text: string, url: string, stream: { isTTY?: boolean }, env: Record<string, string | undefined> = process.env): string {
+  if (takesControlCodes(stream, env))
+    return `\x1B]8;;${url}\x1B\\${text}\x1B]8;;\x1B\\`
+
+  return text === url ? text : `${text} (${url})`
+}

package/src/test.ts

@@ -0,0 +1,42 @@
+import process from 'node:process'
+import { format } from 'node:util'
+
+export interface Captured<T> {
+  result: T
+  // Everything printed to stdout (console.log, console.info and process.stdout.write).
+  out: string
+  // Everything printed to stderr (console.error, console.warn and process.stderr.write).
+  err: string
+}
+
+// Runs a command in-process and returns what it printed, so a test needs no spy on console. Output is restored even when the command throws.
+export async function capture<T>(run: () => Promise<T> | T): Promise<Captured<T>> {
+  const written = { out: '', err: '' }
+  const saved = { log: console.log, info: console.info, error: console.error, warn: console.warn, stdout: process.stdout.write.bind(process.stdout), stderr: process.stderr.write.bind(process.stderr) }
+  const line = (name: 'out' | 'err') => (...parts: unknown[]) => {
+    written[name] += `${format(...parts)}\n`
+  }
+  const chunk = (name: 'out' | 'err') => (data: string | Uint8Array) => {
+    written[name] += typeof data === 'string' ? data : Buffer.from(data).toString()
+
+    return true
+  }
+
+  console.log = line('out')
+  console.info = line('out')
+  console.error = line('err')
+  console.warn = line('err')
+  process.stdout.write = chunk('out')
+  process.stderr.write = chunk('err')
+
+  try {
+    const result = await run()
+
+    return { result, ...written }
+  }
+  finally {
+    Object.assign(console, { log: saved.log, info: saved.info, error: saved.error, warn: saved.warn })
+    process.stdout.write = saved.stdout
+    process.stderr.write = saved.stderr
+  }
+}

package/src/text.ts

@@ -0,0 +1,21 @@
+const ANSI = new RegExp(`${String.fromCharCode(27)}\\[[\\d;?]*[a-z]`, 'gi')
+
+export function stripAnsi(text: string): string {
+  return text.replace(ANSI, '')
+}
+
+// Edit distance between two names, for pointing a mistyped name at the one meant.
+export function distance(a: string, b: string): number {
+  let previous = Array.from({ length: b.length + 1 }, (_, index) => index)
+
+  for (const [i, left] of [...a].entries()) {
+    const current = [i + 1]
+
+    for (const [j, right] of [...b].entries())
+      current.push(Math.min((previous[j + 1] ?? 0) + 1, (current[j] ?? 0) + 1, (previous[j] ?? 0) + (left === right ? 0 : 1)))
+
+    previous = current
+  }
+
+  return previous[b.length] ?? 0
+}