decidim 0.26.0 → 0.27.0.rc1

data/packages/webpacker/node_modules/jest-haste-map/build/watchers/FSEventsWatcher.js

@@ -0,0 +1,294 @@
+'use strict';
+
+function _events() {
+  const data = require('events');
+
+  _events = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function path() {
+  const data = _interopRequireWildcard(require('path'));
+
+  path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _anymatch() {
+  const data = _interopRequireDefault(require('anymatch'));
+
+  _anymatch = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function fs() {
+  const data = _interopRequireWildcard(require('graceful-fs'));
+
+  fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _micromatch() {
+  const data = _interopRequireDefault(require('micromatch'));
+
+  _micromatch = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _walker() {
+  const data = _interopRequireDefault(require('walker'));
+
+  _walker = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== 'function') return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+// eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+// @ts-ignore: this is for CI which runs linux and might not have this
+let fsevents = null;
+
+try {
+  fsevents = require('fsevents');
+} catch {
+  // Optional dependency, only supported on Darwin.
+}
+
+const CHANGE_EVENT = 'change';
+const DELETE_EVENT = 'delete';
+const ADD_EVENT = 'add';
+const ALL_EVENT = 'all';
+
+/**
+ * Export `FSEventsWatcher` class.
+ * Watches `dir`.
+ */
+class FSEventsWatcher extends _events().EventEmitter {
+  static isSupported() {
+    return fsevents !== null;
+  }
+
+  static normalizeProxy(callback) {
+    return (filepath, stats) => callback(path().normalize(filepath), stats);
+  }
+
+  static recReaddir(
+    dir,
+    dirCallback,
+    fileCallback,
+    endCallback,
+    errorCallback,
+    ignored
+  ) {
+    (0, _walker().default)(dir)
+      .filterDir(
+        currentDir => !ignored || !(0, _anymatch().default)(ignored, currentDir)
+      )
+      .on('dir', FSEventsWatcher.normalizeProxy(dirCallback))
+      .on('file', FSEventsWatcher.normalizeProxy(fileCallback))
+      .on('error', errorCallback)
+      .on('end', () => {
+        endCallback();
+      });
+  }
+
+  constructor(dir, opts) {
+    if (!fsevents) {
+      throw new Error(
+        '`fsevents` unavailable (this watcher can only be used on Darwin)'
+      );
+    }
+
+    super();
+
+    _defineProperty(this, 'root', void 0);
+
+    _defineProperty(this, 'ignored', void 0);
+
+    _defineProperty(this, 'glob', void 0);
+
+    _defineProperty(this, 'dot', void 0);
+
+    _defineProperty(this, 'hasIgnore', void 0);
+
+    _defineProperty(this, 'doIgnore', void 0);
+
+    _defineProperty(this, 'fsEventsWatchStopper', void 0);
+
+    _defineProperty(this, '_tracked', void 0);
+
+    this.dot = opts.dot || false;
+    this.ignored = opts.ignored;
+    this.glob = Array.isArray(opts.glob) ? opts.glob : [opts.glob];
+    this.hasIgnore =
+      Boolean(opts.ignored) && !(Array.isArray(opts) && opts.length > 0);
+    this.doIgnore = opts.ignored
+      ? (0, _anymatch().default)(opts.ignored)
+      : () => false;
+    this.root = path().resolve(dir);
+    this.fsEventsWatchStopper = fsevents.watch(
+      this.root,
+      this.handleEvent.bind(this)
+    );
+    this._tracked = new Set();
+    FSEventsWatcher.recReaddir(
+      this.root,
+      filepath => {
+        this._tracked.add(filepath);
+      },
+      filepath => {
+        this._tracked.add(filepath);
+      },
+      this.emit.bind(this, 'ready'),
+      this.emit.bind(this, 'error'),
+      this.ignored
+    );
+  }
+  /**
+   * End watching.
+   */
+
+  async close(callback) {
+    await this.fsEventsWatchStopper();
+    this.removeAllListeners();
+
+    if (typeof callback === 'function') {
+      process.nextTick(callback.bind(null, null, true));
+    }
+  }
+
+  isFileIncluded(relativePath) {
+    if (this.doIgnore(relativePath)) {
+      return false;
+    }
+
+    return this.glob.length
+      ? (0, _micromatch().default)([relativePath], this.glob, {
+          dot: this.dot
+        }).length > 0
+      : this.dot ||
+          (0, _micromatch().default)([relativePath], '**/*').length > 0;
+  }
+
+  handleEvent(filepath) {
+    const relativePath = path().relative(this.root, filepath);
+
+    if (!this.isFileIncluded(relativePath)) {
+      return;
+    }
+
+    fs().lstat(filepath, (error, stat) => {
+      if (error && error.code !== 'ENOENT') {
+        this.emit('error', error);
+        return;
+      }
+
+      if (error) {
+        // Ignore files that aren't tracked and don't exist.
+        if (!this._tracked.has(filepath)) {
+          return;
+        }
+
+        this._emit(DELETE_EVENT, relativePath);
+
+        this._tracked.delete(filepath);
+
+        return;
+      }
+
+      if (this._tracked.has(filepath)) {
+        this._emit(CHANGE_EVENT, relativePath, stat);
+      } else {
+        this._tracked.add(filepath);
+
+        this._emit(ADD_EVENT, relativePath, stat);
+      }
+    });
+  }
+  /**
+   * Emit events.
+   */
+
+  _emit(type, file, stat) {
+    this.emit(type, file, this.root, stat);
+    this.emit(ALL_EVENT, type, file, this.root, stat);
+  }
+}
+
+module.exports = FSEventsWatcher;

data/packages/webpacker/node_modules/jest-haste-map/build/watchers/NodeWatcher.js

@@ -0,0 +1,375 @@
+// vendored from https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/node_watcher.js
+'use strict';
+
+const EventEmitter = require('events').EventEmitter;
+
+const fs = require('fs');
+
+const platform = require('os').platform();
+
+const path = require('path');
+
+const common = require('./common');
+/**
+ * Constants
+ */
+
+const DEFAULT_DELAY = common.DEFAULT_DELAY;
+const CHANGE_EVENT = common.CHANGE_EVENT;
+const DELETE_EVENT = common.DELETE_EVENT;
+const ADD_EVENT = common.ADD_EVENT;
+const ALL_EVENT = common.ALL_EVENT;
+/**
+ * Export `NodeWatcher` class.
+ * Watches `dir`.
+ *
+ * @class NodeWatcher
+ * @param {String} dir
+ * @param {Object} opts
+ * @public
+ */
+
+module.exports = class NodeWatcher extends EventEmitter {
+  constructor(dir, opts) {
+    super();
+    common.assignOptions(this, opts);
+    this.watched = Object.create(null);
+    this.changeTimers = Object.create(null);
+    this.dirRegistery = Object.create(null);
+    this.root = path.resolve(dir);
+    this.watchdir = this.watchdir.bind(this);
+    this.register = this.register.bind(this);
+    this.checkedEmitError = this.checkedEmitError.bind(this);
+    this.watchdir(this.root);
+    common.recReaddir(
+      this.root,
+      this.watchdir,
+      this.register,
+      this.emit.bind(this, 'ready'),
+      this.checkedEmitError,
+      this.ignored
+    );
+  }
+  /**
+   * Register files that matches our globs to know what to type of event to
+   * emit in the future.
+   *
+   * Registery looks like the following:
+   *
+   *  dirRegister => Map {
+   *    dirpath => Map {
+   *       filename => true
+   *    }
+   *  }
+   *
+   * @param {string} filepath
+   * @return {boolean} whether or not we have registered the file.
+   * @private
+   */
+
+  register(filepath) {
+    const relativePath = path.relative(this.root, filepath);
+
+    if (
+      !common.isFileIncluded(this.globs, this.dot, this.doIgnore, relativePath)
+    ) {
+      return false;
+    }
+
+    const dir = path.dirname(filepath);
+
+    if (!this.dirRegistery[dir]) {
+      this.dirRegistery[dir] = Object.create(null);
+    }
+
+    const filename = path.basename(filepath);
+    this.dirRegistery[dir][filename] = true;
+    return true;
+  }
+  /**
+   * Removes a file from the registery.
+   *
+   * @param {string} filepath
+   * @private
+   */
+
+  unregister(filepath) {
+    const dir = path.dirname(filepath);
+
+    if (this.dirRegistery[dir]) {
+      const filename = path.basename(filepath);
+      delete this.dirRegistery[dir][filename];
+    }
+  }
+  /**
+   * Removes a dir from the registery.
+   *
+   * @param {string} dirpath
+   * @private
+   */
+
+  unregisterDir(dirpath) {
+    if (this.dirRegistery[dirpath]) {
+      delete this.dirRegistery[dirpath];
+    }
+  }
+  /**
+   * Checks if a file or directory exists in the registery.
+   *
+   * @param {string} fullpath
+   * @return {boolean}
+   * @private
+   */
+
+  registered(fullpath) {
+    const dir = path.dirname(fullpath);
+    return (
+      this.dirRegistery[fullpath] ||
+      (this.dirRegistery[dir] &&
+        this.dirRegistery[dir][path.basename(fullpath)])
+    );
+  }
+  /**
+   * Emit "error" event if it's not an ignorable event
+   *
+   * @param error
+   * @private
+   */
+
+  checkedEmitError(error) {
+    if (!isIgnorableFileError(error)) {
+      this.emit('error', error);
+    }
+  }
+  /**
+   * Watch a directory.
+   *
+   * @param {string} dir
+   * @private
+   */
+
+  watchdir(dir) {
+    if (this.watched[dir]) {
+      return;
+    }
+
+    const watcher = fs.watch(
+      dir,
+      {
+        persistent: true
+      },
+      this.normalizeChange.bind(this, dir)
+    );
+    this.watched[dir] = watcher;
+    watcher.on('error', this.checkedEmitError);
+
+    if (this.root !== dir) {
+      this.register(dir);
+    }
+  }
+  /**
+   * Stop watching a directory.
+   *
+   * @param {string} dir
+   * @private
+   */
+
+  stopWatching(dir) {
+    if (this.watched[dir]) {
+      this.watched[dir].close();
+      delete this.watched[dir];
+    }
+  }
+  /**
+   * End watching.
+   *
+   * @public
+   */
+
+  close() {
+    Object.keys(this.watched).forEach(this.stopWatching, this);
+    this.removeAllListeners();
+    return Promise.resolve();
+  }
+  /**
+   * On some platforms, as pointed out on the fs docs (most likely just win32)
+   * the file argument might be missing from the fs event. Try to detect what
+   * change by detecting if something was deleted or the most recent file change.
+   *
+   * @param {string} dir
+   * @param {string} event
+   * @param {string} file
+   * @public
+   */
+
+  detectChangedFile(dir, event, callback) {
+    if (!this.dirRegistery[dir]) {
+      return;
+    }
+
+    let found = false;
+    let closest = {
+      mtime: 0
+    };
+    let c = 0;
+    Object.keys(this.dirRegistery[dir]).forEach(function (file, i, arr) {
+      fs.lstat(path.join(dir, file), (error, stat) => {
+        if (found) {
+          return;
+        }
+
+        if (error) {
+          if (isIgnorableFileError(error)) {
+            found = true;
+            callback(file);
+          } else {
+            this.emit('error', error);
+          }
+        } else {
+          if (stat.mtime > closest.mtime) {
+            stat.file = file;
+            closest = stat;
+          }
+
+          if (arr.length === ++c) {
+            callback(closest.file);
+          }
+        }
+      });
+    }, this);
+  }
+  /**
+   * Normalize fs events and pass it on to be processed.
+   *
+   * @param {string} dir
+   * @param {string} event
+   * @param {string} file
+   * @public
+   */
+
+  normalizeChange(dir, event, file) {
+    if (!file) {
+      this.detectChangedFile(dir, event, actualFile => {
+        if (actualFile) {
+          this.processChange(dir, event, actualFile);
+        }
+      });
+    } else {
+      this.processChange(dir, event, path.normalize(file));
+    }
+  }
+  /**
+   * Process changes.
+   *
+   * @param {string} dir
+   * @param {string} event
+   * @param {string} file
+   * @public
+   */
+
+  processChange(dir, event, file) {
+    const fullPath = path.join(dir, file);
+    const relativePath = path.join(path.relative(this.root, dir), file);
+    fs.lstat(fullPath, (error, stat) => {
+      if (error && error.code !== 'ENOENT') {
+        this.emit('error', error);
+      } else if (!error && stat.isDirectory()) {
+        // win32 emits usless change events on dirs.
+        if (event !== 'change') {
+          this.watchdir(fullPath);
+
+          if (
+            common.isFileIncluded(
+              this.globs,
+              this.dot,
+              this.doIgnore,
+              relativePath
+            )
+          ) {
+            this.emitEvent(ADD_EVENT, relativePath, stat);
+          }
+        }
+      } else {
+        const registered = this.registered(fullPath);
+
+        if (error && error.code === 'ENOENT') {
+          this.unregister(fullPath);
+          this.stopWatching(fullPath);
+          this.unregisterDir(fullPath);
+
+          if (registered) {
+            this.emitEvent(DELETE_EVENT, relativePath);
+          }
+        } else if (registered) {
+          this.emitEvent(CHANGE_EVENT, relativePath, stat);
+        } else {
+          if (this.register(fullPath)) {
+            this.emitEvent(ADD_EVENT, relativePath, stat);
+          }
+        }
+      }
+    });
+  }
+  /**
+   * Triggers a 'change' event after debounding it to take care of duplicate
+   * events on os x.
+   *
+   * @private
+   */
+
+  emitEvent(type, file, stat) {
+    const key = type + '-' + file;
+    const addKey = ADD_EVENT + '-' + file;
+
+    if (type === CHANGE_EVENT && this.changeTimers[addKey]) {
+      // Ignore the change event that is immediately fired after an add event.
+      // (This happens on Linux).
+      return;
+    }
+
+    clearTimeout(this.changeTimers[key]);
+    this.changeTimers[key] = setTimeout(() => {
+      delete this.changeTimers[key];
+
+      if (type === ADD_EVENT && stat.isDirectory()) {
+        // Recursively emit add events and watch for sub-files/folders
+        common.recReaddir(
+          path.resolve(this.root, file),
+          function emitAddDir(dir, stats) {
+            this.watchdir(dir);
+            this.rawEmitEvent(ADD_EVENT, path.relative(this.root, dir), stats);
+          }.bind(this),
+          function emitAddFile(file, stats) {
+            this.register(file);
+            this.rawEmitEvent(ADD_EVENT, path.relative(this.root, file), stats);
+          }.bind(this),
+          function endCallback() {},
+          this.checkedEmitError,
+          this.ignored
+        );
+      } else {
+        this.rawEmitEvent(type, file, stat);
+      }
+    }, DEFAULT_DELAY);
+  }
+  /**
+   * Actually emit the events
+   */
+
+  rawEmitEvent(type, file, stat) {
+    this.emit(type, file, this.root, stat);
+    this.emit(ALL_EVENT, type, file, this.root, stat);
+  }
+};
+/**
+ * Determine if a given FS error can be ignored
+ *
+ * @private
+ */
+
+function isIgnorableFileError(error) {
+  return (
+    error.code === 'ENOENT' || // Workaround Windows node issue #4337.
+    (error.code === 'EPERM' && platform === 'win32')
+  );
+}

data/packages/webpacker/node_modules/jest-haste-map/build/watchers/RecrawlWarning.js

@@ -0,0 +1,57 @@
+// vendored from https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/utils/recrawl-warning-dedupe.js
+'use strict';
+
+class RecrawlWarning {
+  constructor(root, count) {
+    this.root = root;
+    this.count = count;
+  }
+
+  static findByRoot(root) {
+    for (let i = 0; i < this.RECRAWL_WARNINGS.length; i++) {
+      const warning = this.RECRAWL_WARNINGS[i];
+
+      if (warning.root === root) {
+        return warning;
+      }
+    }
+
+    return undefined;
+  }
+
+  static isRecrawlWarningDupe(warningMessage) {
+    if (typeof warningMessage !== 'string') {
+      return false;
+    }
+
+    const match = warningMessage.match(this.REGEXP);
+
+    if (!match) {
+      return false;
+    }
+
+    const count = Number(match[1]);
+    const root = match[2];
+    const warning = this.findByRoot(root);
+
+    if (warning) {
+      // only keep the highest count, assume count to either stay the same or
+      // increase.
+      if (warning.count >= count) {
+        return true;
+      } else {
+        // update the existing warning to the latest (highest) count
+        warning.count = count;
+        return false;
+      }
+    } else {
+      this.RECRAWL_WARNINGS.push(new RecrawlWarning(root, count));
+      return false;
+    }
+  }
+}
+
+RecrawlWarning.RECRAWL_WARNINGS = [];
+RecrawlWarning.REGEXP =
+  /Recrawled this watch (\d+) times, most recently because:\n([^:]+)/;
+module.exports = RecrawlWarning;