metro-file-map 0.71.3 → 0.72.2

package/package.json

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

package/src/HasteFS.js

@@ -9,6 +9,8 @@ var _constants = _interopRequireDefault(require("./constants"));
 
 var fastPath = _interopRequireWildcard(require("./lib/fast_path"));
 
+var path = _interopRequireWildcard(require("path"));
+
 var _jestUtil = require("jest-util");
 
 function _getRequireWildcardCache(nodeInterop) {
@@ -66,7 +68,6 @@ function _interopRequireDefault(obj) {
  * @format
  *
  */
-// $FlowFixMe[untyped-import] - jest-util
 class HasteFS {
   constructor({ rootDir, files }) {
     this._rootDir = rootDir;
@@ -141,6 +142,42 @@ class HasteFS {
 
     return files;
   }
+  /**
+   * 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, context) {
+    const files = [];
+    const prefix = "./";
+
+    for (const file of this.getAbsoluteFileIterator()) {
+      const filePath = fastPath.relative(root, file);
+      const isUnderRoot = filePath && !filePath.startsWith(".."); // Ignore everything outside of the provided `root`.
+
+      if (!isUnderRoot) {
+        continue;
+      } // Prevent searching in child directories during a non-recursive search.
+
+      if (!context.recursive && filePath.includes(path.sep)) {
+        continue;
+      }
+
+      if (
+        context.filter.test(
+          // NOTE(EvanBacon): Ensure files start with `./` for matching purposes
+          // this ensures packages work across Metro and Webpack (ex: Storybook for React DOM / React Native).
+          // `a/b.js` -> `./a/b.js`
+          prefix + filePath.replace(/\\/g, "/")
+        )
+      ) {
+        files.push(file);
+      }
+    }
+
+    return files;
+  }
 
   matchFilesWithGlob(globs, root) {
     const files = new Set();

package/src/HasteFS.js.flow

@@ -8,16 +8,13 @@
  * @flow strict-local
  */
 
-import type {FileData, Path} from './flow-types';
+import type {FileData, FileMetaData, Glob, Path} from './flow-types';
 
 import H from './constants';
 import * as fastPath from './lib/fast_path';
-// $FlowFixMe[untyped-import] - jest-util
+import * as path from 'path';
 import {globsToMatcher, replacePathSepForGlob} from 'jest-util';
 
-// $FlowFixMe[unclear-type] - Check TS Config.Glob
-type Glob = any;
-
 export default class HasteFS {
   +_rootDir: Path;
   +_files: FileData;
@@ -84,6 +81,52 @@ export default class HasteFS {
     return files;
   }
 
+  /**
+   * 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,
+    }>,
+  ): Array<Path> {
+    const files = [];
+    const prefix = './';
+
+    for (const file of this.getAbsoluteFileIterator()) {
+      const filePath = fastPath.relative(root, file);
+
+      const isUnderRoot = filePath && !filePath.startsWith('..');
+      // Ignore everything outside of the provided `root`.
+      if (!isUnderRoot) {
+        continue;
+      }
+
+      // Prevent searching in child directories during a non-recursive search.
+      if (!context.recursive && filePath.includes(path.sep)) {
+        continue;
+      }
+
+      if (
+        context.filter.test(
+          // NOTE(EvanBacon): Ensure files start with `./` for matching purposes
+          // this ensures packages work across Metro and Webpack (ex: Storybook for React DOM / React Native).
+          // `a/b.js` -> `./a/b.js`
+          prefix + filePath.replace(/\\/g, '/'),
+        )
+      ) {
+        files.push(file);
+      }
+    }
+
+    return files;
+  }
+
   matchFilesWithGlob(globs: $ReadOnlyArray<Glob>, root: ?Path): Set<Path> {
     const files = new Set<string>();
     const matcher = globsToMatcher(globs);
@@ -97,7 +140,7 @@ export default class HasteFS {
     return files;
   }
 
-  _getFileData(file: Path) {
+  _getFileData(file: Path): void | FileMetaData {
     const relativePath = fastPath.relative(this._rootDir, file);
     return this._files.get(relativePath);
   }

package/src/ModuleMap.js.flow

@@ -184,7 +184,7 @@ export default class ModuleMap implements IModuleMap<SerializableModuleMap> {
     platform: string,
     supportsNativePlatform: boolean,
     relativePathSet: ?DuplicatesSet,
-  ) {
+  ): void {
     if (relativePathSet == null) {
       return;
     }

package/src/cache/DiskCacheManager.js

@@ -30,7 +30,6 @@ function _interopRequireDefault(obj) {
  *
  * @format
  */
-// $FlowFixMe[missing-export] - serialize and deserialize missing typedefs
 const DEFAULT_PREFIX = "metro-file-map";
 const DEFAULT_DIRECTORY = (0, _os.tmpdir)();
 

package/src/cache/DiskCacheManager.js.flow

@@ -19,7 +19,6 @@ import rootRelativeCacheKeys from '../lib/rootRelativeCacheKeys';
 import {readFileSync, writeFileSync} from 'graceful-fs';
 import {tmpdir} from 'os';
 import path from 'path';
-// $FlowFixMe[missing-export] - serialize and deserialize missing typedefs
 import {deserialize, serialize} from 'v8';
 
 type DiskCacheConfig = {

package/src/crawlers/watchman.js

@@ -91,8 +91,12 @@ async function capabilityCheck(client, caps) {
       // @ts-expect-error: incorrectly typed
       caps,
       (error, response) => {
-        if (error) {
-          reject(error);
+        if (error != null || response == null) {
+          reject(
+            error !== null && error !== void 0
+              ? error
+              : new Error("capabilityCheck: Response missing")
+          );
         } else {
           resolve(response);
         }
@@ -279,7 +283,7 @@ module.exports = async function watchmanCrawl(options) {
            * directories. Therefore `glob` < `suffix`.
            */
 
-          let queryGenerator = undefined;
+          let queryGenerator;
 
           if (since != null) {
             // Use the `since` generator and filter by both path and extension.
@@ -352,6 +356,7 @@ module.exports = async function watchmanCrawl(options) {
   const changedFiles = new Map();
   let results;
   let isFresh = false;
+  let queryError;
 
   try {
     const watchmanRoots = await getWatchmanRoots(roots);
@@ -365,15 +370,56 @@ module.exports = async function watchmanCrawl(options) {
     }
 
     results = watchmanFileResults.results;
-  } finally {
-    client.end();
+  } catch (e) {
+    queryError = e;
   }
 
-  if (clientError) {
+  client.end();
+
+  if (results == null) {
+    var _ref, _queryError;
+
+    if (clientError) {
+      var _clientError$message;
+
+      perfLogger === null || perfLogger === void 0
+        ? void 0
+        : perfLogger.annotate({
+            string: {
+              "watchmanCrawl/client_error":
+                (_clientError$message = clientError.message) !== null &&
+                _clientError$message !== void 0
+                  ? _clientError$message
+                  : "[message missing]",
+            },
+          });
+    }
+
+    if (queryError) {
+      var _queryError$message;
+
+      perfLogger === null || perfLogger === void 0
+        ? void 0
+        : perfLogger.annotate({
+            string: {
+              "watchmanCrawl/query_error":
+                (_queryError$message = queryError.message) !== null &&
+                _queryError$message !== void 0
+                  ? _queryError$message
+                  : "[message missing]",
+            },
+          });
+    }
+
     perfLogger === null || perfLogger === void 0
       ? void 0
       : perfLogger.point("watchmanCrawl_end");
-    throw clientError;
+    throw (_ref =
+      (_queryError = queryError) !== null && _queryError !== void 0
+        ? _queryError
+        : clientError) !== null && _ref !== void 0
+      ? _ref
+      : new Error("Watchman file results missing");
   }
 
   perfLogger === null || perfLogger === void 0

package/src/crawlers/watchman.js.flow

@@ -91,8 +91,8 @@ async function capabilityCheck(
       // @ts-expect-error: incorrectly typed
       caps,
       (error, response) => {
-        if (error) {
-          reject(error);
+        if (error != null || response == null) {
+          reject(error ?? new Error('capabilityCheck: Response missing'));
         } else {
           resolve(response);
         }
@@ -269,11 +269,7 @@ module.exports = async function watchmanCrawl(
            * repo but Haste map projects are focused on a handful of
            * directories. Therefore `glob` < `suffix`.
            */
-          let queryGenerator: ?(
-            | $TEMPORARY$string<'glob'>
-            | $TEMPORARY$string<'since'>
-            | $TEMPORARY$string<'suffix'>
-          ) = undefined;
+          let queryGenerator: ?string;
           if (since != null) {
             // Use the `since` generator and filter by both path and extension.
             query.since = since;
@@ -340,6 +336,7 @@ module.exports = async function watchmanCrawl(
   const changedFiles = new Map();
   let results: Map<string, WatchmanQueryResponse>;
   let isFresh = false;
+  let queryError: ?Error;
   try {
     const watchmanRoots = await getWatchmanRoots(roots);
     const watchmanFileResults = await queryWatchmanForDirs(watchmanRoots);
@@ -353,13 +350,32 @@ module.exports = async function watchmanCrawl(
     }
 
     results = watchmanFileResults.results;
-  } finally {
-    client.end();
+  } catch (e) {
+    queryError = e;
   }
-
-  if (clientError) {
+  client.end();
+
+  if (results == null) {
+    if (clientError) {
+      perfLogger?.annotate({
+        string: {
+          'watchmanCrawl/client_error':
+            clientError.message ?? '[message missing]',
+        },
+      });
+    }
+    if (queryError) {
+      perfLogger?.annotate({
+        string: {
+          'watchmanCrawl/query_error':
+            queryError.message ?? '[message missing]',
+        },
+      });
+    }
     perfLogger?.point('watchmanCrawl_end');
-    throw clientError;
+    throw (
+      queryError ?? clientError ?? new Error('Watchman file results missing')
+    );
   }
 
   perfLogger?.point('watchmanCrawl/processResults_start');

package/src/flow-types.js.flow

@@ -126,6 +126,8 @@ export type FileMetaData = [
   /* sha1 */ ?string,
 ];
 
+export type Glob = string;
+
 export interface IModuleMap<S = SerializableModuleMap> {
   getModule(
     name: string,

package/src/index.js

@@ -144,7 +144,7 @@ exports.DuplicateHasteCandidatesError = DuplicateHasteCandidatesError;
 // This should be bumped whenever a code change to `metro-file-map` itself
 // would cause a change to the cache data structure and/or content (for a given
 // filesystem state and build parameters).
-const CACHE_BREAKER = "1";
+const CACHE_BREAKER = "2";
 const CHANGE_INTERVAL = 30;
 const MAX_WAIT_TIME = 240000;
 const NODE_MODULES = path.sep + "node_modules" + path.sep;
@@ -246,7 +246,7 @@ const canUseWatchman = (() => {
 class HasteMap extends _events.default {
   static create(options) {
     return new HasteMap(options);
-  }
+  } // $FlowFixMe[missing-local-annot]
 
   constructor(options) {
     var _options$dependencyEx, _options$watchmanDefe, _this$_options$perfLo;
@@ -988,7 +988,12 @@ class HasteMap extends _events.default {
     const createWatcher = (root) => {
       const watcher = new WatcherImpl(root, {
         dot: true,
-        glob: extensions.map((extension) => "**/*." + extension),
+        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,
       });

package/src/index.js.flow

@@ -135,7 +135,7 @@ export type {
 // This should be bumped whenever a code change to `metro-file-map` itself
 // would cause a change to the cache data structure and/or content (for a given
 // filesystem state and build parameters).
-const CACHE_BREAKER = '1';
+const CACHE_BREAKER = '2';
 
 const CHANGE_INTERVAL = 30;
 const MAX_WAIT_TIME = 240000;
@@ -245,6 +245,7 @@ export default class HasteMap extends EventEmitter {
     return new HasteMap(options);
   }
 
+  // $FlowFixMe[missing-local-annot]
   constructor(options: InputOptions) {
     if (options.perfLogger) {
       options.perfLogger?.point('constructor_start');
@@ -778,7 +779,14 @@ export default class HasteMap extends EventEmitter {
     return this._worker;
   }
 
-  _crawl(hasteMap: InternalData) {
+  _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);
@@ -867,7 +875,12 @@ export default class HasteMap extends EventEmitter {
     const createWatcher = (root: Path): Promise<Watcher> => {
       const watcher = new WatcherImpl(root, {
         dot: true,
-        glob: extensions.map(extension => '**/*.' + extension),
+        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,
       });

package/src/watchers/FSEventsWatcher.js

@@ -123,7 +123,10 @@ class FSEventsWatcher extends _events.default {
       });
   }
 
-  constructor(dir, opts) {
+  constructor(
+    dir,
+    opts // $FlowFixMe[missing-local-annot]
+  ) {
     if (!fsevents) {
       throw new Error(
         "`fsevents` unavailable (this watcher can only be used on Darwin)"

package/src/watchers/FSEventsWatcher.js.flow

@@ -61,7 +61,8 @@ export default class FSEventsWatcher extends EventEmitter {
 
   static _normalizeProxy(
     callback: (normalizedPath: string, stats: fs.Stats) => void,
-  ) {
+    // $FlowFixMe[cannot-resolve-name]
+  ): (filepath: string, stats: Stats) => void {
     return (filepath: string, stats: fs.Stats): void =>
       callback(path.normalize(filepath), stats);
   }
@@ -96,6 +97,7 @@ export default class FSEventsWatcher extends EventEmitter {
       dot: boolean,
       ...
     }>,
+    // $FlowFixMe[missing-local-annot]
   ) {
     if (!fsevents) {
       throw new Error(
@@ -149,7 +151,7 @@ export default class FSEventsWatcher extends EventEmitter {
     }
   }
 
-  _isFileIncluded(relativePath: string) {
+  _isFileIncluded(relativePath: string): boolean {
     if (this.doIgnore(relativePath)) {
       return false;
     }