metro 0.83.0 → 0.83.2

package/src/lib/reporting.js

@@ -1,31 +1,37 @@
 "use strict";
 
-const chalk = require("chalk");
-const util = require("util");
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.logError = logError;
+exports.logInfo = logInfo;
+exports.logWarning = logWarning;
+exports.nullReporter = void 0;
+var _chalk = _interopRequireDefault(require("chalk"));
+var _util = _interopRequireDefault(require("util"));
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
 function logWarning(terminal, format, ...args) {
-  const str = util.format(format, ...args);
-  terminal.log("%s %s", chalk.yellow.inverse.bold(" WARN "), str);
+  const str = _util.default.format(format, ...args);
+  terminal.log("%s %s", _chalk.default.yellow.inverse.bold(" WARN "), str);
 }
 function logError(terminal, format, ...args) {
   terminal.log(
     "%s %s",
-    chalk.red.inverse.bold(" ERROR "),
-    util.format(
-      chalk.supportsColor ? format : util.stripVTControlCharacters(format),
-      ...args
-    )
+    _chalk.default.red.inverse.bold(" ERROR "),
+    _util.default.format(
+      _chalk.default.supportsColor
+        ? format
+        : _util.default.stripVTControlCharacters(format),
+      ...args,
+    ),
   );
 }
 function logInfo(terminal, format, ...args) {
-  const str = util.format(format, ...args);
-  terminal.log("%s %s", chalk.cyan.inverse.bold(" INFO "), str);
+  const str = _util.default.format(format, ...args);
+  terminal.log("%s %s", _chalk.default.cyan.inverse.bold(" INFO "), str);
 }
-const nullReporter = {
+const nullReporter = (exports.nullReporter = {
   update() {},
-};
-module.exports = {
-  logWarning,
-  logError,
-  logInfo,
-  nullReporter,
-};
+});

package/src/lib/reporting.js.flow

@@ -9,15 +9,13 @@
  * @oncall react_native
  */
 
-'use strict';
-
 import type {Terminal} from 'metro-core';
 import type {HealthCheckResult, WatcherStatus} from 'metro-file-map';
 import type {CustomResolverOptions} from 'metro-resolver';
 import type {CustomTransformOptions} from 'metro-transform-worker';
 
