metro-file-map 0.83.4 → 0.83.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro-file-map",
-  "version": "0.83.4",
+  "version": "0.83.6",
   "description": "[Experimental] - 🚇 File crawling, watching and mapping for Metro",
   "main": "src/index.js",
   "exports": {
@@ -10,7 +10,8 @@
   },
   "repository": {
     "type": "git",
-    "url": "git@github.com:facebook/metro.git"
+    "url": "git+https://github.com/facebook/metro.git",
+    "directory": "packages/metro-file-map"
   },
   "scripts": {
     "prepare-release": "test -d build && rm -rf src.real && mv src src.real && mv build src",

package/src/Watcher.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @generated SignedSource<<25fee66c7d26ad53cdd5bbab454fe50b>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/Watcher.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {
+  Console,
+  CrawlerOptions,
+  CrawlResult,
+  PerfLogger,
+  WatcherBackendChangeEvent,
+} from './flow-types';
+
+import EventEmitter from 'events';
+
+type WatcherOptions = {
+  abortSignal: AbortSignal;
+  computeSha1: boolean;
+  console: Console;
+  enableSymlinks: boolean;
+  extensions: ReadonlyArray<string>;
+  forceNodeFilesystemAPI: boolean;
+  healthCheckFilePrefix: string;
+  ignoreForCrawl: (filePath: string) => boolean;
+  ignorePatternForWatch: RegExp;
+  previousState: CrawlerOptions['previousState'];
+  perfLogger: null | undefined | PerfLogger;
+  roots: ReadonlyArray<string>;
+  rootDir: string;
+  useWatchman: boolean;
+  watch: boolean;
+  watchmanDeferStates: ReadonlyArray<string>;
+};
+export type HealthCheckResult =
+  | {
+      type: 'error';
+      timeout: number;
+      error: Error;
+      watcher: null | undefined | string;
+    }
+  | {
+      type: 'success';
+      timeout: number;
+      timeElapsed: number;
+      watcher: null | undefined | string;
+    }
+  | {
+      type: 'timeout';
+      timeout: number;
+      watcher: null | undefined | string;
+      pauseReason: null | undefined | string;
+    };
+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

@@ -29,10 +29,7 @@ function _interopRequireWildcard(e, t) {
     if (!t && e && e.__esModule) return e;
     var o,
       i,
-      f = {
-        __proto__: null,
-        default: e,
-      };
+      f = { __proto__: null, default: e };
     if (null === e || ("object" != typeof e && "function" != typeof e))
       return f;
     if ((o = t ? n : r)) {
@@ -52,11 +49,7 @@ function _interopRequireWildcard(e, t) {
   })(e, t);
 }
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const debug = require("debug")("Metro:Watcher");
 const MAX_WAIT_TIME = 240000;
@@ -76,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 = {
@@ -94,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;
@@ -188,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/cache/DiskCacheManager.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<9cdec2a3b7a46f0a893dd5dc392a5294>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/cache/DiskCacheManager.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {
+  BuildParameters,
+  CacheData,
+  CacheManager,
+  CacheManagerFactoryOptions,
+  CacheManagerWriteOptions,
+} from '../flow-types';
+
+type AutoSaveOptions = Readonly<{debounceMs: number}>;
+type DiskCacheConfig = Readonly<{
+  autoSave?: Partial<AutoSaveOptions> | boolean;
+  cacheFilePrefix?: null | undefined | string;
+  cacheDirectory?: null | undefined | string;
+}>;
+export declare class DiskCacheManager implements CacheManager {
+  constructor(
+    $$PARAM_0$$: CacheManagerFactoryOptions,
+    $$PARAM_1$$: DiskCacheConfig,
+  );
+  static getCacheFilePath(
+    buildParameters: BuildParameters,
+    cacheFilePrefix?: null | undefined | string,
+    cacheDirectory?: null | undefined | string,
+  ): string;
+  getCacheFilePath(): string;
+  read(): Promise<null | undefined | CacheData>;
+  write(
+    getSnapshot: () => CacheData,
+    $$PARAM_1$$: CacheManagerWriteOptions,
+  ): Promise<void>;
+  end(): Promise<void>;
+}

package/src/cache/DiskCacheManager.js

@@ -13,11 +13,7 @@ var _path = _interopRequireDefault(require("path"));
 var _timers = require("timers");
 var _v = require("v8");
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const debug = require("debug")("Metro:FileMapCache");
 const DEFAULT_PREFIX = "metro-file-map";

package/src/constants.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @generated SignedSource<<733fae11203b79438dfb1ee2bbb6473d>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/constants.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {HType} from './flow-types';
+
+declare const $$EXPORT_DEFAULT_DECLARATION$$: HType;
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
+export default $$EXPORT_DEFAULT_DECLARATION$$;

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

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<8b6ff8a24f9156cd7991006c72edd296>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/crawlers/node/hasNativeFindSupport.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+declare function hasNativeFindSupport(): Promise<boolean>;
+export default hasNativeFindSupport;

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

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<27109494e4956802ba89ac6fd22aa277>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/crawlers/node/index.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {CrawlerOptions, CrawlResult} from '../../flow-types';
+
+declare function nodeCrawl(options: CrawlerOptions): Promise<CrawlResult>;
+export default nodeCrawl;

package/src/crawlers/node/index.js

@@ -20,10 +20,7 @@ function _interopRequireWildcard(e, t) {
     if (!t && e && e.__esModule) return e;
     var o,
       i,
-      f = {
-        __proto__: null,
-        default: e,
-      };
+      f = { __proto__: null, default: e };
     if (null === e || ("object" != typeof e && "function" != typeof e))
       return f;
     if ((o = t ? n : r)) {
@@ -43,11 +40,7 @@ function _interopRequireWildcard(e, t) {
   })(e, t);
 }
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const debug = require("debug")("Metro:NodeCrawler");
 function find(
@@ -190,6 +183,7 @@ async function nodeCrawl(options) {
     perfLogger,
     roots,
     abortSignal,
+    subpath,
   } = options;
   abortSignal?.throwIfAborted();
   perfLogger?.point("nodeCrawl_start");
@@ -200,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

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ *
+ * @noformat
+ * @oncall react_native
+ * @generated SignedSource<<bcfb58810773510450845bc00a93beae>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/crawlers/watchman/index.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {CrawlerOptions, CrawlResult} from '../../flow-types';
+
+declare function watchmanCrawl(
+  $$PARAM_0$$: CrawlerOptions,
+): Promise<CrawlResult>;
+export default watchmanCrawl;