@depup/expo__cli 55.0.16-depup.0

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

@@ -0,0 +1,229 @@
+/**
+ * Copyright © 2022 650 Industries.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createRouteHandlerMiddleware", {
+    enumerable: true,
+    get: function() {
+        return createRouteHandlerMiddleware;
+    }
+});
+function _http() {
+    const data = require("expo-server/adapter/http");
+    _http = function() {
+        return data;
+    };
+    return data;
+}
+function _private() {
+    const data = require("expo-server/private");
+    _private = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interop_require_default(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+function _resolvefrom() {
+    const data = /*#__PURE__*/ _interop_require_default(require("resolve-from"));
+    _resolvefrom = function() {
+        return data;
+    };
+    return data;
+}
+const _fetchRouterManifest = require("./fetchRouterManifest");
+const _metroErrorInterface = require("./metroErrorInterface");
+const _router = require("./router");
+const _errors = require("../../../utils/errors");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require('debug')('expo:start:server:metro');
+function createRouteHandlerMiddleware(projectRoot, options) {
+    if (!_resolvefrom().default.silent(projectRoot, 'expo-router')) {
+        throw new _errors.CommandError(`static and server rendering requires the expo-router package to be installed in your project. Either install the expo-router package or change 'web.output' to 'single' in your app.json.`);
+    }
+    return (0, _http().createRequestHandler)({
+        build: '',
+        isDevelopment: true
+    }, {
+        async getRoutesManifest () {
+            var _exp_extra_router, _exp_extra;
+            const manifest = await (0, _fetchRouterManifest.fetchManifest)(projectRoot, options);
+            debug('manifest', manifest);
+            // TODO(@hassankhan): Invert the conditionals for an early return if no manifest if found
+            if (manifest && options.rsc && !manifest.apiRoutes.find((route)=>route.page.startsWith(options.rsc.path))) {
+                // Insert the route before any catch-all routes that might match the RSC path.
+                manifest.apiRoutes.unshift({
+                    file: require.resolve('@expo/cli/static/template/[...rsc]+api.ts'),
+                    page: `${options.rsc.path}/[...rsc]`,
+                    namedRegex: new RegExp(`^${options.rsc.path}(?:/(?<rsc>.+?))?(?:/)?$`),
+                    routeKeys: {
+                        rsc: 'rsc'
+                    }
+                });
+            }
+            const { exp } = options.config;
+            if (manifest && ((_exp_extra = exp.extra) == null ? void 0 : (_exp_extra_router = _exp_extra.router) == null ? void 0 : _exp_extra_router.unstable_useServerDataLoaders) === true) {
+                // In development, set `loader` property on all HTML routes. We can't know which routes
+                // have loaders without bundling via Metro to detect exports. In production, this is
+                // populated by `exportStaticAsync.ts` after bundling.
+                // At runtime, `getLoaderData()` returns a 404 response if no loader exists.
+                for (const route of manifest.htmlRoutes){
+                    route.loader = `_expo/loaders${route.page}.js`;
+                }
+            }
+            // NOTE: no app dir if null
+            // TODO: Redirect to 404 page
+            return manifest ?? {
+                // Support the onboarding screen if there's no manifest
+                htmlRoutes: [
+                    {
+                        file: 'index.js',
+                        page: '/index',
+                        routeKeys: {},
+                        namedRegex: /^\/(?:index)?\/?$/i
+                    }
+                ],
+                apiRoutes: [],
+                notFoundRoutes: [],
+                redirects: [],
+                rewrites: []
+            };
+        },
+        async getHtml (request, route) {
+            try {
+                var _exp_web, _exp_extra_router, _exp_extra;
+                const { exp } = options.config;
+                const isSSREnabled = ((_exp_web = exp.web) == null ? void 0 : _exp_web.output) === 'server' && ((_exp_extra = exp.extra) == null ? void 0 : (_exp_extra_router = _exp_extra.router) == null ? void 0 : _exp_extra_router.unstable_useServerRendering) === true;
+                const { content } = await options.getStaticPageAsync(request.url, route, isSSREnabled ? new (_private()).ImmutableRequest(request) : undefined);
+                return content;
+            } catch (error) {
+                // Forward the Metro server response as-is. It won't be pretty, but at least it will be accurate.
+                try {
+                    return new Response(await (0, _metroErrorInterface.getErrorOverlayHtmlAsync)({
+                        error,
+                        projectRoot,
+                        routerRoot: options.routerRoot
+                    }), {
+                        status: 500,
+                        headers: {
+                            'Content-Type': 'text/html'
+                        }
+                    });
+                } catch (staticError) {
+                    debug('Failed to render static error overlay:', staticError);
+                    // Fallback error for when Expo Router is misconfigured in the project.
+                    return new Response('<span><h3>Internal Error:</h3><b>Project is not setup correctly for static rendering (check terminal for more info):</b><br/>' + error.message + '<br/><br/>' + staticError.message + '</span>', {
+                        status: 500,
+                        headers: {
+                            'Content-Type': 'text/html'
+                        }
+                    });
+                }
+            }
+        },
+        async handleRouteError (error) {
+            // NOTE(@kitten): ExpoError is currently not exposed by expo-server just yet
+            if (error && typeof error === 'object' && error.name === 'ExpoError') {
+                // TODO(@krystofwoldrich): Can we show code snippet of the handler?
+                // NOTE(@krystofwoldrich): Removing stack since to avoid confusion. The error is not in the server code.
+                delete error.stack;
+            }
+            const htmlServerError = await (0, _metroErrorInterface.getErrorOverlayHtmlAsync)({
+                error,
+                projectRoot,
+                routerRoot: options.routerRoot
+            });
+            return new Response(htmlServerError, {
+                status: 500,
+                headers: {
+                    'Content-Type': 'text/html'
+                }
+            });
+        },
+        async getApiRoute (route) {
+            var _exp_web;
+            // We check if RSC is enabled before the warning check, as `web.output` could be set to
+            // `single`
+            if (options.rsc && route.page.startsWith(options.rsc.path)) {
+                return options.rsc.handler;
+            }
+            const { exp } = options.config;
+            if (((_exp_web = exp.web) == null ? void 0 : _exp_web.output) !== 'server') {
+                (0, _router.warnInvalidWebOutput)();
+            }
+            // TODO(@kitten): Unify with MetroBundlerDevServer#exportExpoRouterApiRoutesAsync
+            const resolvedFunctionPath = _path().default.isAbsolute(route.file) ? route.file : _path().default.join(options.appDir, route.file);
+            try {
+                debug(`Bundling API route at: ${resolvedFunctionPath}`);
+                return await options.bundleApiRoute(resolvedFunctionPath);
+            } catch (error) {
+                return new Response('Failed to load API Route: ' + resolvedFunctionPath + '\n\n' + error.message, {
+                    status: 500,
+                    headers: {
+                        'Content-Type': 'text/html'
+                    }
+                });
+            }
+        },
+        async getMiddleware (route) {
+            var _exp_web;
+            const { exp } = options.config;
+            if (!options.unstable_useServerMiddleware) {
+                return {
+                    default: ()=>{
+                        throw new _errors.CommandError('Server middleware is not enabled. Add unstable_useServerMiddleware: true to your `expo-router` plugin config.');
+                    }
+                };
+            }
+            if (((_exp_web = exp.web) == null ? void 0 : _exp_web.output) !== 'server') {
+                (0, _router.warnInvalidMiddlewareOutput)();
+                return {
+                    default: ()=>{
+                        console.warn('Server middleware is only supported when web.output is set to "server" in your app config');
+                    }
+                };
+            }
+            // TODO(@kitten): Unify with MetroBundlerDevServer#exportMiddlewareAsync
+            const resolvedFunctionPath = _path().default.isAbsolute(route.file) ? route.file : _path().default.join(options.appDir, route.file);
+            try {
+                var _middlewareModule_unstable_settings;
+                debug(`Bundling middleware at: ${resolvedFunctionPath}`);
+                const middlewareModule = await options.bundleApiRoute(resolvedFunctionPath);
+                if ((_middlewareModule_unstable_settings = middlewareModule.unstable_settings) == null ? void 0 : _middlewareModule_unstable_settings.matcher) {
+                    var _middlewareModule_unstable_settings1;
+                    (0, _router.warnInvalidMiddlewareMatcherSettings)((_middlewareModule_unstable_settings1 = middlewareModule.unstable_settings) == null ? void 0 : _middlewareModule_unstable_settings1.matcher);
+                }
+                return middlewareModule;
+            } catch (error) {
+                return new Response('Failed to load middleware: ' + resolvedFunctionPath + '\n\n' + error.message, {
+                    status: 500,
+                    headers: {
+                        'Content-Type': 'text/html'
+                    }
+                });
+            }
+        },
+        async getLoaderData (request, route) {
+            const response = await options.executeLoaderAsync(route, new (_private()).ImmutableRequest(request));
+            return response ?? new Response(null, {
+                status: 404
+            });
+        }
+    });
+}
+
+//# sourceMappingURL=createServerRouteMiddleware.js.map

