@atlaspack/fs 2.15.16-typescript-e99c742e9.0 → 2.15.16-typescript-bc4459c37.0

package/lib/NodeFS.browser.d.ts

@@ -0,0 +1,4 @@
+import type { FileSystem } from '@atlaspack/types-internal';
+export declare class NodeFS implements FileSystem {
+    constructor();
+}

package/lib/NodeFS.browser.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NodeFS = void 0;
+// @ts-expect-error TS2420
+class NodeFS {
+  constructor() {
+    throw new Error("NodeFS isn't available in the browser");
+  }
+}
+exports.NodeFS = NodeFS;

package/lib/NodeFS.d.ts

@@ -0,0 +1,38 @@
+import type { ReadStream, Stats } from 'fs';
+import type { Writable } from 'stream';
+import type { FilePath, Encoding, FileOptions, FileSystem } from '@atlaspack/types-internal';
+import type { Event, Options as WatcherOptions, AsyncSubscription } from '@parcel/watcher';
+import watcher from '@parcel/watcher';
+export declare class NodeFS implements FileSystem {
+    readFile: any;
+    copyFile: any;
+    stat: any;
+    readdir: any;
+    symlink: any;
+    unlink: any;
+    utimes: any;
+    ncp: any;
+    createReadStream: (path: string, options?: any) => ReadStream;
+    cwd: () => string;
+    chdir: (directory: string) => void;
+    statSync: (path: string) => Stats;
+    realpathSync: (path: string, cache?: any) => string;
+    existsSync: (path: string) => boolean;
+    readdirSync: any;
+    findAncestorFile: any;
+    findNodeModule: any;
+    findFirstFile: any;
+    watcher(): typeof watcher;
+    createWriteStream(filePath: string, options?: any): Writable;
+    writeFile(filePath: FilePath, contents: Buffer | string, options?: FileOptions | null): Promise<void>;
+    readFileSync(filePath: FilePath, encoding?: Encoding): any;
+    realpath(originalPath: string): Promise<string>;
+    exists(filePath: FilePath): Promise<boolean>;
+    watch(dir: FilePath, fn: (err: Error | null | undefined, events: Array<Event>) => unknown, opts: WatcherOptions): Promise<AsyncSubscription>;
+    getEventsSince(dir: FilePath, snapshot: FilePath, opts: WatcherOptions): Promise<Array<Event>>;
+    writeSnapshot(dir: FilePath, snapshot: FilePath, opts: WatcherOptions): Promise<void>;
+    static deserialize(): NodeFS;
+    serialize(): null;
+    mkdirp(filePath: FilePath): Promise<void>;
+    rimraf(filePath: FilePath): Promise<void>;
+}

package/lib/NodeFS.js

