metro 0.70.2 → 0.71.1

package/src/DeltaBundler/types.flow.js.flow

@@ -10,16 +10,17 @@
 
 'use strict';
 
+import type {PrivateState} from './graphOperations';
 import type {JsTransformOptions} from 'metro-transform-worker';
 
-export type MixedOutput = {|
+export type MixedOutput = {
   +data: mixed,
   +type: string,
-|};
+};
 
 export type AsyncDependencyType = 'async' | 'prefetch';
 
-export type TransformResultDependency = {|
+export type TransformResultDependency = {
   /**
    * The literal name provided to a require or import call. For example 'foo' in
    * case of `require('foo')`.
@@ -30,7 +31,7 @@ export type TransformResultDependency = {|
    * Extra data returned by the dependency extractor. Whatever is added here is
    * blindly piped by Metro to the serializers.
    */
-  +data: {|
+  +data: {
     /**
      * If not null, this dependency is due to a dynamic `import()` or `__prefetchImport()` call.
      */
@@ -38,30 +39,30 @@ export type TransformResultDependency = {|
     /**
      * The condition for splitting on this dependency edge.
      */
-    +splitCondition?: {|
+    +splitCondition?: {
       +mobileConfigName: string,
-    |},
+    },
     /**
      * The dependency is enclosed in a try/catch block.
      */
     +isOptional?: boolean,
 
     +locs: $ReadOnlyArray<BabelSourceLocation>,
-  |},
-|};
+  },
+};
 
-export type Dependency = {|
+export type Dependency = {
   +absolutePath: string,
   +data: TransformResultDependency,
-|};
+};
 
-export type Module<T = MixedOutput> = {|
+export type Module<T = MixedOutput> = {
   +dependencies: Map<string, Dependency>,
   +inverseDependencies: Set<string>,
   +output: $ReadOnlyArray<T>,
   +path: string,
   +getSource: () => Buffer,
-|};
+};
 
 export type Dependencies<T = MixedOutput> = Map<string, Module<T>>;
 
@@ -74,51 +75,56 @@ export type TransformInputOptions = $Diff<
   },
 >;
 
-export type Graph<T = MixedOutput> = {|
-  dependencies: Dependencies<T>,
-  importBundleNames: Set<string>,
-  +entryPoints: $ReadOnlyArray<string>,
+export type GraphInputOptions = $ReadOnly<{
+  entryPoints: $ReadOnlySet<string>,
   // Unused in core but useful for custom serializers / experimentalSerializerHook
-  +transformOptions: TransformInputOptions,
-|};
+  transformOptions: TransformInputOptions,
+}>;
+
+export type Graph<T = MixedOutput> = {
+  ...$ReadOnly<GraphInputOptions>,
+  dependencies: Dependencies<T>,
+  +importBundleNames: Set<string>,
+  +privateState: PrivateState,
+};
 
-export type TransformResult<T = MixedOutput> = $ReadOnly<{|
+export type TransformResult<T = MixedOutput> = $ReadOnly<{
   dependencies: $ReadOnlyArray<TransformResultDependency>,
   output: $ReadOnlyArray<T>,
-|}>;
+}>;
 
-export type TransformResultWithSource<T = MixedOutput> = $ReadOnly<{|
+export type TransformResultWithSource<T = MixedOutput> = $ReadOnly<{
   ...TransformResult<T>,
   getSource: () => Buffer,
-|}>;
+}>;
 
 export type TransformFn<T = MixedOutput> = string => Promise<
   TransformResultWithSource<T>,
 >;
-export type AllowOptionalDependenciesWithOptions = {|
+export type AllowOptionalDependenciesWithOptions = {
   +exclude: Array<string>,
-|};
+};
 export type AllowOptionalDependencies =
   | boolean
   | AllowOptionalDependenciesWithOptions;
 
-export type Options<T = MixedOutput> = {|
+export type Options<T = MixedOutput> = {
   +resolve: (from: string, to: string) => string,
   +transform: TransformFn<T>,
   +transformOptions: TransformInputOptions,
   +onProgress: ?(numProcessed: number, total: number) => mixed,
   +experimentalImportBundleSupport: boolean,
   +shallow: boolean,
-|};
+};
 
