metro 0.84.0 → 0.84.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.84.0",
+  "version": "0.84.2",
   "description": "🚇 The JavaScript bundler for React Native.",
   "main": "src/index.js",
   "bin": "src/cli.js",
@@ -40,18 +40,18 @@
     "jest-worker": "^29.7.0",
     "jsc-safe-url": "^0.2.2",
     "lodash.throttle": "^4.1.1",
-    "metro-babel-transformer": "0.84.0",
-    "metro-cache": "0.84.0",
-    "metro-cache-key": "0.84.0",
-    "metro-config": "0.84.0",
-    "metro-core": "0.84.0",
-    "metro-file-map": "0.84.0",
-    "metro-resolver": "0.84.0",
-    "metro-runtime": "0.84.0",
-    "metro-source-map": "0.84.0",
-    "metro-symbolicate": "0.84.0",
-    "metro-transform-plugins": "0.84.0",
-    "metro-transform-worker": "0.84.0",
+    "metro-babel-transformer": "0.84.2",
+    "metro-cache": "0.84.2",
+    "metro-cache-key": "0.84.2",
+    "metro-config": "0.84.2",
+    "metro-core": "0.84.2",
+    "metro-file-map": "0.84.2",
+    "metro-resolver": "0.84.2",
+    "metro-runtime": "0.84.2",
+    "metro-source-map": "0.84.2",
+    "metro-symbolicate": "0.84.2",
+    "metro-transform-plugins": "0.84.2",
+    "metro-transform-worker": "0.84.2",
     "mime-types": "^3.0.1",
     "nullthrows": "^1.1.1",
     "serialize-error": "^2.1.0",
@@ -72,10 +72,11 @@
     "dedent": "^0.7.0",
     "jest-snapshot": "^29.7.0",
     "jest-snapshot-serializer-raw": "^1.2.0",
-    "metro-babel-register": "0.84.0",
+    "metro-babel-register": "0.84.2",
     "metro-memory-fs": "*",
     "mock-req": "^0.2.0",
     "mock-res": "^0.6.0",
+    "selfsigned": "^5.5.0",
     "stack-trace": "^0.0.10"
   },
   "license": "MIT",

package/src/Assets.d.ts

@@ -0,0 +1,90 @@
+/**
+ * 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<<a58b1d0332fe424196b6d106eacdc2fe>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/Assets.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+export type AssetInfo = {
+  readonly files: Array<string>;
+  readonly hash: string;
+  readonly name: string;
+  readonly scales: Array<number>;
+  readonly type: string;
+};
+export type AssetDataWithoutFiles = {
+  readonly __packager_asset: boolean;
+  readonly fileSystemLocation: string;
+  readonly hash: string;
+  readonly height: null | undefined | number;
+  readonly httpServerLocation: string;
+  readonly name: string;
+  readonly scales: Array<number>;
+  readonly type: string;
+  readonly width: null | undefined | number;
+};
+export type AssetDataFiltered = {
+  readonly __packager_asset: boolean;
+  readonly hash: string;
+  readonly height: null | undefined | number;
+  readonly httpServerLocation: string;
+  readonly name: string;
+  readonly scales: Array<number>;
+  readonly type: string;
+  readonly width: null | undefined | number;
+};
+export declare function isAssetTypeAnImage(type: string): boolean;
+export declare function getAssetSize(
+  type: string,
+  content: Buffer,
+  filePath: string,
+): null | undefined | {readonly width: number; readonly height: number};
+export type AssetData = AssetDataWithoutFiles & {
+  readonly files: Array<string>;
+};
+export type AssetDataPlugin = (
+  assetData: AssetData,
+) => AssetData | Promise<AssetData>;
+export declare function getAssetData(
+  assetPath: string,
+  localPath: string,
+  assetDataPlugins: ReadonlyArray<string>,
+  platform: null | undefined | string,
+  publicPath: string,
+): Promise<AssetData>;
+/**
+ * Returns all the associated files (for different resolutions) of an asset.
+ **/
+export declare function getAssetFiles(
+  assetPath: string,
+  platform?: null | undefined | string,
+): Promise<Array<string>>;
+/**
+ * Return a buffer with the actual image given a request for an image by path.
+ * The relativePath can contain a resolution postfix, in this case we need to
+ * find that image (or the closest one to it's resolution) in one of the
+ * project roots:
+ *
+ * 1. We first parse the directory of the asset
+ * 2. We then build a map of all assets and their scales in this directory
+ * 3. Then try to pick platform-specific asset records
+ * 4. Then pick the closest resolution (rounding up) to the requested one
+ */
+export declare function getAsset(
+  relativePath: string,
+  projectRoot: string,
+  watchFolders: ReadonlyArray<string>,
+  platform: null | undefined | string,
+  assetExts: ReadonlyArray<string>,
+  fileExistsInFileMap?: (absolutePath: string) => boolean,
+): Promise<Buffer>;

