metro 0.70.3 → 0.71.0

package/src/index.js

@@ -37,6 +37,8 @@ const { getDefaultConfig, loadConfig, mergeConfig } = require("metro-config");
 
 const { InspectorProxy } = require("metro-inspector-proxy");
 
+const net = require("net");
+
 const { parse } = require("url");
 
 const ws = require("ws");
@@ -150,6 +152,8 @@ exports.runServer = async (
     websocketEndpoints = {},
   }
 ) => {
+  await earlyPortCheck(host, config.server.port);
+
   if (secure != null || secureCert != null || secureKey != null) {
     // eslint-disable-next-line no-console
     console.warn(
@@ -183,13 +187,11 @@ exports.runServer = async (
     let options = secureServerOptions;
 
     if (typeof secureKey === "string" && typeof secureCert === "string") {
-      options = Object.assign(
-        {
-          key: fs.readFileSync(secureKey),
-          cert: fs.readFileSync(secureCert),
-        },
-        secureServerOptions
-      );
+      options = {
+        key: fs.readFileSync(secureKey),
+        cert: fs.readFileSync(secureCert),
+        ...secureServerOptions,
+      };
     }
 
     httpServer = https.createServer(options, serverApp);
@@ -197,14 +199,15 @@ exports.runServer = async (
     httpServer = http.createServer(serverApp);
   }
 
-  httpServer.on("error", (error) => {
-    if (onError) {
-      onError(error);
-    }
-
-    end();
-  });
   return new Promise((resolve, reject) => {
+    httpServer.on("error", (error) => {
+      if (onError) {
+        onError(error);
+      }
+
+      reject(error);
+      end();
+    });
     httpServer.listen(config.server.port, host, () => {
       if (onReady) {
         onReady(httpServer);
@@ -253,10 +256,6 @@ exports.runServer = async (
     // timeout of 120 seconds to respond to a request.
 
     httpServer.timeout = 0;
-    httpServer.on("error", (error) => {
-      end();
-      reject(error);
-    });
     httpServer.on("close", () => {
       end();
     });
@@ -376,3 +375,18 @@ exports.attachMetroCli = function (
 
   return yargs;
 };
+
+async function earlyPortCheck(host, port) {
+  const server = net.createServer((c) => c.end());
+
+  try {
+    await new Promise((resolve, reject) => {
+      server.on("error", (err) => {
+        reject(err);
+      });
+      server.listen(port, host, undefined, () => resolve());
+    });
+  } finally {
+    await new Promise((resolve) => server.close(() => resolve()));
+  }
+}

package/src/index.js.flow

@@ -37,25 +37,26 @@ const http = require('http');
 const https = require('https');
 const {getDefaultConfig, loadConfig, mergeConfig} = require('metro-config');
 const {InspectorProxy} = require('metro-inspector-proxy');
+const net = require('net');
 const {parse} = require('url');
 const ws = require('ws');
 
-type MetroMiddleWare = {|
+type MetroMiddleWare = {
   attachHmrServer: (httpServer: HttpServer | HttpsServer) => void,
   end: () => void,
   metroServer: MetroServer,
   middleware: Middleware,
-|};
+};
 
 export type RunMetroOptions = {
   ...ServerOptions,
   waitForBundler?: boolean,
 };
 
-export type RunServerOptions = {|
+export type RunServerOptions = {
   hasReducedPerformance?: boolean,
   host?: string,
-  onError?: (Error & {|code?: string|}) => void,
+  onError?: (Error & {code?: string}) => void,
   onReady?: (server: HttpServer | HttpsServer) => void,
   runInspectorProxy?: boolean,
   secureServerOptions?: Object,
@@ -66,9 +67,9 @@ export type RunServerOptions = {|
   websocketEndpoints?: {
     [path: string]: typeof ws.Server,
   },
-|};
+};
 
-type BuildGraphOptions = {|
+type BuildGraphOptions = {
   entries: $ReadOnlyArray<string>,
   customTransformOptions?: CustomTransformOptions,
   dev?: boolean,
@@ -76,9 +77,9 @@ type BuildGraphOptions = {|
   onProgress?: (transformedFileCount: number, totalFileCount: number) => void,
   platform?: string,
   type?: 'module' | 'script',
-|};
+};
 
-export type RunBuildOptions = {|
+export type RunBuildOptions = {
   entry: string,
   dev?: boolean,
   out?: string,
@@ -109,10 +110,10 @@ export type RunBuildOptions = {|
   platform?: string,
   sourceMap?: boolean,
   sourceMapUrl?: string,
-|};
+};
 
-type BuildCommandOptions = {||} | null;
-type ServeCommandOptions = {||} | null;
+type BuildCommandOptions = {} | null;
+type ServeCommandOptions = {} | null;
 
 async function getConfig(config: InputConfigT): Promise<ConfigT> {
   const defaultConfig = await getDefaultConfig(config.projectRoot);
@@ -171,7 +172,7 @@ const createConnectMiddleware = async function (
 ): Promise<MetroMiddleWare> {
   const metroServer = await runMetro(config, options);
 
-  let enhancedMiddleware = metroServer.processRequest;
+  let enhancedMiddleware: Middleware = metroServer.processRequest;
 
   // Enhance the resulting middleware using the config options
   if (config.server.enhanceMiddleware) {
@@ -225,6 +226,8 @@ exports.runServer = async (
     websocketEndpoints = {},
   }: RunServerOptions,
 ): Promise<HttpServer | HttpsServer> => {
+  await earlyPortCheck(host, config.server.port);
+
   if (secure != null || secureCert != null || secureKey != null) {
     // eslint-disable-next-line no-console
     console.warn(
@@ -256,31 +259,29 @@ exports.runServer = async (
   if (secure || secureServerOptions != null) {
     let options = secureServerOptions;
     if (typeof secureKey === 'string' && typeof secureCert === 'string') {
-      options = Object.assign(
-        {
-          key: fs.readFileSync(secureKey),
-          cert: fs.readFileSync(secureCert),
-        },
-        secureServerOptions,
-      );
+      options = {
+        key: fs.readFileSync(secureKey),
+        cert: fs.readFileSync(secureCert),
+        ...secureServerOptions,
+      };
     }
     httpServer = https.createServer(options, serverApp);
   } else {
     httpServer = http.createServer(serverApp);
   }
-
-  httpServer.on('error', error => {
-    if (onError) {
-      onError(error);
-    }
-    end();
-  });
-
   return new Promise(
     (
       resolve: (result: HttpServer | HttpsServer) => void,
       reject: mixed => mixed,
     ) => {
+      httpServer.on('error', error => {
+        if (onError) {
+          onError(error);
+        }
+        reject(error);
+        end();
+      });
+
       httpServer.listen(config.server.port, host, () => {
         if (onReady) {
           onReady(httpServer);
@@ -331,11 +332,6 @@ exports.runServer = async (
       // timeout of 120 seconds to respond to a request.
       httpServer.timeout = 0;
 
-      httpServer.on('error', error => {
-        end();
-        reject(error);
-      });
-
       httpServer.on('close', () => {
         end();
       });
@@ -468,3 +464,17 @@ exports.attachMetroCli = function (
   }
   return yargs;
 };
+
+async function earlyPortCheck(host: void | string, port: number) {
+  const server = net.createServer(c => c.end());
+  try {
+    await new Promise((resolve, reject) => {
+      server.on('error', err => {
+        reject(err);
+      });
+      server.listen(port, host, undefined, () => resolve());
+    });
+  } finally {
+    await new Promise(resolve => server.close(() => resolve()));
+  }
+}

package/src/lib/bundleToBytecode.js.flow

@@ -49,10 +49,10 @@ function addModuleHeader(buffer: Buffer): [Buffer, Buffer] {
  * ...
  *
  */
-function bundleToBytecode(bundle: BytecodeBundle): {|
+function bundleToBytecode(bundle: BytecodeBundle): {
   +bytecode: Buffer,
   +metadata: BundleMetadata,
-|} {
+} {
   const buffers = [];
 
   if (bundle.pre.length) {

package/src/lib/bundleToString.js.flow

@@ -18,10 +18,10 @@ import type {
 /**
  * Serializes a bundle into a plain JS bundle.
  */
-function bundleToString(bundle: Bundle): {|
+function bundleToString(bundle: Bundle): {
   +code: string,
   +metadata: BundleMetadata,
-|} {
+} {
   let code = bundle.pre.length > 0 ? bundle.pre + '\n' : '';
   const modules = [];
 

package/src/lib/getPreludeCode.js.flow

@@ -14,11 +14,11 @@ function getPreludeCode({
   extraVars,
   isDev,
   globalPrefix,
-}: {|
+}: {
   +extraVars?: {[string]: mixed, ...},
   +isDev: boolean,
   +globalPrefix: string,
-|}): string {
+}): string {
   const vars = [
     '__BUNDLE_START_TIME__=this.nativePerformanceNow?nativePerformanceNow():Date.now()',
     `__DEV__=${String(isDev)}`,

package/src/lib/transformHelpers.js.flow

@@ -21,10 +21,10 @@ const path = require('path');
 
 type InlineRequiresRaw = {+blockList: {[string]: true, ...}, ...} | boolean;
 
-type TransformOptionsWithRawInlines = {|
+type TransformOptionsWithRawInlines = {
   ...TransformOptions,
   +inlineRequires: InlineRequiresRaw,
-|};
+};
 
 const baseIgnoredInlineRequires = ['React', 'react', 'react-native'];
 

package/src/node-haste/DependencyGraph/ModuleResolution.js

@@ -149,7 +149,8 @@ class ModuleResolver {
       }
 
       if (error instanceof Resolver.FailedToResolveNameError) {
-        const { dirPaths, extraPaths } = error;
+        const dirPaths = error.dirPaths;
+        const extraPaths = error.extraPaths;
         const displayDirPaths = dirPaths
           .filter((dirPath) => this._options.dirExists(dirPath))
           .map((dirPath) => path.relative(this._options.projectRoot, dirPath))

package/src/node-haste/DependencyGraph/ModuleResolution.js.flow

@@ -10,7 +10,7 @@
 
 'use strict';
 
-import type {ModuleMap} from './types';
+import type {ModuleMap} from 'metro-file-map';
 import type {
   CustomResolver,
   DoesFileExist,
@@ -53,7 +53,7 @@ export type ModuleishCache<TModule, TPackage> = interface {
   getPackageOf(modulePath: string): ?TPackage,
 };
 
-type Options<TModule, TPackage> = {|
+type Options<TModule, TPackage> = {
   +dirExists: DirExistsFn,
   +disableHierarchicalLookup: boolean,
   +doesFileExist: DoesFileExist,
@@ -69,7 +69,7 @@ type Options<TModule, TPackage> = {|
   +resolveAsset: ResolveAsset,
   +resolveRequest: ?CustomResolver,
   +sourceExts: $ReadOnlyArray<string>,
-|};
+};
 
 class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
   _options: Options<TModule, TPackage>;
@@ -204,15 +204,8 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
         );
       }
       if (error instanceof Resolver.FailedToResolveNameError) {
-        const {
-          dirPaths,
-          extraPaths,
-        }: {
-          // $flowfixme these types are defined explicitly in FailedToResolveNameError but Flow refuses to recognize them here
-          dirPaths: $ReadOnlyArray<string>,
-          extraPaths: $ReadOnlyArray<string>,
-          ...
-        } = error;
+        const dirPaths = error.dirPaths;
+        const extraPaths = error.extraPaths;
         const displayDirPaths = dirPaths
           .filter((dirPath: string) => this._options.dirExists(dirPath))
           .map(dirPath => path.relative(this._options.projectRoot, dirPath))

package/src/node-haste/DependencyGraph/createHasteMap.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var _jestHasteMap = _interopRequireDefault(require("jest-haste-map"));
+var _metroFileMap = _interopRequireDefault(require("metro-file-map"));
 
 function _interopRequireDefault(obj) {
   return obj && obj.__esModule ? obj : { default: obj };
@@ -15,7 +15,6 @@ function _interopRequireDefault(obj) {
  *
  * @format
  */
-// $FlowFixMe: Types for `jest-haste-map`
 const ci = require("ci-info");
 
 const path = require("path");
@@ -46,7 +45,7 @@ function getIgnorePattern(config) {
 }
 
 function createHasteMap(config, options) {
-  var _options$name, _options$throwOnModul;
+  var _config$fileMapCacheD, _options$name, _options$throwOnModul;
 
   const dependencyExtractor =
     (options === null || options === void 0
@@ -55,8 +54,12 @@ function createHasteMap(config, options) {
       ? null
       : config.resolver.dependencyExtractor;
   const computeDependencies = dependencyExtractor != null;
-  const hasteConfig = {
-    cacheDirectory: config.hasteMapCacheDirectory,
+  return _metroFileMap.default.create({
+    cacheDirectory:
+      (_config$fileMapCacheD = config.fileMapCacheDirectory) !== null &&
+      _config$fileMapCacheD !== void 0
+        ? _config$fileMapCacheD
+        : config.hasteMapCacheDirectory,
     computeDependencies,
     computeSha1: true,
     dependencyExtractor: config.resolver.dependencyExtractor,
@@ -92,8 +95,7 @@ function createHasteMap(config, options) {
       (options === null || options === void 0 ? void 0 : options.watch) == null
         ? !ci.isCI
         : options.watch,
-  };
-  return _jestHasteMap.default.create(hasteConfig);
+  });
 }
 
 module.exports = createHasteMap;

package/src/node-haste/DependencyGraph/createHasteMap.js.flow

@@ -8,11 +8,9 @@
  * @format
  */
 
-import type {HasteConfig, HasteMap} from './types';
 import type {ConfigT} from 'metro-config/src/configTypes.flow';
 
-// $FlowFixMe: Types for `jest-haste-map`
-import JestHasteMap from 'jest-haste-map';
+import MetroFileMap from 'metro-file-map';
 
 const ci = require('ci-info');
 const path = require('path');
@@ -52,15 +50,16 @@ function createHasteMap(
     throwOnModuleCollision?: boolean,
     name?: string,
   }>,
-): HasteMap {
+): MetroFileMap {
   const dependencyExtractor =
     options?.extractDependencies === false
       ? null
       : config.resolver.dependencyExtractor;
   const computeDependencies = dependencyExtractor != null;
 
-  const hasteConfig: HasteConfig = {
-    cacheDirectory: config.hasteMapCacheDirectory,
+  return MetroFileMap.create({
+    cacheDirectory:
+      config.fileMapCacheDirectory ?? config.hasteMapCacheDirectory,
     computeDependencies,
     computeSha1: true,
     dependencyExtractor: config.resolver.dependencyExtractor,
@@ -80,9 +79,7 @@ function createHasteMap(
     throwOnModuleCollision: options?.throwOnModuleCollision ?? true,
     useWatchman: config.resolver.useWatchman,
     watch: options?.watch == null ? !ci.isCI : options.watch,
-  };
-
-  return JestHasteMap.create(hasteConfig);
+  });
 }
 
 module.exports = createHasteMap;

package/src/node-haste/DependencyGraph.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var _jestHasteMap = require("jest-haste-map");
+var _metroFileMap = require("metro-file-map");
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -35,7 +35,7 @@ const nullthrows = require("nullthrows");
 
 const path = require("path");
 
-const { DuplicateHasteCandidatesError } = _jestHasteMap.ModuleMap;
+const { DuplicateHasteCandidatesError } = _metroFileMap.ModuleMap;
 
 function getOrCreate(map, field) {
   let subMap = map.get(field);
@@ -49,25 +49,12 @@ function getOrCreate(map, field) {
 }
 
 class DependencyGraph extends EventEmitter {
-  constructor({ config, haste, initialHasteFS, initialModuleMap }) {
+  constructor(config, options) {
     super();
     this._config = config;
-    this._haste = haste;
-    this._hasteFS = initialHasteFS;
-    this._moduleMap = initialModuleMap;
     this._assetExtensions = new Set(
       config.resolver.assetExts.map((asset) => "." + asset)
-    ); // $FlowFixMe[method-unbinding] added when improving typing for this parameters
-
-    this._haste.on("change", this._onHasteChange.bind(this));
-
-    this._resolutionCache = new Map();
-    this._moduleCache = this._createModuleCache();
-
-    this._createModuleResolver();
-  }
-
-  static async load(config, options) {
+    );
     const { hasReducedPerformance, watch } =
       options !== null && options !== void 0 ? options : {};
     const initializingMetroLogEntry = log(
@@ -83,17 +70,34 @@ class DependencyGraph extends EventEmitter {
     // Bump this up to silence the max listeners EventEmitter warning.
 
     haste.setMaxListeners(1000);
-    const { hasteFS, moduleMap } = await haste.build();
-    log(createActionEndEntry(initializingMetroLogEntry));
-    config.reporter.update({
-      type: "dep_graph_loaded",
-    });
-    return new DependencyGraph({
-      haste,
-      initialHasteFS: hasteFS,
-      initialModuleMap: moduleMap,
-      config,
+    this._haste = haste;
+    this._readyPromise = haste.build().then(({ hasteFS, moduleMap }) => {
+      log(createActionEndEntry(initializingMetroLogEntry));
+      config.reporter.update({
+        type: "dep_graph_loaded",
+      });
+      this._hasteFS = hasteFS;
+      this._moduleMap = moduleMap; // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+
+      this._haste.on("change", this._onHasteChange.bind(this));
+
+      this._resolutionCache = new Map();
+      this._moduleCache = this._createModuleCache();
+
+      this._createModuleResolver();
     });
+  } // Waits for the dependency graph to become ready after initialisation.
+  // Don't read anything from the graph until this resolves.
+
+  async ready() {
+    await this._readyPromise;
+  } // Creates the dependency graph and waits for it to become ready.
+  // @deprecated Use the constructor + ready() directly.
+
+  static async load(config, options) {
+    const self = new DependencyGraph(config, options);
+    await self.ready();
+    return self;
   }
 
   _getClosestPackage(filePath) {

package/src/node-haste/DependencyGraph.js.flow

@@ -8,11 +8,11 @@
  * @format
  */
 
-import type {HasteFS, HasteMap, ModuleMap} from './DependencyGraph/types';
 import type Package from './Package';
 import type {ConfigT} from 'metro-config/src/configTypes.flow';
+import type MetroFileMap, {HasteFS} from 'metro-file-map';
 
-import {ModuleMap as JestHasteModuleMap} from 'jest-haste-map';
+import {ModuleMap as MetroFileMapModuleMap} from 'metro-file-map';
 
 const createHasteMap = require('./DependencyGraph/createHasteMap');
 const {ModuleResolver} = require('./DependencyGraph/ModuleResolution');
@@ -29,7 +29,7 @@ const {InvalidPackageError} = require('metro-resolver');
 const nullthrows = require('nullthrows');
 const path = require('path');
 
-const {DuplicateHasteCandidatesError} = JestHasteModuleMap;
+const {DuplicateHasteCandidatesError} = MetroFileMapModuleMap;
 
 function getOrCreate<T>(
   map: Map<string, Map<string, T>>,
@@ -46,43 +46,28 @@ function getOrCreate<T>(
 class DependencyGraph extends EventEmitter {
   _assetExtensions: Set<string>;
   _config: ConfigT;
-  _haste: HasteMap;
+  _haste: MetroFileMap;
   _hasteFS: HasteFS;
   _moduleCache: ModuleCache;
-  _moduleMap: ModuleMap;
+  _moduleMap: MetroFileMapModuleMap;
   _moduleResolver: ModuleResolver<Module, Package>;
   _resolutionCache: Map<string, Map<string, Map<string, string>>>;
+  _readyPromise: Promise<void>;
 
-  constructor({
-    config,
-    haste,
-    initialHasteFS,
-    initialModuleMap,
-  }: {|
-    +config: ConfigT,
-    +haste: HasteMap,
-    +initialHasteFS: HasteFS,
-    +initialModuleMap: ModuleMap,
-  |}) {
+  constructor(
+    config: ConfigT,
+    options?: {
+      +hasReducedPerformance?: boolean,
+      +watch?: boolean,
+    },
+  ) {
     super();
+
     this._config = config;
-    this._haste = haste;
-    this._hasteFS = initialHasteFS;
-    this._moduleMap = initialModuleMap;
     this._assetExtensions = new Set(
       config.resolver.assetExts.map(asset => '.' + asset),
     );
-    // $FlowFixMe[method-unbinding] added when improving typing for this parameters
-    this._haste.on('change', this._onHasteChange.bind(this));
-    this._resolutionCache = new Map();
-    this._moduleCache = this._createModuleCache();
-    this._createModuleResolver();
-  }
 
-  static async load(
-    config: ConfigT,
-    options?: {|+hasReducedPerformance?: boolean, +watch?: boolean|},
-  ): Promise<DependencyGraph> {
     const {hasReducedPerformance, watch} = options ?? {};
     const initializingMetroLogEntry = log(
       createActionStartEntry('Initializing Metro'),
@@ -98,19 +83,40 @@ class DependencyGraph extends EventEmitter {
     // Bump this up to silence the max listeners EventEmitter warning.
     haste.setMaxListeners(1000);
 
-    const {hasteFS, moduleMap} = await haste.build();
+    this._haste = haste;
+
+    this._readyPromise = haste.build().then(({hasteFS, moduleMap}) => {
+      log(createActionEndEntry(initializingMetroLogEntry));
+      config.reporter.update({type: 'dep_graph_loaded'});
 
-    log(createActionEndEntry(initializingMetroLogEntry));
-    config.reporter.update({type: 'dep_graph_loaded'});
+      this._hasteFS = hasteFS;
+      this._moduleMap = moduleMap;
 
-    return new DependencyGraph({
-      haste,
-      initialHasteFS: hasteFS,
-      initialModuleMap: moduleMap,
-      config,
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      this._haste.on('change', this._onHasteChange.bind(this));
+      this._resolutionCache = new Map();
+      this._moduleCache = this._createModuleCache();
+      this._createModuleResolver();
     });
   }
 
+  // Waits for the dependency graph to become ready after initialisation.
+  // Don't read anything from the graph until this resolves.
+  async ready(): Promise<void> {
+    await this._readyPromise;
+  }
+
+  // Creates the dependency graph and waits for it to become ready.
+  // @deprecated Use the constructor + ready() directly.
+  static async load(
+    config: ConfigT,
+    options?: {+hasReducedPerformance?: boolean, +watch?: boolean},
+  ): Promise<DependencyGraph> {
+    const self = new DependencyGraph(config, options);
+    await self.ready();
+    return self;
+  }
+
   _getClosestPackage(filePath: string): ?string {
     const parsedPath = path.parse(filePath);
     const root = parsedPath.root;

package/src/node-haste/ModuleCache.js.flow

@@ -69,7 +69,7 @@ class ModuleCache {
   }
 
   getPackageOf(modulePath: string): ?Package {
-    let packagePath = this._packagePathByModulePath[modulePath];
+    let packagePath: ?string = this._packagePathByModulePath[modulePath];
     if (packagePath && this._packageCache[packagePath]) {
       return this._packageCache[packagePath];
     }