metro-file-map 0.83.4 → 0.83.6

package/src/watchers/NativeWatcher.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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<<b68c5620efd3f5bec83279059d0d1b4e>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/watchers/NativeWatcher.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import {AbstractWatcher} from './AbstractWatcher';
+/**
+ * NativeWatcher uses Node's native fs.watch API with recursive: true.
+ *
+ * Supported on macOS (and potentially Windows), because both natively have a
+ * concept of recurisve watching, via FSEvents and ReadDirectoryChangesW
+ * respectively. Notably Linux lacks this capability at the OS level.
+ *
+ * Node.js has at times supported the `recursive` option to fs.watch on Linux
+ * by walking the directory tree and creating a watcher on each directory, but
+ * this fits poorly with the synchronous `watch` API - either it must block for
+ * arbitrarily large IO, or it may drop changes after `watch` returns. See:
+ * https://github.com/nodejs/node/issues/48437
+ *
+ * Therefore, we retain a fallback to our own application-level recursive
+ * FallbackWatcher for Linux, which has async `startWatching`.
+ *
+ * On Windows, this watcher could be used in principle, but needs work around
+ * some Windows-specific edge cases handled in FallbackWatcher, like
+ * deduping file change events, ignoring directory changes, and handling EPERM.
+ */
+declare class NativeWatcher extends AbstractWatcher {
+  static isSupported(): boolean;
+  constructor(
+    dir: string,
+    opts: Readonly<{
+      ignored: null | undefined | RegExp;
+      globs: ReadonlyArray<string>;
+      dot: boolean;
+    }>,
+  );
+  startWatching(): Promise<void>;
+  /**
+   * End watching.
+   */
+  stopWatching(): Promise<void>;
+  _handleEvent(event: string, relativePath: string): void;
+}
+export default NativeWatcher;

package/src/watchers/NativeWatcher.js

