metro-file-map 0.84.2 → 0.84.3

package/src/index.js

@@ -40,6 +40,7 @@ var _checkWatchmanCapabilities = _interopRequireDefault(
   require("./lib/checkWatchmanCapabilities"),
 );
 var _FileProcessor = require("./lib/FileProcessor");
+var _FileSystemChangeAggregator = require("./lib/FileSystemChangeAggregator");
 var _normalizePathSeparatorsToPosix = _interopRequireDefault(
   require("./lib/normalizePathSeparatorsToPosix"),
 );
@@ -52,7 +53,6 @@ var _Watcher = require("./Watcher");
 var _events = _interopRequireDefault(require("events"));
 var _fs = require("fs");
 var _invariant = _interopRequireDefault(require("invariant"));
-var _nullthrows = _interopRequireDefault(require("nullthrows"));
 var path = _interopRequireWildcard(require("path"));
 var _perf_hooks = require("perf_hooks");
 var _DependencyPlugin = _interopRequireDefault(
@@ -270,7 +270,7 @@ class FileMap extends _events.default {
                     };
                   },
                   fileIterator: (opts) =>
-                    mapIterator(
+                    mapIterable(
                       fileSystem.metadataIterator(opts),
                       ({ baseName, canonicalPath, metadata }) => ({
                         baseName,
@@ -284,21 +284,21 @@ class FileMap extends _events.default {
             ),
           ),
         ]);
-        await this.#applyFileDelta(fileSystem, plugins, fileDelta);
+        const actualChanges = await this.#applyFileDelta(
+          fileSystem,
+          plugins,
+          fileDelta,
+        );
+        const changeSize = actualChanges.getSize();
         plugins.forEach(({ plugin }) => plugin.assertValid());
         const watchmanClocks = new Map(fileDelta.clocks ?? []);
         await this.#takeSnapshotAndPersist(
           fileSystem,
           watchmanClocks,
           plugins,
-          fileDelta.changedFiles,
-          fileDelta.removedFiles,
-        );
-        debug(
-          "Finished mapping files (%d changes, %d removed).",
-          fileDelta.changedFiles.size,
-          fileDelta.removedFiles.size,
+          changeSize > 0,
         );
+        debug("Finished mapping files (%d changes).", changeSize);
         await this.#watch(fileSystem, watchmanClocks, plugins);
         return {
           fileSystem,
@@ -368,10 +368,9 @@ class FileMap extends _events.default {
     });
     const watcher = this.#watcher;
     watcher.on("status", (status) => this.emit("status", status));
-    return watcher.crawl().then((result) => {
-      this.#startupPerfLogger?.point("buildFileDelta_end");
-      return result;
-    });
+    const result = await watcher.crawl();
+    this.#startupPerfLogger?.point("buildFileDelta_end");
+    return result;
   }
   #maybeReadLink(normalPath, fileMetadata) {
     if (fileMetadata[_constants.default.SYMLINK] === 1) {
@@ -388,14 +387,11 @@ class FileMap extends _events.default {
     this.#startupPerfLogger?.point("applyFileDelta_start");
     const { changedFiles, removedFiles } = delta;
     this.#startupPerfLogger?.point("applyFileDelta_preprocess_start");
-    const missingFiles = new Set();
     this.#startupPerfLogger?.point("applyFileDelta_remove_start");
-    const removed = [];
+    const changeAggregator =
+      new _FileSystemChangeAggregator.FileSystemChangeAggregator();
     for (const relativeFilePath of removedFiles) {
-      const metadata = fileSystem.remove(relativeFilePath);
-      if (metadata) {
-        removed.push([relativeFilePath, metadata]);
-      }
+      fileSystem.remove(relativeFilePath, changeAggregator);
     }
     this.#startupPerfLogger?.point("applyFileDelta_remove_end");
     const readLinkPromises = [];
@@ -411,12 +407,12 @@ class FileMap extends _events.default {
         const maybeReadLink = this.#maybeReadLink(normalFilePath, fileData);
         if (maybeReadLink) {
           readLinkPromises.push(
-            maybeReadLink.catch((error) =>
+            maybeReadLink.catch((error) => {
               readLinkErrors.push({
                 normalFilePath,
                 error,
-              }),
-            ),
+              });
+            }),
           );
         }
       }
