metro-file-map 0.83.3 → 0.84.0

package/src/crawlers/node/index.js.flow

@@ -30,8 +30,8 @@ const debug = require('debug')('Metro:NodeCrawler');
 type Callback = (result: FileData) => void;
 
 function find(
-  roots: $ReadOnlyArray<string>,
-  extensions: $ReadOnlyArray<string>,
+  roots: ReadonlyArray<string>,
+  extensions: ReadonlyArray<string>,
   ignore: IgnoreMatcher,
   includeSymlinks: boolean,
   rootDir: string,
@@ -79,10 +79,9 @@ function find(
                   stat.mtime.getTime(),
                   stat.size,
                   0,
-                  '',
                   null,
                   stat.isSymbolicLink() ? 1 : 0,
-                  '',
+                  null,
                 ]);
               }
             }
@@ -108,8 +107,8 @@ function find(
 }
 
 function findNative(
-  roots: $ReadOnlyArray<string>,
-  extensions: $ReadOnlyArray<string>,
+  roots: ReadonlyArray<string>,
+  extensions: ReadonlyArray<string>,
   ignore: IgnoreMatcher,
   includeSymlinks: boolean,
   rootDir: string,
@@ -157,10 +156,9 @@ function findNative(
               stat.mtime.getTime(),
               stat.size,
               0,
-              '',
               null,
               stat.isSymbolicLink() ? 1 : 0,
-              '',
+              null,
             ]);
           }
           if (--count === 0) {

package/src/crawlers/watchman/index.js

@@ -16,28 +16,32 @@ var _fbWatchman = _interopRequireDefault(require("fb-watchman"));
 var _invariant = _interopRequireDefault(require("invariant"));
 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 };
