@expo/cli 56.1.3 → 56.1.5

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

@@ -84,13 +84,6 @@ function _private() {
     };
     return data;
 }
-function _https() {
-    const data = /*#__PURE__*/ _interop_require_default(require("https"));
-    _https = function() {
-        return data;
-    };
-    return data;
-}
 function _path() {
     const data = /*#__PURE__*/ _interop_require_default(require("path"));
     _path = function() {
@@ -928,13 +921,13 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             apiRoutes: hasApiRoutes,
             exporting: !!options.isExporting
         });
-        const { metro, hmrServer, server, middleware, messageSocket } = await (0, _instantiateMetro.instantiateMetroAsync)(this, parsedOptions, {
+        const { metro, hmrServer, address, server, middleware, messageSocket } = await (0, _instantiateMetro.instantiateMetroAsync)(this, parsedOptions, {
             isExporting: !!options.isExporting,
             exp
         });
-        const protocol = server instanceof _https().default.Server ? 'https' : 'http';
         // Required for symbolication:
-        process.env.EXPO_DEV_SERVER_ORIGIN = `${protocol}://localhost:${options.port}`;
+        const serverBaseUrl = `${(address == null ? void 0 : address.protocol) ?? 'http'}://localhost:${(address == null ? void 0 : address.port) ?? options.port}`;
+        process.env.EXPO_DEV_SERVER_ORIGIN = serverBaseUrl;
         if (!options.isExporting) {
             var _metro__config_server, _metro__config;
             const manifestMiddleware = await this.getManifestMiddlewareAsync(options);
@@ -1007,7 +1000,6 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                     metro,
                     server
                 }, ({ changes })=>{
-                    var _exp_extra_router, _exp_extra;
                     if (hasApiRoutes) {
                         // NOTE(EvanBacon): We aren't sure what files the API routes are using so we'll just invalidate
                         // aggressively to ensure we always have the latest. The only caching we really get here is for
@@ -1025,12 +1017,6 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                             }
                         }
                     }
-                    // Handle loader file changes for HMR
-                    if ((_exp_extra = exp.extra) == null ? void 0 : (_exp_extra_router = _exp_extra.router) == null ? void 0 : _exp_extra_router.unstable_useServerDataLoaders) {
-                        for (const change of changes.modifiedFiles){
-                            this.handleLoaderFileChange(change[0]);
-                        }
-                    }
                 });
             }
             // If React 19 is enabled, then add RSC middleware to the dev server.
@@ -1122,6 +1108,11 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 this.metro = null;
                 this.hmrServer = null;
                 this.ssrHmrClients = new Map();
+                for (const unlisten of this.loaderGraphListeners.values()){
+                    unlisten();
+                }
+                this.loaderGraphListeners.clear();
+                this.pendingLoaderInvalidationChangeIds.clear();
                 callback == null ? void 0 : callback(err);
             });
         };
@@ -1131,11 +1122,11 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             server,
             location: {
                 // The port is the main thing we want to send back.
-                port: options.port,
+                port: (address == null ? void 0 : address.port) ?? options.port,
                 // localhost isn't always correct.
                 host: 'localhost',
-                url: `${protocol}://localhost:${options.port}`,
-                protocol
+                url: serverBaseUrl,
+                protocol: (address == null ? void 0 : address.protocol) ?? 'http'
             },
             middleware,
             messageSocket
@@ -1355,8 +1346,6 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 isLoaderBundle: true
             });
             if (routeModule.loader) {
-                // Register this module for loader HMR
-                this.setupLoaderHmr(modulePath);
                 const maybeResponse = await routeModule.loader(request, route.params);
                 let data;
                 if (maybeResponse instanceof Response) {
@@ -1433,29 +1422,48 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
         };
         this.registerSsrHmrAsync(url.toString(), onReload);
     }
