@expo/cli 54.1.0-canary-20251031-b135dff → 55.0.0-canary-20251118-8f7ee64

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

@@ -83,13 +83,6 @@ function _path() {
     };
     return data;
 }
-function _resolvefrom() {
-    const data = /*#__PURE__*/ _interop_require_default(require("resolve-from"));
-    _resolvefrom = function() {
-        return data;
-    };
-    return data;
-}
 const _createServerComponentsMiddleware = require("./createServerComponentsMiddleware");
 const _createServerRouteMiddleware = require("./createServerRouteMiddleware");
 const _fetchRouterManifest = require("./fetchRouterManifest");
@@ -106,6 +99,7 @@ const _filePath = require("../../../utils/filePath");
 const _port = require("../../../utils/port");
 const _BundlerDevServer = require("../BundlerDevServer");
 const _getStaticRenderFunctions = require("../getStaticRenderFunctions");
+const _resolveLoader = require("./resolveLoader");
 const _ContextModuleSourceMapsMiddleware = require("../middleware/ContextModuleSourceMapsMiddleware");
 const _CreateFileMiddleware = require("../middleware/CreateFileMiddleware");
 const _DataLoaderModuleMiddleware = require("../middleware/DataLoaderModuleMiddleware");
@@ -246,7 +240,10 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             debug('Adding RSC route to the manifest:', rscPath);
             // NOTE: This might need to be sorted to the correct spot in the future.
             manifest.apiRoutes.push({
-                file: (0, _resolvefrom().default)(this.projectRoot, '@expo/cli/static/template/[...rsc]+api.ts'),
+                // TODO(@kitten): This isn't great, we shouldn't be needing to rely on files like this
+                // It might even be better to make templating strings since that'd be type-checked, but currently,
+                // we rely on this being an entrypoint for Metro
+                file: require.resolve('@expo/cli/static/template/[...rsc]+api.ts'),
                 page: rscPath,
                 namedRegex: '^/_flight(?:/(?<rsc>.+?))?(?:/)?$',
                 routeKeys: {
@@ -324,6 +321,9 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
    * This function is invoked when exporting via `expo export`
    */ async getStaticRenderFunctionAsync() {
         var _exp_extra, _exp_extra1;
+        const { routerRoot } = this.instanceMetroOptions;
+        (0, _assert().default)(routerRoot != null, 'The server must be started before calling getStaticRenderFunctionAsync.');
+        const appDir = _path().default.join(this.projectRoot, routerRoot);
         const url = this.getDevServerUrlOrAssert();
         const { getStaticContent, getManifest, getBuildTimeServerManifestAsync } = await this.ssrLoadModule('@expo/router-server/node/render.js', {
             // This must always use the legacy rendering resolution (no `react-server`) because it leverages
@@ -342,8 +342,20 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 ...(_exp_extra1 = exp.extra) == null ? void 0 : _exp_extra1.router
             }),
             // Get route generating function
-            async renderAsync (path) {
-                return await getStaticContent(new URL(path, url));
+            renderAsync: async (path, route, opts)=>{
+                const location = new URL(path, url);
+                return await getStaticContent(location, opts);
+            },
+            executeLoaderAsync: async (path, route)=>{
+                const location = new URL(path, url);
+                const resolvedLoaderRoute = (0, _resolveLoader.fromRuntimeManifestRoute)(location.pathname, route, {
+                    serverManifest: (0, _fetchRouterManifest.inflateManifest)(serverManifest),
+                    appDir
+                });
+                if (!resolvedLoaderRoute) {
+                    return undefined;
+                }
+                return await this.executeServerDataLoaderAsync(location, resolvedLoaderRoute);
             }
         };
     }
@@ -407,16 +419,19 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             });
             const location = new URL(pathname, this.getDevServerUrlOrAssert());
             const useServerDataLoaders = (_exp_extra = exp.extra) == null ? void 0 : (_exp_extra_router = _exp_extra.router) == null ? void 0 : _exp_extra_router.unstable_useServerDataLoaders;
-            if (useServerDataLoaders) {
-                const data = await this.executeServerDataLoaderAsync(location, route);
-                return await getStaticContent(location, {
-                    loader: {
-                        data
-                    }
-                });
-            } else {
+            if (!useServerDataLoaders) {
                 return await getStaticContent(location);
             }
+            const resolvedLoaderRoute = (0, _resolveLoader.fromServerManifestRoute)(location.pathname, route);
+            if (!resolvedLoaderRoute) {
+                return await getStaticContent(location);
+            }
+            const data = await this.executeServerDataLoaderAsync(location, resolvedLoaderRoute);
+            return await getStaticContent(location, {
+                loader: {
+                    data
+                }
+            });
         };
         const [{ artifacts: resources }, staticHtml] = await Promise.all([
             this.getStaticResourcesAsync({
@@ -843,7 +858,11 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 var _exp_extra_router1, _exp_extra2;
                 if ((_exp_extra2 = exp.extra) == null ? void 0 : (_exp_extra_router1 = _exp_extra2.router) == null ? void 0 : _exp_extra_router1.unstable_useServerDataLoaders) {
                     const loaderModuleMiddleware = new _DataLoaderModuleMiddleware.DataLoaderModuleMiddleware(this.projectRoot, appDir, async (location, route)=>{
-                        return this.executeServerDataLoaderAsync(location, route);
+                        const resolvedLoaderRoute = (0, _resolveLoader.fromServerManifestRoute)(location.pathname, route);
+                        if (!resolvedLoaderRoute) {
+                            return;
+                        }
+                        return this.executeServerDataLoaderAsync(location, resolvedLoaderRoute);
                     }, ()=>this.getDevServerUrlOrAssert());
                     // This MUST be before ServeStaticMiddleware so it doesn't treat the loader files as static assets
                     middleware.use(loaderModuleMiddleware.getHandler());
@@ -1178,27 +1197,13 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
         if (!unstable_useServerDataLoaders) {
             throw new _errors.CommandError('LOADERS_NOT_ENABLED', 'Server data loaders are not enabled. Add `unstable_useServerDataLoaders` to your `expo-router` plugin config.');
         }
-        // If the route is unmatched, we can ignore it
-        // TODO(@hassankhan): Is this the best way of determining the route is unmatched?
-        if (route.page === '/+not-found') {
-            return;
-        }
         const { routerRoot } = this.instanceMetroOptions;
         (0, _assert().default)(routerRoot != null, 'The server must be started before calling executeRouteLoaderAsync.');
         let loaderData;
         try {
-            debug('Matched route loader to file: ', route.file);
-            // TODO(@hassankhan): This should move to a util function
-            const params = {};
-            const match = route.namedRegex.exec(location.pathname);
-            if (match == null ? void 0 : match.groups) {
-                for (const [key, value] of Object.entries(match.groups)){
-                    const namedKey = route.routeKeys[key];
-                    params[namedKey] = value;
-                }
-            }
-            let modulePath = route.file;
+            debug(`Matched ${location.pathname} to file: ${route.file}`);
             const appDir = _path().default.join(this.projectRoot, routerRoot);
+            let modulePath = route.file;
             modulePath = _path().default.isAbsolute(modulePath) ? modulePath : _path().default.join(appDir, modulePath);
             modulePath = modulePath.replace(/\.(js|ts)x?$/, '');
             debug('Using loader module path: ', modulePath);
@@ -1209,7 +1214,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 // Register this module for loader HMR
                 this.setupLoaderHmr(modulePath);
                 loaderData = await routeModule.loader({
-                    params,
+                    params: route.params,
                     // NOTE(@hassankhan): The `request` object should only be available when using SSR
                     request: null
                 });