@@ -441,37 +437,34 @@ class FileMap extends _events.default {
       readLinkErrors,
     )) {
       if (["ENOENT", "EACCESS"].includes(error.code)) {
-        missingFiles.add(normalFilePath);
+        delta.changedFiles.delete(normalFilePath);
+        fileSystem.remove(normalFilePath, changeAggregator);
       } else {
         throw error;
       }
     }
-    for (const relativeFilePath of missingFiles) {
-      changedFiles.delete(relativeFilePath);
-      const metadata = fileSystem.remove(relativeFilePath);
-      if (metadata) {
-        removed.push([relativeFilePath, metadata]);
-      }
-    }
     this.#startupPerfLogger?.point("applyFileDelta_missing_end");
     this.#startupPerfLogger?.point("applyFileDelta_add_start");
-    fileSystem.bulkAddOrModify(changedFiles);
+    fileSystem.bulkAddOrModify(changedFiles, changeAggregator);
     this.#startupPerfLogger?.point("applyFileDelta_add_end");
     this.#startupPerfLogger?.point("applyFileDelta_updatePlugins_start");
-    plugins.forEach(({ plugin, dataIdx }) => {
-      const mapFn =
-        dataIdx != null
-          ? ([relativePath, fileData]) => [relativePath, fileData[dataIdx]]
-          : ([relativePath, fileData]) => [relativePath, null];
-      plugin.bulkUpdate({
-        addedOrModified: mapIterator(changedFiles.entries(), mapFn),
-        removed: mapIterator(removed.values(), mapFn),
-      });
+    this.#plugins.forEach(({ plugin, dataIdx }) => {
+      plugin.onChanged(
+        changeAggregator.getMappedView(
+          dataIdx != null ? (metadata) => metadata[dataIdx] : () => null,
+        ),
+      );
     });
     this.#startupPerfLogger?.point("applyFileDelta_updatePlugins_end");
     this.#startupPerfLogger?.point("applyFileDelta_end");
+    return changeAggregator;
   }