package/build/src/start/server/metro/createServerRouteMiddleware.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/start/server/metro/createServerRouteMiddleware.ts"],"sourcesContent":["/**\n * Copyright © 2022 650 Industries.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nimport type { ProjectConfig } from '@expo/config';\nimport type { MiddlewareSettings } from 'expo-server';\nimport { createRequestHandler } from 'expo-server/adapter/http';\nimport { ImmutableRequest, type RouteInfo } from 'expo-server/private';\nimport path from 'path';\nimport resolveFrom from 'resolve-from';\n\nimport { fetchManifest } from './fetchRouterManifest';\nimport { getErrorOverlayHtmlAsync } from './metroErrorInterface';\nimport {\n  warnInvalidWebOutput,\n  warnInvalidMiddlewareOutput,\n  warnInvalidMiddlewareMatcherSettings,\n} from './router';\nimport { CommandError } from '../../../utils/errors';\n\nconst debug = require('debug')('expo:start:server:metro') as typeof console.log;\n\nexport function createRouteHandlerMiddleware(\n  projectRoot: string,\n  options: {\n    appDir: string;\n    routerRoot: string;\n    getStaticPageAsync: (\n      pathname: string,\n      route: RouteInfo<RegExp>,\n      request?: ImmutableRequest\n    ) => Promise<{ content: string }>;\n    bundleApiRoute: (\n      functionFilePath: string\n    ) => Promise<null | Record<string, Function> | Response>;\n    executeLoaderAsync: (\n      route: RouteInfo<RegExp>,\n      request: ImmutableRequest\n    ) => Promise<Response | undefined>;\n    config: ProjectConfig;\n    headers: Record<string, string | string[]>;\n    rsc?: {\n      path: string;\n      handler: {\n        GET: (req: Request) => Promise<Response>;\n        POST: (req: Request) => Promise<Response>;\n      };\n    };\n  } & import('@expo/router-server/build/routes-manifest').Options\n) {\n  if (!resolveFrom.silent(projectRoot, 'expo-router')) {\n    throw new CommandError(\n      `static and server rendering requires the expo-router package to be installed in your project. Either install the expo-router package or change 'web.output' to 'single' in your app.json.`\n    );\n  }\n\n  return createRequestHandler(\n    { build: '', isDevelopment: true },\n    {\n      async getRoutesManifest() {\n        const manifest = await fetchManifest(projectRoot, options);\n        debug('manifest', manifest);\n\n        // TODO(@hassankhan): Invert the conditionals for an early return if no manifest if found\n\n        if (\n          manifest &&\n          options.rsc &&\n          !manifest.apiRoutes.find((route) => route.page.startsWith(options.rsc!.path))\n        ) {\n          // Insert the route before any catch-all routes that might match the RSC path.\n          manifest.apiRoutes.unshift({\n            file: require.resolve('@expo/cli/static/template/[...rsc]+api.ts'),\n            page: `${options.rsc.path}/[...rsc]`,\n            namedRegex: new RegExp(`^${options.rsc.path}(?:/(?<rsc>.+?))?(?:/)?$`),\n            routeKeys: { rsc: 'rsc' },\n          });\n        }\n\n        const { exp } = options.config;\n\n        if (manifest && exp.extra?.router?.unstable_useServerDataLoaders === true) {\n          // In development, set `loader` property on all HTML routes. We can't know which routes\n          // have loaders without bundling via Metro to detect exports. In production, this is\n          // populated by `exportStaticAsync.ts` after bundling.\n          // At runtime, `getLoaderData()` returns a 404 response if no loader exists.\n          for (const route of manifest.htmlRoutes) {\n            route.loader = `_expo/loaders${route.page}.js`;\n          }\n        }\n\n        // NOTE: no app dir if null\n        // TODO: Redirect to 404 page\n        return (\n          manifest ?? {\n            // Support the onboarding screen if there's no manifest\n            htmlRoutes: [\n              {\n                file: 'index.js',\n                page: '/index',\n                routeKeys: {},\n                namedRegex: /^\\/(?:index)?\\/?$/i,\n              },\n            ],\n            apiRoutes: [],\n            notFoundRoutes: [],\n            redirects: [],\n            rewrites: [],\n          }\n        );\n      },\n      async getHtml(request, route) {\n        try {\n          const { exp } = options.config;\n          const isSSREnabled =\n            exp.web?.output === 'server' && exp.extra?.router?.unstable_useServerRendering === true;\n\n          const { content } = await options.getStaticPageAsync(\n            request.url,\n            route,\n            isSSREnabled ? new ImmutableRequest(request) : undefined\n          );\n          return content;\n        } catch (error: any) {\n          // Forward the Metro server response as-is. It won't be pretty, but at least it will be accurate.\n\n          try {\n            return new Response(\n              await getErrorOverlayHtmlAsync({\n                error,\n                projectRoot,\n                routerRoot: options.routerRoot,\n              }),\n              {\n                status: 500,\n                headers: {\n                  'Content-Type': 'text/html',\n                },\n              }\n            );\n          } catch (staticError: any) {\n            debug('Failed to render static error overlay:', staticError);\n            // Fallback error for when Expo Router is misconfigured in the project.\n            return new Response(\n              '<span><h3>Internal Error:</h3><b>Project is not setup correctly for static rendering (check terminal for more info):</b><br/>' +\n                error.message +\n                '<br/><br/>' +\n                staticError.message +\n                '</span>',\n              {\n                status: 500,\n                headers: {\n                  'Content-Type': 'text/html',\n                },\n              }\n            );\n          }\n        }\n      },\n      async handleRouteError(error) {\n        // NOTE(@kitten): ExpoError is currently not exposed by expo-server just yet\n        if (error && typeof error === 'object' && error.name === 'ExpoError') {\n          // TODO(@krystofwoldrich): Can we show code snippet of the handler?\n          // NOTE(@krystofwoldrich): Removing stack since to avoid confusion. The error is not in the server code.\n          delete error.stack;\n        }\n\n        const htmlServerError = await getErrorOverlayHtmlAsync({\n          error,\n          projectRoot,\n          routerRoot: options.routerRoot!,\n        });\n\n        return new Response(htmlServerError, {\n          status: 500,\n          headers: {\n            'Content-Type': 'text/html',\n          },\n        });\n      },\n      async getApiRoute(route) {\n        // We check if RSC is enabled before the warning check, as `web.output` could be set to\n        // `single`\n        if (options.rsc && route.page.startsWith(options.rsc.path)) {\n          return options.rsc.handler;\n        }\n\n        const { exp } = options.config;\n        if (exp.web?.output !== 'server') {\n          warnInvalidWebOutput();\n        }\n\n        // TODO(@kitten): Unify with MetroBundlerDevServer#exportExpoRouterApiRoutesAsync\n        const resolvedFunctionPath = path.isAbsolute(route.file)\n          ? route.file\n          : path.join(options.appDir, route.file);\n        try {\n          debug(`Bundling API route at: ${resolvedFunctionPath}`);\n          return await options.bundleApiRoute(resolvedFunctionPath!);\n        } catch (error: any) {\n          return new Response(\n            'Failed to load API Route: ' + resolvedFunctionPath + '\\n\\n' + error.message,\n            {\n              status: 500,\n              headers: {\n                'Content-Type': 'text/html',\n              },\n            }\n          );\n        }\n      },\n      async getMiddleware(route) {\n        const { exp } = options.config;\n\n        if (!options.unstable_useServerMiddleware) {\n          return {\n            default: () => {\n              throw new CommandError(\n                'Server middleware is not enabled. Add unstable_useServerMiddleware: true to your `expo-router` plugin config.'\n              );\n            },\n          };\n        }\n\n        if (exp.web?.output !== 'server') {\n          warnInvalidMiddlewareOutput();\n          return {\n            default: () => {\n              console.warn(\n                'Server middleware is only supported when web.output is set to \"server\" in your app config'\n              );\n            },\n          };\n        }\n\n        // TODO(@kitten): Unify with MetroBundlerDevServer#exportMiddlewareAsync\n        const resolvedFunctionPath = path.isAbsolute(route.file)\n          ? route.file\n          : path.join(options.appDir, route.file);\n        try {\n          debug(`Bundling middleware at: ${resolvedFunctionPath}`);\n          const middlewareModule = (await options.bundleApiRoute(resolvedFunctionPath!)) as any;\n\n          if ((middlewareModule.unstable_settings as MiddlewareSettings)?.matcher) {\n            warnInvalidMiddlewareMatcherSettings(middlewareModule.unstable_settings?.matcher);\n          }\n\n          return middlewareModule;\n        } catch (error: any) {\n          return new Response(\n            'Failed to load middleware: ' + resolvedFunctionPath + '\\n\\n' + error.message,\n            {\n              status: 500,\n              headers: {\n                'Content-Type': 'text/html',\n              },\n            }\n          );\n        }\n      },\n      async getLoaderData(request, route) {\n        const response = await options.executeLoaderAsync(route, new ImmutableRequest(request));\n        return response ?? new Response(null, { status: 404 });\n      },\n    }\n  );\n}\n"],"names":["createRouteHandlerMiddleware","debug","require","projectRoot","options","resolveFrom","silent","CommandError","createRequestHandler","build","isDevelopment","getRoutesManifest","exp","manifest","fetchManifest","rsc","apiRoutes","find","route","page","startsWith","path","unshift","file","resolve","namedRegex","RegExp","routeKeys","config","extra","router","unstable_useServerDataLoaders","htmlRoutes","loader","notFoundRoutes","redirects","rewrites","getHtml","request","isSSREnabled","web","output","unstable_useServerRendering","content","getStaticPageAsync","url","ImmutableRequest","undefined","error","Response","getErrorOverlayHtmlAsync","routerRoot","status","headers","staticError","message","handleRouteError","name","stack","htmlServerError","getApiRoute","handler","warnInvalidWebOutput","resolvedFunctionPath","isAbsolute","join","appDir","bundleApiRoute","getMiddleware","unstable_useServerMiddleware","default","warnInvalidMiddlewareOutput","console","warn","middlewareModule","unstable_settings","matcher","warnInvalidMiddlewareMatcherSettings","getLoaderData","response","executeLoaderAsync"],"mappings":"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"}

package/build/src/start/server/metro/debugging/AtlasPrerequisite.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AtlasPrerequisite", {
+    enumerable: true,
+    get: function() {
+        return AtlasPrerequisite;
+    }
+});
+const _Prerequisite = require("../../../doctor/Prerequisite");
+const _ensureDependenciesAsync = require("../../../doctor/dependencies/ensureDependenciesAsync");
+class AtlasPrerequisite extends _Prerequisite.ProjectPrerequisite {
+    async assertImplementation({ exp } = {}) {
+        await this.ensureAtlasInstalled({
+            exp
+        });
+        return true;
+    }
+    async bootstrapAsync({ exp } = {}) {
+        await this.ensureAtlasInstalled({
+            exp,
+            skipPrompt: true,
+            isProjectMutable: true
+        });
+    }
+    async ensureAtlasInstalled(options = {}) {
+        try {
+            return await (0, _ensureDependenciesAsync.ensureDependenciesAsync)(this.projectRoot, {
+                ...options,
+                installMessage: 'Expo Atlas is required to gather bundle information, but it is not installed in this project.',
+                warningMessage: 'Expo Atlas is not installed in this project, unable to gather bundle information.',
+                requiredPackages: [
+                    {
+                        version: '^0.4.0',
+                        pkg: 'expo-atlas',
+                        file: 'expo-atlas/package.json',
+                        dev: true
+                    }
+                ]
+            });
+        } catch (error) {
+            this.resetAssertion({});
+            throw error;
+        }
+    }
+}
+
+//# sourceMappingURL=AtlasPrerequisite.js.map

package/build/src/start/server/metro/debugging/AtlasPrerequisite.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/start/server/metro/debugging/AtlasPrerequisite.ts"],"sourcesContent":["import { ProjectPrerequisite } from '../../../doctor/Prerequisite';\nimport {\n  type EnsureDependenciesOptions,\n  ensureDependenciesAsync,\n} from '../../../doctor/dependencies/ensureDependenciesAsync';\n\nexport class AtlasPrerequisite extends ProjectPrerequisite<\n  boolean,\n  Pick<EnsureDependenciesOptions, 'exp'>\n> {\n  async assertImplementation({ exp }: Pick<EnsureDependenciesOptions, 'exp'> = {}) {\n    await this.ensureAtlasInstalled({ exp });\n    return true;\n  }\n\n  async bootstrapAsync({ exp }: Pick<EnsureDependenciesOptions, 'exp'> = {}) {\n    await this.ensureAtlasInstalled({ exp, skipPrompt: true, isProjectMutable: true });\n  }\n\n  private async ensureAtlasInstalled(options: Partial<EnsureDependenciesOptions> = {}) {\n    try {\n      return await ensureDependenciesAsync(this.projectRoot, {\n        ...options,\n        installMessage:\n          'Expo Atlas is required to gather bundle information, but it is not installed in this project.',\n        warningMessage:\n          'Expo Atlas is not installed in this project, unable to gather bundle information.',\n        requiredPackages: [\n          { version: '^0.4.0', pkg: 'expo-atlas', file: 'expo-atlas/package.json', dev: true },\n        ],\n      });\n    } catch (error) {\n      this.resetAssertion({});\n      throw error;\n    }\n  }\n}\n"],"names":["AtlasPrerequisite","ProjectPrerequisite","assertImplementation","exp","ensureAtlasInstalled","bootstrapAsync","skipPrompt","isProjectMutable","options","ensureDependenciesAsync","projectRoot","installMessage","warningMessage","requiredPackages","version","pkg","file","dev","error","resetAssertion"],"mappings":";;;;+BAMaA;;;eAAAA;;;8BANuB;yCAI7B;AAEA,MAAMA,0BAA0BC,iCAAmB;IAIxD,MAAMC,qBAAqB,EAAEC,GAAG,EAA0C,GAAG,CAAC,CAAC,EAAE;QAC/E,MAAM,IAAI,CAACC,oBAAoB,CAAC;YAAED;QAAI;QACtC,OAAO;IACT;IAEA,MAAME,eAAe,EAAEF,GAAG,EAA0C,GAAG,CAAC,CAAC,EAAE;QACzE,MAAM,IAAI,CAACC,oBAAoB,CAAC;YAAED;YAAKG,YAAY;YAAMC,kBAAkB;QAAK;IAClF;IAEA,MAAcH,qBAAqBI,UAA8C,CAAC,CAAC,EAAE;QACnF,IAAI;YACF,OAAO,MAAMC,IAAAA,gDAAuB,EAAC,IAAI,CAACC,WAAW,EAAE;gBACrD,GAAGF,OAAO;gBACVG,gBACE;gBACFC,gBACE;gBACFC,kBAAkB;oBAChB;wBAAEC,SAAS;wBAAUC,KAAK;wBAAcC,MAAM;wBAA2BC,KAAK;oBAAK;iBACpF;YACH;QACF,EAAE,OAAOC,OAAO;YACd,IAAI,CAACC,cAAc,CAAC,CAAC;YACrB,MAAMD;QACR;IACF;AACF"}

package/build/src/start/server/metro/debugging/MessageHandler.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MessageHandler", {
+    enumerable: true,
+    get: function() {
+        return MessageHandler;
+    }
+});
+class MessageHandler {
+    constructor(connection){
+        this.page = connection.page;
+        this.device = connection.device;
+        this.debugger = connection.debugger;
+    }
+    /** Determine if this middleware should be enabled or disabled, based on the page capabilities */ isEnabled() {
+        return true;
+    }
+    /** Send a message directly to the device */ sendToDevice(message) {
+        this.device.sendMessage(message);
+        return true;
+    }
+    /** Send a message directly to the debugger */ sendToDebugger(message) {
+        this.debugger.sendMessage(message);
+        return true;
+    }
+}
+
+//# sourceMappingURL=MessageHandler.js.map

