metro 0.70.2 → 0.71.1

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

@@ -1,9 +1,47 @@
 "use strict";
 
-var _jestHasteMap = _interopRequireDefault(require("jest-haste-map"));
+var _metroFileMap = _interopRequireWildcard(require("metro-file-map"));
 
-function _interopRequireDefault(obj) {
-  return obj && obj.__esModule ? obj : { default: obj };
+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 _interopRequireWildcard(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 = {};
+  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;
 }
 
 /**
@@ -15,13 +53,10 @@ function _interopRequireDefault(obj) {
  *
  * @format
  */
-// $FlowFixMe: Types for `jest-haste-map`
 const ci = require("ci-info");
 
 const path = require("path");
 
-const JEST_HASTE_MAP_CACHE_BREAKER = 5;
-
 function getIgnorePattern(config) {
   // For now we support both options
   const { blockList, blacklistRE } = config.resolver;
@@ -46,7 +81,10 @@ function getIgnorePattern(config) {
 }
 
 function createHasteMap(config, options) {
-  var _options$name, _options$throwOnModul;
+  var _config$unstable_file,
+    _config$unstable_perf,
+    _config$unstable_perf2,
+    _options$throwOnModul;
 
   const dependencyExtractor =
     (options === null || options === void 0
@@ -55,25 +93,48 @@ function createHasteMap(config, options) {
       ? null
       : config.resolver.dependencyExtractor;
   const computeDependencies = dependencyExtractor != null;
-  const hasteConfig = {
-    cacheDirectory: config.hasteMapCacheDirectory,
+  return _metroFileMap.default.create({
+    cacheManagerFactory:
+      (_config$unstable_file =
+        config === null || config === void 0
+          ? void 0
+          : config.unstable_fileMapCacheManagerFactory) !== null &&
+      _config$unstable_file !== void 0
+        ? _config$unstable_file
+        : (buildParameters) => {
+            var _config$fileMapCacheD;
+
+            return new _metroFileMap.DiskCacheManager({
+              buildParameters,
+              cacheDirectory:
+                (_config$fileMapCacheD = config.fileMapCacheDirectory) !==
+                  null && _config$fileMapCacheD !== void 0
+                  ? _config$fileMapCacheD
+                  : config.hasteMapCacheDirectory,
+              cacheFilePrefix:
+                options === null || options === void 0
+                  ? void 0
+                  : options.cacheFilePrefix,
+            });
+          },
+    perfLogger:
+      (_config$unstable_perf =
+        (_config$unstable_perf2 = config.unstable_perfLogger) === null ||
+        _config$unstable_perf2 === void 0
+          ? void 0
+          : _config$unstable_perf2.subSpan("hasteMap")) !== null &&
+      _config$unstable_perf !== void 0
+        ? _config$unstable_perf
+        : null,
     computeDependencies,
     computeSha1: true,
     dependencyExtractor: config.resolver.dependencyExtractor,
     extensions: config.resolver.sourceExts.concat(config.resolver.assetExts),
     forceNodeFilesystemAPI: !config.resolver.useWatchman,
     hasteImplModulePath: config.resolver.hasteImplModulePath,
-    hasteMapModulePath: config.resolver.unstable_hasteMapModulePath,
     ignorePattern: getIgnorePattern(config),
     maxWorkers: config.maxWorkers,
     mocksPattern: "",
-    name: `${
-      (_options$name =
-        options === null || options === void 0 ? void 0 : options.name) !==
-        null && _options$name !== void 0
-        ? _options$name
-        : "metro"
-    }-${JEST_HASTE_MAP_CACHE_BREAKER}`,
     platforms: config.resolver.platforms,
     retainAllFiles: true,
     resetCache: config.resetCache,
@@ -92,8 +153,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,17 +8,13 @@
  * @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, {DiskCacheManager} from 'metro-file-map';
 
 const ci = require('ci-info');
 const path = require('path');
 
-const JEST_HASTE_MAP_CACHE_BREAKER = 5;
-
 function getIgnorePattern(config: ConfigT): RegExp {
   // For now we support both options
   const {blockList, blacklistRE} = config.resolver;
@@ -50,28 +46,35 @@ function createHasteMap(
     extractDependencies?: boolean,
     watch?: boolean,
     throwOnModuleCollision?: boolean,
-    name?: string,
+    cacheFilePrefix?: 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({
+    cacheManagerFactory:
+      config?.unstable_fileMapCacheManagerFactory ??
+      (buildParameters =>
+        new DiskCacheManager({
+          buildParameters,
+          cacheDirectory:
+            config.fileMapCacheDirectory ?? config.hasteMapCacheDirectory,
+          cacheFilePrefix: options?.cacheFilePrefix,
+        })),
+    perfLogger: config.unstable_perfLogger?.subSpan('hasteMap') ?? null,
     computeDependencies,
     computeSha1: true,
     dependencyExtractor: config.resolver.dependencyExtractor,
     extensions: config.resolver.sourceExts.concat(config.resolver.assetExts),
     forceNodeFilesystemAPI: !config.resolver.useWatchman,
     hasteImplModulePath: config.resolver.hasteImplModulePath,
-    hasteMapModulePath: config.resolver.unstable_hasteMapModulePath,
     ignorePattern: getIgnorePattern(config),
     maxWorkers: config.maxWorkers,
     mocksPattern: '',
-    name: `${options?.name ?? 'metro'}-${JEST_HASTE_MAP_CACHE_BREAKER}`,
     platforms: config.resolver.platforms,
     retainAllFiles: true,
     resetCache: config.resetCache,
@@ -80,9 +83,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];
     }

package/src/node-haste/lib/AssetPaths.js.flow

@@ -13,13 +13,13 @@
 const parsePlatformFilePath = require('./parsePlatformFilePath');
 const path = require('path');
 
-export type AssetPath = {|
+export type AssetPath = {
   assetName: string,
   name: string,
   platform: ?string,
   resolution: number,
   type: string,
-|};
+};
 
 const ASSET_BASE_NAME_RE = /(.+?)(@([\d.]+)x)?$/;
 

package/src/node-haste/lib/parsePlatformFilePath.js.flow

@@ -12,12 +12,12 @@
 
 const path = require('path');
 
-type PlatformFilePathParts = {|
+type PlatformFilePathParts = {
   dirPath: string,
   baseName: string,
   platform: ?string,
   extension: ?string,
-|};
+};
 
 const PATH_RE = /^(.+?)(\.([^.]+))?\.([^.]+)$/;
 

package/src/shared/output/RamBundle/as-indexed-file.js.flow

@@ -109,7 +109,7 @@ function moduleToBuffer(
   id: number,
   code: string,
   encoding: void | 'ascii' | 'utf16le' | 'utf8',
-): {|buffer: Buffer, id: number|} {
+): {buffer: Buffer, id: number} {
   return {
     id,
     buffer: nullTerminatedBuffer(code, encoding),

package/src/shared/output/RamBundle/buildSourcemapWithMetadata.js.flow

@@ -19,12 +19,12 @@ const {
   joinModules,
 } = require('./util');
 
-type Params = {|
+type Params = {
   fixWrapperOffset: boolean,
   lazyModules: $ReadOnlyArray<ModuleTransportLike>,
   moduleGroups: ?ModuleGroups,
   startupModules: $ReadOnlyArray<ModuleTransportLike>,
-|};
+};
 
 module.exports = (({
   fixWrapperOffset,

package/src/shared/types.flow.js.flow

@@ -61,33 +61,33 @@ export type BundleOptions = {
   ...
 };
 
-export type SerializerOptions = {|
+export type SerializerOptions = {
   +sourceMapUrl: ?string,
   +sourceUrl: ?string,
   +runModule: boolean,
   +excludeSource: boolean,
   +inlineSourceMap: boolean,
   +modulesOnly: boolean,
-|};
+};
 
-export type GraphOptions = {|
+export type GraphOptions = {
   +shallow: boolean,
-|};
+};
 
 // Stricter representation of BundleOptions.
-export type SplitBundleOptions = {|
+export type SplitBundleOptions = {
   +entryFile: string,
   +transformOptions: TransformInputOptions,
   +serializerOptions: SerializerOptions,
   +graphOptions: GraphOptions,
   +onProgress: $PropertyType<DeltaBundlerOptions<>, 'onProgress'>,
-|};
+};
 
-export type ModuleGroups = {|
+export type ModuleGroups = {
   groups: Map<number, Set<number>>,
   modulesById: Map<number, ModuleTransportLike>,
   modulesInGroups: Set<number>,
-|};
+};
 
 export type ModuleTransportLike = {
   +code: string,
@@ -97,18 +97,18 @@ export type ModuleTransportLike = {
   +sourcePath: string,
   ...
 };
-export type ModuleTransportLikeStrict = {|
+export type ModuleTransportLikeStrict = {
   +code: string,
   +id: number,
   +map: ?MetroSourceMapOrMappings,
   +name?: string,
   +sourcePath: string,
-|};
-export type RamModuleTransport = {|
+};
+export type RamModuleTransport = {
   ...ModuleTransportLikeStrict,
   +source: string,
   +type: string,
-|};
+};
 
 export type OutputOptions = {
   bundleOutput: string,
@@ -122,7 +122,7 @@ export type OutputOptions = {
   ...
 };
 
-export type RequestOptions = {|
+export type RequestOptions = {
   entryFile: string,
   inlineSourceMap?: boolean,
   sourceMapUrl?: string,
@@ -131,6 +131,6 @@ export type RequestOptions = {|
   platform: string,
   createModuleIdFactory?: () => (path: string) => number,
   onProgress?: (transformedFileCount: number, totalFileCount: number) => void,
-|};
+};
 
 export type {MinifierOptions};

package/src/DeltaBundler/computeDelta.js

@@ -1,42 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- *
- * @format
- */
-"use strict";
-
-function computeDelta(entries1, entries2) {
-  const modules1 = new Map(entries1);
-  const modules2 = new Map(entries2);
-  const added = new Map();
-  const modified = new Map();
-  const deleted = new Set();
-
-  for (const [id, code] of modules1.entries()) {
-    const newCode = modules2.get(id);
-
-    if (newCode == null) {
-      deleted.add(id);
-    } else if (newCode !== code) {
-      modified.set(id, newCode);
-    }
-  }
-
-  for (const [id, code] of modules2.entries()) {
-    if (!modules1.has(id)) {
-      added.set(id, code);
-    }
-  }
-
-  return {
-    added: [...added.entries()],
-    modified: [...modified.entries()],
-    deleted: [...deleted],
-  };
-}
-
-module.exports = computeDelta;

package/src/DeltaBundler/computeDelta.js.flow

@@ -1,47 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow strict-local
- * @format
- */
-
-'use strict';
-
-import type {
-  DeltaBundle,
-  ModuleMap,
-} from 'metro-runtime/src/modules/types.flow';
-
-function computeDelta(entries1: ModuleMap, entries2: ModuleMap): DeltaBundle {
-  const modules1 = new Map(entries1);
-  const modules2 = new Map(entries2);
-  const added = new Map();
-  const modified = new Map();
-  const deleted = new Set();
-
-  for (const [id, code] of modules1.entries()) {
-    const newCode = modules2.get(id);
-    if (newCode == null) {
-      deleted.add(id);
-    } else if (newCode !== code) {
-      modified.set(id, newCode);
-    }
-  }
-
-  for (const [id, code] of modules2.entries()) {
-    if (!modules1.has(id)) {
-      added.set(id, code);
-    }
-  }
-
-  return {
-    added: [...added.entries()],
-    modified: [...modified.entries()],
-    deleted: [...deleted],
-  };
-}
-
-module.exports = computeDelta;