blockmine 1.0.1 → 1.0.7

package/backend/node_modules/nodemon/lib/monitor/watch.js

@@ -1,244 +0,0 @@
-module.exports.watch = watch;
-module.exports.resetWatchers = resetWatchers;
-
-var debug = require('debug')('nodemon:watch');
-var debugRoot = require('debug')('nodemon');
-var chokidar = require('chokidar');
-var undefsafe = require('undefsafe');
-var config = require('../config');
-var path = require('path');
-var utils = require('../utils');
-var bus = utils.bus;
-var match = require('./match');
-var watchers = [];
-var debouncedBus;
-
-bus.on('reset', resetWatchers);
-
-function resetWatchers() {
-  debugRoot('resetting watchers');
-  watchers.forEach(function (watcher) {
-    watcher.close();
-  });
-  watchers = [];
-}
-
-function watch() {
-  if (watchers.length) {
-    debug('early exit on watch, still watching (%s)', watchers.length);
-    return;
-  }
-
-  var dirs = [].slice.call(config.dirs);
-
-  debugRoot('start watch on: %s', dirs.join(', '));
-  const rootIgnored = config.options.ignore;
-  debugRoot('ignored', rootIgnored);
-
-  var watchedFiles = [];
-
-  const promise = new Promise(function (resolve) {
-    const dotFilePattern = /[/\\]\./;
-    var ignored = match.rulesToMonitor(
-      [], // not needed
-      Array.from(rootIgnored),
-      config
-    ).map(pattern => pattern.slice(1));
-
-    const addDotFile = dirs.filter(dir => dir.match(dotFilePattern));
-
-    // don't ignore dotfiles if explicitly watched.
-    if (addDotFile.length === 0) {
-      ignored.push(dotFilePattern);
-    }
-
-    var watchOptions = {
-      ignorePermissionErrors: true,
-      ignored: ignored,
-      persistent: true,
-      usePolling: config.options.legacyWatch || false,
-      interval: config.options.pollingInterval,
-      // note to future developer: I've gone back and forth on adding `cwd`
-      // to the props and in some cases it fixes bugs but typically it causes
-      // bugs elsewhere (since nodemon is used is so many ways). the final
-      // decision is to *not* use it at all and work around it
-      // cwd: ...
-    };
-
-    if (utils.isWindows) {
-      watchOptions.disableGlobbing = true;
-    }
-
-    if (utils.isIBMi) {
-      watchOptions.usePolling = true;
-    }
-
-    if (process.env.TEST) {
-      watchOptions.useFsEvents = false;
-    }
-
-    var watcher = chokidar.watch(
-      dirs,
-      Object.assign({}, watchOptions, config.options.watchOptions || {})
-    );
-
-    watcher.ready = false;
-
-    var total = 0;
-
-    watcher.on('change', filterAndRestart);
-    watcher.on('unlink', filterAndRestart);
-    watcher.on('add', function (file) {
-      if (watcher.ready) {
-        return filterAndRestart(file);
-      }
-
-      watchedFiles.push(file);
-      bus.emit('watching', file);
-      debug('chokidar watching: %s', file);
-    });
-    watcher.on('ready', function () {
-      watchedFiles = Array.from(new Set(watchedFiles)); // ensure no dupes
-      total = watchedFiles.length;
-      watcher.ready = true;
-      resolve(total);
-      debugRoot('watch is complete');
-    });
-
-    watcher.on('error', function (error) {
-      if (error.code === 'EINVAL') {
-        utils.log.error(
-          'Internal watch failed. Likely cause: too many ' +
-          'files being watched (perhaps from the root of a drive?\n' +
-          'See https://github.com/paulmillr/chokidar/issues/229 for details'
-        );
-      } else {
-        utils.log.error('Internal watch failed: ' + error.message);
-        process.exit(1);
-      }
-    });
-
-    watchers.push(watcher);
-  });
-
-  return promise.catch(e => {
-    // this is a core error and it should break nodemon - so I have to break
-    // out of a promise using the setTimeout
-    setTimeout(() => {
-      throw e;
-    });
-  }).then(function () {
-    utils.log.detail(`watching ${watchedFiles.length} file${
-      watchedFiles.length === 1 ? '' : 's'}`);
-    return watchedFiles;
-  });
-}
-
-function filterAndRestart(files) {
-  if (!Array.isArray(files)) {
-    files = [files];
-  }
-
-  if (files.length) {
-    var cwd = process.cwd();
-    if (this.options && this.options.cwd) {
-      cwd = this.options.cwd;
-    }
-
-    utils.log.detail(
-      'files triggering change check: ' +
-      files
-        .map(file => {
-          const res = path.relative(cwd, file);
-          return res;
-        })
-        .join(', ')
-    );
-
-    // make sure the path is right and drop an empty
-    // filenames (sometimes on windows)
-    files = files.filter(Boolean).map(file => {
-      return path.relative(process.cwd(), path.relative(cwd, file));
-    });
-
-    if (utils.isWindows) {
-      // ensure the drive letter is in uppercase (c:\foo -> C:\foo)
-      files = files.map(f => {
-        if (f.indexOf(':') === -1) { return f; }
-        return f[0].toUpperCase() + f.slice(1);
-      });
-    }
-
-
-    debug('filterAndRestart on', files);
-
-    var matched = match(
-      files,
-      config.options.monitor,
-      undefsafe(config, 'options.execOptions.ext')
-    );
-
-    debug('matched?', JSON.stringify(matched));
-
-    // if there's no matches, then test to see if the changed file is the
-    // running script, if so, let's allow a restart
-    if (config.options.execOptions && config.options.execOptions.script) {
-      const script = path.resolve(config.options.execOptions.script);
-      if (matched.result.length === 0 && script) {
-        const length = script.length;
-        files.find(file => {
-          if (file.substr(-length, length) === script) {
-            matched = {
-              result: [file],
-              total: 1,
-            };
-            return true;
-          }
-        });
-      }
-    }
-
-    utils.log.detail(
-      'changes after filters (before/after): ' +
-      [files.length, matched.result.length].join('/')
-    );
-
-    // reset the last check so we're only looking at recently modified files
-    config.lastStarted = Date.now();
-
-    if (matched.result.length) {
-      if (config.options.delay > 0) {
-        utils.log.detail('delaying restart for ' + config.options.delay + 'ms');
-        if (debouncedBus === undefined) {
-          debouncedBus = debounce(restartBus, config.options.delay);
-        }
-        debouncedBus(matched);
-      } else {
-        return restartBus(matched);
-      }
-    }
-  }
-}
-
-function restartBus(matched) {
-  utils.log.status('restarting due to changes...');
-  matched.result.map(file => {
-    utils.log.detail(path.relative(process.cwd(), file));
-  });
-
-  if (config.options.verbose) {
-    utils.log._log('');
-  }
-
-  bus.emit('restart', matched.result);
-}
-
-function debounce(fn, delay) {
-  var timer = null;
-  return function () {
-    const context = this;
-    const args = arguments;
-    clearTimeout(timer);
-    timer = setTimeout(() =>fn.apply(context, args), delay);
-  };
-}

