feat: number input

Author: yyxi

src/compose/get-options-variables.ts

@@ -4,6 +4,7 @@ import type { InputChoiceStateInitial } from '../input/choice/types'
 import type { InputCountStateInitial } from '../input/count/types'
 import type { InputGroupStateInitial } from '../input/group/types'
 import type { InputStringStateInitial } from '../input/string/types'
+import type { InputNumberStateInitial } from '../input/number/types'
 import { type GenericOption, type GenericVariable, InputType, type Match } from '../types'
 
 export const getOptionsVariables = (
@@ -12,6 +13,7 @@ export const getOptionsVariables = (
     | InputChoiceStateInitial
     | InputCountStateInitial
     | InputGroupStateInitial
+    | InputNumberStateInitial
     | InputStringStateInitial,
   match: Match,
 ) => {

src/compose/get-specification.ts

@@ -1,7 +1,7 @@
 import { SYMBOL_LOG, SYMBOL_STATE } from '@escapace/fluent'
 import arg from 'arg'
 import { assign, filter, flatMap, map } from 'lodash-es'
-import { type CommandActionInput, type Command, CommandTypeAction } from '../command/types'
+import { type Command, type CommandActionInput, CommandTypeAction } from '../command/types'
 import type { InputGroup } from '../input/group/types'
 import {
   type Input,
@@ -11,6 +11,7 @@ import {
   SYMBOL_INPUT_CHOICE,
   SYMBOL_INPUT_COUNT,
   SYMBOL_INPUT_GROUP,
+  SYMBOL_INPUT_NUMBER,
   SYMBOL_INPUT_STRING,
 } from '../types'
 
@@ -26,6 +27,8 @@ const match = (
       return state.repeat ? [String] : String
     case SYMBOL_INPUT_COUNT:
       return arg.COUNT
+    case SYMBOL_INPUT_NUMBER:
+      return state.repeat ? [Number] : Number
     case SYMBOL_INPUT_STRING:
       return state.repeat ? [String] : String
   }

src/example.ts

@@ -5,6 +5,7 @@ import { choice } from './input/choice/domain-language'
 import { count } from './input/count/domain-language'
 import { group } from './input/group/domain-language'
 import { string } from './input/string/domain-language'
+import { number } from './input/number/domain-language'
 
 export const grant = string()
   .reference('GRANT')
@@ -28,7 +29,7 @@ export const retrace = count()
   .option('-r', '-d')
   .default(2)
 
-export const pummel = string()
+export const pummel = number()
   .reference('PUMMEL')
   .description(
     'Furlong furlong focal for the genuflect profound of the motif aloof and offers. Gnome gnome gondola for the impugn logos',
@@ -37,7 +38,7 @@ export const pummel = string()
   .option('--pummel')
   .option('-p')
   .variable('PUMMEL')
-  .default(['bison', 'tunnel'])
+  .default([1024, 512])
 
 export const wick = choice()
   .reference('WICK')

src/help/inputs/input-number.ts

@@ -0,0 +1,33 @@
+/* eslint-disable typescript/no-non-null-assertion */
+import { SYMBOL_STATE } from '@escapace/fluent'
+import type { InputNumber } from '../../input/number/types'
+import type { PropertiesShared, SYMBOL_INPUT_NUMBER } from '../../types'
+import { HELP_SIGN_REPEAT } from '../constants'
+import { enclose } from '../enclose'
+import type { HelpInputsExcluding } from '../types'
+
+export const usageInputNumber = (
+  input: InputNumber,
+  depth: number,
+  properties: PropertiesShared,
+): HelpInputsExcluding<typeof SYMBOL_INPUT_NUMBER> => {
+  const { description, options, repeat, type, variables } = input[SYMBOL_STATE]
+
+  return {
+    depth,
+    description: description!,
+    options:
+      options.length === 0
+        ? undefined
+        : `[${enclose(options)}=<number>]${repeat ? `${HELP_SIGN_REPEAT}` : ''}`,
+    type: type as typeof SYMBOL_INPUT_NUMBER,
+    variables:
+      variables.length === 0
+        ? undefined
+        : `${enclose(variables)}=${
+            repeat
+              ? `<number>[${properties.settings.separator}<number>]${HELP_SIGN_REPEAT}`
+              : '<number>'
+          }`,
+  }
+}

src/help/inputs/input.ts

@@ -3,19 +3,22 @@ import type { InputBoolean } from '../../input/boolean/types'
 import type { InputChoice } from '../../input/choice/types'
 import type { InputCount } from '../../input/count/types'
 import type { InputGroup } from '../../input/group/types'
+import type { InputNumber } from '../../input/number/types'
 import type { InputString } from '../../input/string/types'
 import {
   type Input,
   type PropertiesShared,
   SYMBOL_INPUT_BOOLEAN,
   SYMBOL_INPUT_CHOICE,
   SYMBOL_INPUT_COUNT,
+  SYMBOL_INPUT_NUMBER,
   SYMBOL_INPUT_STRING,
 } from '../../types'
 import type { HelpInputsExcluding } from '../types'
 import { usageInputBoolean } from './input-boolean'
 import { usageInputChoice } from './input-choice'
 import { usageInputCount } from './input-count'
+import { usageInputNumber } from './input-number'
 import { usageInputString } from './input-string'
 
 export const usageInput = (
@@ -30,6 +33,8 @@ export const usageInput = (
       return usageInputChoice(input as InputChoice, depth, properties)
     case SYMBOL_INPUT_COUNT:
       return usageInputCount(input as InputCount, depth)
+    case SYMBOL_INPUT_NUMBER:
+      return usageInputNumber(input as InputNumber, depth, properties)
     case SYMBOL_INPUT_STRING:
       return usageInputString(input as InputString, depth, properties)
   }

src/input/boolean/types.ts

@@ -12,11 +12,11 @@ import type {
 } from '@escapace/fluent'
 
 import type {
-  InputType,
   InputPropertiesShared,
+  InputType,
   Reference,
-  StateSharedInitial,
   StateShared,
+  StateSharedInitial,
   SYMBOL_INPUT_BOOLEAN,
 } from '../../types'
 
@@ -292,7 +292,7 @@ interface ModelInputBoolean {
   readonly state: InputBoolean[typeof SYMBOL_STATE]
 }
 
-export interface InputBooleanProperties extends InputPropertiesShared {
+interface InputBooleanProperties extends InputPropertiesShared {
   readonly model: ModelInputBoolean
 }
 

src/input/count/types.ts

@@ -13,8 +13,8 @@ import type {
   GenericOption,
   InputPropertiesShared,
   Reference,
-  StateSharedInitial,
   StateShared,
+  StateSharedInitial,
   SYMBOL_INPUT_COUNT,
 } from '../../types'
 
@@ -213,7 +213,7 @@ interface InputCountModel {
   readonly state: InputCount[typeof SYMBOL_STATE]
 }
 
-export interface InputCountProperties extends InputPropertiesShared {
+interface InputCountProperties extends InputPropertiesShared {
   readonly model: InputCountModel
 }
 

src/input/number/domain-language.spec.ts

@@ -0,0 +1,186 @@
+import { log, state, SYMBOL_LOG, SYMBOL_STATE } from '@escapace/fluent'
+import { assert, describe, it } from 'vitest'
+import { SYMBOL_INPUT_NUMBER } from '../../types'
+import { number } from './domain-language'
+import { reducer } from './reducer'
+import { InputNumberTypeAction } from './types'
+
+describe('input/number', () => {
+  it('domain-language', () => {
+    const reference = 'test'
+
+    assert.isFunction(number)
+
+    const test0 = number()
+
+    assert.hasAllKeys(test0, [SYMBOL_LOG, SYMBOL_STATE, 'reference'])
+
+    assert.deepEqual(log(test0), [])
+
+    assert.deepEqual(state(test0), {
+      default: undefined,
+      description: undefined,
+      isEmpty: true,
+      options: [],
+      reducer,
+      reference: undefined,
+      repeat: false,
+      type: SYMBOL_INPUT_NUMBER,
+      variables: [],
+    })
+
+    const test1 = test0.reference(reference)
+
+    assert.hasAllKeys(test1, [SYMBOL_LOG, SYMBOL_STATE, 'description'])
+
+    assert.deepEqual(log(test1), [{ payload: reference, type: InputNumberTypeAction.Reference }])
+
+    assert.deepEqual(state(test1), {
+      default: undefined,
+      description: undefined,
+      isEmpty: true,
+      options: [],
+      reducer,
+      reference,
+      repeat: false,
+      type: SYMBOL_INPUT_NUMBER,
+      variables: [],
+    })
+
+    const test2 = test1.description('ABC')
+
+    assert.hasAllKeys(test2, [SYMBOL_LOG, SYMBOL_STATE, 'repeat', 'option', 'variable'])
+
+    assert.deepEqual(log(test2), [
+      { payload: 'ABC', type: InputNumberTypeAction.Description },
+      { payload: reference, type: InputNumberTypeAction.Reference },
+    ])
+
+    assert.deepEqual(state(test2), {
+      default: undefined,
+      description: 'ABC',
+      isEmpty: true,
+      options: [],
+      reducer,
+      reference,
+      repeat: false,
+      type: SYMBOL_INPUT_NUMBER,
+      variables: [],
+    })
+
+    const test3 = test2.repeat()
+
+    assert.hasAllKeys(test3, [SYMBOL_LOG, SYMBOL_STATE, 'option', 'variable'])
+
+    assert.deepEqual(log(test3), [
+      { payload: undefined, type: InputNumberTypeAction.Repeat },
+      { payload: 'ABC', type: InputNumberTypeAction.Description },
+      { payload: reference, type: InputNumberTypeAction.Reference },
+    ])
+
+    assert.deepEqual(state(test3), {
+      default: undefined,
+      description: 'ABC',
+      isEmpty: true,
+      options: [],
+      reducer,
+      reference,
+      repeat: true,
+      type: SYMBOL_INPUT_NUMBER,
+      variables: [],
+    })
+
+    const test4 = test3.option('--option')
+
+    assert.hasAllKeys(test4, [SYMBOL_LOG, SYMBOL_STATE, 'default', 'option', 'variable'])
+
+    assert.deepEqual(log(test4), [
+      {
+        payload: {
+          name: '--option',
+        },
+        type: InputNumberTypeAction.Option,
+      },
+      { payload: undefined, type: InputNumberTypeAction.Repeat },
+      { payload: 'ABC', type: InputNumberTypeAction.Description },
+      { payload: reference, type: InputNumberTypeAction.Reference },
+    ])
+
+    assert.deepEqual(state(test4), {
+      default: undefined,
+      description: 'ABC',
+      isEmpty: false,
+      options: ['--option'],
+      reducer,
+      reference,
+      repeat: true,
+      type: SYMBOL_INPUT_NUMBER,
+      variables: [],
+    })
+
+    const test5 = test4.variable('VARIABLE')
+
+    assert.hasAllKeys(test5, [SYMBOL_LOG, SYMBOL_STATE, 'default', 'option', 'variable'])
+
+    assert.deepEqual(log(test5), [
+      {
+        payload: 'VARIABLE',
+        type: InputNumberTypeAction.Variable,
+      },
+      {
+        payload: {
+          name: '--option',
+        },
+        type: InputNumberTypeAction.Option,
+      },
+      { payload: undefined, type: InputNumberTypeAction.Repeat },
+      { payload: 'ABC', type: InputNumberTypeAction.Description },
+      { payload: reference, type: InputNumberTypeAction.Reference },
+    ])
+
+    assert.deepEqual(state(test5), {
+      default: undefined,
+      description: 'ABC',
+      isEmpty: false,
+      options: ['--option'],
+      reducer,
+      reference,
+      repeat: true,
+      type: SYMBOL_INPUT_NUMBER,
+      variables: ['VARIABLE'],
+    })
+
+    const test6 = test5.default([1, 2, 3])
+
+    assert.hasAllKeys(test6, [SYMBOL_LOG, SYMBOL_STATE])
+
+    assert.deepEqual(log(test6), [
+      { payload: [1, 2, 3], type: InputNumberTypeAction.Default },
+      {
+        payload: 'VARIABLE',
+        type: InputNumberTypeAction.Variable,
+      },
+      {
+        payload: {
+          name: '--option',
+        },
+        type: InputNumberTypeAction.Option,
+      },
+      { payload: undefined, type: InputNumberTypeAction.Repeat },
+      { payload: 'ABC', type: InputNumberTypeAction.Description },
+      { payload: reference, type: InputNumberTypeAction.Reference },
+    ])
+
+    assert.deepEqual(state(test6), {
+      default: [1, 2, 3],
+      description: 'ABC',
+      isEmpty: false,
+      options: ['--option'],
+      reducer,
+      reference,
+      repeat: true,
+      type: SYMBOL_INPUT_NUMBER,
+      variables: ['VARIABLE'],
+    })
+  })
+})