metro-file-map 0.84.0 → 0.84.2

package/src/index.d.ts

@@ -0,0 +1,182 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<33bbe77b6d139e247ee97f706bbe485d>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/index.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {
+  BuildParameters,
+  BuildResult,
+  CacheData,
+  CacheManagerFactory,
+  ChangeEventMetadata,
+  Console,
+  FileData,
+  FileMapPlugin,
+  FileSystem,
+  HasteMapData,
+  HasteMapItem,
+  HType,
+  PerfLoggerFactory,
+} from './flow-types';
+
+import EventEmitter from 'events';
+
+export type {
+  BuildParameters,
+  BuildResult,
+  CacheData,
+  ChangeEventMetadata,
+  FileData,
+  FileMap,
+  FileSystem,
+  HasteMapData,
+  HasteMapItem,
+};
+export type InputOptions = Readonly<{
+  computeSha1?: null | undefined | boolean;
+  enableSymlinks?: null | undefined | boolean;
+  extensions: ReadonlyArray<string>;
+  forceNodeFilesystemAPI?: null | undefined | boolean;
+  ignorePattern?: null | undefined | RegExp;
+  plugins?: ReadonlyArray<AnyFileMapPlugin>;
+  retainAllFiles: boolean;
+  rootDir: string;
+  roots: ReadonlyArray<string>;
+  cacheManagerFactory?: null | undefined | CacheManagerFactory;
+  console?: Console;
+  healthCheck: HealthCheckOptions;
+  maxFilesPerWorker?: null | undefined | number;
+  maxWorkers: number;
+  perfLoggerFactory?: null | undefined | PerfLoggerFactory;
+  resetCache?: null | undefined | boolean;
+  useWatchman?: null | undefined | boolean;
+  watch?: null | undefined | boolean;
+  watchmanDeferStates?: ReadonlyArray<string>;
+}>;
+type HealthCheckOptions = Readonly<{
+  enabled: boolean;
+  interval: number;
+  timeout: number;
+  filePrefix: string;
+}>;
+type AnyFileMapPlugin = FileMapPlugin<any, any>;
+export {DiskCacheManager} from './cache/DiskCacheManager';
+export {default as DependencyPlugin} from './plugins/DependencyPlugin';
+export type {DependencyPluginOptions} from './plugins/DependencyPlugin';
+export {DuplicateHasteCandidatesError} from './plugins/haste/DuplicateHasteCandidatesError';
+export {HasteConflictsError} from './plugins/haste/HasteConflictsError';
+export {default as HastePlugin} from './plugins/HastePlugin';
+export type {HasteMap} from './flow-types';
+export type {HealthCheckResult} from './Watcher';
+export type {
+  CacheManager,
+  CacheManagerFactory,
+  CacheManagerFactoryOptions,
+  CacheManagerWriteOptions,
+  ChangeEvent,
+  DependencyExtractor,
+  WatcherStatus,
+} from './flow-types';
+/**
+ * FileMap includes a JavaScript implementation of Facebook's haste module system.
+ *
+ * This implementation is inspired by https://github.com/facebook/node-haste
+ * and was built with for high-performance in large code repositories with
+ * hundreds of thousands of files. This implementation is scalable and provides
+ * predictable performance.
+ *
+ * Because the file map creation and synchronization is critical to startup
+ * performance and most tasks are blocked by I/O this class makes heavy use of
+ * synchronous operations. It uses worker processes for parallelizing file
+ * access and metadata extraction.
+ *
+ * The data structures created by `metro-file-map` can be used directly from the
+ * cache without further processing. The metadata objects in the `files` and
+ * `map` objects contain cross-references: a metadata object from one can look
+ * up the corresponding metadata object in the other map. Note that in most
+ * projects, the number of files will be greater than the number of haste
+ * modules one module can refer to many files based on platform extensions.
+ *
+ * type CacheData = {
+ *   clocks: WatchmanClocks,
+ *   files: {[filepath: string]: FileMetadata},
+ *   map: {[id: string]: HasteMapItem},
+ *   mocks: {[id: string]: string},
+ * }
+ *
+ * // Watchman clocks are used for query synchronization and file system deltas.
+ * type WatchmanClocks = {[filepath: string]: string};
+ *
+ * type FileMetadata = {
+ *   id: ?string, // used to look up module metadata objects in `map`.
+ *   mtime: number, // check for outdated files.
+ *   size: number, // size of the file in bytes.
+ *   visited: boolean, // whether the file has been parsed or not.
+ *   dependencies: Array<string>, // all relative dependencies of this file.
+ *   sha1: ?string, // SHA-1 of the file, if requested via options.
+ *   symlink: ?(1 | 0 | string), // Truthy if symlink, string is target
+ * };
+ *
+ * // Modules can be targeted to a specific platform based on the file name.
+ * // Example: platform.ios.js and Platform.android.js will both map to the same
+ * // `Platform` module. The platform should be specified during resolution.
+ * type HasteMapItem = {[platform: string]: ModuleMetadata};
+ *
+ * //
+ * type ModuleMetadata = {
+ *   path: string, // the path to look up the file object in `files`.
+ *   type: string, // the module type (either `package` or `module`).
+ * };
+ *
+ * Note that the data structures described above are conceptual only. The actual
+ * implementation uses arrays and constant keys for metadata storage. Instead of
+ * `{id: 'flatMap', mtime: 3421, size: 42, visited: true, dependencies: []}` the real
+ * representation is similar to `['flatMap', 3421, 42, 1, []]` to save storage space
+ * and reduce parse and write time of a big JSON blob.
+ *
+ * The FileMap is created as follows:
+ *  1. read data from the cache or create an empty structure.
+ *
+ *  2. crawl the file system.
+ *     * empty cache: crawl the entire file system.
+ *     * cache available:
+ *       * if watchman is available: get file system delta changes.
+ *       * if watchman is unavailable: crawl the entire file system.
+ *     * build metadata objects for every file. This builds the `files` part of
+ *       the `FileMap`.
+ *
+ *  3. visit and extract metadata from changed files, including sha1,
+ *     depedendencies, and any plugins.
+ *     * this is done in parallel over worker processes to improve performance.
+ *     * the worst case is to visit all files.
+ *     * the best case is no file system access and retrieving all data from
+ *       the cache.
+ *     * the average case is a small number of changed files.
+ *
+ *  4. serialize the new `FileMap` in a cache file.
+ *
+ */
+declare class FileMap extends EventEmitter {
+  static create(options: InputOptions): FileMap;
+  constructor(options: InputOptions);
+  build(): Promise<BuildResult>;
+  /**
+   * 1. read data from the cache or create an empty structure.
+   */
+  read(): Promise<null | undefined | CacheData>;
+  end(): Promise<void>;
+  static H: HType;
+}
+export default FileMap;

