metro-file-map 0.76.0 → 0.76.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro-file-map",
-  "version": "0.76.0",
+  "version": "0.76.2",
   "description": "[Experimental] - 🚇 File crawling, watching and mapping for Metro",
   "main": "src/index.js",
   "repository": {
@@ -13,17 +13,16 @@
   },
   "license": "MIT",
   "dependencies": {
-    "abort-controller": "^3.0.0",
     "anymatch": "^3.0.3",
     "debug": "^2.2.0",
     "fb-watchman": "^2.0.0",
     "graceful-fs": "^4.2.4",
     "invariant": "^2.2.4",
     "jest-regex-util": "^27.0.6",
-    "jest-serializer": "^27.0.6",
     "jest-util": "^27.2.0",
     "jest-worker": "^27.2.0",
     "micromatch": "^4.0.4",
+    "node-abort-controller": "^3.1.1",
     "nullthrows": "^1.1.1",
     "walker": "^1.0.7"
   },

package/src/ModuleMap.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 {
+  HTypeValue,
+  IModuleMap,
+  Path,
+  ReadOnlyRawModuleMap,
+} from './flow-types';
+
+export default class ModuleMap implements IModuleMap {
+  getModule(
+    name: string,
+    platform?: string | null,
+    supportsNativePlatform?: boolean | null,
+    type?: HTypeValue | null,
+  ): Path | null;
+  getPackage(
+    name: string,
+    platform: string | null,
+    _supportsNativePlatform?: boolean | null,
+  ): Path | null;
+  getMockModule(name: string): Path | null;
+  getRawModuleMap(): ReadOnlyRawModuleMap;
+  static create(rootDir: Path): ModuleMap;
+}

package/src/Watcher.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.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+export type HealthCheckResult =
+  | {type: 'error'; timeout: number; error: Error; watcher: string | null}
+  | {
+      type: 'success';
+      timeout: number;
+      timeElapsed: number;
+      watcher: string | null;
+    }
+  | {
+      type: 'timeout';
+      timeout: number;
+      watcher: string | null;
+      pauseReason: string | null;
+    };

package/src/Watcher.js

