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

package/dist/esm/rslib-runtime.mjs

@@ -0,0 +1,18 @@
+var __webpack_modules__ = {};
+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__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+export { __webpack_require__ };

package/dist/esm/serverBase.mjs

@@ -0,0 +1,139 @@
+import { server as server_server } from "@modern-js/plugin/server";
+import { Hono } from "hono";
+import { run } from "./context.mjs";
+import { handleSetupResult } from "./plugins/compat/hooks.mjs";
+import { loadConfig } from "./utils/index.mjs";
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+var _applyMiddlewares = /*#__PURE__*/ new WeakSet();
+class ServerBase {
+    async init() {
+        const { serverConfig, config: cliConfig } = this.serverOptions;
+        const mergedConfig = loadConfig({
+            cliConfig,
+            serverConfig: serverConfig || {}
+        });
+        const { serverContext } = await server_server.run({
+            plugins: this.plugins,
+            options: this.serverOptions,
+            config: mergedConfig,
+            handleSetupResult: handleSetupResult
+        });
+        serverContext.serverBase = this;
+        this.serverContext = serverContext;
+        await serverContext.hooks.onPrepare.call();
+        _class_private_method_get(this, _applyMiddlewares, applyMiddlewares).call(this);
+        return this;
+    }
+    addPlugins(plugins) {
+        this.plugins.push(...plugins);
+    }
+    get hooks() {
+        return this.serverContext.hooks;
+    }
+    get all() {
+        return this.app.all.bind(this.app);
+    }
+    get use() {
+        return this.app.use.bind(this.app);
+    }
+    get get() {
+        return this.app.get.bind(this.app);
+    }
+    get options() {
+        return this.app.options.bind(this.app);
+    }
+    get post() {
+        return this.app.post.bind(this.app);
+    }
+    get put() {
+        return this.app.put.bind(this.app);
+    }
+    get delete() {
+        return this.app.delete.bind(this.app);
+    }
+    get patch() {
+        return this.app.patch.bind(this.app);
+    }
+    get handle() {
+        return this.app.fetch.bind(this.app);
+    }
+    get request() {
+        return this.app.request.bind(this.app);
+    }
+    get notFound() {
+        return this.app.notFound.bind(this.app);
+    }
+    get onError() {
+        return this.app.onError.bind(this.app);
+    }
+    constructor(options){
+        _class_private_method_init(this, _applyMiddlewares);
+        this.plugins = [];
+        this.serverContext = null;
+        this.serverOptions = options;
+        this.app = new Hono();
+        this.app.use('*', run);
+    }
+}
+function applyMiddlewares() {
+    const { middlewares } = this.serverContext;
+    const preMiddlewares = [];
+    const defaultMiddlewares = [];
+    const postMiddlewares = [];
+    for (const middleware of middlewares)switch(middleware.order){
+        case 'pre':
+            preMiddlewares.push(middleware);
+            break;
+        case 'post':
+            postMiddlewares.push(middleware);
+            break;
+        default:
+            defaultMiddlewares.push(middleware);
+    }
+    const finalMiddlewares = [];
+    const insertMiddleware = (middleware)=>{
+        if (middleware.before) {
+            const targetIndex = finalMiddlewares.findIndex((item)=>{
+                if (middleware.before?.includes(item.name)) return true;
+                return false;
+            });
+            if (-1 !== targetIndex) finalMiddlewares.splice(targetIndex, 0, middleware);
+            else finalMiddlewares.push(middleware);
+        } else finalMiddlewares.push(middleware);
+    };
+    preMiddlewares.forEach(insertMiddleware);
+    defaultMiddlewares.forEach(insertMiddleware);
+    postMiddlewares.forEach(insertMiddleware);
+    for (const middleware of finalMiddlewares){
+        const { path = '*', method = 'all', handler } = middleware;
+        const handlers = handler2Handlers(handler);
+        if (0 === handlers.length) continue;
+        const firstHandler = handlers[0];
+        const restHandlers = handlers.slice(1);
+        const m = method;
+        const register = this.app[m];
+        register.call(this.app, path, firstHandler, ...restHandlers);
+    }
+    function handler2Handlers(handler) {
+        if (Array.isArray(handler)) return handler;
+        return [
+            handler
+        ];
+    }
+}
+function createServerBase(options) {
+    if (null == options) throw new Error('can not start server without options');
+    const server = new ServerBase(options);
+    return server;
+}
+export { ServerBase, createServerBase };

