@bleedingdev/modern-js-server-core 3.5.0-ultramodern.1 → 3.5.0-ultramodern.100

package/dist/esm-node/adapters/node/plugins/staticServing.mjs

@@ -0,0 +1,130 @@
+import "node:module";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+import { fs } from "@modern-js/utils";
+import { getMimeType } from "hono/utils/mime";
+import path from "path";
+import { applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isBackendModuleFederationManifestRequest, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath } from "./staticModuleFederation.mjs";
+import { applyPreCompressedAssetHeaders, resolvePreCompressedAsset } from "./staticPrecompressed.mjs";
+const getStaticMimeType = (filename)=>getMimeType(filename) ?? ('.cjs' === path.extname(filename).toLowerCase() ? "text/javascript; charset=UTF-8" : void 0);
+const servePreCompressedPublicRouteAsset = async (c, pwd, route)=>{
+    const { entryPath } = route;
+    const originFilename = path.join(pwd, entryPath);
+    const preCompressedAsset = await resolvePreCompressedAsset(c, originFilename);
+    const filename = preCompressedAsset.selected?.filepath ?? originFilename;
+    const data = await fileReader.readFile(filename, 'buffer');
+    const mimeType = getStaticMimeType(originFilename);
+    if (null === data) return null;
+    const body = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    if (mimeType) c.header('Content-Type', mimeType);
+    Object.entries(route.responseHeaders || {}).forEach(([k, v])=>{
+        c.header(k, v);
+    });
+    applyPreCompressedAssetHeaders(c, preCompressedAsset);
+    c.header('Content-Length', String(data.byteLength));
+    return c.body(body, 200);
+};
+const isPathInside = (target, root)=>{
+    const relative = path.relative(path.resolve(root), path.resolve(target));
+    return '' === relative || !relative.startsWith(`..${path.sep}`) && '..' !== relative && !path.isAbsolute(relative);
+};
+const resolvePublicDirectoryAsset = async (pwd, pathname)=>{
+    let decodedPathname;
+    try {
+        decodedPathname = decodeURIComponent(pathname).replace(/\\/gu, '/');
+    } catch  {
+        return null;
+    }
+    if (decodedPathname.includes('\0') || decodedPathname.split('/').includes('..')) return null;
+    const publicDirectory = path.join(pwd, 'public');
+    const filepath = path.resolve(publicDirectory, decodedPathname.replace(/^\/+/u, ''));
+    if (!isPathInside(filepath, publicDirectory)) return null;
+    try {
+        const [realPublicDirectory, realFilepath, stat] = await Promise.all([
+            fs.realpath(publicDirectory),
+            fs.realpath(filepath),
+            fs.stat(filepath)
+        ]);
+        if (!stat.isFile() || !isPathInside(realFilepath, realPublicDirectory)) return null;
+        return realFilepath;
+    } catch  {
+        return null;
+    }
+};
+const servePublicDirectoryAsset = async (c, pwd)=>{
+    const method = c.req.raw.method.toUpperCase();
+    if ('GET' !== method && 'HEAD' !== method) return null;
+    const originFilename = await resolvePublicDirectoryAsset(pwd, c.req.path);
+    if (null === originFilename) return null;
+    const preCompressedAsset = await resolvePreCompressedAsset(c, originFilename);
+    const selectedFilename = preCompressedAsset.selected?.filepath ?? originFilename;
+    const publicDirectory = await fs.realpath(path.join(pwd, 'public'));
+    let realSelectedFilename;
+    try {
+        realSelectedFilename = await fs.realpath(selectedFilename);
+    } catch  {
+        return null;
+    }
+    if (!isPathInside(realSelectedFilename, publicDirectory)) return null;
+    const data = await fileReader.readFileFromSystem(realSelectedFilename, 'buffer');
+    if (null === data) return null;
+    const mimeType = getStaticMimeType(originFilename);
+    if (mimeType) c.header('Content-Type', mimeType);
+    applyPreCompressedAssetHeaders(c, preCompressedAsset);
+    c.header('Content-Length', String(data.byteLength));
+    if ('HEAD' === method) return c.body(null, 200);
+    const body = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    return c.body(body, 200);
+};
+const createModuleFederationStaticServing = ({ pwd, pathPrefix })=>{
+    let moduleFederationAssetsPromise = null;
+    const getModuleFederationAssets = async ()=>{
+        if (!moduleFederationAssetsPromise) moduleFederationAssetsPromise = getModuleFederationAssetList(pwd);
+        return moduleFederationAssetsPromise;
+    };
+    const resolveRequest = async (pathname)=>{
+        const requestPath = getModuleFederationRequestPath(pathname, pathPrefix);
+        if (requestPath.includes('..')) return null;
+        const moduleFederationAssetMeta = await getModuleFederationAssets();
+        return {
+            requestPath,
+            isModuleFederationAsset: moduleFederationAssetMeta.assets.has(requestPath),
+            isModuleFederationRemoteEntry: moduleFederationAssetMeta.remoteEntries.has(requestPath)
+        };
+    };
+    const serveFile = async (c, filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false, requestPath = '')=>{
+        if (moduleFederationAsset) applyModuleFederationAssetHeaders(c);
+        const mimeType = getStaticMimeType(filepath);
+        if (mimeType) c.header('Content-Type', mimeType);
+        const shouldPatchManifest = moduleFederationAsset && isModuleFederationManifestRequest(requestPath) && !isBackendModuleFederationManifestRequest(requestPath);
+        const shouldPatchRemoteEntry = moduleFederationRemoteEntry;
+        const canUsePreCompressed = !shouldPatchManifest && !shouldPatchRemoteEntry;
+        const preCompressedAsset = canUsePreCompressed ? await resolvePreCompressedAsset(c, filepath) : {
+            selected: null,
+            hasVariant: false
+        };
+        const targetFilepath = preCompressedAsset.selected?.filepath ?? filepath;
+        const chunk = await fileReader.readFileFromSystem(targetFilepath, 'buffer');
+        if (null === chunk) return null;
+        const responseChunk = shouldPatchManifest ? patchModuleFederationManifestPublicPath(c, chunk, pathPrefix) : shouldPatchRemoteEntry ? patchModuleFederationRemoteEntryPublicPath(c, chunk, pathPrefix) : chunk;
+        applyPreCompressedAssetHeaders(c, preCompressedAsset);
+        c.header('Content-Length', String(responseChunk.byteLength));
+        const body = new Uint8Array(responseChunk.buffer, responseChunk.byteOffset, responseChunk.byteLength);
+        return c.body(body, 200);
+    };
+    const serveByPath = async (c, filepath, request, moduleFederationAsset = false, moduleFederationRemoteEntry = false)=>{
+        if (!isPathInside(filepath, pwd)) return null;
+        if (!await fs.pathExists(filepath)) return null;
+        return serveFile(c, filepath, moduleFederationAsset, moduleFederationRemoteEntry, request.requestPath);
+    };
+    const serveStaticHit = (c, request)=>serveByPath(c, path.join(pwd, request.requestPath), request, request.isModuleFederationAsset, request.isModuleFederationRemoteEntry);
+    const serveModuleFederationAsset = (c, request)=>{
+        if (!request.isModuleFederationAsset) return null;
+        return serveByPath(c, path.join(pwd, request.requestPath), request, true, request.isModuleFederationRemoteEntry);
+    };
+    return {
+        resolveRequest,
+        serveStaticHit,
+        serveModuleFederationAsset
+    };
+};
+export { createModuleFederationStaticServing, servePreCompressedPublicRouteAsset, servePublicDirectoryAsset };