package/build/src/start/server/metro/debugging/MessageHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/start/server/metro/debugging/MessageHandler.ts"],"sourcesContent":["import type {\n  Connection,\n  DebuggerMetadata,\n  DebuggerRequest,\n  DebuggerResponse,\n  DeviceMetadata,\n  DeviceRequest,\n  DeviceResponse,\n  Page,\n} from './types';\n\ntype BaseMessage = Parameters<DeviceMetadata['sendMessage']>[0];\n\nexport abstract class MessageHandler {\n  protected page: Page;\n  protected device: DeviceMetadata;\n  protected debugger: DebuggerMetadata;\n\n  constructor(connection: Connection) {\n    this.page = connection.page;\n    this.device = connection.device;\n    this.debugger = connection.debugger;\n  }\n\n  /** Determine if this middleware should be enabled or disabled, based on the page capabilities */\n  isEnabled(): boolean {\n    return true;\n  }\n\n  /** Send a message directly to the device */\n  sendToDevice<T = DeviceResponse | DebuggerResponse>(message: Readonly<T>): true {\n    this.device.sendMessage(message as BaseMessage);\n    return true;\n  }\n\n  /** Send a message directly to the debugger */\n  sendToDebugger<T = DeviceResponse | DebuggerResponse>(message: Readonly<T>): true {\n    this.debugger.sendMessage(message as BaseMessage);\n    return true;\n  }\n\n  /**\n   * Intercept a message coming from the device, modify or respond to it through `this._sendMessageToDevice`.\n   * Return `true` if the message was handled, this will stop the message propagation.\n   */\n  handleDeviceMessage?(message: DeviceRequest | DeviceResponse): boolean;\n\n  /**\n   * Intercept a message coming from the debugger, modify or respond to it through `socket.send`.\n   * Return `true` if the message was handled, this will stop the message propagation.\n   */\n  handleDebuggerMessage?(message: DebuggerRequest | DebuggerResponse): boolean;\n}\n"],"names":["MessageHandler","constructor","connection","page","device","debugger","isEnabled","sendToDevice","message","sendMessage","sendToDebugger"],"mappings":";;;;+BAasBA;;;eAAAA;;;AAAf,MAAeA;IAKpBC,YAAYC,UAAsB,CAAE;QAClC,IAAI,CAACC,IAAI,GAAGD,WAAWC,IAAI;QAC3B,IAAI,CAACC,MAAM,GAAGF,WAAWE,MAAM;QAC/B,IAAI,CAACC,QAAQ,GAAGH,WAAWG,QAAQ;IACrC;IAEA,+FAA+F,GAC/FC,YAAqB;QACnB,OAAO;IACT;IAEA,0CAA0C,GAC1CC,aAAoDC,OAAoB,EAAQ;QAC9E,IAAI,CAACJ,MAAM,CAACK,WAAW,CAACD;QACxB,OAAO;IACT;IAEA,4CAA4C,GAC5CE,eAAsDF,OAAoB,EAAQ;QAChF,IAAI,CAACH,QAAQ,CAACI,WAAW,CAACD;QAC1B,OAAO;IACT;AAaF"}

