@bemoje/cli 0.0.4 → 0.0.5

package/src/cmd/CommandBuilderMetaData.test.ts

@@ -0,0 +1,54 @@
+import { CommandBuilderMetaData } from './CommandBuilderMetaData'
+import { Option } from '@commander-js/extra-typings'
+
+describe(CommandBuilderMetaData.name, () => {
+  describe('constructor', () => {
+    it('should have the expected properties', () => {
+      const meta = new CommandBuilderMetaData()
+      expect(meta).toHaveProperty('subcommands', [])
+      expect(meta).toHaveProperty('globalOptions', [])
+      expect(meta).toHaveProperty('hiddenGlobalOptions', new Set<Option>())
+      expect(meta).toHaveProperty('presetOptionKeys', [])
+      expect(meta).toHaveProperty('argParsers', [])
+      expect(meta).toHaveProperty('argValidators', [])
+      expect(meta).toHaveProperty('optParsers', {})
+      expect(meta).toHaveProperty('optValidators', {})
+      expect(meta).toHaveProperty('rawArgs', [])
+      expect(meta).toHaveProperty('isNative', false)
+    })
+
+    it('actionHandler', () => {
+      const meta = new CommandBuilderMetaData()
+      expect(meta.actionHandler).toBeInstanceOf(Function)
+      expect(meta.actionHandler.name).toBe('defaultActionHandler')
+      const custom = () => {}
+      Object.defineProperty(meta, 'actionHandler', { value: custom })
+      expect(meta.actionHandler).toBe(custom)
+    })
+
+    it('errorHandler', () => {
+      const meta = new CommandBuilderMetaData()
+      expect(meta.errorHandler).toBeInstanceOf(Function)
+      expect(meta.errorHandler.name).toBe('defaultErrorHandler')
+      const custom = () => {}
+      Object.defineProperty(meta, 'errorHandler', { value: custom })
+      expect(meta.errorHandler).toBe(custom)
+    })
+
+    it('hasCustomActionHandler', () => {
+      const meta = new CommandBuilderMetaData()
+      expect(meta.hasCustomActionHandler).toBe(false)
+      const custom = () => {}
+      Object.defineProperty(meta, 'actionHandler', { value: custom })
+      expect(meta.hasCustomActionHandler).toBe(true)
+    })
+
+    it('hasCustomErrorHandler', () => {
+      const meta = new CommandBuilderMetaData()
+      expect(meta.hasCustomErrorHandler).toBe(false)
+      const custom = () => {}
+      Object.defineProperty(meta, 'errorHandler', { value: custom })
+      expect(meta.hasCustomErrorHandler).toBe(true)
+    })
+  })
+})

package/src/cmd/CommandBuilderMetaData.ts

@@ -0,0 +1,44 @@
+import type { Any } from '../util/types/Any'
+import { CommandBuilder } from './CommandBuilder'
+import { ErrorParser } from '../util/errors/ErrorParser'
+import { Option } from '@commander-js/extra-typings'
+import { OutputManager } from '../core/OutputManager'
+import type { TStringParser } from '../util/types/TStringParser'
+import type { TValidator } from '../util/types/TValidator'
+
+export class CommandBuilderMetaData<Args extends Any[] = unknown[]> {
+  subcommands: CommandBuilder[] = []
+  optsMap: Record<string, Option> = {}
+  globalOptions: Option[] = []
+  hiddenGlobalOptions = new Set<Option>()
+  presetOptionKeys: string[] = []
+  argParsers: TStringParser<Any>[] = []
+  argValidators: TValidator<Any>[][] = []
+  optParsers: Record<string, TStringParser<Any>> = {}
+  optValidators: Record<string, TValidator<Any>[]> = {}
+  rawArgs: string[] = []
+  isNative = false
+
+  get actionHandler(): (this: CommandBuilder, ...args: any[]) => void | Promise<void> {
+    return async function defaultActionHandler(this: CommandBuilder) {
+      this.outputHelp()
+    }
+  }
+  get errorHandler(): (this: CommandBuilder, error: unknown, cmd: CommandBuilder) => void {
+    return function defaultErrorHandler(this: CommandBuilder, error: unknown) {
+      const parsed = new ErrorParser(error)
+      if (OutputManager.getInstance().debug.isEnabled) {
+        console.error(parsed.prettyStack())
+        this.outputError(parsed.summary())
+      } else {
+        this.outputError(parsed.summary())
+      }
+    }
+  }
+  get hasCustomActionHandler() {
+    return Object.hasOwn(this, 'actionHandler')
+  }
+  get hasCustomErrorHandler() {
+    return Object.hasOwn(this, 'errorHandler')
+  }
+}

