@modern-js/builder 3.0.0-alpha.0 → 3.0.0-alpha.2

package/dist/cjs/rsc/plugins/rspack-rsc-client-plugin.js

@@ -0,0 +1,187 @@
+"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, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    RspackRscClientPlugin: ()=>RspackRscClientPlugin
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_common_js_namespaceObject = require("../common.js");
+const hasExtension = (filePath)=>'' !== external_path_default().extname(filePath);
+class RspackRscClientPlugin {
+    apply(compiler) {
+        const { EntryPlugin, RuntimeGlobals, WebpackError, sources: { RawSource } } = compiler.rspack;
+        const ssrManifest = {
+            moduleMap: {},
+            moduleLoading: null,
+            styles: []
+        };
+        const getEntryModule = (compilation)=>{
+            const entryModules = [];
+            for (const [, entryValue] of compilation.entries.entries()){
+                const entryDependency = entryValue.dependencies[0];
+                if (!entryDependency) {
+                    compilation.errors.push(new WebpackError("Could not find an entry dependency."));
+                    continue;
+                }
+                const resolvedModule = compilation.moduleGraph.getModule(entryDependency);
+                if (resolvedModule) entryModules.push(resolvedModule);
+            }
+            if (0 === entryModules.length) {
+                compilation.errors.push(new WebpackError("Could not find any entries in the compilation."));
+                return [];
+            }
+            return entryModules;
+        };
+        const addClientReferencesChunks = (compilation, callback)=>{
+            const promises = [];
+            [
+                ...this.clientReferencesMap.keys()
+            ].forEach((resourcePath)=>{
+                const entries = compilation.entries.entries();
+                for (const [entryName, entry] of entries){
+                    const runtimeName = entry.options.runtime || entryName;
+                    if (hasExtension(entryName)) continue;
+                    const dependency = EntryPlugin.createDependency(resourcePath);
+                    promises.push(new Promise((resolve, reject)=>{
+                        compilation.addInclude(compiler.context, dependency, {
+                            name: entryName
+                        }, (error, module)=>{
+                            if (error) reject(error);
+                            else {
+                                compilation.moduleGraph.getExportsInfo(module).setUsedInUnknownWay(runtimeName);
+                                this.dependencies.push(dependency);
+                                resolve(void 0);
+                            }
+                        });
+                    }));
+                }
+            });
+            if (this.styles && this.styles.size > 0) for (const style of this.styles){
+                const dependency = EntryPlugin.createDependency(style);
+                promises.push(new Promise((resolve, reject)=>{
+                    compilation.addInclude(compiler.context, dependency, {
+                        name: void 0
+                    }, (error, module)=>{
+                        if (error) reject(error);
+                        else {
+                            compilation.moduleGraph.getExportsInfo(module).setUsedInUnknownWay(void 0);
+                            this.dependencies.push(dependency);
+                            resolve(void 0);
+                        }
+                    });
+                }));
+            }
+            Promise.all(promises).then(()=>callback(null)).catch((error)=>callback(error));
+        };
+        compiler.hooks.finishMake.tapAsync(RspackRscClientPlugin.name, (compilation, callback)=>{
+            const entryModules = getEntryModule(compilation);
+            for (const entryModule of entryModules)if (entryModule) addClientReferencesChunks(compilation, callback);
+        });
+        compiler.hooks.thisCompilation.tap(RspackRscClientPlugin.name, (compilation)=>{
+            this.styles = external_common_js_namespaceObject.sharedData.get('styles');
+            this.clientReferencesMap = external_common_js_namespaceObject.sharedData.get('clientReferencesMap');
+            compilation.hooks.additionalTreeRuntimeRequirements.tap(RspackRscClientPlugin.name, (_chunk, runtimeRequirements)=>{
+                runtimeRequirements.add(RuntimeGlobals.ensureChunkHandlers);
+                runtimeRequirements.add(RuntimeGlobals.ensureChunk);
+                runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
+            });
+            compilation.hooks.processAssets.tap(RspackRscClientPlugin.name, ()=>{
+                const clientManifest = {};
+                const { chunkGraph, moduleGraph } = compilation;
+                for (const dependency of this.dependencies){
+                    const module = moduleGraph.getModule(dependency);
+                    if (!module) continue;
+                    const resourcePath = module.nameForCondition();
+                    const clientReferences = resourcePath ? this.clientReferencesMap.get(resourcePath) : void 0;
+                    if (clientReferences) {
+                        const moduleId = chunkGraph.getModuleId(module);
+                        const ssrModuleMetaData = {};
+                        for (const { id, exportName, ssrId } of clientReferences){
+                            const clientExportName = exportName;
+                            const ssrExportName = exportName;
+                            const chunksSet = new Set();
+                            for (const chunk of chunkGraph.getModuleChunksIterable(module))chunksSet.add(chunk);
+                            for (const connection of moduleGraph.getOutgoingConnections(module))for (const chunk of chunkGraph.getModuleChunksIterable(connection.module))chunksSet.add(chunk);
+                            const chunks = [];
+                            const styles = [];
+                            for (const chunk of chunksSet)if (chunk.id) {
+                                for (const file of chunk.files)if (file.endsWith('.js')) chunks.push(chunk.id, file);
+                            }
+                            clientManifest[id] = {
+                                id: moduleId,
+                                name: clientExportName,
+                                chunks,
+                                styles
+                            };
+                            if (ssrId) ssrModuleMetaData[clientExportName] = {
+                                id: ssrId,
+                                name: ssrExportName,
+                                chunks: []
+                            };
+                        }
+                        ssrManifest.moduleMap[moduleId] = ssrModuleMetaData;
+                    }
+                }
+                compilation.emitAsset(this.clientManifestFilename, new RawSource(JSON.stringify(clientManifest, null, 2), false));
+                const { crossOriginLoading, publicPath = "" } = compilation.outputOptions;
+                ssrManifest.moduleLoading = {
+                    prefix: compilation.getPath(publicPath, {
+                        hash: compilation.hash ?? "XXXX"
+                    }),
+                    crossOrigin: crossOriginLoading ? "use-credentials" === crossOriginLoading ? crossOriginLoading : "" : void 0
+                };
+                if (this.styles && this.styles.size > 0) {
+                    const assets = compilation.getAssets();
+                    const cssAsset = assets.find((asset)=>asset.name.endsWith('.css'));
+                    if (cssAsset) ssrManifest.styles.push(cssAsset.name);
+                }
+                compilation.emitAsset(this.ssrManifestFilename, new RawSource(JSON.stringify(ssrManifest, null, 2), false));
+            });
+        });
+    }
+    constructor(options){
+        this.clientReferencesMap = new Map();
+        this.dependencies = [];
+        this.clientManifestFilename = options?.clientManifestFilename || "react-client-manifest.json";
+        this.ssrManifestFilename = options?.ssrManifestFilename || "react-ssr-manifest.json";
+    }
+}
+exports.RspackRscClientPlugin = __webpack_exports__.RspackRscClientPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RspackRscClientPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/rsc/plugins/rspack-rsc-server-plugin.js