-const chalk = require('chalk');
-const util = require('util');
+import chalk from 'chalk';
+import util from 'util';
 
 export type BundleDetails = {
   bundleType: string,
@@ -129,7 +127,6 @@ export type ReportableEvent =
         | 'groupEnd'
         | 'debug',
       data: Array<mixed>,
-      mode: 'BRIDGE' | 'NOBRIDGE',
       ...
     }
   | {
@@ -187,7 +184,7 @@ export type Reporter = interface {update(event: ReportableEvent): void};
  * calling this, add a new type of ReportableEvent instead, and implement a
  * proper handler in the reporter(s).
  */
-function logWarning(
+export function logWarning(
   terminal: Terminal,
   format: string,
   ...args: Array<mixed>
@@ -199,7 +196,7 @@ function logWarning(
 /**
  * Similar to `logWarning`, but for messages that require the user to act.
  */
-function logError(
+export function logError(
   terminal: Terminal,
   format: string,
   ...args: Array<mixed>
@@ -221,7 +218,7 @@ function logError(
 /**
  * Similar to `logWarning`, but for informational messages.
  */
-function logInfo(
+export function logInfo(
   terminal: Terminal,
   format: string,
   ...args: Array<mixed>
@@ -234,11 +231,4 @@ function logInfo(
  * A reporter that does nothing. Errors and warnings will be swallowed, that
  * is generally not what you want.
  */
-const nullReporter = {update(): void {}};
-
-module.exports = {
-  logWarning,
-  logError,
-  logInfo,
-  nullReporter,
-};
+export const nullReporter = {update(): void {}};

package/src/lib/splitBundleOptions.js

@@ -1,5 +1,9 @@
 "use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = splitBundleOptions;
 function splitBundleOptions(options) {
   return {
     entryFile: options.entryFile,
@@ -10,7 +14,6 @@ function splitBundleOptions(options) {
     transformOptions: {
       customTransformOptions: options.customTransformOptions,
       dev: options.dev,
-      hot: options.hot,
       minify: options.minify,
       platform: options.platform,
       type: "module",
@@ -32,4 +35,3 @@ function splitBundleOptions(options) {
     onProgress: options.onProgress,
   };
 }
-module.exports = splitBundleOptions;

package/src/lib/splitBundleOptions.js.flow

@@ -9,14 +9,14 @@
  * @oncall react_native
  */
 
-'use strict';
-
-import type {BundleOptions, SplitBundleOptions} from '../shared/types.flow';
+import type {BundleOptions, SplitBundleOptions} from '../shared/types';
 
 /**
  * Splits a BundleOptions object into smaller, more manageable parts.
  */
-function splitBundleOptions(options: BundleOptions): SplitBundleOptions {
+export default function splitBundleOptions(
+  options: BundleOptions,
+): SplitBundleOptions {
   return {
     entryFile: options.entryFile,
     resolverOptions: {
@@ -26,7 +26,6 @@ function splitBundleOptions(options: BundleOptions): SplitBundleOptions {
     transformOptions: {
       customTransformOptions: options.customTransformOptions,
       dev: options.dev,
-      hot: options.hot,
       minify: options.minify,
       platform: options.platform,
       type: 'module',
@@ -48,5 +47,3 @@ function splitBundleOptions(options: BundleOptions): SplitBundleOptions {
     onProgress: options.onProgress,
   };
 }
-
-module.exports = splitBundleOptions;

package/src/lib/transformHelpers.js

@@ -1,15 +1,16 @@
 "use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.getResolveDependencyFn = getResolveDependencyFn;
+exports.getTransformFn = getTransformFn;
 var _contextModuleTemplates = require("./contextModuleTemplates");
 var _isAssetFile = _interopRequireDefault(
-  require("metro-resolver/private/utils/isAssetFile")
+  require("metro-resolver/private/utils/isAssetFile"),
 );
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const baseIgnoredInlineRequires = [
   "React",
@@ -25,12 +26,11 @@ async function calcTransformerOptions(
   deltaBundler,
   config,
   options,
-  resolverOptions
+  resolverOptions,
 ) {
   const baseOptions = {
     customTransformOptions: options.customTransformOptions,
     dev: options.dev,
-    hot: options.hot,
     inlineRequires: false,
     inlinePlatform: true,
     minify: options.minify,
@@ -48,7 +48,7 @@ async function calcTransformerOptions(
       resolve: await getResolveDependencyFn(
         bundler,
         options.platform,
-        resolverOptions
+        resolverOptions,
       ),
       transform: await getTransformFn(
         [path],
@@ -59,7 +59,7 @@ async function calcTransformerOptions(
           ...options,
           minify: false,
         },
-        resolverOptions
+        resolverOptions,
       ),
       transformOptions: options,
       onProgress: null,
@@ -76,17 +76,15 @@ async function calcTransformerOptions(
     entryFiles,
     {
       dev: options.dev,
-      hot: options.hot,
+      hot: true,
       platform: options.platform,
     },
-    getDependencies
+    getDependencies,
   );
   return {
     ...baseOptions,
     inlineRequires: transform?.inlineRequires || false,
     experimentalImportSupport: transform?.experimentalImportSupport || false,
-    unstable_disableES6Transforms:
-      transform?.unstable_disableES6Transforms || false,
     unstable_memoizeInlineRequires:
       transform?.unstable_memoizeInlineRequires || false,
     unstable_nonMemoizedInlineRequires:
@@ -108,7 +106,7 @@ async function getTransformFn(
   deltaBundler,
   config,
   options,
-  resolverOptions
+  resolverOptions,
 ) {
   const { inlineRequires, ...transformOptions } = await calcTransformerOptions(
     entryFiles,
@@ -116,7 +114,7 @@ async function getTransformFn(
     deltaBundler,
     config,
     options,
-    resolverOptions
+    resolverOptions,
   );
   const assetExts = new Set(config.resolver.assetExts);
   return async (modulePath, requireContext) => {
@@ -127,12 +125,12 @@ async function getTransformFn(
         graph.matchFilesWithContext(requireContext.from, {
           filter: requireContext.filter,
           recursive: requireContext.recursive,
-        })
+        }),
       );
       const template = (0, _contextModuleTemplates.getContextModuleTemplate)(
         requireContext.mode,
         requireContext.from,
-        files
+        files,
       );
       templateBuffer = Buffer.from(template);
     }
@@ -143,10 +141,10 @@ async function getTransformFn(
         type: getType(transformOptions.type, modulePath, assetExts),
         inlineRequires: removeInlineRequiresBlockListFromOptions(
           modulePath,
-          inlineRequires
+          inlineRequires,
         ),
       },
-      templateBuffer
+      templateBuffer,
     );
   };
 }
@@ -166,10 +164,6 @@ async function getResolveDependencyFn(bundler, platform, resolverOptions) {
       from,
       dependency,
       platform ?? null,
-      resolverOptions
+      resolverOptions,
     );
 }
-module.exports = {
-  getTransformFn,
-  getResolveDependencyFn,
-};

package/src/lib/transformHelpers.js.flow

@@ -9,17 +9,15 @@
  * @oncall react_native
  */
 
-'use strict';
-
 import type Bundler from '../Bundler';
 import type DeltaBundler, {TransformFn} from '../DeltaBundler';
 import type {
   BundlerResolution,
   TransformInputOptions,
   TransformResultDependency,
-} from '../DeltaBundler/types.flow';
+} from '../DeltaBundler/types';
 import type {TransformOptions} from '../DeltaBundler/Worker';
-import type {ResolverInputOptions} from '../shared/types.flow';
+import type {ResolverInputOptions} from '../shared/types';
 import type {RequireContext} from './contextModule';
 import type {ConfigT} from 'metro-config';
 import type {Type} from 'metro-transform-worker';
@@ -56,7 +54,6 @@ async function calcTransformerOptions(
   const baseOptions = {
     customTransformOptions: options.customTransformOptions,
     dev: options.dev,
-    hot: options.hot,
     inlineRequires: false,
     inlinePlatform: true,
     minify: options.minify,
@@ -107,7 +104,7 @@ async function calcTransformerOptions(
 
   const {transform} = await config.transformer.getTransformOptions(
     entryFiles,
-    {dev: options.dev, hot: options.hot, platform: options.platform},
+    {dev: options.dev, hot: true, platform: options.platform},
     getDependencies,
   );
 
@@ -115,8 +112,6 @@ async function calcTransformerOptions(
     ...baseOptions,
     inlineRequires: transform?.inlineRequires || false,
     experimentalImportSupport: transform?.experimentalImportSupport || false,
-    unstable_disableES6Transforms:
-      transform?.unstable_disableES6Transforms || false,
     unstable_memoizeInlineRequires:
       transform?.unstable_memoizeInlineRequires || false,
     unstable_nonMemoizedInlineRequires:
@@ -138,7 +133,7 @@ function removeInlineRequiresBlockListFromOptions(
   return inlineRequires;
 }
 
-async function getTransformFn(
+export async function getTransformFn(
   entryFiles: $ReadOnlyArray<string>,
   bundler: Bundler,
   deltaBundler: DeltaBundler<>,
@@ -213,7 +208,7 @@ function getType(
   return 'module';
 }
 
-async function getResolveDependencyFn(
+export async function getResolveDependencyFn(
   bundler: Bundler,
   platform: ?string,
   resolverOptions: ResolverInputOptions,
@@ -230,8 +225,3 @@ async function getResolveDependencyFn(
       resolverOptions,
     );
 }
-
-module.exports = {
-  getTransformFn,
-  getResolveDependencyFn,
-};

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

@@ -1,33 +1,55 @@
 "use strict";
 
-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");
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.UnableToResolveError = exports.ModuleResolver = void 0;
+var _codeFrame = require("@babel/code-frame");
+var _fs = _interopRequireDefault(require("fs"));
+var _invariant = _interopRequireDefault(require("invariant"));
+var Resolver = _interopRequireWildcard(require("metro-resolver"));
+var _createDefaultContext = _interopRequireDefault(
+  require("metro-resolver/private/createDefaultContext"),
+);
+var _path = _interopRequireDefault(require("path"));
+var _util = _interopRequireDefault(require("util"));
+function _getRequireWildcardCache(e) {
+  if ("function" != typeof WeakMap) return null;
+  var r = new WeakMap(),
+    t = new WeakMap();
+  return (_getRequireWildcardCache = function (e) {
+    return e ? t : r;
+  })(e);
+}
+function _interopRequireWildcard(e, r) {
+  if (!r && e && e.__esModule) return e;
+  if (null === e || ("object" != typeof e && "function" != typeof e))
+    return { default: e };
+  var t = _getRequireWildcardCache(r);
+  if (t && t.has(e)) return t.get(e);
+  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);
+}
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
 class ModuleResolver {
   constructor(options) {
     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.default.join(projectRoot, "_");
   }
   _getEmptyModule() {
     let emptyModule = this._cachedEmptyModule;
     if (!emptyModule) {
       emptyModule = this.resolveDependency(
-        this._projectRootFakeModule,
+        this._projectRootFakeModulePath,
         {
           name: this._options.emptyModulePath,
           data: {
@@ -41,18 +63,18 @@ class ModuleResolver {
         null,
         {
           dev: false,
-        }
+        },
       );
       this._cachedEmptyModule = emptyModule;
     }
     return emptyModule;
   }
   resolveDependency(
-    fromModule,
+    originModulePath,
     dependency,
     allowHaste,
     platform,
-    resolverOptions
+    resolverOptions,
   ) {
     const {
       assetExts,
@@ -72,7 +94,7 @@ class ModuleResolver {
     } = this._options;
     try {
       const result = Resolver.resolve(
-        createDefaultContext(
+        (0, _createDefaultContext.default)(
           {
             allowHaste,
             assetExts,
@@ -93,7 +115,7 @@ class ModuleResolver {
             unstable_enablePackageExports,
             unstable_logWarning: this._logWarning,
             customResolverOptions: resolverOptions.customResolverOptions ?? {},
-            originModulePath: fromModule.path,
+            originModulePath,
             resolveHasteModule: (name) =>
               this._options.getHasteModulePath(name, platform),
             resolveHastePackage: (name) =>
@@ -102,64 +124,62 @@ class ModuleResolver {
             getPackageForModule: (absoluteModulePath) =>
               this._getPackageForModule(absoluteModulePath),
           },
-          dependency
+          dependency,
         ),
         dependency.name,
-        platform
+        platform,
       );
       return this._getFileResolvedModule(result);
     } catch (error) {
       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"),
           {
             cause: error,
             dependency,
-          }
+          },
         );
       } else if (error instanceof Resolver.FailedToResolveUnsupportedError) {
         throw new UnableToResolveError(
-          fromModule.path,
+          originModulePath,
           dependency.name,
           error.message,
           {
             cause: error,
             dependency,
-          }
+          },
         );
       } else if (error instanceof Resolver.FailedToResolveNameError) {
         const dirPaths = error.dirPaths;
         const extraPaths = error.extraPaths;
         const displayDirPaths = dirPaths
           .filter((dirPath) => this._options.dirExists(dirPath))
-          .map((dirPath) => path.relative(this._options.projectRoot, dirPath))
+          .map((dirPath) =>
+            _path.default.relative(this._options.projectRoot, dirPath),
+          )
           .concat(extraPaths);
         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${
-              hint || "."
-            }`,
+            `${dependency.name} could not be found within the project${hint || "."}`,
             ...displayDirPaths.map((dirPath) => `  ${dirPath}`),
           ].join("\n"),
           {
             cause: error,
             dependency,
-          }
+          },
         );
       }
       throw error;
@@ -167,18 +187,18 @@ class ModuleResolver {
   }
   _getPackage = (packageJsonPath) => {
     try {
-      return this._options.moduleCache.getPackage(packageJsonPath).read();
+      return this._options.packageCache.getPackage(packageJsonPath).read();
     } catch (e) {}
     return null;
   };
   _getPackageForModule = (absolutePath) => {
     let result;
     try {
-      result = this._options.moduleCache.getPackageOf(absolutePath);
+      result = this._options.packageCache.getPackageOf(absolutePath);
     } catch (e) {}
     return result != null
       ? {
-          rootPath: path.dirname(result.pkg.path),
+          rootPath: _path.default.dirname(result.pkg.path),
           packageJson: result.pkg.read(),
           packageRelativePath: result.packageRelativePath,
         }
@@ -190,7 +210,7 @@ class ModuleResolver {
         return resolution;
       case "assetFiles":
         const arbitrary = getArrayLowestItem(resolution.filePaths);
-        invariant(arbitrary != null, "invalid asset resolution");
+        (0, _invariant.default)(arbitrary != null, "invalid asset resolution");
         return {
           type: "sourceFile",
           filePath: arbitrary,
@@ -210,14 +230,15 @@ class ModuleResolver {
   };
   _removeRoot(candidates) {
     if (candidates.filePathPrefix) {
-      candidates.filePathPrefix = path.relative(
+      candidates.filePathPrefix = _path.default.relative(
         this._options.projectRoot,
-        candidates.filePathPrefix
+        candidates.filePathPrefix,
       );
     }
     return candidates;
   }
 }
+exports.ModuleResolver = ModuleResolver;
 function getArrayLowestItem(a) {
   if (a.length === 0) {
     return undefined;
@@ -238,18 +259,18 @@ class UnableToResolveError extends Error {
     this.targetModuleName = targetModuleName;
     const codeFrameMessage = this.buildCodeFrameMessage(options?.dependency);
     this.message =
-      util.format(
+      _util.default.format(
         "Unable to resolve module %s from %s: %s",
         targetModuleName,
         originModulePath,
-        message
+        message,
       ) + (codeFrameMessage ? "\n" + codeFrameMessage : "");
     this.cause = options?.cause;
   }
   buildCodeFrameMessage(dependency) {
     let file;
     try {
-      file = fs.readFileSync(this.originModulePath, "utf8");
+      file = _fs.default.readFileSync(this.originModulePath, "utf8");
     } catch (error) {
       if (error.code === "ENOENT" || error.code === "EISDIR") {
         return null;
@@ -260,18 +281,19 @@ class UnableToResolveError extends Error {
       ? refineDependencyLocation(
           dependency.data.locs[0],
           file,
-          this.targetModuleName
+          this.targetModuleName,
         )
       : guessDependencyLocation(file, this.targetModuleName);
-    return codeFrameColumns(
-      fs.readFileSync(this.originModulePath, "utf8"),
+    return (0, _codeFrame.codeFrameColumns)(
+      _fs.default.readFileSync(this.originModulePath, "utf8"),
       location,
       {
         forceColor: process.env.NODE_ENV !== "test",
-      }
+      },
     );
   }
 }
+exports.UnableToResolveError = UnableToResolveError;
 function refineDependencyLocation(loc, fileContents, targetSpecifier) {
   const lines = fileContents.split("\n");
   for (let line = loc.end.line - 1; line >= loc.start.line - 1; line--) {
@@ -339,7 +361,3 @@ function guessDependencyLocation(fileContents, targetSpecifier) {
 function isQuote(str) {
   return str === '"' || str === "'" || str === "`";
 }
-module.exports = {
-  ModuleResolver,
-  UnableToResolveError,
-};