metro 0.83.3 → 0.83.5

package/src/commands/dependencies.js.flow

@@ -4,13 +4,13 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow
+ * @flow strict-local
  * @format
  * @oncall react_native
  */
 
 import type {ConfigT} from 'metro-config';
-import type {ModuleObject} from 'yargs';
+import type {CommandModule} from 'yargs';
 import typeof Yargs from 'yargs';
 
 import {makeAsyncCommand} from '../cli-utils';
@@ -20,7 +20,9 @@ import {loadConfig} from 'metro-config';
 import path from 'path';
 import {promisify} from 'util';
 
-type Args = $ReadOnly<{
+type Args = Readonly<{
+  _: unknown,
+  $0: unknown,
   entryFile: string,
   output?: string,
   platform?: string,
@@ -28,6 +30,7 @@ type Args = $ReadOnly<{
   maxWorkers?: number,
   dev: boolean,
   verbose: boolean,
+  ...
 }>;
 
 async function dependencies(args: Args, config: ConfigT) {
@@ -82,7 +85,7 @@ async function dependencies(args: Args, config: ConfigT) {
     : Promise.resolve();
 }
 
-export default (): {...ModuleObject, handler: Function} => ({
+export default (): CommandModule => ({
   command: 'get-dependencies [entryFile]',
   desc: 'List all dependencies that will be bundled for a given entry point',
   builder: (yargs: Yargs) => {
@@ -123,6 +126,7 @@ export default (): {...ModuleObject, handler: Function} => ({
     });
   },
   handler: makeAsyncCommand(async (argv: Args) => {
+    // $FlowFixMe[incompatible-type] argv has extra props.
     const config = await loadConfig(argv);
     await dependencies(argv, config);
   }),

package/src/commands/serve.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+import type {CommandModule} from 'yargs';
+
+declare const $$EXPORT_DEFAULT_DECLARATION$$: () => CommandModule;
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
+export default $$EXPORT_DEFAULT_DECLARATION$$;

package/src/commands/serve.js

@@ -80,6 +80,8 @@ var _default = () => ({
       const config = await (0, _metroConfig.loadConfig)(argv);
       const MetroApi = require("../index");
       const {
+        _,
+        $0: _0,
         config: _config,
         hmrEnabled: _hmrEnabled,
         maxWorkers: _maxWorkers,

package/src/commands/serve.js.flow

@@ -4,36 +4,37 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow
+ * @flow strict-local
  * @format
  * @oncall react_native
  */
 
-import type {ModuleObject} from 'yargs';
+import type {ServerOptions as HttpsServerOptions} from 'https';
+import type {CommandModule} from 'yargs';
 import typeof Yargs from 'yargs';
 
 import {makeAsyncCommand, watchFile} from '../cli-utils';
 import {loadConfig, resolveConfig} from 'metro-config';
 import {promisify} from 'util';
 
-type Args = $ReadOnly<{
-  projectRoots?: $ReadOnlyArray<string>,
+type Args = Readonly<{
+  _: unknown,
+  $0: unknown,
+  projectRoots?: ReadonlyArray<string>,
   host: string,
   port: number,
   maxWorkers?: number,
   secure?: boolean,
   secureKey?: string,
   secureCert?: string,
-  secureServerOptions?: string,
+  secureServerOptions?: HttpsServerOptions,
   hmrEnabled?: boolean,
   config?: string,
   resetCache?: boolean,
+  ...
 }>;
 
-export default (): {
-  ...ModuleObject,
-  handler: Function,
-} => ({
+export default (): CommandModule => ({
   command: 'serve',
   aliases: ['start'],
   desc: 'Starts Metro on the given port, building bundles on the fly',
@@ -91,6 +92,7 @@ export default (): {
         await promisify(server.close).call(server);
       }
 
+      // $FlowFixMe[incompatible-type] argv has extra props.
       const config = await loadConfig(argv);
 
       // Inline require() to avoid circular dependency with ../index
@@ -98,6 +100,8 @@ export default (): {
       const MetroApi = require('../index');
 
       const {
+        _,
+        $0: _0,
         config: _config,
         hmrEnabled: _hmrEnabled,
         maxWorkers: _maxWorkers,
@@ -108,6 +112,7 @@ export default (): {
       } = argv;
       ({httpServer: server} = await MetroApi.runServer(
         config,
+        // $FlowFixMe[incompatible-exact] argv has extra props.
         runServerOptions,
       ));
 

package/src/index.d.ts

@@ -8,168 +8,154 @@
  * @oncall react_native
  */
 
-export * from './Asset';
-export * from './DeltaBundler/types';
-export * from './ModuleGraph/worker/collectDependencies';
-export * from './Server';
-export * from './lib/reporting';
-
-import type {AssetData} from './Asset';
-import type {ReadOnlyGraph} from './DeltaBundler/types';
-import type {ServerOptions, default as MetroServer} from './Server';
+import type {AssetData} from './Assets';
+import type {ReadOnlyGraph} from './DeltaBundler';
+import type {ServerOptions} from './Server';
 import type {BuildOptions, OutputOptions, RequestOptions} from './shared/types';
 import type {HandleFunction} from 'connect';
-import type {EventEmitter} from 'events';
-import type {IncomingMessage, Server as HttpServer} from 'http';
-import type {Server as HttpsServer} from 'https';
-import type {CustomTransformOptions} from 'metro-babel-transformer';
+import type {Server as HttpServer} from 'http';
+import type {
+  Server as HttpsServer,
+  ServerOptions as HttpsServerOptions,
+} from 'https';
+import type {TransformProfile} from 'metro-babel-transformer';
 import type {
   ConfigT,
   InputConfigT,
   MetroConfig,
   Middleware,
 } from 'metro-config';
-import type {Duplex} from 'stream';
-import type Yargs from 'yargs';
-
-import {TerminalReporter} from './lib/TerminalReporter';
+import type {CustomResolverOptions} from 'metro-resolver';
+import type {CustomTransformOptions} from 'metro-transform-worker';
+import type {Server as WebSocketServer} from 'ws';
+import type $$IMPORT_TYPEOF_1$$ from 'yargs';
+
+import JsonReporter from './lib/JsonReporter';
+import TerminalReporter from './lib/TerminalReporter';
+import MetroServer from './Server';
 import {loadConfig, mergeConfig, resolveConfig} from 'metro-config';
 import {Terminal} from 'metro-core';
 
-export {HttpServer, HttpsServer};
-export {loadConfig, mergeConfig, resolveConfig, Terminal, TerminalReporter};
-
-interface MetroMiddleWare {
+type Yargs = typeof $$IMPORT_TYPEOF_1$$;
+type MetroMiddleWare = {
   attachHmrServer: (httpServer: HttpServer | HttpsServer) => void;
-  end: () => void;
+  end: () => Promise<void>;
   metroServer: MetroServer;
   middleware: Middleware;
-}
-
-export interface RunMetroOptions extends ServerOptions {
-  waitForBundler?: boolean;
-}
-
-interface WebsocketServer extends EventEmitter {
-  handleUpgrade<T = WebsocketServer>(
-    request: IncomingMessage,
-    socket: Duplex,
-    upgradeHead: Buffer,
-    callback: (client: T, request: IncomingMessage) => void,
-  ): void;
-}
-
-export interface RunServerOptions {
+};
+export type RunMetroOptions = Omit<
+  ServerOptions,
+  keyof {waitForBundler?: boolean}
+> & {waitForBundler?: boolean};
+export type RunServerOptions = Readonly<{
   hasReducedPerformance?: boolean;
   host?: string;
-  onError?: (error: Error & {code?: string}) => void;
+  onError?: ($$PARAM_0$$: Error & {code?: string}) => void;
   onReady?: (server: HttpServer | HttpsServer) => void;
-  secureServerOptions?: Record<string, unknown>;
-
-  /** @deprecated since version 0.61 */
+  onClose?: () => void;
+  secureServerOptions?: HttpsServerOptions;
   secure?: boolean;
-
-  /** @deprecated since version 0.61 */
   secureCert?: string;
-
-  /** @deprecated since version 0.61 */
   secureKey?: string;
-
   unstable_extraMiddleware?: ReadonlyArray<HandleFunction>;
   waitForBundler?: boolean;
   watch?: boolean;
-  websocketEndpoints?: {
-    [path: string]: WebsocketServer;
-  };
-}
-
-export interface RunServerResult {
-  httpServer: HttpServer | HttpsServer;
-}
-
-export interface RunBuildOptions {
+  websocketEndpoints?: Readonly<{[path: string]: WebSocketServer}>;
+}>;
+export type RunServerResult = {httpServer: HttpServer | HttpsServer};
+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;
+  assets?: boolean;
   dev?: boolean;
   out?: string;
+  bundleOut?: string;
+  sourceMapOut?: string;
   onBegin?: () => void;
   onComplete?: () => void;
   onProgress?: (transformedFileCount: number, totalFileCount: number) => void;
   minify?: boolean;
-  output?: {
+  output?: Readonly<{
     build: (
-      server: MetroServer,
-      requestOptions: RequestOptions,
-      buildOptions?: BuildOptions,
+      $$PARAM_0$$: MetroServer,
+      $$PARAM_1$$: RequestOptions,
+      $$PARAM_2$$: void | BuildOptions,
     ) => Promise<{
       code: string;
       map: string;
       assets?: ReadonlyArray<AssetData>;
     }>;
     save: (
-      entry: {
-        code: string;
-        map: string;
-      },
-      options: OutputOptions,
-      postSave: (...args: string[]) => void,
+      $$PARAM_0$$: {code: string; map: string},
+      $$PARAM_1$$: OutputOptions,
+      $$PARAM_2$$: (logMessage: string) => void,
     ) => Promise<unknown>;
-  };
+  }>;
   platform?: string;
   sourceMap?: boolean;
   sourceMapUrl?: string;
-}
-
-interface BuildGraphOptions {
-  entries: ReadonlyArray<string>;
+  customResolverOptions?: CustomResolverOptions;
   customTransformOptions?: CustomTransformOptions;
-  dev?: boolean;
-  minify?: boolean;
-  onProgress?: (transformedFileCount: number, totalFileCount: number) => void;
-  platform?: string;
-  type?: 'module' | 'script';
-}
-
-export {MetroConfig};
-
-export function runMetro(
+  unstable_transformProfile?: TransformProfile;
+};
+export type RunBuildResult = {
+  code: string;
+  map: string;
+  assets?: ReadonlyArray<AssetData>;
+};
+type BuildCommandOptions = Readonly<{[$$Key$$: string]: unknown}> | null;
+type ServeCommandOptions = Readonly<{[$$Key$$: string]: unknown}> | null;
+type DependenciesCommandOptions = Readonly<{
+  [$$Key$$: string]: unknown;
+}> | null;
+export {Terminal, JsonReporter, TerminalReporter};
+export type {AssetData} from './Assets';
+export type {Reporter, ReportableEvent} from './lib/reporting';
+export type {TerminalReportableEvent} from './lib/TerminalReporter';
+export type {MetroConfig};
+export declare function runMetro(
   config: InputConfigT,
   options?: RunMetroOptions,
 ): Promise<MetroServer>;
-
-export function createConnectMiddleware(
+export {loadConfig, mergeConfig, resolveConfig};
+export declare const createConnectMiddleware: (
   config: ConfigT,
   options?: RunMetroOptions,
-): Promise<MetroMiddleWare>;
-
-export function runServer(
-  config: ConfigT,
-  options: RunServerOptions,
-): Promise<RunServerResult>;
-
-export function runBuild(
+) => Promise<MetroMiddleWare>;
+export declare type createConnectMiddleware = typeof createConnectMiddleware;
+export declare const runServer: (
   config: ConfigT,
-  options: RunBuildOptions,
-): Promise<void>;
-
-export function buildGraph(
+  $$PARAM_1$$?: RunServerOptions,
+) => Promise<RunServerResult>;
+export declare type runServer = typeof runServer;
+export declare const runBuild: (
   config: ConfigT,
-  options: BuildGraphOptions,
-): Promise<ReadOnlyGraph<void>>;
-
-type BuildCommandOptions = Record<string, unknown> | null;
-type ServeCommandOptions = Record<string, unknown> | null;
-
-interface AttachMetroCLIOptions {
+  $$PARAM_1$$: RunBuildOptions,
+) => Promise<RunBuildResult>;
+export declare type runBuild = typeof runBuild;
+export declare const buildGraph: (
+  config: InputConfigT,
+  $$PARAM_1$$: BuildGraphOptions,
+) => Promise<ReadOnlyGraph>;
+export declare type buildGraph = typeof buildGraph;
+type AttachMetroCLIOptions = {
   build?: BuildCommandOptions;
   serve?: ServeCommandOptions;
-  dependencies?: unknown;
-}
-
-export function attachMetroCli(
-  yargs: Yargs.Argv,
+  dependencies?: DependenciesCommandOptions;
+};
+export declare const attachMetroCli: (
+  yargs: Yargs,
   options?: AttachMetroCLIOptions,
-): Yargs.Argv;
-
+) => Yargs;
+export declare type attachMetroCli = typeof attachMetroCli;
 /**
  * Backwards-compatibility with CommonJS consumers using interopRequireDefault.
  * Do not add to this list.
@@ -180,6 +166,7 @@ declare const $$EXPORT_DEFAULT_DECLARATION$$: {
   attachMetroCli: typeof attachMetroCli;
   runServer: typeof runServer;
   Terminal: typeof Terminal;
+  JsonReporter: typeof JsonReporter;
   TerminalReporter: typeof TerminalReporter;
   loadConfig: typeof loadConfig;
   mergeConfig: typeof mergeConfig;

package/src/index.flow.js

@@ -71,28 +71,32 @@ 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]);
+function _interopRequireWildcard(e, t) {
+  if ("function" == typeof WeakMap)
+    var r = new WeakMap(),
+      n = new WeakMap();
+  return (_interopRequireWildcard = function (e, t) {
+    if (!t && e && e.__esModule) return e;
+    var o,
+      i,
+      f = { __proto__: null, default: e };
+    if (null === e || ("object" != typeof e && "function" != typeof e))
+      return f;
+    if ((o = t ? n : r)) {
+      if (o.has(e)) return o.get(e);
+      o.set(e, f);
     }
-  return ((n.default = e), t && t.set(e, n), n);
+    for (const t in e)
+      "default" !== t &&
+        {}.hasOwnProperty.call(e, t) &&
+        ((i =
+          (o = Object.defineProperty) &&
+          Object.getOwnPropertyDescriptor(e, t)) &&
+        (i.get || i.set)
+          ? o(f, t, i)
+          : (f[t] = e[t]));
+    return f;
+  })(e, t);
 }
 function _interopRequireDefault(e) {
   return e && e.__esModule ? e : { default: e };
@@ -190,7 +194,7 @@ const runServer = async (
     secureKey,
     unstable_extraMiddleware,
     waitForBundler = false,
-    websocketEndpoints = {},
+    websocketEndpoints: userWebsocketEndpoints = {},
     watch,
   } = {},
 ) => {
@@ -200,7 +204,7 @@ const runServer = async (
       _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, or `config.server.tls` in Metro's configuration",
     );
   }
   const connect = require("connect");
@@ -219,15 +223,29 @@ const runServer = async (
   }
   serverApp.use(middleware);
   let httpServer;
-  if (secure || secureServerOptions != null) {
-    let options = secureServerOptions;
-    if (typeof secureKey === "string" && typeof secureCert === "string") {
-      options = {
-        key: _fs.default.readFileSync(secureKey),
-        cert: _fs.default.readFileSync(secureCert),
-        ...secureServerOptions,
-      };
-    }
+  const { tls } = config.server;
+  if (
+    secure === true ||
+    secureServerOptions != null ||
+    typeof tls === "object"
+  ) {
+    const options = {
+      key:
+        typeof tls === "object"
+          ? tls.key
+          : typeof secureKey === "string"
+            ? _fs.default.readFileSync(secureKey)
+            : undefined,
+      cert:
+        typeof tls === "object"
+          ? tls.cert
+          : typeof secureCert === "string"
+            ? _fs.default.readFileSync(secureCert)
+            : undefined,
+      ca: typeof tls === "object" ? tls.ca : undefined,
+      requestCert: typeof tls === "object" ? tls.requestCert : undefined,
+      ...(secureServerOptions ?? {}),
+    };
     httpServer = _https.default.createServer(options, serverApp);
   } else {
     httpServer = _http.default.createServer(serverApp);
@@ -247,8 +265,8 @@ const runServer = async (
         port,
         family,
       });
-      websocketEndpoints = {
-        ...websocketEndpoints,
+      const websocketEndpoints = {
+        ...userWebsocketEndpoints,
         "/hot": (0, _createWebsocketServer.default)({
           websocketServer: new _HmrServer.default(
             metroServer.getBundler(),
@@ -349,7 +367,7 @@ const runBuild = async (
     if (onComplete) {
       onComplete();
     }
-    if (out || bundleOut) {
+    if (out != null || bundleOut != null) {
       const bundleOutput =
         bundleOut ?? (0, _nullthrows.default)(out).replace(/(\.js)?$/, ".js");
       const sourcemapOutput =