metro 0.83.4 → 0.83.6

package/src/Server.js

@@ -25,6 +25,7 @@ var _IncrementalBundler = _interopRequireDefault(
 var _ResourceNotFoundError = _interopRequireDefault(
   require("./IncrementalBundler/ResourceNotFoundError"),
 );
+var _bundleProgressUtils = require("./lib/bundleProgressUtils");
 var _bundleToString = _interopRequireDefault(require("./lib/bundleToString"));
 var _formatBundlingError = _interopRequireDefault(
   require("./lib/formatBundlingError"),
@@ -66,10 +67,7 @@ function _interopRequireWildcard(e, t) {
     if (!t && e && e.__esModule) return e;
     var o,
       i,
-      f = {
-        __proto__: null,
-        default: e,
-      };
+      f = { __proto__: null, default: e };
     if (null === e || ("object" != typeof e && "function" != typeof e))
       return f;
     if ((o = t ? n : r)) {
@@ -89,11 +87,7 @@ function _interopRequireWildcard(e, t) {
   })(e, t);
 }
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const debug = require("debug")("Metro:Server");
 const { createActionStartEntry, createActionEndEntry, log } = _metroCore.Logger;
@@ -136,6 +130,8 @@ class Server {
       ]),
     ];
     this._isEnded = false;
