metro 0.83.3 → 0.83.5

package/src/IncrementalBundler.d.ts

@@ -8,91 +8,89 @@
  * @oncall react_native
  */
 
-import type Bundler from './Bundler';
+import type {DeltaResult, Graph, Module} from './DeltaBundler';
 import type {
   Options as DeltaBundlerOptions,
   ReadOnlyDependencies,
   TransformInputOptions,
 } from './DeltaBundler/types';
 import type {GraphId} from './lib/getGraphId';
+import type {ResolverInputOptions} from './shared/types';
 import type {ConfigT} from 'metro-config';
 
-import DeltaBundler, {DeltaResult, Graph, Module} from './DeltaBundler';
-import {ResolverInputOptions} from './shared/types';
+import Bundler from './Bundler';
+import DeltaBundler from './DeltaBundler';
 
-export type RevisionId = string;
-
-export type OutputGraph = Graph<void>;
-
-export interface OtherOptions {
-  readonly onProgress: DeltaBundlerOptions<void>['onProgress'];
-  readonly shallow: boolean;
-}
-
-export interface GraphRevision {
+export declare type RevisionId = string;
+export type OutputGraph = Graph;
+type OtherOptions = Readonly<{
+  onProgress: DeltaBundlerOptions['onProgress'];
+  shallow: boolean;
+  lazy: boolean;
+}>;
+export type GraphRevision = {
   readonly id: RevisionId;
   readonly date: Date;
   readonly graphId: GraphId;
   readonly graph: OutputGraph;
-  readonly prepend: ReadonlyArray<Module<void>>;
-}
-
-export interface IncrementalBundlerOptions {
-  readonly hasReducedPerformance?: boolean;
-  readonly watch?: boolean;
-}
-
-export default class IncrementalBundler {
+  readonly prepend: ReadonlyArray<Module>;
+};
+export type IncrementalBundlerOptions = Readonly<{
+  hasReducedPerformance?: boolean;
+  watch?: boolean;
+}>;
+declare class IncrementalBundler {
+  _config: ConfigT;
+  _bundler: Bundler;
+  _deltaBundler: DeltaBundler;
+  _revisionsById: Map<RevisionId, Promise<GraphRevision>>;
+  _revisionsByGraphId: Map<GraphId, Promise<GraphRevision>>;
   static revisionIdFromString: (str: string) => RevisionId;
   constructor(config: ConfigT, options?: IncrementalBundlerOptions);
-
-  end(): void;
+  end(): Promise<void>;
   getBundler(): Bundler;
-  getDeltaBundler(): DeltaBundler<void>;
-  getRevision(revisionId: RevisionId): Promise<GraphRevision> | null;
-  getRevisionByGraphId(graphId: GraphId): Promise<GraphRevision> | null;
-
+  getDeltaBundler(): DeltaBundler;
+  getRevision(
+    revisionId: RevisionId,
+  ): null | undefined | Promise<GraphRevision>;
+  getRevisionByGraphId(
+    graphId: GraphId,
+  ): null | undefined | Promise<GraphRevision>;
   buildGraphForEntries(
     entryFiles: ReadonlyArray<string>,
     transformOptions: TransformInputOptions,
     resolverOptions: ResolverInputOptions,
     otherOptions?: OtherOptions,
   ): Promise<OutputGraph>;
-
   getDependencies(
     entryFiles: ReadonlyArray<string>,
     transformOptions: TransformInputOptions,
     resolverOptions: ResolverInputOptions,
     otherOptions?: OtherOptions,
-  ): Promise<ReadOnlyDependencies<void>>;
-
+  ): Promise<ReadOnlyDependencies>;
   buildGraph(
     entryFile: string,
     transformOptions: TransformInputOptions,
     resolverOptions: ResolverInputOptions,
     otherOptions?: OtherOptions,
-  ): Promise<
-    Readonly<{graph: OutputGraph; prepend: ReadonlyArray<Module<void>>}>
-  >;
-
+  ): Promise<{
+    readonly graph: OutputGraph;
+    readonly prepend: ReadonlyArray<Module>;
+  }>;
   initializeGraph(
     entryFile: string,
     transformOptions: TransformInputOptions,
     resolverOptions: ResolverInputOptions,
     otherOptions?: OtherOptions,
-  ): Promise<{
-    delta: DeltaResult<void>;
-    revision: GraphRevision;
-  }>;
-
+  ): Promise<{delta: DeltaResult; revision: GraphRevision}>;
   updateGraph(
     revision: GraphRevision,
     reset: boolean,
-  ): Promise<{
-    delta: DeltaResult<void>;
-    revision: GraphRevision;
-  }>;
-
+  ): Promise<{delta: DeltaResult; revision: GraphRevision}>;
   endGraph(graphId: GraphId): Promise<void>;
