optionator

- update `levn` dependency - supplying a float value to an option with type `Int` now throws an error, instead of silently converting to an `Int`

- fix bug with use of `defaults` and `concatRepeatedArrays` or `mergeRepeatedObjects`

- added `concatrepeatedarrays` option: `oneValuePerFlag`, only allows one array value per flag

- added `parseArgv` which takes an array and parses with the first two items sliced off

- use of `concatRepeatedArrays` and `mergeRepeatedObjects` at the top level is deprecated, use it as either a per-option option, or set them in the `defaults` object to set them for all objects

- added `defaults` lib-option flag, allowing one to set default properties for all options

- added `concatRepeatedArrays` and `mergeRepeatedObjects` as option level properties, allowing you to turn this feature on for specific options only

- `Boolean` flags with `default: 'true'`, and no short aliases, will by default show the `--no` version in help

- use just Levenshtein string compare algo rather than Levenshtein Damerau to due dependency license issue

- add dependency checks to options - added `dependsOn` as an option property

- add interpolation for `prepend` and `append` text with new `generateHelp` option, `interpolate`

  var VERSION, ref$, id, map, compact, any, groupBy, partition, chars, isItNaN, keys, Obj, camelize, deepIs, closestString, nameToRaw, dasherize, naturalJoin, generateHelp, generateHelpForOption, parsedTypeCheck, parseType, parseLevn, camelizeKeys, parseString, main, toString$ = {}.toString, slice$ = [].slice;

  ref$ = require('prelude-ls'), id = ref$.id, map = ref$.map, compact = ref$.compact, any = ref$.any, groupBy = ref$.groupBy, partition = ref$.partition, chars = ref$.chars, isItNaN = ref$.isItNaN, keys = ref$.keys, Obj = ref$.Obj, camelize = ref$.camelize;

  ref$ = require('./util'), closestString = ref$.closestString, nameToRaw = ref$.nameToRaw, dasherize = ref$.dasherize, naturalJoin = ref$.naturalJoin;

  ref$ = require('./help'), generateHelp = ref$.generateHelp, generateHelpForOption = ref$.generateHelpForOption;

  ref$ = require('type-check'), parsedTypeCheck = ref$.parsedTypeCheck, parseType = ref$.parseType;

  parseLevn = require('levn').parsedTypeParse;

    var assignOpt, regex, replaceRegex, result;

    assignOpt = '--?[a-zA-Z][-a-z-A-Z0-9]*=';

    regex = RegExp('(?:' + assignOpt + ')?(?:\'(?:\\\\\'|[^\'])+\'|"(?:\\\\"|[^"])+")|[^\'"\\s]+', 'g');

    replaceRegex = RegExp('^(' + assignOpt + ')?[\'"]([\\s\\S]*)[\'"]$');

      return it.replace(replaceRegex, '$1$2');

    var opts, defaults, required, traverse, getOption, parse;

    if (toString$.call(libOptions.stdout).slice(8, -1) === 'Undefined') {

      libOptions.stdout = process.stdout;

    libOptions.positionalAnywhere == null && (libOptions.positionalAnywhere = true);

    libOptions.typeAliases == null && (libOptions.typeAliases = {});

    libOptions.defaults == null && (libOptions.defaults = {});

    if (libOptions.concatRepeatedArrays != null) {

      libOptions.defaults.concatRepeatedArrays = libOptions.concatRepeatedArrays;

    if (libOptions.mergeRepeatedObjects != null) {

      libOptions.defaults.mergeRepeatedObjects = libOptions.mergeRepeatedObjects;

      var i$, len$, option, name, k, ref$, v, type, that, e, parsedPossibilities, parsedType, j$, len1$, possibility, rawDependsType, dependsOpts, dependsType, cra, alias, shortNames, longNames;

      if (toString$.call(options).slice(8, -1) !== 'Array') {

        throw new Error('No options defined.');

      for (i$ = 0, len$ = options.length; i$ < len$; ++i$) {

            throw new Error("Option '" + name + "' already defined.");

          for (k in ref$ = libOptions.defaults) {

            option[k] == null && (option[k] = v);

          if (option.type === 'Boolean') {

            option.boolean == null && (option.boolean = true);

          if (option.parsedType == null) {

              throw new Error("No type defined for option '" + name + "'.");

              type = (that = libOptions.typeAliases[option.type]) != null

              option.parsedType = parseType(type);

              throw new Error("Option '" + name + "': Error parsing type '" + option.type + "': " + e.message);

              defaults[name] = parseLevn(option.parsedType, option['default']);

              throw new Error("Option '" + name + "': Error parsing default value '" + option['default'] + "' for type '" + option.type + "': " + e.message);

          if (option['enum'] && !option.parsedPossiblities) {

            parsedType = option.parsedType;

            for (j$ = 0, len1$ = (ref$ = option['enum']).length; j$ < len1$; ++j$) {

                parsedPossibilities.push(parseLevn(parsedType, possibility));

                throw new Error("Option '" + name + "': Error parsing enum value '" + possibility + "' for type '" + option.type + "': " + e.message);

            option.parsedPossibilities = parsedPossibilities;

              ref$ = [].concat(option.dependsOn), rawDependsType = ref$[0], dependsOpts = slice$.call(ref$, 1);

              dependsType = rawDependsType.toLowerCase();

  "author": "George Zahariev <z@georgezahariev.com>",

  "description": "option parsing and help generation",

  "homepage": "https://github.com/gkz/optionator",

  "bugs": "https://github.com/gkz/optionator/issues",

    "url": "git://github.com/gkz/optionator.git"

Optionator is a JavaScript option parsing and help generation library used by [eslint](http://eslint.org), [Grasp](http://graspjs.com), [LiveScript](http://livescript.net), [esmangle](https://github.com/estools/esmangle), [escodegen](https://github.com/estools/escodegen), and [many more](https://www.npmjs.com/browse/depended/optionator).

For an online demo, check out the [Grasp online demo](http://www.graspjs.com/#demo).

[About](#about) &middot; [Usage](#usage) &middot; [Settings Format](#settings-format) &middot; [Argument Format](#argument-format)

The  problem with other option parsers, such as `yargs` or `minimist`, is they just accept all input, valid or not.

With Optionator, if you mistype an option, it will give you an error (with a suggestion for what you meant).

If you give the wrong type of argument for an option, it will give you an error rather than supplying the wrong input to your application.

    Invalid option '--halp' - perhaps you meant '--help'?

    Invalid value for option 'count' - expected type Int, received value: str.

Other helpful features include reformatting the help text based on the size of the console, so that it fits even if the console is narrow, and accepting not just an array (eg. process.argv), but a string or object as well, making things like testing much easier.

Optionator uses [type-check](https://github.com/gkz/type-check) and [levn](https://github.com/gkz/levn) behind the scenes to cast and verify input according the specified types.

For updates on Optionator, [follow me on twitter](https://twitter.com/gkzahariev).

`require('optionator');` returns a function. It has one property, `VERSION`, the current version of the library as a string. This function is called with an object specifying your options and other information, see the [settings format section](#settings-format). This in turn returns an object with three properties, `parse`, `parseArgv`, `generateHelp`, and `generateHelpForOption`, which are all functions.

var options = optionator.parseArgv(process.argv);

    console.log(optionator.generateHelp());

`parse` processes the `input` according to your settings, and returns an object with the results.

* input - `[String] | Object | String` - the input you wish to parse

* parseOptions - `{slice: Int}` - all options optional

    - `slice` specifies how much to slice away from the beginning if the input is an array or string - by default `0` for string, `2` for array (works with `process.argv`)

`Object` - the parsed options, each key is a camelCase version of the option name (specified in dash-case), and each value is the processed value for that option. Positional values are in an array under the `_` key.

parse(['node', 't.js', '--count', '2', 'positional']); // {count: 2, _: ['positional']}

parse('--count 2 positional');                         // {count: 2, _: ['positional']}

parse({count: 2, _:['positional']});                   // {count: 2, _: ['positional']}

`parseArgv` works exactly like `parse`, but only for array input and it slices off the first two elements.

* input - `[String]` - the input you wish to parse

`generateHelp` produces help text based on your settings.

* helpOptions - `{showHidden: Boolean, interpolate: Object}` - all options optional

    - `showHidden` specifies whether to show options with `hidden: true` specified, by default it is `false`

    - `interpolate` specify data to be interpolated in `prepend` and `append` text, `{{key}}` is the format - eg. `generateHelp({interpolate:{version: '0.4.2'}})`, will change this `append` text: `Version {{version}}` to `Version 0.4.2`

`generateHelpForOption` produces expanded help text for the specified with `optionName` option. If an `example` was specified for the option, it will be displayed,  and if a `longDescription` was specified, it will display that instead of the `description`.

* optionName - `String` - the name of the option to display

`String` - the generated help text for the option

		@@ -0,1 +1,4 @@
		# 0.8.1
		- update `fast-levenshtein` dependency

		# 0.8.0
		@@ -2,0 +5,0 @@ - update `levn` dependency - supplying a float value to an option with type `Int` now throws an error, instead of silently converting to an `Int`

		// Generated by LiveScript 1.4.0
		(function(){
		var VERSION, ref$, id, map, compact, any, groupBy, partition, chars, isItNaN, keys, Obj, camelize, deepIs, closestString, nameToRaw, dasherize, naturalJoin, generateHelp, generateHelpForOption, parsedTypeCheck, parseType, parseLevn, camelizeKeys, parseString, main, toString$ = {}.toString, slice$ = [].slice;
		VERSION = '0.8.0';
		VERSION = '0.8.1';
		ref$ = require('prelude-ls'), id = ref$.id, map = ref$.map, compact = ref$.compact, any = ref$.any, groupBy = ref$.groupBy, partition = ref$.partition, chars = ref$.chars, isItNaN = ref$.isItNaN, keys = ref$.keys, Obj = ref$.Obj, camelize = ref$.camelize;
		@@ -6,0 +6,0 @@ deepIs = require('deep-is');

		{
		"name": "optionator",
		"version": "0.8.0",
		"version": "0.8.1",
		"author": "George Zahariev <z@georgezahariev.com>",
		@@ -37,3 +37,3 @@ "description": "option parsing and help generation",
		"levn": "~0.3.0",
		"fast-levenshtein": "~1.0.7"
		"fast-levenshtein": "^1.1.0"
		},
		@@ -40,0 +40,0 @@ "devDependencies": {

		@@ -26,3 +26,3 @@ # Optionator

		MIT license. Version 0.8.0
		MIT license. Version 0.8.1

		@@ -29,0 +29,0 @@ npm install optionator

Improved metrics

Dependency changes