metro 0.76.0 → 0.76.1

package/types/Bundler.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 DependencyGraph from './node-haste/DependencyGraph';
+import type {ConfigT} from 'metro-config';
+import type {EventEmitter} from 'events';
+
+export interface BundlerOptions {
+  readonly hasReducedPerformance?: boolean;
+  readonly watch?: boolean;
+}
+
+export default class Bundler {
+  constructor(config: ConfigT, options?: BundlerOptions);
+
+  getWatcher(): EventEmitter;
+
+  end(): Promise<void>;
+
+  getDependencyGraph(): Promise<DependencyGraph>;
+
+  transformFile(
+    filePath: string,
+    transformOptions: TransformOptions,
+    /** Optionally provide the file contents, this can be used to provide virtual contents for a file. */
+    fileBuffer?: Buffer,
+  ): Promise<TransformResultWithSource<void>>;
+
+  ready(): Promise<void>;
+}

package/types/DeltaBundler/Graph.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 {
+  Dependencies,
+  GraphInputOptions,
+  MixedOutput,
+  Module,
+  Options,
+  TransformInputOptions,
+} from './types';
+
+export interface 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>;
+  constructor(options: GraphInputOptions);
+  traverseDependencies(
+    paths: ReadonlyArray<string>,
+    options: Options<T>,
+  ): Promise<Result<T>>;
+  initialTraverseDependencies(options: Options<T>): Promise<Result<T>>;
+  markModifiedContextModules(
+    filePath: string,
+    modifiedPaths: Set<string>,
+  ): void;
+}

package/types/DeltaBundler/Serializers/getRamBundleInfo.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 {ModuleTransportLike} from '../../shared/types';
+
+export interface RamBundleInfo {
+  getDependencies: (filePath: string) => Set<string>;
+  startupModules: Readonly<ModuleTransportLike>;
+  lazyModules: Readonly<ModuleTransportLike>;
+  groups: Map<number, Set<number>>;
+}

package/types/DeltaBundler/Worker.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 {
+  JsTransformerConfig,
+  JsTransformOptions,
+} from 'metro-transform-worker';
+import type {TransformResult} from './types';
+
+type LogEntry = unknown;
+
+export type TransformOptions = JsTransformOptions;
+
+declare function transform(
+  filename: string,
+  transformOptions: JsTransformOptions,
+  projectRoot: string,
+  transformerConfig: TransformerConfig,
+  fileBuffer?: Buffer,
+): Promise<Data>;
+
+export interface Worker {
+  readonly transform: typeof transform;
+}
+
+export interface 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;

