@modern-js/server 2.15.0 → 2.15.1-alpha.0

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.\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

@@ -0,0 +1,322 @@
+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 SocketServer from "./socket-server";
+var noop = function() {};
+function getHMRClientPath(client) {
+    var protocol = (client === null || client === void 0 ? void 0 : client.protocol) ? "&protocol=".concat(client.protocol) : "";
+    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).concat(protocol);
+    return clientEntry;
+}
+var DevMiddleware = /*#__PURE__*/ function(EventEmitter) {
+    "use strict";
+    _inherits(DevMiddleware, EventEmitter);
+    var _super = _createSuper(DevMiddleware);
+    function DevMiddleware(param) {
+        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), "devOptions", void 0);
+        _defineProperty(_assertThisInitialized(_this), "socketServer", void 0);
+        _this.devOptions = dev;
+        _this.socketServer = new SocketServer(dev);
+        if (devMiddleware) {
+            _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: "sockWrite",
+            value: function sockWrite(type, data) {
+                this.socketServer.sockWrite(type, data);
+            }
+        },
+        {
+            key: "setupDevMiddleware",
+            value: function setupDevMiddleware(devMiddleware) {
+                var _this = this;
+                var devOptions = this.devOptions;
+                var callbacks = {
+                    onInvalid: function() {
+                        _this.socketServer.sockWrite("invalid");
+                    },
+                    onDone: function(stats) {
+                        _this.socketServer.updateStats(stats);
+                        _this.emit("change", stats);
+                    }
+                };
+                var enableHMR = this.devOptions.hot || this.devOptions.liveReload;
+                var middleware = devMiddleware(_objectSpread({
+                    headers: devOptions.headers,
+                    stats: false,
+                    callbacks: callbacks,
+                    hmrClientPath: enableHMR ? getHMRClientPath(devOptions.client) : void 0
+                }, devOptions.devMiddleware));
+                return middleware;
+            }
+        }
+    ]);
+    return DevMiddleware;
+}(EventEmitter);
+export { DevMiddleware as default };

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

@@ -0,0 +1,209 @@
+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;
+}
+import ws from "ws";
+import { logger } from "@modern-js/utils";
+var SocketServer = /*#__PURE__*/ function() {
+    "use strict";
+    function SocketServer(options) {
+        _classCallCheck(this, SocketServer);
+        _defineProperty(this, "wsServer", void 0);
+        _defineProperty(this, "sockets", []);
+        _defineProperty(this, "options", void 0);
+        _defineProperty(this, "app", void 0);
+        _defineProperty(this, "stats", void 0);
+        _defineProperty(this, "timer", null);
+        this.options = options;
+    }
+    _createClass(SocketServer, [
+        {
+            key: "prepare",
+            value: function prepare(app) {
+                var _this = this;
+                var ref;
+                this.app = app;
+                this.wsServer = new ws.Server({
+                    noServer: true,
+                    path: (ref = this.options.client) === null || ref === void 0 ? void 0 : ref.path
+                });
+                this.app.on("upgrade", function(req, sock, head) {
+                    if (!_this.wsServer.shouldHandle(req)) {
+                        return;
+                    }
+                    _this.wsServer.handleUpgrade(req, sock, head, function(connection) {
+                        _this.wsServer.emit("connection", connection, req);
+                    });
+                });
+                this.wsServer.on("error", function(err) {
+                    logger.error(err);
+                });
+                this.timer = setInterval(function() {
+                    _this.wsServer.clients.forEach(function(socket) {
+                        var extWs = socket;
+                        if (!extWs.isAlive) {
+                            extWs.terminate();
+                        } else {
+                            extWs.isAlive = false;
+                            extWs.ping(function() {});
+                        }
+                    });
+                }, 3e4);
+                this.wsServer.on("connection", function(socket) {
+                    _this.onConnect(socket);
+                });
+            }
+        },
+        {
+            key: "updateStats",
+            value: function updateStats(stats) {
+                this.stats = stats;
+                this.sendStats();
+            }
+        },
+        {
+            key: "sockWrite",
+            value: function sockWrite(type, data) {
+                var _this = this;
+                this.sockets.forEach(function(socket) {
+                    _this.send(socket, JSON.stringify({
+                        type: type,
+                        data: data
+                    }));
+                });
+            }
+        },
+        {
+            key: "singleWrite",
+            value: function singleWrite(socket, type, data) {
+                this.send(socket, JSON.stringify({
+                    type: type,
+                    data: data
+                }));
+            }
+        },
+        {
+            key: "close",
+            value: function close() {
+                this.sockets.forEach(function(socket) {
+                    socket.close();
+                });
+                if (this.timer) {
+                    clearInterval(this.timer);
+                    this.timer = null;
+                }
+            }
+        },
+        {
+            key: "onConnect",
+            value: function onConnect(socket) {
+                var _this = this;
+                var connection = socket;
+                connection.isAlive = true;
+                connection.on("pong", function() {
+                    connection.isAlive = true;
+                });
+                if (!connection) {
+                    return;
+                }
+                this.sockets.push(connection);
+                connection.on("close", function() {
+                    var idx = _this.sockets.indexOf(connection);
+                    if (idx >= 0) {
+                        _this.sockets.splice(idx, 1);
+                    }
+                });
+                if (this.options.hot || this.options.hot === "only") {
+                    this.singleWrite(connection, "hot");
+                }
+                if (this.options.liveReload) {
+                    this.singleWrite(connection, "liveReload");
+                }
+                if (this.stats) {
+                    this.sendStats(true);
+                }
+            }
+        },
+        {
+            key: "getStats",
+            value: function getStats() {
+                var curStats = this.stats;
+                if (!curStats) {
+                    return null;
+                }
+                var defaultStats = {
+                    all: false,
+                    hash: true,
+                    assets: true,
+                    warnings: true,
+                    errors: true,
+                    errorDetails: false
+                };
+                return curStats.toJson(defaultStats);
+            }
+        },
+        {
+            key: "sendStats",
+            value: function sendStats() {
+                var force = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
+                var stats = this.getStats();
+                if (!stats) {
+                    return null;
+                }
+                var shouldEmit = !force && stats && (!stats.errors || stats.errors.length === 0) && stats.assets && stats.assets.every(function(asset) {
+                    return !asset.emitted;
+                });
+                if (shouldEmit) {
+                    return this.sockWrite("still-ok");
+                }
+                this.sockWrite("hash", stats.hash);
+                if (stats.errors && stats.errors.length > 0) {
+                    return this.sockWrite("errors", stats.errors);
+                } else if (stats.warnings && stats.warnings.length > 0) {
+                    return this.sockWrite("warnings", stats.warnings);
+                } else {
+                    return this.sockWrite("ok");
+                }
+            }
+        },
+        {
+            key: "send",
+            value: function send(connection, message) {
+                if (connection.readyState !== 1) {
+                    return;
+                }
+                connection.send(message);
+            }
+        }
+    ]);
+    return SocketServer;
+}();
+export { SocketServer as default };