@pinnacle0/webpack-util 0.3.25 → 0.3.26

package/src/WebpackConfigGenerator/Rule/{stylesheet.rule.js → stylesheet.rule.ts}

@@ -1,12 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stylesheetRule = void 0;
-const mini_css_extract_plugin_1 = __importDefault(require("mini-css-extract-plugin"));
-const RegExpUtil_1 = require("./RegExpUtil");
-function cssLoader(importLoaders) {
+import MiniCssExtractPlugin from "mini-css-extract-plugin";
+import type webpack from "webpack";
+import {RegExpUtil} from "./RegExpUtil";
+
+interface StylesheetRuleDeps {
+    minimize: boolean;
+}
+
+function cssLoader(importLoaders: number): webpack.RuleSetUseItem {
     return {
         loader: require.resolve("css-loader"),
         options: {
@@ -14,7 +14,8 @@ function cssLoader(importLoaders) {
         },
     };
 }
-function lessLoader() {
+
+function lessLoader(): webpack.RuleSetUseItem {
     return {
         loader: require.resolve("less-loader"),
         options: {
@@ -24,12 +25,14 @@ function lessLoader() {
         },
     };
 }
-function miniCssExtractPluginLoader() {
+
+function miniCssExtractPluginLoader(): webpack.RuleSetUseItem {
     return {
-        loader: require.resolve(mini_css_extract_plugin_1.default.loader),
+        loader: require.resolve(MiniCssExtractPlugin.loader),
     };
 }
-function postcssLoader() {
+
+function postcssLoader(): webpack.RuleSetUseItem {
     return {
         loader: require.resolve("postcss-loader"),
         options: {
@@ -42,11 +45,13 @@ function postcssLoader() {
         },
     };
 }
-function styleLoader() {
+
+function styleLoader(): webpack.RuleSetUseItem {
     return {
         loader: require.resolve("style-loader"),
     };
 }
+
 /**
  * Handles dependency requests to stylesheet assets (".css", ".less")
  * with `minimize: true` by `lessc` -> transform to js module -> inject to DOM as <style> tag,
@@ -58,23 +63,24 @@ function styleLoader() {
  * @see https://webpack.js.org/loaders/postcss-loader/
  * @see https://webpack.js.org/loaders/style-loader/
  */
-function stylesheetRule({ minimize }) {
-    const use = minimize
+export function stylesheetRule({minimize}: StylesheetRuleDeps): webpack.RuleSetRule {
+    const use: webpack.RuleSetUseItem[] = minimize
         ? [
-            miniCssExtractPluginLoader(),
-            cssLoader(2),
-            postcssLoader(),
-            lessLoader(),
-            // prettier-format-preserve
-        ]
+              miniCssExtractPluginLoader(),
+              cssLoader(2),
+              postcssLoader(),
+              lessLoader(),
+              // prettier-format-preserve
+          ]
         : [
-            styleLoader(),
-            cssLoader(1),
-            lessLoader(),
-            // prettier-format-preserve
-        ];
+              styleLoader(),
+              cssLoader(1),
+              lessLoader(),
+              // prettier-format-preserve
+          ];
+
     return {
-        test: RegExpUtil_1.RegExpUtil.fileExtension(".css", ".less"),
+        test: RegExpUtil.fileExtension(".css", ".less"),
         use,
         // Declare all css/less imports as side effects (not to be considered
         // as dead code), regardless of the containing package claims to be
@@ -84,5 +90,3 @@ function stylesheetRule({ minimize }) {
         sideEffects: true,
     };
 }
-exports.stylesheetRule = stylesheetRule;
-//# sourceMappingURL=stylesheet.rule.js.map

package/src/WebpackConfigGenerator/Rule/{ts.rule.js → ts.rule.ts}

@@ -1,11 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tsRule = void 0;
-const path_1 = __importDefault(require("path"));
-const RegExpUtil_1 = require("./RegExpUtil");
+import path from "path";
+import type webpack from "webpack";
+import {RegExpUtil} from "./RegExpUtil";
+
+interface Deps {
+    tsconfigFilepath: string;
+    fastRefresh: boolean;
+}
+
 /**
  * Handles dependency requests to typescript files
  * by compiling with `tsc`.
@@ -17,15 +18,16 @@ const RegExpUtil_1 = require("./RegExpUtil");
  * @see https://github.com/TypeStrong/ts-loader
  * @see https://github.com/pmmmwh/react-refresh-webpack-plugin
  */
-function tsRule({ tsconfigFilepath, fastRefresh }) {
-    const babelLoader = {
+export function tsRule({tsconfigFilepath, fastRefresh}: Deps): webpack.RuleSetRule {
+    const babelLoader: webpack.RuleSetUseItem = {
         loader: require.resolve("babel-loader"),
         options: {
-            plugins: [require.resolve(path_1.default.join(__dirname, "./core-fe-hmr-babel-plugin")), require.resolve("react-refresh/babel")],
+            plugins: [require.resolve(path.join(__dirname, "./core-fe-hmr-babel-plugin")), require.resolve("react-refresh/babel")],
         },
     };
+
     // TODO/Alvis: Check whether ts-loader can be replaced by babel loader
-    const tsLoader = {
+    const tsLoader: webpack.RuleSetUseItem = {
         loader: require.resolve("ts-loader"),
         options: {
             colors: false,
@@ -38,7 +40,8 @@ function tsRule({ tsconfigFilepath, fastRefresh }) {
             transpileOnly: true,
         },
     };
-    const swcLoader = {
+
+    const swcLoader: webpack.RuleSetUseItem = {
         loader: require.resolve("swc-loader"),
         options: {
             jsc: {
@@ -57,10 +60,9 @@ function tsRule({ tsconfigFilepath, fastRefresh }) {
             },
         },
     };
+
     return {
-        test: RegExpUtil_1.RegExpUtil.fileExtension(".ts", ".tsx"),
+        test: RegExpUtil.fileExtension(".ts", ".tsx"),
         use: fastRefresh ? [babelLoader, tsLoader] : [swcLoader],
     };
 }
-exports.tsRule = tsRule;
-//# sourceMappingURL=ts.rule.js.map

package/src/WebpackConfigGenerator/{WebpackConfigSerializationUtil.js → WebpackConfigSerializationUtil.ts}

@@ -1,15 +1,19 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebpackConfigSerializationUtil = void 0;
-const pretty_format_1 = __importDefault(require("pretty-format"));
-class WebpackConfigSerializationUtil {
-    static serializablePlugin(name, PluginConstructor, options) {
+import prettyFormat from "pretty-format";
+import type webpack from "webpack";
+
+interface SerializableWebpackPluginDescriptor {
+    "@@WP_CONFIG_GEN_TYPE": "WebpackPluginConstructorCall";
+    pluginName: string;
+    pluginOptions: any;
+}
+
+export class WebpackConfigSerializationUtil {
+    static serializablePlugin<OptType, T extends {apply(..._: any[]): void}>(name: string, PluginConstructor: new () => T): webpack.WebpackPluginInstance;
+    static serializablePlugin<OptType, T extends {apply(..._: any[]): void}>(name: string, PluginConstructor: new (_: OptType) => T, options: OptType): webpack.WebpackPluginInstance;
+    static serializablePlugin<OptType, T extends {apply(..._: any[]): void}>(name: string, PluginConstructor: new (_?: OptType) => T, options?: OptType): webpack.WebpackPluginInstance {
         const plugin = new PluginConstructor(options);
         return Object.defineProperty(plugin, "toWebpackConfigSerializableType", {
-            value() {
+            value(): SerializableWebpackPluginDescriptor {
                 return {
                     "@@WP_CONFIG_GEN_TYPE": "WebpackPluginConstructorCall",
                     pluginName: name,
@@ -18,8 +22,9 @@ class WebpackConfigSerializationUtil {
             },
         });
     }
-    static configToString(config) {
-        const configString = (0, pretty_format_1.default)(config, {
+
+    static configToString(config: webpack.Configuration): string {
+        const configString = prettyFormat(config, {
             callToJSON: true,
             escapeRegex: false,
             escapeString: false,
@@ -27,23 +32,22 @@ class WebpackConfigSerializationUtil {
             printFunctionName: false,
             plugins: [
                 {
-                    test(val) {
+                    test(val: any) {
                         try {
                             return typeof val.toWebpackConfigSerializableType === "function";
-                        }
-                        catch (_a) {
+                        } catch {
                             return false;
                         }
                     },
-                    serialize(val, config, indentation, depth, refs, printer) {
-                        const _ = val.toWebpackConfigSerializableType();
+                    serialize(val: any, config, indentation, depth, refs, printer) {
+                        const _ = val.toWebpackConfigSerializableType() as SerializableWebpackPluginDescriptor;
                         return `new ${_.pluginName}(${printer(_.pluginOptions, config, indentation, depth, refs)})`;
                     },
                 },
             ],
         });
         try {
-            const { format } = require("prettier");
+            const {format} = require("prettier") as typeof import("prettier");
             return format("module.exports = " + configString, {
                 arrowParens: "avoid",
                 bracketSpacing: false,
@@ -52,12 +56,9 @@ class WebpackConfigSerializationUtil {
                 useTabs: false,
                 filepath: "webpack.config.js",
             });
-        }
-        catch (_a) {
+        } catch {
             // Either prettier cannot be loaded, or formatting failed, return the unformatted config as a fallback.
             return configString;
         }
     }
 }
-exports.WebpackConfigSerializationUtil = WebpackConfigSerializationUtil;
-//# sourceMappingURL=WebpackConfigSerializationUtil.js.map

package/src/WebpackConfigGenerator/WebpackEntryFactory.ts

@@ -0,0 +1,22 @@
+import type webpack from "webpack";
+import type {EntryDescriptor} from "../type";
+
+interface StrictWebpackEntry {
+    [entryName: string]: [string];
+}
+
+interface WebpackEntryFactoryOptions {
+    configEntryDescriptors: EntryDescriptor[];
+}
+
+export class WebpackEntryFactory {
+    static generate({configEntryDescriptors}: WebpackEntryFactoryOptions): NonNullable<webpack.Configuration["entry"]> {
+        const entry: StrictWebpackEntry = {};
+
+        for (const {name, entryPath} of configEntryDescriptors) {
+            entry[name] = [entryPath];
+        }
+
+        return entry;
+    }
+}

package/src/WebpackConfigGenerator/WebpackOutputPublicURLFactory.ts

@@ -0,0 +1,22 @@
+export interface WebpackOutputPublicURLFactoryOptions {
+    env: string | null;
+    /**
+     * Function to dynamically compute additional webpack config from `env`.
+     * Should validates if the config contains `publicUrl` field.
+     */
+    webpackPublicPath: string | ((env: string) => string) | undefined;
+}
+
+export class WebpackOutputPublicURLFactory {
+    static generate({env, webpackPublicPath}: WebpackOutputPublicURLFactoryOptions): string {
+        if (!env || !webpackPublicPath) {
+            return "/";
+        }
+
+        if (typeof webpackPublicPath === "string") {
+            return webpackPublicPath;
+        }
+
+        return webpackPublicPath(env);
+    }
+}

package/src/WebpackConfigGenerator/{WebpackResolveAliasFactory.js → WebpackResolveAliasFactory.ts}

@@ -1,19 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebpackResolveAliasFactory = void 0;
-class WebpackResolveAliasFactory {
-    static generate({ env, resolvers }) {
-        const moduleAliasMap = {};
-        for (const { prefix, resolver } of resolvers) {
+import type {DynamicPathResolver} from "../type";
+
+interface WebpackResolveAliasMapOptions {
+    env: string | null;
+    resolvers: DynamicPathResolver[];
+}
+
+export class WebpackResolveAliasFactory {
+    static generate({env, resolvers}: WebpackResolveAliasMapOptions): {[moduleAlias: string]: string} {
+        const moduleAliasMap: {[moduleAlias: string]: string} = {};
+
+        for (const {prefix, resolver} of resolvers) {
             if (prefix in moduleAliasMap) {
                 throw new Error(`Duplicated resolver prefix: ${prefix}`);
-            }
-            else if (prefix.trim() === "") {
+            } else if (prefix.trim() === "") {
                 throw new Error(`Resolver prefix cannot be empty`);
-            }
-            else if (/\s/.test(prefix)) {
+            } else if (/\s/.test(prefix)) {
                 throw new Error(`Resolver prefix cannot contain whitespace, received: ${prefix}`);
             }
+
             if (resolver) {
                 const resolvedRealPath = typeof resolver === "string" ? resolver : resolver(env);
                 if (resolvedRealPath) {
@@ -21,8 +25,7 @@ class WebpackResolveAliasFactory {
                 }
             }
         }
+
         return moduleAliasMap;
     }
 }
-exports.WebpackResolveAliasFactory = WebpackResolveAliasFactory;
-//# sourceMappingURL=WebpackResolveAliasFactory.js.map

package/src/WebpackConfigGenerator/WebpackResolveExtensionsFactory.ts

@@ -0,0 +1,19 @@
+import {Constant} from "../Constant";
+
+interface WebpackResolveExtensionsFactoryOptions {
+    prioritizedExtensionPrefixes?: string[] | undefined;
+}
+
+export class WebpackResolveExtensionsFactory {
+    static generate({prioritizedExtensionPrefixes = []}: WebpackResolveExtensionsFactoryOptions): string[] {
+        const resolveExtensions = [];
+
+        for (const prefix of prioritizedExtensionPrefixes) {
+            resolveExtensions.push(...Constant.resolveExtensions.map(_ => `.${prefix}${_}`));
+        }
+
+        resolveExtensions.push(...Constant.resolveExtensions);
+
+        return resolveExtensions;
+    }
+}

package/src/WebpackConfigGenerator/{WebpackResolveModulesFactory.js → WebpackResolveModulesFactory.ts}

@@ -1,9 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebpackResolveModulesFactory = void 0;
-class WebpackResolveModulesFactory {
-    static generate({ projectSrcDirectory }) {
+interface WebpackResolveModulesFactoryOptions {
+    projectSrcDirectory: string;
+}
+
+export class WebpackResolveModulesFactory {
+    static generate({projectSrcDirectory}: WebpackResolveModulesFactoryOptions): string[] {
         const resolveModules = [];
+
         /**
          * To let webpack know how to resolve non-relative paths when `tsconfig.json#compilerOptions.baseUrl` is set to "./src"
          * Maybe refactor to a better resolution/aliasing solution later(?)
@@ -24,13 +26,13 @@ class WebpackResolveModulesFactory {
          * ```
          */
         resolveModules.push(projectSrcDirectory);
+
         /**
          * The default behavior to resolve non-relative paths is by looking inside `node_modules` folder.
          * Put at the end so this has the lowest precedence.
          */
         resolveModules.push("node_modules");
+
         return resolveModules;
     }
 }
-exports.WebpackResolveModulesFactory = WebpackResolveModulesFactory;
-//# sourceMappingURL=WebpackResolveModulesFactory.js.map

package/src/WebpackConfigGenerator/index.ts

@@ -0,0 +1,213 @@
+import {Utility} from "@pinnacle0/devtool-util";
+import path from "path";
+import type webpack from "webpack";
+import {Constant} from "../Constant";
+import {CoreUtil} from "../CoreUtil";
+import type {EntryDescriptor, WebpackConfigGeneratorOptions} from "../type";
+import {ConfigEntryDescriptorsFactory} from "./ConfigEntryDescriptorsFactory";
+import {HTMLWebpackPluginsFactory} from "./HTMLWebpackPluginsFactory";
+import {WebpackConfigSerializationUtil} from "./WebpackConfigSerializationUtil";
+import {WebpackEntryFactory} from "./WebpackEntryFactory";
+import {WebpackOutputPublicURLFactory} from "./WebpackOutputPublicURLFactory";
+import {WebpackResolveAliasFactory} from "./WebpackResolveAliasFactory";
+import {WebpackResolveExtensionsFactory} from "./WebpackResolveExtensionsFactory";
+import {WebpackResolveModulesFactory} from "./WebpackResolveModulesFactory";
+import {Plugin} from "./Plugin";
+import {Rule} from "./Rule";
+
+/**
+ * Generates a webpack config with sane defaults.
+ */
+export class WebpackConfigGenerator {
+    private readonly env: string | null;
+    private readonly projectDirectory: string;
+    private readonly projectSrcDirectory: string;
+    private readonly tsconfigFilepath: string;
+    private readonly enableProfiling: boolean;
+    private readonly maxEntryPointKiloByte: number;
+    private readonly maxAssetKiloByte: number;
+    private readonly isFastMode: boolean;
+    private readonly verbose: boolean;
+    private readonly defineVars: {[key: string]: string};
+    private readonly extraExtensionsForOtherRule: string[];
+
+    private readonly configEntryDescriptors: EntryDescriptor[];
+    private readonly entry: NonNullable<webpack.Configuration["entry"]>;
+    private readonly htmlWebpackPluginInstances: NonNullable<webpack.Configuration["plugins"]>;
+    private readonly resolveExtensions: NonNullable<NonNullable<webpack.Configuration["resolve"]>["extensions"]>;
+    private readonly resolveModules: NonNullable<NonNullable<webpack.Configuration["resolve"]>["modules"]>;
+    private readonly resolveAliases: NonNullable<NonNullable<webpack.Configuration["resolve"]>["alias"]>;
+    private readonly outputPublicPath: string;
+
+    private readonly logger = Utility.createConsoleLogger("WebpackConfigGenerator");
+
+    constructor(private readonly options: WebpackConfigGeneratorOptions) {
+        this.env = CoreUtil.currentEnv();
+        this.projectDirectory = options.projectDirectory;
+        this.projectSrcDirectory = path.join(options.projectDirectory, "src");
+        this.tsconfigFilepath = path.join(options.projectDirectory, "tsconfig.json");
+
+        this.enableProfiling = CoreUtil.profilingEnabled();
+        this.isFastMode = CoreUtil.isFastMode();
+        this.maxEntryPointKiloByte = options.maxEntryPointKiloByte ?? Constant.maxEntryPointKiloByte;
+        this.maxAssetKiloByte = options.maxAssetKiloByte ?? Constant.maxAssetKiloByte;
+        this.verbose = options.verbose || false;
+        this.defineVars = options.defineVars || {};
+        this.extraExtensionsForOtherRule = options.extraExtensionsForOtherRule || [];
+
+        this.configEntryDescriptors = ConfigEntryDescriptorsFactory.generate({
+            indexName: options.indexName || "index",
+            projectSrcDirectory: this.projectSrcDirectory,
+            extraEntries: options.extraEntries || {},
+        });
+        this.entry = WebpackEntryFactory.generate({
+            configEntryDescriptors: this.configEntryDescriptors,
+        });
+        this.htmlWebpackPluginInstances = HTMLWebpackPluginsFactory.generate({
+            configEntryDescriptors: this.configEntryDescriptors,
+        });
+        this.outputPublicPath = WebpackOutputPublicURLFactory.generate({
+            env: this.env,
+            webpackPublicPath: options.webpackPublicPath,
+        });
+        this.resolveExtensions = WebpackResolveExtensionsFactory.generate({
+            prioritizedExtensionPrefixes: options.prioritizedExtensionPrefixes,
+        });
+        this.resolveModules = WebpackResolveModulesFactory.generate({
+            projectSrcDirectory: this.projectSrcDirectory,
+        });
+        this.resolveAliases = WebpackResolveAliasFactory.generate({
+            env: this.env,
+            resolvers: options.dynamicPathResolvers ?? [],
+        });
+
+        this.logger.info("Config constructed:");
+        for (const info of [
+            `-- Code Checking: ${this.isFastMode ? "Minimal Check" : "Default"}`,
+            `-- Env: ${this.env || "[N/A]"}`,
+            `-- Src Directory: ${this.projectSrcDirectory}`,
+            `-- HTML Entries: ${Object.keys(this.entry).join(" / ")}`,
+            `-- Webpack Public URL: ${this.outputPublicPath}`,
+            `-- Dynamic Aliases: ${JSON.stringify(this.resolveAliases, null, 4)}`,
+            `-- Use Cache: ${this.env === null}`,
+        ]) {
+            console.info(info);
+        }
+    }
+
+    development(): webpack.Configuration {
+        const config: webpack.Configuration = {
+            mode: "development",
+            entry: this.entry,
+            target: "web", // https://github.com/webpack/webpack-dev-server/issues/2758 Hot-reload will break if we provide list to target
+            output: {
+                filename: "static/js/[name].js",
+                publicPath: "/",
+            },
+            resolve: {
+                extensions: this.resolveExtensions,
+                modules: this.resolveModules,
+                alias: this.resolveAliases,
+            },
+            devtool: "inline-cheap-module-source-map",
+            optimization: {
+                usedExports: true,
+                splitChunks: {
+                    automaticNameDelimiter: "-",
+                    maxAsyncRequests: 30,
+                },
+            },
+            module: {
+                rules: [
+                    Rule.ts({tsconfigFilepath: this.tsconfigFilepath, fastRefresh: true}),
+                    Rule.stylesheet({minimize: false}),
+                    Rule.image(),
+                    Rule.other({extraExtensionsForOtherRule: this.extraExtensionsForOtherRule}),
+                    // prettier-format-preserve
+                ],
+            },
+            plugins: [
+                ...this.htmlWebpackPluginInstances,
+                Plugin.ignoreMomentLocale(),
+                Plugin.reactRefresh(),
+                Plugin.webpack.progress({enableProfiling: false}),
+                Plugin.webpack.define(this.defineVars),
+                // prettier-format-preserve
+            ],
+            cache:
+                this.env === null
+                    ? {
+                          type: "filesystem",
+                          cacheDirectory: path.join(this.projectDirectory, ".webpack-cache"),
+                      }
+                    : false,
+        };
+        if (this.verbose || CoreUtil.verbose()) {
+            this.logger.info("Full webpack config:");
+            console.info(WebpackConfigSerializationUtil.configToString(config));
+        }
+        return config;
+    }
+
+    production(outputDirectory: string): webpack.Configuration {
+        const config: webpack.Configuration = {
+            mode: "production",
+            entry: this.entry,
+            target: ["web", "es5"],
+            output: {
+                path: outputDirectory,
+                filename: this.enableProfiling ? "static/js/[name].js" : pathInfo => this.configEntryDescriptors.find(_ => _.name === pathInfo.chunk!.name)!.outputFilename,
+                chunkFilename: this.enableProfiling ? "static/js/[id].[name].js" : "static/js/[id].[chunkhash:8].js",
+                publicPath: this.outputPublicPath,
+                crossOriginLoading: "anonymous",
+            },
+            resolve: {
+                extensions: this.resolveExtensions,
+                modules: this.resolveModules,
+                alias: this.resolveAliases,
+            },
+            bail: true,
+            optimization: {
+                splitChunks: {
+                    automaticNameDelimiter: "-",
+                    maxAsyncRequests: 30,
+                },
+                minimizer: [
+                    Plugin.minimizer.terser({sourceMap: true}),
+                    Plugin.minimizer.css(),
+                    // prettier-format-preserve
+                ],
+            },
+            performance: {
+                maxEntrypointSize: this.enableProfiling ? Number.MAX_SAFE_INTEGER : this.maxEntryPointKiloByte * 1000,
+                maxAssetSize: this.maxAssetKiloByte * 1000,
+                assetFilter: (filename: string) => Constant.mediaExtensions.concat(this.extraExtensionsForOtherRule).every(_ => !filename.endsWith(_)),
+            },
+            module: {
+                rules: [
+                    Rule.ts({tsconfigFilepath: this.tsconfigFilepath, fastRefresh: false}),
+                    Rule.stylesheet({minimize: true}),
+                    Rule.image(),
+                    Rule.other({extraExtensionsForOtherRule: this.extraExtensionsForOtherRule}),
+                    // prettier-format-preserve
+                ],
+            },
+            plugins: [
+                ...this.htmlWebpackPluginInstances,
+                Plugin.scriptTagCrossOriginPlugin(),
+                Plugin.ignoreMomentLocale(),
+                Plugin.fileOutput.miniCssExtract({enableProfiling: this.enableProfiling}),
+                ...(this.enableProfiling ? [Plugin.webpack.progress({enableProfiling: true})] : []), // disable to not bloat up CI logs
+                Plugin.webpack.define(this.defineVars),
+                // prettier-format-preserve
+            ],
+        };
+        if (this.verbose || CoreUtil.verbose()) {
+            this.logger.info("Full webpack config:");
+            console.info(WebpackConfigSerializationUtil.configToString(config));
+        }
+        return config;
+    }
+}
+
+export type {WebpackConfigGeneratorOptions};