metro 0.71.2 → 0.72.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.71.2",
+  "version": "0.72.1",
   "description": "🚇 The JavaScript bundler for React Native.",
   "main": "src/index.js",
   "bin": "src/cli.js",
@@ -36,22 +36,22 @@
     "invariant": "^2.2.4",
     "jest-worker": "^27.2.0",
     "lodash.throttle": "^4.1.1",
-    "metro-babel-transformer": "0.71.2",
-    "metro-cache": "0.71.2",
-    "metro-cache-key": "0.71.2",
-    "metro-config": "0.71.2",
-    "metro-core": "0.71.2",
-    "metro-file-map": "0.71.2",
-    "metro-hermes-compiler": "0.71.2",
-    "metro-inspector-proxy": "0.71.2",
-    "metro-minify-uglify": "0.71.2",
-    "metro-react-native-babel-preset": "0.71.2",
-    "metro-resolver": "0.71.2",
-    "metro-runtime": "0.71.2",
-    "metro-source-map": "0.71.2",
-    "metro-symbolicate": "0.71.2",
-    "metro-transform-plugins": "0.71.2",
-    "metro-transform-worker": "0.71.2",
+    "metro-babel-transformer": "0.72.1",
+    "metro-cache": "0.72.1",
+    "metro-cache-key": "0.72.1",
+    "metro-config": "0.72.1",
+    "metro-core": "0.72.1",
+    "metro-file-map": "0.72.1",
+    "metro-hermes-compiler": "0.72.1",
+    "metro-inspector-proxy": "0.72.1",
+    "metro-minify-uglify": "0.72.1",
+    "metro-react-native-babel-preset": "0.72.1",
+    "metro-resolver": "0.72.1",
+    "metro-runtime": "0.72.1",
+    "metro-source-map": "0.72.1",
+    "metro-symbolicate": "0.72.1",
+    "metro-transform-plugins": "0.72.1",
+    "metro-transform-worker": "0.72.1",
     "mime-types": "^2.1.27",
     "node-fetch": "^2.2.0",
     "nullthrows": "^1.1.1",
@@ -70,10 +70,10 @@
     "babel-jest": "^26.6.3",
     "dedent": "^0.7.0",
     "jest-snapshot": "^26.5.2",
-    "metro-babel-register": "0.71.2",
-    "metro-memory-fs": "0.71.2",
-    "metro-react-native-babel-preset": "0.71.2",
-    "metro-react-native-babel-transformer": "0.71.2",
+    "metro-babel-register": "0.72.1",
+    "metro-memory-fs": "0.72.1",
+    "metro-react-native-babel-preset": "0.72.1",
+    "metro-react-native-babel-transformer": "0.72.1",
     "stack-trace": "^0.0.10"
   },
   "license": "MIT"

package/src/Assets.js

