metro 0.84.1 → 0.84.3

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/ModuleGraph/worker/JsFileWrapping.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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<<ef37054bf63dff008ccc8b58a2411597>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/ModuleGraph/worker/JsFileWrapping.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {File as BabelNodeFile} from '@babel/types';
+
+declare const WRAP_NAME: '$$_REQUIRE';
+declare function wrapModule(
+  fileAst: BabelNodeFile,
+  importDefaultName: string,
+  importAllName: string,
+  dependencyMapName: string,
+  globalPrefix: string,
+  skipRequireRename: boolean,
+  $$PARAM_6$$?: Readonly<{unstable_useStaticHermesModuleFactory?: boolean}>,
+): {ast: BabelNodeFile; requireName: string};
+declare function wrapPolyfill(fileAst: BabelNodeFile): BabelNodeFile;
+declare function jsonToCommonJS(source: string): string;
+declare function wrapJson(
+  source: string,
+  globalPrefix: string,
+  unstable_useStaticHermesModuleFactory?: boolean,
+): string;
+export {WRAP_NAME, wrapJson, jsonToCommonJS, wrapModule, wrapPolyfill};

package/src/ModuleGraph/worker/collectDependencies.d.ts

@@ -0,0 +1,138 @@
+/**
+ * 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<<ab2d1203f736c3032c6b9d15cc74680b>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/ModuleGraph/worker/collectDependencies.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {ReadonlySourceLocation} from '../../shared/types';
+import type {NodePath} from '@babel/traverse';
+import type {
+  CallExpression,
+  File as BabelNodeFile,
+  Identifier,
+  StringLiteral,
+} from '@babel/types';
+import type {
+  AllowOptionalDependencies,
+  AsyncDependencyType,
+} from 'metro/private/DeltaBundler/types';
+
+export type Dependency = Readonly<{data: DependencyData; name: string}>;
+export type ContextMode = 'sync' | 'eager' | 'lazy' | 'lazy-once';
+type ContextFilter = Readonly<{pattern: string; flags: string}>;
+export type RequireContextParams = Readonly<{
+  recursive: boolean;
+  filter: Readonly<ContextFilter>;
+  /** Mode for resolving dynamic dependencies. Defaults to `sync` */
+  mode: ContextMode;
+}>;
+type DependencyData = Readonly<{
+  key: string;
+  asyncType: AsyncDependencyType | null;
+  isESMImport: boolean;
+  isOptional?: boolean;
+  locs: ReadonlyArray<ReadonlySourceLocation>;
+  /** Context for requiring a collection of modules. */
+  contextParams?: RequireContextParams;
+}>;
+export type MutableInternalDependency = Omit<
+  DependencyData,
+  keyof {locs: Array<ReadonlySourceLocation>; index: number; name: string}
+> & {locs: Array<ReadonlySourceLocation>; index: number; name: string};
+export type InternalDependency = Readonly<MutableInternalDependency>;
+export type State = {
+  asyncRequireModulePathStringLiteral: null | undefined | StringLiteral;
+  dependencyCalls: Set<string>;
+  dependencyRegistry: DependencyRegistry;
+  dependencyTransformer: DependencyTransformer;
+  dynamicRequires: DynamicRequiresBehavior;
+  dependencyMapIdentifier: null | undefined | Identifier;
+  keepRequireNames: boolean;
+  allowOptionalDependencies: AllowOptionalDependencies;
+  /** Enable `require.context` statements which can be used to import multiple files in a directory. */
+  unstable_allowRequireContext: boolean;
+  unstable_isESMImportAtSource:
+    | null
+    | undefined
+    | (($$PARAM_0$$: ReadonlySourceLocation) => boolean);
+};
+export type Options = Readonly<{
+  asyncRequireModulePath: string;
+  dependencyMapName: null | undefined | string;
+  dynamicRequires: DynamicRequiresBehavior;
+  inlineableCalls: ReadonlyArray<string>;
+  keepRequireNames: boolean;
+  allowOptionalDependencies: AllowOptionalDependencies;
+  dependencyTransformer?: DependencyTransformer;
+  /** Enable `require.context` statements which can be used to import multiple files in a directory. */
+  unstable_allowRequireContext: boolean;
+  unstable_isESMImportAtSource?:
+    | null
+    | undefined
+    | (($$PARAM_0$$: ReadonlySourceLocation) => boolean);
+}>;
+export type CollectedDependencies = Readonly<{
+  ast: BabelNodeFile;
+  dependencyMapName: string;
+  dependencies: ReadonlyArray<Dependency>;
+}>;
+export interface DependencyTransformer {
+  transformSyncRequire(
+    path: NodePath<CallExpression>,
+    dependency: InternalDependency,
+    state: State,
+  ): void;
+  transformImportCall(
+    path: NodePath,
+    dependency: InternalDependency,
+    state: State,
+  ): void;
+  transformImportMaybeSyncCall(
+    path: NodePath,
+    dependency: InternalDependency,
+    state: State,
+  ): void;
+  transformPrefetch(
+    path: NodePath,
+    dependency: InternalDependency,
+    state: State,
+  ): void;
+  transformIllegalDynamicRequire(path: NodePath, state: State): void;
+}
+export type DynamicRequiresBehavior = 'throwAtRuntime' | 'reject';
+/**
+ * Transform all the calls to `require()` and `import()` in a file into ID-
+ * independent code, and return the list of dependencies. For example, a call
+ * like `require('Foo')` could be transformed to `require(_depMap[3], 'Foo')`
+ * where `_depMap` is provided by the outer scope. As such, we don't need to
+ * know the actual module ID.
+ *
+ * The second argument is only provided for debugging purposes.
+ */
+declare function collectDependencies(
+  ast: BabelNodeFile,
+  options: Options,
+): CollectedDependencies;
+export default collectDependencies;
+export type ImportQualifier = Readonly<{
+  name: string;
+  asyncType: AsyncDependencyType | null;
+  isESMImport: boolean;
+  optional: boolean;
+  contextParams?: RequireContextParams;
+}>;
+declare class DependencyRegistry {
+  _dependencies: Map<string, InternalDependency>;
+  registerDependency(qualifier: ImportQualifier): InternalDependency;
+  getDependencies(): Array<InternalDependency>;
+}