@@ -0,0 +1,298 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NodeFS = void 0;
+function _gracefulFs() {
+  const data = _interopRequireDefault(require("graceful-fs"));
+  _gracefulFs = function () {
+    return data;
+  };
+  return data;
+}
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _ncp() {
+  const data = _interopRequireDefault(require("ncp"));
+  _ncp = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _os() {
+  const data = require("os");
+  _os = function () {
+    return data;
+  };
+  return data;
+}
+function _util() {
+  const data = require("util");
+  _util = function () {
+    return data;
+  };
+  return data;
+}
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+function _watcher() {
+  const data = _interopRequireDefault(require("@parcel/watcher"));
+  _watcher = function () {
+    return data;
+  };
+  return data;
+}
+var _package = _interopRequireDefault(require("../package.json"));
+function searchNative() {
+  const data = _interopRequireWildcard(require("@atlaspack/rust"));
+  searchNative = function () {
+    return data;
+  };
+  return data;
+}
+var searchJS = _interopRequireWildcard(require("./find"));
+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 && Object.prototype.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]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// @ts-expect-error TS7016
+
+// @ts-expect-error TS7016
+
+// Most of this can go away once we only support Node 10+, which includes
+// require('fs').promises
+const realpath = (0, _util().promisify)(process.platform === 'win32' ? _gracefulFs().default.realpath : _gracefulFs().default.realpath.native);
+const isPnP = process.versions.pnp != null;
+function getWatchmanWatcher() {
+  // This is here to trick atlaspack into ignoring this require...
+  const packageName = ['@atlaspack', 'watcher-watchman-js'].join('/');
+  return require(packageName);
+}
+class NodeFS {
+  readFile = (0, _util().promisify)(_gracefulFs().default.readFile);
+  copyFile = (0, _util().promisify)(_gracefulFs().default.copyFile);
+  stat = (0, _util().promisify)(_gracefulFs().default.stat);
+  readdir = (0, _util().promisify)(_gracefulFs().default.readdir);
+  symlink = (0, _util().promisify)(_gracefulFs().default.symlink);
+  unlink = (0, _util().promisify)(_gracefulFs().default.unlink);
+  utimes = (0, _util().promisify)(_gracefulFs().default.utimes);
+  ncp = (0, _util().promisify)(_ncp().default);
+  createReadStream = _gracefulFs().default.createReadStream;
+  cwd = () => process.cwd();
+  chdir = directory => process.chdir(directory);
+  statSync = path => _gracefulFs().default.statSync(path);
+  realpathSync = process.platform === 'win32' ? _gracefulFs().default.realpathSync : _gracefulFs().default.realpathSync.native;
+  existsSync = _gracefulFs().default.existsSync;
+  readdirSync = _gracefulFs().default.readdirSync;
+  findAncestorFile = isPnP ?
+  // @ts-expect-error TS7019
+  (...args) => searchJS.findAncestorFile(this, ...args) : searchNative().findAncestorFile;
+  findNodeModule = isPnP ?
+  // @ts-expect-error TS7019
+  (...args) => searchJS.findNodeModule(this, ...args) : searchNative().findNodeModule;
+  findFirstFile = isPnP ?
+  // @ts-expect-error TS7019
+  (...args) => searchJS.findFirstFile(this, ...args) : searchNative().findFirstFile;
+  watcher() {
+    return (0, _featureFlags().getFeatureFlag)('useWatchmanWatcher') ? getWatchmanWatcher() : _watcher().default;
+  }
+  createWriteStream(filePath, options) {
+    // Make createWriteStream atomic
+    let tmpFilePath = getTempFilePath(filePath);
+    let failed = false;
+    const move = async () => {
+      if (!failed) {
+        try {
+          await _gracefulFs().default.promises.rename(tmpFilePath, filePath);
+        } catch (e) {
+          // This is adapted from fs-write-stream-atomic. Apparently
+          // Windows doesn't like renaming when the target already exists.
+          if (process.platform === 'win32' && e.syscall && e.syscall === 'rename' && e.code && e.code === 'EPERM') {
+            let [hashTmp, hashTarget] = await Promise.all([(0, _utils().hashFile)(this, tmpFilePath), (0, _utils().hashFile)(this, filePath)]);
+            await this.unlink(tmpFilePath);
+            if (hashTmp != hashTarget) {
+              throw e;
+            }
+          }
+        }
+      }
+    };
+    let writeStream = _gracefulFs().default.createWriteStream(tmpFilePath, {
+      ...options,
+      fs: {
+        ..._gracefulFs().default,
+        // @ts-expect-error TS7006
+        close: (fd, cb) => {
+          // @ts-expect-error TS7006
+          _gracefulFs().default.close(fd, err => {
+            if (err) {
+              cb(err);
+            } else {
+              move().then(() => cb(), err => cb(err));
+            }
+          });
+        }
+      }
+    });
+    writeStream.once('error', () => {
+      failed = true;
+      try {
+        _gracefulFs().default.unlinkSync(tmpFilePath);
+      } catch (_err) {
+        // ignore
+      }
+    });
+    return writeStream;
+  }
+  async writeFile(filePath, contents, options) {
+    let tmpFilePath = getTempFilePath(filePath);
+    await _gracefulFs().default.promises.writeFile(tmpFilePath, contents, options);
+    await _gracefulFs().default.promises.rename(tmpFilePath, filePath);
+  }
+  readFileSync(filePath, encoding) {
+    if (encoding != null) {
+      return _gracefulFs().default.readFileSync(filePath, encoding);
+    }
+    return _gracefulFs().default.readFileSync(filePath);
+  }
+  async realpath(originalPath) {
+    try {
+      return await realpath(originalPath, 'utf8');
+    } catch (e) {
+      // do nothing
+    }
+    return originalPath;
+  }
+  exists(filePath) {
+    return new Promise(resolve => {
+      _gracefulFs().default.exists(filePath, resolve);
+    });
+  }
+  watch(dir, fn, opts) {
+    return this.watcher().subscribe(dir, fn, opts);
+  }
+  getEventsSince(dir, snapshot, opts) {
+    return this.watcher().getEventsSince(dir, snapshot, opts);
+  }
+  async writeSnapshot(dir, snapshot, opts) {
+    await this.mkdirp(_path().default.dirname(snapshot));
+    await this.watcher().writeSnapshot(dir, snapshot, opts);
+  }
+  static deserialize() {
+    return new NodeFS();
+  }
+  serialize() {
+    return null;
+  }
+  async mkdirp(filePath) {
+    await _fs().default.promises.mkdir(filePath, {
+      recursive: true
+    });
+  }
+  async rimraf(filePath) {
+    if (_gracefulFs().default.promises.rm) {
+      await _gracefulFs().default.promises.rm(filePath, {
+        recursive: true,
+        force: true
+      });
+      return;
+    }
+
+    // fs.promises.rm is not supported in node 12...
+    let stat;
+    try {
+      stat = await this.stat(filePath);
+    } catch (err) {
+      return;
+    }
+    if (stat.isDirectory()) {
+      await _fs().default.promises.rmdir(filePath, {
+        recursive: true
+      });
+    } else {
+      await _fs().default.promises.unlink(filePath);
+    }
+  }
+}
+exports.NodeFS = NodeFS;
+(0, _buildCache().registerSerializableClass)(`${_package.default.version}:NodeFS`, NodeFS);
+let writeStreamCalls = 0;
+
+// @ts-expect-error TS7034
+let threadId;
+try {
+  ({
+    threadId
+  } = require('worker_threads'));
+} catch {
+  //
+}
+
+// @ts-expect-error TS7034
+let useOsTmpDir;
+function shouldUseOsTmpDir(filePath) {
+  // @ts-expect-error TS7005
+  if (useOsTmpDir != null) {
+    // @ts-expect-error TS7005
+    return useOsTmpDir;
+  }
+  try {
+    const tmpDir = (0, _os().tmpdir)();
+    _fs().default.accessSync(tmpDir, _fs().default.constants.R_OK | _fs().default.constants.W_OK);
+    const tmpDirStats = _fs().default.statSync(tmpDir);
+    const filePathStats = _fs().default.statSync(filePath);
+    // Check the tmpdir is on the same partition as the target directory.
+    // This is required to ensure renaming is an atomic operation.
+    useOsTmpDir = tmpDirStats.dev === filePathStats.dev;
+  } catch (e) {
+    // We don't have read/write access to the OS tmp directory
+    useOsTmpDir = false;
+  }
+  return useOsTmpDir;
+}
+
+// Generate a temporary file path used for atomic writing of files.
+function getTempFilePath(filePath) {
+  writeStreamCalls = writeStreamCalls % Number.MAX_SAFE_INTEGER;
+  let tmpFilePath = filePath;
+
+  // If possible, write the tmp file to the OS tmp directory
+  // This reduces the amount of FS events the watcher needs to process during the build
+  if (shouldUseOsTmpDir(filePath)) {
+    tmpFilePath = _path().default.join((0, _os().tmpdir)(), _path().default.basename(filePath));
+  }
+  return tmpFilePath + '.' + process.pid + (
+  // @ts-expect-error TS7005
+  threadId != null ? '.' + threadId : '') + '.' + (writeStreamCalls++).toString(36);
+}

