metro-file-map 0.84.2 → 0.84.3

package/package.json

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

package/src/Watcher.d.ts

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  *
  * @noformat
- * @generated SignedSource<<7537b04fdc97fb54ebddaebf60605405>>
+ * @generated SignedSource<<25fee66c7d26ad53cdd5bbab454fe50b>>
  *
  * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
  * Original file: packages/metro-file-map/src/Watcher.js
@@ -17,20 +17,13 @@
 import type {
   Console,
   CrawlerOptions,
-  FileData,
-  Path,
+  CrawlResult,
   PerfLogger,
   WatcherBackendChangeEvent,
-  WatchmanClocks,
 } from './flow-types';
 
 import EventEmitter from 'events';
 
-type CrawlResult = {
-  changedFiles: FileData;
-  clocks?: WatchmanClocks;
-  removedFiles: Set<Path>;
-};
 type WatcherOptions = {
   abortSignal: AbortSignal;
   computeSha1: boolean;
@@ -71,6 +64,10 @@ export type HealthCheckResult =
 export declare class Watcher extends EventEmitter {
   constructor(options: WatcherOptions);
   crawl(): Promise<CrawlResult>;
+  recrawl(
+    subpath: string,
+    currentFileSystem: CrawlerOptions['previousState']['fileSystem'],
+  ): Promise<CrawlResult>;
   watch(onChange: (change: WatcherBackendChangeEvent) => void): void;
   close(): void;
   checkHealth(timeout: number): Promise<HealthCheckResult>;

package/src/Watcher.js

@@ -69,10 +69,32 @@ class Watcher extends _events.default {
   async crawl() {
     this.#options.perfLogger?.point("crawl_start");
     const options = this.#options;
+    const result = await this.#crawl({
+      previousState: options.previousState,
+      roots: options.roots,
+      useWatchman: options.useWatchman,
+    });
+    this.#options.perfLogger?.point("crawl_end");
+    return result;
+  }
+  async recrawl(subpath, currentFileSystem) {
+    return this.#crawl({
+      previousState: {
+        clocks: new Map(),
+        fileSystem: currentFileSystem,
+      },
+      roots: [path.join(this.#options.rootDir, subpath)],
+      subpath,
+      useWatchman: false,
+    });
+  }
+  async #crawl(crawlOptions) {
+    const options = this.#options;
+    const { useWatchman, subpath } = crawlOptions;
     const ignoreForCrawl = (filePath) =>
       options.ignoreForCrawl(filePath) ||
       path.basename(filePath).startsWith(this.#options.healthCheckFilePrefix);
-    const crawl = options.useWatchman ? _watchman.default : _node.default;
+    const crawl = useWatchman ? _watchman.default : _node.default;
     let crawler = crawl === _watchman.default ? "watchman" : "node";
     options.abortSignal.throwIfAborted();
     const crawlerOptions = {
@@ -87,49 +109,47 @@ class Watcher extends _events.default {
         this.emit("status", status);
       },
       perfLogger: options.perfLogger,
-      previousState: options.previousState,
+      previousState: crawlOptions.previousState,
       rootDir: options.rootDir,
-      roots: options.roots,
+      roots: crawlOptions.roots,
+      subpath,
     };
-    const retry = (error) => {
-      if (crawl === _watchman.default) {
-        crawler = "node";
-        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`,
-          );
-        });
+    debug("Crawling roots: %s with %s crawler.", crawlOptions.roots, crawler);
+    let delta;
+    try {
+      delta = await crawl(crawlerOptions);
+    } catch (firstError) {
+      if (crawl !== _watchman.default) {
+        throw firstError;
       }
-      throw error;
-    };
-    const logEnd = (delta) => {
-      debug(
-        'Crawler "%s" returned %d added/modified, %d removed, %d clock(s).',
-        crawler,
-        delta.changedFiles.size,
-        delta.removedFiles.size,
-        delta.clocks?.size ?? 0,
+      crawler = "node";
+      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" +
+          "  " +
+          firstError.toString(),
       );
-      this.#options.perfLogger?.point("crawl_end");
-      return delta;
-    };
-    debug('Beginning crawl with "%s".', crawler);
-    try {
-      return crawl(crawlerOptions).catch(retry).then(logEnd);
-    } catch (error) {
-      return retry(error).then(logEnd);
+      try {
+        delta = await (0, _node.default)(crawlerOptions);
+      } catch (retryError) {
+        throw new Error(
+          "Crawler retry failed:\n" +
+            `  Original error: ${firstError.message}\n` +
+            `  Retry error: ${retryError.message}\n`,
+        );
+      }
     }
+    debug(
+      'Crawler "%s" returned %d added/modified, %d removed, %d clock(s).',
+      crawler,
+      delta.changedFiles.size,
+      delta.removedFiles.size,
+      delta.clocks?.size ?? 0,
+    );
+    return delta;
   }
   async watch(onChange) {
     const { extensions, ignorePatternForWatch, useWatchman } = this.#options;
@@ -181,6 +201,13 @@ class Watcher extends _events.default {
             }
             return;
           }
+          if (change.event === "recrawl" && useWatchman) {
+            this.#options.console.error(
+              "metro-file-map: Received unexpected recrawl event while using " +
+                "Watchman. Watchman recrawls are not implemented.",
+            );
+            return;
+          }
           onChange(change);
         });
         await watcher.startWatching();

package/src/Watcher.js.flow

@@ -11,12 +11,11 @@
 import type {
   Console,
   CrawlerOptions,
-  FileData,
+  CrawlResult,
   Path,
   PerfLogger,
   WatcherBackend,
   WatcherBackendChangeEvent,
-  WatchmanClocks,
 } from './flow-types';
 import type {WatcherOptions as WatcherBackendOptions} from './watchers/common';
 
@@ -37,11 +36,12 @@ const debug = require('debug')('Metro:Watcher');
 
 const MAX_WAIT_TIME = 240000;
 
-type CrawlResult = {
-  changedFiles: FileData,
-  clocks?: WatchmanClocks,
-  removedFiles: Set<Path>,
-};
+type InternalCrawlOptions = Readonly<{
+  previousState: CrawlerOptions['previousState'],
+  roots: ReadonlyArray<string>,
+  subpath?: string,
+  useWatchman: boolean,
+}>;
 
 type WatcherOptions = {
   abortSignal: AbortSignal,
@@ -86,12 +86,41 @@ export class Watcher extends EventEmitter {
 
   async crawl(): Promise<CrawlResult> {
     this.#options.perfLogger?.point('crawl_start');
+    const options = this.#options;
+
+    const result = await this.#crawl({
+      previousState: options.previousState,
+      roots: options.roots,
+      useWatchman: options.useWatchman,
+    });
 
+    this.#options.perfLogger?.point('crawl_end');
+    return result;
+  }
+
+  async recrawl(
+    subpath: string,
+    currentFileSystem: CrawlerOptions['previousState']['fileSystem'],
+  ): Promise<CrawlResult> {
+    return this.#crawl({
+      previousState: {
+        clocks: new Map(),
+        fileSystem: currentFileSystem,
+      },
+      roots: [path.join(this.#options.rootDir, subpath)],
+      subpath,
+      useWatchman: false,
+    });
+  }
+
+  async #crawl(crawlOptions: InternalCrawlOptions): Promise<CrawlResult> {
     const options = this.#options;
+    const {useWatchman, subpath} = crawlOptions;
+
     const ignoreForCrawl = (filePath: string) =>
       options.ignoreForCrawl(filePath) ||
       path.basename(filePath).startsWith(this.#options.healthCheckFilePrefix);
-    const crawl = options.useWatchman ? watchmanCrawl : nodeCrawl;
+    const crawl = useWatchman ? watchmanCrawl : nodeCrawl;
     let crawler = crawl === watchmanCrawl ? 'watchman' : 'node';
 
     options.abortSignal.throwIfAborted();
@@ -108,55 +137,50 @@ export class Watcher extends EventEmitter {
         this.emit('status', status);
       },
       perfLogger: options.perfLogger,
-      previousState: options.previousState,
+      previousState: crawlOptions.previousState,
       rootDir: options.rootDir,
-      roots: options.roots,
+      roots: crawlOptions.roots,
+      subpath,
     };
 
-    const retry = (error: Error): Promise<CrawlResult> => {
-      if (crawl === watchmanCrawl) {
-        crawler = 'node';
-        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(),
-        );
-        // $FlowFixMe[incompatible-type] Found when updating Promise type definition
-        return nodeCrawl(crawlerOptions).catch<CrawlResult>(e => {
-          throw new Error(
-            'Crawler retry failed:\n' +
-              `  Original error: ${error.message}\n` +
-              `  Retry error: ${e.message}\n`,
-          );
-        });
-      }
-
-      throw error;
-    };
-
-    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 delta;
-    };
+    debug('Crawling roots: %s with %s crawler.', crawlOptions.roots, crawler);
 
-    debug('Beginning crawl with "%s".', crawler);
+    let delta: CrawlResult;
     try {
-      // $FlowFixMe[incompatible-type] Found when updating Promise type definition
-      return crawl(crawlerOptions).catch<CrawlResult>(retry).then(logEnd);
-    } catch (error) {
-      return retry(error).then(logEnd);
+      delta = await crawl(crawlerOptions);
+    } catch (firstError) {
+      if (crawl !== watchmanCrawl) {
+        throw firstError;
+      }
+      crawler = 'node';
+      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' +
+          '  ' +
+          firstError.toString(),
+      );
+      try {
+        delta = await nodeCrawl(crawlerOptions);
+      } catch (retryError) {
+        throw new Error(
+          'Crawler retry failed:\n' +
+            `  Original error: ${firstError.message}\n` +
+            `  Retry error: ${retryError.message}\n`,
+        );
+      }
     }
+
+    debug(
+      'Crawler "%s" returned %d added/modified, %d removed, %d clock(s).',
+      crawler,
+      delta.changedFiles.size,
+      delta.removedFiles.size,
+      delta.clocks?.size ?? 0,
+    );
+    return delta;
   }
 
   async watch(onChange: (change: WatcherBackendChangeEvent) => void) {
@@ -214,6 +238,15 @@ export class Watcher extends EventEmitter {
             }
             return;
           }
+          // Watchman handles recrawls internally - receiving a recrawl event
+          // when using Watchman would indicate a bug. Log an error and ignore.
+          if (change.event === 'recrawl' && useWatchman) {
+            this.#options.console.error(
+              'metro-file-map: Received unexpected recrawl event while using ' +
+                'Watchman. Watchman recrawls are not implemented.',
+            );
+            return;
+          }
           onChange(change);
         });
         await watcher.startWatching();

package/src/crawlers/node/index.d.ts

@@ -6,7 +6,7 @@
  *
  * @noformat
  * @oncall react_native
- * @generated SignedSource<<8851cd12d3cd8bdda798362696c830a2>>
+ * @generated SignedSource<<27109494e4956802ba89ac6fd22aa277>>
  *
  * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
  * Original file: packages/metro-file-map/src/crawlers/node/index.js
@@ -15,9 +15,7 @@
  *   yarn run build-ts-defs (OSS) 
  */
 
-import type {CanonicalPath, CrawlerOptions, FileData} from '../../flow-types';
+import type {CrawlerOptions, CrawlResult} from '../../flow-types';
 
-declare function nodeCrawl(
-  options: CrawlerOptions,
-): Promise<{removedFiles: Set<CanonicalPath>; changedFiles: FileData}>;
+declare function nodeCrawl(options: CrawlerOptions): Promise<CrawlResult>;
 export default nodeCrawl;

package/src/crawlers/node/index.js

@@ -183,6 +183,7 @@ async function nodeCrawl(options) {
     perfLogger,
     roots,
     abortSignal,
+    subpath,
   } = options;
   abortSignal?.throwIfAborted();
   perfLogger?.point("nodeCrawl_start");
@@ -193,7 +194,9 @@ async function nodeCrawl(options) {
   debug("Using system find: %s", useNativeFind);
   return new Promise((resolve, reject) => {
     const callback = (fileData) => {
-      const difference = previousState.fileSystem.getDifference(fileData);
+      const difference = previousState.fileSystem.getDifference(fileData, {
+        subpath,
+      });
       perfLogger?.point("nodeCrawl_end");
       try {
         abortSignal?.throwIfAborted();

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

@@ -10,9 +10,9 @@
  */
 
 import type {
-  CanonicalPath,
   Console,
   CrawlerOptions,
+  CrawlResult,
   FileData,
   IgnoreMatcher,
 } from '../../flow-types';
@@ -170,10 +170,9 @@ function findNative(
   });
 }
 
-export default async function nodeCrawl(options: CrawlerOptions): Promise<{
-  removedFiles: Set<CanonicalPath>,
-  changedFiles: FileData,
-}> {
+export default async function nodeCrawl(
+  options: CrawlerOptions,
+): Promise<CrawlResult> {
   const {
     console,
     previousState,
@@ -185,6 +184,7 @@ export default async function nodeCrawl(options: CrawlerOptions): Promise<{
     perfLogger,
     roots,
     abortSignal,
+    subpath,
   } = options;
 
   abortSignal?.throwIfAborted();
@@ -199,7 +199,9 @@ export default async function nodeCrawl(options: CrawlerOptions): Promise<{
 
   return new Promise((resolve, reject) => {
     const callback: Callback = fileData => {
-      const difference = previousState.fileSystem.getDifference(fileData);
+      const difference = previousState.fileSystem.getDifference(fileData, {
+        subpath,
+      });
 
       perfLogger?.point('nodeCrawl_end');
 

package/src/crawlers/watchman/index.d.ts

@@ -6,7 +6,7 @@
  *
  * @noformat
  * @oncall react_native
- * @generated SignedSource<<94c8a03429d06b694e26ca524fb9f17c>>
+ * @generated SignedSource<<bcfb58810773510450845bc00a93beae>>
  *
  * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
  * Original file: packages/metro-file-map/src/crawlers/watchman/index.js
@@ -15,16 +15,9 @@
  *   yarn run build-ts-defs (OSS) 
  */
 
-import type {
-  CanonicalPath,
-  CrawlerOptions,
-  FileData,
-  WatchmanClocks,
-} from '../../flow-types';
+import type {CrawlerOptions, CrawlResult} from '../../flow-types';
 
-declare function watchmanCrawl($$PARAM_0$$: CrawlerOptions): Promise<{
-  changedFiles: FileData;
-  removedFiles: Set<CanonicalPath>;
-  clocks: WatchmanClocks;
-}>;
+declare function watchmanCrawl(
+  $$PARAM_0$$: CrawlerOptions,
+): Promise<CrawlResult>;
 export default watchmanCrawl;

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

@@ -13,10 +13,10 @@ import type {WatchmanClockSpec} from '../../flow-types';
 import type {
   CanonicalPath,
   CrawlerOptions,
+  CrawlResult,
   FileData,
   FileMetadata,
   Path,
-  WatchmanClocks,
 } from '../../flow-types';
 import type {WatchmanQueryResponse, WatchmanWatchResponse} from 'fb-watchman';
 
@@ -57,11 +57,7 @@ export default async function watchmanCrawl({
   previousState,
   rootDir,
   roots,
-}: CrawlerOptions): Promise<{
-  changedFiles: FileData,
-  removedFiles: Set<CanonicalPath>,
-  clocks: WatchmanClocks,
-}> {
+}: CrawlerOptions): Promise<CrawlResult> {
   abortSignal?.throwIfAborted();
 
   const client = new watchman.Client();