Merge remote-tracking branch 'origin/main' into feat/ui-references

Author: V3RON

packages/bundler-metro/src/index.ts

@@ -1,3 +1,4 @@
 export { getMetroInstance } from './factory.js';
 export type { MetroInstance, MetroFactory, MetroOptions } from './types.js';
+export { prewarmMetroBundle } from './prewarm.js';
 export type { Reporter, ReportableEvent } from './reporter.js';

packages/bundler-metro/src/prewarm.ts

@@ -0,0 +1,36 @@
+import { METRO_PORT } from './constants.js';
+import { getResolvedEntryPointWithoutExtension } from './entry-point-utils.js';
+
+type PrewarmOptions = {
+  projectRoot: string;
+  entryPoint: string;
+  platform: string;
+  dev: boolean;
+  minify: boolean;
+  signal: AbortSignal;
+};
+
+export const prewarmMetroBundle = async (
+  options: PrewarmOptions
+): Promise<void> => {
+  const { projectRoot, entryPoint, platform, dev, minify, signal } = options;
+  const resolvedEntryPoint = getResolvedEntryPointWithoutExtension(
+    projectRoot,
+    entryPoint
+  );
+  const searchParams = new URLSearchParams({
+    platform,
+    dev: String(dev),
+    minify: String(minify),
+  });
+  const url = `http://localhost:${METRO_PORT}/${resolvedEntryPoint}.bundle?${searchParams.toString()}`;
+
+  const response = await fetch(url, { signal });
+
+  if (!response.ok) {
+    const snippet = (await response.text()).trim();
+    throw new Error(
+      `Metro pre-warm failed (${response.status} ${response.statusText}). ${snippet}`
+    );
+  }
+};

packages/config/src/types.ts

@@ -10,6 +10,7 @@ const RunnerSchema = z.object({
     ),
   config: z.record(z.any()),
   runner: z.string(),
+  platformId: z.string(),
 });
 
 export const ConfigSchema = z

packages/jest/src/harness.ts

@@ -13,13 +13,15 @@ import {
 } from '@react-native-harness/platforms';
 import {
   getMetroInstance,
+  prewarmMetroBundle,
   Reporter,
   ReportableEvent,
 } from '@react-native-harness/bundler-metro';
 import { InitializationTimeoutError, MaxAppRestartsError } from './errors.js';
 import { Config as HarnessConfig } from '@react-native-harness/config';
 import { createCrashMonitor, CrashMonitor } from './crash-monitor.js';
 import { createClientLogListener } from './client-log-handler.js';
+import { logMetroPrewarmCompleted } from './logs.js';
 
 export type HarnessRunTestsOptions = Exclude<TestExecutionOptions, 'platform'>;
 
