metro 0.83.3 → 0.83.5

package/src/DeltaBundler/Worker.d.ts

@@ -9,37 +9,29 @@
  */
 
 import type {TransformResult} from './types';
+import type {LogEntry} from 'metro-core/private/Logger';
 import type {
   JsTransformerConfig,
   JsTransformOptions,
 } from 'metro-transform-worker';
 
-type LogEntry = unknown;
-
-export type TransformOptions = JsTransformOptions;
-
-export interface Worker {
-  readonly transform: (
-    filename: string,
-    transformOptions: JsTransformOptions,
-    projectRoot: string,
-    transformerConfig: TransformerConfig,
-    fileBuffer?: Buffer,
-  ) => Promise<Data>;
-}
-
-export interface TransformerConfig {
+export type {JsTransformOptions as TransformOptions} from 'metro-transform-worker';
+export type TransformerConfig = {
   transformerPath: string;
   transformerConfig: JsTransformerConfig;
-}
-
-interface Data {
-  readonly result: TransformResult<void>;
-  readonly sha1: string;
-  readonly transformFileStartLogEntry: LogEntry;
-  readonly transformFileEndLogEntry: LogEntry;
-}
-
-declare const worker: Worker;
-
-export default worker;
+};
+type Data = Readonly<{
+  result: TransformResult;
+  sha1: string;
+  transformFileStartLogEntry: LogEntry;
+  transformFileEndLogEntry: LogEntry;
+}>;
+export declare const transform: (
+  filename: string,
+  transformOptions: JsTransformOptions,
+  projectRoot: string,
+  transformerConfig: TransformerConfig,
+  fileBuffer?: Buffer,
+) => Promise<Data>;
+export declare type transform = typeof transform;
+export type Worker = {readonly transform: typeof transform};

package/src/DeltaBundler/Worker.flow.js.flow

@@ -39,7 +39,7 @@ export type TransformerConfig = {
   ...
 };
 
