@nx/expo 23.2.0-beta.6 → 23.2.0-beta.8

package/dist/plugins/metro-resolver.d.ts

@@ -1 +1,4 @@
-export declare function getResolveRequest(extensions: string[], exportsConditionNames?: string[], mainFields?: string[]): (_context: any, realModuleName: string, platform: string | null) => any;
+export declare function getResolveRequest(extensions: string[], exportsConditionNames?: string[], mainFields?: string[], anchor?: {
+    appRoot?: string;
+    usesExpoMetro: boolean;
+}): (_context: any, realModuleName: string, platform: string | null) => any;

package/dist/plugins/metro-resolver.js

@@ -9,29 +9,28 @@ const enhanced_resolve_1 = require("enhanced-resolve");
 const path_1 = require("path");
 const fs = tslib_1.__importStar(require("fs"));
 const devkit_1 = require("@nx/devkit");
-// Cache for metro-resolver module
-let metroResolver = null;
-/**
- * Lazily require the Metro resolver.
- *
- * Expo SDK 55+ ships Metro through `@expo/metro`, so the resolver must come
- * from the same Metro instance Expo uses. Older SDKs (53/54) use the standalone
- * `metro-resolver` package. We prefer `@expo/metro` and fall back to the
- * standalone package to stay compatible with both.
- */
-function getMetroResolver() {
+const metroResolverCache = new Map();
+// The resolver must come from the same Metro instance Expo uses: `@expo/metro`
+// on SDK 55+, standalone `metro-resolver` on 53/54. Resolve from the app root
+// so each app gets its own SDK's copy.
+function getMetroResolver(appRoot, usesExpoMetro) {
+    const cacheKey = `${appRoot ?? ''}|${usesExpoMetro}`;
+    let metroResolver = metroResolverCache.get(cacheKey);
     if (!metroResolver) {
-        try {
-            metroResolver = require('@expo/metro/metro-resolver');
-        }
-        catch {
+        const candidates = usesExpoMetro
+            ? ['@expo/metro/metro-resolver', 'metro-resolver']
+            : ['metro-resolver', '@expo/metro/metro-resolver'];
+        for (const candidate of candidates) {
             try {
-                metroResolver = require('metro-resolver');
-            }
-            catch (error) {
-                throw new Error('Unable to load Metro resolver. Install `@expo/metro` (Expo SDK 55+) or `metro-resolver` (>= 0.82.0).');
+                metroResolver = require(require.resolve(candidate, appRoot ? { paths: [appRoot] } : undefined));
+                break;
             }
+            catch { }
+        }
+        if (!metroResolver) {
+            throw new Error('Unable to load Metro resolver. Install `@expo/metro` (Expo SDK 55+) or `metro-resolver` (>= 0.82.0).');
         }
+        metroResolverCache.set(cacheKey, metroResolver);
     }
     return metroResolver;
 }
@@ -41,13 +40,17 @@ function getMetroResolver() {
  * This resolve function requires projectRoot to be set to
  * workspace root in order modules and assets to be registered and watched.
  */
-function getResolveRequest(extensions, exportsConditionNames = [], mainFields = []) {
+function getResolveRequest(extensions, exportsConditionNames = [], mainFields = [], 
+// which app is being bundled; default keeps the process-wide preference
+anchor = {
+    usesExpoMetro: true,
+}) {
     return function (_context, realModuleName, platform) {
         const debug = process.env.NX_REACT_NATIVE_DEBUG === 'true';
         const { resolveRequest, ...context } = _context;
         const resolvedPath = resolveRequestFromContext(resolveRequest, _context, realModuleName, platform, debug) ??
-            defaultMetroResolver(context, realModuleName, platform, debug) ??
-            tsconfigPathsResolver(context, extensions, realModuleName, platform, debug) ??
+            defaultMetroResolver(context, realModuleName, platform, debug, anchor) ??
+            tsconfigPathsResolver(context, extensions, realModuleName, platform, debug, anchor) ??
             pnpmResolver(extensions, context, realModuleName, debug, exportsConditionNames, mainFields);
         if (resolvedPath) {
             return resolvedPath;
@@ -71,9 +74,9 @@ function resolveRequestFromContext(resolveRequest, context, realModuleName, plat
  * This function try to resolve path using metro's default resolver
  * @returns path if resolved, else undefined
  */
-function defaultMetroResolver(context, realModuleName, platform, debug) {
+function defaultMetroResolver(context, realModuleName, platform, debug, anchor) {
     try {
-        const resolver = getMetroResolver();
+        const resolver = getMetroResolver(anchor.appRoot, anchor.usesExpoMetro);
         return resolver.resolve(context, realModuleName, platform);
     }
     catch {
@@ -109,11 +112,11 @@ function pnpmResolver(extensions, context, realModuleName, debug, exportsConditi
  * This function try to resolve files that are specified in tsconfig's paths
  * @returns path if resolved, else undefined
  */
-function tsconfigPathsResolver(context, extensions, realModuleName, platform, debug) {
+function tsconfigPathsResolver(context, extensions, realModuleName, platform, debug, anchor) {
     try {
         const tsConfigPathMatcher = getMatcher(debug);
         const match = tsConfigPathMatcher(realModuleName, undefined, undefined, extensions.map((ext) => `.${ext}`));
-        const resolver = getMetroResolver();
+        const resolver = getMetroResolver(anchor.appRoot, anchor.usesExpoMetro);
         return resolver.resolve(context, match, platform);
     }
     catch {

package/dist/plugins/with-nx-metro.d.ts

@@ -1,3 +1,4 @@
+export declare function appUsesExpoMetro(appRoot: string | undefined): boolean;
 type MetroConfig = any;
 interface WithNxOptions {
     /**

package/dist/plugins/with-nx-metro.js

@@ -1,36 +1,66 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.appUsesExpoMetro = appUsesExpoMetro;
 exports.withNxMetro = withNxMetro;
 const devkit_1 = require("@nx/devkit");
 const node_fs_1 = require("node:fs");
 const path_1 = require("path");
-// Cache for metro-config module
-let metroConfig = null;
-/**
- * Lazily require the Metro config helpers.
- *
- * Expo SDK 55+ ships Metro through the `@expo/metro` package family, so the
- * `mergeConfig` used here must come from the same Metro instance that
- * `@expo/metro-config`'s `getDefaultConfig` is built against. Older SDKs
- * (53/54) use the standalone `metro-config` package. We prefer `@expo/metro`
- * and fall back to the standalone package to stay compatible with both.
- */
-function getMetroConfig() {
+const metroConfigCache = new Map();
+// `mergeConfig` must come from the same Metro instance as the app's
+// `getDefaultConfig`: `@expo/metro` on SDK 55+, standalone `metro-config` on
+// 53/54. Resolve from the app root so each app gets its own SDK's copy.
+function getMetroConfig(appRoot, usesExpoMetro) {
+    const cacheKey = `${appRoot ?? ''}|${usesExpoMetro}`;
+    let metroConfig = metroConfigCache.get(cacheKey);
     if (!metroConfig) {
-        try {
-            metroConfig = require('@expo/metro/metro-config');
-        }
-        catch {
+        const candidates = usesExpoMetro
+            ? ['@expo/metro/metro-config', 'metro-config']
+            : ['metro-config', '@expo/metro/metro-config'];
+        for (const candidate of candidates) {
             try {
-                metroConfig = require('metro-config');
-            }
-            catch (error) {
-                throw new Error('Unable to load Metro config. Install `@expo/metro` (Expo SDK 55+) or `metro-config` (>= 0.82.0).');
+                metroConfig = require(require.resolve(candidate, appRoot ? { paths: [appRoot] } : undefined));
+                break;
             }
+            catch { }
         }
+        if (!metroConfig) {
+            throw new Error('Unable to load Metro config. Install `@expo/metro` (Expo SDK 55+) or `metro-config` (>= 0.82.0).');
+        }
+        metroConfigCache.set(cacheKey, metroConfig);
     }
     return metroConfig;
 }
+// SDK 55+ ships Metro through `@expo/metro`. Resolve `expo` from the app's
+// own root: probing from this plugin's location reads whichever copy is
+// hoisted, which can belong to a sibling app on a different SDK.
+function appUsesExpoMetro(appRoot) {
+    try {
+        const expoPkgPath = require.resolve('expo/package.json', appRoot ? { paths: [appRoot] } : undefined);
+        return parseInt(require(expoPkgPath).version, 10) >= 55;
+    }
+    catch {
+        // expo not resolvable; probe `@expo/metro` process-wide (no root entry
+        // point, so resolve a known subpath)
+        try {
+            require.resolve('@expo/metro/metro-config');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function appOwnsExpo(appNodeModules) {
+    const appExpo = (0, path_1.join)(appNodeModules, 'expo');
+    if (!(0, node_fs_1.existsSync)(appExpo))
+        return false;
+    const hoistedExpo = (0, path_1.join)(devkit_1.workspaceRoot, 'node_modules', 'expo');
+    // no hoisted copy: the app-local one is the only expo, and Expo's HMR
+    // rewrite resolves strictly from `projectRoot`, so anchor at the app
+    if (!(0, node_fs_1.existsSync)(hoistedExpo))
+        return true;
+    return (0, node_fs_1.realpathSync)(appExpo) !== (0, node_fs_1.realpathSync)(hoistedExpo);
+}
 const metro_resolver_1 = require("./metro-resolver");
 function withNxMetro(userConfig, opts = {}) {
     const extensions = ['', 'ts', 'tsx', 'js', 'jsx', 'json'];
@@ -46,30 +76,30 @@ function withNxMetro(userConfig, opts = {}) {
         watchFolders = watchFolders.concat(opts.watchFolders);
     }
     watchFolders = [...new Set(watchFolders)].filter((folder) => (0, node_fs_1.existsSync)(folder));
-    // Expo SDK 55+ ships Metro via `@expo/metro` and resolves the project's
-    // Babel config relative to `projectRoot`. Forcing `projectRoot` to the
-    // workspace root breaks that lookup, because the app's `.babelrc.js` lives in
-    // the project directory, not the workspace root (Metro's babel transformer
-    // does `path.resolve(projectRoot, '.babelrc.js')`). So only override
-    // `projectRoot` for older SDKs (53/54). Workspace libraries remain resolvable
-    // via `watchFolders`, `nodeModulesPaths`, and the custom `resolveRequest`.
-    // `@expo/metro` has no root entry point (only subpath exports), so resolve a
-    // known subpath to detect it — `require.resolve('@expo/metro')` would throw
-    // ERR_PACKAGE_PATH_NOT_EXPORTED even when the package is installed.
-    let usesExpoMetro = false;
-    try {
-        require.resolve('@expo/metro/metro-config');
-        usesExpoMetro = true;
-    }
-    catch { }
+    // `getDefaultConfig(__dirname)` set this to the app directory
+    const appRoot = userConfig.projectRoot;
+    const usesExpoMetro = appUsesExpoMetro(appRoot);
+    const appNodeModules = appRoot ? (0, path_1.join)(appRoot, 'node_modules') : null;
+    const hasAppNodeModules = !!appNodeModules && (0, node_fs_1.existsSync)(appNodeModules);
+    // an app pinning its own `expo` must stay anchored at the app, or the
+    // bundle picks up the hoisted copy alongside its own. Compare real paths:
+    // `ensureNodeModulesSymlink` links the whole app node_modules to the
+    // workspace's, which is not an app-owned copy.
+    const ownsExpo = hasAppNodeModules && appOwnsExpo(appNodeModules);
+    // SDK 55+ resolves Babel config and the HMR client relative to
+    // `projectRoot`; SDK 53/54 apps relying on hoisted Expo need the workspace
+    // root so `originModulePath` stays workspace-relative for the Nx resolver.
     const nxConfig = {
-        ...(usesExpoMetro ? {} : { projectRoot: devkit_1.workspaceRoot }),
+        ...(usesExpoMetro || ownsExpo ? {} : { projectRoot: devkit_1.workspaceRoot }),
         resolver: {
-            resolveRequest: (0, metro_resolver_1.getResolveRequest)(extensions, opts.exportsConditionNames, opts.mainFields),
-            nodeModulesPaths: [(0, path_1.join)(devkit_1.workspaceRoot, 'node_modules')],
+            resolveRequest: (0, metro_resolver_1.getResolveRequest)(extensions, opts.exportsConditionNames, opts.mainFields, { appRoot, usesExpoMetro }),
+            nodeModulesPaths: [
+                ...(hasAppNodeModules ? [appNodeModules] : []),
+                (0, path_1.join)(devkit_1.workspaceRoot, 'node_modules'),
+            ],
         },
         watchFolders,
     };
-    const { mergeConfig } = getMetroConfig();
+    const { mergeConfig } = getMetroConfig(appRoot, usesExpoMetro);
     return mergeConfig(userConfig, nxConfig);
 }

package/dist/src/executors/serve/serve.impl.js

@@ -60,27 +60,52 @@ function serveAsync(workspaceRoot, projectRoot, options) {
             env: process.env,
             stdio: ['inherit', 'pipe', 'pipe', 'ipc'],
         });
+        let settled = false;
+        const settleResolve = (cp) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(cp);
+        };
+        const settleReject = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(err);
+        };
+        // Expo bundles on first request, so waiting on a bundle log line deadlocks
+        // against a consumer that only requests once we report ready (@nx/cypress).
+        // /status answers packager-status:running once Metro's bundler is ready.
+        void (async () => {
+            while (!settled) {
+                if ((await (0, is_packager_running_1.isPackagerRunning)(options.port)) === 'running') {
+                    settleResolve(childProcess);
+                    return;
+                }
+                await new Promise((r) => setTimeout(r, 500));
+            }
+        })();
         childProcess.stdout.on('data', (data) => {
             process.stdout.write(data);
             if (data.toString().includes('Bundling complete') ||
                 data.toString().includes('Bundled')) {
-                resolve(childProcess);
+                settleResolve(childProcess);
             }
         });
         childProcess.stderr.on('data', (data) => {
             process.stderr.write(data);
         });
         childProcess.on('error', (err) => {
-            reject(err);
+            settleReject(err);
         });
         childProcess.on('exit', (code, signal) => {
             if (code === null)
                 code = (0, internal_1.signalToCode)(signal);
             if (code === 0) {
-                resolve(childProcess);
+                settleResolve(childProcess);
             }
             else {
-                reject(code);
+                settleReject(code);
             }
         });
     });

package/dist/src/generators/application/lib/normalize-options.d.ts

@@ -1,6 +1,8 @@
 import { Tree } from '@nx/devkit';
 import { Schema } from '../schema';
+import type { LinterType } from '@nx/js';
 export interface NormalizedSchema extends Omit<Schema, 'name' | 'useTsSolution'> {
+    linter: LinterType;
     className: string;
     simpleName: string;
     projectName: string;

package/dist/src/generators/application/lib/normalize-options.js

@@ -27,6 +27,10 @@ async function normalizeOptions(host, options) {
     const e2eProjectRoot = rootProject ? 'e2e' : `${appProjectRoot}-e2e`;
     return {
         ...options,
+        // Resolved after the spread: `undefined` is falsy, so the ESLint arm in
+        // add-linting would still run while the `=== 'eslint'` tsconfig excludes
+        // below are skipped.
+        linter: await (0, internal_2.normalizeLinterOption)(host, options.linter),
         unitTestRunner: options.unitTestRunner || 'jest',
         e2eTestRunner: options.e2eTestRunner || 'none',
         simpleName: projectNames.projectSimpleName,

package/dist/src/generators/application/schema.d.ts

@@ -1,4 +1,4 @@
-import type { Linter, LinterType } from '@nx/eslint';
+import type { LinterType } from '@nx/js';
 
 export interface Schema {
   directory: string;
@@ -10,7 +10,7 @@ export interface Schema {
   unitTestRunner: 'jest' | 'none'; // default is jest
   classComponent?: boolean;
   js: boolean; // default is false
-  linter: Linter | LinterType; // default is eslint
+  linter?: LinterType;
   enableTypedLinting?: boolean; // default is false
   /**
    * @deprecated Use `enableTypedLinting` instead. This option will be removed in Nx v24.

package/dist/src/generators/application/schema.json

@@ -41,11 +41,9 @@
       "x-priority": "internal"
     },
     "linter": {
-      "description": "The tool to use for running lint checks.",
+      "description": "The tool to use for running lint checks. Defaults to the linter the workspace already uses.",
       "type": "string",
-      "enum": ["eslint", "none"],
-      "default": "none",
-      "x-prompt": "Which linter would you like to use?",
+      "enum": ["eslint", "oxlint", "none"],
       "x-priority": "important"
     },
     "unitTestRunner": {

package/dist/src/generators/library/lib/normalize-options.d.ts

@@ -1,6 +1,8 @@
 import { Tree } from '@nx/devkit';
 import { Schema } from '../schema';
+import type { LinterType } from '@nx/js';
 export interface NormalizedSchema extends Omit<Schema, 'name'> {
+    linter: LinterType;
     fileName: string;
     projectName: string;
     projectRoot: string;

package/dist/src/generators/library/lib/normalize-options.js

@@ -23,6 +23,10 @@ async function normalizeOptions(host, options) {
     const useProjectJson = options.useProjectJson ?? !isUsingTsSolutionConfig;
     const normalized = {
         ...options,
+        // Resolved in the literal so the type guarantees it: `undefined` is falsy,
+        // so the ESLint arm would still run while the `=== 'eslint'` tsconfig
+        // excludes below are skipped.
+        linter: await (0, internal_2.normalizeLinterOption)(host, options.linter),
         fileName: projectName,
         routePath: `/${projectNames.projectSimpleName}`,
         projectName: isUsingTsSolutionConfig && !options.name ? importPath : projectName,

package/dist/src/generators/library/schema.d.ts

@@ -1,4 +1,4 @@
-import type { Linter, LinterType } from '@nx/eslint';
+import type { LinterType } from '@nx/js';
 
 /**
  * Same as the @nx/react library schema, except it removes keys: style, component, routing, appProject
@@ -10,7 +10,7 @@ export interface Schema {
   skipFormat: boolean; // default is false
   tags?: string;
   unitTestRunner: 'jest' | 'none';
-  linter: Linter | LinterType; // default is eslint
+  linter?: LinterType;
   publishable?: boolean;
   buildable?: boolean;
   importPath?: string;

package/dist/src/generators/library/schema.json

@@ -26,11 +26,9 @@
       "x-priority": "important"
     },
     "linter": {
-      "description": "The tool to use for running lint checks.",
+      "description": "The tool to use for running lint checks. Defaults to the linter the workspace already uses.",
       "type": "string",
-      "enum": ["eslint", "none"],
-      "default": "none",
-      "x-prompt": "Which linter would you like to use?",
+      "enum": ["eslint", "oxlint", "none"],
       "x-priority": "important"
     },
     "unitTestRunner": {

package/dist/src/utils/add-linting.d.ts

@@ -1,7 +1,7 @@
-import { Linter, LinterType } from '@nx/eslint';
+import { LinterType } from '@nx/js';
 import { GeneratorCallback, Tree } from '@nx/devkit';
 interface NormalizedSchema {
-    linter?: Linter | LinterType;
+    linter?: LinterType;
     projectName: string;
     projectRoot: string;
     enableTypedLinting?: boolean;
@@ -10,6 +10,7 @@ interface NormalizedSchema {
      */
     setParserOptionsProject?: boolean;
     tsConfigPaths: string[];
+    unitTestRunner?: string;
     skipPackageJson?: boolean;
     addPlugin?: boolean;
     buildable?: boolean;

package/dist/src/utils/add-linting.js

@@ -1,26 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addLinting = addLinting;
-const eslint_1 = require("@nx/eslint");
 const devkit_1 = require("@nx/devkit");
 const react_1 = require("@nx/react");
 const internal_1 = require("@nx/eslint/internal");
+const internal_2 = require("@nx/js/internal");
 async function addLinting(host, options) {
-    if (options.linter === 'none') {
-        return () => { };
-    }
     const tasks = [];
-    const lintTask = await (0, eslint_1.lintProjectGenerator)(host, {
+    tasks.push(await (0, internal_2.addLintingToProject)(host, {
+        oxlintPlugins: ['react', 'react-perf'],
         linter: options.linter,
         project: options.projectName,
         tsConfigPaths: options.tsConfigPaths,
-        skipFormat: true,
+        unitTestRunner: options.unitTestRunner,
         skipPackageJson: options.skipPackageJson,
         enableTypedLinting: (0, internal_1.isTypedLintingEnabled)(options),
         addPlugin: options.addPlugin,
         addPackageJsonDependencyChecks: options.buildable,
-    });
-    tasks.push(lintTask);
+    }));
+    // Everything below configures ESLint — predefined configs, `extends`, ignore
+    // entries — which have no equivalent in other linters.
+    if (options.linter && options.linter !== 'eslint') {
+        return (0, devkit_1.runTasksInSerial)(...tasks);
+    }
     // Add ignored dependencies and files to dependency-checks rule
     if ((0, internal_1.isEslintConfigSupported)(host)) {
         (0, internal_1.updateOverrideInLintConfig)(host, options.projectRoot, (override) => Boolean(override.rules?.['@nx/dependency-checks']), (override) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/expo",
-  "version": "23.2.0-beta.6",
+  "version": "23.2.0-beta.8",
   "private": false,
   "description": "The Expo Plugin for Nx contains executors and generators for managing and developing an expo application within your workspace. For example, you can directly build for different target platforms as well as generate projects and publish your code.",
   "keywords": [
@@ -61,18 +61,18 @@
     "semver": "^7.6.3",
     "tsconfig-paths": "^4.1.2",
     "tslib": "^2.3.0",
-    "@nx/devkit": "23.2.0-beta.6",
-    "@nx/eslint": "23.2.0-beta.6",
-    "@nx/js": "23.2.0-beta.6",
-    "@nx/react": "23.2.0-beta.6"
+    "@nx/devkit": "23.2.0-beta.8",
+    "@nx/eslint": "23.2.0-beta.8",
+    "@nx/js": "23.2.0-beta.8",
+    "@nx/react": "23.2.0-beta.8"
   },
   "peerDependencies": {
     "expo": ">=53.0.0",
     "@expo/metro": ">= 55.0.0",
     "metro-config": ">= 0.82.0",
     "metro-resolver": ">= 0.82.0",
-    "@nx/cypress": "23.2.0-beta.6",
-    "@nx/playwright": "23.2.0-beta.6"
+    "@nx/cypress": "23.2.0-beta.8",
+    "@nx/playwright": "23.2.0-beta.8"
   },
   "peerDependenciesMeta": {
     "@nx/cypress": {
@@ -95,11 +95,11 @@
     }
   },
   "devDependencies": {
-    "nx": "23.2.0-beta.6"
+    "nx": "23.2.0-beta.8"
   },
   "optionalDependencies": {
-    "@nx/detox": "23.2.0-beta.6",
-    "@nx/rollup": "23.2.0-beta.6"
+    "@nx/detox": "23.2.0-beta.8",
+    "@nx/rollup": "23.2.0-beta.8"
   },
   "executors": "./executors.json",
   "ng-update": {