@bemoje/cli 0.0.5 → 0.0.6

package/{scripts → src}/_example/CommandBuilder.example2.ts

@@ -1,8 +1,8 @@
-import { CLI, CommandBuilder } from '../../src'
+import { CommandBuilder } from '../cmd/CommandBuilder'
 
 console.time('load')
 
-const init = CLI('demo', (c) => {
+const cli = new CommandBuilder('demo', (c) => {
   c.version('0.0.1')
   c.description('A CLI example')
   c.setRecommended()
@@ -23,9 +23,8 @@ const init = CLI('demo', (c) => {
 console.timeEnd('load')
 
 console.time('init')
-const cli = init()
 console.timeEnd('init')
 
 console.time('exec')
-cli.parse()
+cli.$.parse()
 console.timeEnd('exec')

package/{scripts → src}/_example/bFindIn.ts

@@ -1,11 +1,10 @@
-import { CLI } from '../../src/cmd/CLI'
-import { execInherit } from '../../src/util/node/execInherit'
-import { printCounts } from '../../src/core/counter'
-import { strSplitCamelCase } from '../../src/util/string/strSplitCamelCase'
+import { CommandBuilder } from '../cmd/CommandBuilder'
+import { execInherit } from '../util/node/execInherit'
+import { strSplitCamelCase } from '../util/string/strSplitCamelCase'
 
 console.time('load')
 
-const init = CLI('bFindIn', (b) => {
+const cli = new CommandBuilder('bFindIn', (b) => {
   b.setRecommended()
   b.version('0.0.1')
   b.description(
@@ -196,12 +195,6 @@ const init = CLI('bFindIn', (b) => {
 })
 console.timeEnd('load')
 
-console.time('init')
-const cli = init()
-console.timeEnd('init')
-
 console.time('exec')
-cli.parse()
+cli.$.parse()
 console.timeEnd('exec')
-
-printCounts()

package/src/arg/ArgumentParserSelector.test.ts

@@ -1,9 +1,9 @@
 import { ArgumentParserSelector } from './ArgumentParserSelector'
-import { CLI } from '../cmd/CLI'
+import { CommandBuilder } from '../cmd/CommandBuilder'
 
 describe(ArgumentParserSelector.name, () => {
   it('should parse string, number, integer', () => {
-    const run = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.argument('<str>', (a) => a.parser.string())
       c.argument('<num>', (a) => a.parser.number())
       c.argument('<int>', (a) => a.parser.integer())
@@ -13,22 +13,22 @@ describe(ArgumentParserSelector.name, () => {
         expect(int).toBe(3)
       })
     })
-    run().parse(['str', '3.2', '3'], { from: 'user' })
+    run.$.parse(['str', '3.2', '3'], { from: 'user' })
   })
 
   it('should parse variadic argument', () => {
-    const init = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.argument('<str>', (o) => o.parser.string())
       c.argument('<ints...>', (o) => o.parser.integer())
       c.action((str, ints) => {
         expect(ints).toEqual([3, 4, 5])
       })
     })
-    init().parse('abc 3 4 5'.split(' '), { from: 'user' })
+    run.$.parse('abc 3 4 5'.split(' '), { from: 'user' })
   })
 
   it('should parse delimited string, number, integer', () => {
-    const run = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.argument('<strs>', (a) => a.parser.delimitedStrings())
       c.argument('<nums>', (a) => a.parser.delimitedNumbers())
       c.argument('<ints>', (a) => a.parser.delimitedIntegers())
@@ -38,16 +38,16 @@ describe(ArgumentParserSelector.name, () => {
         expect(ints).toEqual([3, 4, 5])
       })
     })
-    run().parse(['a,b', '3.1,4.1', '3,4,5'], { from: 'user' })
+    run.$.parse(['a,b', '3.1,4.1', '3,4,5'], { from: 'user' })
   })
 
   it('should parse with custom parser', () => {
-    const run = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.argument('<arg>', (a) => a.parser.custom((s) => s.split('')))
       c.action((arg) => {
         expect(arg).toEqual(['a', 'b', 'c'])
       })
     })
-    run().parse(['abc'], { from: 'user' })
+    run.$.parse(['abc'], { from: 'user' })
   })
 })

package/src/arg/ArgumentValidatorSelector.test.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 import { ArgumentValidatorSelector } from './ArgumentValidatorSelector'
-import { CLI } from '../cmd/CLI'
+import { CommandBuilder } from '../cmd/CommandBuilder'
 
 describe(ArgumentValidatorSelector.name, () => {
   jest.spyOn(process, 'exit').mockImplementation((code?: number) => {
@@ -9,63 +9,63 @@ describe(ArgumentValidatorSelector.name, () => {
   })
 
   it('should validate string, number, integer', () => {
-    const run = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.argument('<str>', (a) => a.parser.string().validator.isString())
       c.argument('<num>', (a) => a.parser.number().validator.isNumber())
       c.argument('<int>', (a) => a.parser.integer().validator.isInteger())
       c.action(() => {})
     })
-    expect(() => run().parse(['str', '3.2', '3'], { from: 'user' })).not.toThrow()
+    expect(() => run.$.parse(['str', '3.2', '3'], { from: 'user' })).not.toThrow()
   })
 
   it('should throw if invalid', () => {
-    const run = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.argument('<int>', (a) => a.parser.number().validator.isInteger())
       c.action(() => {})
       c.throwInsteadOfProcessExit()
     })
-    expect(() => run().parse(['3.2'], { from: 'user' })).toThrow()
+    expect(() => run.$.parse(['3.2'], { from: 'user' })).toThrow()
   })
 
   it('should validate delimited string, number, integer', () => {
-    const run = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.argument('<strs>', (a) => a.parser.delimitedStrings().validator.isStringArray())
       c.argument('<nums>', (a) => a.parser.delimitedNumbers().validator.isNumberArray())
       c.argument('<ints>', (a) => a.parser.delimitedIntegers().validator.isIntegerArray())
       c.action(() => {})
     })
-    expect(() => run().parse(['a,b', '3.1,4.1', '3,4,5'], { from: 'user' })).not.toThrow()
+    expect(() => run.$.parse(['a,b', '3.1,4.1', '3,4,5'], { from: 'user' })).not.toThrow()
   })
 
   it('should validate variadic argument', () => {
-    const init = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.argument('<str>', (o) => o.validator.isString())
       c.argument('<ints...>', (o) => o.parser.integer().validator.isIntegerArray())
       c.action(() => {})
     })
-    expect(() => init().parse('abc 3 4 5'.split(' '), { from: 'user' })).not.toThrow()
+    expect(() => run.$.parse('abc 3 4 5'.split(' '), { from: 'user' })).not.toThrow()
   })
 
   it('should throw if invalid', () => {
-    const run = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.argument('<ints>', (a) => a.parser.delimitedIntegers().validator.isIntegerArray())
       c.action(() => {})
       c.throwInsteadOfProcessExit()
     })
