metro-file-map 0.83.4 → 0.83.6

package/src/lib/FileSystemChangeAggregator.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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<<5feda1b197530a9a5fdbc57200633ac5>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/FileSystemChangeAggregator.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {
+  CanonicalPath,
+  FileMetadata,
+  FileSystemListener,
+  ReadonlyFileSystemChanges,
+} from '../flow-types';
+
+export declare class FileSystemChangeAggregator implements FileSystemListener {
+  directoryAdded(canonicalPath: CanonicalPath): void;
+  directoryRemoved(canonicalPath: CanonicalPath): void;
+  fileAdded(canonicalPath: CanonicalPath, data: FileMetadata): void;
+  fileModified(
+    canonicalPath: CanonicalPath,
+    oldData: FileMetadata,
+    newData: FileMetadata,
+  ): void;
+  fileRemoved(canonicalPath: CanonicalPath, data: FileMetadata): void;
+  getSize(): number;
+  getView(): ReadonlyFileSystemChanges<FileMetadata>;
+  getMappedView<T>(
+    metadataMapFn: (metadata: FileMetadata) => T,
+  ): ReadonlyFileSystemChanges<T>;
+}

package/src/lib/FileSystemChangeAggregator.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.FileSystemChangeAggregator = void 0;
+class FileSystemChangeAggregator {
+  #addedDirectories = new Set();
+  #removedDirectories = new Set();
+  #addedFiles = new Map();
+  #modifiedFiles = new Map();
+  #removedFiles = new Map();
+  #initialMetadata = new Map();
+  directoryAdded(canonicalPath) {
+    if (!this.#removedDirectories.delete(canonicalPath)) {
+      this.#addedDirectories.add(canonicalPath);
+    }
+  }
+  directoryRemoved(canonicalPath) {
+    if (!this.#addedDirectories.delete(canonicalPath)) {
+      this.#removedDirectories.add(canonicalPath);
+    }
+  }
+  fileAdded(canonicalPath, data) {
+    if (this.#removedFiles.delete(canonicalPath)) {
+      this.#modifiedFiles.set(canonicalPath, data);
+    } else {
+      this.#addedFiles.set(canonicalPath, data);
+    }
+  }
+  fileModified(canonicalPath, oldData, newData) {
+    if (this.#addedFiles.has(canonicalPath)) {
+      this.#addedFiles.set(canonicalPath, newData);
+    } else {
+      if (!this.#initialMetadata.has(canonicalPath)) {
+        this.#initialMetadata.set(canonicalPath, oldData);
+      }
+      this.#modifiedFiles.set(canonicalPath, newData);
+    }
+  }
+  fileRemoved(canonicalPath, data) {
+    if (!this.#addedFiles.delete(canonicalPath)) {
+      let initialData = this.#initialMetadata.get(canonicalPath);
+      if (!initialData) {
+        initialData = data;
+        this.#initialMetadata.set(canonicalPath, initialData);
+      }
+      this.#modifiedFiles.delete(canonicalPath);
+      this.#removedFiles.set(canonicalPath, initialData);
+    }
+  }
+  getSize() {
+    return (
+      this.#addedDirectories.size +
+      this.#removedDirectories.size +
+      this.#addedFiles.size +
+      this.#modifiedFiles.size +
+      this.#removedFiles.size
+    );
+  }
+  getView() {
+    return {
+      addedDirectories: this.#addedDirectories,
+      removedDirectories: this.#removedDirectories,
+      addedFiles: this.#addedFiles,
+      modifiedFiles: this.#modifiedFiles,
+      removedFiles: this.#removedFiles,
+    };
+  }
+  getMappedView(metadataMapFn) {
+    return {
+      addedDirectories: this.#addedDirectories,
+      removedDirectories: this.#removedDirectories,
+      addedFiles: mapIterable(this.#addedFiles, metadataMapFn),
+      modifiedFiles: mapIterable(this.#modifiedFiles, metadataMapFn),
+      removedFiles: mapIterable(this.#removedFiles, metadataMapFn),
+    };
+  }
+}
+exports.FileSystemChangeAggregator = FileSystemChangeAggregator;
+function mapIterable(map, metadataMapFn) {
+  return {
+    *[Symbol.iterator]() {
+      for (const [path, metadata] of map) {
+        yield [path, metadataMapFn(metadata)];
+      }
+    },
+  };
+}

package/src/lib/FileSystemChangeAggregator.js.flow

@@ -0,0 +1,143 @@
+/**
+ * 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
+ * @oncall react_native
+ */
+
+import type {
+  CanonicalPath,
+  FileMetadata,
+  FileSystemListener,
+  ReadonlyFileSystemChanges,
+} from '../flow-types';
+
+export class FileSystemChangeAggregator implements FileSystemListener {
+  // Mutually exclusive with removedDirectories
+  +#addedDirectories: Set<CanonicalPath> = new Set();
+  // Mutually exclusive with addedDirectories
+  +#removedDirectories: Set<CanonicalPath> = new Set();
+
+  // Mutually exclusive with modified and removed files
+  +#addedFiles: Map<CanonicalPath, FileMetadata> = new Map();
+  // Mutually exclusive with added and removed files
+  +#modifiedFiles: Map<CanonicalPath, FileMetadata> = new Map();
+  // Mutually exclusive with added and modified files
+  +#removedFiles: Map<CanonicalPath, FileMetadata> = new Map();
+
+  // Removed files must be paired with the file's metadata the last time it was
+  // observable by consumers - ie, immediately *before* this batch. To report
+  // this accurately with minimal overhead, we'll note the current metadata of
+  // a file the first time it is modified or removed within a batch. If it is
+  // re-added, modified and removed again, we still have the initial metadata.
+  // This is particularly important if, say, a regular file is replaced by a
+  // symlink, or vice-versa.
+  +#initialMetadata: Map<CanonicalPath, FileMetadata> = new Map();
+
+  directoryAdded(canonicalPath: CanonicalPath): void {
+    // Only add to newDirectories if this directory wasn't previously removed
+    // (i.e., it's truly new). If it was removed and re-added, the net effect
+    // is no directory change.
+    if (!this.#removedDirectories.delete(canonicalPath)) {
+      this.#addedDirectories.add(canonicalPath);
+    }
+  }
+
+  directoryRemoved(canonicalPath: CanonicalPath): void {
+    if (!this.#addedDirectories.delete(canonicalPath)) {
+      this.#removedDirectories.add(canonicalPath);
+    }
+  }
+
+  fileAdded(canonicalPath: CanonicalPath, data: FileMetadata): void {
+    if (this.#removedFiles.delete(canonicalPath)) {
+      // File was removed then re-added in the same batch - treat as modification
+      this.#modifiedFiles.set(canonicalPath, data);
+    } else {
+      // New file
+      this.#addedFiles.set(canonicalPath, data);
+    }
+  }
+
+  fileModified(
+    canonicalPath: CanonicalPath,
+    oldData: FileMetadata,
+    newData: FileMetadata,
+  ): void {
+    if (this.#addedFiles.has(canonicalPath)) {
+      // File did not exist before this batch. Further modification only
+      // updates metadata
+      this.#addedFiles.set(canonicalPath, newData);
+    } else {
+      if (!this.#initialMetadata.has(canonicalPath)) {
+        this.#initialMetadata.set(canonicalPath, oldData);
+      }
+      this.#modifiedFiles.set(canonicalPath, newData);
+    }
+  }
+
+  fileRemoved(canonicalPath: CanonicalPath, data: FileMetadata): void {
+    // Check if this file was added in the same batch
+    if (!this.#addedFiles.delete(canonicalPath)) {
+      let initialData = this.#initialMetadata.get(canonicalPath);
+      if (!initialData) {
+        initialData = data;
+        this.#initialMetadata.set(canonicalPath, initialData);
+      }
+
+      // File was not added in this batch, so add to removed with last metadata
+      this.#modifiedFiles.delete(canonicalPath);
+      this.#removedFiles.set(canonicalPath, initialData);
+    }
+    // else: File was added then removed in the same batch - no net change
+  }
+
+  getSize(): number {
+    return (
+      this.#addedDirectories.size +
+      this.#removedDirectories.size +
+      this.#addedFiles.size +
+      this.#modifiedFiles.size +
+      this.#removedFiles.size
+    );
+  }
+
+  getView(): ReadonlyFileSystemChanges<FileMetadata> {
+    return {
+      addedDirectories: this.#addedDirectories,
+      removedDirectories: this.#removedDirectories,
+      addedFiles: this.#addedFiles,
+      modifiedFiles: this.#modifiedFiles,
+      removedFiles: this.#removedFiles,
+    };
+  }
+
+  getMappedView<T>(
+    metadataMapFn: (metadata: FileMetadata) => T,
+  ): ReadonlyFileSystemChanges<T> {
+    return {
+      addedDirectories: this.#addedDirectories,
+      removedDirectories: this.#removedDirectories,
+      addedFiles: mapIterable(this.#addedFiles, metadataMapFn),
+      modifiedFiles: mapIterable(this.#modifiedFiles, metadataMapFn),
+      removedFiles: mapIterable(this.#removedFiles, metadataMapFn),
+    };
+  }
+}
+
+function mapIterable<T>(
+  map: Map<CanonicalPath, FileMetadata>,
+  metadataMapFn: (metadata: FileMetadata) => T,
+): Iterable<Readonly<[CanonicalPath, T]>> {
+  return {
+    *[Symbol.iterator](): Iterator<Readonly<[CanonicalPath, T]>> {
+      for (const [path, metadata] of map) {
+        yield [path, metadataMapFn(metadata)];
+      }
+    },
+  };
+}

package/src/lib/RootPathUtils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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<<5ecdb559fce5f5c6ed50df6e4eaebf20>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/RootPathUtils.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+export declare class RootPathUtils {
+  constructor(rootDir: string);
+  getBasenameOfNthAncestor(n: number): string;
+  getParts(): ReadonlyArray<string>;
+  absoluteToNormal(absolutePath: string): string;
+  normalToAbsolute(normalPath: string): string;
+  relativeToNormal(relativePath: string): string;
+  getAncestorOfRootIdx(normalPath: string): null | undefined | number;
+  joinNormalToRelative(
+    normalPath: string,
+    relativePath: string,
+  ): {normalPath: string; collapsedSegments: number};
+  relative(from: string, to: string): string;
+}

package/src/lib/RootPathUtils.js

@@ -14,10 +14,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)) {
@@ -37,11 +34,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 UP_FRAGMENT_SEP = ".." + path.sep;
 const SEP_UP_FRAGMENT = path.sep + "..";

package/src/lib/TreeFS.d.ts

@@ -0,0 +1,174 @@
+/**
+ * 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<<65a3c4140d459a56b8c949e52b32ea1b>>
+ *
+ * This file was translated from Flow by scripts/generateTypeScriptDefinitions.js
+ * Original file: packages/metro-file-map/src/lib/TreeFS.js
+ * To regenerate, run:
+ *   js1 build metro-ts-defs (internal) OR
+ *   yarn run build-ts-defs (OSS) 
+ */
+
+import type {
+  CacheData,
+  FileData,
+  FileMetadata,
+  FileStats,
+  FileSystemListener,
+  LookupResult,
+  MutableFileSystem,
+  Path,
+  ProcessFileFunction,
+} from '../flow-types';
+
+type DirectoryNode = Map<string, MixedNode>;
+type FileNode = FileMetadata;
+type MixedNode = FileNode | DirectoryNode;
+type DeserializedSnapshotInput = {
+  rootDir: string;
+  fileSystemData: DirectoryNode;
+  processFile: ProcessFileFunction;
+};
+type TreeFSOptions = {
+  rootDir: Path;
+  files?: FileData;
+  processFile: ProcessFileFunction;
+};
+type MatchFilesOptions = Readonly<{
+  filter?: null | undefined | RegExp;
+  filterCompareAbsolute?: boolean;
+  filterComparePosix?: boolean;
+  follow?: boolean;
+  recursive?: boolean;
+  rootDir?: null | undefined | Path;
+}>;
+type MetadataIteratorOptions = Readonly<{
+  includeSymlinks: boolean;
+  includeNodeModules: boolean;
+}>;
+/**
+ * OVERVIEW:
+ *
+ * TreeFS is Metro's in-memory representation of the file system. It is
+ * structured as a tree of non-empty maps and leaves (tuples), with the root
+ * node representing the given `rootDir`, typically Metro's _project root_
+ * (not a filesystem root). Map keys are path segments, and branches outside
+ * the project root are accessed via `'..'`.
+ *
+ * EXAMPLE:
+ *
+ * For a root dir '/data/project', the file '/data/other/app/index.js' would
+ * have metadata at #rootNode.get('..').get('other').get('app').get('index.js')
+ *
+ * SERIALISATION:
+ *
+ * #rootNode is designed to be directly serialisable and directly portable (for
+ * a given project) between different root directories and operating systems.
+ *
+ * SYMLINKS:
+ *
+ * Symlinks are represented as nodes whose metadata contains their literal
+ * target. Literal targets are resolved to normal paths at runtime, and cached.
+ * If a symlink is encountered during traversal, we restart traversal at the
+ * root node targeting join(normal symlink target, remaining path suffix).
+ *
+ * NODE TYPES:
+ *
+ * - A directory (including a parent directory at '..') is represented by a
+ *   `Map` of basenames to any other node type.
+ * - A file is represented by an `Array`  (tuple) of metadata, of which:
+ *   - A regular file has node[H.SYMLINK] === 0
+ *   - A symlink has node[H.SYMLINK] === 1 or
+ *     typeof node[H.SYMLINK] === 'string', where a string is the literal
+ *     content of the symlink (i.e. from readlink), if known.
+ *
+ * TERMINOLOGY:
+ *
+ * - mixedPath
+ *   A root-relative or absolute path
+ * - relativePath
+ *   A root-relative path
+ * - normalPath
+ *   A root-relative, normalised path (no extraneous '.' or '..'), may have a
+ *   single trailing slash
+ * - canonicalPath
+ *   A root-relative, normalised, real path (no symlinks in dirname), never has
+ *   a trailing slash
+ */
+declare class TreeFS implements MutableFileSystem {
+  constructor(opts: TreeFSOptions);
+  getSerializableSnapshot(): CacheData['fileSystemData'];
+  static fromDeserializedSnapshot(args: DeserializedSnapshotInput): TreeFS;
+  getSize(mixedPath: Path): null | undefined | number;
+  getDifference(
+    files: FileData,
+    options?: Readonly<{subpath?: string}>,
+  ): {changedFiles: FileData; removedFiles: Set<string>};
+  getSha1(mixedPath: Path): null | undefined | string;
+  getOrComputeSha1(
+    mixedPath: Path,
+  ): Promise<null | undefined | {sha1: string; content?: Buffer}>;
+  exists(mixedPath: Path): boolean;
+  lookup(mixedPath: Path): LookupResult;
+  getAllFiles(): Array<Path>;
+  linkStats(mixedPath: Path): null | undefined | FileStats;
+  /**
+   * Given a search context, return a list of file paths matching the query.
+   * The query matches against normalized paths which start with `./`,
+   * for example: `a/b.js` -> `./a/b.js`
+   */
+  matchFiles(opts: MatchFilesOptions): Iterable<Path>;
+  addOrModify(
+    mixedPath: Path,
+    metadata: FileMetadata,
+    changeListener?: FileSystemListener,
+  ): void;
+  bulkAddOrModify(
+    addedOrModifiedFiles: FileData,
+    changeListener?: FileSystemListener,
+  ): void;
+  remove(mixedPath: Path, changeListener?: FileSystemListener): void;
+  /**
+   * 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};
+  metadataIterator(opts: MetadataIteratorOptions): Iterator<{
+    baseName: string;
+    canonicalPath: string;
+    metadata: FileMetadata;
+  }>;
+}
+export default TreeFS;

package/src/lib/TreeFS.js

@@ -9,11 +9,7 @@ var _RootPathUtils = require("./RootPathUtils");
 var _invariant = _interopRequireDefault(require("invariant"));
 var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 function isDirectory(node) {
   return node instanceof Map;
@@ -52,13 +48,33 @@ class TreeFS {
     const fileMetadata = this.#getFileData(mixedPath);
     return (fileMetadata && fileMetadata[_constants.default.SIZE]) ?? null;
   }
-  getDifference(files) {
+  getDifference(files, options) {
     const changedFiles = new Map(files);
     const removedFiles = new Set();
-    for (const { canonicalPath, metadata } of this.metadataIterator({
-      includeNodeModules: true,
-      includeSymlinks: true,
-    })) {
+    const subpath = options?.subpath;
+    let rootNode = this.#rootNode;
+    let prefix = "";
+    if (subpath != null && subpath !== "") {
+      const lookupResult = this.#lookupByNormalPath(subpath, {
+        followLeaf: true,
+      });
+      if (!lookupResult.exists || !isDirectory(lookupResult.node)) {
+        return {
+          changedFiles,
+          removedFiles,
+        };
+      }
+      rootNode = lookupResult.node;
+      prefix = lookupResult.canonicalPath;
+    }
+    for (const { canonicalPath, metadata } of this.#metadataIterator(
+      rootNode,
+      {
+        includeNodeModules: true,
+        includeSymlinks: true,
+      },
+      prefix,
+    )) {
       const newMetadata = files.get(canonicalPath);
       if (newMetadata) {
         if (isRegularFile(newMetadata) !== isRegularFile(metadata)) {
@@ -257,11 +273,12 @@ class TreeFS {
       }
     }
   }
-  addOrModify(mixedPath, metadata) {
+  addOrModify(mixedPath, metadata, changeListener) {
     const normalPath = this.#normalizePath(mixedPath);
     const parentDirNode = this.#lookupByNormalPath(
       _path.default.dirname(normalPath),
       {
+        changeListener,
         makeDirectories: true,
       },
     );
@@ -275,9 +292,9 @@ class TreeFS {
         _path.default.sep +
         _path.default.basename(normalPath),
     );
-    this.bulkAddOrModify(new Map([[canonicalPath, metadata]]));
+    this.bulkAddOrModify(new Map([[canonicalPath, metadata]]), changeListener);
   }
-  bulkAddOrModify(addedOrModifiedFiles) {
+  bulkAddOrModify(addedOrModifiedFiles, changeListener) {
     let lastDir;
     let directoryNode;
     for (const [normalPath, metadata] of addedOrModifiedFiles) {
@@ -287,6 +304,7 @@ class TreeFS {
         lastSepIdx === -1 ? normalPath : normalPath.slice(lastSepIdx + 1);
       if (directoryNode == null || dirname !== lastDir) {
         const lookup = this.#lookupByNormalPath(dirname, {
+          changeListener,
           followLeaf: false,
           makeDirectories: true,
         });
@@ -305,30 +323,53 @@ class TreeFS {
         lastDir = dirname;
         directoryNode = lookup.node;
       }
+      if (changeListener != null) {
+        const existingNode = directoryNode.get(basename);
+        if (existingNode != null) {
+          (0, _invariant.default)(
+            !isDirectory(existingNode),
+            "Detected addition or modification of file %s, but it is tracked as a non-empty directory",
+            normalPath,
+          );
+          changeListener.fileModified(normalPath, existingNode, metadata);
+        } else {
+          changeListener.fileAdded(normalPath, metadata);
+        }
+      }
       directoryNode.set(basename, metadata);
     }
   }
-  remove(mixedPath) {
+  remove(mixedPath, changeListener) {
     const normalPath = this.#normalizePath(mixedPath);
     const result = this.#lookupByNormalPath(normalPath, {
       followLeaf: false,
     });
     if (!result.exists) {
-      return null;
+      return;
     }
     const { parentNode, canonicalPath, node } = result;
     if (isDirectory(node) && node.size > 0) {
-      throw new Error(
-        `TreeFS: remove called on a non-empty directory: ${mixedPath}`,
-      );
+      for (const basename of node.keys()) {
+        this.remove(
+          canonicalPath + _path.default.sep + basename,
+          changeListener,
+        );
+      }
+      return;
     }
     if (parentNode != null) {
+      if (changeListener != null) {
+        if (isDirectory(node)) {
+          changeListener.directoryRemoved(canonicalPath);
+        } else {
+          changeListener.fileRemoved(canonicalPath, node);
+        }
+      }
       parentNode.delete(_path.default.basename(canonicalPath));
       if (parentNode.size === 0 && parentNode !== this.#rootNode) {
-        this.remove(_path.default.dirname(canonicalPath));
+        this.remove(_path.default.dirname(canonicalPath), changeListener);
       }
     }
-    return isDirectory(node) ? null : node;
   }
   #lookupByNormalPath(
     requestedNormalPath,
@@ -342,7 +383,7 @@ class TreeFS {
     let fromIdx = opts.start?.pathIdx ?? 0;
     let parentNode = opts.start?.node ?? this.#rootNode;
     let ancestorOfRootIdx = opts.start?.ancestorOfRootIdx ?? 0;
-    const collectAncestors = opts.collectAncestors;
+    const { collectAncestors, changeListener } = opts;
     let unseenPathFromIdx = 0;
     while (targetNormalPath.length > fromIdx) {
       const nextSepIdx = targetNormalPath.indexOf(_path.default.sep, fromIdx);
@@ -373,6 +414,12 @@ class TreeFS {
         }
         segmentNode = new Map();
         if (opts.makeDirectories === true) {
+          if (changeListener != null) {
+            const canonicalPath = isLastSegment
+              ? targetNormalPath
+              : targetNormalPath.slice(0, fromIdx - 1);
+            changeListener.directoryAdded(canonicalPath);
+          }
           parentNode.set(segmentName, segmentNode);
         }
       }