metro 0.70.3 → 0.71.0

package/src/DeltaBundler/WorkerFarm.js.flow

@@ -18,17 +18,17 @@ import type {Readable} from 'stream';
 const {Worker: JestWorker} = require('jest-worker');
 const {Logger} = require('metro-core');
 
-type WorkerInterface = {|
+type WorkerInterface = {
   getStdout(): Readable,
   getStderr(): Readable,
   end(): void,
   ...Worker,
-|};
+};
 
-type TransformerResult = $ReadOnly<{|
+type TransformerResult = $ReadOnly<{
   result: TransformResult<>,
   sha1: string,
-|}>;
+}>;
 
 class WorkerFarm {
   _config: ConfigT;

package/src/DeltaBundler/getTransformCacheKey.js.flow

@@ -21,11 +21,11 @@ type CacheKeyProvider = {
   getCacheKey?: JsTransformerConfig => string,
 };
 
-function getTransformCacheKey(opts: {|
+function getTransformCacheKey(opts: {
   +cacheVersion: string,
   +projectRoot: string,
   +transformerConfig: TransformerConfig,
-|}): string {
+}): string {
   const {transformerPath, transformerConfig} = opts.transformerConfig;
 
   // eslint-disable-next-line no-useless-call

package/src/DeltaBundler/{traverseDependencies.js → graphOperations.js}

@@ -9,7 +9,16 @@
  */
 "use strict";
 
-const nullthrows = require("nullthrows");
+const nullthrows = require("nullthrows"); // Private state for the graph that persists between operations.
+
+function createGraph(options) {
+  return {
+    ...options,
+    dependencies: new Map(),
+    importBundleNames: new Set(),
+    privateState: {},
+  };
+}
 
 function getInternalOptions({
   transform,
@@ -51,10 +60,7 @@ async function traverseDependencies(paths, graph, options) {
   const internalOptions = getInternalOptions(options);
 
   for (const path of paths) {
-    // Only process the path if it's part of the dependency graph. It's possible
-    // that this method receives a path that is no longer part of it (e.g if a
-    // module gets removed from the dependency graph and just afterwards it gets
-    // modified), and we have to ignore these cases.
+    // Start traversing from modules that are already part of the dependency graph.
     if (graph.dependencies.get(path)) {
       delta.modified.add(path);
       await traverseDependenciesForSingleFile(
@@ -67,30 +73,15 @@ async function traverseDependencies(paths, graph, options) {
   }
 
   const added = new Map();
-  const modified = new Map();
-  const deleted = new Set();
-
-  for (const path of delta.deleted) {
-    // If a dependency has been marked both as added and deleted, it means that
-    // this is a renamed file (or that dependency has been removed from one path
-    // but added back in a different path). In this case the addition and
-    // deletion "get cancelled".
-    if (!delta.added.has(path)) {
-      deleted.add(path);
-    }
-
-    delta.modified.delete(path);
-    delta.added.delete(path);
-  }
 
   for (const path of delta.added) {
     added.set(path, nullthrows(graph.dependencies.get(path)));
   }
 
+  const modified = new Map();
+
   for (const path of delta.modified) {
-    // Similarly to the above, a file can be marked as both added and modified
-    // when its path and dependencies have changed. In this case, we only
-    // consider the addition.
+    // Only report a module as modified if we're not already reporting it as added.
     if (!delta.added.has(path)) {
       modified.set(path, nullthrows(graph.dependencies.get(path)));
     }
@@ -99,7 +90,7 @@ async function traverseDependencies(paths, graph, options) {
   return {
     added,
     modified,
-    deleted,
+    deleted: delta.deleted,
   };
 }
 
@@ -112,7 +103,7 @@ async function initialTraverseDependencies(graph, options) {
   };
   const internalOptions = getInternalOptions(options);
   await Promise.all(
-    graph.entryPoints.map((path) =>
+    [...graph.entryPoints].map((path) =>
       traverseDependenciesForSingleFile(path, graph, delta, internalOptions)
     )
   );
@@ -134,6 +125,7 @@ async function traverseDependenciesForSingleFile(path, graph, delta, options) {
 
 async function processModule(path, graph, delta, options) {
   // Transform the file via the given option.
+  // TODO: Unbind the transform method from options
   const result = await options.transform(path); // Get the absolute path of all sub-dependencies (some of them could have been
   // moved but maintain the same relative path).
 
@@ -224,7 +216,15 @@ async function addDependency(parentModule, path, graph, delta, options) {
     return;
   }
 
-  delta.added.add(path);
+  if (delta.deleted.has(path)) {
+    // Mark the addition by clearing a prior deletion.
+    delta.deleted.delete(path);
+  } else {
+    // Mark the addition in the added set.
+    delta.added.add(path);
+    delta.modified.delete(path);
+  }
+
   delta.inverseDependencies.set(path, new Set([parentModule.path]));
   options.onDependencyAdd();
   const module = await processModule(path, graph, delta, options);
@@ -305,7 +305,7 @@ function canSafelyRemoveFromParentModule(
 
   const undeletedInverseDependencies = Array.from(
     topInverseDependencies
-  ).filter((x) => !delta.deleted.has(x));
+  ).filter((x) => graph.dependencies.has(x));
   /**
    * We can only mark the `visited` Set of modules to be safely removable if
    * 1. We do not have top a level module to compare with parentModule.
@@ -362,14 +362,26 @@ function removeDependency(
     }
   }
 
-  delta.deleted.add(module.path); // Now we need to iterate through the module dependencies in order to
+  if (delta.added.has(module.path)) {
+    // Mark the deletion by clearing a prior addition.
+    delta.added.delete(module.path);
+  } else {
+    // Mark the deletion in the deleted set.
+    delta.deleted.add(module.path);
+    delta.modified.delete(module.path);
+  } // This module is not used anywhere else! We can clear it from the bundle.
+  // Clean up all the state associated with this module in order to correctly
+  // re-add it if we encounter it again.
+
+  graph.dependencies.delete(module.path);
+  delta.inverseDependencies.delete(module.path); // Now we need to iterate through the module dependencies in order to
   // clean up everything (we cannot read the module because it may have
   // been deleted).
 
   Array.from(module.dependencies.values())
     .filter(
       (dependency) =>
-        !delta.deleted.has(dependency.absolutePath) &&
+        graph.dependencies.has(dependency.absolutePath) &&
         dependency.absolutePath !== parentModule.path
     )
     .forEach((dependency) =>
@@ -380,9 +392,7 @@ function removeDependency(
         delta,
         canBeRemovedSafely
       )
-    ); // This module is not used anywhere else!! we can clear it from the bundle
-
-  graph.dependencies.delete(module.path);
+    );
 }
 
 function resolveDependencies(parentPath, dependencies, options) {
@@ -464,6 +474,7 @@ function reorderDependencies(graph, module, orderedDependencies, options) {
 }
 
 module.exports = {
+  createGraph,
   initialTraverseDependencies,
   traverseDependencies,
   reorderGraph,

package/src/DeltaBundler/{traverseDependencies.js.flow → graphOperations.js.flow}

@@ -13,6 +13,7 @@
 import type {
   Dependency,
   Graph,
+  GraphInputOptions,
   Module,
   Options,
   TransformResultDependency,
@@ -20,6 +21,20 @@ import type {
 
 const nullthrows = require('nullthrows');
 
+// Private state for the graph that persists between operations.
+export opaque type PrivateState = {
+  // TODO: Track e.g. GC scheduling here.
+};
+
+function createGraph<T>(options: GraphInputOptions): Graph<T> {
+  return {
+    ...options,
+    dependencies: new Map(),
+    importBundleNames: new Set(),
+    privateState: {},
+  };
+}
+
 type Result<T> = {
   added: Map<string, Module<T>>,
   modified: Map<string, Module<T>>,
@@ -32,21 +47,21 @@ type Result<T> = {
  * files have been modified. This allows to return the added modules before the
  * modified ones (which is useful for things like Hot Module Reloading).
  **/
-type Delta = $ReadOnly<{|
+type Delta = $ReadOnly<{
   added: Set<string>,
   modified: Set<string>,
   deleted: Set<string>,
   inverseDependencies: Map<string, Set<string>>,
-|}>;
+}>;
 
-type InternalOptions<T> = $ReadOnly<{|
+type InternalOptions<T> = $ReadOnly<{
   experimentalImportBundleSupport: boolean,
   onDependencyAdd: () => mixed,
   onDependencyAdded: () => mixed,
-  resolve: $PropertyType<Options<T>, 'resolve'>,
-  transform: $PropertyType<Options<T>, 'transform'>,
+  resolve: Options<T>['resolve'],
+  transform: Options<T>['transform'],
   shallow: boolean,
-|}>;
+}>;
 
 function getInternalOptions<T>({
   transform,
@@ -94,10 +109,7 @@ async function traverseDependencies<T>(
   const internalOptions = getInternalOptions(options);
 
   for (const path of paths) {
-    // Only process the path if it's part of the dependency graph. It's possible
-    // that this method receives a path that is no longer part of it (e.g if a
-    // module gets removed from the dependency graph and just afterwards it gets
-    // modified), and we have to ignore these cases.
+    // Start traversing from modules that are already part of the dependency graph.
     if (graph.dependencies.get(path)) {
       delta.modified.add(path);
 
@@ -111,30 +123,13 @@ async function traverseDependencies<T>(
   }
 
   const added = new Map();
-  const modified = new Map();
-  const deleted = new Set();
-
-  for (const path of delta.deleted) {
-    // If a dependency has been marked both as added and deleted, it means that
-    // this is a renamed file (or that dependency has been removed from one path
-    // but added back in a different path). In this case the addition and
-    // deletion "get cancelled".
-    if (!delta.added.has(path)) {
-      deleted.add(path);
-    }
-
-    delta.modified.delete(path);
-    delta.added.delete(path);
-  }
-
   for (const path of delta.added) {
     added.set(path, nullthrows(graph.dependencies.get(path)));
   }
 
+  const modified = new Map();
   for (const path of delta.modified) {
-    // Similarly to the above, a file can be marked as both added and modified
-    // when its path and dependencies have changed. In this case, we only
-    // consider the addition.
+    // Only report a module as modified if we're not already reporting it as added.
     if (!delta.added.has(path)) {
       modified.set(path, nullthrows(graph.dependencies.get(path)));
     }
@@ -143,7 +138,7 @@ async function traverseDependencies<T>(
   return {
     added,
     modified,
-    deleted,
+    deleted: delta.deleted,
   };
 }
 
@@ -161,7 +156,7 @@ async function initialTraverseDependencies<T>(
   const internalOptions = getInternalOptions(options);
 
   await Promise.all(
-    graph.entryPoints.map((path: string) =>
+    [...graph.entryPoints].map((path: string) =>
       traverseDependenciesForSingleFile(path, graph, delta, internalOptions),
     ),
   );
@@ -197,6 +192,7 @@ async function processModule<T>(
   options: InternalOptions<T>,
 ): Promise<Module<T>> {
   // Transform the file via the given option.
+  // TODO: Unbind the transform method from options
   const result = await options.transform(path);
 
   // Get the absolute path of all sub-dependencies (some of them could have been
@@ -304,7 +300,14 @@ async function addDependency<T>(
     return;
   }
 
-  delta.added.add(path);
+  if (delta.deleted.has(path)) {
+    // Mark the addition by clearing a prior deletion.
+    delta.deleted.delete(path);
+  } else {
+    // Mark the addition in the added set.
+    delta.added.add(path);
+    delta.modified.delete(path);
+  }
   delta.inverseDependencies.set(path, new Set([parentModule.path]));
 
   options.onDependencyAdd();
@@ -385,7 +388,7 @@ function canSafelyRemoveFromParentModule<T>(
 
   const undeletedInverseDependencies = Array.from(
     topInverseDependencies,
-  ).filter(x => !delta.deleted.has(x));
+  ).filter(x => graph.dependencies.has(x));
 
   /**
    * We can only mark the `visited` Set of modules to be safely removable if
@@ -443,7 +446,20 @@ function removeDependency<T>(
     }
   }
 
-  delta.deleted.add(module.path);
+  if (delta.added.has(module.path)) {
+    // Mark the deletion by clearing a prior addition.
+    delta.added.delete(module.path);
+  } else {
+    // Mark the deletion in the deleted set.
+    delta.deleted.add(module.path);
+    delta.modified.delete(module.path);
+  }
+
+  // This module is not used anywhere else! We can clear it from the bundle.
+  // Clean up all the state associated with this module in order to correctly
+  // re-add it if we encounter it again.
+  graph.dependencies.delete(module.path);
+  delta.inverseDependencies.delete(module.path);
 
   // Now we need to iterate through the module dependencies in order to
   // clean up everything (we cannot read the module because it may have
@@ -451,7 +467,7 @@ function removeDependency<T>(
   Array.from(module.dependencies.values())
     .filter(
       dependency =>
-        !delta.deleted.has(dependency.absolutePath) &&
+        graph.dependencies.has(dependency.absolutePath) &&
         dependency.absolutePath !== parentModule.path,
     )
     .forEach(dependency =>
@@ -463,8 +479,6 @@ function removeDependency<T>(
         canBeRemovedSafely,
       ),
     );
-  // This module is not used anywhere else!! we can clear it from the bundle
-  graph.dependencies.delete(module.path);
 }
 
 function resolveDependencies<T>(
@@ -559,6 +573,7 @@ function reorderDependencies<T>(
 }
 
 module.exports = {
+  createGraph,
   initialTraverseDependencies,
   traverseDependencies,
   reorderGraph,

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);