package/build/src/start/server/metro/debugging/attachAtlas.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    attachAtlasAsync: function() {
+        return attachAtlasAsync;
+    },
+    waitUntilAtlasExportIsReadyAsync: function() {
+        return waitUntilAtlasExportIsReadyAsync;
+    }
+});
+const _AtlasPrerequisite = require("./AtlasPrerequisite");
+const _env = require("../../../../utils/env");
+const debug = require('debug')('expo:metro:debugging:attachAtlas');
+async function attachAtlasAsync(options) {
+    if (!_env.env.EXPO_ATLAS) {
+        return;
+    }
+    debug('Atlas is enabled, initializing for this project...');
+    await new _AtlasPrerequisite.AtlasPrerequisite(options.projectRoot).bootstrapAsync({
+        exp: options.exp
+    });
+    return !options.isExporting ? attachAtlasToDevServer(options) : await attachAtlasToExport(options);
+}
+/**
+ * Attach Atlas to the Metro bundler for development mode.
+ * This includes attaching to Metro's middleware stack to host the Atlas UI.
+ */ function attachAtlasToDevServer(options) {
+    if (!options.middleware) {
+        throw new Error('Expected middleware to be provided for Atlas when running in development mode');
+    }
+    const atlas = importAtlasForDev(options.projectRoot);
+    if (!atlas) {
+        return debug('Atlas is not installed in the project, skipping initialization');
+    }
+    // TODO(@kitten): Atlas' typings don't match @expo/metro yet
+    const instance = atlas.createExpoAtlasMiddleware(options.metroConfig);
+    options.middleware.use('/_expo/atlas', instance.middleware);
+    debug('Attached Atlas middleware for development on: /_expo/atlas');
+    return instance;
+}
+function importAtlasForDev(projectRoot) {
+    try {
+        return require(require.resolve('expo-atlas/cli', {
+            paths: [
+                projectRoot
+            ]
+        }));
+    } catch (error) {
+        debug('Failed to load Atlas from project:', error);
+        return null;
+    }
+}
+/**
+ * Attach Atlas to the Metro bundler for exporting mode.
+ * This only includes attaching the custom serializer to the Metro config.
+ */ async function attachAtlasToExport(options) {
+    const atlas = importAtlasForExport(options.projectRoot);
+    if (!atlas) {
+        return debug('Atlas is not installed in the project, skipping initialization');
+    }
+    if (options.resetAtlasFile) {
+        const filePath = await atlas.resetExpoAtlasFile(options.projectRoot);
+        debug('(Re)created Atlas file at:', filePath);
+    }
+    // TODO(@kitten): Atlas' typings don't match @expo/metro yet
+    atlas.withExpoAtlas(options.metroConfig);
+    debug('Attached Atlas to Metro config for exporting');
+}
+function importAtlasForExport(projectRoot) {
+    try {
+        return require(require.resolve('expo-atlas/metro', {
+            paths: [
+                projectRoot
+            ]
+        }));
+    } catch (error) {
+        debug('Failed to load Atlas from project:', error);
+        return null;
+    }
+}
+async function waitUntilAtlasExportIsReadyAsync(projectRoot) {
+    if (!_env.env.EXPO_ATLAS) return;
+    const atlas = importAtlasForExport(projectRoot);
+    if (!atlas) {
+        return debug('Atlas is not loaded, cannot wait for export to finish');
+    }
+    if (typeof atlas.waitUntilAtlasFileReady !== 'function') {
+        return debug('Atlas is outdated, cannot wait for export to finish');
+    }
+    debug('Waiting for Atlas to finish exporting...');
+    await atlas.waitUntilAtlasFileReady();
+    debug('Atlas export is ready');
+}
+
+//# sourceMappingURL=attachAtlas.js.map