package/dist/esm-node/plugins/render/render.mjs

@@ -9,10 +9,10 @@ import { renderRscHandler } from "./renderRscHandler.mjs";
 import { serverActionHandler } from "./serverActionHandler.mjs";
 import { ssrRender } from "./ssrRender.mjs";
 import { __webpack_require__ } from "../../rslib-runtime.mjs";
-import * as __rspack_external__modern_js_runtime_utils_router_2aa8d96f from "@modern-js/runtime-utils/router";
+import * as __rspack_external__modern_js_runtime_utils_router_4aa9f9b0 from "@modern-js/runtime-utils/router";
 __webpack_require__.add({
     "@modern-js/runtime-utils/router" (module) {
-        module.exports = __rspack_external__modern_js_runtime_utils_router_2aa8d96f;
+        module.exports = __rspack_external__modern_js_runtime_utils_router_4aa9f9b0;
     }
 });
 const DYNAMIC_ROUTE_REG = /\/:./;
@@ -233,4 +233,4 @@ async function csrRender(request, options) {
     });
     return csrRscRender(request, options);
 }
-export { createRender };
+export { createRender, matchRoute };

package/dist/esm-node/utils/storage.mjs

@@ -1,13 +1,16 @@
 import "node:module";
 import * as __rspack_external_async_hooks from "async_hooks";
