metro-file-map 0.83.3 → 0.84.0

package/src/watchers/FallbackWatcher.js.flow

@@ -42,32 +42,32 @@ const DELETE_EVENT = common.DELETE_EVENT;
 const DEBOUNCE_MS = 100;
 
 export default class FallbackWatcher extends AbstractWatcher {
-  +_changeTimers: Map<string, TimeoutID> = new Map();
-  +_dirRegistry: {
+  +#changeTimers: Map<string, TimeoutID> = new Map();
+  +#dirRegistry: {
     [directory: string]: {[file: string]: true, __proto__: null},
     __proto__: null,
   } = Object.create(null);
-  +watched: {[key: string]: FSWatcher, __proto__: null} = Object.create(null);
+  +#watched: {[key: string]: FSWatcher, __proto__: null} = Object.create(null);
 
-  async startWatching() {
-    this._watchdir(this.root);
+  async startWatching(): Promise<void> {
+    this.#watchdir(this.root);
 
     await new Promise(resolve => {
       recReaddir(
         this.root,
         dir => {
-          this._watchdir(dir);
+          this.#watchdir(dir);
         },
         filename => {
-          this._register(filename, 'f');
+          this.#register(filename, 'f');
         },
         symlink => {
-          this._register(symlink, 'l');
+          this.#register(symlink, 'l');
         },
         () => {
           resolve();
         },
-        this._checkedEmitError,
+        this.#checkedEmitError,
         this.ignored,
       );
     });
@@ -87,10 +87,10 @@ export default class FallbackWatcher extends AbstractWatcher {
    *
    *  Return false if ignored or already registered.
    */
-  _register(filepath: string, type: ChangeEventMetadata['type']): boolean {
+  #register(filepath: string, type: ChangeEventMetadata['type']): boolean {
     const dir = path.dirname(filepath);
     const filename = path.basename(filepath);
-    if (this._dirRegistry[dir] && this._dirRegistry[dir][filename]) {
+    if (this.#dirRegistry[dir] && this.#dirRegistry[dir][filename]) {
       return false;
     }
 
@@ -103,11 +103,11 @@ export default class FallbackWatcher extends AbstractWatcher {
       return false;
     }
 
-    if (!this._dirRegistry[dir]) {
-      this._dirRegistry[dir] = Object.create(null);
+    if (!this.#dirRegistry[dir]) {
+      this.#dirRegistry[dir] = Object.create(null);
     }
 
-    this._dirRegistry[dir][filename] = true;
+    this.#dirRegistry[dir][filename] = true;
 
     return true;
   }
@@ -115,39 +115,39 @@ export default class FallbackWatcher extends AbstractWatcher {
   /**
    * Removes a file from the registry.
    */
-  _unregister(filepath: string) {
+  #unregister(filepath: string) {
     const dir = path.dirname(filepath);
-    if (this._dirRegistry[dir]) {
+    if (this.#dirRegistry[dir]) {
       const filename = path.basename(filepath);
-      delete this._dirRegistry[dir][filename];
+      delete this.#dirRegistry[dir][filename];
     }
   }
 
   /**
    * Removes a dir from the registry.
    */
-  _unregisterDir(dirpath: string): void {
-    if (this._dirRegistry[dirpath]) {
-      delete this._dirRegistry[dirpath];
+  #unregisterDir(dirpath: string): void {
+    if (this.#dirRegistry[dirpath]) {
+      delete this.#dirRegistry[dirpath];
     }
   }
 
   /**
    * Checks if a file or directory exists in the registry.
    */
-  _registered(fullpath: string): boolean {
+  #registered(fullpath: string): boolean {
     const dir = path.dirname(fullpath);
     return !!(
-      this._dirRegistry[fullpath] ||
-      (this._dirRegistry[dir] &&
-        this._dirRegistry[dir][path.basename(fullpath)])
+      this.#dirRegistry[fullpath] ||
+      (this.#dirRegistry[dir] &&
+        this.#dirRegistry[dir][path.basename(fullpath)])
     );
   }
 
   /**
    * Emit "error" event if it's not an ignorable event
    */
-  _checkedEmitError: (error: Error) => void = error => {
+  #checkedEmitError: (error: Error) => void = error => {
     if (!isIgnorableFileError(error)) {
       this.emitError(error);
     }
@@ -156,19 +156,19 @@ export default class FallbackWatcher extends AbstractWatcher {
   /**
    * Watch a directory.
    */
-  _watchdir: string => boolean = (dir: string) => {
-    if (this.watched[dir]) {
+  #watchdir: (dir: string) => boolean = (dir: string) => {
+    if (this.#watched[dir]) {
       return false;
     }
     const watcher = fs.watch(dir, {persistent: true}, (event, filename) =>
-      this._normalizeChange(dir, event, filename),
+      this.#normalizeChange(dir, event, filename),
     );
-    this.watched[dir] = watcher;
+    this.#watched[dir] = watcher;
 
-    watcher.on('error', this._checkedEmitError);
+    watcher.on('error', this.#checkedEmitError);
 
     if (this.root !== dir) {
-      this._register(dir, 'd');
+      this.#register(dir, 'd');
     }
     return true;
   };
@@ -176,12 +176,12 @@ export default class FallbackWatcher extends AbstractWatcher {
   /**
    * Stop watching a directory.
    */
-  async _stopWatching(dir: string): Promise<void> {
-    if (this.watched[dir]) {
+  async #stopWatching(dir: string): Promise<void> {
+    if (this.#watched[dir]) {
       await new Promise(resolve => {
-        this.watched[dir].once('close', () => process.nextTick(resolve));
-        this.watched[dir].close();
-        delete this.watched[dir];
+        this.#watched[dir].once('close', () => process.nextTick(resolve));
+        this.#watched[dir].close();
+        delete this.#watched[dir];
       });
     }
   }
@@ -191,8 +191,8 @@ export default class FallbackWatcher extends AbstractWatcher {
    */
   async stopWatching(): Promise<void> {
     await super.stopWatching();
-    const promises = Object.keys(this.watched).map(dir =>
-      this._stopWatching(dir),
+    const promises = Object.keys(this.#watched).map(dir =>
+      this.#stopWatching(dir),
     );
     await Promise.all(promises);
   }
@@ -202,19 +202,19 @@ export default class FallbackWatcher extends AbstractWatcher {
    * the file argument might be missing from the fs event. Try to detect what
    * change by detecting if something was deleted or the most recent file change.
    */
-  _detectChangedFile(
+  #detectChangedFile(
     dir: string,
     event: string,
     callback: (file: string) => void,
   ) {
-    if (!this._dirRegistry[dir]) {
+    if (!this.#dirRegistry[dir]) {
       return;
     }
 
     let found = false;
-    let closest: ?$ReadOnly<{file: string, mtime: Stats['mtime']}> = null;
+    let closest: ?Readonly<{file: string, mtime: Stats['mtime']}> = null;
     let c = 0;
-    Object.keys(this._dirRegistry[dir]).forEach((file, i, arr) => {
+    Object.keys(this.#dirRegistry[dir]).forEach((file, i, arr) => {
       fs.lstat(path.join(dir, file), (error, stat) => {
         if (found) {
           return;
@@ -242,17 +242,17 @@ export default class FallbackWatcher extends AbstractWatcher {
   /**
    * Normalize fs events and pass it on to be processed.
    */
-  _normalizeChange(dir: string, event: string, file: string) {
+  #normalizeChange(dir: string, event: string, file: string) {
     if (!file) {
-      this._detectChangedFile(dir, event, actualFile => {
+      this.#detectChangedFile(dir, event, actualFile => {
         if (actualFile) {
-          this._processChange(dir, event, actualFile).catch(error =>
+          this.#processChange(dir, event, actualFile).catch(error =>
             this.emitError(error),
           );
         }
       });
     } else {
-      this._processChange(dir, event, path.normalize(file)).catch(error =>
+      this.#processChange(dir, event, path.normalize(file)).catch(error =>
         this.emitError(error),
       );
     }
@@ -261,11 +261,11 @@ export default class FallbackWatcher extends AbstractWatcher {
   /**
    * Process changes.
    */
-  async _processChange(dir: string, event: string, file: string) {
+  async #processChange(dir: string, event: string, file: string) {
     const fullPath = path.join(dir, file);
     const relativePath = path.join(path.relative(this.root, dir), file);
 
-    const registered = this._registered(fullPath);
+    const registered = this.#registered(fullPath);
 
     try {
       const stat = await fsPromises.lstat(fullPath);
@@ -284,8 +284,8 @@ export default class FallbackWatcher extends AbstractWatcher {
         recReaddir(
           path.resolve(this.root, relativePath),
           (dir, stats) => {
-            if (this._watchdir(dir)) {
-              this._emitEvent({
+            if (this.#watchdir(dir)) {
+              this.#emitEvent({
                 event: TOUCH_EVENT,
                 relativePath: path.relative(this.root, dir),
                 metadata: {
@@ -297,8 +297,8 @@ export default class FallbackWatcher extends AbstractWatcher {
             }
           },
           (file, stats) => {
-            if (this._register(file, 'f')) {
-              this._emitEvent({
+            if (this.#register(file, 'f')) {
+              this.#emitEvent({
                 event: TOUCH_EVENT,
                 relativePath: path.relative(this.root, file),
                 metadata: {
@@ -310,7 +310,7 @@ export default class FallbackWatcher extends AbstractWatcher {
             }
           },
           (symlink, stats) => {
-            if (this._register(symlink, 'l')) {
+            if (this.#register(symlink, 'l')) {
               this.emitFileEvent({
                 event: TOUCH_EVENT,
                 relativePath: path.relative(this.root, symlink),
@@ -323,7 +323,7 @@ export default class FallbackWatcher extends AbstractWatcher {
             }
           },
           function endCallback() {},
-          this._checkedEmitError,
+          this.#checkedEmitError,
           this.ignored,
         );
       } else {
@@ -337,10 +337,10 @@ export default class FallbackWatcher extends AbstractWatcher {
           type,
         };
         if (registered) {
-          this._emitEvent({event: TOUCH_EVENT, relativePath, metadata});
+          this.#emitEvent({event: TOUCH_EVENT, relativePath, metadata});
         } else {
-          if (this._register(fullPath, type)) {
-            this._emitEvent({event: TOUCH_EVENT, relativePath, metadata});
+          if (this.#register(fullPath, type)) {
+            this.#emitEvent({event: TOUCH_EVENT, relativePath, metadata});
           }
         }
       }
@@ -349,12 +349,12 @@ export default class FallbackWatcher extends AbstractWatcher {
         this.emitError(error);
         return;
       }
-      this._unregister(fullPath);
-      this._unregisterDir(fullPath);
+      this.#unregister(fullPath);
+      this.#unregisterDir(fullPath);
       if (registered) {
-        this._emitEvent({event: DELETE_EVENT, relativePath});
+        this.#emitEvent({event: DELETE_EVENT, relativePath});
       }
-      await this._stopWatching(fullPath);
+      await this.#stopWatching(fullPath);
     }
   }
 
@@ -365,17 +365,17 @@ export default class FallbackWatcher extends AbstractWatcher {
    *
    * See also note above for DEBOUNCE_MS.
    */
-  _emitEvent(change: Omit<WatcherBackendChangeEvent, 'root'>) {
+  #emitEvent(change: Omit<WatcherBackendChangeEvent, 'root'>) {
     const {event, relativePath} = change;
     const key = event + '-' + relativePath;
-    const existingTimer = this._changeTimers.get(key);
+    const existingTimer = this.#changeTimers.get(key);
     if (existingTimer) {
       clearTimeout(existingTimer);
     }
-    this._changeTimers.set(
+    this.#changeTimers.set(
       key,
       setTimeout(() => {
-        this._changeTimers.delete(key);
+        this.#changeTimers.delete(key);
         this.emitFileEvent(change);
       }, DEBOUNCE_MS),
     );

package/src/watchers/NativeWatcher.js

@@ -9,28 +9,32 @@ var _common = require("./common");
 var _fs = require("fs");
 var _os = require("os");
 var path = _interopRequireWildcard(require("path"));
-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);
 }
 const debug = require("debug")("Metro:NativeWatcher");
 const TOUCH_EVENT = "touch";

package/src/watchers/NativeWatcher.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 {FSWatcher} from 'fs';
@@ -51,9 +51,9 @@ export default class NativeWatcher extends AbstractWatcher {
 
   constructor(
     dir: string,
-    opts: $ReadOnly<{
+    opts: Readonly<{
       ignored: ?RegExp,
-      globs: $ReadOnlyArray<string>,
+      globs: ReadonlyArray<string>,
       dot: boolean,
       ...
     }>,

package/src/watchers/RecrawlWarning.js.flow

@@ -38,7 +38,7 @@ export default class RecrawlWarning {
     return undefined;
   }
 
-  static isRecrawlWarningDupe(warningMessage: mixed): boolean {
+  static isRecrawlWarningDupe(warningMessage: unknown): boolean {
     if (typeof warningMessage !== 'string') {
       return false;
     }

package/src/watchers/WatchmanWatcher.js

@@ -14,28 +14,32 @@ var _assert = _interopRequireDefault(require("assert"));
 var _crypto = require("crypto");
 var _fbWatchman = _interopRequireDefault(require("fb-watchman"));
 var _invariant = _interopRequireDefault(require("invariant"));
-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 };
@@ -45,10 +49,14 @@ const DELETE_EVENT = common.DELETE_EVENT;
 const TOUCH_EVENT = common.TOUCH_EVENT;
 const SUB_PREFIX = "metro-file-map";
 class WatchmanWatcher extends _AbstractWatcher.AbstractWatcher {
+  #client;
+  #watchProjectInfo;
+  #watchmanDeferStates;
   #deferringStates = null;
-  constructor(dir, { watchmanDeferStates, ...opts }) {
-    super(dir, opts);
-    this.watchmanDeferStates = watchmanDeferStates;
+  constructor(dir, opts) {
+    const { watchmanDeferStates, ...baseOpts } = opts;
+    super(dir, baseOpts);
+    this.#watchmanDeferStates = watchmanDeferStates;
     const watchKey = (0, _crypto.createHash)("md5")
       .update(this.root)
       .digest("hex");
@@ -58,32 +66,32 @@ class WatchmanWatcher extends _AbstractWatcher.AbstractWatcher {
     this.subscriptionName = `${SUB_PREFIX}-${process.pid}-${readablePath}-${watchKey}`;
   }
   async startWatching() {
-    await new Promise((resolve, reject) => this._init(resolve, reject));
+    await new Promise((resolve, reject) => this.#init(resolve, reject));
   }
-  _init(onReady, onError) {
-    if (this.client) {
-      this.client.removeAllListeners();
+  #init(onReady, onError) {
+    if (this.#client) {
+      this.#client.removeAllListeners();
     }
     const self = this;
-    this.client = new _fbWatchman.default.Client();
-    this.client.on("error", (error) => {
+    this.#client = new _fbWatchman.default.Client();
+    this.#client.on("error", (error) => {
       this.emitError(error);
     });
-    this.client.on("subscription", (changeEvent) =>
-      this._handleChangeEvent(changeEvent),
+    this.#client.on("subscription", (changeEvent) =>
+      this.#handleChangeEvent(changeEvent),
     );
-    this.client.on("end", () => {
+    this.#client.on("end", () => {
       console.warn(
         "[metro-file-map] Warning: Lost connection to Watchman, reconnecting..",
       );
-      self._init(
+      self.#init(
         () => {},
         (error) => self.emitError(error),
       );
     });
-    this.watchProjectInfo = null;
+    this.#watchProjectInfo = null;
     function getWatchRoot() {
-      return self.watchProjectInfo ? self.watchProjectInfo.root : self.root;
+      return self.#watchProjectInfo ? self.#watchProjectInfo.root : self.root;
     }
     function onWatchProject(error, resp) {
       if (error) {
@@ -92,13 +100,13 @@ class WatchmanWatcher extends _AbstractWatcher.AbstractWatcher {
       }
       debug("Received watch-project response: %s", resp.relative_path);
       handleWarning(resp);
-      self.watchProjectInfo = {
+      self.#watchProjectInfo = {
         relativePath: resp.relative_path
           ? (0, _normalizePathSeparatorsToSystem.default)(resp.relative_path)
           : "",
         root: (0, _normalizePathSeparatorsToSystem.default)(resp.watch),
       };
-      self.client.command(["clock", getWatchRoot()], onClock);
+      self.#client.command(["clock", getWatchRoot()], onClock);
     }
     function onClock(error, resp) {
       if (error) {
@@ -106,7 +114,7 @@ class WatchmanWatcher extends _AbstractWatcher.AbstractWatcher {
         return;
       }
       debug("Received clock response: %s", resp.clock);
-      const watchProjectInfo = self.watchProjectInfo;
+      const watchProjectInfo = self.#watchProjectInfo;
       (0, _invariant.default)(
         watchProjectInfo != null,
         "watch-project response should have been set before clock response",
@@ -115,7 +123,7 @@ class WatchmanWatcher extends _AbstractWatcher.AbstractWatcher {
       const options = {
         fields: ["name", "exists", "new", "type", "size", "mtime_ms"],
         since: resp.clock,
-        defer: self.watchmanDeferStates,
+        defer: self.#watchmanDeferStates,
         relative_root: watchProjectInfo.relativePath,
       };
       if (self.globs.length === 0 && !self.dot) {
@@ -128,7 +136,7 @@ class WatchmanWatcher extends _AbstractWatcher.AbstractWatcher {
           },
         ];
       }
-      self.client.command(
+      self.#client.command(
         ["subscribe", getWatchRoot(), self.subscriptionName, options],
         onSubscribe,
       );
@@ -145,9 +153,9 @@ class WatchmanWatcher extends _AbstractWatcher.AbstractWatcher {
       }
       onReady();
     };
-    self.client.command(["watch-project", getWatchRoot()], onWatchProject);
+    self.#client.command(["watch-project", getWatchRoot()], onWatchProject);
   }
-  _handleChangeEvent(resp) {
+  #handleChangeEvent(resp) {
     debug(
       "Received subscription response: %s (fresh: %s, files: %s, enter: %s, leave: %s, clock: %s)",
       resp.subscription,
@@ -164,13 +172,13 @@ class WatchmanWatcher extends _AbstractWatcher.AbstractWatcher {
     );
     if (Array.isArray(resp.files)) {
       resp.files.forEach((change) =>
-        this._handleFileChange(change, resp.clock),
+        this.#handleFileChange(change, resp.clock),
       );
     }
     const { "state-enter": stateEnter, "state-leave": stateLeave } = resp;
     if (
       stateEnter != null &&
-      (this.watchmanDeferStates ?? []).includes(stateEnter)
+      (this.#watchmanDeferStates ?? []).includes(stateEnter)
     ) {
       this.#deferringStates?.add(stateEnter);
       debug(
@@ -180,7 +188,7 @@ class WatchmanWatcher extends _AbstractWatcher.AbstractWatcher {
     }
     if (
       stateLeave != null &&
-      (this.watchmanDeferStates ?? []).includes(stateLeave)
+      (this.#watchmanDeferStates ?? []).includes(stateLeave)
     ) {
       this.#deferringStates?.delete(stateLeave);
       debug(
@@ -189,9 +197,9 @@ class WatchmanWatcher extends _AbstractWatcher.AbstractWatcher {
       );
     }
   }
-  _handleFileChange(changeDescriptor, rawClock) {
+  #handleFileChange(changeDescriptor, rawClock) {
     const self = this;
-    const watchProjectInfo = self.watchProjectInfo;
+    const watchProjectInfo = self.#watchProjectInfo;
     (0, _invariant.default)(
       watchProjectInfo != null,
       "watch-project response should have been set before receiving subscription events",
@@ -224,8 +232,8 @@ class WatchmanWatcher extends _AbstractWatcher.AbstractWatcher {
       return;
     }
     const clock =
-      typeof rawClock === "string" && this.watchProjectInfo != null
-        ? [this.watchProjectInfo.root, rawClock]
+      typeof rawClock === "string" && this.#watchProjectInfo != null
+        ? [this.#watchProjectInfo.root, rawClock]
         : undefined;
     if (!exists) {
       self.emitFileEvent({
@@ -260,9 +268,9 @@ class WatchmanWatcher extends _AbstractWatcher.AbstractWatcher {
   }
   async stopWatching() {
     await super.stopWatching();
-    if (this.client) {
-      this.client.removeAllListeners();
-      this.client.end();
+    if (this.#client) {
+      this.#client.removeAllListeners();
+      this.#client.end();
     }
     this.#deferringStates = null;
   }