@nicolo-ribaudo Yeah, I realize that validate does not support plugin type, although it says it accepts any OptionsSource-kind. To minimize the change of this PR, I have to add plugin support to validate.

Never mind, it turns out I have confused between PluginObject and PluginOptions.

@loganfsmyth Thanks for your suggestion. I am open to move the check to the reduce step, but I am hesitant to generalize this check to a very board case.

There are various cases that one can generalize this check into.

1. When the last config item is valid and this config item is non-valid plain object

This is the most generalized case and it almost replaces the original validation error because any error in the non-first config item will result to this error. I am opposed to this approach as it introduces too much noise for advanced users.

2. When the last config item is a valid resolve request

That means we will print this message on

{
  "presets": [
    [
      "@babel/preset-env",
      {
        "targets": {
          "esmodules": true
        }
      },
     "@babel/preset-typescript"
    ]
  ]
}

Well in this case we can print this message as a better guess than 1). I can implement this requirement if we can reach consensus here.

It also seems like it could be a lot nicer to append text to the error's message saying something like "maybe you forgot an extra pair of square brackets" instead of throwing a while separate error.

I still favour the separate error message because it is more focused. Let's do a comparison:

This is the error message while appending "maybe you forgot an extra pair of square brackets"

[BABEL] unknown: Unknown option: .useBuiltIns. Check out
https://babeljs.io/docs/en/babel-core/#options for more information about options.
Maybe you forgot an extra pair of square brackets (`[]`).

Unless we improve the error message logic, the leading double unknown words will be really daunting to users: it seems like the config is terribly wrong. And what's worse, the url does not points to the document of the presets, although all of them are technically correct.

While this is the tuned message

.plugin[1] is not a valid plugin. Maybe you meant to use
"plugin": [
  ["@babel/transform-react-jsx", {"useSpread":true}]
]
To be a valid plugin, its name and options should be wrapped in a pair of brackets

It emphasizes the possible copy-paste ready solution over the technical errors. I can prepend [BABEL] to the message so it is more visually consistent.

This is the most generalized case and it almost replaces the original validation error because any error in the non-first config item will result to this error. I am opposed to this approach as it introduces too much noise for advanced users.

Part of what I'm saying is that I don't think we should replace the error at all. Just like we do with

To help clarify things, something like

  const plugins = config.plugins.reduce((acc, descriptor, i) => {
    if (descriptor.options !== false) {
      try {
        acc.push(loadPluginDescriptor(descriptor, context));
      } catch (err) {
        if (typeof descriptor.value === "object" && i > 0 && config.plugins[i].options === undefined) {
          err.message += " It looks like this object might be options for the plugin/preset before it. When applying options, the options need to be grouped with the plugin/preset as a single entry in the overall plugin/preset list. Did you forget to group them with `[]`?";
        }
        throw err;
      }
    }
    return acc;
  }, []);

I get your concerns over error message verbosity though, and I admit I don't feel that strongly. The main reason I comment on this is because the placement of the logic had surprised me. For your case, we could instead do

  const plugins = config.plugins.reduce((acc, descriptor, i) => {
    if (descriptor.options !== false) {
      try {
        acc.push(loadPluginDescriptor(descriptor, context));
      } catch (err) {
        if (
          config.plugins.length === 2 && 
          config.plugins[0].file &&
          config.plugins[0].options === undefined &&
          i === 1 && 
          typeof descriptor.value === "object"
        ) {
            throw new Error(
              `.plugins[1] is not a valid plugin. Maybe you meant to use\n` +
              `"plugin": [\n  ["${config.plugins[i].file.request}", ${JSON.stringify(descriptor.value)}]\n]\n` +
              `To be a valid plugin, its name and options should be wrapped in a pair of brackets`,
               );
        }
        throw err;
      }
    }
    return acc;
  }, []);

and I think it would be clearer and avoid repeating the validation logic.