@@ -108,8 +108,9 @@ async function getAbsoluteAssetRecord(assetPath, platform = null) {
 
   if (!record) {
     throw new Error(
-      /* $FlowFixMe: platform can be null */
-      `Asset not found: ${assetPath} for platform: ${platform}`
+      `Asset not found: ${assetPath} for platform: ${
+        platform !== null && platform !== void 0 ? platform : "(unspecified)"
+      }`
     );
   }
 

package/src/Assets.js.flow

@@ -154,8 +154,9 @@ async function getAbsoluteAssetRecord(
 
   if (!record) {
     throw new Error(
-      /* $FlowFixMe: platform can be null */
-      `Asset not found: ${assetPath} for platform: ${platform}`,
+      `Asset not found: ${assetPath} for platform: ${
+        platform ?? '(unspecified)'
+      }`,
     );
   }
 

package/src/Bundler.js

@@ -55,11 +55,20 @@ class Bundler {
     return this._depGraph;
   }
 
-  async transformFile(filePath, transformOptions) {
+  async transformFile(
+    filePath,
+    transformOptions,
+    /** Optionally provide the file contents, this can be used to provide virtual contents for a file. */
+    fileBuffer
+  ) {
     // We need to be sure that the DependencyGraph has been initialized.
     // TODO: Remove this ugly hack!
     await this._depGraph.ready();
-    return this._transformer.transformFile(filePath, transformOptions);
+    return this._transformer.transformFile(
+      filePath,
+      transformOptions,
+      fileBuffer
+    );
   } // Waits for the bundler to become ready.
 
   async ready() {

package/src/Bundler.js.flow

@@ -68,12 +68,18 @@ class Bundler {
   async transformFile(
     filePath: string,
     transformOptions: TransformOptions,
+    /** Optionally provide the file contents, this can be used to provide virtual contents for a file. */
+    fileBuffer?: Buffer,
   ): Promise<TransformResultWithSource<>> {
     // We need to be sure that the DependencyGraph has been initialized.
     // TODO: Remove this ugly hack!
     await this._depGraph.ready();
 
-    return this._transformer.transformFile(filePath, transformOptions);
+    return this._transformer.transformFile(
+      filePath,
+      transformOptions,
+      fileBuffer,
+    );
   }
 
   // Waits for the bundler to become ready.

package/src/DeltaBundler/DeltaCalculator.js

@@ -9,12 +9,7 @@
  */
 "use strict";
 
-const {
-  createGraph,
-  initialTraverseDependencies,
-  reorderGraph,
-  traverseDependencies,
-} = require("./graphOperations");
+var _graphOperations = require("./graphOperations");
 
 const { EventEmitter } = require("events");
 /**
@@ -27,12 +22,13 @@ const { EventEmitter } = require("events");
 class DeltaCalculator extends EventEmitter {
   _deletedFiles = new Set();
   _modifiedFiles = new Set();
+  _addedFiles = new Set();
 
   constructor(entryPoints, changeEventSource, options) {
     super();
     this._options = options;
     this._changeEventSource = changeEventSource;
-    this._graph = createGraph({
+    this._graph = (0, _graphOperations.createGraph)({
       entryPoints,
       transformOptions: this._options.transformOptions,
     });
@@ -51,12 +47,13 @@ class DeltaCalculator extends EventEmitter {
 
     this.removeAllListeners(); // Clean up all the cache data structures to deallocate memory.
 
-    this._graph = createGraph({
+    this._graph = (0, _graphOperations.createGraph)({
       entryPoints: this._graph.entryPoints,
       transformOptions: this._options.transformOptions,
     });
     this._modifiedFiles = new Set();
     this._deletedFiles = new Set();
+    this._addedFiles = new Set();
   }
   /**
    * Main method to calculate the delta of modules. It returns a DeltaResult,
@@ -75,13 +72,16 @@ class DeltaCalculator extends EventEmitter {
     const modifiedFiles = this._modifiedFiles;
     this._modifiedFiles = new Set();
     const deletedFiles = this._deletedFiles;
-    this._deletedFiles = new Set(); // Concurrent requests should reuse the same bundling process. To do so,
+    this._deletedFiles = new Set();
+    const addedFiles = this._addedFiles;
+    this._addedFiles = new Set(); // Concurrent requests should reuse the same bundling process. To do so,
     // this method stores the promise as an instance variable, and then it's
     // removed after it gets resolved.
 
     this._currentBuildPromise = this._getChangedDependencies(
       modifiedFiles,
-      deletedFiles
+      deletedFiles,
+      addedFiles
     );
     let result;
     const numDependencies = this._graph.dependencies.size;
@@ -94,7 +94,8 @@ class DeltaCalculator extends EventEmitter {
       // do so, asking for a delta after an error will produce an empty Delta,
       // which is not correct.
       modifiedFiles.forEach((file) => this._modifiedFiles.add(file));
-      deletedFiles.forEach((file) => this._deletedFiles.add(file)); // If after an error the number of modules has changed, we could be in
+      deletedFiles.forEach((file) => this._deletedFiles.add(file));
+      addedFiles.forEach((file) => this._addedFiles.add(file)); // If after an error the number of modules has changed, we could be in
       // a weird state. As a safe net we clean the dependency modules to force
       // a clean traversal of the graph next time.
 
@@ -108,7 +109,7 @@ class DeltaCalculator extends EventEmitter {
     } // Return all the modules if the client requested a reset delta.
 
     if (reset) {
-      reorderGraph(this._graph, {
+      (0, _graphOperations.reorderGraph)(this._graph, {
         shallow,
       });
       return {
@@ -130,6 +131,8 @@ class DeltaCalculator extends EventEmitter {
   getGraph() {
     return this._graph;
   }
+  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+   * LTI update could not be added via codemod */
 
   _handleMultipleFileChanges = ({ eventsQueue }) => {
     eventsQueue.forEach(this._handleFileChange);
@@ -141,23 +144,68 @@ class DeltaCalculator extends EventEmitter {
    */
 
   _handleFileChange = ({ type, filePath }) => {
-    if (type === "delete") {
-      this._deletedFiles.add(filePath);
+    let state;
+
+    if (this._deletedFiles.has(filePath)) {
+      state = "deleted";
+    } else if (this._modifiedFiles.has(filePath)) {
+      state = "modified";
+    } else if (this._addedFiles.has(filePath)) {
+      state = "added";
+    }
+
+    let nextState;
 
-      this._modifiedFiles.delete(filePath);
+    if (type === "delete") {
+      nextState = "deleted";
+    } else if (type === "add") {
+      // A deleted+added file is modified
+      nextState = state === "deleted" ? "modified" : "added";
     } else {
-      this._deletedFiles.delete(filePath);
+      // type === 'change'
+      // An added+modified file is added
+      nextState = state === "added" ? "added" : "modified";
+    }
+
+    switch (nextState) {
+      case "deleted":
+        this._deletedFiles.add(filePath);
+
+        this._modifiedFiles.delete(filePath);
+
+        this._addedFiles.delete(filePath);
+
+        break;
 
-      this._modifiedFiles.add(filePath);
+      case "added":
+        this._addedFiles.add(filePath);
+
+        this._deletedFiles.delete(filePath);
+
+        this._modifiedFiles.delete(filePath);
+
+        break;
+
+      case "modified":
+        this._modifiedFiles.add(filePath);
+
+        this._deletedFiles.delete(filePath);
+
+        this._addedFiles.delete(filePath);
+
+        break;
+
+      default:
+        nextState;
     } // Notify users that there is a change in some of the bundle files. This
     // way the client can choose to refetch the bundle.
 
     this.emit("change");
   };
 
-  async _getChangedDependencies(modifiedFiles, deletedFiles) {
+  async _getChangedDependencies(modifiedFiles, deletedFiles, addedFiles) {
     if (!this._graph.dependencies.size) {
-      const { added } = await initialTraverseDependencies(
+      const { added } = await (0, _graphOperations.initialTraverseDependencies)(
         this._graph,
         this._options
       );
@@ -182,7 +230,22 @@ class DeltaCalculator extends EventEmitter {
           }
         });
       }
-    }); // We only want to process files that are in the bundle.
+    }); // NOTE(EvanBacon): This check adds extra complexity so we feature gate it
+    // to enable users to opt out.
+
+    if (this._options.unstable_allowRequireContext) {
+      // Check if any added or removed files are matched in a context module.
+      // We only need to do this for added files because (1) deleted files will have a context
+      // module as an inverse dependency, (2) modified files don't invalidate the contents
+      // of the context module.
+      addedFiles.forEach((filePath) => {
+        (0, _graphOperations.markModifiedContextModules)(
+          this._graph,
+          filePath,
+          modifiedFiles
+        );
+      });
+    } // We only want to process files that are in the bundle.
 
     const modifiedDependencies = Array.from(modifiedFiles).filter((filePath) =>
       this._graph.dependencies.has(filePath)
@@ -197,7 +260,8 @@ class DeltaCalculator extends EventEmitter {
       };
     }
 
-    const { added, modified, deleted } = await traverseDependencies(
+    const { added, modified, deleted } = await (0,
+    _graphOperations.traverseDependencies)(
       modifiedDependencies,
       this._graph,
       this._options

package/src/DeltaBundler/DeltaCalculator.js.flow

@@ -10,14 +10,15 @@
 
 'use strict';
 
-import type {DeltaResult, Graph, Options} from './types.flow';
-
-const {
+import {
   createGraph,
   initialTraverseDependencies,
+  markModifiedContextModules,
   reorderGraph,
   traverseDependencies,
-} = require('./graphOperations');
+} from './graphOperations';
+import type {DeltaResult, Graph, Options} from './types.flow';
+
 const {EventEmitter} = require('events');
 
 /**
@@ -33,6 +34,7 @@ class DeltaCalculator<T> extends EventEmitter {
   _currentBuildPromise: ?Promise<DeltaResult<T>>;
   _deletedFiles: Set<string> = new Set();
   _modifiedFiles: Set<string> = new Set();
+  _addedFiles: Set<string> = new Set();
 
   _graph: Graph<T>;
 
@@ -72,6 +74,7 @@ class DeltaCalculator<T> extends EventEmitter {
     });
     this._modifiedFiles = new Set();
     this._deletedFiles = new Set();
+    this._addedFiles = new Set();
   }
 
   /**
@@ -99,6 +102,8 @@ class DeltaCalculator<T> extends EventEmitter {
     this._modifiedFiles = new Set();
     const deletedFiles = this._deletedFiles;
     this._deletedFiles = new Set();
+    const addedFiles = this._addedFiles;
+    this._addedFiles = new Set();
 
     // Concurrent requests should reuse the same bundling process. To do so,
     // this method stores the promise as an instance variable, and then it's
@@ -106,6 +111,7 @@ class DeltaCalculator<T> extends EventEmitter {
     this._currentBuildPromise = this._getChangedDependencies(
       modifiedFiles,
       deletedFiles,
+      addedFiles,
     );
 
     let result;
@@ -121,6 +127,7 @@ class DeltaCalculator<T> extends EventEmitter {
       // which is not correct.
       modifiedFiles.forEach((file: string) => this._modifiedFiles.add(file));
       deletedFiles.forEach((file: string) => this._deletedFiles.add(file));
+      addedFiles.forEach((file: string) => this._addedFiles.add(file));
 
       // If after an error the number of modules has changed, we could be in
       // a weird state. As a safe net we clean the dependency modules to force
@@ -158,6 +165,8 @@ class DeltaCalculator<T> extends EventEmitter {
     return this._graph;
   }
 
+  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+   * LTI update could not be added via codemod */
   _handleMultipleFileChanges = ({eventsQueue}) => {
     eventsQueue.forEach(this._handleFileChange);
   };
@@ -175,12 +184,45 @@ class DeltaCalculator<T> extends EventEmitter {
     filePath: string,
     ...
   }): mixed => {
+    let state: void | 'deleted' | 'modified' | 'added';
+    if (this._deletedFiles.has(filePath)) {
+      state = 'deleted';
+    } else if (this._modifiedFiles.has(filePath)) {
+      state = 'modified';
+    } else if (this._addedFiles.has(filePath)) {
+      state = 'added';
+    }
+
+    let nextState: 'deleted' | 'modified' | 'added';
     if (type === 'delete') {
-      this._deletedFiles.add(filePath);
-      this._modifiedFiles.delete(filePath);
+      nextState = 'deleted';
+    } else if (type === 'add') {
+      // A deleted+added file is modified
+      nextState = state === 'deleted' ? 'modified' : 'added';
     } else {
-      this._deletedFiles.delete(filePath);
-      this._modifiedFiles.add(filePath);
+      // type === 'change'
+      // An added+modified file is added
+      nextState = state === 'added' ? 'added' : 'modified';
+    }
+
+    switch (nextState) {
+      case 'deleted':
+        this._deletedFiles.add(filePath);
+        this._modifiedFiles.delete(filePath);
+        this._addedFiles.delete(filePath);
+        break;
+      case 'added':
+        this._addedFiles.add(filePath);
+        this._deletedFiles.delete(filePath);
+        this._modifiedFiles.delete(filePath);
+        break;
+      case 'modified':
+        this._modifiedFiles.add(filePath);
+        this._deletedFiles.delete(filePath);
+        this._addedFiles.delete(filePath);
+        break;
+      default:
+        (nextState: empty);
     }
 
     // Notify users that there is a change in some of the bundle files. This
@@ -191,6 +233,7 @@ class DeltaCalculator<T> extends EventEmitter {
   async _getChangedDependencies(
     modifiedFiles: Set<string>,
     deletedFiles: Set<string>,
+    addedFiles: Set<string>,
   ): Promise<DeltaResult<T>> {
     if (!this._graph.dependencies.size) {
       const {added} = await initialTraverseDependencies(
@@ -222,6 +265,18 @@ class DeltaCalculator<T> extends EventEmitter {
       }
     });
 
+    // NOTE(EvanBacon): This check adds extra complexity so we feature gate it
+    // to enable users to opt out.
+    if (this._options.unstable_allowRequireContext) {
+      // Check if any added or removed files are matched in a context module.
+      // We only need to do this for added files because (1) deleted files will have a context
+      // module as an inverse dependency, (2) modified files don't invalidate the contents
+      // of the context module.
+      addedFiles.forEach(filePath => {
+        markModifiedContextModules(this._graph, filePath, modifiedFiles);
+      });
+    }
+
     // We only want to process files that are in the bundle.
     const modifiedDependencies = Array.from(modifiedFiles).filter(
       (filePath: string) => this._graph.dependencies.has(filePath),

package/src/DeltaBundler/Serializers/hmrJSBundle.js.flow

@@ -36,9 +36,7 @@ function generateModules(
   for (const module of sourceModules) {
     if (isJsModule(module)) {
       // Construct a bundle URL for this specific module only
-      const getURL = (
-        extension: $TEMPORARY$string<'bundle'> | $TEMPORARY$string<'map'>,
-      ) => {
+      const getURL = (extension: 'bundle' | 'map') => {
         options.clientUrl.pathname = path.relative(
           options.projectRoot,
           path.join(

package/src/DeltaBundler/Transformer.js

@@ -9,6 +9,12 @@
  */
 "use strict";
 
+var _crypto = _interopRequireDefault(require("crypto"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+
 const getTransformCacheKey = require("./getTransformCacheKey");
 
 const WorkerFarm = require("./WorkerFarm");
@@ -53,7 +59,7 @@ class Transformer {
     this._baseHash = stableHash([globalCacheKey]).toString("binary");
   }
 
-  async transformFile(filePath, transformerOptions) {
+  async transformFile(filePath, transformerOptions, fileBuffer) {
     const cache = this._cache;
     const {
       customTransformOptions,
@@ -100,8 +106,17 @@ class Transformer {
       unstable_disableES6Transforms,
       unstable_transformProfile,
     ]);
-
-    const sha1 = this._getSha1(filePath);
+    let sha1;
+
+    if (fileBuffer) {
+      // Shortcut for virtual modules which provide the contents with the filename.
+      sha1 = _crypto.default
+        .createHash("sha1")
+        .update(fileBuffer)
+        .digest("hex");
+    } else {
+      sha1 = this._getSha1(filePath);
+    }
 
     let fullKey = Buffer.concat([partialKey, Buffer.from(sha1, "hex")]);
     const result = await cache.get(fullKey); // A valid result from the cache is used directly; otherwise we call into
@@ -112,7 +127,11 @@ class Transformer {
           result,
           sha1,
         }
-      : await this._workerFarm.transform(localPath, transformerOptions); // Only re-compute the full key if the SHA-1 changed. This is because
+      : await this._workerFarm.transform(
+          localPath,
+          transformerOptions,
+          fileBuffer
+        ); // Only re-compute the full key if the SHA-1 changed. This is because
     // references are used by the cache implementation in a weak map to keep
     // track of the cache that returned the result.
 
@@ -125,6 +144,10 @@ class Transformer {
       ...data.result,
 
       getSource() {
+        if (fileBuffer) {
+          return fileBuffer;
+        }
+
         return fs.readFileSync(filePath);
       },
     };

package/src/DeltaBundler/Transformer.js.flow

@@ -13,6 +13,7 @@
 import type {TransformResult, TransformResultWithSource} from '../DeltaBundler';
 import type {TransformerConfig, TransformOptions} from './Worker';
 import type {ConfigT} from 'metro-config/src/configTypes.flow';
+import crypto from 'crypto';
 
 const getTransformCacheKey = require('./getTransformCacheKey');
 const WorkerFarm = require('./WorkerFarm');
@@ -66,6 +67,7 @@ class Transformer {
   async transformFile(
     filePath: string,
     transformerOptions: TransformOptions,
+    fileBuffer?: Buffer,
   ): Promise<TransformResultWithSource<>> {
     const cache = this._cache;
 
@@ -119,7 +121,14 @@ class Transformer {
       unstable_transformProfile,
     ]);
 
-    const sha1 = this._getSha1(filePath);
+    let sha1: string;
+    if (fileBuffer) {
+      // Shortcut for virtual modules which provide the contents with the filename.
+      sha1 = crypto.createHash('sha1').update(fileBuffer).digest('hex');
+    } else {
+      sha1 = this._getSha1(filePath);
+    }
+
     let fullKey = Buffer.concat([partialKey, Buffer.from(sha1, 'hex')]);
     const result = await cache.get(fullKey);
 
@@ -127,7 +136,11 @@ class Transformer {
     // the transformer to computed the corresponding result.
     const data = result
       ? {result, sha1}
-      : await this._workerFarm.transform(localPath, transformerOptions);
+      : await this._workerFarm.transform(
+          localPath,
+          transformerOptions,
+          fileBuffer,
+        );
 
     // Only re-compute the full key if the SHA-1 changed. This is because
     // references are used by the cache implementation in a weak map to keep
@@ -141,6 +154,9 @@ class Transformer {
     return {
       ...data.result,
       getSource(): Buffer {
+        if (fileBuffer) {
+          return fileBuffer;
+        }
         return fs.readFileSync(filePath);
       },
     };

package/src/DeltaBundler/Worker.flow.js

@@ -17,10 +17,55 @@ const fs = require("fs");
 
 const path = require("path");
 
+/**
+ * When the `Buffer` is sent over the worker thread it gets serialized into a JSON object.
+ * This helper method will deserialize it if needed.
+ *
+ * @returns `Buffer` representation of the JSON object.
+ * @returns `null` if the given object is nullish or not a serialized `Buffer` object.
+ */
+function asDeserializedBuffer(value) {
+  if (Buffer.isBuffer(value)) {
+    return value;
+  }
+
+  if (value && value.type === "Buffer") {
+    return Buffer.from(value.data);
+  }
+
+  return null;
+}
+
 async function transform(
   filename,
   transformOptions,
   projectRoot,
+  transformerConfig,
+  fileBuffer
+) {
+  let data;
+  const fileBufferObject = asDeserializedBuffer(fileBuffer);
+
+  if (fileBufferObject) {
+    data = fileBufferObject;
+  } else {
+    data = fs.readFileSync(path.resolve(projectRoot, filename));
+  }
+
+  return transformFile(
+    filename,
+    data,
+    transformOptions,
+    projectRoot,
+    transformerConfig
+  );
+}
+
+async function transformFile(
+  filename,
+  data,
+  transformOptions,
+  projectRoot,
   transformerConfig
 ) {
   // eslint-disable-next-line no-useless-call
@@ -33,7 +78,6 @@ async function transform(
     log_entry_label: "Transforming file",
     start_timestamp: process.hrtime(),
   };
-  const data = fs.readFileSync(path.resolve(projectRoot, filename));
   const sha1 = crypto.createHash("sha1").update(data).digest("hex");
   const result = await Transformer.transform(
     transformerConfig.transformerConfig,