metro 0.83.3 → 0.83.5

package/src/ModuleGraph/worker/collectDependencies.js.flow

@@ -4,12 +4,18 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @format
  * @flow
+ * @format
  */
 
+import type {ReadonlySourceLocation} from '../../shared/types';
 import type {NodePath} from '@babel/traverse';
-import type {CallExpression, Identifier, StringLiteral} from '@babel/types';
+import type {
+  CallExpression,
+  File as BabelNodeFile,
+  Identifier,
+  StringLiteral,
+} from '@babel/types';
 import type {
   AllowOptionalDependencies,
   AsyncDependencyType,
@@ -24,12 +30,12 @@ import crypto from 'crypto';
 import invariant from 'invariant';
 import nullthrows from 'nullthrows';
 
-type ImportDependencyOptions = $ReadOnly<{
+type ImportDependencyOptions = Readonly<{
   asyncType: AsyncDependencyType,
   isESMImport: boolean,
 }>;
 
-export type Dependency = $ReadOnly<{
+export type Dependency = Readonly<{
   data: DependencyData,
   name: string,
 }>;
@@ -37,18 +43,18 @@ export type Dependency = $ReadOnly<{
 // TODO: Convert to a Flow enum
 export type ContextMode = 'sync' | 'eager' | 'lazy' | 'lazy-once';
 
-type ContextFilter = $ReadOnly<{pattern: string, flags: string}>;
+type ContextFilter = Readonly<{pattern: string, flags: string}>;
 
-export type RequireContextParams = $ReadOnly<{
+export type RequireContextParams = Readonly<{
   /* Should search for files recursively. Optional, default `true` when `require.context` is used */
   recursive: boolean,
   /* Filename filter pattern for use in `require.context`. Optional, default `.*` (any file) when `require.context` is used */
-  filter: $ReadOnly<ContextFilter>,
+  filter: Readonly<ContextFilter>,
   /** Mode for resolving dynamic dependencies. Defaults to `sync` */
   mode: ContextMode,
 }>;
 
-type DependencyData = $ReadOnly<{
+type DependencyData = Readonly<{
   // A locally unique key for this dependency within the current module.
   key: string,
   // If null, then the dependency is synchronous.
@@ -60,19 +66,19 @@ type DependencyData = $ReadOnly<{
   // and subpath imports.
   isESMImport: boolean,
   isOptional?: boolean,
-  locs: $ReadOnlyArray<BabelSourceLocation>,
+  locs: ReadonlyArray<ReadonlySourceLocation>,
   /** Context for requiring a collection of modules. */
   contextParams?: RequireContextParams,
 }>;
 
 export type MutableInternalDependency = {
   ...DependencyData,
-  locs: Array<BabelSourceLocation>,
+  locs: Array<ReadonlySourceLocation>,
   index: number,
   name: string,
 };
 
-export type InternalDependency = $ReadOnly<MutableInternalDependency>;
+export type InternalDependency = Readonly<MutableInternalDependency>;
 
 export type State = {
   asyncRequireModulePathStringLiteral: ?StringLiteral,
@@ -85,26 +91,26 @@ export type State = {
   allowOptionalDependencies: AllowOptionalDependencies,
   /** Enable `require.context` statements which can be used to import multiple files in a directory. */
   unstable_allowRequireContext: boolean,
-  unstable_isESMImportAtSource: ?(BabelSourceLocation) => boolean,
+  unstable_isESMImportAtSource: ?(ReadonlySourceLocation) => boolean,
 };
 
-export type Options = $ReadOnly<{
+export type Options = Readonly<{
   asyncRequireModulePath: string,
   dependencyMapName: ?string,
   dynamicRequires: DynamicRequiresBehavior,
-  inlineableCalls: $ReadOnlyArray<string>,
+  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?: ?(BabelSourceLocation) => boolean,
+  unstable_isESMImportAtSource?: ?(ReadonlySourceLocation) => boolean,
 }>;
 
-export type CollectedDependencies = $ReadOnly<{
+export type CollectedDependencies = Readonly<{
   ast: BabelNodeFile,
   dependencyMapName: string,
-  dependencies: $ReadOnlyArray<Dependency>,
+  dependencies: ReadonlyArray<Dependency>,
 }>;
 
 export interface DependencyTransformer {
@@ -562,7 +568,7 @@ function processRequireCall(
   transformer.transformSyncRequire(path, dep, state);
 }
 
-function getNearestLocFromPath(path: NodePath<>): ?BabelSourceLocation {
+function getNearestLocFromPath(path: NodePath<>): ?ReadonlySourceLocation {
   let current: ?(NodePath<> | NodePath<BabelNode>) = path;
   while (
     current &&
@@ -582,7 +588,7 @@ function getNearestLocFromPath(path: NodePath<>): ?BabelSourceLocation {
   );
 }
 
-export type ImportQualifier = $ReadOnly<{
+export type ImportQualifier = Readonly<{
   name: string,
   asyncType: AsyncDependencyType | null,
   isESMImport: boolean,
@@ -732,11 +738,11 @@ const DefaultDependencyTransformer: DependencyTransformer = {
     state: State,
   ): void {
     const moduleIDExpression = createModuleIDExpression(dependency, state);
-    path.node.arguments = ([moduleIDExpression]: Array<
+    path.node.arguments = [moduleIDExpression] as Array<
       | BabelNodeExpression
       | BabelNodeSpreadElement
       | BabelNodeArgumentPlaceholder,
-    >);
+    >;
     // Always add the debug name argument last
     if (state.keepRequireNames) {
       path.node.arguments.push(types.stringLiteral(dependency.name));

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

@@ -0,0 +1,19 @@
+/**
+ * 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 {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/generateImportNames.js.flow

@@ -4,10 +4,12 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @format
  * @flow strict-local
+ * @format
  */
 
+import type {Node} from '@babel/types';
+
 import traverse from '@babel/traverse';
 import nullthrows from 'nullthrows';
 
@@ -15,7 +17,7 @@ import nullthrows from 'nullthrows';
  * Select unused names for "metroImportDefault" and "metroImportAll", by
  * calling "generateUid".
  */
-export default function generateImportNames(ast: BabelNode): {
+export default function generateImportNames(ast: Node): {
   importAll: string,
   importDefault: string,
 } {

package/src/ModuleGraph/worker/importLocationsPlugin.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.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+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/ModuleGraph/worker/importLocationsPlugin.js.flow

@@ -9,7 +9,8 @@
  * @oncall react_native
  */
 
-import type {File, PluginObj} from '@babel/core';
+import type {ReadonlySourceLocation} from '../../shared/types';
+import type {PluginObj} from '@babel/core';
 import typeof * as Types from '@babel/types';
 import type {MetroBabelFileMetadata} from 'metro-babel-transformer';
 
@@ -17,7 +18,10 @@ type ImportDeclarationLocs = Set<string>;
 
 type State = {
   importDeclarationLocs: ImportDeclarationLocs,
-  file: File,
+  file: {
+    metadata?: MetroBabelFileMetadata,
+    ...
+  },
   ...
 };
 
@@ -78,7 +82,7 @@ function importLocationsPlugin({
 // Very simple serialisation of a source location. This should remain opaque to
 // the caller.
 const MISSING_LOC = {line: -1, column: -1};
-function locToKey(loc: BabelSourceLocation): string {
+function locToKey(loc: ReadonlySourceLocation): string {
   const {start = MISSING_LOC, end = MISSING_LOC} = loc;
   return `${start.line},${start.column}:${end.line},${end.column}`;
 }

package/src/Server/MultipartResponse.d.ts

@@ -10,12 +10,9 @@
 
 import type {IncomingMessage, ServerResponse} from 'http';
 
-export type Data = string | Buffer | Uint8Array;
-export interface Headers {
-  [name: string]: string | number;
-}
-
-export default class MultipartResponse {
+type Data = string | Buffer | Uint8Array;
+type Headers = {[$$Key$$: string]: string | number};
+declare class MultipartResponse {
   static wrapIfSupported(
     req: IncomingMessage,
     res: ServerResponse,
@@ -28,4 +25,6 @@ export default class MultipartResponse {
   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/MultipartResponse.js.flow

@@ -94,7 +94,7 @@ export default class MultipartResponse {
     this.res.end();
   }
 
-  once(name: string, fn: () => mixed): this {
+  once(name: string, fn: () => unknown): this {
     this.res.once(name, fn);
     return this;
   }

package/src/Server/symbolicate.js.flow

@@ -31,7 +31,7 @@ export type IntermediateStackFrame = {
   collapse?: boolean,
   ...
 };
-export type StackFrameOutput = $ReadOnly<IntermediateStackFrame>;
+export type StackFrameOutput = Readonly<IntermediateStackFrame>;
 type ExplodedSourceMapModule = ExplodedSourceMap[number];
 type Position = {+line1Based: number, column0Based: number};
 
@@ -57,11 +57,11 @@ function createFunctionNameGetter(
 }
 
 export default async function symbolicate(
-  stack: $ReadOnlyArray<StackFrameInput>,
+  stack: ReadonlyArray<StackFrameInput>,
   maps: Iterable<[string, ExplodedSourceMap]>,
   config: ConfigT,
-  extraData: mixed,
-): Promise<$ReadOnlyArray<StackFrameOutput>> {
+  extraData: unknown,
+): Promise<ReadonlyArray<StackFrameOutput>> {
   const mapsByUrl = new Map<?string, ExplodedSourceMap>();
   for (const [url, map] of maps) {
     mapsByUrl.set(url, map);

package/src/Server.d.ts

@@ -8,111 +8,264 @@
  * @oncall react_native
  */
 
-import type {AssetData} from './Asset';
+import type {AssetData} from './Assets';
+import type {ExplodedSourceMap} from './DeltaBundler/Serializers/getExplodedSourceMap';
 import type {RamBundleInfo} from './DeltaBundler/Serializers/getRamBundleInfo';
+import type {
+  Module,
+  ReadOnlyDependencies,
+  ReadOnlyGraph,
+  TransformInputOptions,
+} from './DeltaBundler/types';
+import type {RevisionId} from './IncrementalBundler';
 import type {GraphId} from './lib/getGraphId';
-import type MultipartResponse from './Server/MultipartResponse';
+import type {Reporter} from './lib/reporting';
 import type {
   BuildOptions,
   BundleOptions,
   GraphOptions,
+  ResolverInputOptions,
   SplitBundleOptions,
 } from './shared/types';
-import type {IncomingMessage, ServerResponse} from 'http';
-import type {
-  CustomTransformOptions,
-  TransformProfile,
-} from 'metro-babel-transformer';
+import type {IncomingMessage} from 'connect';
+import type {ServerResponse} from 'http';
 import type {ConfigT, RootPerfLogger} from 'metro-config';
-import type {CustomResolverOptions} from 'metro-resolver';
+import type {
+  ActionLogEntryData,
+  ActionStartLogEntry,
+} from 'metro-core/private/Logger';
+import type {CustomResolverOptions} from 'metro-resolver/private/types';
+import type {CustomTransformOptions} from 'metro-transform-worker';
 
-import IncrementalBundler, {RevisionId} from './IncrementalBundler';
+import IncrementalBundler from './IncrementalBundler';
+import MultipartResponse from './Server/MultipartResponse';
+import {SourcePathsMode} from './shared/types';
+import {Logger} from 'metro-core';
 
-export interface SegmentLoadData {
-  [index: number]: [number[], number | null];
-}
-
-export interface BundleMetadata {
+export type SegmentLoadData = {
+  [$$Key$$: number]: [Array<number>, null | undefined | number];
+};
+export type BundleMetadata = {
   hash: string;
-  otaBuildNumber: string | null;
-  mobileConfigs: string[];
-  segmentHashes: string[];
+  otaBuildNumber: null | undefined | string;
+  mobileConfigs: Array<string>;
+  segmentHashes: Array<string>;
   segmentLoadData: SegmentLoadData;
-}
-
-export interface ProcessStartContext extends SplitBundleOptions {
+};
+type ProcessStartContext = Omit<
+  SplitBundleOptions,
+  keyof {
+    readonly buildNumber: number;
+    readonly bundleOptions: BundleOptions;
+    readonly graphId: GraphId;
+    readonly graphOptions: GraphOptions;
+    readonly mres: MultipartResponse | ServerResponse;
+    readonly req: IncomingMessage;
+    readonly revisionId?: null | undefined | RevisionId;
+    readonly bundlePerfLogger: RootPerfLogger;
+    readonly requestStartTimestamp: number;
+  }
+> & {
   readonly buildNumber: number;
   readonly bundleOptions: BundleOptions;
   readonly graphId: GraphId;
   readonly graphOptions: GraphOptions;
   readonly mres: MultipartResponse | ServerResponse;
   readonly req: IncomingMessage;
-  readonly revisionId?: RevisionId | null;
+  readonly revisionId?: null | undefined | RevisionId;
   readonly bundlePerfLogger: RootPerfLogger;
-}
-
-export interface ProcessDeleteContext {
+  readonly requestStartTimestamp: number;
+};
+type ProcessDeleteContext = {
   readonly graphId: GraphId;
   readonly req: IncomingMessage;
   readonly res: ServerResponse;
-}
-
-export interface ProcessEndContext<T> extends ProcessStartContext {
-  readonly result: T;
-}
-
+};
+type ProcessEndContext<T> = Omit<
+  ProcessStartContext,
+  keyof {readonly result: T}
+> & {readonly result: T};
 export type ServerOptions = Readonly<{
   hasReducedPerformance?: boolean;
   onBundleBuilt?: (bundlePath: string) => void;
   watch?: boolean;
 }>;
-
-export interface DefaultGraphOptions {
-  customResolverOptions: CustomResolverOptions;
-  customTransformOptions: CustomTransformOptions;
-  dev: boolean;
-  minify: boolean;
-  runtimeBytecodeVersion?: number;
-  unstable_transformProfile: TransformProfile;
-}
-
-export interface DefaultBundleOptions extends DefaultGraphOptions {
-  excludeSource: false;
-  inlineSourceMap: false;
-  modulesOnly: false;
-  onProgress: null;
-  runModule: true;
-  shallow: false;
-  sourceMapUrl: null;
-  sourceUrl: null;
-}
-
-export default class Server {
-  static DEFAULT_GRAPH_OPTIONS: DefaultGraphOptions;
-  static DEFAULT_BUNDLE_OPTIONS: BundleOptions;
+type FetchTiming = {
+  graphId: GraphId;
+  startTime: number;
+  endTime: number | null;
+  isPrefetch: boolean;
+};
+declare class Server {
+  _bundler: IncrementalBundler;
+  _config: ConfigT;
+  _createModuleId: (path: string) => number;
+  _isEnded: boolean;
+  _logger: typeof Logger;
+  _nextBundleBuildNumber: number;
+  _platforms: Set<string>;
+  _reporter: Reporter;
+  _serverOptions: ServerOptions | void;
+  _allowedSuffixesForSourceRequests: ReadonlyArray<string>;
+  _sourceRequestRoutingMap: ReadonlyArray<
+    [pathnamePrefix: string, normalizedRootDir: string]
+  >;
+  _fetchTimings: Array<FetchTiming>;
+  _activeFetchCount: number;
   constructor(config: ConfigT, options?: ServerOptions);
   end(): void;
   getBundler(): IncrementalBundler;
   getCreateModuleId(): (path: string) => number;
+  _serializeGraph(
+    $$PARAM_0$$: Readonly<{
+      splitOptions: SplitBundleOptions;
+      prepend: ReadonlyArray<Module>;
+      graph: ReadOnlyGraph;
+    }>,
+  ): Promise<{code: string; map: string}>;
   build(
     bundleOptions: BundleOptions,
-    buildOptions?: BuildOptions,
-  ): Promise<{
-    code: string;
-    map: string;
-    assets?: ReadonlyArray<AssetData>;
-  }>;
+    $$PARAM_1$$?: BuildOptions,
+  ): Promise<{code: string; map: string; assets?: ReadonlyArray<AssetData>}>;
   getRamBundleInfo(options: BundleOptions): Promise<RamBundleInfo>;
   getAssets(options: BundleOptions): Promise<ReadonlyArray<AssetData>>;
+  _getAssetsFromDependencies(
+    dependencies: ReadOnlyDependencies,
+    platform: null | undefined | string,
+  ): Promise<ReadonlyArray<AssetData>>;
   getOrderedDependencyPaths(options: {
     readonly dev: boolean;
     readonly entryFile: string;
     readonly minify: boolean;
-    readonly platform: string;
-  }): Promise<string[]>;
-  processRequest(
-    IncomingMessage: IncomingMessage,
-    ServerResponse: ServerResponse,
-    next: (e: Error | null) => unknown,
-  ): void;
+    readonly platform: null | undefined | string;
+  }): Promise<Array<string>>;
+  _rangeRequestMiddleware(
+    req: IncomingMessage,
+    res: ServerResponse,
+    data: string | Buffer,
+    assetPath: string,
+  ): Buffer | string;
+  _processSingleAssetRequest(
+    req: IncomingMessage,
+    res: ServerResponse,
+  ): Promise<void>;
+  processRequest: (
+    $$PARAM_0$$: IncomingMessage,
+    $$PARAM_1$$: ServerResponse,
+    $$PARAM_2$$: (e: null | undefined | Error) => void,
+  ) => void;
+  _parseOptions(url: string): BundleOptions;
+  _rewriteAndNormalizeUrl(requestUrl: string): string;
+  _processRequest(
+    req: IncomingMessage,
+    res: ServerResponse,
+    next: ($$PARAM_0$$: null | undefined | Error) => void,
+  ): Promise<void>;
+  _processSourceRequest(
+    relativeFilePathname: string,
+    rootDir: string,
+    res: ServerResponse,
+  ): Promise<void>;
+  _createRequestProcessor<T>($$PARAM_0$$: {
+    readonly bundleType: 'assets' | 'bundle' | 'map';
+    readonly createStartEntry: (
+      context: ProcessStartContext,
+    ) => ActionLogEntryData;
+    readonly createEndEntry: (
+      context: ProcessEndContext<T>,
+    ) => Partial<ActionStartLogEntry>;
+    readonly build: (context: ProcessStartContext) => Promise<T>;
+    readonly delete?: (context: ProcessDeleteContext) => Promise<void>;
+    readonly finish: (context: ProcessEndContext<T>) => void;
+  }): (
+    req: IncomingMessage,
+    res: ServerResponse,
+    bundleOptions: BundleOptions,
+    buildContext: Readonly<{
+      buildNumber: number;
+      bundlePerfLogger: RootPerfLogger;
+    }>,
+  ) => Promise<void>;
+  _processBundleRequest: (
+    req: IncomingMessage,
+    res: ServerResponse,
+    bundleOptions: BundleOptions,
+    buildContext: Readonly<{
+      buildNumber: number;
+      bundlePerfLogger: RootPerfLogger;
+    }>,
+  ) => Promise<void>;
+  _getSortedModules(graph: ReadOnlyGraph): ReadonlyArray<Module>;
+  _processSourceMapRequest: (
+    req: IncomingMessage,
+    res: ServerResponse,
+    bundleOptions: BundleOptions,
+    buildContext: Readonly<{
+      buildNumber: number;
+      bundlePerfLogger: RootPerfLogger;
+    }>,
+  ) => Promise<void>;
+  _processAssetsRequest: (
+    req: IncomingMessage,
+    res: ServerResponse,
+    bundleOptions: BundleOptions,
+    buildContext: Readonly<{
+      buildNumber: number;
+      bundlePerfLogger: RootPerfLogger;
+    }>,
+  ) => Promise<void>;
+  _symbolicate(req: IncomingMessage, res: ServerResponse): Promise<void>;
+  _explodedSourceMapForBundleOptions(
+    bundleOptions: BundleOptions,
+  ): Promise<ExplodedSourceMap>;
+  _resolveRelativePath(
+    filePath: string,
+    $$PARAM_1$$: Readonly<{
+      relativeTo: 'project' | 'server';
+      resolverOptions: ResolverInputOptions;
+      transformOptions: TransformInputOptions;
+    }>,
+  ): Promise<string>;
+  getNewBuildNumber(): number;
+  getPlatforms(): ReadonlyArray<string>;
+  getWatchFolders(): ReadonlyArray<string>;
+  static DEFAULT_GRAPH_OPTIONS: Readonly<{
+    customResolverOptions: CustomResolverOptions;
+    customTransformOptions: CustomTransformOptions;
+    dev: boolean;
+    minify: boolean;
+    unstable_transformProfile: 'default';
+  }>;
+  static DEFAULT_BUNDLE_OPTIONS: Omit<
+    typeof Server.DEFAULT_GRAPH_OPTIONS,
+    keyof {
+      excludeSource: false;
+      inlineSourceMap: false;
+      lazy: false;
+      modulesOnly: false;
+      onProgress: null;
+      runModule: true;
+      shallow: false;
+      sourceMapUrl: null;
+      sourceUrl: null;
+      sourcePaths: SourcePathsMode;
+    }
+  > & {
+    excludeSource: false;
+    inlineSourceMap: false;
+    lazy: false;
+    modulesOnly: false;
+    onProgress: null;
+    runModule: true;
+    shallow: false;
+    sourceMapUrl: null;
+    sourceUrl: null;
+    sourcePaths: SourcePathsMode;
+  };
+  _getServerRootDir(): string;
+  _getEntryPointAbsolutePath(entryFile: string): string;
+  ready(): Promise<void>;
+  _shouldAddModuleToIgnoreList(module: Module): boolean;
+  _getModuleSourceUrl(module: Module, mode: SourcePathsMode): string;
 }
+export default Server;