refactor!: restructure configuration to take options bag

README.md

@@ -69,19 +69,16 @@ process.mainArgs = process.argv.slice(process._exec ? 1 : 2)
 
 ----
 
-## 💡 `util.parseArgs([argv][, options])` Proposal
+## 💡 `util.parseArgs([config])` Proposal
 
-* `argv` {string[]} (Optional) Array of argument strings; defaults
-  to [`process.mainArgs`](process_argv)
-* `options` {Object} (Optional) The `options` parameter is an
+* `config` {Object} (Optional) The `config` parameter is an
   object supporting the following properties:
-  * `withValue` {string[]} (Optional) An `Array` of argument
-    strings which expect a value to be defined in `argv` (see [Options][]
-    for details)
-  * `multiples` {string[]} (Optional) An `Array` of argument
-    strings which, when appearing multiple times in `argv`, will be concatenated 
-into an `Array`
-  * `short` {Object} (Optional) An `Object` of key, value pairs of strings which map a "short" alias to an argument; When appearing multiples times in `argv`; Respects `withValue` & `multiples`
+  * `argv` {string[]} (Optional) Array of argument strings; defaults
+    to [`process.mainArgs`](process_argv)
+  * `options` {Object} (Optional) A collection of configuration objects for each `argv`; `options` keys are the long names of the `argv`, and the values are objects with the following properties:
+    * `type` {'string'|'boolean'} (Optional) Type of `argv`; defaults to `'boolean'`; 
+    * `multiples` {boolean} (Optional) If true, when appearing multiple times in `argv`, will be concatenated into an `Array`
+    * `short` {string} (Optional) An alias to an `argv`; When appearing multiples times in `argv`; Respects the `multiples` configuration
   * `strict` {Boolean} (Optional) A `Boolean` on wheather or not to throw an error when unknown args are encountered
 * Returns: {Object} An object having properties:
   * `flags` {Object}, having properties and `Boolean` values corresponding to parsed options passed
@@ -101,7 +98,7 @@ const { parseArgs } = require('@pkgjs/parseargs');
 const { parseArgs } = require('@pkgjs/parseargs');
 const argv = ['-f', '--foo=a', '--bar', 'b'];
 const options = {};
-const { flags, values, positionals } = parseArgs(argv, options);
+const { flags, values, positionals } = parseArgs({ argv, options });
 // flags = { f: true, bar: true }
 // values = { foo: 'a' }
 // positionals = ['b']
@@ -112,9 +109,11 @@ const { parseArgs } = require('@pkgjs/parseargs');
 // withValue
 const argv = ['-f', '--foo=a', '--bar', 'b'];
 const options = {
-  withValue: ['bar']
+  foo: {
+    type: 'string',
+  },
 };
-const { flags, values, positionals } = parseArgs(argv, options);
+const { flags, values, positionals } = parseArgs({ argv, options });
 // flags = { f: true }
 // values = { foo: 'a', bar: 'b' }
 // positionals = []
@@ -125,10 +124,12 @@ const { parseArgs } = require('@pkgjs/parseargs');
 // withValue & multiples
 const argv = ['-f', '--foo=a', '--foo', 'b'];
 const options = {
-  withValue: ['foo'],
-  multiples: ['foo']
+  foo: {
+    type: 'string',
+    multiples: true,
+  },
 };
-const { flags, values, positionals } = parseArgs(argv, options);
+const { flags, values, positionals } = parseArgs({ argv, options });
 // flags = { f: true }
 // values = { foo: ['a', 'b'] }
 // positionals = []
@@ -139,9 +140,11 @@ const { parseArgs } = require('@pkgjs/parseargs');
 // shorts
 const argv = ['-f', 'b'];
 const options = {
-  short: { f: 'foo' }
+  foo: {
+    short: 'f',
+  },
 };
-const { flags, values, positionals } = parseArgs(argv, options);
+const { flags, values, positionals } = parseArgs({ argv, options });
 // flags = { foo: true }
 // values = {}
 // positionals = ['b']

index.js

