metro 0.70.3 → 0.71.2

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.
@@ -15,8 +15,6 @@ const createHasteMap = require("./DependencyGraph/createHasteMap");
 
 const { ModuleResolver } = require("./DependencyGraph/ModuleResolution");
 
-const Module = require("./Module");
-
 const ModuleCache = require("./ModuleCache");
 
 const { EventEmitter } = require("events");
@@ -35,7 +33,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 +47,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 +68,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,15 +8,15 @@
  * @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 type Module from './Module';
 
-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');
-const Module = require('./Module');
 const ModuleCache = require('./ModuleCache');
 const {EventEmitter} = require('events');
 const fs = require('fs');
@@ -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;