@travetto/cli 2.1.2 → 2.2.1

package/bin/cli.ts

@@ -6,7 +6,7 @@ import { EnvUtil } from '@travetto/boot';
 /**
  * Entry point
  */
-export async function main() {
+export async function main(): Promise<void> {
   if (!EnvUtil.isFalse('TRV_CLI_LOCAL') && !PathUtil.toUnix(__filename).includes(PathUtil.cwd)) { // If the current file is not under the working directory
     console.error(`
 The @travetto/cli is not intended to be installed globally.  Please install it within your local project

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/cli",
   "displayName": "Command Line Interface",
-  "version": "2.1.2",
+  "version": "2.2.1",
   "description": "CLI infrastructure for travetto framework",
   "keywords": [
     "cli",
@@ -27,8 +27,8 @@
     "directory": "module/cli"
   },
   "dependencies": {
-    "@travetto/base": "^2.1.2",
-    "commander": "^9.3.0"
+    "@travetto/base": "^2.2.1",
+    "commander": "^9.4.0"
   },
   "docDependencies": {
     "@travetto/app": true

package/src/color.ts

@@ -1,14 +1,6 @@
 import { ColorUtil } from '@travetto/boot/src/color';
 
-/**
- * Colorize a string, as a string interpolation
- *
- * @example
- * ```
- * color`${{title: 'Main Title'}} is ${{subtitle: 'Sub Title}}`
- * ```
- */
-export const color = ColorUtil.makeTemplate({
+const colorSet = {
   input: ColorUtil.makeColorer('yellow'),
   output: ColorUtil.makeColorer('magenta'),
   path: ColorUtil.makeColorer('cyan'),
@@ -21,4 +13,17 @@ export const color = ColorUtil.makeTemplate({
   identifier: ColorUtil.makeColorer('blue', 'bold'),
   subtitle: ColorUtil.makeColorer('white'),
   subsubtitle: ColorUtil.makeColorer('white', 'faint')
-});
+} as const;
+
+/**
+ * Colorize a string, as a string interpolation
+ *
+ * @example
+ * ```
+ * color`${{title: 'Main Title'}} is ${{subtitle: 'Sub Title}}`
+ * ```
+ */
+export const color = ColorUtil.makeTemplate(colorSet);
+
+
+export type ColoredElement = keyof typeof colorSet;

package/src/execute.ts

@@ -1,4 +1,4 @@
-import * as commander from 'commander';
+import { program as commander } from 'commander';
 
 import { CliUtil } from './util';
 import { CompletionConfig } from './types';
@@ -14,10 +14,10 @@ export class ExecutionManager {
   /**
    * Run tab completion given the full args list
    */
-  static async runCompletion(args: string[]) {
-    const compl: CompletionConfig = { all: [], task: {} };
-    await PluginManager.loadAllPlugins(x => x.setupCompletion(compl));
-    const res = await CliUtil.getCompletion(compl, args.slice(3));
+  static async runCompletion(args: string[]): Promise<void> {
+    const cfg: CompletionConfig = { all: [], task: {} };
+    await PluginManager.loadAllPlugins(x => x.setupCompletion(cfg));
+    const res = await CliUtil.getCompletion(cfg, args.slice(3));
     console.log(res.join(' '));
     return;
   }
@@ -25,7 +25,7 @@ export class ExecutionManager {
   /**
    * Run plugin
    */
-  static async runPlugin(args: string[]) {
+  static async runPlugin(args: string[]): Promise<void> {
     const cmd = args[2];
 
     let plugin;
@@ -45,6 +45,9 @@ export class ExecutionManager {
         commander.parse(args);
       }
     } catch (err) {
+      if (!(err instanceof Error)) {
+        throw err;
+      }
       return plugin.showHelp(err);
     }
   }
@@ -53,7 +56,7 @@ export class ExecutionManager {
    * Execute the command line
    * @param args argv
    */
-  static async run(args: string[]) {
+  static async run(args: string[]): Promise<void> {
     const width = +(process.env.TRV_CONSOLE_WIDTH ?? process.stdout.columns ?? 120);
     commander
       .version(version)

package/src/help.ts

@@ -11,7 +11,7 @@ export class HelpUtil {
    * @param text Source text
    * @param key
    */
-  static extractValue(text: string, key: string) {
+  static extractValue(text: string, key: string): readonly [string, string] {
     let sub = '';
     if (text.includes(key)) {
       const start = text.indexOf(key);
@@ -28,7 +28,7 @@ export class HelpUtil {
   /**
    * Colorize Usage
    */
-  static colorizeOptions(option: string) {
+  static colorizeOptions(option: string): string {
     return option.replace(/(\s*)(-[^, ]+)(,?\s*)(--\S+)?((\s+)?((?:\[[^\]]+\])|(?:\<[^>]+>)))?((\s+)(.*))?/g, (
       p: string, spacing: string,
       simpleParam: string, pSep: string,
@@ -59,7 +59,7 @@ export class HelpUtil {
   /**
    * Colorize command section
    */
-  static colorizeCommands(commands: string) {
+  static colorizeCommands(commands: string): string {
     return commands
       .replace(/\s([^\[\]]\S+)/g, param => color`${{ param }}`)
       .replace(/(\s*[^\x1b]\[[^\]]+\])/g, input => color`${{ input }}`) // eslint-disable-line no-control-regex
@@ -69,14 +69,14 @@ export class HelpUtil {
   /**
    * Colorize usage
    */
-  static colorizeUsage(usage: string) {
+  static colorizeUsage(usage: string): string {
     return usage.replace(/Usage:/, title => color`${{ title }}`);
   }
 
   /**
    * Get full help text
    */
-  static getHelpText(text: string, extraText?: string) {
+  static getHelpText(text: string, extraText?: string): string {
     const [usage, text2] = this.extractValue(text, 'Usage:');
     const [options, text3] = this.extractValue(text2, 'Options:');
     const [commands, textFinal] = this.extractValue(text3, 'Commands:');

package/src/plugin-base.ts

@@ -6,7 +6,9 @@ import { CliUtil } from './util';
 
 type Completion = Record<string, string[]>;
 
-type ParamConfig<K> = {
+type OptionPrimitive = string | number | boolean | string[] | number[];
+
+export type OptionConfig<K extends OptionPrimitive = OptionPrimitive> = {
   type?: Function;
   key?: string;
   short?: string | false;
@@ -14,19 +16,19 @@ type ParamConfig<K> = {
   desc: string;
   completion?: boolean;
   def?: K;
-  choices?: K[];
+  choices?: K[] | readonly K[];
   combine?: (v: string, curr: K) => K;
 };
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-type ParamMap<T = any> = { [key in keyof T]: ParamConfig<T[key]> };
+type OptionMap<T = any> = { [key in keyof T]: T[key] extends OptionPrimitive ? OptionConfig<T[key]> : never };
 
-type Shape<M extends ParamMap> = { [k in keyof M]: Exclude<M[k]['def'], undefined> };
+type Shape<M extends OptionMap> = { [k in keyof M]: Exclude<M[k]['def'], undefined> };
 
 /**
  * Base plugin
  */
-export abstract class BasePlugin<V extends ParamMap = ParamMap> {
+export abstract class BasePlugin<V extends OptionMap> {
   /**
    * Command object
    */
@@ -72,7 +74,7 @@ export abstract class BasePlugin<V extends ParamMap = ParamMap> {
   /**
    * Define option
    */
-  option(cfg: ParamConfig<string>): ParamConfig<string> {
+  option(cfg: OptionConfig<string>): OptionConfig<string> {
     if (cfg.combine && cfg.def) {
       cfg.def = cfg.combine(cfg.def, cfg.def);
     }
@@ -82,20 +84,22 @@ export abstract class BasePlugin<V extends ParamMap = ParamMap> {
   /**
    * Define option
    */
-  choiceOption<K>({ choices, ...cfg }: ParamConfig<string> & { choices: K[] | readonly K[] }): ParamConfig<K> {
-    return {
+  choiceOption<K extends string | number>({ choices, ...cfg }: OptionConfig<K> & { choices: K[] | readonly K[] }): OptionConfig<K> {
+    const config: OptionConfig<K> = {
       type: String,
-      combine: (v, acc) => choices.includes(v as unknown as K) ? v as unknown as K : acc,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      combine: (v: string, acc: K): K => choices.includes(v as K) ? v as K : acc,
       choices,
       completion: true,
       ...cfg
-    } as ParamConfig<K>;
+    };
+    return config;
   }
 
   /**
    * Define list option
    */
-  listOption(cfg: ParamConfig<string[]>): ParamConfig<string[]> {
+  listOption(cfg: OptionConfig<string[]>): OptionConfig<string[]> {
     return {
       type: String,
       def: [],
@@ -108,7 +112,7 @@ export abstract class BasePlugin<V extends ParamMap = ParamMap> {
   /**
    * Define bool option
    */
-  boolOption(cfg: ParamConfig<boolean>): ParamConfig<boolean> {
+  boolOption(cfg: OptionConfig<boolean>): OptionConfig<boolean> {
     return {
       type: Boolean,
       combine: CliUtil.toBool.bind(CliUtil),
@@ -120,7 +124,7 @@ export abstract class BasePlugin<V extends ParamMap = ParamMap> {
   /**
    * Define int option
    */
-  intOption({ lower, upper, ...cfg }: ParamConfig<number> & { lower?: number, upper?: number }): ParamConfig<number> {
+  intOption({ lower, upper, ...cfg }: OptionConfig<number> & { lower?: number, upper?: number }): OptionConfig<number> {
     return {
       type: Number,
       combine: CliUtil.toInt.bind(CliUtil, lower, upper),
@@ -131,7 +135,7 @@ export abstract class BasePlugin<V extends ParamMap = ParamMap> {
   /**
    * Pre-compile on every cli execution
    */
-  async build() {
+  async build(): Promise<void> {
     await (await import('@travetto/base/bin/lib/'))
       .BuildUtil.build();
   }
@@ -139,14 +143,14 @@ export abstract class BasePlugin<V extends ParamMap = ParamMap> {
   /**
    * Expose configuration as constrained typed object
    */
-  get cmd() {
-    return this.#cmd.opts() as Shape<ReturnType<Exclude<this['getOptions'], undefined>>>;
+  get cmd(): Shape<V> {
+    return this.#cmd.opts();
   }
 
   /**
    * Expose command line arguments
    */
-  get args() {
+  get args(): string[] {
     return this.#cmd.args;
   }
 
@@ -164,11 +168,11 @@ export abstract class BasePlugin<V extends ParamMap = ParamMap> {
    * Process all options into final set before registering with commander
    * @returns
    */
-  async finalizeOptions() {
-    const opts = this.getOptions?.() ?? {};
+  async finalizeOptions(): Promise<OptionConfig[]> {
+    const opts = this.getOptions?.();
     const used = new Set();
 
-    return Object.entries(opts as ParamMap).map(([k, cfg]) => {
+    return (opts ? Object.entries(opts) : []).map(([k, cfg]) => {
       cfg.key = k;
       cfg.name ??= k.replace(/([a-z])([A-Z])/g, (_, l, r: string) => `${l}-${r.toLowerCase()}`);
       if (cfg.short === undefined) {
@@ -185,7 +189,7 @@ export abstract class BasePlugin<V extends ParamMap = ParamMap> {
   /**
    * Receive the commander object, and process
    */
-  async setup(cmd: commander.Command) {
+  async setup(cmd: commander.Command): Promise<commander.Command> {
     cmd = cmd.command(this.name);
     if (this.allowUnknownOptions) {
       cmd = cmd.allowUnknownOption(true);
@@ -201,7 +205,7 @@ export abstract class BasePlugin<V extends ParamMap = ParamMap> {
       if (cfg.type !== Boolean || cfg.def) {
         key = `${key} <${cfg.name}>`;
       }
-      cmd = cfg.combine ? cmd.option(key, cfg.desc, cfg.combine, cfg.def) : cmd.option(key, cfg.desc, cfg.def);
+      cmd = cfg.combine ? cmd.option(key, cfg.desc, cfg.combine, cfg.def) : cmd.option(key, cfg.desc, (cur, acc) => cur, cfg.def);
     }
 
     cmd = cmd.action(this.runAction.bind(this));
@@ -211,7 +215,7 @@ export abstract class BasePlugin<V extends ParamMap = ParamMap> {
   /**
    * Runs the action at execution time
    */
-  async runAction(...args: unknown[]) {
+  async runAction(...args: unknown[]): Promise<void> {
     await this.envInit?.();
     await this.build();
     return await this.action(...args);
@@ -220,7 +224,7 @@ export abstract class BasePlugin<V extends ParamMap = ParamMap> {
   /**
    * Collection tab completion information
    */
-  async setupCompletion(config: CompletionConfig) {
+  async setupCompletion(config: CompletionConfig): Promise<void> {
     const task = await this.complete();
     config.all = [...config.all, this.name];
     if (task) {
@@ -232,16 +236,14 @@ export abstract class BasePlugin<V extends ParamMap = ParamMap> {
    * Return tab completion information
    */
   async complete(): Promise<Completion | void> {
-    const out: Completion = {
-      '': [] as string[]
-    };
+    const out: Completion = { '': [] };
     for (const el of await this.finalizeOptions()) {
       if (el.completion) {
         out[''] = [...out['']!, `--${el.name} `];
         if (el.choices) {
-          out[`--${el.name} `] = el.choices;
+          out[`--${el.name} `] = el.choices.map(x => `${x}`);
           if (el.short) {
-            out[`- ${el.short} `] = el.choices;
+            out[`- ${el.short} `] = el.choices.map(x => `${x}`);
           }
         }
       }

package/src/plugin.ts

@@ -12,7 +12,7 @@ const PLUGIN_PACKAGE = [
   [/^openapi:(spec|client)$/, 'openapi', true],
   [/^email:(compile|dev)$/, 'email-template', false],
   [/^pack(:assemble|:zip|:docker)?$/, 'pack', false],
-] as [patt: RegExp, pkg: string, prod: boolean][];
+] as const;
 
 /**
  * Manages loading and finding all plugins
@@ -22,7 +22,7 @@ export class PluginManager {
   /**
    * Get list of all plugins available
    */
-  static getPluginMapping() {
+  static getPluginMapping(): Map<string, string> {
     const all = new Map<string, string>();
     for (const { file } of SourceIndex.find({ folder: 'bin', filter: /bin\/cli-/ })) {
       all.set(file.replace(/^.*\/bin\/.+?-(.*?)[.][^.]*$/, (_, f) => f), file);
@@ -47,7 +47,8 @@ ${{ identifier: `npm i ${prod ? '' : '--save-dev '}@travetto/${pkg}` }}`);
       }
       throw new Error(`Unknown command: ${cmd}`);
     }
-    for (const v of Object.values(await import(f)) as { new(...args: unknown[]): unknown }[]) {
+    const values = Object.values<{ new(...args: unknown[]): unknown }>(await import(f));
+    for (const v of values) {
       try {
         const inst = new v();
         if (inst instanceof BasePlugin) {
@@ -64,7 +65,7 @@ ${{ identifier: `npm i ${prod ? '' : '--save-dev '}@travetto/${pkg}` }}`);
   /**
    * Load all available plugins
    */
-  static async loadAllPlugins(op?: (p: BasePlugin) => unknown | Promise<unknown>) {
+  static async loadAllPlugins(op?: (p: BasePlugin) => unknown | Promise<unknown>): Promise<BasePlugin[]> {
     return Promise.all(
       [...this.getPluginMapping().keys()]
         .sort((a, b) => a.localeCompare(b))

package/src/util.ts

@@ -1,4 +1,7 @@
+import * as timers from 'timers/promises';
 import * as readline from 'readline';
+import { Writable } from 'stream';
+
 import { CompletionConfig } from './types';
 
 /**
@@ -8,20 +11,20 @@ export class CliUtil {
 
   static #waitState = '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏'.split('');
 
-  static isBoolean(x: string) {
+  static isBoolean(x: string): boolean {
     return /^(1|0|yes|no|on|off|auto|true|false)$/i.test(x);
   }
 
   static toBool(x: string | boolean, def: boolean): boolean;
   static toBool(x?: string | boolean, def?: boolean): boolean | undefined;
-  static toBool(x?: string | boolean, def?: boolean) {
+  static toBool(x?: string | boolean, def?: boolean): boolean | undefined {
     return x === undefined ? true :
       (typeof x === 'boolean' ? x :
         (this.isBoolean(x) ? /^(1|yes|on|true)$/i.test(x) :
           def));
   }
 
-  static toInt(l: number | undefined, u: number | undefined, v: string, d: number) {
+  static toInt(l: number | undefined, u: number | undefined, v: string, d: number): number {
     let n = +v;
     if (l === undefined && u === undefined) {
       return n;
@@ -38,7 +41,7 @@ export class CliUtil {
   /**
    * Get code completion values
    */
-  static async getCompletion(compl: CompletionConfig, args: string[]) {
+  static async getCompletion(cfg: CompletionConfig, args: string[]): Promise<string[]> {
     args = args.slice(0); // Copy as we mutate
 
     const cmd = args.shift()!;
@@ -47,27 +50,27 @@ export class CliUtil {
     let opts: string[] = [];
 
     // List all commands
-    if (!compl.task[cmd]) {
-      opts = compl.all;
+    if (!cfg.task[cmd]) {
+      opts = cfg.all;
     } else {
       // Look available sub commands
       last = args.pop() ?? '';
       const second = args.pop() ?? '';
       let flag = '';
 
-      if (last in compl.task[cmd]) {
+      if (last in cfg.task[cmd]) {
         flag = last;
         last = '';
-      } else if (second in compl.task[cmd]) {
+      } else if (second in cfg.task[cmd]) {
         // Look for available flags
-        if (compl.task[cmd][second].includes(last)) {
+        if (cfg.task[cmd][second].includes(last)) {
           flag = '';
           last = '';
         } else {
           flag = second;
         }
       }
-      opts = compl.task[cmd][flag];
+      opts = cfg.task[cmd][flag];
     }
 
     return last ? opts.filter(x => x.startsWith(last)) : opts.filter(x => !x.startsWith('-'));
@@ -79,7 +82,7 @@ export class CliUtil {
    * @param text Text, if desired
    * @param clear Should the entire line be cleared?
    */
-  static async rewriteLine(stream: NodeJS.WritableStream, text?: string, clear = false) {
+  static async rewriteLine(stream: Writable, text?: string, clear = false): Promise<void> {
     await new Promise<void>(r => readline.cursorTo(stream, 0, undefined, () => {
       if (clear) {
         readline.clearLine(stream, 0);
@@ -92,10 +95,6 @@ export class CliUtil {
     }));
   }
 
-  static sleep(ms: number) {
-    return new Promise(r => setTimeout(r, ms));
-  }
-
   /**
    * Waiting message with a callback to end
    *
@@ -103,8 +102,8 @@ export class CliUtil {
    * @param delay Delay duration
    */
   static async waiting<T>(message: string, work: Promise<T> | (() => Promise<T>),
-    config: { completion?: string, delay?: number, stream?: NodeJS.WritableStream } = {}
-  ) {
+    config: { completion?: string, delay?: number, stream?: Writable } = {}
+  ): Promise<T> {
     const { stream, delay, completion } = { delay: 1000, stream: process.stderr, ...config };
 
     const writeLine = this.rewriteLine.bind(this, stream);
@@ -120,26 +119,26 @@ export class CliUtil {
     let i = -1;
     let done = false;
     let value: T | undefined;
-    let err: Error | undefined;
+    let capturedError: Error | undefined;
     const final = work
       .then(res => value = res)
-      .catch(e => err = e)
+      .catch(err => capturedError = err)
       .finally(() => done = true);
 
     if (delay) {
-      await Promise.race([this.sleep(delay), final]);
+      await Promise.race([timers.setTimeout(delay), final]);
     }
 
     while (!done) {
       await writeLine(`${this.#waitState[i = (i + 1) % this.#waitState.length]} ${message}`);
-      await this.sleep(50);
+      await timers.setTimeout(50);
     }
 
     if (i >= 0) {
       await writeLine(completion ? `${message} ${completion}\n` : '', true);
     }
-    if (err) {
-      throw err;
+    if (capturedError) {
+      throw capturedError;
     } else {
       return value!;
     }