package/src/ModuleGraph/worker/generateImportNames.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
+ * @generated SignedSource<<9632d9ca461f1fd6aad9131d7afb5839>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/ModuleGraph/worker/generateImportNames.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {Node} from '@babel/types';
+/**
+ * Select unused names for "metroImportDefault" and "metroImportAll", by
+ * calling "generateUid".
+ */
+declare function generateImportNames(ast: Node): {
+  importAll: string;
+  importDefault: string;
+};
+export default generateImportNames;

package/src/ModuleGraph/worker/importLocationsPlugin.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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<<644d25f2f9682a306271d052d09b1d2d>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/ModuleGraph/worker/importLocationsPlugin.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {ReadonlySourceLocation} from '../../shared/types';
+import type {PluginObj} from '@babel/core';
+import type * as $$IMPORT_TYPEOF_1$$ from '@babel/types';
+import type {MetroBabelFileMetadata} from 'metro-babel-transformer';
+
+type Types = typeof $$IMPORT_TYPEOF_1$$;
+type ImportDeclarationLocs = Set<string>;
+type State = {
+  importDeclarationLocs: ImportDeclarationLocs;
+  file: {metadata?: MetroBabelFileMetadata};
+};
+declare function importLocationsPlugin($$PARAM_0$$: {
+  types: Types;
+}): PluginObj<State>;
+declare function locToKey(loc: ReadonlySourceLocation): string;
+export {importLocationsPlugin, locToKey};

package/src/Server/MultipartResponse.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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<<355f5514464c4989f90a211782db41e7>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/Server/MultipartResponse.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {IncomingMessage, ServerResponse} from 'http';
+
+type Data = string | Buffer | Uint8Array;
+type Headers = {[$$Key$$: string]: string | number};
+declare class MultipartResponse {
+  static wrapIfSupported(
+    req: IncomingMessage,
+    res: ServerResponse,
+  ): MultipartResponse | ServerResponse;
+  static serializeHeaders(headers: Headers): string;
+  res: ServerResponse;
+  headers: Headers;
+  constructor(res: ServerResponse);
+  writeChunk(headers: Headers | null, data?: Data, isLast?: boolean): void;
+  writeHead(status: number, headers?: Headers): void;
+  setHeader(name: string, value: string | number): void;
+  end(data?: Data): void;
+  once(name: string, fn: () => unknown): this;
+}
+export default MultipartResponse;

package/src/Server/symbolicate.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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<<74bba01977b0b5887c4bb38eb8fc78ea>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/Server/symbolicate.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {ExplodedSourceMap} from '../DeltaBundler/Serializers/getExplodedSourceMap';
+import type {ConfigT} from 'metro-config';
+
+export type StackFrameInput = {
+  readonly file: null | undefined | string;
+  readonly lineNumber: null | undefined | number;
+  readonly column: null | undefined | number;
+  readonly methodName: null | undefined | string;
+};
+export type IntermediateStackFrame = Omit<
+  StackFrameInput,
+  keyof {collapse?: boolean}
+> & {collapse?: boolean};
+export type StackFrameOutput = Readonly<IntermediateStackFrame>;
+declare function symbolicate(
+  stack: ReadonlyArray<StackFrameInput>,
+  maps: Iterable<[string, ExplodedSourceMap]>,
+  config: ConfigT,
+  extraData: unknown,
+): Promise<ReadonlyArray<StackFrameOutput>>;
+export default symbolicate;