metro 0.83.4 → 0.83.6

package/src/DeltaBundler/types.d.ts

@@ -0,0 +1,170 @@
+/**
+ * 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<<feddf9cb00d4a097d348531773c9f0bd>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/DeltaBundler/types.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+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 = {readonly data: unknown; readonly type: string};
+export type AsyncDependencyType = 'async' | 'maybeSync' | 'prefetch' | 'weak';
+export type TransformResultDependency = Readonly<{
+  /**
+   * The literal name provided to a require or import call. For example 'foo' in
+   * case of `require('foo')`.
+   */
+  name: string;
+  /**
+   * Extra data returned by the dependency extractor.
+   */
+  data: Readonly<{
+    /**
+     * A locally unique key for this dependency within the current module.
+     */
+    key: string;
+    /**
+     * If not null, this dependency is due to a dynamic `import()` or `__prefetchImport()` call.
+     */
+    asyncType: AsyncDependencyType | null;
+    /**
+     * True if the dependency is declared with a static "import x from 'y'" or
+     * an import() call.
+     */
+    isESMImport: boolean;
+    /**
+     * The dependency is enclosed in a try/catch block.
+     */
+    isOptional?: boolean;
+    locs: ReadonlyArray<ReadonlySourceLocation>;
+    /** Context for requiring a collection of modules. */
+    contextParams?: RequireContextParams;
+  }>;
+}>;
+export type ResolvedDependency = Readonly<{
+  absolutePath: string;
+  data: TransformResultDependency;
+}>;
+export type Dependency =
+  | ResolvedDependency
+  | Readonly<{data: TransformResultDependency}>;
+export type Module<T = MixedOutput> = Readonly<{
+  dependencies: Map<string, Dependency>;
+  inverseDependencies: CountingSet<string>;
+  output: ReadonlyArray<T>;
+  path: string;
+  getSource: () => Buffer;
+  unstable_transformResultKey?: null | undefined | string;
+}>;
+export type ModuleData<T = MixedOutput> = Readonly<{
+  dependencies: ReadonlyMap<string, Dependency>;
+  resolvedContexts: ReadonlyMap<string, RequireContext>;
+  output: ReadonlyArray<T>;
+  getSource: () => Buffer;
+  unstable_transformResultKey?: null | undefined | string;
+}>;
+export type Dependencies<T = MixedOutput> = Map<string, Module<T>>;
+export type ReadOnlyDependencies<T = MixedOutput> = ReadonlyMap<
+  string,
+  Module<T>
+>;
+export type TransformInputOptions = Omit<
+  JsTransformOptions,
+  'inlinePlatform' | 'inlineRequires'
+>;
+export type GraphInputOptions = Readonly<{
+  entryPoints: ReadonlySet<string>;
+  transformOptions: TransformInputOptions;
+}>;
+export interface ReadOnlyGraph<T = MixedOutput> {
+  readonly entryPoints: ReadonlySet<string>;
+  readonly transformOptions: Readonly<TransformInputOptions>;
+  readonly dependencies: ReadOnlyDependencies<T>;
+}
+export type {Graph};
+export type TransformResult<T = MixedOutput> = Readonly<{
+  dependencies: ReadonlyArray<TransformResultDependency>;
+  output: ReadonlyArray<T>;
+  unstable_transformResultKey?: null | undefined | string;
+}>;
+export type TransformResultWithSource<T = MixedOutput> = Readonly<
+  Omit<TransformResult<T>, keyof {getSource: () => Buffer}> & {
+    getSource: () => Buffer;
+  }
+>;
+export type TransformFn<T = MixedOutput> = (
+  $$PARAM_0$$: string,
+  $$PARAM_1$$: null | undefined | RequireContext,
+) => Promise<TransformResultWithSource<T>>;
+export type ResolveFn = (
+  from: string,
+  dependency: TransformResultDependency,
+) => BundlerResolution;
+export type AllowOptionalDependenciesWithOptions = {
+  readonly exclude: Array<string>;
+};
+export type AllowOptionalDependencies =
+  | boolean
+  | AllowOptionalDependenciesWithOptions;
+export type BundlerResolution = Readonly<{
+  type: 'sourceFile';
+  filePath: string;
+}>;
+export type Options<T = MixedOutput> = Readonly<{
+  resolve: ResolveFn;
+  transform: TransformFn<T>;
+  transformOptions: TransformInputOptions;
+  onProgress:
+    | null
+    | undefined
+    | ((numProcessed: number, total: number) => unknown);
+  lazy: boolean;
+  unstable_allowRequireContext: boolean;
+  unstable_enablePackageExports: boolean;
+  unstable_incrementalResolution: boolean;
+  shallow: boolean;
+}>;
+export type DeltaResult<T = MixedOutput> = {
+  readonly added: Map<string, Module<T>>;
+  readonly modified: Map<string, Module<T>>;
+  readonly deleted: Set<string>;
+  readonly reset: boolean;
+};
+export type SerializerOptions = Readonly<{
+  asyncRequireModulePath: string;
+  createModuleId: ($$PARAM_0$$: string) => number;
+  dev: boolean;
+  getRunModuleStatement: (
+    moduleId: number | string,
+    globalPrefix: string,
+  ) => string;
+  globalPrefix: string;
+  includeAsyncPaths: boolean;
+  inlineSourceMap: null | undefined | boolean;
+  modulesOnly: boolean;
+  processModuleFilter: (module: Module) => boolean;
+  projectRoot: string;
+  runBeforeMainModule: ReadonlyArray<string>;
+  runModule: boolean;
+  serverRoot: string;
+  shouldAddToIgnoreList: ($$PARAM_0$$: Module) => boolean;
+  sourceMapUrl: null | undefined | string;
+  sourceUrl: null | undefined | string;
+  getSourceUrl: null | undefined | (($$PARAM_0$$: Module) => string);
+}>;