@@ -272,7 +276,7 @@ async function watchmanCrawl({
         if (fileData.type === "l") {
           symlinkInfo = fileData["symlink_target"] ?? 1;
         }
-        const nextData = [mtime, size, 0, "", sha1hex ?? null, symlinkInfo, ""];
+        const nextData = [mtime, size, 0, sha1hex ?? null, symlinkInfo, null];
         if (isFresh) {
           freshFileData.set(relativeFilePath, nextData);
         } else {

package/src/crawlers/watchman/index.js.flow

@@ -31,7 +31,7 @@ import {performance} from 'perf_hooks';
 
 type WatchmanRoots = Map<
   string, // Posix-separated absolute path
-  $ReadOnly<{directoryFilters: Array<string>, watcher: string}>,
+  Readonly<{directoryFilters: Array<string>, watcher: string}>,
 >;
 
 const WATCHMAN_WARNING_INITIAL_DELAY_MILLISECONDS = 10000;
@@ -132,7 +132,7 @@ export default async function watchmanCrawl({
   };
 
   async function getWatchmanRoots(
-    roots: $ReadOnlyArray<Path>,
+    roots: ReadonlyArray<Path>,
   ): Promise<WatchmanRoots> {
     perfLogger?.point('watchmanCrawl/getWatchmanRoots_start');
     const watchmanRoots: WatchmanRoots = new Map();
@@ -336,10 +336,9 @@ export default async function watchmanCrawl({
           mtime,
           size,
           0,
-          '',
           sha1hex ?? null,
           symlinkInfo,
-          '',
+          null,
         ];
 
         // If watchman is fresh, the removed files map starts with all files

package/src/crawlers/watchman/planQuery.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
+ */
+
+type WatchmanQuery = {[key: string]: unknown};
+type WatchmanQuerySince = unknown;
+
+export declare function planQuery(
+  args: Readonly<{
+    since: WatchmanQuerySince;
+    directoryFilters: ReadonlyArray<string>;
+    extensions: ReadonlyArray<string>;
+    includeSha1: boolean;
+    includeSymlinks: boolean;
+  }>,
+): {
+  query: WatchmanQuery;
+  queryGenerator: string;
+};

package/src/crawlers/watchman/planQuery.js.flow

@@ -21,10 +21,10 @@ export function planQuery({
   extensions,
   includeSha1,
   includeSymlinks,
-}: $ReadOnly<{
+}: Readonly<{
   since: ?WatchmanQuerySince,
-  directoryFilters: $ReadOnlyArray<string>,
-  extensions: $ReadOnlyArray<string>,
+  directoryFilters: ReadonlyArray<string>,
+  extensions: ReadonlyArray<string>,
   includeSha1: boolean,
   includeSymlinks: boolean,
 }>): {
@@ -100,7 +100,7 @@ export function planQuery({
       allOfTerms.push([
         'anyof',
         ...directoryFilters.map(
-          dir => (['dirname', dir]: WatchmanDirnameExpression),
+          dir => ['dirname', dir] as WatchmanDirnameExpression,
         ),
       ]);
     }

package/src/flow-types.js.flow

@@ -15,37 +15,28 @@ export type {PerfLoggerFactory, PerfLogger};
 
 // These inputs affect the internal data collected for a given filesystem
 // state, and changes may invalidate a cache.
-export type BuildParameters = $ReadOnly<{
-  computeDependencies: boolean,
+export type BuildParameters = Readonly<{
   computeSha1: boolean,
-  enableHastePackages: boolean,
   enableSymlinks: boolean,
-  extensions: $ReadOnlyArray<string>,
+  extensions: ReadonlyArray<string>,
   forceNodeFilesystemAPI: boolean,
   ignorePattern: RegExp,
-  plugins: $ReadOnlyArray<FileMapPlugin<>>,
+  plugins: ReadonlyArray<FileMapPlugin<>>,
   retainAllFiles: boolean,
   rootDir: string,
-  roots: $ReadOnlyArray<string>,
-  skipPackageJson: boolean,
-
-  // Module paths that should export a 'getCacheKey' method
-  dependencyExtractor: ?string,
-  hasteImplModulePath: ?string,
+  roots: ReadonlyArray<string>,
 
   cacheBreaker: string,
 }>;
 
 export type BuildResult = {
   fileSystem: FileSystem,
-  hasteMap: HasteMap,
-  mockMap: ?MockMap,
 };
 
-export type CacheData = $ReadOnly<{
+export type CacheData = Readonly<{
   clocks: WatchmanClocks,
-  fileSystemData: mixed,
-  plugins: $ReadOnlyMap<string, V8Serializable>,
+  fileSystemData: unknown,
+  plugins: ReadonlyMap<string, void | V8Serializable>,
 }>;
 
 export interface CacheManager {
@@ -83,14 +74,14 @@ export type CacheManagerFactory = (
   options: CacheManagerFactoryOptions,
 ) => CacheManager;
 
-export type CacheManagerFactoryOptions = $ReadOnly<{
+export type CacheManagerFactoryOptions = Readonly<{
   buildParameters: BuildParameters,
 }>;
 
-export type CacheManagerWriteOptions = $ReadOnly<{
+export type CacheManagerWriteOptions = Readonly<{
   changedSinceCacheRead: boolean,
   eventSource: CacheManagerEventSource,
-  onWriteError: Error => void,
+  onWriteError: (error: Error) => void,
 }>;
 
 // A path that is
@@ -116,17 +107,17 @@ export type CrawlerOptions = {
   abortSignal: ?AbortSignal,
   computeSha1: boolean,
   console: Console,
-  extensions: $ReadOnlyArray<string>,
+  extensions: ReadonlyArray<string>,
   forceNodeFilesystemAPI: boolean,
   ignore: IgnoreMatcher,
   includeSymlinks: boolean,
   perfLogger?: ?PerfLogger,
-  previousState: $ReadOnly<{
-    clocks: $ReadOnlyMap<CanonicalPath, WatchmanClockSpec>,
+  previousState: Readonly<{
+    clocks: ReadonlyMap<CanonicalPath, WatchmanClockSpec>,
     fileSystem: FileSystem,
   }>,
   rootDir: string,
-  roots: $ReadOnlyArray<string>,
+  roots: ReadonlyArray<string>,
   onStatus: (status: WatcherStatus) => void,
 };
 
@@ -152,7 +143,7 @@ export type WatcherStatus =
     }
   | {
       type: 'watchman_warning',
-      warning: mixed,
+      warning: unknown,
       command: 'watch-project' | 'query',
     };
 
@@ -165,65 +156,94 @@ export type EventsQueue = Array<{
   type: string,
 }>;
 
-export type FileMapDelta = $ReadOnly<{
-  removed: Iterable<[CanonicalPath, FileMetadata]>,
-  addedOrModified: Iterable<[CanonicalPath, FileMetadata]>,
+export type FileMapDelta<T = null | void> = Readonly<{
+  removed: Iterable<[CanonicalPath, T]>,
+  addedOrModified: Iterable<[CanonicalPath, T]>,
 }>;
 
-interface FileSystemState {
-  metadataIterator(
-    opts: $ReadOnly<{
-      includeNodeModules: boolean,
-      includeSymlinks: boolean,
+export type FileMapPluginInitOptions<
+  SerializableState,
+  PerFileData = void,
+> = Readonly<{
+  files: Readonly<{
+    fileIterator(
+      opts: Readonly<{
+        includeNodeModules: boolean,
+        includeSymlinks: boolean,
+      }>,
+    ): Iterable<{
+      baseName: string,
+      canonicalPath: string,
+      pluginData: ?PerFileData,
     }>,
-  ): Iterable<{
-    baseName: string,
-    canonicalPath: string,
-    metadata: FileMetadata,
-  }>;
-}
-
-export type FileMapPluginInitOptions<SerializableState> = $ReadOnly<{
-  files: FileSystemState,
+    lookup(
+      mixedPath: string,
+    ):
+      | {exists: false}
+      | {exists: true, type: 'f', pluginData: PerFileData}
+      | {exists: true, type: 'd'},
+  }>,
   pluginState: ?SerializableState,
 }>;
 
-type V8Serializable = interface {};
+export type FileMapPluginWorker = Readonly<{
+  worker: Readonly<{
+    modulePath: string,
+    setupArgs: JsonData,
+  }>,
+  filter: ({normalPath: string, isNodeModules: boolean}) => boolean,
+}>;
 
-export interface FileMapPlugin<SerializableState = V8Serializable> {
+export type V8Serializable =
+  | string
+  | number
+  | boolean
+  | null
+  | ReadonlyArray<V8Serializable>
+  | ReadonlySet<V8Serializable>
+  | ReadonlyMap<string, V8Serializable>
+  | Readonly<{[key: string]: V8Serializable}>;
+
+export interface FileMapPlugin<
+  SerializableState: void | V8Serializable = void | V8Serializable,
+  PerFileData: void | V8Serializable = void | V8Serializable,
+> {
   +name: string;
   initialize(
-    initOptions: FileMapPluginInitOptions<SerializableState>,
+    initOptions: FileMapPluginInitOptions<SerializableState, PerFileData>,
   ): Promise<void>;
   assertValid(): void;
-  bulkUpdate(delta: FileMapDelta): Promise<void>;
+  bulkUpdate(delta: FileMapDelta<?PerFileData>): Promise<void>;
   getSerializableSnapshot(): SerializableState;
-  onRemovedFile(relativeFilePath: string, fileMetadata: FileMetadata): void;
-  onNewOrModifiedFile(
-    relativeFilePath: string,
-    fileMetadata: FileMetadata,
-  ): void;
+  onRemovedFile(relativeFilePath: string, pluginData: ?PerFileData): void;
+  onNewOrModifiedFile(relativeFilePath: string, pluginData: ?PerFileData): void;
   getCacheKey(): string;
+  getWorker(): ?FileMapPluginWorker;
+}
+
+export interface MetadataWorker {
+  processFile(
+    WorkerMessage,
+    Readonly<{getContent: () => Buffer}>,
+  ): V8Serializable;
 }
 
 export type HType = {
   MTIME: 0,
   SIZE: 1,
   VISITED: 2,
-  DEPENDENCIES: 3,
-  SHA1: 4,
-  SYMLINK: 5,
-  ID: 6,
+  SHA1: 3,
+  SYMLINK: 4,
+  PLUGINDATA: number,
   PATH: 0,
   TYPE: 1,
   MODULE: 0,
   PACKAGE: 1,
   GENERIC_PLATFORM: 'g',
   NATIVE_PLATFORM: 'native',
-  DEPENDENCY_DELIM: '\0',
 };
 
-export type HTypeValue = $Values<HType>;
+export type HTypeValue = Values<HType>;
 
 export type IgnoreMatcher = (item: string) => boolean;
 
@@ -233,13 +253,13 @@ export type FileMetadata = [
   /* mtime */ ?number,
   /* size */ number,
   /* visited */ 0 | 1,
-  /* dependencies */ string,
   /* sha1 */ ?string,
   /* symlink */ 0 | 1 | string, // string specifies target, if known
-  /* id */ string,
+  /* plugindata */
+  ...
 ];
 
-export type FileStats = $ReadOnly<{
+export type FileStats = Readonly<{
   fileType: 'f' | 'l',
   modifiedTime: ?number,
   size: ?number,
@@ -248,12 +268,10 @@ export type FileStats = $ReadOnly<{
 export interface FileSystem {
   exists(file: Path): boolean;
   getAllFiles(): Array<Path>;
-  getDependencies(file: Path): ?Array<string>;
   getDifference(files: FileData): {
     changedFiles: FileData,
     removedFiles: Set<string>,
   };
-  getModuleName(file: Path): ?string;
   getSerializableSnapshot(): CacheData['fileSystemData'];
   getSha1(file: Path): ?string;
   getOrComputeSha1(file: Path): Promise<?{sha1: string, content?: Buffer}>;
@@ -324,6 +342,14 @@ export interface FileSystem {
 
 export type Glob = string;
 
+export type JsonData =
+  | string
+  | number
+  | boolean
+  | null
+  | Array<JsonData>
+  | {[key: string]: JsonData};
+
 export type LookupResult =
   | {
       // The node is missing from the FileSystem implementation (note this
@@ -331,7 +357,7 @@ export type LookupResult =
       // files).
       exists: false,
       // The real, normal, absolute paths of any symlinks traversed.
-      links: $ReadOnlySet<string>,
+      links: ReadonlySet<string>,
       // The real, normal, absolute path of the first path segment
       // encountered that does not exist, or cannot be navigated through.
       missing: string,
@@ -339,12 +365,24 @@ export type LookupResult =
   | {
       exists: true,
       // The real, normal, absolute paths of any symlinks traversed.
-      links: $ReadOnlySet<string>,
-      // The real, normal, absolute path of the file or directory.
+      links: ReadonlySet<string>,
+      // The real, normal, absolute path of the directory.
+      realPath: string,
+      // Currently lookup always follows symlinks, so can only return
+      // directories or regular files, but this may be extended.
+      type: 'd',
+    }
+  | {
+      exists: true,
+      // The real, normal, absolute paths of any symlinks traversed.
+      links: ReadonlySet<string>,
+      // The real, normal, absolute path of the file.
       realPath: string,
       // Currently lookup always follows symlinks, so can only return
       // directories or regular files, but this may be extended.
-      type: 'd' | 'f',
+      type: 'f',
+      // The file's metadata tuple. Must only be mutated via FileProcessor.
+      metadata: FileMetadata,
     };
 
 export interface MockMap {
@@ -366,6 +404,8 @@ export interface HasteMap {
     type?: ?HTypeValue,
   ): ?Path;
 
+  getModuleNameByPath(file: Path): ?string;
+
   getPackage(
     name: string,
     platform: ?string,
@@ -392,12 +432,12 @@ export interface MutableFileSystem extends FileSystem {
 export type Path = string;
 
 export type ProcessFileFunction = (
-  absolutePath: string,
+  normalPath: string,
   metadata: FileMetadata,
-  request: $ReadOnly<{computeSha1: boolean}>,
+  request: Readonly<{computeSha1: boolean}>,
 ) => ?Buffer;
 
-export type RawMockMap = $ReadOnly<{
+export type RawMockMap = Readonly<{
   duplicates: Map<
     string, // posix-separated mock name
     Set<string>, // posix-separated, project-relative paths
@@ -409,16 +449,16 @@ export type RawMockMap = $ReadOnly<{
   version: number,
 }>;
 
-export type ReadOnlyRawMockMap = $ReadOnly<{
-  duplicates: $ReadOnlyMap<string, $ReadOnlySet<string>>,
-  mocks: $ReadOnlyMap<string, Path>,
+export type ReadOnlyRawMockMap = Readonly<{
+  duplicates: ReadonlyMap<string, ReadonlySet<string>>,
+  mocks: ReadonlyMap<string, Path>,
   version: number,
 }>;
 
 export interface WatcherBackend {
   getPauseReason(): ?string;
-  onError((error: Error) => void): () => void;
-  onFileEvent((event: WatcherBackendChangeEvent) => void): () => void;
+  onError(listener: (error: Error) => void): () => void;
+  onFileEvent(listener: (event: WatcherBackendChangeEvent) => void): () => void;
   startWatching(): Promise<void>;
   stopWatching(): Promise<void>;
 }
@@ -429,14 +469,14 @@ export type ChangeEventClock = [
 ];
 
 export type WatcherBackendChangeEvent =
-  | $ReadOnly<{
+  | Readonly<{
       event: 'touch',
       clock?: ChangeEventClock,
       relativePath: string,
       root: string,
       metadata: ChangeEventMetadata,
     }>
-  | $ReadOnly<{
+  | Readonly<{
       event: 'delete',
       clock?: ChangeEventClock,
       relativePath: string,
@@ -444,33 +484,31 @@ export type WatcherBackendChangeEvent =
       metadata?: void,
     }>;
 
-export type WatcherBackendOptions = $ReadOnly<{
+export type WatcherBackendOptions = Readonly<{
   ignored: ?RegExp,
-  globs: $ReadOnlyArray<string>,
+  globs: ReadonlyArray<string>,
   dot: boolean,
   ...
 }>;
 
 export type WatchmanClockSpec =
   | string
-  | $ReadOnly<{scm: $ReadOnly<{'mergebase-with': string}>}>;
+  | Readonly<{scm: Readonly<{'mergebase-with': string}>}>;
 export type WatchmanClocks = Map<Path, WatchmanClockSpec>;
 
-export type WorkerMessage = $ReadOnly<{
-  computeDependencies: boolean,
+export type WorkerMessage = Readonly<{
   computeSha1: boolean,
-  dependencyExtractor?: ?string,
-  enableHastePackages: boolean,
   filePath: string,
-  hasteImplModulePath?: ?string,
   maybeReturnContent: boolean,
+  pluginsToRun: ReadonlyArray<number>,
 }>;
 
-export type WorkerMetadata = $ReadOnly<{
-  dependencies?: ?$ReadOnlyArray<string>,
-  id?: ?string,
+export type WorkerMetadata = Readonly<{
   sha1?: ?string,
   content?: ?Buffer,
+  pluginData?: ReadonlyArray<V8Serializable>,
 }>;
 
-export type WorkerSetupArgs = $ReadOnly<{}>;
+export type WorkerSetupArgs = Readonly<{
+  plugins?: ReadonlyArray<FileMapPluginWorker['worker']>,
+}>;