Summary

• Continued work for adding require.context to Metro feat: add support for capturing require.context in dependency collector #821
• This PR adds the ability to match files given a "require context". This is similar to the existing method for matching against a regex, but this enables users to search upwards in a directory, search shallow, and match a regex filter.
• Adds ability to pass a Buffer to transformFile as a sort of virtual file mechanism. This accounts for most the changes in packages/metro/src/DeltaBundler/Transformer.js, packages/metro/src/DeltaBundler/Worker.flow.js, packages/metro/src/DeltaBundler/WorkerFarm.js.
• Since we collapse require.context to require I've also added a convenience function in dev mode which warns users if they attempt to access require.context without enabling the feature flag.
• Made DeltaCalculator aware of files being added.
• graphOperations has two notable changes:
  1. When resolving dependencies with context, we attach a query to the absolute path (which is used for indexing), this query has a hex hash of the context -- used hex instead of b64 for filename safety.
  2. We pass the require context to processModule and inside we transform the dependency different based on the existence of a context module.
• When collecting the delta in _getChangedDependencies we now iterate over added and deleted files to see if they match any context modules. This is only enabled when the feature flag is on.
• In packages/metro/src/lib/contextModule.js we handle a number of common tasks related to context handling.
• In packages/metro/src/lib/contextModuleTemplates.js we generate the virtual modules based on the context. There are a number of different modules that can be created based on the ContextMode. I attempted to keep the functionality here similar to Webpack so users could interop bundlers. The most notable missing feature is context.resolve which returns the string path to a module, this doesn't appear to be supported in Metro. This mechansim is used for ensuring a module must be explicitly loaded by the user. Instead I wrapped the require values in getters to achieve the same effect.
• We implement the lazy mode as well but this requires the user to have async bundles already setup, otherwise the module will throw a runtime error.

Notice

I've withheld certain optimizations in order to keep this PR simple but still functional. We will want to follow up with a delta file check to require context so we aren't iterating over every file on every update. This feature can be seen in my test branch.

In my test branch, I built the feature on top of #835 so I know it works, should only require minor changes to graphOperations to get them in sync.

Test plan

• Unit tests -- pending @motiz88 approving the implementation.

Local testing

metro.config.js

const { getDefaultConfig } = require("expo/metro-config");

const config = getDefaultConfig(__dirname);
const path = require("path");

config.watchFolders = [
  path.resolve(__dirname),
  path.resolve(__dirname, "../path/to/metro"),
];

config.transformer = {
  // `require.context` support
  unstable_allowRequireContext: true,
};

module.exports = config;

index.js

console.log(require.context("./").keys());

Start a dev server, when changes to the file system occur, they should be reflected as automatic updates to the context. This does lead to the issue of having multiple contexts triggering multiple sequential reloads, I don't think this is a blocking issue though.

Also tested with async loading enabled, and the context: require.context("./", undefined, undefined, 'lazy').

Behavior

Notable features brought over to ensure this require.context functions as close to the original implementation as possible:

• require.context does not respect platform extensions, it will return every file matched inside of its context.
• require.context can match itself.
• A custom 'empty' module will be generated when no files are matched, this improves the user experience.
• All methods in require.context are named to improve the debugging.
• We always match against a ./ prefix. This prefix is also returned in the keys.
• Modules must be loaded by invoking the context as a function, e.g. context('./module.js')