metro-file-map 0.73.1 → 0.73.3

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

@@ -100,7 +100,7 @@ module.exports = async function watchmanCrawl({
     roots: $ReadOnlyArray<Path>,
   ): Promise<WatchmanRoots> {
     perfLogger?.point('watchmanCrawl/getWatchmanRoots_start');
-    const watchmanRoots = new Map();
+    const watchmanRoots = new Map<string, Array<string>>();
     await Promise.all(
       roots.map(async (root, index) => {
         perfLogger?.point(`watchmanCrawl/watchProject_${index}_start`);
@@ -205,8 +205,8 @@ module.exports = async function watchmanCrawl({
   }
 
   let files = data.files;
-  let removedFiles = new Map();
-  const changedFiles = new Map();
+  let removedFiles = new Map<Path, FileMetaData>();
+  const changedFiles = new Map<Path, FileMetaData>();
   let results: Map<string, WatchmanQueryResponse>;
   let isFresh = false;
   let queryError: ?Error;

package/src/index.js

@@ -52,15 +52,7 @@ var _rootRelativeCacheKeys = _interopRequireDefault(
 
 var _ModuleMap = _interopRequireDefault(require("./ModuleMap"));
 
-var _FSEventsWatcher = _interopRequireDefault(
-  require("./watchers/FSEventsWatcher")
-);
-
-var _NodeWatcher = _interopRequireDefault(require("./watchers/NodeWatcher"));
-
-var _WatchmanWatcher = _interopRequireDefault(
-  require("./watchers/WatchmanWatcher")
-);
+var _Watcher = require("./Watcher");
 
 var _worker = require("./worker");
 
@@ -132,16 +124,9 @@ function _interopRequireDefault(obj) {
  * @format
  * @oncall react_native
  */
-// $FlowFixMe[untyped-import] - it's a fork: https://github.com/facebook/jest/pull/10919
 // $FlowFixMe[untyped-import] - jest-regex-util
 // $FlowFixMe[untyped-import] - jest-worker
 // $FlowFixMe[untyped-import] - this is a polyfill
-const nodeCrawl = require("./crawlers/node");
-
-const watchmanCrawl = require("./crawlers/watchman");
-
-const debug = require("debug")("Metro:FileMap");
-
 const DuplicateHasteCandidatesError =
   _ModuleMap.default.DuplicateHasteCandidatesError;
 exports.DuplicateHasteCandidatesError = DuplicateHasteCandidatesError;
@@ -150,7 +135,6 @@ exports.DuplicateHasteCandidatesError = DuplicateHasteCandidatesError;
 // filesystem state and build parameters).
 const CACHE_BREAKER = "2";
 const CHANGE_INTERVAL = 30;
-const MAX_WAIT_TIME = 240000;
 const NODE_MODULES = path.sep + "node_modules" + path.sep;
 const PACKAGE_JSON = path.sep + "package.json";
 const VCS_DIRECTORIES = [".git", ".hg"]
@@ -309,6 +293,7 @@ class HasteMap extends _events.default {
     };
     this._options = {
       ...buildParameters,
+      healthCheck: options.healthCheck,
       maxWorkers: options.maxWorkers,
       perfLogger: options.perfLogger,
       resetCache: options.resetCache,
@@ -337,7 +322,6 @@ class HasteMap extends _events.default {
     }
 
     this._buildPromise = null;
-    this._watchers = [];
     this._worker = null;
     (_this$_options$perfLo = this._options.perfLogger) === null ||
     _this$_options$perfLo === void 0
@@ -511,7 +495,37 @@ class HasteMap extends _events.default {
       hasteMap = this._createEmptyMap();
     }
 
-    return this._crawl(hasteMap).then((result) => {
+    const {
+      computeSha1,
+      enableSymlinks,
+      extensions,
+      forceNodeFilesystemAPI,
+      ignorePattern,
+      perfLogger,
+      roots,
+      rootDir,
+      watch,
+      watchmanDeferStates,
+    } = this._options;
+    this._watcher = new _Watcher.Watcher({
+      abortSignal: this._crawlerAbortController.signal,
+      computeSha1,
+      console: this._console,
+      enableSymlinks,
+      extensions,
+      forceNodeFilesystemAPI,
+      healthCheckFilePrefix: this._options.healthCheck.filePrefix,
+      ignore: (path) => this._ignore(path),
+      ignorePattern,
+      initialData: hasteMap,
+      perfLogger,
+      roots,
+      rootDir,
+      useWatchman: await this._shouldUseWatchman(),
+      watch,
+      watchmanDeferStates,
+    });
+    return this._watcher.crawl().then((result) => {
       var _this$_options$perfLo8;
 
       (_this$_options$perfLo8 = this._options.perfLogger) === null ||
@@ -893,154 +907,38 @@ class HasteMap extends _events.default {
 
     return this._worker;
   }
-
-  async _crawl(hasteMap) {
-    var _this$_options$perfLo13;
-
-    (_this$_options$perfLo13 = this._options.perfLogger) === null ||
-    _this$_options$perfLo13 === void 0
-      ? void 0
-      : _this$_options$perfLo13.point("crawl_start");
-    const options = this._options;
-
-    const ignore = (filePath) => this._ignore(filePath);
-
-    const crawl = (await this._shouldUseWatchman()) ? watchmanCrawl : nodeCrawl;
-    const crawlerOptions = {
-      abortSignal: this._crawlerAbortController.signal,
-      computeSha1: options.computeSha1,
-      data: hasteMap,
-      enableSymlinks: options.enableSymlinks,
-      extensions: options.extensions,
-      forceNodeFilesystemAPI: options.forceNodeFilesystemAPI,
-      ignore,
-      perfLogger: options.perfLogger,
-      rootDir: options.rootDir,
-      roots: options.roots,
-    };
-
-    const retry = (error) => {
-      if (crawl === watchmanCrawl) {
-        this._console.warn(
-          "metro-file-map: Watchman crawl failed. Retrying once with node " +
-            "crawler.\n" +
-            "  Usually this happens when watchman isn't running. Create an " +
-            "empty `.watchmanconfig` file in your project's root folder or " +
-            "initialize a git or hg repository in your project.\n" +
-            "  " +
-            error.toString()
-        );
-
-        return nodeCrawl(crawlerOptions).catch((e) => {
-          throw new Error(
-            "Crawler retry failed:\n" +
-              `  Original error: ${error.message}\n` +
-              `  Retry error: ${e.message}\n`
-          );
-        });
-      }
-
-      throw error;
-    };
-
-    const logEnd = (result) => {
-      var _this$_options$perfLo14;
-
-      (_this$_options$perfLo14 = this._options.perfLogger) === null ||
-      _this$_options$perfLo14 === void 0
-        ? void 0
-        : _this$_options$perfLo14.point("crawl_end");
-      return result;
-    };
-
-    try {
-      return crawl(crawlerOptions).catch(retry).then(logEnd);
-    } catch (error) {
-      return retry(error).then(logEnd);
-    }
-  }
   /**
    * Watch mode
    */
 
   async _watch(hasteMap) {
-    var _this$_options$perfLo15, _this$_options$perfLo17;
+    var _this$_options$perfLo13, _this$_options$perfLo15;
 
-    (_this$_options$perfLo15 = this._options.perfLogger) === null ||
-    _this$_options$perfLo15 === void 0
+    (_this$_options$perfLo13 = this._options.perfLogger) === null ||
+    _this$_options$perfLo13 === void 0
       ? void 0
-      : _this$_options$perfLo15.point("watch_start");
+      : _this$_options$perfLo13.point("watch_start");
 
     if (!this._options.watch) {
-      var _this$_options$perfLo16;
+      var _this$_options$perfLo14;
 
-      (_this$_options$perfLo16 = this._options.perfLogger) === null ||
-      _this$_options$perfLo16 === void 0
+      (_this$_options$perfLo14 = this._options.perfLogger) === null ||
+      _this$_options$perfLo14 === void 0
         ? void 0
-        : _this$_options$perfLo16.point("watch_end");
+        : _this$_options$perfLo14.point("watch_end");
       return;
     } // In watch mode, we'll only warn about module collisions and we'll retain
     // all files, even changes to node_modules.
 
     this._options.throwOnModuleCollision = false;
-    this._options.retainAllFiles = true; // WatchmanWatcher > FSEventsWatcher > sane.NodeWatcher
-
-    const WatcherImpl = (await this._shouldUseWatchman())
-      ? _WatchmanWatcher.default
-      : _FSEventsWatcher.default.isSupported()
-      ? _FSEventsWatcher.default
-      : _NodeWatcher.default;
-    let watcher = "node";
-
-    if (WatcherImpl === _WatchmanWatcher.default) {
-      watcher = "watchman";
-    } else if (WatcherImpl === _FSEventsWatcher.default) {
-      watcher = "fsevents";
-    }
-
-    debug(`Using watcher: ${watcher}`);
-    (_this$_options$perfLo17 = this._options.perfLogger) === null ||
-    _this$_options$perfLo17 === void 0
-      ? void 0
-      : _this$_options$perfLo17.annotate({
-          string: {
-            watcher,
-          },
-        });
+    this._options.retainAllFiles = true;
     const extensions = this._options.extensions;
-    const ignorePattern = this._options.ignorePattern;
     const rootDir = this._options.rootDir;
     let changeQueue = Promise.resolve();
     let eventsQueue = []; // We only need to copy the entire haste map once on every "frame".
 
     let mustCopy = true;
 
-    const createWatcher = (root) => {
-      const watcherOptions = {
-        dot: true,
-        glob: [
-          // Ensure we always include package.json files, which are crucial for
-          /// module resolution.
-          "**/package.json",
-          ...extensions.map((extension) => "**/*." + extension),
-        ],
-        ignored: ignorePattern,
-        watchmanDeferStates: this._options.watchmanDeferStates,
-      };
-      const watcher = new WatcherImpl(root, watcherOptions);
-      return new Promise((resolve, reject) => {
-        const rejectTimeout = setTimeout(
-          () => reject(new Error("Failed to start watch mode.")),
-          MAX_WAIT_TIME
-        );
-        watcher.once("ready", () => {
-          clearTimeout(rejectTimeout);
-          watcher.on("all", onChange);
-          resolve(watcher);
-        });
-      });
-    };
-
     const emitChange = () => {
       if (eventsQueue.length) {
         mustCopy = true;
@@ -1213,17 +1111,36 @@ class HasteMap extends _events.default {
     };
 
     this._changeInterval = setInterval(emitChange, CHANGE_INTERVAL);
-    await Promise.all(this._options.roots.map(createWatcher)).then(
-      (watchers) => {
-        var _this$_options$perfLo18;
-
-        this._watchers = watchers;
-        (_this$_options$perfLo18 = this._options.perfLogger) === null ||
-        _this$_options$perfLo18 === void 0
-          ? void 0
-          : _this$_options$perfLo18.point("watch_end");
-      }
+    (0, _invariant.default)(
+      this._watcher != null,
+      "Expected _watcher to have been initialised by _buildFileMap"
     );
+    await this._watcher.watch(onChange);
+
+    if (this._options.healthCheck.enabled) {
+      const performHealthCheck = () => {
+        if (!this._watcher) {
+          return;
+        }
+
+        this._watcher
+          .checkHealth(this._options.healthCheck.timeout)
+          .then((result) => {
+            this.emit("healthCheck", result);
+          });
+      };
+
+      performHealthCheck();
+      this._healthCheckInterval = setInterval(
+        performHealthCheck,
+        this._options.healthCheck.interval
+      );
+    }
+
+    (_this$_options$perfLo15 = this._options.perfLogger) === null ||
+    _this$_options$perfLo15 === void 0
+      ? void 0
+      : _this$_options$perfLo15.point("watch_end");
   }
   /**
    * This function should be called when the file under `filePath` is removed
@@ -1290,12 +1207,15 @@ class HasteMap extends _events.default {
       clearInterval(this._changeInterval);
     }
 
-    if (!this._watchers.length) {
+    if (this._healthCheckInterval) {
+      clearInterval(this._healthCheckInterval);
+    }
+
+    if (!this._watcher) {
       return;
     }
 
-    await Promise.all(this._watchers.map((watcher) => watcher.close()));
-    this._watchers = [];
+    await this._watcher.close();
 
     this._crawlerAbortController.abort();
   }
@@ -1326,14 +1246,14 @@ class HasteMap extends _events.default {
       )
         .then(() => true)
         .catch((e) => {
-          var _this$_options$perfLo19, _e$message;
+          var _this$_options$perfLo16, _e$message;
 
           // TODO: Advise people to either install Watchman or set
           // `useWatchman: false` here?
-          (_this$_options$perfLo19 = this._options.perfLogger) === null ||
-          _this$_options$perfLo19 === void 0
+          (_this$_options$perfLo16 = this._options.perfLogger) === null ||
+          _this$_options$perfLo16 === void 0
             ? void 0
-            : _this$_options$perfLo19.annotate({
+            : _this$_options$perfLo16.annotate({
                 string: {
                   watchmanFailedCapabilityCheck:
                     (_e$message =

package/src/index.js.flow

@@ -15,7 +15,6 @@ import type {
   CacheManagerFactory,
   ChangeEvent,
   Console,
-  CrawlerOptions,
   EventsQueue,
   FileData,
   FileMetaData,
@@ -31,8 +30,8 @@ import type {
   SerializableModuleMap,
   WorkerMetadata,
 } from './flow-types';
-import type {WatcherOptions} from './watchers/common';
 import type {Stats} from 'graceful-fs';
+import type {HealthCheckResult} from './Watcher';
 
 import {DiskCacheManager} from './cache/DiskCacheManager';
 import H from './constants';
@@ -45,10 +44,7 @@ import getPlatformExtension from './lib/getPlatformExtension';
 import normalizePathSep from './lib/normalizePathSep';
 import rootRelativeCacheKeys from './lib/rootRelativeCacheKeys';
 import HasteModuleMap from './ModuleMap';
-import FSEventsWatcher from './watchers/FSEventsWatcher';
-// $FlowFixMe[untyped-import] - it's a fork: https://github.com/facebook/jest/pull/10919
-import NodeWatcher from './watchers/NodeWatcher';
-import WatchmanWatcher from './watchers/WatchmanWatcher';
+import {Watcher} from './Watcher';
 import {getSha1, worker} from './worker';
 import EventEmitter from 'events';
 import invariant from 'invariant';
@@ -60,15 +56,12 @@ import * as path from 'path';
 // $FlowFixMe[untyped-import] - this is a polyfill
 import AbortController from 'abort-controller';
 
-const nodeCrawl = require('./crawlers/node');
-const watchmanCrawl = require('./crawlers/watchman');
-const debug = require('debug')('Metro:FileMap');
-
 export type {
   BuildParameters,
   FileData,
   HasteFS,
   HasteMap,
+  HealthCheckResult,
   InternalData,
   ModuleMapData,
   ModuleMapItem,
@@ -101,10 +94,20 @@ export type InputOptions = $ReadOnly<{
   watch?: ?boolean,
   console?: Console,
   cacheManagerFactory?: ?CacheManagerFactory,
+
+  healthCheck: HealthCheckOptions,
+}>;
+
+type HealthCheckOptions = $ReadOnly<{
+  enabled: boolean,
+  interval: number,
+  timeout: number,
+  filePrefix: string,
 }>;
 
 type InternalOptions = {
   ...BuildParameters,
+  healthCheck: HealthCheckOptions,
   perfLogger: ?PerfLogger,
   resetCache: ?boolean,
   maxWorkers: number,
@@ -114,10 +117,6 @@ type InternalOptions = {
   watchmanDeferStates: $ReadOnlyArray<string>,
 };
 
-interface Watcher {
-  close(): Promise<void>;
-}
-
 type WorkerInterface = {worker: typeof worker, getSha1: typeof getSha1};
 
 export const DuplicateHasteCandidatesError =
@@ -140,7 +139,6 @@ export type {
 const CACHE_BREAKER = '2';
 
 const CHANGE_INTERVAL = 30;
-const MAX_WAIT_TIME = 240000;
 const NODE_MODULES = path.sep + 'node_modules' + path.sep;
 const PACKAGE_JSON = path.sep + 'package.json';
 const VCS_DIRECTORIES = ['.git', '.hg']
@@ -237,10 +235,11 @@ export default class HasteMap extends EventEmitter {
   _changeInterval: ?IntervalID;
   _console: Console;
   _options: InternalOptions;
-  _watchers: Array<Watcher>;
+  _watcher: ?Watcher;
   _worker: ?WorkerInterface;
   _cacheManager: CacheManager;
   _crawlerAbortController: typeof AbortController;
+  _healthCheckInterval: ?IntervalID;
 
   static create(options: InputOptions): HasteMap {
     return new HasteMap(options);
@@ -297,6 +296,7 @@ export default class HasteMap extends EventEmitter {
 
     this._options = {
       ...buildParameters,
+      healthCheck: options.healthCheck,
       maxWorkers: options.maxWorkers,
       perfLogger: options.perfLogger,
       resetCache: options.resetCache,
@@ -322,7 +322,6 @@ export default class HasteMap extends EventEmitter {
     }
 
     this._buildPromise = null;
-    this._watchers = [];
     this._worker = null;
     this._options.perfLogger?.point('constructor_end');
     this._crawlerAbortController = new AbortController();
@@ -455,7 +454,40 @@ export default class HasteMap extends EventEmitter {
     } catch {
       hasteMap = this._createEmptyMap();
     }
-    return this._crawl(hasteMap).then(result => {
+
+    const {
+      computeSha1,
+      enableSymlinks,
+      extensions,
+      forceNodeFilesystemAPI,
+      ignorePattern,
+      perfLogger,
+      roots,
+      rootDir,
+      watch,
+      watchmanDeferStates,
+    } = this._options;
+
+    this._watcher = new Watcher({
+      abortSignal: this._crawlerAbortController.signal,
+      computeSha1,
+      console: this._console,
+      enableSymlinks,
+      extensions,
+      forceNodeFilesystemAPI,
+      healthCheckFilePrefix: this._options.healthCheck.filePrefix,
+      ignore: path => this._ignore(path),
+      ignorePattern,
+      initialData: hasteMap,
+      perfLogger,
+      roots,
+      rootDir,
+      useWatchman: await this._shouldUseWatchman(),
+      watch,
+      watchmanDeferStates,
+    });
+
+    return this._watcher.crawl().then(result => {
       this._options.perfLogger?.point('buildFileMap_end');
       return result;
     });
@@ -788,66 +820,6 @@ export default class HasteMap extends EventEmitter {
     return this._worker;
   }
 
-  async _crawl(hasteMap: InternalData): Promise<?(
-    | Promise<{
-        changedFiles?: FileData,
-        hasteMap: InternalData,
-        removedFiles: FileData,
-      }>
-    | {changedFiles?: FileData, hasteMap: InternalData, removedFiles: FileData}
-  )> {
-    this._options.perfLogger?.point('crawl_start');
-    const options = this._options;
-    const ignore = (filePath: string) => this._ignore(filePath);
-    const crawl = (await this._shouldUseWatchman()) ? watchmanCrawl : nodeCrawl;
-    const crawlerOptions: CrawlerOptions = {
-      abortSignal: this._crawlerAbortController.signal,
-      computeSha1: options.computeSha1,
-      data: hasteMap,
-      enableSymlinks: options.enableSymlinks,
-      extensions: options.extensions,
-      forceNodeFilesystemAPI: options.forceNodeFilesystemAPI,
-      ignore,
-      perfLogger: options.perfLogger,
-      rootDir: options.rootDir,
-      roots: options.roots,
-    };
-
-    const retry = (error: Error) => {
-      if (crawl === watchmanCrawl) {
-        this._console.warn(
-          'metro-file-map: Watchman crawl failed. Retrying once with node ' +
-            'crawler.\n' +
-            "  Usually this happens when watchman isn't running. Create an " +
-            "empty `.watchmanconfig` file in your project's root folder or " +
-            'initialize a git or hg repository in your project.\n' +
-            '  ' +
-            error.toString(),
-        );
-        return nodeCrawl(crawlerOptions).catch(e => {
-          throw new Error(
-            'Crawler retry failed:\n' +
-              `  Original error: ${error.message}\n` +
-              `  Retry error: ${e.message}\n`,
-          );
-        });
-      }
-
-      throw error;
-    };
-
-    const logEnd = <T>(result: T): T => {
-      this._options.perfLogger?.point('crawl_end');
-      return result;
-    };
-
-    try {
-      return crawl(crawlerOptions).catch(retry).then(logEnd);
-    } catch (error) {
-      return retry(error).then(logEnd);
-    }
-  }
-
   /**
    * Watch mode
    */
@@ -863,24 +835,7 @@ export default class HasteMap extends EventEmitter {
     this._options.throwOnModuleCollision = false;
     this._options.retainAllFiles = true;
 
-    // WatchmanWatcher > FSEventsWatcher > sane.NodeWatcher
-    const WatcherImpl = (await this._shouldUseWatchman())
-      ? WatchmanWatcher
-      : FSEventsWatcher.isSupported()
-      ? FSEventsWatcher
-      : NodeWatcher;
-
-    let watcher = 'node';
-    if (WatcherImpl === WatchmanWatcher) {
-      watcher = 'watchman';
-    } else if (WatcherImpl === FSEventsWatcher) {
-      watcher = 'fsevents';
-    }
-    debug(`Using watcher: ${watcher}`);
-    this._options.perfLogger?.annotate({string: {watcher}});
-
     const extensions = this._options.extensions;
-    const ignorePattern = this._options.ignorePattern;
     const rootDir = this._options.rootDir;
 
     let changeQueue: Promise<null | void> = Promise.resolve();
@@ -888,34 +843,6 @@ export default class HasteMap extends EventEmitter {
     // We only need to copy the entire haste map once on every "frame".
     let mustCopy = true;
 
-    const createWatcher = (root: Path): Promise<Watcher> => {
-      const watcherOptions: WatcherOptions = {
-        dot: true,
-        glob: [
-          // Ensure we always include package.json files, which are crucial for
-          /// module resolution.
-          '**/package.json',
-          ...extensions.map(extension => '**/*.' + extension),
-        ],
-        ignored: ignorePattern,
-        watchmanDeferStates: this._options.watchmanDeferStates,
-      };
-      const watcher = new WatcherImpl(root, watcherOptions);
-
-      return new Promise((resolve, reject) => {
-        const rejectTimeout = setTimeout(
-          () => reject(new Error('Failed to start watch mode.')),
-          MAX_WAIT_TIME,
-        );
-
-        watcher.once('ready', () => {
-          clearTimeout(rejectTimeout);
-          watcher.on('all', onChange);
-          resolve(watcher);
-        });
-      });
-    };
-
     const emitChange = () => {
       if (eventsQueue.length) {
         mustCopy = true;
@@ -1076,10 +1003,30 @@ export default class HasteMap extends EventEmitter {
 
     this._changeInterval = setInterval(emitChange, CHANGE_INTERVAL);
 
-    await Promise.all(this._options.roots.map(createWatcher)).then(watchers => {
-      this._watchers = watchers;
-      this._options.perfLogger?.point('watch_end');
-    });
+    invariant(
+      this._watcher != null,
+      'Expected _watcher to have been initialised by _buildFileMap',
+    );
+    await this._watcher.watch(onChange);
+
+    if (this._options.healthCheck.enabled) {
+      const performHealthCheck = () => {
+        if (!this._watcher) {
+          return;
+        }
+        this._watcher
+          .checkHealth(this._options.healthCheck.timeout)
+          .then(result => {
+            this.emit('healthCheck', result);
+          });
+      };
+      performHealthCheck();
+      this._healthCheckInterval = setInterval(
+        performHealthCheck,
+        this._options.healthCheck.interval,
+      );
+    }
+    this._options.perfLogger?.point('watch_end');
   }
 
   /**
@@ -1143,14 +1090,14 @@ export default class HasteMap extends EventEmitter {
     if (this._changeInterval) {
       clearInterval(this._changeInterval);
     }
+    if (this._healthCheckInterval) {
+      clearInterval(this._healthCheckInterval);
+    }
 
-    if (!this._watchers.length) {
+    if (!this._watcher) {
       return;
     }
-
-    await Promise.all(this._watchers.map(watcher => watcher.close()));
-
-    this._watchers = [];
+    await this._watcher.close();
     this._crawlerAbortController.abort();
   }