metro 0.70.2 → 0.71.1

package/src/index.js.flow

@@ -10,461 +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 {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 = 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> => {
-  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 = Object.assign(
-        {
-          key: fs.readFileSync(secureKey),
-          cert: fs.readFileSync(secureCert),
-        },
-        secureServerOptions,
-      );
-    }
-    httpServer = https.createServer(options, serverApp);
-  } else {
-    httpServer = http.createServer(serverApp);
-  }
-
-  httpServer.on('error', error => {
-    if (onError) {
-      onError(error);
-    }
-    end();
-  });
-
-  return new Promise(
-    (
-      resolve: (result: HttpServer | HttpsServer) => void,
-      reject: mixed => mixed,
-    ) => {
-      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('error', error => {
-        end();
-        reject(error);
-      });
-
-      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;
-};
+module.exports = require('./index.flow');

package/src/lib/bundleToBytecode.js.flow

@@ -49,10 +49,10 @@ function addModuleHeader(buffer: Buffer): [Buffer, Buffer] {
  * ...
  *
  */
-function bundleToBytecode(bundle: BytecodeBundle): {|
+function bundleToBytecode(bundle: BytecodeBundle): {
   +bytecode: Buffer,
   +metadata: BundleMetadata,
-|} {
+} {
   const buffers = [];
 
   if (bundle.pre.length) {

package/src/lib/bundleToString.js.flow

@@ -18,10 +18,10 @@ import type {
 /**
  * Serializes a bundle into a plain JS bundle.
  */
-function bundleToString(bundle: Bundle): {|
+function bundleToString(bundle: Bundle): {
   +code: string,
   +metadata: BundleMetadata,
-|} {
+} {
   let code = bundle.pre.length > 0 ? bundle.pre + '\n' : '';
   const modules = [];
 

package/src/lib/getPreludeCode.js.flow

@@ -14,11 +14,11 @@ function getPreludeCode({
   extraVars,
   isDev,
   globalPrefix,
-}: {|
+}: {
   +extraVars?: {[string]: mixed, ...},
   +isDev: boolean,
   +globalPrefix: string,
-|}): string {
+}): string {
   const vars = [
     '__BUNDLE_START_TIME__=this.nativePerformanceNow?nativePerformanceNow():Date.now()',
     `__DEV__=${String(isDev)}`,

package/src/lib/transformHelpers.js.flow

@@ -21,10 +21,10 @@ const path = require('path');
 
 type InlineRequiresRaw = {+blockList: {[string]: true, ...}, ...} | boolean;
 
-type TransformOptionsWithRawInlines = {|
+type TransformOptionsWithRawInlines = {
   ...TransformOptions,
   +inlineRequires: InlineRequiresRaw,
-|};
+};
 
 const baseIgnoredInlineRequires = ['React', 'react', 'react-native'];
 

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

@@ -144,12 +144,16 @@ class ModuleResolver {
             `  * ${Resolver.formatFileCandidates(
               this._removeRoot(candidates.dir)
             )}`,
-          ].join("\n")
+          ].join("\n"),
+          {
+            cause: error,
+          }
         );
       }
 
       if (error instanceof Resolver.FailedToResolveNameError) {
-        const { dirPaths, extraPaths } = error;
+        const dirPaths = error.dirPaths;
+        const extraPaths = error.extraPaths;
         const displayDirPaths = dirPaths
           .filter((dirPath) => this._options.dirExists(dirPath))
           .map((dirPath) => path.relative(this._options.projectRoot, dirPath))
@@ -161,7 +165,10 @@ class ModuleResolver {
           [
             `${moduleName} could not be found within the project${hint || "."}`,
             ...displayDirPaths.map((dirPath) => `  ${dirPath}`),
-          ].join("\n")
+          ].join("\n"),
+          {
+            cause: error,
+          }
         );
       }
 
@@ -237,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;
@@ -249,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

@@ -10,7 +10,7 @@
 
 'use strict';
 
-import type {ModuleMap} from './types';
+import type {ModuleMap} from 'metro-file-map';
 import type {
   CustomResolver,
   DoesFileExist,
@@ -53,7 +53,7 @@ export type ModuleishCache<TModule, TPackage> = interface {
   getPackageOf(modulePath: string): ?TPackage,
 };
 
-type Options<TModule, TPackage> = {|
+type Options<TModule, TPackage> = {
   +dirExists: DirExistsFn,
   +disableHierarchicalLookup: boolean,
   +doesFileExist: DoesFileExist,
@@ -69,7 +69,7 @@ type Options<TModule, TPackage> = {|
   +resolveAsset: ResolveAsset,
   +resolveRequest: ?CustomResolver,
   +sourceExts: $ReadOnlyArray<string>,
-|};
+};
 
 class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
   _options: Options<TModule, TPackage>;
@@ -201,18 +201,14 @@ class ModuleResolver<TModule: Moduleish, TPackage: Packageish> {
               this._removeRoot(candidates.dir),
             )}`,
           ].join('\n'),
+          {
+            cause: error,
+          },
         );
       }
       if (error instanceof Resolver.FailedToResolveNameError) {
-        const {
-          dirPaths,
-          extraPaths,
-        }: {
-          // $flowfixme these types are defined explicitly in FailedToResolveNameError but Flow refuses to recognize them here
-          dirPaths: $ReadOnlyArray<string>,
-          extraPaths: $ReadOnlyArray<string>,
-          ...
-        } = error;
+        const dirPaths = error.dirPaths;
+        const extraPaths = error.extraPaths;
         const displayDirPaths = dirPaths
           .filter((dirPath: string) => this._options.dirExists(dirPath))
           .map(dirPath => path.relative(this._options.projectRoot, dirPath))
@@ -227,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;
@@ -294,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;
@@ -311,6 +317,8 @@ class UnableToResolveError extends Error {
         originModulePath,
         message,
       ) + (codeFrameMessage ? '\n' + codeFrameMessage : '');
+
+    this.cause = options?.cause;
   }
 
   buildCodeFrameMessage(): ?string {