metro-file-map 0.83.3 → 0.84.0

package/src/plugins/haste/worker.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 {
+  MetadataWorker,
+  V8Serializable,
+  WorkerMessage,
+} from '../../flow-types';
+
+declare class Worker implements MetadataWorker {
+  constructor(opts: Readonly<{hasteImplModulePath: null | undefined | string}>);
+  processFile(
+    data: WorkerMessage,
+    utils: Readonly<{getContent: () => Buffer}>,
+  ): V8Serializable;
+}
+
+export = Worker;

package/src/plugins/haste/worker.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const excludedExtensions = require("../../workerExclusionList");
+const path = require("path");
+const PACKAGE_JSON = path.sep + "package.json";
+module.exports = class Worker {
+  #hasteImpl = null;
+  constructor({ hasteImplModulePath }) {
+    if (hasteImplModulePath != null) {
+      this.#hasteImpl = require(hasteImplModulePath);
+    }
+  }
+  processFile(data, utils) {
+    let hasteName = null;
+    const { filePath } = data;
+    if (filePath.endsWith(PACKAGE_JSON)) {
+      try {
+        const fileData = JSON.parse(utils.getContent().toString());
+        if (fileData.name) {
+          hasteName = fileData.name;
+        }
+      } catch (err) {
+        throw new Error(`Cannot parse ${filePath} as JSON: ${err.message}`);
+      }
+    } else if (
+      !excludedExtensions.has(filePath.substr(filePath.lastIndexOf(".")))
+    ) {
+      if (!this.#hasteImpl) {
+        throw new Error("computeHaste is true but hasteImplModulePath not set");
+      }
+      hasteName = this.#hasteImpl.getHasteName(filePath) || null;
+    }
+    return hasteName;
+  }
+};

package/src/plugins/haste/worker.js.flow

@@ -0,0 +1,64 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+/* eslint-disable import/no-commonjs */
+
+'use strict';
+
+const excludedExtensions = require('../../workerExclusionList');
+const path = require('path');
+
+/*::
+import type {MetadataWorker, WorkerMessage, V8Serializable} from '../../flow-types';
+*/
+
+const PACKAGE_JSON = path.sep + 'package.json';
+
+module.exports = class Worker /*:: implements MetadataWorker */ {
+  /*:: + */ #hasteImpl /*: ?Readonly<{getHasteName: string => ?string}>  */ =
+    null;
+
+  constructor(
+    {hasteImplModulePath} /*: Readonly<{hasteImplModulePath: ?string}> */,
+  ) {
+    if (hasteImplModulePath != null) {
+      // $FlowFixMe[unsupported-syntax] - dynamic require
+      this.#hasteImpl = require(hasteImplModulePath);
+    }
+  }
+
+  processFile(
+    data /*: WorkerMessage */,
+    utils /*: Readonly<{getContent: () => Buffer }> */,
+  ) /*: V8Serializable */ {
+    let hasteName /*: string | null */ = null;
+    const {filePath} = data;
+    if (filePath.endsWith(PACKAGE_JSON)) {
+      // Process a package.json that is returned as a PACKAGE type with its name.
+      try {
+        const fileData = JSON.parse(utils.getContent().toString());
+        if (fileData.name) {
+          hasteName = fileData.name;
+        }
+      } catch (err) {
+        throw new Error(`Cannot parse ${filePath} as JSON: ${err.message}`);
+      }
+    } else if (
+      !excludedExtensions.has(filePath.substr(filePath.lastIndexOf('.')))
+    ) {
+      if (!this.#hasteImpl) {
+        throw new Error('computeHaste is true but hasteImplModulePath not set');
+      }
+      // Process a random file that is returned as a MODULE.
+      hasteName = this.#hasteImpl.getHasteName(filePath) || null;
+    }
+    return hasteName;
+  }
+};

package/src/plugins/mocks/getMockName.js

