@depup/expo__cli 55.0.16-depup.0

package/build/src/start/server/middleware/ExpoGoManifestHandlerMiddleware.js

@@ -0,0 +1,288 @@
+"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, {
+    ExpoGoManifestHandlerMiddleware: function() {
+        return ExpoGoManifestHandlerMiddleware;
+    },
+    ResponseContentType: function() {
+        return ResponseContentType;
+    }
+});
+function _configplugins() {
+    const data = require("@expo/config-plugins");
+    _configplugins = function() {
+        return data;
+    };
+    return data;
+}
+function _accepts() {
+    const data = /*#__PURE__*/ _interop_require_default(require("accepts"));
+    _accepts = function() {
+        return data;
+    };
+    return data;
+}
+function _crypto() {
+    const data = /*#__PURE__*/ _interop_require_default(require("crypto"));
+    _crypto = function() {
+        return data;
+    };
+    return data;
+}
+function _multitars() {
+    const data = require("multitars");
+    _multitars = function() {
+        return data;
+    };
+    return data;
+}
+function _structuredheaders() {
+    const data = require("structured-headers");
+    _structuredheaders = function() {
+        return data;
+    };
+    return data;
+}
+const _ManifestMiddleware = require("./ManifestMiddleware");
+const _resolvePlatform = require("./resolvePlatform");
+const _resolveRuntimeVersionWithExpoUpdatesAsync = require("./resolveRuntimeVersionWithExpoUpdatesAsync");
+const _UserSettings = require("../../../api/user/UserSettings");
+const _user = require("../../../api/user/user");
+const _codesigning = require("../../../utils/codesigning");
+const _errors = require("../../../utils/errors");
+const _url = require("../../../utils/url");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const MULTIPART_TYPE = 'multipart/form-data';
+const debug = require('debug')('expo:start:server:middleware:ExpoGoManifestHandlerMiddleware');
+let multipartMixedContentType = _multitars().multipartContentType;
+if (multipartMixedContentType.startsWith(MULTIPART_TYPE)) {
+    multipartMixedContentType = 'multipart/mixed' + multipartMixedContentType.slice(MULTIPART_TYPE.length);
+}
+var ResponseContentType = /*#__PURE__*/ function(ResponseContentType) {
+    ResponseContentType[ResponseContentType["TEXT_PLAIN"] = 0] = "TEXT_PLAIN";
+    ResponseContentType[ResponseContentType["APPLICATION_JSON"] = 1] = "APPLICATION_JSON";
+    ResponseContentType[ResponseContentType["APPLICATION_EXPO_JSON"] = 2] = "APPLICATION_EXPO_JSON";
+    ResponseContentType[ResponseContentType["MULTIPART_MIXED"] = 3] = "MULTIPART_MIXED";
+    return ResponseContentType;
+}({});
+class ExpoGoManifestHandlerMiddleware extends _ManifestMiddleware.ManifestMiddleware {
+    getParsedHeaders(req) {
+        let platform = (0, _resolvePlatform.parsePlatformHeader)(req);
+        if (!platform) {
+            debug(`No "expo-platform" header or "platform" query parameter specified. Falling back to "ios".`);
+            platform = 'ios';
+        }
+        (0, _resolvePlatform.assertRuntimePlatform)(platform);
+        // Expo Updates clients explicitly accept "multipart/mixed" responses while browsers implicitly
+        // accept them with "accept: */*". To make it easier to debug manifest responses by visiting their
+        // URLs in a browser, we denote the response as "text/plain" if the user agent appears not to be
+        // an Expo Updates client.
+        const accept = (0, _accepts().default)(req);
+        const acceptedType = accept.types([
+            'unknown/unknown',
+            'multipart/mixed',
+            'application/json',
+            'application/expo+json',
+            'text/plain'
+        ]);
+        let responseContentType;
+        switch(acceptedType){
+            case 'multipart/mixed':
+                responseContentType = 3;
+                break;
+            case 'application/json':
+                responseContentType = 1;
+                break;
+            case 'application/expo+json':
+                responseContentType = 2;
+                break;
+            default:
+                responseContentType = 0;
+                break;
+        }
+        const expectSignature = req.headers['expo-expect-signature'];
+        return {
+            responseContentType,
+            platform,
+            expectSignature: expectSignature ? String(expectSignature) : null,
+            hostname: (0, _url.stripPort)(req.headers['host']),
+            protocol: req.headers['x-forwarded-proto']
+        };
+    }
+    getDefaultResponseHeaders() {
+        const headers = new Headers();
+        // set required headers for Expo Updates manifest specification
+        headers.set('expo-protocol-version', '0');
+        headers.set('expo-sfv-version', '0');
+        headers.set('cache-control', 'private, max-age=0');
+        return headers;
+    }
+    async _getManifestResponseAsync(requestOptions) {
+        var _exp_extra_eas, _exp_extra;
+        const { exp, hostUri, expoGoConfig, bundleUrl } = await this._resolveProjectSettingsAsync(requestOptions);
+        const runtimeVersion = await (0, _resolveRuntimeVersionWithExpoUpdatesAsync.resolveRuntimeVersionWithExpoUpdatesAsync)({
+            projectRoot: this.projectRoot,
+            platform: requestOptions.platform
+        }) ?? // if expo-updates can't determine runtime version, fall back to calculation from config-plugin.
+        // this happens when expo-updates is installed but runtimeVersion hasn't yet been configured or when
+        // expo-updates is not installed.
+        await _configplugins().Updates.getRuntimeVersionAsync(this.projectRoot, {
+            ...exp,
+            runtimeVersion: exp.runtimeVersion ?? {
+                policy: 'sdkVersion'
+            }
+        }, requestOptions.platform);
+        if (!runtimeVersion) {
+            throw new _errors.CommandError('MANIFEST_MIDDLEWARE', `Unable to determine runtime version for platform '${requestOptions.platform}'`);
+        }
+        const codeSigningInfo = await (0, _codesigning.getCodeSigningInfoAsync)(exp, requestOptions.expectSignature, this.options.privateKeyPath);
+        const easProjectId = (_exp_extra = exp.extra) == null ? void 0 : (_exp_extra_eas = _exp_extra.eas) == null ? void 0 : _exp_extra_eas.projectId;
+        const scopeKey = await ExpoGoManifestHandlerMiddleware.getScopeKeyAsync({
+            slug: exp.slug,
+            codeSigningInfo
+        });
+        const expoUpdatesManifest = {
+            id: _crypto().default.randomUUID(),
+            createdAt: new Date().toISOString(),
+            runtimeVersion,
+            launchAsset: {
+                key: 'bundle',
+                contentType: 'application/javascript',
+                url: bundleUrl
+            },
+            assets: [],
+            metadata: {},
+            extra: {
+                eas: {
+                    projectId: easProjectId ?? undefined
+                },
+                expoClient: {
+                    ...exp,
+                    hostUri
+                },
+                expoGo: expoGoConfig,
+                scopeKey
+            }
+        };
+        const stringifiedManifest = JSON.stringify(expoUpdatesManifest);
+        let manifestPartHeaders;
+        let certificateChainBody = null;
+        if (codeSigningInfo) {
+            const signature = (0, _codesigning.signManifestString)(stringifiedManifest, codeSigningInfo);
+            manifestPartHeaders = {
+                'expo-signature': (0, _structuredheaders().serializeDictionary)(convertToDictionaryItemsRepresentation({
+                    keyid: codeSigningInfo.keyId,
+                    sig: signature,
+                    alg: 'rsa-v1_5-sha256'
+                }))
+            };
+            certificateChainBody = codeSigningInfo.certificateChainForResponse.join('\n');
+        }
+        switch(requestOptions.responseContentType){
+            case 3:
+                {
+                    return this.encodeFormDataAsync({
+                        stringifiedManifest,
+                        manifestPartHeaders,
+                        certificateChainBody
+                    });
+                }
+            case 2:
+            case 1:
+            case 0:
+                {
+                    const headers = this.getDefaultResponseHeaders();
+                    headers.set('content-type', ExpoGoManifestHandlerMiddleware.getContentTypeForResponseContentType(requestOptions.responseContentType));
+                    if (manifestPartHeaders == null ? void 0 : manifestPartHeaders['expo-signature']) {
+                        headers.set('expo-signature', manifestPartHeaders['expo-signature']);
+                    }
+                    return new Response(stringifiedManifest, {
+                        status: 200,
+                        headers
+                    });
+                }
+        }
+    }
+    static getContentTypeForResponseContentType(responseContentType) {
+        switch(responseContentType){
+            case 3:
+                return 'multipart/mixed';
+            case 2:
+                return 'application/expo+json';
+            case 1:
+                return 'application/json';
+            case 0:
+                return 'text/plain';
+        }
+    }
+    encodeFormDataAsync({ stringifiedManifest, manifestPartHeaders, certificateChainBody }) {
+        const parts = [
+            [
+                'manifest',
+                new (_multitars()).MultipartPart([
+                    stringifiedManifest
+                ], 'manifest', {
+                    type: 'application/json',
+                    headers: manifestPartHeaders
+                })
+            ]
+        ];
+        if (certificateChainBody && certificateChainBody.length > 0) {
+            parts.push([
+                'certificate_chain',
+                new (_multitars()).MultipartPart([
+                    certificateChainBody
+                ], 'certificate_chain', {
+                    type: 'application/x-pem-file'
+                })
+            ]);
+        }
+        const headers = this.getDefaultResponseHeaders();
+        headers.set('Content-Type', multipartMixedContentType);
+        return new Response((0, _multitars().iterableToStream)((0, _multitars().streamMultipart)(parts)), {
+            status: 200,
+            headers
+        });
+    }
+    static async getScopeKeyAsync({ slug, codeSigningInfo }) {
+        const scopeKeyFromCodeSigningInfo = codeSigningInfo == null ? void 0 : codeSigningInfo.scopeKey;
+        if (scopeKeyFromCodeSigningInfo) {
+            return scopeKeyFromCodeSigningInfo;
+        }
+        // Log.warn(
+        //   env.EXPO_OFFLINE
+        //     ? 'Using anonymous scope key in manifest for offline mode.'
+        //     : 'Using anonymous scope key in manifest.'
+        // );
+        return await getAnonymousScopeKeyAsync(slug);
+    }
+}
+async function getAnonymousScopeKeyAsync(slug) {
+    const userAnonymousIdentifier = await (0, _UserSettings.getAnonymousIdAsync)();
+    return `@${_user.ANONYMOUS_USERNAME}/${slug}-${userAnonymousIdentifier}`;
+}
+function convertToDictionaryItemsRepresentation(obj) {
+    return new Map(Object.entries(obj).map(([k, v])=>{
+        return [
+            k,
+            [
+                v,
+                new Map()
+            ]
+        ];
+    }));
+}
+
+//# sourceMappingURL=ExpoGoManifestHandlerMiddleware.js.map