package/backend/node_modules/nodemon/lib/nodemon.js

@@ -1,317 +0,0 @@
-var debug = require('debug')('nodemon');
-var path = require('path');
-var monitor = require('./monitor');
-var cli = require('./cli');
-var version = require('./version');
-var util = require('util');
-var utils = require('./utils');
-var bus = utils.bus;
-var help = require('./help');
-/** @type {import('..').NodemonEventConfig} */
-var config = require('./config');
-var spawn = require('./spawn');
-const defaults = require('./config/defaults')
-var eventHandlers = {};
-
-// this is fairly dirty, but theoretically sound since it's part of the
-// stable module API
-config.required = utils.isRequired;
-
-/**
- * @param {import('..').NodemonSettings | string} settings
- * @returns {import('..').Nodemon}
- */
-function nodemon(settings) {
-  bus.emit('boot');
-  nodemon.reset();
-  
-  /** @type {import('..').NodemonSettings} */
-  let options
-
-  // allow the cli string as the argument to nodemon, and allow for
-  // `node nodemon -V app.js` or just `-V app.js`
-  if (typeof settings === 'string') {
-    settings = settings.trim();
-    if (settings.indexOf('node') !== 0) {
-      if (settings.indexOf('nodemon') !== 0) {
-        settings = 'nodemon ' + settings;
-      }
-      settings = 'node ' + settings;
-    }
-    options = cli.parse(settings);
-  } else options = settings;
-
-  // set the debug flag as early as possible to get all the detailed logging
-  if (options.verbose) {
-    utils.debug = true;
-  }
-
-  if (options.help) {
-    if (process.stdout.isTTY) {
-      process.stdout._handle.setBlocking(true); // nodejs/node#6456
-    }
-    console.log(help(options.help));
-    if (!config.required) {
-      process.exit(0);
-    }
-  }
-
-  if (options.version) {
-    version().then(function (v) {
-      console.log(v);
-      if (!config.required) {
-        process.exit(0);
-      }
-    });
-    return;
-  }
-
-  // nodemon tools like grunt-nodemon. This affects where
-  // the script is being run from, and will affect where
-  // nodemon looks for the nodemon.json files
-  if (options.cwd) {
-    // this is protection to make sure we haven't dont the chdir already...
-    // say like in cli/parse.js (which is where we do this once already!)
-    if (process.cwd() !== path.resolve(config.system.cwd, options.cwd)) {
-      process.chdir(options.cwd);
-    }
-  }
-
-  config.load(options, function (config) {
-    if (!config.options.dump && !config.options.execOptions.script &&
-      config.options.execOptions.exec === 'node') {
-      if (!config.required) {
-        console.log(help('usage'));
-        process.exit();
-      }
-      return;
-    }
-
-    // before we print anything, update the colour setting on logging
-    utils.colours = config.options.colours;
-
-    // always echo out the current version
-    utils.log.info(version.pinned);
-
-    const cwd = process.cwd();
-
-    if (config.options.cwd) {
-      utils.log.detail('process root: ' + cwd);
-    }
-
-    config.loaded.map(file => file.replace(cwd, '.')).forEach(file => {
-      utils.log.detail('reading config ' + file);
-    });
-
-    if (config.options.stdin && config.options.restartable) {
-      // allow nodemon to restart when the use types 'rs\n'
-      process.stdin.resume();
-      process.stdin.setEncoding('utf8');
-      process.stdin.on('data', data => {
-        const str = data.toString().trim().toLowerCase();
-
-        // if the keys entered match the restartable value, then restart!
-        if (str === config.options.restartable) {
-          bus.emit('restart');
-        } else if (data.charCodeAt(0) === 12) { // ctrl+l
-          console.clear();
-        }
-      });
-    } else if (config.options.stdin) {
-      // so let's make sure we don't eat the key presses
-      // but also, since we're wrapping, watch out for
-      // special keys, like ctrl+c x 2 or '.exit' or ctrl+d or ctrl+l
-      var ctrlC = false;
-      var buffer = '';
-
-      process.stdin.on('data', function (data) {
-        data = data.toString();
-        buffer += data;
-        const chr = data.charCodeAt(0);
-
-        // if restartable, echo back
-        if (chr === 3) {
-          if (ctrlC) {
-            process.exit(0);
-          }
-
-          ctrlC = true;
-          return;
-        } else if (buffer === '.exit' || chr === 4) { // ctrl+d
-          process.exit();
-        } else if (chr === 13 || chr === 10) { // enter / carriage return
-          buffer = '';
-        } else if (chr === 12) { // ctrl+l
-          console.clear();
-          buffer = '';
-        }
-        ctrlC = false;
-      });
-      if (process.stdin.setRawMode) {
-        process.stdin.setRawMode(true);
-      }
-    }
-
-    if (config.options.restartable) {
-      utils.log.info('to restart at any time, enter `' +
-        config.options.restartable + '`');
-    }
-
-    if (!config.required) {
-      const restartSignal = config.options.signal === 'SIGUSR2' ? 'SIGHUP' : 'SIGUSR2';
-      process.on(restartSignal, nodemon.restart);
-      utils.bus.on('error', () => {
-        utils.log.fail((new Error().stack));
-      });
-      utils.log.detail((config.options.restartable ? 'or ' : '') + 'send ' +
-        restartSignal + ' to ' + process.pid + ' to restart');
-    }
-
-    const ignoring = config.options.monitor.map(function (rule) {
-      if (rule.slice(0, 1) !== '!') {
-        return false;
-      }
-
-      rule = rule.slice(1);
-
-      // don't notify of default ignores
-      if (defaults.ignoreRoot.indexOf(rule) !== -1) {
-        return false;
-        // return rule.slice(3).slice(0, -3);
-      }
-
-      if (rule.startsWith(cwd)) {
-        return rule.replace(cwd, '.');
-      }
-
-      return rule;
-    }).filter(Boolean).join(' ');
-    if (ignoring) utils.log.detail('ignoring: ' + ignoring);
-
-    utils.log.info('watching path(s): ' + config.options.monitor.map(function (rule) {
-      if (rule.slice(0, 1) !== '!') {
-        try {
-          rule = path.relative(process.cwd(), rule);
-        } catch (e) {}
-
-        return rule;
-      }
-
-      return false;
-    }).filter(Boolean).join(' '));
-
-    utils.log.info('watching extensions: ' + (config.options.execOptions.ext || '(all)'));
-
-    if (config.options.dump) {
-      utils.log._log('log', '--------------');
-      utils.log._log('log', 'node: ' + process.version);
-      utils.log._log('log', 'nodemon: ' + version.pinned);
-      utils.log._log('log', 'command: ' + process.argv.join(' '));
-      utils.log._log('log', 'cwd: ' + cwd);
-      utils.log._log('log', ['OS:', process.platform, process.arch].join(' '));
-      utils.log._log('log', '--------------');
-      utils.log._log('log', util.inspect(config, { depth: null }));
-      utils.log._log('log', '--------------');
-      if (!config.required) {
-        process.exit();
-      }
-
-      return;
-    }
-
-    config.run = true;
-
-    if (config.options.stdout === false) {
-      nodemon.on('start', function () {
-        nodemon.stdout = bus.stdout;
-        nodemon.stderr = bus.stderr;
-
-        bus.emit('readable');
-      });
-    }
-
-    if (config.options.events && Object.keys(config.options.events).length) {
-      Object.keys(config.options.events).forEach(function (key) {
-        utils.log.detail('bind ' + key + ' -> `' +
-          config.options.events[key] + '`');
-        nodemon.on(key, function () {
-          if (config.options && config.options.events) {
-            spawn(config.options.events[key], config,
-              [].slice.apply(arguments));
-          }
-        });
-      });
-    }
-
-    monitor.run(config.options);
-
-  });
-
-  return nodemon;
-}
-
-nodemon.restart = function () {
-  utils.log.status('restarting child process');
-  bus.emit('restart');
-  return nodemon;
-};
-
-nodemon.addListener = nodemon.on = function (event, handler) {
-  if (!eventHandlers[event]) { eventHandlers[event] = []; }
-  eventHandlers[event].push(handler);
-  bus.on(event, handler);
-  return nodemon;
-};
-
-nodemon.once = function (event, handler) {
-  if (!eventHandlers[event]) { eventHandlers[event] = []; }
-  eventHandlers[event].push(handler);
-  bus.once(event, function () {
-    debug('bus.once(%s)', event);
-    eventHandlers[event].splice(eventHandlers[event].indexOf(handler), 1);
-    handler.apply(this, arguments);
-  });
-  return nodemon;
-};
-
-nodemon.emit = function () {
-  bus.emit.apply(bus, [].slice.call(arguments));
-  return nodemon;
-};
-
-nodemon.removeAllListeners = function (event) {
-  // unbind only the `nodemon.on` event handlers
-  Object.keys(eventHandlers).filter(function (e) {
-    return event ? e === event : true;
-  }).forEach(function (event) {
-    eventHandlers[event].forEach(function (handler) {
-      bus.removeListener(event, handler);
-      eventHandlers[event].splice(eventHandlers[event].indexOf(handler), 1);
-    });
-  });
-
-  return nodemon;
-};
-
-nodemon.reset = function (done) {
-  bus.emit('reset', done);
-};
-
-bus.on('reset', function (done) {
-  debug('reset');
-  nodemon.removeAllListeners();
-  monitor.run.kill(true, function () {
-    utils.reset();
-    config.reset();
-    config.run = false;
-    if (done) {
-      done();
-    }
-  });
-});
-
-// expose the full config
-nodemon.config = config;
-
-module.exports = nodemon;
-

