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

package/dist/cjs/adapters/node/plugins/static.js

@@ -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,23 +70,11 @@ 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;
         }
+        const generatedPublicAsset = await (0, external_staticServing_js_namespaceObject.servePublicDirectoryAsset)(c, pwd);
+        if (null !== generatedPublicAsset) return generatedPublicAsset;
         return await next();
     };
 }
@@ -140,54 +124,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

@@ -41,22 +41,28 @@ __webpack_require__.d(__webpack_exports__, {
     applyModuleFederationAssetHeaders: ()=>applyModuleFederationAssetHeaders,
     getModuleFederationAssetList: ()=>getModuleFederationAssetList,
     getModuleFederationRequestPath: ()=>getModuleFederationRequestPath,
+    isBackendModuleFederationManifestRequest: ()=>isBackendModuleFederationManifestRequest,
     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 isBackendModuleFederationManifestRequest = (requestPath)=>requestPath === BACKEND_MODULE_FEDERATION_MANIFEST_FILE;
 const applyModuleFederationAssetHeaders = (c)=>{
     c.header('Access-Control-Allow-Origin', '*');
     c.header('Access-Control-Allow-Headers', '*');
@@ -67,8 +73,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,56 +114,55 @@ 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;
 exports.applyModuleFederationAssetHeaders = __webpack_exports__.applyModuleFederationAssetHeaders;
 exports.getModuleFederationAssetList = __webpack_exports__.getModuleFederationAssetList;
 exports.getModuleFederationRequestPath = __webpack_exports__.getModuleFederationRequestPath;
+exports.isBackendModuleFederationManifestRequest = __webpack_exports__.isBackendModuleFederationManifestRequest;
 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",
     "getModuleFederationAssetList",
     "getModuleFederationRequestPath",
+    "isBackendModuleFederationManifestRequest",
     "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

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

@@ -0,0 +1,183 @@
+"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,
+    servePublicDirectoryAsset: ()=>servePublicDirectoryAsset
+});
+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 getStaticMimeType = (filename)=>(0, mime_namespaceObject.getMimeType)(filename) ?? ('.cjs' === external_path_default().extname(filename).toLowerCase() ? "text/javascript; charset=UTF-8" : void 0);
+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 = 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);
+    });
+    (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 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 = external_path_default().join(pwd, 'public');
+    const filepath = external_path_default().resolve(publicDirectory, decodedPathname.replace(/^\/+/u, ''));
+    if (!isPathInside(filepath, publicDirectory)) return null;
+    try {
+        const [realPublicDirectory, realFilepath, stat] = await Promise.all([
+            utils_namespaceObject.fs.realpath(publicDirectory),
+            utils_namespaceObject.fs.realpath(filepath),
+            utils_namespaceObject.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 (0, external_staticPrecompressed_js_namespaceObject.resolvePreCompressedAsset)(c, originFilename);
+    const selectedFilename = preCompressedAsset.selected?.filepath ?? originFilename;
+    const publicDirectory = await utils_namespaceObject.fs.realpath(external_path_default().join(pwd, 'public'));
+    let realSelectedFilename;
+    try {
+        realSelectedFilename = await utils_namespaceObject.fs.realpath(selectedFilename);
+    } catch  {
+        return null;
+    }
+    if (!isPathInside(realSelectedFilename, publicDirectory)) return null;
+    const data = await fileReader_namespaceObject.fileReader.readFileFromSystem(realSelectedFilename, 'buffer');
+    if (null === data) return null;
+    const mimeType = getStaticMimeType(originFilename);
+    if (mimeType) c.header('Content-Type', mimeType);
+    (0, external_staticPrecompressed_js_namespaceObject.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 = (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 = getStaticMimeType(filepath);
+        if (mimeType) c.header('Content-Type', mimeType);
+        const shouldPatchManifest = moduleFederationAsset && (0, external_staticModuleFederation_js_namespaceObject.isModuleFederationManifestRequest)(requestPath) && !(0, external_staticModuleFederation_js_namespaceObject.isBackendModuleFederationManifestRequest)(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;
+exports.servePublicDirectoryAsset = __webpack_exports__.servePublicDirectoryAsset;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createModuleFederationStaticServing",
+    "servePreCompressedPublicRouteAsset",
+    "servePublicDirectoryAsset"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -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, servePublicDirectoryAsset } from "./staticServing.mjs";
 const serverStaticPlugin = ()=>({
         name: '@modern-js/plugin-server-static',
         setup (api) {
@@ -30,23 +26,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();
     };
 }
@@ -96,54 +80,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);
     };
 }