-    expect(() => run().parse(['3,q,7'], { from: 'user' })).toThrow()
+    expect(() => run.$.parse(['3,q,7'], { from: 'user' })).toThrow()
   })
 
   it('should validate with custom validator', () => {
-    const run = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.argument('<arg>', (a) => a.validator.custom((arg) => arg === 'abc'))
       c.action(() => {})
       c.throwInsteadOfProcessExit()
     })
-    expect(() => run().parse(['ab'], { from: 'user' })).toThrow()
+    expect(() => run.$.parse(['ab'], { from: 'user' })).toThrow()
   })
 
   it('should validate with multiple validators', () => {
-    const run = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.argument('<arg>', (a) => {
         a.validator.custom((arg: string) => arg !== 'abc')
         a.validator.custom((arg: string) => arg.length >= 3)
@@ -73,8 +73,8 @@ describe(ArgumentValidatorSelector.name, () => {
       c.action(() => {})
       c.throwInsteadOfProcessExit()
     })
-    expect(() => run().parse(['ab'], { from: 'user' })).toThrow()
-    expect(() => run().parse(['abc'], { from: 'user' })).toThrow()
-    expect(() => run().parse(['abcd'], { from: 'user' })).not.toThrow()
+    expect(() => run.$.parse(['ab'], { from: 'user' })).toThrow()
+    expect(() => run.$.parse(['abc'], { from: 'user' })).toThrow()
+    expect(() => run.$.parse(['abcd'], { from: 'user' })).not.toThrow()
   })
 })

