install-nix-action/node_modules/jest-haste-map/build/crawlers/watchman.js

'use strict';

function _path() {
  const data = _interopRequireDefault(require('path'));

  _path = function _path() {
    return data;
  };

  return data;
}

function _fbWatchman() {
  const data = _interopRequireDefault(require('fb-watchman'));

  _fbWatchman = function _fbWatchman() {
    return data;
  };

  return data;
}

var fastPath = _interopRequireWildcard(require('../lib/fast_path'));

var _normalizePathSep = _interopRequireDefault(
  require('../lib/normalizePathSep')
);

var _constants = _interopRequireDefault(require('../constants'));

function _interopRequireWildcard(obj) {
  if (obj && obj.__esModule) {
    return obj;
  } else {
    var newObj = {};
    if (obj != null) {
      for (var key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
          var desc =
            Object.defineProperty && Object.getOwnPropertyDescriptor
              ? Object.getOwnPropertyDescriptor(obj, key)
              : {};
          if (desc.get || desc.set) {
            Object.defineProperty(newObj, key, desc);
          } else {
            newObj[key] = obj[key];
          }
        }
      }
    }
    newObj.default = obj;
    return newObj;
  }
}

function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : {default: obj};
}

function _slicedToArray(arr, i) {
  return (
    _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest()
  );
}

function _nonIterableRest() {
  throw new TypeError('Invalid attempt to destructure non-iterable instance');
}

function _iterableToArrayLimit(arr, i) {
  var _arr = [];
  var _n = true;
  var _d = false;
  var _e = undefined;
  try {
    for (
      var _i = arr[Symbol.iterator](), _s;
      !(_n = (_s = _i.next()).done);
      _n = true
    ) {
      _arr.push(_s.value);
      if (i && _arr.length === i) break;
    }
  } catch (err) {
    _d = true;
    _e = err;
  } finally {
    try {
      if (!_n && _i['return'] != null) _i['return']();
    } finally {
      if (_d) throw _e;
    }
  }
  return _arr;
}

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
  try {
    var info = gen[key](arg);
    var value = info.value;
  } catch (error) {
    reject(error);
    return;
  }
  if (info.done) {
    resolve(value);
  } else {
    Promise.resolve(value).then(_next, _throw);
  }
}

function _asyncToGenerator(fn) {
  return function() {
    var self = this,
      args = arguments;
    return new Promise(function(resolve, reject) {
      var gen = fn.apply(self, args);
      function _next(value) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, 'next', value);
      }
      function _throw(err) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, 'throw', err);
      }
      _next(undefined);
    });
  };
}

const watchmanURL =
  'https://facebook.github.io/watchman/docs/troubleshooting.html';

function WatchmanError(error) {
  error.message =
    `Watchman error: ${error.message.trim()}. Make sure watchman ` +
    `is running for this project. See ${watchmanURL}.`;
  return error;
}