package/backend/node_modules/nodemon/lib/rules/add.js

@@ -1,89 +0,0 @@
-'use strict';
-
-var utils = require('../utils');
-
-// internal
-var reEscComments = /\\#/g;
-// note that '^^' is used in place of escaped comments
-var reUnescapeComments = /\^\^/g;
-var reComments = /#.*$/;
-var reEscapeChars = /[.|\-[\]()\\]/g;
-var reAsterisk = /\*/g;
-
-module.exports = add;
-
-/**
- * Converts file patterns or regular expressions to nodemon
- * compatible RegExp matching rules. Note: the `rules` argument
- * object is modified to include the new rule and new RegExp
- *
- * ### Example:
- *
- *     var rules = { watch: [], ignore: [] };
- *     add(rules, 'watch', '*.js');
- *     add(rules, 'ignore', '/public/');
- *     add(rules, 'watch', ':(\d)*\.js'); // note: string based regexp
- *     add(rules, 'watch', /\d*\.js/);
- *
- * @param {Object} rules containing `watch` and `ignore`. Also updated during
- *                       execution
- * @param {String} which must be either "watch" or "ignore"
- * @param {String|RegExp} rule the actual rule.
- */
-function add(rules, which, rule) {
-  if (!{ ignore: 1, watch: 1}[which]) {
-    throw new Error('rules/index.js#add requires "ignore" or "watch" as the ' +
-      'first argument');
-  }
-
-  if (Array.isArray(rule)) {
-    rule.forEach(function (rule) {
-      add(rules, which, rule);
-    });
-    return;
-  }
-
-  // support the rule being a RegExp, but reformat it to
-  // the custom :<regexp> format that we're working with.
-  if (rule instanceof RegExp) {
-    // rule = ':' + rule.toString().replace(/^\/(.*?)\/$/g, '$1');
-    utils.log.error('RegExp format no longer supported, but globs are.');
-    return;
-  }
-
-  // remove comments and trim lines
-  // this mess of replace methods is escaping "\#" to allow for emacs temp files
-
-  // first up strip comments and remove blank head or tails
-  rule = (rule || '').replace(reEscComments, '^^')
-             .replace(reComments, '')
-             .replace(reUnescapeComments, '#').trim();
-
-  var regexp = false;
-
-  if (typeof rule === 'string' && rule.substring(0, 1) === ':') {
-    rule = rule.substring(1);
-    utils.log.error('RegExp no longer supported: ' + rule);
-    regexp = true;
-  } else if (rule.length === 0) {
-    // blank line (or it was a comment)
-    return;
-  }
-
-  if (regexp) {
-    // rules[which].push(rule);
-  } else {
-    // rule = rule.replace(reEscapeChars, '\\$&')
-    // .replace(reAsterisk, '.*');
-
-    rules[which].push(rule);
-    // compile a regexp of all the rules for this ignore or watch
-    var re = rules[which].map(function (rule) {
-      return rule.replace(reEscapeChars, '\\$&')
-                 .replace(reAsterisk, '.*');
-    }).join('|');
-
-    // used for the directory matching
-    rules[which].re = new RegExp(re);
-  }
-}

