@expo/cli 0.22.25 → 0.22.26

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

@@ -14,12 +14,8 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    createServerComponentsMiddleware: function() {
-        return createServerComponentsMiddleware;
-    },
-    fileURLToFilePath: function() {
-        return fileURLToFilePath;
-    }
+    createServerComponentsMiddleware: ()=>createServerComponentsMiddleware,
+    fileURLToFilePath: ()=>fileURLToFilePath
 });
 function _paths() {
     const data = require("@expo/config/paths");
@@ -36,21 +32,21 @@ function _rsc() {
     return data;
 }
 function _assert() {
-    const data = /*#__PURE__*/ _interop_require_default(require("assert"));
+    const data = /*#__PURE__*/ _interopRequireDefault(require("assert"));
     _assert = function() {
         return data;
     };
     return data;
 }
 function _path() {
-    const data = /*#__PURE__*/ _interop_require_default(require("path"));
+    const data = /*#__PURE__*/ _interopRequireDefault(require("path"));
     _path = function() {
         return data;
     };
     return data;
 }
 function _url() {
-    const data = /*#__PURE__*/ _interop_require_default(require("url"));
+    const data = /*#__PURE__*/ _interopRequireDefault(require("url"));
     _url = function() {
         return data;
     };
@@ -65,31 +61,31 @@ const _ip = require("../../../utils/ip");
 const _stream = require("../../../utils/stream");
 const _createBuiltinAPIRequestHandler = require("../middleware/createBuiltinAPIRequestHandler");
 const _metroOptions = require("../middleware/metroOptions");
-function _interop_require_default(obj) {
+function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-const debug = require('debug')('expo:rsc');
+const debug = require("debug")("expo:rsc");
 const getMetroServerRootMemo = (0, _fn.memoize)(_paths().getMetroServerRoot);
-function createServerComponentsMiddleware(projectRoot, { rscPath, instanceMetroOptions, ssrLoadModule, ssrLoadModuleArtifacts, useClientRouter, createModuleId }) {
-    const routerModule = useClientRouter ? 'expo-router/build/rsc/router/noopRouter' : 'expo-router/build/rsc/router/expo-definedRouter';
+function createServerComponentsMiddleware(projectRoot, { rscPath , instanceMetroOptions , ssrLoadModule , ssrLoadModuleArtifacts , useClientRouter , createModuleId  }) {
+    const routerModule = useClientRouter ? "expo-router/build/rsc/router/noopRouter" : "expo-router/build/rsc/router/expo-definedRouter";
     const rscMiddleware = (0, _rsc().getRscMiddleware)({
         config: {},
         // Disabled in development
-        baseUrl: '',
+        baseUrl: "",
         rscPath,
         onError: console.error,
         renderRsc: async (args)=>{
             // In development we should add simulated versions of common production headers.
-            if (args.headers['x-real-ip'] == null) {
-                args.headers['x-real-ip'] = (0, _ip.getIpAddress)();
+            if (args.headers["x-real-ip"] == null) {
+                args.headers["x-real-ip"] = (0, _ip.getIpAddress)();
             }
-            if (args.headers['x-forwarded-for'] == null) {
-                args.headers['x-forwarded-for'] = args.headers['x-real-ip'];
+            if (args.headers["x-forwarded-for"] == null) {
+                args.headers["x-forwarded-for"] = args.headers["x-real-ip"];
             }
-            if (args.headers['x-forwarded-proto'] == null) {
-                args.headers['x-forwarded-proto'] = 'http';
+            if (args.headers["x-forwarded-proto"] == null) {
+                args.headers["x-forwarded-proto"] = "http";
             }
             // Dev server-only implementation.
             try {
@@ -118,7 +114,7 @@ function createServerComponentsMiddleware(projectRoot, { rscPath, instanceMetroO
                     throw new Response(JSON.stringify(error), {
                         status: (0, _xcodeCompilerLogger.isPossiblyUnableToResolveError)(error) ? 404 : 500,
                         headers: {
-                            'Content-Type': 'application/json'
+                            "Content-Type": "application/json"
                         }
                     });
                 }
@@ -126,17 +122,17 @@ function createServerComponentsMiddleware(projectRoot, { rscPath, instanceMetroO
                 throw new Response(sanitizedServerMessage, {
                     status: 500,
                     headers: {
-                        'Content-Type': 'text/plain'
+                        "Content-Type": "text/plain"
                     }
                 });
             }
         }
     });
     let rscPathPrefix = rscPath;
-    if (rscPathPrefix !== '/') {
-        rscPathPrefix += '/';
+    if (rscPathPrefix !== "/") {
+        rscPathPrefix += "/";
     }
-    async function exportServerActionsAsync({ platform, entryPoints, domRoot }, files) {
+    async function exportServerActionsAsync({ platform , entryPoints , domRoot  }, files) {
         const uniqueEntryPoints = [
             ...new Set(entryPoints)
         ];
@@ -146,10 +142,10 @@ function createServerComponentsMiddleware(projectRoot, { rscPath, instanceMetroO
         const nestedServerBoundaries = [];
         const processedEntryPoints = new Set();
         async function processEntryPoint(entryPoint) {
-            var _contents_artifacts_filter__metadata_reactClientReferences, _contents_artifacts_filter__metadata_reactServerReferences;
+            var ref, ref1;
             processedEntryPoints.add(entryPoint);
             const contents = await ssrLoadModuleArtifacts(entryPoint, {
-                environment: 'react-server',
+                environment: "react-server",
                 platform,
                 // Ignore the metro runtime to avoid overwriting the original in the API route.
                 modulesOnly: true,
@@ -158,27 +154,27 @@ function createServerComponentsMiddleware(projectRoot, { rscPath, instanceMetroO
                 // Required to ensure assets load as client boundaries.
                 domRoot
             });
-            const reactClientReferences = (_contents_artifacts_filter__metadata_reactClientReferences = contents.artifacts.filter((a)=>a.type === 'js')[0].metadata.reactClientReferences) == null ? void 0 : _contents_artifacts_filter__metadata_reactClientReferences.map((ref)=>fileURLToFilePath(ref));
+            const reactClientReferences = (ref = contents.artifacts.filter((a)=>a.type === "js")[0].metadata.reactClientReferences) == null ? void 0 : ref.map((ref)=>fileURLToFilePath(ref));
             if (reactClientReferences) {
                 nestedClientBoundaries.push(...reactClientReferences);
             }
-            const reactServerReferences = (_contents_artifacts_filter__metadata_reactServerReferences = contents.artifacts.filter((a)=>a.type === 'js')[0].metadata.reactServerReferences) == null ? void 0 : _contents_artifacts_filter__metadata_reactServerReferences.map((ref)=>fileURLToFilePath(ref));
+            const reactServerReferences = (ref1 = contents.artifacts.filter((a)=>a.type === "js")[0].metadata.reactServerReferences) == null ? void 0 : ref1.map((ref)=>fileURLToFilePath(ref));
             if (reactServerReferences) {
                 nestedServerBoundaries.push(...reactServerReferences);
             }
             // Naive check to ensure the module runtime is not included in the server action bundle.
-            if (contents.src.includes('The experimental Metro feature')) {
-                throw new Error('Internal error: module runtime should not be included in server action bundles: ' + entryPoint);
+            if (contents.src.includes("The experimental Metro feature")) {
+                throw new Error("Internal error: module runtime should not be included in server action bundles: " + entryPoint);
             }
             const relativeName = createModuleId(entryPoint, {
                 platform,
-                environment: 'react-server'
+                environment: "react-server"
             });
-            const safeName = _path().default.basename(contents.artifacts.find((a)=>a.type === 'js').filename);
+            const safeName = _path().default.basename(contents.artifacts.find((a)=>a.type === "js").filename);
             const outputName = `_expo/rsc/${platform}/${safeName}`;
             // While we're here, export the router for the server to dynamically render RSC.
             files.set(outputName, {
-                targetDomain: 'server',
+                targetDomain: "server",
                 contents: wrapBundle(contents.src)
             });
             // Import relative to `dist/server/_expo/rsc/web/router.js`
@@ -190,7 +186,7 @@ function createServerComponentsMiddleware(projectRoot, { rscPath, instanceMetroO
         async function processEntryPoints(entryPoints, recursions = 0) {
             // Arbitrary recursion limit to prevent infinite loops.
             if (recursions > 10) {
-                throw new Error('Recursion limit exceeded while processing server boundaries');
+                throw new Error("Recursion limit exceeded while processing server boundaries");
             }
             for (const entryPoint of entryPoints){
                 await processEntryPoint(entryPoint);
@@ -202,45 +198,45 @@ function createServerComponentsMiddleware(projectRoot, { rscPath, instanceMetroO
             // Filter out values that have already been processed.
             uniqueNestedServerBoundaries = uniqueNestedServerBoundaries.filter((value)=>!processedEntryPoints.has(value));
             if (uniqueNestedServerBoundaries.length) {
-                debug('bundling nested server action boundaries', uniqueNestedServerBoundaries);
+                debug("bundling nested server action boundaries", uniqueNestedServerBoundaries);
                 return processEntryPoints(uniqueNestedServerBoundaries, recursions + 1);
             }
         }
         await processEntryPoints(uniqueEntryPoints);
         // Save the SSR manifest so we can perform more replacements in the server renderer and with server actions.
         files.set(`_expo/rsc/${platform}/action-manifest.js`, {
-            targetDomain: 'server',
-            contents: 'module.exports = ' + JSON.stringify(manifest)
+            targetDomain: "server",
+            contents: "module.exports = " + JSON.stringify(manifest)
         });
         return {
             manifest,
             clientBoundaries: nestedClientBoundaries
         };
     }
-    async function getExpoRouterClientReferencesAsync({ platform, domRoot }, files) {
-        var _contents_artifacts_filter__metadata_reactServerReferences, _contents_artifacts_filter__metadata_reactClientReferences;
+    async function getExpoRouterClientReferencesAsync({ platform , domRoot  }, files) {
+        var ref, ref1;
         const contents = await ssrLoadModuleArtifacts(routerModule, {
-            environment: 'react-server',
+            environment: "react-server",
             platform,
             modulesOnly: true,
             domRoot
         });
         // Extract the global CSS modules that are imported from the router.
         // These will be injected in the head of the HTML document for the website.
-        const cssModules = contents.artifacts.filter((a)=>a.type.startsWith('css'));
-        const reactServerReferences = (_contents_artifacts_filter__metadata_reactServerReferences = contents.artifacts.filter((a)=>a.type === 'js')[0].metadata.reactServerReferences) == null ? void 0 : _contents_artifacts_filter__metadata_reactServerReferences.map((ref)=>fileURLToFilePath(ref));
+        const cssModules = contents.artifacts.filter((a)=>a.type.startsWith("css"));
+        const reactServerReferences = (ref = contents.artifacts.filter((a)=>a.type === "js")[0].metadata.reactServerReferences) == null ? void 0 : ref.map((ref)=>fileURLToFilePath(ref));
         if (!reactServerReferences) {
-            throw new Error('Static server action references were not returned from the Metro SSR bundle for definedRouter');
+            throw new Error("Static server action references were not returned from the Metro SSR bundle for definedRouter");
         }
-        debug('React client boundaries:', reactServerReferences);
-        const reactClientReferences = (_contents_artifacts_filter__metadata_reactClientReferences = contents.artifacts.filter((a)=>a.type === 'js')[0].metadata.reactClientReferences) == null ? void 0 : _contents_artifacts_filter__metadata_reactClientReferences.map((ref)=>fileURLToFilePath(ref));
+        debug("React client boundaries:", reactServerReferences);
+        const reactClientReferences = (ref1 = contents.artifacts.filter((a)=>a.type === "js")[0].metadata.reactClientReferences) == null ? void 0 : ref1.map((ref)=>fileURLToFilePath(ref));
         if (!reactClientReferences) {
-            throw new Error('Static client references were not returned from the Metro SSR bundle for definedRouter');
+            throw new Error("Static client references were not returned from the Metro SSR bundle for definedRouter");
         }
-        debug('React client boundaries:', reactClientReferences);
+        debug("React client boundaries:", reactClientReferences);
         // While we're here, export the router for the server to dynamically render RSC.
         files.set(`_expo/rsc/${platform}/router.js`, {
-            targetDomain: 'server',
+            targetDomain: "server",
             contents: wrapBundle(contents.src)
         });
         return {
@@ -250,14 +246,14 @@ function createServerComponentsMiddleware(projectRoot, { rscPath, instanceMetroO
         };
     }
     const routerCache = new Map();
-    async function getExpoRouterRscEntriesGetterAsync({ platform }) {
+    async function getExpoRouterRscEntriesGetterAsync({ platform  }) {
         await ensureMemo();
         // We can only cache this if we're using the client router since it doesn't change or use HMR
         if (routerCache.has(platform) && useClientRouter) {
             return routerCache.get(platform);
         }
         const router = await ssrLoadModule(routerModule, {
-            environment: 'react-server',
+            environment: "react-server",
             modulesOnly: true,
             platform
         }, {
@@ -268,27 +264,27 @@ function createServerComponentsMiddleware(projectRoot, { rscPath, instanceMetroO
     }
     function getResolveClientEntry(context) {
         const serverRoot = getMetroServerRootMemo(projectRoot);
-        const { mode, minify = false, isExporting, baseUrl, routerRoot, asyncRoutes, preserveEnvVars, reactCompiler, lazy } = instanceMetroOptions;
+        const { mode , minify =false , isExporting , baseUrl , routerRoot , asyncRoutes , preserveEnvVars , reactCompiler , lazy ,  } = instanceMetroOptions;
         (0, _assert().default)(isExporting != null && baseUrl != null && mode != null && routerRoot != null && asyncRoutes != null, `The server must be started. (isExporting: ${isExporting}, baseUrl: ${baseUrl}, mode: ${mode}, routerRoot: ${routerRoot}, asyncRoutes: ${asyncRoutes})`);
         return (file, isServer)=>{
             if (isExporting) {
-                (0, _assert().default)(context.ssrManifest, 'SSR manifest must exist when exporting');
+                (0, _assert().default)(context.ssrManifest, "SSR manifest must exist when exporting");
                 const relativeFilePath = (0, _filePath.toPosixPath)(_path().default.relative(serverRoot, file));
                 (0, _assert().default)(context.ssrManifest.has(relativeFilePath), `SSR manifest is missing client boundary "${relativeFilePath}"`);
                 const chunk = context.ssrManifest.get(relativeFilePath);
                 return {
                     id: String(createModuleId(file, {
                         platform: context.platform,
-                        environment: 'client'
+                        environment: "client"
                     })),
                     chunks: chunk != null ? [
                         chunk
                     ] : []
                 };
             }
-            const environment = isServer ? 'react-server' : 'client';
+            const environment = isServer ? "react-server" : "client";
             const searchParams = (0, _metroOptions.createBundleUrlSearchParams)({
-                mainModuleName: '',
+                mainModuleName: "",
                 platform: context.platform,
                 mode,
                 minify,
@@ -307,17 +303,17 @@ function createServerComponentsMiddleware(projectRoot, { rscPath, instanceMetroO
                 modulesOnly: true,
                 runModule: false
             });
-            searchParams.set('resolver.clientboundary', String(true));
-            const clientReferenceUrl = new URL('http://a');
+            searchParams.set("resolver.clientboundary", String(true));
+            const clientReferenceUrl = new URL("http://a");
             // TICKLE: Handshake 1
-            searchParams.set('xRSC', '1');
+            searchParams.set("xRSC", "1");
             clientReferenceUrl.search = searchParams.toString();
-            const filePath = file.startsWith('file://') ? fileURLToFilePath(file) : file;
-            const relativeFilePath = _path().default.relative(serverRoot, filePath);
-            clientReferenceUrl.pathname = relativeFilePath;
+            const filePath = file.startsWith("file://") ? fileURLToFilePath(file) : file;
+            const relativeFilePath1 = _path().default.relative(serverRoot, filePath);
+            clientReferenceUrl.pathname = relativeFilePath1;
             // Ensure url.pathname ends with '.bundle'
-            if (!clientReferenceUrl.pathname.endsWith('.bundle')) {
-                clientReferenceUrl.pathname += '.bundle';
+            if (!clientReferenceUrl.pathname.endsWith(".bundle")) {
+                clientReferenceUrl.pathname += ".bundle";
             }
             // Return relative URLs to help Android fetch from wherever it was loaded from since it doesn't support localhost.
             const chunkName = clientReferenceUrl.pathname + clientReferenceUrl.search;
@@ -336,9 +332,9 @@ function createServerComponentsMiddleware(projectRoot, { rscPath, instanceMetroO
     let ensurePromise = null;
     async function ensureSSRReady() {
         // TODO: Extract CSS Modules / Assets from the bundler process
-        const runtime = await ssrLoadModule('metro-runtime/src/modules/empty-module.js', {
-            environment: 'react-server',
-            platform: 'web'
+        const runtime = await ssrLoadModule("metro-runtime/src/modules/empty-module.js", {
+            environment: "react-server",
+            platform: "web"
         });
         return runtime;
     }
@@ -353,8 +349,8 @@ function createServerComponentsMiddleware(projectRoot, { rscPath, instanceMetroO
             return rscRendererCache.get(platform);
         }
         // TODO: Extract CSS Modules / Assets from the bundler process
-        const renderer = await ssrLoadModule('expo-router/build/rsc/rsc-renderer', {
-            environment: 'react-server',
+        const renderer = await ssrLoadModule("expo-router/build/rsc/rsc-renderer", {
+            environment: "react-server",
             platform
         });
         rscRendererCache.set(platform, renderer);
@@ -370,14 +366,14 @@ function createServerComponentsMiddleware(projectRoot, { rscPath, instanceMetroO
         rscRenderContext.set(platform, context);
         return context;
     }
-    async function renderRscToReadableStream({ input, headers, method, platform, body, engine, contentType, ssrManifest, decodedBody }, isExporting = instanceMetroOptions.isExporting) {
-        (0, _assert().default)(isExporting != null, 'The server must be started before calling renderRscToReadableStream.');
-        if (method === 'POST') {
-            (0, _assert().default)(body, 'Server request must be provided when method is POST (server actions)');
+    async function renderRscToReadableStream({ input , headers , method , platform , body , engine , contentType , ssrManifest , decodedBody  }, isExporting = instanceMetroOptions.isExporting) {
+        (0, _assert().default)(isExporting != null, "The server must be started before calling renderRscToReadableStream.");
+        if (method === "POST") {
+            (0, _assert().default)(body, "Server request must be provided when method is POST (server actions)");
         }
         const context = getRscRenderContext(platform);
-        context['__expo_requestHeaders'] = headers;
-        const { renderRsc } = await getRscRendererAsync(platform);
+        context["__expo_requestHeaders"] = headers;
+        const { renderRsc  } = await getRscRendererAsync(platform);
         return renderRsc({
             body,
             decodedBody,
@@ -397,7 +393,7 @@ function createServerComponentsMiddleware(projectRoot, { rscPath, instanceMetroO
             }),
             async loadServerModuleRsc (urlFragment) {
                 const serverRoot = getMetroServerRootMemo(projectRoot);
-                debug('[SSR] loadServerModuleRsc:', urlFragment);
+                debug("[SSR] loadServerModuleRsc:", urlFragment);
                 const options = (0, _metroOptions.getMetroOptionsFromUrl)(urlFragment);
                 return ssrLoadModule(_path().default.join(serverRoot, options.mainModuleName), options, {
                     hot: true
@@ -409,39 +405,39 @@ function createServerComponentsMiddleware(projectRoot, { rscPath, instanceMetroO
         // Get the static client boundaries (no dead code elimination allowed) for the production export.
         getExpoRouterClientReferencesAsync,
         exportServerActionsAsync,
-        async exportRoutesAsync ({ platform, ssrManifest }, files) {
+        async exportRoutesAsync ({ platform , ssrManifest  }, files) {
             // TODO: When we add web SSR support, we need to extract CSS Modules / Assets from the bundler process to prevent FLOUC.
-            const { getBuildConfig } = (await getExpoRouterRscEntriesGetterAsync({
+            const { getBuildConfig  } = (await getExpoRouterRscEntriesGetterAsync({
                 platform
             })).default;
             // Get all the routes to render.
             const buildConfig = await getBuildConfig(async ()=>// TODO: Rework prefetching code to use Metro runtime.
                 []);
-            await Promise.all(Array.from(buildConfig).map(async ({ entries })=>{
-                for (const { input, isStatic } of entries || []){
+            await Promise.all(Array.from(buildConfig).map(async ({ entries  })=>{
+                for (const { input , isStatic  } of entries || []){
                     if (!isStatic) {
-                        debug('Skipping static export for route', {
+                        debug("Skipping static export for route", {
                             input
                         });
                         continue;
                     }
-                    const destRscFile = _path().default.join('_flight', platform, encodeInput(input));
+                    const destRscFile = _path().default.join("_flight", platform, encodeInput(input));
                     const pipe = await renderRscToReadableStream({
                         input,
-                        method: 'GET',
+                        method: "GET",
                         platform,
                         headers: new Headers(),
                         ssrManifest
                     }, true);
                     const rsc = await (0, _stream.streamToStringAsync)(pipe);
-                    debug('RSC Payload', {
+                    debug("RSC Payload", {
                         platform,
                         input,
                         rsc
                     });
                     files.set(destRscFile, {
                         contents: rsc,
-                        targetDomain: 'client',
+                        targetDomain: "client",
                         rscId: input
                     });
                 }
@@ -462,32 +458,32 @@ const getFullUrl = (url)=>{
     try {
         return new URL(url);
     } catch  {
-        return new URL(url, 'http://localhost:0');
+        return new URL(url, "http://localhost:0");
     }
 };
 const fileURLToFilePath = (fileURL)=>{
     return _url().default.fileURLToPath(fileURL);
 };
 const encodeInput = (input)=>{
-    if (input === '') {
-        return 'index.txt';
+    if (input === "") {
+        return "index.txt";
     }
-    if (input === 'index') {
-        throw new Error('Input should not be `index`');
+    if (input === "index") {
+        throw new Error("Input should not be `index`");
     }
-    if (input.startsWith('/')) {
-        throw new Error('Input should not start with `/`');
+    if (input.startsWith("/")) {
+        throw new Error("Input should not start with `/`");
     }
-    if (input.endsWith('/')) {
-        throw new Error('Input should not end with `/`');
+    if (input.endsWith("/")) {
+        throw new Error("Input should not end with `/`");
     }
-    return input + '.txt';
+    return input + ".txt";
 };
 function wrapBundle(str) {
     // Skip the metro runtime so debugging is a bit easier.
     // Replace the __r() call with an export statement.
     // Use gm to apply to the last require line. This is needed when the bundle has side-effects.
-    return str.replace(/^(__r\(.*\);)$/gm, 'module.exports = $1');
+    return str.replace(/^(__r\(.*\);)$/gm, "module.exports = $1");
 }
 
 //# sourceMappingURL=createServerComponentsMiddleware.js.map