package/src/cmd/CommandBuilder.test.ts

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import colors from 'ansi-colors'
-import { CLI } from './CLI'
 import { CommandBuilder } from './CommandBuilder'
 import { OutputManager } from '../core/OutputManager'
 
@@ -573,37 +572,38 @@ describe(CommandBuilder.name, () => {
       })
 
       let result = ''
-      const init = CLI('t', (c) => {
-        c.argument('[name]')
-        c.action((name: string) => {
-          result = name
-        })
-        c.preset('john', {
-          description: '',
-          args: ['john'],
-        })
-        c.preset('anna', {
-          description: '',
-          args: ['anna'],
+      const t = () =>
+        new CommandBuilder('t', (c) => {
+          c.argument('[name]')
+          c.action((name: string) => {
+            result = name
+          })
+          c.preset('john', {
+            description: '',
+            args: ['john'],
+          })
+          c.preset('anna', {
+            description: '',
+            args: ['anna'],
+          })
         })
-      })
 
       it('should parse presets on action', () => {
-        init().parse(['--john'], { from: 'user' })
+        t().$.parse(['--john'], { from: 'user' })
         expect(result).toBe('john')
-        init().parse(['--anna'], { from: 'user' })
+        t().$.parse(['--anna'], { from: 'user' })
         expect(result).toBe('anna')
       })
 
       it('should let stacked presets override each other', () => {
-        init().parse('--anna --john'.split(' '), { from: 'user' })
+        t().$.parse('--anna --john'.split(' '), { from: 'user' })
         expect(result).toBe('john')
-        init().parse('--john --anna'.split(' '), { from: 'user' })
+        t().$.parse('--john --anna'.split(' '), { from: 'user' })
         expect(result).toBe('anna')
       })
 
       it('should always have arguments override preset values', () => {
-        init().parse('mia --john --anna'.split(' '), { from: 'user' })
+        t().$.parse('mia --john --anna'.split(' '), { from: 'user' })
         expect(result).toBe('mia')
       })
     })

package/src/cmd/CommandBuilder.ts

@@ -10,7 +10,6 @@ import { arrAssign } from '../util/object/arrAssign'
 import { arrLast } from '../util/array/arrLast'
 import { arrSome } from '../util/array/arrSome'
 import { CommandBuilderMetaData } from './CommandBuilderMetaData'
-import { commanderBackRefs } from '../proto/overrideCommanderPrototype'
 import { CommandFeatureSelector } from './CommandFeatureSelector'
 import { DefaultHelpConfig } from './DefaultHelpConfig'
 import { ensureThat } from '../util/validation/ensureThat'
@@ -30,10 +29,8 @@ import { OutputManager } from '../core/OutputManager'
 import { PresetsSection } from '../db/PresetsSection'
 import { realizeLazyProperty } from '../util/object/realizeLazyProperty'
 import { removeFile } from '../util/fs/removeFile/removeFile'
-import type { ReturnTypesOfFunctionArray, ReturnTypesOfFunctionMap } from './asdas'
 import { setNonEnumerable } from '../util/object/setNonEnumerable'
 import { splitCombinedArgvShorts } from '../core/splitCombinedArgvShorts'
