@bleedingdev/modern-js-server 3.2.0-ultramodern.0

package/dist/cjs/helpers/devOptions.js

@@ -0,0 +1,61 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getDevAssetPrefix: ()=>getDevAssetPrefix,
+    getDevOptions: ()=>getDevOptions
+});
+const getDevOptions = (devOptions)=>{
+    const defaultOptions = {
+        https: false,
+        server: {}
+    };
+    return {
+        ...defaultOptions,
+        ...devOptions
+    };
+};
+const getDevAssetPrefix = (builder)=>new Promise((resolve)=>{
+        if (!builder) return resolve('');
+        builder?.onAfterCreateCompiler((params)=>{
+            let webCompiler;
+            webCompiler = 'compilers' in params.compiler ? params.compiler.compilers.find((c)=>'web' === c.name || 'client' === c.name) : params.compiler;
+            const publicPath = webCompiler?.options?.output?.publicPath;
+            if (publicPath && 'string' == typeof publicPath) {
+                const formatPublicPath = publicPath.replace(/^https?:\/\/[^/]+/, '');
+                return resolve(formatPublicPath);
+            }
+            return resolve('');
+        });
+    });
+exports.getDevAssetPrefix = __webpack_exports__.getDevAssetPrefix;
+exports.getDevOptions = __webpack_exports__.getDevOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getDevAssetPrefix",
+    "getDevOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/helpers/fileReader.js

@@ -0,0 +1,53 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    initFileReader: ()=>initFileReader
+});
+const fileReader_namespaceObject = require("@modern-js/runtime-utils/fileReader");
+const initFileReader = (compiler)=>{
+    let isInit = false;
+    return async (ctx, next)=>{
+        if (isInit) return next();
+        isInit = true;
+        const { res } = ctx.env.node;
+        if (!compiler) {
+            fileReader_namespaceObject.fileReader.reset();
+            return next();
+        }
+        const resolvedCompiler = 'compilers' in compiler ? compiler.compilers[0] : compiler;
+        const outputFileSystem = resolvedCompiler?.outputFileSystem;
+        if (outputFileSystem) fileReader_namespaceObject.fileReader.reset(outputFileSystem);
+        else fileReader_namespaceObject.fileReader.reset();
+        return next();
+    };
+};
+exports.initFileReader = __webpack_exports__.initFileReader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initFileReader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/helpers/index.js

