chore: cleanup cli (#2009)

packages/serve/src/index.ts

@@ -11,11 +11,10 @@ import parseArgs from './parseArgs';
  */
 export default function serve(...args: string[]): void {
     const cli = new WebpackCLI();
-    const core = cli.getCoreFlags();
 
     const { webpackArgs, devServerArgs } = parseArgs(cli, args);
 
-    cli.getCompiler(webpackArgs, core).then((compiler): void => {
+    cli.getCompiler(webpackArgs).then((compiler): void => {
         startDevServer(compiler, devServerArgs);
     });
 }

packages/webpack-cli/lib/utils/cli-flags.js

@@ -268,9 +268,15 @@ const duplicateFlags = core.map((flag) => flag.name);
 // remove duplicate flags
 flagsFromCore = flagsFromCore.filter((flag) => !duplicateFlags.includes(flag.name));
 
+const coreFlagMap = flagsFromCore.reduce((acc, cur) => {
+    acc.set(cur.name, cur);
+    return acc;
+}, new Map());
+
 module.exports = {
     groups,
     commands,
     core: [...core, ...flagsFromCore],
     flagsFromCore,
+    coreFlagMap,
 };

packages/webpack-cli/lib/webpack-cli.js

@@ -2,11 +2,9 @@ const { packageExists } = require('./utils/package-exists');
 const webpack = packageExists('webpack') ? require('webpack') : undefined;
 const logger = require('./utils/logger');
 const webpackMerge = require('webpack-merge');
-const GroupHelper = require('./utils/GroupHelper');
-const { groups, core } = require('./utils/cli-flags');
+const { core, coreFlagMap } = require('./utils/cli-flags');
 const argParser = require('./utils/arg-parser');
 const { outputStrategy } = require('./utils/merge-strategies');
-const { toKebabCase } = require('./utils/helpers');
 const assignFlagDefaults = require('./utils/flag-defaults');
 const { writeFileSync } = require('fs');
 const { options: coloretteOptions } = require('colorette');
@@ -19,48 +17,33 @@ const resolveStats = require('./groups/resolveStats');
 const resolveOutput = require('./groups/resolveOutput');
 const basicResolver = require('./groups/basicResolver');
 const resolveAdvanced = require('./groups/resolveAdvanced');
+const { toKebabCase } = require('./utils/helpers');
 
-class WebpackCLI extends GroupHelper {
+class WebpackCLI {
     constructor() {
-        super();
-        this.groupMap = new Map();
         this.compilerConfiguration = {};
         this.outputConfiguration = {};
     }
-    setMappedGroups(args, inlineOptions) {
-        Object.keys(args).forEach((key) => {
-            this.setGroupMap(toKebabCase(key), args[key], inlineOptions);
-        });
-    }
-    setGroupMap(key, val, inlineOptions) {
-        if (val === undefined) return;
-        const opt = inlineOptions.find((opt) => opt.name === key);
-        const groupName = opt.group;
-        if (this.groupMap.has(groupName)) {
-            const pushToMap = this.groupMap.get(groupName);
-            pushToMap.push({ [opt.name]: val });
-        } else {
-            this.groupMap.set(groupName, [{ [opt.name]: val }]);
-        }
-    }
 
     /**
      * Responsible for handling flags coming from webpack/webpack
      * @private\
      * @returns {void}
      */
     _handleCoreFlags(parsedArgs) {
-        if (this.groupMap.has('core')) {
-            const coreFlags = this.groupMap.get('core');
-
-            // convert all the flags from map to single object
-            const coreConfig = coreFlags.reduce((allFlag, curFlag) => ({ ...allFlag, ...curFlag }), {});
-            const coreCliHelper = require('webpack').cli;
-            const coreCliArgs = coreCliHelper.getArguments();
-            // Merge the core flag config with the compilerConfiguration
-            coreCliHelper.processArguments(coreCliArgs, this.compilerConfiguration, coreConfig);
-            // Assign some defaults to core flags
-        }
+        const coreConfig = Object.keys(parsedArgs)
+            .filter((arg) => {
+                return coreFlagMap.has(toKebabCase(arg));
+            })
+            .reduce((acc, cur) => {
+                acc[toKebabCase(cur)] = parsedArgs[cur];
+                return acc;
+            }, {});
+        const coreCliHelper = require('webpack').cli;
+        const coreCliArgs = coreCliHelper.getArguments();
+        // Merge the core flag config with the compilerConfiguration
+        coreCliHelper.processArguments(coreCliArgs, this.compilerConfiguration, coreConfig);
+        // Assign some defaults to core flags
         const configWithDefaults = assignFlagDefaults(this.compilerConfiguration, parsedArgs);
         this._mergeOptionsToConfiguration(configWithDefaults);
     }
@@ -83,24 +66,6 @@ class WebpackCLI extends GroupHelper {
         return core;
     }
 
-    /**
-     * Based on the parsed keys, the function will import and create
-     * a group that handles respective values
-     *
-     * @returns {void}
-     */
-    resolveGroups() {
-        for (const [key] of this.groupMap.entries()) {
-            switch (key) {
-                case groups.HELP_GROUP: {
-                    const HelpGroup = require('./groups/runHelp');
-                    this.helpGroup = new HelpGroup();
-                    break;
-                }
-            }
-        }
-    }
-
     /**
      * Responsible to override webpack options.
      * @param {Object} options The options returned by a group helper
@@ -171,22 +136,6 @@ class WebpackCLI extends GroupHelper {
         }
     }
 
-    /**
-     * It receives a group helper, it runs and it merges its result inside
-     * the file result that will be passed to the compiler
-     *
-     * @param {GroupHelper?} groupHelper A group helper
-     * @private
-     * @returns {void}
-     */
-    async _handleGroupHelper(groupHelper) {
-        if (groupHelper) {
-            const result = await groupHelper.run();
-            this._mergeOptionsToConfiguration(result.options, groupHelper.strategy);
-            this._mergeOptionsToOutputConfiguration(result.outputOptions);
-        }
-    }
-
     /**
      * It runs in a fancy order all the expected groups.
      * Zero config and configuration goes first.
@@ -202,15 +151,7 @@ class WebpackCLI extends GroupHelper {
             .then(() => this._handleCoreFlags(parsedArgs))
             .then(() => this._baseResolver(basicResolver, parsedArgs))
             .then(() => this._baseResolver(resolveAdvanced, parsedArgs))
-            .then(() => this._baseResolver(resolveStats, parsedArgs))
-            .then(() => this._handleGroupHelper(this.helpGroup));
-    }
-
-    async processArgs(args, cliOptions) {
-        this.setMappedGroups(args, cliOptions);
-        this.resolveGroups(args);
-
-        return this.runOptionGroups(args);
+            .then(() => this._baseResolver(resolveStats, parsedArgs));
     }
 
     handleError(error) {
@@ -240,14 +181,13 @@ class WebpackCLI extends GroupHelper {
         return compiler;
     }
 
-    async getCompiler(args, cliOptions) {
-        await this.processArgs(args, cliOptions);
-
+    async getCompiler(args) {
+        await this.runOptionGroups(args);
         return this.createCompiler(this.compilerConfiguration);
     }
 
-    async run(args, cliOptions) {
-        await this.processArgs(args, cliOptions);
+    async run(args) {
+        await this.runOptionGroups(args);
 
         let compiler;