npm - @bleedingdev/modern-js-server-core - Versions diffs - 3.5.0-ultramodern.5 → 3.5.0-ultramodern.75 - Mend

@bleedingdev/modern-js-server-core 3.5.0-ultramodern.5 → 3.5.0-ultramodern.75

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/dist/esm/adapters/node/plugins/staticModuleFederation.mjs CHANGED Viewed

@@ -2,12 +2,18 @@ import { fileReader } from "@modern-js/runtime-utils/fileReader";
 import { fs } from "@modern-js/utils";
 import path from "path";
 const MODULE_FEDERATION_MANIFEST_FILE = 'mf-manifest.json';
+const BACKEND_MODULE_FEDERATION_MANIFEST_FILE = 'backend-mf-manifest.json';
+const MODULE_FEDERATION_MANIFEST_FILES = [
+    MODULE_FEDERATION_MANIFEST_FILE,
+    BACKEND_MODULE_FEDERATION_MANIFEST_FILE
+];
 const MODULE_FEDERATION_OPTIONAL_FILES = [
     'mf-stats.json'
 ];
 const trimLeadingSlash = (value)=>value.replace(/^\/+/, '');
 const getModuleFederationRequestPath = (pathname, pathPrefix)=>trimLeadingSlash(pathname.replace(pathPrefix, ()=>''));
-const isModuleFederationManifestRequest = (requestPath)=>requestPath === MODULE_FEDERATION_MANIFEST_FILE;
+const isModuleFederationManifestRequest = (requestPath)=>MODULE_FEDERATION_MANIFEST_FILES.includes(requestPath);
+const isBackendModuleFederationManifestRequest = (requestPath)=>requestPath === BACKEND_MODULE_FEDERATION_MANIFEST_FILE;
 const applyModuleFederationAssetHeaders = (c)=>{
     c.header('Access-Control-Allow-Origin', '*');
     c.header('Access-Control-Allow-Headers', '*');
@@ -18,8 +24,7 @@ const joinModuleFederationAssetPath = (assetPath, assetName)=>{
     return trimLeadingSlash(path.posix.join(assetPath || '', assetName));
 };
 const appendModuleFederationAsset = (set, assetPath)=>{
-    if (!assetPath) return;
-    set.add(trimLeadingSlash(assetPath));
+    if (assetPath) set.add(trimLeadingSlash(assetPath));
 };
 const appendModuleFederationAssets = (set, assets)=>{
     assets?.js?.sync?.forEach((asset)=>appendModuleFederationAsset(set, asset));
@@ -60,37 +65,36 @@ const patchModuleFederationRemoteEntryPublicPath = (c, remoteEntryBuffer, pathPr
 };
 const getModuleFederationAssetList = async (pwd)=>{
     const assets = new Set();
-    const manifestPath = path.join(pwd, MODULE_FEDERATION_MANIFEST_FILE);
-    if (!await fs.pathExists(manifestPath)) return {
-        assets,
-        remoteEntry: null
-    };
-    assets.add(MODULE_FEDERATION_MANIFEST_FILE);
-    const manifestBuffer = await fileReader.readFileFromSystem(manifestPath, 'buffer');
-    if (null === manifestBuffer) return {
-        assets,
-        remoteEntry: null
-    };
-    for (const filename of MODULE_FEDERATION_OPTIONAL_FILES)if (await fs.pathExists(path.join(pwd, filename))) assets.add(filename);
-    let remoteEntryFile = null;
-    try {
-        const manifest = JSON.parse(manifestBuffer.toString('utf-8'));
-        const remoteEntry = joinModuleFederationAssetPath(manifest.metaData?.remoteEntry?.path, manifest.metaData?.remoteEntry?.name);
-        const dtsZip = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.zip);
-        const dtsApi = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.api);
-        if (remoteEntry) {
-            assets.add(remoteEntry);
-            remoteEntryFile = remoteEntry;
-        }
-        if (dtsZip) assets.add(dtsZip);
-        if (dtsApi) assets.add(dtsApi);
-        manifest.shared?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
-        manifest.remotes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
-        manifest.exposes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
-    } catch  {}
+    const remoteEntries = new Set();
+    let manifestFound = false;
+    for (const manifestFile of MODULE_FEDERATION_MANIFEST_FILES){
+        const manifestPath = path.join(pwd, manifestFile);
+        if (!await fs.pathExists(manifestPath)) continue;
+        manifestFound = true;
+        assets.add(manifestFile);
+        const manifestBuffer = await fileReader.readFileFromSystem(manifestPath, 'buffer');
+        if (null !== manifestBuffer) try {
+            const manifest = JSON.parse(manifestBuffer.toString('utf-8'));
+            const remoteEntry = joinModuleFederationAssetPath(manifest.metaData?.remoteEntry?.path, manifest.metaData?.remoteEntry?.name);
+            const dtsZip = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.zip);
+            const dtsApi = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.api);
+            if (remoteEntry) {
+                assets.add(remoteEntry);
+                remoteEntries.add(remoteEntry);
+            }
+            appendModuleFederationAsset(assets, dtsZip);
+            appendModuleFederationAsset(assets, dtsApi);
+            manifest.shared?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
+            manifest.remotes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
+            manifest.exposes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
+        } catch  {}
+    }
+    if (manifestFound) {
+        for (const filename of MODULE_FEDERATION_OPTIONAL_FILES)if (await fs.pathExists(path.join(pwd, filename))) assets.add(filename);
+    }
     return {
         assets,
-        remoteEntry: remoteEntryFile
+        remoteEntries
     };
 };