-import type { TStringParser } from '../util/types/TStringParser'
 import {
   type AddHelpTextPosition,
   Argument,
@@ -47,6 +44,7 @@ import {
   Option,
   type OptionValues,
   type OptionValueSource,
+  ParseOptions,
 } from '@commander-js/extra-typings'
 import { type JsonValue } from '../util/types/JsonValue'
 
@@ -103,7 +101,6 @@ export class CommandBuilder<Args extends Any[] = unknown[], Opts extends OptionV
             child.assertNoDuplicateCommandNames()
           }
         }
-
         if (child.features.isAutoAssignMissingOptionFlagsEnabled) {
           child.assignMissingOptionFlags()
           if (!child.meta.isNative) {
@@ -220,6 +217,7 @@ export class CommandBuilder<Args extends Any[] = unknown[], Opts extends OptionV
   }
   action(fn: (...args: any[]) => void | Promise<void>): this {
     const isAsync = isAsyncFunction(fn) || /^\(.+\) ?=> ?tslib_1\.__awaiter\(/.test(fn.toString().trim())
+    this.meta.isActionAsync = isAsync
     Object.defineProperty(this.meta, 'actionHandler', { value: fn, configurable: false, writable: false })
     this.initializeActionWrapper(isAsync)
     return this
@@ -917,55 +915,6 @@ export class CommandBuilder<Args extends Any[] = unknown[], Opts extends OptionV
             console.info(db.getAll())
           })
         })
-        /*
-        config.option('--editor [cmd]', (o) => {
-          o.description('The command to launch your preferred text editor.')
-        })
-        config.argument('[action]', (a) => {
-          a.description('The action to perform.')
-          a.choices(['edit', 'list', 'get', 'set', 'reset'])
-          a.default('edit')
-        })
-        config.argument('[key]', (a) => {
-          a.description('Property key (if applicable)')
-        })
-        config.argument('[value]', (a) => {
-          a.description('Value to set (if applicable)')
-        })
-        config.action(
-          async (action: string, key: string, value: string, opts: { editor: string }, config: CommandBuilder) => {
-            const cmd = config.getClosestNonNativeParent()
-            const cfg = cmd.db.config
-            if (!action || action === 'edit') {
-              cfg.edit(opts.editor)
-              return console.info(cfg.getAll())
-            } else if (action === 'list') {
-              return console.dir(
-                cfg.keys.map((key: string) => {
-                  return {
-                    key,
-                    description: cfg.descriptions[key],
-                    value: cfg.get(key),
-                    defaultValue: cfg.defaultValues,
-                  }
-                })
-              )
-            } else if (action === 'get') {
-              if (key) return console.log(cfg.get(key))
-              else return console.log(cfg.getAll())
-            } else if (action === 'set') {
-              const from = cfg.get(key)
-              const parse = cfg.parsers[key]
-              const to = typeof parse === 'function' ? cfg.parsers[key](value) : value
-              cfg.set(key, to)
-              return console.info({ changed: key, from, to })
-            } else if (action === 'reset') {
-              if (key) cfg.reset(key)
-              else cfg.resetAll()
-              return console.info(cfg.getAll())
-            }
-          }
-        )*/
       }
     })
   }
@@ -1173,3 +1122,43 @@ export class CommandBuilder<Args extends Any[] = unknown[], Opts extends OptionV
 }
 
 process.argv = splitCombinedArgvShorts(process.argv.slice())
+
+export const commanderBackRefs = new WeakMap<Command<Any, Any>, CommandBuilder<Any, Any>>()
+const oldParse = Command.prototype.parse
+Command.prototype.parse = function parse(this: Command, argv?: readonly string[], options?: ParseOptions) {
+  if (argv) {
+    argv = splitCombinedArgvShorts(argv.slice())
+    this.builder.meta.rawArgs = argv.slice(options?.from === 'user' ? 0 : 2)
+  } else {
+    this.builder.meta.rawArgs = process.argv.slice(2)
+  }
+  return oldParse.call(this, argv, options)
+}
+
+const oldParseAsync = Command.prototype.parseAsync
+Command.prototype.parseAsync = async function (this: Command, argv?: readonly string[], options?: ParseOptions) {
+  if (argv) {
+    argv = splitCombinedArgvShorts(argv.slice())
+    this.builder.meta.rawArgs = argv.slice(options?.from === 'user' ? 0 : 2)
+  } else {
+    this.builder.meta.rawArgs = process.argv.slice(2)
+  }
+  return await oldParseAsync.call(this, argv, options)
+}
+Object.defineProperty(Command.prototype, 'builder', {
+  get(this: Command) {
+    const ins = commanderBackRefs.get(this)
+    if (!ins) throw new Error(`CommandBuilder not found for command ${this.name()}`)
+    return ins
+  },
+})
+
+declare module '@commander-js/extra-typings' {
+  interface Command {
+    get builder(): CommandBuilder
+  }
+}
+
+export function CLI(name: string, cb: (cmd: CommandBuilder) => void) {
+  return new CommandBuilder(name, cb).commander
+}