package/types/DeltaBundler/types.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
+ */
+
+import type {SourceLocation} from '@babel/code-frame';
+import type {JsTransformOptions} from 'metro-transform-worker';
+import type {RequireContextParams} from '../ModuleGraph/worker/collectDependencies';
+import type {RequireContext} from '../lib/contextModule';
+import type CountingSet from '../lib/CountingSet';
+import type {Graph} from './Graph';
+
+export interface MixedOutput {
+  readonly data: {code: string};
+  readonly type: string;
+}
+
+export type AsyncDependencyType = 'async' | 'prefetch';
+
+export interface TransformResultDependency {
+  /**
+   * The literal name provided to a require or import call. For example 'foo' in
+   * case of `require('foo')`.
+   */
+  readonly name: string;
+
+  /**
+   * Extra data returned by the dependency extractor.
+   */
+  readonly data: {
+    /**
+     * A locally unique key for this dependency within the current module.
+     */
+    readonly key: string;
+
+    /**
+     * If not null, this dependency is due to a dynamic `import()` or `__prefetchImport()` call.
+     */
+    readonly asyncType: AsyncDependencyType | null;
+
+    /**
+     * The condition for splitting on this dependency edge.
+     */
+    readonly splitCondition?: {
+      readonly mobileConfigName: string;
+    };
+
+    /**
+     * The dependency is enclosed in a try/catch block.
+     */
+    readonly isOptional?: boolean;
+
+    readonly locs: ReadonlyArray<SourceLocation>;
+
+    /** 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;
+}
+
+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> {
+  dependencies: ReadonlyArray<TransformResultDependency>;
+  output: ReadonlyArray<T>;
+}
+
+export interface TransformResultWithSource<T = MixedOutput>
+  extends TransformResult<T> {
+  getSource: () => Buffer;
+}
+
+export type TransformFn<T = MixedOutput> = (
+  modulePath: string,
+  requireContext: RequireContext | null,
+) => Promise<TransformResultWithSource<T>>;
+
+export interface AllowOptionalDependenciesWithOptions {
+  readonly exclude: 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: string) => string;
+  readonly transform: TransformFn<T>;
+  readonly transformOptions: TransformInputOptions;
+  readonly onProgress:
+    | ((numProcessed: number, total: number) => unknown)
+    | null;
+  readonly experimentalImportBundleSupport: boolean;
+  readonly unstable_allowRequireContext: boolean;
+  readonly shallow: boolean;
+}
+
+export interface 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: (moduleId: string | number) => 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 sourceMapUrl?: string;
+  readonly sourceUrl?: string;
+}

package/types/DeltaBundler.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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,
+  Graph,
+  MixedOutput,
+  Options,
+  ReadOnlyGraph,
+} from './DeltaBundler/types';
+import type {EventEmitter} from 'events';
+
+export type {
+  DeltaResult,
+  Graph,
+  Dependencies,
+  MixedOutput,
+  Module,
+  ReadOnlyGraph,
+  TransformFn,
+  TransformResult,
+  TransformResultDependency,
+  TransformResultWithSource,
+} from './DeltaBundler/types';
+
+export default class DeltaBundler<T = MixedOutput> {
+  constructor(changeEventSource: EventEmitter);
+  end(): void;
+  getDependencies(
+    entryPoints: ReadonlyArray<string>,
+    options: Options<T>,
+  ): Promise<ReadOnlyGraph<T>['dependencies']>;
+  buildGraph(
+    entryPoints: ReadonlyArray<string>,
+    options: Options<T>,
+  ): Promise<Graph<T>>;
+
+  getDelta(
+    graph: Graph<T>,
+    {
+      reset,
+      shallow,
+    }: {
+      reset: boolean;
+      shallow: boolean;
+    },
+  ): Promise<DeltaResult<T>>;
+
+  listen(graph: Graph<T>, callback: () => Promise<void>): () => void;
+  endGraph(graph: Graph<T>): void;
+}

package/types/IncrementalBundler.d.ts

@@ -0,0 +1,97 @@
+/**
+ * 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 {
+  Options as DeltaBundlerOptions,
+  ReadOnlyDependencies,
+  TransformInputOptions,
+} from './DeltaBundler/types';
+import {ResolverInputOptions} from './shared/types';
+import type {ConfigT} from 'metro-config';
+import type {GraphId} from './lib/getGraphId';
+import DeltaBundler, {DeltaResult, Graph, Module} from './DeltaBundler';
+import type Bundler from './Bundler';
+
+export type RevisionId = string;
+
+export type OutputGraph = Graph<void>;
+
+export interface OtherOptions {
+  readonly onProgress: DeltaBundlerOptions<void>['onProgress'];
+  readonly shallow: boolean;
+}
+
+export interface 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 {
+  static revisionIdFromString: (str: string) => RevisionId;
+  constructor(config: ConfigT, options?: IncrementalBundlerOptions);
+
+  end(): void;
+  getBundler(): Bundler;
+  getDeltaBundler(): DeltaBundler<void>;
+  getRevision(revisionId: RevisionId): Promise<GraphRevision> | null;
+  getRevisionByGraphId(graphId: GraphId): Promise<GraphRevision> | null;
+
+  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>>;
+
+  buildGraph(
+    entryFile: string,
+    transformOptions: TransformInputOptions,
+    resolverOptions: ResolverInputOptions,
+    otherOptions?: OtherOptions,
+  ): Promise<
+    Readonly<{graph: OutputGraph; prepend: ReadonlyArray<Module<void>>}>
+  >;
+
+  initializeGraph(
+    entryFile: string,
+    transformOptions: TransformInputOptions,
+    resolverOptions: ResolverInputOptions,
+    otherOptions?: OtherOptions,
+  ): Promise<{
+    delta: DeltaResult<void>;
+    revision: GraphRevision;
+  }>;
+
+  updateGraph(
+    revision: GraphRevision,
+    reset: boolean,
+  ): Promise<{
+    delta: DeltaResult<void>;
+    revision: GraphRevision;
+  }>;
+
+  endGraph(graphId: GraphId): Promise<void>;
+  ready(): Promise<void>;
+}

package/types/ModuleGraph/worker/collectDependencies.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
+ */
+
+export type ContextMode = 'sync' | 'eager' | 'lazy' | 'lazy-once';
+
+export interface ContextFilter {
+  pattern: string;
+  flags: string;
+}
+
+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>;
+  /** Mode for resolving dynamic dependencies. Defaults to `sync` */
+  readonly mode: ContextMode;
+}
+
+export type DynamicRequiresBehavior = 'throwAtRuntime' | 'reject';

package/types/Server/MultipartResponse.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 {IncomingMessage, ServerResponse} from 'http';
+
+export type Data = string | Buffer | Uint8Array;
+export interface Headers {
+  [name: string]: string | number;
+}
+
+export default class MultipartResponse {
+  static wrapIfSupported(
+    req: IncomingMessage,
+    res: ServerResponse,
+  ): MultipartResponse | ServerResponse;
+  static serializeHeaders(headers: Headers): string;
+  res: ServerResponse;
+  headers: Headers;
+  constructor(res: ServerResponse);
+  writeChunk(headers: Headers | null, data?: Data, isLast?: boolean): void;
+  writeHead(status: number, headers?: Headers): void;
+  setHeader(name: string, value: string | number): void;
+  end(data?: Data): void;
+}

package/types/Server.d.ts

@@ -0,0 +1,113 @@
+/**
+ * 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 './Asset';
+import type {RamBundleInfo} from './DeltaBundler/Serializers/getRamBundleInfo';
+import IncrementalBundler, {RevisionId} from './IncrementalBundler';
+import type {GraphId} from './lib/getGraphId';
+import type MultipartResponse from './Server/MultipartResponse';
+import type {
+  BundleOptions,
+  GraphOptions,
+  SplitBundleOptions,
+} from './shared/types';
+import type {IncomingMessage, ServerResponse} from 'http';
+import type {
+  CustomTransformOptions,
+  TransformProfile,
+} from 'metro-babel-transformer';
+import type {ConfigT, RootPerfLogger} from 'metro-config';
+import type {CustomResolverOptions} from 'metro-resolver';
+
+export interface SegmentLoadData {
+  [index: number]: [number[], number | null];
+}
+
+export interface BundleMetadata {
+  hash: string;
+  otaBuildNumber: string | null;
+  mobileConfigs: string[];
+  segmentHashes: string[];
+  segmentLoadData: SegmentLoadData;
+}
+
+export interface ProcessStartContext extends SplitBundleOptions {
+  readonly buildNumber: number;
+  readonly bundleOptions: BundleOptions;
+  readonly graphId: GraphId;
+  readonly graphOptions: GraphOptions;
+  readonly mres: MultipartResponse | ServerResponse;
+  readonly req: IncomingMessage;
+  readonly revisionId?: RevisionId | null;
+  readonly bundlePerfLogger: RootPerfLogger;
+}
+
+export interface ProcessDeleteContext {
+  readonly graphId: GraphId;
+  readonly req: IncomingMessage;
+  readonly res: ServerResponse;
+}
+
+export interface ProcessEndContext<T> extends ProcessStartContext {
+  readonly result: T;
+}
+
+export type ServerOptions = Readonly<{
+  hasReducedPerformance?: boolean;
+  onBundleBuilt?: (bundlePath: string) => void;
+  watch?: boolean;
+}>;
+
+export interface DefaultGraphOptions {
+  customResolverOptions: CustomResolverOptions;
+  customTransformOptions: CustomTransformOptions;
+  dev: boolean;
+  hot: boolean;
+  minify: boolean;
+  runtimeBytecodeVersion?: number;
+  unstable_transformProfile: TransformProfile;
+}
+
+export interface DefaultBundleOptions extends DefaultGraphOptions {
+  excludeSource: false;
+  inlineSourceMap: false;
+  modulesOnly: false;
+  onProgress: null;
+  runModule: true;
+  shallow: false;
+  sourceMapUrl: null;
+  sourceUrl: null;
+}
+
+export default class Server {
+  static DEFAULT_GRAPH_OPTIONS: DefaultGraphOptions;
+  static DEFAULT_BUNDLE_OPTIONS: BundleOptions;
+  constructor(config: ConfigT, options?: ServerOptions);
+  end(): void;
+  getBundler(): IncrementalBundler;
+  getCreateModuleId(): (path: string) => number;
+  build(options: BundleOptions): Promise<{
+    code: string;
+    map: string;
+  }>;
+  getRamBundleInfo(options: BundleOptions): Promise<RamBundleInfo>;
+  getAssets(options: BundleOptions): Promise<ReadonlyArray<AssetData>>;
+  getOrderedDependencyPaths(options: {
+    readonly dev: boolean;
+    readonly entryFile: string;
+    readonly minify: boolean;
+    readonly platform: string;
+  }): Promise<string[]>;
+  processRequest(
+    IncomingMessage: IncomingMessage,
+    ServerResponse: ServerResponse,
+    next: (e: Error | null) => unknown,
+  ): void;
+}