package/build/src/start/server/middleware/ExpoGoManifestHandlerMiddleware.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/start/server/middleware/ExpoGoManifestHandlerMiddleware.ts"],"sourcesContent":["import { ExpoUpdatesManifest } from '@expo/config';\nimport { Updates } from '@expo/config-plugins';\nimport accepts from 'accepts';\nimport crypto from 'crypto';\nimport {\n  iterableToStream,\n  streamMultipart,\n  multipartContentType,\n  FormEntry,\n  MultipartPart,\n} from 'multitars';\nimport { serializeDictionary, Dictionary } from 'structured-headers';\n\nimport { ManifestMiddleware, ManifestRequestInfo } from './ManifestMiddleware';\nimport { assertRuntimePlatform, parsePlatformHeader } from './resolvePlatform';\nimport { resolveRuntimeVersionWithExpoUpdatesAsync } from './resolveRuntimeVersionWithExpoUpdatesAsync';\nimport { ServerRequest } from './server.types';\nimport { getAnonymousIdAsync } from '../../../api/user/UserSettings';\nimport { ANONYMOUS_USERNAME } from '../../../api/user/user';\nimport {\n  CodeSigningInfo,\n  getCodeSigningInfoAsync,\n  signManifestString,\n} from '../../../utils/codesigning';\nimport { CommandError } from '../../../utils/errors';\nimport { stripPort } from '../../../utils/url';\n\nconst MULTIPART_TYPE = 'multipart/form-data';\n\nconst debug = require('debug')('expo:start:server:middleware:ExpoGoManifestHandlerMiddleware');\n\nlet multipartMixedContentType = multipartContentType;\nif (multipartMixedContentType.startsWith(MULTIPART_TYPE)) {\n  multipartMixedContentType =\n    'multipart/mixed' + multipartMixedContentType.slice(MULTIPART_TYPE.length);\n}\n\nexport enum ResponseContentType {\n  TEXT_PLAIN,\n  APPLICATION_JSON,\n  APPLICATION_EXPO_JSON,\n  MULTIPART_MIXED,\n}\n\ninterface ExpoGoManifestRequestInfo extends ManifestRequestInfo {\n  responseContentType: ResponseContentType;\n  expectSignature: string | null;\n}\n\nexport class ExpoGoManifestHandlerMiddleware extends ManifestMiddleware<ExpoGoManifestRequestInfo> {\n  public getParsedHeaders(req: ServerRequest): ExpoGoManifestRequestInfo {\n    let platform = parsePlatformHeader(req);\n\n    if (!platform) {\n      debug(\n        `No \"expo-platform\" header or \"platform\" query parameter specified. Falling back to \"ios\".`\n      );\n      platform = 'ios';\n    }\n\n    assertRuntimePlatform(platform);\n\n    // Expo Updates clients explicitly accept \"multipart/mixed\" responses while browsers implicitly\n    // accept them with \"accept: */*\". To make it easier to debug manifest responses by visiting their\n    // URLs in a browser, we denote the response as \"text/plain\" if the user agent appears not to be\n    // an Expo Updates client.\n    const accept = accepts(req);\n    const acceptedType = accept.types([\n      'unknown/unknown',\n      'multipart/mixed',\n      'application/json',\n      'application/expo+json',\n      'text/plain',\n    ]);\n\n    let responseContentType;\n    switch (acceptedType) {\n      case 'multipart/mixed':\n        responseContentType = ResponseContentType.MULTIPART_MIXED;\n        break;\n      case 'application/json':\n        responseContentType = ResponseContentType.APPLICATION_JSON;\n        break;\n      case 'application/expo+json':\n        responseContentType = ResponseContentType.APPLICATION_EXPO_JSON;\n        break;\n      default:\n        responseContentType = ResponseContentType.TEXT_PLAIN;\n        break;\n    }\n\n    const expectSignature = req.headers['expo-expect-signature'];\n\n    return {\n      responseContentType,\n      platform,\n      expectSignature: expectSignature ? String(expectSignature) : null,\n      hostname: stripPort(req.headers['host']),\n      protocol: req.headers['x-forwarded-proto'] as 'http' | 'https' | undefined,\n    };\n  }\n\n  private getDefaultResponseHeaders(): Headers {\n    const headers = new Headers();\n    // set required headers for Expo Updates manifest specification\n    headers.set('expo-protocol-version', '0');\n    headers.set('expo-sfv-version', '0');\n    headers.set('cache-control', 'private, max-age=0');\n    return headers;\n  }\n\n  public async _getManifestResponseAsync(\n    requestOptions: ExpoGoManifestRequestInfo\n  ): Promise<Response> {\n    const { exp, hostUri, expoGoConfig, bundleUrl } =\n      await this._resolveProjectSettingsAsync(requestOptions);\n\n    const runtimeVersion =\n      (await resolveRuntimeVersionWithExpoUpdatesAsync({\n        projectRoot: this.projectRoot,\n        platform: requestOptions.platform,\n      })) ??\n      // if expo-updates can't determine runtime version, fall back to calculation from config-plugin.\n      // this happens when expo-updates is installed but runtimeVersion hasn't yet been configured or when\n      // expo-updates is not installed.\n      (await Updates.getRuntimeVersionAsync(\n        this.projectRoot,\n        { ...exp, runtimeVersion: exp.runtimeVersion ?? { policy: 'sdkVersion' } },\n        requestOptions.platform\n      ));\n    if (!runtimeVersion) {\n      throw new CommandError(\n        'MANIFEST_MIDDLEWARE',\n        `Unable to determine runtime version for platform '${requestOptions.platform}'`\n      );\n    }\n\n    const codeSigningInfo = await getCodeSigningInfoAsync(\n      exp,\n      requestOptions.expectSignature,\n      this.options.privateKeyPath\n    );\n\n    const easProjectId = exp.extra?.eas?.projectId as string | undefined | null;\n    const scopeKey = await ExpoGoManifestHandlerMiddleware.getScopeKeyAsync({\n      slug: exp.slug,\n      codeSigningInfo,\n    });\n\n    const expoUpdatesManifest: ExpoUpdatesManifest = {\n      id: crypto.randomUUID(),\n      createdAt: new Date().toISOString(),\n      runtimeVersion,\n      launchAsset: {\n        key: 'bundle',\n        contentType: 'application/javascript',\n        url: bundleUrl,\n      },\n      assets: [], // assets are not used in development\n      metadata: {}, // required for the client to detect that this is an expo-updates manifest\n      extra: {\n        eas: {\n          projectId: easProjectId ?? undefined,\n        },\n        expoClient: {\n          ...exp,\n          hostUri,\n        },\n        expoGo: expoGoConfig,\n        scopeKey,\n      },\n    };\n\n    const stringifiedManifest = JSON.stringify(expoUpdatesManifest);\n\n    let manifestPartHeaders: { 'expo-signature': string } | undefined;\n    let certificateChainBody: string | null = null;\n    if (codeSigningInfo) {\n      const signature = signManifestString(stringifiedManifest, codeSigningInfo);\n      manifestPartHeaders = {\n        'expo-signature': serializeDictionary(\n          convertToDictionaryItemsRepresentation({\n            keyid: codeSigningInfo.keyId,\n            sig: signature,\n            alg: 'rsa-v1_5-sha256',\n          })\n        ),\n      };\n      certificateChainBody = codeSigningInfo.certificateChainForResponse.join('\\n');\n    }\n\n    switch (requestOptions.responseContentType) {\n      case ResponseContentType.MULTIPART_MIXED: {\n        return this.encodeFormDataAsync({\n          stringifiedManifest,\n          manifestPartHeaders,\n          certificateChainBody,\n        });\n      }\n      case ResponseContentType.APPLICATION_EXPO_JSON:\n      case ResponseContentType.APPLICATION_JSON:\n      case ResponseContentType.TEXT_PLAIN: {\n        const headers = this.getDefaultResponseHeaders();\n        headers.set(\n          'content-type',\n          ExpoGoManifestHandlerMiddleware.getContentTypeForResponseContentType(\n            requestOptions.responseContentType\n          )\n        );\n        if (manifestPartHeaders?.['expo-signature']) {\n          headers.set('expo-signature', manifestPartHeaders['expo-signature']);\n        }\n        return new Response(stringifiedManifest, { status: 200, headers });\n      }\n    }\n  }\n\n  private static getContentTypeForResponseContentType(\n    responseContentType: ResponseContentType\n  ): string {\n    switch (responseContentType) {\n      case ResponseContentType.MULTIPART_MIXED:\n        return 'multipart/mixed';\n      case ResponseContentType.APPLICATION_EXPO_JSON:\n        return 'application/expo+json';\n      case ResponseContentType.APPLICATION_JSON:\n        return 'application/json';\n      case ResponseContentType.TEXT_PLAIN:\n        return 'text/plain';\n    }\n  }\n\n  private encodeFormDataAsync({\n    stringifiedManifest,\n    manifestPartHeaders,\n    certificateChainBody,\n  }: {\n    stringifiedManifest: string;\n    manifestPartHeaders: { 'expo-signature': string } | undefined;\n    certificateChainBody: string | null;\n  }): Response {\n    const parts: FormEntry[] = [\n      [\n        'manifest',\n        new MultipartPart([stringifiedManifest], 'manifest', {\n          type: 'application/json',\n          headers: manifestPartHeaders,\n        }),\n      ],\n    ];\n    if (certificateChainBody && certificateChainBody.length > 0) {\n      parts.push([\n        'certificate_chain',\n        new MultipartPart([certificateChainBody], 'certificate_chain', {\n          type: 'application/x-pem-file',\n        }),\n      ]);\n    }\n    const headers = this.getDefaultResponseHeaders();\n    headers.set('Content-Type', multipartMixedContentType);\n    return new Response(iterableToStream(streamMultipart(parts)), { status: 200, headers });\n  }\n\n  private static async getScopeKeyAsync({\n    slug,\n    codeSigningInfo,\n  }: {\n    slug: string;\n    codeSigningInfo: CodeSigningInfo | null;\n  }): Promise<string> {\n    const scopeKeyFromCodeSigningInfo = codeSigningInfo?.scopeKey;\n    if (scopeKeyFromCodeSigningInfo) {\n      return scopeKeyFromCodeSigningInfo;\n    }\n\n    // Log.warn(\n    //   env.EXPO_OFFLINE\n    //     ? 'Using anonymous scope key in manifest for offline mode.'\n    //     : 'Using anonymous scope key in manifest.'\n    // );\n    return await getAnonymousScopeKeyAsync(slug);\n  }\n}\n\nasync function getAnonymousScopeKeyAsync(slug: string): Promise<string> {\n  const userAnonymousIdentifier = await getAnonymousIdAsync();\n  return `@${ANONYMOUS_USERNAME}/${slug}-${userAnonymousIdentifier}`;\n}\n\nfunction convertToDictionaryItemsRepresentation(obj: { [key: string]: string }): Dictionary {\n  return new Map(\n    Object.entries(obj).map(([k, v]) => {\n      return [k, [v, new Map()]];\n    })\n  );\n}\n"],"names":["ExpoGoManifestHandlerMiddleware","ResponseContentType","MULTIPART_TYPE","debug","require","multipartMixedContentType","multipartContentType","startsWith","slice","length","ManifestMiddleware","getParsedHeaders","req","platform","parsePlatformHeader","assertRuntimePlatform","accept","accepts","acceptedType","types","responseContentType","expectSignature","headers","String","hostname","stripPort","protocol","getDefaultResponseHeaders","Headers","set","_getManifestResponseAsync","requestOptions","exp","hostUri","expoGoConfig","bundleUrl","_resolveProjectSettingsAsync","runtimeVersion","resolveRuntimeVersionWithExpoUpdatesAsync","projectRoot","Updates","getRuntimeVersionAsync","policy","CommandError","codeSigningInfo","getCodeSigningInfoAsync","options","privateKeyPath","easProjectId","extra","eas","projectId","scopeKey","getScopeKeyAsync","slug","expoUpdatesManifest","id","crypto","randomUUID","createdAt","Date","toISOString","launchAsset","key","contentType","url","assets","metadata","undefined","expoClient","expoGo","stringifiedManifest","JSON","stringify","manifestPartHeaders","certificateChainBody","signature","signManifestString","serializeDictionary","convertToDictionaryItemsRepresentation","keyid","keyId","sig","alg","certificateChainForResponse","join","encodeFormDataAsync","getContentTypeForResponseContentType","Response","status","parts","MultipartPart","type","push","iterableToStream","streamMultipart","scopeKeyFromCodeSigningInfo","getAnonymousScopeKeyAsync","userAnonymousIdentifier","getAnonymousIdAsync","ANONYMOUS_USERNAME","obj","Map","Object","entries","map","k","v"],"mappings":"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"}

package/build/src/start/server/middleware/ExpoMiddleware.js

@@ -0,0 +1,121 @@
+"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, {
+    ExpoMiddleware: function() {
+        return ExpoMiddleware;
+    },
+    disableResponseCache: function() {
+        return disableResponseCache;
+    }
+});
+function _url() {
+    const data = require("url");
+    _url = function() {
+        return data;
+    };
+    return data;
+}
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../log"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+class ExpoMiddleware {
+    constructor(projectRoot, supportedPaths){
+        this.projectRoot = projectRoot;
+        this.supportedPaths = supportedPaths;
+    }
+    /**
+   * Returns true when the middleware should handle the incoming server request.
+   * Exposed for testing.
+   */ shouldHandleRequest(req) {
+        if (!req.url) {
+            return false;
+        }
+        const parsed = (0, _url().parse)(req.url);
+        // Strip the query params
+        if (!parsed.pathname) {
+            return false;
+        }
+        return this.supportedPaths.includes(parsed.pathname);
+    }
+    /** Create a server middleware handler. */ getHandler() {
+        const internalMiddleware = async (req, res, next)=>{
+            try {
+                return await this.handleRequestAsync(req, res, next);
+            } catch (error) {
+                _log.exception(error);
+                // 5xx = Server Error HTTP code
+                res.statusCode = 500;
+                if (typeof error === 'object' && error !== null) {
+                    res.end(JSON.stringify({
+                        error: error.toString()
+                    }));
+                } else {
+                    res.end(`Unexpected error: ${error}`);
+                }
+            }
+        };
+        const middleware = async (req, res, next)=>{
+            if (!this.shouldHandleRequest(req)) {
+                return next();
+            }
+            return internalMiddleware(req, res, next);
+        };
+        middleware.internal = internalMiddleware;
+        return middleware;
+    }
+}
+function disableResponseCache(res) {
+    res.setHeader('Cache-Control', 'private, no-cache, no-store, must-revalidate');
+    res.setHeader('Expires', '-1');
+    res.setHeader('Pragma', 'no-cache');
+    return res;
+}
+
+//# sourceMappingURL=ExpoMiddleware.js.map

