@modern-js/server 2.4.1-beta.0 → 2.5.1-alpha.0

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

@@ -0,0 +1,267 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dev_server_exports = {};
+__export(dev_server_exports, {
+  ModernDevServer: () => ModernDevServer
+});
+module.exports = __toCommonJS(dev_server_exports);
+var import_http = require("http");
+var import_path = __toESM(require("path"));
+var import_https = require("https");
+var import_utils = require("@modern-js/utils");
+var import_prod_server = require("@modern-js/prod-server");
+var import_constants = require("@modern-js/utils/constants");
+var import_constants2 = require("../constants");
+var import_mock = require("../dev-tools/mock");
+var import_register = require("../dev-tools/register");
+var import_watcher = __toESM(require("../dev-tools/watcher"));
+var import_dev_middleware = __toESM(require("../dev-tools/dev-middleware"));
+class ModernDevServer extends import_prod_server.ModernServer {
+  constructor(options) {
+    super(options);
+    this.mockHandler = null;
+    this.workDir = this.pwd;
+    this.dev = this.getDevOptions(options);
+    this.devMiddleware = new import_dev_middleware.default({
+      dev: this.dev,
+      devMiddleware: options.devMiddleware
+    });
+    (0, import_register.enableRegister)(this.pwd, this.conf);
+  }
+  getDevOptions(options) {
+    const devOptions = typeof options.dev === "boolean" ? {} : options.dev;
+    const defaultOptions = (0, import_constants2.getDefaultDevOptions)();
+    return {
+      ...defaultOptions,
+      ...devOptions,
+      client: {
+        ...defaultOptions.client,
+        ...devOptions == null ? void 0 : devOptions.client
+      }
+    };
+  }
+  addMiddlewareHandler(handlers) {
+    handlers.forEach((handler) => {
+      this.addHandler((ctx, next) => {
+        const { req, res } = ctx;
+        return handler(req, res, next);
+      });
+    });
+  }
+  applySetupMiddlewares() {
+    const setupMiddlewares = this.dev.setupMiddlewares || [];
+    const serverOptions = {
+      sockWrite: (type, data) => this.devMiddleware.sockWrite(type, data)
+    };
+    const befores = [];
+    const afters = [];
+    setupMiddlewares.forEach((handler) => {
+      handler(
+        {
+          unshift: (...handlers) => befores.unshift(...handlers),
+          push: (...handlers) => afters.push(...handlers)
+        },
+        serverOptions
+      );
+    });
+    return { befores, afters };
+  }
+  async onInit(runner, app) {
+    this.runner = runner;
+    const { dev } = this;
+    const { befores, afters } = this.applySetupMiddlewares();
+    const beforeHandlers = await this.setupBeforeDevMiddleware();
+    this.addMiddlewareHandler([...beforeHandlers, ...befores]);
+    await this.applyDefaultMiddlewares(app);
+    const afterHandlers = await this.setupAfterDevMiddleware();
+    this.addMiddlewareHandler([...afters, ...afterHandlers]);
+    await super.onInit(runner, app);
+    if (dev.watch) {
+      this.startWatcher();
+      app.on("close", async () => {
+        var _a;
+        await ((_a = this.watcher) == null ? void 0 : _a.close());
+      });
+    }
+  }
+  async applyDefaultMiddlewares(app) {
+    const { pwd, dev, devMiddleware } = this;
+    this.addHandler((ctx, next) => {
+      ctx.res.setHeader("Access-Control-Allow-Origin", "*");
+      if (ctx.path.includes("hot-update")) {
+        ctx.res.setHeader("Access-Control-Allow-Credentials", "false");
+      }
+      const confHeaders = dev.headers;
+      if (confHeaders) {
+        for (const [key, value] of Object.entries(confHeaders)) {
+          ctx.res.setHeader(key, value);
+        }
+      }
+      next();
+    });
+    this.mockHandler = (0, import_mock.createMockHandler)({ pwd });
+    this.addHandler((ctx, next) => {
+      if (this.mockHandler) {
+        this.mockHandler(ctx, next);
+      } else {
+        next();
+      }
+    });
+    const proxyHandlers = (0, import_prod_server.createProxyHandler)(dev.proxy);
+    if (proxyHandlers) {
+      proxyHandlers.forEach((handler) => {
+        this.addHandler(handler);
+      });
+    }
+    devMiddleware.init(app);
+    devMiddleware.on("change", (stats) => {
+      if (stats.toJson({ all: false }).name === "client") {
+        this.onRepack({ routes: this.getRoutes() });
+      }
+    });
+    this.addHandler((ctx, next) => {
+      const { req, res } = ctx;
+      if (devMiddleware.middleware) {
+        devMiddleware.middleware(req, res, next);
+      } else {
+        next();
+      }
+    });
+    if (dev.historyApiFallback) {
+      const { default: connectHistoryApiFallback } = await Promise.resolve().then(() => __toESM(require("connect-history-api-fallback")));
+      const historyApiFallbackMiddleware = connectHistoryApiFallback(
+        typeof dev.historyApiFallback === "boolean" ? {} : dev.historyApiFallback
+      );
+      this.addHandler(
+        (ctx, next) => historyApiFallbackMiddleware(ctx.req, ctx.res, next)
+      );
+    }
+  }
+  onRepack(options = {}) {
+    if (Array.isArray(options.routes)) {
+      this.router.reset(this.filterRoutes(options.routes));
+    }
+    this.cleanSSRCache();
+    this.reader.updateFile();
+    this.runner.repack();
+    super.onRepack(options);
+  }
+  async createHTTPServer(handler) {
+    const { dev } = this;
+    const devHttpsOption = typeof dev === "object" && dev.https;
+    if (devHttpsOption) {
+      const { genHttpsOptions } = require("../dev-tools/https");
+      const httpsOptions = await genHttpsOptions(devHttpsOption, this.pwd);
+      return (0, import_https.createServer)(httpsOptions, handler);
+    } else {
+      return (0, import_http.createServer)(handler);
+    }
+  }
+  warmupSSRBundle() {
+  }
+  onServerChange({
+    filepath,
+    event
+  }) {
+    const { pwd } = this;
+    const { mock } = import_prod_server.AGGRED_DIR;
+    const mockPath = import_path.default.normalize(import_path.default.join(pwd, mock));
+    this.runner.reset();
+    if (filepath.startsWith(mockPath)) {
+      this.mockHandler = (0, import_mock.createMockHandler)({ pwd });
+    } else {
+      try {
+        const success = this.runner.onApiChange([
+          { filename: filepath, event }
+        ]);
+        if (success !== true) {
+          super.onServerChange({ filepath });
+        }
+      } catch (e) {
+        this.logger.error(e);
+      }
+    }
+  }
+  createContext(req, res) {
+    return super.createContext(req, res, { etag: true });
+  }
+  async setupBeforeDevMiddleware() {
+    const { runner, conf, dev } = this;
+    const setupMids = dev.before || [];
+    const pluginMids = await runner.beforeDevServer(conf);
+    return [...setupMids, ...pluginMids].flat();
+  }
+  async setupAfterDevMiddleware() {
+    const { runner, conf, dev } = this;
+    const setupMids = dev.after || [];
+    const pluginMids = await runner.afterDevServer(conf);
+    return [...pluginMids, ...setupMids].flat();
+  }
+  cleanSSRCache() {
+    const { distDir } = this;
+    const bundles = this.router.getBundles();
+    bundles.forEach((bundle) => {
+      const filepath = import_path.default.join(distDir, bundle);
+      if (require.cache[filepath]) {
+        delete require.cache[filepath];
+      }
+    });
+    const loadable = import_path.default.join(distDir, import_constants.LOADABLE_STATS_FILE);
+    if (require.cache[loadable]) {
+      delete require.cache[loadable];
+    }
+  }
+  startWatcher() {
+    var _a;
+    const { pwd, distDir } = this;
+    const { mock } = import_prod_server.AGGRED_DIR;
+    const defaultWatched = [
+      `${mock}/**/*`,
+      `${import_utils.SERVER_DIR}/**/*`,
+      `${import_utils.API_DIR}/**`,
+      `${import_utils.SHARED_DIR}/**/*`,
+      `${distDir}/${import_utils.SERVER_BUNDLE_DIRECTORY}/*-server-loaders.js`
+    ];
+    const watchOptions = (0, import_watcher.mergeWatchOptions)((_a = this.conf.server) == null ? void 0 : _a.watchOptions);
+    const defaultWatchedPaths = defaultWatched.map((p) => {
+      const finalPath = import_path.default.isAbsolute(p) ? p : import_path.default.join(pwd, p);
+      return import_path.default.normalize(finalPath);
+    });
+    const watcher = new import_watcher.default();
+    watcher.createDepTree();
+    watcher.listen(defaultWatchedPaths, watchOptions, (filepath, event) => {
+      watcher.updateDepTree();
+      watcher.cleanDepCache(filepath);
+      this.onServerChange({
+        filepath,
+        event
+      });
+    });
+    this.watcher = watcher;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModernDevServer
+});

