metro 0.83.2 → 0.83.4

package/src/DeltaBundler/Transformer.js.flow

@@ -26,7 +26,7 @@ import path from 'path';
 const debug = require('debug')('Metro:Transformer');
 
 type GetOrComputeSha1Fn = string => Promise<
-  $ReadOnly<{content?: Buffer, sha1: string}>,
+  Readonly<{content?: Buffer, sha1: string}>,
 >;
 
 export default class Transformer {
@@ -38,7 +38,7 @@ export default class Transformer {
 
   constructor(
     config: ConfigT,
-    opts: $ReadOnly<{getOrComputeSha1: GetOrComputeSha1Fn}>,
+    opts: Readonly<{getOrComputeSha1: GetOrComputeSha1Fn}>,
   ) {
     this._config = config;
 
@@ -160,7 +160,7 @@ export default class Transformer {
 
     // A valid result from the cache is used directly; otherwise we call into
     // the transformer to computed the corresponding result.
-    const data: $ReadOnly<{
+    const data: Readonly<{
       result: TransformResult<>,
       sha1: string,
     }> = result

package/src/DeltaBundler/Worker.flow.js

@@ -9,7 +9,11 @@ var _crypto = _interopRequireDefault(require("crypto"));
 var _fs = _interopRequireDefault(require("fs"));
 var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule ? e : { default: e };
+  return e && e.__esModule
+    ? e
+    : {
+        default: e,
+      };
 }
 function asDeserializedBuffer(value) {
   if (Buffer.isBuffer(value)) {

package/src/DeltaBundler/Worker.flow.js.flow

@@ -39,7 +39,7 @@ export type TransformerConfig = {
   ...
 };
 
-type Data = $ReadOnly<{
+type Data = Readonly<{
   result: TransformResult<>,
   sha1: string,
   transformFileStartLogEntry: LogEntry,

package/src/DeltaBundler/WorkerFarm.js

@@ -95,7 +95,7 @@ class WorkerFarm {
   }
   _formatBabelError(err, filename) {
     const error = new TransformError(
-      `${err.type || "Error"}${err.message.includes(filename) ? "" : " in " + filename}: ${err.message}`,
+      `${err.type ?? "Error"}${err.message.includes(filename) ? "" : " in " + filename}: ${err.message}`,
     );
     return Object.assign(error, {
       stack: err.stack,

package/src/DeltaBundler/WorkerFarm.js.flow

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow
+ * @flow strict-local
  * @format
  * @oncall react_native
  */
@@ -17,14 +17,14 @@ import type {Readable} from 'stream';
 import {Worker as JestWorker} from 'jest-worker';
 import {Logger} from 'metro-core';
 
-type WorkerInterface = {
+type WorkerInterface = Readonly<{
+  ...Worker,
+  end(): void | Promise<void>,
   getStdout(): Readable,
   getStderr(): Readable,
-  end(): void,
-  ...Worker,
-};
+}>;
 
-type TransformerResult = $ReadOnly<{
+type TransformerResult = Readonly<{
   result: TransformResult<>,
   sha1: string,
 }>;
@@ -62,7 +62,7 @@ export default class WorkerFarm {
       this._worker = worker;
     } else {
       // eslint-disable-next-line import/no-commonjs
-      this._worker = (require('./Worker'): Worker);
+      this._worker = require('./Worker') as Worker;
     }
   }
 
@@ -104,16 +104,16 @@ export default class WorkerFarm {
 
   _makeFarm(
     absoluteWorkerPath: string,
-    exposedMethods: $ReadOnlyArray<string>,
+    exposedMethods: ReadonlyArray<string>,
     numWorkers: number,
-  ): any {
+  ): WorkerInterface {
     const env = {
       ...process.env,
       // Force color to print syntax highlighted code frames.
       FORCE_COLOR: 1,
     };
 
-    return new JestWorker(absoluteWorkerPath, {
+    return new JestWorker<Worker>(absoluteWorkerPath, {
       computeWorkerKey: this._config.stickyWorkers
         ? // $FlowFixMe[method-unbinding] added when improving typing for this parameters
           // $FlowFixMe[incompatible-type]
@@ -143,7 +143,10 @@ export default class WorkerFarm {
     return null;
   }
 
-  _formatGenericError(err: any, filename: string): TransformError {
+  _formatGenericError(
+    err: Readonly<{message: string, stack?: string, ...}>,
+    filename: string,
+  ): TransformError {
     const error = new TransformError(`${filename}: ${err.message}`);
 
     // $FlowFixMe[unsafe-object-assign]
@@ -153,9 +156,19 @@ export default class WorkerFarm {
     });
   }
 
-  _formatBabelError(err: any, filename: string): TransformError {
+  _formatBabelError(
+    err: Readonly<{
+      message: string,
+      stack?: string,
+      type?: string,
+      codeFrame?: unknown,
+      loc: {line?: number, column?: number, ...},
+      ...
+    }>,
+    filename: string,
+  ): TransformError {
     const error = new TransformError(
-      `${err.type || 'Error'}${
+      `${err.type ?? 'Error'}${
         err.message.includes(filename) ? '' : ' in ' + filename
       }: ${err.message}`,
     );

package/src/DeltaBundler/buildSubgraph.js

@@ -8,7 +8,11 @@ var _contextModule = require("../lib/contextModule");
 var _isResolvedDependency = require("../lib/isResolvedDependency");
 var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule ? e : { default: e };
+  return e && e.__esModule
+    ? e
+    : {
+        default: e,
+      };
 }
 function resolveDependencies(parentPath, dependencies, resolve) {
   const maybeResolvedDeps = new Map();
@@ -24,13 +28,13 @@ function resolveDependencies(parentPath, dependencies, resolve) {
         contextParams,
       );
       const resolvedContext = {
-        from,
-        mode: contextParams.mode,
-        recursive: contextParams.recursive,
         filter: new RegExp(
           contextParams.filter.pattern,
           contextParams.filter.flags,
         ),
+        from,
+        mode: contextParams.mode,
+        recursive: contextParams.recursive,
       };
       resolvedContexts.set(key, resolvedContext);
       maybeResolvedDep = {
@@ -110,7 +114,7 @@ async function buildSubgraph(
     ),
   );
   return {
-    moduleData,
     errors,
+    moduleData,
   };
 }

package/src/DeltaBundler/buildSubgraph.js.flow

@@ -22,7 +22,7 @@ import {deriveAbsolutePathFromContext} from '../lib/contextModule';
 import {isResolvedDependency} from '../lib/isResolvedDependency';
 import path from 'path';
 
-type Parameters<T> = $ReadOnly<{
+type Parameters<T> = Readonly<{
   resolve: ResolveFn,
   transform: TransformFn<T>,
   shouldTraverse: ResolvedDependency => boolean,
@@ -30,7 +30,7 @@ type Parameters<T> = $ReadOnly<{
 
 function resolveDependencies(
   parentPath: string,
-  dependencies: $ReadOnlyArray<TransformResultDependency>,
+  dependencies: ReadonlyArray<TransformResultDependency>,
   resolve: ResolveFn,
 ): {
   dependencies: Map<string, Dependency>,
@@ -52,13 +52,13 @@ function resolveDependencies(
       const absolutePath = deriveAbsolutePathFromContext(from, contextParams);
 
       const resolvedContext: RequireContext = {
-        from,
-        mode: contextParams.mode,
-        recursive: contextParams.recursive,
         filter: new RegExp(
           contextParams.filter.pattern,
           contextParams.filter.flags,
         ),
+        from,
+        mode: contextParams.mode,
+        recursive: contextParams.recursive,
       };
 
       resolvedContexts.set(key, resolvedContext);
@@ -100,8 +100,8 @@ function resolveDependencies(
 }
 
 export async function buildSubgraph<T>(
-  entryPaths: $ReadOnlySet<string>,
-  resolvedContexts: $ReadOnlyMap<string, ?RequireContext>,
+  entryPaths: ReadonlySet<string>,
+  resolvedContexts: ReadonlyMap<string, ?RequireContext>,
   {resolve, transform, shouldTraverse}: Parameters<T>,
 ): Promise<{
   moduleData: Map<string, ModuleData<T>>,
@@ -157,5 +157,5 @@ export async function buildSubgraph<T>(
     ),
   );
 
-  return {moduleData, errors};
+  return {errors, moduleData};
 }

package/src/DeltaBundler/getTransformCacheKey.js

@@ -7,7 +7,11 @@ exports.default = getTransformCacheKey;
 var _crypto = _interopRequireDefault(require("crypto"));
 var _metroCacheKey = require("metro-cache-key");
 function _interopRequireDefault(e) {
-  return e && e.__esModule ? e : { default: e };
+  return e && e.__esModule
+    ? e
+    : {
+        default: e,
+      };
 }
 const VERSION = require("../../package.json").version;
 function getTransformCacheKey(opts) {

package/src/DeltaBundler/types.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.js.flow

@@ -11,19 +11,20 @@
 
 import type {RequireContext} from '../lib/contextModule';
 import type {RequireContextParams} from '../ModuleGraph/worker/collectDependencies';
+import type {ReadonlySourceLocation} from '../shared/types';
 import type {Graph} from './Graph';
 import type {JsTransformOptions} from 'metro-transform-worker';
 
 import CountingSet from '../lib/CountingSet';
 
 export type MixedOutput = {
-  +data: mixed,
+  +data: unknown,
   +type: string,
 };
 
 export type AsyncDependencyType = 'async' | 'maybeSync' | 'prefetch' | 'weak';
 
-export type TransformResultDependency = $ReadOnly<{
+export type TransformResultDependency = Readonly<{
   /**
    * The literal name provided to a require or import call. For example 'foo' in
    * case of `require('foo')`.
@@ -33,7 +34,7 @@ export type TransformResultDependency = $ReadOnly<{
   /**
    * Extra data returned by the dependency extractor.
    */
-  data: $ReadOnly<{
+  data: Readonly<{
     /**
      * A locally unique key for this dependency within the current module.
      */
@@ -52,43 +53,43 @@ export type TransformResultDependency = $ReadOnly<{
      */
     isOptional?: boolean,
 
-    locs: $ReadOnlyArray<BabelSourceLocation>,
+    locs: ReadonlyArray<ReadonlySourceLocation>,
 
     /** Context for requiring a collection of modules. */
     contextParams?: RequireContextParams,
   }>,
 }>;
 
-export type ResolvedDependency = $ReadOnly<{
+export type ResolvedDependency = Readonly<{
   absolutePath: string,
   data: TransformResultDependency,
 }>;
 
 export type Dependency =
   | ResolvedDependency
-  | $ReadOnly<{
+  | Readonly<{
       data: TransformResultDependency,
     }>;
 
-export type Module<T = MixedOutput> = $ReadOnly<{
+export type Module<T = MixedOutput> = Readonly<{
   dependencies: Map<string, Dependency>,
   inverseDependencies: CountingSet<string>,
-  output: $ReadOnlyArray<T>,
+  output: ReadonlyArray<T>,
   path: string,
   getSource: () => Buffer,
   unstable_transformResultKey?: ?string,
 }>;
 
-export type ModuleData<T = MixedOutput> = $ReadOnly<{
-  dependencies: $ReadOnlyMap<string, Dependency>,
-  resolvedContexts: $ReadOnlyMap<string, RequireContext>,
-  output: $ReadOnlyArray<T>,
+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<
+export type ReadOnlyDependencies<T = MixedOutput> = ReadonlyMap<
   string,
   Module<T>,
 >;
@@ -98,28 +99,28 @@ export type TransformInputOptions = Omit<
   'inlinePlatform' | 'inlineRequires',
 >;
 
-export type GraphInputOptions = $ReadOnly<{
-  entryPoints: $ReadOnlySet<string>,
+export type GraphInputOptions = Readonly<{
+  entryPoints: ReadonlySet<string>,
   // Unused in core but useful for custom serializers / experimentalSerializerHook
   transformOptions: TransformInputOptions,
 }>;
 
 export interface ReadOnlyGraph<T = MixedOutput> {
-  +entryPoints: $ReadOnlySet<string>;
+  +entryPoints: ReadonlySet<string>;
   // Unused in core but useful for custom serializers / experimentalSerializerHook
-  +transformOptions: $ReadOnly<TransformInputOptions>;
+  +transformOptions: Readonly<TransformInputOptions>;
   +dependencies: ReadOnlyDependencies<T>;
 }
 
 export type {Graph};
 
-export type TransformResult<T = MixedOutput> = $ReadOnly<{
-  dependencies: $ReadOnlyArray<TransformResultDependency>,
-  output: $ReadOnlyArray<T>,
+export type TransformResult<T = MixedOutput> = Readonly<{
+  dependencies: ReadonlyArray<TransformResultDependency>,
+  output: ReadonlyArray<T>,
   unstable_transformResultKey?: ?string,
 }>;
 
-export type TransformResultWithSource<T = MixedOutput> = $ReadOnly<{
+export type TransformResultWithSource<T = MixedOutput> = Readonly<{
   ...TransformResult<T>,
   getSource: () => Buffer,
 }>;
@@ -141,21 +142,22 @@ export type AllowOptionalDependencies =
   | boolean
   | AllowOptionalDependenciesWithOptions;
 
-export type BundlerResolution = $ReadOnly<{
+export type BundlerResolution = Readonly<{
   type: 'sourceFile',
   filePath: string,
 }>;
 
-export type Options<T = MixedOutput> = {
-  +resolve: ResolveFn,
-  +transform: TransformFn<T>,
-  +transformOptions: TransformInputOptions,
-  +onProgress: ?(numProcessed: number, total: number) => mixed,
-  +lazy: boolean,
-  +unstable_allowRequireContext: boolean,
-  +unstable_enablePackageExports: boolean,
-  +shallow: boolean,
-};
+export type Options<T = MixedOutput> = Readonly<{
+  resolve: ResolveFn,
+  transform: TransformFn<T>,
+  transformOptions: TransformInputOptions,
+  onProgress: ?(numProcessed: number, total: number) => unknown,
+  lazy: boolean,
+  unstable_allowRequireContext: boolean,
+  unstable_enablePackageExports: boolean,
+  unstable_incrementalResolution: boolean,
+  shallow: boolean,
+}>;
 
 export type DeltaResult<T = MixedOutput> = {
   +added: Map<string, Module<T>>,
@@ -164,7 +166,7 @@ export type DeltaResult<T = MixedOutput> = {
   +reset: boolean,
 };
 
-export type SerializerOptions = $ReadOnly<{
+export type SerializerOptions = Readonly<{
   asyncRequireModulePath: string,
   createModuleId: string => number,
   dev: boolean,
@@ -178,7 +180,7 @@ export type SerializerOptions = $ReadOnly<{
   modulesOnly: boolean,
   processModuleFilter: (module: Module<>) => boolean,
   projectRoot: string,
-  runBeforeMainModule: $ReadOnlyArray<string>,
+  runBeforeMainModule: ReadonlyArray<string>,
   runModule: boolean,
   serverRoot: string,
   shouldAddToIgnoreList: (Module<>) => boolean,

package/src/DeltaBundler.js

@@ -8,7 +8,11 @@ var _DeltaCalculator = _interopRequireDefault(
   require("./DeltaBundler/DeltaCalculator"),
 );
 function _interopRequireDefault(e) {
-  return e && e.__esModule ? e : { default: e };
+  return e && e.__esModule
+    ? e
+    : {
+        default: e,
+      };
 }
 class DeltaBundler {
   _deltaCalculators = new Map();

package/src/DeltaBundler.js.flow

@@ -56,7 +56,7 @@ export default class DeltaBundler<T = MixedOutput> {
   }
 
   async getDependencies(
-    entryPoints: $ReadOnlyArray<string>,
+    entryPoints: ReadonlyArray<string>,
     options: Options<T>,
   ): Promise<ReadOnlyGraph<T>['dependencies']> {
     const deltaCalculator = new DeltaCalculator(
@@ -76,7 +76,7 @@ export default class DeltaBundler<T = MixedOutput> {
   // so that we don't leak graphs that are not reachable.
   // To get just the dependencies, use getDependencies which will not leak graphs.
   async buildGraph(
-    entryPoints: $ReadOnlyArray<string>,
+    entryPoints: ReadonlyArray<string>,
     options: Options<T>,
   ): Promise<Graph<T>> {
     const deltaCalculator = new DeltaCalculator(

package/src/HmrServer.js

@@ -31,31 +31,42 @@ var transformHelpers = _interopRequireWildcard(
 );
 var _metroCore = require("metro-core");
 var _nullthrows = _interopRequireDefault(require("nullthrows"));
-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]);
+function _interopRequireWildcard(e, t) {
+  if ("function" == typeof WeakMap)
+    var r = new WeakMap(),
+      n = new WeakMap();
+  return (_interopRequireWildcard = function (e, t) {
+    if (!t && e && e.__esModule) return e;
+    var o,
+      i,
+      f = {
+        __proto__: null,
+        default: e,
+      };
+    if (null === e || ("object" != typeof e && "function" != typeof e))
+      return f;
+    if ((o = t ? n : r)) {
+      if (o.has(e)) return o.get(e);
+      o.set(e, f);
     }
-  return ((n.default = e), t && t.set(e, n), n);
+    for (const t in e)
+      "default" !== t &&
+        {}.hasOwnProperty.call(e, t) &&
+        ((i =
+          (o = Object.defineProperty) &&
+          Object.getOwnPropertyDescriptor(e, t)) &&
+        (i.get || i.set)
+          ? o(f, t, i)
+          : (f[t] = e[t]));
+    return f;
+  })(e, t);
 }
 function _interopRequireDefault(e) {
-  return e && e.__esModule ? e : { default: e };
+  return e && e.__esModule
+    ? e
+    : {
+        default: e,
+      };
 }
 const debug = require("debug")("Metro:HMR");
 const { createActionStartEntry, createActionEndEntry, log } = _metroCore.Logger;
@@ -77,9 +88,10 @@ class HmrServer {
       optedIntoHMR: false,
     };
   };
-  async _registerEntryPoint(client, requestUrl, sendFn) {
-    debug("Registering entry point: %s", requestUrl);
-    requestUrl = this._config.server.rewriteRequestUrl(requestUrl);
+  async _registerEntryPoint(client, originalRequestUrl, sendFn) {
+    debug("Registering entry point: %s", originalRequestUrl);
+    const requestUrl =
+      this._config.server.rewriteRequestUrl(originalRequestUrl);
     debug("Rewritten as: %s", requestUrl);
     const { bundleType: _bundleType, ...options } = (0,
     _parseBundleOptionsFromBundleRequestUrl.default)(
@@ -150,7 +162,7 @@ class HmrServer {
         unlisten: () => unlisten(),
       };
       this._clientGroups.set(id, clientGroup);
-      let latestEventArgs = [];
+      let latestChangeEvent = null;
       const debounceCallHandleFileChange = (0, _debounceAsyncQueue.default)(
         async () => {
           await this._handleFileChange(
@@ -158,15 +170,15 @@ class HmrServer {
             {
               isInitialUpdate: false,
             },
-            ...latestEventArgs,
+            latestChangeEvent,
           );
         },
         50,
       );
       const unlisten = this._bundler
         .getDeltaBundler()
-        .listen(graph, async (...args) => {
-          latestEventArgs = args;
+        .listen(graph, async (changeEvent) => {
+          latestChangeEvent = changeEvent;
           await debounceCallHandleFileChange();
         });
     }
@@ -218,7 +230,7 @@ class HmrServer {
   onClientError = (client, e) => {
     this._config.reporter.update({
       type: "hmr_client_error",
-      error: e.error,
+      error: e,
     });
     this.onClientDisconnect(client);
   };

package/src/HmrServer.js.flow

@@ -4,11 +4,14 @@
  * 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
- * @flow
  */
 
-import type IncrementalBundler, {RevisionId} from './IncrementalBundler';
+import type {
+  RevisionId,
+  default as IncrementalBundler,
+} from './IncrementalBundler';
 import type {GraphOptions} from './shared/types';
 import type {ConfigT, RootPerfLogger} from 'metro-config';
 import type {
@@ -93,11 +96,12 @@ export default class HmrServer<TClient: Client> {
 
   async _registerEntryPoint(
     client: Client,
-    requestUrl: string,
+    originalRequestUrl: string,
     sendFn: (data: string) => void,
   ): Promise<void> {
-    debug('Registering entry point: %s', requestUrl);
-    requestUrl = this._config.server.rewriteRequestUrl(requestUrl);
+    debug('Registering entry point: %s', originalRequestUrl);
+    const requestUrl =
+      this._config.server.rewriteRequestUrl(originalRequestUrl);
     debug('Rewritten as: %s', requestUrl);
 
     const {bundleType: _bundleType, ...options} =
@@ -176,21 +180,22 @@ export default class HmrServer<TClient: Client> {
 
       this._clientGroups.set(id, clientGroup);
 
-      let latestEventArgs: Array<any> = [];
+      let latestChangeEvent: ?{
+        logger: ?RootPerfLogger,
+      } = null;
 
       const debounceCallHandleFileChange = debounceAsyncQueue(async () => {
         await this._handleFileChange(
           nullthrows(clientGroup),
           {isInitialUpdate: false},
-          ...latestEventArgs,
+          latestChangeEvent,
         );
       }, 50);
 
       const unlisten = this._bundler
         .getDeltaBundler()
-        // $FlowFixMe[missing-local-annot]
-        .listen(graph, async (...args) => {
-          latestEventArgs = args;
+        .listen(graph, async changeEvent => {
+          latestChangeEvent = changeEvent;
           await debounceCallHandleFileChange();
         });
     }
@@ -242,10 +247,10 @@ export default class HmrServer<TClient: Client> {
     return Promise.resolve();
   };
 
-  onClientError: (client: TClient, e: ErrorEvent) => void = (client, e) => {
+  onClientError: (client: TClient, e: Error) => void = (client, e) => {
     this._config.reporter.update({
       type: 'hmr_client_error',
-      error: e.error,
+      error: e,
     });
     this.onClientDisconnect(client);
   };