metro-file-map 0.73.3 → 0.73.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro-file-map",
-  "version": "0.73.3",
+  "version": "0.73.4",
   "description": "[Experimental] - 🚇 File crawling, watching and mapping for Metro",
   "main": "src/index.js",
   "repository": {

package/src/HasteFS.js.flow

@@ -8,14 +8,20 @@
  * @flow strict-local
  */
 
-import type {FileData, FileMetaData, Glob, Path} from './flow-types';
+import type {
+  FileData,
+  FileMetaData,
+  FileSystem,
+  Glob,
+  Path,
+} from './flow-types';
 
 import H from './constants';
 import * as fastPath from './lib/fast_path';
 import * as path from 'path';
 import {globsToMatcher, replacePathSepForGlob} from 'jest-util';
 
-export default class HasteFS {
+export default class HasteFS implements FileSystem {
   +_rootDir: Path;
   +_files: FileData;
 

package/src/ModuleMap.js

@@ -7,6 +7,8 @@ exports.default = void 0;
 
 var _constants = _interopRequireDefault(require("./constants"));
 
+var _DuplicateHasteCandidatesError = require("./lib/DuplicateHasteCandidatesError");
+
 var fastPath = _interopRequireWildcard(require("./lib/fast_path"));
 
 function _getRequireWildcardCache(nodeInterop) {
@@ -69,32 +71,6 @@ const EMPTY_OBJ = {};
 const EMPTY_MAP = new Map();
 
 class ModuleMap {
-  // $FlowFixMe[unclear-type] - Refactor away this function
-  static _mapToArrayRecursive(map) {
-    let arr = Array.from(map);
-
-    if (arr[0] && arr[0][1] instanceof Map) {
-      arr = arr.map(
-        // $FlowFixMe[unclear-type] - Refactor away this function
-        (el) => [el[0], this._mapToArrayRecursive(el[1])]
-      );
-    }
-
-    return arr;
-  }
-
-  static _mapFromArrayRecursive(arr) { // $FlowFixMe[unclear-type] - Refactor away this function
-    if (arr[0] && Array.isArray(arr[1])) {
-      // $FlowFixMe[reassign-const] - Refactor away this function
-      arr = arr.map((el) => [
-        el[0], // $FlowFixMe[unclear-type] - Refactor away this function
-        this._mapFromArrayRecursive(el[1]), // $FlowFixMe[unclear-type] - Refactor away this function
-      ]);
-    }
-
-    return new Map(arr);
-  }
-
   constructor(raw) {
     this._raw = raw;
   }
@@ -129,7 +105,8 @@ class ModuleMap {
     return mockPath != null
       ? fastPath.resolve(this._raw.rootDir, mockPath)
       : null;
-  }
+  } // FIXME: This is only used by Meta-internal validation and should be
+  // removed or replaced with a less leaky API.
 
   getRawModuleMap() {
     return {
@@ -139,30 +116,6 @@ class ModuleMap {
       rootDir: this._raw.rootDir,
     };
   }
-
-  toJSON() {
-    if (!this._json) {
-      this._json = {
-        duplicates: ModuleMap._mapToArrayRecursive(this._raw.duplicates),
-        map: Array.from(this._raw.map),
-        mocks: Array.from(this._raw.mocks),
-        rootDir: this._raw.rootDir,
-      };
-    }
-
-    return this._json;
-  }
-
-  static fromJSON(serializableModuleMap) {
-    return new ModuleMap({
-      duplicates: ModuleMap._mapFromArrayRecursive(
-        serializableModuleMap.duplicates
-      ),
-      map: new Map(serializableModuleMap.map),
-      mocks: new Map(serializableModuleMap.mocks),
-      rootDir: serializableModuleMap.rootDir,
-    });
-  }
   /**
    * When looking up a module's data, we walk through each eligible platform for
    * the query. For each platform, we want to check if there are known
@@ -229,7 +182,7 @@ class ModuleMap {
       duplicates.set(duplicatePath, type);
     }
 
-    throw new DuplicateHasteCandidatesError(
+    throw new _DuplicateHasteCandidatesError.DuplicateHasteCandidatesError(
       name,
       platform,
       supportsNativePlatform,
@@ -248,49 +201,3 @@ class ModuleMap {
 }
 
 exports.default = ModuleMap;
-
-class DuplicateHasteCandidatesError extends Error {
-  constructor(name, platform, supportsNativePlatform, duplicatesSet) {
-    const platformMessage = getPlatformMessage(platform);
-    super(
-      `The name \`${name}\` was looked up in the Haste module map. It ` +
-        "cannot be resolved, because there exists several different " +
-        "files, or packages, that provide a module for " +
-        `that particular name and platform. ${platformMessage} You must ` +
-        "delete or exclude files until there remains only one of these:\n\n" +
-        Array.from(duplicatesSet)
-          .map(
-            ([dupFilePath, dupFileType]) =>
-              `  * \`${dupFilePath}\` (${getTypeMessage(dupFileType)})\n`
-          )
-          .sort()
-          .join("")
-    );
-    this.hasteName = name;
-    this.platform = platform;
-    this.supportsNativePlatform = supportsNativePlatform;
-    this.duplicatesSet = duplicatesSet;
-  }
-}
-
-function getPlatformMessage(platform) {
-  if (platform === _constants.default.GENERIC_PLATFORM) {
-    return "The platform is generic (no extension).";
-  }
-
-  return `The platform extension is \`${platform}\`.`;
-}
-
-function getTypeMessage(type) {
-  switch (type) {
-    case _constants.default.MODULE:
-      return "module";
-
-    case _constants.default.PACKAGE:
-      return "package";
-  }
-
-  return "unknown";
-}
-
-ModuleMap.DuplicateHasteCandidatesError = DuplicateHasteCandidatesError;

package/src/ModuleMap.js.flow

@@ -16,48 +16,17 @@ import type {
   ModuleMetaData,
   Path,
   RawModuleMap,
-  SerializableModuleMap,
 } from './flow-types';
 
 import H from './constants';
+import {DuplicateHasteCandidatesError} from './lib/DuplicateHasteCandidatesError';
 import * as fastPath from './lib/fast_path';
 
 const EMPTY_OBJ: {[string]: ModuleMetaData} = {};
 const EMPTY_MAP = new Map<'g' | 'native' | string, ?DuplicatesSet>();
 
-export default class ModuleMap implements IModuleMap<SerializableModuleMap> {
-  static DuplicateHasteCandidatesError: Class<DuplicateHasteCandidatesError>;
+export default class ModuleMap implements IModuleMap {
   +_raw: RawModuleMap;
-  _json: ?SerializableModuleMap;
-
-  // $FlowFixMe[unclear-type] - Refactor away this function
-  static _mapToArrayRecursive(map: Map<string, any>): Array<[string, any]> {
-    let arr = Array.from(map);
-    if (arr[0] && arr[0][1] instanceof Map) {
-      arr = arr.map(
-        // $FlowFixMe[unclear-type] - Refactor away this function
-        el => ([el[0], this._mapToArrayRecursive(el[1])]: [string, any]),
-      );
-    }
-    return arr;
-  }
-
-  static _mapFromArrayRecursive(
-    // $FlowFixMe[unclear-type] - Refactor away this function
-    arr: $ReadOnlyArray<[string, any]>,
-    // $FlowFixMe[unclear-type] - Refactor away this function
-  ): Map<string, any> {
-    if (arr[0] && Array.isArray(arr[1])) {
-      // $FlowFixMe[reassign-const] - Refactor away this function
-      arr = (arr.map(el => [
-        el[0],
-        // $FlowFixMe[unclear-type] - Refactor away this function
-        this._mapFromArrayRecursive((el[1]: Array<[string, any]>)),
-        // $FlowFixMe[unclear-type] - Refactor away this function
-      ]): Array<[string, any]>);
-    }
-    return new Map(arr);
-  }
 
   constructor(raw: RawModuleMap) {
     this._raw = raw;
@@ -97,6 +66,8 @@ export default class ModuleMap implements IModuleMap<SerializableModuleMap> {
       : null;
   }
 
+  // FIXME: This is only used by Meta-internal validation and should be
+  // removed or replaced with a less leaky API.
   getRawModuleMap(): RawModuleMap {
     return {
       duplicates: this._raw.duplicates,
@@ -106,31 +77,6 @@ export default class ModuleMap implements IModuleMap<SerializableModuleMap> {
     };
   }
 
-  toJSON(): SerializableModuleMap {
-    if (!this._json) {
-      this._json = {
-        duplicates: (ModuleMap._mapToArrayRecursive(
-          this._raw.duplicates,
-        ): SerializableModuleMap['duplicates']),
-        map: Array.from(this._raw.map),
-        mocks: Array.from(this._raw.mocks),
-        rootDir: this._raw.rootDir,
-      };
-    }
-    return this._json;
-  }
-
-  static fromJSON(serializableModuleMap: SerializableModuleMap): ModuleMap {
-    return new ModuleMap({
-      duplicates: (ModuleMap._mapFromArrayRecursive(
-        serializableModuleMap.duplicates,
-      ): RawModuleMap['duplicates']),
-      map: new Map(serializableModuleMap.map),
-      mocks: new Map(serializableModuleMap.mocks),
-      rootDir: serializableModuleMap.rootDir,
-    });
-  }
-
   /**
    * When looking up a module's data, we walk through each eligible platform for
    * the query. For each platform, we want to check if there are known
@@ -215,56 +161,3 @@ export default class ModuleMap implements IModuleMap<SerializableModuleMap> {
     });
   }
 }
-
-class DuplicateHasteCandidatesError extends Error {
-  hasteName: string;
-  platform: string | null;
-  supportsNativePlatform: boolean;
-  duplicatesSet: DuplicatesSet;
-
-  constructor(
-    name: string,
-    platform: string,
-    supportsNativePlatform: boolean,
-    duplicatesSet: DuplicatesSet,
-  ) {
-    const platformMessage = getPlatformMessage(platform);
-    super(
-      `The name \`${name}\` was looked up in the Haste module map. It ` +
-        'cannot be resolved, because there exists several different ' +
-        'files, or packages, that provide a module for ' +
-        `that particular name and platform. ${platformMessage} You must ` +
-        'delete or exclude files until there remains only one of these:\n\n' +
-        Array.from(duplicatesSet)
-          .map(
-            ([dupFilePath, dupFileType]) =>
-              `  * \`${dupFilePath}\` (${getTypeMessage(dupFileType)})\n`,
-          )
-          .sort()
-          .join(''),
-    );
-    this.hasteName = name;
-    this.platform = platform;
-    this.supportsNativePlatform = supportsNativePlatform;
-    this.duplicatesSet = duplicatesSet;
-  }
-}
-
-function getPlatformMessage(platform: string) {
-  if (platform === H.GENERIC_PLATFORM) {
-    return 'The platform is generic (no extension).';
-  }
-  return `The platform extension is \`${platform}\`.`;
-}
-
-function getTypeMessage(type: number) {
-  switch (type) {
-    case H.MODULE:
-      return 'module';
-    case H.PACKAGE:
-      return 'package';
-  }
-  return 'unknown';
-}
-
-ModuleMap.DuplicateHasteCandidatesError = DuplicateHasteCandidatesError;

package/src/Watcher.js

@@ -25,6 +25,8 @@ var fs = _interopRequireWildcard(require("fs"));
 
 var _common = require("./watchers/common");
 
+var _events = _interopRequireDefault(require("events"));
+
 var _perf_hooks = require("perf_hooks");
 
 var _nullthrows = _interopRequireDefault(require("nullthrows"));
@@ -90,12 +92,13 @@ const debug = require("debug")("Metro:Watcher");
 const MAX_WAIT_TIME = 240000;
 let nextInstanceId = 0;
 
-class Watcher {
+class Watcher extends _events.default {
   _backends = [];
   _nextHealthCheckId = 0;
   _pendingHealthChecks = new Map();
 
   constructor(options) {
+    super();
     this._options = options;
     this._instanceId = nextInstanceId++;
   }
@@ -114,21 +117,26 @@ class Watcher {
       path.basename(filePath).startsWith(this._options.healthCheckFilePrefix);
 
     const crawl = options.useWatchman ? _watchman.default : _node.default;
+    let crawler = crawl === _watchman.default ? "watchman" : "node";
     const crawlerOptions = {
       abortSignal: options.abortSignal,
       computeSha1: options.computeSha1,
-      data: options.initialData,
       enableSymlinks: options.enableSymlinks,
       extensions: options.extensions,
       forceNodeFilesystemAPI: options.forceNodeFilesystemAPI,
       ignore,
+      onStatus: (status) => {
+        this.emit("status", status);
+      },
       perfLogger: options.perfLogger,
+      previousState: options.previousState,
       rootDir: options.rootDir,
       roots: options.roots,
     };
 
     const retry = (error) => {
       if (crawl === _watchman.default) {
+        crawler = "node";
         options.console.warn(
           "metro-file-map: Watchman crawl failed. Retrying once with node " +
             "crawler.\n" +
@@ -150,16 +158,30 @@ class Watcher {
       throw error;
     };
 
-    const logEnd = (result) => {
-      var _this$_options$perfLo2;
-
+    const logEnd = (delta) => {
+      var _delta$clocks$size, _delta$clocks, _this$_options$perfLo2;
+
+      debug(
+        'Crawler "%s" returned %d added/modified, %d removed, %d clock(s).',
+        crawler,
+        delta.changedFiles.size,
+        delta.removedFiles.size,
+        (_delta$clocks$size =
+          (_delta$clocks = delta.clocks) === null || _delta$clocks === void 0
+            ? void 0
+            : _delta$clocks.size) !== null && _delta$clocks$size !== void 0
+          ? _delta$clocks$size
+          : 0
+      );
       (_this$_options$perfLo2 = this._options.perfLogger) === null ||
       _this$_options$perfLo2 === void 0
         ? void 0
         : _this$_options$perfLo2.point("crawl_end");
-      return result;
+      return delta;
     };
 
+    debug('Beginning crawl with "%s".', crawler);
+
     try {
       return crawl(crawlerOptions).catch(retry).then(logEnd);
     } catch (error) {

package/src/Watcher.js.flow

@@ -12,9 +12,9 @@ import type {
   Console,
   CrawlerOptions,
   FileData,
-  InternalData,
   Path,
   PerfLogger,
+  WatchmanClocks,
 } from './flow-types';
 import type {WatcherOptions as WatcherBackendOptions} from './watchers/common';
 import type {Stats} from 'fs';
@@ -28,6 +28,7 @@ import NodeWatcher from './watchers/NodeWatcher';
 import * as path from 'path';
 import * as fs from 'fs';
 import {ADD_EVENT, CHANGE_EVENT} from './watchers/common';
+import EventEmitter from 'events';
 import {performance} from 'perf_hooks';
 import nullthrows from 'nullthrows';
 
@@ -35,6 +36,12 @@ const debug = require('debug')('Metro:Watcher');
 
 const MAX_WAIT_TIME = 240000;
 
+type CrawlResult = {
+  changedFiles: FileData,
+  clocks?: WatchmanClocks,
+  removedFiles: FileData,
+};
+
 type WatcherOptions = {
   abortSignal: AbortSignal,
   computeSha1: boolean,
@@ -45,7 +52,7 @@ type WatcherOptions = {
   healthCheckFilePrefix: string,
   ignore: string => boolean,
   ignorePattern: RegExp,
-  initialData: InternalData,
+  previousState: CrawlerOptions['previousState'],
   perfLogger: ?PerfLogger,
   roots: $ReadOnlyArray<string>,
   rootDir: string,
@@ -66,7 +73,7 @@ export type HealthCheckResult =
   | {type: 'success', timeout: number, timeElapsed: number, watcher: ?string}
   | {type: 'timeout', timeout: number, watcher: ?string, pauseReason: ?string};
 
-export class Watcher {
+export class Watcher extends EventEmitter {
   _options: WatcherOptions;
   _backends: $ReadOnlyArray<WatcherBackend> = [];
   _instanceId: number;
@@ -76,18 +83,12 @@ export class Watcher {
   _activeWatcher: ?string;
 
   constructor(options: WatcherOptions) {
+    super();
     this._options = options;
     this._instanceId = nextInstanceId++;
   }
 
-  async crawl(): Promise<?(
-    | Promise<{
-        changedFiles?: FileData,
-        hasteMap: InternalData,
-        removedFiles: FileData,
-      }>
-    | {changedFiles?: FileData, hasteMap: InternalData, removedFiles: FileData}
-  )> {
+  async crawl(): Promise<CrawlResult> {
     this._options.perfLogger?.point('crawl_start');
 
     const options = this._options;
@@ -95,21 +96,26 @@ export class Watcher {
       options.ignore(filePath) ||
       path.basename(filePath).startsWith(this._options.healthCheckFilePrefix);
     const crawl = options.useWatchman ? watchmanCrawl : nodeCrawl;
+    let crawler = crawl === watchmanCrawl ? 'watchman' : 'node';
     const crawlerOptions: CrawlerOptions = {
       abortSignal: options.abortSignal,
       computeSha1: options.computeSha1,
-      data: options.initialData,
       enableSymlinks: options.enableSymlinks,
       extensions: options.extensions,
       forceNodeFilesystemAPI: options.forceNodeFilesystemAPI,
       ignore,
+      onStatus: status => {
+        this.emit('status', status);
+      },
       perfLogger: options.perfLogger,
+      previousState: options.previousState,
       rootDir: options.rootDir,
       roots: options.roots,
     };
 
     const retry = (error: Error) => {
       if (crawl === watchmanCrawl) {
+        crawler = 'node';
         options.console.warn(
           'metro-file-map: Watchman crawl failed. Retrying once with node ' +
             'crawler.\n' +
@@ -131,11 +137,19 @@ export class Watcher {
       throw error;
     };
 
-    const logEnd = <T>(result: T): T => {
+    const logEnd = (delta: CrawlResult): CrawlResult => {
+      debug(
+        'Crawler "%s" returned %d added/modified, %d removed, %d clock(s).',
+        crawler,
+        delta.changedFiles.size,
+        delta.removedFiles.size,
+        delta.clocks?.size ?? 0,
+      );
       this._options.perfLogger?.point('crawl_end');
-      return result;
+      return delta;
     };
 
+    debug('Beginning crawl with "%s".', crawler);
     try {
       return crawl(crawlerOptions).catch(retry).then(logEnd);
     } catch (error) {

package/src/crawlers/node.js

@@ -246,7 +246,7 @@ function findNative(roots, extensions, ignore, enableSymlinks, callback) {
 
 module.exports = async function nodeCrawl(options) {
   const {
-    data,
+    previousState,
     extensions,
     forceNodeFilesystemAPI,
     ignore,
@@ -261,28 +261,29 @@ module.exports = async function nodeCrawl(options) {
   const useNativeFind = await hasNativeFindSupport(forceNodeFilesystemAPI);
   return new Promise((resolve) => {
     const callback = (list) => {
-      const files = new Map();
-      const removedFiles = new Map(data.files);
-      list.forEach((fileData) => {
+      const changedFiles = new Map();
+      const removedFiles = new Map(previousState.files);
+
+      for (const fileData of list) {
         const [filePath, mtime, size] = fileData;
         const relativeFilePath = fastPath.relative(rootDir, filePath);
-        const existingFile = data.files.get(relativeFilePath);
+        const existingFile = previousState.files.get(relativeFilePath);
+        removedFiles.delete(relativeFilePath);
 
-        if (existingFile && existingFile[_constants.default.MTIME] === mtime) {
-          files.set(relativeFilePath, existingFile);
-        } else {
+        if (
+          existingFile == null ||
+          existingFile[_constants.default.MTIME] !== mtime
+        ) {
           // See ../constants.js; SHA-1 will always be null and fulfilled later.
-          files.set(relativeFilePath, ["", mtime, size, 0, "", null]);
+          changedFiles.set(relativeFilePath, ["", mtime, size, 0, "", null]);
         }
+      }
 
-        removedFiles.delete(relativeFilePath);
-      });
-      data.files = files;
       perfLogger === null || perfLogger === void 0
         ? void 0
         : perfLogger.point("nodeCrawl_end");
       resolve({
-        hasteMap: data,
+        changedFiles,
         removedFiles,
       });
     };

package/src/crawlers/node.js.flow

@@ -10,12 +10,7 @@
  */
 
 import type {Path, FileMetaData} from '../flow-types';
-import type {
-  CrawlerOptions,
-  FileData,
-  IgnoreMatcher,
-  InternalData,
-} from '../flow-types';
+import type {CrawlerOptions, FileData, IgnoreMatcher} from '../flow-types';
 
 import H from '../constants';
 import * as fastPath from '../lib/fast_path';
@@ -208,10 +203,10 @@ function findNative(
 
 module.exports = async function nodeCrawl(options: CrawlerOptions): Promise<{
   removedFiles: FileData,
-  hasteMap: InternalData,
+  changedFiles: FileData,
 }> {
   const {
-    data,
+    previousState,
     extensions,
     forceNodeFilesystemAPI,
     ignore,
@@ -225,25 +220,22 @@ module.exports = async function nodeCrawl(options: CrawlerOptions): Promise<{
 
   return new Promise(resolve => {
     const callback = (list: Result) => {
-      const files = new Map<Path, FileMetaData>();
-      const removedFiles = new Map(data.files);
-      list.forEach(fileData => {
+      const changedFiles = new Map<Path, FileMetaData>();
+      const removedFiles = new Map(previousState.files);
+      for (const fileData of list) {
         const [filePath, mtime, size] = fileData;
         const relativeFilePath = fastPath.relative(rootDir, filePath);
-        const existingFile = data.files.get(relativeFilePath);
-        if (existingFile && existingFile[H.MTIME] === mtime) {
-          files.set(relativeFilePath, existingFile);
-        } else {
+        const existingFile = previousState.files.get(relativeFilePath);
+        removedFiles.delete(relativeFilePath);
+        if (existingFile == null || existingFile[H.MTIME] !== mtime) {
           // See ../constants.js; SHA-1 will always be null and fulfilled later.
-          files.set(relativeFilePath, ['', mtime, size, 0, '', null]);
+          changedFiles.set(relativeFilePath, ['', mtime, size, 0, '', null]);
         }
-        removedFiles.delete(relativeFilePath);
-      });
-      data.files = files;
+      }
 
       perfLogger?.point('nodeCrawl_end');
       resolve({
-        hasteMap: data,
+        changedFiles,
         removedFiles,
       });
     };