metro 0.71.3 → 0.72.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.71.3",
+  "version": "0.72.2",
   "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.3",
-    "metro-cache": "0.71.3",
-    "metro-cache-key": "0.71.3",
-    "metro-config": "0.71.3",
-    "metro-core": "0.71.3",
-    "metro-file-map": "0.71.3",
-    "metro-hermes-compiler": "0.71.3",
-    "metro-inspector-proxy": "0.71.3",
-    "metro-minify-uglify": "0.71.3",
-    "metro-react-native-babel-preset": "0.71.3",
-    "metro-resolver": "0.71.3",
-    "metro-runtime": "0.71.3",
-    "metro-source-map": "0.71.3",
-    "metro-symbolicate": "0.71.3",
-    "metro-transform-plugins": "0.71.3",
-    "metro-transform-worker": "0.71.3",
+    "metro-babel-transformer": "0.72.2",
+    "metro-cache": "0.72.2",
+    "metro-cache-key": "0.72.2",
+    "metro-config": "0.72.2",
+    "metro-core": "0.72.2",
+    "metro-file-map": "0.72.2",
+    "metro-hermes-compiler": "0.72.2",
+    "metro-inspector-proxy": "0.72.2",
+    "metro-minify-uglify": "0.72.2",
+    "metro-react-native-babel-preset": "0.72.2",
+    "metro-resolver": "0.72.2",
+    "metro-runtime": "0.72.2",
+    "metro-source-map": "0.72.2",
+    "metro-symbolicate": "0.72.2",
+    "metro-transform-plugins": "0.72.2",
+    "metro-transform-worker": "0.72.2",
     "mime-types": "^2.1.27",
     "node-fetch": "^2.2.0",
     "nullthrows": "^1.1.1",
@@ -70,10 +70,12 @@
     "babel-jest": "^26.6.3",
     "dedent": "^0.7.0",
     "jest-snapshot": "^26.5.2",
-    "metro-babel-register": "0.71.3",
-    "metro-memory-fs": "0.71.3",
-    "metro-react-native-babel-preset": "0.71.3",
-    "metro-react-native-babel-transformer": "0.71.3",
+    "metro-babel-register": "0.72.2",
+    "metro-memory-fs": "0.72.2",
+    "metro-react-native-babel-preset": "0.72.2",
+    "metro-react-native-babel-transformer": "0.72.2",
+    "mock-req": "^0.2.0",
+    "mock-res": "^0.6.0",
     "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 {
@@ -143,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
       );
@@ -184,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)
@@ -199,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
@@ -177,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
@@ -193,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(
@@ -224,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/baseBytecodeBundle.js

@@ -15,8 +15,6 @@ const { getJsOutput } = require("./helpers/js");
 
 const processBytecodeModules = require("./helpers/processBytecodeModules");
 
-const { compile } = require("metro-hermes-compiler");
-
 function baseBytecodeBundle(entryPoint, preModules, graph, options) {
   for (const module of graph.dependencies.values()) {
     options.createModuleId(module.path);
@@ -36,6 +34,9 @@ function baseBytecodeBundle(entryPoint, preModules, graph, options) {
   const modules = [...graph.dependencies.values()].sort(
     (a, b) => options.createModuleId(a.path) - options.createModuleId(b.path)
   );
+
+  const { compile } = require("metro-hermes-compiler");
+
   const post = processBytecodeModules(
     getAppendScripts(
       entryPoint,

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

@@ -21,7 +21,6 @@ import type {BytecodeBundle} from 'metro-runtime/src/modules/types.flow';
 const getAppendScripts = require('../../lib/getAppendScripts');
 const {getJsOutput} = require('./helpers/js');
 const processBytecodeModules = require('./helpers/processBytecodeModules');
-const {compile} = require('metro-hermes-compiler');
 
 function baseBytecodeBundle(
   entryPoint: string,
@@ -50,6 +49,8 @@ function baseBytecodeBundle(
       options.createModuleId(a.path) - options.createModuleId(b.path),
   );
 
+  const {compile} = require('metro-hermes-compiler');
+
   const post = processBytecodeModules(
     getAppendScripts(
       entryPoint,

package/src/DeltaBundler/Serializers/helpers/bytecode.js

@@ -11,8 +11,6 @@
 
 const invariant = require("invariant");
 
-const { compile } = require("metro-hermes-compiler");
-
 const path = require("path");
 
 function wrapModule(module, options) {
@@ -39,6 +37,8 @@ function wrapModule(module, options) {
     );
   }
 
+  const { compile } = require("metro-hermes-compiler");
+
   const headerCode = `globalThis.$$METRO_D=[${params.join(",")}];`;
   return [
     compile(headerCode, {

package/src/DeltaBundler/Serializers/helpers/bytecode.js.flow

@@ -14,7 +14,6 @@ import type {Module} from '../../types.flow';
 import type {BytecodeOutput} from 'metro-transform-worker';
 
 const invariant = require('invariant');
-const {compile} = require('metro-hermes-compiler');
 const path = require('path');
 
 export type Options = {
@@ -48,6 +47,8 @@ function wrapModule(module: Module<>, options: Options): Array<Buffer> {
     );
   }
 
+  const {compile} = require('metro-hermes-compiler');
+
   const headerCode = `globalThis.$$METRO_D=[${params.join(',')}];`;
   return [
     compile(headerCode, {

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