metro 0.83.4 → 0.83.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.83.4",
+  "version": "0.83.5",
   "description": "🚇 The JavaScript bundler for React Native.",
   "main": "src/index.js",
   "bin": "src/cli.js",
@@ -11,7 +11,8 @@
   },
   "repository": {
     "type": "git",
-    "url": "git@github.com:facebook/metro.git"
+    "url": "git+https://github.com/facebook/metro.git",
+    "directory": "packages/metro"
   },
   "scripts": {
     "prepare-release": "test -d build && rm -rf src.real && mv src src.real && mv build src",
@@ -39,18 +40,18 @@
     "jest-worker": "^29.7.0",
     "jsc-safe-url": "^0.2.2",
     "lodash.throttle": "^4.1.1",
-    "metro-babel-transformer": "0.83.4",
-    "metro-cache": "0.83.4",
-    "metro-cache-key": "0.83.4",
-    "metro-config": "0.83.4",
-    "metro-core": "0.83.4",
-    "metro-file-map": "0.83.4",
-    "metro-resolver": "0.83.4",
-    "metro-runtime": "0.83.4",
-    "metro-source-map": "0.83.4",
-    "metro-symbolicate": "0.83.4",
-    "metro-transform-plugins": "0.83.4",
-    "metro-transform-worker": "0.83.4",
+    "metro-babel-transformer": "0.83.5",
+    "metro-cache": "0.83.5",
+    "metro-cache-key": "0.83.5",
+    "metro-config": "0.83.5",
+    "metro-core": "0.83.5",
+    "metro-file-map": "0.83.5",
+    "metro-resolver": "0.83.5",
+    "metro-runtime": "0.83.5",
+    "metro-source-map": "0.83.5",
+    "metro-symbolicate": "0.83.5",
+    "metro-transform-plugins": "0.83.5",
+    "metro-transform-worker": "0.83.5",
     "mime-types": "^3.0.1",
     "nullthrows": "^1.1.1",
     "serialize-error": "^2.1.0",
@@ -71,10 +72,11 @@
     "dedent": "^0.7.0",
     "jest-snapshot": "^29.7.0",
     "jest-snapshot-serializer-raw": "^1.2.0",
-    "metro-babel-register": "0.83.4",
+    "metro-babel-register": "0.83.5",
     "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,83 @@
+/**
+ * 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
+ */
+
+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/Assets.js

@@ -17,11 +17,7 @@ var _fs = _interopRequireDefault(require("fs"));
 var _imageSize = _interopRequireDefault(require("image-size"));
 var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 function _interopRequireWildcard(e, t) {
   if ("function" == typeof WeakMap)
@@ -31,10 +27,7 @@ function _interopRequireWildcard(e, t) {
     if (!t && e && e.__esModule) return e;
     var o,
       i,
-      f = {
-        __proto__: null,
-        default: e,
-      };
+      f = { __proto__: null, default: e };
     if (null === e || ("object" != typeof e && "function" != typeof e))
       return f;
     if ((o = t ? n : r)) {

package/src/Bundler/util.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.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+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/util.js

@@ -9,11 +9,7 @@ var babylon = _interopRequireWildcard(require("@babel/parser"));
 var _template = _interopRequireDefault(require("@babel/template"));
 var babelTypes = _interopRequireWildcard(require("@babel/types"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 function _interopRequireWildcard(e, t) {
   if ("function" == typeof WeakMap)
@@ -23,10 +19,7 @@ function _interopRequireWildcard(e, t) {
     if (!t && e && e.__esModule) return e;
     var o,
       i,
-      f = {
-        __proto__: null,
-        default: e,
-      };
+      f = { __proto__: null, default: e };
     if (null === e || ("object" != typeof e && "function" != typeof e))
       return f;
     if ((o = t ? n : r)) {

package/src/Bundler.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 {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/Bundler.js

@@ -11,11 +11,7 @@ var _DependencyGraph = _interopRequireDefault(
   require("./node-haste/DependencyGraph"),
 );
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 class Bundler {
   constructor(config, options) {

package/src/DeltaBundler/DeltaCalculator.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 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 {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/DeltaCalculator.js

@@ -8,11 +8,7 @@ var _Graph = require("./Graph");
 var _events = _interopRequireDefault(require("events"));
 var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const debug = require("debug")("Metro:DeltaCalculator");
 class DeltaCalculator extends _events.default {

package/src/DeltaBundler/Graph.d.ts

@@ -0,0 +1,167 @@
+/**
+ * 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
+ */
+
+/**
+ * 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/Graph.js

@@ -11,11 +11,7 @@ var _buildSubgraph = require("./buildSubgraph");
 var _invariant = _interopRequireDefault(require("invariant"));
 var _nullthrows = _interopRequireDefault(require("nullthrows"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 function getInternalOptions({ transform, resolve, onProgress, lazy, shallow }) {
   let numProcessed = 0;

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

@@ -11,11 +11,7 @@ var _processModules = _interopRequireDefault(
   require("./helpers/processModules"),
 );
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 function baseJSBundle(entryPoint, preModules, graph, options) {
   for (const module of graph.dependencies.values()) {

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

@@ -8,11 +8,7 @@ var _Assets = require("../../Assets");
 var _js = require("./helpers/js");
 var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 async function getAssets(dependencies, options) {
   const promises = [];

package/src/DeltaBundler/Serializers/getExplodedSourceMap.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 {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;