@remix-run/cli 0.0.0 → 0.1.0

package/src/lib/remix-version.ts

@@ -0,0 +1,80 @@
+import * as fs from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import * as path from 'node:path'
+import * as process from 'node:process'
+import { fileURLToPath } from 'node:url'
+
+interface RemixPackageJson {
+  name?: unknown
+  version?: unknown
+}
+
+export async function resolveDefaultRemixVersion(
+  cwd: string = process.cwd(),
+): Promise<string | undefined> {
+  for (let packageJsonPath of getRemixPackageJsonCandidates(cwd)) {
+    let version = await readRemixPackageVersion(packageJsonPath)
+    if (version != null) {
+      return version
+    }
+  }
+}
+
+function getRemixPackageJsonCandidates(cwd: string): string[] {
+  let candidates: string[] = []
+  let seen = new Set<string>()
+
+  function addCandidate(filePath: string | undefined): void {
+    if (filePath == null) {
+      return
+    }
+
+    let resolvedPath = path.resolve(filePath)
+    if (seen.has(resolvedPath)) {
+      return
+    }
+
+    seen.add(resolvedPath)
+    candidates.push(resolvedPath)
+  }
+
+  function addResolvedPackageJson(basePath: string): void {
+    try {
+      addCandidate(createRequire(basePath).resolve('remix/package.json'))
+    } catch {}
+  }
+
+  addResolvedPackageJson(path.join(cwd, 'package.json'))
+
+  if (process.argv[1] != null) {
+    addResolvedPackageJson(path.resolve(process.argv[1]))
+  }
+
+  addResolvedPackageJson(import.meta.url)
+  addCandidate(
+    path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../remix/package.json'),
+  )
+
+  return candidates
+}
+
+async function readRemixPackageVersion(packageJsonPath: string): Promise<string | undefined> {
+  let packageJson: RemixPackageJson
+
+  try {
+    packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8')) as RemixPackageJson
+  } catch {
+    return undefined
+  }
+
+  if (packageJson.name !== 'remix') {
+    return undefined
+  }
+
+  if (typeof packageJson.version !== 'string') {
+    return undefined
+  }
+
+  let version = packageJson.version.trim()
+  return version.length === 0 ? undefined : version
+}

package/src/lib/reporter.ts