package/build/src/start/server/middleware/ExpoMiddleware.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/start/server/middleware/ExpoMiddleware.ts"],"sourcesContent":["import { parse } from 'url';\n\nimport { ServerNext, ServerRequest, ServerResponse } from './server.types';\nimport * as Log from '../../../log';\n\n/** Base middleware creator for Expo dev servers. */\nexport abstract class ExpoMiddleware {\n  constructor(\n    protected projectRoot: string,\n    protected supportedPaths: string[]\n  ) {}\n\n  /**\n   * Returns true when the middleware should handle the incoming server request.\n   * Exposed for testing.\n   */\n  public shouldHandleRequest(req: ServerRequest): boolean {\n    if (!req.url) {\n      return false;\n    }\n    const parsed = parse(req.url);\n    // Strip the query params\n    if (!parsed.pathname) {\n      return false;\n    }\n\n    return this.supportedPaths.includes(parsed.pathname);\n  }\n\n  abstract handleRequestAsync(\n    req: ServerRequest,\n    res: ServerResponse,\n    next: ServerNext\n  ): Promise<void>;\n\n  /** Create a server middleware handler. */\n  public getHandler() {\n    const internalMiddleware = async (\n      req: ServerRequest,\n      res: ServerResponse,\n      next: ServerNext\n    ) => {\n      try {\n        return await this.handleRequestAsync(req, res, next);\n      } catch (error: any) {\n        Log.exception(error);\n        // 5xx = Server Error HTTP code\n        res.statusCode = 500;\n        if (typeof error === 'object' && error !== null) {\n          res.end(\n            JSON.stringify({\n              error: error.toString(),\n            })\n          );\n        } else {\n          res.end(`Unexpected error: ${error}`);\n        }\n      }\n    };\n    const middleware = async (req: ServerRequest, res: ServerResponse, next: ServerNext) => {\n      if (!this.shouldHandleRequest(req)) {\n        return next();\n      }\n      return internalMiddleware(req, res, next);\n    };\n\n    middleware.internal = internalMiddleware;\n\n    return middleware;\n  }\n}\n\nexport function disableResponseCache(res: ServerResponse): ServerResponse {\n  res.setHeader('Cache-Control', 'private, no-cache, no-store, must-revalidate');\n  res.setHeader('Expires', '-1');\n  res.setHeader('Pragma', 'no-cache');\n  return res;\n}\n"],"names":["ExpoMiddleware","disableResponseCache","constructor","projectRoot","supportedPaths","shouldHandleRequest","req","url","parsed","parse","pathname","includes","getHandler","internalMiddleware","res","next","handleRequestAsync","error","Log","exception","statusCode","end","JSON","stringify","toString","middleware","internal","setHeader"],"mappings":";;;;;;;;;;;IAMsBA,cAAc;eAAdA;;IAkENC,oBAAoB;eAApBA;;;;yBAxEM;;;;;;6DAGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGd,MAAeD;IACpBE,YACE,AAAUC,WAAmB,EAC7B,AAAUC,cAAwB,CAClC;aAFUD,cAAAA;aACAC,iBAAAA;IACT;IAEH;;;GAGC,GACD,AAAOC,oBAAoBC,GAAkB,EAAW;QACtD,IAAI,CAACA,IAAIC,GAAG,EAAE;YACZ,OAAO;QACT;QACA,MAAMC,SAASC,IAAAA,YAAK,EAACH,IAAIC,GAAG;QAC5B,yBAAyB;QACzB,IAAI,CAACC,OAAOE,QAAQ,EAAE;YACpB,OAAO;QACT;QAEA,OAAO,IAAI,CAACN,cAAc,CAACO,QAAQ,CAACH,OAAOE,QAAQ;IACrD;IAQA,wCAAwC,GACxC,AAAOE,aAAa;QAClB,MAAMC,qBAAqB,OACzBP,KACAQ,KACAC;YAEA,IAAI;gBACF,OAAO,MAAM,IAAI,CAACC,kBAAkB,CAACV,KAAKQ,KAAKC;YACjD,EAAE,OAAOE,OAAY;gBACnBC,KAAIC,SAAS,CAACF;gBACd,+BAA+B;gBAC/BH,IAAIM,UAAU,GAAG;gBACjB,IAAI,OAAOH,UAAU,YAAYA,UAAU,MAAM;oBAC/CH,IAAIO,GAAG,CACLC,KAAKC,SAAS,CAAC;wBACbN,OAAOA,MAAMO,QAAQ;oBACvB;gBAEJ,OAAO;oBACLV,IAAIO,GAAG,CAAC,CAAC,kBAAkB,EAAEJ,OAAO;gBACtC;YACF;QACF;QACA,MAAMQ,aAAa,OAAOnB,KAAoBQ,KAAqBC;YACjE,IAAI,CAAC,IAAI,CAACV,mBAAmB,CAACC,MAAM;gBAClC,OAAOS;YACT;YACA,OAAOF,mBAAmBP,KAAKQ,KAAKC;QACtC;QAEAU,WAAWC,QAAQ,GAAGb;QAEtB,OAAOY;IACT;AACF;AAEO,SAASxB,qBAAqBa,GAAmB;IACtDA,IAAIa,SAAS,CAAC,iBAAiB;IAC/Bb,IAAIa,SAAS,CAAC,WAAW;IACzBb,IAAIa,SAAS,CAAC,UAAU;IACxB,OAAOb;AACT"}

package/build/src/start/server/middleware/FaviconMiddleware.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FaviconMiddleware", {
+    enumerable: true,
+    get: function() {
+        return FaviconMiddleware;
+    }
+});
+const _ExpoMiddleware = require("./ExpoMiddleware");
+const _favicon = require("../../../export/favicon");
+const debug = require('debug')('expo:start:server:middleware:favicon');
+class FaviconMiddleware extends _ExpoMiddleware.ExpoMiddleware {
+    constructor(projectRoot){
+        super(projectRoot, [
+            '/favicon.ico'
+        ]), this.projectRoot = projectRoot;
+    }
+    async handleRequestAsync(req, res, next) {
+        if (![
+            'GET',
+            'HEAD'
+        ].includes(req.method || '')) {
+            return next();
+        }
+        let faviconImageData;
+        try {
+            const data = await (0, _favicon.getFaviconFromExpoConfigAsync)(this.projectRoot, {
+                force: true
+            });
+            if (!data) {
+                debug('No favicon defined in the Expo Config, skipping generation.');
+                return next();
+            }
+            faviconImageData = data.source;
+            debug('✅ Generated favicon successfully.');
+        } catch (error) {
+            // Pass through on ENOENT errors
+            debug('Failed to generate favicon from Expo config:', error);
+            if (error.code === 'ENOENT') {
+                return next();
+            }
+            return next(error);
+        }
+        // Respond with the generated favicon file
+        res.setHeader('Content-Type', 'image/x-icon');
+        res.end(faviconImageData);
+    }
+}
+
+//# sourceMappingURL=FaviconMiddleware.js.map

