initial

node_modules/command-line-args/lib/argv-parser.js

@@ -0,0 +1,139 @@
+'use strict'
+const argvTools = require('argv-tools')
+
+/**
+ * @module argv-parser
+ */
+
+/**
+ * @alias module:argv-parser
+ */
+class ArgvParser {
+  /**
+   * @param {OptionDefinitions} - Definitions array
+   * @param {object} [options] - Options
+   * @param {string[]} [options.argv] - Overrides `process.argv`
+   * @param {boolean} [options.stopAtFirstUnknown] -
+   */
+  constructor (definitions, options) {
+    this.options = Object.assign({}, options)
+    const Definitions = require('./option-definitions')
+    /**
+     * Option Definitions
+     */
+    this.definitions = Definitions.from(definitions)
+
+    /**
+     * Argv
+     */
+    this.argv = argvTools.ArgvArray.from(this.options.argv)
+    if (this.argv.hasCombinedShortOptions()) {
+      const findReplace = require('find-replace')
+      findReplace(this.argv, argvTools.re.combinedShort, arg => {
+        arg = arg.slice(1)
+        return arg.split('').map(letter => ({ origArg: `-${arg}`, arg: '-' + letter }))
+      })
+    }
+  }
+
+  /**
+   * Yields one `{ event, name, value, arg, def }` argInfo object for each arg in `process.argv` (or `options.argv`).
+   */
+  * [Symbol.iterator] () {
+    const definitions = this.definitions
+    const t = require('typical')
+
+    let def
+    let value
+    let name
+    let event
+    let singularDefaultSet = false
+    let unknownFound = false
+    let origArg
+
+    for (let arg of this.argv) {
+      if (t.isPlainObject(arg)) {
+        origArg = arg.origArg
+        arg = arg.arg
+      }
+
+      if (unknownFound && this.options.stopAtFirstUnknown) {
+        yield { event: 'unknown_value', arg, name: '_unknown', value: undefined }
+        continue
+      }
+
+      /* handle long or short option */
+      if (argvTools.isOption(arg)) {
+        def = definitions.get(arg)
+        value = undefined
+        if (def) {
+          value = def.isBoolean() ? true : null
+          event = 'set'
+        } else {
+          event = 'unknown_option'
+        }
+
+      /* handle --option-value notation */
+    } else if (argvTools.isOptionEqualsNotation(arg)) {
+        const matches = arg.match(argvTools.re.optEquals)
+        def = definitions.get(matches[1])
+        if (def) {
+          if (def.isBoolean()) {
+            yield { event: 'unknown_value', arg, name: '_unknown', value, def }
+            event = 'set'
+            value = true
+          } else {
+            event = 'set'
+            value = matches[2]
+          }
+        } else {
+          event = 'unknown_option'
+        }
+
+      /* handle value */
+    } else if (argvTools.isValue(arg)) {
+        if (def) {
+          value = arg
+          event = 'set'
+        } else {
+          /* get the defaultOption */
+          def = this.definitions.getDefault()
+          if (def && !singularDefaultSet) {
+            value = arg
+            event = 'set'
+          } else {
+            event = 'unknown_value'
+            def = undefined
+          }
+        }
+      }
+
+      name = def ? def.name : '_unknown'
+      const argInfo = { event, arg, name, value, def }
+      if (origArg) {
+        argInfo.subArg = arg
+        argInfo.arg = origArg
+      }
+      yield argInfo
+
+      /* unknownFound logic */
+      if (name === '_unknown') unknownFound = true
+
+      /* singularDefaultSet logic */
+      if (def && def.defaultOption && !def.isMultiple() && event === 'set') singularDefaultSet = true
+
+      /* reset values once consumed and yielded */
+      if (def && def.isBoolean()) def = undefined
+      /* reset the def if it's a singular which has been set */
+      if (def && !def.multiple && t.isDefined(value) && value !== null) {
+        def = undefined
+      }
+      value = undefined
+      event = undefined
+      name = undefined
+      origArg = undefined
+    }
+  }
+}
+
+module.exports = ArgvParser

