metro 0.83.0 → 0.83.2

package/src/commands/dependencies.js

@@ -1,22 +1,29 @@
 "use strict";
 
-const { makeAsyncCommand } = require("../cli-utils");
-const Server = require("../Server");
-const fs = require("fs");
-const { loadConfig } = require("metro-config");
-const path = require("path");
-const { promisify } = require("util");
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+var _cliUtils = require("../cli-utils");
+var _Server = _interopRequireDefault(require("../Server"));
+var _fs = _interopRequireDefault(require("fs"));
+var _metroConfig = require("metro-config");
+var _path = _interopRequireDefault(require("path"));
+var _util = require("util");
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
 async function dependencies(args, config) {
   const rootModuleAbsolutePath = args.entryFile;
-  if (!fs.existsSync(rootModuleAbsolutePath)) {
+  if (!_fs.default.existsSync(rootModuleAbsolutePath)) {
     return Promise.reject(
-      new Error(`File ${rootModuleAbsolutePath} does not exist`)
+      new Error(`File ${rootModuleAbsolutePath} does not exist`),
     );
   }
   config.cacheStores = [];
-  const relativePath = path.relative(
+  const relativePath = _path.default.relative(
     config.server.unstable_serverRoot ?? config.projectRoot,
-    rootModuleAbsolutePath
+    rootModuleAbsolutePath,
   );
   const options = {
     platform: args.platform,
@@ -26,8 +33,10 @@ async function dependencies(args, config) {
     generateSourceMaps: !args.dev,
   };
   const outStream =
-    args.output != null ? fs.createWriteStream(args.output) : process.stdout;
-  const server = new Server(config);
+    args.output != null
+      ? _fs.default.createWriteStream(args.output)
+      : process.stdout;
+  const server = new _Server.default(config);
   try {
     const deps = await server.getOrderedDependencyPaths(options);
     deps.forEach((modulePath) => {
@@ -42,10 +51,10 @@ async function dependencies(args, config) {
     await server.end();
   }
   return args.output != null
-    ? promisify(outStream.end).bind(outStream)()
+    ? (0, _util.promisify)(outStream.end).bind(outStream)()
     : Promise.resolve();
 }
-module.exports = () => ({
+var _default = () => ({
   command: "get-dependencies [entryFile]",
   desc: "List all dependencies that will be bundled for a given entry point",
   builder: (yargs) => {
@@ -85,8 +94,9 @@ module.exports = () => ({
       description: "Enables logging",
     });
   },
-  handler: makeAsyncCommand(async (argv) => {
-    const config = await loadConfig(argv);
+  handler: (0, _cliUtils.makeAsyncCommand)(async (argv) => {
+    const config = await (0, _metroConfig.loadConfig)(argv);
     await dependencies(argv, config);
   }),
 });
+exports.default = _default;

package/src/commands/dependencies.js.flow

@@ -9,18 +9,16 @@
  * @oncall react_native
  */
 
-'use strict';
-
 import type {ConfigT} from 'metro-config';
 import type {ModuleObject} from 'yargs';
 import typeof Yargs from 'yargs';
 
-const {makeAsyncCommand} = require('../cli-utils');
-const Server = require('../Server');
-const fs = require('fs');
-const {loadConfig} = require('metro-config');
-const path = require('path');
-const {promisify} = require('util');
+import {makeAsyncCommand} from '../cli-utils';
+import Server from '../Server';
+import fs from 'fs';
+import {loadConfig} from 'metro-config';
+import path from 'path';
+import {promisify} from 'util';
 
 type Args = $ReadOnly<{
   entryFile: string,
@@ -84,7 +82,7 @@ async function dependencies(args: Args, config: ConfigT) {
     : Promise.resolve();
 }
 
-module.exports = (): {...ModuleObject, handler: Function} => ({
+export default (): {...ModuleObject, handler: Function} => ({
   command: 'get-dependencies [entryFile]',
   desc: 'List all dependencies that will be bundled for a given entry point',
   builder: (yargs: Yargs) => {

package/src/commands/serve.js

@@ -1,9 +1,13 @@
 "use strict";
 
-const { makeAsyncCommand, watchFile } = require("../cli-utils");
-const { loadConfig, resolveConfig } = require("metro-config");
-const { promisify } = require("util");
-module.exports = () => ({
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+var _cliUtils = require("../cli-utils");
+var _metroConfig = require("metro-config");
+var _util = require("util");
+var _default = () => ({
   command: "serve",
   aliases: ["start"],
   desc: "Starts Metro on the given port, building bundles on the fly",
@@ -57,10 +61,10 @@ module.exports = () => ({
     });
     yargs.example(
       "secure-server-options",
-      '-s.cert="$(cat path/to/cert)" -s.key="$(cat path/to/key")'
+      '-s.cert="$(cat path/to/cert)" -s.key="$(cat path/to/key")',
     );
   },
-  handler: makeAsyncCommand(async (argv) => {
+  handler: (0, _cliUtils.makeAsyncCommand)(async (argv) => {
     let server = null;
     let restarting = false;
     async function restart() {
@@ -71,9 +75,9 @@ module.exports = () => ({
       }
       if (server) {
         console.log("Configuration changed. Restarting the server...");
-        await promisify(server.close).call(server);
+        await (0, _util.promisify)(server.close).call(server);
       }
-      const config = await loadConfig(argv);
+      const config = await (0, _metroConfig.loadConfig)(argv);
       const MetroApi = require("../index");
       const {
         config: _config,
@@ -86,15 +90,16 @@ module.exports = () => ({
       } = argv;
       ({ httpServer: server } = await MetroApi.runServer(
         config,
-        runServerOptions
+        runServerOptions,
       ));
       restarting = false;
     }
-    const foundConfig = await resolveConfig(argv.config);
+    const foundConfig = await (0, _metroConfig.resolveConfig)(argv.config);
     if (foundConfig) {
-      await watchFile(foundConfig.filepath, restart);
+      await (0, _cliUtils.watchFile)(foundConfig.filepath, restart);
     } else {
       await restart();
     }
   }),
 });
+exports.default = _default;

package/src/commands/serve.js.flow

@@ -9,14 +9,12 @@
  * @oncall react_native
  */
 
-'use strict';
-
 import type {ModuleObject} from 'yargs';
 import typeof Yargs from 'yargs';
 
-const {makeAsyncCommand, watchFile} = require('../cli-utils');
-const {loadConfig, resolveConfig} = require('metro-config');
-const {promisify} = require('util');
+import {makeAsyncCommand, watchFile} from '../cli-utils';
+import {loadConfig, resolveConfig} from 'metro-config';
+import {promisify} from 'util';
 
 type Args = $ReadOnly<{
   projectRoots?: $ReadOnlyArray<string>,
@@ -32,7 +30,7 @@ type Args = $ReadOnly<{
   resetCache?: boolean,
 }>;
 
-module.exports = (): {
+export default (): {
   ...ModuleObject,
   handler: Function,
 } => ({
@@ -96,6 +94,7 @@ module.exports = (): {
       const config = await loadConfig(argv);
 
       // Inline require() to avoid circular dependency with ../index
+      // eslint-disable-next-line import/no-commonjs
       const MetroApi = require('../index');
 
       const {

package/src/index.d.ts

@@ -32,11 +32,12 @@ import type {
 import type {Duplex} from 'stream';
 import type Yargs from 'yargs';
 
-export {loadConfig, mergeConfig, resolveConfig} from 'metro-config';
-export {Terminal} from 'metro-core';
-export {TerminalReporter} from './lib/TerminalReporter';
+import {TerminalReporter} from './lib/TerminalReporter';
+import {loadConfig, mergeConfig, resolveConfig} from 'metro-config';
+import {Terminal} from 'metro-core';
 
 export {HttpServer, HttpsServer};
+export {loadConfig, mergeConfig, resolveConfig, Terminal, TerminalReporter};
 
 interface MetroMiddleWare {
   attachHmrServer: (httpServer: HttpServer | HttpsServer) => void;
@@ -168,3 +169,25 @@ export function attachMetroCli(
   yargs: Yargs.Argv,
   options?: AttachMetroCLIOptions,
 ): Yargs.Argv;
+
+/**
+ * Backwards-compatibility with CommonJS consumers using interopRequireDefault.
+ * Do not add to this list.
+ *
+ * @deprecated Default import from 'metro' is deprecated, use named exports.
+ */
+declare const $$EXPORT_DEFAULT_DECLARATION$$: {
+  attachMetroCli: typeof attachMetroCli;
+  runServer: typeof runServer;
+  Terminal: typeof Terminal;
+  TerminalReporter: typeof TerminalReporter;
+  loadConfig: typeof loadConfig;
+  mergeConfig: typeof mergeConfig;
+  resolveConfig: typeof resolveConfig;
+  createConnectMiddleware: typeof createConnectMiddleware;
+  runBuild: typeof runBuild;
+  buildGraph: typeof buildGraph;
+};
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
+export default $$EXPORT_DEFAULT_DECLARATION$$;

package/src/index.flow.js

@@ -1,35 +1,108 @@
 "use strict";
 
-const makeBuildCommand = require("./commands/build");
-const makeDependenciesCommand = require("./commands/dependencies");
-const makeServeCommand = require("./commands/serve");
-const MetroHmrServer = require("./HmrServer");
-const IncrementalBundler = require("./IncrementalBundler");
-const createWebsocketServer = require("./lib/createWebsocketServer");
-const JsonReporter = require("./lib/JsonReporter");
-const TerminalReporter = require("./lib/TerminalReporter");
-const MetroServer = require("./Server");
-const outputBundle = require("./shared/output/bundle");
-const chalk = require("chalk");
-const fs = require("fs");
-const http = require("http");
-const https = require("https");
-const {
-  getDefaultConfig,
-  loadConfig,
-  mergeConfig,
-  resolveConfig,
-} = require("metro-config");
-const { Terminal } = require("metro-core");
-const net = require("net");
-const nullthrows = require("nullthrows");
-const { parse } = require("url");
-exports.Terminal = Terminal;
-exports.JsonReporter = JsonReporter;
-exports.TerminalReporter = TerminalReporter;
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+Object.defineProperty(exports, "JsonReporter", {
+  enumerable: true,
+  get: function () {
+    return _JsonReporter.default;
+  },
+});
+Object.defineProperty(exports, "Terminal", {
+  enumerable: true,
+  get: function () {
+    return _metroCore.Terminal;
+  },
+});
+Object.defineProperty(exports, "TerminalReporter", {
+  enumerable: true,
+  get: function () {
+    return _TerminalReporter.default;
+  },
+});
+exports.default =
+  exports.createConnectMiddleware =
+  exports.buildGraph =
+  exports.attachMetroCli =
+    void 0;
+Object.defineProperty(exports, "loadConfig", {
+  enumerable: true,
+  get: function () {
+    return _metroConfig.loadConfig;
+  },
+});
+Object.defineProperty(exports, "mergeConfig", {
+  enumerable: true,
+  get: function () {
+    return _metroConfig.mergeConfig;
+  },
+});
+Object.defineProperty(exports, "resolveConfig", {
+  enumerable: true,
+  get: function () {
+    return _metroConfig.resolveConfig;
+  },
+});
+exports.runBuild = void 0;
+exports.runMetro = runMetro;
+exports.runServer = void 0;
+var _build = _interopRequireDefault(require("./commands/build"));
+var _dependencies = _interopRequireDefault(require("./commands/dependencies"));
+var _serve = _interopRequireDefault(require("./commands/serve"));
+var _HmrServer = _interopRequireDefault(require("./HmrServer"));
+var _IncrementalBundler = _interopRequireDefault(
+  require("./IncrementalBundler"),
+);
+var _createWebsocketServer = _interopRequireDefault(
+  require("./lib/createWebsocketServer"),
+);
+var _JsonReporter = _interopRequireDefault(require("./lib/JsonReporter"));
+var _TerminalReporter = _interopRequireDefault(
+  require("./lib/TerminalReporter"),
+);
+var _Server = _interopRequireDefault(require("./Server"));
+var outputBundle = _interopRequireWildcard(require("./shared/output/bundle"));
+var _chalk = _interopRequireDefault(require("chalk"));
+var _fs = _interopRequireDefault(require("fs"));
+var _http = _interopRequireDefault(require("http"));
+var _https = _interopRequireDefault(require("https"));
+var _metroConfig = require("metro-config");
+var _metroCore = require("metro-core");
+var _net = _interopRequireDefault(require("net"));
+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]);
+    }
+  return ((n.default = e), t && t.set(e, n), n);
+}
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+const DEFAULTS = _Server.default.DEFAULT_BUNDLE_OPTIONS;
 async function getConfig(config) {
-  const defaultConfig = await getDefaultConfig(config.projectRoot);
-  return mergeConfig(defaultConfig, config);
+  const defaultConfig = await (0, _metroConfig.getDefaultConfig)(
+    config.projectRoot,
+  );
+  return (0, _metroConfig.mergeConfig)(defaultConfig, config);
 }
 async function runMetro(config, options) {
   const mergedConfig = await getConfig(config);
@@ -45,7 +118,7 @@ async function runMetro(config, options) {
     type: "initialize_started",
   });
   const { waitForBundler = false, ...serverOptions } = options ?? {};
-  const server = new MetroServer(mergedConfig, serverOptions);
+  const server = new _Server.default(mergedConfig, serverOptions);
   const readyPromise = server
     .ready()
     .then(() => {
@@ -66,30 +139,26 @@ async function runMetro(config, options) {
   }
   return server;
 }
-exports.runMetro = runMetro;
-exports.loadConfig = loadConfig;
-exports.mergeConfig = mergeConfig;
-exports.resolveConfig = resolveConfig;
 const createConnectMiddleware = async function (config, options) {
   const metroServer = await runMetro(config, options);
   let enhancedMiddleware = metroServer.processRequest;
   if (config.server.enhanceMiddleware) {
     enhancedMiddleware = config.server.enhanceMiddleware(
       enhancedMiddleware,
-      metroServer
+      metroServer,
     );
   }
   return {
     attachHmrServer(httpServer) {
-      const wss = createWebsocketServer({
-        websocketServer: new MetroHmrServer(
+      const wss = (0, _createWebsocketServer.default)({
+        websocketServer: new _HmrServer.default(
           metroServer.getBundler(),
           metroServer.getCreateModuleId(),
-          config
+          config,
         ),
       });
       httpServer.on("upgrade", (request, socket, head) => {
-        const { pathname } = parse(request.url);
+        const { pathname } = new URL(request.url, "resolve://");
         if (pathname === "/hot") {
           wss.handleUpgrade(request, socket, head, (ws) => {
             wss.emit("connection", ws, request);
@@ -107,7 +176,7 @@ const createConnectMiddleware = async function (config, options) {
   };
 };
 exports.createConnectMiddleware = createConnectMiddleware;
-exports.runServer = async (
+const runServer = async (
   config,
   {
     hasReducedPerformance = false,
@@ -123,15 +192,15 @@ exports.runServer = async (
     waitForBundler = false,
     websocketEndpoints = {},
     watch,
-  } = {}
+  } = {},
 ) => {
   await earlyPortCheck(host, config.server.port);
   if (secure != null || secureCert != null || secureKey != null) {
     console.warn(
-      chalk.inverse.yellow.bold(" DEPRECATED "),
+      _chalk.default.inverse.yellow.bold(" DEPRECATED "),
       "The `secure`, `secureCert`, and `secureKey` options are now deprecated. " +
         "Please use the `secureServerOptions` object instead to pass options to " +
-        "Metro's https development server."
+        "Metro's https development server.",
     );
   }
   const connect = require("connect");
@@ -154,14 +223,14 @@ exports.runServer = async (
     let options = secureServerOptions;
     if (typeof secureKey === "string" && typeof secureCert === "string") {
       options = {
-        key: fs.readFileSync(secureKey),
-        cert: fs.readFileSync(secureCert),
+        key: _fs.default.readFileSync(secureKey),
+        cert: _fs.default.readFileSync(secureCert),
         ...secureServerOptions,
       };
     }
-    httpServer = https.createServer(options, serverApp);
+    httpServer = _https.default.createServer(options, serverApp);
   } else {
-    httpServer = http.createServer(serverApp);
+    httpServer = _http.default.createServer(serverApp);
   }
   return new Promise((resolve, reject) => {
     httpServer.on("error", (error) => {
@@ -180,16 +249,16 @@ exports.runServer = async (
       });
       websocketEndpoints = {
         ...websocketEndpoints,
-        "/hot": createWebsocketServer({
-          websocketServer: new MetroHmrServer(
+        "/hot": (0, _createWebsocketServer.default)({
+          websocketServer: new _HmrServer.default(
             metroServer.getBundler(),
             metroServer.getCreateModuleId(),
-            config
+            config,
           ),
         }),
       };
       httpServer.on("upgrade", (request, socket, head) => {
-        const { pathname } = parse(request.url);
+        const { pathname } = new URL(request.url, "resolve://");
         if (pathname != null && websocketEndpoints[pathname]) {
           websocketEndpoints[pathname].handleUpgrade(
             request,
@@ -197,7 +266,7 @@ exports.runServer = async (
             head,
             (ws) => {
               websocketEndpoints[pathname].emit("connection", ws, request);
-            }
+            },
           );
         } else {
           socket.destroy();
@@ -218,12 +287,13 @@ exports.runServer = async (
     });
   });
 };
-exports.runBuild = async (
+exports.runServer = runServer;
+const runBuild = async (
   config,
   {
     assets = false,
-    customResolverOptions,
-    customTransformOptions,
+    customResolverOptions = DEFAULTS.customResolverOptions,
+    customTransformOptions = DEFAULTS.customTransformOptions,
     dev = false,
     entry,
     onBegin,
@@ -237,8 +307,8 @@ exports.runBuild = async (
     platform = "web",
     sourceMap = false,
     sourceMapUrl,
-    unstable_transformProfile,
-  }
+    unstable_transformProfile = DEFAULTS.unstable_transformProfile,
+  },
 ) => {
   const metroServer = await runMetro(config, {
     watch: false,
@@ -250,7 +320,11 @@ exports.runBuild = async (
       inlineSourceMap: sourceMap && !sourceMapUrl,
       minify,
       platform,
-      sourceMapUrl: sourceMap === false ? undefined : sourceMapUrl,
+      ...(sourceMap === false
+        ? {}
+        : {
+            sourceMapUrl,
+          }),
       createModuleIdFactory: config.serializer.createModuleIdFactory,
       onProgress,
       customResolverOptions,
@@ -268,7 +342,7 @@ exports.runBuild = async (
     };
     if (assets && result.assets == null) {
       result.assets = await metroServer.getAssets({
-        ...MetroServer.DEFAULT_BUNDLE_OPTIONS,
+        ..._Server.default.DEFAULT_BUNDLE_OPTIONS,
         ...requestOptions,
       });
     }
@@ -277,11 +351,11 @@ exports.runBuild = async (
     }
     if (out || bundleOut) {
       const bundleOutput =
-        bundleOut ?? nullthrows(out).replace(/(\.js)?$/, ".js");
+        bundleOut ?? (0, _nullthrows.default)(out).replace(/(\.js)?$/, ".js");
       const sourcemapOutput =
         sourceMap === false
           ? undefined
-          : sourceMapOut ?? out?.replace(/(\.js)?$/, ".map");
+          : (sourceMapOut ?? out?.replace(/(\.js)?$/, ".map"));
       const outputOptions = {
         bundleOutput,
         sourcemapOutput,
@@ -292,7 +366,7 @@ exports.runBuild = async (
         config.reporter.update({
           type: "bundle_save_log",
           message,
-        })
+        }),
       );
     }
     return result;
@@ -300,7 +374,8 @@ exports.runBuild = async (
     await metroServer.end();
   }
 };
-exports.buildGraph = async function (
+exports.runBuild = runBuild;
+const buildGraph = async function (
   config,
   {
     customTransformOptions = Object.create(null),
@@ -310,13 +385,13 @@ exports.buildGraph = async function (
     onProgress,
     platform = "web",
     type = "module",
-  }
+  },
 ) {
   const mergedConfig = await getConfig(config);
-  const bundler = new IncrementalBundler(mergedConfig);
+  const bundler = new _IncrementalBundler.default(mergedConfig);
   try {
     const { customResolverOptions, ...defaultTransformInputOptions } =
-      MetroServer.DEFAULT_GRAPH_OPTIONS;
+      _Server.default.DEFAULT_GRAPH_OPTIONS;
     return await bundler.buildGraphForEntries(
       entries,
       {
@@ -330,28 +405,30 @@ exports.buildGraph = async function (
       {
         customResolverOptions,
         dev,
-      }
+      },
     );
   } finally {
     await bundler.end();
   }
 };
-exports.attachMetroCli = function (yargs, options = {}) {
+exports.buildGraph = buildGraph;
+const attachMetroCli = function (yargs, options = {}) {
   const { build = {}, serve = {}, dependencies = {} } = options;
   yargs.strict();
   if (build) {
-    yargs.command(makeBuildCommand());
+    yargs.command((0, _build.default)());
   }
   if (serve) {
-    yargs.command(makeServeCommand());
+    yargs.command((0, _serve.default)());
   }
   if (dependencies) {
-    yargs.command(makeDependenciesCommand());
+    yargs.command((0, _dependencies.default)());
   }
   return yargs;
 };
+exports.attachMetroCli = attachMetroCli;
 async function earlyPortCheck(host, port) {
-  const server = net.createServer((c) => c.end());
+  const server = _net.default.createServer((c) => c.end());
   try {
     await new Promise((resolve, reject) => {
       server.on("error", (err) => {
@@ -363,3 +440,16 @@ async function earlyPortCheck(host, port) {
     await new Promise((resolve) => server.close(() => resolve()));
   }
 }
+var _default = (exports.default = {
+  attachMetroCli,
+  runServer,
+  Terminal: _metroCore.Terminal,
+  JsonReporter: _JsonReporter.default,
+  TerminalReporter: _TerminalReporter.default,
+  loadConfig: _metroConfig.loadConfig,
+  mergeConfig: _metroConfig.mergeConfig,
+  resolveConfig: _metroConfig.resolveConfig,
+  createConnectMiddleware,
+  runBuild,
+  buildGraph,
+});