package/lib/NodeVCSAwareFS.d.ts

@@ -0,0 +1,18 @@
+import { NodeFS } from './NodeFS';
+import type { FilePath } from '@atlaspack/types-internal';
+import type { Event, Options as WatcherOptions } from '@parcel/watcher';
+export interface NodeVCSAwareFSOptions {
+    gitRepoPath: null | FilePath;
+    excludePatterns: Array<string>;
+    logEventDiff: null | ((watcherEvents: Event[], vcsEvents: Event[]) => void);
+}
+export type SerializedNodeVCSAwareFS = NodeVCSAwareFSOptions;
+export declare class NodeVCSAwareFS extends NodeFS {
+    #private;
+    constructor(options: NodeVCSAwareFSOptions);
+    static deserialize(data: SerializedNodeVCSAwareFS): NodeVCSAwareFS;
+    serialize(): SerializedNodeVCSAwareFS;
+    setGitRepoPath(gitRepoPath: null | FilePath): void;
+    getEventsSince(dir: FilePath, snapshot: FilePath, opts: WatcherOptions): Promise<Array<Event>>;
+    writeSnapshot(dir: FilePath, snapshot: FilePath, opts: WatcherOptions): Promise<void>;
+}

package/lib/NodeVCSAwareFS.js

@@ -0,0 +1,186 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NodeVCSAwareFS = void 0;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+var _NodeFS = require("./NodeFS");
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = _interopRequireWildcard(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+var _package = _interopRequireDefault(require("../package.json"));
+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 && Object.prototype.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]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class NodeVCSAwareFS extends _NodeFS.NodeFS {
+  /**
+   * These files are excluded from 'dirty file' tracking even if they are
+   * modified.
+   */
+  #excludePatterns;
+  /**
+   * Logging function for the diff between watcher events and vcs events.
+   */
+  #logEventDiff;
+  /**
+   * The path of the git repository containing the project root. Null if the
+   * project is not a git repository.
+   */
+  #gitRepoPath;
+  constructor(options) {
+    super();
+    this.#excludePatterns = options.excludePatterns;
+    this.#logEventDiff = options.logEventDiff;
+    this.#gitRepoPath = options.gitRepoPath;
+  }
+  static deserialize(data) {
+    const fs = new NodeVCSAwareFS({
+      excludePatterns: data.excludePatterns,
+      logEventDiff: null,
+      gitRepoPath: data.gitRepoPath
+    });
+    return fs;
+  }
+
+  // @ts-expect-error TS2416
+  serialize() {
+    return {
+      excludePatterns: this.#excludePatterns,
+      logEventDiff: null,
+      gitRepoPath: this.#gitRepoPath
+    };
+  }
+  setGitRepoPath(gitRepoPath) {
+    this.#gitRepoPath = gitRepoPath;
+  }
+  async getEventsSince(dir, snapshot, opts) {
+    const gitRepoPath = this.#gitRepoPath;
+    if (gitRepoPath == null) {
+      return this.watcher().getEventsSince(dir, snapshot, opts);
+    }
+    const {
+      nativeSnapshotPath,
+      vcsState
+    } = await (0, _logger().instrumentAsync)('NodeVCSAwareFS.readSnapshot', async () => {
+      // Note: can't use toString() directly, or it won't resolve the promise
+      const snapshotFile = await this.readFile(snapshot);
+      const snapshotFileContent = snapshotFile.toString();
+      return JSON.parse(snapshotFileContent);
+    });
+    let watcherEventsSince = [];
+    const vcsEventsSince = vcsState != null ?
+    // @ts-expect-error TS2571
+    (await (0, _logger().instrumentAsync)('NodeVCSAwareFS::rust.getEventsSince', () =>
+    // @ts-expect-error TS2739
+    (0, _rust().getEventsSince)(gitRepoPath, vcsState, null))
+
+    // @ts-expect-error TS7006
+    ).map(e => ({
+      path: e.path,
+      type: e.changeType
+    })) : null;
+    if ((0, _featureFlags().getFeatureFlagValue)('vcsMode') !== 'NEW' && vcsEventsSince != null) {
+      var _this$logEventDiff;
+      watcherEventsSince = await (0, _logger().instrumentAsync)('NodeVCSAwareFS::watchman.getEventsSince', () => this.watcher().getEventsSince(dir, nativeSnapshotPath, opts));
+      (_this$logEventDiff = this.#logEventDiff) === null || _this$logEventDiff === void 0 || _this$logEventDiff.call(this, watcherEventsSince, vcsEventsSince);
+    }
+
+    // @ts-expect-error TS2345
+    if (['NEW_AND_CHECK', 'NEW'].includes((0, _featureFlags().getFeatureFlagValue)('vcsMode'))) {
+      if (vcsEventsSince == null) {
+        _logger().default.error({
+          origin: '@atlaspack/fs',
+          message: 'Missing VCS state. There was an error when writing the snapshot. Please clear your cache.',
+          meta: {
+            trackableEvent: 'vcs_state_snapshot_read_failed'
+          }
+        });
+        return [];
+      }
+      return vcsEventsSince;
+    }
+    return watcherEventsSince;
+  }
+  async writeSnapshot(dir, snapshot, opts) {
+    const gitRepoPath = this.#gitRepoPath;
+    if (gitRepoPath == null) {
+      await this.watcher().writeSnapshot(dir, snapshot, opts);
+      return;
+    }
+    const snapshotDirectory = _path().default.dirname(snapshot);
+    await this.mkdirp(snapshotDirectory);
+    const filename = _path().default.basename(snapshot, '.txt');
+    const nativeSnapshotPath = _path().default.join(snapshotDirectory, `${filename}.native-snapshot.txt`);
+    if ((0, _featureFlags().getFeatureFlagValue)('vcsMode') !== 'NEW') {
+      await (0, _logger().instrumentAsync)('NodeVCSAwareFS::watchman.writeSnapshot', async () => {
+        await this.watcher().writeSnapshot(dir, nativeSnapshotPath, opts);
+      });
+    }
+    let vcsState = null;
+    try {
+      var _vcsState, _vcsState2;
+      vcsState = await (0, _logger().instrumentAsync)('NodeVCSAwareFS::getVcsStateSnapshot',
+      // @ts-expect-error TS2322
+      () => (0, _rust().getVcsStateSnapshot)(gitRepoPath, this.#excludePatterns));
+      _logger().default.verbose({
+        origin: '@atlaspack/fs',
+        message: 'Expose VCS timing metrics',
+        meta: {
+          trackableEvent: 'vcs_timing_metrics',
+          // @ts-expect-error TS2339
+          dirtyFilesExecutionTime: (_vcsState = vcsState) === null || _vcsState === void 0 ? void 0 : _vcsState.dirtyFilesExecutionTime,
+          // @ts-expect-error TS2339
+          yarnStatesExecutionTime: (_vcsState2 = vcsState) === null || _vcsState2 === void 0 ? void 0 : _vcsState2.yarnStatesExecutionTime
+        }
+      });
+    } catch (err) {
+      _logger().default.error({
+        origin: '@atlaspack/fs',
+        message: `Failed to get VCS state snapshot: ${err.message}`,
+        meta: {
+          trackableEvent: 'vcs_state_snapshot_failed',
+          error: err
+        }
+      });
+    }
+    const snapshotContents = {
+      vcsState,
+      nativeSnapshotPath
+    };
+    await this.writeFile(snapshot, JSON.stringify(snapshotContents));
+  }
+}
+exports.NodeVCSAwareFS = NodeVCSAwareFS;
+(0, _buildCache().registerSerializableClass)(`${_package.default.version}:NodeVCSAwareFS`, NodeVCSAwareFS);

package/lib/OverlayFS.d.ts

@@ -0,0 +1,50 @@
+import type { Readable, Writable } from 'stream';
+import type { FilePath, Encoding, FileOptions, FileSystem, ReaddirOptions, FileStats } from '@atlaspack/types-internal';
+import type { Event, Options as WatcherOptions, AsyncSubscription } from '@parcel/watcher';
+import WorkerFarm from '@atlaspack/workers';
+export declare class OverlayFS implements FileSystem {
+    deleted: Set<FilePath>;
+    writable: FileSystem;
+    readable: FileSystem;
+    _cwd: FilePath;
+    constructor(workerFarmOrFS: WorkerFarm | FileSystem, readable: FileSystem);
+    static deserialize(opts: any): OverlayFS;
+    serialize(): {
+        $$raw: boolean;
+        readable: FileSystem;
+        writable: FileSystem;
+        deleted: Set<FilePath>;
+    };
+    _deletedThrows(filePath: FilePath): FilePath;
+    _checkExists(filePath: FilePath): FilePath;
+    _isSymlink(filePath: FilePath): boolean;
+    _copyPathForWrite(filePath: FilePath): Promise<FilePath>;
+    _normalizePath(filePath: FilePath): FilePath;
+    readFile(filePath: FilePath, encoding?: Encoding): Promise<any>;
+    writeFile(filePath: FilePath, contents: string | Buffer, options?: FileOptions | null): Promise<void>;
+    copyFile(source: FilePath, destination: FilePath): Promise<void>;
+    stat(filePath: FilePath): Promise<FileStats>;
+    symlink(target: FilePath, filePath: FilePath): Promise<void>;
+    unlink(filePath: FilePath): Promise<void>;
+    mkdirp(dir: FilePath): Promise<void>;
+    rimraf(filePath: FilePath): Promise<void>;
+    ncp(source: FilePath, destination: FilePath): Promise<void>;
+    createReadStream(filePath: FilePath, opts?: FileOptions | null): Readable;
+    createWriteStream(path: FilePath, opts?: FileOptions | null): Writable;
+    cwd(): FilePath;
+    chdir(path: FilePath): void;
+    realpath(filePath: FilePath): Promise<FilePath>;
+    readFileSync(filePath: FilePath, encoding?: Encoding): any;
+    statSync(filePath: FilePath): FileStats;
+    realpathSync(filePath: FilePath): FilePath;
+    exists(filePath: FilePath): Promise<boolean>;
+    existsSync(filePath: FilePath): boolean;
+    readdir(path: FilePath, opts?: ReaddirOptions): Promise<any>;
+    readdirSync(dir: FilePath, opts?: ReaddirOptions): any;
+    watch(dir: FilePath, fn: (err: Error | null | undefined, events: Array<Event>) => unknown, opts: WatcherOptions): Promise<AsyncSubscription>;
+    getEventsSince(dir: FilePath, snapshot: FilePath, opts: WatcherOptions): Promise<Array<Event>>;
+    writeSnapshot(dir: FilePath, snapshot: FilePath, opts: WatcherOptions): Promise<void>;
+    findAncestorFile(fileNames: Array<string>, fromDir: FilePath, root: FilePath): FilePath | null | undefined;
+    findNodeModule(moduleName: string, fromDir: FilePath): FilePath | null | undefined;
+    findFirstFile(filePaths: Array<FilePath>): FilePath | null | undefined;
+}