package/src/Bundler/util.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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<<adf0e819f93597b57ff231cca9c918ef>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/Bundler/util.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {AssetDataWithoutFiles} from '../Assets';
+import type {ModuleTransportLike} from '../shared/types';
+import type {File} from '@babel/types';
+
+type SubTree<T extends ModuleTransportLike> = (
+  moduleTransport: T,
+  moduleTransportsByPath: Map<string, T>,
+) => Iterable<number>;
+export declare function generateAssetCodeFileAst(
+  assetRegistryPath: string,
+  assetDescriptor: AssetDataWithoutFiles,
+): File;
+export declare function createRamBundleGroups<T extends ModuleTransportLike>(
+  ramGroups: ReadonlyArray<string>,
+  groupableModules: ReadonlyArray<T>,
+  subtree: SubTree<T>,
+): Map<number, Set<number>>;

package/src/Bundler.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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<<3d5664309abdece0f247fcd0c53c3aaf>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/Bundler.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {TransformResultWithSource} from './DeltaBundler';
+import type {TransformOptions} from './DeltaBundler/Worker';
+import type EventEmitter from 'events';
+import type {ConfigT} from 'metro-config';
+
+import Transformer from './DeltaBundler/Transformer';
+import DependencyGraph from './node-haste/DependencyGraph';
+
+export type BundlerOptions = Readonly<{
+  hasReducedPerformance?: boolean;
+  watch?: boolean;
+}>;
+declare class Bundler {
+  _depGraph: DependencyGraph;
+  _initializedPromise: Promise<void>;
+  _transformer: Transformer;
+  constructor(config: ConfigT, options?: BundlerOptions);
+  getWatcher(): EventEmitter;
+  end(): Promise<void>;
+  getDependencyGraph(): Promise<DependencyGraph>;
+  transformFile(
+    filePath: string,
+    transformOptions: TransformOptions,
+    fileBuffer?: Buffer,
+  ): Promise<TransformResultWithSource>;
+  ready(): Promise<void>;
+}
+export default Bundler;

package/src/DeltaBundler/DeltaCalculator.d.ts

