metro 0.82.4 → 0.83.0

package/src/DeltaBundler/buildSubgraph.js.flow

@@ -12,18 +12,20 @@ import type {RequireContext} from '../lib/contextModule';
 import type {
   Dependency,
   ModuleData,
+  ResolvedDependency,
   ResolveFn,
   TransformFn,
   TransformResultDependency,
 } from './types.flow';
 
 import {deriveAbsolutePathFromContext} from '../lib/contextModule';
+import {isResolvedDependency} from '../lib/isResolvedDependency';
 import path from 'path';
 
 type Parameters<T> = $ReadOnly<{
   resolve: ResolveFn,
   transform: TransformFn<T>,
-  shouldTraverse: Dependency => boolean,
+  shouldTraverse: ResolvedDependency => boolean,
 }>;
 
 function resolveDependencies(
@@ -34,11 +36,11 @@ function resolveDependencies(
   dependencies: Map<string, Dependency>,
   resolvedContexts: Map<string, RequireContext>,
 } {
-  const maybeResolvedDeps = new Map<string, void | Dependency>();
+  const maybeResolvedDeps = new Map<string, Dependency>();
   const resolvedContexts = new Map<string, RequireContext>();
 
   for (const dep of dependencies) {
-    let resolvedDep;
+    let maybeResolvedDep: Dependency;
     const key = dep.data.key;
 
     // `require.context`
@@ -61,13 +63,13 @@ function resolveDependencies(
 
       resolvedContexts.set(key, resolvedContext);
 
-      resolvedDep = {
+      maybeResolvedDep = {
         absolutePath,
         data: dep,
       };
     } else {
       try {
-        resolvedDep = {
+        maybeResolvedDep = {
           absolutePath: resolve(parentPath, dep).filePath,
           data: dep,
         };
@@ -77,6 +79,9 @@ function resolveDependencies(
         if (dep.data.isOptional !== true) {
           throw error;
         }
+        maybeResolvedDep = {
+          data: dep,
+        };
       }
     }
 
@@ -85,21 +90,13 @@ function resolveDependencies(
         `resolveDependencies: Found duplicate dependency key '${key}' in ${parentPath}`,
       );
     }
-    maybeResolvedDeps.set(key, resolvedDep);
+    maybeResolvedDeps.set(key, maybeResolvedDep);
   }
 
-  const resolvedDeps = new Map<string, Dependency>();
-  // 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 {dependencies: resolvedDeps, resolvedContexts};
+  return {
+    dependencies: maybeResolvedDeps,
+    resolvedContexts,
+  };
 }
 
 export async function buildSubgraph<T>(
@@ -138,9 +135,12 @@ export async function buildSubgraph<T>(
     });
 
     await Promise.all(
-      [...resolutionResult.dependencies]
-        .filter(([key, dependency]) => shouldTraverse(dependency))
-        .map(([key, dependency]) =>
+      [...resolutionResult.dependencies.values()]
+        .filter(
+          dependency =>
+            isResolvedDependency(dependency) && shouldTraverse(dependency),
+        )
+        .map(dependency =>
           visit(
             dependency.absolutePath,
             resolutionResult.resolvedContexts.get(dependency.data.data.key),

package/src/DeltaBundler/getTransformCacheKey.js

@@ -2,7 +2,7 @@
 
 const VERSION = require("../../package.json").version;
 const crypto = require("crypto");
-const getCacheKey = require("metro-cache-key");
+const { getCacheKey } = require("metro-cache-key");
 function getTransformCacheKey(opts) {
   const { transformerPath, transformerConfig } = opts.transformerConfig;
   const Transformer = require.call(null, transformerPath);

package/src/DeltaBundler/getTransformCacheKey.js.flow

@@ -16,7 +16,7 @@ import type {JsTransformerConfig} from 'metro-transform-worker';
 
 const VERSION = require('../../package.json').version;
 const crypto = require('crypto');
-const getCacheKey = require('metro-cache-key');
+const {getCacheKey} = require('metro-cache-key');
 
 type CacheKeyProvider = {
   getCacheKey?: JsTransformerConfig => string,

package/src/DeltaBundler/types.flow.js

@@ -2,5 +2,9 @@
 
 var _CountingSet = _interopRequireDefault(require("../lib/CountingSet"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule ? e : { default: e };
+  return e && e.__esModule
+    ? e
+    : {
+        default: e,
+      };
 }

package/src/DeltaBundler/types.flow.js.flow

@@ -61,11 +61,17 @@ export type TransformResultDependency = $ReadOnly<{
   }>,
 }>;
 
-export type Dependency = $ReadOnly<{
+export type ResolvedDependency = $ReadOnly<{
   absolutePath: string,
   data: TransformResultDependency,
 }>;
 
+export type Dependency =
+  | ResolvedDependency
+  | $ReadOnly<{
+      data: TransformResultDependency,
+    }>;
+
 export type Module<T = MixedOutput> = $ReadOnly<{
   dependencies: Map<string, Dependency>,
   inverseDependencies: CountingSet<string>,

package/src/ModuleGraph/worker/JsFileWrapping.js

@@ -15,10 +15,14 @@ function _getRequireWildcardCache(e) {
 function _interopRequireWildcard(e, r) {
   if (!r && e && e.__esModule) return e;
   if (null === e || ("object" != typeof e && "function" != typeof e))
-    return { default: e };
+    return {
+      default: e,
+    };
   var t = _getRequireWildcardCache(r);
   if (t && t.has(e)) return t.get(e);
-  var n = { __proto__: null },
+  var n = {
+      __proto__: null,
+    },
     a = Object.defineProperty && Object.getOwnPropertyDescriptor;
   for (var u in e)
     if ("default" !== u && {}.hasOwnProperty.call(e, u)) {
@@ -28,7 +32,11 @@ function _interopRequireWildcard(e, r) {
   return (n.default = e), t && t.set(e, n), n;
 }
 function _interopRequireDefault(e) {
-  return e && e.__esModule ? e : { default: e };
+  return e && e.__esModule
+    ? e
+    : {
+        default: e,
+      };
 }
 const WRAP_NAME = "$$_REQUIRE";
 const IIFE_PARAM = _template.default.expression(
@@ -40,7 +48,8 @@ function wrapModule(
   importAllName,
   dependencyMapName,
   globalPrefix,
-  skipRequireRename
+  skipRequireRename,
+  { unstable_useStaticHermesModuleFactory = false } = {}
 ) {
   const params = buildParameters(
     importDefaultName,
@@ -48,7 +57,17 @@ function wrapModule(
     dependencyMapName
   );
   const factory = functionFromProgram(fileAst.program, params);
-  const def = t.callExpression(t.identifier(`${globalPrefix}__d`), [factory]);
+  const def = t.callExpression(t.identifier(`${globalPrefix}__d`), [
+    unstable_useStaticHermesModuleFactory
+      ? t.callExpression(
+          t.memberExpression(
+            t.identifier("$SHBuiltin"),
+            t.identifier("moduleFactory")
+          ),
+          [t.identifier("_$$_METRO_MODULE_ID"), factory]
+        )
+      : factory,
+  ]);
   const ast = t.file(t.program([t.expressionStatement(def)]));
   const requireName = skipRequireRename ? "require" : renameRequires(ast);
   return {
@@ -64,17 +83,28 @@ function wrapPolyfill(fileAst) {
 function jsonToCommonJS(source) {
   return `module.exports = ${source};`;
 }
-function wrapJson(source, globalPrefix) {
+function wrapJson(
+  source,
+  globalPrefix,
+  unstable_useStaticHermesModuleFactory = false
+) {
   const moduleFactoryParameters = buildParameters(
     "_importDefaultUnused",
     "_importAllUnused",
     "_dependencyMapUnused"
   );
-  return [
-    `${globalPrefix}__d(function(${moduleFactoryParameters.join(", ")}) {`,
+  const factory = [
+    `function(${moduleFactoryParameters.join(", ")}) {`,
     `  ${jsonToCommonJS(source)}`,
-    "});",
+    "}",
   ].join("\n");
+  return (
+    `${globalPrefix}__d(` +
+    (unstable_useStaticHermesModuleFactory
+      ? "$SHBuiltin.moduleFactory(_$$_METRO_MODULE_ID, " + factory + ")"
+      : factory) +
+    ");"
+  );
 }
 function functionFromProgram(program, parameters) {
   return t.functionExpression(

package/src/ModuleGraph/worker/JsFileWrapping.js.flow

@@ -33,6 +33,9 @@ function wrapModule(
   dependencyMapName: string,
   globalPrefix: string,
   skipRequireRename: boolean,
+  {
+    unstable_useStaticHermesModuleFactory = false,
+  }: $ReadOnly<{unstable_useStaticHermesModuleFactory?: boolean}> = {},
 ): {
   ast: BabelNodeFile,
   requireName: string,
@@ -43,7 +46,19 @@ function wrapModule(
     dependencyMapName,
   );
   const factory = functionFromProgram(fileAst.program, params);
-  const def = t.callExpression(t.identifier(`${globalPrefix}__d`), [factory]);
+
+  const def = t.callExpression(t.identifier(`${globalPrefix}__d`), [
+    unstable_useStaticHermesModuleFactory
+      ? t.callExpression(
+          t.memberExpression(
+            t.identifier('$SHBuiltin'),
+            t.identifier('moduleFactory'),
+          ),
+          [t.identifier('_$$_METRO_MODULE_ID'), factory],
+        )
+      : factory,
+  ]);
+
   const ast = t.file(t.program([t.expressionStatement(def)]));
 
   // `require` doesn't need to be scoped when Metro serializes to iife because the local function
@@ -64,7 +79,11 @@ function jsonToCommonJS(source: string): string {
   return `module.exports = ${source};`;
 }
 
-function wrapJson(source: string, globalPrefix: string): string {
+function wrapJson(
+  source: string,
+  globalPrefix: string,
+  unstable_useStaticHermesModuleFactory?: boolean = false,
+): string {
   // Unused parameters; remember that's wrapping JSON.
   const moduleFactoryParameters = buildParameters(
     '_importDefaultUnused',
@@ -72,11 +91,19 @@ function wrapJson(source: string, globalPrefix: string): string {
     '_dependencyMapUnused',
   );
 
-  return [
-    `${globalPrefix}__d(function(${moduleFactoryParameters.join(', ')}) {`,
+  const factory = [
+    `function(${moduleFactoryParameters.join(', ')}) {`,
     `  ${jsonToCommonJS(source)}`,
-    '});',
+    '}',
   ].join('\n');
+
+  return (
+    `${globalPrefix}__d(` +
+    (unstable_useStaticHermesModuleFactory
+      ? '$SHBuiltin.moduleFactory(_$$_METRO_MODULE_ID, ' + factory + ')'
+      : factory) +
+    ');'
+  );
 }
 
 function functionFromProgram(

package/src/ModuleGraph/worker/collectDependencies.js.flow

@@ -15,7 +15,7 @@ import type {CallExpression, Identifier, StringLiteral} from '@babel/types';
 import type {
   AllowOptionalDependencies,
   AsyncDependencyType,
-} from 'metro/src/DeltaBundler/types.flow.js';
+} from 'metro/private/DeltaBundler/types.flow';
 
 import {isProgram} from '@babel/types';
 
@@ -766,6 +766,8 @@ const DefaultDependencyTransformer: DependencyTransformer = {
         ? {MODULE_NAME: createModuleNameLiteral(dependency)}
         : null),
     };
+    /* $FlowFixMe[incompatible-call] Natural Inference rollout. See
+     * https://fburl.com/gdoc/y8dn025u */
     path.replaceWith(makeNode(opts));
   },
 
@@ -787,6 +789,8 @@ const DefaultDependencyTransformer: DependencyTransformer = {
         ? {MODULE_NAME: createModuleNameLiteral(dependency)}
         : null),
     };
+    /* $FlowFixMe[incompatible-call] Natural Inference rollout. See
+     * https://fburl.com/gdoc/y8dn025u */
     path.replaceWith(makeNode(opts));
   },
 
@@ -808,6 +812,8 @@ const DefaultDependencyTransformer: DependencyTransformer = {
         ? {MODULE_NAME: createModuleNameLiteral(dependency)}
         : null),
     };
+    /* $FlowFixMe[incompatible-call] Natural Inference rollout. See
+     * https://fburl.com/gdoc/y8dn025u */
     path.replaceWith(makeNode(opts));
   },
 

package/src/Server/symbolicate.js

@@ -1,9 +1,11 @@
 "use strict";
 
-const { greatestLowerBound } = require("metro-source-map/src/Consumer/search");
+const {
+  greatestLowerBound,
+} = require("metro-source-map/private/Consumer/search");
 const {
   SourceMetadataMapConsumer,
-} = require("metro-symbolicate/src/Symbolication");
+} = require("metro-symbolicate/private/Symbolication");
 function createFunctionNameGetter(module) {
   const consumer = new SourceMetadataMapConsumer(
     {

package/src/Server/symbolicate.js.flow

@@ -17,10 +17,12 @@ import type {
 import type {ExplodedSourceMap} from '../DeltaBundler/Serializers/getExplodedSourceMap';
 import type {ConfigT} from 'metro-config';
 
-const {greatestLowerBound} = require('metro-source-map/src/Consumer/search');
+const {
+  greatestLowerBound,
+} = require('metro-source-map/private/Consumer/search');
 const {
   SourceMetadataMapConsumer,
-} = require('metro-symbolicate/src/Symbolication');
+} = require('metro-symbolicate/private/Symbolication');
 
 export type StackFrameInput = {
   +file: ?string,

package/src/Server.d.ts

@@ -13,6 +13,7 @@ import type {RamBundleInfo} from './DeltaBundler/Serializers/getRamBundleInfo';
 import type {GraphId} from './lib/getGraphId';
 import type MultipartResponse from './Server/MultipartResponse';
 import type {
+  BuildOptions,
   BundleOptions,
   GraphOptions,
   SplitBundleOptions,
@@ -94,9 +95,13 @@ export default class Server {
   end(): void;
   getBundler(): IncrementalBundler;
   getCreateModuleId(): (path: string) => number;
-  build(options: BundleOptions): Promise<{
+  build(
+    bundleOptions: BundleOptions,
+    buildOptions?: BuildOptions,
+  ): Promise<{
     code: string;
     map: string;
+    assets?: ReadonlyArray<AssetData>;
   }>;
   getRamBundleInfo(options: BundleOptions): Promise<RamBundleInfo>;
   getAssets(options: BundleOptions): Promise<ReadonlyArray<AssetData>>;

package/src/Server.js

@@ -100,25 +100,14 @@ class Server {
   getCreateModuleId() {
     return this._createModuleId;
   }
-  async build(options) {
+  async _serializeGraph({ splitOptions, prepend, graph }) {
     const {
       entryFile,
       graphOptions,
-      onProgress,
       resolverOptions,
       serializerOptions,
       transformOptions,
-    } = splitBundleOptions(options);
-    const { prepend, graph } = await this._bundler.buildGraph(
-      entryFile,
-      transformOptions,
-      resolverOptions,
-      {
-        onProgress,
-        shallow: graphOptions.shallow,
-        lazy: graphOptions.lazy,
-      }
-    );
+    } = splitOptions;
     const entryPoint = this._getEntryPointAbsolutePath(entryFile);
     const bundleOptions = {
       asyncRequireModulePath: await this._resolveRelativePath(
@@ -188,6 +177,48 @@ class Server {
       map: bundleMap,
     };
   }
+  async build(bundleOptions, { withAssets } = {}) {
+    const splitOptions = splitBundleOptions(bundleOptions);
+    const {
+      entryFile,
+      graphOptions,
+      onProgress,
+      resolverOptions,
+      transformOptions,
+    } = splitOptions;
+    const { prepend, graph } = await this._bundler.buildGraph(
+      entryFile,
+      transformOptions,
+      resolverOptions,
+      {
+        onProgress,
+        shallow: graphOptions.shallow,
+        lazy: graphOptions.lazy,
+      }
+    );
+    const [{ code, map }, assets] = await Promise.all([
+      this._serializeGraph({
+        splitOptions,
+        prepend,
+        graph,
+      }),
+      withAssets
+        ? this._getAssetsFromDependencies(
+            graph.dependencies,
+            bundleOptions.platform
+          )
+        : null,
+    ]);
+    return {
+      code,
+      map,
+      ...(withAssets
+        ? {
+            assets: nullthrows(assets),
+          }
+        : null),
+    };
+  }
   async getRamBundleInfo(options) {
     const {
       entryFile,
@@ -256,10 +287,16 @@ class Server {
         lazy: false,
       }
     );
+    return this._getAssetsFromDependencies(
+      dependencies,
+      transformOptions.platform
+    );
+  }
+  async _getAssetsFromDependencies(dependencies, platform) {
     return await getAssets(dependencies, {
       processModuleFilter: this._config.serializer.processModuleFilter,
       assetPlugins: this._config.transformer.assetPlugins,
-      platform: transformOptions.platform,
+      platform,
       projectRoot: this._getServerRootDir(),
       publicPath: this._config.transformer.publicPath,
     });

package/src/Server.js.flow

@@ -17,6 +17,7 @@ import type {RamBundleInfo} from './DeltaBundler/Serializers/getRamBundleInfo';
 import type {
   MixedOutput,
   Module,
+  ReadOnlyDependencies,
   ReadOnlyGraph,
   TransformInputOptions,
   TransformResult,
@@ -26,6 +27,7 @@ import type {GraphId} from './lib/getGraphId';
 import type {Reporter} from './lib/reporting';
 import type {StackFrameInput, StackFrameOutput} from './Server/symbolicate';
 import type {
+  BuildOptions,
   BundleOptions,
   GraphOptions,
   ResolverInputOptions,
@@ -38,8 +40,8 @@ import type {ConfigT, RootPerfLogger} from 'metro-config';
 import type {
   ActionLogEntryData,
   ActionStartLogEntry,
-} from 'metro-core/src/Logger';
-import type {CustomResolverOptions} from 'metro-resolver/src/types';
+} from 'metro-core/private/Logger';
+import type {CustomResolverOptions} from 'metro-resolver/private/types';
 import type {CustomTransformOptions} from 'metro-transform-worker';
 
 import {SourcePathsMode} from './shared/types.flow';
@@ -211,30 +213,22 @@ class Server {
     return this._createModuleId;
   }
 
-  async build(options: BundleOptions): Promise<{
-    code: string,
-    map: string,
-    ...
-  }> {
+  async _serializeGraph({
+    splitOptions,
+    prepend,
+    graph,
+  }: $ReadOnly<{
+    splitOptions: SplitBundleOptions,
+    prepend: $ReadOnlyArray<Module<>>,
+    graph: ReadOnlyGraph<>,
+  }>): Promise<{code: string, map: string}> {
     const {
       entryFile,
       graphOptions,
-      onProgress,
       resolverOptions,
       serializerOptions,
       transformOptions,
-    } = splitBundleOptions(options);
-
-    const {prepend, graph} = await this._bundler.buildGraph(
-      entryFile,
-      transformOptions,
-      resolverOptions,
-      {
-        onProgress,
-        shallow: graphOptions.shallow,
-        lazy: graphOptions.lazy,
-      },
-    );
+    } = splitOptions;
 
     const entryPoint = this._getEntryPointAbsolutePath(entryFile);
 
@@ -307,6 +301,56 @@ class Server {
     };
   }
 
+  async build(
+    bundleOptions: BundleOptions,
+    {withAssets}: BuildOptions = {},
+  ): Promise<{
+    code: string,
+    map: string,
+    assets?: $ReadOnlyArray<AssetData>,
+    ...
+  }> {
+    const splitOptions = splitBundleOptions(bundleOptions);
+    const {
+      entryFile,
+      graphOptions,
+      onProgress,
+      resolverOptions,
+      transformOptions,
+    } = splitOptions;
+
+    const {prepend, graph} = await this._bundler.buildGraph(
+      entryFile,
+      transformOptions,
+      resolverOptions,
+      {
+        onProgress,
+        shallow: graphOptions.shallow,
+        lazy: graphOptions.lazy,
+      },
+    );
+
+    const [{code, map}, assets] = await Promise.all([
+      this._serializeGraph({
+        splitOptions,
+        prepend,
+        graph,
+      }),
+      withAssets
+        ? this._getAssetsFromDependencies(
+            graph.dependencies,
+            bundleOptions.platform,
+          )
+        : null,
+    ]);
+
+    return {
+      code,
+      map,
+      ...(withAssets ? {assets: nullthrows(assets)} : null),
+    };
+  }
+
   async getRamBundleInfo(options: BundleOptions): Promise<RamBundleInfo> {
     const {
       entryFile,
@@ -377,10 +421,20 @@ class Server {
       {onProgress, shallow: false, lazy: false},
     );
 
+    return this._getAssetsFromDependencies(
+      dependencies,
+      transformOptions.platform,
+    );
+  }
+
+  async _getAssetsFromDependencies(
+    dependencies: ReadOnlyDependencies<>,
+    platform: ?string,
+  ): Promise<$ReadOnlyArray<AssetData>> {
     return await getAssets(dependencies, {
       processModuleFilter: this._config.serializer.processModuleFilter,
       assetPlugins: this._config.transformer.assetPlugins,
-      platform: transformOptions.platform,
+      platform,
       projectRoot: this._getServerRootDir(),
       publicPath: this._config.transformer.publicPath,
     });

package/src/commands/build.js

@@ -4,7 +4,11 @@ var _parseKeyValueParamArray = _interopRequireDefault(
   require("../cli/parseKeyValueParamArray")
 );
 function _interopRequireDefault(e) {
-  return e && e.__esModule ? e : { default: e };
+  return e && e.__esModule
+    ? e
+    : {
+        default: e,
+      };
 }
 const { makeAsyncCommand } = require("../cli-utils");
 const TerminalReporter = require("../lib/TerminalReporter");

package/src/commands/serve.js

@@ -84,7 +84,10 @@ module.exports = () => ({
         resetCache: _resetCache,
         ...runServerOptions
       } = argv;
-      server = await MetroApi.runServer(config, runServerOptions);
+      ({ httpServer: server } = await MetroApi.runServer(
+        config,
+        runServerOptions
+      ));
       restarting = false;
     }
     const foundConfig = await resolveConfig(argv.config);

package/src/commands/serve.js.flow

@@ -107,7 +107,10 @@ module.exports = (): {
         resetCache: _resetCache,
         ...runServerOptions
       } = argv;
-      server = await MetroApi.runServer(config, runServerOptions);
+      ({httpServer: server} = await MetroApi.runServer(
+        config,
+        runServerOptions,
+      ));
 
       restarting = false;
     }