@@ -0,0 +1,245 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    RscServerPlugin: ()=>RscServerPlugin
+});
+const external_common_js_namespaceObject = require("../common.js");
+const rspack_rsc_server_plugin_resourcePath2Entries = new Map();
+class RscServerPlugin {
+    isValidModule(module) {
+        return Boolean(module?.resource);
+    }
+    hasValidEntries(entries) {
+        return Boolean(entries && entries.length > 0);
+    }
+    getEntryNameFromIssuer(issuer) {
+        return issuer.resource ? this.entryPath2Name.get(issuer.resource) : void 0;
+    }
+    createEntryFromIssuer(issuer, entryName) {
+        return {
+            entryName,
+            entryPath: issuer.resource
+        };
+    }
+    buildModuleToEntriesMapping(compilation) {
+        this.moduleToEntries.clear();
+        for (const [entryName, entryDependency] of compilation.entries.entries()){
+            const entryModule = compilation.moduleGraph.getModule(entryDependency.dependencies[0]);
+            if (entryModule) this.traverseModulesFromEntry(entryModule, entryName, compilation.moduleGraph, new Set());
+        }
+    }
+    traverseModulesFromEntry(module, entryName, moduleGraph, visited) {
+        if (!module?.resource || visited.has(module.resource)) return;
+        visited.add(module.resource);
+        if (!this.moduleToEntries.has(module.resource)) this.moduleToEntries.set(module.resource, new Set());
+        this.moduleToEntries.get(module.resource).add(entryName);
+        for (const connection of moduleGraph.getOutgoingConnections(module))if (connection.module && 'resource' in connection.module) this.traverseModulesFromEntry(connection.module, entryName, moduleGraph, visited);
+    }
+    findModuleEntries(module, compilation, resourcePath2Entries, visited = new Set()) {
+        if (!this.isValidModule(module) || visited.has(module.resource)) return [];
+        visited.add(module.resource);
+        const currentEntries = resourcePath2Entries.get(module.resource);
+        if (this.hasValidEntries(currentEntries)) return currentEntries;
+        const entryNames = this.moduleToEntries.get(module.resource);
+        if (entryNames && entryNames.size > 0) {
+            const entries = [];
+            for (const entryName of entryNames){
+                const entryPath = this.getEntryPathByName(entryName, compilation);
+                if (entryPath) entries.push({
+                    entryName,
+                    entryPath
+                });
+            }
+            return entries;
+        }
+        const issuer = (0, external_common_js_namespaceObject.findRootIssuer)(compilation.moduleGraph, module);
+        if (!issuer) return [];
+        const issuerEntries = this.findModuleEntries(issuer, compilation, resourcePath2Entries, visited);
+        if (issuerEntries.length > 0) return issuerEntries;
+        const entryName = this.getEntryNameFromIssuer(issuer);
+        if (entryName) return [
+            this.createEntryFromIssuer(issuer, entryName)
+        ];
+        return [];
+    }
+    getEntryPathByName(entryName, compilation) {
+        const entryDependency = compilation.entries.get(entryName);
+        if (entryDependency && entryDependency.dependencies.length > 0) {
+            const firstDep = entryDependency.dependencies[0];
+            if ('request' in firstDep && 'string' == typeof firstDep.request) return firstDep.request;
+        }
+    }
+    apply(compiler) {
+        const { EntryPlugin, WebpackError, sources: { RawSource } } = compiler.rspack;
+        const includeModule = async (compilation, resource, resourceEntryNames, layer)=>{
+            const entries = Array.from(compilation.entries.entries());
+            if (0 === entries.length) return void compilation.errors.push(new WebpackError("Could not find an entry in the compilation."));
+            const includePromises = entries.filter(([entryName])=>resourceEntryNames?.includes(entryName)).map(([entryName])=>{
+                const dependency = EntryPlugin.createDependency(resource);
+                return new Promise((resolve, reject)=>{
+                    compilation.addInclude(compiler.context, dependency, {
+                        name: entryName,
+                        layer
+                    }, (error, module)=>{
+                        if (error) {
+                            compilation.errors.push(error);
+                            return reject(error);
+                        }
+                        if (!module) {
+                            const noModuleError = new WebpackError("Module not added");
+                            noModuleError.file = resource;
+                            compilation.errors.push(noModuleError);
+                            return reject(noModuleError);
+                        }
+                        (0, external_common_js_namespaceObject.setRscBuildInfo)(module, {
+                            __entryName: entryName
+                        });
+                        compilation.moduleGraph.getExportsInfo(module).setUsedInUnknownWay(entryName);
+                        resolve();
+                    });
+                });
+            });
+            await Promise.all(includePromises);
+        };
+        let needsAdditionalPass = false;
+        compiler.hooks.finishMake.tapPromise(RscServerPlugin.name, async (compilation)=>{
+            this.buildModuleToEntriesMapping(compilation);
+            const processModules = (modules)=>{
+                let hasChangeReference = false;
+                for (const module of modules){
+                    if ('resource' in module && (0, external_common_js_namespaceObject.isCssModule)(module)) this.styles.add(module.resource);
+                    const buildInfo = (0, external_common_js_namespaceObject.getRscBuildInfo)(module);
+                    if (!buildInfo || !buildInfo.resourcePath) continue;
+                    if (module.layer && 'server' === buildInfo.type) external_common_js_namespaceObject.sharedData.set(buildInfo?.resourcePath, buildInfo);
+                    if (!module.layer && 'client' === buildInfo.type) external_common_js_namespaceObject.sharedData.set(buildInfo?.resourcePath, buildInfo);
+                    const currentReference = buildInfo?.type === 'client' ? this.clientReferencesMap.get(buildInfo.resourcePath) : this.serverReferencesMap.get(buildInfo.resourcePath);
+                    if (buildInfo?.type !== 'client' || currentReference) {
+                        if (buildInfo?.type === 'server' && !currentReference) {
+                            hasChangeReference = true;
+                            this.serverReferencesMap.set(buildInfo.resourcePath, buildInfo.exportNames);
+                        }
+                    } else {
+                        hasChangeReference = true;
+                        this.clientReferencesMap.set(buildInfo.resourcePath, buildInfo.clientReferences);
+                    }
+                    const entries = this.findModuleEntries(module, compilation, rspack_rsc_server_plugin_resourcePath2Entries);
+                    if (entries.length > 0) rspack_rsc_server_plugin_resourcePath2Entries.set(module.resource, entries);
+                }
+                return hasChangeReference;
+            };
+            this.serverManifest = {};
+            const clientReferences = [
+                ...this.clientReferencesMap.keys()
+            ];
+            const serverReferences = [
+                ...this.serverReferencesMap.keys()
+            ];
+            const referencesBefore = [
+                ...clientReferences,
+                ...serverReferences
+            ];
+            let hasChangeReference = false;
+            await Promise.all([
+                ...clientReferences.map(async (resource)=>{
+                    try {
+                        await includeModule(compilation, resource, rspack_rsc_server_plugin_resourcePath2Entries.get(resource)?.map((entry)=>entry.entryName) || []);
+                    } catch (error) {
+                        console.error(error);
+                        hasChangeReference = true;
+                        this.clientReferencesMap.delete(resource);
+                    }
+                }),
+                ...serverReferences.map(async (resource)=>{
+                    try {
+                        await includeModule(compilation, resource, rspack_rsc_server_plugin_resourcePath2Entries.get(resource)?.map((entry)=>entry.entryName) || [], external_common_js_namespaceObject.rspackRscLayerName);
+                    } catch (error) {
+                        console.error(error);
+                        hasChangeReference = true;
+                        this.serverReferencesMap.delete(resource);
+                    }
+                })
+            ]);
+            hasChangeReference = processModules(compilation.modules);
+            const referencesAfter = [
+                ...this.clientReferencesMap.keys(),
+                ...this.serverReferencesMap.keys()
+            ];
+            if (referencesBefore.length !== referencesAfter.length || !referencesAfter.every((reference)=>referencesBefore.includes(reference)) && hasChangeReference) needsAdditionalPass = true;
+        });
+        compiler.hooks.done.tap(RscServerPlugin.name, ()=>{
+            external_common_js_namespaceObject.sharedData.set('serverReferencesMap', this.serverReferencesMap);
+            external_common_js_namespaceObject.sharedData.set('clientReferencesMap', this.clientReferencesMap);
+            external_common_js_namespaceObject.sharedData.set('styles', this.styles);
+        });
+        compiler.hooks.afterCompile.tap(RscServerPlugin.name, (compilation)=>{
+            for (const module of compilation.modules){
+                const resource = module.nameForCondition();
+                if (!resource) continue;
+                const moduleId = compilation.chunkGraph.getModuleId(module);
+                if (null !== moduleId) {
+                    if (module.layer !== external_common_js_namespaceObject.rspackRscLayerName && this.clientReferencesMap.has(resource)) {
+                        const clientReferences = this.clientReferencesMap.get(resource);
+                        if (clientReferences) for (const clientReference of clientReferences)clientReference.ssrId = moduleId;
+                        else compilation.errors.push(new WebpackError(`Could not find client references info in \`clientReferencesMap\` for ${resource}.`));
+                    } else if (module.layer === external_common_js_namespaceObject.rspackRscLayerName && (0, external_common_js_namespaceObject.getRscBuildInfo)(module)?.type === 'server') {
+                        const serverReferencesModuleInfo = (0, external_common_js_namespaceObject.getRscBuildInfo)(module);
+                        if (serverReferencesModuleInfo) {
+                            serverReferencesModuleInfo.moduleId = moduleId;
+                            for (const exportName of serverReferencesModuleInfo.exportNames)this.serverManifest[`${moduleId}#${exportName}`] = {
+                                id: moduleId,
+                                chunks: [],
+                                name: exportName
+                            };
+                        } else compilation.errors.push(new WebpackError(`Could not find server references module info in \`serverReferencesMap\` for ${resource}.`));
+                    }
+                }
+            }
+        });
+        compiler.hooks.thisCompilation.tap(RscServerPlugin.name, (compilation)=>{
+            compilation.hooks.needAdditionalPass.tap(RscServerPlugin.name, ()=>!(needsAdditionalPass = !needsAdditionalPass));
+            compilation.hooks.processAssets.tap(RscServerPlugin.name, ()=>{
+                compilation.emitAsset(this.serverManifestFilename, new RawSource(JSON.stringify(this.serverManifest, null, 2), false));
+            });
+        });
+    }
+    constructor(options){
+        this.clientReferencesMap = new Map();
+        this.serverReferencesMap = new Map();
+        this.serverManifest = {};
+        this.entryPath2Name = new Map();
+        this.moduleToEntries = new Map();
+        this.styles = new Set();
+        this.serverManifestFilename = options?.serverManifestFilename || "react-server-manifest.json";
+        this.entryPath2Name = options?.entryPath2Name || new Map();
+    }
+}
+exports.RscServerPlugin = __webpack_exports__.RscServerPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RscServerPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/rsc/rsc-client-loader.js