module.exports =
  /*#__PURE__*/
  (function() {
    var _watchmanCrawl = _asyncToGenerator(function*(options) {
      const fields = ['name', 'exists', 'mtime_ms', 'size'];
      const data = options.data,
        extensions = options.extensions,
        ignore = options.ignore,
        rootDir = options.rootDir,
        roots = options.roots;
      const defaultWatchExpression = [
        'allof',
        ['type', 'f'],
        ['anyof', ...extensions.map(extension => ['suffix', extension])]
      ];
      const clocks = data.clocks;
      const client = new (_fbWatchman()).default.Client();
      let clientError;
      client.on('error', error => (clientError = WatchmanError(error))); // TODO: type better than `any`

      const cmd = (...args) =>
        new Promise((resolve, reject) =>
          client.command(args, (error, result) =>
            error ? reject(WatchmanError(error)) : resolve(result)
          )
        );

      if (options.computeSha1) {
        const _ref = yield cmd('list-capabilities'),
          capabilities = _ref.capabilities;

        if (capabilities.indexOf('field-content.sha1hex') !== -1) {
          fields.push('content.sha1hex');
        }
      }

      function getWatchmanRoots(_x2) {
        return _getWatchmanRoots.apply(this, arguments);
      }

      function _getWatchmanRoots() {
        _getWatchmanRoots = _asyncToGenerator(function*(roots) {
          const watchmanRoots = new Map();
          yield Promise.all(
            roots.map(
              /*#__PURE__*/
              (function() {
                var _ref2 = _asyncToGenerator(function*(root) {
                  const response = yield cmd('watch-project', root);
                  const existing = watchmanRoots.get(response.watch); // A root can only be filtered if it was never seen with a
                  // relative_path before.

                  const canBeFiltered = !existing || existing.length > 0;

                  if (canBeFiltered) {
                    if (response.relative_path) {
                      watchmanRoots.set(
                        response.watch,
                        (existing || []).concat(response.relative_path)
                      );
                    } else {
                      // Make the filter directories an empty array to signal that this
                      // root was already seen and needs to be watched for all files or
                      // directories.
                      watchmanRoots.set(response.watch, []);
                    }
                  }
                });

                return function(_x4) {
                  return _ref2.apply(this, arguments);
                };
              })()
            )
          );
          return watchmanRoots;
        });
        return _getWatchmanRoots.apply(this, arguments);
      }

      function queryWatchmanForDirs(_x3) {
        return _queryWatchmanForDirs.apply(this, arguments);
      }

      function _queryWatchmanForDirs() {
        _queryWatchmanForDirs = _asyncToGenerator(function*(
          rootProjectDirMappings
        ) {
          const files = new Map();
          let isFresh = false;
          yield Promise.all(
            Array.from(rootProjectDirMappings).map(
              /*#__PURE__*/
              (function() {
                var _ref3 = _asyncToGenerator(function*([
                  root,
                  directoryFilters
                ]) {
                  const expression = Array.from(defaultWatchExpression);
                  const glob = [];

                  if (directoryFilters.length > 0) {
                    expression.push([
                      'anyof',
                      ...directoryFilters.map(dir => ['dirname', dir])
                    ]);
                    var _iteratorNormalCompletion2 = true;
                    var _didIteratorError2 = false;
                    var _iteratorError2 = undefined;

                    try {
                      for (
                        var _iterator2 = directoryFilters[Symbol.iterator](),
                          _step2;
                        !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next())
                          .done);
                        _iteratorNormalCompletion2 = true
                      ) {
                        const directory = _step2.value;
                        var _iteratorNormalCompletion3 = true;
                        var _didIteratorError3 = false;
                        var _iteratorError3 = undefined;

                        try {
                          for (
                            var _iterator3 = extensions[Symbol.iterator](),
                              _step3;
                            !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next())
                              .done);
                            _iteratorNormalCompletion3 = true
                          ) {
                            const extension = _step3.value;
                            glob.push(`${directory}/**/*.${extension}`);
                          }
                        } catch (err) {
                          _didIteratorError3 = true;
                          _iteratorError3 = err;
                        } finally {
                          try {
                            if (
                              !_iteratorNormalCompletion3 &&
                              _iterator3.return != null
                            ) {
                              _iterator3.return();
                            }
                          } finally {
                            if (_didIteratorError3) {
                              throw _iteratorError3;
                            }
                          }
                        }
                      }
                    } catch (err) {
                      _didIteratorError2 = true;
                      _iteratorError2 = err;
                    } finally {
                      try {
                        if (
                          !_iteratorNormalCompletion2 &&
                          _iterator2.return != null
                        ) {
                          _iterator2.return();
                        }
                      } finally {
                        if (_didIteratorError2) {
                          throw _iteratorError2;
                        }
                      }
                    }
                  } else {
                    var _iteratorNormalCompletion4 = true;
                    var _didIteratorError4 = false;
                    var _iteratorError4 = undefined;

                    try {
                      for (
                        var _iterator4 = extensions[Symbol.iterator](), _step4;
                        !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next())
                          .done);
                        _iteratorNormalCompletion4 = true
                      ) {
                        const extension = _step4.value;
                        glob.push(`**/*.${extension}`);
                      }
                    } catch (err) {
                      _didIteratorError4 = true;
                      _iteratorError4 = err;
                    } finally {
                      try {
                        if (
                          !_iteratorNormalCompletion4 &&
                          _iterator4.return != null
                        ) {
                          _iterator4.return();
                        }
                      } finally {
                        if (_didIteratorError4) {
                          throw _iteratorError4;
                        }
                      }
                    }
                  }

                  const relativeRoot = fastPath.relative(rootDir, root);
                  const query = clocks.has(relativeRoot) // Use the `since` generator if we have a clock available
                    ? {
                        expression,
                        fields,
                        since: clocks.get(relativeRoot)
                      } // Otherwise use the `glob` filter
                    : {
                        expression,
                        fields,
                        glob
                      };
                  const response = yield cmd('query', root, query);

                  if ('warning' in response) {
                    console.warn('watchman warning: ', response.warning);
                  }

                  isFresh = isFresh || response.is_fresh_instance;
                  files.set(root, response);
                });

                return function(_x5) {
                  return _ref3.apply(this, arguments);
                };
              })()
            )
          );
          return {
            files,
            isFresh
          };
        });
        return _queryWatchmanForDirs.apply(this, arguments);
      }

      let files = data.files;
      let removedFiles = new Map();
      const changedFiles = new Map();
      let watchmanFiles;
      let isFresh = false;

      try {
        const watchmanRoots = yield getWatchmanRoots(roots);
        const watchmanFileResults = yield queryWatchmanForDirs(watchmanRoots); // Reset the file map if watchman was restarted and sends us a list of
        // files.

        if (watchmanFileResults.isFresh) {
          files = new Map();
          removedFiles = new Map(data.files);
          isFresh = true;
        }

        watchmanFiles = watchmanFileResults.files;
      } finally {
        client.end();
      }

      if (clientError) {
        throw clientError;
      } // TODO: remove non-null

      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        for (
          var _iterator = watchmanFiles[Symbol.iterator](), _step;
          !(_iteratorNormalCompletion = (_step = _iterator.next()).done);
          _iteratorNormalCompletion = true
        ) {
          const _step$value = _slicedToArray(_step.value, 2),
            watchRoot = _step$value[0],
            response = _step$value[1];

          const fsRoot = (0, _normalizePathSep.default)(watchRoot);
          const relativeFsRoot = fastPath.relative(rootDir, fsRoot);
          clocks.set(relativeFsRoot, response.clock);
          var _iteratorNormalCompletion5 = true;
          var _didIteratorError5 = false;
          var _iteratorError5 = undefined;

          try {
            for (
              var _iterator5 = response.files[Symbol.iterator](), _step5;
              !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done);
              _iteratorNormalCompletion5 = true
            ) {
              const fileData = _step5.value;
              const filePath =
                fsRoot +
                _path().default.sep +
                (0, _normalizePathSep.default)(fileData.name);
              const relativeFilePath = fastPath.relative(rootDir, filePath);
              const existingFileData = data.files.get(relativeFilePath); // If watchman is fresh, the removed files map starts with all files
              // and we remove them as we verify they still exist.

              if (isFresh && existingFileData && fileData.exists) {
                removedFiles.delete(relativeFilePath);
              }

              if (!fileData.exists) {
                // No need to act on files that do not exist and were not tracked.
                if (existingFileData) {
                  files.delete(relativeFilePath); // If watchman is not fresh, we will know what specific files were
                  // deleted since we last ran and can track only those files.

                  if (!isFresh) {
                    removedFiles.set(relativeFilePath, existingFileData);
                  }
                }
              } else if (!ignore(filePath)) {
                const mtime =
                  typeof fileData.mtime_ms === 'number'
                    ? fileData.mtime_ms
                    : fileData.mtime_ms.toNumber();
                const size = fileData.size;
                let sha1hex = fileData['content.sha1hex'];

                if (typeof sha1hex !== 'string' || sha1hex.length !== 40) {
                  sha1hex = null;
                }

                let nextData;

                if (
                  existingFileData &&
                  existingFileData[_constants.default.MTIME] === mtime
                ) {
                  nextData = existingFileData;
                } else if (
                  existingFileData &&
                  sha1hex &&
                  existingFileData[_constants.default.SHA1] === sha1hex
                ) {
                  nextData = [
                    existingFileData[0],
                    mtime,
                    existingFileData[2],
                    existingFileData[3],
                    existingFileData[4],
                    existingFileData[5]
                  ];
                } else {
                  // See ../constants.ts
                  nextData = ['', mtime, size, 0, '', sha1hex];
                }

                const mappings = options.mapper
                  ? options.mapper(filePath)
                  : null;

                if (mappings) {
                  var _iteratorNormalCompletion6 = true;
                  var _didIteratorError6 = false;
                  var _iteratorError6 = undefined;

                  try {
                    for (
                      var _iterator6 = mappings[Symbol.iterator](), _step6;
                      !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next())
                        .done);
                      _iteratorNormalCompletion6 = true
                    ) {
                      const absoluteVirtualFilePath = _step6.value;

                      if (!ignore(absoluteVirtualFilePath)) {
                        const relativeVirtualFilePath = fastPath.relative(
                          rootDir,
                          absoluteVirtualFilePath
                        );
                        files.set(relativeVirtualFilePath, nextData);
                        changedFiles.set(relativeVirtualFilePath, nextData);
                      }
                    }
                  } catch (err) {
                    _didIteratorError6 = true;
                    _iteratorError6 = err;
                  } finally {
                    try {
                      if (
                        !_iteratorNormalCompletion6 &&
                        _iterator6.return != null
                      ) {
                        _iterator6.return();
                      }
                    } finally {
                      if (_didIteratorError6) {
                        throw _iteratorError6;
                      }
                    }
                  }
                } else {
                  files.set(relativeFilePath, nextData);
                  changedFiles.set(relativeFilePath, nextData);
                }
              }
            }
          } catch (err) {
            _didIteratorError5 = true;
            _iteratorError5 = err;
          } finally {
            try {
              if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
                _iterator5.return();
              }
            } finally {
              if (_didIteratorError5) {
                throw _iteratorError5;
              }
            }
          }
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return != null) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }

      data.files = files;
      return {
        changedFiles: isFresh ? undefined : changedFiles,
        hasteMap: data,
        removedFiles
      };
    });

    function watchmanCrawl(_x) {
      return _watchmanCrawl.apply(this, arguments);
    }

    return watchmanCrawl;
  })();