package/src/index.js

@@ -458,18 +458,16 @@ class FileMap extends _events.default {
     fileSystem.bulkAddOrModify(changedFiles);
     this.#startupPerfLogger?.point("applyFileDelta_add_end");
     this.#startupPerfLogger?.point("applyFileDelta_updatePlugins_start");
-    await Promise.all([
-      plugins.map(({ plugin, dataIdx }) => {
-        const mapFn =
-          dataIdx != null
-            ? ([relativePath, fileData]) => [relativePath, fileData[dataIdx]]
-            : ([relativePath, fileData]) => [relativePath, null];
-        return plugin.bulkUpdate({
-          addedOrModified: mapIterator(changedFiles.entries(), mapFn),
-          removed: mapIterator(removed.values(), mapFn),
-        });
-      }),
-    ]);
+    plugins.forEach(({ plugin, dataIdx }) => {
+      const mapFn =
+        dataIdx != null
+          ? ([relativePath, fileData]) => [relativePath, fileData[dataIdx]]
+          : ([relativePath, fileData]) => [relativePath, null];
+      plugin.bulkUpdate({
+        addedOrModified: mapIterator(changedFiles.entries(), mapFn),
+        removed: mapIterator(removed.values(), mapFn),
+      });
+    });
     this.#startupPerfLogger?.point("applyFileDelta_updatePlugins_end");
     this.#startupPerfLogger?.point("applyFileDelta_end");
   }

package/src/index.js.flow

