metro 0.80.2 → 0.80.3

package/src/DeltaBundler/buildSubgraph.js

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.buildSubgraph = buildSubgraph;
+var _contextModule = require("../lib/contextModule");
+var _path = _interopRequireDefault(require("path"));
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+/**
+ * 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
+ */
+
+function resolveDependencies(parentPath, dependencies, resolve) {
+  const maybeResolvedDeps = new Map();
+  const resolvedContexts = new Map();
+  for (const dep of dependencies) {
+    let resolvedDep;
+    const key = dep.data.key;
+
+    // `require.context`
+    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.default.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
+        ),
+      };
+      resolvedContexts.set(key, resolvedContext);
+      resolvedDep = {
+        absolutePath,
+        data: dep,
+      };
+    } else {
+      try {
+        resolvedDep = {
+          absolutePath: resolve(parentPath, dep).filePath,
+          data: dep,
+        };
+      } 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;
+        }
+      }
+    }
+    if (maybeResolvedDeps.has(key)) {
+      throw new Error(
+        `resolveDependencies: Found duplicate dependency key '${key}' in ${parentPath}`
+      );
+    }
+    maybeResolvedDeps.set(key, resolvedDep);
+  }
+  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 {
+    dependencies: resolvedDeps,
+    resolvedContexts,
+  };
+}
+async function buildSubgraph(
+  entryPaths,
+  resolvedContexts,
+  { resolve, transform, shouldTraverse }
+) {
+  const moduleData = new Map();
+  const errors = new Map();
+  const visitedPaths = new Set();
+  async function visit(absolutePath, requireContext) {
+    if (visitedPaths.has(absolutePath)) {
+      return;
+    }
+    visitedPaths.add(absolutePath);
+    const transformResult = await transform(absolutePath, requireContext);
+
+    // Get the absolute path of all sub-dependencies (some of them could have been
+    // moved but maintain the same relative path).
+    const resolutionResult = resolveDependencies(
+      absolutePath,
+      transformResult.dependencies,
+      resolve
+    );
+    moduleData.set(absolutePath, {
+      ...transformResult,
+      ...resolutionResult,
+    });
+    await Promise.all(
+      [...resolutionResult.dependencies]
+        .filter(([key, dependency]) => shouldTraverse(dependency))
+        .map(([key, dependency]) =>
+          visit(
+            dependency.absolutePath,
+            resolutionResult.resolvedContexts.get(dependency.data.data.key)
+          ).catch((error) => errors.set(dependency.absolutePath, error))
+        )
+    );
+  }
+  await Promise.all(
+    [...entryPaths].map((absolutePath) =>
+      visit(absolutePath, resolvedContexts.get(absolutePath)).catch((error) =>
+        errors.set(absolutePath, error)
+      )
+    )
+  );
+  return {
+    moduleData,
+    errors,
+  };
+}

package/src/DeltaBundler/buildSubgraph.js.flow

