feat: concrete option type

yjl9903 · Jun 21, 2022 · d23bd4c · d23bd4c
1 parent 8a6e697
commit d23bd4c
Show file tree

Hide file tree

Showing 9 changed files with 286 additions and 101 deletions.
diff --git a/README.md b/README.md
@@ -35,9 +35,7 @@ cli.run(process.argv.slice(2))
 
 If you are using IDEs that support TypeScript (like [Visual Studio Code](https://code.visualstudio.com/)), move your cursor to the parameter `option` in this `dev` command, and then you will find the `option` is automatically typed with `{ host: string, port: string }` or `Record<'host' | 'port', string>`.
 
-![vscode1](./images/vscode1.png)
-
-![vscode2](./images/vscode2.png)
+![vscode](./images/vscode.png)
 
 ### Limitation
 

diff --git a/images/vscode1.png → images/vscode.png b/images/vscode1.png → images/vscode.png
diff --git a/images/vscode2.png b/images/vscode2.png
diff --git a/src/breadc.ts b/src/breadc.ts
@@ -6,7 +6,7 @@ import { createDefaultLogger } from './logger';
 import { Option, OptionConfig } from './option';
 import { Command, CommandConfig, createHelpCommand, createVersionCommand } from './command';
 
-export class Breadc<GlobalOption extends string | never = never> {
+export class Breadc<GlobalOption extends object = {}> {
   private readonly name: string;
   private readonly _version: string;
   private readonly description?: string | string[];
@@ -22,7 +22,7 @@ export class Breadc<GlobalOption extends string | never = never> {
     this.name = name;
     this._version = option.version ?? 'unknown';
     this.description = option.description;
-    this.logger = option.logger ?? createDefaultLogger(name);
+    this.logger = createDefaultLogger(name, option.logger);
 
     const breadc = {
       name: this.name,
@@ -103,34 +103,34 @@ export class Breadc<GlobalOption extends string | never = never> {
     return output;
   }
 
-  option<F extends string>(
+  option<F extends string, T = string>(
     format: F,
     description: string,
-    config?: Omit<OptionConfig, 'description'>
-  ): Breadc<GlobalOption | ExtractOption<F>>;
+    config?: Omit<OptionConfig<T>, 'description'>
+  ): Breadc<GlobalOption & ExtractOption<F>>;
 
-  option<F extends string>(
+  option<F extends string, T = string>(
     format: F,
-    config?: OptionConfig
-  ): Breadc<GlobalOption | ExtractOption<F>>;
+    config?: OptionConfig<T>
+  ): Breadc<GlobalOption & ExtractOption<F>>;
 
-  option<F extends string>(
+  option<F extends string, T = string>(
     format: F,
-    configOrDescription: OptionConfig | string = '',
-    otherConfig: Omit<OptionConfig, 'description'> = {}
-  ): Breadc<GlobalOption | ExtractOption<F>> {
-    const config: OptionConfig =
+    configOrDescription: OptionConfig<T> | string = '',
+    otherConfig: Omit<OptionConfig<T>, 'description'> = {}
+  ): Breadc<GlobalOption & ExtractOption<F>> {
+    const config: OptionConfig<T> =
       typeof configOrDescription === 'object'
         ? configOrDescription
         : { ...otherConfig, description: configOrDescription };
 
     try {
-      const option = new Option(format, config);
-      this.options.push(option);
+      const option = new Option<F, T>(format, config);
+      this.options.push(option as unknown as Option);
     } catch (error: any) {
       this.logger.warn(error.message);
     }
-    return this as Breadc<GlobalOption | ExtractOption<F>>;
+    return this as Breadc<GlobalOption & ExtractOption<F>>;
   }
 
   command<F extends string>(
@@ -163,32 +163,52 @@ export class Breadc<GlobalOption extends string | never = never> {
   }
 
   parse(args: string[]): ParseResult {
-    const allowOptions = [this.options, this.commands.map((c) => c.options)].flat() as Option[];
+    const allowOptions: Option[] = [...this.options, ...this.commands.flatMap((c) => c.options)];
 
     const alias = allowOptions.reduce((map: Record<string, string>, o) => {
       if (o.shortcut) {
         map[o.shortcut] = o.name;
       }
       return map;
     }, {});
+    const defaults = allowOptions.reduce((map: Record<string, string>, o) => {
+      if (o.default) {
+        map[o.name] = o.default;
+      }
+      return map;
+    }, {});
 
     const argv = minimist(args, {
       string: allowOptions.filter((o) => o.type === 'string').map((o) => o.name),
       boolean: allowOptions.filter((o) => o.type === 'boolean').map((o) => o.name),
-      alias
+      alias,
+      default: defaults,
+      unknown: (t) => {
+        if (t[0] !== '-') return true;
+        else {
+          if (['--help', '-h', '--version', '-v'].includes(t)) {
+            return true;
+          } else {
+            this.logger.warn(`Find unknown flag "${t}"`);
+            return false;
+          }
+        }
+      }
     });
 
     for (const shortcut of Object.keys(alias)) {
       delete argv[shortcut];
     }
 
+    // Try non-default command first
     for (const command of this.commands) {
       if (!command.default && command.shouldRun(argv)) {
-        return command.parseArgs(argv);
+        return command.parseArgs(argv, this.options);
       }
     }
+    // Then try default command
     if (this.defaultCommand) {
-      return this.defaultCommand.parseArgs(argv);
+      return this.defaultCommand.parseArgs(argv, this.options);
     }
 
     const argumentss = argv['_'];

diff --git a/src/command.ts b/src/command.ts
@@ -17,11 +17,7 @@ export interface CommandConfig {
   description?: string;
 }
 
-export class Command<
-  F extends string = string,
-  GlobalOption extends string | never = never,
-  CommandOption extends string | never = never
-> {
+export class Command<F extends string = string, CommandOption extends object = {}> {
   private static MaxDep = 5;
 
   private readonly conditionFn?: ConditionFn;
@@ -32,7 +28,7 @@ export class Command<
   readonly description: string;
   readonly options: Option[] = [];
 
-  private actionFn?: ActionFn<ExtractCommand<F>, GlobalOption | CommandOption>;
+  private actionFn?: ActionFn<ExtractCommand<F>, CommandOption>;
 
   constructor(format: F, config: CommandConfig & { condition?: ConditionFn; logger: Logger }) {
     this.format = config.condition
@@ -53,34 +49,34 @@ export class Command<
     }
   }
 
-  option<OF extends string>(
+  option<OF extends string, T = string>(
     format: OF,
     description: string,
-    config?: Omit<OptionConfig, 'description'>
-  ): Command<F, GlobalOption, CommandOption | ExtractOption<OF>>;
+    config?: Omit<OptionConfig<T>, 'description'>
+  ): Command<F, CommandOption & ExtractOption<OF>>;
 
-  option<OF extends string>(
+  option<OF extends string, T = string>(
     format: OF,
-    config?: OptionConfig
-  ): Command<F, GlobalOption, CommandOption | ExtractOption<OF>>;
+    config?: OptionConfig<T>
+  ): Command<F, CommandOption & ExtractOption<OF>>;
 
-  option<OF extends string>(
+  option<OF extends string, T = string>(
     format: OF,
-    configOrDescription: OptionConfig | string = '',
-    otherConfig: Omit<OptionConfig, 'description'> = {}
-  ): Command<F, GlobalOption, CommandOption | ExtractOption<OF>> {
-    const config: OptionConfig =
+    configOrDescription: OptionConfig<T> | string = '',
+    otherConfig: Omit<OptionConfig<T>, 'description'> = {}
+  ): Command<F, CommandOption & ExtractOption<OF>> {
+    const config: OptionConfig<T> =
       typeof configOrDescription === 'object'
         ? configOrDescription
         : { ...otherConfig, description: configOrDescription };
 
     try {
-      const option = new Option(format, config);
-      this.options.push(option);
+      const option = new Option<OF, T>(format, config);
+      this.options.push(option as unknown as Option);
     } catch (error: any) {
       this.logger.warn(error.message);
     }
-    return this as Command<F, GlobalOption, CommandOption | ExtractOption<OF>>;
+    return this as Command<F, CommandOption & ExtractOption<OF>>;
   }
 
   get hasConditionFn(): boolean {
@@ -105,7 +101,7 @@ export class Command<
     }
   }
 
-  parseArgs(args: ParsedArgs): ParseResult {
+  parseArgs(args: ParsedArgs, globalOptions: Option[]): ParseResult {
     if (this.conditionFn) {
       const argumentss: any[] = args['_'];
       const options: Record<string, string> = args;
@@ -144,18 +140,38 @@ export class Command<
       }
     }
 
-    const options: Record<string, string> = args;
+    const fullOptions = globalOptions.concat(this.options).reduce((map, o) => {
+      map.set(o.name, o);
+      return map;
+    }, new Map<string, Option>());
+    const options: Record<string, any> = args;
     delete options['_'];
 
+    for (const [name, rawOption] of fullOptions) {
+      if (rawOption.required) {
+        if (options[name] === undefined) {
+          options[name] = false;
+        } else if (options[name] === '') {
+          options[name] = true;
+        }
+      } else {
+        if (options[name] === false) {
+          options[name] = undefined;
+        } else if (!(name in options)) {
+          options[name] = undefined;
+        }
+      }
+    }
+
     return {
       // @ts-ignore
       command: this,
       arguments: argumentss,
-      options: args
+      options
     };
   }
 
-  action(fn: ActionFn<ExtractCommand<F>, GlobalOption | CommandOption>) {
+  action(fn: ActionFn<ExtractCommand<F>, CommandOption>) {
     this.actionFn = fn;
     return this;
   }

diff --git a/src/logger.ts b/src/logger.ts
@@ -1,23 +1,31 @@
-import type { Logger } from './types';
+import type { Logger, LoggerFn } from './types';
 
 import createDebug from 'debug';
 import { blue, red, yellow } from 'kolorist';
 
-export function createDefaultLogger(name: string): Logger {
+export function createDefaultLogger(name: string, logger?: Logger | LoggerFn): Logger {
+  if (!!logger && typeof logger === 'object') {
+    return logger;
+  }
+
   const debug = createDebug(name + ':breadc');
+  const println: LoggerFn =
+    !!logger && typeof logger === 'function'
+      ? logger
+      : (message: string, ...args: any[]) => {
+          console.log(message, ...args);
+        };
 
   return {
-    println(message) {
-      console.log(message);
-    },
+    println,
     info(message, ...args) {
-      console.log(`${blue('INFO')} ${message}`, ...args);
+      println(`${blue('INFO')} ${message}`, ...args);
     },
     warn(message, ...args) {
-      console.log(`${yellow('WARN')} ${message}`, ...args);
+      println(`${yellow('WARN')} ${message}`, ...args);
     },
     error(message, ...args) {
-      console.log(`${red('ERROR')} ${message}`, ...args);
+      println(`${red('ERROR')} ${message}`, ...args);
     },
     debug(message, ...args) {
       debug(message, ...args);

diff --git a/src/option.ts b/src/option.ts
@@ -1,5 +1,3 @@
-import type { ExtractOption } from './types';
-
 export interface OptionConfig<T = string> {
   description?: string;
   default?: T;
@@ -15,18 +13,20 @@ export interface OptionConfig<T = string> {
  * + --option <arg>
  * + --option [arg]
  */
-export class Option<T extends string = string, U = ExtractOption<T>> {
+export class Option<T extends string = string, F = string> {
   private static OptionRE = /^(-[a-zA-Z], )?--([a-zA-Z.]+)( \[[a-zA-Z]+\]| <[a-zA-Z]+>)?$/;
 
   readonly name: string;
   readonly shortcut?: string;
+  readonly default?: F;
   readonly format: string;
   readonly description: string;
   readonly type: 'string' | 'boolean';
+  readonly required: boolean;
 
   readonly construct: (rawText: string | undefined) => any;
 
-  constructor(format: T, config: OptionConfig = {}) {
+  constructor(format: T, config: OptionConfig<F> = {}) {
     this.format = format;
 
     const match = Option.OptionRE.exec(format);
@@ -45,6 +45,8 @@ export class Option<T extends string = string, U = ExtractOption<T>> {
     }
 
     this.description = config.description ?? '';
+    this.required = format.indexOf('<') !== -1;
+    this.default = config.default;
     this.construct = config.construct ?? ((text) => text ?? config.default ?? undefined);
   }
 }