metro 0.71.0 → 0.71.3

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/lib/CountingSet.js

@@ -0,0 +1,116 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+
+/**
+ * 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
+ */
+
+/**
+ * A Set that only deletes a given item when the number of delete(item) calls
+ * matches the number of add(item) calls. Iteration and `size` are in terms of
+ * *unique* items.
+ */
+class CountingSet {
+  #map = new Map();
+
+  constructor(items) {
+    if (items) {
+      if (items instanceof CountingSet) {
+        this.#map = new Map(items.#map);
+      } else {
+        for (const item of items) {
+          this.add(item);
+        }
+      }
+    }
+  }
+
+  has(item) {
+    return this.#map.has(item);
+  }
+
+  add(item) {
+    const newCount = this.count(item) + 1;
+    this.#map.set(item, newCount);
+  }
+
+  delete(item) {
+    const newCount = this.count(item) - 1;
+
+    if (newCount <= 0) {
+      this.#map.delete(item);
+    } else {
+      this.#map.set(item, newCount);
+    }
+  }
+
+  keys() {
+    return this.#map.keys();
+  }
+
+  values() {
+    return this.#map.keys();
+  }
+
+  *entries() {
+    for (const item of this) {
+      yield [item, item];
+    }
+  } // Iterate over unique entries
+  // $FlowIssue[unsupported-syntax]
+
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  /*::
+  // For Flow's benefit
+  @@iterator(): Iterator<T> {
+    return this.values();
+  }
+  */
+  // Number of unique entries
+  // $FlowIssue[unsafe-getters-setters]
+
+  get size() {
+    return this.#map.size;
+  }
+
+  count(item) {
+    var _this$map$get;
+
+    return (_this$map$get = this.#map.get(item)) !== null &&
+      _this$map$get !== void 0
+      ? _this$map$get
+      : 0;
+  }
+
+  clear() {
+    this.#map.clear();
+  }
+
+  forEach(callbackFn, thisArg) {
+    for (const item of this) {
+      callbackFn.call(thisArg, item, item, this);
+    }
+  } // For Jest purposes. Ideally a custom serializer would be enough, but in
+  // practice there is hardcoded magic for Set in toEqual (etc) that we cannot
+  // extend to custom collection classes. Instead let's assume values are
+  // sortable ( = strings) and make this look like an array with some stable
+  // order.
+
+  toJSON() {
+    return [...this].sort();
+  }
+}
+
+exports.default = CountingSet;

package/src/lib/CountingSet.js.flow

@@ -0,0 +1,126 @@
+/**
+ * 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
+ */
+
+export interface ReadOnlyCountingSet<T> extends Iterable<T> {
+  has(item: T): boolean;
+  @@iterator(): Iterator<T>;
+  +size: number;
+  count(item: T): number;
+  forEach<ThisT>(
+    callbackFn: (
+      this: ThisT,
+      value: T,
+      key: T,
+      set: ReadOnlyCountingSet<T>,
+    ) => mixed,
+
+    // NOTE: Should be optional, but Flow seems happy to infer undefined here
+    // which is what we want.
+    thisArg: ThisT,
+  ): void;
+}
+
+/**
+ * A Set that only deletes a given item when the number of delete(item) calls
+ * matches the number of add(item) calls. Iteration and `size` are in terms of
+ * *unique* items.
+ */
+export default class CountingSet<T> implements ReadOnlyCountingSet<T> {
+  #map: Map<T, number> = new Map();
+
+  constructor(items?: Iterable<T>) {
+    if (items) {
+      if (items instanceof CountingSet) {
+        this.#map = new Map(items.#map);
+      } else {
+        for (const item of items) {
+          this.add(item);
+        }
+      }
+    }
+  }
+
+  has(item: T): boolean {
+    return this.#map.has(item);
+  }
+
+  add(item: T): void {
+    const newCount = this.count(item) + 1;
+    this.#map.set(item, newCount);
+  }
+
+  delete(item: T): void {
+    const newCount = this.count(item) - 1;
+    if (newCount <= 0) {
+      this.#map.delete(item);
+    } else {
+      this.#map.set(item, newCount);
+    }
+  }
+
+  keys(): Iterator<T> {
+    return this.#map.keys();
+  }
+
+  values(): Iterator<T> {
+    return this.#map.keys();
+  }
+
+  *entries(): Iterator<[T, T]> {
+    for (const item of this) {
+      yield [item, item];
+    }
+  }
+
+  // Iterate over unique entries
+  // $FlowIssue[unsupported-syntax]
+  [Symbol.iterator](): Iterator<T> {
+    return this.values();
+  }
+
+  /*::
+  // For Flow's benefit
+  @@iterator(): Iterator<T> {
+    return this.values();
+  }
+  */
+
+  // Number of unique entries
+  // $FlowIssue[unsafe-getters-setters]
+  get size(): number {
+    return this.#map.size;
+  }
+
+  count(item: T): number {
+    return this.#map.get(item) ?? 0;
+  }
+
+  clear(): void {
+    this.#map.clear();
+  }
+
+  forEach<ThisT>(
+    callbackFn: (this: ThisT, value: T, key: T, set: CountingSet<T>) => mixed,
+    thisArg: ThisT,
+  ): void {
+    for (const item of this) {
+      callbackFn.call(thisArg, item, item, this);
+    }
+  }
+
+  // For Jest purposes. Ideally a custom serializer would be enough, but in
+  // practice there is hardcoded magic for Set in toEqual (etc) that we cannot
+  // extend to custom collection classes. Instead let's assume values are
+  // sortable ( = strings) and make this look like an array with some stable
+  // order.
+  toJSON(): mixed {
+    return [...this].sort();
+  }
+}