@@ -0,0 +1,78 @@
+/**
+ * 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<<b825a92cd295988e6e972591f11221fd>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/DeltaBundler/DeltaCalculator.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {DeltaResult, Options} from './types';
+import type {RootPerfLogger} from 'metro-config';
+import type {ChangeEvent} from 'metro-file-map';
+
+import {Graph} from './Graph';
+import EventEmitter from 'events';
+/**
+ * This class is in charge of calculating the delta of changed modules that
+ * happen between calls. To do so, it subscribes to file changes, so it can
+ * traverse the files that have been changed between calls and avoid having to
+ * traverse the whole dependency tree for trivial small changes.
+ */
+declare class DeltaCalculator<T> extends EventEmitter {
+  _changeEventSource: EventEmitter;
+  _options: Options<T>;
+  _currentBuildPromise: null | undefined | Promise<DeltaResult<T>>;
+  _deletedFiles: Set<string>;
+  _modifiedFiles: Set<string>;
+  _addedFiles: Set<string>;
+  _requiresReset: boolean;
+  _graph: Graph<T>;
+  constructor(
+    entryPoints: ReadonlySet<string>,
+    changeEventSource: EventEmitter,
+    options: Options<T>,
+  );
+  /**
+   * Stops listening for file changes and clears all the caches.
+   */
+  end(): void;
+  /**
+   * Main method to calculate the delta of modules. It returns a DeltaResult,
+   * which contain the modified/added modules and the removed modules.
+   */
+  getDelta($$PARAM_0$$: {
+    reset: boolean;
+    shallow: boolean;
+  }): Promise<DeltaResult<T>>;
+  /**
+   * Returns the graph with all the dependencies. Each module contains the
+   * needed information to do the traversing (dependencies, inverseDependencies)
+   * plus some metadata.
+   */
+  getGraph(): Graph<T>;
+  _handleMultipleFileChanges: (changeEvent: ChangeEvent) => void;
+  /**
+   * Handles a single file change. To avoid doing any work before it's needed,
+   * the listener only stores the modified file, which will then be used later
+   * when the delta needs to be calculated.
+   */
+  _handleFileChange: (
+    $$PARAM_0$$: ChangeEvent['eventsQueue'][number],
+    logger: null | undefined | RootPerfLogger,
+  ) => unknown;
+  _getChangedDependencies(
+    modifiedFiles: Set<string>,
+    deletedFiles: Set<string>,
+    addedFiles: Set<string>,
+  ): Promise<DeltaResult<T>>;
+}
+export default DeltaCalculator;

package/src/DeltaBundler/Graph.d.ts

