metro 0.71.0 → 0.71.1

package/src/index.js.flow

@@ -10,471 +10,13 @@
 
 'use strict';
 
-import type {Graph} from './DeltaBundler';
-import type {ServerOptions} from './Server';
-import type {OutputOptions, RequestOptions} from './shared/types.flow.js';
-import type {Server as HttpServer} from 'http';
-import type {Server as HttpsServer} from 'https';
-import type {
-  ConfigT,
-  InputConfigT,
-  Middleware,
-} from 'metro-config/src/configTypes.flow';
-import type {CustomTransformOptions} from 'metro-transform-worker';
-import typeof Yargs from 'yargs';
+/*::
+export type * from './index.flow';
+*/
 
-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 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} = require('metro-config');
-const {InspectorProxy} = require('metro-inspector-proxy');
-const net = require('net');
-const {parse} = require('url');
-const ws = require('ws');
+try {
+  // $FlowFixMe[untyped-import]
+  require('metro-babel-register').unstable_registerForMetroMonorepo();
+} catch {}
 
-type MetroMiddleWare = {
-  attachHmrServer: (httpServer: HttpServer | HttpsServer) => void,
-  end: () => void,
-  metroServer: MetroServer,
-  middleware: Middleware,
-};
-
-export type RunMetroOptions = {
-  ...ServerOptions,
-  waitForBundler?: boolean,
-};
-
-export type RunServerOptions = {
-  hasReducedPerformance?: boolean,
-  host?: string,
-  onError?: (Error & {code?: string}) => void,
-  onReady?: (server: HttpServer | HttpsServer) => void,
-  runInspectorProxy?: boolean,
-  secureServerOptions?: Object,
-  secure?: boolean, // deprecated
-  secureCert?: string, // deprecated
-  secureKey?: string, // deprecated
-  waitForBundler?: boolean,
-  websocketEndpoints?: {
-    [path: string]: typeof ws.Server,
-  },
-};
-
-type BuildGraphOptions = {
-  entries: $ReadOnlyArray<string>,
-  customTransformOptions?: CustomTransformOptions,
-  dev?: boolean,
-  minify?: boolean,
-  onProgress?: (transformedFileCount: number, totalFileCount: number) => void,
-  platform?: string,
-  type?: 'module' | 'script',
-};
-
-export type RunBuildOptions = {
-  entry: string,
-  dev?: boolean,
-  out?: string,
-  onBegin?: () => void,
-  onComplete?: () => void,
-  onProgress?: (transformedFileCount: number, totalFileCount: number) => void,
-  minify?: boolean,
-  output?: {
-    build: (
-      MetroServer,
-      RequestOptions,
-    ) => Promise<{
-      code: string,
-      map: string,
-      ...
-    }>,
-    save: (
-      {
-        code: string,
-        map: string,
-        ...
-      },
-      OutputOptions,
-      (...args: Array<string>) => void,
-    ) => Promise<mixed>,
-    ...
-  },
-  platform?: string,
-  sourceMap?: boolean,
-  sourceMapUrl?: string,
-};
-
-type BuildCommandOptions = {} | null;
-type ServeCommandOptions = {} | null;
-
-async function getConfig(config: InputConfigT): Promise<ConfigT> {
-  const defaultConfig = await getDefaultConfig(config.projectRoot);
-  return mergeConfig(defaultConfig, config);
-}
-
-async function runMetro(
-  config: InputConfigT,
-  options?: RunMetroOptions,
-): Promise<MetroServer> {
-  const mergedConfig = await getConfig(config);
-  const {
-    reporter,
-    server: {port},
-  } = mergedConfig;
-
-  reporter.update({
-    hasReducedPerformance: options
-      ? Boolean(options.hasReducedPerformance)
-      : false,
-    port,
-    type: 'initialize_started',
-  });
-
-  const {waitForBundler = false, ...serverOptions} = options ?? {};
-  const server = new MetroServer(mergedConfig, serverOptions);
-
-  const readyPromise = server
-    .ready()
-    .then(() => {
-      reporter.update({
-        type: 'initialize_done',
-        port,
-      });
-    })
-    .catch(error => {
-      reporter.update({
-        type: 'initialize_failed',
-        port,
-        error,
-      });
-    });
-  if (waitForBundler) {
-    await readyPromise;
-  }
-
-  return server;
-}
-
-exports.runMetro = runMetro;
-exports.loadConfig = loadConfig;
-
-const createConnectMiddleware = async function (
-  config: ConfigT,
-  options?: RunMetroOptions,
-): Promise<MetroMiddleWare> {
-  const metroServer = await runMetro(config, options);
-
-  let enhancedMiddleware: Middleware = metroServer.processRequest;
-
-  // Enhance the resulting middleware using the config options
-  if (config.server.enhanceMiddleware) {
-    enhancedMiddleware = config.server.enhanceMiddleware(
-      enhancedMiddleware,
-      metroServer,
-    );
-  }
-
-  return {
-    attachHmrServer(httpServer: HttpServer | HttpsServer): void {
-      const wss = createWebsocketServer({
-        websocketServer: new MetroHmrServer(
-          metroServer.getBundler(),
-          metroServer.getCreateModuleId(),
-          config,
-        ),
-      });
-      httpServer.on('upgrade', (request, socket, head) => {
-        const {pathname} = parse(request.url);
-        if (pathname === '/hot') {
-          wss.handleUpgrade(request, socket, head, ws => {
-            wss.emit('connection', ws, request);
-          });
-        } else {
-          socket.destroy();
-        }
-      });
-    },
-    metroServer,
-    middleware: enhancedMiddleware,
-    end(): void {
-      metroServer.end();
-    },
-  };
-};
-exports.createConnectMiddleware = createConnectMiddleware;
-
-exports.runServer = async (
-  config: ConfigT,
-  {
-    hasReducedPerformance = false,
-    host,
-    onError,
-    onReady,
-    secureServerOptions,
-    secure, //deprecated
-    secureCert, // deprecated
-    secureKey, // deprecated
-    waitForBundler = false,
-    websocketEndpoints = {},
-  }: RunServerOptions,
-): Promise<HttpServer | HttpsServer> => {
-  await earlyPortCheck(host, config.server.port);
-
-  if (secure != null || secureCert != null || secureKey != null) {
-    // eslint-disable-next-line no-console
-    console.warn(
-      chalk.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.",
-    );
-  }
-  // Lazy require
-  const connect = require('connect');
-
-  const serverApp = connect();
-
-  const {middleware, end, metroServer} = await createConnectMiddleware(config, {
-    hasReducedPerformance,
-    waitForBundler,
-  });
-
-  serverApp.use(middleware);
-
-  let inspectorProxy: ?InspectorProxy = null;
-  if (config.server.runInspectorProxy) {
-    inspectorProxy = new InspectorProxy(config.projectRoot);
-  }
-
-  let httpServer;
-
-  if (secure || secureServerOptions != null) {
-    let options = secureServerOptions;
-    if (typeof secureKey === 'string' && typeof secureCert === 'string') {
-      options = {
-        key: fs.readFileSync(secureKey),
-        cert: fs.readFileSync(secureCert),
-        ...secureServerOptions,
-      };
-    }
-    httpServer = https.createServer(options, serverApp);
-  } else {
-    httpServer = http.createServer(serverApp);
-  }
-  return new Promise(
-    (
-      resolve: (result: HttpServer | HttpsServer) => void,
-      reject: mixed => mixed,
-    ) => {
-      httpServer.on('error', error => {
-        if (onError) {
-          onError(error);
-        }
-        reject(error);
-        end();
-      });
-
-      httpServer.listen(config.server.port, host, () => {
-        if (onReady) {
-          onReady(httpServer);
-        }
-
-        Object.assign(websocketEndpoints, {
-          ...(inspectorProxy
-            ? {...inspectorProxy.createWebSocketListeners(httpServer)}
-            : {}),
-          '/hot': createWebsocketServer({
-            websocketServer: new MetroHmrServer(
-              metroServer.getBundler(),
-              metroServer.getCreateModuleId(),
-              config,
-            ),
-          }),
-        });
-
-        httpServer.on('upgrade', (request, socket, head) => {
-          const {pathname} = parse(request.url);
-          if (pathname != null && websocketEndpoints[pathname]) {
-            websocketEndpoints[pathname].handleUpgrade(
-              request,
-              socket,
-              head,
-              ws => {
-                websocketEndpoints[pathname].emit('connection', ws, request);
-              },
-            );
-          } else {
-            socket.destroy();
-          }
-        });
-
-        if (inspectorProxy) {
-          // TODO(hypuk): Refactor inspectorProxy.processRequest into separate request handlers
-          // so that we could provide routes (/json/list and /json/version) here.
-          // Currently this causes Metro to give warning about T31407894.
-          // $FlowFixMe[method-unbinding] added when improving typing for this parameters
-          serverApp.use(inspectorProxy.processRequest.bind(inspectorProxy));
-        }
-
-        resolve(httpServer);
-      });
-
-      // Disable any kind of automatic timeout behavior for incoming
-      // requests in case it takes the packager more than the default
-      // timeout of 120 seconds to respond to a request.
-      httpServer.timeout = 0;
-
-      httpServer.on('close', () => {
-        end();
-      });
-    },
-  );
-};
-
-exports.runBuild = async (
-  config: ConfigT,
-  {
-    dev = false,
-    entry,
-    onBegin,
-    onComplete,
-    onProgress,
-    minify = true,
-    output = outputBundle,
-    out,
-    platform = 'web',
-    sourceMap = false,
-    sourceMapUrl,
-  }: RunBuildOptions,
-): Promise<{
-  code: string,
-  map: string,
-  ...
-}> => {
-  const metroServer = await runMetro(config, {
-    watch: false,
-  });
-
-  try {
-    const requestOptions: RequestOptions = {
-      dev,
-      entryFile: entry,
-      inlineSourceMap: sourceMap && !sourceMapUrl,
-      minify,
-      platform,
-      sourceMapUrl: sourceMap === false ? undefined : sourceMapUrl,
-      createModuleIdFactory: config.serializer.createModuleIdFactory,
-      onProgress,
-    };
-
-    if (onBegin) {
-      onBegin();
-    }
-
-    const metroBundle = await output.build(metroServer, requestOptions);
-
-    if (onComplete) {
-      onComplete();
-    }
-
-    if (out) {
-      const bundleOutput = out.replace(/(\.js)?$/, '.js');
-      const sourcemapOutput =
-        sourceMap === false ? undefined : out.replace(/(\.js)?$/, '.map');
-
-      const outputOptions: OutputOptions = {
-        bundleOutput,
-        sourcemapOutput,
-        dev,
-        platform,
-      };
-
-      // eslint-disable-next-line no-console
-      await output.save(metroBundle, outputOptions, console.log);
-    }
-
-    return metroBundle;
-  } finally {
-    await metroServer.end();
-  }
-};
-
-exports.buildGraph = async function (
-  config: InputConfigT,
-  {
-    customTransformOptions = Object.create(null),
-    dev = false,
-    entries,
-    minify = false,
-    onProgress,
-    platform = 'web',
-    type = 'module',
-  }: BuildGraphOptions,
-): Promise<Graph<>> {
-  const mergedConfig = await getConfig(config);
-
-  const bundler = new IncrementalBundler(mergedConfig);
-
-  try {
-    return await bundler.buildGraphForEntries(entries, {
-      ...MetroServer.DEFAULT_GRAPH_OPTIONS,
-      customTransformOptions,
-      dev,
-      minify,
-      platform,
-      type,
-    });
-  } finally {
-    bundler.end();
-  }
-};
-
-exports.attachMetroCli = function (
-  yargs: Yargs,
-  {
-    build = {},
-    serve = {},
-    dependencies = {},
-  }: {
-    build: BuildCommandOptions,
-    serve: ServeCommandOptions,
-    dependencies: any,
-    ...
-  } = {},
-): Yargs {
-  if (build) {
-    const {command, description, builder, handler} = makeBuildCommand();
-    yargs.command(command, description, builder, handler);
-  }
-  if (serve) {
-    const {command, description, builder, handler} = makeServeCommand();
-    yargs.command(command, description, builder, handler);
-  }
-  if (dependencies) {
-    const {command, description, builder, handler} = makeDependenciesCommand();
-    yargs.command(command, description, builder, handler);
-  }
-  return yargs;
-};
-
-async function earlyPortCheck(host: void | string, port: number) {
-  const server = net.createServer(c => c.end());
-  try {
-    await new Promise((resolve, reject) => {
-      server.on('error', err => {
-        reject(err);
-      });
-      server.listen(port, host, undefined, () => resolve());
-    });
-  } finally {
-    await new Promise(resolve => server.close(() => resolve()));
-  }
-}
+module.exports = require('./index.flow');

