@expo/cli 0.13.2 → 0.15.0

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

@@ -7,13 +7,13 @@ exports.withExtendedResolver = withExtendedResolver;
 exports.shouldAliasAssetRegistryForWeb = shouldAliasAssetRegistryForWeb;
 exports.shouldAliasModule = shouldAliasModule;
 exports.withMetroMultiPlatformAsync = withMetroMultiPlatformAsync;
-var _chalk = _interopRequireDefault(require("chalk"));
 var _fs = _interopRequireDefault(require("fs"));
+var metroResolver = _interopRequireWildcard(require("metro-resolver"));
 var _path = _interopRequireDefault(require("path"));
 var _resolveFrom = _interopRequireDefault(require("resolve-from"));
+var _createExpoMetroResolver = require("./createExpoMetroResolver");
 var _externals = require("./externals");
 var _metroErrors = require("./metroErrors");
-var _resolveFromProject = require("./resolveFromProject");
 var _router = require("./router");
 var _withMetroResolvers = require("./withMetroResolvers");
 var _log = require("../../../log");
@@ -21,7 +21,6 @@ var _fileNotifier = require("../../../utils/FileNotifier");
 var _env = require("../../../utils/env");
 var _exit = require("../../../utils/exit");
 var _interactive = require("../../../utils/interactive");
-var _link = require("../../../utils/link");
 var _loadTsConfigPaths = require("../../../utils/tsconfig/loadTsConfigPaths");
 var _resolveWithTsConfigPaths = require("../../../utils/tsconfig/resolveWithTsConfigPaths");
 var _webSupportProjectPrerequisite = require("../../doctor/web/WebSupportProjectPrerequisite");
@@ -30,22 +29,43 @@ function _interopRequireDefault(obj) {
         default: obj
     };
 }
+function _interopRequireWildcard(obj) {
+    if (obj && obj.__esModule) {
+        return obj;
+    } else {
+        var newObj = {};
+        if (obj != null) {
+            for(var key in obj){
+                if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                    var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
+                    if (desc.get || desc.set) {
+                        Object.defineProperty(newObj, key, desc);
+                    } else {
+                        newObj[key] = obj[key];
+                    }
+                }
+            }
+        }
+        newObj.default = obj;
+        return newObj;
+    }
+}
 const debug = require("debug")("expo:start:server:metro:multi-platform");