@@ -0,0 +1,174 @@
+/**
+ * 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<<2af7aa3b61c2afa4d8794e127666c226>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/DeltaBundler/Graph.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+/**
+ * Portions of this code are based on the Synchronous Cycle Collection
+ * algorithm described in:
+ *
+ * David F. Bacon and V. T. Rajan. 2001. Concurrent Cycle Collection in
+ * Reference Counted Systems. In Proceedings of the 15th European Conference on
+ * Object-Oriented Programming (ECOOP '01). Springer-Verlag, Berlin,
+ * Heidelberg, 207–235.
+ *
+ * Notable differences from the algorithm in the paper:
+ * 1. Our implementation uses the inverseDependencies set (which we already
+ *    have to maintain) instead of a separate refcount variable. A module's
+ *    reference count is equal to the size of its inverseDependencies set, plus
+ *    1 if it's an entry point of the graph.
+ * 2. We keep the "root buffer" (possibleCycleRoots) free of duplicates by
+ *    making it a Set, instead of storing a "buffered" flag on each node.
+ * 3. On top of tracking edges between nodes, we also count references between
+ *    nodes and entries in the importBundleNodes set.
+ */
+
+import type {RequireContext} from '../lib/contextModule';
+import type {
+  Dependencies,
+  Dependency,
+  GraphInputOptions,
+  MixedOutput,
+  Module,
+  ModuleData,
+  Options,
+  ResolvedDependency,
+  TransformInputOptions,
+} from './types';
+
+import CountingSet from '../lib/CountingSet';
+
+export type Result<T> = {
+  added: Map<string, Module<T>>;
+  modified: Map<string, Module<T>>;
+  deleted: Set<string>;
+};
+type Delta<T> = Readonly<{
+  added: Set<string>;
+  touched: Set<string>;
+  deleted: Set<string>;
+  updatedModuleData: ReadonlyMap<string, ModuleData<T>>;
+  baseModuleData: Map<string, ModuleData<T>>;
+  errors: ReadonlyMap<string, Error>;
+}>;
+type InternalOptions<T> = Readonly<{
+  lazy: boolean;
+  onDependencyAdd: () => unknown;
+  onDependencyAdded: () => unknown;
+  resolve: Options<T>['resolve'];
+  transform: Options<T>['transform'];
+  shallow: boolean;
+}>;
+export declare class Graph<T = MixedOutput> {
+  readonly entryPoints: ReadonlySet<string>;
+  readonly transformOptions: TransformInputOptions;
+  readonly dependencies: Dependencies<T>;
+  constructor(options: GraphInputOptions);
+  /**
+   * Dependency Traversal logic for the Delta Bundler. This method calculates
+   * the modules that should be included in the bundle by traversing the
+   * dependency graph.
+   * Instead of traversing the whole graph each time, it just calculates the
+   * difference between runs by only traversing the added/removed dependencies.
+   * To do so, it uses the passed graph dependencies and it mutates it.
+   * The paths parameter contains the absolute paths of the root files that the
+   * method should traverse. Normally, these paths should be the modified files
+   * since the last traversal.
+   */
+  traverseDependencies(
+    paths: ReadonlyArray<string>,
+    options: Options<T>,
+  ): Promise<Result<T>>;
+  initialTraverseDependencies(options: Options<T>): Promise<Result<T>>;
+  _buildDelta(
+    pathsToVisit: ReadonlySet<string>,
+    options: InternalOptions<T>,
+    moduleFilter?: (path: string) => boolean,
+  ): Promise<Delta<T>>;
+  _recursivelyCommitModule(
+    path: string,
+    delta: Delta<T>,
+    options: InternalOptions<T>,
+    commitOptions?: Readonly<{onlyRemove: boolean}>,
+  ): Module<T>;
+  _addDependency(
+    parentModule: Module<T>,
+    key: string,
+    dependency: Dependency,
+    requireContext: null | undefined | RequireContext,
+    delta: Delta<T>,
+    options: InternalOptions<T>,
+  ): void;
+  _removeDependency(
+    parentModule: Module<T>,
+    key: string,
+    dependency: Dependency,
+    delta: Delta<T>,
+    options: InternalOptions<T>,
+  ): void;
+  /**
+   * Collect a list of context modules which include a given file.
+   */
+  markModifiedContextModules(
+    filePath: string,
+    modifiedPaths: Set<string> | CountingSet<string>,
+  ): void;
+  /**
+   * Gets the list of modules affected by the deletion of a given file. The
+   * caller is expected to mark these modules as modified in the next call to
+   * traverseDependencies. Note that the list may contain duplicates.
+   */
+  getModifiedModulesForDeletedPath(filePath: string): Iterable<string>;
+  /**
+   * Re-traverse the dependency graph in DFS order to reorder the modules and
+   * guarantee the same order between runs. This method mutates the passed graph.
+   */
+  reorderGraph(options: {shallow: boolean}): void;
+  _reorderDependencies(
+    module: Module<T>,
+    orderedDependencies: Map<string, Module<T>>,
+    options: {shallow: boolean},
+  ): void;
+  /** Garbage collection functions */
+
+  _incrementImportBundleReference(
+    dependency: ResolvedDependency,
+    parentModule: Module<T>,
+  ): void;
+  _decrementImportBundleReference(
+    dependency: ResolvedDependency,
+    parentModule: Module<T>,
+  ): void;
+  _markModuleInUse(module: Module<T>): void;
+  _children(
+    module: Module<T>,
+    options: InternalOptions<T>,
+  ): Iterator<Module<T>>;
+  _moduleSnapshot(module: Module<T>): ModuleData<T>;
+  _releaseModule(
+    module: Module<T>,
+    delta: Delta<T>,
+    options: InternalOptions<T>,
+  ): void;
+  _freeModule(module: Module<T>, delta: Delta<T>): void;
+  _markAsPossibleCycleRoot(module: Module<T>): void;
+  _collectCycles(delta: Delta<T>, options: InternalOptions<T>): void;
+  _markGray(module: Module<T>, options: InternalOptions<T>): void;
+  _scan(module: Module<T>, options: InternalOptions<T>): void;
+  _scanBlack(module: Module<T>, options: InternalOptions<T>): void;
+  _collectWhite(module: Module<T>, delta: Delta<T>): void;
+
+  /** End of garbage collection functions */
+}

package/src/DeltaBundler/Serializers/baseJSBundle.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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<<e21aeb433f191f32b37d05733b0b76bd>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/DeltaBundler/Serializers/baseJSBundle.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {Module, ReadOnlyGraph, SerializerOptions} from '../types';
+import type {Bundle} from 'metro-runtime/src/modules/types';
+
+declare function baseJSBundle(
+  entryPoint: string,
+  preModules: ReadonlyArray<Module>,
+  graph: ReadOnlyGraph,
+  options: SerializerOptions,
+): Bundle;
+export default baseJSBundle;