@@ -667,21 +667,16 @@ export default class FileMap extends EventEmitter {
     this.#startupPerfLogger?.point('applyFileDelta_add_end');
 
     this.#startupPerfLogger?.point('applyFileDelta_updatePlugins_start');
-
-    await Promise.all([
-      plugins.map(({plugin, dataIdx}) => {
-        const mapFn: (
-          [CanonicalPath, FileMetadata],
-        ) => [CanonicalPath, unknown] =
-          dataIdx != null
-            ? ([relativePath, fileData]) => [relativePath, fileData[dataIdx]]
-            : ([relativePath, fileData]) => [relativePath, null];
-        return plugin.bulkUpdate({
-          addedOrModified: mapIterator(changedFiles.entries(), mapFn),
-          removed: mapIterator(removed.values(), mapFn),
-        });
-      }),
-    ]);
+    plugins.forEach(({plugin, dataIdx}) => {
+      const mapFn: ([CanonicalPath, FileMetadata]) => [CanonicalPath, unknown] =
+        dataIdx != null
+          ? ([relativePath, fileData]) => [relativePath, fileData[dataIdx]]
+          : ([relativePath, fileData]) => [relativePath, null];
+      plugin.bulkUpdate({
+        addedOrModified: mapIterator(changedFiles.entries(), mapFn),
+        removed: mapIterator(removed.values(), mapFn),
+      });
+    });
     this.#startupPerfLogger?.point('applyFileDelta_updatePlugins_end');
     this.#startupPerfLogger?.point('applyFileDelta_end');
   }

package/src/lib/FileProcessor.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<2ea213f753eef5de14cb8a27f68b9fa2>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/FileProcessor.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {
+  FileMapPluginWorker,
+  FileMetadata,
+  PerfLogger,
+} from '../flow-types';
+
+type ProcessFileRequest = Readonly<{
+  /**
+   * Populate metadata[H.SHA1] with the SHA1 of the file's contents.
+   */
+  computeSha1: boolean;
+  /**
+   * Only if processing has already required reading the file's contents, return
+   * the contents as a Buffer - null otherwise. Not supported for batches.
+   */
+  maybeReturnContent: boolean;
+}>;
+interface MaybeCodedError extends Error {
+  code?: string;
+}
+export declare class FileProcessor {
+  constructor(
+    opts: Readonly<{
+      maxFilesPerWorker?: null | undefined | number;
+      maxWorkers: number;
+      pluginWorkers: null | undefined | ReadonlyArray<FileMapPluginWorker>;
+      perfLogger: null | undefined | PerfLogger;
+      rootDir: string;
+    }>,
+  );
+  processBatch(
+    files: ReadonlyArray<[string, FileMetadata]>,
+    req: ProcessFileRequest,
+  ): Promise<{
+    errors: Array<{normalFilePath: string; error: MaybeCodedError}>;
+  }>;
+  processRegularFile(
+    normalPath: string,
+    fileMetadata: FileMetadata,
+    req: ProcessFileRequest,
+  ): null | undefined | {content: null | undefined | Buffer};
+  end(): Promise<void>;
+}

package/src/lib/RootPathUtils.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.
+ *
+ * @noformat
+ * @generated SignedSource<<5ecdb559fce5f5c6ed50df6e4eaebf20>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/RootPathUtils.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+export declare class RootPathUtils {
+  constructor(rootDir: string);
+  getBasenameOfNthAncestor(n: number): string;
+  getParts(): ReadonlyArray<string>;
+  absoluteToNormal(absolutePath: string): string;
+  normalToAbsolute(normalPath: string): string;
+  relativeToNormal(relativePath: string): string;
+  getAncestorOfRootIdx(normalPath: string): null | undefined | number;
+  joinNormalToRelative(
+    normalPath: string,
+    relativePath: string,
+  ): {normalPath: string; collapsedSegments: number};
+  relative(from: string, to: string): string;
+}

package/src/lib/TreeFS.d.ts