+  _getAbsoluteEntryFiles(
+    entryFiles: ReadonlyArray<string>,
+  ): Promise<ReadonlyArray<string>>;
   ready(): Promise<void>;
 }
+export default IncrementalBundler;

package/src/IncrementalBundler.js

@@ -19,28 +19,32 @@ var transformHelpers = _interopRequireWildcard(
 var _crypto = _interopRequireDefault(require("crypto"));
 var _fs = _interopRequireDefault(require("fs"));
 var _path = _interopRequireDefault(require("path"));
-function _getRequireWildcardCache(e) {
-  if ("function" != typeof WeakMap) return null;
-  var r = new WeakMap(),
-    t = new WeakMap();
-  return (_getRequireWildcardCache = function (e) {
-    return e ? t : r;
-  })(e);
-}
-function _interopRequireWildcard(e, r) {
-  if (!r && e && e.__esModule) return e;
-  if (null === e || ("object" != typeof e && "function" != typeof e))
-    return { default: e };
-  var t = _getRequireWildcardCache(r);
-  if (t && t.has(e)) return t.get(e);
-  var n = { __proto__: null },
-    a = Object.defineProperty && Object.getOwnPropertyDescriptor;
-  for (var u in e)
-    if ("default" !== u && {}.hasOwnProperty.call(e, u)) {
-      var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
-      i && (i.get || i.set) ? Object.defineProperty(n, u, i) : (n[u] = e[u]);
+function _interopRequireWildcard(e, t) {
+  if ("function" == typeof WeakMap)
+    var r = new WeakMap(),
+      n = new WeakMap();
+  return (_interopRequireWildcard = function (e, t) {
+    if (!t && e && e.__esModule) return e;
+    var o,
+      i,
+      f = { __proto__: null, default: e };
+    if (null === e || ("object" != typeof e && "function" != typeof e))
+      return f;
+    if ((o = t ? n : r)) {
+      if (o.has(e)) return o.get(e);
+      o.set(e, f);
     }
-  return ((n.default = e), t && t.set(e, n), n);
+    for (const t in e)
+      "default" !== t &&
+        {}.hasOwnProperty.call(e, t) &&
+        ((i =
+          (o = Object.defineProperty) &&
+          Object.getOwnPropertyDescriptor(e, t)) &&
+        (i.get || i.set)
+          ? o(f, t, i)
+          : (f[t] = e[t]));
+    return f;
+  })(e, t);
 }
 function _interopRequireDefault(e) {
   return e && e.__esModule ? e : { default: e };
@@ -108,6 +112,8 @@ class IncrementalBundler {
         this._config.transformer.unstable_allowRequireContext,
       unstable_enablePackageExports:
         this._config.resolver.unstable_enablePackageExports,
+      unstable_incrementalResolution:
+        this._config.resolver.unstable_incrementalResolution,
       shallow: otherOptions.shallow,
     });
     this._config.serializer.experimentalSerializerHook(graph, {
@@ -152,6 +158,8 @@ class IncrementalBundler {
           this._config.transformer.unstable_allowRequireContext,
         unstable_enablePackageExports:
           this._config.resolver.unstable_enablePackageExports,
+        unstable_incrementalResolution:
+          this._config.resolver.unstable_incrementalResolution,
         shallow: otherOptions.shallow,
       },
     );

package/src/IncrementalBundler.js.flow

@@ -33,7 +33,7 @@ export opaque type RevisionId: string = string;
 
 export type OutputGraph = Graph<>;
 
-type OtherOptions = $ReadOnly<{
+type OtherOptions = Readonly<{
   onProgress: DeltaBundlerOptions<>['onProgress'],
   shallow: boolean,
   lazy: boolean,
@@ -45,10 +45,10 @@ export type GraphRevision = {
   +date: Date,
   +graphId: GraphId,
   +graph: OutputGraph,
-  +prepend: $ReadOnlyArray<Module<>>,
+  +prepend: ReadonlyArray<Module<>>,
 };
 
-export type IncrementalBundlerOptions = $ReadOnly<{
+export type IncrementalBundlerOptions = Readonly<{
   hasReducedPerformance?: boolean,
   watch?: boolean,
 }>;
@@ -99,7 +99,7 @@ export default class IncrementalBundler {
   }
 
   async buildGraphForEntries(
-    entryFiles: $ReadOnlyArray<string>,
+    entryFiles: ReadonlyArray<string>,
     transformOptions: TransformInputOptions,
     resolverOptions: ResolverInputOptions,
     otherOptions?: OtherOptions = {
@@ -131,6 +131,8 @@ export default class IncrementalBundler {
         this._config.transformer.unstable_allowRequireContext,
       unstable_enablePackageExports:
         this._config.resolver.unstable_enablePackageExports,
+      unstable_incrementalResolution:
+        this._config.resolver.unstable_incrementalResolution,
       shallow: otherOptions.shallow,
     });
 
@@ -145,7 +147,7 @@ export default class IncrementalBundler {
   }
 
   async getDependencies(
-    entryFiles: $ReadOnlyArray<string>,
+    entryFiles: ReadonlyArray<string>,
     transformOptions: TransformInputOptions,
     resolverOptions: ResolverInputOptions,
     otherOptions?: OtherOptions = {
@@ -179,6 +181,8 @@ export default class IncrementalBundler {
           this._config.transformer.unstable_allowRequireContext,
         unstable_enablePackageExports:
           this._config.resolver.unstable_enablePackageExports,
+        unstable_incrementalResolution:
+          this._config.resolver.unstable_incrementalResolution,
         shallow: otherOptions.shallow,
       },
     );
@@ -195,7 +199,7 @@ export default class IncrementalBundler {
       shallow: false,
       lazy: false,
     },
-  ): Promise<{+graph: OutputGraph, +prepend: $ReadOnlyArray<Module<>>}> {
+  ): Promise<{+graph: OutputGraph, +prepend: ReadonlyArray<Module<>>}> {
     const graph = await this.buildGraphForEntries(
       [entryFile],
       transformOptions,
@@ -330,8 +334,8 @@ export default class IncrementalBundler {
   }
 
   async _getAbsoluteEntryFiles(
-    entryFiles: $ReadOnlyArray<string>,
-  ): Promise<$ReadOnlyArray<string>> {
+    entryFiles: ReadonlyArray<string>,
+  ): Promise<ReadonlyArray<string>> {
     const absoluteEntryFiles = entryFiles.map((entryFile: string) =>
       path.resolve(
         this._config.server.unstable_serverRoot ?? this._config.projectRoot,
@@ -342,7 +346,7 @@ export default class IncrementalBundler {
     await Promise.all(
       absoluteEntryFiles.map(
         (entryFile: string) =>
-          new Promise((resolve: void => void, reject: mixed => mixed) => {
+          new Promise((resolve: void => void, reject: unknown => unknown) => {
             // This should throw an error if the file doesn't exist.
             // Using this instead of fs.exists to account for SimLinks.
             fs.realpath(entryFile, err => {

package/src/ModuleGraph/worker/JsFileWrapping.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.
+ *
+ * @format
+ */
+
+import type {File as BabelNodeFile} from '@babel/types';
+
+declare const WRAP_NAME: '$$_REQUIRE';
+declare function wrapModule(
+  fileAst: BabelNodeFile,
+  importDefaultName: string,
+  importAllName: string,
+  dependencyMapName: string,
+  globalPrefix: string,
+  skipRequireRename: boolean,
+  $$PARAM_6$$?: Readonly<{unstable_useStaticHermesModuleFactory?: boolean}>,
+): {ast: BabelNodeFile; requireName: string};
+declare function wrapPolyfill(fileAst: BabelNodeFile): BabelNodeFile;
+declare function jsonToCommonJS(source: string): string;
+declare function wrapJson(
+  source: string,
+  globalPrefix: string,
+  unstable_useStaticHermesModuleFactory?: boolean,
+): string;
+export {WRAP_NAME, wrapJson, jsonToCommonJS, wrapModule, wrapPolyfill};

package/src/ModuleGraph/worker/JsFileWrapping.js

@@ -12,28 +12,32 @@ var _template = _interopRequireDefault(require("@babel/template"));
 var _traverse = _interopRequireDefault(require("@babel/traverse"));
 var t = _interopRequireWildcard(require("@babel/types"));
 var _invariant = _interopRequireDefault(require("invariant"));
-function _getRequireWildcardCache(e) {
-  if ("function" != typeof WeakMap) return null;
-  var r = new WeakMap(),
-    t = new WeakMap();
-  return (_getRequireWildcardCache = function (e) {
-    return e ? t : r;
-  })(e);
-}
-function _interopRequireWildcard(e, r) {
-  if (!r && e && e.__esModule) return e;
-  if (null === e || ("object" != typeof e && "function" != typeof e))
-    return { default: e };
-  var t = _getRequireWildcardCache(r);
-  if (t && t.has(e)) return t.get(e);
-  var n = { __proto__: null },
-    a = Object.defineProperty && Object.getOwnPropertyDescriptor;
-  for (var u in e)
-    if ("default" !== u && {}.hasOwnProperty.call(e, u)) {
-      var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
-      i && (i.get || i.set) ? Object.defineProperty(n, u, i) : (n[u] = e[u]);
+function _interopRequireWildcard(e, t) {
+  if ("function" == typeof WeakMap)
+    var r = new WeakMap(),
+      n = new WeakMap();
+  return (_interopRequireWildcard = function (e, t) {
+    if (!t && e && e.__esModule) return e;
+    var o,
+      i,
+      f = { __proto__: null, default: e };
+    if (null === e || ("object" != typeof e && "function" != typeof e))
+      return f;
+    if ((o = t ? n : r)) {
+      if (o.has(e)) return o.get(e);
+      o.set(e, f);
     }
-  return ((n.default = e), t && t.set(e, n), n);
+    for (const t in e)
+      "default" !== t &&
+        {}.hasOwnProperty.call(e, t) &&
+        ((i =
+          (o = Object.defineProperty) &&
+          Object.getOwnPropertyDescriptor(e, t)) &&
+        (i.get || i.set)
+          ? o(f, t, i)
+          : (f[t] = e[t]));
+    return f;
+  })(e, t);
 }
 function _interopRequireDefault(e) {
   return e && e.__esModule ? e : { default: e };

package/src/ModuleGraph/worker/JsFileWrapping.js.flow

@@ -4,11 +4,16 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @format
  * @flow strict-local
+ * @format
  */
 
-import type {FunctionExpression, Identifier, Program} from '@babel/types';
+import type {
+  File as BabelNodeFile,
+  FunctionExpression,
+  Identifier,
+  Program,
+} from '@babel/types';
 
 import template from '@babel/template';
 import traverse from '@babel/traverse';
@@ -33,7 +38,7 @@ function wrapModule(
   skipRequireRename: boolean,
   {
     unstable_useStaticHermesModuleFactory = false,
-  }: $ReadOnly<{unstable_useStaticHermesModuleFactory?: boolean}> = {},
+  }: Readonly<{unstable_useStaticHermesModuleFactory?: boolean}> = {},
 ): {
   ast: BabelNodeFile,
   requireName: string,
@@ -106,7 +111,7 @@ function wrapJson(
 
 function functionFromProgram(
   program: Program,
-  parameters: $ReadOnlyArray<string>,
+  parameters: ReadonlyArray<string>,
 ): FunctionExpression {
   return t.functionExpression(
     undefined,
@@ -123,7 +128,7 @@ function buildParameters(
   importDefaultName: string,
   importAllName: string,
   dependencyMapName: string,
-): $ReadOnlyArray<string> {
+): ReadonlyArray<string> {
   return [
     'global',
     'require',

package/src/ModuleGraph/worker/collectDependencies.d.ts

@@ -5,23 +5,127 @@
  * LICENSE file in the root directory of this source tree.
  *
  * @format
- * @oncall react_native
  */
 
-export type ContextMode = 'sync' | 'eager' | 'lazy' | 'lazy-once';
-
-export interface ContextFilter {
-  pattern: string;
-  flags: string;
-}
+import type {ReadonlySourceLocation} from '../../shared/types';
+import type {NodePath} from '@babel/traverse';
+import type {
+  CallExpression,
+  File as BabelNodeFile,
+  Identifier,
+  StringLiteral,
+} from '@babel/types';
+import type {
+  AllowOptionalDependencies,
+  AsyncDependencyType,
+} from 'metro/private/DeltaBundler/types';
 
-export interface RequireContextParams {
-  /* Should search for files recursively. Optional, default `true` when `require.context` is used */
-  readonly recursive: boolean;
-  /* Filename filter pattern for use in `require.context`. Optional, default `.*` (any file) when `require.context` is used */
-  readonly filter: Readonly<ContextFilter>;
+export type Dependency = Readonly<{data: DependencyData; name: string}>;
+export type ContextMode = 'sync' | 'eager' | 'lazy' | 'lazy-once';
+type ContextFilter = Readonly<{pattern: string; flags: string}>;
+export type RequireContextParams = Readonly<{
+  recursive: boolean;
+  filter: Readonly<ContextFilter>;
   /** Mode for resolving dynamic dependencies. Defaults to `sync` */
-  readonly mode: ContextMode;
+  mode: ContextMode;
+}>;
+type DependencyData = Readonly<{
+  key: string;
+  asyncType: AsyncDependencyType | null;
+  isESMImport: boolean;
+  isOptional?: boolean;
+  locs: ReadonlyArray<ReadonlySourceLocation>;
+  /** Context for requiring a collection of modules. */
+  contextParams?: RequireContextParams;
+}>;
+export type MutableInternalDependency = Omit<
+  DependencyData,
+  keyof {locs: Array<ReadonlySourceLocation>; index: number; name: string}
+> & {locs: Array<ReadonlySourceLocation>; index: number; name: string};
+export type InternalDependency = Readonly<MutableInternalDependency>;
+export type State = {
+  asyncRequireModulePathStringLiteral: null | undefined | StringLiteral;
+  dependencyCalls: Set<string>;
+  dependencyRegistry: DependencyRegistry;
+  dependencyTransformer: DependencyTransformer;
+  dynamicRequires: DynamicRequiresBehavior;
+  dependencyMapIdentifier: null | undefined | Identifier;
+  keepRequireNames: boolean;
+  allowOptionalDependencies: AllowOptionalDependencies;
+  /** Enable `require.context` statements which can be used to import multiple files in a directory. */
+  unstable_allowRequireContext: boolean;
+  unstable_isESMImportAtSource:
+    | null
+    | undefined
+    | (($$PARAM_0$$: ReadonlySourceLocation) => boolean);
+};
+export type Options = Readonly<{
+  asyncRequireModulePath: string;
+  dependencyMapName: null | undefined | string;
+  dynamicRequires: DynamicRequiresBehavior;
+  inlineableCalls: ReadonlyArray<string>;
+  keepRequireNames: boolean;
+  allowOptionalDependencies: AllowOptionalDependencies;
+  dependencyTransformer?: DependencyTransformer;
+  /** Enable `require.context` statements which can be used to import multiple files in a directory. */
+  unstable_allowRequireContext: boolean;
+  unstable_isESMImportAtSource?:
+    | null
+    | undefined
+    | (($$PARAM_0$$: ReadonlySourceLocation) => boolean);
+}>;
+export type CollectedDependencies = Readonly<{
+  ast: BabelNodeFile;
+  dependencyMapName: string;
+  dependencies: ReadonlyArray<Dependency>;
+}>;
+export interface DependencyTransformer {
+  transformSyncRequire(
+    path: NodePath<CallExpression>,
+    dependency: InternalDependency,
+    state: State,
+  ): void;
+  transformImportCall(
+    path: NodePath,
+    dependency: InternalDependency,
+    state: State,
+  ): void;
+  transformImportMaybeSyncCall(
+    path: NodePath,
+    dependency: InternalDependency,
+    state: State,
+  ): void;
+  transformPrefetch(
+    path: NodePath,
+    dependency: InternalDependency,
+    state: State,
+  ): void;
+  transformIllegalDynamicRequire(path: NodePath, state: State): void;
 }
-
 export type DynamicRequiresBehavior = 'throwAtRuntime' | 'reject';
+/**
+ * Transform all the calls to `require()` and `import()` in a file into ID-
+ * independent code, and return the list of dependencies. For example, a call
+ * like `require('Foo')` could be transformed to `require(_depMap[3], 'Foo')`
+ * where `_depMap` is provided by the outer scope. As such, we don't need to
+ * know the actual module ID.
+ *
+ * The second argument is only provided for debugging purposes.
+ */
+declare function collectDependencies(
+  ast: BabelNodeFile,
+  options: Options,
+): CollectedDependencies;
+export default collectDependencies;
+export type ImportQualifier = Readonly<{
+  name: string;
+  asyncType: AsyncDependencyType | null;
+  isESMImport: boolean;
+  optional: boolean;
+  contextParams?: RequireContextParams;
+}>;
+declare class DependencyRegistry {
+  _dependencies: Map<string, InternalDependency>;
+  registerDependency(qualifier: ImportQualifier): InternalDependency;
+  getDependencies(): Array<InternalDependency>;
+}

package/src/ModuleGraph/worker/collectDependencies.js

@@ -12,28 +12,32 @@ var types = _types;
 var _crypto = _interopRequireDefault(require("crypto"));
 var _invariant = _interopRequireDefault(require("invariant"));
 var _nullthrows = _interopRequireDefault(require("nullthrows"));
-function _getRequireWildcardCache(e) {
-  if ("function" != typeof WeakMap) return null;
-  var r = new WeakMap(),
-    t = new WeakMap();
-  return (_getRequireWildcardCache = function (e) {
-    return e ? t : r;
-  })(e);
-}
-function _interopRequireWildcard(e, r) {
-  if (!r && e && e.__esModule) return e;
-  if (null === e || ("object" != typeof e && "function" != typeof e))
-    return { default: e };
-  var t = _getRequireWildcardCache(r);
-  if (t && t.has(e)) return t.get(e);
-  var n = { __proto__: null },
-    a = Object.defineProperty && Object.getOwnPropertyDescriptor;
-  for (var u in e)
-    if ("default" !== u && {}.hasOwnProperty.call(e, u)) {
-      var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
-      i && (i.get || i.set) ? Object.defineProperty(n, u, i) : (n[u] = e[u]);
+function _interopRequireWildcard(e, t) {
+  if ("function" == typeof WeakMap)
+    var r = new WeakMap(),
+      n = new WeakMap();
+  return (_interopRequireWildcard = function (e, t) {
+    if (!t && e && e.__esModule) return e;
+    var o,
+      i,
+      f = { __proto__: null, default: e };
+    if (null === e || ("object" != typeof e && "function" != typeof e))
+      return f;
+    if ((o = t ? n : r)) {
+      if (o.has(e)) return o.get(e);
+      o.set(e, f);
     }
-  return ((n.default = e), t && t.set(e, n), n);
+    for (const t in e)
+      "default" !== t &&
+        {}.hasOwnProperty.call(e, t) &&
+        ((i =
+          (o = Object.defineProperty) &&
+          Object.getOwnPropertyDescriptor(e, t)) &&
+        (i.get || i.set)
+          ? o(f, t, i)
+          : (f[t] = e[t]));
+    return f;
+  })(e, t);
 }
 function _interopRequireDefault(e) {
   return e && e.__esModule ? e : { default: e };