metro 0.84.1 → 0.84.3

package/src/Server.d.ts

@@ -0,0 +1,278 @@
+/**
+ * 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<<161e77301d04ce6cc254f1dbf15ef06b>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/Server.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+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 {Reporter} from './lib/reporting';
+import type {
+  BuildOptions,
+  BundleOptions,
+  GraphOptions,
+  ResolverInputOptions,
+  SplitBundleOptions,
+} from './shared/types';
+import type {IncomingMessage} from 'connect';
+import type {ServerResponse} from 'http';
+import type {ConfigT, RootPerfLogger} from 'metro-config';
+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 from './IncrementalBundler';
+import MultipartResponse from './Server/MultipartResponse';
+import {SourcePathsMode} from './shared/types';
+import {Logger} from 'metro-core';
+
+export type SegmentLoadData = {
+  [$$Key$$: number]: [Array<number>, null | undefined | number];
+};
+export type BundleMetadata = {
+  hash: string;
+  otaBuildNumber: null | undefined | string;
+  mobileConfigs: Array<string>;
+  segmentHashes: Array<string>;
+  segmentLoadData: SegmentLoadData;
+};
+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?: null | undefined | RevisionId;
+  readonly bundlePerfLogger: RootPerfLogger;
+  readonly requestStartTimestamp: number;
+};
+type ProcessDeleteContext = {
+  readonly graphId: GraphId;
+  readonly req: IncomingMessage;
+  readonly res: ServerResponse;
+};
+type ProcessEndContext<T> = Omit<
+  ProcessStartContext,
+  keyof {readonly result: T}
+> & {readonly result: T};
+export type ServerOptions = Readonly<{
+  hasReducedPerformance?: boolean;
+  onBundleBuilt?: (bundlePath: string) => void;
+  watch?: boolean;
+}>;
+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,
+    $$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: 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;

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/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/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/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$$;

package/src/index.flow.js.flow

@@ -156,9 +156,28 @@ type DependenciesCommandOptions = Readonly<{[string]: unknown}> | null;
 export {Terminal, JsonReporter, TerminalReporter};
 
 export type {AssetData} from './Assets';
-export type {Reporter, ReportableEvent} from './lib/reporting';
+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 {MetroConfig};
+export type {
+  ContextMode,
+  RequireContextParams,
+} from './ModuleGraph/worker/collectDependencies';
+export type {ServerOptions} from './Server';
+export type {MetroConfig, MetroServer};
 
 async function getConfig(config: InputConfigT): Promise<ConfigT> {
   const defaultConfig = await getDefaultConfig(config.projectRoot);

package/src/lib/BatchProcessor.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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<<5872ab26db1c8f4499c971170c5012c4>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/lib/BatchProcessor.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import {setTimeout} from 'timers';
+
+type ProcessBatch<TItem, TResult> = (
+  batch: Array<TItem>,
+) => Promise<Array<TResult>>;
+type BatchProcessorOptions = {
+  maximumDelayMs: number;
+  maximumItems: number;
+  concurrency: number;
+};
+type QueueItem<TItem, TResult> = {
+  item: TItem;
+  reject: (error: unknown) => unknown;
+  resolve: (result: TResult) => unknown;
+};
+/**
+ * We batch items together trying to minimize their processing, for example as
+ * network queries. For that we wait a small moment before processing a batch.
+ * We limit also the number of items we try to process in a single batch so that
+ * if we have many items pending in a short amount of time, we can start
+ * processing right away.
+ */
+declare class BatchProcessor<TItem, TResult> {
+  _currentProcessCount: number;
+  _options: BatchProcessorOptions;
+  _processBatch: ProcessBatch<TItem, TResult>;
+  _queue: Array<QueueItem<TItem, TResult>>;
+  _timeoutHandle: null | undefined | ReturnType<typeof setTimeout>;
+  constructor(
+    options: BatchProcessorOptions,
+    processBatch: ProcessBatch<TItem, TResult>,
+  );
+  _onBatchFinished(): void;
+  _onBatchResults(
+    jobs: Array<QueueItem<TItem, TResult>>,
+    results: Array<TResult>,
+  ): void;
+  _onBatchError(jobs: Array<QueueItem<TItem, TResult>>, error: unknown): void;
+  _processQueue(): void;
+  _processQueueOnceReady(): void;
+  queue(item: TItem): Promise<TResult>;
+  getQueueLength(): number;
+}
+export default BatchProcessor;