Unnecessary arrays in result `values`?

[shadowspawn]

const { parseArgs } = require('@pkgjs/parseargs');
const options = {
    withValue: ['foo']
};
const result = parseArgs(undefined, options);
console.log(result.values);

Actual:

 % node withValue.js --flag --foo bar
{ flag: [ undefined ], foo: [ 'bar' ] }

I expect a plain string for foo rather than an array, and no "value" at all for flag.

Expected:

 % node withValue.js --flag --foo bar
{ foo:  'bar'  }

[shadowspawn]

(Happy to fix this, checking my expected behaviour first!)

[ljharb]

I’d expect a value of true for flag if it had one at all.

[shadowspawn]

Historical digging. The current implementation was written to match the README description: https://github.com/pkgjs/parseargs#-examples-w-output

As mentioned in: #9 (comment)

The README text was added by @darcyclarke in: 3f057c1

[shadowspawn]

For comparison, the "Initial Proposal" has this example. Combined options property in result, no superfluous array wrappers.

 * parseArgs(['--foo', 'bar'], {optionsWithValue: 'foo'})
 *   // {options: {foo: 'bar'}, positionals: []}

[bcoe]

I think my expectation would be it's only an array if you set multiples? and if you set multiples, it's an array even if you have only one item?

[ljharb]

We should absolutely never have the type of something vary based on whether there's 1 or 2+ items.

[shadowspawn]

Edit: opened PR with evolution of this code, see #26

---

Some code to always use arrays for multiple. And for non-multiples, do not use arrays, and only store either flag or value and not both. I haven't discussed that last part yet!

function setOptionValue(parseOptions, option, value, result) {
  const multiple = parseOptions.multiples &&
    parseOptions.multiples.includes(option);
  const withValue = parseOptions.withValue &&
    parseOptions.withValue.includes(option);
  const isFlag = !withValue && value === undefined;

  // Normal flag: !withValue && value === undefined
  // Normal value, withValue && value !== undefined
  // Special case: withValue && value === undefined, store undefined not flag
  // Special case: !withValue && value !== undefined, store value not flag

  // Flags
  // Only mark flags for plain flag without a value, expected or otherwise.
  if (isFlag)
    result.flags[option] = true;

  // Values
  if (multiple) {
    // Always store value in array, including for flags.
    const val = isFlag ? true : value;
    if (result.values[option])
      result.values[option].concat(val);
    else
      result.values[option] = [val];
  } else if (!isFlag) {
    result.values[option] = value;
  }
}