@@ -5,34 +5,38 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 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 MOCKS_PATTERN = path.sep + "__mocks__" + path.sep;
-const getMockName = (filePath) => {
+var _default = (filePath) => {
   const mockPath = filePath.split(MOCKS_PATTERN)[1];
   return mockPath
     .substring(0, mockPath.lastIndexOf(path.extname(mockPath)))
     .replaceAll("\\", "/");
 };
-var _default = (exports.default = getMockName);
+exports.default = _default;

package/src/plugins/mocks/getMockName.js.flow

@@ -4,19 +4,17 @@
  * 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
+ * @format
  */
 
 import * as path from 'path';
 
 const MOCKS_PATTERN = path.sep + '__mocks__' + path.sep;
 
-const getMockName = (filePath: string): string => {
+export default (filePath: string): string => {
   const mockPath = filePath.split(MOCKS_PATTERN)[1];
   return mockPath
     .substring(0, mockPath.lastIndexOf(path.extname(mockPath)))
     .replaceAll('\\', '/');
 };
-
-export default getMockName;

package/src/watchers/AbstractWatcher.js

@@ -7,35 +7,40 @@ exports.AbstractWatcher = void 0;
 var _common = require("./common");
 var _events = _interopRequireDefault(require("events"));
 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);
 }
 function _interopRequireDefault(e) {
   return e && e.__esModule ? e : { default: e };
 }
 class AbstractWatcher {
   #emitter = new _events.default();
-  constructor(dir, { ignored, globs, dot }) {
+  constructor(dir, opts) {
+    const { ignored, globs, dot } = opts;
     this.dot = dot || false;
     this.ignored = ignored;
     this.globs = globs;

package/src/watchers/AbstractWatcher.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 {
@@ -18,7 +18,7 @@ import {posixPathMatchesPattern} from './common';
 import EventEmitter from 'events';
 import * as path from 'path';
 
-export type Listeners = $ReadOnly<{
+export type Listeners = Readonly<{
   onFileEvent: (event: WatcherBackendChangeEvent) => void,
   onError: (error: Error) => void,
 }>;
@@ -26,13 +26,14 @@ export type Listeners = $ReadOnly<{
 export class AbstractWatcher implements WatcherBackend {
   +root: string;
   +ignored: ?RegExp;
-  +globs: $ReadOnlyArray<string>;
+  +globs: ReadonlyArray<string>;
   +dot: boolean;
   +doIgnore: (path: string) => boolean;
 
   #emitter: EventEmitter = new EventEmitter();
 
-  constructor(dir: string, {ignored, globs, dot}: WatcherBackendOptions) {
+  constructor(dir: string, opts: WatcherBackendOptions) {
+    const {ignored, globs, dot} = opts;
     this.dot = dot || false;
     this.ignored = ignored;
     this.globs = globs;
@@ -63,7 +64,7 @@ export class AbstractWatcher implements WatcherBackend {
     // Must be implemented by subclasses
   }
 
-  async stopWatching() {
+  async stopWatching(): Promise<void> {
     this.#emitter.removeAllListeners();
   }
 

package/src/watchers/FallbackWatcher.js

@@ -13,28 +13,32 @@ var _walker = _interopRequireDefault(require("walker"));
 function _interopRequireDefault(e) {
   return e && e.__esModule ? e : { default: e };
 }
-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 platform = _os.default.platform();
 const fsPromises = _fs.default.promises;
@@ -42,35 +46,35 @@ const TOUCH_EVENT = common.TOUCH_EVENT;
 const DELETE_EVENT = common.DELETE_EVENT;
 const DEBOUNCE_MS = 100;
 class FallbackWatcher extends _AbstractWatcher.AbstractWatcher {
-  _changeTimers = new Map();
-  _dirRegistry = Object.create(null);
-  watched = Object.create(null);
+  #changeTimers = new Map();
+  #dirRegistry = Object.create(null);
+  #watched = Object.create(null);
   async startWatching() {
-    this._watchdir(this.root);
+    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,
       );
     });
   }
-  _register(filepath, type) {
+  #register(filepath, type) {
     const dir = _path.default.dirname(filepath);
     const filename = _path.default.basename(filepath);
-    if (this._dirRegistry[dir] && this._dirRegistry[dir][filename]) {
+    if (this.#dirRegistry[dir] && this.#dirRegistry[dir][filename]) {
       return false;
     }
     const relativePath = _path.default.relative(this.root, filepath);
@@ -81,39 +85,39 @@ class FallbackWatcher extends _AbstractWatcher.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;
   }
-  _unregister(filepath) {
+  #unregister(filepath) {
     const dir = _path.default.dirname(filepath);
-    if (this._dirRegistry[dir]) {
+    if (this.#dirRegistry[dir]) {
       const filename = _path.default.basename(filepath);
-      delete this._dirRegistry[dir][filename];
+      delete this.#dirRegistry[dir][filename];
     }
   }
-  _unregisterDir(dirpath) {
-    if (this._dirRegistry[dirpath]) {
-      delete this._dirRegistry[dirpath];
+  #unregisterDir(dirpath) {
+    if (this.#dirRegistry[dirpath]) {
+      delete this.#dirRegistry[dirpath];
     }
   }
-  _registered(fullpath) {
+  #registered(fullpath) {
     const dir = _path.default.dirname(fullpath);
     return !!(
-      this._dirRegistry[fullpath] ||
-      (this._dirRegistry[dir] &&
-        this._dirRegistry[dir][_path.default.basename(fullpath)])
+      this.#dirRegistry[fullpath] ||
+      (this.#dirRegistry[dir] &&
+        this.#dirRegistry[dir][_path.default.basename(fullpath)])
     );
   }
-  _checkedEmitError = (error) => {
+  #checkedEmitError = (error) => {
     if (!isIgnorableFileError(error)) {
       this.emitError(error);
     }
   };
-  _watchdir = (dir) => {
-    if (this.watched[dir]) {
+  #watchdir = (dir) => {
+    if (this.#watched[dir]) {
       return false;
     }
     const watcher = _fs.default.watch(
@@ -121,39 +125,39 @@ class FallbackWatcher extends _AbstractWatcher.AbstractWatcher {
       {
         persistent: true,
       },
-      (event, filename) => this._normalizeChange(dir, event, filename),
+      (event, filename) => this.#normalizeChange(dir, event, filename),
     );
-    this.watched[dir] = watcher;
-    watcher.on("error", this._checkedEmitError);
+    this.#watched[dir] = watcher;
+    watcher.on("error", this.#checkedEmitError);
     if (this.root !== dir) {
-      this._register(dir, "d");
+      this.#register(dir, "d");
     }
     return true;
   };
-  async _stopWatching(dir) {
-    if (this.watched[dir]) {
+  async #stopWatching(dir) {
+    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];
       });
     }
   }
   async stopWatching() {
     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);
   }
-  _detectChangedFile(dir, event, callback) {
-    if (!this._dirRegistry[dir]) {
+  #detectChangedFile(dir, event, callback) {
+    if (!this.#dirRegistry[dir]) {
       return;
     }
     let found = false;
     let closest = null;
     let c = 0;
-    Object.keys(this._dirRegistry[dir]).forEach((file, i, arr) => {
+    Object.keys(this.#dirRegistry[dir]).forEach((file, i, arr) => {
       _fs.default.lstat(_path.default.join(dir, file), (error, stat) => {
         if (found) {
           return;
@@ -179,28 +183,28 @@ class FallbackWatcher extends _AbstractWatcher.AbstractWatcher {
       });
     });
   }
-  _normalizeChange(dir, event, file) {
+  #normalizeChange(dir, event, file) {
     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.default.normalize(file)).catch(
+      this.#processChange(dir, event, _path.default.normalize(file)).catch(
         (error) => this.emitError(error),
       );
     }
   }
-  async _processChange(dir, event, file) {
+  async #processChange(dir, event, file) {
     const fullPath = _path.default.join(dir, file);
     const relativePath = _path.default.join(
       _path.default.relative(this.root, dir),
       file,
     );
-    const registered = this._registered(fullPath);
+    const registered = this.#registered(fullPath);
     try {
       const stat = await fsPromises.lstat(fullPath);
       if (stat.isDirectory()) {
@@ -216,8 +220,8 @@ class FallbackWatcher extends _AbstractWatcher.AbstractWatcher {
         recReaddir(
           _path.default.resolve(this.root, relativePath),
           (dir, stats) => {
-            if (this._watchdir(dir)) {
-              this._emitEvent({
+            if (this.#watchdir(dir)) {
+              this.#emitEvent({
                 event: TOUCH_EVENT,
                 relativePath: _path.default.relative(this.root, dir),
                 metadata: {
@@ -229,8 +233,8 @@ class FallbackWatcher extends _AbstractWatcher.AbstractWatcher {
             }
           },
           (file, stats) => {
-            if (this._register(file, "f")) {
-              this._emitEvent({
+            if (this.#register(file, "f")) {
+              this.#emitEvent({
                 event: TOUCH_EVENT,
                 relativePath: _path.default.relative(this.root, file),
                 metadata: {
@@ -242,7 +246,7 @@ class FallbackWatcher extends _AbstractWatcher.AbstractWatcher {
             }
           },
           (symlink, stats) => {
-            if (this._register(symlink, "l")) {
+            if (this.#register(symlink, "l")) {
               this.emitFileEvent({
                 event: TOUCH_EVENT,
                 relativePath: _path.default.relative(this.root, symlink),
@@ -255,7 +259,7 @@ class FallbackWatcher extends _AbstractWatcher.AbstractWatcher {
             }
           },
           function endCallback() {},
-          this._checkedEmitError,
+          this.#checkedEmitError,
           this.ignored,
         );
       } else {
@@ -269,14 +273,14 @@ class FallbackWatcher extends _AbstractWatcher.AbstractWatcher {
           type,
         };
         if (registered) {
-          this._emitEvent({
+          this.#emitEvent({
             event: TOUCH_EVENT,
             relativePath,
             metadata,
           });
         } else {
-          if (this._register(fullPath, type)) {
-            this._emitEvent({
+          if (this.#register(fullPath, type)) {
+            this.#emitEvent({
               event: TOUCH_EVENT,
               relativePath,
               metadata,
@@ -289,28 +293,28 @@ class FallbackWatcher extends _AbstractWatcher.AbstractWatcher {
         this.emitError(error);
         return;
       }
-      this._unregister(fullPath);
-      this._unregisterDir(fullPath);
+      this.#unregister(fullPath);
+      this.#unregisterDir(fullPath);
       if (registered) {
-        this._emitEvent({
+        this.#emitEvent({
           event: DELETE_EVENT,
           relativePath,
         });
       }
-      await this._stopWatching(fullPath);
+      await this.#stopWatching(fullPath);
     }
   }
-  _emitEvent(change) {
+  #emitEvent(change) {
     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),
     );