metro 0.83.0 → 0.83.2

package/src/DeltaBundler/Transformer.js.flow

@@ -9,27 +9,27 @@
  * @oncall react_native
  */
 
-'use strict';
-
 import type {TransformResult, TransformResultWithSource} from '../DeltaBundler';
 import type {TransformerConfig, TransformOptions} from './Worker';
 import type {ConfigT} from 'metro-config';
 
+import {normalizePathSeparatorsToPosix} from '../lib/pathUtils';
+import getTransformCacheKey from './getTransformCacheKey';
+import WorkerFarm from './WorkerFarm';
+import assert from 'assert';
 import crypto from 'crypto';
+import fs from 'fs';
+import {Cache, stableHash} from 'metro-cache';
+import path from 'path';
 
-const getTransformCacheKey = require('./getTransformCacheKey');
-const WorkerFarm = require('./WorkerFarm');
-const assert = require('assert');
+// eslint-disable-next-line import/no-commonjs
 const debug = require('debug')('Metro:Transformer');
-const fs = require('fs');
-const {Cache, stableHash} = require('metro-cache');
-const path = require('path');
 
 type GetOrComputeSha1Fn = string => Promise<
   $ReadOnly<{content?: Buffer, sha1: string}>,
 >;
 
-class Transformer {
+export default class Transformer {
   _config: ConfigT;
   _cache: Cache<TransformResult<>>;
   _baseHash: string;
@@ -87,14 +87,12 @@ class Transformer {
       customTransformOptions,
       dev,
       experimentalImportSupport,
-      hot,
       inlinePlatform,
       inlineRequires,
       minify,
       nonInlinedRequires,
       platform,
       type,
-      unstable_disableES6Transforms,
       unstable_transformProfile,
       unstable_memoizeInlineRequires,
       unstable_nonMemoizedInlineRequires,
@@ -119,19 +117,16 @@ class Transformer {
       // Project-relative, posix-separated path for portability. Necessary in
       // addition to content hash because transformers receive path as an
       // input, and may apply e.g. extension-based logic.
-      path.sep === '/' ? localPath : localPath.replaceAll(path.sep, '/'),
-
+      normalizePathSeparatorsToPosix(localPath),
       customTransformOptions,
       dev,
       experimentalImportSupport,
-      hot,
       inlinePlatform,
       inlineRequires,
       minify,
       nonInlinedRequires,
       platform,
       type,
-      unstable_disableES6Transforms,
       unstable_memoizeInlineRequires,
       unstable_nonMemoizedInlineRequires,
       unstable_transformProfile,
@@ -212,5 +207,3 @@ function verifyRootExists(root: string): void {
   // Verify that the root exists.
   assert(fs.statSync(root).isDirectory(), 'Root has to be a valid directory');
 }
-
-module.exports = Transformer;

package/src/DeltaBundler/Worker.flow.js

@@ -1,9 +1,16 @@
 "use strict";
 
-const traverse = require("@babel/traverse").default;
-const crypto = require("crypto");
-const fs = require("fs");
-const path = require("path");
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.transform = void 0;
+var _traverse = _interopRequireDefault(require("@babel/traverse"));
+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 };
+}
 function asDeserializedBuffer(value) {
   if (Buffer.isBuffer(value)) {
     return value;
@@ -16,34 +23,37 @@ function asDeserializedBuffer(value) {
   }
   return null;
 }
-async function transform(
+const transform = (
   filename,
   transformOptions,
   projectRoot,
   transformerConfig,
-  fileBuffer
-) {
+  fileBuffer,
+) => {
   let data;
   const fileBufferObject = asDeserializedBuffer(fileBuffer);
   if (fileBufferObject) {
     data = fileBufferObject;
   } else {
-    data = fs.readFileSync(path.resolve(projectRoot, filename));
+    data = _fs.default.readFileSync(
+      _path.default.resolve(projectRoot, filename),
+    );
   }
   return transformFile(
     filename,
     data,
     transformOptions,
     projectRoot,
-    transformerConfig
+    transformerConfig,
   );
-}
+};
+exports.transform = transform;
 async function transformFile(
   filename,
   data,
   transformOptions,
   projectRoot,
-  transformerConfig
+  transformerConfig,
 ) {
   const Transformer = require.call(null, transformerConfig.transformerPath);
   const transformFileStartLogEntry = {
@@ -53,18 +63,18 @@ async function transformFile(
     log_entry_label: "Transforming file",
     start_timestamp: process.hrtime(),
   };
-  const sha1 = crypto.createHash("sha1").update(data).digest("hex");
+  const sha1 = _crypto.default.createHash("sha1").update(data).digest("hex");
   const result = await Transformer.transform(
     transformerConfig.transformerConfig,
     projectRoot,
     filename,
     data,
-    transformOptions
+    transformOptions,
   );
-  traverse.cache.clear();
+  _traverse.default.cache.clear();
   const transformFileEndLogEntry = getEndLogEntry(
     transformFileStartLogEntry,
-    filename
+    filename,
   );
   return {
     result,
@@ -84,6 +94,3 @@ function getEndLogEntry(startLogEntry, filename) {
     log_entry_label: "Transforming file",
   };
 }
-module.exports = {
-  transform,
-};

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

@@ -9,26 +9,20 @@
  * @oncall react_native
  */
 
-'use strict';
-
-import type {TransformResult} from './types.flow';
+import type {TransformResult} from './types';
 import type {LogEntry} from 'metro-core/private/Logger';
 import type {
   JsTransformerConfig,
   JsTransformOptions,
 } from 'metro-transform-worker';
 
-const traverse = require('@babel/traverse').default;
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
+import traverse from '@babel/traverse';
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
 
 export type {JsTransformOptions as TransformOptions} from 'metro-transform-worker';
 
-export type Worker = {
-  +transform: typeof transform,
-};
-
 type TransformerInterface = {
   transform(
     JsTransformerConfig,
@@ -72,13 +66,13 @@ function asDeserializedBuffer(value: any): Buffer | null {
   return null;
 }
 
-async function transform(
+export const transform = (
   filename: string,
   transformOptions: JsTransformOptions,
   projectRoot: string,
   transformerConfig: TransformerConfig,
   fileBuffer?: Buffer,
-): Promise<Data> {
+): Promise<Data> => {
   let data;
 
   const fileBufferObject = asDeserializedBuffer(fileBuffer);
@@ -94,7 +88,11 @@ async function transform(
     projectRoot,
     transformerConfig,
   );
-}
+};
+
+export type Worker = {
+  +transform: typeof transform,
+};
 
 async function transformFile(
   filename: string,
@@ -160,7 +158,3 @@ function getEndLogEntry(startLogEntry: LogEntry, filename: string): LogEntry {
     log_entry_label: 'Transforming file',
   };
 }
-
-module.exports = ({
-  transform,
-}: Worker);

package/src/DeltaBundler/Worker.js.flow

@@ -9,6 +9,8 @@
  * @oncall react_native
  */
 
+/* eslint-disable import/no-commonjs */
+
 'use strict';
 
 /*::

package/src/DeltaBundler/WorkerFarm.js

@@ -1,7 +1,11 @@
 "use strict";
 
-const { Worker: JestWorker } = require("jest-worker");
-const { Logger } = require("metro-core");
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+var _jestWorker = require("jest-worker");
+var _metroCore = require("metro-core");
 class WorkerFarm {
   constructor(config, transformerConfig) {
     this._config = config;
@@ -11,7 +15,7 @@ class WorkerFarm {
       const worker = this._makeFarm(
         absoluteWorkerPath,
         ["transform"],
-        this._config.maxWorkers
+        this._config.maxWorkers,
       );
       worker.getStdout().on("data", (chunk) => {
         this._config.reporter.update({
@@ -42,10 +46,10 @@ class WorkerFarm {
         options,
         this._config.projectRoot,
         this._transformerConfig,
-        fileBuffer
+        fileBuffer,
       );
-      Logger.log(data.transformFileStartLogEntry);
-      Logger.log(data.transformFileEndLogEntry);
+      _metroCore.Logger.log(data.transformFileStartLogEntry);
+      _metroCore.Logger.log(data.transformFileEndLogEntry);
       return {
         result: data.result,
         sha1: data.sha1,
@@ -63,7 +67,7 @@ class WorkerFarm {
       ...process.env,
       FORCE_COLOR: 1,
     };
-    return new JestWorker(absoluteWorkerPath, {
+    return new _jestWorker.Worker(absoluteWorkerPath, {
       computeWorkerKey: this._config.stickyWorkers
         ? this._computeWorkerKey
         : undefined,
@@ -91,9 +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,
@@ -104,6 +106,7 @@ class WorkerFarm {
     });
   }
 }
+exports.default = WorkerFarm;
 class TransformError extends SyntaxError {
   type = "TransformError";
   constructor(message) {
@@ -111,4 +114,3 @@ class TransformError extends SyntaxError {
     Error.captureStackTrace && Error.captureStackTrace(this, TransformError);
   }
 }
-module.exports = WorkerFarm;

package/src/DeltaBundler/WorkerFarm.js.flow

@@ -9,15 +9,13 @@
  * @oncall react_native
  */
 
-'use strict';
-
 import type {TransformResult} from '../DeltaBundler';
 import type {TransformerConfig, TransformOptions, Worker} from './Worker';
 import type {ConfigT} from 'metro-config';
 import type {Readable} from 'stream';
 
-const {Worker: JestWorker} = require('jest-worker');
-const {Logger} = require('metro-core');
+import {Worker as JestWorker} from 'jest-worker';
+import {Logger} from 'metro-core';
 
 type WorkerInterface = {
   getStdout(): Readable,
@@ -31,7 +29,7 @@ type TransformerResult = $ReadOnly<{
   sha1: string,
 }>;
 
-class WorkerFarm {
+export default class WorkerFarm {
   _config: ConfigT;
   _transformerConfig: TransformerConfig;
   _worker: WorkerInterface | Worker;
@@ -63,6 +61,7 @@ class WorkerFarm {
 
       this._worker = worker;
     } else {
+      // eslint-disable-next-line import/no-commonjs
       this._worker = (require('./Worker'): Worker);
     }
   }
@@ -117,7 +116,7 @@ class WorkerFarm {
     return new JestWorker(absoluteWorkerPath, {
       computeWorkerKey: this._config.stickyWorkers
         ? // $FlowFixMe[method-unbinding] added when improving typing for this parameters
-          // $FlowFixMe[incompatible-call]
+          // $FlowFixMe[incompatible-type]
           this._computeWorkerKey
         : undefined,
       exposedMethods,
@@ -161,7 +160,8 @@ class WorkerFarm {
       }: ${err.message}`,
     );
 
-    // $FlowExpectedError: TODO(t67543470): Change this to properly extend the error.
+    // $FlowFixMe[prop-missing]
+    // $FlowExpectedError[unsafe-object-assign] : TODO(t67543470): Change this to properly extend the error.
     return Object.assign(error, {
       stack: err.stack,
       snippet: err.codeFrame,
@@ -180,5 +180,3 @@ class TransformError extends SyntaxError {
     Error.captureStackTrace && Error.captureStackTrace(this, TransformError);
   }
 }
-
-module.exports = WorkerFarm;

package/src/DeltaBundler/buildSubgraph.js

@@ -8,11 +8,7 @@ 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();
@@ -25,7 +21,7 @@ function resolveDependencies(parentPath, dependencies, resolve) {
       const from = _path.default.join(parentPath, "..", dep.name);
       const absolutePath = (0, _contextModule.deriveAbsolutePathFromContext)(
         from,
-        contextParams
+        contextParams,
       );
       const resolvedContext = {
         from,
@@ -33,7 +29,7 @@ function resolveDependencies(parentPath, dependencies, resolve) {
         recursive: contextParams.recursive,
         filter: new RegExp(
           contextParams.filter.pattern,
-          contextParams.filter.flags
+          contextParams.filter.flags,
         ),
       };
       resolvedContexts.set(key, resolvedContext);
@@ -58,7 +54,7 @@ function resolveDependencies(parentPath, dependencies, resolve) {
     }
     if (maybeResolvedDeps.has(key)) {
       throw new Error(
-        `resolveDependencies: Found duplicate dependency key '${key}' in ${parentPath}`
+        `resolveDependencies: Found duplicate dependency key '${key}' in ${parentPath}`,
       );
     }
     maybeResolvedDeps.set(key, maybeResolvedDep);
@@ -71,7 +67,7 @@ function resolveDependencies(parentPath, dependencies, resolve) {
 async function buildSubgraph(
   entryPaths,
   resolvedContexts,
-  { resolve, transform, shouldTraverse }
+  { resolve, transform, shouldTraverse },
 ) {
   const moduleData = new Map();
   const errors = new Map();
@@ -85,7 +81,7 @@ async function buildSubgraph(
     const resolutionResult = resolveDependencies(
       absolutePath,
       transformResult.dependencies,
-      resolve
+      resolve,
     );
     moduleData.set(absolutePath, {
       ...transformResult,
@@ -96,22 +92,22 @@ async function buildSubgraph(
         .filter(
           (dependency) =>
             (0, _isResolvedDependency.isResolvedDependency)(dependency) &&
-            shouldTraverse(dependency)
+            shouldTraverse(dependency),
         )
         .map((dependency) =>
           visit(
             dependency.absolutePath,
-            resolutionResult.resolvedContexts.get(dependency.data.data.key)
-          ).catch((error) => errors.set(dependency.absolutePath, error))
-        )
+            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)
-      )
-    )
+        errors.set(absolutePath, error),
+      ),
+    ),
   );
   return {
     moduleData,

package/src/DeltaBundler/buildSubgraph.js.flow

@@ -16,7 +16,7 @@ import type {
   ResolveFn,
   TransformFn,
   TransformResultDependency,
-} from './types.flow';
+} from './types';
 
 import {deriveAbsolutePathFromContext} from '../lib/contextModule';
 import {isResolvedDependency} from '../lib/isResolvedDependency';

package/src/DeltaBundler/getTransformCacheKey.js

@@ -1,26 +1,32 @@
 "use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = getTransformCacheKey;
+var _crypto = _interopRequireDefault(require("crypto"));
+var _metroCacheKey = require("metro-cache-key");
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
 const VERSION = require("../../package.json").version;
-const crypto = require("crypto");
-const { getCacheKey } = require("metro-cache-key");
 function getTransformCacheKey(opts) {
   const { transformerPath, transformerConfig } = opts.transformerConfig;
   const Transformer = require.call(null, transformerPath);
   const transformerKey = Transformer.getCacheKey
     ? Transformer.getCacheKey(transformerConfig)
     : "";
-  return crypto
+  return _crypto.default
     .createHash("sha1")
     .update(
       [
         "metro-cache",
         VERSION,
         opts.cacheVersion,
-        getCacheKey([require.resolve(transformerPath)]),
+        (0, _metroCacheKey.getCacheKey)([require.resolve(transformerPath)]),
         transformerKey,
         transformerConfig.globalPrefix,
-      ].join("$")
+      ].join("$"),
     )
     .digest("hex");
 }
-module.exports = getTransformCacheKey;

package/src/DeltaBundler/getTransformCacheKey.js.flow

@@ -9,20 +9,20 @@
  * @oncall react_native
  */
 
-'use strict';
-
 import type {TransformerConfig} from './Worker';
 import type {JsTransformerConfig} from 'metro-transform-worker';
 
+import crypto from 'crypto';
+import {getCacheKey} from 'metro-cache-key';
+
+// eslint-disable-next-line import/no-commonjs
 const VERSION = require('../../package.json').version;
-const crypto = require('crypto');
-const {getCacheKey} = require('metro-cache-key');
 
 type CacheKeyProvider = {
   getCacheKey?: JsTransformerConfig => string,
 };
 
-function getTransformCacheKey(opts: {
+export default function getTransformCacheKey(opts: {
   +cacheVersion: string,
   +projectRoot: string,
   +transformerConfig: TransformerConfig,
@@ -49,5 +49,3 @@ function getTransformCacheKey(opts: {
     )
     .digest('hex');
 }
-
-module.exports = getTransformCacheKey;

package/src/DeltaBundler/mergeDeltas.js

@@ -1,5 +1,9 @@
 "use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = mergeDeltas;
 function mergeDeltas(delta1, delta2) {
   const added1 = new Map(delta1.added);
   const modified1 = new Map(delta1.modified);
@@ -50,4 +54,3 @@ function mergeDeltas(delta1, delta2) {
     deleted: [...deleted],
   };
 }
-module.exports = mergeDeltas;

package/src/DeltaBundler/mergeDeltas.js.flow

@@ -9,11 +9,12 @@
  * @oncall react_native
  */
 
-'use strict';
+import type {DeltaBundle} from 'metro-runtime/src/modules/types';
 
-import type {DeltaBundle} from 'metro-runtime/src/modules/types.flow';
-
-function mergeDeltas(delta1: DeltaBundle, delta2: DeltaBundle): DeltaBundle {
+export default function mergeDeltas(
+  delta1: DeltaBundle,
+  delta2: DeltaBundle,
+): DeltaBundle {
   const added1 = new Map(delta1.added);
   const modified1 = new Map(delta1.modified);
   const deleted1 = new Set(delta1.deleted);
@@ -70,5 +71,3 @@ function mergeDeltas(delta1: DeltaBundle, delta2: DeltaBundle): DeltaBundle {
     deleted: [...deleted],
   };
 }
-
-module.exports = mergeDeltas;

package/src/DeltaBundler/types.d.ts

@@ -148,7 +148,10 @@ export interface SerializerOptions<T = MixedOutput> {
   readonly asyncRequireModulePath: string;
   readonly createModuleId: (filePath: string) => number;
   readonly dev: boolean;
-  readonly getRunModuleStatement: (moduleId: string | number) => string;
+  readonly getRunModuleStatement: (
+    moduleId: number | string,
+    globalPrefix: string,
+  ) => string;
   readonly includeAsyncPaths: boolean;
   readonly inlineSourceMap?: boolean;
   readonly modulesOnly: boolean;

package/src/DeltaBundler/{types.flow.js → types.js}

@@ -2,9 +2,5 @@
 
 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.flow.js.flow → types.js.flow}

@@ -9,8 +9,6 @@
  * @oncall react_native
  */
 
-'use strict';
-
 import type {RequireContext} from '../lib/contextModule';
 import type {RequireContextParams} from '../ModuleGraph/worker/collectDependencies';
 import type {Graph} from './Graph';
@@ -170,7 +168,11 @@ export type SerializerOptions = $ReadOnly<{
   asyncRequireModulePath: string,
   createModuleId: string => number,
   dev: boolean,
-  getRunModuleStatement: (number | string) => string,
+  getRunModuleStatement: (
+    moduleId: number | string,
+    globalPrefix: string,
+  ) => string,
+  globalPrefix: string,
   includeAsyncPaths: boolean,
   inlineSourceMap: ?boolean,
   modulesOnly: boolean,

package/src/DeltaBundler.js

@@ -1,6 +1,15 @@
 "use strict";
 
-const DeltaCalculator = require("./DeltaBundler/DeltaCalculator");
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+var _DeltaCalculator = _interopRequireDefault(
+  require("./DeltaBundler/DeltaCalculator"),
+);
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
 class DeltaBundler {
   _deltaCalculators = new Map();
   constructor(changeEventSource) {
@@ -11,10 +20,10 @@ class DeltaBundler {
     this._deltaCalculators = new Map();
   }
   async getDependencies(entryPoints, options) {
-    const deltaCalculator = new DeltaCalculator(
+    const deltaCalculator = new _DeltaCalculator.default(
       new Set(entryPoints),
       this._changeEventSource,
-      options
+      options,
     );
     await deltaCalculator.getDelta({
       reset: true,
@@ -25,10 +34,10 @@ class DeltaBundler {
     return graph.dependencies;
   }
   async buildGraph(entryPoints, options) {
-    const deltaCalculator = new DeltaCalculator(
+    const deltaCalculator = new _DeltaCalculator.default(
       new Set(entryPoints),
       this._changeEventSource,
-      options
+      options,
     );
     await deltaCalculator.getDelta({
       reset: true,
@@ -67,4 +76,4 @@ class DeltaBundler {
     this._deltaCalculators.delete(graph);
   }
 }
-module.exports = DeltaBundler;
+exports.default = DeltaBundler;