inquirer-plugins 1.0.0-alpha.1

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "inquirer-plugins",
+  "version": "1.0.0-alpha.1",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "prepare": "husky",
+    "lint": "eslint .",
+    "lint:fix": "npm run lint -- --fix",
+    "_prettier": "prettier .",
+    "prettier:write": "npm run _prettier -- --write",
+    "prettier": "npm run prettier:write",
+    "prettier:check": "npm run _prettier -- --check",
+    "clean": "rimraf ./dist ./cli",
+    "tsc": "tsc -p tsconfig.publish.json && tsc-alias -p tsconfig.publish.json",
+    "generate": "tsx --tsconfig ./tsconfig.tsx.json ./tools/generate-alias.zx.ts",
+    "ci:update-version": "tsx --tsconfig ./tsconfig.tsx.json ./tools/update-version.zx.ts",
+    "md:generate": "tsx --tsconfig ./tsconfig.tsx.json ./tools/generate-md.ts",
+    "//--- test ---//": "",
+    "test": "run-s test:*",
+    "test:lint": "npm run lint",
+    "test:prettier": "npm run prettier:check",
+    "//--- build ---//": "",
+    "build": "run-s build:*",
+    "build:test": "npm run test",
+    "build:clean": "npm run clean",
+    "build:tsc": "npm run tsc",
+    "build:generate": "npm run generate",
+    "//--- publish ---//": "",
+    "publish:build": "run-s build:{clean,tsc,generate}",
+    "dry-run": "tsx --tsconfig ./tsconfig.tsx.json ./src/_internal/plugins/test.ts"
+  },
+  "author": "",
+  "license": "MIT",
+  "description": "",
+  "engines": {
+    "node": ">=19.0.0"
+  },
+  "exports": {
+    ".": "./dist/**/*.js",
+    "./table": "./dist/modules/table.js",
+    "./types/inquirer": "./dist/modules/types/inquirer.js",
+    "./types/parse-types": "./dist/modules/types/parse-types.js",
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@actions/core": "^1.10.1",
+    "@actions/exec": "^1.1.1",
+    "@actions/github": "^6.0.0",
+    "chalk": "^5.3.0",
+    "cli-cursor": "^4.0.0",
+    "cli-table3": "^0.6.5",
+    "inquirer": "^9.2.23",
+    "zx": "^8.1.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^8.57.0",
+    "@types/inquirer": "^9.0.7",
+    "@typescript-eslint/eslint-plugin": "^7.9.0",
+    "@typescript-eslint/parser": "^7.9.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-import-resolver-typescript": "^3.6.1",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jest": "^28.5.0",
+    "eslint-plugin-unused-imports": "^3.2.0",
+    "husky": "^9.0.11",
+    "lint-staged": "^15.2.5",
+    "my-gadgetry": "^1.2.5",
+    "npm-run-all2": "^6.2.0",
+    "prettier": "^3.3.1",
+    "tsc-alias": "^1.8.10",
+    "tsx": "^4.14.1",
+    "typescript": "^5.4.5",
+    "typescript-eslint": "^7.12.0"
+  },
+  "files": [
+    "!**/__tests__",
+    "dist",
+    "types",
+    "table",
+    "src",
+    "package.json",
+    "tsconfig.json"
+  ]
+}

package/src/_internal/plugins/table/table.ts

@@ -0,0 +1,68 @@
+import { PARSE_TYPES } from '~types/parse-types.js'
+import { trim } from '~utils/chalk.js'
+import { parse } from '~utils/parse-types.js'
+
+import { Column, Cell } from './types.js'
+
+export class TableClass {
+  columns: Column[] = []
+  rows: string[][] = []
+
+  constructor(columns: Column[], rows: Cell[][]) {
+    this.columns = columns
+    this.rows = rows.map(columns => columns.map(value => `${value}`))
+  }
+
+  get header() {
+    return this.columns.map(({ name }) => `${name}`)
+  }
+
+  getColumnType(columnIndex: number) {
+    if (!(columnIndex in this.columns)) {
+      return PARSE_TYPES.input
+    }
+    return this.columns[columnIndex].type
+  }
+
+  updateRow(rowIndex: number, columnIndex: number, value: string) {
+    if (!(rowIndex in this.rows)) {
+      return
+    }
+    const columns = this.rows[rowIndex]
+    if (!(columnIndex in columns)) {
+      return
+    }
+    const validate = this.columns[columnIndex].validate || (() => true)
+    if (!validate(value)) {
+      return
+    }
+    const parser = this.columns[columnIndex].parser || ((txt: string) => txt)
+    const parsed = parser(value)
+    columns[columnIndex] = `${parsed}`
+  }
+
+  getValue(rowIndex: number, columnIndex: number) {
+    if (!(rowIndex in this.rows)) {
+      return ''
+    }
+    const columns = this.rows[rowIndex]
+    if (!(columnIndex in columns)) {
+      return ''
+    }
+    return columns[columnIndex]
+  }
+
+  getResult() {
+    const result: Record<string, Cell>[] = []
+    for (let i = 0; i < this.rows.length; i++) {
+      result.push({})
+      for (let ii = 0; ii < (this.rows[i] || []).length; ii++) {
+        const { name: n, type, parser } = this.columns[ii]
+        const name = trim(n.toString())
+        const value = trim(this.rows[i][ii])
+        result[i][name] = parser ? parser(value) : parse(value, type)
+      }
+    }
+    return result
+  }
+}