package/src/cmd/CommandFeatureSelector.test.ts

@@ -0,0 +1,185 @@
+import { CommandBuilder } from './CommandBuilder'
+import { CommandFeatureSelector } from './CommandFeatureSelector'
+
+describe(CommandFeatureSelector.name, () => {
+  let c: CommandBuilder
+  let f: CommandFeatureSelector
+
+  beforeEach(() => {
+    c = new CommandBuilder('t')
+    f = new CommandFeatureSelector(c)
+  })
+
+  describe('constructor', () => {
+    it('should create a new instance', () => {
+      expect(f).toBeInstanceOf(CommandFeatureSelector)
+    })
+
+    it('should set default property values', () => {
+      expect(f.isAppDataEnabled).toBe(false)
+      expect(f.isConfigEnabled).toBe(false)
+      expect(f.isPresetsEnabled).toBe(false)
+      expect(f.isAutoAssignMissingOptionFlagsEnabled).toBe(false)
+      expect(f.isAutoAssignSubCommandAliasesEnabled).toBe(false)
+    })
+  })
+
+  describe('inheritFrom', () => {
+    it('should inherit feature settings from parentFeatures', () => {
+      const parentFeatures = new CommandFeatureSelector(c)
+      parentFeatures.isAutoAssignMissingOptionFlagsEnabled = true
+      parentFeatures.isAutoAssignSubCommandAliasesEnabled = true
+      parentFeatures.isPresetsEnabled = true
+      f.inheritFrom(parentFeatures)
+      expect(f.isAutoAssignMissingOptionFlagsEnabled).toBe(true)
+      expect(f.isAutoAssignSubCommandAliasesEnabled).toBe(true)
+      expect(f.isPresetsEnabled).toBe(true)
+    })
+  })
+
+  describe('appData', () => {
+    it('should enable the app data feature', () => {
+      f.appData()
+      expect(f.isAppDataEnabled).toBe(true)
+    })
+
+    it('should disable the app data feature', () => {
+      f.isAppDataEnabled = true
+      f.appData(false)
+      expect(f.isAppDataEnabled).toBe(false)
+    })
+
+    it('should not modify the app data feature if the value is same as current', () => {
+      f.isAppDataEnabled = true
+      f.appData(true)
+      expect(f.isAppDataEnabled).toBe(true)
+    })
+
+    it('should throw an error if the command is native', () => {
+      c.meta.isNative = true
+      expect(() => {
+        f.appData()
+      }).toThrowError('Cannot configure appData for native command.')
+    })
+
+    it('should output a debug message', () => {
+      const spy = jest.spyOn(c, 'outputDebugMessage').mockImplementation(() => {})
+      f.appData()
+      expect(spy).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('config', () => {
+    it('should enable the config feature', () => {
+      f.config()
+      expect(f.isConfigEnabled).toBe(true)
+    })
+
+    it('should disable the config feature', () => {
+      f.isConfigEnabled = true
+      f.config(false)
+      expect(f.isConfigEnabled).toBe(false)
+    })
+
+    it('should not modify the config feature if the value is same as current', () => {
+      f.isConfigEnabled = true
+      f.config(true)
+      expect(f.isConfigEnabled).toBe(true)
+    })
+
+    it('should throw an error if the command is native', () => {
+      c.meta.isNative = true
+      expect(() => {
+        f.config()
+      }).toThrowError('Cannot configure config for native command.')
+    })
+
+    it('should output a debug message', () => {
+      const spy = jest.spyOn(c, 'outputDebugMessage').mockImplementation(() => {})
+      f.config()
+      expect(spy).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('presets', () => {
+    it('should enable the presets feature', () => {
+      f.presets()
+      expect(f.isPresetsEnabled).toBe(true)
+    })
+
+    it('should disable the presets feature', () => {
+      f.isPresetsEnabled = true
+      f.presets(false)
+      expect(f.isPresetsEnabled).toBe(false)
+    })
+
+    it('should not modify the presets feature if the value is same as current', () => {
+      f.isPresetsEnabled = true
+      f.presets(true)
+      expect(f.isPresetsEnabled).toBe(true)
+    })
+
+    it('should throw an error if the command is native', () => {
+      c.meta.isNative = true
+      expect(() => {
+        f.presets()
+      }).toThrowError('Cannot configure presets for native command.')
+    })
+
+    it('should output a debug message', () => {
+      const spy = jest.spyOn(c, 'outputDebugMessage').mockImplementation(() => {})
+      f.presets()
+      expect(spy).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('autoAssignMissingOptionFlags', () => {
+    it('should enable the auto assign missing option flags feature', () => {
+      f.autoAssignMissingOptionFlags()
+      expect(f.isAutoAssignMissingOptionFlagsEnabled).toBe(true)
+    })
+
+    it('should disable the auto assign missing option flags feature', () => {
+      f.isAutoAssignMissingOptionFlagsEnabled = true
+      f.autoAssignMissingOptionFlags(false)
+      expect(f.isAutoAssignMissingOptionFlagsEnabled).toBe(false)
+    })
+
+    it('should not modify the auto assign missing option flags feature if the value is same as current', () => {
+      f.isAutoAssignMissingOptionFlagsEnabled = true
+      f.autoAssignMissingOptionFlags(true)
+      expect(f.isAutoAssignMissingOptionFlagsEnabled).toBe(true)
+    })
+
+    it('should output a debug message', () => {
+      const spy = jest.spyOn(c, 'outputDebugMessage').mockImplementation(() => {})
+      f.autoAssignMissingOptionFlags()
+      expect(spy).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('autoAssignSubCommandAliases', () => {
+    it('should enable the auto assign sub command aliases feature', () => {
+      f.autoAssignSubCommandAliases()
+      expect(f.isAutoAssignSubCommandAliasesEnabled).toBe(true)
+    })
+
+    it('should disable the auto assign sub command aliases feature', () => {
+      f.isAutoAssignSubCommandAliasesEnabled = true
+      f.autoAssignSubCommandAliases(false)
+      expect(f.isAutoAssignSubCommandAliasesEnabled).toBe(false)
+    })
+
+    it('should not modify the auto assign sub command aliases feature if the value is same as current', () => {
+      f.isAutoAssignSubCommandAliasesEnabled = true
+      f.autoAssignSubCommandAliases(true)
+      expect(f.isAutoAssignSubCommandAliasesEnabled).toBe(true)
+    })
+
+    it('should output a debug message', () => {
+      const spy = jest.spyOn(c, 'outputDebugMessage').mockImplementation(() => {})
+      f.autoAssignSubCommandAliases()
+      expect(spy).toHaveBeenCalledTimes(1)
+    })
+  })
+})

package/src/cmd/CommandFeatureSelector.ts

@@ -0,0 +1,113 @@
+import { CommandBuilder } from './CommandBuilder'
+
+/**
+ * Represents a selector for enabling or disabling command features.
+ */
+export class CommandFeatureSelector {
+  /**
+   * Indicates whether the app data feature is enabled.
+   */
+  isAppDataEnabled = false
+
+  /**
+   * Indicates whether the config feature is enabled.
+   */
+  isConfigEnabled = false
+
+  /**
+   * Indicates whether the presets feature is enabled.
+   */
+  isPresetsEnabled = false
+
+  /**
+   * Indicates whether the auto assign missing option flags feature is enabled.
+   */
+  isAutoAssignMissingOptionFlagsEnabled = false
+
+  /**
+   * Indicates whether the auto assign sub command aliases feature is enabled.
+   */
+  isAutoAssignSubCommandAliasesEnabled = false
+
+  /**
+   * Creates a new instance of the CommandFeatureSelector class.
+   * @param cmd - The command builder instance.
+   */
+  constructor(protected readonly cmd: CommandBuilder) {}
+
+  /**
+   * Inherits the feature settings from a parent CommandFeatureSelector instance.
+   * @param parentFeatures - The parent CommandFeatureSelector instance to inherit from.
+   */
+  inheritFrom(parentFeatures: CommandFeatureSelector) {
+    if (!parentFeatures) return
+    if (this.cmd.meta.isNative) this.isAutoAssignMissingOptionFlagsEnabled = true
+    else this.isAutoAssignMissingOptionFlagsEnabled = parentFeatures.isAutoAssignMissingOptionFlagsEnabled
+    this.isAutoAssignSubCommandAliasesEnabled = parentFeatures.isAutoAssignSubCommandAliasesEnabled
+    this.isPresetsEnabled = parentFeatures.isPresetsEnabled
+  }
+
+  /**
+   * Enables or disables the app data feature.
+   * @param boolean - Indicates whether the app data feature should be enabled or disabled.
+   * @returns The current CommandFeatureSelector instance.
+   * @throws Error if the command is native and the app data feature is being configured.
+   */
+  appData(boolean = true) {
+    return this.setProperty(boolean, 'isAppDataEnabled', 'appData', true)
+  }
+
+  /**
+   * Enables or disables the config feature.
+   * @param boolean - Indicates whether the config feature should be enabled or disabled.
+   * @returns The current CommandFeatureSelector instance.
+   * @throws Error if the command is native and the config feature is being configured.
+   */
+  config(boolean = true) {
+    return this.setProperty(boolean, 'isConfigEnabled', 'config', true)
+  }
+
+  /**
+   * Enables or disables the presets feature.
+   * @param boolean - Indicates whether the presets feature should be enabled or disabled.
+   * @returns The current CommandFeatureSelector instance.
+   * @throws Error if the command is native and the presets feature is being configured.
+   */
+  presets(boolean = true) {
+    return this.setProperty(boolean, 'isPresetsEnabled', 'presets', true)
+  }
+
+  /**
+   * Enables or disables the auto assign missing option flags feature.
+   * @param boolean - Indicates whether the auto assign missing option flags feature should be enabled or disabled.
+   * @returns The current CommandFeatureSelector instance.
+   */
+  autoAssignMissingOptionFlags(boolean = true) {
+    return this.setProperty(boolean, 'isAutoAssignMissingOptionFlagsEnabled', 'autoAssignMissingOptionFlags', false)
+  }
+
+  /**
+   * Enables or disables the auto assign sub command aliases feature.
+   * @param boolean - Indicates whether the auto assign sub command aliases feature should be enabled or disabled.
+   * @returns The current CommandFeatureSelector instance.
+   */
+  autoAssignSubCommandAliases(boolean = true) {
+    return this.setProperty(boolean, 'isAutoAssignSubCommandAliasesEnabled', 'autoAssignSubCommandAliases', false)
+  }
+
+  /**
+   * Helper method to enable or disable a feature.
+   * @param boolean - Indicates whether the auto assign sub command aliases feature should be enabled or disabled.
+   * @param prop - The property name to set.
+   * @param method - The method name to output in the debug message.
+   * @param throwIfNative - Indicates whether an error should be thrown if the command is native.
+   * @returns The current CommandFeatureSelector instance.
+   */
+  protected setProperty(boolean = true, prop: keyof this, method: string, throwIfNative: boolean) {
+    if (this[prop] === boolean) return this
+    if (throwIfNative && this.cmd.meta.isNative) throw new Error(`Cannot configure ${method} for native command.`)
+    Object.defineProperty(this, prop, { value: boolean, configurable: true, writable: true, enumerable: true })
+    this.cmd.outputDebugMessage('featureEnabled', () => ({ [method]: boolean }))
+    return this
+  }
+}

package/src/cmd/DefaultHelpConfig.test.ts

@@ -0,0 +1,22 @@
+import { CommandBuilder } from './CommandBuilder'
+import { DefaultHelpConfig } from './DefaultHelpConfig'
+
+describe('DefaultHelpConfig', () => {
+  it('should be a partial Help object', () => {
+    CommandBuilder // needs to load first for prototype override
+    expect(DefaultHelpConfig).toHaveProperty('helpWidth')
+    expect(DefaultHelpConfig).toHaveProperty('showGlobalOptions')
+    expect(DefaultHelpConfig).toHaveProperty('sortSubcommands')
+    expect(DefaultHelpConfig).toHaveProperty('sortOptions')
+    expect(DefaultHelpConfig).toHaveProperty('subcommandTerm')
+    expect(DefaultHelpConfig).toHaveProperty('argumentTerm')
+    expect(DefaultHelpConfig).toHaveProperty('commandUsage')
+    expect(DefaultHelpConfig).toHaveProperty('visibleOptions')
+    expect(DefaultHelpConfig).toHaveProperty('visibleGlobalOptions')
+    expect(DefaultHelpConfig).toHaveProperty('subcommandDescription')
+    expect(DefaultHelpConfig).toHaveProperty('optionDescription')
+    expect(DefaultHelpConfig).toHaveProperty('argumentDescription')
+    expect(DefaultHelpConfig).toHaveProperty('commandDescription')
+    expect(DefaultHelpConfig).toHaveProperty('formatHelp')
+  })
+})

package/src/cmd/DefaultHelpConfig.ts

@@ -0,0 +1,141 @@
+import colors from 'ansi-colors'
+import { Argument, Command, Help, Option } from '@commander-js/extra-typings'
+
+export const DefaultHelpConfig = {
+  helpWidth: undefined,
+  showGlobalOptions: true,
+  sortSubcommands: false,
+  sortOptions: false,
+  subcommandTerm,
+  argumentTerm,
+  commandUsage,
+  visibleOptions,
+  visibleGlobalOptions,
+  subcommandDescription,
+  optionDescription,
+  argumentDescription,
+  commandDescription,
+  formatHelp,
+}
+
+function formatHelp(this: Help, cmd: Command) {
+  let result = Help.prototype.formatHelp.call(this, cmd, this)
+  result = movePresetOptionsUnderOwnHeader(result)
+  result = rearrangeSections(result)
+  result = fixLinebreaks(result)
+  result = addColors(result)
+  return result
+
+  function movePresetOptionsUnderOwnHeader(result: string) {
+    const lines = result.split('\n')
+    const presetLines = lines.filter((line) => line.includes('[Preset]:'))
+    const firstPresetIndex = lines.findIndex((line) => line.includes('[Preset]'))
+    if (firstPresetIndex !== -1) {
+      lines.splice(firstPresetIndex, presetLines.length)
+      lines.push('', 'Preset Options:', ...presetLines)
+      result = lines.join('\n')
+    }
+    return result
+  }
+
+  function rearrangeSections(result: string) {
+    const order = [
+      'Usage:',
+      'Version:',
+      'Description:',
+      'Commands:',
+      'Arguments:',
+      'Options:',
+      'Global Options:',
+      'Preset Options:',
+    ]
+    const blocks: Record<string, unknown> = {}
+    let lastAddedBlock = 'Description:'
+    result.split(/\n\n+/).forEach((block) => {
+      const title = block.split(':')[0].trim() + ':'
+      if (/^[A-Z][\w ]+:/.test(title)) {
+        blocks[title] = block
+        lastAddedBlock = title
+        if (!order.includes(title)) order.push(title)
+      } else {
+        if (!order.includes(lastAddedBlock)) order.push(lastAddedBlock)
+        blocks[lastAddedBlock] = ((blocks[lastAddedBlock] || '') + '\n\n' + block).trim()
+      }
+    })
+    result = order
+      .map((title) => blocks[title])
+      .join('\n\n')
+      .trim()
+    return result
+  }
+
+  function fixLinebreaks(result: string) {
+    result = '\n' + result.trim() + '\n\n'
+    result = result.replace(/\n\n+/g, '\n\n')
+    return result
+  }
+
+  function addColors(result: string) {
+    result = result.replace(/\|/g, colors.gray(colors.dim('|')))
+    result = result.replace(/^[A-Z][\w ]+:/gm, (s) => colors.yellow(s))
+    return result
+  }
+}
+
+function subcommandTerm(this: Help, cmd: Command): string {
+  const args = cmd.registeredArguments.map((arg) => this.argumentTerm(arg)).join(' ')
+  const parent = cmd.parent || cmd
+  const hasAliases = !cmd.parent || parent.commands.some((c) => !!c.alias())
+  if (!hasAliases) return cmd.name() + (args ? ' ' + args : '')
+  const padsize = Math.max(1, ...parent.commands.map((c) => c.alias()?.length || 1))
+  let alias = cmd.alias() || ' '
+  alias = alias.padEnd(padsize, ' ') + ' |'
+  return alias + cmd.name() + (args ? ' ' + args : '')
+}
+
+function argumentTerm(this: Help, arg: Argument) {
+  let r = arg.name()
+  const rest = arg.variadic ? '...' : ''
+  if (arg.required) r = '<' + r + rest + '>'
+  else r = '[' + r + rest + ']'
+  return r
+}
+
+function commandUsage(this: Help, cmd: Command) {
+  const args = cmd.registeredArguments.map((arg) => this.argumentTerm(arg)).join(' ')
+  return [cmd.builder.getPrefixString() + ' ' + (args ? args : '[command]'), '[options]'].join(' ')
+}
+
+function visibleOptions(this: Help, cmd: Command) {
+  const builder = cmd.builder
+  const opts = cmd.options.filter((opt) => !opt.hidden && !builder.meta.globalOptions.includes(opt))
+  const presets = opts.filter((opt) => opt.description.startsWith('[Preset]'))
+  return opts.filter((opt) => !presets.includes(opt)).concat(presets)
+}
+
+function visibleGlobalOptions(this: Help, cmd: Command) {
+  const gopts = cmd.builder.getGlobalOptions()
+  if (gopts.find((opt) => opt.long === '--help')) return gopts
+  const help = cmd.options.find((opt) => opt.long === '--help')
+  if (help) gopts.push(help)
+  return gopts
+}
+
+function subcommandDescription(this: Help, cmd: Command) {
+  return colors.gray(Help.prototype.subcommandDescription.call(this, cmd))
+}
+
+function optionDescription(this: Help, opt: Option) {
+  return colors.gray(Help.prototype.optionDescription.call(this, opt))
+}
+
+function argumentDescription(this: Help, arg: Argument) {
+  return colors.gray(Help.prototype.argumentDescription.call(this, arg))
+}
+
+function commandDescription(this: Help, cmd: Command) {
+  const v = cmd.builder.getVersion()
+  const version = v ? colors.yellow('Version: ') + v + '\n\n' : ''
+  const description = 'Description:\n' + Help.prototype.commandDescription.call(this, cmd)
+  return version + description
+}

package/src/cmd/asdas.ts

@@ -0,0 +1,40 @@
+// export type MappedTypeWithNewProperties<T> = {
+//   [K in keyof T]: T[K]
+// }
+
+import { CommandBuilder } from './CommandBuilder'
+
+export type ReturnTypesOfFunctionArray<Arr extends ((...args: any[]) => unknown)[]> = {
+  [I in keyof Arr]: Arr[I] extends never | undefined ? string : ReturnType<Arr[I]>
+}
+
+export type ReturnTypesOfFunctionMap<O extends Record<string, (...args: any[]) => unknown>> = {
+  [K in keyof O]: O[K] extends never | undefined ? string : ReturnType<O[K]>
+}
+
+const args = [() => 1, () => '1', () => true]
+const opts = { a: () => 1, b: () => '1', c: () => true }
+
+type TArgs = ReturnTypesOfFunctionArray<typeof args>
+
+type TOpts = ReturnTypesOfFunctionMap<typeof opts>
+
+const cli = new CommandBuilder('test', (c) => {
+  c.argument('[int]', (a) => {
+    a.parser.integer()
+  })
+  c.argument('[str]', (a) => {
+    a.parser.string()
+  })
+  c.option('--opt1 <value>', (o) => {
+    o.parser.string()
+  })
+  c.option('--opt1 <value>', (o) => {
+    o.parser.integer()
+  })
+  c.action((int, str, opts) => {
+    const parsers = cli.meta.argParsers
+    type Arrr = ReturnTypesOfFunctionArray<typeof parsers>
+    console.log({ int, str, opts })
+  })
+})