react-cosmos 5.6.4

package/dist/plugins/userDepsFile.js

@@ -0,0 +1,164 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.userDepsFile = userDepsFile;
+
+var _chokidar = require("chokidar");
+
+var _fs = require("fs");
+
+var _lodash = require("lodash");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _util = _interopRequireDefault(require("util.promisify"));
+
+var _cli = require("../shared/cli");
+
+var _userDeps = require("../shared/userDeps");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+var writeFileAsync = (0, _util.default)(_fs.writeFile);
+
+function userDepsFile(_x) {
+  return _userDepsFile.apply(this, arguments);
+}
+
+function _userDepsFile() {
+  _userDepsFile = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(args) {
+    var cosmosConfig, watcher;
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            if (shouldGenerateUserDepsFile(args)) {
+              _context.next = 2;
+              break;
+            }
+
+            return _context.abrupt("return");
+
+          case 2:
+            cosmosConfig = args.cosmosConfig;
+            _context.next = 5;
+            return generateUserDepsFile(cosmosConfig);
+
+          case 5:
+            _context.next = 7;
+            return startFixtureFileWatcher(cosmosConfig);
+
+          case 7:
+            watcher = _context.sent;
+            return _context.abrupt("return", function () {
+              watcher.close();
+            });
+
+          case 9:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _userDepsFile.apply(this, arguments);
+}
+
+function shouldGenerateUserDepsFile(_ref) {
+  var cosmosConfig = _ref.cosmosConfig,
+      platformType = _ref.platformType;
+  return platformType === 'native' || cosmosConfig.experimentalRendererUrl !== null || // CLI support for --external-userdeps flag (useful with react-native-web)
+  Boolean((0, _cli.getCliArgs)().externalUserdeps);
+}
+
+var DEBOUNCE_INTERVAL = 50;
+
+function startFixtureFileWatcher(_x2) {
+  return _startFixtureFileWatcher.apply(this, arguments);
+}
+
+function _startFixtureFileWatcher() {
+  _startFixtureFileWatcher = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(cosmosConfig) {
+    var fixturesDir, fixtureFileSuffix, FILE_PATTERNS;
+    return regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            fixturesDir = cosmosConfig.fixturesDir, fixtureFileSuffix = cosmosConfig.fixtureFileSuffix;
+            FILE_PATTERNS = [].concat(_toConsumableArray((0, _userDeps.getFixturePatterns)(fixturesDir, fixtureFileSuffix)), _toConsumableArray((0, _userDeps.getDecoratorPatterns)()));
+            return _context2.abrupt("return", new Promise(function (resolve) {
+              var watcher = (0, _chokidar.watch)(FILE_PATTERNS, {
+                ignored: (0, _userDeps.getIgnorePatterns)(),
+                ignoreInitial: true,
+                cwd: cosmosConfig.rootDir
+              }).on('ready', function () {
+                return resolve(watcher);
+              }).on('all', (0, _lodash.debounce)(function () {
+                return generateUserDepsFile(cosmosConfig);
+              }, DEBOUNCE_INTERVAL));
+            }));
+
+          case 3:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _startFixtureFileWatcher.apply(this, arguments);
+}
+
+function generateUserDepsFile(_x3) {
+  return _generateUserDepsFile.apply(this, arguments);
+}
+
+function _generateUserDepsFile() {
+  _generateUserDepsFile = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(cosmosConfig) {
+    var userDepsFilePath, port, rendererConfig, userDepsModule, relUserDepsFilePath;
+    return regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            userDepsFilePath = cosmosConfig.userDepsFilePath, port = cosmosConfig.port;
+            rendererConfig = {
+              port: port
+            };
+            userDepsModule = (0, _userDeps.generateUserDepsModule)({
+              cosmosConfig: cosmosConfig,
+              rendererConfig: rendererConfig,
+              relativeToDir: _path.default.dirname(userDepsFilePath)
+            });
+            _context3.next = 5;
+            return writeFileAsync(userDepsFilePath, userDepsModule, 'utf8');
+
+          case 5:
+            relUserDepsFilePath = _path.default.relative(process.cwd(), userDepsFilePath);
+            console.log("[Cosmos] Generated ".concat(relUserDepsFilePath));
+
+          case 7:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _generateUserDepsFile.apply(this, arguments);
+}

package/dist/plugins/webpack/client/errorOverlay/index.d.ts

@@ -0,0 +1 @@
+export declare function dismissErrorOverlay(): void;

package/dist/plugins/webpack/client/errorOverlay/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dismissErrorOverlay = dismissErrorOverlay;
+
+if (__DEV__) {
+  require('./reactErrorOverlay').init();
+}
+
+function dismissErrorOverlay() {
+  if (__DEV__) {
+    require('./reactErrorOverlay').dismiss();
+  }
+}

package/dist/plugins/webpack/client/errorOverlay/reactErrorOverlay.d.ts

@@ -0,0 +1,2 @@
+export declare function init(): void;
+export declare function dismiss(): void;

package/dist/plugins/webpack/client/errorOverlay/reactErrorOverlay.js

@@ -0,0 +1,63 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init = init;
+exports.dismiss = dismiss;
+
+var _url = require("react-cosmos-shared2/url");
+
+var ErrorOverlay = _interopRequireWildcard(require("react-error-overlay"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var LAUNCH_EDITOR_ENDPOINT = '/_open';
+
+function init() {
+  ErrorOverlay.startReportingRuntimeErrors({
+    filename: process.env.PUBLIC_URL + '/main.js'
+  });
+  ErrorOverlay.setEditorHandler(function (errorLocation) {
+    return window.fetch(getLaunchEditorUrl(errorLocation));
+  });
+  setUpBuildErrorReporting();
+}
+
+function dismiss() {
+  ErrorOverlay.dismissRuntimeErrors();
+}
+
+function getLaunchEditorUrl(errorLocation) {
+  return "".concat(LAUNCH_EDITOR_ENDPOINT, "?").concat((0, _url.stringifyUrlQuery)({
+    filePath: errorLocation.fileName,
+    line: errorLocation.lineNumber || 1,
+    column: errorLocation.colNumber || 1
+  }));
+}
+
+function setUpBuildErrorReporting() {
+  var clientWindow = window;
+
+  if (clientWindow.__webpack_hot_middleware_reporter__ === undefined) {
+    return;
+  }
+
+  clientWindow.__webpack_hot_middleware_reporter__.useCustomOverlay({
+    showProblems: function showProblems(type, obj) {
+      if (type !== 'errors') {
+        // We might've went from errors -> warnings
+        ErrorOverlay.dismissBuildError();
+      } else {
+        ErrorOverlay.reportBuildError(obj[0]);
+      }
+    },
+    clear: function clear() {
+      ErrorOverlay.dismissBuildError();
+    }
+  });
+}

package/dist/plugins/webpack/client/hmrErrorHandler.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/plugins/webpack/client/hmrErrorHandler.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _dom = require("../../../dom");
+
+if (__DEV__) {
+  var webpackRendererConnect = _dom.rendererConnect;
+
+  window.onHotReloadError = function () {
+    return webpackRendererConnect.postMessage({
+      type: 'rendererHmrFail',
+      payload: {
+        rendererId: _dom.rendererId
+      }
+    });
+  };
+}

package/dist/plugins/webpack/client/index.d.ts

@@ -0,0 +1,6 @@
+import 'regenerator-runtime/runtime';
+import 'core-js/features/promise';
+import 'core-js/features/array/find';
+import 'core-js/features/array/includes';
+import 'core-js/features/array/fill';
+import './hmrErrorHandler';

package/dist/plugins/webpack/client/index.js

@@ -0,0 +1,43 @@
+"use strict";
+
+require("regenerator-runtime/runtime");
+
+require("core-js/features/promise");
+
+require("core-js/features/array/find");
+
+require("core-js/features/array/includes");
+
+require("core-js/features/array/fill");
+
+var _dom = require("../../../dom");
+
+var _errorOverlay = require("./errorOverlay");
+
+require("./hmrErrorHandler");
+
+mount();
+
+function mount() {
+  // Use dynamic import to load updated modules upon hot reloading
+  var _require = require('./userDeps'),
+      rendererConfig = _require.rendererConfig,
+      fixtures = _require.fixtures,
+      decorators = _require.decorators;
+
+  (0, _dom.mountDomRenderer)({
+    rendererConfig: rendererConfig,
+    fixtures: fixtures,
+    decorators: decorators,
+    onErrorReset: _errorOverlay.dismissErrorOverlay
+  });
+}
+
+if (module.hot) {
+  module.hot.accept('./userDeps', function () {
+    // If a previous error has been solved, the error overlay auto-closes nicely.
+    // If the error persists, however, the overlay will pop up again on its own
+    (0, _errorOverlay.dismissErrorOverlay)();
+    mount();
+  });
+}

package/dist/plugins/webpack/client/reactDevtoolsHook.js

@@ -0,0 +1,19 @@
+"use strict";
+
+// TLDR: This has to be done before React is imported
+// https://github.com/facebook/react-devtools/issues/76#issuecomment-128091900
+// More context: User-defined "global imports" have to be imported *after* this
+// file (because they can import React), but *before* the main renderer entry
+// point (because the user's global imports have to take effect before we
+// import fixture and decorator modules). For this reason this file has to be
+// imported by hand in each renderer implementation.
+// @ts-ignore
+if (process.env.NODE_ENV === 'development') {
+  // Accessing the parent window can throw when loading a static export without
+  // a web server (i.e. via file:/// protocol)
+  try {
+    window.__REACT_DEVTOOLS_GLOBAL_HOOK__ = window.parent.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  } catch (err) {
+    console.warn('Could not access parent React devtools hook');
+  }
+}

package/dist/plugins/webpack/client/userDeps.d.ts

@@ -0,0 +1,5 @@
+import { ReactDecoratorsByPath, ReactFixtureExportsByPath } from 'react-cosmos-shared2/react';
+import { DomRendererConfig } from '../../../shared/rendererConfig';
+export declare const rendererConfig: DomRendererConfig;
+export declare const fixtures: ReactFixtureExportsByPath;
+export declare const decorators: ReactDecoratorsByPath;

package/dist/plugins/webpack/client/userDeps.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decorators = exports.fixtures = exports.rendererConfig = void 0;
+// NOTE: Renderer data is statically injected at compile time
+var rendererConfig = {
+  containerQuerySelector: null
+};
+exports.rendererConfig = rendererConfig;
+var fixtures = {};
+exports.fixtures = fixtures;
+var decorators = {};
+exports.decorators = decorators;

package/dist/plugins/webpack/cosmosConfig/dom.d.ts

@@ -0,0 +1,6 @@
+import { CosmosConfig } from '../../../config';
+declare type DomCosmosConfig = {
+    containerQuerySelector: null | string;
+};
+export declare function createDomCosmosConfig(cosmosConfig: CosmosConfig): DomCosmosConfig;
+export {};

package/dist/plugins/webpack/cosmosConfig/dom.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDomCosmosConfig = createDomCosmosConfig;
+
+function createDomCosmosConfig(cosmosConfig) {
+  var configInput = cosmosConfig.dom || {};
+  return {
+    containerQuerySelector: getContainerQuerySelector(configInput)
+  };
+}
+
+function getContainerQuerySelector(_ref) {
+  var _ref$containerQuerySe = _ref.containerQuerySelector,
+      containerQuerySelector = _ref$containerQuerySe === void 0 ? null : _ref$containerQuerySe;
+  return containerQuerySelector;
+}

package/dist/plugins/webpack/cosmosConfig/webpack.d.ts

@@ -0,0 +1,9 @@
+import { CosmosConfig } from '../../../config';
+declare type WebpackCosmosConfig = {
+    configPath: null | string;
+    overridePath: null | string;
+    includeHashInOutputFilename: boolean;
+    hotReload: boolean;
+};
+export declare function createWebpackCosmosConfig(cosmosConfig: CosmosConfig): WebpackCosmosConfig;
+export {};

package/dist/plugins/webpack/cosmosConfig/webpack.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createWebpackCosmosConfig = createWebpackCosmosConfig;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _config = require("../../../config");
+
+var _fs = require("../../../shared/fs");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function createWebpackCosmosConfig(cosmosConfig) {
+  var rootDir = cosmosConfig.rootDir;
+  var configInput = cosmosConfig.webpack || {};
+  return {
+    configPath: getWebpackConfigPath(configInput, rootDir),
+    overridePath: getWebpackOverridePath(configInput, rootDir),
+    includeHashInOutputFilename: getIncludeHashInOutputFilename(configInput),
+    hotReload: getHotReload(configInput)
+  };
+}
+
+function getWebpackConfigPath(_ref, rootDir) {
+  var configPath = _ref.configPath;
+
+  if (typeof configPath === 'undefined') {
+    return (0, _config.resolveModule)(rootDir, 'webpack.config.js');
+  } // User can choose to prevent automatical use of an existing webpack.config.js
+  // file (relative to the root dir) by setting configPath to null
+
+
+  if (!configPath) {
+    return null;
+  }
+
+  var absPath = (0, _config.resolveModule)(rootDir, configPath);
+
+  if (!(0, _fs.fileExists)(absPath)) {
+    var relPath = _path.default.relative(process.cwd(), absPath);
+
+    throw new Error("webpack config not found at path: ".concat(relPath));
+  }
+
+  return absPath;
+}
+
+function getWebpackOverridePath(_ref2, rootDir) {
+  var overridePath = _ref2.overridePath;
+
+  if (typeof overridePath === 'undefined') {
+    return (0, _config.resolveModule)(rootDir, 'webpack.override.js');
+  } // User can choose to prevent automatical use of an existing webpack.override.js
+  // file (relative to the root dir) by setting overridePath to null
+
+
+  if (!overridePath) {
+    return null;
+  }
+
+  var absPath = (0, _config.resolveModule)(rootDir, overridePath);
+
+  if (!(0, _fs.fileExists)(absPath)) {
+    var relPath = _path.default.relative(process.cwd(), absPath);
+
+    throw new Error("webpack override module not found at path: ".concat(relPath));
+  }
+
+  return absPath;
+} // Default value is False to not break backwards compatibility
+// In future releases it's better to mark this as @deprecated and set
+// output.filename to "[name].[contenthash].js" by default
+
+
+function getIncludeHashInOutputFilename(_ref3) {
+  var _ref3$includeHashInOu = _ref3.includeHashInOutputFilename,
+      includeHashInOutputFilename = _ref3$includeHashInOu === void 0 ? false : _ref3$includeHashInOu;
+  return includeHashInOutputFilename;
+}
+
+function getHotReload(_ref4) {
+  var _ref4$hotReload = _ref4.hotReload,
+      hotReload = _ref4$hotReload === void 0 ? true : _ref4$hotReload;
+  return hotReload;
+}

package/dist/plugins/webpack/devServer.d.ts

@@ -0,0 +1,2 @@
+import { DevServerPluginArgs } from '../../shared/devServer';
+export declare function webpackDevServer({ cosmosConfig, expressApp, sendMessage, }: DevServerPluginArgs): Promise<(() => Promise<void>) | undefined>;

package/dist/plugins/webpack/devServer.js

@@ -0,0 +1,168 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.webpackDevServer = webpackDevServer;
+
+var _webpackHotMiddleware = _interopRequireDefault(require("@skidding/webpack-hot-middleware"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _shared = require("../../shared/shared");
+
+var _static = require("../../shared/static");
+
+var _webpack = require("./cosmosConfig/webpack");
+
+var _shared2 = require("./shared");
+
+var _webpackConfig = require("./webpackConfig");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function webpackDevServer(_x) {
+  return _webpackDevServer.apply(this, arguments);
+}
+
+function _webpackDevServer() {
+  _webpackDevServer = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(_ref) {
+    var cosmosConfig, expressApp, sendMessage, userWebpack, webpackConfig, webpackDerivedStaticPath, sendBuildMessage, webpackCompiler, onCompilationDone, wdm, wdmInst, _createWebpackCosmosC, hotReload;
+
+    return regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            sendBuildMessage = function _sendBuildMessage(msg) {
+              sendMessage(msg);
+            };
+
+            cosmosConfig = _ref.cosmosConfig, expressApp = _ref.expressApp, sendMessage = _ref.sendMessage;
+
+            if (!cosmosConfig.experimentalRendererUrl) {
+              _context2.next = 4;
+              break;
+            }
+
+            return _context2.abrupt("return");
+
+          case 4:
+            userWebpack = (0, _shared2.getWebpack)(cosmosConfig.rootDir);
+
+            if (userWebpack) {
+              _context2.next = 7;
+              break;
+            }
+
+            return _context2.abrupt("return");
+
+          case 7:
+            _context2.next = 9;
+            return (0, _webpackConfig.getDevWebpackConfig)(cosmosConfig, userWebpack);
+
+          case 9:
+            webpackConfig = _context2.sent;
+
+            // Serve static path derived from devServer.contentBase webpack config
+            if (cosmosConfig.staticPath === null) {
+              webpackDerivedStaticPath = getWebpackStaticPath(webpackConfig);
+
+              if (webpackDerivedStaticPath !== null) {
+                (0, _static.serveStaticDir)(expressApp, _path.default.resolve(cosmosConfig.rootDir, webpackDerivedStaticPath), cosmosConfig.publicUrl);
+              }
+            }
+
+            webpackCompiler = userWebpack(webpackConfig);
+            webpackCompiler.hooks.invalid.tap('Cosmos', function (filePath) {
+              if (typeof filePath === 'string') {
+                var relFilePath = _path.default.relative(process.cwd(), filePath);
+
+                console.log('[Cosmos] webpack build invalidated by', relFilePath);
+              } else {
+                console.log('[Cosmos] webpack build invalidated by unknown file');
+              }
+
+              sendBuildMessage({
+                type: 'buildStart'
+              });
+            });
+            webpackCompiler.hooks.failed.tap('Cosmos', function () {
+              sendBuildMessage({
+                type: 'buildError'
+              });
+            });
+            onCompilationDone = new Promise(function (resolve) {
+              webpackCompiler.hooks.done.tap('Cosmos', function (stats) {
+                resolve();
+
+                if (stats.hasErrors()) {
+                  sendBuildMessage({
+                    type: 'buildError'
+                  });
+                } else {
+                  sendBuildMessage({
+                    type: 'buildDone'
+                  });
+                }
+              });
+            });
+            console.log('[Cosmos] Building webpack...'); // Why import WDM here instead of at module level? Because it imports webpack,
+            // which might not be installed in the user's codebase. If this were to happen
+            // the Cosmos server would crash with a cryptic import error. See import here:
+            // https://github.com/webpack/webpack-dev-middleware/blob/eb2e32bab57df11bdfbbac19474eb16817d504fe/lib/fs.js#L8
+            // Instead, prior to importing WDM we check if webpack is installed and fail
+            // gracefully if not.
+
+            wdm = require('webpack-dev-middleware');
+            wdmInst = wdm(webpackCompiler, {
+              // publicPath is the base path for the webpack assets and has to match
+              // webpack.output.path
+              publicPath: (0, _shared.removeLeadingDot)(cosmosConfig.publicUrl)
+            });
+            expressApp.use(wdmInst);
+            _createWebpackCosmosC = (0, _webpack.createWebpackCosmosConfig)(cosmosConfig), hotReload = _createWebpackCosmosC.hotReload;
+
+            if (hotReload) {
+              expressApp.use((0, _webpackHotMiddleware.default)(webpackCompiler));
+            }
+
+            _context2.next = 23;
+            return onCompilationDone;
+
+          case 23:
+            return _context2.abrupt("return", /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+              return regeneratorRuntime.wrap(function _callee$(_context) {
+                while (1) {
+                  switch (_context.prev = _context.next) {
+                    case 0:
+                      _context.next = 2;
+                      return new Promise(function (res) {
+                        return wdmInst.close(res);
+                      });
+
+                    case 2:
+                    case "end":
+                      return _context.stop();
+                  }
+                }
+              }, _callee);
+            })));
+
+          case 24:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _webpackDevServer.apply(this, arguments);
+}
+
+function getWebpackStaticPath(_ref2) {
+  var devServer = _ref2.devServer;
+  return devServer && typeof devServer.contentBase === 'string' ? devServer.contentBase : null;
+}

package/dist/plugins/webpack/export.d.ts

@@ -0,0 +1,2 @@
+import { ExportPluginArgs } from '../../shared/export';
+export declare function webpackExport({ cosmosConfig }: ExportPluginArgs): Promise<void>;