-function withWebPolyfills(config, projectRoot) {
+function withWebPolyfills(config) {
     const originalGetPolyfills = config.serializer.getPolyfills ? config.serializer.getPolyfills.bind(config.serializer) : ()=>[]
     ;
     const getPolyfills = (ctx)=>{
         if (ctx.platform === "web") {
             return [
                 // NOTE: We might need this for all platforms
-                _path.default.join(projectRoot, _externals.EXTERNAL_REQUIRE_POLYFILL)
+                _path.default.join(config.projectRoot, _externals.EXTERNAL_REQUIRE_POLYFILL)
             ];
         }
         // Generally uses `rn-get-polyfills`
         const polyfills = originalGetPolyfills(ctx);
         return [
             ...polyfills,
-            _externals.EXTERNAL_REQUIRE_NATIVE_POLYFILL
+            _path.default.join(config.projectRoot, _externals.EXTERNAL_REQUIRE_NATIVE_POLYFILL)
         ];
     };
     return {
@@ -72,19 +92,23 @@ function getNodejsExtensions(srcExts) {
     nodejsSourceExtensions.splice(jsIndex + 1, 0, ...mjsExts);
     return nodejsSourceExtensions;
 }
-function withExtendedResolver(config, { projectRoot , tsconfig , platforms , isTsconfigPathsEnabled  }) {
+function withExtendedResolver(config, { tsconfig , platforms , isTsconfigPathsEnabled , isFastResolverEnabled , isExporting  }) {
+    var ref5, ref1, ref2, ref3;
+    if (isFastResolverEnabled) {
+        _log.Log.warn(`Experimental bundling features are enabled.`);
+    }
     // Get the `transformer.assetRegistryPath`
     // this needs to be unified since you can't dynamically
     // swap out the transformer based on platform.
-    const assetRegistryPath = _fs.default.realpathSync(// This is the native asset registry alias for native.
-    _path.default.resolve((0, _resolveFrom).default(projectRoot, "react-native/Libraries/Image/AssetRegistry")));
-    let reactNativeWebAppContainer = null;
-    try {
-        reactNativeWebAppContainer = _fs.default.realpathSync(// This is the native asset registry alias for native.
-        _path.default.resolve((0, _resolveFrom).default(projectRoot, "expo-router/build/fork/react-native-web-container")));
-    } catch  {}
-    const isWebEnabled = platforms.includes("web");
-    const { resolve  } = (0, _resolveFromProject).importMetroResolverFromProject(projectRoot);
+    const assetRegistryPath = _fs.default.realpathSync(_path.default.resolve((0, _resolveFrom).default(config.projectRoot, "@react-native/assets-registry/registry.js")));
+    const defaultResolver = metroResolver.resolve;
+    var ref4;
+    const resolver = isFastResolverEnabled ? (0, _createExpoMetroResolver).createFastResolver({
+        preserveSymlinks: (ref4 = (ref5 = config.resolver) == null ? void 0 : ref5.unstable_enableSymlinks) != null ? ref4 : false,
+        blockList: Array.isArray((ref1 = config.resolver) == null ? void 0 : ref1.blockList) ? (ref2 = config.resolver) == null ? void 0 : ref2.blockList : [
+            (ref3 = config.resolver) == null ? void 0 : ref3.blockList
+        ]
+    }) : defaultResolver;
     const extraNodeModules = {};
     const aliases = {
         web: {
@@ -92,6 +116,8 @@ function withExtendedResolver(config, { projectRoot , tsconfig , platforms , isT
             "react-native/index": "react-native-web"
         }
     };
+    // TODO: We can probably drop this resolution hack.
+    const isWebEnabled = platforms.includes("web");
     if (isWebEnabled) {
         // Allow `react-native-web` to be optional when web is not enabled but path aliases is.
         extraNodeModules["web"] = {
@@ -113,191 +139,239 @@ function withExtendedResolver(config, { projectRoot , tsconfig , platforms , isT
         paths: (_paths1 = tsconfig.paths) != null ? _paths1 : {},
         baseUrl: tsconfig.baseUrl
     }) : null;
-    if (isTsconfigPathsEnabled && (0, _interactive).isInteractive()) {
-        // TODO: We should track all the files that used imports and invalidate them
-        // currently the user will need to save all the files that use imports to
-        // use the new aliases.
-        const configWatcher = new _fileNotifier.FileNotifier(projectRoot, [
-            "./tsconfig.json",
-            "./jsconfig.json"
-        ]);
-        configWatcher.startObserving(()=>{
-            debug("Reloading tsconfig.json");
-            (0, _loadTsConfigPaths).loadTsConfigPathsAsync(projectRoot).then((tsConfigPaths)=>{
-                if ((tsConfigPaths == null ? void 0 : tsConfigPaths.paths) && !!Object.keys(tsConfigPaths.paths).length) {
-                    debug("Enabling tsconfig.json paths support");
-                    var _paths;
-                    tsConfigResolve = _resolveWithTsConfigPaths.resolveWithTsConfigPaths.bind(_resolveWithTsConfigPaths.resolveWithTsConfigPaths, {
-                        paths: (_paths = tsConfigPaths.paths) != null ? _paths : {},
-                        baseUrl: tsConfigPaths.baseUrl
-                    });
-                } else {
-                    debug("Disabling tsconfig.json paths support");
-                    tsConfigResolve = null;
-                }
+    // TODO: Move this to be a transform key for invalidation.
+    if (!isExporting && (0, _interactive).isInteractive()) {
+        if (isTsconfigPathsEnabled) {
+            // TODO: We should track all the files that used imports and invalidate them
+            // currently the user will need to save all the files that use imports to
+            // use the new aliases.
+            const configWatcher = new _fileNotifier.FileNotifier(config.projectRoot, [
+                "./tsconfig.json",
+                "./jsconfig.json", 
+            ]);
+            configWatcher.startObserving(()=>{
+                debug("Reloading tsconfig.json");
+                (0, _loadTsConfigPaths).loadTsConfigPathsAsync(config.projectRoot).then((tsConfigPaths)=>{
+                    if ((tsConfigPaths == null ? void 0 : tsConfigPaths.paths) && !!Object.keys(tsConfigPaths.paths).length) {
+                        debug("Enabling tsconfig.json paths support");
+                        var _paths;
+                        tsConfigResolve = _resolveWithTsConfigPaths.resolveWithTsConfigPaths.bind(_resolveWithTsConfigPaths.resolveWithTsConfigPaths, {
+                            paths: (_paths = tsConfigPaths.paths) != null ? _paths : {},
+                            baseUrl: tsConfigPaths.baseUrl
+                        });
+                    } else {
+                        debug("Disabling tsconfig.json paths support");
+                        tsConfigResolve = null;
+                    }
+                });
             });
-        });
-        // TODO: This probably prevents the process from exiting.
-        (0, _exit).installExitHooks(()=>{
-            configWatcher.stopObserving();
-        });
-    } else {
-        debug("Skipping tsconfig.json paths support");
+            // TODO: This probably prevents the process from exiting.
+            (0, _exit).installExitHooks(()=>{
+                configWatcher.stopObserving();
+            });
+        } else {
+            debug("Skipping tsconfig.json paths support");
+        }
     }
     let nodejsSourceExtensions = null;
-    return (0, _withMetroResolvers).withMetroResolvers(config, projectRoot, [
-        // Add a resolver to alias the web asset resolver.
-        (immutableContext, moduleName1, platform)=>{
-            var ref;
-            let context = {
-                ...immutableContext
-            };
-            const environment = (ref = context.customResolverOptions) == null ? void 0 : ref.environment;
-            const isNode = environment === "node";
-            // TODO: We need to prevent the require.context from including API routes as these use externals.
-            // Should be fine after async routes lands.
-            if (isNode) {
-                const moduleId = (0, _externals).isNodeExternal(moduleName1);
-                if (moduleId) {
-                    moduleName1 = (0, _externals).getNodeExternalModuleId(context.originModulePath, moduleId);
-                    debug(`Redirecting Node.js external "${moduleId}" to "${moduleName1}"`);
-                }
-                // Adjust nodejs source extensions to sort mjs after js, including platform variants.
-                if (nodejsSourceExtensions === null) {
-                    nodejsSourceExtensions = getNodejsExtensions(context.sourceExts);
+    const shimsFolder = _path.default.join(config.projectRoot, _externals.METRO_SHIMS_FOLDER);
+    function getStrictResolver({ resolveRequest , ...context }, platform) {
+        return function doResolve(moduleName) {
+            return resolver(context, moduleName, platform);
+        };
+    }
+    function getOptionalResolver(context, platform) {
+        const doResolve = getStrictResolver(context, platform);
+        return function optionalResolve(moduleName) {
+            try {
+                return doResolve(moduleName);
+            } catch (error) {
+                // If the error is directly related to a resolver not being able to resolve a module, then
+                // we can ignore the error and try the next resolver. Otherwise, we should throw the error.
+                const isResolutionError = (0, _metroErrors).isFailedToResolveNameError(error) || (0, _metroErrors).isFailedToResolvePathError(error);
+                if (!isResolutionError) {
+                    throw error;
                 }
-                context.sourceExts = nodejsSourceExtensions;
-            }
-            // Conditionally remap `react-native` to `react-native-web` on web in
-            // a way that doesn't require Babel to resolve the alias.
-            if (platform && platform in aliases && aliases[platform][moduleName1]) {
-                moduleName1 = aliases[platform][moduleName1];
-            }
-            // TODO: We may be able to remove this in the future, it's doing no harm
-            // by staying here.
-            // Conditionally remap `react-native` to `react-native-web`
-            if (platform && platform in extraNodeModules) {
-                context.extraNodeModules = {
-                    ...extraNodeModules[platform],
-                    ...context.extraNodeModules
-                };
             }
-            if ((tsconfig == null ? void 0 : tsconfig.baseUrl) && isTsconfigPathsEnabled) {
-                context = {
-                    ...context,
-                    nodeModulesPaths: [
-                        ...immutableContext.nodeModulesPaths,
-                        // add last to ensure node modules are resolved first
-                        tsconfig.baseUrl, 
-                    ]
-                };
-            }
-            let mainFields = context.mainFields;
-            if (isNode) {
-                // Node.js runtimes should only be importing main at the moment.
-                // This is a temporary fix until we can support the package.json exports.
-                mainFields = [
-                    "main",
-                    "module"
-                ];
-            } else if (_env.env.EXPO_METRO_NO_MAIN_FIELD_OVERRIDE) {
-                mainFields = context.mainFields;
-            } else if (platform && platform in preferredMainFields) {
-                mainFields = preferredMainFields[platform];
+            return null;
+        };
+    }
+    const metroConfigWithCustomResolver = (0, _withMetroResolvers).withMetroResolvers(config, [
+        // tsconfig paths
+        (context, moduleName, platform)=>{
+            var ref;
+            return (ref = tsConfigResolve == null ? void 0 : tsConfigResolve({
+                originModulePath: context.originModulePath,
+                moduleName
+            }, getOptionalResolver(context, platform))) != null ? ref : null;
+        },
+        // Node.js built-ins get empty externals on web
+        (context, moduleName, platform)=>{
+            var // Skip when targeting server runtimes
+            ref;
+            if (isFastResolverEnabled || // is web
+            platform !== "web" || ((ref = context.customResolverOptions) == null ? void 0 : ref.environment) === "node" || // This transform only applies to Node.js built-ins
+            !(0, _externals).isNodeExternal(moduleName)) {
+                return null;
             }
-            function doResolve(moduleName) {
-                return resolve({
-                    ...context,
-                    resolveRequest: undefined,
-                    mainFields,
-                    // Passing `mainFields` directly won't be considered (in certain version of Metro)
-                    // we need to extend the `getPackageMainPath` directly to
-                    // use platform specific `mainFields`.
-                    // @ts-ignore
-                    getPackageMainPath (packageJsonPath) {
-                        // @ts-expect-error: mainFields is not on type
-                        const package_ = context.moduleCache.getPackage(packageJsonPath);
-                        return package_.getMain(mainFields);
-                    }
-                }, moduleName, platform);
+            // Perform optional resolve first. If the module doesn't exist (no module in the node_modules)
+            // then we can mock the file to use an empty module.
+            const result = getOptionalResolver(context, platform)(moduleName);
+            return result != null ? result : {
+                // In this case, mock the file to use an empty module.
+                type: "empty"
+            };
+        },
+        // Node.js externals support
+        (context, moduleName, platform)=>{
+            var // Only apply to server runtimes
+            ref;
+            if (// is web
+            platform !== "web" || ((ref = context.customResolverOptions) == null ? void 0 : ref.environment) !== "node") {
+                return null;
             }
-            function optionalResolve(moduleName) {
-                try {
-                    return doResolve(moduleName);
-                } catch (error) {
-                    // If the error is directly related to a resolver not being able to resolve a module, then
-                    // we can ignore the error and try the next resolver. Otherwise, we should throw the error.
-                    const isResolutionError = (0, _metroErrors).isFailedToResolveNameError(error) || (0, _metroErrors).isFailedToResolvePathError(error);
-                    if (!isResolutionError) {
-                        throw error;
-                    }
-                }
+            const moduleId = (0, _externals).isNodeExternal(moduleName);
+            if (!moduleId) {
                 return null;
             }
-            let result = null;
-            // React Native uses `event-target-shim` incorrectly and this causes the native runtime
-            // to fail to load. This is a temporary workaround until we can fix this upstream.
-            // https://github.com/facebook/react-native/pull/38628
-            if (moduleName1.includes("event-target-shim") && context.originModulePath.includes(_path.default.sep + "react-native" + _path.default.sep)) {
-                context.sourceExts = context.sourceExts.filter((f)=>!f.includes("mjs")
-                );
-                debug("Skip mjs support for event-target-shim in:", context.originModulePath);
+            const redirectedModuleName = (0, _externals).getNodeExternalModuleId(context.originModulePath, moduleId);
+            debug(`Redirecting Node.js external "${moduleId}" to "${redirectedModuleName}"`);
+            const doResolve = getStrictResolver(context, platform);
+            return doResolve(redirectedModuleName);
+        },
+        // Basic moduleId aliases
+        (context, moduleName, platform)=>{
+            // Conditionally remap `react-native` to `react-native-web` on web in
+            // a way that doesn't require Babel to resolve the alias.
+            if (platform && platform in aliases && aliases[platform][moduleName]) {
+                const redirectedModuleName = aliases[platform][moduleName];
+                const doResolve = getStrictResolver(context, platform);
+                return doResolve(redirectedModuleName);
             }
-            if (tsConfigResolve) {
-                result = tsConfigResolve({
-                    originModulePath: context.originModulePath,
-                    moduleName: moduleName1
-                }, optionalResolve);
+            return null;
+        },
+        // HACK(EvanBacon):
+        // React Native uses `event-target-shim` incorrectly and this causes the native runtime
+        // to fail to load. This is a temporary workaround until we can fix this upstream.
+        // https://github.com/facebook/react-native/pull/38628
+        (context, moduleName, platform)=>{
+            if (platform !== "web" && moduleName === "event-target-shim") {
+                debug("For event-target-shim to use js:", context.originModulePath);
+                const doResolve = getStrictResolver(context, platform);
+                return doResolve("event-target-shim/dist/event-target-shim.js");
             }
-            if (// is web
-            platform === "web" && // Not server runtime
-            !isNode && // Is Node.js built-in
-            (0, _externals).isNodeExternal(moduleName1)) {
-                // Perform optional resolve first. If the module doesn't exist (no module in the node_modules)
-                // then we can mock the file to use an empty module.
-                result != null ? result : result = optionalResolve(moduleName1);
-                if (!result) {
-                    // In this case, mock the file to use an empty module.
-                    return {
-                        type: "empty"
-                    };
-                }
+            return null;
+        },
+        // TODO: Reduce these as much as possible in the future.
+        // Complex post-resolution rewrites.
+        (context, moduleName, platform)=>{
+            const doResolve = getStrictResolver(context, platform);
+            const result = doResolve(moduleName);
+            if (result.type !== "sourceFile") {
+                return result;
             }
-            result != null ? result : result = doResolve(moduleName1);
-            if (result) {
-                // Replace the web resolver with the original one.
-                // This is basically an alias for web-only.
-                if (shouldAliasAssetRegistryForWeb(platform, result)) {
-                    // @ts-expect-error: `readonly` for some reason.
-                    result.filePath = assetRegistryPath;
-                }
-                // React Native Web adds a couple extra divs for no reason, these
-                // make static rendering much harder as we expect the root element to be `<html>`.
-                // This resolution will alias to a simple in-out component to avoid React Native web.
-                if (// Only apply the transform if expo-router is present.
-                reactNativeWebAppContainer && shouldAliasModule({
-                    platform,
-                    result
-                }, {
-                    platform: "web",
-                    output: "react-native-web/dist/exports/AppRegistry/AppContainer.js"
-                })) {
+            // Replace the web resolver with the original one.
+            // This is basically an alias for web-only.
+            // TODO: Drop this in favor of the standalone asset registry module.
+            if (shouldAliasAssetRegistryForWeb(platform, result)) {
+                // @ts-expect-error: `readonly` for some reason.
+                result.filePath = assetRegistryPath;
+            }
+            if (platform === "web" && result.filePath.includes("node_modules")) {
+                // Replace with static shims
+                const normalName = normalizeSlashes(result.filePath)// Drop everything up until the `node_modules` folder.
+                .replace(/.*node_modules\//, "");
+                const shimPath = _path.default.join(shimsFolder, normalName);
+                if (_fs.default.existsSync(shimPath)) {
                     // @ts-expect-error: `readonly` for some reason.
-                    result.filePath = reactNativeWebAppContainer;
+                    result.filePath = shimPath;
                 }
             }
             return result;
         }, 
     ]);
+    // Ensure we mutate the resolution context to include the custom resolver options for server and web.
+    const metroConfigWithCustomContext = (0, _withMetroResolvers).withMetroMutatedResolverContext(metroConfigWithCustomResolver, (immutableContext, moduleName, platform)=>{
+        var ref;
+        const context = {
+            ...immutableContext
+        };
+        if (((ref = context.customResolverOptions) == null ? void 0 : ref.environment) === "node") {
+            // Adjust nodejs source extensions to sort mjs after js, including platform variants.
+            if (nodejsSourceExtensions === null) {
+                nodejsSourceExtensions = getNodejsExtensions(context.sourceExts);
+            }
+            context.sourceExts = nodejsSourceExtensions;
+            context.unstable_enablePackageExports = true;
+            context.unstable_conditionNames = [
+                "node",
+                "require"
+            ];
+            context.unstable_conditionsByPlatform = {};
+            // Node.js runtimes should only be importing main at the moment.
+            // This is a temporary fix until we can support the package.json exports.
+            context.mainFields = [
+                "main",
+                "module"
+            ];
+        } else {
+            // Non-server changes
+            if (!_env.env.EXPO_METRO_NO_MAIN_FIELD_OVERRIDE && platform && platform in preferredMainFields) {
+                context.mainFields = preferredMainFields[platform];
+            }
+        }
+        // TODO: We may be able to remove this in the future, it's doing no harm
+        // by staying here.
+        // Conditionally remap `react-native` to `react-native-web`
+        if (platform && platform in extraNodeModules) {
+            context.extraNodeModules = {
+                ...extraNodeModules[platform],
+                ...context.extraNodeModules
+            };
+        }
+        if ((tsconfig == null ? void 0 : tsconfig.baseUrl) && isTsconfigPathsEnabled) {
+            const nodeModulesPaths = [
+                ...immutableContext.nodeModulesPaths
+            ];
+            if (isFastResolverEnabled) {
+                // add last to ensure node modules are resolved first
+                nodeModulesPaths.push(_path.default.isAbsolute(tsconfig.baseUrl) ? tsconfig.baseUrl : _path.default.join(config.projectRoot, tsconfig.baseUrl));
+            } else {
+                // add last to ensure node modules are resolved first
+                nodeModulesPaths.push(tsconfig.baseUrl);
+            }
+            context.nodeModulesPaths = nodeModulesPaths;
+        }
+        // TODO: We can drop this in the next version upgrade (SDK 50).
+        const mainFields = context.mainFields;
+        return {
+            ...context,
+            preferNativePlatform: platform !== "web",
+            // Passing `mainFields` directly won't be considered (in certain version of Metro)
+            // we need to extend the `getPackageMainPath` directly to
+            // use platform specific `mainFields`.
+            // @ts-ignore
+            getPackageMainPath (packageJsonPath) {
+                // @ts-expect-error: mainFields is not on type
+                const package_ = context.moduleCache.getPackage(packageJsonPath);
+                return package_.getMain(mainFields);
+            }
+        };
+    });
+    return (0, _withMetroResolvers).withMetroErrorReportingResolver(metroConfigWithCustomContext);
 }
 function shouldAliasAssetRegistryForWeb(platform, result) {
     return platform === "web" && (result == null ? void 0 : result.type) === "sourceFile" && typeof (result == null ? void 0 : result.filePath) === "string" && normalizeSlashes(result.filePath).endsWith("react-native-web/dist/modules/AssetRegistry/index.js");
 }
 function shouldAliasModule(input, alias) {
-    var ref, ref1;
-    return input.platform === alias.platform && ((ref = input.result) == null ? void 0 : ref.type) === "sourceFile" && typeof ((ref1 = input.result) == null ? void 0 : ref1.filePath) === "string" && normalizeSlashes(input.result.filePath).endsWith(alias.output);
+    var ref, ref6;
+    return input.platform === alias.platform && ((ref = input.result) == null ? void 0 : ref.type) === "sourceFile" && typeof ((ref6 = input.result) == null ? void 0 : ref6.filePath) === "string" && normalizeSlashes(input.result.filePath).endsWith(alias.output);
 }
-async function withMetroMultiPlatformAsync(projectRoot, { config , platformBundlers , isTsconfigPathsEnabled , webOutput , routerDirectory  }) {
+async function withMetroMultiPlatformAsync(projectRoot, { config , platformBundlers , isTsconfigPathsEnabled , webOutput , routerDirectory , isFastResolverEnabled , isExporting  }) {
+    if (!config.projectRoot) {
+        // @ts-expect-error: read-only types
+        config.projectRoot = projectRoot;
+    }
     // Auto pick app entry for router.
     process.env.EXPO_ROUTER_APP_ROOT = (0, _router).getAppRouterRelativeEntryPath(projectRoot, routerDirectory);
     var _EXPO_PUBLIC_PROJECT_ROOT;
@@ -310,6 +384,15 @@ async function withMetroMultiPlatformAsync(projectRoot, { config , platformBundl
         // Enable static rendering in runtime space.
         process.env.EXPO_PUBLIC_USE_STATIC = "1";
     }
+    // This is used for running Expo CLI in development against projects outside the monorepo.
+    if (!isDirectoryIn(__dirname, projectRoot)) {
+        if (!config.watchFolders) {
+            // @ts-expect-error: watchFolders is readonly
+            config.watchFolders = [];
+        }
+        // @ts-expect-error: watchFolders is readonly
+        config.watchFolders.push(_path.default.join(require.resolve("metro-runtime/package.json"), "../.."));
+    }
     // Ensure the cache is invalidated if these values change.
     // @ts-expect-error
     config.transformer._expoRouterRootDirectory = process.env.EXPO_ROUTER_APP_ROOT;
@@ -321,18 +404,10 @@ async function withMetroMultiPlatformAsync(projectRoot, { config , platformBundl
     }
     let tsconfig = null;
     if (isTsconfigPathsEnabled) {
-        _log.Log.warn(_chalk.default.yellow`Experimental path aliases feature is enabled. ` + (0, _link).learnMore("https://docs.expo.dev/guides/typescript/#path-aliases"));
         tsconfig = await (0, _loadTsConfigPaths).loadTsConfigPathsAsync(projectRoot);
     }
+    await (0, _externals).setupShimFiles(projectRoot);
     await (0, _externals).setupNodeExternals(projectRoot);
-    return withMetroMultiPlatform(projectRoot, {
-        config,
-        platformBundlers,
-        tsconfig,
-        isTsconfigPathsEnabled
-    });
-}
-function withMetroMultiPlatform(projectRoot, { config , platformBundlers , isTsconfigPathsEnabled , tsconfig  }) {
     let expoConfigPlatforms = Object.entries(platformBundlers).filter(([, bundler])=>bundler === "metro"
     ).map(([platform])=>platform
     );
@@ -343,15 +418,17 @@ function withMetroMultiPlatform(projectRoot, { config , platformBundlers , isTsc
     }
     // @ts-expect-error: typed as `readonly`.
     config.resolver.platforms = expoConfigPlatforms;
-    if (expoConfigPlatforms.includes("web")) {
-        config = withWebPolyfills(config, projectRoot);
-    }
+    config = withWebPolyfills(config);
     return withExtendedResolver(config, {
-        projectRoot,
         tsconfig,
+        isExporting,
         isTsconfigPathsEnabled,
-        platforms: expoConfigPlatforms
+        platforms: expoConfigPlatforms,
+        isFastResolverEnabled
     });
 }
+function isDirectoryIn(a, b) {
+    return b.startsWith(a) && b.length > a.length;
+}
 
 //# sourceMappingURL=withMetroMultiPlatform.js.map