package/backend/node_modules/nodemon/lib/rules/index.js

@@ -1,53 +0,0 @@
-'use strict';
-var utils = require('../utils');
-var add = require('./add');
-var parse = require('./parse');
-
-// exported
-var rules = { ignore: [], watch: [] };
-
-/**
- * Loads a nodemon config file and populates the ignore
- * and watch rules with it's contents, and calls callback
- * with the new rules
- *
- * @param  {String} filename
- * @param  {Function} callback
- */
-function load(filename, callback) {
-  parse(filename, function (err, result) {
-    if (err) {
-      // we should have bombed already, but
-      utils.log.error(err);
-      callback(err);
-    }
-
-    if (result.raw) {
-      result.raw.forEach(add.bind(null, rules, 'ignore'));
-    } else {
-      result.ignore.forEach(add.bind(null, rules, 'ignore'));
-      result.watch.forEach(add.bind(null, rules, 'watch'));
-    }
-
-    callback(null, rules);
-  });
-}
-
-module.exports = {
-  reset: function () { // just used for testing
-    rules.ignore.length = rules.watch.length = 0;
-    delete rules.ignore.re;
-    delete rules.watch.re;
-  },
-  load: load,
-  ignore: {
-    test: add.bind(null, rules, 'ignore'),
-    add: add.bind(null, rules, 'ignore'),
-  },
-  watch: {
-    test: add.bind(null, rules, 'watch'),
-    add: add.bind(null, rules, 'watch'),
-  },
-  add: add.bind(null, rules),
-  rules: rules,
-};