metro-file-map 0.83.3 → 0.83.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro-file-map",
-  "version": "0.83.3",
+  "version": "0.83.5",
   "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

@@ -5,20 +5,66 @@
  * LICENSE file in the root directory of this source tree.
  *
  * @format
- * @oncall react_native
  */
 
+import type {
+  Console,
+  CrawlerOptions,
+  FileData,
+  Path,
+  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;
+  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: string | null}
+  | {
+      type: 'error';
+      timeout: number;
+      error: Error;
+      watcher: null | undefined | string;
+    }
   | {
       type: 'success';
       timeout: number;
       timeElapsed: number;
-      watcher: string | null;
+      watcher: null | undefined | string;
     }
   | {
       type: 'timeout';
       timeout: number;
-      watcher: string | null;
-      pauseReason: string | null;
+      watcher: null | undefined | string;
+      pauseReason: null | undefined | string;
     };
+export declare class Watcher extends EventEmitter {
+  constructor(options: WatcherOptions);
+  crawl(): Promise<CrawlResult>;
+  watch(onChange: (change: WatcherBackendChangeEvent) => void): void;
+  close(): void;
+  checkHealth(timeout: number): Promise<HealthCheckResult>;
+}

package/src/Watcher.js

@@ -21,28 +21,32 @@ var fs = _interopRequireWildcard(require("fs"));
 var _nullthrows = _interopRequireDefault(require("nullthrows"));
 var path = _interopRequireWildcard(require("path"));
 var _perf_hooks = require("perf_hooks");
