metro-file-map 0.73.1 → 0.73.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro-file-map",
-  "version": "0.73.1",
+  "version": "0.73.3",
   "description": "[Experimental] - 🚇 File crawling, watching and mapping for Metro",
   "main": "src/index.js",
   "repository": {
@@ -24,6 +24,7 @@
     "jest-util": "^27.2.0",
     "jest-worker": "^27.2.0",
     "micromatch": "^4.0.4",
+    "nullthrows": "^1.1.1",
     "walker": "^1.0.7"
   },
   "devDependencies": {

package/src/ModuleMap.js.flow

@@ -23,7 +23,7 @@ import H from './constants';
 import * as fastPath from './lib/fast_path';
 
 const EMPTY_OBJ: {[string]: ModuleMetaData} = {};
-const EMPTY_MAP = new Map();
+const EMPTY_MAP = new Map<'g' | 'native' | string, ?DuplicatesSet>();
 
 export default class ModuleMap implements IModuleMap<SerializableModuleMap> {
   static DuplicateHasteCandidatesError: Class<DuplicateHasteCandidatesError>;
@@ -191,7 +191,7 @@ export default class ModuleMap implements IModuleMap<SerializableModuleMap> {
     }
     // Force flow refinement
     const previousSet = relativePathSet;
-    const duplicates = new Map();
+    const duplicates = new Map<string, number>();
 
     for (const [relativePath, type] of previousSet) {
       const duplicatePath = fastPath.resolve(this._raw.rootDir, relativePath);

package/src/Watcher.js

@@ -0,0 +1,344 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.Watcher = void 0;
+
+var _watchman = _interopRequireDefault(require("./crawlers/watchman"));
+
+var _node = _interopRequireDefault(require("./crawlers/node"));
+
+var _WatchmanWatcher = _interopRequireDefault(
+  require("./watchers/WatchmanWatcher")
+);
+
+var _FSEventsWatcher = _interopRequireDefault(
+  require("./watchers/FSEventsWatcher")
+);
+
+var _NodeWatcher = _interopRequireDefault(require("./watchers/NodeWatcher"));
+
+var path = _interopRequireWildcard(require("path"));
+
+var fs = _interopRequireWildcard(require("fs"));
+
+var _common = require("./watchers/common");
+
+var _perf_hooks = require("perf_hooks");
+
+var _nullthrows = _interopRequireDefault(require("nullthrows"));
+
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function") return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== "object" && typeof obj !== "function")) {
+    return { default: obj };
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+
+/**
+ * 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
+ *
+ */
+// $FlowFixMe[untyped-import] - it's a fork: https://github.com/facebook/jest/pull/10919
+const debug = require("debug")("Metro:Watcher");
+
+const MAX_WAIT_TIME = 240000;
+let nextInstanceId = 0;
+
+class Watcher {
+  _backends = [];
+  _nextHealthCheckId = 0;
+  _pendingHealthChecks = new Map();
+
+  constructor(options) {
+    this._options = options;
+    this._instanceId = nextInstanceId++;
+  }
+
+  async crawl() {
+    var _this$_options$perfLo;
+
+    (_this$_options$perfLo = this._options.perfLogger) === null ||
+    _this$_options$perfLo === void 0
+      ? void 0
+      : _this$_options$perfLo.point("crawl_start");
+    const options = this._options;
+
+    const ignore = (filePath) =>
+      options.ignore(filePath) ||
+      path.basename(filePath).startsWith(this._options.healthCheckFilePrefix);
+
+    const crawl = options.useWatchman ? _watchman.default : _node.default;
+    const crawlerOptions = {
+      abortSignal: options.abortSignal,
+      computeSha1: options.computeSha1,
+      data: options.initialData,
+      enableSymlinks: options.enableSymlinks,
+      extensions: options.extensions,
+      forceNodeFilesystemAPI: options.forceNodeFilesystemAPI,
+      ignore,
+      perfLogger: options.perfLogger,
+      rootDir: options.rootDir,
+      roots: options.roots,
+    };
+
+    const retry = (error) => {
+      if (crawl === _watchman.default) {
+        options.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 (0, _node.default)(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$perfLo2;
+
+      (_this$_options$perfLo2 = this._options.perfLogger) === null ||
+      _this$_options$perfLo2 === void 0
+        ? void 0
+        : _this$_options$perfLo2.point("crawl_end");
+      return result;
+    };
+
+    try {
+      return crawl(crawlerOptions).catch(retry).then(logEnd);
+    } catch (error) {
+      return retry(error).then(logEnd);
+    }
+  }
+
+  async watch(onChange) {
+    var _this$_options$perfLo3;
+
+    const { extensions, ignorePattern, useWatchman } = this._options; // WatchmanWatcher > FSEventsWatcher > sane.NodeWatcher
+
+    const WatcherImpl = useWatchman
+      ? _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$perfLo3 = this._options.perfLogger) === null ||
+    _this$_options$perfLo3 === void 0
+      ? void 0
+      : _this$_options$perfLo3.annotate({
+          string: {
+            watcher,
+          },
+        });
+    this._activeWatcher = watcher;
+
+    const createWatcherBackend = (root) => {
+      const watcherOptions = {
+        dot: true,
+        glob: [
+          // Ensure we always include package.json files, which are crucial for
+          /// module resolution.
+          "**/package.json", // Ensure we always watch any health check files
+          "**/" + this._options.healthCheckFilePrefix + "*",
+          ...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", (type, filePath, root, stat) => {
+            const basename = path.basename(filePath);
+
+            if (basename.startsWith(this._options.healthCheckFilePrefix)) {
+              if (type === _common.ADD_EVENT || type === _common.CHANGE_EVENT) {
+                debug(
+                  "Observed possible health check cookie: %s in %s",
+                  filePath,
+                  root
+                );
+
+                this._handleHealthCheckObservation(basename);
+              }
+
+              return;
+            }
+
+            onChange(type, filePath, root, stat);
+          });
+          resolve(watcher);
+        });
+      });
+    };
+
+    this._backends = await Promise.all(
+      this._options.roots.map(createWatcherBackend)
+    );
+  }
+
+  _handleHealthCheckObservation(basename) {
+    const resolveHealthCheck = this._pendingHealthChecks.get(basename);
+
+    if (!resolveHealthCheck) {
+      return;
+    }
+
+    resolveHealthCheck();
+  }
+
+  async close() {
+    await Promise.all(this._backends.map((watcher) => watcher.close()));
+    this._activeWatcher = null;
+  }
+
+  async checkHealth(timeout) {
+    const healthCheckId = this._nextHealthCheckId++;
+
+    if (healthCheckId === Number.MAX_SAFE_INTEGER) {
+      this._nextHealthCheckId = 0;
+    }
+
+    const watcher = this._activeWatcher;
+    const basename =
+      this._options.healthCheckFilePrefix +
+      "-" +
+      process.pid +
+      "-" +
+      this._instanceId +
+      "-" +
+      healthCheckId;
+    const healthCheckPath = path.join(this._options.rootDir, basename);
+    let result;
+    const timeoutPromise = new Promise((resolve) =>
+      setTimeout(resolve, timeout)
+    ).then(() => {
+      if (!result) {
+        var _this$_backends$;
+
+        result = {
+          type: "timeout",
+          pauseReason:
+            (_this$_backends$ = this._backends[0]) === null ||
+            _this$_backends$ === void 0
+              ? void 0
+              : _this$_backends$.getPauseReason(),
+          timeout,
+          watcher,
+        };
+      }
+    });
+
+    const startTime = _perf_hooks.performance.now();
+
+    debug("Creating health check cookie: %s", healthCheckPath);
+    const creationPromise = fs.promises
+      .writeFile(healthCheckPath, String(startTime))
+      .catch((error) => {
+        if (!result) {
+          result = {
+            type: "error",
+            error,
+            timeout,
+            watcher,
+          };
+        }
+      });
+    const observationPromise = new Promise((resolve) => {
+      this._pendingHealthChecks.set(basename, resolve);
+    }).then(() => {
+      if (!result) {
+        result = {
+          type: "success",
+          timeElapsed: _perf_hooks.performance.now() - startTime,
+          timeout,
+          watcher,
+        };
+      }
+    });
+    await Promise.race([
+      timeoutPromise,
+      creationPromise.then(() => observationPromise),
+    ]);
+
+    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.
+
+    creationPromise.then(() =>
+      fs.promises.unlink(healthCheckPath).catch(() => {})
+    );
+    debug("Health check result: %o", result);
+    return (0, _nullthrows.default)(result);
+  }
+}
+
+exports.Watcher = Watcher;

