feat: Add strict mode to parser

errors.js

@@ -7,16 +7,32 @@ class ERR_INVALID_ARG_TYPE extends TypeError {
   }
 }
 
+class ERR_INVALID_OPTION_VALUE extends Error {
+  constructor(message) {
+    super(message);
+    this.code = 'ERR_INVALID_OPTION_VALUE';
+  }
+}
+
 class ERR_INVALID_SHORT_OPTION extends TypeError {
   constructor(longOption, shortOption) {
     super(`options.${longOption}.short must be a single character, got '${shortOption}'`);
     this.code = 'ERR_INVALID_SHORT_OPTION';
   }
 }
 
+class ERR_UNKNOWN_OPTION extends Error {
+  constructor(message) {
+    super(message);
+    this.code = 'ERR_UNKNOWN_OPTION';
+  }
+}
+
 module.exports = {
   codes: {
     ERR_INVALID_ARG_TYPE,
-    ERR_INVALID_SHORT_OPTION
+    ERR_INVALID_OPTION_VALUE,
+    ERR_INVALID_SHORT_OPTION,
+    ERR_UNKNOWN_OPTION,
   }
 };

index.js

@@ -34,7 +34,9 @@ const {
 
 const {
   codes: {
+    ERR_INVALID_OPTION_VALUE,
     ERR_INVALID_SHORT_OPTION,
+    ERR_UNKNOWN_OPTION,
   },
 } = require('./errors');
 
@@ -73,8 +75,36 @@ function getMainArgs() {
 }
 
 const protoKey = '__proto__';
-function storeOptionValue(options, longOption, value, result) {
-  const optionConfig = options[longOption] || {};
+
+function storeOption({
+  strict,
+  options,
+  result,
+  longOption,
+  shortOption,
+  optionValue,
+}) {
+  const hasOptionConfig = ObjectHasOwn(options, longOption);
+
+  if (strict) {
+    const longOrShortOption = shortOption == null ?
+      `long option '--${longOption}'` :
+      `short option '-${shortOption}'`;
+
+    if (!hasOptionConfig) {
+      throw new ERR_UNKNOWN_OPTION(`Unknown ${longOrShortOption}`);
+    }
+
+    if (options[longOption].type === 'string' && optionValue == null) {
+      throw new ERR_INVALID_OPTION_VALUE(`Missing value for ${longOrShortOption} with type:'string'`);
+    }
+
+    if (options[longOption].type === 'boolean' && optionValue != null) {
+      throw new ERR_INVALID_OPTION_VALUE(`Unexpected value '${optionValue}' for ${longOrShortOption} with type:'boolean'`);
+    }
+  }
+
+  const optionConfig = hasOptionConfig ? options[longOption] : {};
 
   // Flags
   result.flags[longOption] = true;
@@ -89,22 +119,24 @@ function storeOptionValue(options, longOption, value, result) {
     // result.values[longOption] 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;
+    const usedAsFlag = optionValue === undefined;
+    const newValue = usedAsFlag ? true : optionValue;
     if (result.values[longOption] !== undefined)
       ArrayPrototypePush(result.values[longOption], newValue);
     else
       result.values[longOption] = [newValue];
   } else {
-    result.values[longOption] = value;
+    result.values[longOption] = optionValue;
   }
 }
 
 const parseArgs = ({
   args = getMainArgs(),
+  strict = false,
   options = {}
 } = {}) => {
   validateArray(args, 'args');
+  validateBoolean(strict, 'strict');
   validateObject(options, 'options');
   ArrayPrototypeForEach(
     ObjectEntries(options),
@@ -160,7 +192,14 @@ const parseArgs = ({
         // e.g. '-f', 'bar'
         optionValue = ArrayPrototypeShift(remainingArgs);
       }
-      storeOptionValue(options, longOption, optionValue, result);
+      storeOption({
+        strict,
+        options,
+        result,
+        longOption,
+        shortOption,
+        optionValue,
+      });
       continue;
     }
 
@@ -191,7 +230,14 @@ const parseArgs = ({
       const shortOption = StringPrototypeCharAt(arg, 1);
       const longOption = findLongOptionForShort(shortOption, options);
       const optionValue = StringPrototypeSlice(arg, 2);
-      storeOptionValue(options, longOption, optionValue, result);
+      storeOption({
+        strict,
+        options,
+        result,
+        longOption,
+        shortOption,
+        optionValue,
+      });
       continue;
     }
 
@@ -203,7 +249,7 @@ const parseArgs = ({
         // e.g. '--foo', 'bar'
         optionValue = ArrayPrototypeShift(remainingArgs);
       }
-      storeOptionValue(options, longOption, optionValue, result);
+      storeOption({ strict, options, result, longOption, optionValue });
       continue;
     }
 
@@ -212,7 +258,7 @@ const parseArgs = ({
       const index = StringPrototypeIndexOf(arg, '=');
       const longOption = StringPrototypeSlice(arg, 2, index);
       const optionValue = StringPrototypeSlice(arg, index + 1);
-      storeOptionValue(options, longOption, optionValue, result);
+      storeOption({ strict, options, result, longOption, optionValue });
       continue;
     }
 

test/index.js

@@ -381,6 +381,68 @@ test('invalid union value passed to "type" option', function(t) {
   t.end();
 });
 
+// Test strict mode
+
+test('unknown long option --bar', function(t) {
+  const passedArgs = ['--foo', '--bar'];
+  const passedOptions = { foo: { type: 'boolean' } };
+  const strict = true;
+
+  t.throws(function() { parseArgs({ strict, args: passedArgs, options: passedOptions }); });
+
+  t.end();
+});
+
+test('unknown short option -b', function(t) {
+  const passedArgs = ['--foo', '-b'];
+  const passedOptions = { foo: { type: 'boolean' } };
+  const strict = true;
+
+  t.throws(function() { parseArgs({ strict, args: passedArgs, options: passedOptions }); });
+
+  t.end();
+});
+
+test('unknown option -r in short option group -bar', function(t) {
+  const passedArgs = ['--foo', '-bar'];
+  const passedOptions = { foo: { type: 'boolean' }, b: { type: 'boolean' }, a: { type: 'boolean' } };
+  const strict = true;
+
+  t.throws(function() { parseArgs({ strict, args: passedArgs, options: passedOptions }); });
+
+  t.end();
+});
+
+test('unknown option with explicit value', function(t) {
+  const passedArgs = ['--foo', '--bar=baz'];
+  const passedOptions = { foo: { type: 'boolean' } };
+  const strict = true;
+
+  t.throws(function() { parseArgs({ strict, args: passedArgs, options: passedOptions }); });
+
+  t.end();
+});
+
+test('string option used as boolean', function(t) {
+  const passedArgs = ['--foo'];
+  const passedOptions = { foo: { type: 'string' } };
+  const strict = true;
+
+  t.throws(function() { parseArgs({ strict, args: passedArgs, options: passedOptions }); });
+
+  t.end();
+});
+
+test('boolean option used with value', function(t) {
+  const passedArgs = ['--foo=bar'];
+  const passedOptions = { foo: { type: 'boolean' } };
+  const strict = true;
+
+  t.throws(function() { parseArgs({ strict, args: passedArgs, options: passedOptions }); });
+
+  t.end();
+});
+
 test('invalid short option length', function(t) {
   const passedArgs = [];
   const passedOptions = { foo: { short: 'fo' } };