package/dist/esm/types/config/index.mjs

@@ -0,0 +1,6 @@
+export * from "./bff.mjs";
+export * from "./html.mjs";
+export * from "./output.mjs";
+export * from "./server.mjs";
+export * from "./source.mjs";
+export * from "./tools.mjs";

package/dist/esm/types/index.mjs

@@ -0,0 +1,4 @@
+export * from "./config/index.mjs";
+export * from "./plugins/index.mjs";
+export * from "./render.mjs";
+export * from "./server.mjs";

package/dist/esm/types/plugins/index.mjs

@@ -0,0 +1 @@
+export * from "./plugin.mjs";

package/dist/esm/utils/entry.mjs

@@ -0,0 +1,3 @@
+const sortRoutes = (route1, route2)=>route2.urlPath.length - route1.urlPath.length;
+const uniqueKeyByRoute = (route)=>`${route.entryName}-${route.urlPath}`;
+export { sortRoutes, uniqueKeyByRoute };

package/dist/esm/utils/env.mjs

@@ -0,0 +1,14 @@
+const getRuntimeEnv = ()=>{
+    if (globalThis?.process?.release?.name === 'node') return 'node';
+    return 'other';
+};
+const checkIsProd = ()=>{
+    const env = getRuntimeEnv();
+    switch(env){
+        case 'node':
+            return 'production' === process.env.NODE_ENV;
+        default:
+            return false;
+    }
+};
+export { checkIsProd, getRuntimeEnv };

package/dist/esm/utils/error.mjs

@@ -0,0 +1,53 @@
+import { parseHeaders } from "./request.mjs";
+const ERROR_PAGE_TEXT = {
+    404: 'This page could not be found.',
+    500: 'Internal Server Error.'
+};
+const createErrorHtml = (status)=>{
+    const text = ERROR_PAGE_TEXT[status] || '';
+    const title = `${status}: ${text}`;
+    return `<!DOCTYPE html>
+  <html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width">
+    <title>${title}</title>
+    <style>
+      html,body {
+        margin: 0;
+      }
+
+      .page-container {
+        color: #000;
+        background: #fff;
+        height: 100vh;
+        text-align: center;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="page-container">
+    <h1>${status}</h1>
+    <div>${text}</div>
+  </body>
+  </html>
+  `;
+};
+var error_ErrorDigest = /*#__PURE__*/ function(ErrorDigest) {
+    ErrorDigest["ENOTF"] = "Page could not be found";
+    ErrorDigest["EINTER"] = "Internal server error";
+    ErrorDigest["ERENDER"] = "SSR render fallback";
+    return ErrorDigest;
+}({});
+function onError(digest, error, monitors, req) {
+    const headerData = req && parseHeaders(req);
+    headerData && delete headerData.cookie;
+    if (monitors) monitors.error(req ? `Server Error - ${digest}, error = %s, req.url = %s, req.headers = %o` : `Server Error - ${digest}, error = %s`, error instanceof Error ? error.stack || error.message : error, req?.url, headerData);
+    else if (req) console.error(`Server Error - ${digest}, error = ${error instanceof Error ? error.stack || error.message : error}, req.url = ${req.url}, req.headers = ${JSON.stringify(headerData)}`);
+    else console.error(`Server Error - ${digest}, error = ${error instanceof Error ? error.stack || error.message : error} `);
+}
+export { createErrorHtml, error_ErrorDigest as ErrorDigest, onError };

package/dist/esm/utils/index.mjs

@@ -0,0 +1,9 @@
+export * from "./entry.mjs";
+export * from "./env.mjs";
+export * from "./error.mjs";
+export * from "./middlewareCollector.mjs";
+export * from "./publicDir.mjs";
+export * from "./request.mjs";
+export * from "./serverConfig.mjs";
+export * from "./transformStream.mjs";
+export * from "./warmup.mjs";

package/dist/esm/utils/middlewareCollector.mjs

@@ -0,0 +1,26 @@
+const mergeExtension = (users)=>{
+    const output = [];
+    return {
+        middleware: output.concat(users)
+    };
+};
+const createMiddlewareCollecter = ()=>{
+    const webMiddlewares = [];
+    const apiMiddlewares = [];
+    const addWebMiddleware = (input)=>{
+        webMiddlewares.push(input);
+    };
+    const addAPIMiddleware = (input)=>{
+        apiMiddlewares.push(input);
+    };
+    const getMiddlewares = ()=>({
+            web: webMiddlewares,
+            api: apiMiddlewares
+        });
+    return {
+        getMiddlewares,
+        addWebMiddleware,
+        addAPIMiddleware
+    };
+};
+export { createMiddlewareCollecter, mergeExtension };

