@modern-js/server 2.0.0-beta.4 → 2.0.0-beta.7

package/dist/js/treeshaking/dev-tools/dev-middleware/hmr-client/index.js

@@ -1,157 +1,157 @@
 var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __commonJS = function(cb, mod) {
-      return function __require() {
-          return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
-              exports: {}
-          }).exports, mod), mod.exports;
-      };
-  };
-  import stripAnsi from "@modern-js/utils/strip-ansi";
-  import { formatWebpackMessages } from "@modern-js/utils/format";
-  import { createSocketUrl } from "./createSocketUrl";
-  var require_hmr_client = __commonJS({
-      "src/dev-tools/dev-middleware/hmr-client/index.ts": function(exports, module) {
-          var clearOutdatedErrors = function clearOutdatedErrors() {
-              if (typeof console !== "undefined" && typeof console.clear === "function") {
-                  if (hasCompileErrors) {
-                      console.clear();
-                  }
-              }
-          };
-          var handleSuccess = function handleSuccess() {
-              clearOutdatedErrors();
-              var isHotUpdate = !isFirstCompilation;
-              isFirstCompilation = false;
-              hasCompileErrors = false;
-              if (isHotUpdate) {
-                  tryApplyUpdates();
-              }
-          };
-          var handleWarnings = function handleWarnings(warnings) {
-              clearOutdatedErrors();
-              var isHotUpdate = !isFirstCompilation;
-              isFirstCompilation = false;
-              hasCompileErrors = false;
-              function printWarnings() {
-                  var formatted = formatWebpackMessages({
-                      warnings: warnings,
-                      errors: []
-                  });
-                  if (typeof console !== "undefined" && typeof console.warn === "function") {
-                      for(var i = 0; i < formatted.warnings.length; i++){
-                          if (i === 5) {
-                              console.warn("There were more warnings in other files. You can find a complete log in the terminal.");
-                              break;
-                          }
-                          console.warn(stripAnsi(formatted.warnings[i]));
-                      }
-                  }
-              }
-              printWarnings();
-              if (isHotUpdate) {
-                  tryApplyUpdates();
-              }
-          };
-          var handleErrors = function handleErrors(errors) {
-              clearOutdatedErrors();
-              isFirstCompilation = false;
-              hasCompileErrors = true;
-              var formatted = formatWebpackMessages({
-                  errors: errors,
-                  warnings: []
-              });
-              if (typeof console !== "undefined" && typeof console.error === "function") {
-                  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                  try {
-                      for(var _iterator = formatted.errors[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                          var error = _step.value;
-                          console.error(stripAnsi(error));
-                      }
-                  } catch (err) {
-                      _didIteratorError = true;
-                      _iteratorError = err;
-                  } finally{
-                      try {
-                          if (!_iteratorNormalCompletion && _iterator.return != null) {
-                              _iterator.return();
-                          }
-                      } finally{
-                          if (_didIteratorError) {
-                              throw _iteratorError;
-                          }
-                      }
-                  }
-              }
-          };
-          var handleAvailableHash = function handleAvailableHash(hash) {
-              mostRecentCompilationHash = hash;
-          };
-          var isUpdateAvailable = function isUpdateAvailable() {
-              return mostRecentCompilationHash !== __webpack_hash__;
-          };
-          var canApplyUpdates = function canApplyUpdates() {
-              return module.hot.status() === "idle";
-          };
-          var hadRuntimeError = false;
-          var socketUrl = createSocketUrl(__resourceQuery);
-          var connection = new WebSocket(socketUrl);
-          connection.onclose = function() {
-              if (typeof console !== "undefined" && typeof console.info === "function") {
-                  console.info("The development server has disconnected. Refresh the page if necessary.");
-              }
-          };
-          var isFirstCompilation = true;
-          var mostRecentCompilationHash = null;
-          var hasCompileErrors = false;
-          connection.onmessage = function(e) {
-              var message = JSON.parse(e.data);
-              switch(message.type){
-                  case "hash":
-                      handleAvailableHash(message.data);
-                      break;
-                  case "still-ok":
-                  case "ok":
-                      handleSuccess();
-                      break;
-                  case "content-changed":
-                      window.location.reload();
-                      break;
-                  case "warnings":
-                      handleWarnings(message.data);
-                      break;
-                  case "errors":
-                      handleErrors(message.data);
-                      break;
-                  default:
-              }
-          };
-          function tryApplyUpdates() {
-              if (!module.hot) {
-                  window.location.reload();
-                  return;
-              }
-              if (!isUpdateAvailable() || !canApplyUpdates()) {
-                  return;
-              }
-              function handleApplyUpdates(err, updatedModules) {
-                  var wantsForcedReload = err || !updatedModules || hadRuntimeError;
-                  if (wantsForcedReload) {
-                      window.location.reload();
-                      return;
-                  }
-                  if (isUpdateAvailable()) {
-                      tryApplyUpdates();
-                  }
-              }
-              var result = module.hot.check(true, handleApplyUpdates);
-              if (result === null || result === void 0 ? void 0 : result.then) {
-                  result.then(function(updatedModules) {
-                      handleApplyUpdates(null, updatedModules);
-                  }, function(err) {
-                      handleApplyUpdates(err, null);
-                  });
-              }
-          }
-      }
-  });
-  export default require_hmr_client();
+var __commonJS = function(cb, mod) {
+    return function __require() {
+        return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
+            exports: {}
+        }).exports, mod), mod.exports;
+    };
+};
+import stripAnsi from "@modern-js/utils/strip-ansi";
+import { formatWebpackMessages } from "@modern-js/utils/format";
+import { createSocketUrl } from "./createSocketUrl";
+var require_hmr_client = __commonJS({
+    "src/dev-tools/dev-middleware/hmr-client/index.ts": function(exports, module) {
+        var clearOutdatedErrors = function clearOutdatedErrors() {
+            if (typeof console !== "undefined" && typeof console.clear === "function") {
+                if (hasCompileErrors) {
+                    console.clear();
+                }
+            }
+        };
+        var handleSuccess = function handleSuccess() {
+            clearOutdatedErrors();
+            var isHotUpdate = !isFirstCompilation;
+            isFirstCompilation = false;
+            hasCompileErrors = false;
+            if (isHotUpdate) {
+                tryApplyUpdates();
+            }
+        };
+        var handleWarnings = function handleWarnings(warnings) {
+            clearOutdatedErrors();
+            var isHotUpdate = !isFirstCompilation;
+            isFirstCompilation = false;
+            hasCompileErrors = false;
+            function printWarnings() {
+                var formatted = formatWebpackMessages({
+                    warnings: warnings,
+                    errors: []
+                });
+                if (typeof console !== "undefined" && typeof console.warn === "function") {
+                    for(var i = 0; i < formatted.warnings.length; i++){
+                        if (i === 5) {
+                            console.warn("There were more warnings in other files.\nYou can find a complete log in the terminal.");
+                            break;
+                        }
+                        console.warn(stripAnsi(formatted.warnings[i]));
+                    }
+                }
+            }
+            printWarnings();
+            if (isHotUpdate) {
+                tryApplyUpdates();
+            }
+        };
+        var handleErrors = function handleErrors(errors) {
+            clearOutdatedErrors();
+            isFirstCompilation = false;
+            hasCompileErrors = true;
+            var formatted = formatWebpackMessages({
+                errors: errors,
+                warnings: []
+            });
+            if (typeof console !== "undefined" && typeof console.error === "function") {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = formatted.errors[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var error = _step.value;
+                        console.error(stripAnsi(error));
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        };
+        var handleAvailableHash = function handleAvailableHash(hash) {
+            mostRecentCompilationHash = hash;
+        };
+        var isUpdateAvailable = function isUpdateAvailable() {
+            return mostRecentCompilationHash !== __webpack_hash__;
+        };
+        var canApplyUpdates = function canApplyUpdates() {
+            return module.hot.status() === "idle";
+        };
+        var hadRuntimeError = false;
+        var socketUrl = createSocketUrl(__resourceQuery);
+        var connection = new WebSocket(socketUrl);
+        connection.onclose = function() {
+            if (typeof console !== "undefined" && typeof console.info === "function") {
+                console.info("The development server has disconnected.\nRefresh the page if necessary.");
+            }
+        };
+        var isFirstCompilation = true;
+        var mostRecentCompilationHash = null;
+        var hasCompileErrors = false;
+        connection.onmessage = function(e) {
+            var message = JSON.parse(e.data);
+            switch(message.type){
+                case "hash":
+                    handleAvailableHash(message.data);
+                    break;
+                case "still-ok":
+                case "ok":
+                    handleSuccess();
+                    break;
+                case "content-changed":
+                    window.location.reload();
+                    break;
+                case "warnings":
+                    handleWarnings(message.data);
+                    break;
+                case "errors":
+                    handleErrors(message.data);
+                    break;
+                default:
+            }
+        };
+        function tryApplyUpdates() {
+            if (!module.hot) {
+                window.location.reload();
+                return;
+            }
+            if (!isUpdateAvailable() || !canApplyUpdates()) {
+                return;
+            }
+            function handleApplyUpdates(err, updatedModules) {
+                var wantsForcedReload = err || !updatedModules || hadRuntimeError;
+                if (wantsForcedReload) {
+                    window.location.reload();
+                    return;
+                }
+                if (isUpdateAvailable()) {
+                    tryApplyUpdates();
+                }
+            }
+            var result = module.hot.check(true, handleApplyUpdates);
+            if (result === null || result === void 0 ? void 0 : result.then) {
+                result.then(function(updatedModules) {
+                    handleApplyUpdates(null, updatedModules);
+                }, function(err) {
+                    handleApplyUpdates(err, null);
+                });
+            }
+        }
+    }
+});
+export default require_hmr_client();

package/dist/js/treeshaking/dev-tools/dev-middleware/index.js

@@ -236,29 +236,30 @@ var __generator = this && this.__generator || function(thisArg, body) {
     }
 };
 import { EventEmitter } from "events";
-import webpackDevMiddleware from "@modern-js/utils/webpack-dev-middleware";
-import DevServerPlugin from "./dev-server-plugin";
 import SocketServer from "./socket-server";
 var noop = function() {};
+function getHMRClientPath(client) {
+    var host = (client === null || client === void 0 ? void 0 : client.host) ? "&host=".concat(client.host) : "";
+    var path = (client === null || client === void 0 ? void 0 : client.path) ? "&path=".concat(client.path) : "";
+    var port = (client === null || client === void 0 ? void 0 : client.port) ? "&port=".concat(client.port) : "";
+    var clientEntry = "".concat(require.resolve("./hmr-client"), "?").concat(host).concat(path).concat(port);
+    return clientEntry;
+}
 var DevMiddleware = /*#__PURE__*/ function(EventEmitter) {
     "use strict";
     _inherits(DevMiddleware, EventEmitter);
     var _super = _createSuper(DevMiddleware);
     function DevMiddleware(param) {
-        var compiler = param.compiler, dev = param.dev, devMiddleware = param.devMiddleware;
+        var dev = param.dev, devMiddleware = param.devMiddleware;
         _classCallCheck(this, DevMiddleware);
         var _this;
         _this = _super.call(this);
         _defineProperty(_assertThisInitialized(_this), "middleware", void 0);
-        _defineProperty(_assertThisInitialized(_this), "compiler", void 0);
         _defineProperty(_assertThisInitialized(_this), "devOptions", void 0);
         _defineProperty(_assertThisInitialized(_this), "socketServer", void 0);
-        _this.compiler = compiler;
         _this.devOptions = dev;
         _this.socketServer = new SocketServer(dev);
-        if (_this.compiler) {
-            _this.setupDevServerPlugin();
-            _this.setupHooks();
+        if (devMiddleware) {
             _this.middleware = _this.setupDevMiddleware(devMiddleware);
         }
         return _this;
@@ -284,22 +285,6 @@ var DevMiddleware = /*#__PURE__*/ function(EventEmitter) {
                 }));
             }
         },
