New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
cli-kit - npm Package Compare versions
Comparing version 0.3.0 to 0.4.0-beta
291
dist/cli.js
@@ -8,21 +8,45 @@ "use strict"; | ||
| var _command = _interopRequireDefault(require("./command")); | ||
| var _command = _interopRequireDefault(require("./parser/command")); | ||
| var _context = _interopRequireDefault(require("./context")); | ||
| var _context = _interopRequireDefault(require("./parser/context")); | ||
| var _debug2 = _interopRequireDefault(require("./debug")); | ||
| var _debug2 = _interopRequireDefault(require("./lib/debug")); | ||
| var _errors = _interopRequireDefault(require("./errors")); | ||
| var _errors = _interopRequireDefault(require("./lib/errors")); | ||
| var _util = require("./util"); | ||
| var _extension = _interopRequireDefault(require("./parser/extension")); | ||
| var _help = _interopRequireDefault(require("./commands/help")); | ||
| var _parser = _interopRequireDefault(require("./parser/parser")); | ||
| var _outputStream = _interopRequireDefault(require("./render/output-stream")); | ||
| var _console = require("console"); | ||
| var _util = require("./lib/util"); | ||
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
| function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); } | ||
| function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } | ||
| function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } | ||
| function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } | ||
| const _debug = (0, _debug2.default)('cli-kit:cli'), | ||
| log = _debug.log; | ||
| error = _debug.error, | ||
| log = _debug.log, | ||
| warn = _debug.warn; | ||
| const highlight = _debug2.default.styles.highlight; | ||
| const pluralize = _debug2.default.pluralize; | ||
| /** | ||
| * Defines a CLI context and is responsible for parsing the command line arguments. | ||
| * | ||
| * @extends {Context} | ||
| */ | ||
| class CLI extends _context.default { | ||
@@ -37,12 +61,19 @@ /** | ||
| * @param {Boolean} [params.defaultCommand] - The default command to execute. | ||
| * @param {Boolean} [params.errorIfUnknownCommand=true] - When `true`, `help` is enabled, and | ||
| * the parser didn't find a command, but it did find an unknown argument, it will show the help | ||
| * screen with an unknown command error. | ||
| * @param {Boolean} [params.help=false] - When `true`, enables the built-in help command. | ||
| * @param {Number} [params.helpExitCode] - The exit code to return when the help command is | ||
| * finished. | ||
| * @param {Boolean} [params.hideNoBannerOption=false] - When `true` and a `banner` is specified, | ||
| * it does not add the `--no-banner` option. | ||
| * @param {Boolean} [params.hideNoColorOption=false] - When `true` and `colors` is enabled, it | ||
| * does not add the `--no-color` option. | ||
| * @param {String} [params.name] - The name of the program. | ||
| * @param {Boolean} [params.hideNoBannerOption=false] - When `true` and a `banner` is specified, it | ||
| * does not add the `--no-banner` option. | ||
| * @param {Boolean} [params.hideNoColorOption=false] - When `true` and `colors` is enabled, it does | ||
| * not add the `--no-color` option. | ||
| * @param {Object|Writable} [params.out=process.stdout] - A stream to write output such as the | ||
| * help screen or an object with a `write()` method. | ||
| * @param {Object} [params.renderOpts] - Various render options to control the output stream | ||
| * such as the display width. | ||
| * @param {Object|stream.Writable} [params.stdout=process.stdout] - A stream or an object with a | ||
| * `write()` method to write output such as the help screen to. | ||
| * @param {Object|stream.Writable} [params.stderr=process.stderr] - A stream or an object with a | ||
| * `write()` method to write error messages to. | ||
| * @param {Boolean} [params.showHelpOnError=true] - If an error occurs and `help` is enabled, | ||
@@ -52,4 +83,2 @@ * then display the error before the help information. | ||
| * @param {String} [params.version] - The program version. | ||
| * @param {Number} [params.width] - The number of characters to wrap long descriptions. Defaults | ||
| * to `process.stdout.columns` if exists, otherwise `100`. Must be at least `40`. | ||
| * @access public | ||
@@ -60,3 +89,3 @@ */ | ||
| if (typeof params !== 'object' || Array.isArray(params)) { | ||
| if (!params || typeof params !== 'object' || Array.isArray(params)) { | ||
| throw _errors.default.INVALID_ARGUMENT('Expected CLI parameters to be an object or Context', { | ||
@@ -69,13 +98,21 @@ name: 'params', | ||
| if (params.out && (typeof params.out !== 'object' || typeof params.out.write !== 'function')) { | ||
| throw _errors.default.INVALID_ARGUMENT('Expected output stream to be a writable stream', { | ||
| name: 'params.out', | ||
| if (params.banner !== undefined && typeof params.banner !== 'string' && typeof params.banner !== 'function') { | ||
| throw _errors.default.INVALID_ARGUMENT('Expected banner to be a string or function', { | ||
| name: 'banner', | ||
| scope: 'CLI.constructor', | ||
| value: params.out | ||
| value: params.banner | ||
| }); | ||
| } | ||
| if (params.extensions && typeof params.extensions !== 'object') { | ||
| throw _errors.default.INVALID_ARGUMENT('Expected extensions to be an array of extension paths or an object of names to extension paths', { | ||
| name: 'extensions', | ||
| scope: 'CLI.constructor', | ||
| value: params.extensions | ||
| }); | ||
| } | ||
| if (params.helpExitCode !== undefined && typeof params.helpExitCode !== 'number') { | ||
| throw _errors.default.INVALID_ARGUMENT('Expected help exit code to be a number', { | ||
| name: 'params.helpExitCode', | ||
| name: 'helpExitCode', | ||
| scope: 'CLI.constructor', | ||
@@ -86,30 +123,47 @@ value: params.helpExitCode | ||
| if (params.width !== undefined && typeof params.width !== 'number') { | ||
| throw _errors.default.INVALID_ARGUMENT('Expected width to be a number', { | ||
| name: 'params.width', | ||
| if (params.stdout && (typeof params.stdout !== 'object' || typeof params.stdout.write !== 'function')) { | ||
| throw _errors.default.INVALID_ARGUMENT('Expected stdout stream to be a writable stream', { | ||
| name: 'stdout', | ||
| scope: 'CLI.constructor', | ||
| value: params.width | ||
| value: params.stdout | ||
| }); | ||
| } | ||
| if (params.banner !== undefined && typeof params.banner !== 'string' && typeof params.banner !== 'function') { | ||
| throw _errors.default.INVALID_ARGUMENT('Expected banner to be a string or function', { | ||
| name: 'params.banner', | ||
| if (params.stderr && (typeof params.stderr !== 'object' || typeof params.stderr.write !== 'function')) { | ||
| throw _errors.default.INVALID_ARGUMENT('Expected stderr stream to be a writable stream', { | ||
| name: 'stderr', | ||
| scope: 'CLI.constructor', | ||
| value: params.banner | ||
| value: params.stderr | ||
| }); | ||
| } | ||
| params.colors = params.colors !== false; | ||
| params.name || (params.name = 'program'); | ||
| params.title || (params.title = 'Global'); // extract params that we don't want mixed in | ||
| super({ | ||
| args: params.args, | ||
| camelCase: params.camelCase, | ||
| commands: params.commands, | ||
| desc: params.desc, | ||
| name: params.name || 'program', | ||
| options: params.options, | ||
| title: params.title || 'Global', | ||
| treatUnknownOptionsAsArguments: params.treatUnknownOptionsAsArguments | ||
| }); | ||
| (0, _util.declareCLIKitClass)(this, 'CLI'); | ||
| this.banner = params.banner; | ||
| this.colors = params.colors !== false; | ||
| this.errorIfUnknownCommand = params.errorIfUnknownCommand !== false; | ||
| this.helpExitCode = params.helpExitCode; | ||
| this.warnings = []; | ||
| const renderOpts = Object.assign({ | ||
| markdown: true | ||
| }, params.renderOpts); // init the output streams | ||
| const extensions = params.extensions, | ||
| hideNoBannerOption = params.hideNoBannerOption, | ||
| hideNoColorOption = params.hideNoColorOption; | ||
| delete params.extensions; | ||
| delete params.hideNoBannerOption; | ||
| delete params.hideNoColorOption; | ||
| super(params); | ||
| (0, _util.declareCLIKitClass)(this, 'CLI'); // set the default command | ||
| this.stdout = new _outputStream.default(renderOpts); | ||
| this.stdout.pipe(params.stdout || process.stdout); | ||
| this.stderr = new _outputStream.default(renderOpts); | ||
| this.stderr.pipe(params.stderr || process.stderr); | ||
| process.on('exit', () => { | ||
| this.stdout.end(); | ||
| this.stderr.end(); | ||
| }); | ||
| this.console = new _console.Console(this.stdout, this.stderr); // set the default command | ||
@@ -123,21 +177,6 @@ this.defaultCommand = params.defaultCommand; // add the built-in help | ||
| this.defaultCommand = 'help'; | ||
| } | ||
| } // note: we must clone the help command params since the object gets modified | ||
| this.command('help', { | ||
| hidden: true, | ||
| async action(_ref) { | ||
| let contexts = _ref.contexts, | ||
| err = _ref.err; | ||
| // the first context is the help command, so just skip to the second context | ||
| await contexts[1].renderHelp({ | ||
| err | ||
| }); // istanbul ignore if | ||
| if (params.helpExitCode !== undefined) { | ||
| process.exit(params.helpExitCode); | ||
| } | ||
| } | ||
| }); | ||
| this.command('help', Object.assign({}, _help.default)); | ||
| this.option('-h, --help', 'displays the help screen'); | ||
@@ -147,8 +186,4 @@ } // add the --no-banner flag | ||
| if (this.banner && !hideNoBannerOption) { | ||
| this.showBanner = true; | ||
| if (this.banner && !params.hideNoBannerOption) { | ||
| this.option('--no-banner', { | ||
| callback: value => { | ||
| this.showBanner = value; | ||
| }, | ||
| desc: 'suppress the banner' | ||
@@ -159,3 +194,3 @@ }); | ||
| if (this.colors && !hideNoColorOption) { | ||
| if (this.colors && !params.hideNoColorOption) { | ||
| this.option('--no-color', { | ||
@@ -170,6 +205,6 @@ aliases: ['--no-colors'], | ||
| this.option('-v, --version', { | ||
| callback: () => { | ||
| this.showBanner = false; | ||
| const out = this.get('out', process.stdout); | ||
| out.write(`${params.version}\n`); | ||
| callback: async (_ref) => { | ||
| let next = _ref.next; | ||
| await next(); | ||
| this.get('stdout').write(`${params.version}\n`); | ||
| process.exit(0); | ||
@@ -182,10 +217,27 @@ }, | ||
| if (Array.isArray(extensions)) { | ||
| for (const extensionPath of extensions) { | ||
| this.extension(extensionPath); | ||
| if (params.extensions) { | ||
| if (Array.isArray(params.extensions)) { | ||
| for (const ext of params.extensions) { | ||
| try { | ||
| this.extension(ext); | ||
| } catch (e) { | ||
| this.warnings.push(e); | ||
| warn(e); | ||
| } | ||
| } | ||
| } else { | ||
| for (const _ref2 of Object.entries(params.extensions)) { | ||
| var _ref3 = _slicedToArray(_ref2, 2); | ||
| const name = _ref3[0]; | ||
| const ext = _ref3[1]; | ||
| try { | ||
| this.extension(ext, name); | ||
| } catch (e) { | ||
| this.warnings.push(e); | ||
| warn(e); | ||
| } | ||
| } | ||
| } | ||
| } else if (typeof extensions === 'object') { | ||
| for (const name of Object.keys(extensions)) { | ||
| this.extension(extensions[name], name); | ||
| } | ||
| } | ||
@@ -212,62 +264,64 @@ } | ||
| let banner = this.get('banner'); | ||
| banner = banner && String(typeof banner === 'function' ? await banner() : banner).trim(); | ||
| const out = this.get('out', process.stdout); | ||
| const originalWrite = out.write; // if we have a banner, then override write() so we can immediately write the banner | ||
| const parser = new _parser.default(); | ||
| if (banner) { | ||
| const dataRegExp = /^\s*[<{]/; | ||
| try { | ||
| const _ref4 = await parser.parse(unparsedArgs || process.argv.slice(2), this), | ||
| _ = _ref4._, | ||
| argv = _ref4.argv, | ||
| contexts = _ref4.contexts, | ||
| unknown = _ref4.unknown; | ||
| out.write = (chunk, encoding, cb) => { | ||
| if (typeof encoding === 'function') { | ||
| cb = encoding; | ||
| encoding = null; | ||
| } | ||
| let cmd = contexts[0]; | ||
| log('Parsing complete: ' + `${pluralize('option', Object.keys(argv).length, true)}, ` + `${pluralize('unknown option', Object.keys(unknown).length, true)}, ` + `${pluralize('arg', _.length, true)}, ` + `${pluralize('context', contexts.length, true)}`); // wire up the banner | ||
| if (typeof cb !== 'function') { | ||
| cb = () => {}; | ||
| } // restore the original write; | ||
| let banner = this.get('banner'); | ||
| if (banner && argv.banner) { | ||
| banner = String(typeof banner === 'function' ? await banner() : banner).trim(); | ||
| out.write = originalWrite; | ||
| const showBanner = write => { | ||
| banner && write(`${banner}\n\n`); | ||
| banner = null; | ||
| }; | ||
| if (encoding === 'base64' || encoding === 'binary' || encoding === 'hex') {// noop | ||
| } else if (this.get('showBanner', true) && !dataRegExp.test(chunk)) { | ||
| originalWrite.call(out, `${banner}\n\n`); | ||
| } | ||
| this.stdout.on('start', showBanner); | ||
| this.stderr.on('start', showBanner); | ||
| } | ||
| return originalWrite.call(out, chunk, encoding, cb); | ||
| }; | ||
| } | ||
| const results = { | ||
| _, | ||
| argv, | ||
| console: this.console, | ||
| contexts, | ||
| unknown, | ||
| warnings: this.warnings | ||
| }; // determine the command to run | ||
| let $args; | ||
| try { | ||
| $args = await this.parse(unparsedArgs ? unparsedArgs.slice() : process.argv.slice(2)); | ||
| let cmd = $args.contexts[0]; | ||
| if (this.help && $args.argv.help) { | ||
| if (this.help && argv.help && (!(cmd instanceof _extension.default) || cmd.isCLIKitExtension)) { | ||
| log('Selected help command'); | ||
| cmd = this.commands.help; | ||
| $args.contexts.unshift(cmd); | ||
| } else if (!(cmd instanceof _command.default) && this.defaultCommand && this.commands[this.defaultCommand] instanceof _command.default) { | ||
| cmd = this.commands.get('help'); | ||
| parser.contexts.unshift(cmd); | ||
| } else if (!(cmd instanceof _command.default) && this.defaultCommand && this.commands.has(this.defaultCommand)) { | ||
| log(`Selected default command: ${this.defaultCommand}`); | ||
| cmd = this.commands[this.defaultCommand]; | ||
| $args.contexts.unshift(cmd); | ||
| } | ||
| cmd = this.commands.get(this.defaultCommand); | ||
| parser.contexts.unshift(cmd); | ||
| } // execute the command | ||
| let result; // execute the command | ||
| if (cmd && typeof cmd.action === 'function') { | ||
| result = await cmd.action.call(this, $args); | ||
| log(`Executing command: ${highlight(cmd.name)}`); | ||
| return await cmd.action(results); | ||
| } | ||
| return result || $args; | ||
| log('No command to execute, returning parsed arguments'); | ||
| return results; | ||
| } catch (err) { | ||
| const help = this.help && this.showHelpOnError !== false && this.commands.help; | ||
| error(err); | ||
| const help = this.help && this.showHelpOnError !== false && this.commands.get('help'); | ||
| if (help) { | ||
| return await help.action({ | ||
| contexts: [help, ...(err.contexts || $args && $args.contexts || [this])], | ||
| err | ||
| contexts: err.contexts || parser.contexts || [this], | ||
| err, | ||
| warnings: this.warnings | ||
| }); | ||
@@ -278,5 +332,4 @@ } | ||
| } finally { | ||
| if (banner) { | ||
| out.write = originalWrite; | ||
| } | ||
| this.stdout.end(); | ||
| this.stderr.end(); | ||
| } | ||
@@ -288,2 +341,2 @@ } | ||
| exports.default = CLI; | ||
| //# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["cli.js"],"names":["log","CLI","constructor","params","Array","isArray","INVALID_ARGUMENT","name","scope","value","out","write","helpExitCode","undefined","width","banner","colors","title","extensions","hideNoBannerOption","hideNoColorOption","defaultCommand","help","command","hidden","action","contexts","err","renderHelp","process","exit","option","showBanner","callback","desc","aliases","version","lookup","short","v","long","get","stdout","extensionPath","extension","Object","keys","exec","unparsedArgs","String","trim","originalWrite","dataRegExp","chunk","encoding","cb","test","call","$args","parse","slice","argv","cmd","commands","unshift","result","showHelpOnError"],"mappings":"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","sourcesContent":["import Command from './command';\nimport Context from './context';\nimport debug from './debug';\nimport E from './errors';\n\nimport { declareCLIKitClass } from './util';\n\nconst { log } = debug('cli-kit:cli');\n\n/**\n * Defines a CLI context and is responsible for parsing the command line arguments.\n */\nexport default class CLI extends Context {\n\t/**\n\t * Created a CLI instance.\n\t *\n\t * @param {Object} [params] - Various options.\n\t * @param {String|Function} [params.banner] - A banner or a function that returns the banner\n\t * to be displayed before each command.\n\t * @param {Boolean} [params.colors=true] - Enables colors, specifically on the help screen.\n\t * @param {Boolean} [params.defaultCommand] - The default command to execute.\n\t * @param {Boolean} [params.help=false] - When `true`, enables the built-in help command.\n\t * @param {Number} [params.helpExitCode] - The exit code to return when the help command is\n\t * finished.\n\t * @param {String} [params.name] - The name of the program.\n\t * @param {Boolean} [params.hideNoBannerOption=false] - When `true` and a `banner` is specified, it\n\t * does not add the `--no-banner` option.\n\t * @param {Boolean} [params.hideNoColorOption=false] - When `true` and `colors` is enabled, it does\n\t * not add the `--no-color` option.\n\t * @param {Object|Writable} [params.out=process.stdout] - A stream to write output such as the\n\t * help screen or an object with a `write()` method.\n\t * @param {Boolean} [params.showHelpOnError=true] - If an error occurs and `help` is enabled,\n\t * then display the error before the help information.\n\t * @param {String} [params.title='Global'] - The title for the global context.\n\t * @param {String} [params.version] - The program version.\n\t * @param {Number} [params.width] - The number of characters to wrap long descriptions. Defaults\n\t * to `process.stdout.columns` if exists, otherwise `100`. Must be at least `40`.\n\t * @access public\n\t */\n\tconstructor(params = {}) {\n\t\tif (typeof params !== 'object' || Array.isArray(params)) {\n\t\t\tthrow E.INVALID_ARGUMENT('Expected CLI parameters to be an object or Context', { name: 'params', scope: 'CLI.constructor', value: params });\n\t\t}\n\n\t\tif (params.out && (typeof params.out !== 'object' || typeof params.out.write !== 'function')) {\n\t\t\tthrow E.INVALID_ARGUMENT('Expected output stream to be a writable stream', { name: 'params.out', scope: 'CLI.constructor', value: params.out });\n\t\t}\n\n\t\tif (params.helpExitCode !== undefined && typeof params.helpExitCode !== 'number') {\n\t\t\tthrow E.INVALID_ARGUMENT('Expected help exit code to be a number', { name: 'params.helpExitCode', scope: 'CLI.constructor', value: params.helpExitCode });\n\t\t}\n\n\t\tif (params.width !== undefined && typeof params.width !== 'number') {\n\t\t\tthrow E.INVALID_ARGUMENT('Expected width to be a number', { name: 'params.width', scope: 'CLI.constructor', value: params.width });\n\t\t}\n\n\t\tif (params.banner !== undefined && typeof params.banner !== 'string' && typeof params.banner !== 'function') {\n\t\t\tthrow E.INVALID_ARGUMENT('Expected banner to be a string or function', { name: 'params.banner', scope: 'CLI.constructor', value: params.banner });\n\t\t}\n\n\t\tparams.colors = params.colors !== false;\n\t\tparams.name || (params.name = 'program');\n\t\tparams.title || (params.title = 'Global');\n\n\t\t// extract params that we don't want mixed in\n\t\tconst { extensions, hideNoBannerOption, hideNoColorOption } = params;\n\t\tdelete params.extensions;\n\t\tdelete params.hideNoBannerOption;\n\t\tdelete params.hideNoColorOption;\n\n\t\tsuper(params);\n\t\tdeclareCLIKitClass(this, 'CLI');\n\n\t\t// set the default command\n\t\tthis.defaultCommand = params.defaultCommand;\n\n\t\t// add the built-in help\n\t\tthis.help = !!params.help;\n\t\tif (this.help) {\n\t\t\tif (this.defaultCommand === undefined) {\n\t\t\t\tthis.defaultCommand = 'help';\n\t\t\t}\n\n\t\t\tthis.command('help', {\n\t\t\t\thidden: true,\n\t\t\t\tasync action({ contexts, err }) {\n\t\t\t\t\t// the first context is the help command, so just skip to the second context\n\t\t\t\t\tawait contexts[1].renderHelp({ err });\n\n\t\t\t\t\t// istanbul ignore if\n\t\t\t\t\tif (params.helpExitCode !== undefined) {\n\t\t\t\t\t\tprocess.exit(params.helpExitCode);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t});\n\n\t\t\tthis.option('-h, --help', 'displays the help screen');\n\t\t}\n\n\t\t// add the --no-banner flag\n\t\tif (this.banner && !hideNoBannerOption) {\n\t\t\tthis.showBanner = true;\n\n\t\t\tthis.option('--no-banner', {\n\t\t\t\tcallback: value => {\n\t\t\t\t\tthis.showBanner = value;\n\t\t\t\t},\n\t\t\t\tdesc: 'suppress the banner'\n\t\t\t});\n\t\t}\n\n\t\t// add the --no-colors flag\n\t\tif (this.colors && !hideNoColorOption) {\n\t\t\tthis.option('--no-color', {\n\t\t\t\taliases: [ '--no-colors' ],\n\t\t\t\tdesc: 'disable colors'\n\t\t\t});\n\t\t}\n\n\t\t// add the --version flag\n\t\tif (params.version && !this.lookup.short.v && !this.lookup.long.version) {\n\t\t\tthis.option('-v, --version', {\n\t\t\t\tcallback: () => {\n\t\t\t\t\tthis.showBanner = false;\n\t\t\t\t\tconst out = this.get('out', process.stdout);\n\t\t\t\t\tout.write(`${params.version}\\n`);\n\t\t\t\t\tprocess.exit(0);\n\t\t\t\t},\n\t\t\t\tdesc: 'outputs the version'\n\t\t\t});\n\t\t}\n\n\t\t// add the extensions now that the auto-generated options exist\n\t\tif (Array.isArray(extensions)) {\n\t\t\tfor (const extensionPath of extensions) {\n\t\t\t\tthis.extension(extensionPath);\n\t\t\t}\n\t\t} else if (typeof extensions === 'object') {\n\t\t\tfor (const name of Object.keys(extensions)) {\n\t\t\t\tthis.extension(extensions[name], name);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Parses the command line arguments and runs the command.\n\t *\n\t * @param {Array.<String>} [unparsedArgs] - An array of arguments to parse. If not specified, it\n\t * defaults to the `process.argv` starting with the 3rd argument.\n\t * @returns {Promise.<Arguments>}\n\t * @access public\n\t */\n\tasync exec(unparsedArgs) {\n\t\tif (unparsedArgs && !Array.isArray(unparsedArgs)) {\n\t\t\tthrow E.INVALID_ARGUMENT('Expected arguments to be an array', { name: 'args', scope: 'CLI.exec', value: unparsedArgs });\n\t\t}\n\n\t\tlet banner = this.get('banner');\n\t\tbanner = banner && String(typeof banner === 'function' ? await banner() : banner).trim();\n\t\tconst out = this.get('out', process.stdout);\n\t\tconst originalWrite = out.write;\n\n\t\t// if we have a banner, then override write() so we can immediately write the banner\n\t\tif (banner) {\n\t\t\tconst dataRegExp = /^\\s*[<{]/;\n\n\t\t\tout.write = (chunk, encoding, cb) => {\n\t\t\t\tif (typeof encoding === 'function') {\n\t\t\t\t\tcb = encoding;\n\t\t\t\t\tencoding = null;\n\t\t\t\t}\n\n\t\t\t\tif (typeof cb !== 'function') {\n\t\t\t\t\tcb = () => {};\n\t\t\t\t}\n\n\t\t\t\t// restore the original write;\n\t\t\t\tout.write = originalWrite;\n\n\t\t\t\tif (encoding === 'base64' || encoding === 'binary' || encoding === 'hex') {\n\t\t\t\t\t// noop\n\t\t\t\t} else if (this.get('showBanner', true) && !dataRegExp.test(chunk)) {\n\t\t\t\t\toriginalWrite.call(out, `${banner}\\n\\n`);\n\t\t\t\t}\n\n\t\t\t\treturn originalWrite.call(out, chunk, encoding, cb);\n\t\t\t};\n\t\t}\n\n\t\tlet $args;\n\n\t\ttry {\n\t\t\t$args = await this.parse(unparsedArgs ? unparsedArgs.slice() : process.argv.slice(2));\n\t\t\tlet cmd = $args.contexts[0];\n\n\t\t\tif (this.help && $args.argv.help) {\n\t\t\t\tlog('Selected help command');\n\t\t\t\tcmd = this.commands.help;\n\t\t\t\t$args.contexts.unshift(cmd);\n\n\t\t\t} else if (!(cmd instanceof Command) && this.defaultCommand && (this.commands[this.defaultCommand] instanceof Command)) {\n\t\t\t\tlog(`Selected default command: ${this.defaultCommand}`);\n\t\t\t\tcmd = this.commands[this.defaultCommand];\n\t\t\t\t$args.contexts.unshift(cmd);\n\t\t\t}\n\n\t\t\tlet result;\n\n\t\t\t// execute the command\n\t\t\tif (cmd && typeof cmd.action === 'function') {\n\t\t\t\tresult = await cmd.action.call(this, $args);\n\t\t\t}\n\n\t\t\treturn result || $args;\n\t\t} catch (err) {\n\t\t\tconst help = this.help && this.showHelpOnError !== false && this.commands.help;\n\n\t\t\tif (help) {\n\t\t\t\treturn await help.action({\n\t\t\t\t\tcontexts: [ help, ...(err.contexts || ($args && $args.contexts) || [ this ]) ],\n\t\t\t\t\terr\n\t\t\t\t});\n\t\t\t}\n\n\t\t\tthrow err;\n\t\t} finally {\n\t\t\tif (banner) {\n\t\t\t\tout.write = originalWrite;\n\t\t\t}\n\t\t}\n\t}\n}\n"],"file":"cli.js"} | ||
| //# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["cli.js"],"names":["error","log","warn","highlight","styles","pluralize","CLI","constructor","params","Array","isArray","INVALID_ARGUMENT","name","scope","value","banner","undefined","extensions","helpExitCode","stdout","write","stderr","args","camelCase","commands","desc","options","title","treatUnknownOptionsAsArguments","colors","errorIfUnknownCommand","warnings","renderOpts","Object","assign","markdown","pipe","process","on","end","console","defaultCommand","help","command","option","hideNoBannerOption","hideNoColorOption","aliases","version","lookup","short","v","long","callback","next","get","exit","ext","extension","e","push","entries","exec","unparsedArgs","parser","parse","argv","slice","_","contexts","unknown","cmd","keys","length","String","trim","showBanner","results","isCLIKitExtension","unshift","has","action","err","showHelpOnError"],"mappings":";;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAEA;;AACA;;;;;;;;;;;;eAE6B,qBAAM,aAAN,C;MAArBA,K,UAAAA,K;MAAOC,G,UAAAA,G;MAAKC,I,UAAAA,I;;MACZC,S,GAAe,gBAAMC,M,CAArBD,S;MACAE,S,mBAAAA,S;AAER;;;;;;AAKe,MAAMC,GAAN,0BAA0B;AACxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BAC,EAAAA,WAAW,GAAc;AAAA,QAAbC,MAAa,uEAAJ,EAAI;;AACxB,QAAI,CAACA,MAAD,IAAW,OAAOA,MAAP,KAAkB,QAA7B,IAAyCC,KAAK,CAACC,OAAN,CAAcF,MAAd,CAA7C,EAAoE;AACnE,YAAM,gBAAEG,gBAAF,CAAmB,oDAAnB,EAAyE;AAAEC,QAAAA,IAAI,EAAE,QAAR;AAAkBC,QAAAA,KAAK,EAAE,iBAAzB;AAA4CC,QAAAA,KAAK,EAAEN;AAAnD,OAAzE,CAAN;AACA;;AAED,QAAIA,MAAM,CAACO,MAAP,KAAkBC,SAAlB,IAA+B,OAAOR,MAAM,CAACO,MAAd,KAAyB,QAAxD,IAAoE,OAAOP,MAAM,CAACO,MAAd,KAAyB,UAAjG,EAA6G;AAC5G,YAAM,gBAAEJ,gBAAF,CAAmB,4CAAnB,EAAiE;AAAEC,QAAAA,IAAI,EAAE,QAAR;AAAkBC,QAAAA,KAAK,EAAE,iBAAzB;AAA4CC,QAAAA,KAAK,EAAEN,MAAM,CAACO;AAA1D,OAAjE,CAAN;AACA;;AAED,QAAIP,MAAM,CAACS,UAAP,IAAqB,OAAOT,MAAM,CAACS,UAAd,KAA6B,QAAtD,EAAgE;AAC/D,YAAM,gBAAEN,gBAAF,CACL,gGADK,EAEL;AAAEC,QAAAA,IAAI,EAAE,YAAR;AAAsBC,QAAAA,KAAK,EAAE,iBAA7B;AAAgDC,QAAAA,KAAK,EAAEN,MAAM,CAACS;AAA9D,OAFK,CAAN;AAIA;;AAED,QAAIT,MAAM,CAACU,YAAP,KAAwBF,SAAxB,IAAqC,OAAOR,MAAM,CAACU,YAAd,KAA+B,QAAxE,EAAkF;AACjF,YAAM,gBAAEP,gBAAF,CAAmB,wCAAnB,EAA6D;AAAEC,QAAAA,IAAI,EAAE,cAAR;AAAwBC,QAAAA,KAAK,EAAE,iBAA/B;AAAkDC,QAAAA,KAAK,EAAEN,MAAM,CAACU;AAAhE,OAA7D,CAAN;AACA;;AAED,QAAIV,MAAM,CAACW,MAAP,KAAkB,OAAOX,MAAM,CAACW,MAAd,KAAyB,QAAzB,IAAqC,OAAOX,MAAM,CAACW,MAAP,CAAcC,KAArB,KAA+B,UAAtF,CAAJ,EAAuG;AACtG,YAAM,gBAAET,gBAAF,CAAmB,gDAAnB,EAAqE;AAAEC,QAAAA,IAAI,EAAE,QAAR;AAAkBC,QAAAA,KAAK,EAAE,iBAAzB;AAA4CC,QAAAA,KAAK,EAAEN,MAAM,CAACW;AAA1D,OAArE,CAAN;AACA;;AAED,QAAIX,MAAM,CAACa,MAAP,KAAkB,OAAOb,MAAM,CAACa,MAAd,KAAyB,QAAzB,IAAqC,OAAOb,MAAM,CAACa,MAAP,CAAcD,KAArB,KAA+B,UAAtF,CAAJ,EAAuG;AACtG,YAAM,gBAAET,gBAAF,CAAmB,gDAAnB,EAAqE;AAAEC,QAAAA,IAAI,EAAE,QAAR;AAAkBC,QAAAA,KAAK,EAAE,iBAAzB;AAA4CC,QAAAA,KAAK,EAAEN,MAAM,CAACa;AAA1D,OAArE,CAAN;AACA;;AAED,UAAM;AACLC,MAAAA,IAAI,EAAQd,MAAM,CAACc,IADd;AAELC,MAAAA,SAAS,EAAGf,MAAM,CAACe,SAFd;AAGLC,MAAAA,QAAQ,EAAIhB,MAAM,CAACgB,QAHd;AAILC,MAAAA,IAAI,EAAQjB,MAAM,CAACiB,IAJd;AAKLb,MAAAA,IAAI,EAAQJ,MAAM,CAACI,IAAP,IAAe,SALtB;AAMLc,MAAAA,OAAO,EAAKlB,MAAM,CAACkB,OANd;AAOLC,MAAAA,KAAK,EAAOnB,MAAM,CAACmB,KAAP,IAAgB,QAPvB;AAQLC,MAAAA,8BAA8B,EAAEpB,MAAM,CAACoB;AARlC,KAAN;AAWA,kCAAmB,IAAnB,EAAyB,KAAzB;AAEA,SAAKb,MAAL,GAA6BP,MAAM,CAACO,MAApC;AACA,SAAKc,MAAL,GAA6BrB,MAAM,CAACqB,MAAP,KAAkB,KAA/C;AACA,SAAKC,qBAAL,GAA6BtB,MAAM,CAACsB,qBAAP,KAAiC,KAA9D;AACA,SAAKZ,YAAL,GAA6BV,MAAM,CAACU,YAApC;AACA,SAAKa,QAAL,GAA6B,EAA7B;AAEA,UAAMC,UAAU,GAAGC,MAAM,CAACC,MAAP,CAAc;AAChCC,MAAAA,QAAQ,EAAE;AADsB,KAAd,EAEhB3B,MAAM,CAACwB,UAFS,CAAnB,CA/CwB,CAmDxB;;AACA,SAAKb,MAAL,GAAc,0BAAiBa,UAAjB,CAAd;AACA,SAAKb,MAAL,CAAYiB,IAAZ,CAAiB5B,MAAM,CAACW,MAAP,IAAiBkB,OAAO,CAAClB,MAA1C;AAEA,SAAKE,MAAL,GAAc,0BAAiBW,UAAjB,CAAd;AACA,SAAKX,MAAL,CAAYe,IAAZ,CAAiB5B,MAAM,CAACa,MAAP,IAAiBgB,OAAO,CAAChB,MAA1C;AAEAgB,IAAAA,OAAO,CAACC,EAAR,CAAW,MAAX,EAAmB,MAAM;AACxB,WAAKnB,MAAL,CAAYoB,GAAZ;AACA,WAAKlB,MAAL,CAAYkB,GAAZ;AACA,KAHD;AAKA,SAAKC,OAAL,GAAe,qBAAY,KAAKrB,MAAjB,EAAyB,KAAKE,MAA9B,CAAf,CA/DwB,CAiExB;;AACA,SAAKoB,cAAL,GAAsBjC,MAAM,CAACiC,cAA7B,CAlEwB,CAoExB;;AACA,SAAKC,IAAL,GAAY,CAAC,CAAClC,MAAM,CAACkC,IAArB;;AACA,QAAI,KAAKA,IAAT,EAAe;AACd,UAAI,KAAKD,cAAL,KAAwBzB,SAA5B,EAAuC;AACtC,aAAKyB,cAAL,GAAsB,MAAtB;AACA,OAHa,CAKd;;;AACA,WAAKE,OAAL,CAAa,MAAb,EAAqBV,MAAM,CAACC,MAAP,CAAc,EAAd,gBAArB;AAEA,WAAKU,MAAL,CAAY,YAAZ,EAA0B,0BAA1B;AACA,KA/EuB,CAiFxB;;;AACA,QAAI,KAAK7B,MAAL,IAAe,CAACP,MAAM,CAACqC,kBAA3B,EAA+C;AAC9C,WAAKD,MAAL,CAAY,aAAZ,EAA2B;AAC1BnB,QAAAA,IAAI,EAAE;AADoB,OAA3B;AAGA,KAtFuB,CAwFxB;;;AACA,QAAI,KAAKI,MAAL,IAAe,CAACrB,MAAM,CAACsC,iBAA3B,EAA8C;AAC7C,WAAKF,MAAL,CAAY,YAAZ,EAA0B;AACzBG,QAAAA,OAAO,EAAE,CAAE,aAAF,CADgB;AAEzBtB,QAAAA,IAAI,EAAE;AAFmB,OAA1B;AAIA,KA9FuB,CAgGxB;;;AACA,QAAIjB,MAAM,CAACwC,OAAP,IAAkB,CAAC,KAAKC,MAAL,CAAYC,KAAZ,CAAkBC,CAArC,IAA0C,CAAC,KAAKF,MAAL,CAAYG,IAAZ,CAAiBJ,OAAhE,EAAyE;AACxE,WAAKJ,MAAL,CAAY,eAAZ,EAA6B;AAC5BS,QAAAA,QAAQ,EAAE,gBAAoB;AAAA,cAAXC,IAAW,QAAXA,IAAW;AAC7B,gBAAMA,IAAI,EAAV;AACA,eAAKC,GAAL,CAAS,QAAT,EAAmBnC,KAAnB,CAA0B,GAAEZ,MAAM,CAACwC,OAAQ,IAA3C;AACAX,UAAAA,OAAO,CAACmB,IAAR,CAAa,CAAb;AACA,SAL2B;AAM5B/B,QAAAA,IAAI,EAAE;AANsB,OAA7B;AAQA,KA1GuB,CA4GxB;;;AACA,QAAIjB,MAAM,CAACS,UAAX,EAAuB;AACtB,UAAIR,KAAK,CAACC,OAAN,CAAcF,MAAM,CAACS,UAArB,CAAJ,EAAsC;AACrC,aAAK,MAAMwC,GAAX,IAAkBjD,MAAM,CAACS,UAAzB,EAAqC;AACpC,cAAI;AACH,iBAAKyC,SAAL,CAAeD,GAAf;AACA,WAFD,CAEE,OAAOE,CAAP,EAAU;AACX,iBAAK5B,QAAL,CAAc6B,IAAd,CAAmBD,CAAnB;AACAzD,YAAAA,IAAI,CAACyD,CAAD,CAAJ;AACA;AACD;AACD,OATD,MASO;AACN,4BAA4B1B,MAAM,CAAC4B,OAAP,CAAerD,MAAM,CAACS,UAAtB,CAA5B,EAA+D;AAAA;;AAAA,gBAAlDL,IAAkD;AAAA,gBAA5C6C,GAA4C;;AAC9D,cAAI;AACH,iBAAKC,SAAL,CAAeD,GAAf,EAAoB7C,IAApB;AACA,WAFD,CAEE,OAAO+C,CAAP,EAAU;AACX,iBAAK5B,QAAL,CAAc6B,IAAd,CAAmBD,CAAnB;AACAzD,YAAAA,IAAI,CAACyD,CAAD,CAAJ;AACA;AACD;AACD;AACD;AACD;AAED;;;;;;;;;;AAQA,QAAMG,IAAN,CAAWC,YAAX,EAAyB;AACxB,QAAIA,YAAY,IAAI,CAACtD,KAAK,CAACC,OAAN,CAAcqD,YAAd,CAArB,EAAkD;AACjD,YAAM,gBAAEpD,gBAAF,CAAmB,mCAAnB,EAAwD;AAAEC,QAAAA,IAAI,EAAE,MAAR;AAAgBC,QAAAA,KAAK,EAAE,UAAvB;AAAmCC,QAAAA,KAAK,EAAEiD;AAA1C,OAAxD,CAAN;AACA;;AAED,UAAMC,MAAM,GAAG,qBAAf;;AAEA,QAAI;AAAA,oBACoC,MAAMA,MAAM,CAACC,KAAP,CAAaF,YAAY,IAAI1B,OAAO,CAAC6B,IAAR,CAAaC,KAAb,CAAmB,CAAnB,CAA7B,EAAoD,IAApD,CAD1C;AAAA,YACKC,CADL,SACKA,CADL;AAAA,YACQF,IADR,SACQA,IADR;AAAA,YACcG,QADd,SACcA,QADd;AAAA,YACwBC,OADxB,SACwBA,OADxB;;AAEH,UAAIC,GAAG,GAAGF,QAAQ,CAAC,CAAD,CAAlB;AAEApE,MAAAA,GAAG,CAAC,uBACF,GAAEI,SAAS,CAAC,QAAD,EAAW4B,MAAM,CAACuC,IAAP,CAAYN,IAAZ,EAAkBO,MAA7B,EAAqC,IAArC,CAA2C,IADpD,GAEF,GAAEpE,SAAS,CAAC,gBAAD,EAAmB4B,MAAM,CAACuC,IAAP,CAAYF,OAAZ,EAAqBG,MAAxC,EAAgD,IAAhD,CAAsD,IAF/D,GAGF,GAAEpE,SAAS,CAAC,KAAD,EAAQ+D,CAAC,CAACK,MAAV,EAAkB,IAAlB,CAAwB,IAHjC,GAIF,GAAEpE,SAAS,CAAC,SAAD,EAAYgE,QAAQ,CAACI,MAArB,EAA6B,IAA7B,CAAmC,EAJ7C,CAAH,CAJG,CAWH;;AACA,UAAI1D,MAAM,GAAG,KAAKwC,GAAL,CAAS,QAAT,CAAb;;AACA,UAAIxC,MAAM,IAAImD,IAAI,CAACnD,MAAnB,EAA2B;AAC1BA,QAAAA,MAAM,GAAG2D,MAAM,CAAC,OAAO3D,MAAP,KAAkB,UAAlB,GAA+B,MAAMA,MAAM,EAA3C,GAAgDA,MAAjD,CAAN,CAA+D4D,IAA/D,EAAT;;AACA,cAAMC,UAAU,GAAGxD,KAAK,IAAI;AAC3BL,UAAAA,MAAM,IAAIK,KAAK,CAAE,GAAEL,MAAO,MAAX,CAAf;AACAA,UAAAA,MAAM,GAAG,IAAT;AACA,SAHD;;AAIA,aAAKI,MAAL,CAAYmB,EAAZ,CAAe,OAAf,EAAwBsC,UAAxB;AACA,aAAKvD,MAAL,CAAYiB,EAAZ,CAAe,OAAf,EAAwBsC,UAAxB;AACA;;AAED,YAAMC,OAAO,GAAG;AACfT,QAAAA,CADe;AAEfF,QAAAA,IAFe;AAGf1B,QAAAA,OAAO,EAAE,KAAKA,OAHC;AAIf6B,QAAAA,QAJe;AAKfC,QAAAA,OALe;AAMfvC,QAAAA,QAAQ,EAAE,KAAKA;AANA,OAAhB,CAvBG,CAgCH;;AACA,UAAI,KAAKW,IAAL,IAAawB,IAAI,CAACxB,IAAlB,KAA2B,EAAE6B,GAAG,8BAAL,KAA+BA,GAAG,CAACO,iBAA9D,CAAJ,EAAsF;AACrF7E,QAAAA,GAAG,CAAC,uBAAD,CAAH;AACAsE,QAAAA,GAAG,GAAG,KAAK/C,QAAL,CAAc+B,GAAd,CAAkB,MAAlB,CAAN;AACAS,QAAAA,MAAM,CAACK,QAAP,CAAgBU,OAAhB,CAAwBR,GAAxB;AAEA,OALD,MAKO,IAAI,EAAEA,GAAG,4BAAL,KAA6B,KAAK9B,cAAlC,IAAoD,KAAKjB,QAAL,CAAcwD,GAAd,CAAkB,KAAKvC,cAAvB,CAAxD,EAAgG;AACtGxC,QAAAA,GAAG,CAAE,6BAA4B,KAAKwC,cAAe,EAAlD,CAAH;AACA8B,QAAAA,GAAG,GAAG,KAAK/C,QAAL,CAAc+B,GAAd,CAAkB,KAAKd,cAAvB,CAAN;AACAuB,QAAAA,MAAM,CAACK,QAAP,CAAgBU,OAAhB,CAAwBR,GAAxB;AACA,OA1CE,CA4CH;;;AACA,UAAIA,GAAG,IAAI,OAAOA,GAAG,CAACU,MAAX,KAAsB,UAAjC,EAA6C;AAC5ChF,QAAAA,GAAG,CAAE,sBAAqBE,SAAS,CAACoE,GAAG,CAAC3D,IAAL,CAAW,EAA3C,CAAH;AACA,eAAO,MAAM2D,GAAG,CAACU,MAAJ,CAAWJ,OAAX,CAAb;AACA;;AAED5E,MAAAA,GAAG,CAAC,mDAAD,CAAH;AACA,aAAO4E,OAAP;AACA,KApDD,CAoDE,OAAOK,GAAP,EAAY;AACblF,MAAAA,KAAK,CAACkF,GAAD,CAAL;AAEA,YAAMxC,IAAI,GAAG,KAAKA,IAAL,IAAa,KAAKyC,eAAL,KAAyB,KAAtC,IAA+C,KAAK3D,QAAL,CAAc+B,GAAd,CAAkB,MAAlB,CAA5D;;AACA,UAAIb,IAAJ,EAAU;AACT,eAAO,MAAMA,IAAI,CAACuC,MAAL,CAAY;AACxBZ,UAAAA,QAAQ,EAAEa,GAAG,CAACb,QAAJ,IAAgBL,MAAM,CAACK,QAAvB,IAAmC,CAAE,IAAF,CADrB;AAExBa,UAAAA,GAFwB;AAGxBnD,UAAAA,QAAQ,EAAE,KAAKA;AAHS,SAAZ,CAAb;AAKA;;AAED,YAAMmD,GAAN;AACA,KAjED,SAiEU;AACT,WAAK/D,MAAL,CAAYoB,GAAZ;AACA,WAAKlB,MAAL,CAAYkB,GAAZ;AACA;AACD;;AAxPuC","sourcesContent":["import Command from './parser/command';\nimport Context from './parser/context';\nimport debug from './lib/debug';\nimport E from './lib/errors';\nimport Extension from './parser/extension';\nimport helpCommand from './commands/help';\nimport Parser from './parser/parser';\nimport OutputStream from './render/output-stream';\n\nimport { Console } from 'console';\nimport { declareCLIKitClass } from './lib/util';\n\nconst { error, log, warn } = debug('cli-kit:cli');\nconst { highlight }  = debug.styles;\nconst { pluralize } = debug;\n\n/**\n * Defines a CLI context and is responsible for parsing the command line arguments.\n *\n * @extends {Context}\n */\nexport default class CLI extends Context {\n\t/**\n\t * Created a CLI instance.\n\t *\n\t * @param {Object} [params] - Various options.\n\t * @param {String|Function} [params.banner] - A banner or a function that returns the banner\n\t * to be displayed before each command.\n\t * @param {Boolean} [params.colors=true] - Enables colors, specifically on the help screen.\n\t * @param {Boolean} [params.defaultCommand] - The default command to execute.\n\t * @param {Boolean} [params.errorIfUnknownCommand=true] - When `true`, `help` is enabled, and\n\t * the parser didn't find a command, but it did find an unknown argument, it will show the help\n\t * screen with an unknown command error.\n\t * @param {Boolean} [params.help=false] - When `true`, enables the built-in help command.\n\t * @param {Number} [params.helpExitCode] - The exit code to return when the help command is\n\t * finished.\n\t * @param {Boolean} [params.hideNoBannerOption=false] - When `true` and a `banner` is specified,\n\t * it does not add the `--no-banner` option.\n\t * @param {Boolean} [params.hideNoColorOption=false] - When `true` and `colors` is enabled, it\n\t * does not add the `--no-color` option.\n\t * @param {String} [params.name] - The name of the program.\n\t * @param {Object} [params.renderOpts] - Various render options to control the output stream\n\t * such as the display width.\n\t * @param {Object|stream.Writable} [params.stdout=process.stdout] - A stream or an object with a\n\t * `write()` method to write output such as the help screen to.\n\t * @param {Object|stream.Writable} [params.stderr=process.stderr] - A stream or an object with a\n\t * `write()` method to write error messages to.\n\t * @param {Boolean} [params.showHelpOnError=true] - If an error occurs and `help` is enabled,\n\t * then display the error before the help information.\n\t * @param {String} [params.title='Global'] - The title for the global context.\n\t * @param {String} [params.version] - The program version.\n\t * @access public\n\t */\n\tconstructor(params = {}) {\n\t\tif (!params || typeof params !== 'object' || Array.isArray(params)) {\n\t\t\tthrow E.INVALID_ARGUMENT('Expected CLI parameters to be an object or Context', { name: 'params', scope: 'CLI.constructor', value: params });\n\t\t}\n\n\t\tif (params.banner !== undefined && typeof params.banner !== 'string' && typeof params.banner !== 'function') {\n\t\t\tthrow E.INVALID_ARGUMENT('Expected banner to be a string or function', { name: 'banner', scope: 'CLI.constructor', value: params.banner });\n\t\t}\n\n\t\tif (params.extensions && typeof params.extensions !== 'object') {\n\t\t\tthrow E.INVALID_ARGUMENT(\n\t\t\t\t'Expected extensions to be an array of extension paths or an object of names to extension paths',\n\t\t\t\t{ name: 'extensions', scope: 'CLI.constructor', value: params.extensions }\n\t\t\t);\n\t\t}\n\n\t\tif (params.helpExitCode !== undefined && typeof params.helpExitCode !== 'number') {\n\t\t\tthrow E.INVALID_ARGUMENT('Expected help exit code to be a number', { name: 'helpExitCode', scope: 'CLI.constructor', value: params.helpExitCode });\n\t\t}\n\n\t\tif (params.stdout && (typeof params.stdout !== 'object' || typeof params.stdout.write !== 'function')) {\n\t\t\tthrow E.INVALID_ARGUMENT('Expected stdout stream to be a writable stream', { name: 'stdout', scope: 'CLI.constructor', value: params.stdout });\n\t\t}\n\n\t\tif (params.stderr && (typeof params.stderr !== 'object' || typeof params.stderr.write !== 'function')) {\n\t\t\tthrow E.INVALID_ARGUMENT('Expected stderr stream to be a writable stream', { name: 'stderr', scope: 'CLI.constructor', value: params.stderr });\n\t\t}\n\n\t\tsuper({\n\t\t\targs:       params.args,\n\t\t\tcamelCase:  params.camelCase,\n\t\t\tcommands:   params.commands,\n\t\t\tdesc:       params.desc,\n\t\t\tname:       params.name || 'program',\n\t\t\toptions:    params.options,\n\t\t\ttitle:      params.title || 'Global',\n\t\t\ttreatUnknownOptionsAsArguments: params.treatUnknownOptionsAsArguments\n\t\t});\n\n\t\tdeclareCLIKitClass(this, 'CLI');\n\n\t\tthis.banner                = params.banner;\n\t\tthis.colors                = params.colors !== false;\n\t\tthis.errorIfUnknownCommand = params.errorIfUnknownCommand !== false;\n\t\tthis.helpExitCode          = params.helpExitCode;\n\t\tthis.warnings              = [];\n\n\t\tconst renderOpts = Object.assign({\n\t\t\tmarkdown: true\n\t\t}, params.renderOpts);\n\n\t\t// init the output streams\n\t\tthis.stdout = new OutputStream(renderOpts);\n\t\tthis.stdout.pipe(params.stdout || process.stdout);\n\n\t\tthis.stderr = new OutputStream(renderOpts);\n\t\tthis.stderr.pipe(params.stderr || process.stderr);\n\n\t\tprocess.on('exit', () => {\n\t\t\tthis.stdout.end();\n\t\t\tthis.stderr.end();\n\t\t});\n\n\t\tthis.console = new Console(this.stdout, this.stderr);\n\n\t\t// set the default command\n\t\tthis.defaultCommand = params.defaultCommand;\n\n\t\t// add the built-in help\n\t\tthis.help = !!params.help;\n\t\tif (this.help) {\n\t\t\tif (this.defaultCommand === undefined) {\n\t\t\t\tthis.defaultCommand = 'help';\n\t\t\t}\n\n\t\t\t// note: we must clone the help command params since the object gets modified\n\t\t\tthis.command('help', Object.assign({}, helpCommand));\n\n\t\t\tthis.option('-h, --help', 'displays the help screen');\n\t\t}\n\n\t\t// add the --no-banner flag\n\t\tif (this.banner && !params.hideNoBannerOption) {\n\t\t\tthis.option('--no-banner', {\n\t\t\t\tdesc: 'suppress the banner'\n\t\t\t});\n\t\t}\n\n\t\t// add the --no-colors flag\n\t\tif (this.colors && !params.hideNoColorOption) {\n\t\t\tthis.option('--no-color', {\n\t\t\t\taliases: [ '--no-colors' ],\n\t\t\t\tdesc: 'disable colors'\n\t\t\t});\n\t\t}\n\n\t\t// add the --version flag\n\t\tif (params.version && !this.lookup.short.v && !this.lookup.long.version) {\n\t\t\tthis.option('-v, --version', {\n\t\t\t\tcallback: async ({ next }) => {\n\t\t\t\t\tawait next();\n\t\t\t\t\tthis.get('stdout').write(`${params.version}\\n`);\n\t\t\t\t\tprocess.exit(0);\n\t\t\t\t},\n\t\t\t\tdesc: 'outputs the version'\n\t\t\t});\n\t\t}\n\n\t\t// add the extensions now that the auto-generated options exist\n\t\tif (params.extensions) {\n\t\t\tif (Array.isArray(params.extensions)) {\n\t\t\t\tfor (const ext of params.extensions) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tthis.extension(ext);\n\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\tthis.warnings.push(e);\n\t\t\t\t\t\twarn(e);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor (const [ name, ext ] of Object.entries(params.extensions)) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tthis.extension(ext, name);\n\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\tthis.warnings.push(e);\n\t\t\t\t\t\twarn(e);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Parses the command line arguments and runs the command.\n\t *\n\t * @param {Array.<String>} [unparsedArgs] - An array of arguments to parse. If not specified, it\n\t * defaults to the `process.argv` starting with the 3rd argument.\n\t * @returns {Promise.<Arguments>}\n\t * @access public\n\t */\n\tasync exec(unparsedArgs) {\n\t\tif (unparsedArgs && !Array.isArray(unparsedArgs)) {\n\t\t\tthrow E.INVALID_ARGUMENT('Expected arguments to be an array', { name: 'args', scope: 'CLI.exec', value: unparsedArgs });\n\t\t}\n\n\t\tconst parser = new Parser();\n\n\t\ttry {\n\t\t\tconst { _, argv, contexts, unknown } = await parser.parse(unparsedArgs || process.argv.slice(2), this);\n\t\t\tlet cmd = contexts[0];\n\n\t\t\tlog('Parsing complete: ' +\n\t\t\t\t`${pluralize('option', Object.keys(argv).length, true)}, ` +\n\t\t\t\t`${pluralize('unknown option', Object.keys(unknown).length, true)}, ` +\n\t\t\t\t`${pluralize('arg', _.length, true)}, ` +\n\t\t\t\t`${pluralize('context', contexts.length, true)}`\n\t\t\t);\n\n\t\t\t// wire up the banner\n\t\t\tlet banner = this.get('banner');\n\t\t\tif (banner && argv.banner) {\n\t\t\t\tbanner = String(typeof banner === 'function' ? await banner() : banner).trim();\n\t\t\t\tconst showBanner = write => {\n\t\t\t\t\tbanner && write(`${banner}\\n\\n`);\n\t\t\t\t\tbanner = null;\n\t\t\t\t};\n\t\t\t\tthis.stdout.on('start', showBanner);\n\t\t\t\tthis.stderr.on('start', showBanner);\n\t\t\t}\n\n\t\t\tconst results = {\n\t\t\t\t_,\n\t\t\t\targv,\n\t\t\t\tconsole: this.console,\n\t\t\t\tcontexts,\n\t\t\t\tunknown,\n\t\t\t\twarnings: this.warnings\n\t\t\t};\n\n\t\t\t// determine the command to run\n\t\t\tif (this.help && argv.help && (!(cmd instanceof Extension) || cmd.isCLIKitExtension)) {\n\t\t\t\tlog('Selected help command');\n\t\t\t\tcmd = this.commands.get('help');\n\t\t\t\tparser.contexts.unshift(cmd);\n\n\t\t\t} else if (!(cmd instanceof Command) && this.defaultCommand && this.commands.has(this.defaultCommand)) {\n\t\t\t\tlog(`Selected default command: ${this.defaultCommand}`);\n\t\t\t\tcmd = this.commands.get(this.defaultCommand);\n\t\t\t\tparser.contexts.unshift(cmd);\n\t\t\t}\n\n\t\t\t// execute the command\n\t\t\tif (cmd && typeof cmd.action === 'function') {\n\t\t\t\tlog(`Executing command: ${highlight(cmd.name)}`);\n\t\t\t\treturn await cmd.action(results);\n\t\t\t}\n\n\t\t\tlog('No command to execute, returning parsed arguments');\n\t\t\treturn results;\n\t\t} catch (err) {\n\t\t\terror(err);\n\n\t\t\tconst help = this.help && this.showHelpOnError !== false && this.commands.get('help');\n\t\t\tif (help) {\n\t\t\t\treturn await help.action({\n\t\t\t\t\tcontexts: err.contexts || parser.contexts || [ this ],\n\t\t\t\t\terr,\n\t\t\t\t\twarnings: this.warnings\n\t\t\t\t});\n\t\t\t}\n\n\t\t\tthrow err;\n\t\t} finally {\n\t\t\tthis.stdout.end();\n\t\t\tthis.stderr.end();\n\t\t}\n\t}\n}\n"],"file":"cli.js"} |
@@ -6,15 +6,2 @@ "use strict"; | ||
| }); | ||
| var _exportNames = { | ||
| chalk: true, | ||
| humanize: true, | ||
| moment: true, | ||
| pluralize: true, | ||
| symbols: true, | ||
| snooplogg: true, | ||
| CLI: true, | ||
| Argument: true, | ||
| Command: true, | ||
| Option: true, | ||
| Extension: true | ||
| }; | ||
| Object.defineProperty(exports, "snooplogg", { | ||
@@ -62,3 +49,3 @@ enumerable: true, | ||
| }); | ||
| exports.symbols = exports.pluralize = exports.moment = exports.humanize = exports.chalk = void 0; | ||
| exports.util = exports.types = exports.template = exports.symbols = exports.pluralize = exports.moment = exports.humanize = exports.chalk = void 0; | ||
@@ -69,23 +56,24 @@ var _snooplogg = _interopRequireDefault(require("snooplogg")); | ||
| var _argument = _interopRequireDefault(require("./argument")); | ||
| var _argument = _interopRequireDefault(require("./parser/argument")); | ||
| var _command = _interopRequireDefault(require("./command")); | ||
| var _command = _interopRequireDefault(require("./parser/command")); | ||
| var _option = _interopRequireDefault(require("./option")); | ||
| var _option = _interopRequireDefault(require("./parser/option")); | ||
| var _extension = _interopRequireDefault(require("./extension")); | ||
| var _extension = _interopRequireDefault(require("./parser/extension")); | ||
| var _util = require("./util"); | ||
| var template = _interopRequireWildcard(require("./render/template")); | ||
| Object.keys(_util).forEach(function (key) { | ||
| if (key === "default" || key === "__esModule") return; | ||
| if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return; | ||
| Object.defineProperty(exports, key, { | ||
| enumerable: true, | ||
| get: function () { | ||
| return _util[key]; | ||
| } | ||
| }); | ||
| }); | ||
| exports.template = template; | ||
| var types = _interopRequireWildcard(require("./parser/types")); | ||
| exports.types = types; | ||
| var util = _interopRequireWildcard(require("./lib/util")); | ||
| exports.util = util; | ||
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } | ||
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
@@ -108,2 +96,2 @@ | ||
| exports.chalk = chalk; | ||
| //# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbIkVycm9yIiwicHJlcGFyZVN0YWNrVHJhY2UiLCJyZXF1aXJlIiwiY2hhbGsiLCJodW1hbml6ZSIsIm1vbWVudCIsInBsdXJhbGl6ZSIsInN5bWJvbHMiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBS0E7O0FBS0E7O0FBS0E7O0FBQ0E7O0FBQ0E7O0FBQ0E7O0FBQ0E7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7Ozs7QUFuQkE7QUFDQSxJQUFJLENBQUNBLE1BQU1DLGlCQUFYLEVBQThCO0FBQzdCQyxVQUFRLDZCQUFSO0FBQ0E7O01BS2NDLEssc0JBQUFBLEs7TUFBT0MsUSxzQkFBQUEsUTtNQUFVQyxNLHNCQUFBQSxNO01BQVFDLFMsc0JBQUFBLFM7TUFBV0MsTyxzQkFBQUEsTyIsInNvdXJjZXNDb250ZW50IjpbIi8qIGlzdGFuYnVsIGlnbm9yZSBpZiAqL1xuaWYgKCFFcnJvci5wcmVwYXJlU3RhY2tUcmFjZSkge1xuXHRyZXF1aXJlKCdzb3VyY2UtbWFwLXN1cHBvcnQvcmVnaXN0ZXInKTtcbn1cblxuaW1wb3J0IHNub29wbG9nZyBmcm9tICdzbm9vcGxvZ2cnO1xuXG5leHBvcnQgeyBzbm9vcGxvZ2cgfTtcbmV4cG9ydCBjb25zdCB7IGNoYWxrLCBodW1hbml6ZSwgbW9tZW50LCBwbHVyYWxpemUsIHN5bWJvbHMgfSA9IHNub29wbG9nZztcblxuZXhwb3J0IHtcblx0ZGVmYXVsdCxcblx0ZGVmYXVsdCBhcyBDTElcbn0gZnJvbSAnLi9jbGknO1xuXG5leHBvcnQgeyBkZWZhdWx0IGFzIEFyZ3VtZW50IH0gZnJvbSAnLi9hcmd1bWVudCc7XG5leHBvcnQgeyBkZWZhdWx0IGFzIENvbW1hbmQgfSBmcm9tICcuL2NvbW1hbmQnO1xuZXhwb3J0IHsgZGVmYXVsdCBhcyBPcHRpb24gfSBmcm9tICcuL29wdGlvbic7XG5leHBvcnQgeyBkZWZhdWx0IGFzIEV4dGVuc2lvbiB9IGZyb20gJy4vZXh0ZW5zaW9uJztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbCc7XG4iXSwiZmlsZSI6ImluZGV4LmpzIn0= | ||
| //# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbIkVycm9yIiwicHJlcGFyZVN0YWNrVHJhY2UiLCJyZXF1aXJlIiwiY2hhbGsiLCJodW1hbml6ZSIsIm1vbWVudCIsInBsdXJhbGl6ZSIsInN5bWJvbHMiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFLQTs7QUFLQTs7QUFLQTs7QUFDQTs7QUFDQTs7QUFDQTs7QUFFQTs7OztBQUNBOzs7O0FBQ0E7Ozs7Ozs7O0FBdEJBO0FBQ0EsSUFBSSxDQUFDQSxLQUFLLENBQUNDLGlCQUFYLEVBQThCO0FBQzdCQyxFQUFBQSxPQUFPLENBQUMsNkJBQUQsQ0FBUDtBQUNBOztNQUtjQyxLLHNCQUFBQSxLO01BQU9DLFEsc0JBQUFBLFE7TUFBVUMsTSxzQkFBQUEsTTtNQUFRQyxTLHNCQUFBQSxTO01BQVdDLE8sc0JBQUFBLE8iLCJzb3VyY2VzQ29udGVudCI6WyIvKiBpc3RhbmJ1bCBpZ25vcmUgaWYgKi9cbmlmICghRXJyb3IucHJlcGFyZVN0YWNrVHJhY2UpIHtcblx0cmVxdWlyZSgnc291cmNlLW1hcC1zdXBwb3J0L3JlZ2lzdGVyJyk7XG59XG5cbmltcG9ydCBzbm9vcGxvZ2cgZnJvbSAnc25vb3Bsb2dnJztcblxuZXhwb3J0IHsgc25vb3Bsb2dnIH07XG5leHBvcnQgY29uc3QgeyBjaGFsaywgaHVtYW5pemUsIG1vbWVudCwgcGx1cmFsaXplLCBzeW1ib2xzIH0gPSBzbm9vcGxvZ2c7XG5cbmV4cG9ydCB7XG5cdGRlZmF1bHQsXG5cdGRlZmF1bHQgYXMgQ0xJXG59IGZyb20gJy4vY2xpJztcblxuaW1wb3J0IEFyZ3VtZW50IGZyb20gJy4vcGFyc2VyL2FyZ3VtZW50JztcbmltcG9ydCBDb21tYW5kIGZyb20gJy4vcGFyc2VyL2NvbW1hbmQnO1xuaW1wb3J0IE9wdGlvbiBmcm9tICcuL3BhcnNlci9vcHRpb24nO1xuaW1wb3J0IEV4dGVuc2lvbiBmcm9tICcuL3BhcnNlci9leHRlbnNpb24nO1xuXG5pbXBvcnQgKiBhcyB0ZW1wbGF0ZSBmcm9tICcuL3JlbmRlci90ZW1wbGF0ZSc7XG5pbXBvcnQgKiBhcyB0eXBlcyBmcm9tICcuL3BhcnNlci90eXBlcyc7XG5pbXBvcnQgKiBhcyB1dGlsIGZyb20gJy4vbGliL3V0aWwnO1xuXG5leHBvcnQge1xuXHRBcmd1bWVudCxcblx0Q29tbWFuZCxcblx0T3B0aW9uLFxuXHRFeHRlbnNpb24sXG5cdHRlbXBsYXRlLFxuXHR0eXBlcyxcblx0dXRpbFxufTtcbiJdLCJmaWxlIjoiaW5kZXguanMifQ== |
| { | ||
| "name": "cli-kit", | ||
| "version": "0.3.0", | ||
| "version": "0.4.0-beta", | ||
| "description": "Everything you need to create awesome command line interfaces", | ||
@@ -42,8 +42,11 @@ "main": "./dist/index.js", | ||
| "dependencies": { | ||
| "hook-emitter": "^3.0.0", | ||
| "fast-levenshtein": "^2.0.6", | ||
| "hook-emitter": "^3.0.2", | ||
| "isexe": "^2.0.0", | ||
| "kramed": "^0.5.6", | ||
| "lodash.camelcase": "^4.3.0", | ||
| "pkg-dir": "^2.0.0", | ||
| "snooplogg": "^1.10.1", | ||
| "source-map-support": "^0.5.6", | ||
| "marked-terminal": "^3.0.0", | ||
| "pkg-dir": "^3.0.0", | ||
| "snooplogg": "^1.12.1", | ||
| "source-map-support": "^0.5.9", | ||
| "which": "^1.3.1" | ||
@@ -54,3 +57,3 @@ }, | ||
| "@babel/register": "latest", | ||
| "babel-eslint": "^8.2.3", | ||
| "babel-eslint": "^8.2.6", | ||
| "babel-plugin-istanbul": "^4.1.6", | ||
@@ -65,3 +68,3 @@ "babel-plugin-transform-class-properties": "next", | ||
| "codeclimate-test-reporter": "^0.5.0", | ||
| "coveralls": "^3.0.1", | ||
| "coveralls": "^3.0.2", | ||
| "esdoc": "^1.1.0", | ||
@@ -71,7 +74,7 @@ "esdoc-ecmascript-proposal-plugin": "^1.0.0", | ||
| "eslint-plugin-security": "^1.4.0", | ||
| "fs-extra": "^6.0.1", | ||
| "fs-extra": "^7.0.0", | ||
| "gulp": "^3.9.1", | ||
| "gulp-babel": "next", | ||
| "gulp-debug": "^3.2.0", | ||
| "gulp-eslint": "^4.0.2", | ||
| "gulp-debug": "^4.0.0", | ||
| "gulp-eslint": "^5.0.0", | ||
| "gulp-load-plugins": "^1.5.0", | ||
@@ -83,5 +86,5 @@ "gulp-plumber": "^1.2.0", | ||
| "mocha": "^5.2.0", | ||
| "nyc": "^11.8.0", | ||
| "sinon": "^5.0.10", | ||
| "sinon-chai": "^3.1.0", | ||
| "nyc": "^12.0.2", | ||
| "sinon": "^6.1.5", | ||
| "sinon-chai": "^3.2.0", | ||
| "tmp": "^0.0.33" | ||
@@ -88,0 +91,0 @@ }, |
@@ -5,2 +5,4 @@ > Note: cli-kit is under development. | ||
| [](https://greenkeeper.io/) | ||
| [![NPM Version][npm-image]][npm-url] | ||
@@ -21,11 +23,14 @@ [![NPM Downloads][downloads-image]][downloads-url] | ||
| * Auto-generated help | ||
| * CLI template engine | ||
| * Markdown/kramdown rendering | ||
| * Extension support (e.g. wrap external CLI's) | ||
| ## Installation | ||
| yarn add cli-kit --save | ||
| ```bash | ||
| yarn add cli-kit --save | ||
| # or | ||
| npm i cli-kit --save | ||
| ``` | ||
| or | ||
| npm i cli-kit --save | ||
| ## Usage | ||
@@ -286,10 +291,10 @@ | ||
| | Options support | :white_check_mark: | :white_check_mark: | :white_check_mark: | | :white_check_mark: | | | | | | | | | ||
| | Option validation | Coming soon! | :white_check_mark: | | | :white_check_mark: | | | | | | | | | ||
| | Option validation | :white_check_mark: | :white_check_mark: | | | :white_check_mark: | | | | | | | | | ||
| | Default values | :white_check_mark: | | | | | | | | | | | | | ||
| | Flags support | :white_check_mark: | :white_check_mark: | :white_check_mark: | | :x: | | | | | | | | | ||
| | Argument support | :white_check_mark: | :white_check_mark: | :white_check_mark: | | :white_check_mark: | | | | | | | | | ||
| | Argument validation | Coming soon! | :white_check_mark: | | | :white_check_mark: | | | | | | | | | ||
| | Argument validation | :white_check_mark: | :white_check_mark: | | | :white_check_mark: | | | | | | | | | ||
| | Dynamic command hierarchies | :white_check_mark: | | | | | | | | | | | | | ||
| | Automatic parsed value data type coercion | :white_check_mark: | :white_check_mark: | Numbers only | | Numbers and Booleans | | | | | | | | | ||
| | Parsed value transforming | Coming soon! | | | | | | | | | | | | | ||
| | Parsed value transforming | :white_check_mark: | | | | | | | | | | | | | ||
| | Auto-generated help screen | :white_check_mark: | :white_check_mark: | | | :x: | | :white_check_mark: | | | | | | | ||
@@ -303,3 +308,3 @@ | Help exits with code | :white_check_mark: | | | | | | :white_check_mark: | | | | | | | ||
| | --------------------------------------------- | ------------------ | ------------------ | ------------------ | ------------------ | ------------------------------------- | ------------------ | ------------------ | | ||
| | Actively maintained <br> (within last year) | :white_check_mark: | :white_check_mark: | | :white_check_mark: | :white_check_mark: | :white_check_mark: | :x: | | ||
| | Actively maintained <br> (within last year) | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :x: | | ||
| | Open Source | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | :white_check_mark: | | ||
@@ -306,0 +311,0 @@ | Language | JavaScript | JavaScript | TypeScript | JavaScript | JavaScript | JavaScript | JavaScript | |
New alerts
AI-detected possible typosquat
Supply chain riskAI has identified this package as a potential typosquat of a more popular package. This suggests that the package may be intentionally mimicking another package's name, description, or other metadata.
Found 1 instance in 1 package
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Uses eval
Supply chain riskPackage uses dynamic code execution (e.g., eval()), which is a dangerous practice. This can prevent the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.
Found 1 instance in 1 package
Environment variable access
Supply chain riskPackage accesses environment variables, which may be a sign of credential stuffing or data theft.
Found 1 instance in 1 package
Improved metrics
- Total package byte prevSize
- increased by1.66%
463948
- Number of package files
- increased by42.11%
27
- Lines of code
- increased by58.12%
4965
- Number of lines in readme file
- increased by1.53%
332
Worsened metrics
- Dependency count
- increased by42.86%
10
- Number of low supply chain risk alerts
- increased by80%
9
- Number of medium supply chain risk alerts
- increased by300%
4
Dependency changes
+ Addedfast-levenshtein@^2.0.6
+ Addedkramed@^0.5.6
+ Addedmarked-terminal@^3.0.0
+ Addedansi-escapes@3.2.0(transitive)
+ Addedansicolors@0.3.2(transitive)
+ Addedcardinal@2.1.1(transitive)
+ Addedcli-table@0.3.11(transitive)
+ Addedcolors@1.0.3(transitive)
+ Addedesprima@4.0.1(transitive)
+ Addedfast-levenshtein@2.0.6(transitive)
+ Addedfind-up@3.0.0(transitive)
+ Addedhas-flag@2.0.0(transitive)
+ Addedkramed@0.5.6(transitive)
+ Addedlocate-path@3.0.0(transitive)
+ Addedlodash@4.17.21(transitive)
+ Addedmarked@0.7.0(transitive)
+ Addedmarked-terminal@3.3.0(transitive)
+ Addednode-emoji@1.11.0(transitive)
+ Addedp-limit@2.3.0(transitive)
+ Addedp-locate@3.0.0(transitive)
+ Addedp-try@2.2.0(transitive)
+ Addedpkg-dir@3.0.0(transitive)
+ Addedredeyed@2.1.1(transitive)
+ Addedsupports-hyperlinks@1.0.1(transitive)
- Removedfind-up@2.1.0(transitive)
- Removedlocate-path@2.0.0(transitive)
- Removedp-limit@1.3.0(transitive)
- Removedp-locate@2.0.0(transitive)
- Removedp-try@1.0.0(transitive)
- Removedpkg-dir@2.0.0(transitive)
Updatedhook-emitter@^3.0.2
Updatedpkg-dir@^3.0.0
Updatedsnooplogg@^1.12.1
Updatedsource-map-support@^0.5.9