node_modules/command-line-args/lib/option-definition.js

@@ -0,0 +1,265 @@
+'use strict'
+const t = require('typical')
+
+/**
+ * @module option-definition
+ */
+
+/**
+ * Describes a command-line option. Additionally, if generating a usage guide with [command-line-usage](https://github.com/75lb/command-line-usage) you could optionally add `description` and `typeLabel` properties to each definition.
+ *
+ * @alias module:option-definition
+ * @typicalname option
+ */
+class OptionDefinition {
+  constructor (definition) {
+    /**
+    * The only required definition property is `name`, so the simplest working example is
+    * ```js
+    * const optionDefinitions = [
+    *   { name: 'file' },
+    *   { name: 'depth' }
+    * ]
+    * ```
+    *
+    * Where a `type` property is not specified it will default to `String`.
+    *
+    * | #   | Command line args | .parse() output |
+    * | --- | -------------------- | ------------ |
+    * | 1   | `--file` | `{ file: null }` |
+    * | 2   | `--file lib.js` | `{ file: 'lib.js' }` |
+    * | 3   | `--depth 2` | `{ depth: '2' }` |
+    *
+    * Unicode option names and aliases are valid, for example:
+    * ```js
+    * const optionDefinitions = [
+    *   { name: 'один' },
+    *   { name: '两' },
+    *   { name: 'три', alias: 'т' }
+    * ]
+    * ```
+    * @type {string}
+    */
+    this.name = definition.name
+
+    /**
+    * The `type` value is a setter function (you receive the output from this), enabling you to be specific about the type and value received.
+    *
+    * The most common values used are `String` (the default), `Number` and `Boolean` but you can use a custom function, for example:
+    *
+    * ```js
+    * const fs = require('fs')
+    *
+    * class FileDetails {
+    *   constructor (filename) {
+    *     this.filename = filename
+    *     this.exists = fs.existsSync(filename)
+    *   }
+    * }
+    *
+    * const cli = commandLineArgs([
+    *   { name: 'file', type: filename => new FileDetails(filename) },
+    *   { name: 'depth', type: Number }
+    * ])
+    * ```
+    *
+    * | #   | Command line args| .parse() output |
+    * | --- | ----------------- | ------------ |
+    * | 1   | `--file asdf.txt` | `{ file: { filename: 'asdf.txt', exists: false } }` |
+    *
+    * The `--depth` option expects a `Number`. If no value was set, you will receive `null`.
+    *
+    * | #   | Command line args | .parse() output |
+    * | --- | ----------------- | ------------ |
+    * | 2   | `--depth` | `{ depth: null }` |
+    * | 3   | `--depth 2` | `{ depth: 2 }` |
+    *
+    * @type {function}
+    * @default String
+    */
+    this.type = definition.type || String
+
+    /**
+    * getopt-style short option names. Can be any single character (unicode included) except a digit or hyphen.
+    *
+    * ```js
+    * const optionDefinitions = [
+    *   { name: 'hot', alias: 'h', type: Boolean },
+    *   { name: 'discount', alias: 'd', type: Boolean },
+    *   { name: 'courses', alias: 'c' , type: Number }
+    * ]
+    * ```
+    *
+    * | #   | Command line | .parse() output |
+    * | --- | ------------ | ------------ |
+    * | 1   | `-hcd` | `{ hot: true, courses: null, discount: true }` |
+    * | 2   | `-hdc 3` | `{ hot: true, discount: true, courses: 3 }` |
+    *
+    * @type {string}
+    */
+    this.alias = definition.alias
+
+    /**
+    * Set this flag if the option takes a list of values. You will receive an array of values, each passed through the `type` function (if specified).
+    *
+    * ```js
+    * const optionDefinitions = [
+    *   { name: 'files', type: String, multiple: true }
+    * ]
+    * ```
+    *
+    * Note, examples 1 and 3 below demonstrate "greedy" parsing which can be disabled by using `lazyMultiple`.
+    *
+    * | #   | Command line | .parse() output |
+    * | --- | ------------ | ------------ |
+    * | 1   | `--files one.js two.js` | `{ files: [ 'one.js', 'two.js' ] }` |
+    * | 2   | `--files one.js --files two.js` | `{ files: [ 'one.js', 'two.js' ] }` |
+    * | 3   | `--files *` | `{ files: [ 'one.js', 'two.js' ] }` |
+    *
+    * @type {boolean}
+    */
+    this.multiple = definition.multiple
+
+    /**
+     * Identical to `multiple` but with greedy parsing disabled.
+     *
+     * ```js
+     * const optionDefinitions = [
+     *   { name: 'files', lazyMultiple: true },
+     *   { name: 'verbose', alias: 'v', type: Boolean, lazyMultiple: true }
+     * ]
+     * ```
+     *
+     * | #   | Command line | .parse() output |
+     * | --- | ------------ | ------------ |
+     * | 1   | `--files one.js --files two.js` | `{ files: [ 'one.js', 'two.js' ] }` |
+     * | 2   | `-vvv` | `{ verbose: [ true, true, true ] }` |
+     *
+     * @type {boolean}
+     */
+    this.lazyMultiple = definition.lazyMultiple
+
+    /**
+    * Any values unaccounted for by an option definition will be set on the `defaultOption`. This flag is typically set on the most commonly-used option to make for more concise usage (i.e. `$ example *.js` instead of `$ example --files *.js`).
+    *
+    * ```js
+    * const optionDefinitions = [
+    *   { name: 'files', multiple: true, defaultOption: true }
+    * ]
+    * ```
+    *
+    * | #   | Command line | .parse() output |
+    * | --- | ------------ | ------------ |
+    * | 1   | `--files one.js two.js` | `{ files: [ 'one.js', 'two.js' ] }` |
+    * | 2   | `one.js two.js` | `{ files: [ 'one.js', 'two.js' ] }` |
+    * | 3   | `*` | `{ files: [ 'one.js', 'two.js' ] }` |
+    *
+    * @type {boolean}
+    */
+    this.defaultOption = definition.defaultOption
+
+    /**
+    * An initial value for the option.
+    *
+    * ```js
+    * const optionDefinitions = [
+    *   { name: 'files', multiple: true, defaultValue: [ 'one.js' ] },
+    *   { name: 'max', type: Number, defaultValue: 3 }
+    * ]
+    * ```
+    *
+    * | #   | Command line | .parse() output |
+    * | --- | ------------ | ------------ |
+    * | 1   |  | `{ files: [ 'one.js' ], max: 3 }` |
+    * | 2   | `--files two.js` | `{ files: [ 'two.js' ], max: 3 }` |
+    * | 3   | `--max 4` | `{ files: [ 'one.js' ], max: 4 }` |
+    *
+    * @type {*}
+    */
+    this.defaultValue = definition.defaultValue
+
+    /**
+    * When your app has a large amount of options it makes sense to organise them in groups.
+    *
+    * There are two automatic groups: `_all` (contains all options) and `_none` (contains options without a `group` specified in their definition).
+    *
+    * ```js
+    * const optionDefinitions = [
+    *   { name: 'verbose', group: 'standard' },
+    *   { name: 'help', group: [ 'standard', 'main' ] },
+    *   { name: 'compress', group: [ 'server', 'main' ] },
+    *   { name: 'static', group: 'server' },
+    *   { name: 'debug' }
+    * ]
+    * ```
+    *
+    *<table>
+    *  <tr>
+    *    <th>#</th><th>Command Line</th><th>.parse() output</th>
+    *  </tr>
+    *  <tr>
+    *    <td>1</td><td><code>--verbose</code></td><td><pre><code>
+    *{
+    *  _all: { verbose: true },
+    *  standard: { verbose: true }
+    *}
+    *</code></pre></td>
+    *  </tr>
+    *  <tr>
+    *    <td>2</td><td><code>--debug</code></td><td><pre><code>
+    *{
+    *  _all: { debug: true },
+    *  _none: { debug: true }
+    *}
+    *</code></pre></td>
+    *  </tr>
+    *  <tr>
+    *    <td>3</td><td><code>--verbose --debug --compress</code></td><td><pre><code>
+    *{
+    *  _all: {
+    *    verbose: true,
+    *    debug: true,
+    *    compress: true
+    *  },
+    *  standard: { verbose: true },
+    *  server: { compress: true },
+    *  main: { compress: true },
+    *  _none: { debug: true }
+    *}
+    *</code></pre></td>
+    *  </tr>
+    *  <tr>
+    *    <td>4</td><td><code>--compress</code></td><td><pre><code>
+    *{
+    *  _all: { compress: true },
+    *  server: { compress: true },
+    *  main: { compress: true }
+    *}
+    *</code></pre></td>
+    *  </tr>
+    *</table>
+    *
+    * @type {string|string[]}
+    */
+    this.group = definition.group
+
+    /* pick up any remaining properties */
+    for (let prop in definition) {
+      if (!this[prop]) this[prop] = definition[prop]
+    }
+  }
+
+  isBoolean () {
+    return this.type === Boolean || (t.isFunction(this.type) && this.type.name === 'Boolean')
+  }
+  isMultiple () {
+    return this.multiple || this.lazyMultiple
+  }
+
+  static create (def) {
+    const result = new this(def)
+    return result
+  }
+}
+
+module.exports = OptionDefinition

