feat: added config command

OPTIONS.md

@@ -1042,6 +1042,7 @@ Global options:
 
 Commands:
   build|bundle|b [entries...] [options]                                              Run webpack (default command, can be omitted).
+  config|c [command] [options]                                                       Get the configuration of a particular project.
   configtest|t [config-path]                                                         Validate a webpack configuration.
   help|h [command] [option]                                                          Display help for commands and options.
   info|i [options]                                                                   Outputs information about your system.

package.json

@@ -96,5 +96,8 @@
     "webpack": "^5.90.3",
     "webpack-bundle-analyzer": "^4.5.0",
     "webpack-dev-server": "^5.0.2"
+  },
+  "dependencies": {
+    "yarn": "^1.22.21"
   }
 }

packages/webpack-cli/src/types.ts

@@ -55,6 +55,7 @@ interface IWebpackCLI {
     options: WebpackCLICommandOptions,
     action: CommandAction,
   ): Promise<WebpackCLICommand | undefined>;
+  getConfigOutput(options: WebpackDevServerOptions): Promise<void>;
   makeOption(command: WebpackCLICommand, option: WebpackCLIBuiltInOption): void;
   run(
     args: Parameters<WebpackCLICommand["parseOptions"]>[0],

packages/webpack-cli/src/webpack-cli.ts

@@ -44,7 +44,7 @@ import type {
 } from "./types";
 
 import type webpackMerge from "webpack-merge";
-import type webpack from "webpack";
+import webpack, { web } from "webpack";
 import {
   type Compiler,
   type MultiCompiler,
@@ -459,6 +459,49 @@ class WebpackCLI implements IWebpackCLI {
     ];
   }
 
+  getConfigOptions(): WebpackCLIBuiltInOption[] {
+    return [
+      {
+        name: "file",
+        alias: "f",
+        configs: [
+          {
+            type: "path",
+          },
+        ],
+        description: "Provide path to one or more webpack configuration files to process.",
+        helpLevel: "minimum",
+      },
+      {
+        name: "name",
+        alias: "n",
+        configs: [
+          {
+            type: "string",
+            values: [],
+          },
+        ],
+        multiple: true,
+        description:
+          "Name(s) of particular configuration(s) to use if configuration file exports an array of multiple configurations.",
+        helpLevel: "minimum",
+      },
+      {
+        name: "include",
+        alias: "i",
+        configs: [
+          {
+            type: "string",
+            values: [],
+          },
+        ],
+        multiple: true,
+        description: "To include the options of webpack-dev-server.",
+        helpLevel: "minimum",
+      },
+    ];
+  }
+
   async getInfoOutput(options: { output: string; additionalPackage: string[] }): Promise<string> {
     let { output } = options;
     const envinfoConfig: { [key: string]: boolean } = {};
@@ -517,6 +560,49 @@ class WebpackCLI implements IWebpackCLI {
     return info;
   }
 
+  async getConfigOutput(options: WebpackDevServerOptions): Promise<void> {
+    const config = await this.loadConfig({
+      config: [options.file ? options.file : "webpack.config.js"],
+      name: options.name,
+      configName: options.name ? (options.name as unknown as string[]) : undefined,
+    });
+    if (options.name) {
+      config.options = Array.isArray(config.options)
+        ? config.options.filter((option: any) => options.name?.includes(option.name))
+        : [];
+    }
+
+    if (options.include) {
+      const includeOptions = webpack.config.getNormalizedWebpackOptions({});
+      Array.isArray(config.options)
+        ? config.options.forEach((option) => {
+            Object.keys(option || {}).forEach((key) => {
+              if (options.include.includes(key) && options.name?.includes(option.name || "")) {
+                let finalOption: any = includeOptions[key as keyof WebpackOptionsNormalized];
+                if (typeof option[key as keyof typeof option] === "string") {
+                  finalOption = option[key as keyof typeof option] as string;
+                } else {
+                  Object.keys(option[key as keyof typeof option] || {}).forEach((subkey) => {
+                    finalOption[subkey] = (option[key as keyof typeof option] as any)?.[subkey];
+                  });
+                }
+                console.log(`\n${key}:`, finalOption);
+              }
+            });
+          })
+        : [];
+    }
+
+    const compiler = webpack(config.options as webpack.Configuration[]);
+    compiler.run((err, stats) => {
+      if (err) {
+        console.error(err);
+        process.exit(1);
+      }
+      this.logger.raw(stats?.toString({ colors: this.colors.isColorSupported }));
+      process.exit(0);
+    });
+  }
   async makeCommand(
     commandOptions: WebpackCLIOptions,
     options: WebpackCLICommandOptions,
@@ -863,33 +949,6 @@ class WebpackCLI implements IWebpackCLI {
 
     const builtInFlags: WebpackCLIBuiltInFlag[] = [
       // For configs
-      {
-        name: "config",
-        alias: "c",
-        configs: [
-          {
-            type: "string",
-          },
-        ],
-        multiple: true,
-        valueName: "pathToConfigFile",
-        description:
-          'Provide path to one or more webpack configuration files to process, e.g. "./webpack.config.js".',
-        helpLevel: "minimum",
-      },
-      {
-        name: "config-name",
-        configs: [
-          {
-            type: "string",
-          },
-        ],
-        multiple: true,
-        valueName: "name",
-        description:
-          "Name(s) of particular configuration(s) to use if configuration file exports an array of multiple configurations.",
-        helpLevel: "minimum",
-      },
       {
         name: "merge",
         alias: "m",
@@ -1123,6 +1182,12 @@ class WebpackCLI implements IWebpackCLI {
       alias: "h",
       description: "Display help for commands and options.",
     };
+    const configCommandOptions = {
+      name: "config [command]",
+      alias: "c",
+      description: "Get the configuration of a command.",
+      usage: "[options]",
+    };
     // Built-in external commands
     const externalBuiltInCommandsInfo: WebpackCLIExternalCommandInfo[] = [
       {
@@ -1162,6 +1227,7 @@ class WebpackCLI implements IWebpackCLI {
       watchCommandOptions,
       versionCommandOptions,
       helpCommandOptions,
+      configCommandOptions,
       ...externalBuiltInCommandsInfo,
     ];
     const getCommandName = (name: string) => name.split(" ")[0];
@@ -1239,6 +1305,10 @@ class WebpackCLI implements IWebpackCLI {
             cli.logger.raw(info);
           },
         );
+      } else if (isCommand(commandName, configCommandOptions)) {
+        this.makeCommand(configCommandOptions, this.getConfigOptions(), async (_, options) => {
+          await this.getConfigOutput(options);
+        });
       } else {
         const builtInExternalCommandInfo = externalBuiltInCommandsInfo.find(
           (externalBuiltInCommandInfo) =>