package/build/src/start/server/middleware/FaviconMiddleware.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/start/server/middleware/FaviconMiddleware.ts"],"sourcesContent":["import { ExpoMiddleware } from './ExpoMiddleware';\nimport { ServerNext, ServerRequest, ServerResponse } from './server.types';\nimport { getFaviconFromExpoConfigAsync } from '../../../export/favicon';\n\nconst debug = require('debug')('expo:start:server:middleware:favicon') as typeof console.log;\n\n/**\n * Middleware for generating a favicon.ico file for the current project if one doesn't exist.\n *\n * Test by making a get request with:\n * curl -v http://localhost:8081/favicon.ico\n */\nexport class FaviconMiddleware extends ExpoMiddleware {\n  constructor(protected projectRoot: string) {\n    super(projectRoot, ['/favicon.ico']);\n  }\n\n  async handleRequestAsync(\n    req: ServerRequest,\n    res: ServerResponse,\n    next: ServerNext\n  ): Promise<void> {\n    if (!['GET', 'HEAD'].includes(req.method || '')) {\n      return next();\n    }\n\n    let faviconImageData: Buffer | null;\n    try {\n      const data = await getFaviconFromExpoConfigAsync(this.projectRoot, { force: true });\n      if (!data) {\n        debug('No favicon defined in the Expo Config, skipping generation.');\n        return next();\n      }\n      faviconImageData = data.source;\n      debug('✅ Generated favicon successfully.');\n    } catch (error: any) {\n      // Pass through on ENOENT errors\n      debug('Failed to generate favicon from Expo config:', error);\n      if (error.code === 'ENOENT') {\n        return next();\n      }\n      return next(error);\n    }\n    // Respond with the generated favicon file\n    res.setHeader('Content-Type', 'image/x-icon');\n    res.end(faviconImageData);\n  }\n}\n"],"names":["FaviconMiddleware","debug","require","ExpoMiddleware","constructor","projectRoot","handleRequestAsync","req","res","next","includes","method","faviconImageData","data","getFaviconFromExpoConfigAsync","force","source","error","code","setHeader","end"],"mappings":";;;;+BAYaA;;;eAAAA;;;gCAZkB;yBAEe;AAE9C,MAAMC,QAAQC,QAAQ,SAAS;AAQxB,MAAMF,0BAA0BG,8BAAc;IACnDC,YAAY,AAAUC,WAAmB,CAAE;QACzC,KAAK,CAACA,aAAa;YAAC;SAAe,QADfA,cAAAA;IAEtB;IAEA,MAAMC,mBACJC,GAAkB,EAClBC,GAAmB,EACnBC,IAAgB,EACD;QACf,IAAI,CAAC;YAAC;YAAO;SAAO,CAACC,QAAQ,CAACH,IAAII,MAAM,IAAI,KAAK;YAC/C,OAAOF;QACT;QAEA,IAAIG;QACJ,IAAI;YACF,MAAMC,OAAO,MAAMC,IAAAA,sCAA6B,EAAC,IAAI,CAACT,WAAW,EAAE;gBAAEU,OAAO;YAAK;YACjF,IAAI,CAACF,MAAM;gBACTZ,MAAM;gBACN,OAAOQ;YACT;YACAG,mBAAmBC,KAAKG,MAAM;YAC9Bf,MAAM;QACR,EAAE,OAAOgB,OAAY;YACnB,gCAAgC;YAChChB,MAAM,gDAAgDgB;YACtD,IAAIA,MAAMC,IAAI,KAAK,UAAU;gBAC3B,OAAOT;YACT;YACA,OAAOA,KAAKQ;QACd;QACA,0CAA0C;QAC1CT,IAAIW,SAAS,CAAC,gBAAgB;QAC9BX,IAAIY,GAAG,CAACR;IACV;AACF"}

package/build/src/start/server/middleware/HistoryFallbackMiddleware.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HistoryFallbackMiddleware", {
+    enumerable: true,
+    get: function() {
+        return HistoryFallbackMiddleware;
+    }
+});
+const _resolvePlatform = require("./resolvePlatform");
+class HistoryFallbackMiddleware {
+    constructor(indexMiddleware){
+        this.indexMiddleware = indexMiddleware;
+    }
+    getHandler() {
+        return (req, res, next)=>{
+            const platform = (0, _resolvePlatform.parsePlatformHeader)(req);
+            if (!platform || platform === 'web') {
+                // Redirect unknown to the manifest handler while preserving the path.
+                // This implements the HTML5 history fallback API.
+                return this.indexMiddleware(req, res, next);
+            }
+            return next();
+        };
+    }
+}
+
+//# sourceMappingURL=HistoryFallbackMiddleware.js.map

package/build/src/start/server/middleware/HistoryFallbackMiddleware.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/start/server/middleware/HistoryFallbackMiddleware.ts"],"sourcesContent":["import { parsePlatformHeader } from './resolvePlatform';\nimport { ServerNext, ServerRequest, ServerResponse } from './server.types';\n\n/**\n * Create a web-only middleware which redirects to the index middleware without losing the path component.\n * This is useful for things like React Navigation which need to render the index.html and then direct the user in-memory.\n */\nexport class HistoryFallbackMiddleware {\n  constructor(\n    private indexMiddleware: (\n      req: ServerRequest,\n      res: ServerResponse,\n      next: ServerNext\n    ) => Promise<void>\n  ) {}\n  getHandler() {\n    return (req: ServerRequest, res: ServerResponse, next: any) => {\n      const platform = parsePlatformHeader(req);\n\n      if (!platform || platform === 'web') {\n        // Redirect unknown to the manifest handler while preserving the path.\n        // This implements the HTML5 history fallback API.\n        return this.indexMiddleware(req, res, next);\n      }\n\n      return next();\n    };\n  }\n}\n"],"names":["HistoryFallbackMiddleware","constructor","indexMiddleware","getHandler","req","res","next","platform","parsePlatformHeader"],"mappings":";;;;+BAOaA;;;eAAAA;;;iCAPuB;AAO7B,MAAMA;IACXC,YACE,AAAQC,eAIU,CAClB;aALQA,kBAAAA;IAKP;IACHC,aAAa;QACX,OAAO,CAACC,KAAoBC,KAAqBC;YAC/C,MAAMC,WAAWC,IAAAA,oCAAmB,EAACJ;YAErC,IAAI,CAACG,YAAYA,aAAa,OAAO;gBACnC,sEAAsE;gBACtE,kDAAkD;gBAClD,OAAO,IAAI,CAACL,eAAe,CAACE,KAAKC,KAAKC;YACxC;YAEA,OAAOA;QACT;IACF;AACF"}