package/src/_internal/plugins/table/types.ts

@@ -0,0 +1,71 @@
+import chalk, { ChalkInstance } from 'chalk'
+
+import { ParseType } from '~types/parse-types.js'
+import { hop, success, warn } from '~utils/chalk.js'
+
+export const DEFAULT_PAGE_SIZE = 5
+export const INDEX_ERRORS = Object.freeze({
+  excess: 'excess',
+  disabled: 'disabled',
+} as const)
+
+export interface DefaultOptions extends Required<Omit<TableQuestion, 'type' | 'name' | 'colors'>> {
+  colors: Colors
+}
+
+export const DEFAULT_OPTIONS: DefaultOptions = {
+  message: '',
+  description: '',
+  escapeMessage: chalk.red('Press ESC again to exit!'),
+  confirmMessage: chalk.red('Press ENTER again to confirm!'),
+  disableColumnIndexes: [],
+  colors: {
+    selected: warn,
+    editable: success,
+    editing: hop,
+  },
+  columns: [],
+  rows: [],
+  pageSize: DEFAULT_PAGE_SIZE,
+  validate: () => ({ isValid: true, message: '' }),
+}
+
+export interface RequiredOptions extends Required<Omit<TableQuestion, 'colors'>> {
+  colors: Colors
+}
+
+export interface Colors {
+  selected: ChalkInstance
+  editable: ChalkInstance
+  editing: ChalkInstance
+}
+
+export interface ValidateResult {
+  isValid: boolean
+  message: string
+}
+
+export interface TableQuestion {
+  type: string
+  name: string
+  message?: string | ChalkInstance
+  description?: string | ChalkInstance
+  escapeMessage?: string | ChalkInstance
+  confirmMessage?: string | ChalkInstance
+  disableColumnIndexes?: number[]
+  colors?: Partial<Colors>
+  columns: Column[]
+  rows: Cell[][]
+  validate?: (...args: any[]) => ValidateResult
+  pageSize?: number
+}
+
+export interface Column {
+  name: string | ChalkInstance
+  value: string
+  type: ParseType
+  validate?: (input: string) => boolean
+  parser?: (input: any) => any
+}
+
+export type Cell = number | string | boolean

package/src/_internal/plugins/table/utils.ts

@@ -0,0 +1,25 @@
+import { INDEX_ERRORS } from '~internal/plugins/table/types.js'
+
+export const isNoChoiceOfIndex = (maxIndex: number, disableIndexes: number[]) => {
+  return disableIndexes.length > maxIndex && [...Array(maxIndex).keys()].every(index => disableIndexes.includes(index))
+}
+
+export const gateValidateColumnIndexError = (index: number, maxIndex: number, disableIndexes: number[]) => {
+  if (index > maxIndex || index < 0) {
+    return INDEX_ERRORS.excess
+  }
+  if (disableIndexes.includes(index)) {
+    return INDEX_ERRORS.disabled
+  }
+  return false
+}
+
+export const getNextIndex = (index: number, maxIndex: number, num: number) => {
+  if (index > maxIndex) {
+    return 0
+  }
+  if (index < 0) {
+    return maxIndex
+  }
+  return index > maxIndex ? 0 : index + num
+}

package/src/_internal/plugins/table.ts