@@ -0,0 +1,71 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    default: ()=>rscClientLoader
+});
+const external_common_js_namespaceObject = require("./common.js");
+async function rscClientLoader(source, sourceMap) {
+    this.cacheable(true);
+    const callback = this.async();
+    const ast = await (0, external_common_js_namespaceObject.parseSource)(source);
+    const hasUseServerDirective = await (0, external_common_js_namespaceObject.isServerModule)(ast);
+    if (!hasUseServerDirective) return void callback(null, source, sourceMap);
+    const { callServerImport = "@modern-js/runtime/rsc/client", registerImport = "@modern-js/runtime/rsc/client" } = this.getOptions();
+    const buildInfo = external_common_js_namespaceObject.sharedData.get(this.resourcePath);
+    const moduleInfo = buildInfo ? {
+        moduleId: buildInfo?.moduleId,
+        exportNames: buildInfo?.exportNames
+    } : null;
+    if (!moduleInfo) {
+        this.emitError(new Error(`Could not find server module info in \`serverReferencesMap\` for ${this.resourcePath}.`));
+        callback(null, '');
+        return;
+    }
+    const { moduleId, exportNames } = moduleInfo;
+    if (!moduleId) {
+        this.emitError(new Error(`Could not find server module ID in \`serverReferencesMap\` for ${this.resourcePath}.`));
+        callback(null, '');
+        return;
+    }
+    if (!exportNames) return void callback(null, '');
+    const importsCode = `
+    import { createServerReference } from "${registerImport}";
+    import { callServer } from "${callServerImport}";
+  `;
+    const exportsCode = exportNames.map((item)=>{
+        const name = item;
+        if ('default' === name) return `export default createServerReference("${moduleId}", callServer);`;
+        return `export var ${name} = createServerReference("${moduleId}#${name}", callServer);`;
+    }).join('\n');
+    callback(null, `${importsCode}\n${exportsCode}`);
+}
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/rsc/rsc-css-loader.js