package/src/node-haste/DependencyGraph/ModuleResolution.js

@@ -144,7 +144,10 @@ class ModuleResolver {
             `  * ${Resolver.formatFileCandidates(
               this._removeRoot(candidates.dir)
             )}`,
-          ].join("\n")
+          ].join("\n"),
+          {
+            cause: error,
+          }
         );
       }
 
@@ -162,7 +165,10 @@ class ModuleResolver {
           [
             `${moduleName} could not be found within the project${hint || "."}`,
             ...displayDirPaths.map((dirPath) => `  ${dirPath}`),
-          ].join("\n")
+          ].join("\n"),
+          {
+            cause: error,
+          }
         );
       }
 
@@ -238,7 +244,11 @@ class UnableToResolveError extends Error {
    * The name of the module that was required, no necessarily a path,
    * ex. `./bar`, or `invariant`.
    */
-  constructor(originModulePath, targetModuleName, message) {
+
+  /**
+   * Original error that causes this error
+   */
+  constructor(originModulePath, targetModuleName, message, options) {
     super();
     this.originModulePath = originModulePath;
     this.targetModuleName = targetModuleName;
@@ -250,6 +260,8 @@ class UnableToResolveError extends Error {
         originModulePath,
         message
       ) + (codeFrameMessage ? "\n" + codeFrameMessage : "");
+    this.cause =
+      options === null || options === void 0 ? void 0 : options.cause;
   }
 
   buildCodeFrameMessage() {

package/src/node-haste/DependencyGraph/ModuleResolution.js.flow

@@ -201,6 +201,9 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
               this._removeRoot(candidates.dir),
             )}`,
           ].join('\n'),
+          {
+            cause: error,
+          },
         );
       }
       if (error instanceof Resolver.FailedToResolveNameError) {
@@ -220,6 +223,9 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
             `${moduleName} could not be found within the project${hint || '.'}`,
             ...displayDirPaths.map((dirPath: string) => `  ${dirPath}`),
           ].join('\n'),
+          {
+            cause: error,
+          },
         );
       }
       throw error;
@@ -287,11 +293,18 @@ class UnableToResolveError extends Error {
    * ex. `./bar`, or `invariant`.
    */
   targetModuleName: string;
+  /**
+   * Original error that causes this error
+   */
+  cause: ?Error;
 
   constructor(
     originModulePath: string,
     targetModuleName: string,
     message: string,
+    options?: $ReadOnly<{
+      cause?: Error,
+    }>,
   ) {
     super();
     this.originModulePath = originModulePath;
@@ -304,6 +317,8 @@ class UnableToResolveError extends Error {
         originModulePath,
         message,
       ) + (codeFrameMessage ? '\n' + codeFrameMessage : '');
+
+    this.cause = options?.cause;
   }
 
   buildCodeFrameMessage(): ?string {

package/src/node-haste/DependencyGraph/createHasteMap.js

@@ -1,9 +1,47 @@
 "use strict";
 
-var _metroFileMap = _interopRequireDefault(require("metro-file-map"));
+var _metroFileMap = _interopRequireWildcard(require("metro-file-map"));
 
-function _interopRequireDefault(obj) {
-  return obj && obj.__esModule ? obj : { default: obj };
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function") return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== "object" && typeof obj !== "function")) {
+    return { default: obj };
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
 }
 
 /**
@@ -19,8 +57,6 @@ const ci = require("ci-info");
 
 const path = require("path");
 
-const JEST_HASTE_MAP_CACHE_BREAKER = 5;
-
 function getIgnorePattern(config) {
   // For now we support both options
   const { blockList, blacklistRE } = config.resolver;
@@ -45,7 +81,10 @@ function getIgnorePattern(config) {
 }
 
 function createHasteMap(config, options) {
-  var _config$fileMapCacheD, _options$name, _options$throwOnModul;
+  var _config$unstable_file,
+    _config$unstable_perf,
+    _config$unstable_perf2,
+    _options$throwOnModul;
 
   const dependencyExtractor =
     (options === null || options === void 0
@@ -55,28 +94,47 @@ function createHasteMap(config, options) {
       : config.resolver.dependencyExtractor;
   const computeDependencies = dependencyExtractor != null;
   return _metroFileMap.default.create({
-    cacheDirectory:
-      (_config$fileMapCacheD = config.fileMapCacheDirectory) !== null &&
-      _config$fileMapCacheD !== void 0
-        ? _config$fileMapCacheD
-        : config.hasteMapCacheDirectory,
+    cacheManagerFactory:
+      (_config$unstable_file =
+        config === null || config === void 0
+          ? void 0
+          : config.unstable_fileMapCacheManagerFactory) !== null &&
+      _config$unstable_file !== void 0
+        ? _config$unstable_file
+        : (buildParameters) => {
+            var _config$fileMapCacheD;
+
+            return new _metroFileMap.DiskCacheManager({
+              buildParameters,
+              cacheDirectory:
+                (_config$fileMapCacheD = config.fileMapCacheDirectory) !==
+                  null && _config$fileMapCacheD !== void 0
+                  ? _config$fileMapCacheD
+                  : config.hasteMapCacheDirectory,
+              cacheFilePrefix:
+                options === null || options === void 0
+                  ? void 0
+                  : options.cacheFilePrefix,
+            });
+          },
+    perfLogger:
+      (_config$unstable_perf =
+        (_config$unstable_perf2 = config.unstable_perfLogger) === null ||
+        _config$unstable_perf2 === void 0
+          ? void 0
+          : _config$unstable_perf2.subSpan("hasteMap")) !== null &&
+      _config$unstable_perf !== void 0
+        ? _config$unstable_perf
+        : null,
     computeDependencies,
     computeSha1: true,
     dependencyExtractor: config.resolver.dependencyExtractor,
     extensions: config.resolver.sourceExts.concat(config.resolver.assetExts),
     forceNodeFilesystemAPI: !config.resolver.useWatchman,
     hasteImplModulePath: config.resolver.hasteImplModulePath,
-    hasteMapModulePath: config.resolver.unstable_hasteMapModulePath,
     ignorePattern: getIgnorePattern(config),
     maxWorkers: config.maxWorkers,
     mocksPattern: "",
-    name: `${
-      (_options$name =
-        options === null || options === void 0 ? void 0 : options.name) !==
-        null && _options$name !== void 0
-        ? _options$name
-        : "metro"
-    }-${JEST_HASTE_MAP_CACHE_BREAKER}`,
     platforms: config.resolver.platforms,
     retainAllFiles: true,
     resetCache: config.resetCache,