node_modules/command-line-args/lib/option-definitions.js

@@ -0,0 +1,170 @@
+'use strict'
+const arrayify = require('array-back')
+const argvTools = require('argv-tools')
+const t = require('typical')
+
+/**
+ * @module option-definitions
+ */
+
+/**
+ * @alias module:option-definitions
+ */
+class Definitions extends Array {
+  /**
+   * validate option definitions
+   * @returns {string}
+   */
+  validate () {
+    const someHaveNoName = this.some(def => !def.name)
+    if (someHaveNoName) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Invalid option definitions: the `name` property is required on each definition'
+      )
+    }
+
+    const someDontHaveFunctionType = this.some(def => def.type && typeof def.type !== 'function')
+    if (someDontHaveFunctionType) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Invalid option definitions: the `type` property must be a setter fuction (default: `Boolean`)'
+      )
+    }
+
+    let invalidOption
+
+    const numericAlias = this.some(def => {
+      invalidOption = def
+      return t.isDefined(def.alias) && t.isNumber(def.alias)
+    })
+    if (numericAlias) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Invalid option definition: to avoid ambiguity an alias cannot be numeric [--' + invalidOption.name + ' alias is -' + invalidOption.alias + ']'
+      )
+    }
+
+    const multiCharacterAlias = this.some(def => {
+      invalidOption = def
+      return t.isDefined(def.alias) && def.alias.length !== 1
+    })
+    if (multiCharacterAlias) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Invalid option definition: an alias must be a single character'
+      )
+    }
+
+    const hypenAlias = this.some(def => {
+      invalidOption = def
+      return def.alias === '-'
+    })
+    if (hypenAlias) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Invalid option definition: an alias cannot be "-"'
+      )
+    }
+
+    const duplicateName = hasDuplicates(this.map(def => def.name))
+    if (duplicateName) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Two or more option definitions have the same name'
+      )
+    }
+
+    const duplicateAlias = hasDuplicates(this.map(def => def.alias))
+    if (duplicateAlias) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Two or more option definitions have the same alias'
+      )
+    }
+
+    const duplicateDefaultOption = hasDuplicates(this.map(def => def.defaultOption))
+    if (duplicateDefaultOption) {
+      halt(
+        'INVALID_DEFINITIONS',
+        'Only one option definition can be the defaultOption'
+      )
+    }
+
+    const defaultBoolean = this.some(def => {
+      invalidOption = def
+      return def.isBoolean() && def.defaultOption
+    })
+    if (defaultBoolean) {
+      halt(
+        'INVALID_DEFINITIONS',
+        `A boolean option ["${invalidOption.name}"] can not also be the defaultOption.`
+      )
+    }
+  }
+
+  /**
+   * Get definition by option arg (e.g. `--one` or `-o`)
+   * @param {string}
+   * @returns {Definition}
+   */
+  get (arg) {
+    if (argvTools.isOption(arg)) {
+      return argvTools.re.short.test(arg)
+        ? this.find(def => def.alias === argvTools.getOptionName(arg))
+        : this.find(def => def.name === argvTools.getOptionName(arg))
+    } else {
+      return this.find(def => def.name === arg)
+    }
+  }
+
+  getDefault () {
+    return this.find(def => def.defaultOption === true)
+  }
+
+  isGrouped () {
+    return this.some(def => def.group)
+  }
+
+  whereGrouped () {
+    return this.filter(containsValidGroup)
+  }
+  whereNotGrouped () {
+    return this.filter(def => !containsValidGroup(def))
+  }
+  whereDefaultValueSet () {
+    return this.filter(def => t.isDefined(def.defaultValue))
+  }
+
+  static from (definitions) {
+    if (definitions instanceof this) return definitions
+    const Definition = require('./option-definition')
+    const result = super.from(arrayify(definitions), def => Definition.create(def))
+    result.validate()
+    return result
+  }
+}
+
+function halt (name, message) {
+  const err = new Error(message)
+  err.name = name
+  throw err
+}
+
+function containsValidGroup (def) {
+  return arrayify(def.group).some(group => group)
+}
+
+function hasDuplicates (array) {
+  const items = {}
+  for (let i = 0; i < array.length; i++) {
+    const value = array[i]
+    if (items[value]) {
+      return true
+    } else {
+      if (t.isDefined(value)) items[value] = true
+    }
+  }
+}
+
+module.exports = Definitions