@@ -0,0 +1,535 @@
+import * as process from 'node:process'
+
+import {
+  bold,
+  canUseAnsi,
+  clearCurrentLine,
+  lightGray,
+  lightGreen,
+  lightRed,
+  lightYellow,
+  remixWordmark,
+} from './terminal.ts'
+
+const BULLET = '•'
+const DOT_FRAMES = ['.', '..', '...'] as const
+const DEFAULT_INDENT = '  '
+const DEFAULT_STATUS_FRAME_INTERVAL_MS = 250
+
+interface StepProgressLabel {
+  complete: string
+  running?: string
+}
+
+export interface CommandReporter {
+  finish(): void
+  out: TextChannel
+  status: StatusChannel
+}
+
+export interface TableOptions {
+  headers: string[]
+  noHeaders?: boolean
+  rows: string[][]
+  formatRow?: (line: string, rowIndex: number) => string
+}
+
+export interface TextChannel {
+  blank(): void
+  bullet(text: string): void
+  bullets(items: string[]): void
+  dedent(): void
+  indent(): void
+  label(tag: string, text: string, options?: LabelOptions): string
+  line(text?: string): void
+  section(title: string, callback?: () => void): void
+  table(options: TableOptions): void
+  withIndent<result>(callback: () => result): result
+}
+
+export interface StatusChannel extends TextChannel {
+  commandHeader(commandLabel: string): Promise<void>
+  failStep(label?: string): void
+  skipStep(label: string, reason?: string): void
+  startStep(label: string): void
+  succeedStep(label?: string): void
+  summaryGap(): void
+}
+
+export interface LabelOptions {
+  tone?: 'error' | 'warn'
+}
+
+export interface CreateCommandReporterOptions {
+  remixVersion?: string
+  stderr?: NodeJS.WriteStream
+  statusFrameIntervalMs?: number
+  stdout?: NodeJS.WriteStream
+}
+
+export interface StepProgressReporter<step extends string> {
+  fail(step: step): void
+  skip(step: step, reason?: string): void
+  start(step: step): void
+  succeed(step: step): void
+  writeSummaryGap(): void
+}
+
+export function createCommandReporter(options: CreateCommandReporterOptions = {}): CommandReporter {
+  let stdout = options.stdout ?? process.stdout
+  let stderr = options.stderr ?? process.stderr
+  let session = new ReporterSessionState()
+  let states = new Map<NodeJS.WriteStream, ReporterStreamState>()
+  let getState = (stream: NodeJS.WriteStream) => {
+    let state = states.get(stream)
+    if (state != null) {
+      return state
+    }
+
+    state = new ReporterStreamState(stream, session)
+    states.set(stream, state)
+    return state
+  }
+
+  return {
+    finish() {
+      for (let state of states.values()) {
+        state.finish()
+      }
+    },
+    out: new ReporterTextChannel(stdout, getState(stdout)),
+    status: new ReporterStatusChannel(
+      stderr,
+      getState(stderr),
+      options.statusFrameIntervalMs ?? DEFAULT_STATUS_FRAME_INTERVAL_MS,
+      options.remixVersion,
+    ),
+  }
+}
+
+export function createStepProgressReporter<step extends string>(
+  status: StatusChannel,
+  labels: Record<step, string | StepProgressLabel>,
+): StepProgressReporter<step> {
+  return {
+    fail(step) {
+      status.failStep(getCompleteLabel(labels[step]))
+    },
+    skip(step, reason) {
+      status.skipStep(getCompleteLabel(labels[step]), reason)
+    },
+    start(step) {
+      status.startStep(getRunningLabel(labels[step]))
+    },
+    succeed(step) {
+      status.succeedStep(getCompleteLabel(labels[step]))
+    },
+    writeSummaryGap() {
+      status.summaryGap()
+    },
+  }
+}
+
+export async function runProgressStep<step extends string, result>(
+  progress: StepProgressReporter<step> | null | undefined,
+  step: step,
+  callback: () => Promise<result>,
+): Promise<result> {
+  progress?.start(step)
+
+  try {
+    let result = await callback()
+    progress?.succeed(step)
+    return result
+  } catch (error) {
+    progress?.fail(step)
+    throw error
+  }
+}
+
+class ReporterTextChannel implements TextChannel {
+  #indentLevel = 0
+  #state: ReporterStreamState
+  #stream: NodeJS.WriteStream
+
+  constructor(stream: NodeJS.WriteStream, state: ReporterStreamState) {
+    this.#stream = stream
+    this.#state = state
+  }
+
+  blank(): void {
+    if (!this.#state.hasWrittenContent()) {
+      return
+    }
+
+    this.#state.queueBlank()
+  }
+
+  bullet(text: string): void {
+    this.line(`${BULLET} ${text}`)
+  }
+
+  bullets(items: string[]): void {
+    for (let item of items) {
+      this.bullet(item)
+    }
+  }
+
+  dedent(): void {
+    this.#indentLevel = Math.max(0, this.#indentLevel - 1)
+  }
+
+  indent(): void {
+    this.#indentLevel += 1
+  }
+
+  label(tag: string, text: string, options?: LabelOptions): string {
+    let line = text.length === 0 ? formatLabel(tag) : `${formatLabel(tag)} ${text}`
+
+    if (options?.tone === 'warn') {
+      return lightYellow(line, this.#stream)
+    }
+
+    if (options?.tone === 'error') {
+      return lightRed(line, this.#stream)
+    }
+
+    return line
+  }
+
+  line(text = ''): void {
+    if (text.length === 0) {
+      this.blank()
+      return
+    }
+
+    this.#flushPendingBlank()
+    this.#write(`${this.#getIndent()}${text}\n`)
+  }
+
+  section(title: string, callback?: () => void): void {
+    this.line(title)
+    if (callback == null) {
+      return
+    }
+
+    this.withIndent(callback)
+  }
+
+  table({ formatRow, headers, noHeaders = false, rows }: TableOptions): void {
+    let columnCount = Math.max(headers.length, ...rows.map((row) => row.length))
+    let widths = Array.from({ length: columnCount }, (_, columnIndex) => {
+      let headerWidth = headers[columnIndex]?.length ?? 0
+      let rowWidth = rows.reduce((width, row) => Math.max(width, row[columnIndex]?.length ?? 0), 0)
+      return Math.max(headerWidth, rowWidth)
+    })
+
+    if (!noHeaders) {
+      this.line(
+        headers
+          .map((header, columnIndex) =>
+            bold(header.padEnd(widths[columnIndex] ?? header.length), this.#stream),
+          )
+          .join('  '),
+      )
+    }
+
+    rows.forEach((row, rowIndex) => {
+      let line = row
+        .map((cell, columnIndex) => cell.padEnd(widths[columnIndex] ?? cell.length))
+        .join('  ')
+      this.line(formatRow == null ? line : formatRow(line, rowIndex))
+    })
+  }
+
+  withIndent<result>(callback: () => result): result {
+    this.indent()
+
+    try {
+      return callback()
+    } finally {
+      this.dedent()
+    }
+  }
+
+  getStream(): NodeJS.WriteStream {
+    return this.#stream
+  }
+
+  writeImmediate(text: string): void {
+    this.#state.writeImmediate(text)
+  }
+
+  getIndentText(): string {
+    return this.#getIndent()
+  }
+
+  #flushPendingBlank(): void {
+    this.#state.flushPendingBlank()
+  }
+
+  #getIndent(): string {
+    return DEFAULT_INDENT.repeat(this.#indentLevel)
+  }
+
+  #write(text: string): void {
+    this.#state.write(text)
+  }
+}
+
+class ReporterStatusChannel extends ReporterTextChannel implements StatusChannel {
+  #activeLabel: string | null = null
+  #activeTimer: NodeJS.Timeout | null = null
+  #frameIndex = 0
+  #frameIntervalMs: number
+  #hasRenderedStep = false
+  #hasWrittenSummaryGap = false
+  #remixVersion: string | undefined
+
+  constructor(
+    stream: NodeJS.WriteStream,
+    state: ReporterStreamState,
+    frameIntervalMs: number,
+    remixVersion: string | undefined,
+  ) {
+    super(stream, state)
+    this.#frameIntervalMs = frameIntervalMs
+    this.#remixVersion = remixVersion
+  }
+
+  async commandHeader(commandLabel: string): Promise<void> {
+    if (!this.getStream().isTTY || this.#remixVersion == null) {
+      return
+    }
+
+    this.writeImmediate(
+      `${remixWordmark(this.getStream())} v${this.#remixVersion} - ${commandLabel}\n\n`,
+    )
+  }
+
+  failStep(label = this.#activeLabel ?? ''): void {
+    this.#stopAnimation()
+    this.#activeLabel = null
+    this.#noteStepOutput()
+    this.#writeFinalLine(this.#formatFailedLine(label))
+  }
+
+  skipStep(label: string, reason?: string): void {
+    this.#stopAnimation()
+    if (this.#activeLabel === label) {
+      this.#activeLabel = null
+    }
+    this.#noteStepOutput()
+    this.#writeFinalLine(this.#formatSkippedLine(label, reason))
+  }
+
+  startStep(label: string): void {
+    this.#stopAnimation()
+    this.#activeLabel = label
+    this.#noteStepOutput()
+
+    if (this.#isInteractive()) {
+      this.#frameIndex = 0
+      this.writeImmediate(this.#renderLiveLine(this.#formatRunningLine(label, DOT_FRAMES[0])))
+      this.#activeTimer = setInterval(() => {
+        if (this.#activeLabel == null) {
+          return
+        }
+
+        this.#frameIndex = (this.#frameIndex + 1) % DOT_FRAMES.length
+        this.writeImmediate(
+          this.#renderLiveLine(
+            this.#formatRunningLine(this.#activeLabel, DOT_FRAMES[this.#frameIndex]),
+          ),
+        )
+      }, this.#frameIntervalMs)
+      this.#activeTimer.unref?.()
+      return
+    }
+
+    this.writeImmediate(`${this.#formatRunningLine(label, '...')}\n`)
+  }
+
+  succeedStep(label = this.#activeLabel ?? ''): void {
+    this.#stopAnimation()
+    this.#activeLabel = null
+    this.#noteStepOutput()
+    this.#writeFinalLine(this.#formatSucceededLine(label))
+  }
+
+  summaryGap(): void {
+    if (!this.#hasRenderedStep || this.#hasWrittenSummaryGap) {
+      return
+    }
+
+    this.writeImmediate('\n')
+    this.#hasWrittenSummaryGap = true
+  }
+
+  #formatFailedLine(label: string): string {
+    return `${this.getIndentText()}${lightRed('✗', this.getStream())} ${lightGray(label, this.getStream())}`
+  }
+
+  #formatRunningLine(label: string, dots: string): string {
+    return lightGray(`${this.getIndentText()}${BULLET} ${label}${dots}`, this.getStream())
+  }
+
+  #formatSkippedLine(label: string, reason?: string): string {
+    let line = reason == null ? `${BULLET} ${label}` : `${BULLET} ${label} (skipped: ${reason})`
+    return lightGray(`${this.getIndentText()}${line}`, this.getStream())
+  }
+
+  #formatSucceededLine(label: string): string {
+    return `${this.getIndentText()}${lightGreen('✓', this.getStream())} ${lightGray(label, this.getStream())}`
+  }
+
+  #isInteractive(): boolean {
+    return canUseAnsi(this.getStream())
+  }
+
+  #noteStepOutput(): void {
+    this.#hasRenderedStep = true
+    this.#hasWrittenSummaryGap = false
+  }
+
+  #renderLiveLine(line: string): string {
+    return `${clearCurrentLine()}${line}`
+  }
+
+  #stopAnimation(): void {
+    if (this.#activeTimer != null) {
+      clearInterval(this.#activeTimer)
+      this.#activeTimer = null
+    }
+  }
+
+  #writeFinalLine(line: string): void {
+    if (this.#isInteractive()) {
+      this.writeImmediate(`${this.#renderLiveLine(line)}\n`)
+      return
+    }
+
+    this.writeImmediate(`${line}\n`)
+  }
+}
+
+class ReporterStreamState {
+  #hasWrittenContent = false
+  #pendingBlank = false
+  #session: ReporterSessionState
+  #stream: NodeJS.WriteStream
+  #trailingNewlineCount = 0
+
+  constructor(stream: NodeJS.WriteStream, session: ReporterSessionState) {
+    this.#session = session
+    this.#stream = stream
+  }
+
+  finish(): void {
+    if (!this.#hasWrittenContent) {
+      return
+    }
+
+    if (this.#trailingNewlineCount >= 2) {
+      return
+    }
+
+    this.#writeRaw('\n')
+    this.#pendingBlank = false
+  }
+
+  flushPendingBlank(): void {
+    if (!this.#pendingBlank) {
+      return
+    }
+
+    this.#writeRaw('\n')
+    this.#pendingBlank = false
+  }
+
+  hasWrittenContent(): boolean {
+    return this.#hasWrittenContent
+  }
+
+  queueBlank(): void {
+    this.#pendingBlank = true
+  }
+
+  write(text: string): void {
+    if (!this.#session.hasWrittenPreamble()) {
+      this.#writeRaw('\n')
+      this.#session.markPreambleWritten()
+    }
+
+    this.#writeRaw(text)
+    this.#hasWrittenContent = true
+  }
+
+  writeImmediate(text: string): void {
+    if (!this.#session.hasWrittenPreamble()) {
+      this.#writeRaw('\n')
+      this.#session.markPreambleWritten()
+    }
+
+    this.#writeRaw(text)
+    this.#hasWrittenContent = true
+    this.#pendingBlank = false
+  }
+
+  #writeRaw(text: string): void {
+    this.#stream.write(text)
+    this.#updateTrailingNewlines(text)
+  }
+
+  #updateTrailingNewlines(text: string): void {
+    let trailingNewlines = 0
+
+    for (let index = text.length - 1; index >= 0; index--) {
+      if (text[index] !== '\n') {
+        break
+      }
+
+      trailingNewlines += 1
+    }
+
+    if (trailingNewlines === 0) {
+      this.#trailingNewlineCount = 0
+      return
+    }
+
+    if (trailingNewlines === text.length) {
+      this.#trailingNewlineCount += trailingNewlines
+      return
+    }
+
+    this.#trailingNewlineCount = trailingNewlines
+  }
+}
+
+class ReporterSessionState {
+  #hasWrittenPreamble = false
+
+  hasWrittenPreamble(): boolean {
+    return this.#hasWrittenPreamble
+  }
+
+  markPreambleWritten(): void {
+    this.#hasWrittenPreamble = true
+  }
+}
+
+function formatLabel(tag: string): string {
+  if (tag.startsWith('[') && tag.endsWith(']')) {
+    return tag
+  }
+
+  return `[${tag}]`
+}
+
+function getCompleteLabel(label: string | StepProgressLabel): string {
+  return typeof label === 'string' ? label : label.complete
+}
+
+function getRunningLabel(label: string | StepProgressLabel): string {
+  return typeof label === 'string' ? label : (label.running ?? label.complete)
+}