@corellium/corellium-cli 1.2.0 → 1.2.1

package/node_modules/chokidar/lib/nodefs-handler.js

@@ -1,654 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const sysPath = require('path');
-const { promisify } = require('util');
-const isBinaryPath = require('is-binary-path');
-const {
-  isWindows,
-  isLinux,
-  EMPTY_FN,
-  EMPTY_STR,
-  KEY_LISTENERS,
-  KEY_ERR,
-  KEY_RAW,
-  HANDLER_KEYS,
-  EV_CHANGE,
-  EV_ADD,
-  EV_ADD_DIR,
-  EV_ERROR,
-  STR_DATA,
-  STR_END,
-  BRACE_START,
-  STAR
-} = require('./constants');
-
-const THROTTLE_MODE_WATCH = 'watch';
-
-const open = promisify(fs.open);
-const stat = promisify(fs.stat);
-const lstat = promisify(fs.lstat);
-const close = promisify(fs.close);
-const fsrealpath = promisify(fs.realpath);
-
-const statMethods = { lstat, stat };
-
-// TODO: emit errors properly. Example: EMFILE on Macos.
-const foreach = (val, fn) => {
-  if (val instanceof Set) {
-    val.forEach(fn);
-  } else {
-    fn(val);
-  }
-};
-
-const addAndConvert = (main, prop, item) => {
-  let container = main[prop];
-  if (!(container instanceof Set)) {
-    main[prop] = container = new Set([container]);
-  }
-  container.add(item);
-};
-
-const clearItem = cont => key => {
-  const set = cont[key];
-  if (set instanceof Set) {
-    set.clear();
-  } else {
-    delete cont[key];
-  }
-};
-
-const delFromSet = (main, prop, item) => {
-  const container = main[prop];
-  if (container instanceof Set) {
-    container.delete(item);
-  } else if (container === item) {
-    delete main[prop];
-  }
-};
-
-const isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
-
-/**
- * @typedef {String} Path
- */
-
-// fs_watch helpers
-
-// object to hold per-process fs_watch instances
-// (may be shared across chokidar FSWatcher instances)
-
-/**
- * @typedef {Object} FsWatchContainer
- * @property {Set} listeners
- * @property {Set} errHandlers
- * @property {Set} rawEmitters
- * @property {fs.FSWatcher=} watcher
- * @property {Boolean=} watcherUnusable
- */
-
-/**
- * @type {Map<String,FsWatchContainer>}
- */
-const FsWatchInstances = new Map();
-
-/**
- * Instantiates the fs_watch interface
- * @param {String} path to be watched
- * @param {Object} options to be passed to fs_watch
- * @param {Function} listener main event handler
- * @param {Function} errHandler emits info about errors
- * @param {Function} emitRaw emits raw event data
- * @returns {fs.FSWatcher} new fsevents instance
- */
-function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
-  const handleEvent = (rawEvent, evPath) => {
-    listener(path);
-    emitRaw(rawEvent, evPath, {watchedPath: path});
-
-    // emit based on events occurring for files from a directory's watcher in
-    // case the file's watcher misses it (and rely on throttling to de-dupe)
-    if (evPath && path !== evPath) {
-      fsWatchBroadcast(
-        sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath)
-      );
-    }
-  };
-  try {
-    return fs.watch(path, options, handleEvent);
-  } catch (error) {
-    errHandler(error);
-  }
-}
-
-/**
- * Helper for passing fs_watch event data to a collection of listeners
- * @param {Path} fullPath absolute path bound to fs_watch instance
- * @param {String} type listener type
- * @param {*=} val1 arguments to be passed to listeners
- * @param {*=} val2
- * @param {*=} val3
- */
-const fsWatchBroadcast = (fullPath, type, val1, val2, val3) => {
-  const cont = FsWatchInstances.get(fullPath);
-  if (!cont) return;
-  foreach(cont[type], (listener) => {
-    listener(val1, val2, val3);
-  });
-};
-
-/**
- * Instantiates the fs_watch interface or binds listeners
- * to an existing one covering the same file system entry
- * @param {String} path
- * @param {String} fullPath absolute path
- * @param {Object} options to be passed to fs_watch
- * @param {Object} handlers container for event listener functions
- */
-const setFsWatchListener = (path, fullPath, options, handlers) => {
-  const {listener, errHandler, rawEmitter} = handlers;
-  let cont = FsWatchInstances.get(fullPath);
-
-  /** @type {fs.FSWatcher=} */
-  let watcher;
-  if (!options.persistent) {
-    watcher = createFsWatchInstance(
-      path, options, listener, errHandler, rawEmitter
-    );
-    return watcher.close.bind(watcher);
-  }
-  if (cont) {
-    addAndConvert(cont, KEY_LISTENERS, listener);
-    addAndConvert(cont, KEY_ERR, errHandler);
-    addAndConvert(cont, KEY_RAW, rawEmitter);
-  } else {
-    watcher = createFsWatchInstance(
-      path,
-      options,
-      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
-      errHandler, // no need to use broadcast here
-      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
-    );
-    if (!watcher) return;
-    watcher.on(EV_ERROR, async (error) => {
-      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
-      cont.watcherUnusable = true; // documented since Node 10.4.1
-      // Workaround for https://github.com/joyent/node/issues/4337
-      if (isWindows && error.code === 'EPERM') {
-        try {
-          const fd = await open(path, 'r');
-          await close(fd);
-          broadcastErr(error);
-        } catch (err) {}
-      } else {
-        broadcastErr(error);
-      }
-    });
-    cont = {
-      listeners: listener,
-      errHandlers: errHandler,
-      rawEmitters: rawEmitter,
-      watcher
-    };
-    FsWatchInstances.set(fullPath, cont);
-  }
-  // const index = cont.listeners.indexOf(listener);
-
-  // removes this instance's listeners and closes the underlying fs_watch
-  // instance if there are no more listeners left
-  return () => {
-    delFromSet(cont, KEY_LISTENERS, listener);
-    delFromSet(cont, KEY_ERR, errHandler);
-    delFromSet(cont, KEY_RAW, rawEmitter);
-    if (isEmptySet(cont.listeners)) {
-      // Check to protect against issue gh-730.
-      // if (cont.watcherUnusable) {
-      cont.watcher.close();
-      // }
-      FsWatchInstances.delete(fullPath);
-      HANDLER_KEYS.forEach(clearItem(cont));
-      cont.watcher = undefined;
-      Object.freeze(cont);
-    }
-  };
-};
-
-// fs_watchFile helpers
-
-// object to hold per-process fs_watchFile instances
-// (may be shared across chokidar FSWatcher instances)
-const FsWatchFileInstances = new Map();
-
-/**
- * Instantiates the fs_watchFile interface or binds listeners
- * to an existing one covering the same file system entry
- * @param {String} path to be watched
- * @param {String} fullPath absolute path
- * @param {Object} options options to be passed to fs_watchFile
- * @param {Object} handlers container for event listener functions
- * @returns {Function} closer
- */
-const setFsWatchFileListener = (path, fullPath, options, handlers) => {
-  const {listener, rawEmitter} = handlers;
-  let cont = FsWatchFileInstances.get(fullPath);
-
-  /* eslint-disable no-unused-vars, prefer-destructuring */
-  let listeners = new Set();
-  let rawEmitters = new Set();
-
-  const copts = cont && cont.options;
-  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-    // "Upgrade" the watcher to persistence or a quicker interval.
-    // This creates some unlikely edge case issues if the user mixes
-    // settings in a very weird way, but solving for those cases
-    // doesn't seem worthwhile for the added complexity.
-    listeners = cont.listeners;
-    rawEmitters = cont.rawEmitters;
-    fs.unwatchFile(fullPath);
-    cont = undefined;
-  }
-
-  /* eslint-enable no-unused-vars, prefer-destructuring */
-
-  if (cont) {
-    addAndConvert(cont, KEY_LISTENERS, listener);
-    addAndConvert(cont, KEY_RAW, rawEmitter);
-  } else {
-    // TODO
-    // listeners.add(listener);
-    // rawEmitters.add(rawEmitter);
-    cont = {
-      listeners: listener,
-      rawEmitters: rawEmitter,
-      options,
-      watcher: fs.watchFile(fullPath, options, (curr, prev) => {
-        foreach(cont.rawEmitters, (rawEmitter) => {
-          rawEmitter(EV_CHANGE, fullPath, {curr, prev});
-        });
-        const currmtime = curr.mtimeMs;
-        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener) => listener(path, curr));
-        }
-      })
-    };
-    FsWatchFileInstances.set(fullPath, cont);
-  }
-  // const index = cont.listeners.indexOf(listener);
-
-  // Removes this instance's listeners and closes the underlying fs_watchFile
-  // instance if there are no more listeners left.
-  return () => {
-    delFromSet(cont, KEY_LISTENERS, listener);
-    delFromSet(cont, KEY_RAW, rawEmitter);
-    if (isEmptySet(cont.listeners)) {
-      FsWatchFileInstances.delete(fullPath);
-      fs.unwatchFile(fullPath);
-      cont.options = cont.watcher = undefined;
-      Object.freeze(cont);
-    }
-  };
-};
-
-/**
- * @mixin
- */
-class NodeFsHandler {
-
-/**
- * @param {import("../index").FSWatcher} fsW
- */
-constructor(fsW) {
-  this.fsw = fsW;
-  this._boundHandleError = (error) => fsW._handleError(error);
-}
-
-/**
- * Watch file for changes with fs_watchFile or fs_watch.
- * @param {String} path to file or dir
- * @param {Function} listener on fs change
- * @returns {Function} closer for the watcher instance
- */
-_watchWithNodeFs(path, listener) {
-  const opts = this.fsw.options;
-  const directory = sysPath.dirname(path);
-  const basename = sysPath.basename(path);
-  const parent = this.fsw._getWatchedDir(directory);
-  parent.add(basename);
-  const absolutePath = sysPath.resolve(path);
-  const options = {persistent: opts.persistent};
-  if (!listener) listener = EMPTY_FN;
-
-  let closer;
-  if (opts.usePolling) {
-    options.interval = opts.enableBinaryInterval && isBinaryPath(basename) ?
-      opts.binaryInterval : opts.interval;
-    closer = setFsWatchFileListener(path, absolutePath, options, {
-      listener,
-      rawEmitter: this.fsw._emitRaw
-    });
-  } else {
-    closer = setFsWatchListener(path, absolutePath, options, {
-      listener,
-      errHandler: this._boundHandleError,
-      rawEmitter: this.fsw._emitRaw
-    });
-  }
-  return closer;
-}
-
-/**
- * Watch a file and emit add event if warranted.
- * @param {Path} file Path
- * @param {fs.Stats} stats result of fs_stat
- * @param {Boolean} initialAdd was the file added at watch instantiation?
- * @returns {Function} closer for the watcher instance
- */
-_handleFile(file, stats, initialAdd) {
-  if (this.fsw.closed) {
-    return;
-  }
-  const dirname = sysPath.dirname(file);
-  const basename = sysPath.basename(file);
-  const parent = this.fsw._getWatchedDir(dirname);
-  // stats is always present
-  let prevStats = stats;
-
-  // if the file is already being watched, do nothing
-  if (parent.has(basename)) return;
-
-  const listener = async (path, newStats) => {
-    if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
-    if (!newStats || newStats.mtimeMs === 0) {
-      try {
-        const newStats = await stat(file);
-        if (this.fsw.closed) return;
-        // Check that change event was not fired because of changed only accessTime.
-        const at = newStats.atimeMs;
-        const mt = newStats.mtimeMs;
-        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
-          this.fsw._emit(EV_CHANGE, file, newStats);
-        }
-        if (isLinux && prevStats.ino !== newStats.ino) {
-          this.fsw._closeFile(path)
-          prevStats = newStats;
-          this.fsw._addPathCloser(path, this._watchWithNodeFs(file, listener));
-        } else {
-          prevStats = newStats;
-        }
-      } catch (error) {
-        // Fix issues where mtime is null but file is still present
-        this.fsw._remove(dirname, basename);
-      }
-      // add is about to be emitted if file not already tracked in parent
-    } else if (parent.has(basename)) {
-      // Check that change event was not fired because of changed only accessTime.
-      const at = newStats.atimeMs;
-      const mt = newStats.mtimeMs;
-      if (!at || at <= mt || mt !== prevStats.mtimeMs) {
-        this.fsw._emit(EV_CHANGE, file, newStats);
-      }
-      prevStats = newStats;
-    }
-  }
-  // kick off the watcher
-  const closer = this._watchWithNodeFs(file, listener);
-
-  // emit an add event if we're supposed to
-  if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
-    if (!this.fsw._throttle(EV_ADD, file, 0)) return;
-    this.fsw._emit(EV_ADD, file, stats);
-  }
-
-  return closer;
-}
-
-/**
- * Handle symlinks encountered while reading a dir.
- * @param {Object} entry returned by readdirp
- * @param {String} directory path of dir being read
- * @param {String} path of this item
- * @param {String} item basename of this item
- * @returns {Promise<Boolean>} true if no more processing is needed for this entry.
- */
-async _handleSymlink(entry, directory, path, item) {
-  if (this.fsw.closed) {
-    return;
-  }
-  const full = entry.fullPath;
-  const dir = this.fsw._getWatchedDir(directory);
-
-  if (!this.fsw.options.followSymlinks) {
-    // watch symlink directly (don't follow) and detect changes
-    this.fsw._incrReadyCount();
-
-    let linkPath;
-    try {
-      linkPath = await fsrealpath(path);
-    } catch (e) {
-      this.fsw._emitReady();
-      return true;
-    }
-
-    if (this.fsw.closed) return;
-    if (dir.has(item)) {
-      if (this.fsw._symlinkPaths.get(full) !== linkPath) {
-        this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV_CHANGE, path, entry.stats);
-      }
-    } else {
-      dir.add(item);
-      this.fsw._symlinkPaths.set(full, linkPath);
-      this.fsw._emit(EV_ADD, path, entry.stats);
-    }
-    this.fsw._emitReady();
-    return true;
-  }
-
-  // don't follow the same symlink more than once
-  if (this.fsw._symlinkPaths.has(full)) {
-    return true;
-  }
-
-  this.fsw._symlinkPaths.set(full, true);
-}
-
-_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
-  // Normalize the directory name on Windows
-  directory = sysPath.join(directory, EMPTY_STR);
-
-  if (!wh.hasGlob) {
-    throttler = this.fsw._throttle('readdir', directory, 1000);
-    if (!throttler) return;
-  }
-
-  const previous = this.fsw._getWatchedDir(wh.path);
-  const current = new Set();
-
-  let stream = this.fsw._readdirp(directory, {
-    fileFilter: entry => wh.filterPath(entry),
-    directoryFilter: entry => wh.filterDir(entry),
-    depth: 0
-  }).on(STR_DATA, async (entry) => {
-    if (this.fsw.closed) {
-      stream = undefined;
-      return;
-    }
-    const item = entry.path;
-    let path = sysPath.join(directory, item);
-    current.add(item);
-
-    if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
-      return;
-    }
-
-    if (this.fsw.closed) {
-      stream = undefined;
-      return;
-    }
-    // Files that present in current directory snapshot
-    // but absent in previous are added to watch list and
-    // emit `add` event.
-    if (item === target || !target && !previous.has(item)) {
-      this.fsw._incrReadyCount();
-
-      // ensure relativeness of path is preserved in case of watcher reuse
-      path = sysPath.join(dir, sysPath.relative(dir, path));
-
-      this._addToNodeFs(path, initialAdd, wh, depth + 1);
-    }
-  }).on(EV_ERROR, this._boundHandleError);
-
-  return new Promise(resolve =>
-    stream.once(STR_END, () => {
-      if (this.fsw.closed) {
-        stream = undefined;
-        return;
-      }
-      const wasThrottled = throttler ? throttler.clear() : false;
-
-      resolve();
-
-      // Files that absent in current directory snapshot
-      // but present in previous emit `remove` event
-      // and are removed from @watched[directory].
-      previous.getChildren().filter((item) => {
-        return item !== directory &&
-          !current.has(item) &&
-          // in case of intersecting globs;
-          // a path may have been filtered out of this readdir, but
-          // shouldn't be removed because it matches a different glob
-          (!wh.hasGlob || wh.filterPath({
-            fullPath: sysPath.resolve(directory, item)
-          }));
-      }).forEach((item) => {
-        this.fsw._remove(directory, item);
-      });
-
-      stream = undefined;
-
-      // one more time for any missed in case changes came in extremely quickly
-      if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler);
-    })
-  );
-}
-
-/**
- * Read directory to add / remove files from `@watched` list and re-read it on change.
- * @param {String} dir fs path
- * @param {fs.Stats} stats
- * @param {Boolean} initialAdd
- * @param {Number} depth relative to user-supplied path
- * @param {String} target child path targeted for watch
- * @param {Object} wh Common watch helpers for this path
- * @param {String} realpath
- * @returns {Promise<Function>} closer for the watcher instance.
- */
-async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
-  const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
-  const tracked = parentDir.has(sysPath.basename(dir));
-  if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
-    if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR, dir, stats);
-  }
-
-  // ensure dir is tracked (harmless if redundant)
-  parentDir.add(sysPath.basename(dir));
-  this.fsw._getWatchedDir(dir);
-  let throttler;
-  let closer;
-
-  const oDepth = this.fsw.options.depth;
-  if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
-    if (!target) {
-      await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
-      if (this.fsw.closed) return;
-    }
-
-    closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
-      // if current directory is removed, do nothing
-      if (stats && stats.mtimeMs === 0) return;
-
-      this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
-    });
-  }
-  return closer;
-}
-
-/**
- * Handle added file, directory, or glob pattern.
- * Delegates call to _handleFile / _handleDir after checks.
- * @param {String} path to file or ir
- * @param {Boolean} initialAdd was the file added at watch instantiation?
- * @param {Object} priorWh depth relative to user-supplied path
- * @param {Number} depth Child path actually targeted for watch
- * @param {String=} target Child path actually targeted for watch
- * @returns {Promise}
- */
-async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
-  const ready = this.fsw._emitReady;
-  if (this.fsw._isIgnored(path) || this.fsw.closed) {
-    ready();
-    return false;
-  }
-
-  const wh = this.fsw._getWatchHelpers(path, depth);
-  if (!wh.hasGlob && priorWh) {
-    wh.hasGlob = priorWh.hasGlob;
-    wh.globFilter = priorWh.globFilter;
-    wh.filterPath = entry => priorWh.filterPath(entry);
-    wh.filterDir = entry => priorWh.filterDir(entry);
-  }
-
-  // evaluate what is at the path we're being asked to watch
-  try {
-    const stats = await statMethods[wh.statMethod](wh.watchPath);
-    if (this.fsw.closed) return;
-    if (this.fsw._isIgnored(wh.watchPath, stats)) {
-      ready();
-      return false;
-    }
-
-    const follow = this.fsw.options.followSymlinks && !path.includes(STAR) && !path.includes(BRACE_START);
-    let closer;
-    if (stats.isDirectory()) {
-      const absPath = sysPath.resolve(path);
-      const targetPath = follow ? await fsrealpath(path) : path;
-      if (this.fsw.closed) return;
-      closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
-      if (this.fsw.closed) return;
-      // preserve this symlink's target path
-      if (absPath !== targetPath && targetPath !== undefined) {
-        this.fsw._symlinkPaths.set(absPath, targetPath);
-      }
-    } else if (stats.isSymbolicLink()) {
-      const targetPath = follow ? await fsrealpath(path) : path;
-      if (this.fsw.closed) return;
-      const parent = sysPath.dirname(wh.watchPath);
-      this.fsw._getWatchedDir(parent).add(wh.watchPath);
-      this.fsw._emit(EV_ADD, wh.watchPath, stats);
-      closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
-      if (this.fsw.closed) return;
-
-      // preserve this symlink's target path
-      if (targetPath !== undefined) {
-        this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
-      }
-    } else {
-      closer = this._handleFile(wh.watchPath, stats, initialAdd);
-    }
-    ready();
-
-    this.fsw._addPathCloser(path, closer);
-    return false;
-
-  } catch (error) {
-    if (this.fsw._handleError(error)) {
-      ready();
-      return path;
-    }
-  }
-}
-
-}
-
-module.exports = NodeFsHandler;