@@ -0,0 +1,299 @@
+import { Interface as ReadLineInterface, Key } from 'readline'
+
+import { ChalkInstance } from 'chalk'
+import cliCursor from 'cli-cursor'
+import Table from 'cli-table3'
+import { Question, Answers } from 'inquirer'
+import Base from 'inquirer/lib/prompts/base.js'
+import observe from 'inquirer/lib/utils/events.js'
+import { map } from 'rxjs/operators'
+
+import { Done } from '~types/inquirer.js'
+import { dim, error } from '~utils/chalk.js'
+import { getKeypressValue } from '~utils/keypress.js'
+
+import { TableClass } from './table/table.js'
+import { DEFAULT_OPTIONS, RequiredOptions, TableQuestion } from './table/types.js'
+import { isNoChoiceOfIndex, gateValidateColumnIndexError, getNextIndex } from './table/utils.js'
+
+export class TablePlugin extends Base {
+  table = new TableClass([], [])
+  options!: RequiredOptions
+
+  done!: Done
+
+  pointerIndexes = {
+    row: 0,
+    column: 0,
+  }
+  isNextCloses = {
+    escape: false,
+  }
+  editing = false
+  temporaryBackup: string | null = null
+  answers: Answers = []
+
+  constructor(question: Question<TableQuestion>, readLine: ReadLineInterface, answers: Answers) {
+    super({ ...question, validate: () => false } as Question, readLine, answers)
+    this.options = {
+      ...DEFAULT_OPTIONS,
+      ...(this.opt as any),
+      validate: question.validate || DEFAULT_OPTIONS.validate,
+    }
+    this.answers = answers
+    this.table = new TableClass(this.options.columns, this.options.rows)
+
+    if (isNoChoiceOfIndex(this.maxColumnIndex, this.options.disableColumnIndexes)) {
+      throw new Error('disableColumnIndexes contains all of index.')
+    }
+    this.pointerIndexes.row = 0
+    this.updateColumnIndex(1)
+  }
+
+  getCurrentValues() {
+    return this.table.getResult()
+  }
+
+  isEditable(index: number) {
+    return !this.options.disableColumnIndexes.includes(index)
+  }
+
+  _run(callback: Done) {
+    this.done = callback
+
+    const events = observe(this.rl)
+    const validation = this.handleSubmitEvents(events.line.pipe(map(this.getCurrentValues.bind(this))))
+    validation.success.forEach(this.onEnd.bind(this))
+    validation.error.forEach(this.onError.bind(this))
+
+    events.keypress.forEach(({ key }) => {
+      if (key.name !== 'escape') {
+        this.isNextCloses.escape = false
+      }
+
+      if (!this.editing) {
+        switch (key.name) {
+          case 'down':
+            return this.onDownKey()
+
+          case 'up':
+            return this.onUpKey()
+
+          case 'left':
+            return this.onLeftKey()
+
+          case 'right':
+            return this.onRightKey()
+
+          case 'escape':
+            if (!this.isNextCloses.escape) {
+              this.isNextCloses.escape = true
+              return this.render()
+            } else {
+              this.render()
+              return this.onEnd(false)
+            }
+
+          default:
+            if (this.isEditable(this.pointerIndexes.column)) {
+              this.editing = true
+              this.onEditPress(key)
+            }
+        }
+      } else {
+        return this.onEditPress(key)
+      }
+    })
+
+    cliCursor.hide()
+    this.render()
+
+    return this
+  }
+
+  get maxPageIndex() {
+    return this.options.pageSize - 1
+  }
+  get maxRowIndex() {
+    return this.table.rows.length - 1
+  }
+
+  get maxColumnIndex() {
+    return this.table.columns.length - 1
+  }
+
+  onDownKey() {
+    if (this.pointerIndexes.row < this.maxRowIndex) {
+      ++this.pointerIndexes.row
+    }
+    this.render()
+  }
+  onUpKey() {
+    if (this.pointerIndexes.row > 0) {
+      --this.pointerIndexes.row
+    }
+    this.render()
+  }
+
+  updateColumnIndex(num: number) {
+    let index = this.pointerIndexes.column
+    for (let c = 0; c <= this.maxColumnIndex; c++) {
+      index = getNextIndex(index, this.maxColumnIndex, num)
+      const error = gateValidateColumnIndexError(index, this.maxColumnIndex, this.options.disableColumnIndexes)
+      if (!error) {
+        break
+      }
+    }
+    this.pointerIndexes.column = index
+  }
+
+  onLeftKey() {
+    this.updateColumnIndex(-1)
+    this.render()
+  }
+
+  onRightKey() {
+    this.updateColumnIndex(1)
+    this.render()
+  }
+
+  clear() {
+    this.temporaryBackup = null
+  }
+
+  onEnd(state: any) {
+    this.render(true)
+    this.clear()
+    this.status = 'answered'
+    this.screen.done()
+    cliCursor.show()
+    if (state) {
+      return this.done({
+        state,
+        result: this.table.getResult(),
+      })
+    } else {
+      return this.done({
+        state,
+      })
+    }
+  }
+
+  validate() {
+    return this.options.validate(this.getCurrentValues(), this.answers)
+  }
+
+  onError(_state: any) {
+    this.clear()
+    if (this.editing) {
+      this.editing = false
+      this.render()
+    } else {
+      if (this.validate().isValid) {
+        return this.onEnd(true)
+      } else {
+        return this.render()
+      }
+    }
+  }
+
+  validateValue() {}
+
+  updateChoice(value: string) {
+    this.table.updateRow(this.pointerIndexes.row, this.pointerIndexes.column, value)
+  }
+
+  get currentValue() {
+    return this.table.getValue(this.pointerIndexes.row, this.pointerIndexes.column)
+  }
+
+  onEditPress(key: Key) {
+    let value = this.currentValue
+    if (this.temporaryBackup === null) {
+      this.temporaryBackup = value
+      value = ''
+    }
+    switch (key.name) {
+      case 'escape':
+        this.updateChoice(this.temporaryBackup)
+        this.editing = false
+        break
+      case 'delete':
+        this.updateChoice('')
+        break
+      case 'backspace': {
+        let currentValue = value
+        currentValue = currentValue.slice(0, -1)
+        this.updateChoice(currentValue)
+        break
+      }
+      default:
+        this.updateChoice(`${value}${getKeypressValue(key)}`)
+        break
+    }
+    this.render()
+  }
+
+  getShowRowIndex() {
+    const middleOfPage = Math.floor(this.options.pageSize / 2)
+    let rowIndexFrom = Math.max(0, this.pointerIndexes.row - middleOfPage)
+    const rowIndexTo = Math.min(this.maxRowIndex, rowIndexFrom + this.maxPageIndex)
+    rowIndexFrom = Math.min(rowIndexFrom, rowIndexTo - (this.options.pageSize - 1))
+    return { rowIndexFrom, rowIndexTo }
+  }
+
+  isSelected(rowIndex: number, columnIndex: number) {
+    return this.pointerIndexes.row === rowIndex && this.pointerIndexes.column === columnIndex
+  }
+  getColor(_value: string, isSelected: boolean, isEditable: boolean) {
+    const value = isEditable ? _value : dim(_value)
+    if (!isSelected) {
+      return value
+    }
+    if (this.editing) {
+      return isEditable ? this.options.colors.editing(value) : this.options.colors.selected(value)
+    }
+    return isEditable ? this.options.colors.editable(value) : this.options.colors.selected(value)
+  }
+
+  render(isDisconnect = false) {
+    let content = this.getQuestion()
+    let bottomContent: string | ChalkInstance = ''
+
+    content += this.options.description ? `\n${this.options.description}` : ''
+
+    const { rowIndexFrom, rowIndexTo } = this.getShowRowIndex()
+    const table = new Table({
+      head: this.table.header,
+    })
+    for (let i = 0; i < this.table.rows.length; i++) {
+      if (i < rowIndexFrom || i > rowIndexTo) {
+        continue
+      }
+      const columnValues: string[] = []
+      for (let ii = 0; ii < (this.table.rows[i] || []).length; ii++) {
+        const isEditable = this.isEditable(ii)
+        const value = this.table.rows[i][ii]
+        columnValues.push(this.getColor(value, this.isSelected(i, ii), isEditable))
+      }
+      table.push(columnValues)
+    }
+
+    content += '\n\n' + table.toString()
+
+    if (!isDisconnect) {
+      const validateResult = this.validate()
+      if (!this.editing && validateResult.isValid) {
+        bottomContent = this.options.confirmMessage
+      }
+      if (!validateResult.isValid) {
+        bottomContent = validateResult.message || error('Something went wrong.')
+      }
+    }
+    if (this.isNextCloses.escape) {
+      bottomContent = this.options.escapeMessage
+    }
+
+    this.screen.render(content, bottomContent as string)
+  }
+}