+const getGlobalStorage = (storageKey)=>{
+    const globalStore = globalThis;
+    const key = 'string' == typeof storageKey ? Symbol.for(storageKey) : storageKey;
+    const sharedStorage = globalStore[key];
+    const storage = sharedStorage ?? new __rspack_external_async_hooks.AsyncLocalStorage();
+    globalStore[key] = storage;
+    return storage;
+};
 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();
+    if (void 0 !== __rspack_external_async_hooks.AsyncLocalStorage) storage = storageKey ? getGlobalStorage(storageKey) : 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
         `);
@@ -25,12 +28,13 @@ const createStorage = (storageKey)=>{
         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");
+        if (!context) throw new Error("Can't call useContext out of server scope");
         return context;
     };
     return {
         run,
-        useContext
+        useContext,
+        useHonoContext: useContext
     };
 };
 export { createStorage };

package/dist/types/adapters/node/plugins/staticModuleFederation.d.ts

@@ -2,11 +2,11 @@ import type { Middleware } from '../../../types';
 export declare const MODULE_FEDERATION_MANIFEST_FILE = "mf-manifest.json";
 export type ModuleFederationServeAssets = {
     assets: Set<string>;
-    remoteEntry: string | null;
+    remoteEntries: Set<string>;
 };
-export declare const trimLeadingSlash: (value: string) => string;
 export declare const getModuleFederationRequestPath: (pathname: string, pathPrefix: string) => string;
-export declare const isModuleFederationManifestRequest: (requestPath: string) => requestPath is "mf-manifest.json";
+export declare const isModuleFederationManifestRequest: (requestPath: string) => boolean;
+export declare const isBackendModuleFederationManifestRequest: (requestPath: string) => requestPath is "backend-mf-manifest.json";
 export declare const applyModuleFederationAssetHeaders: (c: Parameters<Middleware>[0]) => void;
 export declare const patchModuleFederationManifestPublicPath: (c: Parameters<Middleware>[0], manifestBuffer: Buffer, pathPrefix: string) => Buffer<ArrayBufferLike>;
 export declare const patchModuleFederationRemoteEntryPublicPath: (c: Parameters<Middleware>[0], remoteEntryBuffer: Buffer, pathPrefix: string) => Buffer<ArrayBufferLike>;

package/dist/types/adapters/node/plugins/staticPrecompressed.d.ts

@@ -1,13 +1,12 @@
 import type { Middleware } from '../../../types';
 type SupportedEncoding = 'br' | 'gzip';
-export type ResolvePreCompressedAssetResult = {
+type ResolvePreCompressedAssetResult = {
     selected: {
         filepath: string;
         encoding: SupportedEncoding;
     } | null;
     hasVariant: boolean;
 };
-export declare const appendVaryHeader: (c: Parameters<Middleware>[0], value: string) => void;
 export declare const resolvePreCompressedAsset: (c: Parameters<Middleware>[0], filepath: string) => Promise<ResolvePreCompressedAssetResult>;
 export declare const applyPreCompressedAssetHeaders: (c: Parameters<Middleware>[0], preCompressedAsset: ResolvePreCompressedAssetResult) => void;
 export {};

package/dist/types/adapters/node/plugins/staticServing.d.ts

@@ -0,0 +1,25 @@
+import type { ServerRoute } from '@modern-js/types';
+import type { Middleware } from '../../../types';
+type MiddlewareContext = Parameters<Middleware>[0];
+type StaticServingRequest = {
+    requestPath: string;
+    isModuleFederationAsset: boolean;
+    isModuleFederationRemoteEntry: boolean;
+};
+type StaticServingOptions = {
+    pwd: string;
+    pathPrefix: string;
+};
+export declare const servePreCompressedPublicRouteAsset: (c: MiddlewareContext, pwd: string, route: ServerRoute) => Promise<(Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null>;
+/**
+ * Serves post-build convention assets generated under dist/public at their
+ * root URL. This is intentionally independent of config/public and route.json:
+ * the generator runs after the route manifest is built.
+ */
+export declare const servePublicDirectoryAsset: (c: MiddlewareContext, pwd: string) => Promise<(Response & import("hono").TypedResponse<null, 200, "body">) | (Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null>;
+export declare const createModuleFederationStaticServing: ({ pwd, pathPrefix, }: StaticServingOptions) => {
+    resolveRequest: (pathname: string) => Promise<StaticServingRequest | null>;
+    serveStaticHit: (c: MiddlewareContext, request: StaticServingRequest) => Promise<(Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null>;
+    serveModuleFederationAsset: (c: MiddlewareContext, request: StaticServingRequest) => Promise<(Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null> | null;
+};
+export {};

package/dist/types/plugins/render/render.d.ts

@@ -1,5 +1,7 @@
 import type { ServerRoute } from '@modern-js/types';
+import type { Router } from 'hono/router';
 import type { CacheConfig, OnFallback, Render, UserConfig } from '../../types';
+import type { Params } from '../../types/requestHandler';
 interface CreateRenderOptions {
     pwd: string;
     routes: ServerRoute[];
@@ -12,5 +14,7 @@ interface CreateRenderOptions {
     forceCSRMap?: Map<string, boolean>;
     nonce?: string;
 }
+type MatchedRoute = [ServerRoute | undefined, Params];
+export declare function matchRoute(router: Router<ServerRoute>, pathname: string, entryName?: string): MatchedRoute;
 export declare function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, forceCSRMap, config, onFallback, }: CreateRenderOptions): Promise<Render>;
 export {};

package/dist/types/types/config/dev.d.ts

@@ -1,4 +1,10 @@
 export interface DevUserConfig {
     assetPrefix?: string;
+    /**
+     * Customize the directory containing the Mock API entry file.
+     * Relative paths are resolved from the application directory.
+     * @default './config/mock'
+     */
+    mockDir?: string;
 }
 export type DevNormalizedConfig = DevUserConfig;

package/dist/types/utils/storage.d.ts

@@ -1,5 +1,6 @@
-declare const createStorage: <T>(storageKey?: symbol) => {
+declare const createStorage: <T>(storageKey?: string | symbol) => {
     run: <O>(context: T, cb: () => O | Promise<O>) => Promise<O>;
     useContext: () => T;
+    useHonoContext: () => T;
 };
 export { createStorage };

package/package.json

@@ -17,13 +17,12 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.5.0-ultramodern.1",
+  "version": "3.5.0-ultramodern.100",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
-      "modern:source": "./src/index.ts",
       "node": {
         "import": "./dist/esm-node/index.mjs",
         "require": "./dist/cjs/index.js"
@@ -32,7 +31,6 @@
     },
     "./node": {
       "types": "./dist/types/adapters/node/index.d.ts",
-      "modern:source": "./src/adapters/node/index.ts",
       "node": {
         "import": "./dist/esm-node/adapters/node/index.mjs",
         "require": "./dist/cjs/adapters/node/index.js"
@@ -68,31 +66,31 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.100",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.100",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.100",
     "@swc/helpers": "^0.5.23",
     "@web-std/fetch": "^4.2.1",
     "@web-std/file": "^3.0.3",
     "@web-std/stream": "^1.0.3",
     "cloneable-readable": "^3.0.0",
     "flatted": "^3.4.2",
-    "hono": "^4.12.27",
-    "ts-deepmerge": "8.0.0",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.1",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.1",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.1"
+    "hono": "^4.12.28",
+    "ts-deepmerge": "8.0.0"
   },
   "devDependencies": {
-    "@rslib/core": "0.23.0",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.100",
+    "@rslib/core": "0.23.2",
+    "@scripts/rstest-config": "2.66.0",
     "@types/cloneable-readable": "^2.0.3",
     "@types/merge-deep": "^3.0.3",
-    "@types/node": "^26.0.1",
-    "@typescript/native-preview": "7.0.0-dev.20260624.1",
-    "http-proxy-middleware": "^4.1.1",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.1",
-    "@scripts/rstest-config": "2.66.0"
+    "@types/node": "^26.1.1",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "http-proxy-middleware": "^4.2.0",
+    "typescript": "^7.0.2"
   },
   "sideEffects": false,
   "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
   "scripts": {