@seamapi/cli 0.18.1 → 0.19.0

package/src/lib/util/prompt.ts

@@ -1,229 +0,0 @@
-import type { EventEmitter } from 'node:events'
-import type { Key } from 'node:readline'
-
-import {
-  autocomplete,
-  autocompleteMultiselect,
-  confirm,
-  isCancel,
-  type Option,
-  select,
-  text,
-} from '@clack/prompts'
-import chalk from 'chalk'
-
-import { NonInteractiveError } from './cli-args.js'
-
-/**
- * Whether the CLI can ask the user a question.
- *
- * Prompts read raw keypresses and render an interface, so they need a
- * terminal on both ends: when stdin is a pipe or a file it holds request
- * params, not answers, and when stderr is redirected nobody sees the
- * question.
- */
-export const canPrompt = (): boolean =>
-  process.stdin.isTTY === true && process.stderr.isTTY === true
-
-/** The user dismissed a prompt with ctrl-c or escape instead of answering. */
-export class PromptCancelledError extends Error {
-  constructor() {
-    super('Cancelled')
-  }
-}
-
-export interface PromptChoice<Value> {
-  label: string
-  value: Value
-  hint?: string | undefined
-}
-
-/**
- * Note on a prompt message that dismissing it returns to the previous step.
- *
- * Only for prompts whose caller catches the dismissal: elsewhere it still
- * stops the CLI, and saying otherwise would mislead. The note goes in the
- * message because clack renders its own keyboard hints from a hardcoded list
- * that a caller cannot add to.
- */
-export const withBackHint = (message: string): string =>
-  `${message} ${chalk.dim('· Esc: go back')}`
-
-const ensureInteractive = (): void => {
-  if (!canPrompt()) {
-    throw new NonInteractiveError(
-      'Cannot prompt without a terminal: pass the missing arguments, or pipe them in as JSON',
-    )
-  }
-  installArrowKeyAliases()
-}
-
-/**
- * The arrow keypress an Emacs-style control keypress stands for, or
- * undefined for any other key: ctrl-p is up and ctrl-n is down.
- */
-export const arrowKeyFor = (key: Key | undefined): Key | undefined => {
-  if (key?.ctrl !== true || key.meta === true || key.shift === true) {
-    return undefined
-  }
-  const base = { ctrl: false, meta: false, shift: false }
-  if (key.name === 'p') return { ...base, name: 'up', sequence: '\x1B[A' }
-  if (key.name === 'n') return { ...base, name: 'down', sequence: '\x1B[B' }
-  return undefined
-}
-
-/**
- * Re-emit Emacs-style control keypresses as the arrow keys they stand for.
- *
- * Clack navigates on the readline key name, so a synthetic arrow keypress
- * moves the cursor in every prompt kind. Its own alias table cannot express
- * this: aliases match bare key names, unaware of ctrl, and are ignored by
- * prompts that track typed input, such as autocomplete.
- */
-export const emitArrowKeyAliases = (input: EventEmitter): void => {
-  input.on('keypress', (_char, key: Key | undefined) => {
-    const arrowKey = arrowKeyFor(key)
-    if (arrowKey !== undefined) input.emit('keypress', undefined, arrowKey)
-  })
-}
-
-let arrowKeyAliasesInstalled = false
-
-// Keypress events only flow while a prompt has stdin in raw mode, so the
-// listener is inert the rest of the time and never holds the process open.
-const installArrowKeyAliases = (): void => {
-  if (arrowKeyAliasesInstalled) return
-  arrowKeyAliasesInstalled = true
-  emitArrowKeyAliases(process.stdin)
-}
-
-const unwrap = <Value>(value: Value | symbol): Value => {
-  if (isCancel(value)) throw new PromptCancelledError()
-  return value as Value
-}
-
-// Prompts are rendered to stderr: a selection is not a command result,
-// so it must not end up in stdout when the CLI is piped.
-const output = process.stderr
-
-const toOptions = <Value>(
-  choices: Array<PromptChoice<Value>>,
-): Array<Option<Value>> =>
-  choices.map(
-    ({ label, value, hint }) =>
-      (hint === undefined
-        ? { label, value }
-        : { label, value, hint }) as Option<Value>,
-  )
-
-export const promptText = async (options: {
-  message: string
-  placeholder?: string
-  defaultValue?: string
-  validate?: (value: string | undefined) => string | undefined
-}): Promise<string> => {
-  ensureInteractive()
-  return unwrap(await text({ ...options, output }))
-}
-
-export const promptNumber = async (options: {
-  message: string
-  validate?: (value: number) => string | undefined
-}): Promise<number> => {
-  ensureInteractive()
-  const value = unwrap(
-    await text({
-      message: options.message,
-      validate: (value) => {
-        if (value == null || value.trim() === '') return 'Enter a number'
-        const parsed = Number(value)
-        if (Number.isNaN(parsed)) return 'Enter a number'
-        return options.validate?.(parsed)
-      },
-      output,
-    }),
-  )
-  return Number(value)
-}
-
-export const promptConfirm = async (options: {
-  message: string
-  initialValue?: boolean
-  active?: string
-  inactive?: string
-}): Promise<boolean> => {
-  ensureInteractive()
-  return unwrap(await confirm({ ...options, output }))
-}
-
-export const promptSelect = async <Value>(options: {
-  message: string
-  choices: Array<PromptChoice<Value>>
-}): Promise<Value> => {
-  ensureInteractive()
-  return unwrap(
-    await select<Value>({
-      message: options.message,
-      options: toOptions(options.choices),
-      output,
-    }),
-  )
-}
-
-export const promptAutocomplete = async <Value>(options: {
-  message: string
-  choices: Array<PromptChoice<Value>>
-}): Promise<Value> => {
-  ensureInteractive()
-  return unwrap(
-    await autocomplete<Value>({
-      message: options.message,
-      options: toOptions(options.choices),
-      // Search a list by any part of a name or hint, rather than only by
-      // the label, which is all clack matches for itself.
-      filter: searchChoices,
-      output,
-    }),
-  )
-}
-
-export const promptAutocompleteMultiselect = async <Value>(options: {
-  message: string
-  choices: Array<PromptChoice<Value>>
-}): Promise<Value[]> => {
-  ensureInteractive()
-  return unwrap(
-    await autocompleteMultiselect<Value>({
-      message: options.message,
-      options: toOptions(options.choices),
-      filter: searchChoices,
-      output,
-    }),
-  )
-}
-
-export interface SearchableChoice {
-  label?: string | undefined
-  hint?: string | undefined
-}
-
-/**
- * Match a choice by every whitespace separated term of the input, matched
- * case insensitively against the label and the hint.
- */
-export const searchChoices = (
-  input: string,
-  choice: SearchableChoice,
-): boolean => {
-  const terms = input
-    .toLowerCase()
-    .split(/\s+/)
-    .filter((term) => term.length > 0)
-
-  if (terms.length === 0) return true
-
-  const searchable = `${choice.label ?? ''} ${choice.hint ?? ''}`
-    .toLowerCase()
-    .trim()
-  return terms.every((term) => searchable.includes(term))
-}

