metro 0.83.0 → 0.83.2

package/src/DeltaBundler/Serializers/hmrJSBundle.js

@@ -1,31 +1,74 @@
 "use strict";
 
-const { isJsModule, wrapModule } = require("./helpers/js");
-const jscSafeUrl = require("jsc-safe-url");
-const { addParamsToDefineCall } = require("metro-transform-plugins");
-const path = require("path");
-const url = require("url");
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = hmrJSBundle;
+var _js = require("./helpers/js");
+var jscSafeUrl = _interopRequireWildcard(require("jsc-safe-url"));
+var _metroTransformPlugins = require("metro-transform-plugins");
+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]);
+    }
+  return ((n.default = e), t && t.set(e, n), n);
+}
+const debug = require("debug")("Metro:HMR");
 function generateModules(sourceModules, graph, options) {
   const modules = [];
   for (const module of sourceModules) {
-    if (isJsModule(module)) {
-      const getURL = (extension) => {
-        const moduleUrl = url.parse(url.format(options.clientUrl), true);
-        moduleUrl.search = "";
-        moduleUrl.pathname = path.relative(
-          options.serverRoot ?? options.projectRoot,
-          path.join(
-            path.dirname(module.path),
-            path.basename(module.path, path.extname(module.path)) +
-              "." +
-              extension
+    if ((0, _js.isJsModule)(module)) {
+      const getPathname = (extension) => {
+        return _path.default
+          .relative(
+            options.serverRoot ?? options.projectRoot,
+            _path.default.join(
+              _path.default.dirname(module.path),
+              _path.default.basename(
+                module.path,
+                _path.default.extname(module.path),
+              ) +
+                "." +
+                extension,
+            ),
           )
-        );
-        delete moduleUrl.query.excludeSource;
-        return url.format(moduleUrl);
+          .split(_path.default.sep)
+          .map((segment) => encodeURIComponent(segment))
+          .join("/");
       };
-      const sourceMappingURL = getURL("map");
-      const sourceURL = jscSafeUrl.toJscSafeUrl(getURL("bundle"));
+      const clientUrl = new URL(options.clientUrl);
+      clientUrl.searchParams.delete("excludeSource");
+      clientUrl.pathname = getPathname("map");
+      const sourceMappingURL = clientUrl.toString();
+      clientUrl.pathname = getPathname("bundle");
+      const sourceURL = jscSafeUrl.toJscSafeUrl(clientUrl.toString());
+      debug(
+        "got sourceMappingURL: %s\nand sourceURL: %s\nfor module: %s",
+        sourceMappingURL,
+        sourceURL,
+        module.path,
+      );
       const code =
         prepareModule(module, graph, options) +
         `\n//# sourceMappingURL=${sourceMappingURL}\n` +
@@ -40,9 +83,9 @@ function generateModules(sourceModules, graph, options) {
   return modules;
 }
 function prepareModule(module, graph, options) {
-  const code = wrapModule(module, {
+  const code = (0, _js.wrapModule)(module, {
     ...options,
-    sourceUrl: url.format(options.clientUrl),
+    sourceUrl: options.clientUrl.toString(),
     dev: true,
   });
   const inverseDependencies = getInverseDependencies(module.path, graph);
@@ -52,7 +95,10 @@ function prepareModule(module, graph, options) {
       path
     ].map(options.createModuleId);
   });
-  return addParamsToDefineCall(code, inverseDependenciesById);
+  return (0, _metroTransformPlugins.addParamsToDefineCall)(
+    code,
+    inverseDependenciesById,
+  );
 }
 function getInverseDependencies(path, graph, inverseDependencies = {}) {
   if (path in inverseDependencies) {
@@ -76,4 +122,3 @@ function hmrJSBundle(delta, graph, options) {
     deleted: [...delta.deleted].map((path) => options.createModuleId(path)),
   };
 }
-module.exports = hmrJSBundle;

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

@@ -9,20 +9,19 @@
  * @oncall react_native
  */
 
-'use strict';
+import type {DeltaResult, Module, ReadOnlyGraph} from '../types';
+import type {HmrModule} from 'metro-runtime/src/modules/types';
 
-import type {EntryPointURL} from '../../HmrServer';
-import type {DeltaResult, Module, ReadOnlyGraph} from '../types.flow';
-import type {HmrModule} from 'metro-runtime/src/modules/types.flow';
+import {isJsModule, wrapModule} from './helpers/js';
+import * as jscSafeUrl from 'jsc-safe-url';
+import {addParamsToDefineCall} from 'metro-transform-plugins';
+import path from 'path';
 
-const {isJsModule, wrapModule} = require('./helpers/js');
-const jscSafeUrl = require('jsc-safe-url');
-const {addParamsToDefineCall} = require('metro-transform-plugins');
-const path = require('path');
-const url = require('url');
+// eslint-disable-next-line import/no-commonjs
+const debug = require('debug')('Metro:HMR');
 
 type Options = $ReadOnly<{
-  clientUrl: EntryPointURL,
+  clientUrl: URL,
   createModuleId: string => number,
   includeAsyncPaths: boolean,
   projectRoot: string,
@@ -39,28 +38,41 @@ function generateModules(
 
   for (const module of sourceModules) {
     if (isJsModule(module)) {
-      // Construct a bundle URL for this specific module only
-      const getURL = (extension: 'bundle' | 'map') => {
-        const moduleUrl = url.parse(url.format(options.clientUrl), true);
-        // the legacy url object is parsed with both "search" and "query" fields.
-        // for the "query" field to be used when formatting the object bach to string, the "search" field must be empty.
-        // https://nodejs.org/api/url.html#urlformaturlobject:~:text=If%20the%20urlObject.search%20property%20is%20undefined
-        moduleUrl.search = '';
-        moduleUrl.pathname = path.relative(
-          options.serverRoot ?? options.projectRoot,
-          path.join(
-            path.dirname(module.path),
-            path.basename(module.path, path.extname(module.path)) +
-              '.' +
-              extension,
-          ),
+      const getPathname = (extension: 'bundle' | 'map') => {
+        return (
+          path
+            .relative(
+              options.serverRoot ?? options.projectRoot,
+              path.join(
+                path.dirname(module.path),
+                path.basename(module.path, path.extname(module.path)) +
+                  '.' +
+                  extension,
+              ),
+            )
+            .split(path.sep)
+            // using this Metro particular convention for encoding file paths as URL paths.
+            .map(segment => encodeURIComponent(segment))
+            .join('/')
         );
-        delete moduleUrl.query.excludeSource;
-        return url.format(moduleUrl);
       };
 
-      const sourceMappingURL = getURL('map');
-      const sourceURL = jscSafeUrl.toJscSafeUrl(getURL('bundle'));
+      const clientUrl = new URL(options.clientUrl);
+      clientUrl.searchParams.delete('excludeSource');
+
+      clientUrl.pathname = getPathname('map');
+      const sourceMappingURL = clientUrl.toString();
+
+      clientUrl.pathname = getPathname('bundle');
+      const sourceURL = jscSafeUrl.toJscSafeUrl(clientUrl.toString());
+
+      debug(
+        'got sourceMappingURL: %s\nand sourceURL: %s\nfor module: %s',
+        sourceMappingURL,
+        sourceURL,
+        module.path,
+      );
+
       const code =
         prepareModule(module, graph, options) +
         `\n//# sourceMappingURL=${sourceMappingURL}\n` +
@@ -84,7 +96,7 @@ function prepareModule(
 ): string {
   const code = wrapModule(module, {
     ...options,
-    sourceUrl: url.format(options.clientUrl),
+    sourceUrl: options.clientUrl.toString(),
     dev: true,
   });
 
@@ -131,7 +143,7 @@ function getInverseDependencies(
   return inverseDependencies;
 }
 
-function hmrJSBundle(
+export default function hmrJSBundle(
   delta: DeltaResult<>,
   graph: ReadOnlyGraph<>,
   options: Options,
@@ -148,5 +160,3 @@ function hmrJSBundle(
     ),
   };
 }
-
-module.exports = hmrJSBundle;

package/src/DeltaBundler/Serializers/sourceMapGenerator.js

@@ -1,22 +1,29 @@
 "use strict";
 
-const getSourceMapInfo = require("./helpers/getSourceMapInfo");
-const { isJsModule } = require("./helpers/js");
-const {
-  fromRawMappings,
-  fromRawMappingsNonBlocking,
-} = require("metro-source-map");
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.sourceMapGenerator = sourceMapGenerator;
+exports.sourceMapGeneratorNonBlocking = sourceMapGeneratorNonBlocking;
+var _getSourceMapInfo = _interopRequireDefault(
+  require("./helpers/getSourceMapInfo"),
+);
+var _js = require("./helpers/js");
+var _metroSourceMap = require("metro-source-map");
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
 function getSourceMapInfosImpl(isBlocking, onDone, modules, options) {
   const sourceMapInfos = [];
   const modulesToProcess = modules
-    .filter(isJsModule)
+    .filter(_js.isJsModule)
     .filter(options.processModuleFilter);
   function processNextModule() {
     if (modulesToProcess.length === 0) {
       return true;
     }
     const mod = modulesToProcess.shift();
-    const info = getSourceMapInfo(mod, {
+    const info = (0, _getSourceMapInfo.default)(mod, {
       excludeSource: options.excludeSource,
       shouldAddToIgnoreList: options.shouldAddToIgnoreList,
       getSourceUrl: options.getSourceUrl,
@@ -52,22 +59,18 @@ function sourceMapGenerator(modules, options) {
       sourceMapInfos = infos;
     },
     modules,
-    options
+    options,
   );
   if (sourceMapInfos == null) {
     throw new Error(
-      "Expected getSourceMapInfosImpl() to finish synchronously."
+      "Expected getSourceMapInfosImpl() to finish synchronously.",
     );
   }
-  return fromRawMappings(sourceMapInfos);
+  return (0, _metroSourceMap.fromRawMappings)(sourceMapInfos);
 }
 async function sourceMapGeneratorNonBlocking(modules, options) {
   const sourceMapInfos = await new Promise((resolve) => {
     getSourceMapInfosImpl(false, resolve, modules, options);
   });
-  return fromRawMappingsNonBlocking(sourceMapInfos);
+  return (0, _metroSourceMap.fromRawMappingsNonBlocking)(sourceMapInfos);
 }
-module.exports = {
-  sourceMapGenerator,
-  sourceMapGeneratorNonBlocking,
-};

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

@@ -9,16 +9,11 @@
  * @oncall react_native
  */
 
-'use strict';
+import type {Module} from '../types';
 
-import type {Module} from '../types.flow';
-
-const getSourceMapInfo = require('./helpers/getSourceMapInfo');
-const {isJsModule} = require('./helpers/js');
-const {
-  fromRawMappings,
-  fromRawMappingsNonBlocking,
-} = require('metro-source-map');
+import getSourceMapInfo from './helpers/getSourceMapInfo';
+import {isJsModule} from './helpers/js';
+import {fromRawMappings, fromRawMappingsNonBlocking} from 'metro-source-map';
 
 export type SourceMapGeneratorOptions = $ReadOnly<{
   excludeSource: boolean,
@@ -44,7 +39,7 @@ function getSourceMapInfosImpl(
     }
 
     const mod = modulesToProcess.shift();
-    // $FlowFixMe[incompatible-call]
+    // $FlowFixMe[incompatible-type]
     const info = getSourceMapInfo(mod, {
       excludeSource: options.excludeSource,
       shouldAddToIgnoreList: options.shouldAddToIgnoreList,
@@ -113,7 +108,4 @@ async function sourceMapGeneratorNonBlocking(
   return fromRawMappingsNonBlocking(sourceMapInfos);
 }
 
-module.exports = {
-  sourceMapGenerator,
-  sourceMapGeneratorNonBlocking,
-};
+export {sourceMapGenerator, sourceMapGeneratorNonBlocking};

package/src/DeltaBundler/Serializers/sourceMapObject.js

@@ -1,22 +1,24 @@
 "use strict";
 
-const {
-  sourceMapGenerator,
-  sourceMapGeneratorNonBlocking,
-} = require("./sourceMapGenerator");
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.sourceMapObject = sourceMapObject;
+exports.sourceMapObjectNonBlocking = sourceMapObjectNonBlocking;
+var _sourceMapGenerator = require("./sourceMapGenerator");
 function sourceMapObject(modules, options) {
-  const generator = sourceMapGenerator(modules, options);
+  const generator = (0, _sourceMapGenerator.sourceMapGenerator)(
+    modules,
+    options,
+  );
   return generator.toMap(undefined, {
     excludeSource: options.excludeSource,
   });
 }
 async function sourceMapObjectNonBlocking(modules, options) {
-  const generator = await sourceMapGeneratorNonBlocking(modules, options);
+  const generator = await (0,
+  _sourceMapGenerator.sourceMapGeneratorNonBlocking)(modules, options);
   return generator.toMap(undefined, {
     excludeSource: options.excludeSource,
   });
 }
-module.exports = {
-  sourceMapObject,
-  sourceMapObjectNonBlocking,
-};

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

@@ -9,16 +9,14 @@
  * @oncall react_native
  */
 
-'use strict';
-
-import type {Module} from '../types.flow';
+import type {Module} from '../types';
 import type {SourceMapGeneratorOptions} from './sourceMapGenerator';
 import type {MixedSourceMap} from 'metro-source-map';
 
-const {
+import {
   sourceMapGenerator,
   sourceMapGeneratorNonBlocking,
-} = require('./sourceMapGenerator');
+} from './sourceMapGenerator';
 
 function sourceMapObject(
   modules: $ReadOnlyArray<Module<>>,
@@ -40,7 +38,4 @@ async function sourceMapObjectNonBlocking(
   });
 }
 
-module.exports = {
-  sourceMapObject,
-  sourceMapObjectNonBlocking,
-};
+export {sourceMapObject, sourceMapObjectNonBlocking};

package/src/DeltaBundler/Serializers/sourceMapString.js

@@ -1,21 +1,23 @@
 "use strict";
 
-const {
-  sourceMapGenerator,
-  sourceMapGeneratorNonBlocking,
-} = require("./sourceMapGenerator");
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.sourceMapString = sourceMapString;
+exports.sourceMapStringNonBlocking = sourceMapStringNonBlocking;
+var _sourceMapGenerator = require("./sourceMapGenerator");
 function sourceMapString(modules, options) {
-  return sourceMapGenerator(modules, options).toString(undefined, {
-    excludeSource: options.excludeSource,
-  });
+  return (0, _sourceMapGenerator.sourceMapGenerator)(modules, options).toString(
+    undefined,
+    {
+      excludeSource: options.excludeSource,
+    },
+  );
 }
 async function sourceMapStringNonBlocking(modules, options) {
-  const generator = await sourceMapGeneratorNonBlocking(modules, options);
+  const generator = await (0,
+  _sourceMapGenerator.sourceMapGeneratorNonBlocking)(modules, options);
   return generator.toString(undefined, {
     excludeSource: options.excludeSource,
   });
 }
-module.exports = {
-  sourceMapString,
-  sourceMapStringNonBlocking,
-};

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

@@ -9,15 +9,13 @@
  * @oncall react_native
  */
 
-'use strict';
-
-import type {Module} from '../types.flow';
+import type {Module} from '../types';
 import type {SourceMapGeneratorOptions} from './sourceMapGenerator';
 
-const {
+import {
   sourceMapGenerator,
   sourceMapGeneratorNonBlocking,
-} = require('./sourceMapGenerator');
+} from './sourceMapGenerator';
 
 function sourceMapString(
   modules: $ReadOnlyArray<Module<>>,
@@ -38,7 +36,4 @@ async function sourceMapStringNonBlocking(
   });
 }
 
-module.exports = {
-  sourceMapString,
-  sourceMapStringNonBlocking,
-};
+export {sourceMapString, sourceMapStringNonBlocking};

package/src/DeltaBundler/Transformer.js

@@ -1,25 +1,28 @@
 "use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+var _pathUtils = require("../lib/pathUtils");
+var _getTransformCacheKey = _interopRequireDefault(
+  require("./getTransformCacheKey"),
+);
+var _WorkerFarm = _interopRequireDefault(require("./WorkerFarm"));
+var _assert = _interopRequireDefault(require("assert"));
 var _crypto = _interopRequireDefault(require("crypto"));
+var _fs = _interopRequireDefault(require("fs"));
+var _metroCache = require("metro-cache");
+var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
-const getTransformCacheKey = require("./getTransformCacheKey");
-const WorkerFarm = require("./WorkerFarm");
-const assert = require("assert");
 const debug = require("debug")("Metro:Transformer");
-const fs = require("fs");
-const { Cache, stableHash } = require("metro-cache");
-const path = require("path");
 class Transformer {
   constructor(config, opts) {
     this._config = config;
     this._config.watchFolders.forEach(verifyRootExists);
-    this._cache = new Cache(config.cacheStores);
+    this._cache = new _metroCache.Cache(config.cacheStores);
     this._getSha1 = opts.getOrComputeSha1;
     const {
       getTransformOptions: _getTransformOptions,
@@ -31,15 +34,15 @@ class Transformer {
       transformerPath: this._config.transformerPath,
       transformerConfig,
     };
-    this._workerFarm = new WorkerFarm(config, transformerOptions);
+    this._workerFarm = new _WorkerFarm.default(config, transformerOptions);
     const globalCacheKey = this._cache.isDisabled
       ? ""
-      : getTransformCacheKey({
+      : (0, _getTransformCacheKey.default)({
           cacheVersion: this._config.cacheVersion,
           projectRoot: this._config.projectRoot,
           transformerConfig: transformerOptions,
         });
-    const baseHashBuffer = stableHash([globalCacheKey]);
+    const baseHashBuffer = (0, _metroCache.stableHash)([globalCacheKey]);
     this._baseHash = baseHashBuffer.toString("binary");
     debug("Base hash: %s", baseHashBuffer.toString("hex"));
   }
@@ -49,14 +52,12 @@ class Transformer {
       customTransformOptions,
       dev,
       experimentalImportSupport,
-      hot,
       inlinePlatform,
       inlineRequires,
       minify,
       nonInlinedRequires,
       platform,
       type,
-      unstable_disableES6Transforms,
       unstable_transformProfile,
       unstable_memoizeInlineRequires,
       unstable_nonMemoizedInlineRequires,
@@ -65,25 +66,26 @@ class Transformer {
     for (const key in extra) {
       if (hasOwnProperty.call(extra, key)) {
         throw new Error(
-          "Extra keys detected: " + Object.keys(extra).join(", ")
+          "Extra keys detected: " + Object.keys(extra).join(", "),
         );
       }
     }
-    const localPath = path.relative(this._config.projectRoot, filePath);
-    const partialKey = stableHash([
+    const localPath = _path.default.relative(
+      this._config.projectRoot,
+      filePath,
+    );
+    const partialKey = (0, _metroCache.stableHash)([
       this._baseHash,
-      path.sep === "/" ? localPath : localPath.replaceAll(path.sep, "/"),
+      (0, _pathUtils.normalizePathSeparatorsToPosix)(localPath),
       customTransformOptions,
       dev,
       experimentalImportSupport,
-      hot,
       inlinePlatform,
       inlineRequires,
       minify,
       nonInlinedRequires,
       platform,
       type,
-      unstable_disableES6Transforms,
       unstable_memoizeInlineRequires,
       unstable_nonMemoizedInlineRequires,
       unstable_transformProfile,
@@ -122,7 +124,7 @@ class Transformer {
       : await this._workerFarm.transform(
           localPath,
           transformerOptions,
-          content
+          content,
         );
     if (sha1 !== data.sha1) {
       fullKey = Buffer.concat([partialKey, Buffer.from(data.sha1, "hex")]);
@@ -140,7 +142,7 @@ class Transformer {
         if (fileBuffer) {
           return fileBuffer;
         }
-        return fs.readFileSync(filePath);
+        return _fs.default.readFileSync(filePath);
       },
     };
   }
@@ -148,7 +150,10 @@ class Transformer {
     await this._workerFarm.kill();
   }
 }
+exports.default = Transformer;
 function verifyRootExists(root) {
-  assert(fs.statSync(root).isDirectory(), "Root has to be a valid directory");
+  (0, _assert.default)(
+    _fs.default.statSync(root).isDirectory(),
+    "Root has to be a valid directory",
+  );
 }
-module.exports = Transformer;