metro 0.76.0 → 0.76.2

package/src/cli/parseKeyValueParamArray.js.flow

@@ -0,0 +1,31 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import querystring from 'querystring';
+
+export default function coerceKeyValueArray(
+  keyValueArray: $ReadOnlyArray<string>,
+): {
+  [key: string]: string,
+  __proto__: null,
+} {
+  const result: {[key: string]: string, __proto__: null} = Object.create(null);
+  for (const item of keyValueArray) {
+    if (item.indexOf('=') === -1) {
+      throw new Error('Expected parameter to include "=" but found: ' + item);
+    }
+    if (item.indexOf('&') !== -1) {
+      throw new Error('Parameter cannot include "&" but found: ' + item);
+    }
+    Object.assign(result, querystring.parse(item));
+  }
+  return result;
+}

package/src/cli-utils.js.flow

@@ -11,8 +11,6 @@
 
 'use strict';
 
-import type {YargArguments} from 'metro-config/src/configTypes.flow';
-
 const fs = require('fs');
 
 exports.watchFile = async function (
@@ -27,10 +25,8 @@ exports.watchFile = async function (
 };
 
 exports.makeAsyncCommand =
-  (
-    command: (argv: YargArguments) => Promise<void>,
-  ): ((argv: YargArguments) => void) =>
-  (argv: YargArguments) => {
+  <T>(command: (argv: T) => Promise<void>): ((argv: T) => void) =>
+  (argv: T) => {
     Promise.resolve(command(argv)).catch(error => {
       console.error(error.stack);
       process.exitCode = 1;

package/src/cli.js

@@ -17,4 +17,6 @@ try {
 } catch {}
 const { attachMetroCli } = require("./index");
 const yargs = require("yargs");
+
+// $FlowFixMe[unused-promise]
 attachMetroCli(yargs.demandCommand(1)).argv;

package/src/cli.js.flow

@@ -20,4 +20,5 @@ try {
 const {attachMetroCli} = require('./index');
 const yargs = require('yargs');
 
+// $FlowFixMe[unused-promise]
 attachMetroCli(yargs.demandCommand(1)).argv;

package/src/commands/build.js

@@ -1,3 +1,11 @@
+"use strict";
+
+var _parseKeyValueParamArray = _interopRequireDefault(
+  require("../cli/parseKeyValueParamArray")
+);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -9,8 +17,6 @@
  * @oncall react_native
  */
 
-"use strict";
-
 const { makeAsyncCommand } = require("../cli-utils");
 const TerminalReporter = require("../lib/TerminalReporter");
 const { loadConfig } = require("metro-config");
@@ -64,6 +70,21 @@ module.exports = () => ({
       alias: "c",
       type: "string",
     });
+    yargs.option("transform-option", {
+      type: "string",
+      array: true,
+      alias: "transformer-option",
+      coerce: _parseKeyValueParamArray.default,
+      describe:
+        "Custom transform options of the form key=value. URL-encoded. May be specified multiple times.",
+    });
+    yargs.option("resolver-option", {
+      type: "string",
+      array: true,
+      coerce: _parseKeyValueParamArray.default,
+      describe:
+        "Custom resolver options of the form key=value. URL-encoded. May be specified multiple times.",
+    });
 
     // Deprecated
     yargs.option("reset-cache", {
@@ -72,8 +93,17 @@ module.exports = () => ({
   },
   handler: makeAsyncCommand(async (argv) => {
     const config = await loadConfig(argv);
-    // $FlowExpectedError YargArguments and RunBuildOptions are used interchangeable but their types are not yet compatible
-    const options = argv;
+    const options = {
+      entry: argv.entry,
+      dev: argv.dev,
+      out: argv.out,
+      minify: argv.minify,
+      platform: argv.platform,
+      sourceMap: argv.sourceMap,
+      sourceMapUrl: argv.sourceMapUrl,
+      customResolverOptions: argv.resolverOption,
+      customTransformOptions: argv.transformOption,
+    };
 
     // Inline require() to avoid circular dependency with ../index
     const MetroApi = require("../index");
@@ -89,9 +119,6 @@ module.exports = () => ({
             entryFile: options.entry,
             minify: !!options.minify,
             platform: options.platform,
-            // Bytecode bundles in Metro are not meant for production use. Instead,
-            // the Hermes Bytecode Compiler should be invoked on the resulting JS bundle from Metro.
-            runtimeBytecodeVersion: null,
           },
         });
       },

package/src/commands/build.js.flow

@@ -9,10 +9,11 @@
  * @oncall react_native
  */
 
-'use strict';
+import parseKeyValueParamArray from '../cli/parseKeyValueParamArray';
 
+import type {CustomTransformOptions} from 'metro-babel-transformer';
+import type {CustomResolverOptions} from 'metro-resolver';
 import type {RunBuildOptions} from '../index';
-import type {YargArguments} from 'metro-config/src/configTypes.flow';
 import typeof Yargs from 'yargs';
 import type {ModuleObject} from 'yargs';
 
@@ -24,6 +25,24 @@ const {Terminal} = require('metro-core');
 const term = new Terminal(process.stdout);
 const updateReporter = new TerminalReporter(term);
 
+type Args = $ReadOnly<{
+  config?: string,
+  dev?: boolean,
+  entry: string,
+  legacyBundler?: boolean,
+  maxWorkers?: number,
+  minify?: boolean,
+  out: string,
+  outputType?: string,
+  platform?: string,
+  projectRoots?: $ReadOnlyArray<string>,
+  resetCache?: boolean,
+  sourceMap?: boolean,
+  sourceMapUrl?: string,
+  transformOption: CustomTransformOptions,
+  resolverOption: CustomResolverOptions,
+}>;
+
 module.exports = (): {
   ...ModuleObject,
   handler: Function,
@@ -54,14 +73,40 @@ module.exports = (): {
 
     yargs.option('config', {alias: 'c', type: 'string'});
 
+    yargs.option('transform-option', {
+      type: 'string',
+      array: true,
+      alias: 'transformer-option',
+      coerce: (parseKeyValueParamArray: $FlowFixMe),
+      describe:
+        'Custom transform options of the form key=value. URL-encoded. May be specified multiple times.',
+    });
+
+    yargs.option('resolver-option', {
+      type: 'string',
+      array: true,
+      coerce: (parseKeyValueParamArray: $FlowFixMe),
+      describe:
+        'Custom resolver options of the form key=value. URL-encoded. May be specified multiple times.',
+    });
+
     // Deprecated
     yargs.option('reset-cache', {type: 'boolean'});
   },
 
-  handler: makeAsyncCommand(async (argv: YargArguments) => {
+  handler: makeAsyncCommand(async (argv: Args) => {
     const config = await loadConfig(argv);
-    // $FlowExpectedError YargArguments and RunBuildOptions are used interchangeable but their types are not yet compatible
-    const options = (argv: RunBuildOptions);
+    const options: RunBuildOptions = {
+      entry: argv.entry,
+      dev: argv.dev,
+      out: argv.out,
+      minify: argv.minify,
+      platform: argv.platform,
+      sourceMap: argv.sourceMap,
+      sourceMapUrl: argv.sourceMapUrl,
+      customResolverOptions: argv.resolverOption,
+      customTransformOptions: argv.transformOption,
+    };
 
     // Inline require() to avoid circular dependency with ../index
     const MetroApi = require('../index');
@@ -78,9 +123,6 @@ module.exports = (): {
             entryFile: options.entry,
             minify: !!options.minify,
             platform: options.platform,
-            // Bytecode bundles in Metro are not meant for production use. Instead,
-            // the Hermes Bytecode Compiler should be invoked on the resulting JS bundle from Metro.
-            runtimeBytecodeVersion: null,
           },
         });
       },

package/src/commands/dependencies.js

@@ -4,6 +4,7 @@
  * 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
  */
@@ -12,10 +13,10 @@
 
 const { makeAsyncCommand } = require("../cli-utils");
 const Server = require("../Server");
-const denodeify = require("denodeify");
 const fs = require("fs");
 const { loadConfig } = require("metro-config");
 const path = require("path");
+const { promisify } = require("util");
 async function dependencies(args, config) {
   const rootModuleAbsolutePath = args.entryFile;
   if (!fs.existsSync(rootModuleAbsolutePath)) {
@@ -23,6 +24,8 @@ async function dependencies(args, config) {
       new Error(`File ${rootModuleAbsolutePath} does not exist`)
     );
   }
+
+  // $FlowFixMe[cannot-write]
   config.cacheStores = [];
   const relativePath = path.relative(
     config.server.unstable_serverRoot ?? config.projectRoot,
@@ -35,10 +38,8 @@ async function dependencies(args, config) {
     minify: false,
     generateSourceMaps: !args.dev,
   };
-  const writeToFile = args.output;
-  const outStream = writeToFile
-    ? fs.createWriteStream(args.output)
-    : process.stdout;
+  const outStream =
+    args.output != null ? fs.createWriteStream(args.output) : process.stdout;
   const server = new Server(config);
   const deps = await server.getOrderedDependencyPaths(options);
   deps.forEach((modulePath) => {
@@ -54,13 +55,14 @@ async function dependencies(args, config) {
     }
   });
   server.end();
-  return writeToFile
-    ? denodeify(outStream.end).bind(outStream)()
+  return args.output != null
+    ? // $FlowFixMe[method-unbinding]
+      promisify(outStream.end).bind(outStream)()
     : Promise.resolve();
 }
 module.exports = () => ({
-  command: "get-dependencies",
-  desc: "List dependencies",
+  command: "get-dependencies [entryFile]",
+  desc: "List all dependencies that will be bundled for a given entry point",
   builder: (yargs) => {
     yargs.option("entry-file", {
       type: "string",

package/src/commands/dependencies.js.flow

@@ -0,0 +1,128 @@
+/**
+ * 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.
+ *
+ * @flow
+ * @format
+ * @oncall react_native
+ */
+
+'use strict';
+
+import type {ConfigT} from 'metro-config';
+import typeof Yargs from 'yargs';
+import type {ModuleObject} 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');
+
+type Args = $ReadOnly<{
+  entryFile: string,
+  output?: string,
+  platform?: string,
+  transformer?: string,
+  maxWorkers?: number,
+  dev: boolean,
+  verbose: boolean,
+}>;
+
+async function dependencies(args: Args, config: ConfigT) {
+  const rootModuleAbsolutePath = args.entryFile;
+  if (!fs.existsSync(rootModuleAbsolutePath)) {
+    return Promise.reject(
+      new Error(`File ${rootModuleAbsolutePath} does not exist`),
+    );
+  }
+
+  // $FlowFixMe[cannot-write]
+  config.cacheStores = [];
+
+  const relativePath = path.relative(
+    config.server.unstable_serverRoot ?? config.projectRoot,
+    rootModuleAbsolutePath,
+  );
+
+  const options = {
+    platform: args.platform,
+    entryFile: relativePath,
+    dev: args.dev,
+    minify: false,
+    generateSourceMaps: !args.dev,
+  };
+
+  const outStream =
+    args.output != null ? fs.createWriteStream(args.output) : process.stdout;
+
+  const server = new Server(config);
+  const deps = await server.getOrderedDependencyPaths(options);
+  deps.forEach(modulePath => {
+    // Temporary hack to disable listing dependencies not under this directory.
+    // Long term, we need either
+    // (a) JS code to not depend on anything outside this directory, or
+    // (b) Come up with a way to declare this dependency in Buck.
+    const isInsideProjectRoots =
+      config.watchFolders.filter(root => modulePath.startsWith(root)).length >
+      0;
+    if (isInsideProjectRoots) {
+      outStream.write(modulePath + '\n');
+    }
+  });
+
+  server.end();
+  return args.output != null
+    ? // $FlowFixMe[method-unbinding]
+      promisify(outStream.end).bind(outStream)()
+    : Promise.resolve();
+}
+
+module.exports = (): {...ModuleObject, handler: Function} => ({
+  command: 'get-dependencies [entryFile]',
+  desc: 'List all dependencies that will be bundled for a given entry point',
+  builder: (yargs: Yargs) => {
+    yargs.option('entry-file', {
+      type: 'string',
+      demandOption: true,
+      describe: 'Absolute path to the root JS file',
+    });
+    yargs.option('output', {
+      type: 'string',
+      describe:
+        'File name where to store the output, ex. /tmp/dependencies.txt',
+    });
+    yargs.option('platform', {
+      type: 'string',
+      describe: 'The platform extension used for selecting modules',
+    });
+    yargs.option('transformer', {
+      type: 'string',
+      describe: 'Specify a custom transformer to be used',
+    });
+    yargs.option('max-workers', {
+      type: 'number',
+      describe:
+        'Specifies the maximum number of workers the worker-pool ' +
+        'will spawn for transforming files. This defaults to the number of the ' +
+        'cores available on your machine.',
+    });
+    yargs.option('dev', {
+      type: 'boolean',
+      default: true,
+      describe: 'If false, skip all dev-only code path',
+    });
+    yargs.option('verbose', {
+      type: 'boolean',
+      default: false,
+      description: 'Enables logging',
+    });
+  },
+  handler: makeAsyncCommand(async (argv: Args) => {
+    const config = await loadConfig(argv);
+    await dependencies(argv, config);
+  }),
+});

package/src/commands/serve.js

@@ -94,12 +94,19 @@ module.exports = () => ({
 
       // Inline require() to avoid circular dependency with ../index
       const MetroApi = require("../index");
-
-      // $FlowExpectedError YargArguments and RunBuildOptions are used interchangeable but their types are not yet compatible
-      server = await MetroApi.runServer(config, argv);
+      const {
+        config: _config,
+        hmrEnabled: _hmrEnabled,
+        maxWorkers: _maxWorkers,
+        port: _port,
+        projectRoots: _projectRoots,
+        resetCache: _resetCache,
+        ...runServerOptions
+      } = argv;
+      server = await MetroApi.runServer(config, runServerOptions);
       restarting = false;
     }
-    const foundConfig = await resolveConfig(argv.config, argv.cwd);
+    const foundConfig = await resolveConfig(argv.config);
     if (foundConfig) {
       await watchFile(foundConfig.filepath, restart);
     } else {

package/src/commands/serve.js.flow

@@ -11,8 +11,6 @@
 
 'use strict';
 
-import type {RunServerOptions} from '../index';
-import type {YargArguments} from 'metro-config/src/configTypes.flow';
 import typeof Yargs from 'yargs';
 import type {ModuleObject} from 'yargs';
 
@@ -20,6 +18,20 @@ const {makeAsyncCommand, watchFile} = require('../cli-utils');
 const {loadConfig, resolveConfig} = require('metro-config');
 const {promisify} = require('util');
 
+type Args = $ReadOnly<{
+  projectRoots?: $ReadOnlyArray<string>,
+  host: string,
+  port: number,
+  maxWorkers?: number,
+  secure?: boolean,
+  secureKey?: string,
+  secureCert?: string,
+  secureServerOptions?: string,
+  hmrEnabled?: boolean,
+  config?: string,
+  resetCache?: boolean,
+}>;
+
 module.exports = (): {
   ...ModuleObject,
   handler: Function,
@@ -63,7 +75,7 @@ module.exports = (): {
     );
   },
 
-  handler: makeAsyncCommand(async (argv: YargArguments) => {
+  handler: makeAsyncCommand(async (argv: Args) => {
     let server = null;
     let restarting = false;
 
@@ -86,13 +98,21 @@ module.exports = (): {
       // Inline require() to avoid circular dependency with ../index
       const MetroApi = require('../index');
 
-      // $FlowExpectedError YargArguments and RunBuildOptions are used interchangeable but their types are not yet compatible
-      server = await MetroApi.runServer(config, (argv: RunServerOptions));
+      const {
+        config: _config,
+        hmrEnabled: _hmrEnabled,
+        maxWorkers: _maxWorkers,
+        port: _port,
+        projectRoots: _projectRoots,
+        resetCache: _resetCache,
+        ...runServerOptions
+      } = argv;
+      server = await MetroApi.runServer(config, runServerOptions);
 
       restarting = false;
     }
 
-    const foundConfig = await resolveConfig(argv.config, argv.cwd);
+    const foundConfig = await resolveConfig(argv.config);
 
     if (foundConfig) {
       await watchFile(foundConfig.filepath, restart);

package/src/index.d.ts

@@ -0,0 +1,161 @@
+/**
+ * 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
+ */
+
+export * from './Asset';
+export * from './DeltaBundler/types';
+export * from './ModuleGraph/worker/collectDependencies';
+export * from './Server';
+export * from './lib/reporting';
+
+import type {EventEmitter} from 'events';
+import type {IncomingMessage, Server as HttpServer} from 'http';
+import type {Server as HttpsServer} from 'https';
+import type {
+  ConfigT,
+  InputConfigT,
+  MetroConfig,
+  Middleware,
+} from 'metro-config';
+import type {CustomTransformOptions} from 'metro-babel-transformer';
+import type {ReadOnlyGraph} from './DeltaBundler/types';
+import type {Duplex} from 'stream';
+import Yargs = require('yargs');
+import type {default as MetroServer, ServerOptions} from './Server';
+import type {OutputOptions, RequestOptions} from './shared/types';
+
+export {loadConfig, mergeConfig, resolveConfig} from 'metro-config';
+export {Terminal} from 'metro-core';
+
+export {HttpServer, HttpsServer};
+
+interface MetroMiddleWare {
+  attachHmrServer: (httpServer: HttpServer | HttpsServer) => void;
+  end: () => 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 {
+  hasReducedPerformance?: boolean;
+  host?: string;
+  onError?: (error: Error & {code?: string}) => void;
+  onReady?: (server: HttpServer | HttpsServer) => void;
+  runInspectorProxy?: boolean;
+  secureServerOptions?: Record<string, unknown>;
+
+  /** @deprecated since version 0.61 */
+  secure?: boolean;
+
+  /** @deprecated since version 0.61 */
+  secureCert?: string;
+
+  /** @deprecated since version 0.61 */
+  secureKey?: string;
+
+  waitForBundler?: boolean;
+  watch?: boolean;
+  websocketEndpoints?: {
+    [path: string]: WebsocketServer;
+  };
+}
+
+export interface RunBuildOptions {
+  entry: string;
+  dev?: boolean;
+  out?: string;
+  onBegin?: () => void;
+  onComplete?: () => void;
+  onProgress?: (transformedFileCount: number, totalFileCount: number) => void;
+  minify?: boolean;
+  output?: {
+    build: (
+      server: MetroServer,
+      options: RequestOptions,
+    ) => Promise<{
+      code: string;
+      map: string;
+    }>;
+    save: (
+      entry: {
+        code: string;
+        map: string;
+      },
+      options: OutputOptions,
+      postSave: (...args: string[]) => void,
+    ) => Promise<unknown>;
+  };
+  platform?: string;
+  sourceMap?: boolean;
+  sourceMapUrl?: string;
+}
+
+interface BuildGraphOptions {
+  entries: ReadonlyArray<string>;
+  customTransformOptions?: CustomTransformOptions;
+  dev?: boolean;
+  minify?: boolean;
+  onProgress?: (transformedFileCount: number, totalFileCount: number) => void;
+  platform?: string;
+  type?: 'module' | 'script';
+}
+
+export {MetroConfig};
+
+export function runMetro(
+  config: InputConfigT,
+  options?: RunMetroOptions,
+): Promise<MetroServer>;
+
+export function createConnectMiddleWare(
+  config: ConfigT,
+  options?: RunMetroOptions,
+): Promise<MetroMiddleWare>;
+
+export function runServer(
+  config: ConfigT,
+  options: RunServerOptions,
+): Promise<HttpServer | HttpsServer>;
+
+export function runBuild(
+  config: ConfigT,
+  options: RunBuildOptions,
+): Promise<void>;
+
+export function buildGraph(
+  config: ConfigT,
+  options: BuildGraphOptions,
+): Promise<ReadOnlyGraph<void>>;
+
+type BuildCommandOptions = Record<string, unknown> | null;
+type ServeCommandOptions = Record<string, unknown> | null;
+
+interface AttachMetroCLIOptions {
+  build?: BuildCommandOptions;
+  serve?: ServeCommandOptions;
+  dependencies?: unknown;
+}
+
+export function attachMetroCli(
+  yargs: typeof Yargs,
+  options?: AttachMetroCLIOptions,
+): typeof Yargs;