package/src/lib/util/request-seam-api.ts

@@ -1,47 +0,0 @@
-import chalk from 'chalk'
-
-import { getSeam } from 'lib/get-seam.js'
-import { getOutput } from 'lib/output/get-output.js'
-import { selectResponsePayload } from 'lib/output/select-response-payload.js'
-
-import { withLoading } from './with-loading.js'
-
-export interface RequestSeamApiOptions {
-  path: string
-  params: Record<string, any>
-  /** Response key for the endpoint, used to trim the reported payload. */
-  responseKey?: string | null | undefined
-}
-
-export const RequestSeamApi = async ({
-  path,
-  params,
-  responseKey,
-}: RequestSeamApiOptions) => {
-  const seam = await getSeam()
-  const output = getOutput()
-
-  output.info(`\n${chalk.green(path)}`)
-  output.info(`Request Params:`)
-  output.info(formatParams(params))
-
-  const response = await withLoading('Making request...', () =>
-    seam.client.post(path, params, {
-      validateStatus: () => true,
-    }),
-  )
-
-  if (response.status >= 400) {
-    output.warn(chalk.red(`[${response.status}]`))
-    process.exitCode = 1
-  } else {
-    output.info(chalk.green(`[${response.status}]`))
-  }
-
-  output.data(selectResponsePayload(response.data, { responseKey }))
-
-  return response
-}
-
-const formatParams = (params: Record<string, any>): string =>
-  JSON.stringify(params, null, 2)