-type Data = $ReadOnly<{
+type Data = Readonly<{
   result: TransformResult<>,
   sha1: string,
   transformFileStartLogEntry: LogEntry,

package/src/DeltaBundler/WorkerFarm.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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 {TransformResult} from '../DeltaBundler';
+import type {TransformerConfig, TransformOptions, Worker} from './Worker';
+import type {ConfigT} from 'metro-config';
+import type {Readable} from 'stream';
+
+type WorkerInterface = Readonly<
+  Omit<
+    Worker,
+    keyof {
+      end(): void | Promise<void>;
+      getStdout(): Readable;
+      getStderr(): Readable;
+    }
+  > & {
+    end(): void | Promise<void>;
+    getStdout(): Readable;
+    getStderr(): Readable;
+  }
+>;
+type TransformerResult = Readonly<{result: TransformResult; sha1: string}>;
+declare class WorkerFarm {
+  _config: ConfigT;
+  _transformerConfig: TransformerConfig;
+  _worker: WorkerInterface | Worker;
+  constructor(config: ConfigT, transformerConfig: TransformerConfig);
+  kill(): Promise<void>;
+  transform(
+    filename: string,
+    options: TransformOptions,
+    fileBuffer?: Buffer,
+  ): Promise<TransformerResult>;
+  _makeFarm(
+    absoluteWorkerPath: string,
+    exposedMethods: ReadonlyArray<string>,
+    numWorkers: number,
+  ): WorkerInterface;
+  _computeWorkerKey(
+    method: string,
+    filename: string,
+  ): null | undefined | string;
+  _formatGenericError(
+    err: Readonly<{message: string; stack?: string}>,
+    filename: string,
+  ): TransformError;
+  _formatBabelError(
+    err: Readonly<{
+      message: string;
+      stack?: string;
+      type?: string;
+      codeFrame?: unknown;
+      loc: {line?: number; column?: number};
+    }>,
+    filename: string,
+  ): TransformError;
+}
+export default WorkerFarm;
+declare class TransformError extends SyntaxError {
+  type: string;
+  constructor(message: string);
+}

package/src/DeltaBundler/WorkerFarm.js

@@ -95,7 +95,7 @@ class WorkerFarm {
   }
   _formatBabelError(err, filename) {
     const error = new TransformError(
-      `${err.type || "Error"}${err.message.includes(filename) ? "" : " in " + filename}: ${err.message}`,
+      `${err.type ?? "Error"}${err.message.includes(filename) ? "" : " in " + filename}: ${err.message}`,
     );
     return Object.assign(error, {
       stack: err.stack,

package/src/DeltaBundler/WorkerFarm.js.flow

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow
+ * @flow strict-local
  * @format
  * @oncall react_native
  */
@@ -17,14 +17,14 @@ import type {Readable} from 'stream';
 import {Worker as JestWorker} from 'jest-worker';
 import {Logger} from 'metro-core';
 
-type WorkerInterface = {
+type WorkerInterface = Readonly<{
+  ...Worker,
+  end(): void | Promise<void>,
   getStdout(): Readable,
   getStderr(): Readable,
-  end(): void,
-  ...Worker,
-};
+}>;
 
-type TransformerResult = $ReadOnly<{
+type TransformerResult = Readonly<{
   result: TransformResult<>,
   sha1: string,
 }>;
@@ -62,7 +62,7 @@ export default class WorkerFarm {
       this._worker = worker;
     } else {
       // eslint-disable-next-line import/no-commonjs
-      this._worker = (require('./Worker'): Worker);
+      this._worker = require('./Worker') as Worker;
     }
   }
 
@@ -104,16 +104,16 @@ export default class WorkerFarm {
 
   _makeFarm(
     absoluteWorkerPath: string,
-    exposedMethods: $ReadOnlyArray<string>,
+    exposedMethods: ReadonlyArray<string>,
     numWorkers: number,
-  ): any {
+  ): WorkerInterface {
     const env = {
       ...process.env,
       // Force color to print syntax highlighted code frames.
       FORCE_COLOR: 1,
     };
 
-    return new JestWorker(absoluteWorkerPath, {
+    return new JestWorker<Worker>(absoluteWorkerPath, {
       computeWorkerKey: this._config.stickyWorkers
         ? // $FlowFixMe[method-unbinding] added when improving typing for this parameters
           // $FlowFixMe[incompatible-type]
@@ -143,7 +143,10 @@ export default class WorkerFarm {
     return null;
   }
 
-  _formatGenericError(err: any, filename: string): TransformError {
+  _formatGenericError(
+    err: Readonly<{message: string, stack?: string, ...}>,
+    filename: string,
+  ): TransformError {
     const error = new TransformError(`${filename}: ${err.message}`);
 
     // $FlowFixMe[unsafe-object-assign]
@@ -153,9 +156,19 @@ export default class WorkerFarm {
     });
   }
 
-  _formatBabelError(err: any, filename: string): TransformError {
+  _formatBabelError(
+    err: Readonly<{
+      message: string,
+      stack?: string,
+      type?: string,
+      codeFrame?: unknown,
+      loc: {line?: number, column?: number, ...},
+      ...
+    }>,
+    filename: string,
+  ): TransformError {
     const error = new TransformError(
-      `${err.type || 'Error'}${
+      `${err.type ?? 'Error'}${
         err.message.includes(filename) ? '' : ' in ' + filename
       }: ${err.message}`,
     );

package/src/DeltaBundler/buildSubgraph.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 {RequireContext} from '../lib/contextModule';
+import type {
+  ModuleData,
+  ResolvedDependency,
+  ResolveFn,
+  TransformFn,
+} from './types';
+
+type Parameters<T> = Readonly<{
+  resolve: ResolveFn;
+  transform: TransformFn<T>;
+  shouldTraverse: ($$PARAM_0$$: ResolvedDependency) => boolean;
+}>;
+export declare function buildSubgraph<T>(
+  entryPaths: ReadonlySet<string>,
+  resolvedContexts: ReadonlyMap<string, null | undefined | RequireContext>,
+  $$PARAM_2$$: Parameters<T>,
+): Promise<{
+  moduleData: Map<string, ModuleData<T>>;
+  errors: Map<string, Error>;
+}>;

package/src/DeltaBundler/buildSubgraph.js

@@ -24,13 +24,13 @@ function resolveDependencies(parentPath, dependencies, resolve) {
         contextParams,
       );
       const resolvedContext = {
-        from,
-        mode: contextParams.mode,
-        recursive: contextParams.recursive,
         filter: new RegExp(
           contextParams.filter.pattern,
           contextParams.filter.flags,
         ),
+        from,
+        mode: contextParams.mode,
+        recursive: contextParams.recursive,
       };
       resolvedContexts.set(key, resolvedContext);
       maybeResolvedDep = {
@@ -110,7 +110,7 @@ async function buildSubgraph(
     ),
   );
   return {
-    moduleData,
     errors,
+    moduleData,
   };
 }

package/src/DeltaBundler/buildSubgraph.js.flow

@@ -22,7 +22,7 @@ import {deriveAbsolutePathFromContext} from '../lib/contextModule';
 import {isResolvedDependency} from '../lib/isResolvedDependency';
 import path from 'path';
 
-type Parameters<T> = $ReadOnly<{
+type Parameters<T> = Readonly<{
   resolve: ResolveFn,
   transform: TransformFn<T>,
   shouldTraverse: ResolvedDependency => boolean,
@@ -30,7 +30,7 @@ type Parameters<T> = $ReadOnly<{
 
 function resolveDependencies(
   parentPath: string,
-  dependencies: $ReadOnlyArray<TransformResultDependency>,
+  dependencies: ReadonlyArray<TransformResultDependency>,
   resolve: ResolveFn,
 ): {
   dependencies: Map<string, Dependency>,
@@ -52,13 +52,13 @@ function resolveDependencies(
       const absolutePath = deriveAbsolutePathFromContext(from, contextParams);
 
       const resolvedContext: RequireContext = {
-        from,
-        mode: contextParams.mode,
-        recursive: contextParams.recursive,
         filter: new RegExp(
           contextParams.filter.pattern,
           contextParams.filter.flags,
         ),
+        from,
+        mode: contextParams.mode,
+        recursive: contextParams.recursive,
       };
 
       resolvedContexts.set(key, resolvedContext);
@@ -100,8 +100,8 @@ function resolveDependencies(
 }
 
 export async function buildSubgraph<T>(
-  entryPaths: $ReadOnlySet<string>,
-  resolvedContexts: $ReadOnlyMap<string, ?RequireContext>,
+  entryPaths: ReadonlySet<string>,
+  resolvedContexts: ReadonlyMap<string, ?RequireContext>,
   {resolve, transform, shouldTraverse}: Parameters<T>,
 ): Promise<{
   moduleData: Map<string, ModuleData<T>>,
@@ -157,5 +157,5 @@ export async function buildSubgraph<T>(
     ),
   );
 
-  return {moduleData, errors};
+  return {errors, moduleData};
 }

package/src/DeltaBundler/getTransformCacheKey.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 {TransformerConfig} from './Worker';
+
+declare function getTransformCacheKey(opts: {
+  readonly cacheVersion: string;
+  readonly projectRoot: string;
+  readonly transformerConfig: TransformerConfig;
+}): string;
+export default getTransformCacheKey;

package/src/DeltaBundler/mergeDeltas.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 {DeltaBundle} from 'metro-runtime/src/modules/types';
+
+declare function mergeDeltas(
+  delta1: DeltaBundle,
+  delta2: DeltaBundle,
+): DeltaBundle;
+export default mergeDeltas;

package/src/DeltaBundler/types.d.ts

@@ -9,158 +9,155 @@
  */
 
 import type {RequireContext} from '../lib/contextModule';
-import type CountingSet from '../lib/CountingSet';
 import type {RequireContextParams} from '../ModuleGraph/worker/collectDependencies';
+import type {ReadonlySourceLocation} from '../shared/types';
 import type {Graph} from './Graph';
 import type {JsTransformOptions} from 'metro-transform-worker';
 
-export interface MixedOutput {
-  readonly data: {code: string};
-  readonly type: string;
-}
-
-export type AsyncDependencyType = 'async' | 'prefetch' | 'weak';
+import CountingSet from '../lib/CountingSet';
 
-export interface TransformResultDependency {
+export type MixedOutput = {readonly data: unknown; readonly type: string};
+export type AsyncDependencyType = 'async' | 'maybeSync' | 'prefetch' | 'weak';
+export type TransformResultDependency = Readonly<{
   /**
    * The literal name provided to a require or import call. For example 'foo' in
    * case of `require('foo')`.
    */
-  readonly name: string;
-
+  name: string;
   /**
    * Extra data returned by the dependency extractor.
    */
-  readonly data: {
+  data: Readonly<{
     /**
      * A locally unique key for this dependency within the current module.
      */
-    readonly key: string;
-
+    key: string;
     /**
      * If not null, this dependency is due to a dynamic `import()` or `__prefetchImport()` call.
      */
-    readonly asyncType: AsyncDependencyType | null;
-
+    asyncType: AsyncDependencyType | null;
+    /**
+     * True if the dependency is declared with a static "import x from 'y'" or
+     * an import() call.
+     */
+    isESMImport: boolean;
     /**
      * The dependency is enclosed in a try/catch block.
      */
-    readonly isOptional?: boolean;
-
-    readonly locs: ReadonlyArray<{
-      readonly start: {readonly line: number; readonly column: number};
-      readonly end: {readonly line: number; readonly column: number};
-    }>;
-
+    isOptional?: boolean;
+    locs: ReadonlyArray<ReadonlySourceLocation>;
     /** Context for requiring a collection of modules. */
-    readonly contextParams?: RequireContextParams;
-  };
-}
-
-export interface Dependency {
-  readonly absolutePath: string;
-  readonly data: TransformResultDependency;
-  [key: string]: unknown;
-}
-
-export interface Module<T = MixedOutput> {
-  readonly dependencies: Map<string, Dependency>;
-  readonly inverseDependencies: CountingSet<string>;
-  readonly output: ReadonlyArray<T>;
-  readonly path: string;
-  readonly getSource: () => Buffer;
-}
-
+    contextParams?: RequireContextParams;
+  }>;
+}>;
+export type ResolvedDependency = Readonly<{
+  absolutePath: string;
+  data: TransformResultDependency;
+}>;
+export type Dependency =
+  | ResolvedDependency
+  | Readonly<{data: TransformResultDependency}>;
+export type Module<T = MixedOutput> = Readonly<{
+  dependencies: Map<string, Dependency>;
+  inverseDependencies: CountingSet<string>;
+  output: ReadonlyArray<T>;
+  path: string;
+  getSource: () => Buffer;
+  unstable_transformResultKey?: null | undefined | string;
+}>;
+export type ModuleData<T = MixedOutput> = Readonly<{
+  dependencies: ReadonlyMap<string, Dependency>;
+  resolvedContexts: ReadonlyMap<string, RequireContext>;
+  output: ReadonlyArray<T>;
+  getSource: () => Buffer;
+  unstable_transformResultKey?: null | undefined | string;
+}>;
 export type Dependencies<T = MixedOutput> = Map<string, Module<T>>;
 export type ReadOnlyDependencies<T = MixedOutput> = ReadonlyMap<
   string,
   Module<T>
 >;
-
 export type TransformInputOptions = Omit<
   JsTransformOptions,
   'inlinePlatform' | 'inlineRequires'
 >;
-
 export type GraphInputOptions = Readonly<{
   entryPoints: ReadonlySet<string>;
-  // Unused in core but useful for custom serializers / experimentalSerializerHook
   transformOptions: TransformInputOptions;
 }>;
-
 export interface ReadOnlyGraph<T = MixedOutput> {
   readonly entryPoints: ReadonlySet<string>;
-  // Unused in core but useful for custom serializers / experimentalSerializerHook
   readonly transformOptions: Readonly<TransformInputOptions>;
   readonly dependencies: ReadOnlyDependencies<T>;
 }
-
 export type {Graph};
-
-export interface TransformResult<T = MixedOutput> {
+export type TransformResult<T = MixedOutput> = Readonly<{
   dependencies: ReadonlyArray<TransformResultDependency>;
   output: ReadonlyArray<T>;
-}
-
-export interface TransformResultWithSource<T = MixedOutput>
-  extends TransformResult<T> {
-  getSource: () => Buffer;
-}
-
+  unstable_transformResultKey?: null | undefined | string;
+}>;
+export type TransformResultWithSource<T = MixedOutput> = Readonly<
+  Omit<TransformResult<T>, keyof {getSource: () => Buffer}> & {
+    getSource: () => Buffer;
+  }
+>;
 export type TransformFn<T = MixedOutput> = (
-  modulePath: string,
-  requireContext: RequireContext | null,
+  $$PARAM_0$$: string,
+  $$PARAM_1$$: null | undefined | RequireContext,
 ) => Promise<TransformResultWithSource<T>>;
-
-export interface AllowOptionalDependenciesWithOptions {
-  readonly exclude: string[];
-}
-
+export type ResolveFn = (
+  from: string,
+  dependency: TransformResultDependency,
+) => BundlerResolution;
+export type AllowOptionalDependenciesWithOptions = {
+  readonly exclude: Array<string>;
+};
 export type AllowOptionalDependencies =
   | boolean
   | AllowOptionalDependenciesWithOptions;
-
-export interface BundlerResolution {
-  readonly type: 'sourceFile';
-  readonly filePath: string;
-}
-
-export interface Options<T = MixedOutput> {
-  readonly resolve: (from: string, to: TransformResultDependency) => string;
-  readonly transform: TransformFn<T>;
-  readonly transformOptions: TransformInputOptions;
-  readonly onProgress:
-    | ((numProcessed: number, total: number) => unknown)
-    | null;
-  readonly lazy: boolean;
-  readonly unstable_allowRequireContext: boolean;
-  readonly shallow: boolean;
-}
-
-export interface DeltaResult<T = MixedOutput> {
+export type BundlerResolution = Readonly<{
+  type: 'sourceFile';
+  filePath: string;
+}>;
+export type Options<T = MixedOutput> = Readonly<{
+  resolve: ResolveFn;
+  transform: TransformFn<T>;
+  transformOptions: TransformInputOptions;
+  onProgress:
+    | null
+    | undefined
+    | ((numProcessed: number, total: number) => unknown);
+  lazy: boolean;
+  unstable_allowRequireContext: boolean;
+  unstable_enablePackageExports: boolean;
+  unstable_incrementalResolution: boolean;
+  shallow: boolean;
+}>;
+export type DeltaResult<T = MixedOutput> = {
   readonly added: Map<string, Module<T>>;
   readonly modified: Map<string, Module<T>>;
   readonly deleted: Set<string>;
   readonly reset: boolean;
-}
-
-export interface SerializerOptions<T = MixedOutput> {
-  readonly asyncRequireModulePath: string;
-  readonly createModuleId: (filePath: string) => number;
-  readonly dev: boolean;
-  readonly getRunModuleStatement: (
+};
+export type SerializerOptions = Readonly<{
+  asyncRequireModulePath: string;
+  createModuleId: ($$PARAM_0$$: string) => number;
+  dev: boolean;
+  getRunModuleStatement: (
     moduleId: number | string,
     globalPrefix: string,
   ) => string;
-  readonly includeAsyncPaths: boolean;
-  readonly inlineSourceMap?: boolean;
-  readonly modulesOnly: boolean;
-  readonly processModuleFilter: (module: Module<T>) => boolean;
-  readonly projectRoot: string;
-  readonly runBeforeMainModule: ReadonlyArray<string>;
-  readonly runModule: boolean;
-  readonly serverRoot: string;
-  readonly shouldAddToIgnoreList: (module: Module<T>) => boolean;
-  readonly sourceMapUrl?: string;
-  readonly sourceUrl?: string;
-}
+  globalPrefix: string;
+  includeAsyncPaths: boolean;
+  inlineSourceMap: null | undefined | boolean;
+  modulesOnly: boolean;
+  processModuleFilter: (module: Module) => boolean;
+  projectRoot: string;
+  runBeforeMainModule: ReadonlyArray<string>;
+  runModule: boolean;
+  serverRoot: string;
+  shouldAddToIgnoreList: ($$PARAM_0$$: Module) => boolean;
+  sourceMapUrl: null | undefined | string;
+  sourceUrl: null | undefined | string;
+  getSourceUrl: null | undefined | (($$PARAM_0$$: Module) => string);
+}>;