package/src/Watcher.js.flow

@@ -0,0 +1,305 @@
+/**
+ * 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
+ * @flow strict-local
+ */
+
+import type {
+  Console,
+  CrawlerOptions,
+  FileData,
+  InternalData,
+  Path,
+  PerfLogger,
+} from './flow-types';
+import type {WatcherOptions as WatcherBackendOptions} from './watchers/common';
+import type {Stats} from 'fs';
+
+import watchmanCrawl from './crawlers/watchman';
+import nodeCrawl from './crawlers/node';
+import WatchmanWatcher from './watchers/WatchmanWatcher';
+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 * as path from 'path';
+import * as fs from 'fs';
+import {ADD_EVENT, CHANGE_EVENT} from './watchers/common';
+import {performance} from 'perf_hooks';
+import nullthrows from 'nullthrows';
+
+const debug = require('debug')('Metro:Watcher');
+
+const MAX_WAIT_TIME = 240000;
+
+type WatcherOptions = {
+  abortSignal: AbortSignal,
+  computeSha1: boolean,
+  console: Console,
+  enableSymlinks: boolean,
+  extensions: $ReadOnlyArray<string>,
+  forceNodeFilesystemAPI: boolean,
+  healthCheckFilePrefix: string,
+  ignore: string => boolean,
+  ignorePattern: RegExp,
+  initialData: InternalData,
+  perfLogger: ?PerfLogger,
+  roots: $ReadOnlyArray<string>,
+  rootDir: string,
+  useWatchman: boolean,
+  watch: boolean,
+  watchmanDeferStates: $ReadOnlyArray<string>,
+};
+
+interface WatcherBackend {
+  getPauseReason(): ?string;
+  close(): Promise<void>;
+}
+
+let nextInstanceId = 0;
+
+export type HealthCheckResult =
+  | {type: 'error', timeout: number, error: Error, watcher: ?string}
+  | {type: 'success', timeout: number, timeElapsed: number, watcher: ?string}
+  | {type: 'timeout', timeout: number, watcher: ?string, pauseReason: ?string};
+
+export class Watcher {
+  _options: WatcherOptions;
+  _backends: $ReadOnlyArray<WatcherBackend> = [];
+  _instanceId: number;
+  _nextHealthCheckId: number = 0;
+  _pendingHealthChecks: Map</* basename */ string, /* resolve */ () => void> =
+    new Map();
+  _activeWatcher: ?string;
+
+  constructor(options: WatcherOptions) {
+    this._options = options;
+    this._instanceId = nextInstanceId++;
+  }
+
+  async crawl(): 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) =>
+      options.ignore(filePath) ||
+      path.basename(filePath).startsWith(this._options.healthCheckFilePrefix);
+    const crawl = options.useWatchman ? watchmanCrawl : nodeCrawl;
+    const crawlerOptions: CrawlerOptions = {
+      abortSignal: options.abortSignal,
+      computeSha1: options.computeSha1,
+      data: options.initialData,
+      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) {
+        options.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);
+    }
+  }
+
+  async watch(
+    onChange: (
+      type: string,
+      filePath: string,
+      root: string,
+      stat?: Stats,
+    ) => void,
+  ) {
+    const {extensions, ignorePattern, useWatchman} = this._options;
+
+    // WatchmanWatcher > FSEventsWatcher > sane.NodeWatcher
+    const WatcherImpl = useWatchman
+      ? 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}});
+    this._activeWatcher = watcher;
+
+    const createWatcherBackend = (root: Path): Promise<WatcherBackend> => {
+      const watcherOptions: WatcherBackendOptions = {
+        dot: true,
+        glob: [
+          // Ensure we always include package.json files, which are crucial for
+          /// module resolution.
+          '**/package.json',
+          // Ensure we always watch any health check files
+          '**/' + this._options.healthCheckFilePrefix + '*',
+          ...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',
+            (type: string, filePath: string, root: string, stat?: Stats) => {
+              const basename = path.basename(filePath);
+              if (basename.startsWith(this._options.healthCheckFilePrefix)) {
+                if (type === ADD_EVENT || type === CHANGE_EVENT) {
+                  debug(
+                    'Observed possible health check cookie: %s in %s',
+                    filePath,
+                    root,
+                  );
+                  this._handleHealthCheckObservation(basename);
+                }
+                return;
+              }
+              onChange(type, filePath, root, stat);
+            },
+          );
+          resolve(watcher);
+        });
+      });
+    };
+
+    this._backends = await Promise.all(
+      this._options.roots.map(createWatcherBackend),
+    );
+  }
+
+  _handleHealthCheckObservation(basename: string) {
+    const resolveHealthCheck = this._pendingHealthChecks.get(basename);
+    if (!resolveHealthCheck) {
+      return;
+    }
+    resolveHealthCheck();
+  }
+
+  async close() {
+    await Promise.all(this._backends.map(watcher => watcher.close()));
+    this._activeWatcher = null;
+  }
+
+  async checkHealth(timeout: number): Promise<HealthCheckResult> {
+    const healthCheckId = this._nextHealthCheckId++;
+    if (healthCheckId === Number.MAX_SAFE_INTEGER) {
+      this._nextHealthCheckId = 0;
+    }
+    const watcher = this._activeWatcher;
+    const basename =
+      this._options.healthCheckFilePrefix +
+      '-' +
+      process.pid +
+      '-' +
+      this._instanceId +
+      '-' +
+      healthCheckId;
+    const healthCheckPath = path.join(this._options.rootDir, basename);
+    let result: ?HealthCheckResult;
+    const timeoutPromise = new Promise(resolve =>
+      setTimeout(resolve, timeout),
+    ).then(() => {
+      if (!result) {
+        result = {
+          type: 'timeout',
+          pauseReason: this._backends[0]?.getPauseReason(),
+          timeout,
+          watcher,
+        };
+      }
+    });
+    const startTime = performance.now();
+    debug('Creating health check cookie: %s', healthCheckPath);
+    const creationPromise = fs.promises
+      .writeFile(healthCheckPath, String(startTime))
+      .catch(error => {
+        if (!result) {
+          result = {
+            type: 'error',
+            error,
+            timeout,
+            watcher,
+          };
+        }
+      });
+    const observationPromise = new Promise(resolve => {
+      this._pendingHealthChecks.set(basename, resolve);
+    }).then(() => {
+      if (!result) {
+        result = {
+          type: 'success',
+          timeElapsed: performance.now() - startTime,
+          timeout,
+          watcher,
+        };
+      }
+    });
+    await Promise.race([
+      timeoutPromise,
+      creationPromise.then(() => observationPromise),
+    ]);
+    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.
+    creationPromise.then(() =>
+      fs.promises.unlink(healthCheckPath).catch(() => {}),
+    );
+    debug('Health check result: %o', result);
+    return nullthrows(result);
+  }
+}

package/src/crawlers/node.js.flow

@@ -9,6 +9,7 @@
  * @oncall react_native
  */
 
+import type {Path, FileMetaData} from '../flow-types';
 import type {
   CrawlerOptions,
   FileData,
@@ -224,7 +225,7 @@ module.exports = async function nodeCrawl(options: CrawlerOptions): Promise<{
 
   return new Promise(resolve => {
     const callback = (list: Result) => {
-      const files = new Map();
+      const files = new Map<Path, FileMetaData>();
       const removedFiles = new Map(data.files);
       list.forEach(fileData => {
         const [filePath, mtime, size] = fileData;