metro-file-map 0.73.7 → 0.73.9

package/package.json

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

package/src/watchers/FSEventsWatcher.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _anymatch = _interopRequireDefault(require("anymatch"));
 var _events = _interopRequireDefault(require("events"));
-var fs = _interopRequireWildcard(require("graceful-fs"));
+var _fs = require("fs");
 var path = _interopRequireWildcard(require("path"));
 var _walker = _interopRequireDefault(require("walker"));
 var _common = require("./common");
@@ -69,8 +69,6 @@ function _interopRequireDefault(obj) {
 
 // $FlowFixMe[untyped-import] - walker
 
-// $FlowFixMe[untyped-import] - micromatch
-const micromatch = require("micromatch");
 const debug = require("debug")("Metro:FSEventsWatcher");
 let fsevents = null;
 try {
@@ -101,6 +99,7 @@ class FSEventsWatcher extends _events.default {
     dir,
     dirCallback,
     fileCallback,
+    symlinkCallback,
     // $FlowFixMe[unclear-type] Add types for callback
     endCallback,
     // $FlowFixMe[unclear-type] Add types for callback
@@ -113,6 +112,7 @@ class FSEventsWatcher extends _events.default {
       )
       .on("dir", FSEventsWatcher._normalizeProxy(dirCallback))
       .on("file", FSEventsWatcher._normalizeProxy(fileCallback))
+      .on("symlink", FSEventsWatcher._normalizeProxy(symlinkCallback))
       .on("error", errorCallback)
       .on("end", () => {
         endCallback();
@@ -132,25 +132,25 @@ class FSEventsWatcher extends _events.default {
     this.dot = opts.dot || false;
     this.ignored = opts.ignored;
     this.glob = Array.isArray(opts.glob) ? opts.glob : [opts.glob];
-    this.hasIgnore =
-      Boolean(opts.ignored) && !(Array.isArray(opts) && opts.length > 0);
     this.doIgnore = opts.ignored
       ? (0, _anymatch.default)(opts.ignored)
       : () => false;
     this.root = path.resolve(dir);
-    this.fsEventsWatchStopper = fsevents.watch(this.root, (path) =>
-      this._handleEvent(path)
-    );
+    this.fsEventsWatchStopper = fsevents.watch(this.root, (path) => {
+      this._handleEvent(path).catch((error) => {
+        this.emit("error", error);
+      });
+    });
     debug(`Watching ${this.root}`);
     this._tracked = new Set();
+    const trackPath = (filePath) => {
+      this._tracked.add(filePath);
+    };
     FSEventsWatcher._recReaddir(
       this.root,
-      (filepath) => {
-        this._tracked.add(filepath);
-      },
-      (filepath) => {
-        this._tracked.add(filepath);
-      },
+      trackPath,
+      trackPath,
+      trackPath,
       // $FlowFixMe[method-unbinding] - Refactor
       this.emit.bind(this, "ready"),
       // $FlowFixMe[method-unbinding] - Refactor
@@ -170,39 +170,27 @@ class FSEventsWatcher extends _events.default {
       process.nextTick(callback.bind(null, null, true));
     }
   }
-  _isFileIncluded(relativePath) {
-    if (this.doIgnore(relativePath)) {
-      return false;
-    }
-    return this.glob.length
-      ? micromatch([relativePath], this.glob, {
-          dot: this.dot,
-        }).length > 0
-      : this.dot || micromatch([relativePath], "**/*").length > 0;
-  }
-  _handleEvent(filepath) {
+  async _handleEvent(filepath) {
     const relativePath = path.relative(this.root, filepath);
-    if (!this._isFileIncluded(relativePath)) {
-      return;
-    }
-    fs.lstat(filepath, (error, stat) => {
-      if (error && error.code !== "ENOENT") {
-        this.emit("error", error);
-        return;
-      }
-      if (error) {
-        // Ignore files that aren't tracked and don't exist.
-        if (!this._tracked.has(filepath)) {
-          return;
-        }
-        this._emit(DELETE_EVENT, relativePath);
-        this._tracked.delete(filepath);
-        return;
-      }
+    try {
+      const stat = await _fs.promises.lstat(filepath);
       const type = (0, _common.typeFromStat)(stat);
+
+      // Ignore files of an unrecognized type
       if (!type) {
         return;
       }
+      if (
+        !(0, _common.isIncluded)(
+          type,
+          this.glob,
+          this.dot,
+          this.doIgnore,
+          relativePath
+        )
+      ) {
+        return;
+      }
       const metadata = {
         type,
         modifiedTime: stat.mtime.getTime(),
@@ -214,7 +202,21 @@ class FSEventsWatcher extends _events.default {
         this._tracked.add(filepath);
         this._emit(ADD_EVENT, relativePath, metadata);
       }
-    });
+    } catch (error) {
+      if (
+        (error === null || error === void 0 ? void 0 : error.code) !== "ENOENT"
+      ) {
+        this.emit("error", error);
+        return;
+      }
+
+      // Ignore files that aren't tracked and don't exist.
+      if (!this._tracked.has(filepath)) {
+        return;
+      }
+      this._emit(DELETE_EVENT, relativePath);
+      this._tracked.delete(filepath);
+    }
   }
 
   /**

package/src/watchers/FSEventsWatcher.js.flow

@@ -9,20 +9,18 @@
  */
 
 import type {ChangeEventMetadata} from '../flow-types';
+import type {Stats} from 'fs';
 // $FlowFixMe[cannot-resolve-module] - Optional, Darwin only
 import type {FSEvents} from 'fsevents';
 
 // $FlowFixMe[untyped-import] - anymatch
 import anymatch from 'anymatch';
 import EventEmitter from 'events';
-import * as fs from 'graceful-fs';
+import {promises as fsPromises} from 'fs';
 import * as path from 'path';
 // $FlowFixMe[untyped-import] - walker
 import walker from 'walker';
-import {typeFromStat} from './common';
-
-// $FlowFixMe[untyped-import] - micromatch
-const micromatch = require('micromatch');
+import {isIncluded, typeFromStat} from './common';
 
 const debug = require('debug')('Metro:FSEventsWatcher');
 
@@ -56,7 +54,6 @@ export default class FSEventsWatcher extends EventEmitter {
   +ignored: ?Matcher;
   +glob: $ReadOnlyArray<string>;
   +dot: boolean;
-  +hasIgnore: boolean;
   +doIgnore: (path: string) => boolean;
   +fsEventsWatchStopper: () => Promise<void>;
   _tracked: Set<string>;
@@ -66,17 +63,18 @@ export default class FSEventsWatcher extends EventEmitter {
   }
 
   static _normalizeProxy(
-    callback: (normalizedPath: string, stats: fs.Stats) => void,
+    callback: (normalizedPath: string, stats: Stats) => void,
     // $FlowFixMe[cannot-resolve-name]
   ): (filepath: string, stats: Stats) => void {
-    return (filepath: string, stats: fs.Stats): void =>
+    return (filepath: string, stats: Stats): void =>
       callback(path.normalize(filepath), stats);
   }
 
   static _recReaddir(
     dir: string,
-    dirCallback: (normalizedPath: string, stats: fs.Stats) => void,
-    fileCallback: (normalizedPath: string, stats: fs.Stats) => void,
+    dirCallback: (normalizedPath: string, stats: Stats) => void,
+    fileCallback: (normalizedPath: string, stats: Stats) => void,
+    symlinkCallback: (normalizedPath: string, stats: Stats) => void,
     // $FlowFixMe[unclear-type] Add types for callback
     endCallback: Function,
     // $FlowFixMe[unclear-type] Add types for callback
@@ -89,6 +87,7 @@ export default class FSEventsWatcher extends EventEmitter {
       )
       .on('dir', FSEventsWatcher._normalizeProxy(dirCallback))
       .on('file', FSEventsWatcher._normalizeProxy(fileCallback))
+      .on('symlink', FSEventsWatcher._normalizeProxy(symlinkCallback))
       .on('error', errorCallback)
       .on('end', () => {
         endCallback();
@@ -116,28 +115,27 @@ export default class FSEventsWatcher extends EventEmitter {
     this.dot = opts.dot || false;
     this.ignored = opts.ignored;
     this.glob = Array.isArray(opts.glob) ? opts.glob : [opts.glob];
-
-    this.hasIgnore =
-      Boolean(opts.ignored) && !(Array.isArray(opts) && opts.length > 0);
     this.doIgnore = opts.ignored ? anymatch(opts.ignored) : () => false;
 
     this.root = path.resolve(dir);
 
-    this.fsEventsWatchStopper = fsevents.watch(this.root, path =>
-      this._handleEvent(path),
-    );
+    this.fsEventsWatchStopper = fsevents.watch(this.root, path => {
+      this._handleEvent(path).catch(error => {
+        this.emit('error', error);
+      });
+    });
 
     debug(`Watching ${this.root}`);
 
     this._tracked = new Set();
+    const trackPath = (filePath: string) => {
+      this._tracked.add(filePath);
+    };
     FSEventsWatcher._recReaddir(
       this.root,
-      (filepath: string) => {
-        this._tracked.add(filepath);
-      },
-      (filepath: string) => {
-        this._tracked.add(filepath);
-      },
+      trackPath,
+      trackPath,
+      trackPath,
       // $FlowFixMe[method-unbinding] - Refactor
       this.emit.bind(this, 'ready'),
       // $FlowFixMe[method-unbinding] - Refactor
@@ -158,42 +156,22 @@ export default class FSEventsWatcher extends EventEmitter {
     }
   }
 
-  _isFileIncluded(relativePath: string): boolean {
-    if (this.doIgnore(relativePath)) {
-      return false;
-    }
-    return this.glob.length
-      ? micromatch([relativePath], this.glob, {dot: this.dot}).length > 0
-      : this.dot || micromatch([relativePath], '**/*').length > 0;
-  }
-
-  _handleEvent(filepath: string) {
+  async _handleEvent(filepath: string) {
     const relativePath = path.relative(this.root, filepath);
-    if (!this._isFileIncluded(relativePath)) {
-      return;
-    }
-
-    fs.lstat(filepath, (error, stat) => {
-      if (error && error.code !== 'ENOENT') {
-        this.emit('error', error);
-        return;
-      }
 
-      if (error) {
-        // Ignore files that aren't tracked and don't exist.
-        if (!this._tracked.has(filepath)) {
-          return;
-        }
+    try {
+      const stat = await fsPromises.lstat(filepath);
+      const type = typeFromStat(stat);
 
-        this._emit(DELETE_EVENT, relativePath);
-        this._tracked.delete(filepath);
+      // Ignore files of an unrecognized type
+      if (!type) {
         return;
       }
 
-      const type = typeFromStat(stat);
-      if (!type) {
+      if (!isIncluded(type, this.glob, this.dot, this.doIgnore, relativePath)) {
         return;
       }
+
       const metadata: ChangeEventMetadata = {
         type,
         modifiedTime: stat.mtime.getTime(),
@@ -206,7 +184,20 @@ export default class FSEventsWatcher extends EventEmitter {
         this._tracked.add(filepath);
         this._emit(ADD_EVENT, relativePath, metadata);
       }
-    });
+    } catch (error) {
+      if (error?.code !== 'ENOENT') {
+        this.emit('error', error);
+        return;
+      }
+
+      // Ignore files that aren't tracked and don't exist.
+      if (!this._tracked.has(filepath)) {
+        return;
+      }
+
+      this._emit(DELETE_EVENT, relativePath);
+      this._tracked.delete(filepath);
+    }
   }
 
   /**

package/src/watchers/NodeWatcher.js

@@ -20,6 +20,7 @@ const { EventEmitter } = require("events");
 const fs = require("fs");
 const platform = require("os").platform();
 const path = require("path");
+const fsPromises = fs.promises;
 const CHANGE_EVENT = common.CHANGE_EVENT;
 const DELETE_EVENT = common.DELETE_EVENT;
 const ADD_EVENT = common.ADD_EVENT;
@@ -46,7 +47,10 @@ module.exports = class NodeWatcher extends EventEmitter {
         this._watchdir(dir);
       },
       (filename) => {
-        this._register(filename);
+        this._register(filename, "f");
+      },
+      (symlink) => {
+        this._register(symlink, "l");
       },
       () => {
         this.emit("ready");
@@ -70,7 +74,7 @@ module.exports = class NodeWatcher extends EventEmitter {
    *
    *  Return false if ignored or already registered.
    */
-  _register(filepath) {
+  _register(filepath, type) {
     const dir = path.dirname(filepath);
     const filename = path.basename(filepath);
     if (this._dirRegistry[dir] && this._dirRegistry[dir][filename]) {
@@ -78,7 +82,8 @@ module.exports = class NodeWatcher extends EventEmitter {
     }
     const relativePath = path.relative(this.root, filepath);
     if (
-      !common.isFileIncluded(this.globs, this.dot, this.doIgnore, relativePath)
+      type === "f" &&
+      !common.isIncluded("f", this.globs, this.dot, this.doIgnore, relativePath)
     ) {
       return false;
     }
@@ -147,7 +152,7 @@ module.exports = class NodeWatcher extends EventEmitter {
     this.watched[dir] = watcher;
     watcher.on("error", this._checkedEmitError);
     if (this.root !== dir) {
-      this._register(dir);
+      this._register(dir, "d");
     }
     return true;
   };
@@ -216,91 +221,108 @@ module.exports = class NodeWatcher extends EventEmitter {
     if (!file) {
       this._detectChangedFile(dir, event, (actualFile) => {
         if (actualFile) {
-          this._processChange(dir, event, actualFile);
+          this._processChange(dir, event, actualFile).catch((error) =>
+            this.emit("error", error)
+          );
         }
       });
     } else {
-      this._processChange(dir, event, path.normalize(file));
+      this._processChange(dir, event, path.normalize(file)).catch((error) =>
+        this.emit("error", error)
+      );
     }
   }
 
   /**
    * Process changes.
    */
-  _processChange(dir, event, file) {
+  async _processChange(dir, event, file) {
     const fullPath = path.join(dir, file);
     const relativePath = path.join(path.relative(this.root, dir), file);
-    fs.lstat(fullPath, (error, stat) => {
-      if (error && error.code !== "ENOENT") {
-        this.emit("error", error);
-      } else if (!error && stat.isDirectory()) {
+    const registered = this._registered(fullPath);
+    try {
+      const stat = await fsPromises.lstat(fullPath);
+      if (stat.isDirectory()) {
+        // win32 emits usless change events on dirs.
         if (event === "change") {
-          // win32 emits usless change events on dirs.
           return;
         }
         if (
-          stat &&
-          common.isFileIncluded(
+          !common.isIncluded(
+            "d",
             this.globs,
             this.dot,
             this.doIgnore,
             relativePath
           )
         ) {
-          common.recReaddir(
-            path.resolve(this.root, relativePath),
-            (dir, stats) => {
-              if (this._watchdir(dir)) {
-                this._emitEvent(ADD_EVENT, path.relative(this.root, dir), {
-                  modifiedTime: stats.mtime.getTime(),
-                  size: stats.size,
-                  type: "d",
-                });
-              }
-            },
-            (file, stats) => {
-              if (this._register(file)) {
-                this._emitEvent(ADD_EVENT, path.relative(this.root, file), {
-                  modifiedTime: stats.mtime.getTime(),
-                  size: stats.size,
-                  type: "f",
-                });
-              }
-            },
-            function endCallback() {},
-            this._checkedEmitError,
-            this.ignored
-          );
+          return;
         }
+        common.recReaddir(
+          path.resolve(this.root, relativePath),
+          (dir, stats) => {
+            if (this._watchdir(dir)) {
+              this._emitEvent(ADD_EVENT, path.relative(this.root, dir), {
+                modifiedTime: stats.mtime.getTime(),
+                size: stats.size,
+                type: "d",
+              });
+            }
+          },
+          (file, stats) => {
+            if (this._register(file, "f")) {
+              this._emitEvent(ADD_EVENT, path.relative(this.root, file), {
+                modifiedTime: stats.mtime.getTime(),
+                size: stats.size,
+                type: "f",
+              });
+            }
+          },
+          (symlink, stats) => {
+            if (this._register(symlink, "l")) {
+              this._rawEmitEvent(ADD_EVENT, path.relative(this.root, symlink), {
+                modifiedTime: stats.mtime.getTime(),
+                size: stats.size,
+                type: "l",
+              });
+            }
+          },
+          function endCallback() {},
+          this._checkedEmitError,
+          this.ignored
+        );
       } else {
-        const registered = this._registered(fullPath);
-        if (error && error.code === "ENOENT") {
-          this._unregister(fullPath);
-          this._stopWatching(fullPath);
-          this._unregisterDir(fullPath);
-          if (registered) {
-            this._emitEvent(DELETE_EVENT, relativePath);
-          }
+        const type = common.typeFromStat(stat);
+        if (type == null) {
+          return;
+        }
+        const metadata = {
+          modifiedTime: stat.mtime.getTime(),
+          size: stat.size,
+          type,
+        };
+        if (registered) {
+          this._emitEvent(CHANGE_EVENT, relativePath, metadata);
         } else {
-          const type = common.typeFromStat(stat);
-          if (type == null) {
-            return;
-          }
-          const metadata = {
-            modifiedTime: stat.mtime.getTime(),
-            size: stat.size,
-            type,
-          };
-          if (registered) {
-            this._emitEvent(CHANGE_EVENT, relativePath, metadata);
-          } else {
-            if (this._register(fullPath)) {
-              this._emitEvent(ADD_EVENT, relativePath, metadata);
-            }
+          if (this._register(fullPath, type)) {
+            this._emitEvent(ADD_EVENT, relativePath, metadata);
           }
         }
       }
-    });
+    } catch (error) {
+      if (
+        (error === null || error === void 0 ? void 0 : error.code) !== "ENOENT"
+      ) {
+        this.emit("error", error);
+        return;
+      }
+      this._unregister(fullPath);
+      this._stopWatching(fullPath);
+      this._unregisterDir(fullPath);
+      if (registered) {
+        this._emitEvent(DELETE_EVENT, relativePath);
+      }
+    }
   }
 
   /**

package/src/watchers/NodeWatcher.js.flow

@@ -25,6 +25,8 @@ const fs = require('fs');
 const platform = require('os').platform();
 const path = require('path');
 
+const fsPromises = fs.promises;
+
 const CHANGE_EVENT = common.CHANGE_EVENT;
 const DELETE_EVENT = common.DELETE_EVENT;
 const ADD_EVENT = common.ADD_EVENT;
@@ -46,7 +48,6 @@ module.exports = class NodeWatcher extends EventEmitter {
   doIgnore: string => boolean;
   dot: boolean;
   globs: $ReadOnlyArray<string>;
-  hasIgnore: boolean;
   ignored: ?(boolean | RegExp);
   root: string;
   watched: {[key: string]: FSWatcher, __proto__: null};
@@ -68,7 +69,10 @@ module.exports = class NodeWatcher extends EventEmitter {
         this._watchdir(dir);
       },
       filename => {
-        this._register(filename);
+        this._register(filename, 'f');
+      },
+      symlink => {
+        this._register(symlink, 'l');
       },
       () => {
         this.emit('ready');
@@ -92,7 +96,7 @@ module.exports = class NodeWatcher extends EventEmitter {
    *
    *  Return false if ignored or already registered.
    */
-  _register(filepath: string): 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]) {
@@ -101,7 +105,8 @@ module.exports = class NodeWatcher extends EventEmitter {
 
     const relativePath = path.relative(this.root, filepath);
     if (
-      !common.isFileIncluded(this.globs, this.dot, this.doIgnore, relativePath)
+      type === 'f' &&
+      !common.isIncluded('f', this.globs, this.dot, this.doIgnore, relativePath)
     ) {
       return false;
     }
@@ -171,7 +176,7 @@ module.exports = class NodeWatcher extends EventEmitter {
     watcher.on('error', this._checkedEmitError);
 
     if (this.root !== dir) {
-      this._register(dir);
+      this._register(dir, 'd');
     }
     return true;
   };
@@ -243,92 +248,109 @@ module.exports = class NodeWatcher extends EventEmitter {
     if (!file) {
       this._detectChangedFile(dir, event, actualFile => {
         if (actualFile) {
-          this._processChange(dir, event, actualFile);
+          this._processChange(dir, event, actualFile).catch(error =>
+            this.emit('error', error),
+          );
         }
       });
     } else {
-      this._processChange(dir, event, path.normalize(file));
+      this._processChange(dir, event, path.normalize(file)).catch(error =>
+        this.emit('error', error),
+      );
     }
   }
 
   /**
    * Process changes.
    */
-  _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);
 
-    fs.lstat(fullPath, (error, stat) => {
-      if (error && error.code !== 'ENOENT') {
-        this.emit('error', error);
-      } else if (!error && stat.isDirectory()) {
+    const registered = this._registered(fullPath);
+
+    try {
+      const stat = await fsPromises.lstat(fullPath);
+      if (stat.isDirectory()) {
+        // win32 emits usless change events on dirs.
         if (event === 'change') {
-          // win32 emits usless change events on dirs.
           return;
         }
+
         if (
-          stat &&
-          common.isFileIncluded(
+          !common.isIncluded(
+            'd',
             this.globs,
             this.dot,
             this.doIgnore,
             relativePath,
           )
         ) {
-          common.recReaddir(
-            path.resolve(this.root, relativePath),
-            (dir, stats) => {
-              if (this._watchdir(dir)) {
-                this._emitEvent(ADD_EVENT, path.relative(this.root, dir), {
-                  modifiedTime: stats.mtime.getTime(),
-                  size: stats.size,
-                  type: 'd',
-                });
-              }
-            },
-            (file, stats) => {
-              if (this._register(file)) {
-                this._emitEvent(ADD_EVENT, path.relative(this.root, file), {
-                  modifiedTime: stats.mtime.getTime(),
-                  size: stats.size,
-                  type: 'f',
-                });
-              }
-            },
-            function endCallback() {},
-            this._checkedEmitError,
-            this.ignored,
-          );
+          return;
         }
+        common.recReaddir(
+          path.resolve(this.root, relativePath),
+          (dir, stats) => {
+            if (this._watchdir(dir)) {
+              this._emitEvent(ADD_EVENT, path.relative(this.root, dir), {
+                modifiedTime: stats.mtime.getTime(),
+                size: stats.size,
+                type: 'd',
+              });
+            }
+          },
+          (file, stats) => {
+            if (this._register(file, 'f')) {
+              this._emitEvent(ADD_EVENT, path.relative(this.root, file), {
+                modifiedTime: stats.mtime.getTime(),
+                size: stats.size,
+                type: 'f',
+              });
+            }
+          },
+          (symlink, stats) => {
+            if (this._register(symlink, 'l')) {
+              this._rawEmitEvent(ADD_EVENT, path.relative(this.root, symlink), {
+                modifiedTime: stats.mtime.getTime(),
+                size: stats.size,
+                type: 'l',
+              });
+            }
+          },
+          function endCallback() {},
+          this._checkedEmitError,
+          this.ignored,
+        );
       } else {
-        const registered = this._registered(fullPath);
-        if (error && error.code === 'ENOENT') {
-          this._unregister(fullPath);
-          this._stopWatching(fullPath);
-          this._unregisterDir(fullPath);
-          if (registered) {
-            this._emitEvent(DELETE_EVENT, relativePath);
-          }
+        const type = common.typeFromStat(stat);
+        if (type == null) {
+          return;
+        }
+        const metadata = {
+          modifiedTime: stat.mtime.getTime(),
+          size: stat.size,
+          type,
+        };
+        if (registered) {
+          this._emitEvent(CHANGE_EVENT, relativePath, metadata);
         } else {
-          const type = common.typeFromStat(stat);
-          if (type == null) {
-            return;
-          }
-          const metadata = {
-            modifiedTime: stat.mtime.getTime(),
-            size: stat.size,
-            type,
-          };
-          if (registered) {
-            this._emitEvent(CHANGE_EVENT, relativePath, metadata);
-          } else {
-            if (this._register(fullPath)) {
-              this._emitEvent(ADD_EVENT, relativePath, metadata);
-            }
+          if (this._register(fullPath, type)) {
+            this._emitEvent(ADD_EVENT, relativePath, metadata);
           }
         }
       }
-    });
+    } catch (error) {
+      if (error?.code !== 'ENOENT') {
+        this.emit('error', error);
+        return;
+      }
+      this._unregister(fullPath);
+      this._stopWatching(fullPath);
+      this._unregisterDir(fullPath);
+      if (registered) {
+        this._emitEvent(DELETE_EVENT, relativePath);
+      }
+    }
   }
 
   /**

package/src/watchers/WatchmanWatcher.js

@@ -258,14 +258,25 @@ class WatchmanWatcher extends _events.default {
       size,
     } = changeDescriptor;
     debug(
-      "Handling change to: %s (new: %s, exists: %s)",
+      "Handling change to: %s (new: %s, exists: %s, type: %s)",
       relativePath,
       isNew,
-      exists
+      exists,
+      type
     );
+
+    // Ignore files of an unrecognized type
+    if (type != null && !(type === "f" || type === "d" || type === "l")) {
+      return;
+    }
     if (
-      this.hasIgnore &&
-      !common.isFileIncluded(this.globs, this.dot, this.doIgnore, relativePath)
+      !common.isIncluded(
+        type,
+        this.globs,
+        this.dot,
+        this.doIgnore,
+        relativePath
+      )
     ) {
       return;
     }
@@ -283,10 +294,8 @@ class WatchmanWatcher extends _events.default {
         size
       );
       if (
-        type === "f" ||
-        type === "l" ||
         // Change event on dirs are mostly useless.
-        (type === "d" && eventType !== CHANGE_EVENT)
+        !(type === "d" && eventType === CHANGE_EVENT)
       ) {
         self._emitEvent(eventType, relativePath, self.root, {
           modifiedTime: Number(mtime_ms),

package/src/watchers/WatchmanWatcher.js.flow

@@ -46,7 +46,6 @@ export default class WatchmanWatcher extends EventEmitter {
   dot: boolean;
   doIgnore: string => boolean;
   globs: $ReadOnlyArray<string>;
-  hasIgnore: boolean;
   root: string;
   subscriptionName: string;
   watchProjectInfo: ?$ReadOnly<{
@@ -248,15 +247,26 @@ export default class WatchmanWatcher extends EventEmitter {
     } = changeDescriptor;
 
     debug(
-      'Handling change to: %s (new: %s, exists: %s)',
+      'Handling change to: %s (new: %s, exists: %s, type: %s)',
       relativePath,
       isNew,
       exists,
+      type,
     );
 
+    // Ignore files of an unrecognized type
+    if (type != null && !(type === 'f' || type === 'd' || type === 'l')) {
+      return;
+    }
+
     if (
-      this.hasIgnore &&
-      !common.isFileIncluded(this.globs, this.dot, this.doIgnore, relativePath)
+      !common.isIncluded(
+        type,
+        this.globs,
+        this.dot,
+        this.doIgnore,
+        relativePath,
+      )
     ) {
       return;
     }
@@ -276,10 +286,8 @@ export default class WatchmanWatcher extends EventEmitter {
       );
 
       if (
-        type === 'f' ||
-        type === 'l' ||
         // Change event on dirs are mostly useless.
-        (type === 'd' && eventType !== CHANGE_EVENT)
+        !(type === 'd' && eventType === CHANGE_EVENT)
       ) {
         self._emitEvent(eventType, relativePath, self.root, {
           modifiedTime: Number(mtime_ms),

package/src/watchers/common.js

@@ -25,7 +25,7 @@ exports.assignOptions =
   exports.ALL_EVENT =
   exports.ADD_EVENT =
     void 0;
-exports.isFileIncluded = isFileIncluded;
+exports.isIncluded = isIncluded;
 exports.recReaddir = recReaddir;
 exports.typeFromStat = typeFromStat;
 // $FlowFixMe[untyped-import] - Write libdefs for `anymatch`
@@ -72,8 +72,6 @@ const assignOptions = function (watcher, opts) {
   if (!Array.isArray(watcher.globs)) {
     watcher.globs = [watcher.globs];
   }
-  watcher.hasIgnore =
-    Boolean(opts.ignored) && !(Array.isArray(opts) && opts.length > 0);
   watcher.doIgnore =
     opts.ignored != null && opts.ignored !== false
       ? anymatch(opts.ignored)
@@ -88,15 +86,18 @@ const assignOptions = function (watcher, opts) {
  * Checks a file relative path against the globs array.
  */
 exports.assignOptions = assignOptions;
-function isFileIncluded(globs, dot, doIgnore, relativePath) {
+function isIncluded(type, globs, dot, doIgnore, relativePath) {
   if (doIgnore(relativePath)) {
     return false;
   }
-  return globs.length
-    ? micromatch.some(relativePath, globs, {
-        dot,
-      })
-    : dot || micromatch.some(relativePath, "**/*");
+  // For non-regular files or if there are no glob matchers, just respect the
+  // `dot` option to filter dotfiles if dot === false.
+  if (globs.length === 0 || type !== "f") {
+    return dot || micromatch.some(relativePath, "**/*");
+  }
+  return micromatch.some(relativePath, globs, {
+    dot,
+  });
 }
 
 /**
@@ -106,6 +107,7 @@ function recReaddir(
   dir,
   dirCallback,
   fileCallback,
+  symlinkCallback,
   endCallback,
   errorCallback,
   ignored
@@ -114,6 +116,7 @@ function recReaddir(
     .filterDir((currentDir) => !anymatch(ignored, currentDir))
     .on("dir", normalizeProxy(dirCallback))
     .on("file", normalizeProxy(fileCallback))
+    .on("symlink", normalizeProxy(symlinkCallback))
     .on("error", errorCallback)
     .on("end", () => {
       if (platform === "win32") {

package/src/watchers/common.js.flow

@@ -49,7 +49,6 @@ interface Watcher {
   doIgnore: string => boolean;
   dot: boolean;
   globs: $ReadOnlyArray<string>;
-  hasIgnore: boolean;
   ignored?: ?(boolean | RegExp);
   watchmanDeferStates: $ReadOnlyArray<string>;
   watchmanPath?: ?string;
@@ -75,8 +74,6 @@ export const assignOptions = function (
   if (!Array.isArray(watcher.globs)) {
     watcher.globs = [watcher.globs];
   }
-  watcher.hasIgnore =
-    Boolean(opts.ignored) && !(Array.isArray(opts) && opts.length > 0);
   watcher.doIgnore =
     opts.ignored != null && opts.ignored !== false
       ? anymatch(opts.ignored)
@@ -92,7 +89,8 @@ export const assignOptions = function (
 /**
  * Checks a file relative path against the globs array.
  */
-export function isFileIncluded(
+export function isIncluded(
+  type: ?('f' | 'l' | 'd'),
   globs: $ReadOnlyArray<string>,
   dot: boolean,
   doIgnore: string => boolean,
@@ -101,9 +99,12 @@ export function isFileIncluded(
   if (doIgnore(relativePath)) {
     return false;
   }
-  return globs.length
-    ? micromatch.some(relativePath, globs, {dot})
-    : dot || micromatch.some(relativePath, '**/*');
+  // For non-regular files or if there are no glob matchers, just respect the
+  // `dot` option to filter dotfiles if dot === false.
+  if (globs.length === 0 || type !== 'f') {
+    return dot || micromatch.some(relativePath, '**/*');
+  }
+  return micromatch.some(relativePath, globs, {dot});
 }
 
 /**
@@ -113,6 +114,7 @@ export function recReaddir(
   dir: string,
   dirCallback: (string, Stats) => void,
   fileCallback: (string, Stats) => void,
+  symlinkCallback: (string, Stats) => void,
   endCallback: () => void,
   errorCallback: Error => void,
   ignored: ?(boolean | RegExp),
@@ -121,6 +123,7 @@ export function recReaddir(
     .filterDir(currentDir => !anymatch(ignored, currentDir))
     .on('dir', normalizeProxy(dirCallback))
     .on('file', normalizeProxy(fileCallback))
+    .on('symlink', normalizeProxy(symlinkCallback))
     .on('error', errorCallback)
     .on('end', () => {
       if (platform === 'win32') {