metro 0.83.3 → 0.83.5

package/src/DeltaBundler/DeltaCalculator.js.flow

@@ -34,12 +34,12 @@ export default class DeltaCalculator<T> extends EventEmitter {
   _deletedFiles: Set<string> = new Set();
   _modifiedFiles: Set<string> = new Set();
   _addedFiles: Set<string> = new Set();
-  _requiresReset = false;
+  _requiresReset: boolean = false;
 
   _graph: Graph<T>;
 
   constructor(
-    entryPoints: $ReadOnlySet<string>,
+    entryPoints: ReadonlySet<string>,
     changeEventSource: EventEmitter,
     options: Options<T>,
   ) {
@@ -154,8 +154,8 @@ export default class DeltaCalculator<T> extends EventEmitter {
 
       return {
         added: this._graph.dependencies,
-        modified: new Map(),
         deleted: new Set(),
+        modified: new Map(),
         reset: true,
       };
     }
@@ -186,7 +186,7 @@ export default class DeltaCalculator<T> extends EventEmitter {
   _handleFileChange = (
     {type, filePath, metadata}: ChangeEvent['eventsQueue'][number],
     logger: ?RootPerfLogger,
-  ): mixed => {
+  ): unknown => {
     debug('Handling %s: %s (type: %s)', type, filePath, metadata.type);
     if (
       metadata.type === 'l' ||
@@ -234,7 +234,7 @@ export default class DeltaCalculator<T> extends EventEmitter {
         this._addedFiles.delete(filePath);
         break;
       default:
-        (nextState: empty);
+        nextState as empty;
     }
 
     // Notify users that there is a change in some of the bundle files. This
@@ -256,8 +256,8 @@ export default class DeltaCalculator<T> extends EventEmitter {
 
       return {
         added,
-        modified: new Map(),
         deleted: new Set(),
+        modified: new Map(),
         reset: true,
       };
     }
@@ -297,8 +297,8 @@ export default class DeltaCalculator<T> extends EventEmitter {
     if (modifiedDependencies.length === 0) {
       return {
         added: new Map(),
-        modified: new Map(),
         deleted: new Set(),
+        modified: new Map(),
         reset: false,
       };
     }
@@ -317,8 +317,8 @@ export default class DeltaCalculator<T> extends EventEmitter {
 
     return {
       added,
-      modified,
       deleted,
+      modified,
       reset: false,
     };
   }

package/src/DeltaBundler/Graph.d.ts

@@ -8,33 +8,160 @@
  * @oncall react_native
  */
 
+/**
+ * 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';
 
-export interface Result<T> {
+import CountingSet from '../lib/CountingSet';
+
+export type Result<T> = {
   added: Map<string, Module<T>>;
   modified: Map<string, Module<T>>;
   deleted: Set<string>;
-}
-
-export class Graph<T = MixedOutput> {
-  entryPoints: ReadonlySet<string>;
-  transformOptions: TransformInputOptions;
-  dependencies: Dependencies<T>;
+};
+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>,
+    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/Graph.js

@@ -18,11 +18,11 @@ function getInternalOptions({ transform, resolve, onProgress, lazy, shallow }) {
   let total = 0;
   return {
     lazy,
-    transform,
-    resolve,
     onDependencyAdd: () => onProgress && onProgress(numProcessed, ++total),
     onDependencyAdded: () => onProgress && onProgress(++numProcessed, total),
+    resolve,
     shallow,
+    transform,
   };
 }
 function isWeakOrLazy(dependency, options) {
@@ -88,11 +88,11 @@ class Graph {
     } catch (error) {
       const rollbackDelta = {
         added: delta.added,
+        baseModuleData: new Map(),
         deleted: delta.deleted,
+        errors: new Map(),
         touched: new Set(),
         updatedModuleData: delta.baseModuleData,
-        baseModuleData: new Map(),
-        errors: new Map(),
       };
       for (const modified of modifiedPathsInBaseGraph) {
         const module = this.dependencies.get(modified);
@@ -127,8 +127,8 @@ class Graph {
     }
     return {
       added,
-      modified,
       deleted: delta.deleted,
+      modified,
     };
   }
   async initialTraverseDependencies(options) {
@@ -155,8 +155,8 @@ class Graph {
     });
     return {
       added: this.dependencies,
-      modified: new Map(),
       deleted: new Set(),
+      modified: new Map(),
     };
   }
   async _buildDelta(pathsToVisit, options, moduleFilter) {
@@ -165,27 +165,27 @@ class Graph {
       this.#resolvedContexts,
       {
         resolve: options.resolve,
-        transform: async (absolutePath, requireContext) => {
-          options.onDependencyAdd();
-          const result = await options.transform(absolutePath, requireContext);
-          options.onDependencyAdded();
-          return result;
-        },
         shouldTraverse: (dependency) => {
           if (options.shallow || isWeakOrLazy(dependency, options)) {
             return false;
           }
           return moduleFilter == null || moduleFilter(dependency.absolutePath);
         },
+        transform: async (absolutePath, requireContext) => {
+          options.onDependencyAdd();
+          const result = await options.transform(absolutePath, requireContext);
+          options.onDependencyAdded();
+          return result;
+        },
       },
     );
     return {
       added: new Set(),
-      touched: new Set(),
-      deleted: new Set(),
-      updatedModuleData: subGraph.moduleData,
       baseModuleData: new Map(),
+      deleted: new Set(),
       errors: subGraph.errors,
+      touched: new Set(),
+      updatedModuleData: subGraph.moduleData,
     };
   }
   _recursivelyCommitModule(
@@ -462,9 +462,9 @@ class Graph {
     }
     return {
       dependencies: new Map(dependencies),
-      resolvedContexts,
       getSource,
       output,
+      resolvedContexts,
       unstable_transformResultKey,
     };
   }

package/src/DeltaBundler/Graph.js.flow

@@ -73,12 +73,12 @@ export type Result<T> = {
   deleted: Set<string>,
 };
 
-/**
+/*
  * Internal data structure that the traversal logic uses to know which of the
  * files have been modified. This allows to return the added modules before the
  * modified ones (which is useful for things like Hot Module Reloading).
- **/
-type Delta<T> = $ReadOnly<{
+ */
+type Delta<T> = Readonly<{
   // `added` and `deleted` are mutually exclusive.
   // Internally, a module can be in both `touched` and (either) `added` or
   // `deleted`. Before returning the result, we'll calculate
@@ -87,15 +87,15 @@ type Delta<T> = $ReadOnly<{
   touched: Set<string>,
   deleted: Set<string>,
 
-  updatedModuleData: $ReadOnlyMap<string, ModuleData<T>>,
+  updatedModuleData: ReadonlyMap<string, ModuleData<T>>,
   baseModuleData: Map<string, ModuleData<T>>,
-  errors: $ReadOnlyMap<string, Error>,
+  errors: ReadonlyMap<string, Error>,
 }>;
 
-type InternalOptions<T> = $ReadOnly<{
+type InternalOptions<T> = Readonly<{
   lazy: boolean,
-  onDependencyAdd: () => mixed,
-  onDependencyAdded: () => mixed,
+  onDependencyAdd: () => unknown,
+  onDependencyAdded: () => unknown,
   resolve: Options<T>['resolve'],
   transform: Options<T>['transform'],
   shallow: boolean,
@@ -113,11 +113,11 @@ function getInternalOptions<T>({
 
   return {
     lazy,
-    transform,
-    resolve,
     onDependencyAdd: () => onProgress && onProgress(numProcessed, ++total),
     onDependencyAdded: () => onProgress && onProgress(++numProcessed, total),
+    resolve,
     shallow,
+    transform,
   };
 }
 
@@ -130,12 +130,12 @@ function isWeakOrLazy<T>(
 }
 
 export class Graph<T = MixedOutput> {
-  +entryPoints: $ReadOnlySet<string>;
+  +entryPoints: ReadonlySet<string>;
   +transformOptions: TransformInputOptions;
   +dependencies: Dependencies<T> = new Map();
   +#importBundleNodes: Map<
     string,
-    $ReadOnly<{
+    Readonly<{
       inverseDependencies: CountingSet<string>,
     }>,
   > = new Map();
@@ -169,7 +169,7 @@ export class Graph<T = MixedOutput> {
    * since the last traversal.
    */
   async traverseDependencies(
-    paths: $ReadOnlyArray<string>,
+    paths: ReadonlyArray<string>,
     options: Options<T>,
   ): Promise<Result<T>> {
     const internalOptions = getInternalOptions(options);
@@ -246,11 +246,11 @@ export class Graph<T = MixedOutput> {
       // Roll back to base before re-throwing.
       const rollbackDelta: Delta<T> = {
         added: delta.added,
+        baseModuleData: new Map(),
         deleted: delta.deleted,
+        errors: new Map(),
         touched: new Set(),
         updatedModuleData: delta.baseModuleData,
-        baseModuleData: new Map(),
-        errors: new Map(),
       };
       for (const modified of modifiedPathsInBaseGraph) {
         const module = this.dependencies.get(modified);
@@ -295,8 +295,8 @@ export class Graph<T = MixedOutput> {
 
     return {
       added,
-      modified,
       deleted: delta.deleted,
+      modified,
     };
   }
 
@@ -338,39 +338,39 @@ export class Graph<T = MixedOutput> {
 
     return {
       added: this.dependencies,
-      modified: new Map(),
       deleted: new Set(),
+      modified: new Map(),
     };
   }
 
   async _buildDelta(
-    pathsToVisit: $ReadOnlySet<string>,
+    pathsToVisit: ReadonlySet<string>,
     options: InternalOptions<T>,
     moduleFilter?: (path: string) => boolean,
   ): Promise<Delta<T>> {
     const subGraph = await buildSubgraph(pathsToVisit, this.#resolvedContexts, {
       resolve: options.resolve,
-      transform: async (absolutePath, requireContext) => {
-        options.onDependencyAdd();
-        const result = await options.transform(absolutePath, requireContext);
-        options.onDependencyAdded();
-        return result;
-      },
       shouldTraverse: (dependency: ResolvedDependency) => {
         if (options.shallow || isWeakOrLazy(dependency, options)) {
           return false;
         }
         return moduleFilter == null || moduleFilter(dependency.absolutePath);
       },
+      transform: async (absolutePath, requireContext) => {
+        options.onDependencyAdd();
+        const result = await options.transform(absolutePath, requireContext);
+        options.onDependencyAdded();
+        return result;
+      },
     });
 
     return {
       added: new Set(),
-      touched: new Set(),
-      deleted: new Set(),
-      updatedModuleData: subGraph.moduleData,
       baseModuleData: new Map(),
+      deleted: new Set(),
       errors: subGraph.errors,
+      touched: new Set(),
+      updatedModuleData: subGraph.moduleData,
     };
   }
 
@@ -378,7 +378,7 @@ export class Graph<T = MixedOutput> {
     path: string,
     delta: Delta<T>,
     options: InternalOptions<T>,
-    commitOptions: $ReadOnly<{
+    commitOptions: Readonly<{
       onlyRemove: boolean,
     }> = {onlyRemove: false},
   ): Module<T> {
@@ -775,9 +775,9 @@ export class Graph<T = MixedOutput> {
     }
     return {
       dependencies: new Map(dependencies),
-      resolvedContexts,
       getSource,
       output,
+      resolvedContexts,
       unstable_transformResultKey,
     };
   }
@@ -936,7 +936,7 @@ export class Graph<T = MixedOutput> {
 function dependenciesEqual(
   a: Dependency,
   b: Dependency,
-  options: $ReadOnly<{lazy: boolean, ...}>,
+  options: Readonly<{lazy: boolean, ...}>,
 ): boolean {
   return (
     a === b ||

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

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

@@ -22,7 +22,7 @@ import processModules from './helpers/processModules';
 
 export default function baseJSBundle(
   entryPoint: string,
-  preModules: $ReadOnlyArray<Module<>>,
+  preModules: ReadonlyArray<Module<>>,
   graph: ReadOnlyGraph<>,
   options: SerializerOptions,
 ): Bundle {

package/src/DeltaBundler/Serializers/getAllFiles.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.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+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/getAllFiles.js.flow

@@ -20,10 +20,10 @@ type Options = {
 };
 
 export default async function getAllFiles(
-  pre: $ReadOnlyArray<Module<>>,
+  pre: ReadonlyArray<Module<>>,
   graph: ReadOnlyGraph<>,
   options: Options,
-): Promise<$ReadOnlyArray<string>> {
+): Promise<ReadonlyArray<string>> {
   const modules = graph.dependencies;
   const {processModuleFilter} = options;
 

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

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

@@ -18,7 +18,7 @@ import path from 'path';
 
 type Options = {
   +processModuleFilter: (module: Module<>) => boolean,
-  assetPlugins: $ReadOnlyArray<string>,
+  assetPlugins: ReadonlyArray<string>,
   platform: ?string,
   projectRoot: string,
   publicPath: string,
@@ -27,7 +27,7 @@ type Options = {
 export default async function getAssets(
   dependencies: ReadOnlyDependencies<>,
   options: Options,
-): Promise<$ReadOnlyArray<AssetData>> {
+): Promise<ReadonlyArray<AssetData>> {
   const promises = [];
   const {processModuleFilter} = options;
 

package/src/DeltaBundler/Serializers/getExplodedSourceMap.js.flow

@@ -17,7 +17,7 @@ import type {
 
 import {getJsOutput, isJsModule} from './helpers/js';
 
-export type ExplodedSourceMap = $ReadOnlyArray<{
+export type ExplodedSourceMap = ReadonlyArray<{
   +map: Array<MetroSourceMapSegmentTuple>,
   +firstLine1Based: number,
   +functionMap: ?FBSourceFunctionMap,
@@ -25,7 +25,7 @@ export type ExplodedSourceMap = $ReadOnlyArray<{
 }>;
 
 export function getExplodedSourceMap(
-  modules: $ReadOnlyArray<Module<>>,
+  modules: ReadonlyArray<Module<>>,
   options: {
     +processModuleFilter: (module: Module<>) => boolean,
   },

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

@@ -8,11 +8,41 @@
  * @oncall react_native
  */
 
-import {ModuleTransportLike} from '../../shared/types';
+import type {ModuleTransportLike} from '../../shared/types';
+import type {Module, ReadOnlyGraph, SerializerOptions} from '../types';
+import type {SourceMapGeneratorOptions} from './sourceMapGenerator';
+import type {GetTransformOptions} from 'metro-config';
 
-export interface RamBundleInfo {
-  getDependencies: (filePath: string) => Set<string>;
-  startupModules: Readonly<ModuleTransportLike>;
-  lazyModules: Readonly<ModuleTransportLike>;
+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;