metro 0.76.3 → 0.76.5

package/src/DeltaBundler/Graph.js.flow

@@ -174,11 +174,26 @@ export class Graph<T = MixedOutput> {
 
     const internalOptions = getInternalOptions(options);
 
+    // Record the paths that are part of the dependency graph before we start
+    // traversing - we'll use this to ensure we don't report modules modified
+    // that only exist as part of the graph mid-traversal, and to eliminate
+    // modules that end up in the same state that they started from the delta.
+    const originalModules = new Map<string, Module<T>>();
     for (const path of paths) {
-      // Start traversing from modules that are already part of the dependency graph.
-      if (this.dependencies.get(path)) {
-        delta.modified.add(path);
+      const originalModule = this.dependencies.get(path);
+      if (originalModule) {
+        originalModules.set(path, originalModule);
+      }
+    }
 
+    for (const [path] of originalModules) {
+      // Traverse over modules that are part of the dependency graph.
+      //
+      // Note: A given path may not be part of the graph *at this time*, in
+      // particular it may have been removed since we started traversing, but
+      // in that case the path will be visited if and when we add it back to
+      // the graph in a subsequent iteration.
+      if (this.dependencies.has(path)) {
         await this._traverseDependenciesForSingleFile(
           path,
           delta,
@@ -195,10 +210,41 @@ export class Graph<T = MixedOutput> {
     }
 
     const modified = new Map<string, Module<T>>();
-    for (const path of delta.modified) {
-      // Only report a module as modified if we're not already reporting it as added or deleted.
-      if (!delta.added.has(path) && !delta.deleted.has(path)) {
-        modified.set(path, nullthrows(this.dependencies.get(path)));
+
+    // A path in delta.modified has been processed during this traversal,
+    // but may not actually differ, may be new, or may have been deleted after
+    // processing. The actually-modified modules are the intersection of
+    // delta.modified with the pre-existing paths, minus modules deleted.
+    for (const [path, originalModule] of originalModules) {
+      invariant(
+        !delta.added.has(path),
+        'delta.added has %s, but this path was already in the graph.',
+        path,
+      );
+      if (delta.modified.has(path)) {
+        // It's expected that a module may be both modified and subsequently
+        // deleted - we'll only return it as deleted.
+        if (!delta.deleted.has(path)) {
+          // If a module existed before and has not been deleted, it must be
+          // in the dependencies map.
+          const newModule = nullthrows(this.dependencies.get(path));
+          if (
+            // Module.dependencies is mutable, so it's not obviously the case
+            // that referential equality implies no modification. However, we
+            // only mutate dependencies in two cases:
+            // 1. Within _processModule. In that case, we always mutate a new
+            //    module and set a new reference in this.dependencies.
+            // 2. During _releaseModule, when recursively removing
+            //    dependencies. In that case, we immediately discard the module
+            //    object.
+            // TODO: Refactor for more explicit immutability
+            newModule !== originalModule ||
+            transfromOutputMayDiffer(newModule, originalModule) ||
+            !allDependenciesEqual(newModule, originalModule)
+          ) {
+            modified.set(path, newModule);
+          }
+        }
       }
     }
 
@@ -268,6 +314,7 @@ export class Graph<T = MixedOutput> {
     options: InternalOptions<T>,
   ): Promise<Module<T>> {
     const resolvedContext = this.#resolvedContexts.get(path);
+
     // Transform the file via the given option.
     // TODO: Unbind the transform method from options
     const result = await options.transform(path, resolvedContext);
@@ -280,48 +327,67 @@ export class Graph<T = MixedOutput> {
       options,
     );
 
-    const previousModule = this.dependencies.get(path) || {
-      inverseDependencies:
-        delta.earlyInverseDependencies.get(path) || new CountingSet(),
-      path,
-    };
-    const previousDependencies = previousModule.dependencies || new Map();
+    const previousModule = this.dependencies.get(path);
 
-    // Update the module information.
-    const module = {
-      ...previousModule,
+    const previousDependencies = previousModule?.dependencies ?? new Map();
+
+    const nextModule = {
+      ...(previousModule ?? {
+        inverseDependencies:
+          delta.earlyInverseDependencies.get(path) ?? new CountingSet(),
+        path,
+      }),
       dependencies: new Map(previousDependencies),
       getSource: result.getSource,
       output: result.output,
+      unstable_transformResultKey: result.unstable_transformResultKey,
     };
-    this.dependencies.set(module.path, module);
+
+    // Update the module information.
+    this.dependencies.set(nextModule.path, nextModule);
 
     // Diff dependencies (1/2): remove dependencies that have changed or been removed.
+    let dependenciesRemoved = false;
     for (const [key, prevDependency] of previousDependencies) {
       const curDependency = currentDependencies.get(key);
       if (
         !curDependency ||
         !dependenciesEqual(prevDependency, curDependency, options)
       ) {
-        this._removeDependency(module, key, prevDependency, delta, options);
+        dependenciesRemoved = true;
+        this._removeDependency(nextModule, key, prevDependency, delta, options);
       }
     }
 
     // Diff dependencies (2/2): add dependencies that have changed or been added.
-    const promises = [];
+    const addDependencyPromises = [];
     for (const [key, curDependency] of currentDependencies) {
       const prevDependency = previousDependencies.get(key);
       if (
         !prevDependency ||
         !dependenciesEqual(prevDependency, curDependency, options)
       ) {
-        promises.push(
-          this._addDependency(module, key, curDependency, delta, options),
+        addDependencyPromises.push(
+          this._addDependency(nextModule, key, curDependency, delta, options),
         );
       }
     }
 
-    await Promise.all(promises);
+    if (
+      previousModule &&
+      !transfromOutputMayDiffer(previousModule, nextModule) &&
+      !dependenciesRemoved &&
+      addDependencyPromises.length === 0
+    ) {
+      // We have not operated on nextModule, so restore previousModule
+      // to aid diffing.
+      this.dependencies.set(previousModule.path, previousModule);
+      return previousModule;
+    }
+
+    delta.modified.add(path);
+
+    await Promise.all(addDependencyPromises);
 
     // Replace dependencies with the correctly-ordered version. As long as all
     // the above promises have resolved, this will be the same map but without
@@ -331,13 +397,13 @@ export class Graph<T = MixedOutput> {
 
     // Catch obvious errors with a cheap assertion.
     invariant(
-      module.dependencies.size === currentDependencies.size,
+      nextModule.dependencies.size === currentDependencies.size,
       'Failed to add the correct dependencies',
     );
 
-    module.dependencies = currentDependencies;
+    nextModule.dependencies = currentDependencies;
 
-    return module;
+    return nextModule;
   }
 
   async _addDependency(
@@ -444,7 +510,10 @@ export class Graph<T = MixedOutput> {
   /**
    * Collect a list of context modules which include a given file.
    */
-  markModifiedContextModules(filePath: string, modifiedPaths: Set<string>) {
+  markModifiedContextModules(
+    filePath: string,
+    modifiedPaths: Set<string> | CountingSet<string>,
+  ) {
     for (const [absolutePath, context] of this.#resolvedContexts) {
       if (
         !modifiedPaths.has(absolutePath) &&
@@ -788,6 +857,23 @@ function dependenciesEqual(
   );
 }
 
+function allDependenciesEqual<T>(
+  a: Module<T>,
+  b: Module<T>,
+  options: $ReadOnly<{lazy: boolean, ...}>,
+): boolean {
+  if (a.dependencies.size !== b.dependencies.size) {
+    return false;
+  }
+  for (const [key, depA] of a.dependencies) {
+    const depB = b.dependencies.get(key);
+    if (!depB || !dependenciesEqual(depA, depB, options)) {
+      return false;
+    }
+  }
+  return true;
+}
+
 function contextParamsEqual(
   a: ?RequireContextParams,
   b: ?RequireContextParams,
@@ -803,3 +889,10 @@ function contextParamsEqual(
       a.mode === b.mode)
   );
 }
+
+function transfromOutputMayDiffer<T>(a: Module<T>, b: Module<T>): boolean {
+  return (
+    a.unstable_transformResultKey == null ||
+    a.unstable_transformResultKey !== b.unstable_transformResultKey
+  );
+}

package/src/DeltaBundler/Serializers/baseJSBundle.js

@@ -45,6 +45,7 @@ function baseJSBundle(entryPoint, preModules, graph, options) {
       inlineSourceMap: options.inlineSourceMap,
       runBeforeMainModule: options.runBeforeMainModule,
       runModule: options.runModule,
+      shouldAddToIgnoreList: options.shouldAddToIgnoreList,
       sourceMapUrl: options.sourceMapUrl,
       sourceUrl: options.sourceUrl,
     }),

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

@@ -64,6 +64,7 @@ function baseJSBundle(
       inlineSourceMap: options.inlineSourceMap,
       runBeforeMainModule: options.runBeforeMainModule,
       runModule: options.runModule,
+      shouldAddToIgnoreList: options.shouldAddToIgnoreList,
       sourceMapUrl: options.sourceMapUrl,
       sourceUrl: options.sourceUrl,
     }),

package/src/DeltaBundler/Serializers/getRamBundleInfo.js

@@ -31,6 +31,7 @@ async function getRamBundleInfo(entryPoint, pre, graph, options) {
       map: sourceMapObject([module], {
         excludeSource: options.excludeSource,
         processModuleFilter: options.processModuleFilter,
+        shouldAddToIgnoreList: options.shouldAddToIgnoreList,
       }),
       name: path.basename(module.path),
       sourcePath: module.path,

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

@@ -16,6 +16,7 @@ import type {
   RamModuleTransport,
 } from '../../shared/types.flow';
 import type {Module, ReadOnlyGraph, SerializerOptions} from '../types.flow';
+import type {SourceMapGeneratorOptions} from './sourceMapGenerator';
 import type {GetTransformOptions} from 'metro-config/src/configTypes.flow.js';
 
 const {createRamBundleGroups} = require('../../Bundler/util');
@@ -28,7 +29,7 @@ const path = require('path');
 
 type Options = $ReadOnly<{
   ...SerializerOptions,
-  excludeSource: boolean,
+  ...SourceMapGeneratorOptions,
   getTransformOptions: ?GetTransformOptions,
   platform: ?string,
 }>;
@@ -63,6 +64,7 @@ async function getRamBundleInfo(
       map: sourceMapObject([module], {
         excludeSource: options.excludeSource,
         processModuleFilter: options.processModuleFilter,
+        shouldAddToIgnoreList: options.shouldAddToIgnoreList,
       }),
       name: path.basename(module.path),
       sourcePath: module.path,

package/src/DeltaBundler/Serializers/helpers/getSourceMapInfo.js

@@ -15,6 +15,7 @@ const { getJsOutput } = require("./js");
 function getSourceMapInfo(module, options) {
   return {
     ...getJsOutput(module).data,
+    isIgnored: options.shouldAddToIgnoreList(module),
     path: module.path,
     source: options.excludeSource ? "" : getModuleSource(module),
   };

package/src/DeltaBundler/Serializers/helpers/getSourceMapInfo.js.flow

@@ -23,6 +23,7 @@ function getSourceMapInfo(
   module: Module<>,
   options: {
     +excludeSource: boolean,
+    +shouldAddToIgnoreList: (Module<>) => boolean,
   },
 ): {
   +map: Array<MetroSourceMapSegmentTuple>,
@@ -31,9 +32,11 @@ function getSourceMapInfo(
   +path: string,
   +source: string,
   +lineCount: number,
+  +isIgnored: boolean,
 } {
   return {
     ...getJsOutput(module).data,
+    isIgnored: options.shouldAddToIgnoreList(module),
     path: module.path,
     source: options.excludeSource ? '' : getModuleSource(module),
   };

package/src/DeltaBundler/Serializers/helpers/js.js

@@ -12,6 +12,7 @@
 "use strict";
 
 const invariant = require("invariant");
+const jscSafeUrl = require("jsc-safe-url");
 const { addParamsToDefineCall } = require("metro-transform-plugins");
 const path = require("path");
 function wrapModule(module, options) {
@@ -41,7 +42,9 @@ function getModuleParams(module, options) {
         // Construct a server-relative URL for the split bundle, propagating
         // most parameters from the main bundle's URL.
 
-        const { searchParams } = new URL(options.sourceUrl);
+        const { searchParams } = new URL(
+          jscSafeUrl.toNormalUrl(options.sourceUrl)
+        );
         searchParams.set("modulesOnly", "true");
         searchParams.set("runModule", "false");
         const bundlePath = path.relative(

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

@@ -15,6 +15,7 @@ import type {MixedOutput, Module} from '../../types.flow';
 import type {JsOutput} from 'metro-transform-worker';
 
 const invariant = require('invariant');
+const jscSafeUrl = require('jsc-safe-url');
 const {addParamsToDefineCall} = require('metro-transform-plugins');
 const path = require('path');
 
@@ -59,7 +60,9 @@ function getModuleParams(module: Module<>, options: Options): Array<mixed> {
         // Construct a server-relative URL for the split bundle, propagating
         // most parameters from the main bundle's URL.
 
-        const {searchParams} = new URL(options.sourceUrl);
+        const {searchParams} = new URL(
+          jscSafeUrl.toNormalUrl(options.sourceUrl),
+        );
         searchParams.set('modulesOnly', 'true');
         searchParams.set('runModule', 'false');
 

package/src/DeltaBundler/Serializers/hmrJSBundle.js

@@ -12,6 +12,7 @@
 "use strict";
 
 const { isJsModule, wrapModule } = require("./helpers/js");
+const jscSafeUrl = require("jsc-safe-url");
 const { addParamsToDefineCall } = require("metro-transform-plugins");
 const path = require("path");
 const url = require("url");
@@ -33,7 +34,7 @@ function generateModules(sourceModules, graph, options) {
         return url.format(options.clientUrl);
       };
       const sourceMappingURL = getURL("map");
-      const sourceURL = getURL("bundle");
+      const sourceURL = jscSafeUrl.toJscSafeUrl(getURL("bundle"));
       const code =
         prepareModule(module, graph, options) +
         `\n//# sourceMappingURL=${sourceMappingURL}\n` +

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

@@ -16,6 +16,7 @@ import type {DeltaResult, Module, ReadOnlyGraph} from '../types.flow';
 import type {HmrModule} from 'metro-runtime/src/modules/types.flow';
 
 const {isJsModule, wrapModule} = require('./helpers/js');
+const jscSafeUrl = require('jsc-safe-url');
 const {addParamsToDefineCall} = require('metro-transform-plugins');
 const path = require('path');
 const url = require('url');
@@ -53,7 +54,7 @@ function generateModules(
       };
 
       const sourceMappingURL = getURL('map');
-      const sourceURL = getURL('bundle');
+      const sourceURL = jscSafeUrl.toJscSafeUrl(getURL('bundle'));
       const code =
         prepareModule(module, graph, options) +
         `\n//# sourceMappingURL=${sourceMappingURL}\n` +

package/src/DeltaBundler/Serializers/sourceMapGenerator.js

@@ -29,6 +29,7 @@ function getSourceMapInfosImpl(isBlocking, onDone, modules, options) {
     const mod = modulesToProcess.shift();
     const info = getSourceMapInfo(mod, {
       excludeSource: options.excludeSource,
+      shouldAddToIgnoreList: options.shouldAddToIgnoreList,
     });
     sourceMapInfos.push(info);
     return false;

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

@@ -13,6 +13,12 @@
 
 import type {Module} from '../types.flow';
 
+export type SourceMapGeneratorOptions = $ReadOnly<{
+  excludeSource: boolean,
+  processModuleFilter: (module: Module<>) => boolean,
+  shouldAddToIgnoreList: (module: Module<>) => boolean,
+}>;
+
 const getSourceMapInfo = require('./helpers/getSourceMapInfo');
 const {isJsModule} = require('./helpers/js');
 const {
@@ -26,10 +32,7 @@ function getSourceMapInfosImpl(
   isBlocking: boolean,
   onDone: ($ReadOnlyArray<ReturnType<typeof getSourceMapInfo>>) => void,
   modules: $ReadOnlyArray<Module<>>,
-  options: {
-    +excludeSource: boolean,
-    +processModuleFilter: (module: Module<>) => boolean,
-  },
+  options: SourceMapGeneratorOptions,
 ): void {
   const sourceMapInfos = [];
   const modulesToProcess = modules
@@ -44,6 +47,7 @@ function getSourceMapInfosImpl(
     const mod = modulesToProcess.shift();
     const info = getSourceMapInfo(mod, {
       excludeSource: options.excludeSource,
+      shouldAddToIgnoreList: options.shouldAddToIgnoreList,
     });
     sourceMapInfos.push(info);
     return false;
@@ -77,10 +81,7 @@ function getSourceMapInfosImpl(
 
 function sourceMapGenerator(
   modules: $ReadOnlyArray<Module<>>,
-  options: {
-    +excludeSource: boolean,
-    +processModuleFilter: (module: Module<>) => boolean,
-  },
+  options: SourceMapGeneratorOptions,
 ): ReturnType<typeof fromRawMappings> {
   let sourceMapInfos;
   getSourceMapInfosImpl(
@@ -101,10 +102,7 @@ function sourceMapGenerator(
 
 async function sourceMapGeneratorNonBlocking(
   modules: $ReadOnlyArray<Module<>>,
-  options: {
-    +excludeSource: boolean,
-    +processModuleFilter: (module: Module<>) => boolean,
-  },
+  options: SourceMapGeneratorOptions,
 ): ReturnType<typeof fromRawMappingsNonBlocking> {
   const sourceMapInfos = await new Promise<
     $ReadOnlyArray<ReturnType<typeof getSourceMapInfo>>,

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

@@ -12,6 +12,7 @@
 'use strict';
 
 import type {Module} from '../types.flow';
+import type {SourceMapGeneratorOptions} from './sourceMapGenerator';
 import type {MixedSourceMap} from 'metro-source-map';
 
 const {
@@ -21,10 +22,7 @@ const {
 
 function sourceMapObject(
   modules: $ReadOnlyArray<Module<>>,
-  options: {
-    +excludeSource: boolean,
-    +processModuleFilter: (module: Module<>) => boolean,
-  },
+  options: SourceMapGeneratorOptions,
 ): MixedSourceMap {
   const generator = sourceMapGenerator(modules, options);
   return generator.toMap(undefined, {
@@ -34,10 +32,7 @@ function sourceMapObject(
 
 async function sourceMapObjectNonBlocking(
   modules: $ReadOnlyArray<Module<>>,
-  options: {
-    +excludeSource: boolean,
-    +processModuleFilter: (module: Module<>) => boolean,
-  },
+  options: SourceMapGeneratorOptions,
 ): Promise<MixedSourceMap> {
   const generator = await sourceMapGeneratorNonBlocking(modules, options);
   return generator.toMap(undefined, {

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

@@ -12,15 +12,13 @@
 'use strict';
 
 import type {Module} from '../types.flow';
+import type {SourceMapGeneratorOptions} from './sourceMapGenerator';
 
 const {sourceMapGenerator} = require('./sourceMapGenerator');
 
 function sourceMapString(
   modules: $ReadOnlyArray<Module<>>,
-  options: {
-    +excludeSource: boolean,
-    +processModuleFilter: (module: Module<>) => boolean,
-  },
+  options: SourceMapGeneratorOptions,
 ): string {
   return sourceMapGenerator(modules, options).toString(undefined, {
     excludeSource: options.excludeSource,

package/src/DeltaBundler/Transformer.js

@@ -130,6 +130,7 @@ class Transformer {
     cache.set(fullKey, data.result);
     return {
       ...data.result,
+      unstable_transformResultKey: fullKey.toString(),
       getSource() {
         if (fileBuffer) {
           return fileBuffer;

package/src/DeltaBundler/Transformer.js.flow

@@ -155,6 +155,7 @@ class Transformer {
 
     return {
       ...data.result,
+      unstable_transformResultKey: fullKey.toString(),
       getSource(): Buffer {
         if (fileBuffer) {
           return fileBuffer;

package/src/DeltaBundler/types.d.ts

@@ -164,6 +164,7 @@ export interface SerializerOptions<T = MixedOutput> {
   readonly runBeforeMainModule: ReadonlyArray<string>;
   readonly runModule: boolean;
   readonly serverRoot: string;
+  readonly shouldAddToIgnoreList: (module: Module<T>) => boolean;
   readonly sourceMapUrl?: string;
   readonly sourceUrl?: string;
 }

package/src/DeltaBundler/types.flow.js.flow

@@ -61,13 +61,14 @@ export type Dependency = {
   +data: TransformResultDependency,
 };
 
-export type Module<T = MixedOutput> = {
-  +dependencies: Map<string, Dependency>,
-  +inverseDependencies: CountingSet<string>,
-  +output: $ReadOnlyArray<T>,
-  +path: string,
-  +getSource: () => Buffer,
-};
+export type Module<T = MixedOutput> = $ReadOnly<{
+  dependencies: Map<string, Dependency>,
+  inverseDependencies: CountingSet<string>,
+  output: $ReadOnlyArray<T>,
+  path: string,
+  getSource: () => Buffer,
+  unstable_transformResultKey?: ?string,
+}>;
 
 export type Dependencies<T = MixedOutput> = Map<string, Module<T>>;
 export type ReadOnlyDependencies<T = MixedOutput> = $ReadOnlyMap<
@@ -102,6 +103,7 @@ export type {Graph};
 export type TransformResult<T = MixedOutput> = $ReadOnly<{
   dependencies: $ReadOnlyArray<TransformResultDependency>,
   output: $ReadOnlyArray<T>,
+  unstable_transformResultKey?: ?string,
 }>;
 
 export type TransformResultWithSource<T = MixedOutput> = $ReadOnly<{
@@ -156,6 +158,7 @@ export type SerializerOptions = $ReadOnly<{
   runBeforeMainModule: $ReadOnlyArray<string>,
   runModule: boolean,
   serverRoot: string,
+  shouldAddToIgnoreList: (Module<>) => boolean,
   sourceMapUrl: ?string,
   sourceUrl: ?string,
 }>;