@rushstack/heft-webpack5-plugin 0.6.0-rc.4 → 0.6.1

package/README.md

@@ -1,12 +1,11 @@
 # @rushstack/heft-webpack5-plugin
 
-This is a Heft plugin for using Webpack 5.
+This is a Heft plugin for using Webpack 5 during the "bundle" stage.
 
 ## Links
 
 - [CHANGELOG.md](
   https://github.com/microsoft/rushstack/blob/main/heft-plugins/heft-webpack5-plugin/CHANGELOG.md) - Find
   out what's new in the latest version
-- [@rushstack/heft](https://www.npmjs.com/package/@rushstack/heft) - Heft is a config-driven toolchain that invokes popular tools such as TypeScript, ESLint, Jest, Webpack, and API Extractor.
 
 Heft is part of the [Rush Stack](https://rushstack.io/) family of projects.

package/dist/heft-webpack5-plugin.d.ts

@@ -1,114 +1,49 @@
-import type { AsyncParallelHook } from 'tapable';
-import type { AsyncSeriesBailHook } from 'tapable';
-import type { AsyncSeriesHook } from 'tapable';
 import type { Configuration } from 'webpack-dev-server';
-import type { HeftConfiguration } from '@rushstack/heft';
-import type { IHeftTaskSession } from '@rushstack/heft';
-import type * as TWebpack from 'webpack';
+import type { IBuildStageProperties } from '@rushstack/heft';
+import type { IBundleSubstageProperties } from '@rushstack/heft';
+import type { IHeftPlugin } from '@rushstack/heft';
+import type * as webpack from 'webpack';
 
 /**
  * @public
  */
-export declare type IWebpackConfiguration = IWebpackConfigurationWithDevServer | IWebpackConfigurationWithDevServer[];
+declare const _default: IHeftPlugin<void>;
+export default _default;
 
 /**
- * The environment passed into the Webpack configuration function. Loosely based
- * on the default Webpack environment options, specified here:
- * https://webpack.js.org/api/cli/#environment-options
- *
  * @public
  */
-export declare interface IWebpackConfigurationFnEnvironment {
-    /**
-     * Whether or not the run is in production mode. Synonym of
-     * IWebpackConfigurationFnEnvironment.production.
-     */
-    prod: boolean;
-    /**
-     * Whether or not the run is in production mode. Synonym of
-     * IWebpackConfigurationFnEnvironment.prod.
-     */
-    production: boolean;
-    /**
-     * The task session provided to the plugin.
-     */
-    taskSession: IHeftTaskSession;
-    /**
-     * The Heft configuration provided to the plugin.
-     */
-    heftConfiguration: HeftConfiguration;
-    /**
-     * The resolved Webpack package.
-     */
-    webpack: typeof TWebpack;
-}
-
-/**
- * @public
- */
-export declare interface IWebpackConfigurationWithDevServer extends TWebpack.Configuration {
-    devServer?: Configuration;
-}
-
-/**
- * @public
- */
-export declare interface IWebpackPluginAccessor {
-    /**
-     * Hooks that are called at various points in the Webpack plugin lifecycle.
-     */
-    readonly hooks: IWebpackPluginAccessorHooks;
-    /**
-     * Parameters that are provided by the Webpack plugin.
-     */
-    readonly parameters: IWebpackPluginAccessorParameters;
+export declare interface IWebpackBuildStageProperties extends IBuildStageProperties {
+    webpackStats?: webpack.Stats | webpack.MultiStats;
 }
 
 /**
  * @public
  */
-export declare interface IWebpackPluginAccessorHooks {
+export declare interface IWebpackBundleSubstageProperties extends IBundleSubstageProperties {
     /**
-     * A hook that allows for loading custom configurations used by the Webpack
-     * plugin. If a webpack configuration is provided, this will be populated automatically
-     * with the exports of the config file. If a webpack configuration is not provided,
-     * one will be loaded by the Webpack plugin.
+     * The configuration used by the Webpack plugin. This must be populated
+     * for Webpack to run. If webpackConfigFilePath is specified,
+     * this will be populated automatically with the exports of the
+     * config file referenced in that property.
      *
      * @remarks
-     * Tapable event handlers can return `false` instead of `undefined` to suppress
-     * other handlers from creating a configuration object, and prevent webpack from running.
-     */
-    readonly onLoadConfiguration: AsyncSeriesBailHook<never, never, never, IWebpackConfiguration | false>;
-    /**
-     * A hook that allows for modification of the loaded configuration used by the Webpack
-     * plugin. If no configuration was loaded, this hook will not be called.
+     * Tapable event handlers can return `null` instead of `undefined` to suppress
+     * other handlers from creating a configuration object.
      */
-    readonly onConfigure: AsyncSeriesHook<IWebpackConfiguration, never, never>;
-    /**
-     * A hook that provides the finalized configuration that will be used by Webpack.
-     * If no configuration was loaded, this hook will not be called.
-     */
-    readonly onAfterConfigure: AsyncParallelHook<IWebpackConfiguration, never, never>;
-    /**
-     * A hook that provides the stats output from Webpack. If no configuration is loaded,
-     * this hook will not be called.
-     */
-    readonly onEmitStats: AsyncParallelHook<TWebpack.Stats | TWebpack.MultiStats, never, never>;
+    webpackConfiguration?: webpack.Configuration | webpack.Configuration[] | null;
 }
 
 /**
  * @public
  */
-export declare interface IWebpackPluginAccessorParameters {
-    /**
-     * Whether or not serve mode was enabled by passing the `--serve` flag.
-     */
-    readonly isServeMode: boolean;
-}
+export declare type IWebpackConfiguration = IWebpackConfigurationWithDevServer | IWebpackConfigurationWithDevServer[] | undefined;
 
 /**
  * @public
  */
-export declare const PluginName: 'webpack5-plugin';
+export declare interface IWebpackConfigurationWithDevServer extends webpack.Configuration {
+    devServer?: Configuration;
+}
 
 export { }

package/dist/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.33.7"
+      "packageVersion": "7.34.4"
     }
   ]
 }

package/lib/WebpackConfigurationLoader.d.ts

@@ -1,19 +1,7 @@
-import type * as TWebpack from 'webpack';
-import type { IScopedLogger, IHeftTaskSession, HeftConfiguration } from '@rushstack/heft';
-import type { IWebpackPluginOptions } from './Webpack5Plugin';
-import type { IWebpackConfiguration } from './shared';
-interface ILoadWebpackConfigurationOptions extends IWebpackPluginOptions {
-    taskSession: IHeftTaskSession;
-    heftConfiguration: HeftConfiguration;
-    loadWebpackAsyncFn: () => Promise<typeof TWebpack>;
-}
+import type { IBuildStageProperties, ScopedLogger } from '@rushstack/heft';
+import { IWebpackConfiguration } from './shared';
 export declare class WebpackConfigurationLoader {
-    private readonly _logger;
-    private readonly _production;
-    private readonly _serveMode;
-    constructor(logger: IScopedLogger, production: boolean, serveMode: boolean);
-    tryLoadWebpackConfigurationAsync(options: ILoadWebpackConfigurationOptions): Promise<IWebpackConfiguration | undefined>;
-    private _tryLoadWebpackConfigurationInnerAsync;
+    static tryLoadWebpackConfigAsync(logger: ScopedLogger, buildFolder: string, buildProperties: IBuildStageProperties): Promise<IWebpackConfiguration | undefined>;
+    private static _tryLoadWebpackConfiguration;
 }
-export {};
 //# sourceMappingURL=WebpackConfigurationLoader.d.ts.map

package/lib/WebpackConfigurationLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebpackConfigurationLoader.d.ts","sourceRoot":"","sources":["../src/WebpackConfigurationLoader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,QAAQ,MAAM,SAAS,CAAC;AAEzC,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAE1F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,KAAK,EAAE,qBAAqB,EAAsC,MAAM,UAAU,CAAC;AAW1F,UAAU,gCAAiC,SAAQ,qBAAqB;IACtE,WAAW,EAAE,gBAAgB,CAAC;IAC9B,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,kBAAkB,EAAE,MAAM,OAAO,CAAC,OAAO,QAAQ,CAAC,CAAC;CACpD;AAKD,qBAAa,0BAA0B;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IACxC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAU;IACtC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAU;gBAElB,MAAM,EAAE,aAAa,EAAE,UAAU,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO;IAMpE,gCAAgC,CAC3C,OAAO,EAAE,gCAAgC,GACxC,OAAO,CAAC,qBAAqB,GAAG,SAAS,CAAC;YAwD/B,sCAAsC;CAmBrD"}
+{"version":3,"file":"WebpackConfigurationLoader.d.ts","sourceRoot":"","sources":["../src/WebpackConfigurationLoader.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAuBjD,qBAAa,0BAA0B;WACjB,yBAAyB,CAC3C,MAAM,EAAE,YAAY,EACpB,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,qBAAqB,GACrC,OAAO,CAAC,qBAAqB,GAAG,SAAS,CAAC;IAgD7C,OAAO,CAAC,MAAM,CAAC,4BAA4B;CAe5C"}

package/lib/WebpackConfigurationLoader.js

@@ -28,46 +28,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebpackConfigurationLoader = void 0;
 const path = __importStar(require("path"));
 const node_core_library_1 = require("@rushstack/node-core-library");
-const DEFAULT_WEBPACK_CONFIG_PATH = './webpack.config.js';
-const DEFAULT_WEBPACK_DEV_CONFIG_PATH = './webpack.dev.config.js';
 class WebpackConfigurationLoader {
-    constructor(logger, production, serveMode) {
-        this._logger = logger;
-        this._production = production;
-        this._serveMode = serveMode;
-    }
-    async tryLoadWebpackConfigurationAsync(options) {
+    static async tryLoadWebpackConfigAsync(logger, buildFolder, buildProperties) {
         // TODO: Eventually replace this custom logic with a call to this utility in in webpack-cli:
         // https://github.com/webpack/webpack-cli/blob/next/packages/webpack-cli/lib/groups/ConfigGroup.js
-        const { taskSession, heftConfiguration, configurationPath, devConfigurationPath, loadWebpackAsyncFn } = options;
+        const webpackConfigFiles = await findWebpackConfigAsync(buildFolder);
+        const webpackDevConfigFilename = webpackConfigFiles.dev;
+        const webpackConfigFilename = webpackConfigFiles.prod;
         let webpackConfigJs;
         try {
-            const buildFolderPath = heftConfiguration.buildFolderPath;
-            if (this._serveMode) {
-                const devConfigPath = path.resolve(buildFolderPath, devConfigurationPath || DEFAULT_WEBPACK_DEV_CONFIG_PATH);
-                this._logger.terminal.writeVerboseLine(`Attempting to load webpack configuration from "${devConfigPath}".`);
-                webpackConfigJs = await this._tryLoadWebpackConfigurationInnerAsync(devConfigPath);
+            if (buildProperties.serveMode && webpackDevConfigFilename) {
+                logger.terminal.writeVerboseLine(`Attempting to load webpack configuration from "${webpackDevConfigFilename}".`);
+                webpackConfigJs = WebpackConfigurationLoader._tryLoadWebpackConfiguration(buildFolder, webpackDevConfigFilename);
             }
-            if (!webpackConfigJs) {
-                const configPath = path.resolve(buildFolderPath, configurationPath || DEFAULT_WEBPACK_CONFIG_PATH);
-                this._logger.terminal.writeVerboseLine(`Attempting to load webpack configuration from "${configPath}".`);
-                webpackConfigJs = await this._tryLoadWebpackConfigurationInnerAsync(configPath);
+            if (!webpackConfigJs && webpackConfigFilename) {
+                logger.terminal.writeVerboseLine(`Attempting to load webpack configuration from "${webpackConfigFilename}".`);
+                webpackConfigJs = WebpackConfigurationLoader._tryLoadWebpackConfiguration(buildFolder, webpackConfigFilename);
             }
         }
         catch (error) {
-            this._logger.emitError(error);
+            logger.emitError(error);
         }
         if (webpackConfigJs) {
             const webpackConfig = webpackConfigJs.default || webpackConfigJs;
             if (typeof webpackConfig === 'function') {
-                // Defer loading of webpack until we know for sure that we will need it
-                return webpackConfig({
-                    prod: this._production,
-                    production: this._production,
-                    taskSession,
-                    heftConfiguration,
-                    webpack: await loadWebpackAsyncFn()
-                });
+                return webpackConfig({ prod: buildProperties.production, production: buildProperties.production });
             }
             else {
                 return webpackConfig;
@@ -77,19 +62,14 @@ class WebpackConfigurationLoader {
             return undefined;
         }
     }
-    async _tryLoadWebpackConfigurationInnerAsync(configurationPath) {
-        const configExists = await node_core_library_1.FileSystem.existsAsync(configurationPath);
-        if (configExists) {
+    static _tryLoadWebpackConfiguration(buildFolder, configurationFilename) {
+        const fullWebpackConfigPath = path.join(buildFolder, configurationFilename);
+        if (node_core_library_1.FileSystem.exists(fullWebpackConfigPath)) {
             try {
-                return await Promise.resolve().then(() => __importStar(require(configurationPath)));
+                return require(fullWebpackConfigPath);
             }
             catch (e) {
-                const error = e;
-                if (error.code === 'ERR_MODULE_NOT_FOUND') {
-                    // No configuration found, return undefined.
-                    return undefined;
-                }
-                throw new Error(`Error loading webpack configuration at "${configurationPath}": ${e}`);
+                throw new Error(`Error loading webpack configuration at "${fullWebpackConfigPath}": ${e}`);
             }
         }
         else {
@@ -98,4 +78,34 @@ class WebpackConfigurationLoader {
     }
 }
 exports.WebpackConfigurationLoader = WebpackConfigurationLoader;
+async function findWebpackConfigAsync(buildFolder) {
+    try {
+        const folderItems = await node_core_library_1.FileSystem.readFolderItemsAsync(buildFolder);
+        const dev = [];
+        const prod = [];
+        for (const folderItem of folderItems) {
+            if (folderItem.isFile()) {
+                if (folderItem.name.match(/^webpack.dev.config\.(cjs|js|mjs)$/)) {
+                    dev.push(folderItem.name);
+                }
+                else if (folderItem.name.match(/^webpack.config\.(cjs|js|mjs)$/)) {
+                    prod.push(folderItem.name);
+                }
+            }
+        }
+        if (dev.length > 1) {
+            throw new Error(`Error: Found more than one dev webpack configuration file.`);
+        }
+        else if (prod.length > 1) {
+            throw new Error(`Error: Found more than one non-dev webpack configuration file.`);
+        }
+        return {
+            dev: dev[0],
+            prod: prod[0]
+        };
+    }
+    catch (e) {
+        throw new Error(`Error finding webpack configuration: ${e}`);
+    }
+}
 //# sourceMappingURL=WebpackConfigurationLoader.js.map

package/lib/WebpackConfigurationLoader.js.map

@@ -1 +1 @@
-{"version":3,"file":"WebpackConfigurationLoader.js","sourceRoot":"","sources":["../src/WebpackConfigurationLoader.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;;;;;;;;;;;;;;;;;;;;;;;;AAE3D,2CAA6B;AAE7B,oEAA0D;AAqB1D,MAAM,2BAA2B,GAA0B,qBAAqB,CAAC;AACjF,MAAM,+BAA+B,GAA8B,yBAAyB,CAAC;AAE7F,MAAa,0BAA0B;IAKrC,YAAmB,MAAqB,EAAE,UAAmB,EAAE,SAAkB;QAC/E,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;QAC9B,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;IAC9B,CAAC;IAEM,KAAK,CAAC,gCAAgC,CAC3C,OAAyC;QAEzC,4FAA4F;QAC5F,kGAAkG;QAElG,MAAM,EAAE,WAAW,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,GACnG,OAAO,CAAC;QACV,IAAI,eAA6C,CAAC;QAElD,IAAI;YACF,MAAM,eAAe,GAAW,iBAAiB,CAAC,eAAe,CAAC;YAClE,IAAI,IAAI,CAAC,UAAU,EAAE;gBACnB,MAAM,aAAa,GAAW,IAAI,CAAC,OAAO,CACxC,eAAe,EACf,oBAAoB,IAAI,+BAA+B,CACxD,CAAC;gBACF,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CACpC,kDAAkD,aAAa,IAAI,CACpE,CAAC;gBACF,eAAe,GAAG,MAAM,IAAI,CAAC,sCAAsC,CAAC,aAAa,CAAC,CAAC;aACpF;YAED,IAAI,CAAC,eAAe,EAAE;gBACpB,MAAM,UAAU,GAAW,IAAI,CAAC,OAAO,CACrC,eAAe,EACf,iBAAiB,IAAI,2BAA2B,CACjD,CAAC;gBACF,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CACpC,kDAAkD,UAAU,IAAI,CACjE,CAAC;gBACF,eAAe,GAAG,MAAM,IAAI,CAAC,sCAAsC,CAAC,UAAU,CAAC,CAAC;aACjF;SACF;QAAC,OAAO,KAAK,EAAE;YACd,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,KAAc,CAAC,CAAC;SACxC;QAED,IAAI,eAAe,EAAE;YACnB,MAAM,aAAa,GAChB,eAAuD,CAAC,OAAO,IAAI,eAAe,CAAC;YAEtF,IAAI,OAAO,aAAa,KAAK,UAAU,EAAE;gBACvC,uEAAuE;gBACvE,OAAO,aAAa,CAAC;oBACnB,IAAI,EAAE,IAAI,CAAC,WAAW;oBACtB,UAAU,EAAE,IAAI,CAAC,WAAW;oBAC5B,WAAW;oBACX,iBAAiB;oBACjB,OAAO,EAAE,MAAM,kBAAkB,EAAE;iBACpC,CAAC,CAAC;aACJ;iBAAM;gBACL,OAAO,aAAa,CAAC;aACtB;SACF;aAAM;YACL,OAAO,SAAS,CAAC;SAClB;IACH,CAAC;IAEO,KAAK,CAAC,sCAAsC,CAClD,iBAAyB;QAEzB,MAAM,YAAY,GAAY,MAAM,8BAAU,CAAC,WAAW,CAAC,iBAAiB,CAAC,CAAC;QAC9E,IAAI,YAAY,EAAE;YAChB,IAAI;gBACF,OAAO,wDAAa,iBAAiB,GAAC,CAAC;aACxC;YAAC,OAAO,CAAC,EAAE;gBACV,MAAM,KAAK,GAA0B,CAA0B,CAAC;gBAChE,IAAI,KAAK,CAAC,IAAI,KAAK,sBAAsB,EAAE;oBACzC,4CAA4C;oBAC5C,OAAO,SAAS,CAAC;iBAClB;gBACD,MAAM,IAAI,KAAK,CAAC,2CAA2C,iBAAiB,MAAM,CAAC,EAAE,CAAC,CAAC;aACxF;SACF;aAAM;YACL,OAAO,SAAS,CAAC;SAClB;IACH,CAAC;CACF;AAxFD,gEAwFC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport * as path from 'path';\nimport type * as TWebpack from 'webpack';\nimport { FileSystem } from '@rushstack/node-core-library';\nimport type { IScopedLogger, IHeftTaskSession, HeftConfiguration } from '@rushstack/heft';\n\nimport type { IWebpackPluginOptions } from './Webpack5Plugin';\nimport type { IWebpackConfiguration, IWebpackConfigurationFnEnvironment } from './shared';\n\ntype IWebpackConfigJsExport =\n  | TWebpack.Configuration\n  | TWebpack.Configuration[]\n  | Promise<TWebpack.Configuration>\n  | Promise<TWebpack.Configuration[]>\n  | ((env: IWebpackConfigurationFnEnvironment) => TWebpack.Configuration | TWebpack.Configuration[])\n  | ((env: IWebpackConfigurationFnEnvironment) => Promise<TWebpack.Configuration | TWebpack.Configuration[]>);\ntype IWebpackConfigJs = IWebpackConfigJsExport | { default: IWebpackConfigJsExport };\n\ninterface ILoadWebpackConfigurationOptions extends IWebpackPluginOptions {\n  taskSession: IHeftTaskSession;\n  heftConfiguration: HeftConfiguration;\n  loadWebpackAsyncFn: () => Promise<typeof TWebpack>;\n}\n\nconst DEFAULT_WEBPACK_CONFIG_PATH: './webpack.config.js' = './webpack.config.js';\nconst DEFAULT_WEBPACK_DEV_CONFIG_PATH: './webpack.dev.config.js' = './webpack.dev.config.js';\n\nexport class WebpackConfigurationLoader {\n  private readonly _logger: IScopedLogger;\n  private readonly _production: boolean;\n  private readonly _serveMode: boolean;\n\n  public constructor(logger: IScopedLogger, production: boolean, serveMode: boolean) {\n    this._logger = logger;\n    this._production = production;\n    this._serveMode = serveMode;\n  }\n\n  public async tryLoadWebpackConfigurationAsync(\n    options: ILoadWebpackConfigurationOptions\n  ): Promise<IWebpackConfiguration | undefined> {\n    // TODO: Eventually replace this custom logic with a call to this utility in in webpack-cli:\n    // https://github.com/webpack/webpack-cli/blob/next/packages/webpack-cli/lib/groups/ConfigGroup.js\n\n    const { taskSession, heftConfiguration, configurationPath, devConfigurationPath, loadWebpackAsyncFn } =\n      options;\n    let webpackConfigJs: IWebpackConfigJs | undefined;\n\n    try {\n      const buildFolderPath: string = heftConfiguration.buildFolderPath;\n      if (this._serveMode) {\n        const devConfigPath: string = path.resolve(\n          buildFolderPath,\n          devConfigurationPath || DEFAULT_WEBPACK_DEV_CONFIG_PATH\n        );\n        this._logger.terminal.writeVerboseLine(\n          `Attempting to load webpack configuration from \"${devConfigPath}\".`\n        );\n        webpackConfigJs = await this._tryLoadWebpackConfigurationInnerAsync(devConfigPath);\n      }\n\n      if (!webpackConfigJs) {\n        const configPath: string = path.resolve(\n          buildFolderPath,\n          configurationPath || DEFAULT_WEBPACK_CONFIG_PATH\n        );\n        this._logger.terminal.writeVerboseLine(\n          `Attempting to load webpack configuration from \"${configPath}\".`\n        );\n        webpackConfigJs = await this._tryLoadWebpackConfigurationInnerAsync(configPath);\n      }\n    } catch (error) {\n      this._logger.emitError(error as Error);\n    }\n\n    if (webpackConfigJs) {\n      const webpackConfig: IWebpackConfigJsExport =\n        (webpackConfigJs as { default: IWebpackConfigJsExport }).default || webpackConfigJs;\n\n      if (typeof webpackConfig === 'function') {\n        // Defer loading of webpack until we know for sure that we will need it\n        return webpackConfig({\n          prod: this._production,\n          production: this._production,\n          taskSession,\n          heftConfiguration,\n          webpack: await loadWebpackAsyncFn()\n        });\n      } else {\n        return webpackConfig;\n      }\n    } else {\n      return undefined;\n    }\n  }\n\n  private async _tryLoadWebpackConfigurationInnerAsync(\n    configurationPath: string\n  ): Promise<IWebpackConfigJs | undefined> {\n    const configExists: boolean = await FileSystem.existsAsync(configurationPath);\n    if (configExists) {\n      try {\n        return await import(configurationPath);\n      } catch (e) {\n        const error: NodeJS.ErrnoException = e as NodeJS.ErrnoException;\n        if (error.code === 'ERR_MODULE_NOT_FOUND') {\n          // No configuration found, return undefined.\n          return undefined;\n        }\n        throw new Error(`Error loading webpack configuration at \"${configurationPath}\": ${e}`);\n      }\n    } else {\n      return undefined;\n    }\n  }\n}\n"]}
+{"version":3,"file":"WebpackConfigurationLoader.js","sourceRoot":"","sources":["../src/WebpackConfigurationLoader.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;;;;;;;;;;;;;;;;;;;;;;;;AAE3D,2CAA6B;AAC7B,oEAA2E;AA2B3E,MAAa,0BAA0B;IAC9B,MAAM,CAAC,KAAK,CAAC,yBAAyB,CAC3C,MAAoB,EACpB,WAAmB,EACnB,eAAsC;QAEtC,4FAA4F;QAC5F,kGAAkG;QAElG,MAAM,kBAAkB,GAAwC,MAAM,sBAAsB,CAAC,WAAW,CAAC,CAAC;QAC1G,MAAM,wBAAwB,GAAuB,kBAAkB,CAAC,GAAG,CAAC;QAC5E,MAAM,qBAAqB,GAAuB,kBAAkB,CAAC,IAAI,CAAC;QAE1E,IAAI,eAA6C,CAAC;QAElD,IAAI;YACF,IAAI,eAAe,CAAC,SAAS,IAAI,wBAAwB,EAAE;gBACzD,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAC9B,kDAAkD,wBAAwB,IAAI,CAC/E,CAAC;gBACF,eAAe,GAAG,0BAA0B,CAAC,4BAA4B,CACvE,WAAW,EACX,wBAAwB,CACzB,CAAC;aACH;YAED,IAAI,CAAC,eAAe,IAAI,qBAAqB,EAAE;gBAC7C,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAC9B,kDAAkD,qBAAqB,IAAI,CAC5E,CAAC;gBACF,eAAe,GAAG,0BAA0B,CAAC,4BAA4B,CACvE,WAAW,EACX,qBAAqB,CACtB,CAAC;aACH;SACF;QAAC,OAAO,KAAK,EAAE;YACd,MAAM,CAAC,SAAS,CAAC,KAAc,CAAC,CAAC;SAClC;QAED,IAAI,eAAe,EAAE;YACnB,MAAM,aAAa,GAChB,eAAuD,CAAC,OAAO,IAAI,eAAe,CAAC;YAEtF,IAAI,OAAO,aAAa,KAAK,UAAU,EAAE;gBACvC,OAAO,aAAa,CAAC,EAAE,IAAI,EAAE,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,eAAe,CAAC,UAAU,EAAE,CAAC,CAAC;aACpG;iBAAM;gBACL,OAAO,aAAa,CAAC;aACtB;SACF;aAAM;YACL,OAAO,SAAS,CAAC;SAClB;IACH,CAAC;IAEO,MAAM,CAAC,4BAA4B,CACzC,WAAmB,EACnB,qBAA6B;QAE7B,MAAM,qBAAqB,GAAW,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,qBAAqB,CAAC,CAAC;QACpF,IAAI,8BAAU,CAAC,MAAM,CAAC,qBAAqB,CAAC,EAAE;YAC5C,IAAI;gBACF,OAAO,OAAO,CAAC,qBAAqB,CAAC,CAAC;aACvC;YAAC,OAAO,CAAC,EAAE;gBACV,MAAM,IAAI,KAAK,CAAC,2CAA2C,qBAAqB,MAAM,CAAC,EAAE,CAAC,CAAC;aAC5F;SACF;aAAM;YACL,OAAO,SAAS,CAAC;SAClB;IACH,CAAC;CACF;AApED,gEAoEC;AAED,KAAK,UAAU,sBAAsB,CAAC,WAAmB;IACvD,IAAI;QACF,MAAM,WAAW,GAAiB,MAAM,8BAAU,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;QACrF,MAAM,GAAG,GAAa,EAAE,CAAC;QACzB,MAAM,IAAI,GAAa,EAAE,CAAC;QAE1B,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE;YACpC,IAAI,UAAU,CAAC,MAAM,EAAE,EAAE;gBACvB,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,oCAAoC,CAAC,EAAE;oBAC/D,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;iBAC3B;qBAAM,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,gCAAgC,CAAC,EAAE;oBAClE,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;iBAC5B;aACF;SACF;QAED,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE;YAClB,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;SAC/E;aAAM,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;YAC1B,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAC;SACnF;QAED,OAAO;YACL,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;YACX,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;SACd,CAAC;KACH;IAAC,OAAO,CAAC,EAAE;QACV,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,EAAE,CAAC,CAAC;KAC9D;AACH,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport * as path from 'path';\nimport { type FolderItem, FileSystem } from '@rushstack/node-core-library';\nimport type * as webpack from 'webpack';\nimport type { IBuildStageProperties, ScopedLogger } from '@rushstack/heft';\n\nimport { IWebpackConfiguration } from './shared';\n\n/**\n * See https://webpack.js.org/api/cli/#environment-options\n */\ninterface IWebpackConfigFunctionEnv {\n  prod: boolean;\n  production: boolean;\n}\ntype IWebpackConfigJsExport =\n  | webpack.Configuration\n  | webpack.Configuration[]\n  | Promise<webpack.Configuration>\n  | Promise<webpack.Configuration[]>\n  | ((env: IWebpackConfigFunctionEnv) => webpack.Configuration | webpack.Configuration[])\n  | ((env: IWebpackConfigFunctionEnv) => Promise<webpack.Configuration | webpack.Configuration[]>);\ntype IWebpackConfigJs = IWebpackConfigJsExport | { default: IWebpackConfigJsExport };\n\ninterface IWebpackConfigFileNames {\n  dev: string | undefined;\n  prod: string | undefined;\n}\n\nexport class WebpackConfigurationLoader {\n  public static async tryLoadWebpackConfigAsync(\n    logger: ScopedLogger,\n    buildFolder: string,\n    buildProperties: IBuildStageProperties\n  ): Promise<IWebpackConfiguration | undefined> {\n    // TODO: Eventually replace this custom logic with a call to this utility in in webpack-cli:\n    // https://github.com/webpack/webpack-cli/blob/next/packages/webpack-cli/lib/groups/ConfigGroup.js\n\n    const webpackConfigFiles: IWebpackConfigFileNames | undefined = await findWebpackConfigAsync(buildFolder);\n    const webpackDevConfigFilename: string | undefined = webpackConfigFiles.dev;\n    const webpackConfigFilename: string | undefined = webpackConfigFiles.prod;\n\n    let webpackConfigJs: IWebpackConfigJs | undefined;\n\n    try {\n      if (buildProperties.serveMode && webpackDevConfigFilename) {\n        logger.terminal.writeVerboseLine(\n          `Attempting to load webpack configuration from \"${webpackDevConfigFilename}\".`\n        );\n        webpackConfigJs = WebpackConfigurationLoader._tryLoadWebpackConfiguration(\n          buildFolder,\n          webpackDevConfigFilename\n        );\n      }\n\n      if (!webpackConfigJs && webpackConfigFilename) {\n        logger.terminal.writeVerboseLine(\n          `Attempting to load webpack configuration from \"${webpackConfigFilename}\".`\n        );\n        webpackConfigJs = WebpackConfigurationLoader._tryLoadWebpackConfiguration(\n          buildFolder,\n          webpackConfigFilename\n        );\n      }\n    } catch (error) {\n      logger.emitError(error as Error);\n    }\n\n    if (webpackConfigJs) {\n      const webpackConfig: IWebpackConfigJsExport =\n        (webpackConfigJs as { default: IWebpackConfigJsExport }).default || webpackConfigJs;\n\n      if (typeof webpackConfig === 'function') {\n        return webpackConfig({ prod: buildProperties.production, production: buildProperties.production });\n      } else {\n        return webpackConfig;\n      }\n    } else {\n      return undefined;\n    }\n  }\n\n  private static _tryLoadWebpackConfiguration(\n    buildFolder: string,\n    configurationFilename: string\n  ): IWebpackConfigJs | undefined {\n    const fullWebpackConfigPath: string = path.join(buildFolder, configurationFilename);\n    if (FileSystem.exists(fullWebpackConfigPath)) {\n      try {\n        return require(fullWebpackConfigPath);\n      } catch (e) {\n        throw new Error(`Error loading webpack configuration at \"${fullWebpackConfigPath}\": ${e}`);\n      }\n    } else {\n      return undefined;\n    }\n  }\n}\n\nasync function findWebpackConfigAsync(buildFolder: string): Promise<IWebpackConfigFileNames> {\n  try {\n    const folderItems: FolderItem[] = await FileSystem.readFolderItemsAsync(buildFolder);\n    const dev: string[] = [];\n    const prod: string[] = [];\n\n    for (const folderItem of folderItems) {\n      if (folderItem.isFile()) {\n        if (folderItem.name.match(/^webpack.dev.config\\.(cjs|js|mjs)$/)) {\n          dev.push(folderItem.name);\n        } else if (folderItem.name.match(/^webpack.config\\.(cjs|js|mjs)$/)) {\n          prod.push(folderItem.name);\n        }\n      }\n    }\n\n    if (dev.length > 1) {\n      throw new Error(`Error: Found more than one dev webpack configuration file.`);\n    } else if (prod.length > 1) {\n      throw new Error(`Error: Found more than one non-dev webpack configuration file.`);\n    }\n\n    return {\n      dev: dev[0],\n      prod: prod[0]\n    };\n  } catch (e) {\n    throw new Error(`Error finding webpack configuration: ${e}`);\n  }\n}\n"]}

package/lib/WebpackPlugin.d.ts

@@ -0,0 +1,14 @@
+import type { HeftConfiguration, HeftSession, IHeftPlugin } from '@rushstack/heft';
+/**
+ * @internal
+ */
+export declare class WebpackPlugin implements IHeftPlugin {
+    readonly pluginName: string;
+    private static _webpackVersions;
+    private static _getWebpackVersions;
+    apply(heftSession: HeftSession, heftConfiguration: HeftConfiguration): void;
+    private _runWebpackAsync;
+    private _emitErrors;
+    private _normalizeError;
+}
+//# sourceMappingURL=WebpackPlugin.d.ts.map

package/lib/WebpackPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebpackPlugin.d.ts","sourceRoot":"","sources":["../src/WebpackPlugin.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,iBAAiB,EACjB,WAAW,EAIX,WAAW,EAEZ,MAAM,iBAAiB,CAAC;AAmBzB;;GAEG;AACH,qBAAa,aAAc,YAAW,WAAW;IAC/C,SAAgB,UAAU,EAAE,MAAM,CAAe;IAEjD,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAA+B;IAC9D,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAkB3B,KAAK,CAAC,WAAW,EAAE,WAAW,EAAE,iBAAiB,EAAE,iBAAiB,GAAG,IAAI;YA2CpE,gBAAgB;IAoK9B,OAAO,CAAC,WAAW;IAyCnB,OAAO,CAAC,eAAe;CAqBxB"}

package/lib/WebpackPlugin.js

@@ -0,0 +1,266 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebpackPlugin = void 0;
+const nodePath = __importStar(require("path"));
+const node_core_library_1 = require("@rushstack/node-core-library");
+const WebpackConfigurationLoader_1 = require("./WebpackConfigurationLoader");
+const webpack = node_core_library_1.Import.lazy('webpack', require);
+const PLUGIN_NAME = 'WebpackPlugin';
+const WEBPACK_DEV_SERVER_PACKAGE_NAME = 'webpack-dev-server';
+const WEBPACK_DEV_SERVER_ENV_VAR_NAME = 'WEBPACK_DEV_SERVER';
+/**
+ * @internal
+ */
+class WebpackPlugin {
+    constructor() {
+        this.pluginName = PLUGIN_NAME;
+    }
+    static _getWebpackVersions() {
+        if (!WebpackPlugin._webpackVersions) {
+            const webpackDevServerPackageJsonPath = node_core_library_1.Import.resolveModule({
+                modulePath: 'webpack-dev-server/package.json',
+                baseFolderPath: __dirname
+            });
+            const webpackDevServerPackageJson = node_core_library_1.PackageJsonLookup.instance.loadPackageJson(webpackDevServerPackageJsonPath);
+            WebpackPlugin._webpackVersions = {
+                webpackVersion: webpack.version,
+                webpackDevServerVersion: webpackDevServerPackageJson.version
+            };
+        }
+        return WebpackPlugin._webpackVersions;
+    }
+    apply(heftSession, heftConfiguration) {
+        heftSession.hooks.build.tap(PLUGIN_NAME, (build) => {
+            build.hooks.bundle.tap(PLUGIN_NAME, (bundle) => {
+                bundle.hooks.configureWebpack.tap({ name: PLUGIN_NAME, stage: Number.MIN_SAFE_INTEGER }, (webpackConfiguration) => {
+                    const webpackVersions = WebpackPlugin._getWebpackVersions();
+                    bundle.properties.webpackVersion = webpack.version;
+                    bundle.properties.webpackDevServerVersion = webpackVersions.webpackDevServerVersion;
+                    return webpackConfiguration;
+                });
+                bundle.hooks.configureWebpack.tapPromise(PLUGIN_NAME, async (existingConfiguration) => {
+                    const logger = heftSession.requestScopedLogger('configure-webpack');
+                    if (existingConfiguration) {
+                        logger.terminal.writeVerboseLine('Skipping loading webpack config file because the webpack config has already been set.');
+                        return existingConfiguration;
+                    }
+                    else {
+                        return await WebpackConfigurationLoader_1.WebpackConfigurationLoader.tryLoadWebpackConfigAsync(logger, heftConfiguration.buildFolder, build.properties);
+                    }
+                });
+                bundle.hooks.run.tapPromise(PLUGIN_NAME, async () => {
+                    await this._runWebpackAsync(heftSession, heftConfiguration, bundle.properties, build.properties, heftConfiguration.terminalProvider.supportsColor);
+                });
+            });
+        });
+    }
+    async _runWebpackAsync(heftSession, heftConfiguration, bundleSubstageProperties, buildProperties, supportsColor) {
+        const webpackConfiguration = bundleSubstageProperties.webpackConfiguration;
+        if (!webpackConfiguration) {
+            return;
+        }
+        const logger = heftSession.requestScopedLogger('webpack');
+        const webpackVersions = WebpackPlugin._getWebpackVersions();
+        if (bundleSubstageProperties.webpackVersion !== webpackVersions.webpackVersion) {
+            logger.emitError(new Error(`The Webpack plugin expected to be configured with Webpack version ${webpackVersions.webpackVersion}, ` +
+                `but the configuration specifies version ${bundleSubstageProperties.webpackVersion}. ` +
+                'Are multiple versions of the Webpack plugin present?'));
+        }
+        if (bundleSubstageProperties.webpackDevServerVersion !== webpackVersions.webpackDevServerVersion) {
+            logger.emitError(new Error(`The Webpack plugin expected to be configured with webpack-dev-server version ${webpackVersions.webpackDevServerVersion}, ` +
+                `but the configuration specifies version ${bundleSubstageProperties.webpackDevServerVersion}. ` +
+                'Are multiple versions of the Webpack plugin present?'));
+        }
+        logger.terminal.writeLine(`Using Webpack version ${webpack.version}`);
+        let compiler;
+        if (Array.isArray(webpackConfiguration)) {
+            if (webpackConfiguration.length === 0) {
+                logger.terminal.writeLine('The webpack configuration is an empty array - nothing to do.');
+                return;
+            }
+            else {
+                compiler = webpack(webpackConfiguration); /* (webpack.Compilation[]) => MultiCompiler */
+            }
+        }
+        else {
+            compiler = webpack(webpackConfiguration); /* (webpack.Compilation) => Compiler */
+        }
+        if (buildProperties.serveMode) {
+            const defaultDevServerOptions = {
+                host: 'localhost',
+                devMiddleware: {
+                    publicPath: '/',
+                    stats: {
+                        cached: false,
+                        cachedAssets: false,
+                        colors: supportsColor
+                    }
+                },
+                client: {
+                    logging: 'info',
+                    webSocketURL: {
+                        port: 8080
+                    }
+                },
+                port: 8080
+            };
+            let options;
+            if (Array.isArray(webpackConfiguration)) {
+                const devServerOptions = webpackConfiguration
+                    .map((configuration) => configuration.devServer)
+                    .filter((devServer) => !!devServer);
+                if (devServerOptions.length > 1) {
+                    logger.emitWarning(new Error(`Detected multiple webpack devServer configurations, using the first one.`));
+                }
+                if (devServerOptions.length > 0) {
+                    options = Object.assign(Object.assign({}, defaultDevServerOptions), devServerOptions[0]);
+                }
+                else {
+                    options = defaultDevServerOptions;
+                }
+            }
+            else {
+                options = Object.assign(Object.assign({}, defaultDevServerOptions), webpackConfiguration.devServer);
+            }
+            // Register a plugin to callback after webpack is done with the first compilation
+            // so we can move on to post-build
+            let firstCompilationDoneCallback;
+            const originalBeforeCallback = options.setupMiddlewares;
+            options.setupMiddlewares = (middlewares, devServer) => {
+                compiler.hooks.done.tap('heft-webpack-plugin', () => {
+                    if (firstCompilationDoneCallback) {
+                        firstCompilationDoneCallback();
+                        firstCompilationDoneCallback = undefined;
+                    }
+                });
+                if (originalBeforeCallback) {
+                    return originalBeforeCallback(middlewares, devServer);
+                }
+                return middlewares;
+            };
+            // The webpack-dev-server package has a design flaw, where merely loading its package will set the
+            // WEBPACK_DEV_SERVER environment variable -- even if no APIs are accessed. This environment variable
+            // causes incorrect behavior if Heft is not running in serve mode. Thus, we need to be careful to call require()
+            // only if Heft is in serve mode.
+            const WebpackDevServer = require(WEBPACK_DEV_SERVER_PACKAGE_NAME);
+            // TODO: the WebpackDevServer accepts a third parameter for a logger. We should make
+            // use of that to make logging cleaner
+            const webpackDevServer = new WebpackDevServer(options, compiler);
+            await new Promise((resolve, reject) => {
+                firstCompilationDoneCallback = resolve;
+                // Wrap in promise.resolve due to small issue in the type declaration, return type should be
+                // webpackDevServer.start(): Promise<void>;
+                Promise.resolve(webpackDevServer.start()).catch(reject);
+            });
+        }
+        else {
+            if (process.env[WEBPACK_DEV_SERVER_ENV_VAR_NAME]) {
+                logger.emitWarning(new Error(`The "${WEBPACK_DEV_SERVER_ENV_VAR_NAME}" environment variable is set, ` +
+                    'which will cause problems when webpack is not running in serve mode. ' +
+                    `(Did a dependency inadvertently load the "${WEBPACK_DEV_SERVER_PACKAGE_NAME}" package?)`));
+            }
+            let stats;
+            if (buildProperties.watchMode) {
+                try {
+                    stats = await node_core_library_1.LegacyAdapters.convertCallbackToPromise(compiler.watch.bind(compiler), {});
+                }
+                catch (e) {
+                    logger.emitError(e);
+                }
+            }
+            else {
+                try {
+                    stats = await node_core_library_1.LegacyAdapters.convertCallbackToPromise(compiler.run.bind(compiler));
+                    await node_core_library_1.LegacyAdapters.convertCallbackToPromise(compiler.close.bind(compiler));
+                }
+                catch (e) {
+                    logger.emitError(e);
+                }
+            }
+            if (stats) {
+                // eslint-disable-next-line require-atomic-updates
+                buildProperties.webpackStats = stats;
+                this._emitErrors(logger, heftConfiguration.buildFolder, stats);
+            }
+        }
+    }
+    _emitErrors(logger, buildFolder, stats) {
+        if (stats.hasErrors() || stats.hasWarnings()) {
+            const serializedStats = [stats.toJson('errors-warnings')];
+            const errors = [];
+            const warnings = [];
+            for (const compilationStats of serializedStats) {
+                if (compilationStats.warnings) {
+                    for (const warning of compilationStats.warnings) {
+                        warnings.push(this._normalizeError(buildFolder, warning));
+                    }
+                }
+                if (compilationStats.errors) {
+                    for (const error of compilationStats.errors) {
+                        errors.push(this._normalizeError(buildFolder, error));
+                    }
+                }
+                if (compilationStats.children) {
+                    for (const child of compilationStats.children) {
+                        serializedStats.push(child);
+                    }
+                }
+            }
+            for (const warning of warnings) {
+                logger.emitWarning(warning);
+            }
+            for (const error of errors) {
+                logger.emitError(error);
+            }
+        }
+    }
+    _normalizeError(buildFolder, error) {
+        if (error instanceof Error) {
+            return error;
+        }
+        else {
+            let moduleName = error.moduleName;
+            if (!moduleName && error.moduleIdentifier) {
+                moduleName = node_core_library_1.Path.convertToSlashes(nodePath.relative(buildFolder, error.moduleIdentifier));
+            }
+            let formattedError;
+            if (error.loc && moduleName) {
+                formattedError = `${moduleName}:${error.loc} - ${error.message}`;
+            }
+            else if (moduleName) {
+                formattedError = `${moduleName} - ${error.message}`;
+            }
+            else {
+                formattedError = error.message;
+            }
+            return new Error(formattedError);
+        }
+    }
+}
+exports.WebpackPlugin = WebpackPlugin;
+//# sourceMappingURL=WebpackPlugin.js.map