@@ -0,0 +1,166 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @generated SignedSource<<1f36861cea798d8cc2a5dc61293ecb1b>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/TreeFS.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {
+  CacheData,
+  FileData,
+  FileMetadata,
+  FileStats,
+  LookupResult,
+  MutableFileSystem,
+  Path,
+  ProcessFileFunction,
+} from '../flow-types';
+
+type DirectoryNode = Map<string, MixedNode>;
+type FileNode = FileMetadata;
+type MixedNode = FileNode | DirectoryNode;
+type DeserializedSnapshotInput = {
+  rootDir: string;
+  fileSystemData: DirectoryNode;
+  processFile: ProcessFileFunction;
+};
+type TreeFSOptions = {
+  rootDir: Path;
+  files?: FileData;
+  processFile: ProcessFileFunction;
+};
+type MatchFilesOptions = Readonly<{
+  filter?: null | undefined | RegExp;
+  filterCompareAbsolute?: boolean;
+  filterComparePosix?: boolean;
+  follow?: boolean;
+  recursive?: boolean;
+  rootDir?: null | undefined | Path;
+}>;
+type MetadataIteratorOptions = Readonly<{
+  includeSymlinks: boolean;
+  includeNodeModules: boolean;
+}>;
+/**
+ * OVERVIEW:
+ *
+ * TreeFS is Metro's in-memory representation of the file system. It is
+ * structured as a tree of non-empty maps and leaves (tuples), with the root
+ * node representing the given `rootDir`, typically Metro's _project root_
+ * (not a filesystem root). Map keys are path segments, and branches outside
+ * the project root are accessed via `'..'`.
+ *
+ * EXAMPLE:
+ *
+ * For a root dir '/data/project', the file '/data/other/app/index.js' would
+ * have metadata at #rootNode.get('..').get('other').get('app').get('index.js')
+ *
+ * SERIALISATION:
+ *
+ * #rootNode is designed to be directly serialisable and directly portable (for
+ * a given project) between different root directories and operating systems.
+ *
+ * SYMLINKS:
+ *
+ * Symlinks are represented as nodes whose metadata contains their literal
+ * target. Literal targets are resolved to normal paths at runtime, and cached.
+ * If a symlink is encountered during traversal, we restart traversal at the
+ * root node targeting join(normal symlink target, remaining path suffix).
+ *
+ * NODE TYPES:
+ *
+ * - A directory (including a parent directory at '..') is represented by a
+ *   `Map` of basenames to any other node type.
+ * - A file is represented by an `Array`  (tuple) of metadata, of which:
+ *   - A regular file has node[H.SYMLINK] === 0
+ *   - A symlink has node[H.SYMLINK] === 1 or
+ *     typeof node[H.SYMLINK] === 'string', where a string is the literal
+ *     content of the symlink (i.e. from readlink), if known.
+ *
+ * TERMINOLOGY:
+ *
+ * - mixedPath
+ *   A root-relative or absolute path
+ * - relativePath
+ *   A root-relative path
+ * - normalPath
+ *   A root-relative, normalised path (no extraneous '.' or '..'), may have a
+ *   single trailing slash
+ * - canonicalPath
+ *   A root-relative, normalised, real path (no symlinks in dirname), never has
+ *   a trailing slash
+ */
+declare class TreeFS implements MutableFileSystem {
+  constructor(opts: TreeFSOptions);
+  getSerializableSnapshot(): CacheData['fileSystemData'];
+  static fromDeserializedSnapshot(args: DeserializedSnapshotInput): TreeFS;
+  getSize(mixedPath: Path): null | undefined | number;
+  getDifference(files: FileData): {
+    changedFiles: FileData;
+    removedFiles: Set<string>;
+  };
+  getSha1(mixedPath: Path): null | undefined | string;
+  getOrComputeSha1(
+    mixedPath: Path,
+  ): Promise<null | undefined | {sha1: string; content?: Buffer}>;
+  exists(mixedPath: Path): boolean;
+  lookup(mixedPath: Path): LookupResult;
+  getAllFiles(): Array<Path>;
+  linkStats(mixedPath: Path): null | undefined | FileStats;
+  /**
+   * Given a search context, return a list of file paths matching the query.
+   * The query matches against normalized paths which start with `./`,
+   * for example: `a/b.js` -> `./a/b.js`
+   */
+  matchFiles(opts: MatchFilesOptions): Iterable<Path>;
+  addOrModify(mixedPath: Path, metadata: FileMetadata): void;
+  bulkAddOrModify(addedOrModifiedFiles: FileData): void;
+  remove(mixedPath: Path): null | undefined | FileMetadata;
+  /**
+   * Given a start path (which need not exist), a subpath and type, and
+   * optionally a 'breakOnSegment', performs the following:
+   *
+   * X = mixedStartPath
+   * do
+   *   if basename(X) === opts.breakOnSegment
+   *     return null
+   *   if X + subpath exists and has type opts.subpathType
+   *     return {
+   *       absolutePath: realpath(X + subpath)
+   *       containerRelativePath: relative(mixedStartPath, X)
+   *     }
+   *   X = dirname(X)
+   * while X !== dirname(X)
+   *
+   * If opts.invalidatedBy is given, collects all absolute, real paths that if
+   * added or removed may invalidate this result.
+   *
+   * Useful for finding the closest package scope (subpath: package.json,
+   * type f, breakOnSegment: node_modules) or closest potential package root
+   * (subpath: node_modules/pkg, type: d) in Node.js resolution.
+   */
+  hierarchicalLookup(
+    mixedStartPath: string,
+    subpath: string,
+    opts: {
+      breakOnSegment: null | undefined | string;
+      invalidatedBy: null | undefined | Set<string>;
+      subpathType: 'f' | 'd';
+    },
+  ): null | undefined | {absolutePath: string; containerRelativePath: string};
+  metadataIterator(opts: MetadataIteratorOptions): Iterator<{
+    baseName: string;
+    canonicalPath: string;
+    metadata: FileMetadata;
+  }>;
+}
+export default TreeFS;