node_modules/command-line-args/lib/option-flag.js

@@ -0,0 +1,14 @@
+'use strict'
+const Option = require('./option')
+
+class FlagOption extends Option {
+  set (val) {
+    super.set(true)
+  }
+
+  static create (def) {
+    return new this(def)
+  }
+}
+
+module.exports = FlagOption

node_modules/command-line-args/lib/option.js

@@ -0,0 +1,83 @@
+'use strict'
+const _value = new WeakMap()
+const arrayify = require('array-back')
+const t = require('typical')
+const Definition = require('./option-definition')
+
+/**
+ * Encapsulates behaviour (defined by an OptionDefinition) when setting values
+ */
+class Option {
+  constructor (definition) {
+    this.definition = new Definition(definition)
+    this.state = null /* set or default */
+    this.resetToDefault()
+  }
+
+  get () {
+    return _value.get(this)
+  }
+
+  set (val) {
+    this._set(val, 'set')
+  }
+
+  _set (val, state) {
+    const def = this.definition
+    if (def.isMultiple()) {
+      /* don't add null or undefined to a multiple */
+      if (val !== null && val !== undefined) {
+        const arr = this.get()
+        if (this.state === 'default') arr.length = 0
+        arr.push(def.type(val))
+        this.state = state
+      }
+    } else {
+      /* throw if already set on a singlar defaultOption */
+      if (!def.isMultiple() && this.state === 'set') {
+        const err = new Error(`Singular option already set [${this.definition.name}=${this.get()}]`)
+        err.name = 'ALREADY_SET'
+        err.value = val
+        err.optionName = def.name
+        throw err
+      } else if (val === null || val === undefined) {
+        _value.set(this, val)
+        // /* required to make 'partial: defaultOption with value equal to defaultValue 2' pass */
+        // if (!(def.defaultOption && !def.isMultiple())) {
+        //   this.state = state
+        // }
+      } else {
+        _value.set(this, def.type(val))
+        this.state = state
+      }
+    }
+  }
+
+  resetToDefault () {
+    if (t.isDefined(this.definition.defaultValue)) {
+      if (this.definition.isMultiple()) {
+        _value.set(this, arrayify(this.definition.defaultValue).slice())
+      } else {
+        _value.set(this, this.definition.defaultValue)
+      }
+    } else {
+      if (this.definition.isMultiple()) {
+        _value.set(this, [])
+      } else {
+        _value.set(this, null)
+      }
+    }
+    this.state = 'default'
+  }
+
+  static create (definition) {
+    definition = new Definition(definition)
+    if (definition.isBoolean()) {
+      return require('./option-flag').create(definition)
+    } else {
+      return new this(definition)
+    }
+  }
+}
+
+module.exports = Option

