breadc 0.2.0 → 0.4.1

package/README.md

@@ -2,7 +2,13 @@
 
 [![version](https://img.shields.io/npm/v/breadc?color=rgb%2850%2C203%2C86%29&label=Breadc)](https://www.npmjs.com/package/breadc) [![CI](https://github.com/yjl9903/Breadc/actions/workflows/ci.yml/badge.svg)](https://github.com/yjl9903/Breadc/actions/workflows/ci.yml)
 
-Yet another Command Line Application Framework powered by [minimist](https://www.npmjs.com/package/minimist), but with fully [TypeScript](https://www.typescriptlang.org/) support.
+Yet another Command Line Application Framework powered by [minimist](https://www.npmjs.com/package/minimist), but with fully strong [TypeScript](https://www.typescriptlang.org/) support.
+
+## Features
+
++ ⚡️ **Light-weight**: Only 61 kB.
++ 📖 **East to Learn**: Breadc is basically compatible with [cac](https://github.com/cacjs/cac) and there are only 4 APIs for building a CLI application: `command`, `option`, `action`, `run`.
++ 💻 **TypeScript Infer**: IDE will automatically infer the type of your command action function.
 
 ## Installation
 
@@ -18,11 +24,11 @@ Try [./examples/echo.ts](./examples/echo.ts).
 import Breadc from 'breadc'
 
 const cli = Breadc('echo', { version: '1.0.0' })
-  .option('--host <host>')
-  .option('--port <port>')
+  .option('--host [host]', { default: 'localhost' })
+  .option('--port [port]', { construct: (port) => (port ? +port : 3000) });
 
 cli
-  .command('[message]')
+  .command('[message]', 'Say something!')
   .action((message, option) => {
     const host = option.host;
     const port = option.port;

package/dist/index.cjs

@@ -3,37 +3,283 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const kolorist = require('kolorist');
-const minimist = require('minimist');
-const createDebug = require('debug');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
 
 const kolorist__default = /*#__PURE__*/_interopDefaultLegacy(kolorist);
-const minimist__default = /*#__PURE__*/_interopDefaultLegacy(minimist);
-const createDebug__default = /*#__PURE__*/_interopDefaultLegacy(createDebug);
+
+var minimist = function (args, opts) {
+    if (!opts) opts = {};
+    
+    var flags = { bools : {}, strings : {}, unknownFn: null };
+
+    if (typeof opts['unknown'] === 'function') {
+        flags.unknownFn = opts['unknown'];
+    }
+
+    if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
+      flags.allBools = true;
+    } else {
+      [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
+          flags.bools[key] = true;
+      });
+    }
+    
+    var aliases = {};
+    Object.keys(opts.alias || {}).forEach(function (key) {
+        aliases[key] = [].concat(opts.alias[key]);
+        aliases[key].forEach(function (x) {
+            aliases[x] = [key].concat(aliases[key].filter(function (y) {
+                return x !== y;
+            }));
+        });
+    });
+
+    [].concat(opts.string).filter(Boolean).forEach(function (key) {
+        flags.strings[key] = true;
+        if (aliases[key]) {
+            flags.strings[aliases[key]] = true;
+        }
+     });
+
+    var defaults = opts['default'] || {};
+    
+    var argv = { _ : [] };
+    Object.keys(flags.bools).forEach(function (key) {
+        setArg(key, defaults[key] === undefined ? false : defaults[key]);
+    });
+    
+    var notFlags = [];
+
+    if (args.indexOf('--') !== -1) {
+        notFlags = args.slice(args.indexOf('--')+1);
+        args = args.slice(0, args.indexOf('--'));
+    }
+
+    function argDefined(key, arg) {
+        return (flags.allBools && /^--[^=]+$/.test(arg)) ||
+            flags.strings[key] || flags.bools[key] || aliases[key];
+    }
+
+    function setArg (key, val, arg) {
+        if (arg && flags.unknownFn && !argDefined(key, arg)) {
+            if (flags.unknownFn(arg) === false) return;
+        }
+
+        var value = !flags.strings[key] && isNumber(val)
+            ? Number(val) : val
+        ;
+        setKey(argv, key.split('.'), value);
+        
+        (aliases[key] || []).forEach(function (x) {
+            setKey(argv, x.split('.'), value);
+        });
+    }
+
+    function setKey (obj, keys, value) {
+        var o = obj;
+        for (var i = 0; i < keys.length-1; i++) {
+            var key = keys[i];
+            if (isConstructorOrProto(o, key)) return;
+            if (o[key] === undefined) o[key] = {};
+            if (o[key] === Object.prototype || o[key] === Number.prototype
+                || o[key] === String.prototype) o[key] = {};
+            if (o[key] === Array.prototype) o[key] = [];
+            o = o[key];
+        }
+
+        var key = keys[keys.length - 1];
+        if (isConstructorOrProto(o, key)) return;
+        if (o === Object.prototype || o === Number.prototype
+            || o === String.prototype) o = {};
+        if (o === Array.prototype) o = [];
+        if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') {
+            o[key] = value;
+        }
+        else if (Array.isArray(o[key])) {
+            o[key].push(value);
+        }
+        else {
+            o[key] = [ o[key], value ];
+        }
+    }
+    
+    function aliasIsBoolean(key) {
+      return aliases[key].some(function (x) {
+          return flags.bools[x];
+      });
+    }
+
+    for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        
+        if (/^--.+=/.test(arg)) {
+            // Using [\s\S] instead of . because js doesn't support the
+            // 'dotall' regex modifier. See:
+            // http://stackoverflow.com/a/1068308/13216
+            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+            var key = m[1];
+            var value = m[2];
+            if (flags.bools[key]) {
+                value = value !== 'false';
+            }
+            setArg(key, value, arg);
+        }
+        else if (/^--no-.+/.test(arg)) {
+            var key = arg.match(/^--no-(.+)/)[1];
+            setArg(key, false, arg);
+        }
+        else if (/^--.+/.test(arg)) {
+            var key = arg.match(/^--(.+)/)[1];
+            var next = args[i + 1];
+            if (next !== undefined && !/^-/.test(next)
+            && !flags.bools[key]
+            && !flags.allBools
+            && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                setArg(key, next, arg);
+                i++;
+            }
+            else if (/^(true|false)$/.test(next)) {
+                setArg(key, next === 'true', arg);
+                i++;
+            }
+            else {
+                setArg(key, flags.strings[key] ? '' : true, arg);
+            }
+        }
+        else if (/^-[^-]+/.test(arg)) {
+            var letters = arg.slice(1,-1).split('');
+            
+            var broken = false;
+            for (var j = 0; j < letters.length; j++) {
+                var next = arg.slice(j+2);
+                
+                if (next === '-') {
+                    setArg(letters[j], next, arg);
+                    continue;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+                    setArg(letters[j], next.split('=')[1], arg);
+                    broken = true;
+                    break;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j])
+                && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+                    setArg(letters[j], next, arg);
+                    broken = true;
+                    break;
+                }
+                
+                if (letters[j+1] && letters[j+1].match(/\W/)) {
+                    setArg(letters[j], arg.slice(j+2), arg);
+                    broken = true;
+                    break;
+                }
+                else {
+                    setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
+                }
+            }
+            
+            var key = arg.slice(-1)[0];
+            if (!broken && key !== '-') {
+                if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
+                && !flags.bools[key]
+                && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                    setArg(key, args[i+1], arg);
+                    i++;
+                }
+                else if (args[i+1] && /^(true|false)$/.test(args[i+1])) {
+                    setArg(key, args[i+1] === 'true', arg);
+                    i++;
+                }
+                else {
+                    setArg(key, flags.strings[key] ? '' : true, arg);
+                }
+            }
+        }
+        else {
+            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+                argv._.push(
+                    flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
+                );
+            }
+            if (opts.stopEarly) {
+                argv._.push.apply(argv._, args.slice(i + 1));
+                break;
+            }
+        }
+    }
+    
+    Object.keys(defaults).forEach(function (key) {
+        if (!hasKey(argv, key.split('.'))) {
+            setKey(argv, key.split('.'), defaults[key]);
+            
+            (aliases[key] || []).forEach(function (x) {
+                setKey(argv, x.split('.'), defaults[key]);
+            });
+        }
+    });
+    
+    if (opts['--']) {
+        argv['--'] = new Array();
+        notFlags.forEach(function(key) {
+            argv['--'].push(key);
+        });
+    }
+    else {
+        notFlags.forEach(function(key) {
+            argv._.push(key);
+        });
+    }
+
+    return argv;
+};
+
+function hasKey (obj, keys) {
+    var o = obj;
+    keys.slice(0,-1).forEach(function (key) {
+        o = (o[key] || {});
+    });
+
+    var key = keys[keys.length - 1];
+    return key in o;
+}
+
+function isNumber (x) {
+    if (typeof x === 'number') return true;
+    if (/^0x[0-9a-f]+$/i.test(x)) return true;
+    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+}
+
+
+function isConstructorOrProto (obj, key) {
+    return key === 'constructor' && typeof obj[key] === 'function' || key === '__proto__';
+}
 
 function createDefaultLogger(name, logger) {
-  if (!!logger && typeof logger === "object") {
-    return logger;
-  }
-  const debug = createDebug__default(name + ":breadc");
-  const println = !!logger && typeof logger === "function" ? logger : (message, ...args) => {
+  const println = !!logger && typeof logger === "function" ? logger : logger?.println ?? ((message, ...args) => {
     console.log(message, ...args);
+  });
+  const info = typeof logger === "object" && logger?.info ? logger.info : (message, ...args) => {
+    println(`${kolorist.blue("INFO")} ${message}`, ...args);
+  };
+  const warn = typeof logger === "object" && logger?.warn ? logger.warn : (message, ...args) => {
+    println(`${kolorist.yellow("WARN")} ${message}`, ...args);
+  };
+  const error = typeof logger === "object" && logger?.error ? logger.error : (message, ...args) => {
+    println(`${kolorist.red("ERROR")} ${message}`, ...args);
+  };
+  const debug = typeof logger === "object" && logger?.debug ? logger.debug : (message, ...args) => {
+    println(`${kolorist.gray(name)} ${message}`, ...args);
   };
   return {
     println,
-    info(message, ...args) {
-      println(`${kolorist.blue("INFO")} ${message}`, ...args);
-    },
-    warn(message, ...args) {
-      println(`${kolorist.yellow("WARN")} ${message}`, ...args);
-    },
-    error(message, ...args) {
-      println(`${kolorist.red("ERROR")} ${message}`, ...args);
-    },
-    debug(message, ...args) {
-      debug(message, ...args);
-    }
+    info,
+    warn,
+    error,
+    debug
   };
 }
 
@@ -57,11 +303,11 @@ const _Option = class {
     this.description = config.description ?? "";
     this.required = format.indexOf("<") !== -1;
     this.default = config.default;
-    this.construct = config.construct ?? ((text) => text ?? config.default ?? void 0);
+    this.construct = config.construct;
   }
 };
 let Option = _Option;