@@ -0,0 +1,161 @@
+/**
+ * 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 strict-local
+ * @format
+ */
+
+import type {RequireContext} from '../lib/contextModule';
+import type {
+  Dependency,
+  ModuleData,
+  ResolveFn,
+  TransformFn,
+  TransformResultDependency,
+} from './types.flow';
+
+import {deriveAbsolutePathFromContext} from '../lib/contextModule';
+import path from 'path';
+
+type Parameters<T> = $ReadOnly<{
+  resolve: ResolveFn,
+  transform: TransformFn<T>,
+  shouldTraverse: Dependency => boolean,
+}>;
+
+function resolveDependencies(
+  parentPath: string,
+  dependencies: $ReadOnlyArray<TransformResultDependency>,
+  resolve: ResolveFn,
+): {
+  dependencies: Map<string, Dependency>,
+  resolvedContexts: Map<string, RequireContext>,
+} {
+  const maybeResolvedDeps = new Map<string, void | Dependency>();
+  const resolvedContexts = new Map<string, RequireContext>();
+
+  for (const dep of dependencies) {
+    let resolvedDep;
+    const key = dep.data.key;
+
+    // `require.context`
+    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 = deriveAbsolutePathFromContext(from, contextParams);
+
+      const resolvedContext: RequireContext = {
+        from,
+        mode: contextParams.mode,
+        recursive: contextParams.recursive,
+        filter: new RegExp(
+          contextParams.filter.pattern,
+          contextParams.filter.flags,
+        ),
+      };
+
+      resolvedContexts.set(key, resolvedContext);
+
+      resolvedDep = {
+        absolutePath,
+        data: dep,
+      };
+    } else {
+      try {
+        resolvedDep = {
+          absolutePath: resolve(parentPath, dep).filePath,
+          data: dep,
+        };
+      } 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;
+        }
+      }
+    }
+
+    if (maybeResolvedDeps.has(key)) {
+      throw new Error(
+        `resolveDependencies: Found duplicate dependency key '${key}' in ${parentPath}`,
+      );
+    }
+    maybeResolvedDeps.set(key, resolvedDep);
+  }
+
+  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};
+}
+
+export async function buildSubgraph<T>(
+  entryPaths: $ReadOnlySet<string>,
+  resolvedContexts: $ReadOnlyMap<string, ?RequireContext>,
+  {resolve, transform, shouldTraverse}: Parameters<T>,
+): Promise<{
+  moduleData: Map<string, ModuleData<T>>,
+  errors: Map<string, Error>,
+}> {
+  const moduleData: Map<string, ModuleData<T>> = new Map();
+  const errors: Map<string, Error> = new Map();
+  const visitedPaths: Set<string> = new Set();
+
+  async function visit(
+    absolutePath: string,
+    requireContext: ?RequireContext,
+  ): Promise<void> {
+    if (visitedPaths.has(absolutePath)) {
+      return;
+    }
+    visitedPaths.add(absolutePath);
+    const transformResult = await transform(absolutePath, requireContext);
+
+    // Get the absolute path of all sub-dependencies (some of them could have been
+    // moved but maintain the same relative path).
+    const resolutionResult = resolveDependencies(
+      absolutePath,
+      transformResult.dependencies,
+      resolve,
+    );
+
+    moduleData.set(absolutePath, {
+      ...transformResult,
+      ...resolutionResult,
+    });
+
+    await Promise.all(
+      [...resolutionResult.dependencies]
+        .filter(([key, dependency]) => shouldTraverse(dependency))
+        .map(([key, dependency]) =>
+          visit(
+            dependency.absolutePath,
+            resolutionResult.resolvedContexts.get(dependency.data.data.key),
+          ).catch(error => errors.set(dependency.absolutePath, error)),
+        ),
+    );
+  }
+
+  await Promise.all(
+    [...entryPaths].map(absolutePath =>
+      visit(absolutePath, resolvedContexts.get(absolutePath)).catch(error =>
+        errors.set(absolutePath, error),
+      ),
+    ),
+  );
+
+  return {moduleData, errors};
+}

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