node_modules/command-line-args/lib/output-grouped.js

@@ -0,0 +1,41 @@
+'use strict'
+const Output = require('./output')
+
+class GroupedOutput extends Output {
+  toObject (options) {
+    const arrayify = require('array-back')
+    const t = require('typical')
+    const camelCase = require('lodash.camelcase')
+    const superOutputNoCamel = super.toObject({ skipUnknown: options.skipUnknown })
+    const superOutput = super.toObject(options)
+    const unknown = superOutput._unknown
+    delete superOutput._unknown
+    const grouped = {
+      _all: superOutput
+    }
+    if (unknown && unknown.length) grouped._unknown = unknown
+
+    this.definitions.whereGrouped().forEach(def => {
+      const name = options.camelCase ? camelCase(def.name) : def.name
+      const outputValue = superOutputNoCamel[def.name]
+      for (const groupName of arrayify(def.group)) {
+        grouped[groupName] = grouped[groupName] || {}
+        if (t.isDefined(outputValue)) {
+          grouped[groupName][name] = outputValue
+        }
+      }
+    })
+
+    this.definitions.whereNotGrouped().forEach(def => {
+      const name = options.camelCase ? camelCase(def.name) : def.name
+      const outputValue = superOutputNoCamel[def.name]
+      if (t.isDefined(outputValue)) {
+        if (!grouped._none) grouped._none = {}
+        grouped._none[name] = outputValue
+      }
+    })
+    return grouped
+  }
+}
+
+module.exports = GroupedOutput