@@ -92,6 +92,7 @@ class Watcher extends _events.default {
       path.basename(filePath).startsWith(this._options.healthCheckFilePrefix);
     const crawl = options.useWatchman ? _watchman.default : _node.default;
     let crawler = crawl === _watchman.default ? "watchman" : "node";
+    options.abortSignal.throwIfAborted();
     const crawlerOptions = {
       abortSignal: options.abortSignal,
       computeSha1: options.computeSha1,
@@ -286,6 +287,7 @@ class Watcher extends _events.default {
     this._pendingHealthChecks.delete(basename);
     // Chain a deletion to the creation promise (which may not have even settled yet!),
     // don't await it, and swallow errors. This is just best-effort cleanup.
+    // $FlowFixMe[unused-promise]
     creationPromise.then(() =>
       fs.promises.unlink(healthCheckPath).catch(() => {})
     );

package/src/Watcher.js.flow

@@ -18,6 +18,7 @@ import type {
   WatchmanClocks,
 } from './flow-types';
 import type {WatcherOptions as WatcherBackendOptions} from './watchers/common';
+import type {AbortSignal} from 'node-abort-controller';
 
 import watchmanCrawl from './crawlers/watchman';
 import nodeCrawl from './crawlers/node';
@@ -96,6 +97,9 @@ export class Watcher extends EventEmitter {
       path.basename(filePath).startsWith(this._options.healthCheckFilePrefix);
     const crawl = options.useWatchman ? watchmanCrawl : nodeCrawl;
     let crawler = crawl === watchmanCrawl ? 'watchman' : 'node';
+
+    options.abortSignal.throwIfAborted();
+
     const crawlerOptions: CrawlerOptions = {
       abortSignal: options.abortSignal,
       computeSha1: options.computeSha1,
@@ -314,6 +318,7 @@ export class Watcher extends EventEmitter {
     this._pendingHealthChecks.delete(basename);
     // Chain a deletion to the creation promise (which may not have even settled yet!),
     // don't await it, and swallow errors. This is just best-effort cleanup.
+    // $FlowFixMe[unused-promise]
     creationPromise.then(() =>
       fs.promises.unlink(healthCheckPath).catch(() => {}),
     );

package/src/cache/DiskCacheManager.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 {
+  BuildParameters,
+  CacheData,
+  CacheManager,
+  FileData,
+} from '../flow-types';
+
+export interface DiskCacheConfig {
+  buildParameters: BuildParameters;
+  cacheFilePrefix?: string | null;
+  cacheDirectory?: string | null;
+}
+
+export class DiskCacheManager implements CacheManager {
+  constructor(options: DiskCacheConfig);
+  static getCacheFilePath(
+    buildParameters: BuildParameters,
+    cacheFilePrefix?: string | null,
+    cacheDirectory?: string | null,
+  ): string;
+  getCacheFilePath(): string;
+  read(): Promise<CacheData | null>;
+  write(
+    dataSnapshot: CacheData,
+    {changed, removed}: Readonly<{changed: FileData; removed: FileData}>,
+  ): Promise<void>;
+}

package/src/crawlers/node/index.js

@@ -185,14 +185,16 @@ module.exports = async function nodeCrawl(options) {
     includeSymlinks,
     perfLogger,
     roots,
+    abortSignal,
   } = options;
+  abortSignal?.throwIfAborted();
   perfLogger?.point("nodeCrawl_start");
   const useNativeFind =
     !forceNodeFilesystemAPI &&
     (0, _os.platform)() !== "win32" &&
     (await (0, _hasNativeFindSupport.default)());
   debug("Using system find: %s", useNativeFind);
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
     const callback = (list) => {
       const changedFiles = new Map();
       const removedFiles = new Map(previousState.files);
@@ -218,6 +220,12 @@ module.exports = async function nodeCrawl(options) {
         }
       }
       perfLogger?.point("nodeCrawl_end");
+      try {
+        // TODO: Use AbortSignal.reason directly when Flow supports it
+        abortSignal?.throwIfAborted();
+      } catch (e) {
+        reject(e);
+      }
       resolve({
         changedFiles,
         removedFiles,

package/src/crawlers/node/index.js.flow

@@ -175,7 +175,11 @@ module.exports = async function nodeCrawl(options: CrawlerOptions): Promise<{
     includeSymlinks,
     perfLogger,
     roots,
+    abortSignal,
   } = options;
+
+  abortSignal?.throwIfAborted();
+
   perfLogger?.point('nodeCrawl_start');
   const useNativeFind =
     !forceNodeFilesystemAPI &&
@@ -184,7 +188,7 @@ module.exports = async function nodeCrawl(options: CrawlerOptions): Promise<{
 
   debug('Using system find: %s', useNativeFind);
 
-  return new Promise(resolve => {
+  return new Promise((resolve, reject) => {
     const callback = (list: Result) => {
       const changedFiles = new Map<Path, FileMetaData>();
       const removedFiles = new Map(previousState.files);
@@ -208,6 +212,13 @@ module.exports = async function nodeCrawl(options: CrawlerOptions): Promise<{
       }
 
       perfLogger?.point('nodeCrawl_end');
+
+      try {
+        // TODO: Use AbortSignal.reason directly when Flow supports it
+        abortSignal?.throwIfAborted();
+      } catch (e) {
+        reject(e);
+      }
       resolve({
         changedFiles,
         removedFiles,

package/src/crawlers/watchman/index.js

@@ -85,10 +85,11 @@ module.exports = async function watchmanCrawl({
   rootDir,
   roots,
 }) {
-  perfLogger?.point("watchmanCrawl_start");
-  const newClocks = new Map();
+  abortSignal?.throwIfAborted();
   const client = new watchman.Client();
   abortSignal?.addEventListener("abort", () => client.end());
+  perfLogger?.point("watchmanCrawl_start");
+  const newClocks = new Map();
   let clientError;
   client.on("error", (error) => {
     clientError = makeWatchmanError(error);
@@ -274,6 +275,7 @@ module.exports = async function watchmanCrawl({
       });
     }
     perfLogger?.point("watchmanCrawl_end");
+    abortSignal?.throwIfAborted();
     throw (
       queryError ?? clientError ?? new Error("Watchman file results missing")
     );
@@ -356,6 +358,7 @@ module.exports = async function watchmanCrawl({
   }
   perfLogger?.point("watchmanCrawl/processResults_end");
   perfLogger?.point("watchmanCrawl_end");
+  abortSignal?.throwIfAborted();
   return {
     changedFiles,
     removedFiles,

package/src/crawlers/watchman/index.js.flow

@@ -62,13 +62,15 @@ module.exports = async function watchmanCrawl({
   removedFiles: FileData,
   clocks: WatchmanClocks,
 }> {
-  perfLogger?.point('watchmanCrawl_start');
-
-  const newClocks = new Map<Path, WatchmanClockSpec>();
+  abortSignal?.throwIfAborted();
 
   const client = new watchman.Client();
   abortSignal?.addEventListener('abort', () => client.end());
 
+  perfLogger?.point('watchmanCrawl_start');
+
+  const newClocks = new Map<Path, WatchmanClockSpec>();
+
   let clientError;
   client.on('error', error => {
     clientError = makeWatchmanError(error);
@@ -280,6 +282,7 @@ module.exports = async function watchmanCrawl({
       });
     }
     perfLogger?.point('watchmanCrawl_end');
+    abortSignal?.throwIfAborted();
     throw (
       queryError ?? clientError ?? new Error('Watchman file results missing')
     );
@@ -378,6 +381,7 @@ module.exports = async function watchmanCrawl({
 
   perfLogger?.point('watchmanCrawl/processResults_end');
   perfLogger?.point('watchmanCrawl_end');
+  abortSignal?.throwIfAborted();
   return {
     changedFiles,
     removedFiles,

package/src/flow-types.d.ts

@@ -0,0 +1,272 @@
+/**
+ * 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 ModuleMap from './ModuleMap';
+import type {PerfLoggerFactory, RootPerfLogger, PerfLogger} from 'metro-config';
+import type {AbortSignal} from 'node-abort-controller';
+
+export type {PerfLoggerFactory, PerfLogger};
+
+/**
+ * These inputs affect the internal data collected for a given filesystem
+ * state, and changes may invalidate a cache.
+ */
+export type BuildParameters = Readonly<{
+  computeDependencies: boolean;
+  computeSha1: boolean;
+  enableSymlinks: boolean;
+  extensions: ReadonlyArray<string>;
+  forceNodeFilesystemAPI: boolean;
+  ignorePattern: RegExp;
+  mocksPattern: RegExp | null;
+  platforms: ReadonlyArray<string>;
+  retainAllFiles: boolean;
+  rootDir: string;
+  roots: ReadonlyArray<string>;
+  skipPackageJson: boolean;
+  dependencyExtractor: string | null;
+  hasteImplModulePath: string | null;
+  cacheBreaker: string;
+}>;
+
+export interface BuildResult {
+  fileSystem: FileSystem;
+  hasteModuleMap: ModuleMap;
+}
+
+export interface CacheData {
+  readonly clocks: WatchmanClocks;
+  readonly map: RawModuleMap['map'];
+  readonly mocks: RawModuleMap['mocks'];
+  readonly duplicates: RawModuleMap['duplicates'];
+  readonly files: FileData;
+}
+
+export interface CacheManager {
+  read(): Promise<CacheData | null>;
+  write(
+    dataSnapshot: CacheData,
+    delta: Readonly<{changed: FileData; removed: FileData}>,
+  ): Promise<void>;
+}
+
+export type CacheManagerFactory = (
+  buildParameters: BuildParameters,
+) => CacheManager;
+
+export interface ChangeEvent {
+  logger: RootPerfLogger | null;
+  eventsQueue: EventsQueue;
+}
+
+export interface ChangeEventMetadata {
+  /** Epoch ms */
+  modifiedTime: number | null;
+  /** Bytes */
+  size: number | null;
+  /** Regular file / Directory / Symlink */
+  type: 'f' | 'd' | 'l';
+}
+
+export type Console = typeof global.console;
+
+export interface CrawlerOptions {
+  abortSignal: AbortSignal | null;
+  computeSha1: boolean;
+  extensions: ReadonlyArray<string>;
+  forceNodeFilesystemAPI: boolean;
+  ignore: IgnoreMatcher;
+  includeSymlinks: boolean;
+  perfLogger?: PerfLogger | null;
+  previousState: Readonly<{
+    clocks: ReadonlyMap<Path, WatchmanClockSpec>;
+    files: ReadonlyMap<Path, FileMetaData>;
+  }>;
+  rootDir: string;
+  roots: ReadonlyArray<string>;
+  onStatus: (status: WatcherStatus) => void;
+}
+
+export type WatcherStatus =
+  | {
+      type: 'watchman_slow_command';
+      timeElapsed: number;
+      command: 'watch-project' | 'query';
+    }
+  | {
+      type: 'watchman_slow_command_complete';
+      timeElapsed: number;
+      command: 'watch-project' | 'query';
+    }
+  | {
+      type: 'watchman_warning';
+      warning: unknown;
+      command: 'watch-project' | 'query';
+    };
+
+export type DuplicatesSet = Map<string, /* type */ number>;
+export type DuplicatesIndex = Map<string, Map<string, DuplicatesSet>>;
+
+export type EventsQueue = Array<{
+  filePath: Path;
+  metadata?: ChangeEventMetadata | null;
+  type: string;
+}>;
+
+export interface HType {
+  ID: 0;
+  MTIME: 1;
+  SIZE: 2;
+  VISITED: 3;
+  DEPENDENCIES: 4;
+  SHA1: 5;
+  SYMLINK: 6;
+  PATH: 0;
+  TYPE: 1;
+  MODULE: 0;
+  PACKAGE: 1;
+  GENERIC_PLATFORM: 'g';
+  NATIVE_PLATFORM: 'native';
+  DEPENDENCY_DELIM: '\0';
+}
+
+type Values<T> = T[keyof T];
+export type HTypeValue = Values<HType>;
+
+export type IgnoreMatcher = (item: string) => boolean;
+
+export type FileData = Map<Path, FileMetaData>;
+
+export type FileMetaData = [
+  /* id */ string,
+  /* mtime */ number,
+  /* size */ number,
+  /* visited */ 0 | 1,
+  /* dependencies */ string,
+  /* sha1 */ string | null,
+  /* symlink */ 0 | 1 | string, // string specifies target, if known
+];
+
+export type FileStats = Readonly<{
+  fileType: 'f' | 'l';
+  modifiedTime: number;
+}>;
+
+export interface FileSystem {
+  exists(file: Path): boolean;
+  getAllFiles(): Path[];
+  getDependencies(file: Path): string[] | null;
+  getModuleName(file: Path): string | null;
+  getRealPath(file: Path): string | null;
+  getSerializableSnapshot(): FileData;
+  getSha1(file: Path): string | null;
+
+  /**
+   * Analogous to posix lstat. If the file at `file` is a symlink, return
+   * information about the symlink without following it.
+   */
+  linkStats(file: Path): FileStats | null;
+
+  matchFiles(pattern: RegExp | string): Path[];
+
+  /**
+   * 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`
+   */
+  matchFilesWithContext(
+    root: Path,
+    context: Readonly<{
+      /* Should search for files recursively. */
+      recursive: boolean;
+      /* Filter relative paths against a pattern. */
+      filter: RegExp;
+    }>,
+  ): Path[];
+}
+
+export type Glob = string;
+
+// tslint:disable-next-line interface-name
+export interface IModuleMap {
+  getModule(
+    name: string,
+    platform?: string | null,
+    supportsNativePlatform?: boolean | null,
+    type?: HTypeValue | null,
+  ): Path | null;
+
+  getPackage(
+    name: string,
+    platform: string | null,
+    _supportsNativePlatform: boolean | null,
+  ): Path | null;
+
+  getMockModule(name: string): Path | null;
+
+  getRawModuleMap(): ReadOnlyRawModuleMap;
+}
+
+export type MockData = Map<string, Path>;
+export type ModuleMapData = Map<string, ModuleMapItem>;
+
+export interface ModuleMapItem {
+  [platform: string]: ModuleMetaData;
+}
+export type ModuleMetaData = [/* path */ string, /* type */ number];
+
+export interface MutableFileSystem extends FileSystem {
+  remove(filePath: Path): void;
+  addOrModify(filePath: Path, fileMetadata: FileMetaData): void;
+  bulkAddOrModify(addedOrModifiedFiles: FileData): void;
+}
+
+export type Path = string;
+
+export interface RawModuleMap {
+  rootDir: Path;
+  duplicates: DuplicatesIndex;
+  map: ModuleMapData;
+  mocks: MockData;
+}
+
+export type ReadOnlyRawModuleMap = Readonly<{
+  rootDir: Path;
+  duplicates: ReadonlyMap<
+    string,
+    ReadonlyMap<string, ReadonlyMap<string, number>>
+  >;
+  map: ReadonlyMap<string, ModuleMapItem>;
+  mocks: ReadonlyMap<string, Path>;
+}>;
+
+export type WatchmanClockSpec =
+  | string
+  | Readonly<{scm: Readonly<{'mergebase-with': string}>}>;
+export type WatchmanClocks = Map<Path, WatchmanClockSpec>;
+
+export type WorkerMessage = Readonly<{
+  computeDependencies: boolean;
+  computeSha1: boolean;
+  dependencyExtractor?: string | null;
+  enableHastePackages: boolean;
+  readLink: boolean;
+  rootDir: string;
+  filePath: string;
+  hasteImplModulePath?: string | null;
+}>;
+
+export type WorkerMetadata = Readonly<{
+  dependencies?: ReadonlyArray<string>;
+  id?: string | null;
+  module?: ModuleMetaData | null;
+  sha1?: string | null;
+  symlinkTarget?: string | null;
+}>;

package/src/flow-types.js.flow

@@ -13,6 +13,7 @@
 
 import type ModuleMap from './ModuleMap';
 import type {PerfLoggerFactory, RootPerfLogger, PerfLogger} from 'metro-config';
+import type {AbortSignal} from 'node-abort-controller';
 
 export type {PerfLoggerFactory, PerfLogger};
 

package/src/index.d.ts

@@ -0,0 +1,94 @@
+/**
+ * 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 {
+  BuildParameters,
+  BuildResult,
+  CacheData,
+  CacheManagerFactory,
+  ChangeEventMetadata,
+  Console,
+  FileData,
+  FileSystem,
+  ModuleMapData,
+  ModuleMapItem,
+  PerfLoggerFactory,
+} from './flow-types';
+import type {EventEmitter} from 'events';
+
+export type {
+  BuildParameters,
+  CacheData,
+  ChangeEventMetadata,
+  FileData,
+  FileSystem,
+  HasteMap,
+  ModuleMapData,
+  ModuleMapItem,
+};
+
+export type InputOptions = Readonly<{
+  computeDependencies?: boolean | null;
+  computeSha1?: boolean | null;
+  enableSymlinks?: boolean | null;
+  extensions: ReadonlyArray<string>;
+  forceNodeFilesystemAPI?: boolean | null;
+  ignorePattern?: RegExp | null;
+  mocksPattern?: string | null;
+  platforms: ReadonlyArray<string>;
+  retainAllFiles: boolean;
+  rootDir: string;
+  roots: ReadonlyArray<string>;
+  skipPackageJson?: boolean | null;
+
+  /** Module paths that should export a 'getCacheKey' method */
+  dependencyExtractor?: string | null;
+  hasteImplModulePath?: string | null;
+
+  perfLoggerFactory?: PerfLoggerFactory | null;
+  resetCache?: boolean | null;
+  maxWorkers: number;
+  throwOnModuleCollision?: boolean | null;
+  useWatchman?: boolean | null;
+  watchmanDeferStates?: ReadonlyArray<string>;
+  watch?: boolean | null;
+  console?: Console;
+  cacheManagerFactory?: CacheManagerFactory | null;
+
+  healthCheck: HealthCheckOptions;
+}>;
+
+type HealthCheckOptions = Readonly<{
+  enabled: boolean;
+  interval: number;
+  timeout: number;
+  filePrefix: string;
+}>;
+
+export {default as ModuleMap} from './ModuleMap';
+export {DiskCacheManager} from './cache/DiskCacheManager';
+export {DuplicateHasteCandidatesError} from './lib/DuplicateHasteCandidatesError';
+export type {IModuleMap} from './flow-types';
+export type {HealthCheckResult} from './Watcher';
+export type {
+  CacheManager,
+  CacheManagerFactory,
+  ChangeEvent,
+  WatcherStatus,
+} from './flow-types';
+
+export default class HasteMap extends EventEmitter {
+  static create(options: InputOptions): HasteMap;
+  constructor(options: InputOptions);
+  build(): Promise<BuildResult>;
+  read(): Promise<CacheData | null>;
+}
+
+export class DuplicateError extends Error {}