-function _getRequireWildcardCache(e) {
-  if ("function" != typeof WeakMap) return null;
-  var r = new WeakMap(),
-    t = new WeakMap();
-  return (_getRequireWildcardCache = function (e) {
-    return e ? t : r;
-  })(e);
-}
-function _interopRequireWildcard(e, r) {
-  if (!r && e && e.__esModule) return e;
-  if (null === e || ("object" != typeof e && "function" != typeof e))
-    return { default: e };
-  var t = _getRequireWildcardCache(r);
-  if (t && t.has(e)) return t.get(e);
-  var n = { __proto__: null },
-    a = Object.defineProperty && Object.getOwnPropertyDescriptor;
-  for (var u in e)
-    if ("default" !== u && {}.hasOwnProperty.call(e, u)) {
-      var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
-      i && (i.get || i.set) ? Object.defineProperty(n, u, i) : (n[u] = e[u]);
+function _interopRequireWildcard(e, t) {
+  if ("function" == typeof WeakMap)
+    var r = new WeakMap(),
+      n = new WeakMap();
+  return (_interopRequireWildcard = function (e, t) {
+    if (!t && e && e.__esModule) return e;
+    var o,
+      i,
+      f = { __proto__: null, default: e };
+    if (null === e || ("object" != typeof e && "function" != typeof e))
+      return f;
+    if ((o = t ? n : r)) {
+      if (o.has(e)) return o.get(e);
+      o.set(e, f);
     }
-  return ((n.default = e), t && t.set(e, n), n);
+    for (const t in e)
+      "default" !== t &&
+        {}.hasOwnProperty.call(e, t) &&
+        ((i =
+          (o = Object.defineProperty) &&
+          Object.getOwnPropertyDescriptor(e, t)) &&
+        (i.get || i.set)
+          ? o(f, t, i)
+          : (f[t] = e[t]));
+    return f;
+  })(e, t);
 }
 function _interopRequireDefault(e) {
   return e && e.__esModule ? e : { default: e };
@@ -51,20 +55,23 @@ const debug = require("debug")("Metro:Watcher");
 const MAX_WAIT_TIME = 240000;
 let nextInstanceId = 0;
 class Watcher extends _events.default {
-  _backends = [];
-  _nextHealthCheckId = 0;
-  _pendingHealthChecks = new Map();
+  #activeWatcher;
+  #backends = [];
+  #instanceId;
+  #nextHealthCheckId = 0;
+  #options;
+  #pendingHealthChecks = new Map();
   constructor(options) {
     super();
-    this._options = options;
-    this._instanceId = nextInstanceId++;
+    this.#options = options;
+    this.#instanceId = nextInstanceId++;
   }
   async crawl() {
-    this._options.perfLogger?.point("crawl_start");
-    const options = this._options;
+    this.#options.perfLogger?.point("crawl_start");
+    const options = this.#options;
     const ignoreForCrawl = (filePath) =>
       options.ignoreForCrawl(filePath) ||
-      path.basename(filePath).startsWith(this._options.healthCheckFilePrefix);
+      path.basename(filePath).startsWith(this.#options.healthCheckFilePrefix);
     const crawl = options.useWatchman ? _watchman.default : _node.default;
     let crawler = crawl === _watchman.default ? "watchman" : "node";
     options.abortSignal.throwIfAborted();
@@ -114,7 +121,7 @@ class Watcher extends _events.default {
         delta.removedFiles.size,
         delta.clocks?.size ?? 0,
       );
-      this._options.perfLogger?.point("crawl_end");
+      this.#options.perfLogger?.point("crawl_end");
       return delta;
     };
     debug('Beginning crawl with "%s".', crawler);
@@ -125,7 +132,7 @@ class Watcher extends _events.default {
     }
   }
   async watch(onChange) {
-    const { extensions, ignorePatternForWatch, useWatchman } = this._options;
+    const { extensions, ignorePatternForWatch, useWatchman } = this.#options;
     const WatcherImpl = useWatchman
       ? _WatchmanWatcher.default
       : _NativeWatcher.default.isSupported()
@@ -138,22 +145,22 @@ class Watcher extends _events.default {
       watcher = "native";
     }
     debug(`Using watcher: ${watcher}`);
-    this._options.perfLogger?.annotate({
+    this.#options.perfLogger?.annotate({
       string: {
         watcher,
       },
     });
-    this._activeWatcher = watcher;
+    this.#activeWatcher = watcher;
     const createWatcherBackend = (root) => {
       const watcherOptions = {
         dot: true,
         globs: [
           "**/package.json",
-          "**/" + this._options.healthCheckFilePrefix + "*",
+          "**/" + this.#options.healthCheckFilePrefix + "*",
           ...extensions.map((extension) => "**/*." + extension),
         ],
         ignored: ignorePatternForWatch,
-        watchmanDeferStates: this._options.watchmanDeferStates,
+        watchmanDeferStates: this.#options.watchmanDeferStates,
       };
       const watcher = new WatcherImpl(root, watcherOptions);
       return new Promise(async (resolve, reject) => {
@@ -163,14 +170,14 @@ class Watcher extends _events.default {
         );
         watcher.onFileEvent((change) => {
           const basename = path.basename(change.relativePath);
-          if (basename.startsWith(this._options.healthCheckFilePrefix)) {
+          if (basename.startsWith(this.#options.healthCheckFilePrefix)) {
             if (change.event === _common.TOUCH_EVENT) {
               debug(
                 "Observed possible health check cookie: %s in %s",
                 change.relativePath,
                 root,
               );
-              this._handleHealthCheckObservation(basename);
+              this.#handleHealthCheckObservation(basename);
             }
             return;
           }
@@ -181,36 +188,36 @@ class Watcher extends _events.default {
         resolve(watcher);
       });
     };
-    this._backends = await Promise.all(
-      this._options.roots.map(createWatcherBackend),
+    this.#backends = await Promise.all(
+      this.#options.roots.map(createWatcherBackend),
     );
   }
-  _handleHealthCheckObservation(basename) {
-    const resolveHealthCheck = this._pendingHealthChecks.get(basename);
+  #handleHealthCheckObservation(basename) {
+    const resolveHealthCheck = this.#pendingHealthChecks.get(basename);
     if (!resolveHealthCheck) {
       return;
     }
     resolveHealthCheck();
   }
   async close() {
-    await Promise.all(this._backends.map((watcher) => watcher.stopWatching()));
-    this._activeWatcher = null;
+    await Promise.all(this.#backends.map((watcher) => watcher.stopWatching()));
+    this.#activeWatcher = null;
   }
   async checkHealth(timeout) {
-    const healthCheckId = this._nextHealthCheckId++;
+    const healthCheckId = this.#nextHealthCheckId++;
     if (healthCheckId === Number.MAX_SAFE_INTEGER) {
-      this._nextHealthCheckId = 0;
+      this.#nextHealthCheckId = 0;
     }
-    const watcher = this._activeWatcher;
+    const watcher = this.#activeWatcher;
     const basename =
-      this._options.healthCheckFilePrefix +
+      this.#options.healthCheckFilePrefix +
       "-" +
       process.pid +
       "-" +
-      this._instanceId +
+      this.#instanceId +
       "-" +
       healthCheckId;
-    const healthCheckPath = path.join(this._options.rootDir, basename);
+    const healthCheckPath = path.join(this.#options.rootDir, basename);
     let result;
     const timeoutPromise = new Promise((resolve) =>
       setTimeout(resolve, timeout),
@@ -218,7 +225,7 @@ class Watcher extends _events.default {
       if (!result) {
         result = {
           type: "timeout",
-          pauseReason: this._backends[0]?.getPauseReason(),
+          pauseReason: this.#backends[0]?.getPauseReason(),
           timeout,
           watcher,
         };
@@ -239,7 +246,7 @@ class Watcher extends _events.default {
         }
       });
     const observationPromise = new Promise((resolve) => {
-      this._pendingHealthChecks.set(basename, resolve);
+      this.#pendingHealthChecks.set(basename, resolve);
     }).then(() => {
       if (!result) {
         result = {
@@ -254,7 +261,7 @@ class Watcher extends _events.default {
       timeoutPromise,
       creationPromise.then(() => observationPromise),
     ]);
-    this._pendingHealthChecks.delete(basename);
+    this.#pendingHealthChecks.delete(basename);
     creationPromise.then(() =>
       fs.promises.unlink(healthCheckPath).catch(() => {}),
     );

package/src/Watcher.js.flow

@@ -4,8 +4,8 @@
  * 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
+ * @format
  */
 
 import type {
@@ -48,18 +48,18 @@ type WatcherOptions = {
   computeSha1: boolean,
   console: Console,
   enableSymlinks: boolean,
-  extensions: $ReadOnlyArray<string>,
+  extensions: ReadonlyArray<string>,
   forceNodeFilesystemAPI: boolean,
   healthCheckFilePrefix: string,
-  ignoreForCrawl: string => boolean,
+  ignoreForCrawl: (filePath: string) => boolean,
   ignorePatternForWatch: RegExp,
   previousState: CrawlerOptions['previousState'],
   perfLogger: ?PerfLogger,
-  roots: $ReadOnlyArray<string>,
+  roots: ReadonlyArray<string>,
   rootDir: string,
   useWatchman: boolean,
   watch: boolean,
-  watchmanDeferStates: $ReadOnlyArray<string>,
+  watchmanDeferStates: ReadonlyArray<string>,
 };
 
 let nextInstanceId = 0;
@@ -70,27 +70,27 @@ export type HealthCheckResult =
   | {type: 'timeout', timeout: number, watcher: ?string, pauseReason: ?string};
 
 export class Watcher extends EventEmitter {
-  _options: WatcherOptions;
-  _backends: $ReadOnlyArray<WatcherBackend> = [];
-  _instanceId: number;
-  _nextHealthCheckId: number = 0;
-  _pendingHealthChecks: Map</* basename */ string, /* resolve */ () => void> =
+  #activeWatcher: ?string;
+  #backends: ReadonlyArray<WatcherBackend> = [];
+  +#instanceId: number;
+  #nextHealthCheckId: number = 0;
+  +#options: WatcherOptions;
+  +#pendingHealthChecks: Map</* basename */ string, /* resolve */ () => void> =
     new Map();
-  _activeWatcher: ?string;
 
   constructor(options: WatcherOptions) {
     super();
-    this._options = options;
-    this._instanceId = nextInstanceId++;
+    this.#options = options;
+    this.#instanceId = nextInstanceId++;
   }
 
   async crawl(): Promise<CrawlResult> {
-    this._options.perfLogger?.point('crawl_start');
+    this.#options.perfLogger?.point('crawl_start');
 
-    const options = this._options;
+    const options = this.#options;
     const ignoreForCrawl = (filePath: string) =>
       options.ignoreForCrawl(filePath) ||
-      path.basename(filePath).startsWith(this._options.healthCheckFilePrefix);
+      path.basename(filePath).startsWith(this.#options.healthCheckFilePrefix);
     const crawl = options.useWatchman ? watchmanCrawl : nodeCrawl;
     let crawler = crawl === watchmanCrawl ? 'watchman' : 'node';
 
@@ -146,7 +146,7 @@ export class Watcher extends EventEmitter {
         delta.removedFiles.size,
         delta.clocks?.size ?? 0,
       );
-      this._options.perfLogger?.point('crawl_end');
+      this.#options.perfLogger?.point('crawl_end');
       return delta;
     };
 
@@ -160,7 +160,7 @@ export class Watcher extends EventEmitter {
   }
 
   async watch(onChange: (change: WatcherBackendChangeEvent) => void) {
-    const {extensions, ignorePatternForWatch, useWatchman} = this._options;
+    const {extensions, ignorePatternForWatch, useWatchman} = this.#options;
 
     // WatchmanWatcher > NativeWatcher > FallbackWatcher
     const WatcherImpl = useWatchman
@@ -176,8 +176,8 @@ export class Watcher extends EventEmitter {
       watcher = 'native';
     }
     debug(`Using watcher: ${watcher}`);
-    this._options.perfLogger?.annotate({string: {watcher}});
-    this._activeWatcher = watcher;
+    this.#options.perfLogger?.annotate({string: {watcher}});
+    this.#activeWatcher = watcher;
 
     const createWatcherBackend = (root: Path): Promise<WatcherBackend> => {
       const watcherOptions: WatcherBackendOptions = {
@@ -187,11 +187,11 @@ export class Watcher extends EventEmitter {
           /// module resolution.
           '**/package.json',
           // Ensure we always watch any health check files
-          '**/' + this._options.healthCheckFilePrefix + '*',
+          '**/' + this.#options.healthCheckFilePrefix + '*',
           ...extensions.map(extension => '**/*.' + extension),
         ],
         ignored: ignorePatternForWatch,
-        watchmanDeferStates: this._options.watchmanDeferStates,
+        watchmanDeferStates: this.#options.watchmanDeferStates,
       };
       const watcher: WatcherBackend = new WatcherImpl(root, watcherOptions);
 
@@ -203,14 +203,14 @@ export class Watcher extends EventEmitter {
 
         watcher.onFileEvent(change => {
           const basename = path.basename(change.relativePath);
-          if (basename.startsWith(this._options.healthCheckFilePrefix)) {
+          if (basename.startsWith(this.#options.healthCheckFilePrefix)) {
             if (change.event === TOUCH_EVENT) {
               debug(
                 'Observed possible health check cookie: %s in %s',
                 change.relativePath,
                 root,
               );
-              this._handleHealthCheckObservation(basename);
+              this.#handleHealthCheckObservation(basename);
             }
             return;
           }
@@ -222,13 +222,13 @@ export class Watcher extends EventEmitter {
       });
     };
 
-    this._backends = await Promise.all(
-      this._options.roots.map(createWatcherBackend),
+    this.#backends = await Promise.all(
+      this.#options.roots.map(createWatcherBackend),
     );
   }
 
-  _handleHealthCheckObservation(basename: string) {
-    const resolveHealthCheck = this._pendingHealthChecks.get(basename);
+  #handleHealthCheckObservation(basename: string) {
+    const resolveHealthCheck = this.#pendingHealthChecks.get(basename);
     if (!resolveHealthCheck) {
       return;
     }
@@ -236,25 +236,25 @@ export class Watcher extends EventEmitter {
   }
 
   async close() {
-    await Promise.all(this._backends.map(watcher => watcher.stopWatching()));
-    this._activeWatcher = null;
+    await Promise.all(this.#backends.map(watcher => watcher.stopWatching()));
+    this.#activeWatcher = null;
   }
 
   async checkHealth(timeout: number): Promise<HealthCheckResult> {
-    const healthCheckId = this._nextHealthCheckId++;
+    const healthCheckId = this.#nextHealthCheckId++;
     if (healthCheckId === Number.MAX_SAFE_INTEGER) {
-      this._nextHealthCheckId = 0;
+      this.#nextHealthCheckId = 0;
     }
-    const watcher = this._activeWatcher;
+    const watcher = this.#activeWatcher;
     const basename =
-      this._options.healthCheckFilePrefix +
+      this.#options.healthCheckFilePrefix +
       '-' +
       process.pid +
       '-' +
-      this._instanceId +
+      this.#instanceId +
       '-' +
       healthCheckId;
-    const healthCheckPath = path.join(this._options.rootDir, basename);
+    const healthCheckPath = path.join(this.#options.rootDir, basename);
     let result: ?HealthCheckResult;
     const timeoutPromise = new Promise(resolve =>
       setTimeout(resolve, timeout),
@@ -262,7 +262,7 @@ export class Watcher extends EventEmitter {
       if (!result) {
         result = {
           type: 'timeout',
-          pauseReason: this._backends[0]?.getPauseReason(),
+          pauseReason: this.#backends[0]?.getPauseReason(),
           timeout,
           watcher,
         };
@@ -283,7 +283,7 @@ export class Watcher extends EventEmitter {
         }
       });
     const observationPromise = new Promise(resolve => {
-      this._pendingHealthChecks.set(basename, resolve);
+      this.#pendingHealthChecks.set(basename, resolve);
     }).then(() => {
       if (!result) {
         result = {
@@ -298,7 +298,7 @@ export class Watcher extends EventEmitter {
       timeoutPromise,
       creationPromise.then(() => observationPromise),
     ]);
-    this._pendingHealthChecks.delete(basename);
+    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.
     // $FlowFixMe[unused-promise]

package/src/cache/DiskCacheManager.d.ts

@@ -12,27 +12,31 @@ import type {
   BuildParameters,
   CacheData,
   CacheManager,
+  CacheManagerFactoryOptions,
   CacheManagerWriteOptions,
 } from '../flow-types';
 
-export interface DiskCacheConfig {
-  buildParameters: BuildParameters;
-  cacheFilePrefix?: string | null;
-  cacheDirectory?: string | null;
-}
-
-export class DiskCacheManager implements CacheManager {
-  constructor(options: DiskCacheConfig);
+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?: string | null,
-    cacheDirectory?: string | null,
+    cacheFilePrefix?: null | undefined | string,
+    cacheDirectory?: null | undefined | string,
   ): string;
   getCacheFilePath(): string;
-  read(): Promise<CacheData | null>;
+  read(): Promise<null | undefined | CacheData>;
   write(
     getSnapshot: () => CacheData,
-    opts: CacheManagerWriteOptions,
+    $$PARAM_1$$: CacheManagerWriteOptions,
   ): Promise<void>;
   end(): Promise<void>;
 }

package/src/cache/DiskCacheManager.js.flow

@@ -27,11 +27,11 @@ import {deserialize, serialize} from 'v8';
 // eslint-disable-next-line import/no-commonjs
 const debug = require('debug')('Metro:FileMapCache');
 
-type AutoSaveOptions = $ReadOnly<{
+type AutoSaveOptions = Readonly<{
   debounceMs: number,
 }>;
 
-type DiskCacheConfig = $ReadOnly<{
+type DiskCacheConfig = Readonly<{
   autoSave?: Partial<AutoSaveOptions> | boolean,
   cacheFilePrefix?: ?string,
   cacheDirectory?: ?string,
@@ -150,7 +150,7 @@ export class DiskCacheManager implements CacheManager {
     }
   }
 
-  async end() {
+  async end(): Promise<void> {
     // Clear any timers
     if (this.#debounceTimeout) {
       clearTimeout(this.#debounceTimeout);

package/src/constants.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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
+ */
+
+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/constants.js

@@ -1,19 +1,20 @@
 "use strict";
 
-const constants = {
-  DEPENDENCY_DELIM: "\0",
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+var _default = (exports.default = {
   MTIME: 0,
   SIZE: 1,
   VISITED: 2,
-  DEPENDENCIES: 3,
-  SHA1: 4,
-  SYMLINK: 5,
-  ID: 6,
+  SHA1: 3,
+  SYMLINK: 4,
+  PLUGINDATA: 5,
   PATH: 0,
   TYPE: 1,
   MODULE: 0,
   PACKAGE: 1,
   GENERIC_PLATFORM: "g",
   NATIVE_PLATFORM: "native",
-};
-module.exports = constants;
+});