package/src/lib/checkWatchmanCapabilities.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.
+ *
+ * @noformat
+ * @generated SignedSource<<f72d8f0c4d8f513383584a02f36795ef>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/checkWatchmanCapabilities.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+declare function checkWatchmanCapabilities(
+  requiredCapabilities: ReadonlyArray<string>,
+): Promise<{version: string}>;
+export default checkWatchmanCapabilities;

package/src/lib/normalizePathSeparatorsToPosix.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.
+ *
+ * @noformat
+ * @generated SignedSource<<30b5e6d2308dde108c136f95a59e3740>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/normalizePathSeparatorsToPosix.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+declare const $$EXPORT_DEFAULT_DECLARATION$$: (filePath: string) => string;
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
+export default $$EXPORT_DEFAULT_DECLARATION$$;

package/src/lib/normalizePathSeparatorsToSystem.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.
+ *
+ * @noformat
+ * @generated SignedSource<<719a82b7670f09ecb97e007293fddfc6>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/normalizePathSeparatorsToSystem.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+declare const $$EXPORT_DEFAULT_DECLARATION$$: (filePath: string) => string;
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
+export default $$EXPORT_DEFAULT_DECLARATION$$;

package/src/lib/rootRelativeCacheKeys.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<f82cf1eeac38c409c5bf891686c2e828>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/rootRelativeCacheKeys.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {BuildParameters} from '../flow-types';
+
+declare function rootRelativeCacheKeys(buildParameters: BuildParameters): {
+  rootDirHash: string;
+  relativeConfigHash: string;
+};
+export default rootRelativeCacheKeys;

package/src/lib/sorting.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @generated SignedSource<<8805bc71542c6b43e940f8c5761ff187>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/sorting.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+export declare function compareStrings(
+  a: null | string,
+  b: null | string,
+): number;
+export declare function chainComparators<T>(
+  ...comparators: Array<(a: T, b: T) => number>
+): (a: T, b: T) => number;

package/src/plugins/DependencyPlugin.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<71361b3fd04f54f55665031c66465dd7>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/plugins/DependencyPlugin.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {
+  FileMapDelta,
+  FileMapPlugin,
+  FileMapPluginInitOptions,
+  FileMapPluginWorker,
+  Path,
+} from '../flow-types';
+
+export type DependencyPluginOptions = Readonly<{
+  /** Path to custom dependency extractor module */
+  dependencyExtractor: null | undefined | string;
+  /** Whether to compute dependencies (performance optimization) */
+  computeDependencies: boolean;
+  rootDir: Path;
+}>;
+declare class DependencyPlugin
+  implements FileMapPlugin<null, ReadonlyArray<string> | null>
+{
+  readonly name: 'dependencies';
+  constructor(options: DependencyPluginOptions);
+  initialize(
+    initOptions: FileMapPluginInitOptions<null, ReadonlyArray<string> | null>,
+  ): Promise<void>;
+  getSerializableSnapshot(): null;
+  bulkUpdate(
+    delta: FileMapDelta<null | undefined | ReadonlyArray<string>>,
+  ): void;
+  onNewOrModifiedFile(
+    relativeFilePath: string,
+    pluginData: null | undefined | ReadonlyArray<string>,
+  ): void;
+  onRemovedFile(
+    relativeFilePath: string,
+    pluginData: null | undefined | ReadonlyArray<string>,
+  ): void;
+  assertValid(): void;
+  getCacheKey(): string;
+  getWorker(): FileMapPluginWorker;
+  /**
+   * Get the list of dependencies for a given file.
+   * @param mixedPath Absolute or project-relative path to the file
+   * @returns Array of dependency module names, or null if the file doesn't exist
+   */
+  getDependencies(mixedPath: Path): null | undefined | ReadonlyArray<string>;
+}
+export default DependencyPlugin;