-    setupLoaderHmr(modulePath) {
-        if (this.watchedLoaderFiles.has(modulePath)) {
+    // Subscribe to a loader bundle's Metro graph so we can broadcast `loader-invalidate` and
+    // drop the SSR module eval cache when the loader's dependency graph is dirtied. This avoids
+    // the full-page reload the old stub used and keeps client state across loader edits.
+    setupLoaderGraphListener(graphId, resolvedEntryFilePath, graph) {
+        if (this.loaderGraphListeners.has(graphId) || !this.metro) {
             return;
         }
-        this.watchedLoaderFiles.add(modulePath);
-        debug('[Loader HMR] Registering loader file for HMR:', modulePath);
-    }
-    handleLoaderFileChange(changedFilePath) {
-        for (const loaderPath of this.watchedLoaderFiles){
-            const possibleExtensions = [
-                '.tsx',
-                '.ts',
-                '.jsx',
-                '.js'
-            ];
-            const isLoaderFile = possibleExtensions.some((ext)=>changedFilePath === loaderPath + ext || changedFilePath === loaderPath);
-            if (isLoaderFile) {
-                debug('[Loader HMR] Loader file changed, triggering reload:', changedFilePath);
-                this.broadcastMessage('sendDevCommand', {
-                    name: 'reload'
-                });
+        const deltaBundler = this.metro.getBundler().getDeltaBundler();
+        const onChange = async (changeEvent)=>{
+            debug('[Loader HMR] Graph change detected for:', resolvedEntryFilePath);
+            if (!this.shouldBroadcastLoaderInvalidation(changeEvent == null ? void 0 : changeEvent.changeId)) {
+                return;
+            }
+            if (typeof globalThis.__c === 'function') {
+                globalThis.__c();
             }
+            this.broadcastMessage('sendDevCommand', {
+                name: 'loader-invalidate',
+                data: {
+                    scope: 'all'
+                }
+            });
+        };
+        const unlisten = deltaBundler.listen(graph, onChange);
+        this.loaderGraphListeners.set(graphId, unlisten);
+    }
+    shouldBroadcastLoaderInvalidation(changeId) {
+        if (!changeId) {
+            return true;
         }
+        if (this.pendingLoaderInvalidationChangeIds.has(changeId)) {
+            return false;
+        }
+        this.pendingLoaderInvalidationChangeIds.add(changeId);
+        // All listeners for a single filesystem change are dispatched synchronously from one
+        // DeltaCalculator EventEmitter.emit(), so dedupe collisions resolve within microseconds.
+        // The timeout exists only to bound memory: without it, this Set would accumulate one entry
+        // per change for the lifetime of the dev server.
+        setTimeout(()=>{
+            this.pendingLoaderInvalidationChangeIds.delete(changeId);
+        }, 500);
+        return true;
     }
     // Direct Metro access
     // Emulates the Metro dev server .bundle endpoint without having to go through a server.
@@ -1502,13 +1510,14 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             type: 'bundle_build_started'
         });
         try {
+            var _transformOptions_customTransformOptions;
             let delta;
             let revision;
             try {
-                var _transformOptions_customTransformOptions;
+                var _transformOptions_customTransformOptions1;
                 // TODO: Some bug in Metro/RSC causes this to break when changing imports in server components.
                 // We should resolve the bug because it results in ~6x faster bundling to reuse the graph revision.
-                if (((_transformOptions_customTransformOptions = transformOptions.customTransformOptions) == null ? void 0 : _transformOptions_customTransformOptions.environment) === 'react-server') {
+                if (((_transformOptions_customTransformOptions1 = transformOptions.customTransformOptions) == null ? void 0 : _transformOptions_customTransformOptions1.environment) === 'react-server') {
                     const props = await this.metro.getBundler().initializeGraph(// NOTE: Using absolute path instead of relative input path is a breaking change.
                     // entryFile,
                     resolvedEntryFilePath, transformOptions, resolverOptions, {
@@ -1534,6 +1543,9 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 (0, _metroErrorInterface.dropStackIfContainsCodeFrame)(error);
                 throw error;
             }
+            if (!this.instanceMetroOptions.isExporting && transformOptions.dev !== false && ((_transformOptions_customTransformOptions = transformOptions.customTransformOptions) == null ? void 0 : _transformOptions_customTransformOptions.isLoaderBundle) === 'true') {
+                this.setupLoaderGraphListener(revision.graphId, resolvedEntryFilePath, revision.graph);
+            }
             bundlePerfLogger == null ? void 0 : bundlePerfLogger.annotate({
                 int: {
                     graph_node_count: revision.graph.dependencies.size
@@ -1665,7 +1677,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
         });
     }
     constructor(...args){
-        super(...args), this.metro = null, this.hmrServer = null, this.ssrHmrClients = new Map(), // Set when the server is started.
+        super(...args), this.metro = null, this.hmrServer = null, this.ssrHmrClients = new Map(), this.loaderGraphListeners = new Map(), this.pendingLoaderInvalidationChangeIds = new Set(), // Set when the server is started.
         this.instanceMetroOptions = {}, this.ssrLoadModule = async (filePath, specificOptions = {}, extras = {})=>{
             // NOTE(@kitten): We don't properly initialize the server-side modules
             // Instead, we first load an entrypoint with an empty bundle to initialize the runtime instead
@@ -1685,7 +1697,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             }
             return (0, _getStaticRenderFunctions.evalMetroAndWrapFunctions)(this.projectRoot, res.src, res.filename, res.map, specificOptions.isExporting ?? this.instanceMetroOptions.isExporting);
         }, this.rscRenderer = null, this.onReloadRscEvent = null, // API Routes
-        this.pendingRouteOperations = new Map(), this.watchedLoaderFiles = new Set();
+        this.pendingRouteOperations = new Map();
     }
 }
 function getBuildID(buildNumber) {