@@ -0,0 +1,42 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    default: ()=>rscCssLoader
+});
+const external_common_js_namespaceObject = require("./common.js");
+function rscCssLoader(source) {
+    this._module && (0, external_common_js_namespaceObject.setRscBuildInfo)(this._module, {
+        isCssModule: true
+    });
+    return source;
+}
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/rsc/rsc-server-loader.js

@@ -0,0 +1,102 @@
+"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, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    default: ()=>rscServerLoader
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const core_namespaceObject = require("@swc/core");
+const external_common_js_namespaceObject = require("./common.js");
+function extractMetadata(code) {
+    const metadataRegex = /\/\* @modern-js-rsc-metadata\n([\s\S]*?)\*\//;
+    const match = code.match(metadataRegex);
+    if (!match) return null;
+    try {
+        const metadata = JSON.parse(match[1]);
+        return metadata;
+    } catch (e) {
+        console.error('Failed to parse metadata:', e);
+        return null;
+    }
+}
+async function rscServerLoader(source) {
+    this.cacheable(true);
+    const callback = this.async();
+    const { appDir, runtimePath = '@modern-js/runtime/rsc/server' } = this.getOptions();
+    const result = await (0, core_namespaceObject.transform)(source, {
+        filename: this.resourcePath,
+        jsc: {
+            target: 'es2020',
+            experimental: {
+                cacheRoot: external_path_default().resolve(appDir, 'node_modules/.swc'),
+                plugins: [
+                    [
+                        require.resolve('@modern-js/flight-server-transform-plugin'),
+                        {
+                            appDir: appDir,
+                            runtimePath: runtimePath
+                        }
+                    ]
+                ]
+            }
+        },
+        isModule: true
+    });
+    const { code, map } = result;
+    const metadata = extractMetadata(code);
+    if (metadata?.directive && 'client' === metadata.directive) {
+        const { exportNames } = metadata;
+        if (exportNames.length > 0) (0, external_common_js_namespaceObject.setRscBuildInfo)(this._module, {
+            type: 'client',
+            resourcePath: this.resourcePath,
+            clientReferences: exportNames
+        });
+    } else if (metadata) {
+        const { exportNames } = metadata;
+        if (exportNames.length > 0) (0, external_common_js_namespaceObject.setRscBuildInfo)(this._module, {
+            type: 'server',
+            resourcePath: this.resourcePath,
+            exportNames: exportNames.map((item)=>item.exportName)
+        });
+    }
+    return callback(null, code, map);
+}
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});