package/dist/esm/utils/publicDir.mjs

@@ -0,0 +1,33 @@
+import path from "path";
+function normalizePublicDir(publicDir) {
+    if (!publicDir) return [];
+    return Array.isArray(publicDir) ? publicDir : [
+        publicDir
+    ];
+}
+function normalizePublicDirPath(dir) {
+    return dir.replace(/^\.\//, '').replace(/\/$/, '');
+}
+function getPublicDirRoutePrefixes(publicDir) {
+    const dirs = normalizePublicDir(publicDir);
+    return dirs.map((dir)=>{
+        const normalized = normalizePublicDirPath(dir);
+        return `/${normalized}`;
+    });
+}
+function getPublicDirPatterns(publicDir) {
+    const dirs = normalizePublicDir(publicDir);
+    return dirs.map((dir)=>{
+        const normalized = normalizePublicDirPath(dir);
+        return `${normalized}/`;
+    });
+}
+function resolvePublicDirPaths(publicDir, appDirectory) {
+    const dirs = normalizePublicDir(publicDir);
+    if (!appDirectory) return dirs;
+    return dirs.map((dir)=>path.resolve(appDirectory, dir));
+}
+function getPublicDirConfig(serverConfig) {
+    return serverConfig?.publicDir;
+}
+export { getPublicDirConfig, getPublicDirPatterns, getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath, resolvePublicDirPaths };

package/dist/esm/utils/request.mjs

@@ -0,0 +1,40 @@
+function parseQuery(req) {
+    const query = {};
+    const { url } = req;
+    const q = url.split('?')[1];
+    if (q) {
+        const search = new URLSearchParams(q);
+        search.forEach((v, k)=>{
+            query[k] = v;
+        });
+    }
+    return query;
+}
+function parseHeaders(request) {
+    const headersData = {};
+    request.headers.forEach((value, key)=>{
+        headersData[key] = value;
+    });
+    return headersData;
+}
+function getPathname(request) {
+    const match = request.url.match(/^https?:\/\/[^/]+(\/[^?]*)/);
+    return match?.[1] ?? '/';
+}
+function getHost(request) {
+    const { headers } = request;
+    let host = headers.get('X-Forwarded-Host');
+    if (!host) host = headers.get('Host');
+    host = host?.split(/\s*,\s*/, 1)[0] || 'undefined';
+    return host;
+}
+function parseCookie(req) {
+    const _cookie = req.headers.get('Cookie');
+    const cookie = {};
+    _cookie?.trim().split(';').forEach((item)=>{
+        const [k, v] = item.trim().split('=');
+        if (k && void 0 !== v) cookie[k] = v;
+    });
+    return cookie;
+}
+export { getHost, getPathname, parseCookie, parseHeaders, parseQuery };

package/dist/esm/utils/serverConfig.mjs

@@ -0,0 +1,9 @@
+import { merge } from "ts-deepmerge";
+const loadConfig = ({ cliConfig, serverConfig })=>{
+    const config = merge({
+        ...cliConfig,
+        plugins: []
+    }, serverConfig);
+    return config;
+};
+export { loadConfig };

package/dist/esm/utils/storage.mjs

@@ -0,0 +1,35 @@
+import * as __rspack_external_async_hooks from "async_hooks";
+const createStorage = (storageKey)=>{
+    let storage;
+    if (void 0 !== __rspack_external_async_hooks.AsyncLocalStorage) if (storageKey) {
+        const globalStore = globalThis;
+        const sharedStorage = globalStore[storageKey];
+        storage = sharedStorage ?? new __rspack_external_async_hooks.AsyncLocalStorage();
+        globalStore[storageKey] = storage;
+    } else storage = new __rspack_external_async_hooks.AsyncLocalStorage();
+    const run = (context, cb)=>{
+        if (!storage) throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+        return new Promise((resolve, reject)=>{
+            storage.run(context, ()=>{
+                try {
+                    return resolve(cb());
+                } catch (error) {
+                    return reject(error);
+                }
+            });
+        });
+    };
+    const useContext = ()=>{
+        if (!storage) throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+        const context = storage.getStore();
+        if (!context) throw new Error("Can't call context hook out of server scope");
+        return context;
+    };
+    return {
+        run,
+        useContext
+    };
+};
+export { createStorage };

package/dist/esm/utils/transformStream.mjs

@@ -0,0 +1,28 @@
+function createTransformStream(fn) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    return new TransformStream({
+        async transform (chunk, controller) {
+            const content = decoder.decode(chunk);
+            const newContent = fn ? await fn(content) : content;
+            controller.enqueue(encoder.encode(newContent));
+        }
+    });
+}
+function transformResponse(response, transformCb) {
+    let readable = null;
+    if (response.body) {
+        const stream = createTransformStream(async (before)=>{
+            if (Array.isArray(transformCb)) return transformCb.reduce(async (before, cb)=>cb(await before), Promise.resolve(before));
+            return transformCb(before);
+        });
+        response.body.pipeThrough(stream);
+        readable = stream.readable;
+    }
+    return new Response(readable, {
+        status: response.status,
+        headers: response.headers,
+        statusText: response.statusText
+    });
+}
+export { createTransformStream, transformResponse };

