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

@bleedingdev/modern-js-server-core 3.5.0-ultramodern.4 → 3.5.0-ultramodern.41

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/cjs/adapters/node/plugins/static.js CHANGED Viewed

@@ -41,15 +41,11 @@ __webpack_require__.d(__webpack_exports__, {
     createStaticMiddleware: ()=>createStaticMiddleware,
     serverStaticPlugin: ()=>serverStaticPlugin
 });
-const fileReader_namespaceObject = require("@modern-js/runtime-utils/fileReader");
-const utils_namespaceObject = require("@modern-js/utils");
-const mime_namespaceObject = require("hono/utils/mime");
 const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const index_js_namespaceObject = require("../../../utils/index.js");
 const publicDir_js_namespaceObject = require("../../../utils/publicDir.js");
-const external_staticModuleFederation_js_namespaceObject = require("./staticModuleFederation.js");
-const external_staticPrecompressed_js_namespaceObject = require("./staticPrecompressed.js");
+const external_staticServing_js_namespaceObject = require("./staticServing.js");
 const serverStaticPlugin = ()=>({
         name: '@modern-js/plugin-server-static',
         setup (api) {
@@ -74,22 +70,8 @@ function createPublicMiddleware({ pwd, routes }) {
     return async (c, next)=>{
         const route = matchPublicRoute(c.req, routes);
         if (route) {
-            const { entryPath } = route;
-            const originFilename = external_path_default().join(pwd, entryPath);
-            const preCompressedAsset = await (0, external_staticPrecompressed_js_namespaceObject.resolvePreCompressedAsset)(c, originFilename);
-            const filename = preCompressedAsset.selected?.filepath ?? originFilename;
-            const data = await fileReader_namespaceObject.fileReader.readFile(filename, 'buffer');
-            const mimeType = (0, mime_namespaceObject.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);
-                });
-                (0, external_staticPrecompressed_js_namespaceObject.applyPreCompressedAssetHeaders)(c, preCompressedAsset);
-                c.header('Content-Length', String(data.byteLength));
-                return c.body(body, 200);
-            }
+            const response = await (0, external_staticServing_js_namespaceObject.servePreCompressedPublicRouteAsset)(c, pwd, route);
+            if (null !== response) return response;
         }
         return await next();
     };
@@ -140,54 +122,24 @@ function createStaticMiddleware(options) {
         pwd,
         routes: routes || []
     });
