@expo/cli 0.22.8 → 0.22.10

package/build/src/start/server/metro/MetroBundlerDevServer.js

@@ -265,12 +265,13 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
     }
     async getServerManifestAsync() {
         // NOTE: This could probably be folded back into `renderStaticContent` when expo-asset and font support RSC.
-        const { getBuildTimeServerManifestAsync  } = await this.ssrLoadModule("expo-router/build/static/getServerManifest.js", {
+        const { getBuildTimeServerManifestAsync , getManifest  } = await this.ssrLoadModule("expo-router/build/static/getServerManifest.js", {
             // Only use react-server environment when the routes are using react-server rendering by default.
             environment: this.isReactServerRoutesEnabled ? "react-server" : "node"
         });
         return {
-            serverManifest: await getBuildTimeServerManifestAsync()
+            serverManifest: await getBuildTimeServerManifestAsync(),
+            htmlManifest: await getManifest()
         };
     }
     async getStaticRenderFunctionAsync() {
@@ -375,7 +376,8 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
     instanceMetroOptions = {};
     ssrLoadModule = async (filePath, specificOptions = {}, extras = {})=>{
         const res = await this.ssrLoadModuleContents(filePath, specificOptions);
-        if (extras.hot && this.instanceMetroOptions.isExporting !== true) {
+        if (// TODO: hot should be a callback function for invalidating the related SSR module.
+        extras.hot && this.instanceMetroOptions.isExporting !== true) {
             // Register SSR HMR
             const serverRoot = (0, _paths().getMetroServerRoot)(this.projectRoot);
             const relativePath = _path().default.relative(serverRoot, res.filename);
@@ -524,52 +526,56 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         return this.legacySinglePageExportBundleAsync(options, extraOptions);
     }
     async singlePageReactServerComponentExportAsync(options, files, extraOptions = {}) {
+        const getReactServerReferences = (artifacts)=>{
+            // Get the React server action boundaries from the client bundle.
+            return unique(artifacts.filter((a)=>a.type === "js").map((artifact)=>{
+                var ref;
+                return (ref = artifact.metadata.reactServerReferences) == null ? void 0 : ref.map((ref)=>(0, _createServerComponentsMiddleware.fileURLToFilePath)(ref));
+            })// TODO: Segment by module for splitting.
+            .flat().filter(Boolean));
+        };
         // NOTE(EvanBacon): This will not support any code elimination since it's a static pass.
         let { reactClientReferences: clientBoundaries , reactServerReferences: serverActionReferencesInServer , cssModules ,  } = await this.rscRenderer.getExpoRouterClientReferencesAsync({
             platform: options.platform,
             domRoot: options.domRoot
         }, files);
         // TODO: The output keys should be in production format or use a lookup manifest.
-        debug("Evaluated client boundaries:", clientBoundaries);
-        // Run metro bundler and create the JS bundles/source maps.
-        let bundle = await this.legacySinglePageExportBundleAsync({
-            ...options,
-            clientBoundaries
-        }, extraOptions);
-        // Get the React server action boundaries from the client bundle.
-        const reactServerReferences = bundle.artifacts.filter((a)=>a.type === "js").map((artifact)=>{
-            var ref;
-            return (ref = artifact.metadata.reactServerReferences) == null ? void 0 : ref.map((ref)=>(0, _createServerComponentsMiddleware.fileURLToFilePath)(ref));
-        })// TODO: Segment by module for splitting.
-        .flat().filter(Boolean);
-        if (!reactServerReferences) {
-            // Issue with babel plugin / metro-config.
-            throw new Error("Static server action references were not returned from the Metro client bundle");
-        }
-        debug("React server action boundaries from client:", reactServerReferences);
-        // When we export the server actions that were imported from the client, we may need to re-bundle the client with the new client boundaries.
-        const { clientBoundaries: nestedClientBoundaries  } = await this.rscRenderer.exportServerActionsAsync({
-            platform: options.platform,
-            domRoot: options.domRoot,
-            entryPoints: [
-                ...serverActionReferencesInServer,
-                ...reactServerReferences
-            ]
-        }, files);
-        // TODO: Check against all modules in the initial client bundles.
-        const hasUniqueClientBoundaries = nestedClientBoundaries.some((boundary)=>!clientBoundaries.includes(boundary));
-        if (hasUniqueClientBoundaries) {
-            debug("Re-bundling client with nested client boundaries:", nestedClientBoundaries);
-            clientBoundaries = [
-                ...new Set(clientBoundaries.concat(nestedClientBoundaries))
-            ];
-            // Re-bundle the client with the new client boundaries that only exist in server actions that were imported from the client.
+        const processClientBoundaries = async (reactServerReferences)=>{
+            debug("Evaluated client boundaries:", clientBoundaries);
             // Run metro bundler and create the JS bundles/source maps.
-            bundle = await this.legacySinglePageExportBundleAsync({
+            const bundle = await this.legacySinglePageExportBundleAsync({
                 ...options,
                 clientBoundaries
             }, extraOptions);
-        }
+            // Get the React server action boundaries from the client bundle.
+            const newReactServerReferences = getReactServerReferences(bundle.artifacts);
+            if (!newReactServerReferences) {
+                // Possible issue with babel plugin / metro-config.
+                throw new Error("Static server action references were not returned from the Metro client bundle");
+            }
+            debug("React server action boundaries from client:", newReactServerReferences);
+            const allKnownReactServerReferences = unique([
+                ...reactServerReferences,
+                ...newReactServerReferences, 
+            ]);
+            // When we export the server actions that were imported from the client, we may need to re-bundle the client with the new client boundaries.
+            const { clientBoundaries: nestedClientBoundaries  } = await this.rscRenderer.exportServerActionsAsync({
+                platform: options.platform,
+                domRoot: options.domRoot,
+                entryPoints: allKnownReactServerReferences
+            }, files);
+            // TODO: Check against all modules in the initial client bundles.
+            const hasUniqueClientBoundaries = nestedClientBoundaries.some((boundary)=>!clientBoundaries.includes(boundary));
+            if (!hasUniqueClientBoundaries) {
+                return bundle;
+            }
+            debug("Re-bundling client with nested client boundaries:", nestedClientBoundaries);
+            clientBoundaries = unique(clientBoundaries.concat(nestedClientBoundaries));
+            // Re-bundle the client with the new client boundaries that only exist in server actions that were imported from the client.
+            // Run metro bundler and create the JS bundles/source maps.
+            return processClientBoundaries(allKnownReactServerReferences);
+        };
+        const bundle = await processClientBoundaries(serverActionReferencesInServer);
         // Inject the global CSS that was imported during the server render.
         bundle.artifacts.push(...cssModules);
         const serverRoot = (0, _paths().getMetroServerRoot)(this.projectRoot);
@@ -670,7 +676,7 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
     }
     rscRenderer = null;
     async startImplementationAsync(options) {
-        var ref, ref1, ref2, ref3, ref4, ref5, ref6, ref7;
+        var ref, ref1, ref2, ref3, ref4, ref5, ref6, ref7, ref8, ref9, ref10;
         options.port = await this.resolvePortAsync(options);
         this.urlCreator = this.getUrlCreator(options);
         const config = (0, _config().getConfig)(this.projectRoot, {
@@ -693,8 +699,14 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         const reactCompiler = !!((ref7 = exp.experiments) == null ? void 0 : ref7.reactCompiler);
         const appDir = _path().default.join(this.projectRoot, routerRoot);
         const mode = options.mode ?? "development";
-        if (isReactServerComponentsEnabled && useServerRendering) {
-            throw new _errors.CommandError(`Experimental server component support does not support 'web.output: ${exp.web.output}' yet. Use 'web.output: "single"' during the experimental phase.`);
+        if (isReactServerComponentsEnabled && ((ref8 = exp.web) == null ? void 0 : ref8.output) === "static") {
+            throw new _errors.CommandError(`Experimental server component support does not support 'web.output: ${exp.web.output}' yet. Use 'web.output: "server"' during the experimental phase.`);
+        }
+        // Error early about the window.location polyfill when React Server Components are enabled.
+        if (isReactServerComponentsEnabled && (exp == null ? void 0 : (ref9 = exp.extra) == null ? void 0 : (ref10 = ref9.router) == null ? void 0 : ref10.origin) === false) {
+            const configPath = config.dynamicConfigPath ?? config.staticConfigPath ?? "/app.json";
+            const configFileName = _path().default.basename(configPath);
+            throw new _errors.CommandError(`The Expo Router "origin" property in the Expo config (${configFileName}) cannot be "false" when React Server Components is enabled. Remove it from the ${configFileName} file and try again.`);
         }
         const instanceMetroOptions = {
             isExporting: !!options.isExporting,
@@ -806,20 +818,30 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             }
             // Append support for redirecting unhandled requests to the index.html page on web.
             if (this.isTargetingWeb()) {
-                if (!useServerRendering || isReactServerComponentsEnabled) {
+                if (!useServerRendering) {
                     // This MUST run last since it's the fallback.
                     middleware.use(new _historyFallbackMiddleware.HistoryFallbackMiddleware(manifestMiddleware.getHandler().internal).getHandler());
                 } else {
-                    var ref8;
+                    var ref11;
                     middleware.use((0, _createServerRouteMiddleware.createRouteHandlerMiddleware)(this.projectRoot, {
                         appDir,
                         routerRoot,
                         config,
-                        ...(ref8 = config.exp.extra) == null ? void 0 : ref8.router,
+                        ...(ref11 = config.exp.extra) == null ? void 0 : ref11.router,
                         bundleApiRoute: (functionFilePath)=>this.ssrImportApiRoute(functionFilePath, {
                                 platform: "web"
                             }),
-                        getStaticPageAsync: (pathname)=>{
+                        getStaticPageAsync: async (pathname)=>{
+                            // TODO: Add server rendering when RSC is enabled.
+                            if (isReactServerComponentsEnabled) {
+                                // NOTE: This is a temporary hack to return the SPA/template index.html in development when RSC is enabled.
+                                // While this technically works, it doesn't provide the correct experience of server rendering the React code to HTML first.
+                                const html = await manifestMiddleware.getSingleHtmlTemplateAsync();
+                                return {
+                                    content: html
+                                };
+                            }
+                            // Non-RSC apps will bundle the static HTML for a given pathname and respond with it.
                             return this.getStaticPageAsync(pathname);
                         }
                     }));
@@ -890,8 +912,21 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                         // NOTE: We throw away the updates and instead simply send a trigger to the client to re-fetch the server route.
                         if (!isInitialUpdate && hasUpdate) {
                             // Clear all SSR modules before sending the reload event. This ensures that the next event will rebuild the in-memory state from scratch.
-                            // if (typeof globalThis.__c === 'function') globalThis.__c();
-                            onReload();
+                            // @ts-expect-error
+                            if (typeof globalThis.__c === "function") globalThis.__c();
+                            const allModuleIds = new Set([
+                                ...added,
+                                ...modified
+                            ].map((m)=>m.module[0]).concat(deleted));
+                            const platforms = unique(Array.from(allModuleIds).map((moduleId)=>{
+                                var ref;
+                                if (typeof moduleId !== "string") {
+                                    return null;
+                                }
+                                // Extract platforms from the module IDs.
+                                return ((ref = moduleId.match(/[?&]platform=([\w]+)/)) == null ? void 0 : ref[1]) ?? null;
+                            }).filter(Boolean));
+                            onReload(platforms);
                         }
                     }
                     break;
@@ -1063,14 +1098,23 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
     }
     // Metro HMR
     setupHmr(url) {
-        const onReload = ()=>{
-            var _obj, ref;
+        const onReload = (platforms = [])=>{
             // Send reload command to client from Fast Refresh code.
-            debug("[SSR]: Reload requested.");
-            (ref = (_obj = this).onReloadRscEvent) == null ? void 0 : ref.call(_obj);
-            this.broadcastMessage("sendDevCommand", {
-                name: "rsc-reload"
-            });
+            if (!platforms.length) {
+                // TODO: When is this called?
+                this.broadcastMessage("sendDevCommand", {
+                    name: "rsc-reload"
+                });
+            } else {
+                for (const platform of platforms){
+                    var _obj, ref;
+                    (ref = (_obj = this).onReloadRscEvent) == null ? void 0 : ref.call(_obj, platform);
+                    this.broadcastMessage("sendDevCommand", {
+                        name: "rsc-reload",
+                        platform
+                    });
+                }
+            }
         };
         this.registerSsrHmrAsync(url.toString(), onReload);
     }
@@ -1238,6 +1282,9 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                 map: bundleMap
             };
         } catch (error1) {
+            // Mark the error so we know how to format and return it later.
+            // @ts-expect-error
+            error1[_metroErrorInterface.IS_METRO_BUNDLE_ERROR_SYMBOL] = true;
             this.metro._reporter.update({
                 buildID: getBuildID(buildNumber),
                 type: "bundle_build_failed"
@@ -1283,5 +1330,8 @@ async function sourceMapStringAsync(modules, options) {
         excludeSource: options.excludeSource
     });
 }
+function unique(array) {
+    return Array.from(new Set(array));
+}
 
 //# sourceMappingURL=MetroBundlerDevServer.js.map