+    this._fetchTimings = [];
+    this._activeFetchCount = 0;
     this._createModuleId = config.serializer.createModuleIdFactory();
     this._bundler = new _IncrementalBundler.default(config, {
       hasReducedPerformance: options && options.hasReducedPerformance,
@@ -684,14 +680,16 @@ class Server {
       }
       const mres = _MultipartResponse.default.wrapIfSupported(req, res);
       let onProgress = null;
-      let lastProgress = -1;
+      let lastRatio = -1;
       if (this._config.reporter) {
         onProgress = (transformedFileCount, totalFileCount) => {
-          const currentProgress = parseInt(
-            (transformedFileCount / totalFileCount) * 100,
-            10,
+          const newRatio = (0,
+          _bundleProgressUtils.calculateBundleProgressRatio)(
+            transformedFileCount,
+            totalFileCount,
+            lastRatio,
           );
-          if (currentProgress > lastProgress || totalFileCount < 10) {
+          if (newRatio > lastRatio) {
             if (mres instanceof _MultipartResponse.default) {
               mres.writeChunk(
                 {
@@ -700,13 +698,14 @@ class Server {
                 JSON.stringify({
                   done: transformedFileCount,
                   total: totalFileCount,
+                  percent: Math.floor(newRatio * 100),
                 }),
               );
             }
             if (res.socket != null && res.socket.uncork != null) {
               res.socket.uncork();
             }
-            lastProgress = currentProgress;
+            lastRatio = newRatio;
           }
           this._reporter.update({
             buildID: getBuildID(buildNumber),
@@ -748,8 +747,16 @@ class Server {
       const logEntry = log(
         createActionStartEntry(createStartEntry(startContext)),
       );
+      const fetchTiming = {
+        graphId,
+        startTime: requestStartTimestamp,
+        endTime: null,
+        isPrefetch: req.method === "HEAD",
+      };
       let result;
       try {
+        this._fetchTimings.push(fetchTiming);
+        this._activeFetchCount++;
         result = await build(startContext);
       } catch (error) {
         const formattedError = (0, _formatBundlingError.default)(error);
@@ -779,6 +786,31 @@ class Server {
         debug("Bundling error", error);
         buildContext.bundlePerfLogger.end("FAIL");
         return;
+      } finally {
+        fetchTiming.endTime =
+          _perf_hooks.performance.timeOrigin + _perf_hooks.performance.now();
+        if (!fetchTiming.isPrefetch) {
+          buildContext.bundlePerfLogger.annotate({
+            bool: {
+              had_competing_prefetch: this._fetchTimings
+                .filter((t) => t.isPrefetch && t.graphId !== graphId)
+                .some((prefetch) => {
+                  const prefetchEndTime =
+                    prefetch.endTime ?? Number.MAX_SAFE_INTEGER;
+                  const fetchEndTime =
+                    fetchTiming.endTime ?? Number.MAX_SAFE_INTEGER;
+                  return (
+                    prefetch.startTime < fetchEndTime &&
+                    prefetchEndTime > fetchTiming.startTime
+                  );
+                }),
+            },
+          });
+        }
+        this._activeFetchCount--;
+        if (this._activeFetchCount === 0) {
+          this._fetchTimings = [];
+        }
       }
       const endContext = {
         ...startContext,

package/src/Server.js.flow

@@ -52,6 +52,7 @@ import getRamBundleInfo from './DeltaBundler/Serializers/getRamBundleInfo';
 import {sourceMapStringNonBlocking} from './DeltaBundler/Serializers/sourceMapString';
 import IncrementalBundler from './IncrementalBundler';
 import ResourceNotFoundError from './IncrementalBundler/ResourceNotFoundError';
+import {calculateBundleProgressRatio} from './lib/bundleProgressUtils';
 import bundleToString from './lib/bundleToString';
 import formatBundlingError from './lib/formatBundlingError';
 import getGraphId from './lib/getGraphId';
@@ -130,6 +131,13 @@ export type ServerOptions = Readonly<{
 const DELTA_ID_HEADER = 'X-Metro-Delta-ID';
 const FILES_CHANGED_COUNT_HEADER = 'X-Metro-Files-Changed-Count';
 
+type FetchTiming = {
+  graphId: GraphId,
+  startTime: number,
+  endTime: number | null,
+  isPrefetch: boolean,
+};
+
 export default class Server {
   _bundler: IncrementalBundler;
   _config: ConfigT;
@@ -144,6 +152,8 @@ export default class Server {
   _sourceRequestRoutingMap: ReadonlyArray<
     [pathnamePrefix: string, normalizedRootDir: string],
   >;
+  _fetchTimings: Array<FetchTiming>;
+  _activeFetchCount: number;
 
   constructor(config: ConfigT, options?: ServerOptions) {
     this._config = config;
@@ -176,6 +186,8 @@ export default class Server {
       ]),
     ];
     this._isEnded = false;
+    this._fetchTimings = [];
+    this._activeFetchCount = 0;
 
     // TODO(T34760917): These two properties should eventually be instantiated
     // elsewhere and passed as parameters, since they are also needed by
@@ -846,25 +858,23 @@ export default class Server {
       const mres = MultipartResponse.wrapIfSupported(req, res);
 
       let onProgress = null;
-      let lastProgress = -1;
+      let lastRatio = -1;
       if (this._config.reporter) {
         onProgress = (transformedFileCount: number, totalFileCount: number) => {
-          const currentProgress = parseInt(
-            (transformedFileCount / totalFileCount) * 100,
-            10,
+          const newRatio = calculateBundleProgressRatio(
+            transformedFileCount,
+            totalFileCount,
+            lastRatio,
           );
 
-          // We want to throttle the updates so that we only show meaningful
-          // UI updates slow enough for the client to actually handle them. For
-          // that, we check the percentage, and only send percentages that are
-          // actually different and that have increased from the last one we sent.
-          if (currentProgress > lastProgress || totalFileCount < 10) {
+          if (newRatio > lastRatio) {
             if (mres instanceof MultipartResponse) {
               mres.writeChunk(
                 {'Content-Type': 'application/json'},
                 JSON.stringify({
                   done: transformedFileCount,
                   total: totalFileCount,
+                  percent: Math.floor(newRatio * 100),
                 }),
               );
             }
@@ -880,7 +890,7 @@ export default class Server {
               res.socket.uncork();
             }
 
-            lastProgress = currentProgress;
+            lastRatio = newRatio;
           }
 
           this._reporter.update({
@@ -926,8 +936,18 @@ export default class Server {
         createActionStartEntry(createStartEntry(startContext)),
       );
 
+      const fetchTiming: FetchTiming = {
+        graphId,
+        startTime: requestStartTimestamp,
+        endTime: null,
+        isPrefetch: req.method === 'HEAD',
+      };
+
       let result;
       try {
+        this._fetchTimings.push(fetchTiming);
+        this._activeFetchCount++;
+
         result = await build(startContext);
       } catch (error) {
         const formattedError = formatBundlingError(error);
@@ -960,6 +980,33 @@ export default class Server {
         buildContext.bundlePerfLogger.end('FAIL');
 
         return;
+      } finally {
+        fetchTiming.endTime = performance.timeOrigin + performance.now();
+
+        if (!fetchTiming.isPrefetch) {
+          buildContext.bundlePerfLogger.annotate({
+            bool: {
+              had_competing_prefetch: this._fetchTimings
+                // fetching the same bundle as a prefetch don't compete, since they resolve a shared promise for the same graph id
+                .filter(t => t.isPrefetch && t.graphId !== graphId)
+                .some(prefetch => {
+                  const prefetchEndTime =
+                    prefetch.endTime ?? Number.MAX_SAFE_INTEGER;
+                  const fetchEndTime =
+                    fetchTiming.endTime ?? Number.MAX_SAFE_INTEGER;
+                  return (
+                    prefetch.startTime < fetchEndTime &&
+                    prefetchEndTime > fetchTiming.startTime
+                  );
+                }),
+            },
+          });
+        }
+
+        this._activeFetchCount--;
+        if (this._activeFetchCount === 0) {
+          this._fetchTimings = [];
+        }
       }
 
       const endContext: ProcessEndContext<T> = {

package/src/cli/parseKeyValueParamArray.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<ece5a9f14463102dc54489fe7db6b3c8>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/cli/parseKeyValueParamArray.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+declare function coerceKeyValueArray(keyValueArray: ReadonlyArray<string>): {
+  [key: string]: string;
+};
+export default coerceKeyValueArray;

package/src/cli-utils.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<b5035a5d26a55e608aca030ee9ee6afa>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/cli-utils.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+export declare const watchFile: (
+  filename: string,
+  callback: () => unknown,
+) => Promise<void>;
+export declare type watchFile = typeof watchFile;
+export declare const makeAsyncCommand: <T>(
+  command: (argv: T) => Promise<void>,
+) => (argv: T) => void;
+export declare type makeAsyncCommand = typeof makeAsyncCommand;

package/src/cli-utils.js

@@ -6,11 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.watchFile = exports.makeAsyncCommand = void 0;
 var _fs = _interopRequireDefault(require("fs"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const watchFile = async function (filename, callback) {
   _fs.default.watchFile(filename, () => {

package/src/commands/build.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<10c41709fa9779dd0e12ef411eaef8eb>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/commands/build.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+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/build.js

@@ -14,11 +14,7 @@ var _TerminalReporter = _interopRequireDefault(
 var _metroConfig = require("metro-config");
 var _metroCore = require("metro-core");
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const term = new _metroCore.Terminal(process.stdout);
 const updateReporter = new _TerminalReporter.default(term);

package/src/commands/dependencies.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<a73d915901dde7a679972b78a1e08a3e>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/commands/dependencies.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+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/dependencies.js

@@ -11,11 +11,7 @@ var _metroConfig = require("metro-config");
 var _path = _interopRequireDefault(require("path"));
 var _util = require("util");
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 async function dependencies(args, config) {
   const rootModuleAbsolutePath = args.entryFile;

package/src/commands/serve.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<367f11c0b6933f8c8c58718c7dd41e78>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/commands/serve.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+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/index.d.ts

@@ -0,0 +1,206 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<3c6460427c6760887187d6b16151c609>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/index.flow.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+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 {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 {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';
+
+type Yargs = typeof $$IMPORT_TYPEOF_1$$;
+type MetroMiddleWare = {
+  attachHmrServer: (httpServer: HttpServer | HttpsServer) => void;
+  end: () => Promise<void>;
+  metroServer: MetroServer;
+  middleware: Middleware;
+};
+export type RunMetroOptions = Omit<
+  ServerOptions,
+  keyof {waitForBundler?: boolean}
+> & {waitForBundler?: boolean};
+export type RunServerOptions = Readonly<{
+  hasReducedPerformance?: boolean;
+  host?: string;
+  onError?: ($$PARAM_0$$: Error & {code?: string}) => void;
+  onReady?: (server: HttpServer | HttpsServer) => void;
+  onClose?: () => void;
+  secureServerOptions?: HttpsServerOptions;
+  secure?: boolean;
+  secureCert?: string;
+  secureKey?: string;
+  unstable_extraMiddleware?: ReadonlyArray<HandleFunction>;
+  waitForBundler?: boolean;
+  watch?: boolean;
+  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?: Readonly<{
+    build: (
+      $$PARAM_0$$: MetroServer,
+      $$PARAM_1$$: RequestOptions,
+      $$PARAM_2$$: void | BuildOptions,
+    ) => Promise<{
+      code: string;
+      map: string;
+      assets?: ReadonlyArray<AssetData>;
+    }>;
+    save: (
+      $$PARAM_0$$: {code: string; map: string},
+      $$PARAM_1$$: OutputOptions,
+      $$PARAM_2$$: (logMessage: string) => void,
+    ) => Promise<unknown>;
+  }>;
+  platform?: string;
+  sourceMap?: boolean;
+  sourceMapUrl?: string;
+  customResolverOptions?: CustomResolverOptions;
+  customTransformOptions?: CustomTransformOptions;
+  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 {
+  AsyncDependencyType,
+  DeltaResult,
+  Dependency,
+  MixedOutput,
+  Module,
+  ReadOnlyDependencies,
+  ReadOnlyGraph,
+  SerializerOptions,
+  TransformInputOptions,
+  TransformResult,
+  TransformResultDependency,
+} from './DeltaBundler/types';
+export type {default as DependencyGraph} from './node-haste/DependencyGraph';
+export type {BundleDetails, Reporter, ReportableEvent} from './lib/reporting';
+export type {TerminalReportableEvent} from './lib/TerminalReporter';
+export type {
+  ContextMode,
+  RequireContextParams,
+} from './ModuleGraph/worker/collectDependencies';
+export type {ServerOptions} from './Server';
+export type {MetroConfig, MetroServer};
+export declare function runMetro(
+  config: InputConfigT,
+  options?: RunMetroOptions,
+): Promise<MetroServer>;
+export {loadConfig, mergeConfig, resolveConfig};
+export declare const createConnectMiddleware: (
+  config: ConfigT,
+  options?: RunMetroOptions,
+) => Promise<MetroMiddleWare>;
+export declare type createConnectMiddleware = typeof createConnectMiddleware;
+export declare const runServer: (
+  config: ConfigT,
+  $$PARAM_1$$?: RunServerOptions,
+) => Promise<RunServerResult>;
+export declare type runServer = typeof runServer;
+export declare const runBuild: (
+  config: ConfigT,
+  $$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?: DependenciesCommandOptions;
+};
+export declare const attachMetroCli: (
+  yargs: Yargs,
+  options?: AttachMetroCLIOptions,
+) => Yargs;
+export declare type attachMetroCli = typeof attachMetroCli;
+/**
+ * Backwards-compatibility with CommonJS consumers using interopRequireDefault.
+ * Do not add to this list.
+ *
+ * @deprecated Default import from 'metro' is deprecated, use named exports.
+ */
+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;
+  resolveConfig: typeof resolveConfig;
+  createConnectMiddleware: typeof createConnectMiddleware;
+  runBuild: typeof runBuild;
+  buildGraph: typeof buildGraph;
+};
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
+export default $$EXPORT_DEFAULT_DECLARATION$$;