@@ -17,10 +17,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)) {
@@ -42,6 +39,7 @@ function _interopRequireWildcard(e, t) {
 const debug = require("debug")("Metro:NativeWatcher");
 const TOUCH_EVENT = "touch";
 const DELETE_EVENT = "delete";
+const RECRAWL_EVENT = "recrawl";
 class NativeWatcher extends _AbstractWatcher.AbstractWatcher {
   #fsWatcher;
   static isSupported() {
@@ -60,8 +58,8 @@ class NativeWatcher extends _AbstractWatcher.AbstractWatcher {
         persistent: false,
         recursive: true,
       },
-      (_event, relativePath) => {
-        this._handleEvent(relativePath).catch((error) => {
+      (event, relativePath) => {
+        this._handleEvent(event, relativePath).catch((error) => {
           this.emitError(error);
         });
       },
@@ -74,13 +72,23 @@ class NativeWatcher extends _AbstractWatcher.AbstractWatcher {
       this.#fsWatcher.close();
     }
   }
-  async _handleEvent(relativePath) {
+  async _handleEvent(event, relativePath) {
     const absolutePath = path.resolve(this.root, relativePath);
     if (this.doIgnore(relativePath)) {
-      debug("Ignoring event on %s (root: %s)", relativePath, this.root);
+      debug(
+        'Ignoring event "%s" on %s (root: %s)',
+        event,
+        relativePath,
+        this.root,
+      );
       return;
     }
-    debug("Handling event on %s (root: %s)", relativePath, this.root);
+    debug(
+      'Handling event "%s" on %s (root: %s)',
+      event,
+      relativePath,
+      this.root,
+    );
     try {
       const stat = await _fs.promises.lstat(absolutePath);
       const type = (0, _common.typeFromStat)(stat);
@@ -92,6 +100,17 @@ class NativeWatcher extends _AbstractWatcher.AbstractWatcher {
       ) {
         return;
       }
+      if (type === "d" && event === "rename") {
+        debug(
+          "Directory rename detected on %s, requesting recrawl",
+          relativePath,
+        );
+        this.emitFileEvent({
+          event: RECRAWL_EVENT,
+          relativePath,
+        });
+        return;
+      }
       this.emitFileEvent({
         event: TOUCH_EVENT,
         relativePath,

package/src/watchers/NativeWatcher.js.flow

@@ -21,6 +21,7 @@ const debug = require('debug')('Metro:NativeWatcher');
 
 const TOUCH_EVENT = 'touch';
 const DELETE_EVENT = 'delete';
+const RECRAWL_EVENT = 'recrawl';
 
 /**
  * NativeWatcher uses Node's native fs.watch API with recursive: true.
@@ -74,9 +75,8 @@ export default class NativeWatcher extends AbstractWatcher {
         // ~instant on macOS or Windows.
         recursive: true,
       },
-      (_event, relativePath) => {
-        // _event is always 'rename' on macOS, so we don't use it.
-        this._handleEvent(relativePath).catch(error => {
+      (event, relativePath) => {
+        this._handleEvent(event, relativePath).catch(error => {
           this.emitError(error);
         });
       },
@@ -95,13 +95,23 @@ export default class NativeWatcher extends AbstractWatcher {
     }
   }
 
-  async _handleEvent(relativePath: string) {
+  async _handleEvent(event: string, relativePath: string) {
     const absolutePath = path.resolve(this.root, relativePath);
     if (this.doIgnore(relativePath)) {
-      debug('Ignoring event on %s (root: %s)', relativePath, this.root);
+      debug(
+        'Ignoring event "%s" on %s (root: %s)',
+        event,
+        relativePath,
+        this.root,
+      );
       return;
     }
-    debug('Handling event on %s (root: %s)', relativePath, this.root);
+    debug(
+      'Handling event "%s" on %s (root: %s)',
+      event,
+      relativePath,
+      this.root,
+    );
 
     try {
       const stat = await fsPromises.lstat(absolutePath);
@@ -116,6 +126,23 @@ export default class NativeWatcher extends AbstractWatcher {
         return;
       }
 
+      // For directory "rename" events, notify that we need a recrawl since we
+      // wont' receive events for unmodified files underneath a moved (or
+      // cloned) directory. Renames are fired by the OS on moves, clones, and
+      // creations. We ignore "change" events because they indiciate a change
+      // to directory metadata, rather than its path or existence.
+      if (type === 'd' && event === 'rename') {
+        debug(
+          'Directory rename detected on %s, requesting recrawl',
+          relativePath,
+        );
+        this.emitFileEvent({
+          event: RECRAWL_EVENT,
+          relativePath,
+        });
+        return;
+      }
+
       this.emitFileEvent({
         event: TOUCH_EVENT,
         relativePath,

package/src/watchers/RecrawlWarning.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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<<dc063c7e351d5c09a5ad65d09b5b6b2a>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/watchers/RecrawlWarning.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+/**
+ * Originally vendored from
+ * https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/utils/recrawl-warning-dedupe.js
+ */
+
+declare class RecrawlWarning {
+  static RECRAWL_WARNINGS: Array<RecrawlWarning>;
+  static REGEXP: RegExp;
+  root: string;
+  count: number;
+  constructor(root: string, count: number);
+  static findByRoot(root: string): null | undefined | RecrawlWarning;
+  static isRecrawlWarningDupe(warningMessage: unknown): boolean;
+}
+export default RecrawlWarning;

package/src/watchers/WatchmanWatcher.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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<<b8358b8822835bcef505207f90b02c66>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/watchers/WatchmanWatcher.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {WatcherOptions} from './common';
+
+import {AbstractWatcher} from './AbstractWatcher';
+/**
+ * Watches `dir`.
+ */
+declare class WatchmanWatcher extends AbstractWatcher {
+  readonly subscriptionName: string;
+  constructor(dir: string, opts: WatcherOptions);
+  startWatching(): Promise<void>;
+  /**
+   * Closes the watcher.
+   */
+  stopWatching(): Promise<void>;
+  getPauseReason(): null | undefined | string;
+}
+export default WatchmanWatcher;

package/src/watchers/WatchmanWatcher.js

@@ -22,10 +22,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)) {
@@ -45,11 +42,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:WatchmanWatcher");
 const DELETE_EVENT = common.DELETE_EVENT;

package/src/watchers/common.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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<<ebebfbca9d43e034fde8489e1d9f2dbb>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/watchers/common.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+/**
+ * Originally vendored from
+ * https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/common.js
+ */
+
+import type {ChangeEventMetadata} from '../flow-types';
+import type {Stats} from 'fs';
+/**
+ * Constants
+ */
+export declare const DELETE_EVENT: 'delete';
+export declare type DELETE_EVENT = typeof DELETE_EVENT;
+export declare const TOUCH_EVENT: 'touch';
+export declare type TOUCH_EVENT = typeof TOUCH_EVENT;
+export declare const RECRAWL_EVENT: 'recrawl';
+export declare type RECRAWL_EVENT = typeof RECRAWL_EVENT;
+export declare const ALL_EVENT: 'all';
+export declare type ALL_EVENT = typeof ALL_EVENT;
+export type WatcherOptions = Readonly<{
+  globs: ReadonlyArray<string>;
+  dot: boolean;
+  ignored: null | undefined | RegExp;
+  watchmanDeferStates: ReadonlyArray<string>;
+  watchman?: unknown;
+  watchmanPath?: string;
+}>;
+/**
+ * Checks a file relative path against the globs array.
+ */
+export declare function includedByGlob(
+  type: null | undefined | ('f' | 'l' | 'd'),
+  globs: ReadonlyArray<string>,
+  dot: boolean,
+  relativePath: string,
+): boolean;
+/**
+ * Whether the given filePath matches the given RegExp, after converting
+ * (on Windows only) system separators to posix separators.
+ *
+ * Conversion to posix is for backwards compatibility with the previous
+ * anymatch matcher, which normlises all inputs[1]. This may not be consistent
+ * with other parts of metro-file-map.
+ *
+ * [1]: https://github.com/micromatch/anymatch/blob/3.1.1/index.js#L50
+ */
+export declare const posixPathMatchesPattern: (
+  pattern: RegExp,
+  filePath: string,
+) => boolean;
+export declare type posixPathMatchesPattern = typeof posixPathMatchesPattern;
+export declare function typeFromStat(
+  stat: Stats,
+): null | undefined | ChangeEventMetadata['type'];

package/src/watchers/common.js

@@ -3,21 +3,22 @@
 Object.defineProperty(exports, "__esModule", {
   value: true,
 });
-exports.TOUCH_EVENT = exports.DELETE_EVENT = exports.ALL_EVENT = void 0;
+exports.TOUCH_EVENT =
+  exports.RECRAWL_EVENT =
+  exports.DELETE_EVENT =
+  exports.ALL_EVENT =
+    void 0;
 exports.includedByGlob = includedByGlob;
 exports.posixPathMatchesPattern = void 0;
 exports.typeFromStat = typeFromStat;
 var _micromatch = _interopRequireDefault(require("micromatch"));
 var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const DELETE_EVENT = (exports.DELETE_EVENT = "delete");
 const TOUCH_EVENT = (exports.TOUCH_EVENT = "touch");
+const RECRAWL_EVENT = (exports.RECRAWL_EVENT = "recrawl");
 const ALL_EVENT = (exports.ALL_EVENT = "all");
 function includedByGlob(type, globs, dot, relativePath) {
   if (globs.length === 0 || type !== "f") {

package/src/watchers/common.js.flow

@@ -26,6 +26,7 @@ import path from 'path';
  */
 export const DELETE_EVENT = 'delete';
 export const TOUCH_EVENT = 'touch';
+export const RECRAWL_EVENT = 'recrawl';
 export const ALL_EVENT = 'all';
 
 export type WatcherOptions = Readonly<{