-export type DeltaResult<T = MixedOutput> = {|
+export type DeltaResult<T = MixedOutput> = {
   +added: Map<string, Module<T>>,
   +modified: Map<string, Module<T>>,
   +deleted: Set<string>,
   +reset: boolean,
-|};
+};
 
-export type SerializerOptions = {|
+export type SerializerOptions = {
   +asyncRequireModulePath: string,
   +createModuleId: string => number,
   +dev: boolean,
@@ -132,4 +138,4 @@ export type SerializerOptions = {|
   +serverRoot: string,
   +sourceMapUrl: ?string,
   +sourceUrl: ?string,
-|};
+};

package/src/DeltaBundler.js

@@ -11,6 +11,8 @@
 
 const DeltaCalculator = require("./DeltaBundler/DeltaCalculator");
 
+const { EventEmitter } = require("events");
+
 /**
  * `DeltaBundler` uses the `DeltaTransformer` to build bundle deltas. This
  * module handles all the transformer instances so it can support multiple
@@ -20,8 +22,8 @@ const DeltaCalculator = require("./DeltaBundler/DeltaCalculator");
 class DeltaBundler {
   _deltaCalculators = new Map();
 
-  constructor(bundler) {
-    this._bundler = bundler;
+  constructor(changeEventSource) {
+    this._changeEventSource = changeEventSource;
   }
 
   end() {
@@ -31,8 +33,11 @@ class DeltaBundler {
   }
 
   async getDependencies(entryPoints, options) {
-    const depGraph = await this._bundler.getDependencyGraph();
-    const deltaCalculator = new DeltaCalculator(entryPoints, depGraph, options);
+    const deltaCalculator = new DeltaCalculator(
+      new Set(entryPoints),
+      this._changeEventSource,
+      options
+    );
     await deltaCalculator.getDelta({
       reset: true,
       shallow: options.shallow,
@@ -45,8 +50,11 @@ class DeltaBundler {
   // To get just the dependencies, use getDependencies which will not leak graphs.
 
   async buildGraph(entryPoints, options) {
-    const depGraph = await this._bundler.getDependencyGraph();
-    const deltaCalculator = new DeltaCalculator(entryPoints, depGraph, options);
+    const deltaCalculator = new DeltaCalculator(
+      new Set(entryPoints),
+      this._changeEventSource,
+      options
+    );
     await deltaCalculator.getDelta({
       reset: true,
       shallow: options.shallow,

package/src/DeltaBundler.js.flow

@@ -10,7 +10,6 @@
 
 'use strict';
 
-import type Bundler from './Bundler';
 import type {
   DeltaResult,
   Dependencies,
@@ -21,6 +20,7 @@ import type {
 } from './DeltaBundler/types.flow';
 
 const DeltaCalculator = require('./DeltaBundler/DeltaCalculator');
+const {EventEmitter} = require('events');
 
 export type {
   DeltaResult,
@@ -41,11 +41,11 @@ export type {
  * `clientId` param (which maps a client to a specific delta transformer).
  */
 class DeltaBundler<T = MixedOutput> {
-  _bundler: Bundler;
+  _changeEventSource: EventEmitter;
   _deltaCalculators: Map<Graph<T>, DeltaCalculator<T>> = new Map();
 
-  constructor(bundler: Bundler) {
-    this._bundler = bundler;
+  constructor(changeEventSource: EventEmitter) {
+    this._changeEventSource = changeEventSource;
   }
 
   end(): void {
@@ -59,9 +59,11 @@ class DeltaBundler<T = MixedOutput> {
     entryPoints: $ReadOnlyArray<string>,
     options: Options<T>,
   ): Promise<Dependencies<T>> {
-    const depGraph = await this._bundler.getDependencyGraph();
-
-    const deltaCalculator = new DeltaCalculator(entryPoints, depGraph, options);
+    const deltaCalculator = new DeltaCalculator(
+      new Set(entryPoints),
+      this._changeEventSource,
+      options,
+    );
 
     await deltaCalculator.getDelta({reset: true, shallow: options.shallow});
     const graph = deltaCalculator.getGraph();
@@ -77,9 +79,11 @@ class DeltaBundler<T = MixedOutput> {
     entryPoints: $ReadOnlyArray<string>,
     options: Options<T>,
   ): Promise<Graph<T>> {
-    const depGraph = await this._bundler.getDependencyGraph();
-
-    const deltaCalculator = new DeltaCalculator(entryPoints, depGraph, options);
+    const deltaCalculator = new DeltaCalculator(
+      new Set(entryPoints),
+      this._changeEventSource,
+      options,
+    );
 
     await deltaCalculator.getDelta({reset: true, shallow: options.shallow});
     const graph = deltaCalculator.getGraph();

package/src/HmrServer.js.flow

@@ -39,18 +39,18 @@ const url = require('url');
 type $ReturnType<F> = $Call<<A, R>((...A) => R) => R, F>;
 export type EntryPointURL = $ReturnType<typeof url.parse>;
 
-type Client = {|
+type Client = {
   optedIntoHMR: boolean,
   revisionIds: Array<RevisionId>,
   +sendFn: string => void,
-|};
+};
 
-type ClientGroup = {|
+type ClientGroup = {
   +clients: Set<Client>,
   clientUrl: EntryPointURL,
   revisionId: RevisionId,
   +unlisten: () => void,
-|};
+};
 
 function send(sendFns: Array<(string) => void>, message: HmrMessage): void {
   const strMessage = JSON.stringify(message);
@@ -252,7 +252,7 @@ class HmrServer<TClient: Client> {
 
   async _handleFileChange(
     group: ClientGroup,
-    options: {|isInitialUpdate: boolean|},
+    options: {isInitialUpdate: boolean},
   ): Promise<void> {
     const optedIntoHMR = [...group.clients].some(
       (client: Client) => client.optedIntoHMR,
@@ -292,7 +292,7 @@ class HmrServer<TClient: Client> {
 
   async _prepareMessage(
     group: ClientGroup,
-    options: {|isInitialUpdate: boolean|},
+    options: {isInitialUpdate: boolean},
   ): Promise<HmrUpdateMessage | HmrErrorMessage> {
     try {
       const revPromise = this._bundler.getRevision(group.revisionId);

package/src/IncrementalBundler.js

@@ -43,7 +43,7 @@ class IncrementalBundler {
   constructor(config, options) {
     this._config = config;
     this._bundler = new Bundler(config, options);
-    this._deltaBundler = new DeltaBundler(this._bundler);
+    this._deltaBundler = new DeltaBundler(this._bundler.getWatcher());
   }
 
   end() {

package/src/IncrementalBundler.js.flow

@@ -33,24 +33,24 @@ export opaque type RevisionId: string = string;
 
 export type OutputGraph = Graph<>;
 
-type OtherOptions = {|
+type OtherOptions = {
   +onProgress: $PropertyType<DeltaBundlerOptions<>, 'onProgress'>,
   +shallow: boolean,
-|};
+};
 
-export type GraphRevision = {|
+export type GraphRevision = {
   // Identifies the last computed revision.
   +id: RevisionId,
   +date: Date,
   +graphId: GraphId,
   +graph: OutputGraph,
   +prepend: $ReadOnlyArray<Module<>>,
-|};
+};
 
-export type IncrementalBundlerOptions = $ReadOnly<{|
+export type IncrementalBundlerOptions = $ReadOnly<{
   hasReducedPerformance?: boolean,
   watch?: boolean,
-|}>;
+}>;
 
 function createRevisionId(): RevisionId {
   return crypto.randomBytes(8).toString('hex');
@@ -73,7 +73,7 @@ class IncrementalBundler {
   constructor(config: ConfigT, options?: IncrementalBundlerOptions) {
     this._config = config;
     this._bundler = new Bundler(config, options);
-    this._deltaBundler = new DeltaBundler(this._bundler);
+    this._deltaBundler = new DeltaBundler(this._bundler.getWatcher());
   }
 
   end(): void {
@@ -178,7 +178,7 @@ class IncrementalBundler {
       onProgress: null,
       shallow: false,
     },
-  ): Promise<{|+graph: OutputGraph, +prepend: $ReadOnlyArray<Module<>>|}> {
+  ): Promise<{+graph: OutputGraph, +prepend: $ReadOnlyArray<Module<>>}> {
     const graph = await this.buildGraphForEntries(
       [entryFile],
       transformOptions,

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

@@ -24,7 +24,7 @@ module.exports = class ModuleCache {
   getModule(path) {
     // This is hacky as hell... `ModuleGraph` handles relative paths but which
     // start with a slash (so we can have `/js/foo.js` or even `/../foo.js`).
-    // This does not play well with `jest-haste-map`, which tries to convert
+    // This does not play well with `metro-file-map`, which tries to convert
     // paths to absolute (https://fburl.com/vbwmjsxa) causing an additional
     // slashed to be prepended in the file path.
     // TODO: Refactor the way metro-buck handles paths to make them either

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

@@ -36,7 +36,7 @@ module.exports = class ModuleCache {
   getModule(path: string): Module {
     // This is hacky as hell... `ModuleGraph` handles relative paths but which
     // start with a slash (so we can have `/js/foo.js` or even `/../foo.js`).
-    // This does not play well with `jest-haste-map`, which tries to convert
+    // This does not play well with `metro-file-map`, which tries to convert
     // paths to absolute (https://fburl.com/vbwmjsxa) causing an additional
     // slashed to be prepended in the file path.
     // TODO: Refactor the way metro-buck handles paths to make them either

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

@@ -55,13 +55,13 @@ export type FastFS = {
   ...
 };
 
-type HasteMapOptions = {|
+type HasteMapOptions = {
   extensions: Extensions,
   files: Array<string>,
   moduleCache: ModuleCache,
   platforms: Platforms,
   preferNativePlatform: true,
-|};
+};
 
 declare class HasteMap {
   // node-haste/DependencyGraph/HasteMap.js

package/src/ModuleGraph/node-haste/node-haste.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.
@@ -45,7 +45,7 @@ const NULL_MODULE = {
 };
 const NODE_MODULES = path.sep + "node_modules" + path.sep;
 
-const isNodeModules = (file) => file.includes(NODE_MODULES); // This function maps the ModuleGraph data structure to jest-haste-map's ModuleMap
+const isNodeModules = (file) => file.includes(NODE_MODULES); // This function maps the ModuleGraph data structure to metro-file-map's ModuleMap
 
 const createModuleMap = ({ files, moduleCache, sourceExts, platforms }) => {
   const platformSet = new Set(
@@ -78,7 +78,7 @@ const createModuleMap = ({ files, moduleCache, sourceExts, platforms }) => {
     const mapModule = map.get(id) || Object.create(null);
     const platform =
       parsePlatformFilePath(filePath, platformSet).platform || GENERIC_PLATFORM;
-    const existingModule = mapModule[platform]; // 0 = Module, 1 = Package in jest-haste-map
+    const existingModule = mapModule[platform]; // 0 = Module, 1 = Package in metro-file-map
 
     mapModule[platform] = [filePath, module.type === "Package" ? 1 : 0];
 
@@ -141,7 +141,7 @@ exports.createResolveFn = function (options) {
     mainFields: options.mainFields,
     // $FlowFixMe -- error revealed by types-first codemod
     moduleCache,
-    moduleMap: new _jestHasteMap.ModuleMap({
+    moduleMap: new _metroFileMap.ModuleMap({
       duplicates: new Map(),
       map: createModuleMap({
         files,

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

@@ -11,9 +11,10 @@
 import type {Moduleish} from '../../node-haste/DependencyGraph/ModuleResolution';
 import type {ResolveFn, TransformedCodeFile} from '../types.flow';
 import type {Extensions, Path} from './node-haste.flow';
+import type {ModuleMapData, ModuleMapItem} from 'metro-file-map';
 import type {CustomResolver} from 'metro-resolver';
 
-import {ModuleMap} from 'jest-haste-map';
+import {ModuleMap} from 'metro-file-map';
 
 const {
   ModuleResolver,
@@ -25,7 +26,7 @@ const ModuleCache = require('./ModuleCache');
 const defaults = require('metro-config/src/defaults/defaults');
 const path = require('path');
 
-type ResolveOptions = {|
+type ResolveOptions = {
   assetExts: Extensions,
   assetResolutions: $ReadOnlyArray<string>,
   +disableHierarchicalLookup: boolean,
@@ -38,7 +39,7 @@ type ResolveOptions = {|
   resolveRequest?: ?CustomResolver,
   +sourceExts: Extensions,
   transformedFiles: {[path: Path]: TransformedCodeFile, ...},
-|};
+};
 
 const NATIVE_PLATFORM = 'native';
 const GENERIC_PLATFORM = 'g';
@@ -57,8 +58,13 @@ const NULL_MODULE: Moduleish = {
 const NODE_MODULES = path.sep + 'node_modules' + path.sep;
 const isNodeModules = file => file.includes(NODE_MODULES);
 
-// This function maps the ModuleGraph data structure to jest-haste-map's ModuleMap
-const createModuleMap = ({files, moduleCache, sourceExts, platforms}) => {
+// This function maps the ModuleGraph data structure to metro-file-map's ModuleMap
+const createModuleMap = ({
+  files,
+  moduleCache,
+  sourceExts,
+  platforms,
+}): ModuleMapData => {
   const platformSet = new Set(
     (platforms ?? defaults.platforms).concat([NATIVE_PLATFORM]),
   );
@@ -83,13 +89,13 @@ const createModuleMap = ({files, moduleCache, sourceExts, platforms}) => {
       return;
     }
 
-    const mapModule = map.get(id) || Object.create(null);
+    const mapModule: ModuleMapItem = map.get(id) || Object.create(null);
 
     const platform =
       parsePlatformFilePath(filePath, platformSet).platform || GENERIC_PLATFORM;
 
     const existingModule = mapModule[platform];
-    // 0 = Module, 1 = Package in jest-haste-map
+    // 0 = Module, 1 = Package in metro-file-map
     mapModule[platform] = [filePath, module.type === 'Package' ? 1 : 0];
 
     if (existingModule && existingModule[0] !== filePath) {

package/src/ModuleGraph/output/indexed-ram-bundle.js.flow

@@ -45,11 +45,11 @@ function asIndexedRamBundle({
   requireCalls: Iterable<Module>,
   segmentID: number,
   sourceMapPath?: ?string,
-}>): {|
+}>): {
   code: string | Buffer,
   extraFiles?: Iterable<[string, string | Buffer]>,
   map: IndexMap,
-|} {
+} {
   const idForPath = (x: {path: string, ...}) => idsForPath(x).moduleId;
   const [startup, deferred] = partition(modules, preloadedModules);
   const startupModules = [...startup, ...requireCalls];

package/src/ModuleGraph/output/plain-bundle.js.flow

@@ -27,11 +27,11 @@ function asPlainBundle({
   requireCalls,
   sourceMapPath,
   enableIDInlining,
-}: OutputFnArg): {|
+}: OutputFnArg): {
   code: string | Buffer,
   extraFiles?: Iterable<[string, string | Buffer]>,
   map: MixedSourceMap,
-|} {
+} {
   const builder = new BundleBuilder(filename);
   const modIdForPath = (x: {path: string, ...}) => idsForPath(x).moduleId;
 

package/src/ModuleGraph/output/reverse-dependency-map-references.js.flow

@@ -17,18 +17,18 @@ import typeof * as Types from '@babel/types';
 import invariant from 'invariant';
 import nullthrows from 'nullthrows';
 
-type State = {|
-  opts: {|
+type State = {
+  opts: {
     +dependencyIds: $ReadOnlyArray<number>,
     +globalPrefix: string,
-  |},
-|};
+  },
+};
 
-function reverseDependencyMapReferences({types: t}: {types: Types, ...}): {|
-  visitor: {|
+function reverseDependencyMapReferences({types: t}: {types: Types, ...}): {
+  visitor: {
     CallExpression: (path: NodePath<CallExpression>, state: State) => void,
-  |},
-|} {
+  },
+} {
   return {
     visitor: {
       CallExpression(path: NodePath<CallExpression>, state: State) {

package/src/ModuleGraph/output/util.js.flow

@@ -238,10 +238,10 @@ function getModuleCodeAndMap(
     dependencyMapReservedName: ?string,
     globalPrefix: string,
   }>,
-): {|
+): {
   moduleCode: string,
   moduleMap: ?BasicSourceMap,
-|} {
+} {
   const {file} = module;
   let moduleCode, moduleMap;