package/src/_internal/plugins/test.ts

@@ -0,0 +1,58 @@
+import chalk from 'chalk'
+import inquirer from 'inquirer'
+
+import { success, warn, hop, cyan } from '../utils/chalk.js'
+
+import { TableQuestion } from './table/types.js'
+import { TablePlugin } from './table.js'
+
+const run = async () => {
+  inquirer.registerPrompt('table-input', TablePlugin)
+  const rows = [...Array(33).keys()].map(i => [cyan(`--path ${i}--`), '--id--', true, i + 100, '--lock--'])
+  const question: TableQuestion = {
+    type: 'table-input',
+    name: 'links',
+    message: chalk.red('GENERATE LINKS PATH SETTINGS'),
+    description: 'Edit setting.',
+    disableColumnIndexes: [0],
+    colors: {
+      selected: warn,
+      editable: success,
+      editing: hop,
+    },
+    columns: [
+      { name: cyan.bold('filepath'), value: 'path', type: 'input' },
+      { name: cyan.bold('id'), value: 'id', type: 'input', parser: () => 'aaa' },
+      { name: cyan.bold('title'), value: 'title', type: 'confirm' },
+      {
+        name: cyan.bold('num'),
+        value: 'output',
+        type: 'number',
+        validate: (value: string) => /^\d*$/.test(value) || value === '0' || !value,
+      },
+      { name: cyan.bold('lock'), value: 'lock', type: 'input' },
+    ],
+    rows: rows,
+    validate: (inputs, _answers) => {
+      const isValid = inputs.every((i: any) => Object.values(i).every(v => `${v}`.length))
+      return {
+        isValid,
+        message: isValid ? '' : 'not allow empty input',
+      }
+    },
+  }
+  const answers = await inquirer.prompt([
+    // {
+    //   type: 'confirm',
+    //   name: 'id',
+    //   message: 'type id',
+    //   choices: ['aa', 'bb']
+    // },
+    question,
+  ])
+  console.log('answers', JSON.stringify(answers, null, 2))
+}
+
+run().then(() => {
+  console.log('--- end ---')
+})