package/dist/cjs/server/index.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  DevServer: () => DevServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_prod_server = require("@modern-js/prod-server");
+var import_dev_server = require("./dev-server");
+const createDevServer = (options) => {
+  return new import_dev_server.ModernDevServer(options);
+};
+class DevServer extends import_prod_server.Server {
+  constructor(options) {
+    super(options);
+    if (options.dev) {
+      this.serverImpl = createDevServer;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DevServer
+});

package/dist/cjs/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/esm/constants.js

@@ -0,0 +1,21 @@
+import { getIpv4Interfaces, HMR_SOCK_PATH } from "@modern-js/utils";
+var getDefaultDevOptions = function() {
+    var network = getIpv4Interfaces().find(function(item) {
+        return !item.internal;
+    });
+    return {
+        client: {
+            port: "8080",
+            path: HMR_SOCK_PATH,
+            host: (network === null || network === void 0 ? void 0 : network.address) || "localhost"
+        },
+        https: false,
+        devMiddleware: {
+            writeToDisk: true
+        },
+        watch: true,
+        hot: true,
+        liveReload: true
+    };
+};
+export { getDefaultDevOptions };

package/dist/esm/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/esm/dev-tools/dev-middleware/hmr-client/index.js

@@ -0,0 +1,162 @@
+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.onopen = function() {
+            if (typeof console !== "undefined" && typeof console.debug === "function") {
+                console.debug("[HMR] connected.");
+            }
+        };
+        connection.onclose = function() {
+            if (typeof console !== "undefined" && typeof console.info === "function") {
+                console.debug("[HMR] 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();