@@ -176,6 +178,16 @@ const getHarnessInternal = async (
   }
 
   try {
+    await prewarmMetroBundle({
+      projectRoot,
+      entryPoint: config.entryPoint,
+      platform: platform.platformId,
+      dev: true,
+      minify: false,
+      signal,
+    });
+    logMetroPrewarmCompleted(platform);
+
     await waitForAppReady({
       metroEvents: metroInstance.events,
       serverBridge,

packages/jest/src/logs.ts

@@ -25,6 +25,12 @@ export const logTestEnvironmentReady = (runner: HarnessPlatform): void => {
   log(`${TAG} Runner ${chalk.bold(runner.name)} ready\n`);
 };
 
+export const logMetroPrewarmCompleted = (runner: HarnessPlatform): void => {
+  log(
+    `${TAG} Metro pre-warm for ${chalk.bold(runner.name)} completed\n`
+  );
+};
+
 export const getErrorMessage = (error: HarnessError): string => {
   return `${ERROR_TAG} ${error.message}\n`;
 };

packages/metro/src/resolver.ts

@@ -0,0 +1,16 @@
+import type { HarnessResolver, MetroResolver } from './types';
+
+export const createHarnessResolver = (
+  resolvers: HarnessResolver[]
+): MetroResolver => {
+  return (context, moduleName, platform) => {
+    for (const resolver of resolvers) {
+      const result = resolver(context, moduleName, platform);
+      if (result != null) {
+        return result;
+      }
+    }
+
+    return context.resolveRequest(context, moduleName, platform);
+  };
+};

packages/metro/src/resolvers/composite-resolver.ts

@@ -0,0 +1,107 @@
+import type { MetroConfig } from '@react-native/metro-config';
+import type { Config as HarnessConfig } from '@react-native-harness/config';
+import { createHarnessResolver } from './composite-resolver';
+import { createTsConfigResolver } from './tsconfig-resolver';
+import type { HarnessResolver, MetroResolver } from './types';
+
+export const createHarnessEntryPointResolver = (
+  harnessConfig: HarnessConfig
+): HarnessResolver => {
+  // Can be relative to the project root or absolute, need to normalize it
+  const resolvedEntryPointPath = require.resolve(harnessConfig.entryPoint, {
+    paths: [process.cwd()],
+  });
+
+  return (_context, moduleName, _platform) => {
+    if (moduleName === resolvedEntryPointPath) {
+      return {
+        type: 'sourceFile',
+        filePath: require.resolve('@react-native-harness/runtime/entry-point'),
+      };
+    }
+
+    if (moduleName === harnessConfig.entryPoint) {
+      return {
+        type: 'sourceFile',
+        filePath: require.resolve('@react-native-harness/runtime/entry-point'),
+      };
+    }
+
+    if (typeof moduleName === 'string') {
+      try {
+        const resolvedModuleName = require.resolve(moduleName, {
+          paths: [process.cwd()],
+        });
+        if (resolvedModuleName === resolvedEntryPointPath) {
+          return {
+            type: 'sourceFile',
+            filePath: require.resolve(
+              '@react-native-harness/runtime/entry-point'
+            ),
+          };
+        }
+      } catch {
+        // Ignore and fall through
+      }
+    }
+
+    return null;
+  };
+};
+
+export const createJestGlobalsResolver = (): HarnessResolver => {
+  return (_context, moduleName, _platform) => {
+    // Intercept @jest/globals imports and redirect to mock module
+    if (moduleName === '@jest/globals') {
+      return {
+        type: 'sourceFile',
+        filePath: require.resolve('../jest-globals-mock'),
+      };
+    }
+
+    return null;
+  };
+};
+
+export const createJsxRuntimeResolver = (): HarnessResolver => {
+  const resolvedJsxRuntimePath = require.resolve(
+    '@react-native-harness/runtime/jsx-runtime'
+  );
+  const resolvedJsxDevRuntimePath = require.resolve(
+    '@react-native-harness/runtime/jsx-dev-runtime'
+  );
+
+  return (_context, moduleName, _platform) => {
+    if (moduleName === '@react-native-harness/runtime/jsx-runtime') {
+      return {
+        type: 'sourceFile',
+        filePath: resolvedJsxRuntimePath,
+      };
+    }
+
+    if (moduleName === '@react-native-harness/runtime/jsx-dev-runtime') {
+      return {
+        type: 'sourceFile',
+        filePath: resolvedJsxDevRuntimePath,
+      };
+    }
+
+    return null;
+  };
+};
+
+export const getHarnessResolver = (
+  metroConfig: MetroConfig,
+  harnessConfig: HarnessConfig
+): MetroResolver => {
+  const userResolver = metroConfig.resolver?.resolveRequest;
+  const resolvers: HarnessResolver[] = [
+    createHarnessEntryPointResolver(harnessConfig),
+    createJestGlobalsResolver(),
+    createJsxRuntimeResolver(),
+    createTsConfigResolver(process.cwd()),
+    userResolver,
+  ].filter((resolver): resolver is HarnessResolver => !!resolver);
+
+  return createHarnessResolver(resolvers);
+};