metro 0.83.3 → 0.83.5

package/src/DeltaBundler/types.js.flow

@@ -11,19 +11,20 @@
 
 import type {RequireContext} from '../lib/contextModule';
 import type {RequireContextParams} from '../ModuleGraph/worker/collectDependencies';
+import type {ReadonlySourceLocation} from '../shared/types';
 import type {Graph} from './Graph';
 import type {JsTransformOptions} from 'metro-transform-worker';
 
 import CountingSet from '../lib/CountingSet';
 
 export type MixedOutput = {
-  +data: mixed,
+  +data: unknown,
   +type: string,
 };
 
 export type AsyncDependencyType = 'async' | 'maybeSync' | 'prefetch' | 'weak';
 
-export type TransformResultDependency = $ReadOnly<{
+export type TransformResultDependency = Readonly<{
   /**
    * The literal name provided to a require or import call. For example 'foo' in
    * case of `require('foo')`.
@@ -33,7 +34,7 @@ export type TransformResultDependency = $ReadOnly<{
   /**
    * Extra data returned by the dependency extractor.
    */
-  data: $ReadOnly<{
+  data: Readonly<{
     /**
      * A locally unique key for this dependency within the current module.
      */
@@ -52,43 +53,43 @@ export type TransformResultDependency = $ReadOnly<{
      */
     isOptional?: boolean,
 
-    locs: $ReadOnlyArray<BabelSourceLocation>,
+    locs: ReadonlyArray<ReadonlySourceLocation>,
 
     /** Context for requiring a collection of modules. */
     contextParams?: RequireContextParams,
   }>,
 }>;
 
-export type ResolvedDependency = $ReadOnly<{
+export type ResolvedDependency = Readonly<{
   absolutePath: string,
   data: TransformResultDependency,
 }>;
 
 export type Dependency =
   | ResolvedDependency
-  | $ReadOnly<{
+  | Readonly<{
       data: TransformResultDependency,
     }>;
 
-export type Module<T = MixedOutput> = $ReadOnly<{
+export type Module<T = MixedOutput> = Readonly<{
   dependencies: Map<string, Dependency>,
   inverseDependencies: CountingSet<string>,
-  output: $ReadOnlyArray<T>,
+  output: ReadonlyArray<T>,
   path: string,
   getSource: () => Buffer,
   unstable_transformResultKey?: ?string,
 }>;
 
-export type ModuleData<T = MixedOutput> = $ReadOnly<{
-  dependencies: $ReadOnlyMap<string, Dependency>,
-  resolvedContexts: $ReadOnlyMap<string, RequireContext>,
-  output: $ReadOnlyArray<T>,
+export type ModuleData<T = MixedOutput> = Readonly<{
+  dependencies: ReadonlyMap<string, Dependency>,
+  resolvedContexts: ReadonlyMap<string, RequireContext>,
+  output: ReadonlyArray<T>,
   getSource: () => Buffer,
   unstable_transformResultKey?: ?string,
 }>;
 
 export type Dependencies<T = MixedOutput> = Map<string, Module<T>>;
-export type ReadOnlyDependencies<T = MixedOutput> = $ReadOnlyMap<
+export type ReadOnlyDependencies<T = MixedOutput> = ReadonlyMap<
   string,
   Module<T>,
 >;
@@ -98,28 +99,28 @@ export type TransformInputOptions = Omit<
   'inlinePlatform' | 'inlineRequires',
 >;
 
-export type GraphInputOptions = $ReadOnly<{
-  entryPoints: $ReadOnlySet<string>,
+export type GraphInputOptions = Readonly<{
+  entryPoints: ReadonlySet<string>,
   // Unused in core but useful for custom serializers / experimentalSerializerHook
   transformOptions: TransformInputOptions,
 }>;
 
 export interface ReadOnlyGraph<T = MixedOutput> {
-  +entryPoints: $ReadOnlySet<string>;
+  +entryPoints: ReadonlySet<string>;
   // Unused in core but useful for custom serializers / experimentalSerializerHook
-  +transformOptions: $ReadOnly<TransformInputOptions>;
+  +transformOptions: Readonly<TransformInputOptions>;
   +dependencies: ReadOnlyDependencies<T>;
 }
 
 export type {Graph};
 
-export type TransformResult<T = MixedOutput> = $ReadOnly<{
-  dependencies: $ReadOnlyArray<TransformResultDependency>,
-  output: $ReadOnlyArray<T>,
+export type TransformResult<T = MixedOutput> = Readonly<{
+  dependencies: ReadonlyArray<TransformResultDependency>,
+  output: ReadonlyArray<T>,
   unstable_transformResultKey?: ?string,
 }>;
 
-export type TransformResultWithSource<T = MixedOutput> = $ReadOnly<{
+export type TransformResultWithSource<T = MixedOutput> = Readonly<{
   ...TransformResult<T>,
   getSource: () => Buffer,
 }>;
@@ -141,21 +142,22 @@ export type AllowOptionalDependencies =
   | boolean
   | AllowOptionalDependenciesWithOptions;
 
-export type BundlerResolution = $ReadOnly<{
+export type BundlerResolution = Readonly<{
   type: 'sourceFile',
   filePath: string,
 }>;
 
-export type Options<T = MixedOutput> = {
-  +resolve: ResolveFn,
-  +transform: TransformFn<T>,
-  +transformOptions: TransformInputOptions,
-  +onProgress: ?(numProcessed: number, total: number) => mixed,
-  +lazy: boolean,
-  +unstable_allowRequireContext: boolean,
-  +unstable_enablePackageExports: boolean,
-  +shallow: boolean,
-};
+export type Options<T = MixedOutput> = Readonly<{
+  resolve: ResolveFn,
+  transform: TransformFn<T>,
+  transformOptions: TransformInputOptions,
+  onProgress: ?(numProcessed: number, total: number) => unknown,
+  lazy: boolean,
+  unstable_allowRequireContext: boolean,
+  unstable_enablePackageExports: boolean,
+  unstable_incrementalResolution: boolean,
+  shallow: boolean,
+}>;
 
 export type DeltaResult<T = MixedOutput> = {
   +added: Map<string, Module<T>>,
@@ -164,7 +166,7 @@ export type DeltaResult<T = MixedOutput> = {
   +reset: boolean,
 };
 
-export type SerializerOptions = $ReadOnly<{
+export type SerializerOptions = Readonly<{
   asyncRequireModulePath: string,
   createModuleId: string => number,
   dev: boolean,
@@ -178,7 +180,7 @@ export type SerializerOptions = $ReadOnly<{
   modulesOnly: boolean,
   processModuleFilter: (module: Module<>) => boolean,
   projectRoot: string,
-  runBeforeMainModule: $ReadOnlyArray<string>,
+  runBeforeMainModule: ReadonlyArray<string>,
   runModule: boolean,
   serverRoot: string,
   shouldAddToIgnoreList: (Module<>) => boolean,

package/src/DeltaBundler.d.ts

@@ -15,7 +15,9 @@ import type {
   Options,
   ReadOnlyGraph,
 } from './DeltaBundler/types';
-import type {EventEmitter} from 'events';
+import type EventEmitter from 'events';
+
+import DeltaCalculator from './DeltaBundler/DeltaCalculator';
 
 export type {
   DeltaResult,
@@ -29,8 +31,15 @@ export type {
   TransformResultDependency,
   TransformResultWithSource,
 } from './DeltaBundler/types';
-
-export default class DeltaBundler<T = MixedOutput> {
+/**
+ * `DeltaBundler` uses the `DeltaTransformer` to build bundle deltas. This
+ * module handles all the transformer instances so it can support multiple
+ * concurrent clients requesting their own deltas. This is done through the
+ * `clientId` param (which maps a client to a specific delta transformer).
+ */
+declare class DeltaBundler<T = MixedOutput> {
+  _changeEventSource: EventEmitter;
+  _deltaCalculators: Map<Graph<T>, DeltaCalculator<T>>;
   constructor(changeEventSource: EventEmitter);
   end(): void;
   getDependencies(
@@ -41,18 +50,11 @@ export default class DeltaBundler<T = MixedOutput> {
     entryPoints: ReadonlyArray<string>,
     options: Options<T>,
   ): Promise<Graph<T>>;
-
   getDelta(
     graph: Graph<T>,
-    {
-      reset,
-      shallow,
-    }: {
-      reset: boolean;
-      shallow: boolean;
-    },
+    $$PARAM_1$$: {reset: boolean; shallow: boolean},
   ): Promise<DeltaResult<T>>;
-
   listen(graph: Graph<T>, callback: () => Promise<void>): () => void;
   endGraph(graph: Graph<T>): void;
 }
+export default DeltaBundler;

package/src/DeltaBundler.js.flow

@@ -56,7 +56,7 @@ export default class DeltaBundler<T = MixedOutput> {
   }
 
   async getDependencies(
-    entryPoints: $ReadOnlyArray<string>,
+    entryPoints: ReadonlyArray<string>,
     options: Options<T>,
   ): Promise<ReadOnlyGraph<T>['dependencies']> {
     const deltaCalculator = new DeltaCalculator(
@@ -76,7 +76,7 @@ export default class DeltaBundler<T = MixedOutput> {
   // so that we don't leak graphs that are not reachable.
   // To get just the dependencies, use getDependencies which will not leak graphs.
   async buildGraph(
-    entryPoints: $ReadOnlyArray<string>,
+    entryPoints: ReadonlyArray<string>,
     options: Options<T>,
   ): Promise<Graph<T>> {
     const deltaCalculator = new DeltaCalculator(

package/src/HmrServer.d.ts

@@ -0,0 +1,79 @@
+/**
+ * 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
+ */
+
+import type {
+  RevisionId,
+  default as IncrementalBundler,
+} from './IncrementalBundler';
+import type {GraphOptions} from './shared/types';
+import type {ConfigT, RootPerfLogger} from 'metro-config';
+import type {
+  HmrErrorMessage,
+  HmrUpdateMessage,
+} from 'metro-runtime/src/modules/types';
+
+export type Client = {
+  optedIntoHMR: boolean;
+  revisionIds: Array<RevisionId>;
+  readonly sendFn: ($$PARAM_0$$: string) => void;
+};
+type ClientGroup = {
+  readonly clients: Set<Client>;
+  clientUrl: URL;
+  revisionId: RevisionId;
+  readonly unlisten: () => void;
+  readonly graphOptions: GraphOptions;
+};
+/**
+ * The HmrServer (Hot Module Reloading) implements a lightweight interface
+ * to communicate easily to the logic in the React Native repository (which
+ * is the one that handles the Web Socket connections).
+ *
+ * This interface allows the HmrServer to hook its own logic to WS clients
+ * getting connected, disconnected or having errors (through the
+ * `onClientConnect`, `onClientDisconnect` and `onClientError` methods).
+ */
+declare class HmrServer<TClient extends Client> {
+  _config: ConfigT;
+  _bundler: IncrementalBundler;
+  _createModuleId: (path: string) => number;
+  _clientGroups: Map<RevisionId, ClientGroup>;
+  constructor(
+    bundler: IncrementalBundler,
+    createModuleId: (path: string) => number,
+    config: ConfigT,
+  );
+  onClientConnect: (
+    requestUrl: string,
+    sendFn: (data: string) => void,
+  ) => Promise<Client>;
+  _registerEntryPoint(
+    client: Client,
+    originalRequestUrl: string,
+    sendFn: (data: string) => void,
+  ): Promise<void>;
+  onClientMessage: (
+    client: TClient,
+    message: string | Buffer | ArrayBuffer | Array<Buffer>,
+    sendFn: (data: string) => void,
+  ) => Promise<void>;
+  onClientError: (client: TClient, e: Error) => void;
+  onClientDisconnect: (client: TClient) => void;
+  _handleFileChange(
+    group: ClientGroup,
+    options: {isInitialUpdate: boolean},
+    changeEvent: null | undefined | {logger: null | undefined | RootPerfLogger},
+  ): Promise<void>;
+  _prepareMessage(
+    group: ClientGroup,
+    options: {isInitialUpdate: boolean},
+    changeEvent: null | undefined | {logger: null | undefined | RootPerfLogger},
+  ): Promise<HmrUpdateMessage | HmrErrorMessage>;
+}
+export default HmrServer;

package/src/HmrServer.js

@@ -31,28 +31,32 @@ var transformHelpers = _interopRequireWildcard(
 );
 var _metroCore = require("metro-core");
 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 };
@@ -77,9 +81,10 @@ class HmrServer {
       optedIntoHMR: false,
     };
   };
-  async _registerEntryPoint(client, requestUrl, sendFn) {
-    debug("Registering entry point: %s", requestUrl);
-    requestUrl = this._config.server.rewriteRequestUrl(requestUrl);
+  async _registerEntryPoint(client, originalRequestUrl, sendFn) {
+    debug("Registering entry point: %s", originalRequestUrl);
+    const requestUrl =
+      this._config.server.rewriteRequestUrl(originalRequestUrl);
     debug("Rewritten as: %s", requestUrl);
     const { bundleType: _bundleType, ...options } = (0,
     _parseBundleOptionsFromBundleRequestUrl.default)(
@@ -150,7 +155,7 @@ class HmrServer {
         unlisten: () => unlisten(),
       };
       this._clientGroups.set(id, clientGroup);
-      let latestEventArgs = [];
+      let latestChangeEvent = null;
       const debounceCallHandleFileChange = (0, _debounceAsyncQueue.default)(
         async () => {
           await this._handleFileChange(
@@ -158,15 +163,15 @@ class HmrServer {
             {
               isInitialUpdate: false,
             },
-            ...latestEventArgs,
+            latestChangeEvent,
           );
         },
         50,
       );
       const unlisten = this._bundler
         .getDeltaBundler()
-        .listen(graph, async (...args) => {
-          latestEventArgs = args;
+        .listen(graph, async (changeEvent) => {
+          latestChangeEvent = changeEvent;
           await debounceCallHandleFileChange();
         });
     }
@@ -218,7 +223,7 @@ class HmrServer {
   onClientError = (client, e) => {
     this._config.reporter.update({
       type: "hmr_client_error",
-      error: e.error,
+      error: e,
     });
     this.onClientDisconnect(client);
   };

package/src/HmrServer.js.flow

@@ -4,11 +4,14 @@
  * 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
- * @flow
  */
 
-import type IncrementalBundler, {RevisionId} from './IncrementalBundler';
+import type {
+  RevisionId,
+  default as IncrementalBundler,
+} from './IncrementalBundler';
 import type {GraphOptions} from './shared/types';
 import type {ConfigT, RootPerfLogger} from 'metro-config';
 import type {
@@ -93,11 +96,12 @@ export default class HmrServer<TClient: Client> {
 
   async _registerEntryPoint(
     client: Client,
-    requestUrl: string,
+    originalRequestUrl: string,
     sendFn: (data: string) => void,
   ): Promise<void> {
-    debug('Registering entry point: %s', requestUrl);
-    requestUrl = this._config.server.rewriteRequestUrl(requestUrl);
+    debug('Registering entry point: %s', originalRequestUrl);
+    const requestUrl =
+      this._config.server.rewriteRequestUrl(originalRequestUrl);
     debug('Rewritten as: %s', requestUrl);
 
     const {bundleType: _bundleType, ...options} =
@@ -176,21 +180,22 @@ export default class HmrServer<TClient: Client> {
 
       this._clientGroups.set(id, clientGroup);
 
-      let latestEventArgs: Array<any> = [];
+      let latestChangeEvent: ?{
+        logger: ?RootPerfLogger,
+      } = null;
 
       const debounceCallHandleFileChange = debounceAsyncQueue(async () => {
         await this._handleFileChange(
           nullthrows(clientGroup),
           {isInitialUpdate: false},
-          ...latestEventArgs,
+          latestChangeEvent,
         );
       }, 50);
 
       const unlisten = this._bundler
         .getDeltaBundler()
-        // $FlowFixMe[missing-local-annot]
-        .listen(graph, async (...args) => {
-          latestEventArgs = args;
+        .listen(graph, async changeEvent => {
+          latestChangeEvent = changeEvent;
           await debounceCallHandleFileChange();
         });
     }
@@ -242,10 +247,10 @@ export default class HmrServer<TClient: Client> {
     return Promise.resolve();
   };
 
-  onClientError: (client: TClient, e: ErrorEvent) => void = (client, e) => {
+  onClientError: (client: TClient, e: Error) => void = (client, e) => {
     this._config.reporter.update({
       type: 'hmr_client_error',
-      error: e.error,
+      error: e,
     });
     this.onClientDisconnect(client);
   };

package/src/IncrementalBundler/GraphNotFoundError.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 {GraphId} from '../lib/getGraphId';
+
+declare class GraphNotFoundError extends Error {
+  graphId: GraphId;
+  constructor(graphId: GraphId);
+}
+export default GraphNotFoundError;

package/src/IncrementalBundler/ResourceNotFoundError.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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
+ */
+
+declare class ResourceNotFoundError extends Error {
+  resourcePath: string;
+  constructor(resourcePath: string);
+}
+export default ResourceNotFoundError;

package/src/IncrementalBundler/RevisionNotFoundError.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 {RevisionId} from '../IncrementalBundler';
+
+declare class RevisionNotFoundError extends Error {
+  revisionId: RevisionId;
+  constructor(revisionId: RevisionId);
+}
+export default RevisionNotFoundError;