package/build/src/start/server/metro/debugging/attachAtlas.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/start/server/metro/debugging/attachAtlas.ts"],"sourcesContent":["import type { ConfigT as MetroConfig } from '@expo/metro/metro-config';\nimport type { Server as ConnectServer } from 'connect';\n\nimport { AtlasPrerequisite } from './AtlasPrerequisite';\nimport { env } from '../../../../utils/env';\nimport { type EnsureDependenciesOptions } from '../../../doctor/dependencies/ensureDependenciesAsync';\n\nconst debug = require('debug')('expo:metro:debugging:attachAtlas') as typeof console.log;\n\ntype AttachAtlasOptions = Pick<EnsureDependenciesOptions, 'exp'> & {\n  isExporting: boolean;\n  projectRoot: string;\n  middleware?: ConnectServer;\n  metroConfig: MetroConfig;\n  resetAtlasFile?: boolean;\n};\n\nexport async function attachAtlasAsync(\n  options: AttachAtlasOptions\n): Promise<void | ReturnType<typeof import('expo-atlas/cli').createExpoAtlasMiddleware>> {\n  if (!env.EXPO_ATLAS) {\n    return;\n  }\n\n  debug('Atlas is enabled, initializing for this project...');\n  await new AtlasPrerequisite(options.projectRoot).bootstrapAsync({ exp: options.exp });\n\n  return !options.isExporting\n    ? attachAtlasToDevServer(options)\n    : await attachAtlasToExport(options);\n}\n\n/**\n * Attach Atlas to the Metro bundler for development mode.\n * This includes attaching to Metro's middleware stack to host the Atlas UI.\n */\nfunction attachAtlasToDevServer(\n  options: Pick<AttachAtlasOptions, 'projectRoot' | 'middleware' | 'metroConfig'>\n): void | ReturnType<typeof import('expo-atlas/cli').createExpoAtlasMiddleware> {\n  if (!options.middleware) {\n    throw new Error(\n      'Expected middleware to be provided for Atlas when running in development mode'\n    );\n  }\n\n  const atlas = importAtlasForDev(options.projectRoot);\n  if (!atlas) {\n    return debug('Atlas is not installed in the project, skipping initialization');\n  }\n\n  // TODO(@kitten): Atlas' typings don't match @expo/metro yet\n  const instance = atlas.createExpoAtlasMiddleware(options.metroConfig as any);\n  options.middleware.use('/_expo/atlas', instance.middleware);\n  debug('Attached Atlas middleware for development on: /_expo/atlas');\n  return instance;\n}\n\nfunction importAtlasForDev(projectRoot: string): null | typeof import('expo-atlas/cli') {\n  try {\n    return require(require.resolve('expo-atlas/cli', { paths: [projectRoot] }));\n  } catch (error: any) {\n    debug('Failed to load Atlas from project:', error);\n    return null;\n  }\n}\n\n/**\n * Attach Atlas to the Metro bundler for exporting mode.\n * This only includes attaching the custom serializer to the Metro config.\n */\nasync function attachAtlasToExport(\n  options: Pick<AttachAtlasOptions, 'projectRoot' | 'metroConfig' | 'resetAtlasFile'>\n): Promise<void> {\n  const atlas = importAtlasForExport(options.projectRoot);\n  if (!atlas) {\n    return debug('Atlas is not installed in the project, skipping initialization');\n  }\n\n  if (options.resetAtlasFile) {\n    const filePath = await atlas.resetExpoAtlasFile(options.projectRoot);\n    debug('(Re)created Atlas file at:', filePath);\n  }\n\n  // TODO(@kitten): Atlas' typings don't match @expo/metro yet\n  atlas.withExpoAtlas(options.metroConfig as any);\n  debug('Attached Atlas to Metro config for exporting');\n}\n\nfunction importAtlasForExport(projectRoot: string): null | typeof import('expo-atlas/metro') {\n  try {\n    return require(require.resolve('expo-atlas/metro', { paths: [projectRoot] }));\n  } catch (error: any) {\n    debug('Failed to load Atlas from project:', error);\n    return null;\n  }\n}\n\n/**\n * Wait until the Atlas file has all data written.\n * Note, this is a workaround whenever `process.exit` is required, avoid if possible.\n * @internal\n */\nexport async function waitUntilAtlasExportIsReadyAsync(projectRoot: string) {\n  if (!env.EXPO_ATLAS) return;\n\n  const atlas = importAtlasForExport(projectRoot);\n\n  if (!atlas) {\n    return debug('Atlas is not loaded, cannot wait for export to finish');\n  }\n  if (typeof atlas.waitUntilAtlasFileReady !== 'function') {\n    return debug('Atlas is outdated, cannot wait for export to finish');\n  }\n\n  debug('Waiting for Atlas to finish exporting...');\n  await atlas.waitUntilAtlasFileReady();\n  debug('Atlas export is ready');\n}\n"],"names":["attachAtlasAsync","waitUntilAtlasExportIsReadyAsync","debug","require","options","env","EXPO_ATLAS","AtlasPrerequisite","projectRoot","bootstrapAsync","exp","isExporting","attachAtlasToDevServer","attachAtlasToExport","middleware","Error","atlas","importAtlasForDev","instance","createExpoAtlasMiddleware","metroConfig","use","resolve","paths","error","importAtlasForExport","resetAtlasFile","filePath","resetExpoAtlasFile","withExpoAtlas","waitUntilAtlasFileReady"],"mappings":";;;;;;;;;;;IAiBsBA,gBAAgB;eAAhBA;;IAqFAC,gCAAgC;eAAhCA;;;mCAnGY;qBACd;AAGpB,MAAMC,QAAQC,QAAQ,SAAS;AAUxB,eAAeH,iBACpBI,OAA2B;IAE3B,IAAI,CAACC,QAAG,CAACC,UAAU,EAAE;QACnB;IACF;IAEAJ,MAAM;IACN,MAAM,IAAIK,oCAAiB,CAACH,QAAQI,WAAW,EAAEC,cAAc,CAAC;QAAEC,KAAKN,QAAQM,GAAG;IAAC;IAEnF,OAAO,CAACN,QAAQO,WAAW,GACvBC,uBAAuBR,WACvB,MAAMS,oBAAoBT;AAChC;AAEA;;;CAGC,GACD,SAASQ,uBACPR,OAA+E;IAE/E,IAAI,CAACA,QAAQU,UAAU,EAAE;QACvB,MAAM,IAAIC,MACR;IAEJ;IAEA,MAAMC,QAAQC,kBAAkBb,QAAQI,WAAW;IACnD,IAAI,CAACQ,OAAO;QACV,OAAOd,MAAM;IACf;IAEA,4DAA4D;IAC5D,MAAMgB,WAAWF,MAAMG,yBAAyB,CAACf,QAAQgB,WAAW;IACpEhB,QAAQU,UAAU,CAACO,GAAG,CAAC,gBAAgBH,SAASJ,UAAU;IAC1DZ,MAAM;IACN,OAAOgB;AACT;AAEA,SAASD,kBAAkBT,WAAmB;IAC5C,IAAI;QACF,OAAOL,QAAQA,QAAQmB,OAAO,CAAC,kBAAkB;YAAEC,OAAO;gBAACf;aAAY;QAAC;IAC1E,EAAE,OAAOgB,OAAY;QACnBtB,MAAM,sCAAsCsB;QAC5C,OAAO;IACT;AACF;AAEA;;;CAGC,GACD,eAAeX,oBACbT,OAAmF;IAEnF,MAAMY,QAAQS,qBAAqBrB,QAAQI,WAAW;IACtD,IAAI,CAACQ,OAAO;QACV,OAAOd,MAAM;IACf;IAEA,IAAIE,QAAQsB,cAAc,EAAE;QAC1B,MAAMC,WAAW,MAAMX,MAAMY,kBAAkB,CAACxB,QAAQI,WAAW;QACnEN,MAAM,8BAA8ByB;IACtC;IAEA,4DAA4D;IAC5DX,MAAMa,aAAa,CAACzB,QAAQgB,WAAW;IACvClB,MAAM;AACR;AAEA,SAASuB,qBAAqBjB,WAAmB;IAC/C,IAAI;QACF,OAAOL,QAAQA,QAAQmB,OAAO,CAAC,oBAAoB;YAAEC,OAAO;gBAACf;aAAY;QAAC;IAC5E,EAAE,OAAOgB,OAAY;QACnBtB,MAAM,sCAAsCsB;QAC5C,OAAO;IACT;AACF;AAOO,eAAevB,iCAAiCO,WAAmB;IACxE,IAAI,CAACH,QAAG,CAACC,UAAU,EAAE;IAErB,MAAMU,QAAQS,qBAAqBjB;IAEnC,IAAI,CAACQ,OAAO;QACV,OAAOd,MAAM;IACf;IACA,IAAI,OAAOc,MAAMc,uBAAuB,KAAK,YAAY;QACvD,OAAO5B,MAAM;IACf;IAEAA,MAAM;IACN,MAAMc,MAAMc,uBAAuB;IACnC5B,MAAM;AACR"}

package/build/src/start/server/metro/debugging/createDebugMiddleware.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createDebugMiddleware", {
+    enumerable: true,
+    get: function() {
+        return createDebugMiddleware;
+    }
+});
+function _ws() {
+    const data = require("ws");
+    _ws = function() {
+        return data;
+    };
+    return data;
+}
+const _createHandlersFactory = require("./createHandlersFactory");
+const _env = require("../../../../utils/env");
+const _net = require("../../../../utils/net");
+const _NetworkResponse = require("./messageHandlers/NetworkResponse");
+const debug = require('debug')('expo:metro:debugging:middleware');
+function createDebugMiddleware({ serverBaseUrl, reporter }) {
+    // Load the React Native debugging tools from project
+    // TODO: check if this works with isolated modules
+    const { createDevMiddleware } = require('@react-native/dev-middleware');
+    const { middleware, websocketEndpoints } = createDevMiddleware({
+        // TODO: Check with cedric why this can be removed
+        // https://github.com/facebook/react-native/pull/53921
+        // projectRoot: metroBundler.projectRoot,
+        serverBaseUrl,
+        logger: createLogger(reporter),
+        unstable_customInspectorMessageHandler: (0, _createHandlersFactory.createHandlersFactory)(),
+        // TODO: Forward all events to the shared Metro log reporter. Do this when we have opinions on how all logs should be presented.
+        // unstable_eventReporter: {
+        //   logEvent(event) {
+        //     reporter.update(event);
+        //   },
+        // },
+        unstable_experiments: {
+            // Enable the Network tab in React Native DevTools
+            enableNetworkInspector: true,
+            // Only enable opening the browser version of React Native DevTools when debugging.
+            // This is useful when debugging the React Native DevTools by going to `/open-debugger` in the browser.
+            enableOpenDebuggerRedirect: _env.env.EXPO_DEBUG,
+            // The standalone fusebox shell (@react-native/debugger-shell) starts installing almost
+            // immediately in the background when the dev middleware is created, which we don't
+            // always want to happen
+            enableStandaloneFuseboxShell: !(0, _env.envIsHeadless)()
+        }
+    });
+    const debuggerWebsocketEndpoint = websocketEndpoints['/inspector/debug'];
+    // NOTE(cedric): add a temporary websocket to handle Network-related CDP events
+    websocketEndpoints['/inspector/network'] = createNetworkWebsocket(debuggerWebsocketEndpoint);
+    // Explicitly limit debugger websocket to loopback requests
+    debuggerWebsocketEndpoint.on('connection', (socket, request)=>{
+        if (!(0, _net.isLocalSocket)(request.socket) || !(0, _net.isMatchingOrigin)(request, serverBaseUrl)) {
+            // NOTE: `socket.close` nicely closes the websocket, which will still allow incoming messages
+            // `socket.terminate` instead forcefully closes down the socket
+            socket.terminate();
+        }
+    });
+    return {
+        debugMiddleware (req, res, next) {
+            // The debugger middleware is skipped entirely if the connection isn't a loopback request
+            if ((0, _net.isLocalSocket)(req.socket)) {
+                return middleware(req, res, next);
+            } else {
+                return next();
+            }
+        },
+        debugWebsocketEndpoints: websocketEndpoints
+    };
+}
+function createLogger(reporter) {
+    return {
+        info: makeLogger(reporter, 'info'),
+        warn: makeLogger(reporter, 'warn'),
+        error: makeLogger(reporter, 'error')
+    };
+}
+function makeLogger(reporter, level) {
+    return (...data)=>reporter.update({
+            type: 'unstable_server_log',
+            level,
+            data
+        });
+}
+/**
+ * This adds a dedicated websocket connection that handles Network-related CDP events.
+ * It's a temporary solution until Fusebox either implements the Network CDP domain,
+ * or allows external domain agents that can send messages over the CDP socket to the debugger.
+ * The Network websocket rebroadcasts events on the debugger CDP connections.
+ */ function createNetworkWebsocket(debuggerWebsocket) {
+    const wss = new (_ws()).WebSocketServer({
+        noServer: true,
+        perMessageDeflate: true,
+        // Don't crash on exceptionally large messages - assume the device is
+        // well-behaved and the debugger is prepared to handle large messages.
+        maxPayload: 0
+    });
+    wss.on('connection', (networkSocket)=>{
+        networkSocket.on('message', (data)=>{
+            try {
+                // Parse the network message, to determine how the message should be handled
+                const message = JSON.parse(data.toString());
+                if (message.method === 'Expo(Network.receivedResponseBody)' && message.params) {
+                    // If its a response body, write it to the global storage
+                    const { requestId, ...requestInfo } = message.params;
+                    _NetworkResponse.NETWORK_RESPONSE_STORAGE.set(requestId, requestInfo);
+                } else if (message.method.startsWith('Network.')) {
+                    // Otherwise, directly re-broadcast the Network events to all connected debuggers
+                    debuggerWebsocket.clients.forEach((debuggerSocket)=>{
+                        if (debuggerSocket.readyState === debuggerSocket.OPEN) {
+                            debuggerSocket.send(data.toString());
+                        }
+                    });
+                }
+            } catch (error) {
+                debug('Failed to handle Network CDP event', error);
+            }
+        });
+    });
+    return wss;
+}
+
+//# sourceMappingURL=createDebugMiddleware.js.map

