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

package/dist/js/treeshaking/dev-tools/dev-middleware/dev-server-plugin.js

@@ -0,0 +1,74 @@
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+var DevServerPlugin = /*#__PURE__*/ function() {
+    "use strict";
+    function DevServerPlugin(options) {
+        _classCallCheck(this, DevServerPlugin);
+        _defineProperty(this, "options", void 0);
+        this.options = options;
+    }
+    _createClass(DevServerPlugin, [
+        {
+            key: "injectHMRClient",
+            value: function injectHMRClient(compiler) {
+                var client = this.options.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);
+                new compiler.webpack.EntryPlugin(compiler.context, clientEntry, {
+                    name: void 0
+                }).apply(compiler);
+            }
+        },
+        {
+            key: "apply",
+            value: function apply(compiler) {
+                if (this.options.hot || this.options.liveReload) {
+                    this.injectHMRClient(compiler);
+                }
+                var compilerOptions = compiler.options;
+                var HotModuleReplacementPlugin = compiler.webpack.HotModuleReplacementPlugin;
+                compilerOptions.plugins = compilerOptions.plugins || [];
+                if (!compilerOptions.plugins.find(function(p) {
+                    return p.constructor === HotModuleReplacementPlugin;
+                })) {
+                    var plugin = new HotModuleReplacementPlugin();
+                    plugin.apply(compiler);
+                }
+            }
+        }
+    ]);
+    return DevServerPlugin;
+}();
+export { DevServerPlugin as default };

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

@@ -0,0 +1,51 @@
+import { HMR_SOCK_PATH } from "@modern-js/utils/constants";
+function createSocketUrl(resourceQuery) {
+    var searchParams = resourceQuery.substr(1).split("&");
+    var options = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = searchParams[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var pair = _step.value;
+            var ary = pair.split("=");
+            options[ary[0]] = decodeURIComponent(ary[1]);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var currentLocation = self.location;
+    return getSocketUrl(options, currentLocation);
+}
+function formatURL(param) {
+    var port = param.port, protocol = param.protocol, hostname = param.hostname, pathname = param.pathname;
+    if (window.URL) {
+        var url = new URL("http://localhost");
+        url.port = port;
+        url.hostname = hostname;
+        url.protocol = protocol;
+        url.pathname = pathname;
+        return url.toString();
+    }
+    var colon = protocol.indexOf(":") === -1 ? ":" : "";
+    return "".concat(protocol).concat(colon, "//").concat(hostname, ":").concat(port).concat(pathname);
+}
+function getSocketUrl(urlParts, location) {
+    var host = urlParts.host, port = urlParts.port, path = urlParts.path, protocol = urlParts.protocol;
+    return formatURL({
+        protocol: protocol || location.protocol === "https:" ? "wss" : "ws",
+        hostname: host || location.hostname,
+        port: port || location.port,
+        pathname: path || HMR_SOCK_PATH
+    });
+}
+export { createSocketUrl, formatURL };

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

@@ -0,0 +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();

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

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,363 @@
+function _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+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 _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assertThisInitialized(self);
+}
+function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
+var __generator = this && this.__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+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() {};
+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;
+        _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();
+            _this.middleware = _this.setupDevMiddleware(devMiddleware);
+        }
+        return _this;
+    }
+    _createClass(DevMiddleware, [
+        {
+            key: "init",
+            value: function init(app) {
+                var _this = this;
+                app.on("listening", function() {
+                    _this.socketServer.prepare(app);
+                });
+                var _this1 = this;
+                app.on("close", /*#__PURE__*/ _asyncToGenerator(function() {
+                    var ref;
+                    return __generator(this, function(_state) {
+                        (ref = _this1.middleware) === null || ref === void 0 ? void 0 : ref.close(noop);
+                        _this1.socketServer.close();
+                        return [
+                            2
+                        ];
+                    });
+                }));
+            }
+        },
+        {
+            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) {
+                this.socketServer.sockWrite(type, data);
+            }
+        },
+        {
+            key: "setupHooks",
+            value: function setupHooks() {
+                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) {
+                        _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({
+                    headers: devOptions.headers,
+                    stats: false
+                }, 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;
+}(EventEmitter);
+export { DevMiddleware as default };