@@ -0,0 +1,173 @@
+"use strict";
+var __webpack_modules__ = {
+    "../dev-tools/watcher" (module) {
+        module.exports = require("../dev-tools/watcher/index.js");
+    },
+    "./devOptions" (module) {
+        module.exports = require("./devOptions.js");
+    },
+    "./fileReader" (module) {
+        module.exports = require("./fileReader.js");
+    },
+    "./mock" (module) {
+        module.exports = require("./mock.js");
+    },
+    "./repack" (module) {
+        module.exports = require("./repack.js");
+    },
+    "./utils" (module) {
+        module.exports = require("./utils.js");
+    },
+    "@modern-js/server-core" (module) {
+        module.exports = require("@modern-js/server-core");
+    },
+    "@modern-js/utils" (module) {
+        module.exports = require("@modern-js/utils");
+    },
+    path (module) {
+        module.exports = require("path");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        startWatcher: ()=>startWatcher
+    });
+    var _modern_js_server_core__rspack_import_0 = __webpack_require__("@modern-js/server-core");
+    var _modern_js_utils__rspack_import_1 = __webpack_require__("@modern-js/utils");
+    var path__rspack_import_2 = __webpack_require__("path");
+    var path__rspack_import_2_default = /*#__PURE__*/ __webpack_require__.n(path__rspack_import_2);
+    var _dev_tools_watcher__rspack_import_3 = __webpack_require__("../dev-tools/watcher");
+    var _dev_tools_watcher__rspack_import_3_default = /*#__PURE__*/ __webpack_require__.n(_dev_tools_watcher__rspack_import_3);
+    var _mock__rspack_import_4 = __webpack_require__("./mock");
+    var _utils__rspack_import_5 = __webpack_require__("./utils");
+    var _devOptions__rspack_import_6 = __webpack_require__("./devOptions");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _devOptions__rspack_import_6)if ([
+        "startWatcher",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_devOptions__rspack_import_6[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _fileReader__rspack_import_7 = __webpack_require__("./fileReader");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _fileReader__rspack_import_7)if ([
+        "startWatcher",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_fileReader__rspack_import_7[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _mock__rspack_import_4)if ([
+        "startWatcher",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_mock__rspack_import_4[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _repack__rspack_import_8 = __webpack_require__("./repack");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _repack__rspack_import_8)if ([
+        "startWatcher",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_repack__rspack_import_8[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    async function onServerChange({ pwd, filepath, event, server }) {
+        const { mock } = _modern_js_server_core__rspack_import_0.AGGRED_DIR;
+        const mockPath = path__rspack_import_2_default().normalize(path__rspack_import_2_default().join(pwd, mock));
+        const { hooks } = server;
+        if (filepath.startsWith(mockPath)) {
+            await (0, _mock__rspack_import_4.initOrUpdateMockMiddlewares)(pwd);
+            _modern_js_utils__rspack_import_1.logger.info('Finish update the mock handlers');
+        } else try {
+            const fileChangeEvent = {
+                type: 'file-change',
+                payload: [
+                    {
+                        filename: filepath,
+                        event
+                    }
+                ]
+            };
+            await hooks.onReset.call({
+                event: fileChangeEvent
+            });
+            (0, _utils__rspack_import_5.debug)(`Finish reload server, trigger by ${filepath} ${event}`);
+        } catch (e) {
+            _modern_js_utils__rspack_import_1.logger.error(e);
+        }
+    }
+    function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server }) {
+        const { mock } = _modern_js_server_core__rspack_import_0.AGGRED_DIR;
+        const defaultWatched = [
+            `${mock}/**/*`,
+            `${_modern_js_utils__rspack_import_1.SERVER_DIR}/**/*`,
+            `${apiDir}/**`,
+            `${sharedDir}/**/*`,
+            `${distDir}/${_modern_js_utils__rspack_import_1.SERVER_BUNDLE_DIRECTORY}/*-server-loaders.js`
+        ];
+        const mergedWatchOptions = (0, _dev_tools_watcher__rspack_import_3.mergeWatchOptions)(watchOptions);
+        const defaultWatchedPaths = defaultWatched.map((p)=>{
+            const finalPath = path__rspack_import_2_default().isAbsolute(p) ? p : path__rspack_import_2_default().join(pwd, p);
+            return path__rspack_import_2_default().normalize(finalPath);
+        });
+        const watcher = new (_dev_tools_watcher__rspack_import_3_default())();
+        watcher.createDepTree();
+        watcher.listen(defaultWatchedPaths, mergedWatchOptions, (filepath, event)=>{
+            if (filepath.includes('-server-loaders.js')) return void delete require.cache[filepath];
+            watcher.updateDepTree();
+            watcher.cleanDepCache(filepath);
+            onServerChange({
+                pwd,
+                filepath,
+                event,
+                server
+            });
+        });
+        return watcher;
+    }
+})();
+exports.startWatcher = __webpack_exports__.startWatcher;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "startWatcher"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/helpers/mock.js

@@ -0,0 +1,136 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getMatched: ()=>getMatched,
+    getMockMiddleware: ()=>getMockMiddleware,
+    initOrUpdateMockMiddlewares: ()=>initOrUpdateMockMiddlewares
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const server_core_namespaceObject = require("@modern-js/server-core");
+const node_namespaceObject = require("@modern-js/server-core/node");
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_to_regexp_namespaceObject = require("path-to-regexp");
+let mockAPIs = [];
+let mockConfig;
+const parseKey = (key)=>{
+    const _blank = ' ';
+    const splitted = key.split(_blank).filter(Boolean);
+    if (splitted.length > 1) {
+        const [method, pathname] = splitted;
+        return {
+            method: (method ?? 'get').toLowerCase(),
+            path: pathname ?? '/'
+        };
+    }
+    return {
+        method: 'get',
+        path: key
+    };
+};
+const getMockModule = async (pwd)=>{
+    const exts = [
+        '.ts',
+        '.js'
+    ];
+    let mockFilePath = '';
+    for (const ext of exts){
+        const maybeMatch = external_node_path_default().join(pwd, `${server_core_namespaceObject.AGGRED_DIR.mock}/index${ext}`);
+        if (await utils_namespaceObject.fs.pathExists(maybeMatch)) {
+            mockFilePath = maybeMatch;
+            break;
+        }
+    }
+    if (!mockFilePath) return;
+    const { default: mockHandlers, config } = await import(mockFilePath);
+    const enable = config?.enable;
+    if (false === enable) return;
+    if (!mockHandlers) throw new Error(`Mock file ${mockFilePath} parsed failed!`);
+    return {
+        mockHandlers,
+        config
+    };
+};
+const getMatched = (request, mockApis)=>{
+    const { path: targetPathname, method: targetMethod } = request;
+    const matched = mockApis.find((mockApi)=>{
+        const { method, path: pathname } = mockApi;
+        if (method.toLowerCase() === targetMethod.toLowerCase()) return (0, external_path_to_regexp_namespaceObject.match)(pathname, {
+            decode: decodeURIComponent
+        })(targetPathname);
+        return false;
+    });
+    return matched;
+};
+async function initOrUpdateMockMiddlewares(pwd) {
+    const mockModule = await getMockModule(pwd);
+    mockConfig = mockModule?.config;
+    mockAPIs = Object.entries(mockModule?.mockHandlers || {}).map(([key, handler])=>{
+        const { method, path } = parseKey(key);
+        return {
+            method,
+            path,
+            handler
+        };
+    });
+}
+async function getMockMiddleware(pwd) {
+    await initOrUpdateMockMiddlewares(pwd);
+    const mockMiddleware = async (c, next)=>{
+        if ('function' == typeof mockConfig?.enable) {
+            const isEnabled = mockConfig.enable(c.env.node.req, c.env.node.res);
+            if (!isEnabled) return next();
+        }
+        const matchedMockAPI = getMatched(c.req, mockAPIs);
+        if (matchedMockAPI) {
+            const { handler } = matchedMockAPI;
+            if ('function' == typeof handler) return await (0, node_namespaceObject.connectMockMid2HonoMid)(handler)(c, next);
+            return c.json(handler);
+        }
+        return next();
+    };
+    return mockMiddleware;
+}
+exports.getMatched = __webpack_exports__.getMatched;
+exports.getMockMiddleware = __webpack_exports__.getMockMiddleware;
+exports.initOrUpdateMockMiddlewares = __webpack_exports__.initOrUpdateMockMiddlewares;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getMatched",
+    "getMockMiddleware",
+    "initOrUpdateMockMiddlewares"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/helpers/repack.js

@@ -0,0 +1,50 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    onRepack: ()=>onRepack
+});
+const fileReader_namespaceObject = require("@modern-js/runtime-utils/fileReader");
+const cleanSSRCache = (distDir)=>{
+    Object.keys(require.cache).forEach((key)=>{
+        if (key.startsWith(distDir)) delete require.cache[key];
+    });
+};
+const onRepack = (distDir, hooks)=>{
+    cleanSSRCache(distDir);
+    fileReader_namespaceObject.fileReader.reset();
+    hooks.onReset.call({
+        event: {
+            type: 'repack'
+        }
+    });
+};
+exports.onRepack = __webpack_exports__.onRepack;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "onRepack"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/helpers/utils.js

@@ -0,0 +1,37 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    debug: ()=>debug
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const debug = (0, utils_namespaceObject.createDebugger)('server');
+exports.debug = __webpack_exports__.debug;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "debug"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createDevServer: ()=>external_createDevServer_js_namespaceObject.createDevServer
+});
+const external_createDevServer_js_namespaceObject = require("./createDevServer.js");
+exports.createDevServer = __webpack_exports__.createDevServer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDevServer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/createDevServer.mjs

@@ -0,0 +1,58 @@
+import node_path from "node:path";
+import { createServerBase } from "@modern-js/server-core";
+import { createNodeServer, loadServerRuntimeConfig } from "@modern-js/server-core/node";
+import { devPlugin } from "./dev.mjs";
+import { getDevAssetPrefix, getDevOptions } from "./helpers/index.mjs";
+async function createDevServer(options, applyPlugins) {
+    const { config, pwd, serverConfigPath, builder } = options;
+    const dev = getDevOptions(options.dev);
+    const distDir = node_path.resolve(pwd, config.output.distPath?.root || 'dist');
+    const serverConfig = await loadServerRuntimeConfig(serverConfigPath) || {};
+    const prodServerOptions = {
+        ...options,
+        pwd: distDir,
+        serverConfig: {
+            ...serverConfig,
+            ...options.serverConfig
+        },
+        plugins: [
+            ...serverConfig.plugins || [],
+            ...options.plugins || []
+        ]
+    };
+    const server = createServerBase(prodServerOptions);
+    const devHttpsOption = 'object' == typeof dev && dev.https;
+    const isHttp2 = !!devHttpsOption;
+    let nodeServer;
+    if (devHttpsOption) {
+        const { genHttpsOptions } = await import("./dev-tools/https/index.mjs");
+        const httpsOptions = await genHttpsOptions(devHttpsOption, pwd);
+        nodeServer = await createNodeServer(server.handle.bind(server), httpsOptions, isHttp2);
+    } else nodeServer = await createNodeServer(server.handle.bind(server));
+    const promise = getDevAssetPrefix(builder);
+    let compiler = null;
+    builder?.onAfterCreateCompiler((context)=>{
+        compiler = context.compiler;
+    });
+    const builderDevServer = await builder?.createDevServer({
+        runCompile: options.runCompile
+    });
+    server.addPlugins([
+        devPlugin({
+            ...options,
+            builderDevServer
+        }, compiler)
+    ]);
+    const assetPrefix = await promise;
+    if (assetPrefix) prodServerOptions.config.output.assetPrefix = assetPrefix;
+    await applyPlugins(server, prodServerOptions, nodeServer);
+    await server.init();
+    const afterListen = async ()=>{
+        await builderDevServer?.afterListen();
+    };
+    return {
+        server: nodeServer,
+        afterListen
+    };
+}
+export { createDevServer };

package/dist/esm/dev-tools/https/index.mjs

@@ -0,0 +1,23 @@
+import { chalk, getPackageManager, logger, tryResolve } from "@modern-js/utils";
+const genHttpsOptions = async (userOptions, pwd)=>{
+    const httpsOptions = 'boolean' == typeof userOptions ? {} : userOptions;
+    if (!httpsOptions.key || !httpsOptions.cert) {
+        let devcertPath;
+        try {
+            devcertPath = tryResolve('devcert', pwd, __dirname);
+        } catch (err) {
+            const packageManager = await getPackageManager(pwd);
+            const command = chalk.yellow.bold(`${packageManager} add devcert@1.2.2 -D`);
+            logger.error('You have enabled "dev.https" option, but the "devcert" package is not installed.');
+            logger.error(`Please run ${command} to install manually, otherwise the https can not work.`);
+            throw new Error('[https] "devcert" is not found.');
+        }
+        const devcert = require(devcertPath);
+        const selfsign = await devcert.certificateFor([
+            'localhost'
+        ]);
+        return selfsign;
+    }
+    return httpsOptions;
+};
+export { genHttpsOptions };