-        {
-            key: "setupDevServerPlugin",
-            value: function setupDevServerPlugin() {
-                var _this = this;
-                var devOptions = this.devOptions;
-                if (this.compiler.compilers) {
-                    this.compiler.compilers.forEach(function(target) {
-                        if (_this.isClientCompiler(target)) {
-                            new DevServerPlugin(devOptions).apply(target);
-                        }
-                    });
-                } else {
-                    new DevServerPlugin(devOptions).apply(this.compiler);
-                }
-            }
-        },
         {
             key: "sockWrite",
             value: function sockWrite(type, data) {
@@ -307,55 +292,28 @@ var DevMiddleware = /*#__PURE__*/ function(EventEmitter) {
             }
         },
         {
-            key: "setupHooks",
-            value: function setupHooks() {
+            key: "setupDevMiddleware",
+            value: function setupDevMiddleware(devMiddleware) {
                 var _this = this;
-                var invalidPlugin = function() {
-                    _this.socketServer.sockWrite("invalid");
-                };
-                var addHooks = function(compiler) {
-                    if (compiler.name === "server") {
-                        return;
-                    }
-                    var _hooks = compiler.hooks, compile = _hooks.compile, invalid = _hooks.invalid, done = _hooks.done;
-                    compile.tap("modern-dev-server", invalidPlugin);
-                    invalid.tap("modern-dev-server", invalidPlugin);
-                    done.tap("modern-dev-server", function(stats) {
+                var devOptions = this.devOptions;
+                var callbacks = {
+                    onInvalid: function() {
+                        _this.socketServer.sockWrite("invalid");
+                    },
+                    onDone: function(stats) {
                         _this.socketServer.updateStats(stats);
                         _this.emit("change", stats);
-                    });
+                    }
                 };
-                if (this.compiler.compilers) {
-                    this.compiler.compilers.forEach(addHooks);
-                } else {
-                    addHooks(this.compiler);
-                }
-            }
-        },
-        {
-            key: "setupDevMiddleware",
-            value: function setupDevMiddleware() {
-                var devMiddleware = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : webpackDevMiddleware;
-                var devOptions = this.devOptions;
-                var middleware = devMiddleware(this.compiler, _objectSpread({
+                var enableHMR = this.devOptions.hot || this.devOptions.liveReload;
+                var middleware = devMiddleware(_objectSpread({
                     headers: devOptions.headers,
-                    stats: false
+                    stats: false,
+                    callbacks: callbacks,
+                    hmrClientPath: enableHMR ? getHMRClientPath(devOptions.client) : void 0
                 }, devOptions.devMiddleware));
                 return middleware;
             }
-        },
-        {
-            key: "isClientCompiler",
-            value: function isClientCompiler(compiler) {
-                var target = compiler.options.target;
-                if (target) {
-                    if (Array.isArray(target)) {
-                        return !target.includes("node");
-                    }
-                    return target !== "node";
-                }
-                return compiler.name === "client";
-            }
         }
     ]);
     return DevMiddleware;

package/dist/js/treeshaking/dev-tools/https/index.js

@@ -122,31 +122,63 @@ var __generator = this && this.__generator || function(thisArg, body) {
         };
     }
 };
-import * as devcert from "devcert";
+import { chalk, getPackageManager, logger } from "@modern-js/utils";
 var genHttpsOptions = function() {
-    var _ref = _asyncToGenerator(function(userOptions) {
-        var httpsOptions, selfsign;
+    var _ref = _asyncToGenerator(function(userOptions, pwd) {
+        var httpsOptions, devcertPath, err, packageManager, command, devcert, selfsign;
         return __generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     httpsOptions = typeof userOptions === "boolean" ? {} : userOptions;
                     if (!(!httpsOptions.key || !httpsOptions.cert)) return [
                         3,
-                        2
+                        6
                     ];
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        2,
+                        ,
+                        4
+                    ]);
+                    devcertPath = require.resolve("devcert", {
+                        paths: [
+                            pwd,
+                            __dirname
+                        ]
+                    });
+                    return [
+                        3,
+                        4
+                    ];
+                case 2:
+                    err = _state.sent();
+                    return [
+                        4,
+                        getPackageManager(pwd)
+                    ];
+                case 3:
+                    packageManager = _state.sent();
+                    command = chalk.yellow.bold("".concat(packageManager, " install devcert@1.2.2 -D"));
+                    logger.error('You have enabled "dev.https" option, but the "devcert" package is not installed.');
+                    logger.error("Please run ".concat(command, " to install manually, otherwise the https can not work."));
+                    throw new Error('[https] "devcert" is not found.');
+                case 4:
+                    devcert = require(devcertPath);
                     return [
                         4,
                         devcert.certificateFor([
                             "localhost"
                         ])
                     ];
-                case 1:
+                case 5:
                     selfsign = _state.sent();
                     return [
                         2,
                         selfsign
                     ];
-                case 2:
+                case 6:
                     return [
                         2,
                         httpsOptions
@@ -154,7 +186,7 @@ var genHttpsOptions = function() {
             }
         });
     });
-    return function genHttpsOptions(userOptions) {
+    return function genHttpsOptions(userOptions, pwd) {
         return _ref.apply(this, arguments);
     };
 }();

package/dist/js/treeshaking/index.js

@@ -1,7 +1,7 @@
 import { DevServer as Server } from "./server";
 var src_default = function(options) {
     if (options == null) {
-        throw new Error("can not start mserver without options");
+        throw new Error("can not start server without options");
     }
     var server = new Server(options);
     return server.init();

package/dist/js/treeshaking/server/dev-server.js

@@ -367,7 +367,6 @@ var ModernDevServer = /*#__PURE__*/ function(ModernServer) {
         _this.dev = _this.getDevOptions(options);
         _this.devMiddleware = new DevMiddleware({
             dev: _this.dev,
-            compiler: options.compiler,
             devMiddleware: options.devMiddleware
         });
         enableRegister(_this.pwd, _this.conf);
@@ -628,7 +627,7 @@ var ModernDevServer = /*#__PURE__*/ function(ModernServer) {
                                 genHttpsOptions = require("../dev-tools/https").genHttpsOptions;
                                 return [
                                     4,
-                                    genHttpsOptions(devHttpsOption)
+                                    genHttpsOptions(devHttpsOption, _this.pwd)
                                 ];
                             case 1:
                                 httpsOptions = _state.sent();

package/dist/types/dev-tools/dev-middleware/index.d.ts

@@ -2,28 +2,21 @@
 /// <reference types="node" />
 import { Server } from 'http';
 import { EventEmitter } from 'events';
-import { Compiler, MultiCompiler } from 'webpack';
-import { DevServerOptions, DevMiddlewareAPI, CustomDevMiddleware } from '../../types';
+import { DevServerOptions, DevMiddlewareAPI, DevMiddleware as CustomDevMiddleware } from '../../types';
 declare type Options = {
-  compiler: MultiCompiler | Compiler | null;
   dev: DevServerOptions;
   devMiddleware?: CustomDevMiddleware;
 };
 export default class DevMiddleware extends EventEmitter {
   middleware?: DevMiddlewareAPI;
-  private compiler;
   private devOptions;
   private socketServer;
   constructor({
-    compiler,
     dev,
     devMiddleware
   }: Options);
   init(app: Server): void;
-  private setupDevServerPlugin;
   sockWrite(type: string, data?: Record<string, any> | string | boolean): void;
-  private setupHooks;
   private setupDevMiddleware;
-  private isClientCompiler;
 }
 export {};

package/dist/types/dev-tools/https/index.d.ts

@@ -1,6 +1,6 @@
 import type Buffer from 'buffer';
 import type { DevServerHttpsOptions } from '../../types';
-export declare const genHttpsOptions: (userOptions: DevServerHttpsOptions) => Promise<{
+export declare const genHttpsOptions: (userOptions: DevServerHttpsOptions, pwd: string) => Promise<{
   key?: Buffer | string;
   cert?: Buffer | string;
 }>;

package/dist/types/types.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="node" />
 import type { IncomingMessage, ServerResponse } from 'http';
-import type webpack from 'webpack';
 import type { DevServerOptions, DevServerHttpsOptions, NextFunction } from '@modern-js/types';
 import type { ModernServerOptions } from '@modern-js/prod-server';
 export type { DevServerOptions, DevServerHttpsOptions };
@@ -8,14 +7,32 @@ declare type Middleware = (req: IncomingMessage, res: ServerResponse, next: Next
 export declare type DevMiddlewareAPI = Middleware & {
   close: (callback: (err: Error | null | undefined) => void) => any;
 };
-export declare type CustomDevMiddleware = (compiler: webpack.MultiCompiler | webpack.Compiler, options: {
+export declare type MiddlewareCallbacks = {
+  onInvalid: () => void;
+  onDone: (stats: any) => void;
+};
+export declare type DevMiddlewareOptions = {
+  /** To ensure HMR works, the devMiddleware need inject the hmr client path into page when HMR enable. */
+  hmrClientPath?: string;
+  /** The options need by compiler middleware (like webpackMiddleware) */
+
   headers?: Record<string, string>;
   writeToDisk?: boolean | ((filename: string) => boolean);
   stats?: boolean;
-}) => DevMiddlewareAPI;
+  /** should trigger when compiler hook called */
+
+  callbacks: MiddlewareCallbacks;
+};
+/**
+ * The modern/server do nothing about compiler, the devMiddleware need do such things to ensure dev works well:
+ * - Call compiler.watch （normally did by webpack-dev-middleware）.
+ * - Inject the hmr client path into page （the hmr client modern/server already provide）.
+ * - Notify server when compiler hooks are triggered.
+ */
+
+export declare type DevMiddleware = (options: DevMiddlewareOptions) => DevMiddlewareAPI;
 export declare type ExtraOptions = {
   dev: boolean | Partial<DevServerOptions>;
-  compiler: webpack.MultiCompiler | webpack.Compiler | null;
-  devMiddleware?: CustomDevMiddleware;
+  devMiddleware?: DevMiddleware;
 };
 export declare type ModernDevServerOptions = ModernServerOptions & ExtraOptions;