-Option.OptionRE = /^(-[a-zA-Z], )?--([a-zA-Z.]+)( \[[a-zA-Z]+\]| <[a-zA-Z]+>)?$/;
+Option.OptionRE = /^(-[a-zA-Z], )?--([a-zA-Z]+)( \[[a-zA-Z]+\]| <[a-zA-Z]+>)?$/;
 
 const _Command = class {
   constructor(format, config) {
@@ -161,6 +407,13 @@ const _Command = class {
           options[name] = void 0;
         }
       }
+      if (rawOption.construct) {
+        options[name] = rawOption.construct(options[name]);
+      } else if (rawOption.default) {
+        if (!options[name]) {
+          options[name] = rawOption.default;
+        }
+      }
     }
     return {
       command: this,
@@ -334,17 +587,10 @@ class Breadc {
       }
       return map;
     }, {});
-    const defaults = allowOptions.reduce((map, o) => {
-      if (o.default) {
-        map[o.name] = o.default;
-      }
-      return map;
-    }, {});
-    const argv = minimist__default(args, {
+    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,
-      default: defaults,
       unknown: (t) => {
         if (t[0] !== "-")
           return true;
@@ -399,6 +645,5 @@ function breadc(name, option = {}) {
 }
 
 exports.kolorist = kolorist__default;
-exports.minimist = minimist__default;
-exports.createDebug = createDebug__default;
 exports["default"] = breadc;
+exports.minimist = minimist;

package/dist/index.d.ts

@@ -1,12 +1,259 @@
-import { ParsedArgs } from 'minimist';
-export { default as minimist } from 'minimist';
 export { default as kolorist } from 'kolorist';
-export { default as createDebug } from 'debug';
 
-interface OptionConfig<T = string> {
+var minimist = function (args, opts) {
+    if (!opts) opts = {};
+    
+    var flags = { bools : {}, strings : {}, unknownFn: null };
+
+    if (typeof opts['unknown'] === 'function') {
+        flags.unknownFn = opts['unknown'];
+    }
+
+    if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
+      flags.allBools = true;
+    } else {
+      [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
+          flags.bools[key] = true;
+      });
+    }
+    
+    var aliases = {};
+    Object.keys(opts.alias || {}).forEach(function (key) {
+        aliases[key] = [].concat(opts.alias[key]);
+        aliases[key].forEach(function (x) {
+            aliases[x] = [key].concat(aliases[key].filter(function (y) {
+                return x !== y;
+            }));
+        });
+    });
+
+    [].concat(opts.string).filter(Boolean).forEach(function (key) {
+        flags.strings[key] = true;
+        if (aliases[key]) {
+            flags.strings[aliases[key]] = true;
+        }
+     });
+
+    var defaults = opts['default'] || {};
+    
+    var argv = { _ : [] };
+    Object.keys(flags.bools).forEach(function (key) {
+        setArg(key, defaults[key] === undefined ? false : defaults[key]);
+    });
+    
+    var notFlags = [];
+
+    if (args.indexOf('--') !== -1) {
+        notFlags = args.slice(args.indexOf('--')+1);
+        args = args.slice(0, args.indexOf('--'));
+    }
+
+    function argDefined(key, arg) {
+        return (flags.allBools && /^--[^=]+$/.test(arg)) ||
+            flags.strings[key] || flags.bools[key] || aliases[key];
+    }
+
+    function setArg (key, val, arg) {
+        if (arg && flags.unknownFn && !argDefined(key, arg)) {
+            if (flags.unknownFn(arg) === false) return;
+        }
+
+        var value = !flags.strings[key] && isNumber(val)
+            ? Number(val) : val
+        ;
+        setKey(argv, key.split('.'), value);
+        
+        (aliases[key] || []).forEach(function (x) {
+            setKey(argv, x.split('.'), value);
+        });
+    }
+
+    function setKey (obj, keys, value) {
+        var o = obj;
+        for (var i = 0; i < keys.length-1; i++) {
+            var key = keys[i];
+            if (isConstructorOrProto(o, key)) return;
+            if (o[key] === undefined) o[key] = {};
+            if (o[key] === Object.prototype || o[key] === Number.prototype
+                || o[key] === String.prototype) o[key] = {};
+            if (o[key] === Array.prototype) o[key] = [];
+            o = o[key];
+        }
+
+        var key = keys[keys.length - 1];
+        if (isConstructorOrProto(o, key)) return;
+        if (o === Object.prototype || o === Number.prototype
+            || o === String.prototype) o = {};
+        if (o === Array.prototype) o = [];
+        if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') {
+            o[key] = value;
+        }
+        else if (Array.isArray(o[key])) {
+            o[key].push(value);
+        }
+        else {
+            o[key] = [ o[key], value ];
+        }
+    }
+    
+    function aliasIsBoolean(key) {
+      return aliases[key].some(function (x) {
+          return flags.bools[x];
+      });
+    }
+
+    for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        
+        if (/^--.+=/.test(arg)) {
+            // Using [\s\S] instead of . because js doesn't support the
+            // 'dotall' regex modifier. See:
+            // http://stackoverflow.com/a/1068308/13216
+            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+            var key = m[1];
+            var value = m[2];
+            if (flags.bools[key]) {
+                value = value !== 'false';
+            }
+            setArg(key, value, arg);
+        }
+        else if (/^--no-.+/.test(arg)) {
+            var key = arg.match(/^--no-(.+)/)[1];
+            setArg(key, false, arg);
+        }
+        else if (/^--.+/.test(arg)) {
+            var key = arg.match(/^--(.+)/)[1];
+            var next = args[i + 1];
+            if (next !== undefined && !/^-/.test(next)
+            && !flags.bools[key]
+            && !flags.allBools
+            && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                setArg(key, next, arg);
+                i++;
+            }
+            else if (/^(true|false)$/.test(next)) {
+                setArg(key, next === 'true', arg);
+                i++;
+            }
+            else {
+                setArg(key, flags.strings[key] ? '' : true, arg);
+            }
+        }
+        else if (/^-[^-]+/.test(arg)) {
+            var letters = arg.slice(1,-1).split('');
+            
+            var broken = false;
+            for (var j = 0; j < letters.length; j++) {
+                var next = arg.slice(j+2);
+                
+                if (next === '-') {
+                    setArg(letters[j], next, arg);
+                    continue;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+                    setArg(letters[j], next.split('=')[1], arg);
+                    broken = true;
+                    break;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j])
+                && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+                    setArg(letters[j], next, arg);
+                    broken = true;
+                    break;
+                }
+                
+                if (letters[j+1] && letters[j+1].match(/\W/)) {
+                    setArg(letters[j], arg.slice(j+2), arg);
+                    broken = true;
+                    break;
+                }
+                else {
+                    setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
+                }
+            }
+            
+            var key = arg.slice(-1)[0];
+            if (!broken && key !== '-') {
+                if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
+                && !flags.bools[key]
+                && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                    setArg(key, args[i+1], arg);
+                    i++;
+                }
+                else if (args[i+1] && /^(true|false)$/.test(args[i+1])) {
+                    setArg(key, args[i+1] === 'true', arg);
+                    i++;
+                }
+                else {
+                    setArg(key, flags.strings[key] ? '' : true, arg);
+                }
+            }
+        }
+        else {
+            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+                argv._.push(
+                    flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
+                );
+            }
+            if (opts.stopEarly) {
+                argv._.push.apply(argv._, args.slice(i + 1));
+                break;
+            }
+        }
+    }
+    
+    Object.keys(defaults).forEach(function (key) {
+        if (!hasKey(argv, key.split('.'))) {
+            setKey(argv, key.split('.'), defaults[key]);
+            
+            (aliases[key] || []).forEach(function (x) {
+                setKey(argv, x.split('.'), defaults[key]);
+            });
+        }
+    });
+    
+    if (opts['--']) {
+        argv['--'] = new Array();
+        notFlags.forEach(function(key) {
+            argv['--'].push(key);
+        });
+    }
+    else {
+        notFlags.forEach(function(key) {
+            argv._.push(key);
+        });
+    }
+
+    return argv;
+};
+
+function hasKey (obj, keys) {
+    var o = obj;
+    keys.slice(0,-1).forEach(function (key) {
+        o = (o[key] || {});
+    });
+
+    var key = keys[keys.length - 1];
+    return key in o;
+}
+
+function isNumber (x) {
+    if (typeof x === 'number') return true;
+    if (/^0x[0-9a-f]+$/i.test(x)) return true;
+    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+}
+
+
+function isConstructorOrProto (obj, key) {
+    return key === 'constructor' && typeof obj[key] === 'function' || key === '__proto__';
+}
+
+interface OptionConfig<F extends string, T = never> {
     description?: string;
     default?: T;
-    construct?: (rawText?: string) => T;
+    construct?: (rawText: ExtractOptionType<F>) => T;
 }
 /**
  * Option
@@ -26,11 +273,11 @@ declare class Option<T extends string = string, F = string> {
     readonly description: string;
     readonly type: 'string' | 'boolean';
     readonly required: boolean;
-    readonly construct: (rawText: string | undefined) => any;
-    constructor(format: T, config?: OptionConfig<F>);
+    readonly construct?: (rawText: ExtractOptionType<T>) => F;
+    constructor(format: T, config?: OptionConfig<T, F>);
 }
 
-declare type ConditionFn = (args: ParsedArgs) => boolean;
+declare type ConditionFn = (args: minimist.ParsedArgs) => boolean;
 interface CommandConfig {
     description?: string;
 }
@@ -47,11 +294,11 @@ declare class Command<F extends string = string, CommandOption extends object =
         condition?: ConditionFn;
         logger: Logger;
     });
-    option<OF extends string, T = string>(format: OF, description: string, config?: Omit<OptionConfig<T>, 'description'>): Command<F, CommandOption & ExtractOption<OF>>;
-    option<OF extends string, T = string>(format: OF, config?: OptionConfig<T>): Command<F, CommandOption & ExtractOption<OF>>;
+    option<OF extends string, T = undefined>(format: OF, description: string, config?: Omit<OptionConfig<OF, T>, 'description'>): Command<F, CommandOption & ExtractOption<OF, T>>;
+    option<OF extends string, T = undefined>(format: OF, config?: OptionConfig<OF, T>): Command<F, CommandOption & ExtractOption<OF, T>>;
     get hasConditionFn(): boolean;
-    shouldRun(args: ParsedArgs): boolean;
-    parseArgs(args: ParsedArgs, globalOptions: Option[]): ParseResult;
+    shouldRun(args: minimist.ParsedArgs): boolean;
+    parseArgs(args: minimist.ParsedArgs, globalOptions: Option[]): ParseResult;
     action(fn: ActionFn<ExtractCommand<F>, CommandOption>): this;
     run(...args: any[]): Promise<void>;
 }
@@ -60,7 +307,7 @@ interface AppOption {
     version?: string;
     description?: string | string[];
     help?: string | string[] | (() => string | string[]);
-    logger?: Logger | LoggerFn;
+    logger?: Partial<Logger> | LoggerFn;
 }
 declare type LoggerFn = (message: string, ...args: any[]) => void;
 interface Logger {
@@ -75,8 +322,8 @@ interface ParseResult {
     arguments: any[];
     options: Record<string, string>;
 }
-declare type ExtractOption<T extends string> = {
-    [k in ExtractOptionName<T>]: ExtractOptionType<T>;
+declare type ExtractOption<T extends string, D = undefined> = {
+    [k in ExtractOptionName<T>]: D extends undefined ? ExtractOptionType<T> : D;
 };
 /**
  * Extract option name type
@@ -110,8 +357,8 @@ declare class Breadc<GlobalOption extends object = {}> {
     constructor(name: string, option: AppOption);
     version(): string;
     help(command?: Command): string[];
-    option<F extends string, T = string>(format: F, description: string, config?: Omit<OptionConfig<T>, 'description'>): Breadc<GlobalOption & ExtractOption<F>>;
-    option<F extends string, T = string>(format: F, config?: OptionConfig<T>): Breadc<GlobalOption & ExtractOption<F>>;
+    option<F extends string, T = undefined>(format: F, description: string, config?: Omit<OptionConfig<F, T>, 'description'>): Breadc<GlobalOption & ExtractOption<F, T>>;
+    option<F extends string, T = undefined>(format: F, config?: OptionConfig<F, T>): Breadc<GlobalOption & ExtractOption<F, T>>;
     command<F extends string>(format: F, description: string, config?: Omit<CommandConfig, 'description'>): Command<F, GlobalOption>;
     command<F extends string>(format: F, config?: CommandConfig): Command<F, GlobalOption>;
     parse(args: string[]): ParseResult;
@@ -120,4 +367,4 @@ declare class Breadc<GlobalOption extends object = {}> {
 
 declare function breadc(name: string, option?: AppOption): Breadc<{}>;
 
-export { breadc as default };
+export { breadc as default, minimist };

package/dist/index.mjs

@@ -1,32 +1,278 @@
-import { blue, yellow, red } from 'kolorist';
+import { blue, yellow, red, gray } from 'kolorist';
 export { default as kolorist } from 'kolorist';
-import minimist from 'minimist';
-export { default as minimist } from 'minimist';
-import createDebug from 'debug';
-export { default as createDebug } from 'debug';
+
+var minimist = function (args, opts) {
+    if (!opts) opts = {};
+    
+    var flags = { bools : {}, strings : {}, unknownFn: null };
+
+    if (typeof opts['unknown'] === 'function') {
+        flags.unknownFn = opts['unknown'];
+    }
+
+    if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
+      flags.allBools = true;
+    } else {
+      [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
+          flags.bools[key] = true;
+      });
+    }
+    
+    var aliases = {};
+    Object.keys(opts.alias || {}).forEach(function (key) {
+        aliases[key] = [].concat(opts.alias[key]);
+        aliases[key].forEach(function (x) {
+            aliases[x] = [key].concat(aliases[key].filter(function (y) {
+                return x !== y;
+            }));
+        });
+    });
+
+    [].concat(opts.string).filter(Boolean).forEach(function (key) {
+        flags.strings[key] = true;
+        if (aliases[key]) {
+            flags.strings[aliases[key]] = true;
+        }
+     });
+
+    var defaults = opts['default'] || {};
+    
+    var argv = { _ : [] };
+    Object.keys(flags.bools).forEach(function (key) {
+        setArg(key, defaults[key] === undefined ? false : defaults[key]);
+    });
+    
+    var notFlags = [];
+
+    if (args.indexOf('--') !== -1) {
+        notFlags = args.slice(args.indexOf('--')+1);
+        args = args.slice(0, args.indexOf('--'));
+    }
+
+    function argDefined(key, arg) {
+        return (flags.allBools && /^--[^=]+$/.test(arg)) ||
+            flags.strings[key] || flags.bools[key] || aliases[key];
+    }
+
+    function setArg (key, val, arg) {
+        if (arg && flags.unknownFn && !argDefined(key, arg)) {
+            if (flags.unknownFn(arg) === false) return;
+        }
+
+        var value = !flags.strings[key] && isNumber(val)
+            ? Number(val) : val
+        ;
+        setKey(argv, key.split('.'), value);
+        
+        (aliases[key] || []).forEach(function (x) {
+            setKey(argv, x.split('.'), value);
+        });
+    }
+
+    function setKey (obj, keys, value) {
+        var o = obj;
+        for (var i = 0; i < keys.length-1; i++) {
+            var key = keys[i];
+            if (isConstructorOrProto(o, key)) return;
+            if (o[key] === undefined) o[key] = {};
+            if (o[key] === Object.prototype || o[key] === Number.prototype
+                || o[key] === String.prototype) o[key] = {};
+            if (o[key] === Array.prototype) o[key] = [];
+            o = o[key];
+        }
+
+        var key = keys[keys.length - 1];
+        if (isConstructorOrProto(o, key)) return;
+        if (o === Object.prototype || o === Number.prototype
+            || o === String.prototype) o = {};
+        if (o === Array.prototype) o = [];
+        if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') {
+            o[key] = value;
+        }
+        else if (Array.isArray(o[key])) {
+            o[key].push(value);
+        }
+        else {
+            o[key] = [ o[key], value ];
+        }
+    }
+    
+    function aliasIsBoolean(key) {
+      return aliases[key].some(function (x) {
+          return flags.bools[x];
+      });
+    }
+
+    for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        
+        if (/^--.+=/.test(arg)) {
+            // Using [\s\S] instead of . because js doesn't support the
+            // 'dotall' regex modifier. See:
+            // http://stackoverflow.com/a/1068308/13216
+            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+            var key = m[1];
+            var value = m[2];
+            if (flags.bools[key]) {
+                value = value !== 'false';
+            }
+            setArg(key, value, arg);
+        }
+        else if (/^--no-.+/.test(arg)) {
+            var key = arg.match(/^--no-(.+)/)[1];
+            setArg(key, false, arg);
+        }
+        else if (/^--.+/.test(arg)) {
+            var key = arg.match(/^--(.+)/)[1];
+            var next = args[i + 1];
+            if (next !== undefined && !/^-/.test(next)
+            && !flags.bools[key]
+            && !flags.allBools
+            && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                setArg(key, next, arg);
+                i++;
+            }
+            else if (/^(true|false)$/.test(next)) {
+                setArg(key, next === 'true', arg);
+                i++;
+            }
+            else {
+                setArg(key, flags.strings[key] ? '' : true, arg);
+            }
+        }
+        else if (/^-[^-]+/.test(arg)) {
+            var letters = arg.slice(1,-1).split('');
+            
+            var broken = false;
+            for (var j = 0; j < letters.length; j++) {
+                var next = arg.slice(j+2);
+                
+                if (next === '-') {
+                    setArg(letters[j], next, arg);
+                    continue;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+                    setArg(letters[j], next.split('=')[1], arg);
+                    broken = true;
+                    break;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j])
+                && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+                    setArg(letters[j], next, arg);
+                    broken = true;
+                    break;
+                }
+                
+                if (letters[j+1] && letters[j+1].match(/\W/)) {
+                    setArg(letters[j], arg.slice(j+2), arg);
+                    broken = true;
+                    break;
+                }
+                else {
+                    setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
+                }
+            }
+            
+            var key = arg.slice(-1)[0];
+            if (!broken && key !== '-') {
+                if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
+                && !flags.bools[key]
+                && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                    setArg(key, args[i+1], arg);
+                    i++;
+                }
+                else if (args[i+1] && /^(true|false)$/.test(args[i+1])) {
+                    setArg(key, args[i+1] === 'true', arg);
+                    i++;
+                }
+                else {
+                    setArg(key, flags.strings[key] ? '' : true, arg);
+                }
+            }
+        }
+        else {
+            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+                argv._.push(
+                    flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
+                );
+            }
+            if (opts.stopEarly) {
+                argv._.push.apply(argv._, args.slice(i + 1));
+                break;
+            }
+        }
+    }
+    
+    Object.keys(defaults).forEach(function (key) {
+        if (!hasKey(argv, key.split('.'))) {
+            setKey(argv, key.split('.'), defaults[key]);
+            
+            (aliases[key] || []).forEach(function (x) {
+                setKey(argv, x.split('.'), defaults[key]);
+            });
+        }
+    });
+    
+    if (opts['--']) {
+        argv['--'] = new Array();
+        notFlags.forEach(function(key) {
+            argv['--'].push(key);
+        });
+    }
+    else {
+        notFlags.forEach(function(key) {
+            argv._.push(key);
+        });
+    }
+
+    return argv;
+};
+
+function hasKey (obj, keys) {
+    var o = obj;
+    keys.slice(0,-1).forEach(function (key) {
+        o = (o[key] || {});
+    });
+
+    var key = keys[keys.length - 1];
+    return key in o;
+}
+
+function isNumber (x) {
+    if (typeof x === 'number') return true;
+    if (/^0x[0-9a-f]+$/i.test(x)) return true;
+    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+}
+
+
+function isConstructorOrProto (obj, key) {
+    return key === 'constructor' && typeof obj[key] === 'function' || key === '__proto__';
+}
 
 function createDefaultLogger(name, logger) {
-  if (!!logger && typeof logger === "object") {
-    return logger;
-  }
-  const debug = createDebug(name + ":breadc");
-  const println = !!logger && typeof logger === "function" ? logger : (message, ...args) => {
+  const println = !!logger && typeof logger === "function" ? logger : logger?.println ?? ((message, ...args) => {
     console.log(message, ...args);
+  });
+  const info = typeof logger === "object" && logger?.info ? logger.info : (message, ...args) => {
+    println(`${blue("INFO")} ${message}`, ...args);
+  };
+  const warn = typeof logger === "object" && logger?.warn ? logger.warn : (message, ...args) => {
+    println(`${yellow("WARN")} ${message}`, ...args);
+  };
+  const error = typeof logger === "object" && logger?.error ? logger.error : (message, ...args) => {
+    println(`${red("ERROR")} ${message}`, ...args);
+  };
+  const debug = typeof logger === "object" && logger?.debug ? logger.debug : (message, ...args) => {
+    println(`${gray(name)} ${message}`, ...args);
   };
   return {
     println,
-    info(message, ...args) {
-      println(`${blue("INFO")} ${message}`, ...args);
-    },
-    warn(message, ...args) {
-      println(`${yellow("WARN")} ${message}`, ...args);
-    },
-    error(message, ...args) {
-      println(`${red("ERROR")} ${message}`, ...args);
-    },
-    debug(message, ...args) {
-      debug(message, ...args);
-    }
+    info,
+    warn,
+    error,
+    debug
   };
 }
 
@@ -50,11 +296,11 @@ const _Option = class {
     this.description = config.description ?? "";
     this.required = format.indexOf("<") !== -1;
     this.default = config.default;
-    this.construct = config.construct ?? ((text) => text ?? config.default ?? void 0);
+    this.construct = config.construct;
   }
 };
 let Option = _Option;
-Option.OptionRE = /^(-[a-zA-Z], )?--([a-zA-Z.]+)( \[[a-zA-Z]+\]| <[a-zA-Z]+>)?$/;
+Option.OptionRE = /^(-[a-zA-Z], )?--([a-zA-Z]+)( \[[a-zA-Z]+\]| <[a-zA-Z]+>)?$/;
 
 const _Command = class {
   constructor(format, config) {
@@ -154,6 +400,13 @@ const _Command = class {
           options[name] = void 0;
         }
       }
+      if (rawOption.construct) {
+        options[name] = rawOption.construct(options[name]);
+      } else if (rawOption.default) {
+        if (!options[name]) {
+          options[name] = rawOption.default;
+        }
+      }
     }
     return {
       command: this,
@@ -327,17 +580,10 @@ class Breadc {
       }
       return map;
     }, {});
-    const defaults = allowOptions.reduce((map, 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,
-      default: defaults,
       unknown: (t) => {
         if (t[0] !== "-")
           return true;
@@ -391,4 +637,4 @@ function breadc(name, option = {}) {
   return new Breadc(name, option);
 }
 
-export { breadc as default };
+export { breadc as default, minimist };

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "breadc",
-  "version": "0.2.0",
-  "description": "Yet another Command Line Application Framework",
+  "version": "0.4.1",
+  "description": "Yet another Command Line Application Framework with fully strong TypeScript support",
   "keywords": [
     "cli",
     "framework",
     "command-line",
-    "minimist"
+    "minimist",
+    "typescript"
   ],
   "homepage": "https://github.com/yjl9903/Breadc#readme",
   "bugs": {
@@ -33,15 +34,13 @@
     "dist"
   ],
   "dependencies": {
-    "debug": "^4.3.4",
-    "kolorist": "^1.5.1",
-    "minimist": "^1.2.6"
+    "kolorist": "^1.5.1"
   },
   "devDependencies": {
-    "@types/debug": "^4.1.7",
     "@types/minimist": "^1.2.2",
     "@types/node": "^17.0.43",
     "bumpp": "^8.2.1",
+    "minimist": "^1.2.6",
     "prettier": "^2.7.1",
     "typescript": "^4.7.4",
     "unbuild": "^0.7.4",