metro-file-map 0.83.4 → 0.83.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro-file-map",
-  "version": "0.83.4",
+  "version": "0.83.5",
   "description": "[Experimental] - 🚇 File crawling, watching and mapping for Metro",
   "main": "src/index.js",
   "exports": {
@@ -10,7 +10,8 @@
   },
   "repository": {
     "type": "git",
-    "url": "git@github.com:facebook/metro.git"
+    "url": "git+https://github.com/facebook/metro.git",
+    "directory": "packages/metro-file-map"
   },
   "scripts": {
     "prepare-release": "test -d build && rm -rf src.real && mv src src.real && mv build src",

package/src/Watcher.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.
+ *
+ * @format
+ */
+
+import type {
+  Console,
+  CrawlerOptions,
+  FileData,
+  Path,
+  PerfLogger,
+  WatcherBackendChangeEvent,
+  WatchmanClocks,
+} from './flow-types';
+
+import EventEmitter from 'events';
+
+type CrawlResult = {
+  changedFiles: FileData;
+  clocks?: WatchmanClocks;
+  removedFiles: Set<Path>;
+};
+type WatcherOptions = {
+  abortSignal: AbortSignal;
+  computeSha1: boolean;
+  console: Console;
+  enableSymlinks: boolean;
+  extensions: ReadonlyArray<string>;
+  forceNodeFilesystemAPI: boolean;
+  healthCheckFilePrefix: string;
+  ignoreForCrawl: (filePath: string) => boolean;
+  ignorePatternForWatch: RegExp;
+  previousState: CrawlerOptions['previousState'];
+  perfLogger: null | undefined | PerfLogger;
+  roots: ReadonlyArray<string>;
+  rootDir: string;
+  useWatchman: boolean;
+  watch: boolean;
+  watchmanDeferStates: ReadonlyArray<string>;
+};
+export type HealthCheckResult =
+  | {
+      type: 'error';
+      timeout: number;
+      error: Error;
+      watcher: null | undefined | string;
+    }
+  | {
+      type: 'success';
+      timeout: number;
+      timeElapsed: number;
+      watcher: null | undefined | string;
+    }
+  | {
+      type: 'timeout';
+      timeout: number;
+      watcher: null | undefined | string;
+      pauseReason: null | undefined | string;
+    };
+export declare class Watcher extends EventEmitter {
+  constructor(options: WatcherOptions);
+  crawl(): Promise<CrawlResult>;
+  watch(onChange: (change: WatcherBackendChangeEvent) => void): void;
+  close(): void;
+  checkHealth(timeout: number): Promise<HealthCheckResult>;
+}

package/src/Watcher.js

@@ -29,10 +29,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)) {
@@ -52,11 +49,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:Watcher");
 const MAX_WAIT_TIME = 240000;

package/src/cache/DiskCacheManager.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+import type {
+  BuildParameters,
+  CacheData,
+  CacheManager,
+  CacheManagerFactoryOptions,
+  CacheManagerWriteOptions,
+} from '../flow-types';
+
+type AutoSaveOptions = Readonly<{debounceMs: number}>;
+type DiskCacheConfig = Readonly<{
+  autoSave?: Partial<AutoSaveOptions> | boolean;
+  cacheFilePrefix?: null | undefined | string;
+  cacheDirectory?: null | undefined | string;
+}>;
+export declare class DiskCacheManager implements CacheManager {
+  constructor(
+    $$PARAM_0$$: CacheManagerFactoryOptions,
+    $$PARAM_1$$: DiskCacheConfig,
+  );
+  static getCacheFilePath(
+    buildParameters: BuildParameters,
+    cacheFilePrefix?: null | undefined | string,
+    cacheDirectory?: null | undefined | string,
+  ): string;
+  getCacheFilePath(): string;
+  read(): Promise<null | undefined | CacheData>;
+  write(
+    getSnapshot: () => CacheData,
+    $$PARAM_1$$: CacheManagerWriteOptions,
+  ): Promise<void>;
+  end(): Promise<void>;
+}

package/src/cache/DiskCacheManager.js

@@ -13,11 +13,7 @@ var _path = _interopRequireDefault(require("path"));
 var _timers = require("timers");
 var _v = require("v8");
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const debug = require("debug")("Metro:FileMapCache");
 const DEFAULT_PREFIX = "metro-file-map";

package/src/constants.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 {HType} from './flow-types';
+
+declare const $$EXPORT_DEFAULT_DECLARATION$$: HType;
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
+export default $$EXPORT_DEFAULT_DECLARATION$$;

package/src/crawlers/node/hasNativeFindSupport.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+declare function hasNativeFindSupport(): Promise<boolean>;
+export default hasNativeFindSupport;

package/src/crawlers/node/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+import type {CanonicalPath, CrawlerOptions, FileData} from '../../flow-types';
+
+declare function nodeCrawl(
+  options: CrawlerOptions,
+): Promise<{removedFiles: Set<CanonicalPath>; changedFiles: FileData}>;
+export default nodeCrawl;

package/src/crawlers/node/index.js

@@ -20,10 +20,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)) {
@@ -43,11 +40,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:NodeCrawler");
 function find(

package/src/crawlers/watchman/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+import type {
+  CanonicalPath,
+  CrawlerOptions,
+  FileData,
+  WatchmanClocks,
+} from '../../flow-types';
+
+declare function watchmanCrawl($$PARAM_0$$: CrawlerOptions): Promise<{
+  changedFiles: FileData;
+  removedFiles: Set<CanonicalPath>;
+  clocks: WatchmanClocks;
+}>;
+export default watchmanCrawl;

package/src/crawlers/watchman/index.js

@@ -24,10 +24,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)) {
@@ -47,11 +44,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 WATCHMAN_WARNING_INITIAL_DELAY_MILLISECONDS = 10000;
 const WATCHMAN_WARNING_INTERVAL_MILLISECONDS = 20000;

package/src/flow-types.d.ts

@@ -0,0 +1,404 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+import type {PerfLogger, PerfLoggerFactory, RootPerfLogger} from 'metro-config';
+
+export type {PerfLoggerFactory, PerfLogger};
+export type BuildParameters = Readonly<{
+  computeSha1: boolean;
+  enableSymlinks: boolean;
+  extensions: ReadonlyArray<string>;
+  forceNodeFilesystemAPI: boolean;
+  ignorePattern: RegExp;
+  plugins: ReadonlyArray<FileMapPlugin>;
+  retainAllFiles: boolean;
+  rootDir: string;
+  roots: ReadonlyArray<string>;
+  cacheBreaker: string;
+}>;
+export type BuildResult = {fileSystem: FileSystem};
+export type CacheData = Readonly<{
+  clocks: WatchmanClocks;
+  fileSystemData: unknown;
+  plugins: ReadonlyMap<string, void | V8Serializable>;
+}>;
+export interface CacheManager {
+  /**
+   * Called during startup to load initial state, if available. Provided to
+   * a crawler, which will return the delta between the initial state and the
+   * current file system state.
+   */
+  read(): Promise<null | undefined | CacheData>;
+  /**
+   * Called when metro-file-map `build()` has applied changes returned by the
+   * crawler - i.e. internal state reflects the current file system state.
+   *
+   * getSnapshot may be retained and called at any time before end(), such as
+   * in response to eventSource 'change' events.
+   */
+  write(
+    getSnapshot: () => CacheData,
+    opts: CacheManagerWriteOptions,
+  ): Promise<void>;
+  /**
+   * The last call that will be made to this CacheManager. Any handles should
+   * be closed by the time this settles.
+   */
+  end(): Promise<void>;
+}
+export interface CacheManagerEventSource {
+  onChange(listener: () => void): () => void;
+}
+export type CacheManagerFactory = (
+  options: CacheManagerFactoryOptions,
+) => CacheManager;
+export type CacheManagerFactoryOptions = Readonly<{
+  buildParameters: BuildParameters;
+}>;
+export type CacheManagerWriteOptions = Readonly<{
+  changedSinceCacheRead: boolean;
+  eventSource: CacheManagerEventSource;
+  onWriteError: (error: Error) => void;
+}>;
+export type CanonicalPath = string;
+export type ChangeEvent = {
+  logger: null | undefined | RootPerfLogger;
+  eventsQueue: EventsQueue;
+};
+export type ChangeEventMetadata = {
+  modifiedTime: null | undefined | number;
+  size: null | undefined | number;
+  type: 'f' | 'd' | 'l';
+};
+export type Console = typeof global.console;
+export type CrawlerOptions = {
+  abortSignal: null | undefined | AbortSignal;
+  computeSha1: boolean;
+  console: Console;
+  extensions: ReadonlyArray<string>;
+  forceNodeFilesystemAPI: boolean;
+  ignore: IgnoreMatcher;
+  includeSymlinks: boolean;
+  perfLogger?: null | undefined | PerfLogger;
+  previousState: Readonly<{
+    clocks: ReadonlyMap<CanonicalPath, WatchmanClockSpec>;
+    fileSystem: FileSystem;
+  }>;
+  rootDir: string;
+  roots: ReadonlyArray<string>;
+  onStatus: (status: WatcherStatus) => void;
+};
+export type DependencyExtractor = {
+  extract: (
+    content: string,
+    absoluteFilePath: string,
+    defaultExtractor?: DependencyExtractor['extract'],
+  ) => Set<string>;
+  getCacheKey: () => string;
+};
+export type WatcherStatus =
+  | {
+      type: 'watchman_slow_command';
+      timeElapsed: number;
+      command: 'watch-project' | 'query';
+    }
+  | {
+      type: 'watchman_slow_command_complete';
+      timeElapsed: number;
+      command: 'watch-project' | 'query';
+    }
+  | {
+      type: 'watchman_warning';
+      warning: unknown;
+      command: 'watch-project' | 'query';
+    };
+export type DuplicatesSet = Map<string, number>;
+export type DuplicatesIndex = Map<string, Map<string, DuplicatesSet>>;
+export type EventsQueue = Array<{
+  filePath: Path;
+  metadata: ChangeEventMetadata;
+  type: string;
+}>;
+export type FileMapDelta<T = null | void> = Readonly<{
+  removed: Iterable<[CanonicalPath, T]>;
+  addedOrModified: Iterable<[CanonicalPath, T]>;
+}>;
+export type FileMapPluginInitOptions<
+  SerializableState,
+  PerFileData = void,
+> = Readonly<{
+  files: Readonly<{
+    fileIterator(
+      opts: Readonly<{includeNodeModules: boolean; includeSymlinks: boolean}>,
+    ): Iterable<{
+      baseName: string;
+      canonicalPath: string;
+      pluginData: null | undefined | PerFileData;
+    }>;
+    lookup(
+      mixedPath: string,
+    ):
+      | {exists: false}
+      | {exists: true; type: 'f'; pluginData: PerFileData}
+      | {exists: true; type: 'd'};
+  }>;
+  pluginState: null | undefined | SerializableState;
+}>;
+export type FileMapPluginWorker = Readonly<{
+  worker: Readonly<{modulePath: string; setupArgs: JsonData}>;
+  filter: ($$PARAM_0$$: {
+    normalPath: string;
+    isNodeModules: boolean;
+  }) => boolean;
+}>;
+export type V8Serializable =
+  | string
+  | number
+  | boolean
+  | null
+  | ReadonlyArray<V8Serializable>
+  | ReadonlySet<V8Serializable>
+  | ReadonlyMap<string, V8Serializable>
+  | Readonly<{[key: string]: V8Serializable}>;
+export interface FileMapPlugin<
+  SerializableState extends void | V8Serializable = void | V8Serializable,
+  PerFileData extends void | V8Serializable = void | V8Serializable,
+> {
+  readonly name: string;
+  initialize(
+    initOptions: FileMapPluginInitOptions<SerializableState, PerFileData>,
+  ): Promise<void>;
+  assertValid(): void;
+  bulkUpdate(delta: FileMapDelta<null | undefined | PerFileData>): void;
+  getSerializableSnapshot(): SerializableState;
+  onRemovedFile(
+    relativeFilePath: string,
+    pluginData: null | undefined | PerFileData,
+  ): void;
+  onNewOrModifiedFile(
+    relativeFilePath: string,
+    pluginData: null | undefined | PerFileData,
+  ): void;
+  getCacheKey(): string;
+  getWorker(): null | undefined | FileMapPluginWorker;
+}
+export interface MetadataWorker {
+  processFile(
+    $$PARAM_0$$: WorkerMessage,
+    $$PARAM_1$$: Readonly<{getContent: () => Buffer}>,
+  ): V8Serializable;
+}
+export type HType = {
+  MTIME: 0;
+  SIZE: 1;
+  VISITED: 2;
+  SHA1: 3;
+  SYMLINK: 4;
+  PLUGINDATA: number;
+  PATH: 0;
+  TYPE: 1;
+  MODULE: 0;
+  PACKAGE: 1;
+  GENERIC_PLATFORM: 'g';
+  NATIVE_PLATFORM: 'native';
+};
+export type HTypeValue = HType[keyof HType];
+export type IgnoreMatcher = (item: string) => boolean;
+export type FileData = Map<CanonicalPath, FileMetadata>;
+export type FileMetadata = [
+  null | undefined | number,
+  number,
+  0 | 1,
+  null | undefined | string,
+  0 | 1 | string,
+  ...unknown[],
+];
+export type FileStats = Readonly<{
+  fileType: 'f' | 'l';
+  modifiedTime: null | undefined | number;
+  size: null | undefined | number;
+}>;
+export interface FileSystem {
+  exists(file: Path): boolean;
+  getAllFiles(): Array<Path>;
+  getDifference(files: FileData): {
+    changedFiles: FileData;
+    removedFiles: Set<string>;
+  };
+  getSerializableSnapshot(): CacheData['fileSystemData'];
+  getSha1(file: Path): null | undefined | string;
+  getOrComputeSha1(
+    file: Path,
+  ): Promise<null | undefined | {sha1: string; content?: Buffer}>;
+  /**
+   * Given a start path (which need not exist), a subpath and type, and
+   * optionally a 'breakOnSegment', performs the following:
+   *
+   * X = mixedStartPath
+   * do
+   *   if basename(X) === opts.breakOnSegment
+   *     return null
+   *   if X + subpath exists and has type opts.subpathType
+   *     return {
+   *       absolutePath: realpath(X + subpath)
+   *       containerRelativePath: relative(mixedStartPath, X)
+   *     }
+   *   X = dirname(X)
+   * while X !== dirname(X)
+   *
+   * If opts.invalidatedBy is given, collects all absolute, real paths that if
+   * added or removed may invalidate this result.
+   *
+   * Useful for finding the closest package scope (subpath: package.json,
+   * type f, breakOnSegment: node_modules) or closest potential package root
+   * (subpath: node_modules/pkg, type: d) in Node.js resolution.
+   */
+  hierarchicalLookup(
+    mixedStartPath: string,
+    subpath: string,
+    opts: {
+      breakOnSegment: null | undefined | string;
+      invalidatedBy: null | undefined | Set<string>;
+      subpathType: 'f' | 'd';
+    },
+  ): null | undefined | {absolutePath: string; containerRelativePath: string};
+  /**
+   * Analogous to posix lstat. If the file at `file` is a symlink, return
+   * information about the symlink without following it.
+   */
+  linkStats(file: Path): null | undefined | FileStats;
+  /**
+   * Return information about the given path, whether a directory or file.
+   * Always follow symlinks, and return a real path if it exists.
+   */
+  lookup(mixedPath: Path): LookupResult;
+  matchFiles(opts: {
+    filter?: RegExp | null;
+    filterCompareAbsolute?: boolean;
+    filterComparePosix?: boolean;
+    follow?: boolean;
+    recursive?: boolean;
+    rootDir?: Path | null;
+  }): Iterable<Path>;
+}
+export type Glob = string;
+export type JsonData =
+  | string
+  | number
+  | boolean
+  | null
+  | Array<JsonData>
+  | {[key: string]: JsonData};
+export type LookupResult =
+  | {exists: false; links: ReadonlySet<string>; missing: string}
+  | {exists: true; links: ReadonlySet<string>; realPath: string; type: 'd'}
+  | {
+      exists: true;
+      links: ReadonlySet<string>;
+      realPath: string;
+      type: 'f';
+      metadata: FileMetadata;
+    };
+export interface MockMap {
+  getMockModule(name: string): null | undefined | Path;
+}
+export type HasteConflict = {
+  id: string;
+  platform: string | null;
+  absolutePaths: Array<string>;
+  type: 'duplicate' | 'shadowing';
+};
+export interface HasteMap {
+  getModule(
+    name: string,
+    platform?: null | undefined | string,
+    supportsNativePlatform?: null | undefined | boolean,
+    type?: null | undefined | HTypeValue,
+  ): null | undefined | Path;
+  getModuleNameByPath(file: Path): null | undefined | string;
+  getPackage(
+    name: string,
+    platform: null | undefined | string,
+    _supportsNativePlatform: null | undefined | boolean,
+  ): null | undefined | Path;
+  computeConflicts(): Array<HasteConflict>;
+}
+export type HasteMapData = Map<string, HasteMapItem>;
+export type HasteMapItem = {
+  [platform: string]: HasteMapItemMetadata;
+};
+export type HasteMapItemMetadata = [string, number];
+export interface MutableFileSystem extends FileSystem {
+  remove(filePath: Path): null | undefined | FileMetadata;
+  addOrModify(filePath: Path, fileMetadata: FileMetadata): void;
+  bulkAddOrModify(addedOrModifiedFiles: FileData): void;
+}
+export type Path = string;
+export type ProcessFileFunction = (
+  normalPath: string,
+  metadata: FileMetadata,
+  request: Readonly<{computeSha1: boolean}>,
+) => null | undefined | Buffer;
+export type RawMockMap = Readonly<{
+  duplicates: Map<string, Set<string>>;
+  mocks: Map<string, Path>;
+  version: number;
+}>;
+export type ReadOnlyRawMockMap = Readonly<{
+  duplicates: ReadonlyMap<string, ReadonlySet<string>>;
+  mocks: ReadonlyMap<string, Path>;
+  version: number;
+}>;
+export interface WatcherBackend {
+  getPauseReason(): null | undefined | string;
+  onError(listener: (error: Error) => void): () => void;
+  onFileEvent(listener: (event: WatcherBackendChangeEvent) => void): () => void;
+  startWatching(): Promise<void>;
+  stopWatching(): Promise<void>;
+}
+export type ChangeEventClock = [string, string];
+export type WatcherBackendChangeEvent =
+  | Readonly<{
+      event: 'touch';
+      clock?: ChangeEventClock;
+      relativePath: string;
+      root: string;
+      metadata: ChangeEventMetadata;
+    }>
+  | Readonly<{
+      event: 'delete';
+      clock?: ChangeEventClock;
+      relativePath: string;
+      root: string;
+      metadata?: void;
+    }>;
+export type WatcherBackendOptions = Readonly<{
+  ignored: null | undefined | RegExp;
+  globs: ReadonlyArray<string>;
+  dot: boolean;
+}>;
+export type WatchmanClockSpec =
+  | string
+  | Readonly<{scm: Readonly<{'mergebase-with': string}>}>;
+export type WatchmanClocks = Map<Path, WatchmanClockSpec>;
+export type WorkerMessage = Readonly<{
+  computeSha1: boolean;
+  filePath: string;
+  maybeReturnContent: boolean;
+  pluginsToRun: ReadonlyArray<number>;
+}>;
+export type WorkerMetadata = Readonly<{
+  sha1?: null | undefined | string;
+  content?: null | undefined | Buffer;
+  pluginData?: ReadonlyArray<V8Serializable>;
+}>;
+export type WorkerSetupArgs = Readonly<{
+  plugins?: ReadonlyArray<FileMapPluginWorker['worker']>;
+}>;