metro 0.83.3 → 0.84.0

package/src/DeltaBundler/Graph.js.flow

@@ -73,12 +73,12 @@ export type Result<T> = {
   deleted: Set<string>,
 };
 
-/**
+/*
  * Internal data structure that the traversal logic uses to know which of the
  * files have been modified. This allows to return the added modules before the
  * modified ones (which is useful for things like Hot Module Reloading).
- **/
-type Delta<T> = $ReadOnly<{
+ */
+type Delta<T> = Readonly<{
   // `added` and `deleted` are mutually exclusive.
   // Internally, a module can be in both `touched` and (either) `added` or
   // `deleted`. Before returning the result, we'll calculate
@@ -87,15 +87,15 @@ type Delta<T> = $ReadOnly<{
   touched: Set<string>,
   deleted: Set<string>,
 
-  updatedModuleData: $ReadOnlyMap<string, ModuleData<T>>,
+  updatedModuleData: ReadonlyMap<string, ModuleData<T>>,
   baseModuleData: Map<string, ModuleData<T>>,
-  errors: $ReadOnlyMap<string, Error>,
+  errors: ReadonlyMap<string, Error>,
 }>;
 
-type InternalOptions<T> = $ReadOnly<{
+type InternalOptions<T> = Readonly<{
   lazy: boolean,
-  onDependencyAdd: () => mixed,
-  onDependencyAdded: () => mixed,
+  onDependencyAdd: () => unknown,
+  onDependencyAdded: () => unknown,
   resolve: Options<T>['resolve'],
   transform: Options<T>['transform'],
   shallow: boolean,
@@ -113,11 +113,11 @@ function getInternalOptions<T>({
 
   return {
     lazy,
-    transform,
-    resolve,
     onDependencyAdd: () => onProgress && onProgress(numProcessed, ++total),
     onDependencyAdded: () => onProgress && onProgress(++numProcessed, total),
+    resolve,
     shallow,
+    transform,
   };
 }
 
@@ -130,12 +130,12 @@ function isWeakOrLazy<T>(
 }
 
 export class Graph<T = MixedOutput> {
-  +entryPoints: $ReadOnlySet<string>;
+  +entryPoints: ReadonlySet<string>;
   +transformOptions: TransformInputOptions;
   +dependencies: Dependencies<T> = new Map();
   +#importBundleNodes: Map<
     string,
-    $ReadOnly<{
+    Readonly<{
       inverseDependencies: CountingSet<string>,
     }>,
   > = new Map();
@@ -169,7 +169,7 @@ export class Graph<T = MixedOutput> {
    * since the last traversal.
    */
   async traverseDependencies(
-    paths: $ReadOnlyArray<string>,
+    paths: ReadonlyArray<string>,
     options: Options<T>,
   ): Promise<Result<T>> {
     const internalOptions = getInternalOptions(options);
@@ -246,11 +246,11 @@ export class Graph<T = MixedOutput> {
       // Roll back to base before re-throwing.
       const rollbackDelta: Delta<T> = {
         added: delta.added,
+        baseModuleData: new Map(),
         deleted: delta.deleted,
+        errors: new Map(),
         touched: new Set(),
         updatedModuleData: delta.baseModuleData,
-        baseModuleData: new Map(),
-        errors: new Map(),
       };
       for (const modified of modifiedPathsInBaseGraph) {
         const module = this.dependencies.get(modified);
@@ -295,8 +295,8 @@ export class Graph<T = MixedOutput> {
 
     return {
       added,
-      modified,
       deleted: delta.deleted,
+      modified,
     };
   }
 
@@ -338,39 +338,39 @@ export class Graph<T = MixedOutput> {
 
     return {
       added: this.dependencies,
-      modified: new Map(),
       deleted: new Set(),
+      modified: new Map(),
     };
   }
 
   async _buildDelta(
-    pathsToVisit: $ReadOnlySet<string>,
+    pathsToVisit: ReadonlySet<string>,
     options: InternalOptions<T>,
     moduleFilter?: (path: string) => boolean,
   ): Promise<Delta<T>> {
     const subGraph = await buildSubgraph(pathsToVisit, this.#resolvedContexts, {
       resolve: options.resolve,
-      transform: async (absolutePath, requireContext) => {
-        options.onDependencyAdd();
-        const result = await options.transform(absolutePath, requireContext);
-        options.onDependencyAdded();
-        return result;
-      },
       shouldTraverse: (dependency: ResolvedDependency) => {
         if (options.shallow || isWeakOrLazy(dependency, options)) {
           return false;
         }
         return moduleFilter == null || moduleFilter(dependency.absolutePath);
       },
+      transform: async (absolutePath, requireContext) => {
+        options.onDependencyAdd();
+        const result = await options.transform(absolutePath, requireContext);
+        options.onDependencyAdded();
+        return result;
+      },
     });
 
     return {
       added: new Set(),
-      touched: new Set(),
-      deleted: new Set(),
-      updatedModuleData: subGraph.moduleData,
       baseModuleData: new Map(),
+      deleted: new Set(),
       errors: subGraph.errors,
+      touched: new Set(),
+      updatedModuleData: subGraph.moduleData,
     };
   }
 
@@ -378,7 +378,7 @@ export class Graph<T = MixedOutput> {
     path: string,
     delta: Delta<T>,
     options: InternalOptions<T>,
-    commitOptions: $ReadOnly<{
+    commitOptions: Readonly<{
       onlyRemove: boolean,
     }> = {onlyRemove: false},
   ): Module<T> {
@@ -775,9 +775,9 @@ export class Graph<T = MixedOutput> {
     }
     return {
       dependencies: new Map(dependencies),
-      resolvedContexts,
       getSource,
       output,
+      resolvedContexts,
       unstable_transformResultKey,
     };
   }
@@ -936,7 +936,7 @@ export class Graph<T = MixedOutput> {
 function dependenciesEqual(
   a: Dependency,
   b: Dependency,
-  options: $ReadOnly<{lazy: boolean, ...}>,
+  options: Readonly<{lazy: boolean, ...}>,
 ): boolean {
   return (
     a === b ||

package/src/DeltaBundler/Serializers/baseJSBundle.js.flow

@@ -22,7 +22,7 @@ import processModules from './helpers/processModules';
 
 export default function baseJSBundle(
   entryPoint: string,
-  preModules: $ReadOnlyArray<Module<>>,
+  preModules: ReadonlyArray<Module<>>,
   graph: ReadOnlyGraph<>,
   options: SerializerOptions,
 ): Bundle {

package/src/DeltaBundler/Serializers/getAllFiles.js.flow

@@ -20,10 +20,10 @@ type Options = {
 };
 
 export default async function getAllFiles(
-  pre: $ReadOnlyArray<Module<>>,
+  pre: ReadonlyArray<Module<>>,
   graph: ReadOnlyGraph<>,
   options: Options,
-): Promise<$ReadOnlyArray<string>> {
+): Promise<ReadonlyArray<string>> {
   const modules = graph.dependencies;
   const {processModuleFilter} = options;
 

package/src/DeltaBundler/Serializers/getAssets.js.flow

@@ -18,7 +18,7 @@ import path from 'path';
 
 type Options = {
   +processModuleFilter: (module: Module<>) => boolean,
-  assetPlugins: $ReadOnlyArray<string>,
+  assetPlugins: ReadonlyArray<string>,
   platform: ?string,
   projectRoot: string,
   publicPath: string,
@@ -27,7 +27,7 @@ type Options = {
 export default async function getAssets(
   dependencies: ReadOnlyDependencies<>,
   options: Options,
-): Promise<$ReadOnlyArray<AssetData>> {
+): Promise<ReadonlyArray<AssetData>> {
   const promises = [];
   const {processModuleFilter} = options;
 

package/src/DeltaBundler/Serializers/getExplodedSourceMap.js.flow

@@ -17,7 +17,7 @@ import type {
 
 import {getJsOutput, isJsModule} from './helpers/js';
 
-export type ExplodedSourceMap = $ReadOnlyArray<{
+export type ExplodedSourceMap = ReadonlyArray<{
   +map: Array<MetroSourceMapSegmentTuple>,
   +firstLine1Based: number,
   +functionMap: ?FBSourceFunctionMap,
@@ -25,7 +25,7 @@ export type ExplodedSourceMap = $ReadOnlyArray<{
 }>;
 
 export function getExplodedSourceMap(
-  modules: $ReadOnlyArray<Module<>>,
+  modules: ReadonlyArray<Module<>>,
   options: {
     +processModuleFilter: (module: Module<>) => boolean,
   },

package/src/DeltaBundler/Serializers/getRamBundleInfo.js.flow

@@ -22,7 +22,7 @@ import {sourceMapObject} from './sourceMapObject';
 import nullthrows from 'nullthrows';
 import path from 'path';
 
-type Options = $ReadOnly<{
+type Options = Readonly<{
   ...SerializerOptions,
   ...SourceMapGeneratorOptions,
   getTransformOptions: ?GetTransformOptions,
@@ -31,18 +31,18 @@ type Options = $ReadOnly<{
 
 export type RamBundleInfo = {
   getDependencies: string => Set<string>,
-  startupModules: $ReadOnlyArray<ModuleTransportLike>,
-  lazyModules: $ReadOnlyArray<ModuleTransportLike>,
+  startupModules: ReadonlyArray<ModuleTransportLike>,
+  lazyModules: ReadonlyArray<ModuleTransportLike>,
   groups: Map<number, Set<number>>,
 };
 
 export default async function getRamBundleInfo(
   entryPoint: string,
-  pre: $ReadOnlyArray<Module<>>,
+  pre: ReadonlyArray<Module<>>,
   graph: ReadOnlyGraph<>,
   options: Options,
 ): Promise<RamBundleInfo> {
-  let modules: $ReadOnlyArray<Module<>> = [
+  let modules: ReadonlyArray<Module<>> = [
     ...pre,
     ...graph.dependencies.values(),
   ];
@@ -142,9 +142,9 @@ async function _getRamOptions(
   getDependencies: string => Iterable<string>,
   getTransformOptions: ?GetTransformOptions,
 ): Promise<
-  $ReadOnly<{
-    preloadedModules: $ReadOnly<{[string]: true, ...}>,
-    ramGroups: $ReadOnlyArray<string>,
+  Readonly<{
+    preloadedModules: Readonly<{[string]: true, ...}>,
+    ramGroups: ReadonlyArray<string>,
   }>,
 > {
   if (getTransformOptions == null) {

package/src/DeltaBundler/Serializers/helpers/js.js

@@ -13,28 +13,32 @@ var _invariant = _interopRequireDefault(require("invariant"));
 var jscSafeUrl = _interopRequireWildcard(require("jsc-safe-url"));
 var _metroTransformPlugins = require("metro-transform-plugins");
 var _path = _interopRequireDefault(require("path"));
-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 };

package/src/DeltaBundler/Serializers/helpers/js.js.flow

@@ -19,7 +19,7 @@ import * as jscSafeUrl from 'jsc-safe-url';
 import {addParamsToDefineCall} from 'metro-transform-plugins';
 import path from 'path';
 
-export type Options = $ReadOnly<{
+export type Options = Readonly<{
   createModuleId: string => number | string,
   dev: boolean,
   includeAsyncPaths: boolean,
@@ -43,10 +43,10 @@ export function wrapModule(module: Module<>, options: Options): string {
 export function getModuleParams(
   module: Module<>,
   options: Options,
-): Array<mixed> {
+): Array<unknown> {
   const moduleId = options.createModuleId(module.path);
 
-  const paths: {[moduleID: number | string]: mixed} = {};
+  const paths: {[moduleID: number | string]: unknown} = {};
   let hasPaths = false;
   const dependencyMapArray = Array.from(module.dependencies.values()).map(
     dependency => {
@@ -118,8 +118,8 @@ export function getModuleParams(
 }
 
 export function getJsOutput(
-  module: $ReadOnly<{
-    output: $ReadOnlyArray<MixedOutput>,
+  module: Readonly<{
+    output: ReadonlyArray<MixedOutput>,
     path?: string,
     ...
   }>,
@@ -133,7 +133,7 @@ export function getJsOutput(
     } has ${jsModules.length} JS outputs.`,
   );
 
-  const jsOutput: JsOutput = (jsModules[0]: any);
+  const jsOutput: JsOutput = jsModules[0] as any;
 
   invariant(
     Number.isFinite(jsOutput.data.lineCount),

package/src/DeltaBundler/Serializers/helpers/processModules.js.flow

@@ -14,7 +14,7 @@ import type {Module} from '../../types';
 import {isJsModule, wrapModule} from './js';
 
 export default function processModules(
-  modules: $ReadOnlyArray<Module<>>,
+  modules: ReadonlyArray<Module<>>,
   {
     filter = () => true,
     createModuleId,
@@ -23,7 +23,7 @@ export default function processModules(
     projectRoot,
     serverRoot,
     sourceUrl,
-  }: $ReadOnly<{
+  }: Readonly<{
     filter?: (module: Module<>) => boolean,
     createModuleId: string => number,
     dev: boolean,
@@ -32,7 +32,7 @@ export default function processModules(
     serverRoot: string,
     sourceUrl: ?string,
   }>,
-): $ReadOnlyArray<[Module<>, string]> {
+): ReadonlyArray<[Module<>, string]> {
   return [...modules]
     .filter(isJsModule)
     .filter(filter)

package/src/DeltaBundler/Serializers/hmrJSBundle.js

@@ -11,28 +11,32 @@ var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
   return e && e.__esModule ? e : { default: e };
 }
-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);
 }
 const debug = require("debug")("Metro:HMR");
 function generateModules(sourceModules, graph, options) {

package/src/DeltaBundler/Serializers/hmrJSBundle.js.flow

@@ -20,7 +20,7 @@ import path from 'path';
 // eslint-disable-next-line import/no-commonjs
 const debug = require('debug')('Metro:HMR');
 
-type Options = $ReadOnly<{
+type Options = Readonly<{
   clientUrl: URL,
   createModuleId: string => number,
   includeAsyncPaths: boolean,
@@ -33,7 +33,7 @@ function generateModules(
   sourceModules: Iterable<Module<>>,
   graph: ReadOnlyGraph<>,
   options: Options,
-): $ReadOnlyArray<HmrModule> {
+): ReadonlyArray<HmrModule> {
   const modules = [];
 
   for (const module of sourceModules) {
@@ -148,9 +148,9 @@ export default function hmrJSBundle(
   graph: ReadOnlyGraph<>,
   options: Options,
 ): {
-  +added: $ReadOnlyArray<HmrModule>,
-  +deleted: $ReadOnlyArray<number>,
-  +modified: $ReadOnlyArray<HmrModule>,
+  +added: ReadonlyArray<HmrModule>,
+  +deleted: ReadonlyArray<number>,
+  +modified: ReadonlyArray<HmrModule>,
 } {
   return {
     added: generateModules(delta.added.values(), graph, options),

package/src/DeltaBundler/Serializers/sourceMapGenerator.js.flow

@@ -15,7 +15,7 @@ import getSourceMapInfo from './helpers/getSourceMapInfo';
 import {isJsModule} from './helpers/js';
 import {fromRawMappings, fromRawMappingsNonBlocking} from 'metro-source-map';
 
-export type SourceMapGeneratorOptions = $ReadOnly<{
+export type SourceMapGeneratorOptions = Readonly<{
   excludeSource: boolean,
   processModuleFilter: (module: Module<>) => boolean,
   shouldAddToIgnoreList: (module: Module<>) => boolean,
@@ -24,8 +24,8 @@ export type SourceMapGeneratorOptions = $ReadOnly<{
 
 function getSourceMapInfosImpl(
   isBlocking: boolean,
-  onDone: ($ReadOnlyArray<ReturnType<typeof getSourceMapInfo>>) => void,
-  modules: $ReadOnlyArray<Module<>>,
+  onDone: (ReadonlyArray<ReturnType<typeof getSourceMapInfo>>) => void,
+  modules: ReadonlyArray<Module<>>,
   options: SourceMapGeneratorOptions,
 ): void {
   const sourceMapInfos = [];
@@ -76,7 +76,7 @@ function getSourceMapInfosImpl(
 }
 
 function sourceMapGenerator(
-  modules: $ReadOnlyArray<Module<>>,
+  modules: ReadonlyArray<Module<>>,
   options: SourceMapGeneratorOptions,
 ): ReturnType<typeof fromRawMappings> {
   let sourceMapInfos;
@@ -97,11 +97,11 @@ function sourceMapGenerator(
 }
 
 async function sourceMapGeneratorNonBlocking(
-  modules: $ReadOnlyArray<Module<>>,
+  modules: ReadonlyArray<Module<>>,
   options: SourceMapGeneratorOptions,
 ): ReturnType<typeof fromRawMappingsNonBlocking> {
   const sourceMapInfos = await new Promise<
-    $ReadOnlyArray<ReturnType<typeof getSourceMapInfo>>,
+    ReadonlyArray<ReturnType<typeof getSourceMapInfo>>,
   >(resolve => {
     getSourceMapInfosImpl(false, resolve, modules, options);
   });

package/src/DeltaBundler/Serializers/sourceMapObject.js.flow

@@ -19,7 +19,7 @@ import {
 } from './sourceMapGenerator';
 
 function sourceMapObject(
-  modules: $ReadOnlyArray<Module<>>,
+  modules: ReadonlyArray<Module<>>,
   options: SourceMapGeneratorOptions,
 ): MixedSourceMap {
   const generator = sourceMapGenerator(modules, options);
@@ -29,7 +29,7 @@ function sourceMapObject(
 }
 
 async function sourceMapObjectNonBlocking(
-  modules: $ReadOnlyArray<Module<>>,
+  modules: ReadonlyArray<Module<>>,
   options: SourceMapGeneratorOptions,
 ): Promise<MixedSourceMap> {
   const generator = await sourceMapGeneratorNonBlocking(modules, options);

package/src/DeltaBundler/Serializers/sourceMapString.js.flow

@@ -18,7 +18,7 @@ import {
 } from './sourceMapGenerator';
 
 function sourceMapString(
-  modules: $ReadOnlyArray<Module<>>,
+  modules: ReadonlyArray<Module<>>,
   options: SourceMapGeneratorOptions,
 ): string {
   return sourceMapGenerator(modules, options).toString(undefined, {
@@ -27,7 +27,7 @@ function sourceMapString(
 }
 
 async function sourceMapStringNonBlocking(
-  modules: $ReadOnlyArray<Module<>>,
+  modules: ReadonlyArray<Module<>>,
   options: SourceMapGeneratorOptions,
 ): Promise<string> {
   const generator = await sourceMapGeneratorNonBlocking(modules, options);

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.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,