-    let moduleFederationAssetsPromise = null;
-    const getModuleFederationAssets = async ()=>{
-        if (!moduleFederationAssetsPromise) moduleFederationAssetsPromise = (0, external_staticModuleFederation_js_namespaceObject.getModuleFederationAssetList)(pwd);
-        return moduleFederationAssetsPromise;
-    };
-    const serveFile = async (c, filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false, requestPath = '')=>{
-        if (moduleFederationAsset) (0, external_staticModuleFederation_js_namespaceObject.applyModuleFederationAssetHeaders)(c);
-        const mimeType = (0, mime_namespaceObject.getMimeType)(filepath);
-        if (mimeType) c.header('Content-Type', mimeType);
-        const shouldPatchManifest = moduleFederationAsset && (0, external_staticModuleFederation_js_namespaceObject.isModuleFederationManifestRequest)(requestPath);
-        const shouldPatchRemoteEntry = moduleFederationRemoteEntry;
-        const canUsePreCompressed = !shouldPatchManifest && !shouldPatchRemoteEntry;
-        const preCompressedAsset = canUsePreCompressed ? await (0, external_staticPrecompressed_js_namespaceObject.resolvePreCompressedAsset)(c, filepath) : {
-            selected: null,
-            hasVariant: false
-        };
-        const targetFilepath = preCompressedAsset.selected?.filepath ?? filepath;
-        const chunk = await fileReader_namespaceObject.fileReader.readFileFromSystem(targetFilepath, 'buffer');
-        if (null === chunk) return null;
-        const responseChunk = shouldPatchManifest ? (0, external_staticModuleFederation_js_namespaceObject.patchModuleFederationManifestPublicPath)(c, chunk, pathPrefix) : shouldPatchRemoteEntry ? (0, external_staticModuleFederation_js_namespaceObject.patchModuleFederationRemoteEntryPublicPath)(c, chunk, pathPrefix) : chunk;
-        (0, external_staticPrecompressed_js_namespaceObject.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 = (0, external_staticServing_js_namespaceObject.createModuleFederationStaticServing)({
+        pwd,
+        pathPrefix
+    });
     return async (c, next)=>{
         const pageRoute = c.get('route');
         const pathname = c.req.path;
         if (pageRoute && '' === external_path_default().extname(pathname)) return next();
         const hit = staticPathRegExp.test(pathname);
-        const requestPath = (0, external_staticModuleFederation_js_namespaceObject.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 utils_namespaceObject.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(external_path_default().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(external_path_default().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/cjs/adapters/node/plugins/staticModuleFederation.js CHANGED Viewed

@@ -43,20 +43,24 @@ __webpack_require__.d(__webpack_exports__, {
     getModuleFederationRequestPath: ()=>getModuleFederationRequestPath,
     isModuleFederationManifestRequest: ()=>isModuleFederationManifestRequest,
     patchModuleFederationManifestPublicPath: ()=>patchModuleFederationManifestPublicPath,
-    patchModuleFederationRemoteEntryPublicPath: ()=>patchModuleFederationRemoteEntryPublicPath,
-    trimLeadingSlash: ()=>trimLeadingSlash
+    patchModuleFederationRemoteEntryPublicPath: ()=>patchModuleFederationRemoteEntryPublicPath
 });
 const fileReader_namespaceObject = require("@modern-js/runtime-utils/fileReader");
 const utils_namespaceObject = require("@modern-js/utils");
 const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 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 applyModuleFederationAssetHeaders = (c)=>{
     c.header('Access-Control-Allow-Origin', '*');
     c.header('Access-Control-Allow-Headers', '*');
@@ -67,8 +71,7 @@ const joinModuleFederationAssetPath = (assetPath, assetName)=>{
     return trimLeadingSlash(external_path_default().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));
@@ -109,37 +112,36 @@ const patchModuleFederationRemoteEntryPublicPath = (c, remoteEntryBuffer, pathPr
 };
 const getModuleFederationAssetList = async (pwd)=>{
     const assets = new Set();
-    const manifestPath = external_path_default().join(pwd, MODULE_FEDERATION_MANIFEST_FILE);
-    if (!await utils_namespaceObject.fs.pathExists(manifestPath)) return {
-        assets,
-        remoteEntry: null
-    };
-    assets.add(MODULE_FEDERATION_MANIFEST_FILE);
-    const manifestBuffer = await fileReader_namespaceObject.fileReader.readFileFromSystem(manifestPath, 'buffer');
-    if (null === manifestBuffer) return {
-        assets,
-        remoteEntry: null
-    };
-    for (const filename of MODULE_FEDERATION_OPTIONAL_FILES)if (await utils_namespaceObject.fs.pathExists(external_path_default().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 = external_path_default().join(pwd, manifestFile);
+        if (!await utils_namespaceObject.fs.pathExists(manifestPath)) continue;
+        manifestFound = true;
+        assets.add(manifestFile);
+        const manifestBuffer = await fileReader_namespaceObject.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 utils_namespaceObject.fs.pathExists(external_path_default().join(pwd, filename))) assets.add(filename);
+    }
     return {
         assets,
-        remoteEntry: remoteEntryFile
+        remoteEntries
     };
 };
 exports.MODULE_FEDERATION_MANIFEST_FILE = __webpack_exports__.MODULE_FEDERATION_MANIFEST_FILE;
@@ -149,7 +151,6 @@ exports.getModuleFederationRequestPath = __webpack_exports__.getModuleFederation
 exports.isModuleFederationManifestRequest = __webpack_exports__.isModuleFederationManifestRequest;
 exports.patchModuleFederationManifestPublicPath = __webpack_exports__.patchModuleFederationManifestPublicPath;
 exports.patchModuleFederationRemoteEntryPublicPath = __webpack_exports__.patchModuleFederationRemoteEntryPublicPath;
-exports.trimLeadingSlash = __webpack_exports__.trimLeadingSlash;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "MODULE_FEDERATION_MANIFEST_FILE",
     "applyModuleFederationAssetHeaders",
@@ -157,8 +158,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "getModuleFederationRequestPath",
     "isModuleFederationManifestRequest",
     "patchModuleFederationManifestPublicPath",
-    "patchModuleFederationRemoteEntryPublicPath",
-    "trimLeadingSlash"
+    "patchModuleFederationRemoteEntryPublicPath"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/adapters/node/plugins/staticPrecompressed.js CHANGED Viewed

@@ -28,7 +28,6 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    appendVaryHeader: ()=>appendVaryHeader,
     applyPreCompressedAssetHeaders: ()=>applyPreCompressedAssetHeaders,
     resolvePreCompressedAsset: ()=>resolvePreCompressedAsset
 });
@@ -122,11 +121,9 @@ const applyPreCompressedAssetHeaders = (c, preCompressedAsset)=>{
     if (preCompressedAsset.hasVariant) appendVaryHeader(c, 'Accept-Encoding');
     if (preCompressedAsset.selected) c.header('Content-Encoding', preCompressedAsset.selected.encoding);
 };
-exports.appendVaryHeader = __webpack_exports__.appendVaryHeader;
 exports.applyPreCompressedAssetHeaders = __webpack_exports__.applyPreCompressedAssetHeaders;
 exports.resolvePreCompressedAsset = __webpack_exports__.resolvePreCompressedAsset;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "appendVaryHeader",
     "applyPreCompressedAssetHeaders",
     "resolvePreCompressedAsset"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cjs/adapters/node/plugins/staticServing.js ADDED Viewed

@@ -0,0 +1,131 @@
+"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, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    createModuleFederationStaticServing: ()=>createModuleFederationStaticServing,
+    servePreCompressedPublicRouteAsset: ()=>servePreCompressedPublicRouteAsset
+});
+const fileReader_namespaceObject = require("@modern-js/runtime-utils/fileReader");
+const utils_namespaceObject = require("@modern-js/utils");
+const mime_namespaceObject = require("hono/utils/mime");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_staticModuleFederation_js_namespaceObject = require("./staticModuleFederation.js");
+const external_staticPrecompressed_js_namespaceObject = require("./staticPrecompressed.js");
+const servePreCompressedPublicRouteAsset = async (c, pwd, route)=>{
+    const { entryPath } = route;
+    const originFilename = external_path_default().join(pwd, entryPath);
+    const preCompressedAsset = await (0, external_staticPrecompressed_js_namespaceObject.resolvePreCompressedAsset)(c, originFilename);
+    const filename = preCompressedAsset.selected?.filepath ?? originFilename;
+    const data = await fileReader_namespaceObject.fileReader.readFile(filename, 'buffer');
+    const mimeType = (0, mime_namespaceObject.getMimeType)(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);
+    });
+    (0, external_staticPrecompressed_js_namespaceObject.applyPreCompressedAssetHeaders)(c, preCompressedAsset);
+    c.header('Content-Length', String(data.byteLength));
+    return c.body(body, 200);
+};
+const isPathInside = (target, root)=>{
+    const relative = external_path_default().relative(external_path_default().resolve(root), external_path_default().resolve(target));
+    return '' === relative || !relative.startsWith(`..${external_path_default().sep}`) && '..' !== relative && !external_path_default().isAbsolute(relative);
+};
+const createModuleFederationStaticServing = ({ pwd, pathPrefix })=>{
+    let moduleFederationAssetsPromise = null;
+    const getModuleFederationAssets = async ()=>{
+        if (!moduleFederationAssetsPromise) moduleFederationAssetsPromise = (0, external_staticModuleFederation_js_namespaceObject.getModuleFederationAssetList)(pwd);
+        return moduleFederationAssetsPromise;
+    };
+    const resolveRequest = async (pathname)=>{
+        const requestPath = (0, external_staticModuleFederation_js_namespaceObject.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) (0, external_staticModuleFederation_js_namespaceObject.applyModuleFederationAssetHeaders)(c);
+        const mimeType = (0, mime_namespaceObject.getMimeType)(filepath);
+        if (mimeType) c.header('Content-Type', mimeType);
+        const shouldPatchManifest = moduleFederationAsset && (0, external_staticModuleFederation_js_namespaceObject.isModuleFederationManifestRequest)(requestPath);
+        const shouldPatchRemoteEntry = moduleFederationRemoteEntry;
+        const canUsePreCompressed = !shouldPatchManifest && !shouldPatchRemoteEntry;
+        const preCompressedAsset = canUsePreCompressed ? await (0, external_staticPrecompressed_js_namespaceObject.resolvePreCompressedAsset)(c, filepath) : {
+            selected: null,
+            hasVariant: false
+        };
+        const targetFilepath = preCompressedAsset.selected?.filepath ?? filepath;
+        const chunk = await fileReader_namespaceObject.fileReader.readFileFromSystem(targetFilepath, 'buffer');
+        if (null === chunk) return null;
+        const responseChunk = shouldPatchManifest ? (0, external_staticModuleFederation_js_namespaceObject.patchModuleFederationManifestPublicPath)(c, chunk, pathPrefix) : shouldPatchRemoteEntry ? (0, external_staticModuleFederation_js_namespaceObject.patchModuleFederationRemoteEntryPublicPath)(c, chunk, pathPrefix) : chunk;
+        (0, external_staticPrecompressed_js_namespaceObject.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 utils_namespaceObject.fs.pathExists(filepath)) return null;
+        return serveFile(c, filepath, moduleFederationAsset, moduleFederationRemoteEntry, request.requestPath);
+    };
+    const serveStaticHit = (c, request)=>serveByPath(c, external_path_default().join(pwd, request.requestPath), request, request.isModuleFederationAsset, request.isModuleFederationRemoteEntry);
+    const serveModuleFederationAsset = (c, request)=>{
+        if (!request.isModuleFederationAsset) return null;
+        return serveByPath(c, external_path_default().join(pwd, request.requestPath), request, true, request.isModuleFederationRemoteEntry);
+    };
+    return {
+        resolveRequest,
+        serveStaticHit,
+        serveModuleFederationAsset
+    };
+};
+exports.createModuleFederationStaticServing = __webpack_exports__.createModuleFederationStaticServing;
+exports.servePreCompressedPublicRouteAsset = __webpack_exports__.servePreCompressedPublicRouteAsset;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createModuleFederationStaticServing",
+    "servePreCompressedPublicRouteAsset"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -1,11 +1,7 @@
-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 } from "./staticServing.mjs";
 const serverStaticPlugin = ()=>({
         name: '@modern-js/plugin-server-static',
         setup (api) {
@@ -30,22 +26,8 @@ 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;
         }
         return await next();
     };
@@ -96,54 +78,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/adapters/node/plugins/staticModuleFederation.mjs CHANGED Viewed

@@ -2,12 +2,17 @@ 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 applyModuleFederationAssetHeaders = (c)=>{
     c.header('Access-Control-Allow-Origin', '*');
     c.header('Access-Control-Allow-Headers', '*');
@@ -18,8 +23,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 +64,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, 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,80 @@
+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, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath } from "./staticModuleFederation.mjs";
+import { applyPreCompressedAssetHeaders, resolvePreCompressedAsset } from "./staticPrecompressed.mjs";
+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 = getMimeType(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 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 = 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 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 };

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 } from "./staticServing.mjs";
 const serverStaticPlugin = ()=>({
         name: '@modern-js/plugin-server-static',
         setup (api) {
@@ -31,22 +27,8 @@ 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;
         }
         return await next();
     };
@@ -97,54 +79,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,17 @@ 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 applyModuleFederationAssetHeaders = (c)=>{
     c.header('Access-Control-Allow-Origin', '*');
     c.header('Access-Control-Allow-Headers', '*');
@@ -19,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));
@@ -61,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, 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,81 @@
+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, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath } from "./staticModuleFederation.mjs";
+import { applyPreCompressedAssetHeaders, resolvePreCompressedAsset } from "./staticPrecompressed.mjs";
+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 = getMimeType(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 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 = 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 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 };

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

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

@@ -0,0 +1,19 @@
+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>;
+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/package.json CHANGED Viewed

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.5.0-ultramodern.4",
+  "version": "3.5.0-ultramodern.41",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -74,21 +74,21 @@
     "@web-std/stream": "^1.0.3",
     "cloneable-readable": "^3.0.0",
     "flatted": "^3.4.2",
-    "hono": "^4.12.27",
+    "hono": "^4.12.28",
     "ts-deepmerge": "8.0.0",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.4",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.4",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.4"
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.41",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.41",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.41"
   },
   "devDependencies": {
-    "@rslib/core": "0.23.1",
+    "@rslib/core": "0.23.2",
     "@types/cloneable-readable": "^2.0.3",
     "@types/merge-deep": "^3.0.3",
-    "@types/node": "^26.0.1",
-    "@typescript/native-preview": "7.0.0-dev.20260628.1",
-    "http-proxy-middleware": "^4.1.1",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.4",
-    "@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",
+    "@scripts/rstest-config": "2.66.0",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.41"
   },
   "sideEffects": false,
   "publishConfig": {