package/src/DeltaBundler/types.js

@@ -2,9 +2,5 @@
 
 var _CountingSet = _interopRequireDefault(require("../lib/CountingSet"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }

package/src/DeltaBundler.d.ts

@@ -0,0 +1,67 @@
+/**
+ * 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<<db564db653a99b07f3ad7585b2bed707>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/DeltaBundler.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {
+  DeltaResult,
+  Graph,
+  MixedOutput,
+  Options,
+  ReadOnlyGraph,
+} from './DeltaBundler/types';
+import type EventEmitter from 'events';
+
+import DeltaCalculator from './DeltaBundler/DeltaCalculator';
+
+export type {
+  DeltaResult,
+  Graph,
+  Dependencies,
+  MixedOutput,
+  Module,
+  ReadOnlyGraph,
+  TransformFn,
+  TransformResult,
+  TransformResultDependency,
+  TransformResultWithSource,
+} from './DeltaBundler/types';
+/**
+ * `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(
+    entryPoints: ReadonlyArray<string>,
+    options: Options<T>,
+  ): Promise<ReadOnlyGraph<T>['dependencies']>;
+  buildGraph(
+    entryPoints: ReadonlyArray<string>,
+    options: Options<T>,
+  ): Promise<Graph<T>>;
+  getDelta(
+    graph: Graph<T>,
+    $$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

@@ -8,11 +8,7 @@ var _DeltaCalculator = _interopRequireDefault(
   require("./DeltaBundler/DeltaCalculator"),
 );
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 class DeltaBundler {
   _deltaCalculators = new Map();

package/src/HmrServer.d.ts

@@ -0,0 +1,98 @@
+/**
+ * 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
+ * @generated SignedSource<<ab4c245134631e14db114a9d49da79d1>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/HmrServer.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+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
+      | {
+          readonly logger: null | undefined | RootPerfLogger;
+          readonly changeId?: string;
+        },
+  ): Promise<void>;
+  _prepareMessage(
+    group: ClientGroup,
+    options: {isInitialUpdate: boolean},
+    changeEvent:
+      | null
+      | undefined
+      | {
+          readonly logger: null | undefined | RootPerfLogger;
+          readonly changeId?: string;
+        },
+  ): Promise<HmrUpdateMessage | HmrErrorMessage>;
+}
+export default HmrServer;

package/src/HmrServer.js

@@ -39,10 +39,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)) {
@@ -62,11 +59,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:HMR");
 const { createActionStartEntry, createActionEndEntry, log } = _metroCore.Logger;
@@ -221,6 +214,10 @@ class HmrServer {
         case "log-opt-in":
           client.optedIntoHMR = true;
           break;
+        case "heartbeat":
+          debug("Heartbeat received");
+          sendFn(String(message));
+          break;
         default:
           break;
       }
@@ -272,6 +269,9 @@ class HmrServer {
     send(sendFns, message);
     send(sendFns, {
       type: "update-done",
+      body: {
+        changeId: changeEvent?.changeId,
+      },
     });
     log({
       ...createActionEndEntry(processingHmrChange),

package/src/HmrServer.js.flow

@@ -66,7 +66,7 @@ function send(sendFns: Array<(string) => void>, message: HmrMessage): void {
  * getting connected, disconnected or having errors (through the
  * `onClientConnect`, `onClientDisconnect` and `onClientError` methods).
  */
-export default class HmrServer<TClient: Client> {
+export default class HmrServer<TClient extends Client> {
   _config: ConfigT;
   _bundler: IncrementalBundler;
   _createModuleId: (path: string) => number;
@@ -181,7 +181,8 @@ export default class HmrServer<TClient: Client> {
       this._clientGroups.set(id, clientGroup);
 
       let latestChangeEvent: ?{
-        logger: ?RootPerfLogger,
+        +logger: ?RootPerfLogger,
+        +changeId: string,
       } = null;
 
       const debounceCallHandleFileChange = debounceAsyncQueue(async () => {
@@ -240,6 +241,10 @@ export default class HmrServer<TClient: Client> {
         case 'log-opt-in':
           client.optedIntoHMR = true;
           break;
+        case 'heartbeat':
+          debug('Heartbeat received');
+          sendFn(String(message));
+          break;
         default:
           break;
       }
@@ -273,7 +278,8 @@ export default class HmrServer<TClient: Client> {
     group: ClientGroup,
     options: {isInitialUpdate: boolean},
     changeEvent: ?{
-      logger: ?RootPerfLogger,
+      +logger: ?RootPerfLogger,
+      +changeId?: string,
     },
   ): Promise<void> {
     const logger = !options.isInitialUpdate ? changeEvent?.logger : null;
@@ -308,7 +314,10 @@ export default class HmrServer<TClient: Client> {
 
     const message = await this._prepareMessage(group, options, changeEvent);
     send(sendFns, message);
-    send(sendFns, {type: 'update-done'});
+    send(sendFns, {
+      type: 'update-done',
+      body: {changeId: changeEvent?.changeId},
+    });
 
     log({
       ...createActionEndEntry(processingHmrChange),
@@ -328,7 +337,8 @@ export default class HmrServer<TClient: Client> {
     group: ClientGroup,
     options: {isInitialUpdate: boolean},
     changeEvent: ?{
-      logger: ?RootPerfLogger,
+      +logger: ?RootPerfLogger,
+      +changeId?: string,
     },
   ): Promise<HmrUpdateMessage | HmrErrorMessage> {
     const logger = !options.isInitialUpdate ? changeEvent?.logger : null;

package/src/IncrementalBundler/GraphNotFoundError.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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<<850ba6867e140fb0973cd13d0fd1bc60>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/IncrementalBundler/GraphNotFoundError.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+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,22 @@
+/**
+ * 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<<6a9d75bc74b654362c3563ec8babda0b>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/IncrementalBundler/ResourceNotFoundError.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+declare class ResourceNotFoundError extends Error {
+  resourcePath: string;
+  constructor(resourcePath: string);
+}
+export default ResourceNotFoundError;

package/src/IncrementalBundler/RevisionNotFoundError.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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<<2c2d4a1a2d357eb73806a68bba897795>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/IncrementalBundler/RevisionNotFoundError.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {RevisionId} from '../IncrementalBundler';
+
+declare class RevisionNotFoundError extends Error {
+  revisionId: RevisionId;
+  constructor(revisionId: RevisionId);
+}
+export default RevisionNotFoundError;

package/src/IncrementalBundler.d.ts

@@ -0,0 +1,103 @@
+/**
+ * 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<<0ec72971869a882d97b381e3f1baa922>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/IncrementalBundler.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {DeltaResult, Graph, Module} from './DeltaBundler';
+import type {
+  Options as DeltaBundlerOptions,
+  ReadOnlyDependencies,
+  TransformInputOptions,
+} from './DeltaBundler/types';
+import type {GraphId} from './lib/getGraphId';
+import type {ResolverInputOptions} from './shared/types';
+import type {ConfigT} from 'metro-config';
+
+import Bundler from './Bundler';
+import DeltaBundler from './DeltaBundler';
+
+export declare type RevisionId = string;
+export type OutputGraph = Graph;
+type OtherOptions = Readonly<{
+  onProgress: DeltaBundlerOptions['onProgress'];
+  shallow: boolean;
+  lazy: boolean;
+}>;
+export type GraphRevision = {
+  readonly id: RevisionId;
+  readonly date: Date;
+  readonly graphId: GraphId;
+  readonly graph: OutputGraph;
+  readonly prepend: ReadonlyArray<Module>;
+};
+export type IncrementalBundlerOptions = Readonly<{
+  hasReducedPerformance?: boolean;
+  watch?: boolean;
+}>;
+declare class IncrementalBundler {
+  _config: ConfigT;
+  _bundler: Bundler;
+  _deltaBundler: DeltaBundler;
+  _revisionsById: Map<RevisionId, Promise<GraphRevision>>;
+  _revisionsByGraphId: Map<GraphId, Promise<GraphRevision>>;
+  static revisionIdFromString: (str: string) => RevisionId;
+  constructor(config: ConfigT, options?: IncrementalBundlerOptions);
+  end(): Promise<void>;
+  getBundler(): Bundler;
+  getDeltaBundler(): DeltaBundler;
+  getRevision(
+    revisionId: RevisionId,
+  ): null | undefined | Promise<GraphRevision>;
+  getRevisionByGraphId(
+    graphId: GraphId,
+  ): null | undefined | Promise<GraphRevision>;
+  buildGraphForEntries(
+    entryFiles: ReadonlyArray<string>,
+    transformOptions: TransformInputOptions,
+    resolverOptions: ResolverInputOptions,
+    otherOptions?: OtherOptions,
+  ): Promise<OutputGraph>;
+  getDependencies(
+    entryFiles: ReadonlyArray<string>,
+    transformOptions: TransformInputOptions,
+    resolverOptions: ResolverInputOptions,
+    otherOptions?: OtherOptions,
+  ): Promise<ReadOnlyDependencies>;
+  buildGraph(
+    entryFile: string,
+    transformOptions: TransformInputOptions,
+    resolverOptions: ResolverInputOptions,
+    otherOptions?: OtherOptions,
+  ): Promise<{
+    readonly graph: OutputGraph;
+    readonly prepend: ReadonlyArray<Module>;
+  }>;
+  initializeGraph(
+    entryFile: string,
+    transformOptions: TransformInputOptions,
+    resolverOptions: ResolverInputOptions,
+    otherOptions?: OtherOptions,
+  ): Promise<{delta: DeltaResult; revision: GraphRevision}>;
+  updateGraph(
+    revision: GraphRevision,
+    reset: boolean,
+  ): Promise<{delta: DeltaResult; revision: GraphRevision}>;
+  endGraph(graphId: GraphId): Promise<void>;
+  _getAbsoluteEntryFiles(
+    entryFiles: ReadonlyArray<string>,
+  ): Promise<ReadonlyArray<string>>;
+  ready(): Promise<void>;
+}
+export default IncrementalBundler;

package/src/IncrementalBundler.js

@@ -27,10 +27,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)) {
@@ -50,11 +47,7 @@ function _interopRequireWildcard(e, t) {
   })(e, t);
 }
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 function createRevisionId() {
   return _crypto.default.randomBytes(8).toString("hex");