package/src/_internal/types/inquirer.ts

@@ -0,0 +1 @@
+export type Done = (value: any) => void

package/src/_internal/types/parse-types.ts

@@ -0,0 +1,7 @@
+export const PARSE_TYPES = Object.freeze({
+  input: 'input',
+  number: 'number',
+  confirm: 'confirm',
+} as const)
+
+export type ParseType = (typeof PARSE_TYPES)[keyof typeof PARSE_TYPES]

package/src/_internal/utils/chalk.ts

@@ -0,0 +1,13 @@
+import chalk from 'chalk'
+
+// eslint-disable-next-line no-control-regex
+export const trim = (txt: string) => txt.replace(/\u001b\[[0-9;]*m/g, '')
+
+export const success = chalk.green
+export const warn = chalk.hex('#FFA500')
+export const info = chalk.hex('#77CFF5')
+export const error = chalk.red
+export const hop = chalk.hex('#F577F5')
+export const cyan = chalk.cyan
+export const bold = chalk.bold
+export const dim = chalk.dim

package/src/_internal/utils/keypress.ts

@@ -0,0 +1,16 @@
+import { Key } from 'readline'
+
+export const getKeypressValue = (key: Key) => {
+  switch (key.name) {
+    case 'escape':
+    case 'delete':
+    case 'backspace':
+    case 'down':
+    case 'up':
+    case 'left':
+    case 'right':
+      return ''
+    default:
+      return key.sequence
+  }
+}

package/src/_internal/utils/parse-types.ts

@@ -0,0 +1,25 @@
+import { PARSE_TYPES, ParseType } from '~types/parse-types.js'
+
+const BOOL_VALUES = Object.freeze(['Y', 'y', 'yes', 'YES', 'x', 'v', 'o', 'true'])
+
+export const parse = (value: string, type: ParseType) => {
+  switch (type) {
+    case PARSE_TYPES.number:
+      return value ? Number(value) : 0
+    case PARSE_TYPES.confirm:
+      return BOOL_VALUES.includes(value)
+    default:
+      return value
+  }
+}
+
+export const parseView = (value: string, type: ParseType) => {
+  switch (type) {
+    case PARSE_TYPES.number:
+      return value ? Number(value) : 0
+    case PARSE_TYPES.confirm:
+      return value === 'true'
+    default:
+      return value
+  }
+}

package/src/modules/table.ts

@@ -0,0 +1,2 @@
+export * from '~internal/plugins/table.js'
+export * from '~internal/plugins/table/types.js'

package/src/modules/types/inquirer.ts

@@ -0,0 +1 @@
+export * from '~types/inquirer.js'

package/src/modules/types/parse-types.ts

@@ -0,0 +1 @@
+export * from '~types/parse-types.js'

package/table/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@cilly/inquirer-plugins-modules-table",
+  "types": "../dist/modules/table.d.ts",
+  "main": "../dist/modules/table.js",
+  "sideEffects": false
+}