metro 0.71.2 → 0.72.1

package/src/lib/transformHelpers.js.flow

@@ -16,6 +16,9 @@ import type {TransformInputOptions} from '../DeltaBundler/types.flow';
 import type {TransformOptions} from '../DeltaBundler/Worker';
 import type {ConfigT} from 'metro-config/src/configTypes.flow';
 import type {Type} from 'metro-transform-worker';
+import type {RequireContext} from './contextModule';
+
+import {getContextModuleTemplate} from './contextModuleTemplates';
 
 const path = require('path');
 
@@ -68,6 +71,8 @@ async function calcTransformerOptions(
       onProgress: null,
       experimentalImportBundleSupport:
         config.transformer.experimentalImportBundleSupport,
+      unstable_allowRequireContext:
+        config.transformer.unstable_allowRequireContext,
       shallow: false,
     });
 
@@ -118,15 +123,47 @@ async function getTransformFn(
     options,
   );
 
-  return async (path: string) => {
-    return await bundler.transformFile(path, {
-      ...transformOptions,
-      type: getType(transformOptions.type, path, config.resolver.assetExts),
-      inlineRequires: removeInlineRequiresBlockListFromOptions(
-        path,
-        inlineRequires,
-      ),
-    });
+  return async (modulePath: string, requireContext: ?RequireContext) => {
+    let templateBuffer: Buffer;
+
+    if (requireContext) {
+      const graph = await bundler.getDependencyGraph();
+
+      // TODO: Check delta changes to avoid having to look over all files each time
+      // this is a massive performance boost.
+
+      // Search against all files, this is very expensive.
+      // TODO: Maybe we could let the user specify which root to check against.
+      const files = graph.matchFilesWithContext(requireContext.from, {
+        filter: requireContext.filter,
+        recursive: requireContext.recursive,
+      });
+
+      const template = getContextModuleTemplate(
+        requireContext.mode,
+        requireContext.from,
+        files,
+      );
+
+      templateBuffer = Buffer.from(template);
+    }
+
+    return await bundler.transformFile(
+      modulePath,
+      {
+        ...transformOptions,
+        type: getType(
+          transformOptions.type,
+          modulePath,
+          config.resolver.assetExts,
+        ),
+        inlineRequires: removeInlineRequiresBlockListFromOptions(
+          modulePath,
+          inlineRequires,
+        ),
+      },
+      templateBuffer,
+    );
   };
 }
 

package/src/node-haste/DependencyGraph/ModuleResolution.js

@@ -199,6 +199,7 @@ class ModuleResolver {
         return this._options.moduleCache.getModule(arbitrary);
 
       case "empty":
+        // $FlowFixMe[incompatible-return]
         return this._getEmptyModule();
 
       default:

package/src/node-haste/DependencyGraph/ModuleResolution.js.flow

@@ -94,7 +94,7 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
     };
   }
 