@@ -2,11 +2,11 @@
 
 const {
   ArrayPrototypeConcat,
-  ArrayPrototypeIncludes,
   ArrayPrototypeSlice,
   ArrayPrototypeSplice,
   ArrayPrototypePush,
   ObjectHasOwn,
+  ObjectEntries,
   StringPrototypeCharAt,
   StringPrototypeIncludes,
   StringPrototypeIndexOf,
@@ -16,7 +16,10 @@ const {
 
 const {
   validateArray,
-  validateObject
+  validateObject,
+  validateString,
+  validateUnion,
+  validateBoolean,
 } = require('./validators');
 
 function getMainArgs() {
@@ -53,39 +56,48 @@ function getMainArgs() {
   return ArrayPrototypeSlice(process.argv, 2);
 }
 
-function storeOptionValue(parseOptions, option, value, result) {
-  const multiple = parseOptions.multiples &&
-    ArrayPrototypeIncludes(parseOptions.multiples, option);
+function storeOptionValue(options, arg, value, result) {
+  const option = options[arg] || {};
 
   // Flags
-  result.flags[option] = true;
+  result.flags[arg] = true;
 
   // Values
-  if (multiple) {
+  if (option.multiples) {
     // Always store value in array, including for flags.
-    // result.values[option] starts out not present,
+    // result.values[arg] starts out not present,
     // first value is added as new array [newValue],
     // subsequent values are pushed to existing array.
     const usedAsFlag = value === undefined;
     const newValue = usedAsFlag ? true : value;
-    if (result.values[option] !== undefined)
-      ArrayPrototypePush(result.values[option], newValue);
+    if (result.values[arg] !== undefined)
+      ArrayPrototypePush(result.values[arg], newValue);
     else
-      result.values[option] = [newValue];
+      result.values[arg] = [newValue];
   } else {
-    result.values[option] = value;
+    result.values[arg] = value;
   }
 }
 
-const parseArgs = (
+const parseArgs = ({
   argv = getMainArgs(),
   options = {}
-) => {
+} = {}) => {
   validateArray(argv, 'argv');
   validateObject(options, 'options');
-  for (const key of ['withValue', 'multiples']) {
-    if (ObjectHasOwn(options, key)) {
-      validateArray(options[key], `options.${key}`);
+  for (const [arg, option] of ObjectEntries(options)) {
+    validateObject(option, `options.${arg}`);
+
+    if (ObjectHasOwn(option, 'type')) {
+      validateUnion(option.type, `options.${arg}.type`, ['string', 'boolean']);
+    }
+
+    if (ObjectHasOwn(option, 'short')) {
+      validateString(option.short, `options.${arg}.short`);
+    }
+
+    if (ObjectHasOwn(option, 'multiples')) {
+      validateBoolean(option.multiples, `options.${arg}.multiples`);
     }
   }
 
@@ -125,15 +137,19 @@ const parseArgs = (
         }
 
         arg = StringPrototypeCharAt(arg, 1); // short
-        if (options.short && options.short[arg])
-          arg = options.short[arg]; // now long!
+        for (const [longName, option] of ObjectEntries(options)) {
+          if (option.short === arg) {
+            arg = longName;
+            break;
+          }
+        }
         // ToDo: later code tests for `=` in arg and wrong for shorts
       } else {
         arg = StringPrototypeSlice(arg, 2); // remove leading --
       }
 
       if (StringPrototypeIncludes(arg, '=')) {
-        // Store option=value same way independent of `withValue` as:
+        // Store option=value same way independent of `type: "string"` as:
         // - looks like a value, store as a value
         // - match the intention of the user
         // - preserve information for author to process further
@@ -146,15 +162,15 @@ const parseArgs = (
       } else if (pos + 1 < argv.length &&
         !StringPrototypeStartsWith(argv[pos + 1], '-')
       ) {
-        // withValue option should also support setting values when '=
+        // `type: "string"` option should also support setting values when '='
         // isn't used ie. both --foo=b and --foo b should work
 
-        // If withValue option is specified, take next position arguement as
-        // value and then increment pos so that we don't re-evaluate that
+        // If `type: "string"` option is specified, take next position argument
+        // as value and then increment pos so that we don't re-evaluate that
         // arg, else set value as undefined ie. --foo b --bar c, after setting
         // b as the value for foo, evaluate --bar next and skip 'b'
-        const val = options.withValue &&
-          ArrayPrototypeIncludes(options.withValue, arg) ? argv[++pos] :
+        const val = options[arg] && options[arg].type === 'string' ?
+          argv[++pos] :
           undefined;
         storeOptionValue(options, arg, val, result);
       } else {
@@ -163,7 +179,6 @@ const parseArgs = (
         // shave value as undefined
         storeOptionValue(options, arg, undefined, result);
       }
-
     } else {
       // Arguements without a dash prefix are considered "positional"
       ArrayPrototypePush(result.positionals, arg);