@@ -25,41 +25,41 @@ export type MixedOutput = {
 
 export type AsyncDependencyType = 'async' | 'prefetch' | 'weak';
 
-export type TransformResultDependency = {
+export type TransformResultDependency = $ReadOnly<{
   /**
    * The literal name provided to a require or import call. For example 'foo' in
    * case of `require('foo')`.
    */
-  +name: string,
+  name: string,
 
   /**
    * Extra data returned by the dependency extractor.
    */
-  +data: {
+  data: $ReadOnly<{
     /**
      * A locally unique key for this dependency within the current module.
      */
-    +key: string,
+    key: string,
     /**
      * If not null, this dependency is due to a dynamic `import()` or `__prefetchImport()` call.
      */
-    +asyncType: AsyncDependencyType | null,
+    asyncType: AsyncDependencyType | null,
     /**
      * The dependency is enclosed in a try/catch block.
      */
-    +isOptional?: boolean,
+    isOptional?: boolean,
 
-    +locs: $ReadOnlyArray<BabelSourceLocation>,
+    locs: $ReadOnlyArray<BabelSourceLocation>,
 
     /** Context for requiring a collection of modules. */
-    +contextParams?: RequireContextParams,
-  },
-};
+    contextParams?: RequireContextParams,
+  }>,
+}>;
 
-export type Dependency = {
-  +absolutePath: string,
-  +data: TransformResultDependency,
-};
+export type Dependency = $ReadOnly<{
+  absolutePath: string,
+  data: TransformResultDependency,
+}>;
 
 export type Module<T = MixedOutput> = $ReadOnly<{
   dependencies: Map<string, Dependency>,
@@ -70,6 +70,14 @@ export type Module<T = MixedOutput> = $ReadOnly<{
   unstable_transformResultKey?: ?string,
 }>;
 
+export type ModuleData<T = MixedOutput> = $ReadOnly<{
+  dependencies: $ReadOnlyMap<string, Dependency>,
+  resolvedContexts: $ReadOnlyMap<string, RequireContext>,
+  output: $ReadOnlyArray<T>,
+  getSource: () => Buffer,
+  unstable_transformResultKey?: ?string,
+}>;
+
 export type Dependencies<T = MixedOutput> = Map<string, Module<T>>;
 export type ReadOnlyDependencies<T = MixedOutput> = $ReadOnlyMap<
   string,
@@ -115,6 +123,12 @@ export type TransformFn<T = MixedOutput> = (
   string,
   ?RequireContext,
 ) => Promise<TransformResultWithSource<T>>;
+
+export type ResolveFn = (
+  from: string,
+  dependency: TransformResultDependency,
+) => BundlerResolution;
+
 export type AllowOptionalDependenciesWithOptions = {
   +exclude: Array<string>,
 };
@@ -128,10 +142,7 @@ export type BundlerResolution = $ReadOnly<{
 }>;
 
 export type Options<T = MixedOutput> = {
-  +resolve: (
-    from: string,
-    dependency: TransformResultDependency,
-  ) => BundlerResolution,
+  +resolve: ResolveFn,
   +transform: TransformFn<T>,
   +transformOptions: TransformInputOptions,
   +onProgress: ?(numProcessed: number, total: number) => mixed,

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

@@ -38,7 +38,7 @@ export type Dependency = $ReadOnly<{
 // TODO: Convert to a Flow enum
 export type ContextMode = 'sync' | 'eager' | 'lazy' | 'lazy-once';
 
-type ContextFilter = {pattern: string, flags: string};
+type ContextFilter = $ReadOnly<{pattern: string, flags: string}>;
 
 export type RequireContextParams = $ReadOnly<{
   /* Should search for files recursively. Optional, default `true` when `require.context` is used */

package/src/index.flow.js

@@ -321,6 +321,7 @@ exports.buildGraph = async function (
       },
       {
         customResolverOptions,
+        dev,
       }
     );
   } finally {

package/src/index.flow.js.flow

@@ -458,7 +458,7 @@ exports.buildGraph = async function (
         platform,
         type,
       },
-      {customResolverOptions},
+      {customResolverOptions, dev},
     );
   } finally {
     bundler.end();

package/src/lib/splitBundleOptions.js

@@ -19,6 +19,7 @@ function splitBundleOptions(options) {
     entryFile: options.entryFile,
     resolverOptions: {
       customResolverOptions: options.customResolverOptions,
+      dev: options.dev,
     },
     transformOptions: {
       customTransformOptions: options.customTransformOptions,

package/src/lib/splitBundleOptions.js.flow

@@ -21,6 +21,7 @@ function splitBundleOptions(options: BundleOptions): SplitBundleOptions {
     entryFile: options.entryFile,
     resolverOptions: {
       customResolverOptions: options.customResolverOptions,
+      dev: options.dev,
     },
     transformOptions: {
       customTransformOptions: options.customTransformOptions,

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

@@ -53,7 +53,9 @@ class ModuleResolver {
         },
         false,
         null,
-        /* resolverOptions */ {}
+        /* resolverOptions */ {
+          dev: false,
+        }
       );
       this._cachedEmptyModule = emptyModule;
     }
@@ -88,6 +90,7 @@ class ModuleResolver {
           {
             allowHaste,
             assetExts,
+            dev: resolverOptions.dev,
             disableHierarchicalLookup,
             doesFileExist,
             extraNodeModules,

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

@@ -120,7 +120,7 @@ class ModuleResolver<TPackage: Packageish> {
         },
         false,
         null,
-        /* resolverOptions */ {},
+        /* resolverOptions */ {dev: false},
       );
       this._cachedEmptyModule = emptyModule;
     }
@@ -157,6 +157,7 @@ class ModuleResolver<TPackage: Packageish> {
           {
             allowHaste,
             assetExts,
+            dev: resolverOptions.dev,
             disableHierarchicalLookup,
             doesFileExist,
             extraNodeModules,

package/src/node-haste/DependencyGraph.js

@@ -260,10 +260,7 @@ class DependencyGraph extends EventEmitter {
 
     // Compound key for the resolver cache
     const resolverOptionsKey =
-      JSON.stringify(
-        resolverOptions.customResolverOptions ?? {},
-        canonicalize
-      ) ?? "";
+      JSON.stringify(resolverOptions ?? {}, canonicalize) ?? "";
     const originKey = isSensitiveToOriginFolder ? path.dirname(from) : "";
     const targetKey = to;
     const platformKey = platform ?? NULL_PLATFORM;

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

@@ -335,10 +335,7 @@ class DependencyGraph extends EventEmitter {
 
     // Compound key for the resolver cache
     const resolverOptionsKey =
-      JSON.stringify(
-        resolverOptions.customResolverOptions ?? {},
-        canonicalize,
-      ) ?? '';
+      JSON.stringify(resolverOptions ?? {}, canonicalize) ?? '';
     const originKey = isSensitiveToOriginFolder ? path.dirname(from) : '';
     const targetKey = to;
     const platformKey = platform ?? NULL_PLATFORM;

package/src/shared/types.flow.js.flow

@@ -65,6 +65,7 @@ export type BundleOptions = {
 
 export type ResolverInputOptions = $ReadOnly<{
   customResolverOptions?: CustomResolverOptions,
+  dev: boolean,
 }>;
 
 export type SerializerOptions = {