-  _getEmptyModule() {
+  _getEmptyModule(): TModule | Moduleish {
     let emptyModule = this._cachedEmptyModule;
     if (!emptyModule) {
       emptyModule = this.resolveDependency(
@@ -252,6 +252,7 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
         invariant(arbitrary != null, 'invalid asset resolution');
         return this._options.moduleCache.getModule(arbitrary);
       case 'empty':
+        // $FlowFixMe[incompatible-return]
         return this._getEmptyModule();
       default:
         (resolution.type: empty);
@@ -259,7 +260,7 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
     }
   }
 
-  _removeRoot(candidates: FileCandidates) {
+  _removeRoot(candidates: FileCandidates): FileCandidates {
     if (candidates.filePathPrefix) {
       candidates.filePathPrefix = path.relative(
         this._options.projectRoot,

package/src/node-haste/DependencyGraph/createHasteMap.js

@@ -129,7 +129,13 @@ function createHasteMap(config, options) {
     computeDependencies,
     computeSha1: true,
     dependencyExtractor: config.resolver.dependencyExtractor,
-    extensions: config.resolver.sourceExts.concat(config.resolver.assetExts),
+    extensions: Array.from(
+      new Set([
+        ...config.resolver.sourceExts,
+        ...config.resolver.assetExts,
+        ...config.watcher.additionalExts,
+      ])
+    ),
     forceNodeFilesystemAPI: !config.resolver.useWatchman,
     hasteImplModulePath: config.resolver.hasteImplModulePath,
     ignorePattern: getIgnorePattern(config),

package/src/node-haste/DependencyGraph/createHasteMap.js.flow

@@ -25,7 +25,7 @@ function getIgnorePattern(config: ConfigT): RegExp {
     return / ^/;
   }
 
-  const combine = regexes =>
+  const combine = (regexes: Array<RegExp>) =>
     new RegExp(
       regexes
         .map(regex => '(' + regex.source.replace(/\//g, path.sep) + ')')
@@ -69,7 +69,13 @@ function createHasteMap(
     computeDependencies,
     computeSha1: true,
     dependencyExtractor: config.resolver.dependencyExtractor,
-    extensions: config.resolver.sourceExts.concat(config.resolver.assetExts),
+    extensions: Array.from(
+      new Set([
+        ...config.resolver.sourceExts,
+        ...config.resolver.assetExts,
+        ...config.watcher.additionalExts,
+      ]),
+    ),
     forceNodeFilesystemAPI: !config.resolver.useWatchman,
     hasteImplModulePath: config.resolver.hasteImplModulePath,
     ignorePattern: getIgnorePattern(config),

package/src/node-haste/DependencyGraph.js

@@ -115,6 +115,8 @@ class DependencyGraph extends EventEmitter {
 
     return null;
   }
+  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+   * LTI update could not be added via codemod */
 
   _onHasteChange({ eventsQueue, hasteFS, moduleMap }) {
     this._hasteFS = hasteFS;
@@ -206,6 +208,11 @@ class DependencyGraph extends EventEmitter {
   end() {
     this._haste.end();
   }
+  /** Given a search context, return a list of file paths matching the query. */
+
+  matchFilesWithContext(from, context) {
+    return this._hasteFS.matchFilesWithContext(from, context);
+  }
 
   resolveDependency(
     from,

package/src/node-haste/DependencyGraph.js.flow

@@ -33,7 +33,7 @@ const {DuplicateHasteCandidatesError} = MetroFileMapModuleMap;
 
 function getOrCreate<T>(
   map: Map<string, Map<string, T>>,
-  field,
+  field: string,
 ): Map<string, T> {
   let subMap = map.get(field);
   if (!subMap) {
@@ -131,6 +131,8 @@ class DependencyGraph extends EventEmitter {
     return null;
   }
 
+  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+   * LTI update could not be added via codemod */
   _onHasteChange({eventsQueue, hasteFS, moduleMap}) {
     this._hasteFS = hasteFS;
     this._resolutionCache = new Map();
@@ -177,7 +179,7 @@ class DependencyGraph extends EventEmitter {
     });
   }
 
-  _createModuleCache() {
+  _createModuleCache(): ModuleCache {
     return new ModuleCache({
       // $FlowFixMe[method-unbinding] added when improving typing for this parameters
       getClosestPackage: this._getClosestPackage.bind(this),
@@ -223,6 +225,19 @@ class DependencyGraph extends EventEmitter {
     this._haste.end();
   }
 
+  /** Given a search context, return a list of file paths matching the query. */
+  matchFilesWithContext(
+    from: string,
+    context: $ReadOnly<{
+      /* Should search for files recursively. */
+      recursive: boolean,
+      /* Filter relative paths against a pattern. */
+      filter: RegExp,
+    }>,
+  ): string[] {
+    return this._hasteFS.matchFilesWithContext(from, context);
+  }
+
   resolveDependency(
     from: string,
     to: string,

package/src/shared/output/bundle.flow.js

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+"use strict";
+
+const relativizeSourceMapInline = require("../../lib/relativizeSourceMap");
+
+const Server = require("../../Server");
+
+const writeFile = require("./writeFile");
+
+function buildBundle(packagerClient, requestOptions) {
+  return packagerClient.build({
+    ...Server.DEFAULT_BUNDLE_OPTIONS,
+    ...requestOptions,
+    bundleType: "bundle",
+  });
+}
+
+function relativateSerializedMap(map, sourceMapSourcesRoot) {
+  const sourceMap = JSON.parse(map);
+  relativizeSourceMapInline(sourceMap, sourceMapSourcesRoot);
+  return JSON.stringify(sourceMap);
+}
+
+async function saveBundleAndMap(bundle, options, log) {
+  const {
+    bundleOutput,
+    bundleEncoding: encoding,
+    sourcemapOutput,
+    sourcemapSourcesRoot,
+  } = options;
+  const writeFns = [];
+  writeFns.push(async () => {
+    log("Writing bundle output to:", bundleOutput);
+    await writeFile(bundleOutput, bundle.code, encoding);
+    log("Done writing bundle output");
+  });
+
+  if (sourcemapOutput) {
+    let { map } = bundle;
+
+    if (sourcemapSourcesRoot !== undefined) {
+      log("start relativating source map");
+      map = relativateSerializedMap(map, sourcemapSourcesRoot);
+      log("finished relativating");
+    }
+
+    writeFns.push(async () => {
+      log("Writing sourcemap output to:", sourcemapOutput);
+      await writeFile(sourcemapOutput, map, null);
+      log("Done writing sourcemap output");
+    });
+  } // Wait until everything is written to disk.
+
+  await Promise.all(writeFns.map((cb) => cb()));
+}
+
+exports.build = buildBundle;
+exports.save = saveBundleAndMap;
+exports.formatName = "bundle";

package/src/shared/output/bundle.flow.js.flow

@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+import type {OutputOptions, RequestOptions} from '../types.flow';
+import type {MixedSourceMap} from 'metro-source-map';
+
+const relativizeSourceMapInline = require('../../lib/relativizeSourceMap');
+const Server = require('../../Server');
+const writeFile = require('./writeFile');
+
+function buildBundle(
+  packagerClient: Server,
+  requestOptions: RequestOptions,
+): Promise<{
+  code: string,
+  map: string,
+  ...
+}> {
+  return packagerClient.build({
+    ...Server.DEFAULT_BUNDLE_OPTIONS,
+    ...requestOptions,
+    bundleType: 'bundle',
+  });
+}
+
+function relativateSerializedMap(
+  map: string,
+  sourceMapSourcesRoot: string,
+): string {
+  const sourceMap = (JSON.parse(map): MixedSourceMap);
+  relativizeSourceMapInline(sourceMap, sourceMapSourcesRoot);
+  return JSON.stringify(sourceMap);
+}
+
+async function saveBundleAndMap(
+  bundle: {
+    code: string,
+    map: string,
+    ...
+  },
+  options: OutputOptions,
+  log: (...args: Array<string>) => void,
+): Promise<mixed> {
+  const {
+    bundleOutput,
+    bundleEncoding: encoding,
+    sourcemapOutput,
+    sourcemapSourcesRoot,
+  } = options;
+
+  const writeFns = [];
+
+  writeFns.push(async () => {
+    log('Writing bundle output to:', bundleOutput);
+    await writeFile(bundleOutput, bundle.code, encoding);
+    log('Done writing bundle output');
+  });
+
+  if (sourcemapOutput) {
+    let {map} = bundle;
+    if (sourcemapSourcesRoot !== undefined) {
+      log('start relativating source map');
+      map = relativateSerializedMap(map, sourcemapSourcesRoot);
+      log('finished relativating');
+    }
+
+    writeFns.push(async () => {
+      log('Writing sourcemap output to:', sourcemapOutput);
+      await writeFile(sourcemapOutput, map, null);
+      log('Done writing sourcemap output');
+    });
+  }
+
+  // Wait until everything is written to disk.
+  await Promise.all(writeFns.map((cb: void => mixed) => cb()));
+}
+
+exports.build = buildBundle;
+exports.save = saveBundleAndMap;
+exports.formatName = 'bundle';

package/src/shared/output/bundle.js

@@ -8,60 +8,13 @@
  * @format
  */
 "use strict";
+/*::
+export type * from './bundle.flow';
+*/
 
-const relativizeSourceMapInline = require("../../lib/relativizeSourceMap");
+try {
+  // $FlowFixMe[untyped-import]
+  require("metro-babel-register").unstable_registerForMetroMonorepo();
+} catch {}
 
-const Server = require("../../Server");
-
-const writeFile = require("./writeFile");
-
-function buildBundle(packagerClient, requestOptions) {
-  return packagerClient.build({
-    ...Server.DEFAULT_BUNDLE_OPTIONS,
-    ...requestOptions,
-    bundleType: "bundle",
-  });
-}
-
-function relativateSerializedMap(map, sourceMapSourcesRoot) {
-  const sourceMap = JSON.parse(map);
-  relativizeSourceMapInline(sourceMap, sourceMapSourcesRoot);
-  return JSON.stringify(sourceMap);
-}
-
-async function saveBundleAndMap(bundle, options, log) {
-  const {
-    bundleOutput,
-    bundleEncoding: encoding,
-    sourcemapOutput,
-    sourcemapSourcesRoot,
-  } = options;
-  const writeFns = [];
-  writeFns.push(async () => {
-    log("Writing bundle output to:", bundleOutput);
-    await writeFile(bundleOutput, bundle.code, encoding);
-    log("Done writing bundle output");
-  });
-
-  if (sourcemapOutput) {
-    let { map } = bundle;
-
-    if (sourcemapSourcesRoot !== undefined) {
-      log("start relativating source map");
-      map = relativateSerializedMap(map, sourcemapSourcesRoot);
-      log("finished relativating");
-    }
-
-    writeFns.push(async () => {
-      log("Writing sourcemap output to:", sourcemapOutput);
-      await writeFile(sourcemapOutput, map, null);
-      log("Done writing sourcemap output");
-    });
-  } // Wait until everything is written to disk.
-
-  await Promise.all(writeFns.map((cb) => cb()));
-}
-
-exports.build = buildBundle;
-exports.save = saveBundleAndMap;
-exports.formatName = "bundle";
+module.exports = require("./bundle.flow");

package/src/shared/output/bundle.js.flow

@@ -10,80 +10,13 @@
 
 'use strict';
 
-import type {OutputOptions, RequestOptions} from '../types.flow';
-import type {MixedSourceMap} from 'metro-source-map';
+/*::
+export type * from './bundle.flow';
+*/
 
-const relativizeSourceMapInline = require('../../lib/relativizeSourceMap');
-const Server = require('../../Server');
-const writeFile = require('./writeFile');
+try {
+  // $FlowFixMe[untyped-import]
+  require('metro-babel-register').unstable_registerForMetroMonorepo();
+} catch {}
 
-function buildBundle(
-  packagerClient: Server,
-  requestOptions: RequestOptions,
-): Promise<{
-  code: string,
-  map: string,
-  ...
-}> {
-  return packagerClient.build({
-    ...Server.DEFAULT_BUNDLE_OPTIONS,
-    ...requestOptions,
-    bundleType: 'bundle',
-  });
-}
-
-function relativateSerializedMap(
-  map: string,
-  sourceMapSourcesRoot: string,
-): string {
-  const sourceMap = (JSON.parse(map): MixedSourceMap);
-  relativizeSourceMapInline(sourceMap, sourceMapSourcesRoot);
-  return JSON.stringify(sourceMap);
-}
-
-async function saveBundleAndMap(
-  bundle: {
-    code: string,
-    map: string,
-    ...
-  },
-  options: OutputOptions,
-  log: (...args: Array<string>) => void,
-): Promise<mixed> {
-  const {
-    bundleOutput,
-    bundleEncoding: encoding,
-    sourcemapOutput,
-    sourcemapSourcesRoot,
-  } = options;
-
-  const writeFns = [];
-
-  writeFns.push(async () => {
-    log('Writing bundle output to:', bundleOutput);
-    await writeFile(bundleOutput, bundle.code, encoding);
-    log('Done writing bundle output');
-  });
-
-  if (sourcemapOutput) {
-    let {map} = bundle;
-    if (sourcemapSourcesRoot !== undefined) {
-      log('start relativating source map');
-      map = relativateSerializedMap(map, sourcemapSourcesRoot);
-      log('finished relativating');
-    }
-
-    writeFns.push(async () => {
-      log('Writing sourcemap output to:', sourcemapOutput);
-      await writeFile(sourcemapOutput, map, null);
-      log('Done writing sourcemap output');
-    });
-  }
-
-  // Wait until everything is written to disk.
-  await Promise.all(writeFns.map((cb: void => mixed) => cb()));
-}
-
-exports.build = buildBundle;
-exports.save = saveBundleAndMap;
-exports.formatName = 'bundle';
+module.exports = require('./bundle.flow');