package/src/cmd/CommandBuilderMetaData.ts

@@ -18,6 +18,7 @@ export class CommandBuilderMetaData<Args extends Any[] = unknown[]> {
   optValidators: Record<string, TValidator<Any>[]> = {}
   rawArgs: string[] = []
   isNative = false
+  isActionAsync = false
 
   get actionHandler(): (this: CommandBuilder, ...args: any[]) => void | Promise<void> {
     return async function defaultActionHandler(this: CommandBuilder) {

package/src/index.ts

@@ -3,7 +3,6 @@ export * from './arg/ArgumentParserSelector'
 export * from './arg/ArgumentReader'
 export * from './arg/ArgumentValidatorSelector'
 export * from './cmd/asdas'
-export * from './cmd/CLI'
 export * from './cmd/CommandBuilder'
 export * from './cmd/CommandBuilderMetaData'
 export * from './cmd/CommandFeatureSelector'
@@ -22,7 +21,6 @@ export * from './opt/OptionArgumentValidatorSelector'
 export * from './opt/OptionBuilder'
 export * from './opt/OptionHelpers'
 export * from './opt/OptionReader'
-export * from './proto/overrideCommanderPrototype'
 export * from './types/IConfig'
 export * from './types/IPreset'
 export * from './util/array/arrLast'
@@ -100,4 +98,5 @@ export * from './util/validation/isString'
 export * from './util/validation/isStringArray'
 export * from './util/validation/isStringWithNoSpacesOrDashes'
 export * from './util/validation/numbers/isInteger'
-export * from './util/validation/numbers/isValidNumber'
+export * from './util/validation/numbers/isValidNumber'
+export * from './_example/bFindIn'

package/src/opt/OptionArgumentParserSelector.test.ts

@@ -1,9 +1,9 @@
-import { CLI } from '../cmd/CLI'
+import { CommandBuilder } from '../cmd/CommandBuilder'
 import { OptionArgumentParserSelector } from './OptionArgumentParserSelector'
 
 describe(OptionArgumentParserSelector.name, () => {
   it('should parse string, number, integer', () => {
-    const init = CLI('t', (c) => {
+    const init = new CommandBuilder('t', (c) => {
       c.option('--str <val>', (o) => o.parser.string())
       c.option('--num <val>', (o) => o.parser.number())
       c.option('--int <val>', (o) => o.parser.integer())
@@ -13,23 +13,24 @@ describe(OptionArgumentParserSelector.name, () => {
         expect(opts.int).toBe(3)
       })
     })
-    init().parse('--str str --num 3.2 --int 3'.split(' '), { from: 'user' })
+    init.$.parse('--str str --num 3.2 --int 3'.split(' '), { from: 'user' })
   })
 
   it('should parse variadic option', () => {
-    const init = CLI('t', (c) => {
-      c.option('--ints <val...>', (o) => o.parser.integer())
-      c.option('--str <val>', (o) => o.parser.string())
-      c.action((opts) => {
-        expect(opts.ints).toEqual([3, 4, 5])
+    const init = () =>
+      new CommandBuilder('t', (c) => {
+        c.option('--ints <val...>', (o) => o.parser.integer())
+        c.option('--str <val>', (o) => o.parser.string())
+        c.action((opts) => {
+          expect(opts.ints).toEqual([3, 4, 5])
+        })
       })
-    })
-    init().parse('--ints 3 4 5'.split(' '), { from: 'user' })
-    init().parse('--ints 3 4 5 --str abc'.split(' '), { from: 'user' })
+    init().$.parse('--ints 3 4 5'.split(' '), { from: 'user' })
+    init().$.parse('--ints 3 4 5 --str abc'.split(' '), { from: 'user' })
   })
 
   it('should parse delimited string, number, integer', () => {
-    const init = CLI('t', (c) => {
+    const init = new CommandBuilder('t', (c) => {
       c.option('--strs <val>', (o) => o.parser.delimitedStrings())
       c.option('--nums <val>', (o) => o.parser.delimitedNumbers())
       c.option('--ints <val>', (o) => o.parser.delimitedIntegers())
@@ -39,16 +40,16 @@ describe(OptionArgumentParserSelector.name, () => {
         expect(opts.ints).toEqual([3, 4, 5])
       })
     })
-    init().parse('--strs a,b --nums 3.1,4.1 --ints 3,4,5'.split(' '), { from: 'user' })
+    init.$.parse('--strs a,b --nums 3.1,4.1 --ints 3,4,5'.split(' '), { from: 'user' })
   })
 
   it('should parse with custom parser', () => {
-    const init = CLI('t', (c) => {
+    const init = new CommandBuilder('t', (c) => {
       c.option('--chars <val>', (o) => o.parser.custom((s) => s.split('')))
       c.action((opts) => {
         expect(opts.chars).toEqual(['a', 'b', 'c'])
       })
     })
-    init().parse('--chars abc'.split(' '), { from: 'user' })
+    init.$.parse('--chars abc'.split(' '), { from: 'user' })
   })
 })

package/src/opt/OptionArgumentValidatorSelector.test.ts

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-import { CLI } from '../cmd/CLI'
 import { CommandBuilder } from '../cmd/CommandBuilder'
 import { OptionArgumentValidatorSelector } from './OptionArgumentValidatorSelector'
 import { OptionBuilder } from './OptionBuilder'
@@ -17,65 +16,65 @@ describe(OptionArgumentValidatorSelector.name, () => {
   })
 
   it('should validate string, number, integer', () => {
-    const run = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.option('--s <str>', (o) => o.parser.string().validator.isString())
       c.option('--n <num>', (o) => o.parser.number().validator.isNumber())
       c.option('--i <int>', (o) => o.parser.integer().validator.isInteger())
       c.action(() => {})
     })
-    expect(() => run().parse('--s str --n 3.2 --i 3'.split(' '), { from: 'user' })).not.toThrow()
+    expect(() => run.$.parse('--s str --n 3.2 --i 3'.split(' '), { from: 'user' })).not.toThrow()
   })
 
   it('should throw if invalid', () => {
-    const run = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.throwInsteadOfProcessExit()
       c.option('--i <int>', (a) => a.parser.number().validator.isInteger())
       c.action(() => {})
       c.throwInsteadOfProcessExit()
     })
-    expect(() => run().parse('--i 3.2'.split(' '), { from: 'user' })).toThrow()
+    expect(() => run.$.parse('--i 3.2'.split(' '), { from: 'user' })).toThrow()
   })
 
   it('should validate delimited string, number, integer', () => {
-    const run = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.option('--s <strs>', (o) => o.parser.delimitedStrings().validator.isStringArray())
       c.option('--n <nums>', (o) => o.parser.delimitedNumbers().validator.isNumberArray())
       c.option('--i <ints>', (o) => o.parser.delimitedIntegers().validator.isIntegerArray())
       c.action(() => {})
     })
-    run().parse('--s a,b --n 3.1,4.1 --i 3,4,5'.split(' '), { from: 'user' })
+    run.$.parse('--s a,b --n 3.1,4.1 --i 3,4,5'.split(' '), { from: 'user' })
   })
 
   it('should validate variadic argument', () => {
-    const init = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.option('--i <ints...>', (o) => o.parser.integer().validator.isIntegerArray())
       c.option('--s <str>', (o) => o.validator.isString())
       c.action(() => {})
     })
-    expect(() => init().parse('--i 3 4 5 --s abc'.split(' '), { from: 'user' })).not.toThrow()
+    expect(() => run.$.parse('--i 3 4 5 --s abc'.split(' '), { from: 'user' })).not.toThrow()
   })
 
   it('should throw if invalid', () => {
-    const run = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.option('--i <ints>', (a) => a.parser.delimitedIntegers().validator.isIntegerArray())
       c.action(() => {})
       c.throwInsteadOfProcessExit()
       OutputManager.getInstance().stderr.disable()
     })
-    expect(() => run().parse(['--i 3,q,7'], { from: 'user' })).toThrow()
+    expect(() => run.$.parse(['--i 3,q,7'], { from: 'user' })).toThrow()
   })
 
   it('should validate with custom validator', () => {
-    const run = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.option('--a <arg>', (a) => a.validator.custom((arg) => arg === 'abc'))
       c.action(() => {})
       c.throwInsteadOfProcessExit()
     })
-    expect(() => run().parse('--a ab'.split(' '), { from: 'user' })).toThrow()
+    expect(() => run.$.parse('--a ab'.split(' '), { from: 'user' })).toThrow()
   })
 
   it('should validate with multiple validators', () => {
-    const run = CLI('t', (c) => {
+    const run = new CommandBuilder('t', (c) => {
       c.option('--a <arg>', (a) => {
         a.validator.custom((arg: string) => arg !== 'abc')
         a.validator.custom((arg: string) => arg.length >= 3)
@@ -83,8 +82,8 @@ describe(OptionArgumentValidatorSelector.name, () => {
       c.action(() => {})
       c.throwInsteadOfProcessExit()
     })
-    expect(() => run().parse('--a ab'.split(' '), { from: 'user' })).toThrow()
-    expect(() => run().parse('--a abc'.split(' '), { from: 'user' })).toThrow()
-    expect(() => run().parse('--a abcd'.split(' '), { from: 'user' })).not.toThrow()
+    expect(() => run.$.parse('--a ab'.split(' '), { from: 'user' })).toThrow()
+    expect(() => run.$.parse('--a abc'.split(' '), { from: 'user' })).toThrow()
+    expect(() => run.$.parse('--a abcd'.split(' '), { from: 'user' })).not.toThrow()
   })
 })

package/src/util/array/arrSome.test.ts

@@ -6,17 +6,17 @@ describe('arrSome', () => {
     expect(
       arrSome(arr, (element: any) => {
         return element.length > 5
-      }),
+      })
     ).toBe(false)
     expect(
       arrSome(arr, (element: any) => {
         return element.length === 5
-      }),
+      })
     ).toBe(true)
     expect(
       arrSome([], (element: any) => {
         return element.length === 5
-      }),
+      })
     ).toBe(false)
   })
 

package/dist/cjs/cmd/CLI.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLI = void 0;
-const CommandBuilder_1 = require("./CommandBuilder");
-function CLI(name, callback) {
-    return () => new CommandBuilder_1.CommandBuilder(name, callback).commander;
-}
-exports.CLI = CLI;
-/*
-
-TODO: should return a class that offers:
-- command
-- main
-- action
-*/
-//# sourceMappingURL=CLI.js.map

package/dist/cjs/cmd/CLI.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"CLI.js","sourceRoot":"","sources":["../../../src/cmd/CLI.ts"],"names":[],"mappings":";;;AAAA,qDAAiD;AAEjD,SAAgB,GAAG,CAAC,IAAY,EAAE,QAA6D;IAC7F,OAAO,GAAG,EAAE,CAAC,IAAI,+BAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,SAAS,CAAA;AAC3D,CAAC;AAFD,kBAEC;AAED;;;;;;EAME"}