metro 0.71.2 → 0.72.1

package/src/DeltaBundler/Worker.flow.js.flow

@@ -51,11 +51,53 @@ type Data = $ReadOnly<{
   transformFileEndLogEntry: LogEntry,
 }>;
 
+/**
+ * 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: any): Buffer | null {
+  if (Buffer.isBuffer(value)) {
+    return value;
+  }
+  if (value && value.type === 'Buffer') {
+    return Buffer.from(value.data);
+  }
+  return null;
+}
+
 async function transform(
   filename: string,
   transformOptions: JsTransformOptions,
   projectRoot: string,
   transformerConfig: TransformerConfig,
+  fileBuffer?: Buffer,
+): Promise<Data> {
+  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: string,
+  data: Buffer,
+  transformOptions: JsTransformOptions,
+  projectRoot: string,
+  transformerConfig: TransformerConfig,
 ): Promise<Data> {
   // eslint-disable-next-line no-useless-call
   const Transformer = (require.call(
@@ -71,7 +113,6 @@ async function transform(
     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(

package/src/DeltaBundler/WorkerFarm.js

@@ -50,13 +50,14 @@ class WorkerFarm {
     }
   }
 
-  async transform(filename, options) {
+  async transform(filename, options, fileBuffer) {
     try {
       const data = await this._worker.transform(
         filename,
         options,
         this._config.projectRoot,
-        this._transformerConfig
+        this._transformerConfig,
+        fileBuffer
       );
       Logger.log(data.transformFileStartLogEntry);
       Logger.log(data.transformFileEndLogEntry);

package/src/DeltaBundler/WorkerFarm.js.flow

@@ -78,6 +78,7 @@ class WorkerFarm {
   async transform(
     filename: string,
     options: TransformOptions,
+    fileBuffer?: Buffer,
   ): Promise<TransformerResult> {
     try {
       const data = await this._worker.transform(
@@ -85,6 +86,7 @@ class WorkerFarm {
         options,
         this._config.projectRoot,
         this._transformerConfig,
+        fileBuffer,
       );
 
       Logger.log(data.transformFileStartLogEntry);
@@ -107,7 +109,7 @@ class WorkerFarm {
     workerPath: string,
     exposedMethods: $ReadOnlyArray<string>,
     numWorkers: number,
-  ) {
+  ): any {
     const env = {
       ...process.env,
       // Force color to print syntax highlighted code frames.
@@ -136,7 +138,7 @@ class WorkerFarm {
     return null;
   }
 
-  _formatGenericError(err, filename: string): TransformError {
+  _formatGenericError(err: any, filename: string): TransformError {
     const error = new TransformError(`${filename}: ${err.message}`);
 
     return Object.assign(error, {
@@ -145,7 +147,7 @@ class WorkerFarm {
     });
   }
 
-  _formatBabelError(err, filename: string): TransformError {
+  _formatBabelError(err: any, filename: string): TransformError {
     const error = new TransformError(
       `${err.type || 'Error'}${
         err.message.includes(filename) ? '' : ' in ' + filename

package/src/DeltaBundler/graphOperations.js

@@ -31,6 +31,52 @@
 
 var _CountingSet = _interopRequireDefault(require("../lib/CountingSet"));
 
+var _contextModule = require("../lib/contextModule");
+
+var path = _interopRequireWildcard(require("path"));
+
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function") return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== "object" && typeof obj !== "function")) {
+    return { default: obj };
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
 function _interopRequireDefault(obj) {
   return obj && obj.__esModule ? obj : { default: obj };
 }
@@ -45,6 +91,7 @@ function createGraph(options) {
     dependencies: new Map(),
     importBundleNames: new Set(),
     privateState: {
+      resolvedContexts: new Map(),
       gc: {
         color: new Map(),
         possibleCycleRoots: new Set(),
@@ -78,7 +125,7 @@ function getInternalOptions({
  * dependency graph.
  * Instead of traversing the whole graph each time, it just calculates the
  * difference between runs by only traversing the added/removed dependencies.
- * To do so, it uses the passed passed graph dependencies and it mutates it.
+ * To do so, it uses the passed graph dependencies and it mutates it.
  * The paths parameter contains the absolute paths of the root files that the
  * method should traverse. Normally, these paths should be the modified files
  * since the last traversal.
@@ -176,12 +223,14 @@ async function traverseDependenciesForSingleFile(path, graph, delta, options) {
 }
 
 async function processModule(path, graph, delta, options) {
-  // Transform the file via the given option.
+  const resolvedContext = graph.privateState.resolvedContexts.get(path); // 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
+
+  const result = await options.transform(path, resolvedContext); // Get the absolute path of all sub-dependencies (some of them could have been
   // moved but maintain the same relative path).
 
   const currentDependencies = resolveDependencies(
+    graph,
     path,
     result.dependencies,
     options
@@ -201,48 +250,28 @@ async function processModule(path, graph, delta, options) {
   };
   graph.dependencies.set(module.path, module); // Diff dependencies (1/2): remove dependencies that have changed or been removed.
 
-  for (const [relativePath, prevDependency] of previousDependencies) {
-    const curDependency = currentDependencies.get(relativePath);
+  for (const [key, prevDependency] of previousDependencies) {
+    const curDependency = currentDependencies.get(key);
 
     if (
       !curDependency ||
-      curDependency.absolutePath !== prevDependency.absolutePath ||
-      (options.experimentalImportBundleSupport &&
-        curDependency.data.data.asyncType !==
-          prevDependency.data.data.asyncType)
+      !dependenciesEqual(prevDependency, curDependency, options)
     ) {
-      removeDependency(
-        module,
-        relativePath,
-        prevDependency,
-        graph,
-        delta,
-        options
-      );
+      removeDependency(module, key, prevDependency, graph, delta, options);
     }
   } // Diff dependencies (2/2): add dependencies that have changed or been added.
 
   const promises = [];
 
-  for (const [relativePath, curDependency] of currentDependencies) {
-    const prevDependency = previousDependencies.get(relativePath);
+  for (const [key, curDependency] of currentDependencies) {
+    const prevDependency = previousDependencies.get(key);
 
     if (
       !prevDependency ||
-      prevDependency.absolutePath !== curDependency.absolutePath ||
-      (options.experimentalImportBundleSupport &&
-        prevDependency.data.data.asyncType !==
-          curDependency.data.data.asyncType)
+      !dependenciesEqual(prevDependency, curDependency, options)
     ) {
       promises.push(
-        addDependency(
-          module,
-          relativePath,
-          curDependency,
-          graph,
-          delta,
-          options
-        )
+        addDependency(module, key, curDependency, graph, delta, options)
       );
     }
   }
@@ -263,9 +292,32 @@ async function processModule(path, graph, delta, options) {
   return module;
 }
 
+function dependenciesEqual(a, b, options) {
+  return (
+    a === b ||
+    (a.absolutePath === b.absolutePath &&
+      (!options.experimentalImportBundleSupport ||
+        a.data.data.asyncType === b.data.data.asyncType) &&
+      contextParamsEqual(a.data.data.contextParams, b.data.data.contextParams))
+  );
+}
+
+function contextParamsEqual(a, b) {
+  return (
+    a === b ||
+    (a == null && b == null) ||
+    (a != null &&
+      b != null &&
+      a.recursive === b.recursive &&
+      a.filter.pattern === b.filter.pattern &&
+      a.filter.flags === b.filter.flags &&
+      a.mode === b.mode)
+  );
+}
+
 async function addDependency(
   parentModule,
-  relativePath,
+  key,
   dependency,
   graph,
   delta,
@@ -323,18 +375,18 @@ async function addDependency(
   // inverseDependencies and the other fields in the case of lazy edges.
   // Not an optimal representation :(
 
-  parentModule.dependencies.set(relativePath, dependency);
+  parentModule.dependencies.set(key, dependency);
 }
 
 function removeDependency(
   parentModule,
-  relativePath,
+  key,
   dependency,
   graph,
   delta,
   options
 ) {
-  parentModule.dependencies.delete(relativePath);
+  parentModule.dependencies.delete(key);
   const { absolutePath } = dependency;
 
   if (
@@ -364,40 +416,93 @@ function removeDependency(
     releaseModule(module, graph, delta, options);
   }
 }
+/**
+ * Collect a list of context modules which include a given file.
+ */
+
+function markModifiedContextModules(graph, filePath, modifiedPaths) {
+  for (const [absolutePath, context] of graph.privateState.resolvedContexts) {
+    if (
+      !modifiedPaths.has(absolutePath) &&
+      (0, _contextModule.fileMatchesContext)(filePath, context)
+    ) {
+      modifiedPaths.add(absolutePath);
+    }
+  }
+}
+
+function resolveDependencies(graph, parentPath, dependencies, options) {
+  const maybeResolvedDeps = new Map();
+
+  for (const dep of dependencies) {
+    let resolvedDep; // `require.context`
 
-function resolveDependencies(parentPath, dependencies, options) {
-  const resolve = (parentPath, result) => {
-    const relativePath = result.name;
-
-    try {
-      return [
-        relativePath,
-        {
-          absolutePath: options.resolve(parentPath, relativePath),
-          data: result,
-        },
-      ];
-    } catch (error) {
-      // Ignore unavailable optional dependencies. They are guarded
-      // with a try-catch block and will be handled during runtime.
-      if (result.data.isOptional !== true) {
-        throw error;
+    const { contextParams } = dep.data;
+
+    if (contextParams) {
+      // Ensure the filepath has uniqueness applied to ensure multiple `require.context`
+      // statements can be used to target the same file with different properties.
+      const from = path.join(parentPath, "..", dep.name);
+      const absolutePath = (0, _contextModule.deriveAbsolutePathFromContext)(
+        from,
+        contextParams
+      );
+      const resolvedContext = {
+        from,
+        mode: contextParams.mode,
+        recursive: contextParams.recursive,
+        filter: new RegExp(
+          contextParams.filter.pattern,
+          contextParams.filter.flags
+        ),
+      };
+      graph.privateState.resolvedContexts.set(absolutePath, resolvedContext);
+      resolvedDep = {
+        absolutePath,
+        data: dep,
+      };
+    } else {
+      try {
+        resolvedDep = {
+          absolutePath: options.resolve(parentPath, dep.name),
+          data: dep,
+        }; // This dependency may have existed previously as a require.context -
+        // clean it up.
+
+        graph.privateState.resolvedContexts.delete(resolvedDep.absolutePath);
+      } catch (error) {
+        // Ignore unavailable optional dependencies. They are guarded
+        // with a try-catch block and will be handled during runtime.
+        if (dep.data.isOptional !== true) {
+          throw error;
+        }
       }
     }
 
-    return undefined;
-  };
+    const key = dep.data.key;
 
-  const resolved = dependencies.reduce((list, result) => {
-    const resolvedPath = resolve(parentPath, result);
+    if (maybeResolvedDeps.has(key)) {
+      throw new Error(
+        `resolveDependencies: Found duplicate dependency key '${key}' in ${parentPath}`
+      );
+    }
+
+    maybeResolvedDeps.set(key, resolvedDep);
+  }
 
-    if (resolvedPath) {
-      list.push(resolvedPath);
+  const resolvedDeps = new Map(); // Return just the dependencies we successfully resolved.
+  // FIXME: This has a bad bug affecting all dependencies *after* an unresolved
+  // optional dependency. We'll need to propagate the nulls all the way to the
+  // serializer and the require() runtime to keep the dependency map from being
+  // desynced from the contents of the module.
+
+  for (const [key, resolvedDep] of maybeResolvedDeps) {
+    if (resolvedDep) {
+      resolvedDeps.set(key, resolvedDep);
     }
+  }
 
-    return list;
-  }, []);
-  return new Map(resolved);
+  return resolvedDeps;
 }
 /**
  * Re-traverse the dependency graph in DFS order to reorder the modules and
@@ -485,8 +590,8 @@ function markModuleInUse(module, graph) {
 // Called when the reference count of a module has reached 0.
 
 function releaseModule(module, graph, delta, options) {
-  for (const [relativePath, dependency] of module.dependencies) {
-    removeDependency(module, relativePath, dependency, graph, delta, options);
+  for (const [key, dependency] of module.dependencies) {
+    removeDependency(module, key, dependency, graph, delta, options);
   }
 
   graph.privateState.gc.color.set(module.path, "black");
@@ -512,6 +617,7 @@ function freeModule(module, graph, delta) {
   delta.earlyInverseDependencies.delete(module.path);
   graph.privateState.gc.possibleCycleRoots.delete(module.path);
   graph.privateState.gc.color.delete(module.path);
+  graph.privateState.resolvedContexts.delete(module.path);
 } // Mark a module as a possible cycle root
 
 function markAsPossibleCycleRoot(module, graph) {
@@ -638,4 +744,5 @@ module.exports = {
   initialTraverseDependencies,
   traverseDependencies,
   reorderGraph,
+  markModifiedContextModules,
 };