-  async #takeSnapshotAndPersist(fileSystem, clocks, plugins, changed, removed) {
+  async #takeSnapshotAndPersist(
+    fileSystem,
+    clocks,
+    plugins,
+    changedSinceCacheRead,
+  ) {
     this.#startupPerfLogger?.point("persist_start");
     await this.#cacheManager.write(
       () => ({
@@ -485,7 +478,7 @@ class FileMap extends _events.default {
         ),
       }),
       {
-        changedSinceCacheRead: changed.size + removed.size > 0,
+        changedSinceCacheRead,
         eventSource: {
           onChange: (cb) => {
             this.on("change", cb);
@@ -511,14 +504,46 @@ class FileMap extends _events.default {
     }
     const hasWatchedExtension = (filePath) =>
       this.#options.extensions.some((ext) => filePath.endsWith(ext));
-    let changeQueue = Promise.resolve();
     let nextEmit = null;
     const emitChange = () => {
-      if (nextEmit == null || nextEmit.eventsQueue.length === 0) {
+      if (nextEmit == null) {
+        return;
+      }
+      const { events, firstEventTimestamp, firstEnqueuedTimestamp } = nextEmit;
+      const changeAggregator =
+        new _FileSystemChangeAggregator.FileSystemChangeAggregator();
+      for (const event of events) {
+        const { relativeFilePath, clock } = event;
+        if (event.type === "delete") {
+          fileSystem.remove(relativeFilePath, changeAggregator);
+        } else {
+          fileSystem.addOrModify(
+            relativeFilePath,
+            event.metadata,
+            changeAggregator,
+          );
+        }
+        this.#updateClock(clocks, clock);
+      }
+      const changeSize = changeAggregator.getSize();
+      if (changeSize === 0) {
+        nextEmit = null;
         return;
       }
-      const { eventsQueue, firstEventTimestamp, firstEnqueuedTimestamp } =
-        nextEmit;
+      const _netChange = changeAggregator.getView();
+      this.#plugins.forEach(({ plugin, dataIdx }) => {
+        plugin.onChanged(
+          changeAggregator.getMappedView(
+            dataIdx != null ? (metadata) => metadata[dataIdx] : () => null,
+          ),
+        );
+      });
+      const toPublicMetadata = (metadata) => ({
+        isSymlink: metadata[_constants.default.SYMLINK] !== 0,
+        modifiedTime: metadata[_constants.default.MTIME] ?? null,
+      });
+      const changesWithMetadata =
+        changeAggregator.getMappedView(toPublicMetadata);
       const hmrPerfLogger = this.#options.perfLoggerFactory?.("HMR", {
         key: this.#getNextChangeID(),
       });
@@ -532,20 +557,23 @@ class FileMap extends _events.default {
         hmrPerfLogger.point("waitingForChangeInterval_end");
         hmrPerfLogger.annotate({
           int: {
-            eventsQueueLength: eventsQueue.length,
+            changeSize,
           },
         });
         hmrPerfLogger.point("fileChange_start");
       }
       const changeEvent = {
-        eventsQueue,
+        changes: changesWithMetadata,
         logger: hmrPerfLogger,
+        rootDir: this.#options.rootDir,
       };
       this.emit("change", changeEvent);
       nextEmit = null;
     };
+    let changeQueue = Promise.resolve();
     const onChange = (change) => {
       if (
+        change.event !== "recrawl" &&
         change.metadata &&
         (change.metadata.type === "d" ||
           (change.metadata.type === "f" &&
@@ -563,62 +591,36 @@ class FileMap extends _events.default {
       }
       const relativeFilePath =
         this.#pathUtils.absoluteToNormal(absoluteFilePath);
-      const linkStats = fileSystem.linkStats(relativeFilePath);
-      if (
-        change.event === "touch" &&
-        linkStats != null &&
-        change.metadata.modifiedTime != null &&
-        linkStats.modifiedTime === change.metadata.modifiedTime
-      ) {
-        return;
-      }
-      const eventTypeToEmit =
-        change.event === "touch"
-          ? linkStats == null
-            ? "add"
-            : "change"
-          : "delete";
       const onChangeStartTime =
         _perf_hooks.performance.timeOrigin + _perf_hooks.performance.now();
+      const enqueueEvent = (event) => {
+        nextEmit ??= {
+          events: [],
+          firstEnqueuedTimestamp:
+            _perf_hooks.performance.timeOrigin + _perf_hooks.performance.now(),
+          firstEventTimestamp: onChangeStartTime,
+        };
+        nextEmit.events.push(event);
+      };
       changeQueue = changeQueue
         .then(async () => {
           if (
             nextEmit != null &&
-            nextEmit.eventsQueue.find(
+            nextEmit.events.find(
               (event) =>
-                event.type === eventTypeToEmit &&
-                event.filePath === absoluteFilePath &&
+                event.type === change.event &&
+                event.relativeFilePath === relativeFilePath &&
                 ((!event.metadata && !change.metadata) ||
                   (event.metadata &&
                     change.metadata &&
-                    event.metadata.modifiedTime != null &&
+                    event.metadata[_constants.default.MTIME] != null &&
                     change.metadata.modifiedTime != null &&
-                    event.metadata.modifiedTime ===
+                    event.metadata[_constants.default.MTIME] ===
                       change.metadata.modifiedTime)),
             )
           ) {
             return null;
           }
-          const linkStats = fileSystem.linkStats(relativeFilePath);
-          const enqueueEvent = (metadata) => {
-            const event = {
-              filePath: absoluteFilePath,
-              metadata,
-              type: eventTypeToEmit,
-            };
-            if (nextEmit == null) {
-              nextEmit = {
-                eventsQueue: [event],
-                firstEnqueuedTimestamp:
-                  _perf_hooks.performance.timeOrigin +
-                  _perf_hooks.performance.now(),
-                firstEventTimestamp: onChangeStartTime,
-              };
-            } else {
-              nextEmit.eventsQueue.push(event);
-            }
-            return null;
-          };
           if (change.event === "touch") {
             (0, _invariant.default)(
               change.metadata.size != null,
@@ -645,40 +647,65 @@ class FileMap extends _events.default {
                   },
                 );
               }
-              fileSystem.addOrModify(relativeFilePath, fileMetadata);
-              this.#updateClock(clocks, change.clock);
-              plugins.forEach(({ plugin, dataIdx }) =>
-                dataIdx != null
-                  ? plugin.onNewOrModifiedFile(
-                      relativeFilePath,
-                      fileMetadata[dataIdx],
-                    )
-                  : plugin.onNewOrModifiedFile(relativeFilePath),
-              );
-              enqueueEvent(change.metadata);
+              enqueueEvent({
+                clock: change.clock,
+                relativeFilePath,
+                metadata: fileMetadata,
+                type: change.event,
+              });
             } catch (e) {
               if (!["ENOENT", "EACCESS"].includes(e.code)) {
                 throw e;
               }
             }
           } else if (change.event === "delete") {
-            if (linkStats == null) {
+            enqueueEvent({
+              clock: change.clock,
+              relativeFilePath,
+              type: "delete",
+            });
+          } else if (change.event === "recrawl") {
+            emitChange();
+            const absoluteDirPath = path.join(
+              change.root,
+              (0, _normalizePathSeparatorsToSystem.default)(
+                change.relativePath,
+              ),
+            );
+            const subpath = this.#pathUtils.absoluteToNormal(absoluteDirPath);
+            const watcher = this.#watcher;
+            (0, _invariant.default)(
+              watcher != null,
+              "Watcher must be initialized",
+            );
+            const crawlResult = await watcher.recrawl(subpath, fileSystem);
+            if (
+              crawlResult.changedFiles.size === 0 &&
+              crawlResult.removedFiles.size === 0
+            ) {
               return null;
             }
-            const metadata = (0, _nullthrows.default)(
-              fileSystem.remove(relativeFilePath),
+            const recrawlChangeAggregator = await this.#applyFileDelta(
+              fileSystem,
+              this.#plugins,
+              crawlResult,
             );
             this.#updateClock(clocks, change.clock);
-            plugins.forEach(({ plugin, dataIdx }) =>
-              dataIdx != null
-                ? plugin.onRemovedFile(relativeFilePath, metadata[dataIdx])
-                : plugin.onRemovedFile(relativeFilePath),
-            );
-            enqueueEvent({
-              modifiedTime: null,
-              size: null,
-              type: linkStats.fileType,
+            if (recrawlChangeAggregator.getSize() === 0) {
+              return null;
+            }
+            const toPublicMetadata = (metadata) => ({
+              isSymlink: metadata[_constants.default.SYMLINK] !== 0,
+              modifiedTime: metadata[_constants.default.MTIME] ?? null,
             });
+            const changesWithMetadata =
+              recrawlChangeAggregator.getMappedView(toPublicMetadata);
+            const changeEvent = {
+              changes: changesWithMetadata,
+              logger: null,
+              rootDir: this.#options.rootDir,
+            };
+            this.emit("change", changeEvent);
           } else {
             throw new Error(
               `metro-file-map: Unrecognized event type from watcher: ${change.event}`,
@@ -778,11 +805,9 @@ class FileMap extends _events.default {
   static H = _constants.default;
 }
 exports.default = FileMap;
-const mapIterator = (it, fn) =>
-  "map" in it
-    ? it.map(fn)
-    : (function* mapped() {
-        for (const item of it) {
-          yield fn(item);
-        }
-      })();
+const mapIterable = (it, fn) =>
+  (function* mapped() {
+    for (const item of it) {
+      yield fn(item);
+    }
+  })();