package/build/src/start/server/metro/debugging/createDebugMiddleware.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/start/server/metro/debugging/createDebugMiddleware.ts"],"sourcesContent":["import type { NextHandleFunction } from 'connect';\nimport { WebSocketServer } from 'ws';\n\nimport { createHandlersFactory } from './createHandlersFactory';\nimport { env, envIsHeadless } from '../../../../utils/env';\nimport { isLocalSocket, isMatchingOrigin } from '../../../../utils/net';\nimport { TerminalReporter } from '../TerminalReporter';\nimport { NETWORK_RESPONSE_STORAGE } from './messageHandlers/NetworkResponse';\n\nconst debug = require('debug')('expo:metro:debugging:middleware') as typeof console.log;\n\ninterface DebugMiddleware {\n  debugMiddleware: NextHandleFunction;\n  debugWebsocketEndpoints: Record<string, WebSocketServer>;\n}\n\ninterface DebugMiddlewareParams {\n  serverBaseUrl: string;\n  reporter: TerminalReporter;\n}\n\nexport function createDebugMiddleware({\n  serverBaseUrl,\n  reporter,\n}: DebugMiddlewareParams): DebugMiddleware {\n  // Load the React Native debugging tools from project\n  // TODO: check if this works with isolated modules\n  const { createDevMiddleware } =\n    require('@react-native/dev-middleware') as typeof import('@react-native/dev-middleware');\n\n  const { middleware, websocketEndpoints } = createDevMiddleware({\n    // TODO: Check with cedric why this can be removed\n    // https://github.com/facebook/react-native/pull/53921\n    // projectRoot: metroBundler.projectRoot,\n    serverBaseUrl,\n    logger: createLogger(reporter),\n    unstable_customInspectorMessageHandler: createHandlersFactory(),\n    // TODO: Forward all events to the shared Metro log reporter. Do this when we have opinions on how all logs should be presented.\n    // unstable_eventReporter: {\n    //   logEvent(event) {\n    //     reporter.update(event);\n    //   },\n    // },\n    unstable_experiments: {\n      // Enable the Network tab in React Native DevTools\n      enableNetworkInspector: true,\n      // Only enable opening the browser version of React Native DevTools when debugging.\n      // This is useful when debugging the React Native DevTools by going to `/open-debugger` in the browser.\n      enableOpenDebuggerRedirect: env.EXPO_DEBUG,\n      // The standalone fusebox shell (@react-native/debugger-shell) starts installing almost\n      // immediately in the background when the dev middleware is created, which we don't\n      // always want to happen\n      enableStandaloneFuseboxShell: !envIsHeadless(),\n    },\n  });\n\n  const debuggerWebsocketEndpoint = websocketEndpoints['/inspector/debug'] as WebSocketServer;\n\n  // NOTE(cedric): add a temporary websocket to handle Network-related CDP events\n  websocketEndpoints['/inspector/network'] = createNetworkWebsocket(debuggerWebsocketEndpoint);\n\n  // Explicitly limit debugger websocket to loopback requests\n  debuggerWebsocketEndpoint.on('connection', (socket, request) => {\n    if (!isLocalSocket(request.socket) || !isMatchingOrigin(request, serverBaseUrl)) {\n      // NOTE: `socket.close` nicely closes the websocket, which will still allow incoming messages\n      // `socket.terminate` instead forcefully closes down the socket\n      socket.terminate();\n    }\n  });\n\n  return {\n    debugMiddleware(req, res, next) {\n      // The debugger middleware is skipped entirely if the connection isn't a loopback request\n      if (isLocalSocket(req.socket)) {\n        return middleware(req, res, next);\n      } else {\n        return next();\n      }\n    },\n    debugWebsocketEndpoints: websocketEndpoints,\n  };\n}\n\nfunction createLogger(\n  reporter: TerminalReporter\n): Parameters<typeof import('@react-native/dev-middleware').createDevMiddleware>[0]['logger'] {\n  return {\n    info: makeLogger(reporter, 'info'),\n    warn: makeLogger(reporter, 'warn'),\n    error: makeLogger(reporter, 'error'),\n  };\n}\n\nfunction makeLogger(reporter: TerminalReporter, level: 'info' | 'warn' | 'error') {\n  return (...data: any[]) =>\n    reporter.update({\n      type: 'unstable_server_log',\n      level,\n      data,\n    });\n}\n\n/**\n * This adds a dedicated websocket connection that handles Network-related CDP events.\n * It's a temporary solution until Fusebox either implements the Network CDP domain,\n * or allows external domain agents that can send messages over the CDP socket to the debugger.\n * The Network websocket rebroadcasts events on the debugger CDP connections.\n */\nfunction createNetworkWebsocket(debuggerWebsocket: WebSocketServer) {\n  const wss = new WebSocketServer({\n    noServer: true,\n    perMessageDeflate: true,\n    // Don't crash on exceptionally large messages - assume the device is\n    // well-behaved and the debugger is prepared to handle large messages.\n    maxPayload: 0,\n  });\n\n  wss.on('connection', (networkSocket) => {\n    networkSocket.on('message', (data) => {\n      try {\n        // Parse the network message, to determine how the message should be handled\n        const message = JSON.parse(data.toString());\n\n        if (message.method === 'Expo(Network.receivedResponseBody)' && message.params) {\n          // If its a response body, write it to the global storage\n          const { requestId, ...requestInfo } = message.params;\n          NETWORK_RESPONSE_STORAGE.set(requestId, requestInfo);\n        } else if (message.method.startsWith('Network.')) {\n          // Otherwise, directly re-broadcast the Network events to all connected debuggers\n          debuggerWebsocket.clients.forEach((debuggerSocket) => {\n            if (debuggerSocket.readyState === debuggerSocket.OPEN) {\n              debuggerSocket.send(data.toString());\n            }\n          });\n        }\n      } catch (error) {\n        debug('Failed to handle Network CDP event', error);\n      }\n    });\n  });\n\n  return wss;\n}\n"],"names":["createDebugMiddleware","debug","require","serverBaseUrl","reporter","createDevMiddleware","middleware","websocketEndpoints","logger","createLogger","unstable_customInspectorMessageHandler","createHandlersFactory","unstable_experiments","enableNetworkInspector","enableOpenDebuggerRedirect","env","EXPO_DEBUG","enableStandaloneFuseboxShell","envIsHeadless","debuggerWebsocketEndpoint","createNetworkWebsocket","on","socket","request","isLocalSocket","isMatchingOrigin","terminate","debugMiddleware","req","res","next","debugWebsocketEndpoints","info","makeLogger","warn","error","level","data","update","type","debuggerWebsocket","wss","WebSocketServer","noServer","perMessageDeflate","maxPayload","networkSocket","message","JSON","parse","toString","method","params","requestId","requestInfo","NETWORK_RESPONSE_STORAGE","set","startsWith","clients","forEach","debuggerSocket","readyState","OPEN","send"],"mappings":"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"}