node_modules/command-line-args/lib/output.js

@@ -0,0 +1,39 @@
+'use strict'
+const Option = require('./option')
+
+/**
+ * A map of { DefinitionNameString: Option }. By default, an Output has an `_unknown` property and any options with defaultValues.
+ */
+class Output extends Map {
+  constructor (definitions) {
+    super()
+    const Definitions = require('./option-definitions')
+    /**
+     * @type {OptionDefinitions}
+     */
+    this.definitions = Definitions.from(definitions)
+
+    /* by default, an Output has an `_unknown` property and any options with defaultValues */
+    this.set('_unknown', Option.create({ name: '_unknown', multiple: true }))
+    for (const def of this.definitions.whereDefaultValueSet()) {
+      this.set(def.name, Option.create(def))
+    }
+  }
+
+  toObject (options) {
+    const camelCase = require('lodash.camelcase')
+    options = options || {}
+    const output = {}
+    for (const item of this) {
+      const name = options.camelCase && item[0] !== '_unknown' ? camelCase(item[0]) : item[0]
+      const option = item[1]
+      if (name === '_unknown' && !option.get().length) continue
+      output[name] = option.get()
+    }
+
+    if (options.skipUnknown) delete output._unknown
+    return output
+  }
+}
+
+module.exports = Output