-export { MODULE_FEDERATION_MANIFEST_FILE, applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath, trimLeadingSlash };
+export { MODULE_FEDERATION_MANIFEST_FILE, applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isBackendModuleFederationManifestRequest, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath };

package/dist/esm/adapters/node/plugins/staticPrecompressed.mjs CHANGED Viewed

@@ -88,4 +88,4 @@ const applyPreCompressedAssetHeaders = (c, preCompressedAsset)=>{
     if (preCompressedAsset.hasVariant) appendVaryHeader(c, 'Accept-Encoding');
     if (preCompressedAsset.selected) c.header('Content-Encoding', preCompressedAsset.selected.encoding);
 };
-export { appendVaryHeader, applyPreCompressedAssetHeaders, resolvePreCompressedAsset };
+export { applyPreCompressedAssetHeaders, resolvePreCompressedAsset };

package/dist/esm/adapters/node/plugins/staticServing.mjs ADDED Viewed

@@ -0,0 +1,129 @@
+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/plugins/render/render.mjs CHANGED Viewed

@@ -8,10 +8,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({
-    2420 (module) {
-        module.exports = __rspack_external__modern_js_runtime_utils_router_2aa8d96f;
+    5327 (module) {
+        module.exports = __rspack_external__modern_js_runtime_utils_router_4aa9f9b0;
     }
 });
 const DYNAMIC_ROUTE_REG = /\/:./;
@@ -163,7 +163,7 @@ async function renderHandler(request, options, mode, fallbackWrapper, framework)
         const { nestedRoutesJson } = serverManifest;
         const routes = nestedRoutesJson?.[options.routeInfo.entryName];
         if (routes) {
-            const { matchRoutes } = __webpack_require__(2420);
+            const { matchRoutes } = __webpack_require__(5327);
             const url = new URL(request.url);
             const matchedRoutes = matchRoutes(routes, url.pathname, options.routeInfo.urlPath);
             if (matchedRoutes) {

package/dist/esm-node/adapters/node/plugins/static.mjs CHANGED Viewed

@@ -1,12 +1,8 @@
 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 { sortRoutes } from "../../../utils/index.mjs";
 import { getPublicDirPatterns } from "../../../utils/publicDir.mjs";
-import { applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath } from "./staticModuleFederation.mjs";
-import { applyPreCompressedAssetHeaders, resolvePreCompressedAsset } from "./staticPrecompressed.mjs";
+import { createModuleFederationStaticServing, servePreCompressedPublicRouteAsset, servePublicDirectoryAsset } from "./staticServing.mjs";
 const serverStaticPlugin = ()=>({
         name: '@modern-js/plugin-server-static',
         setup (api) {
@@ -31,23 +27,11 @@ function createPublicMiddleware({ pwd, routes }) {
     return async (c, next)=>{
         const route = matchPublicRoute(c.req, routes);
         if (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 = getMimeType(originFilename);
-            if (null !== data) {
-                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 response = await servePreCompressedPublicRouteAsset(c, pwd, route);
+            if (null !== response) return response;
         }
+        const generatedPublicAsset = await servePublicDirectoryAsset(c, pwd);
+        if (null !== generatedPublicAsset) return generatedPublicAsset;
         return await next();
     };
 }
@@ -97,54 +81,24 @@ function createStaticMiddleware(options) {
         pwd,
         routes: routes || []
     });
-    let moduleFederationAssetsPromise = null;
-    const getModuleFederationAssets = async ()=>{
-        if (!moduleFederationAssetsPromise) moduleFederationAssetsPromise = getModuleFederationAssetList(pwd);
-        return moduleFederationAssetsPromise;
-    };
-    const serveFile = async (c, filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false, requestPath = '')=>{
-        if (moduleFederationAsset) applyModuleFederationAssetHeaders(c);
-        const mimeType = getMimeType(filepath);
-        if (mimeType) c.header('Content-Type', mimeType);
-        const shouldPatchManifest = moduleFederationAsset && isModuleFederationManifestRequest(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 moduleFederationStaticServing = createModuleFederationStaticServing({
+        pwd,
+        pathPrefix
+    });
     return async (c, next)=>{
         const pageRoute = c.get('route');
         const pathname = c.req.path;
         if (pageRoute && '' === path.extname(pathname)) return next();
         const hit = staticPathRegExp.test(pathname);
-        const requestPath = getModuleFederationRequestPath(pathname, pathPrefix);
-        if (requestPath.includes('..')) return next();
-        const moduleFederationAssetMeta = await getModuleFederationAssets();
-        const isModuleFederationAsset = moduleFederationAssetMeta.assets.has(requestPath);
-        const isModuleFederationRemoteEntry = moduleFederationAssetMeta.remoteEntry === requestPath;
-        const serveByPath = async (filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false)=>{
-            if (!await fs.pathExists(filepath)) return null;
-            return serveFile(c, filepath, moduleFederationAsset, moduleFederationRemoteEntry, requestPath);
-        };
+        const staticServingRequest = await moduleFederationStaticServing.resolveRequest(pathname);
+        if (null === staticServingRequest) return next();
         if (hit) {
-            const response = await serveByPath(path.join(pwd, requestPath), isModuleFederationAsset, isModuleFederationRemoteEntry);
+            const response = await moduleFederationStaticServing.serveStaticHit(c, staticServingRequest);
             if (null !== response) return response;
             return next();
         }
-        if (isModuleFederationAsset) {
-            const response = await serveByPath(path.join(pwd, requestPath), true, isModuleFederationRemoteEntry);
-            if (null !== response) return response;
-        }
+        const moduleFederationResponse = await moduleFederationStaticServing.serveModuleFederationAsset(c, staticServingRequest);
+        if (null !== moduleFederationResponse) return moduleFederationResponse;
         return publicMiddleware(c, next);
     };
 }

package/dist/esm-node/adapters/node/plugins/staticModuleFederation.mjs CHANGED Viewed

@@ -3,12 +3,18 @@ import { fileReader } from "@modern-js/runtime-utils/fileReader";
 import { fs } from "@modern-js/utils";
 import path from "path";
 const MODULE_FEDERATION_MANIFEST_FILE = 'mf-manifest.json';
+const BACKEND_MODULE_FEDERATION_MANIFEST_FILE = 'backend-mf-manifest.json';
+const MODULE_FEDERATION_MANIFEST_FILES = [
+    MODULE_FEDERATION_MANIFEST_FILE,
+    BACKEND_MODULE_FEDERATION_MANIFEST_FILE
+];
 const MODULE_FEDERATION_OPTIONAL_FILES = [
     'mf-stats.json'
 ];
 const trimLeadingSlash = (value)=>value.replace(/^\/+/, '');
 const getModuleFederationRequestPath = (pathname, pathPrefix)=>trimLeadingSlash(pathname.replace(pathPrefix, ()=>''));
-const isModuleFederationManifestRequest = (requestPath)=>requestPath === MODULE_FEDERATION_MANIFEST_FILE;
+const isModuleFederationManifestRequest = (requestPath)=>MODULE_FEDERATION_MANIFEST_FILES.includes(requestPath);
+const isBackendModuleFederationManifestRequest = (requestPath)=>requestPath === BACKEND_MODULE_FEDERATION_MANIFEST_FILE;
 const applyModuleFederationAssetHeaders = (c)=>{
     c.header('Access-Control-Allow-Origin', '*');
     c.header('Access-Control-Allow-Headers', '*');
@@ -19,8 +25,7 @@ const joinModuleFederationAssetPath = (assetPath, assetName)=>{
     return trimLeadingSlash(path.posix.join(assetPath || '', assetName));
 };
 const appendModuleFederationAsset = (set, assetPath)=>{
-    if (!assetPath) return;
-    set.add(trimLeadingSlash(assetPath));
+    if (assetPath) set.add(trimLeadingSlash(assetPath));
 };
 const appendModuleFederationAssets = (set, assets)=>{
     assets?.js?.sync?.forEach((asset)=>appendModuleFederationAsset(set, asset));
@@ -61,37 +66,36 @@ const patchModuleFederationRemoteEntryPublicPath = (c, remoteEntryBuffer, pathPr
 };
 const getModuleFederationAssetList = async (pwd)=>{
     const assets = new Set();
-    const manifestPath = path.join(pwd, MODULE_FEDERATION_MANIFEST_FILE);
-    if (!await fs.pathExists(manifestPath)) return {
-        assets,
-        remoteEntry: null
-    };
-    assets.add(MODULE_FEDERATION_MANIFEST_FILE);
-    const manifestBuffer = await fileReader.readFileFromSystem(manifestPath, 'buffer');
-    if (null === manifestBuffer) return {
-        assets,
-        remoteEntry: null
-    };
-    for (const filename of MODULE_FEDERATION_OPTIONAL_FILES)if (await fs.pathExists(path.join(pwd, filename))) assets.add(filename);
-    let remoteEntryFile = null;
-    try {
-        const manifest = JSON.parse(manifestBuffer.toString('utf-8'));
-        const remoteEntry = joinModuleFederationAssetPath(manifest.metaData?.remoteEntry?.path, manifest.metaData?.remoteEntry?.name);
-        const dtsZip = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.zip);
-        const dtsApi = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.api);
-        if (remoteEntry) {
-            assets.add(remoteEntry);
-            remoteEntryFile = remoteEntry;
-        }
-        if (dtsZip) assets.add(dtsZip);
-        if (dtsApi) assets.add(dtsApi);
-        manifest.shared?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
-        manifest.remotes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
-        manifest.exposes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
-    } catch  {}
+    const remoteEntries = new Set();
+    let manifestFound = false;
+    for (const manifestFile of MODULE_FEDERATION_MANIFEST_FILES){
+        const manifestPath = path.join(pwd, manifestFile);
+        if (!await fs.pathExists(manifestPath)) continue;
+        manifestFound = true;
+        assets.add(manifestFile);
+        const manifestBuffer = await fileReader.readFileFromSystem(manifestPath, 'buffer');
+        if (null !== manifestBuffer) try {
+            const manifest = JSON.parse(manifestBuffer.toString('utf-8'));
+            const remoteEntry = joinModuleFederationAssetPath(manifest.metaData?.remoteEntry?.path, manifest.metaData?.remoteEntry?.name);
+            const dtsZip = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.zip);
+            const dtsApi = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.api);
+            if (remoteEntry) {
+                assets.add(remoteEntry);
+                remoteEntries.add(remoteEntry);
+            }
+            appendModuleFederationAsset(assets, dtsZip);
+            appendModuleFederationAsset(assets, dtsApi);
+            manifest.shared?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
+            manifest.remotes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
+            manifest.exposes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
+        } catch  {}
+    }
+    if (manifestFound) {
+        for (const filename of MODULE_FEDERATION_OPTIONAL_FILES)if (await fs.pathExists(path.join(pwd, filename))) assets.add(filename);
+    }
     return {
         assets,
-        remoteEntry: remoteEntryFile
+        remoteEntries
     };
 };
-export { MODULE_FEDERATION_MANIFEST_FILE, applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath, trimLeadingSlash };
+export { MODULE_FEDERATION_MANIFEST_FILE, applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isBackendModuleFederationManifestRequest, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath };

package/dist/esm-node/adapters/node/plugins/staticPrecompressed.mjs CHANGED Viewed

@@ -89,4 +89,4 @@ const applyPreCompressedAssetHeaders = (c, preCompressedAsset)=>{
     if (preCompressedAsset.hasVariant) appendVaryHeader(c, 'Accept-Encoding');
     if (preCompressedAsset.selected) c.header('Content-Encoding', preCompressedAsset.selected.encoding);
 };
-export { appendVaryHeader, applyPreCompressedAssetHeaders, resolvePreCompressedAsset };
+export { applyPreCompressedAssetHeaders, resolvePreCompressedAsset };

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

@@ -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 CHANGED Viewed

@@ -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 = /\/:./;

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

@@ -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>;