package/dist/esm/utils/warmup.mjs

@@ -0,0 +1,6 @@
+function warmup(bundles) {
+    bundles.forEach((bundle)=>{
+        bundle && import(bundle).catch((_)=>{});
+    });
+}
+export { warmup };

package/dist/esm-node/adapters/node/helper/index.mjs

@@ -0,0 +1,6 @@
+import "node:module";
+export { loadCacheConfig } from "./loadCache.mjs";
+export { loadServerCliConfig, loadServerRuntimeConfig } from "./loadConfig.mjs";
+export { loadServerEnv } from "./loadEnv.mjs";
+export { loadServerPlugins } from "./loadPlugin.mjs";
+export { isResFinalized } from "./utils.mjs";

package/dist/esm-node/adapters/node/helper/loadCache.mjs

@@ -0,0 +1,15 @@
+import "node:module";
+import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
+import path from "path";
+const CACHE_FILENAME = 'cache';
+async function loadCacheConfig(pwd) {
+    const serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
+    const mod = await requireExistModule(serverCacheFilepath, {
+        interop: false
+    });
+    if (mod?.cacheOption) return {
+        strategy: mod.cacheOption,
+        container: mod.customContainer
+    };
+}
+export { loadCacheConfig };

package/dist/esm-node/adapters/node/helper/loadConfig.mjs

@@ -0,0 +1,32 @@
+import "node:module";
+import { OUTPUT_CONFIG_FILE, ensureAbsolutePath, fs as utils_fs, lodash, requireExistModule } from "@modern-js/utils";
+import { parse } from "flatted";
+import path_0 from "path";
+async function loadServerConfigNew(serverConfigPath) {
+    const mod = await requireExistModule(serverConfigPath);
+    if (mod) return mod;
+}
+async function loadServerRuntimeConfig(serverConfigPath) {
+    const newServerConfig = await loadServerConfigNew(serverConfigPath);
+    return newServerConfig;
+}
+function loadServerCliConfig(pwd, defaultConfig = {}) {
+    const cliConfigPath = ensureAbsolutePath(pwd, path_0.join(defaultConfig.output?.distPath?.root || 'dist', OUTPUT_CONFIG_FILE));
+    let cliConfig = {
+        output: {},
+        source: {},
+        tools: {},
+        server: {},
+        security: {},
+        bff: {},
+        html: {},
+        dev: {}
+    };
+    try {
+        const content = utils_fs.readFileSync(cliConfigPath, 'utf-8');
+        cliConfig = parse(content);
+    } catch (_) {}
+    const mergedCliConfig = lodash.merge(defaultConfig, cliConfig);
+    return mergedCliConfig;
+}
+export { loadServerCliConfig, loadServerRuntimeConfig };

package/dist/esm-node/adapters/node/helper/loadEnv.mjs

@@ -0,0 +1,23 @@
+import "node:module";
+import { dotenv, dotenvExpand, fs } from "@modern-js/utils";
+import path from "path";
+async function loadServerEnv(options) {
+    const { pwd } = options;
+    const serverEnv = process.env.MODERN_ENV;
+    const defaultEnvPath = path.resolve(pwd, ".env");
+    const serverEnvPath = path.resolve(pwd, `.env.${serverEnv}`);
+    if (await fs.pathExists(defaultEnvPath) && !(await fs.stat(defaultEnvPath)).isDirectory()) {
+        const envConfig = dotenv.config({
+            path: defaultEnvPath
+        });
+        dotenvExpand(envConfig);
+    }
+    if (await fs.pathExists(serverEnvPath) && !(await fs.stat(serverEnvPath)).isDirectory()) {
+        const envConfig = dotenv.config({
+            path: serverEnvPath
+        });
+        if (envConfig.parsed) Object.assign(process.env, envConfig.parsed);
+        dotenvExpand(envConfig);
+    }
+}
+export { loadServerEnv };