package/src/DeltaBundler/Serializers/getAllFiles.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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<<1d044a890d1eebbef947f78609d7c58f>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/DeltaBundler/Serializers/getAllFiles.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {Module, ReadOnlyGraph} from '../types';
+
+type Options = {
+  platform: null | undefined | string;
+  readonly processModuleFilter: (module: Module) => boolean;
+};
+declare function getAllFiles(
+  pre: ReadonlyArray<Module>,
+  graph: ReadOnlyGraph,
+  options: Options,
+): Promise<ReadonlyArray<string>>;
+export default getAllFiles;

package/src/DeltaBundler/Serializers/getAssets.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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<<0a49d828c4a80d52ccab4d4766b84c86>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/DeltaBundler/Serializers/getAssets.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {AssetData} from '../../Assets';
+import type {Module, ReadOnlyDependencies} from '../types';
+
+type Options = {
+  readonly processModuleFilter: (module: Module) => boolean;
+  assetPlugins: ReadonlyArray<string>;
+  platform: null | undefined | string;
+  projectRoot: string;
+  publicPath: string;
+};
+declare function getAssets(
+  dependencies: ReadOnlyDependencies,
+  options: Options,
+): Promise<ReadonlyArray<AssetData>>;
+export default getAssets;

package/src/DeltaBundler/Serializers/getExplodedSourceMap.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<<623892927b76c4f68802bb69f19d9974>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/DeltaBundler/Serializers/getExplodedSourceMap.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {Module} from '../types';
+import type {
+  FBSourceFunctionMap,
+  MetroSourceMapSegmentTuple,
+} from 'metro-source-map';
+
+export type ExplodedSourceMap = ReadonlyArray<{
+  readonly map: Array<MetroSourceMapSegmentTuple>;
+  readonly firstLine1Based: number;
+  readonly functionMap: null | undefined | FBSourceFunctionMap;
+  readonly path: string;
+}>;
+export declare function getExplodedSourceMap(
+  modules: ReadonlyArray<Module>,
+  options: {readonly processModuleFilter: (module: Module) => boolean},
+): ExplodedSourceMap;

package/src/DeltaBundler/Serializers/getRamBundleInfo.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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<<b01899b6156596978e6b8e7ba93e97a4>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/DeltaBundler/Serializers/getRamBundleInfo.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {ModuleTransportLike} from '../../shared/types';
+import type {Module, ReadOnlyGraph, SerializerOptions} from '../types';
+import type {SourceMapGeneratorOptions} from './sourceMapGenerator';
+import type {GetTransformOptions} from 'metro-config';
+
+type Options = Readonly<
+  Omit<
+    SerializerOptions,
+    | keyof SourceMapGeneratorOptions
+    | keyof {
+        getTransformOptions: null | undefined | GetTransformOptions;
+        platform: null | undefined | string;
+      }
+  > &
+    Omit<
+      SourceMapGeneratorOptions,
+      keyof {
+        getTransformOptions: null | undefined | GetTransformOptions;
+        platform: null | undefined | string;
+      }
+    > & {
+      getTransformOptions: null | undefined | GetTransformOptions;
+      platform: null | undefined | string;
+    }
+>;
+export type RamBundleInfo = {
+  getDependencies: ($$PARAM_0$$: string) => Set<string>;
+  startupModules: ReadonlyArray<ModuleTransportLike>;
+  lazyModules: ReadonlyArray<ModuleTransportLike>;
+  groups: Map<number, Set<number>>;
+};
+declare function getRamBundleInfo(
+  entryPoint: string,
+  pre: ReadonlyArray<Module>,
+  graph: ReadOnlyGraph,
+  options: Options,
+): Promise<RamBundleInfo>;
+export default getRamBundleInfo;

package/src/DeltaBundler/Serializers/helpers/getInlineSourceMappingURL.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.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<f9cd017db02091bdd4f6d114e4744087>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro/src/DeltaBundler/Serializers/helpers/getInlineSourceMappingURL.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+declare function getInlineSourceMappingURL(sourceMap: string): string;
+export default getInlineSourceMappingURL;