metro 0.83.0 → 0.83.2

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

@@ -9,14 +9,12 @@
  * @oncall react_native
  */
 
-'use strict';
-
 import type {
   BundlerResolution,
   TransformResultDependency,
-} from '../../DeltaBundler/types.flow';
+} from '../../DeltaBundler/types';
 import type {Reporter} from '../../lib/reporting';
-import type {ResolverInputOptions} from '../../shared/types.flow';
+import type {ResolverInputOptions} from '../../shared/types';
 import type {
   CustomResolver,
   DoesFileExist,
@@ -27,13 +25,13 @@ import type {
 } from 'metro-resolver';
 import type {PackageForModule, PackageJson} from 'metro-resolver/private/types';
 
-const {codeFrameColumns} = require('@babel/code-frame');
-const fs = require('fs');
-const invariant = require('invariant');
-const Resolver = require('metro-resolver');
-const createDefaultContext = require('metro-resolver/private/createDefaultContext');
-const path = require('path');
-const util = require('util');
+import {codeFrameColumns} from '@babel/code-frame';
+import fs from 'fs';
+import invariant from 'invariant';
+import * as Resolver from 'metro-resolver';
+import createDefaultContext from 'metro-resolver/private/createDefaultContext';
+import path from 'path';
+import util from 'util';
 
 export type DirExistsFn = (filePath: string) => boolean;
 
@@ -44,10 +42,9 @@ export type Packageish = interface {
 
 export type Moduleish = interface {
   +path: string,
-  getPackage(): ?Packageish,
 };
 
-export type ModuleishCache<TPackage> = interface {
+export type PackageishCache<TPackage> = interface {
   getPackage(
     name: string,
     platform?: string,
@@ -70,7 +67,7 @@ type Options<TPackage> = $ReadOnly<{
   getHasteModulePath: (name: string, platform: ?string) => ?string,
   getHastePackagePath: (name: string, platform: ?string) => ?string,
   mainFields: $ReadOnlyArray<string>,
-  moduleCache: ModuleishCache<TPackage>,
+  packageCache: PackageishCache<TPackage>,
   nodeModulesPaths: $ReadOnlyArray<string>,
   preferNativePlatform: boolean,
   projectRoot: string,
@@ -85,34 +82,24 @@ type Options<TPackage> = $ReadOnly<{
   unstable_enablePackageExports: boolean,
 }>;
 
-class ModuleResolver<TPackage: Packageish> {
+export class ModuleResolver<TPackage: Packageish> {
   _options: Options<TPackage>;
   // A module representing the project root, used as the origin when resolving `emptyModulePath`.
-  _projectRootFakeModule: Moduleish;
+  _projectRootFakeModulePath: string;
   // An empty module, the result of resolving `emptyModulePath` from the project root.
   _cachedEmptyModule: ?BundlerResolution;
 
   constructor(options: Options<TPackage>) {
     this._options = options;
-    const {projectRoot, moduleCache} = this._options;
-    this._projectRootFakeModule = {
-      path: path.join(projectRoot, '_'),
-      getPackage: () =>
-        moduleCache.getPackageOf(this._projectRootFakeModule.path)?.pkg,
-      isHaste() {
-        throw new Error('not implemented');
-      },
-      getName() {
-        throw new Error('not implemented');
-      },
-    };
+    const {projectRoot} = this._options;
+    this._projectRootFakeModulePath = path.join(projectRoot, '_');
   }
 
   _getEmptyModule(): BundlerResolution {
     let emptyModule = this._cachedEmptyModule;
     if (!emptyModule) {
       emptyModule = this.resolveDependency(
-        this._projectRootFakeModule,
+        this._projectRootFakeModulePath,
         {
           name: this._options.emptyModulePath,
           data: {
@@ -132,7 +119,7 @@ class ModuleResolver<TPackage: Packageish> {
   }
 
   resolveDependency(
-    fromModule: Moduleish,
+    originModulePath: string,
     dependency: TransformResultDependency,
     allowHaste: boolean,
     platform: string | null,
@@ -178,7 +165,7 @@ class ModuleResolver<TPackage: Packageish> {
             unstable_enablePackageExports,
             unstable_logWarning: this._logWarning,
             customResolverOptions: resolverOptions.customResolverOptions ?? {},
-            originModulePath: fromModule.path,
+            originModulePath,
             resolveHasteModule: (name: string) =>
               this._options.getHasteModulePath(name, platform),
             resolveHastePackage: (name: string) =>
@@ -197,14 +184,16 @@ class ModuleResolver<TPackage: Packageish> {
       if (error instanceof Resolver.FailedToResolvePathError) {
         const {candidates} = error;
         throw new UnableToResolveError(
-          fromModule.path,
+          originModulePath,
           dependency.name,
           '\n\nNone of these files exist:\n' +
             [candidates.file, candidates.dir]
               .filter(Boolean)
               .map(
                 candidates =>
-                  `  * ${Resolver.formatFileCandidates(this._removeRoot(candidates))}`,
+                  `  * ${Resolver.formatFileCandidates(
+                    this._removeRoot(candidates),
+                  )}`,
               )
               .join('\n'),
           {
@@ -214,7 +203,7 @@ class ModuleResolver<TPackage: Packageish> {
         );
       } else if (error instanceof Resolver.FailedToResolveUnsupportedError) {
         throw new UnableToResolveError(
-          fromModule.path,
+          originModulePath,
           dependency.name,
           error.message,
           {cause: error, dependency},
@@ -230,7 +219,7 @@ class ModuleResolver<TPackage: Packageish> {
         const hint = displayDirPaths.length ? ' or in these directories:' : '';
 
         throw new UnableToResolveError(
-          fromModule.path,
+          originModulePath,
           dependency.name,
           [
             `${dependency.name} could not be found within the project${
@@ -250,7 +239,7 @@ class ModuleResolver<TPackage: Packageish> {
 
   _getPackage = (packageJsonPath: string): ?PackageJson => {
     try {
-      return this._options.moduleCache.getPackage(packageJsonPath).read();
+      return this._options.packageCache.getPackage(packageJsonPath).read();
     } catch (e) {
       // Do nothing. The standard module cache does not trigger any error, but
       // the ModuleGraph one does, if the module does not exist.
@@ -263,7 +252,7 @@ class ModuleResolver<TPackage: Packageish> {
     let result;
 
     try {
-      result = this._options.moduleCache.getPackageOf(absolutePath);
+      result = this._options.packageCache.getPackageOf(absolutePath);
     } catch (e) {
       // Do nothing. The standard module cache does not trigger any error, but
       // the ModuleGraph one does, if the module does not exist.
@@ -330,8 +319,8 @@ function getArrayLowestItem(a: $ReadOnlyArray<string>): string | void {
   return lowest;
 }
 
-// $FlowFixMe[incompatible-extend]
-class UnableToResolveError extends Error {
+// $FlowFixMe[incompatible-type]
+export class UnableToResolveError extends Error {
   /**
    * File path of the module that tried to require a module, ex. `/js/foo.js`.
    */
@@ -493,8 +482,3 @@ function guessDependencyLocation(
 function isQuote(str: ?string): boolean {
   return str === '"' || str === "'" || str === '`';
 }
-
-module.exports = {
-  ModuleResolver,
-  UnableToResolveError,
-};

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

@@ -1,5 +1,10 @@
 "use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = createFileMap;
+var _ciInfo = _interopRequireDefault(require("ci-info"));
 var _metroFileMap = _interopRequireWildcard(require("metro-file-map"));
 function _getRequireWildcardCache(e) {
   if ("function" != typeof WeakMap) return null;
@@ -12,23 +17,21 @@ 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)) {
       var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
       i && (i.get || i.set) ? Object.defineProperty(n, u, i) : (n[u] = e[u]);
     }
-  return (n.default = e), t && t.set(e, n), n;
+  return ((n.default = e), t && t.set(e, n), n);
+}
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
 }
-const ci = require("ci-info");
 function getIgnorePattern(config) {
   const { blockList, blacklistRE } = config.resolver;
   const ignorePattern = blacklistRE || blockList;
@@ -46,13 +49,13 @@ function getIgnorePattern(config) {
                 regexes[0].toString() +
                 "\n" +
                 ` - Pattern ${index}: ` +
-                regexes[index].toString()
+                regexes[index].toString(),
             );
           }
           return "(" + regex.source + ")";
         })
         .join("|"),
-      regexes[0]?.flags ?? ""
+      regexes[0]?.flags ?? "",
     );
   if (Array.isArray(ignorePattern)) {
     return combine(ignorePattern);
@@ -65,7 +68,7 @@ function createFileMap(config, options) {
       ? null
       : config.resolver.dependencyExtractor;
   const computeDependencies = dependencyExtractor != null;
-  const watch = options?.watch == null ? !ci.isCI : options.watch;
+  const watch = options?.watch == null ? !_ciInfo.default.isCI : options.watch;
   const { enabled: autoSaveEnabled, ...autoSaveOpts } =
     config.watcher.unstable_autoSaveCache ?? {};
   const autoSave = watch && autoSaveEnabled ? autoSaveOpts : false;
@@ -91,7 +94,7 @@ function createFileMap(config, options) {
         ...config.resolver.sourceExts,
         ...config.resolver.assetExts,
         ...config.watcher.additionalExts,
-      ])
+      ]),
     ),
     forceNodeFilesystemAPI: !config.resolver.useWatchman,
     hasteImplModulePath: config.resolver.hasteImplModulePath,
@@ -113,4 +116,3 @@ function createFileMap(config, options) {
     watchmanDeferStates: config.watcher.watchman.deferStates,
   });
 }
-module.exports = createFileMap;

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

@@ -11,10 +11,9 @@
 
 import type {ConfigT} from 'metro-config';
 
+import ci from 'ci-info';
 import MetroFileMap, {DiskCacheManager} from 'metro-file-map';
 
-const ci = require('ci-info');
-
 function getIgnorePattern(config: ConfigT): RegExp {
   // For now we support both options
   const {blockList, blacklistRE} = config.resolver;
@@ -53,7 +52,7 @@ function getIgnorePattern(config: ConfigT): RegExp {
   return ignorePattern;
 }
 
-function createFileMap(
+export default function createFileMap(
   config: ConfigT,
   options?: $ReadOnly<{
     extractDependencies?: boolean,
@@ -114,5 +113,3 @@ function createFileMap(
     watchmanDeferStates: config.watcher.watchman.deferStates,
   });
 }
-
-module.exports = createFileMap;

package/src/node-haste/DependencyGraph.js

@@ -1,20 +1,28 @@
 "use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+var _createFileMap = _interopRequireDefault(
+  require("./DependencyGraph/createFileMap"),
+);
+var _ModuleResolution = require("./DependencyGraph/ModuleResolution");
+var _PackageCache = require("./PackageCache");
+var _events = _interopRequireDefault(require("events"));
+var _fs = _interopRequireDefault(require("fs"));
+var _metroCore = require("metro-core");
+var _canonicalize = _interopRequireDefault(
+  require("metro-core/private/canonicalize"),
+);
 var _metroFileMap = require("metro-file-map");
-const createFileMap = require("./DependencyGraph/createFileMap");
-const { ModuleResolver } = require("./DependencyGraph/ModuleResolution");
-const ModuleCache = require("./ModuleCache");
-const { EventEmitter } = require("events");
-const fs = require("fs");
-const {
-  AmbiguousModuleResolutionError,
-  Logger: { createActionStartEntry, createActionEndEntry, log },
-  PackageResolutionError,
-} = require("metro-core");
-const canonicalize = require("metro-core/private/canonicalize");
-const { InvalidPackageError } = require("metro-resolver");
-const nullthrows = require("nullthrows");
-const path = require("path");
+var _metroResolver = require("metro-resolver");
+var _nullthrows = _interopRequireDefault(require("nullthrows"));
+var _path = _interopRequireDefault(require("path"));
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+const { createActionStartEntry, createActionEndEntry, log } = _metroCore.Logger;
 const NULL_PLATFORM = Symbol();
 function getOrCreateMap(map, field) {
   let subMap = map.get(field);
@@ -24,19 +32,20 @@ function getOrCreateMap(map, field) {
   }
   return subMap;
 }
-class DependencyGraph extends EventEmitter {
+class DependencyGraph extends _events.default {
+  #packageCache;
   constructor(config, options) {
     super();
     this._config = config;
     const { hasReducedPerformance, watch } = options ?? {};
     const initializingMetroLogEntry = log(
-      createActionStartEntry("Initializing Metro")
+      createActionStartEntry("Initializing Metro"),
     );
     config.reporter.update({
       type: "dep_graph_loading",
       hasReducedPerformance: !!hasReducedPerformance,
     });
-    const fileMap = createFileMap(config, {
+    const fileMap = (0, _createFileMap.default)(config, {
       throwOnModuleCollision: false,
       watch,
     });
@@ -53,13 +62,13 @@ class DependencyGraph extends EventEmitter {
         this._fileSystem = fileSystem;
         this._hasteMap = hasteMap;
         this._haste.on("change", (changeEvent) =>
-          this._onHasteChange(changeEvent)
+          this._onHasteChange(changeEvent),
         );
         this._haste.on("healthCheck", (result) =>
-          this._onWatcherHealthCheck(result)
+          this._onWatcherHealthCheck(result),
         );
         this._resolutionCache = new Map();
-        this._moduleCache = this._createModuleCache();
+        this.#packageCache = this._createPackageCache();
         this._createModuleResolver();
       });
   }
@@ -86,7 +95,7 @@ class DependencyGraph extends EventEmitter {
   _onHasteChange({ eventsQueue }) {
     this._resolutionCache = new Map();
     eventsQueue.forEach(({ filePath }) =>
-      this._moduleCache.invalidate(filePath)
+      this.#packageCache.invalidate(filePath),
     );
     this._createModuleResolver();
     this.emit("change");
@@ -105,11 +114,11 @@ class DependencyGraph extends EventEmitter {
         exists: false,
       };
     };
-    this._moduleResolver = new ModuleResolver({
+    this._moduleResolver = new _ModuleResolution.ModuleResolver({
       assetExts: new Set(this._config.resolver.assetExts),
       dirExists: (filePath) => {
         try {
-          return fs.lstatSync(filePath).isDirectory();
+          return _fs.default.lstatSync(filePath).isDirectory();
         } catch (e) {}
         return false;
       },
@@ -124,17 +133,17 @@ class DependencyGraph extends EventEmitter {
       getHastePackagePath: (name, platform) =>
         this._hasteMap.getPackage(name, platform, true),
       mainFields: this._config.resolver.resolverMainFields,
-      moduleCache: this._moduleCache,
       nodeModulesPaths: this._config.resolver.nodeModulesPaths,
+      packageCache: this.#packageCache,
       preferNativePlatform: true,
       projectRoot: this._config.projectRoot,
       reporter: this._config.reporter,
       resolveAsset: (dirPath, assetName, extension) => {
-        const basePath = dirPath + path.sep + assetName;
+        const basePath = dirPath + _path.default.sep + assetName;
         const assets = [
           basePath + extension,
           ...this._config.resolver.assetResolutions.map(
-            (resolution) => basePath + "@" + resolution + "x" + extension
+            (resolution) => basePath + "@" + resolution + "x" + extension,
           ),
         ]
           .map((assetPath) => fileSystemLookup(assetPath).realPath)
@@ -158,7 +167,7 @@ class DependencyGraph extends EventEmitter {
         breakOnSegment: "node_modules",
         invalidatedBy: null,
         subpathType: "f",
-      }
+      },
     );
     return result
       ? {
@@ -167,14 +176,14 @@ class DependencyGraph extends EventEmitter {
         }
       : null;
   }
-  _createModuleCache() {
-    return new ModuleCache({
+  _createPackageCache() {
+    return new _PackageCache.PackageCache({
       getClosestPackage: (absolutePath) =>
         this._getClosestPackage(absolutePath),
     });
   }
   getAllFiles() {
-    return nullthrows(this._fileSystem).getAllFiles();
+    return (0, _nullthrows.default)(this._fileSystem).getAllFiles();
   }
   async getOrComputeSha1(mixedPath) {
     const result = await this._fileSystem.getOrComputeSha1(mixedPath);
@@ -205,13 +214,13 @@ class DependencyGraph extends EventEmitter {
     });
   }
   resolveDependency(
-    from,
+    originModulePath,
     dependency,
     platform,
     resolverOptions,
     { assumeFlatNodeModules } = {
       assumeFlatNodeModules: false,
-    }
+    },
   ) {
     const to = dependency.name;
     const isSensitiveToOriginFolder =
@@ -219,17 +228,21 @@ class DependencyGraph extends EventEmitter {
       to.includes("/") ||
       to === "." ||
       to === ".." ||
-      from.includes(path.sep + "node_modules" + path.sep);
+      originModulePath.includes(
+        _path.default.sep + "node_modules" + _path.default.sep,
+      );
     const resolverOptionsKey =
-      JSON.stringify(resolverOptions ?? {}, canonicalize) ?? "";
-    const originKey = isSensitiveToOriginFolder ? path.dirname(from) : "";
+      JSON.stringify(resolverOptions ?? {}, _canonicalize.default) ?? "";
+    const originKey = isSensitiveToOriginFolder
+      ? _path.default.dirname(originModulePath)
+      : "";
     const targetKey =
       to + (dependency.data.isESMImport === true ? "\0esm" : "\0cjs");
     const platformKey = platform ?? NULL_PLATFORM;
     const mapByResolverOptions = this._resolutionCache;
     const mapByOrigin = getOrCreateMap(
       mapByResolverOptions,
-      resolverOptionsKey
+      resolverOptionsKey,
     );
     const mapByTarget = getOrCreateMap(mapByOrigin, originKey);
     const mapByPlatform = getOrCreateMap(mapByTarget, targetKey);
@@ -237,20 +250,23 @@ class DependencyGraph extends EventEmitter {
     if (!resolution) {
       try {
         resolution = this._moduleResolver.resolveDependency(
-          this._moduleCache.getModule(from),
+          originModulePath,
           dependency,
           true,
           platform,
-          resolverOptions
+          resolverOptions,
         );
       } catch (error) {
         if (error instanceof _metroFileMap.DuplicateHasteCandidatesError) {
-          throw new AmbiguousModuleResolutionError(from, error);
+          throw new _metroCore.AmbiguousModuleResolutionError(
+            originModulePath,
+            error,
+          );
         }
-        if (error instanceof InvalidPackageError) {
-          throw new PackageResolutionError({
+        if (error instanceof _metroResolver.InvalidPackageError) {
+          throw new _metroCore.PackageResolutionError({
             packageError: error,
-            originModulePath: from,
+            originModulePath,
             targetModuleName: to,
           });
         }
@@ -268,10 +284,10 @@ class DependencyGraph extends EventEmitter {
     if (hasteName) {
       return hasteName;
     }
-    return path.relative(this._config.projectRoot, filePath);
+    return _path.default.relative(this._config.projectRoot, filePath);
   }
   getDependencies(filePath) {
-    return nullthrows(this._fileSystem.getDependencies(filePath));
+    return (0, _nullthrows.default)(this._fileSystem.getDependencies(filePath));
   }
 }
-module.exports = DependencyGraph;
+exports.default = DependencyGraph;