package/dist/esm-node/adapters/node/helper/loadPlugin.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+import { compatibleRequire, tryResolve } from "@modern-js/utils";
+async function resolveServerPlugin(plugin, appDirectory) {
+    const { name, options } = plugin;
+    const pluginPath = tryResolve(name, appDirectory);
+    const module = await compatibleRequire(pluginPath);
+    const pluginInstance = module(options);
+    return pluginInstance;
+}
+async function loadServerPlugins(serverPlugins, appDirectory) {
+    const instances = await Promise.all(serverPlugins.map((plugin)=>resolveServerPlugin(plugin, appDirectory)));
+    return instances;
+}
+export { loadServerPlugins };

package/dist/esm-node/adapters/node/helper/utils.mjs

@@ -0,0 +1,6 @@
+import "node:module";
+const isResFinalized = (res)=>{
+    const response = res;
+    return Boolean(response.headersSent) || Boolean(response._modernBodyPiped) || Boolean(response.writableEnded) || Boolean(response.finished) || response.socket?.writable === false;
+};
+export { isResFinalized };

package/dist/esm-node/adapters/node/hono.mjs

@@ -0,0 +1,56 @@
+import "node:module";
+import { isResFinalized } from "./helper/index.mjs";
+const httpCallBack2HonoMid = (handler)=>async (context, next)=>{
+        const { req, res: rawRes } = context.env.node;
+        const res = rawRes;
+        const onPipe = ()=>{
+            res._modernBodyPiped = true;
+        };
+        res.once?.('pipe', onPipe);
+        req.__honoRequest = context.req;
+        req.__templates = context.get('templates') || {};
+        req.__serverManifest = context.get('serverManifest') || {};
+        req.__rscServerManifest = context.get('rscServerManifest');
+        req.__rscClientManifest = context.get('rscClientManifest');
+        req.__rscSSRManifest = context.get('rscSSRManifest');
+        try {
+            await handler(req, res);
+        } finally{
+            delete req.__honoRequest;
+            delete req.__templates;
+            delete req.__serverManifest;
+            delete req.__rscServerManifest;
+            delete req.__rscClientManifest;
+            delete req.__rscSSRManifest;
+            res.removeListener?.('pipe', onPipe);
+        }
+        if (isResFinalized(res)) {
+            context.res;
+            context.finalized = true;
+        } else await next();
+    };
+const noop = ()=>{};
+const connectMid2HonoMid = (handler)=>async (context, next)=>new Promise((resolve, reject)=>{
+            const { req, res } = context.env.node;
+            if (handler.length < 3) resolve(handler(req, res, noop));
+            else handler(req, res, (err)=>{
+                if (err) reject(err);
+                else resolve(next());
+            });
+        });
+const connectMockMid2HonoMid = (handler)=>async (context, next)=>new Promise((resolve, reject)=>{
+            const { req, res: rawRes } = context.env.node;
+            const res = rawRes;
+            if (handler.length < 3) {
+                res.once?.('finish', ()=>{
+                    context.res;
+                    context.finalized = true;
+                    resolve();
+                });
+                handler(req, res, noop);
+            } else handler(req, res, (err)=>{
+                if (err) reject(err);
+                else resolve(next());
+            });
+        });
+export { connectMid2HonoMid, connectMockMid2HonoMid, httpCallBack2HonoMid };

package/dist/esm-node/adapters/node/index.mjs

@@ -0,0 +1,5 @@
+import "node:module";
+export { loadCacheConfig, loadServerCliConfig, loadServerEnv, loadServerPlugins, loadServerRuntimeConfig } from "./helper/index.mjs";
+export { connectMid2HonoMid, connectMockMid2HonoMid, httpCallBack2HonoMid } from "./hono.mjs";
+export { createNodeServer, createWebRequest, sendResponse } from "./node.mjs";
+export { getHtmlTemplates, getServerManifest, injectNodeSeverPlugin, injectResourcePlugin, injectRscManifestPlugin, serverStaticPlugin } from "./plugins/index.mjs";