(function () {
'use strict';

var classCallCheck = function (instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
};

var createClass = function () {
  function defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  return function (Constructor, protoProps, staticProps) {
    if (protoProps) defineProperties(Constructor.prototype, protoProps);
    if (staticProps) defineProperties(Constructor, staticProps);
    return Constructor;
  };
}();



























var slicedToArray = function () {
  function sliceIterator(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"]) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  return function (arr, i) {
    if (Array.isArray(arr)) {
      return arr;
    } else if (Symbol.iterator in Object(arr)) {
      return sliceIterator(arr, i);
    } else {
      throw new TypeError("Invalid attempt to destructure non-iterable instance");
    }
  };
}();













var toConsumableArray = function (arr) {
  if (Array.isArray(arr)) {
    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];

    return arr2;
  } else {
    return Array.from(arr);
  }
};

/* global process,require */
var isGlobalSym = Symbol('isGlobal');
var npmSym = Symbol('npm');
var whereSym = Symbol('where');
var fetch = require('node-fetch');
var swapFolderAndGlobal = function SwapFolderAndGlobal(prefix, isGlobal) {

  var oldPrefix = this[npmSym].config.prefix,
      oldGlobal = this[npmSym].config.global;

  this[npmSym].config.prefix = prefix;
  this[npmSym].config.global = isGlobal;

  return [oldPrefix, oldGlobal];
};

var NpmOperations = function () {
  function NpmOperations(where, configuredNpm, isGlobal) {
    classCallCheck(this, NpmOperations);


    this[whereSym] = where;
    this[npmSym] = configuredNpm;
    this[isGlobalSym] = isGlobal;
  }

  createClass(NpmOperations, [{
    key: 'ping',
    value: function ping() {
      var _this = this;

      return new Promise(function (resolvePing, rejectPing) {
        _this[npmSym].commands.ping('', function (err) {
          if (err) {

            return rejectPing(err);
          }

          return resolvePing();
        });
      });
    }
  }, {
    key: 'launchInstall',
    value: function launchInstall() {
      var _this2 = this;

      return new Promise(function (resolveInstall, rejectInstall) {
        _this2[npmSym].commands.install(_this2[whereSym], [], function (err) {
          if (err) {

            return rejectInstall(err);
          }

          return resolveInstall();
        });
      });
    }
  }, {
    key: 'search',
    value: function search(keyword) {

      return fetch('https://registry.npmjs.org/-/v1/search?text=' + keyword + '&size=25').then(function (res) {
        return res.json();
      });
    }
  }, {
    key: 'run',
    value: function run(scriptName) {
      var _this3 = this;

      return new Promise(function (resolveRun, rejectRun) {
        _this3[npmSym].commands.runScript([scriptName], function (err, infos) {
          if (err) {

            return rejectRun(err);
          }

          return resolveRun(infos);
        });
      });
    }
  }, {
    key: 'view',
    value: function view(packageName) {
      var _this4 = this;

      return new Promise(function (resolveView, rejectView) {

        _this4[npmSym].commands.view([packageName], function (err, infos) {
          if (err) {

            return rejectView(err);
          }

          return resolveView(infos);
        });
      });
    }
  }, {
    key: 'build',
    value: function build(folder) {
      var _this5 = this;

      return new Promise(function (resolveBuild, rejectBuild) {

        _this5[npmSym].commands.build([folder], function (err, infos) {
          if (err) {

            return rejectBuild(err);
          }

          return resolveBuild(infos);
        });
      });
    }
  }, {
    key: 'rebuild',
    value: function rebuild() {
      var _this6 = this;

      return new Promise(function (resolveRebuild, rejectRebuild) {

        _this6[npmSym].commands.rebuild([], function (err, infos) {
          if (err) {
            return rejectRebuild(err);
          }
          return resolveRebuild(infos);
        });
      });
    }
  }, {
    key: 'install',
    value: function install(dependency, version) {
      var _this7 = this;

      var dependencyToSubmit = dependency.name;

      if (version && version !== 'false' && version !== 'undefined') {

        dependencyToSubmit += '@' + version;
      }

      return new Promise(function (resolveInstall, rejectInstall) {
        var toInstall = [dependencyToSubmit],
            whereToInstall = _this7[isGlobalSym] ? '' : _this7[whereSym];

        if (!_this7[isGlobalSym] && dependency.kind === 'dev') {

          _this7[npmSym].config.set('save-dev', true);
        } else if (!_this7[isGlobalSym]) {

          _this7[npmSym].config.set('save', true);
        }

        _this7[npmSym].commands.install(whereToInstall, toInstall, function (err) {

          if (err) {

            return rejectInstall(err);
          }

          if (!_this7[isGlobalSym]) {

            _this7[npmSym].config.set('save-dev', false);
            _this7[npmSym].config.set('save', false);
          }
          return resolveInstall();
        });
      });
    }
  }, {
    key: 'installLatest',
    value: function installLatest(dependency) {

      return this.install(dependency, dependency.latest);
    }
  }, {
    key: 'update',
    value: function update(dependency) {
      var _this8 = this;

      return new Promise(function (resolveUpdate, rejectUpdate) {
        var toUpdate = [dependency.name];

        if (!_this8[isGlobalSym] && dependency.kind === 'dev') {

          _this8[npmSym].config.set('save-dev', true);
        } else if (!_this8[isGlobalSym]) {

          _this8[npmSym].config.set('save', true);
        }

        _this8[npmSym].commands.update(toUpdate, function (err) {

          if (err) {

            return rejectUpdate(err);
          }

          if (!_this8[isGlobalSym]) {

            _this8[npmSym].config.set('save-dev', false);
            _this8[npmSym].config.set('save', false);
          }
          return resolveUpdate();
        });
      });
    }
  }, {
    key: 'rm',
    value: function rm(dependency) {
      var _this9 = this;

      return new Promise(function (resolveRm, rejectRm) {
        var toRemove = [dependency.name];

        if (!_this9[isGlobalSym] && dependency.kind === 'dev') {

          _this9[npmSym].config.set('save-dev', true);
        } else if (!_this9[isGlobalSym]) {

          _this9[npmSym].config.set('save', true);
        }

        _this9[npmSym].commands.rm(toRemove, function (err) {

          if (err) {

            return rejectRm(err);
          }

          if (!_this9[isGlobalSym]) {

            _this9[npmSym].config.set('save-dev', false);
            _this9[npmSym].config.set('save', false);
          }
          return resolveRm();
        });
      });
    }
  }, {
    key: 'listOutdated',
    value: function listOutdated() {
      var _this10 = this;

      return new Promise(function (listOutdatedResolve, listOutdatedReject) {

        Promise.all([_this10.list(), _this10.outdated()]).then(function (resolved) {

          if (resolved && Array.isArray(resolved) && resolved.length === 2) {
            var outdatedList = resolved[1],
                listList = resolved[0];
            var toResolve = [];

            listList.forEach(function (element) {

              if (element && element.name) {
                var outdatedData = outdatedList.filter(function (filterElement) {
                  return filterElement && filterElement.name === element.name;
                }).map(function (mapElement) {
                  return {
                    'name': element.name,
                    'kind': element.kind,
                    'current': mapElement.current,
                    'wanted': mapElement.wanted,
                    'latest': mapElement.latest
                  };
                });

                if (outdatedData.length > 0) {

                  toResolve = toResolve.concat(outdatedData);
                } else {

                  toResolve.push(element);
                }
              }
            });

            return listOutdatedResolve(toResolve);
          }

          return listOutdatedReject('Output from list and oudated commands wrong!');
        }).catch(function (err) {
          return listOutdatedReject(err);
        });
      });
    }
  }, {
    key: 'outdated',
    value: function outdated() {
      var _this11 = this;

      return new Promise(function (resolveOutdated, rejectOutdated) {
        var _swapFolderAndGlobal$ = swapFolderAndGlobal.apply(_this11, [_this11[whereSym], _this11[isGlobalSym]]),
            _swapFolderAndGlobal$2 = slicedToArray(_swapFolderAndGlobal$, 2),
            oldPrefix = _swapFolderAndGlobal$2[0],
            oldGlobal = _swapFolderAndGlobal$2[1];

        _this11[npmSym].commands.outdated([], true, function (outdatedError, packageInformations) {

          if (outdatedError) {

            _this11[npmSym].config.prefix = oldPrefix;
            _this11[npmSym].config.global = oldGlobal;
            return rejectOutdated(outdatedError);
          }

          if (packageInformations && Array.isArray(packageInformations)) {
            var toResolve = [];

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

            try {
              for (var _iterator = packageInformations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                var aPackageInformation = _step.value;


                toResolve.push({
                  'name': aPackageInformation[1],
                  'current': aPackageInformation[2],
                  'wanted': aPackageInformation[3],
                  'latest': aPackageInformation[4]
                });
              }
            } catch (err) {
              _didIteratorError = true;
              _iteratorError = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion && _iterator.return) {
                  _iterator.return();
                }
              } finally {
                if (_didIteratorError) {
                  throw _iteratorError;
                }
              }
            }

            _this11[npmSym].config.prefix = oldPrefix;
            _this11[npmSym].config.global = oldGlobal;
            return resolveOutdated(toResolve);
          }

          return rejectOutdated('Package informations from outdated are wrong!');
        });
      });
    }
  }, {
    key: 'prune',
    value: function prune() {
      var _this12 = this;

      return new Promise(function (resolvePrune, rejectPrune) {
        var oldCWD = process.cwd();

        process.chdir(_this12[whereSym]);
        _this12[npmSym].commands.prune([], function (pruneError, packageInformations) {

          process.chdir(oldCWD);
          if (pruneError) {

            return rejectPrune(pruneError);
          }

          return resolvePrune(packageInformations);
        });
      });
    }
  }, {
    key: 'dedupe',
    value: function dedupe() {
      var _this13 = this;

      return new Promise(function (resolveDedupe, rejectDedupe) {

        _this13[npmSym].commands.dedupe([], function (DedupeError, packageInformations) {

          if (DedupeError) {

            return rejectDedupe(DedupeError);
          }

          return resolveDedupe(packageInformations);
        });
      });
    }
  }, {
    key: 'list',
    value: function list() {
      var _this14 = this;

      return new Promise(function (resolveList, rejectList) {
        var _swapFolderAndGlobal$3 = swapFolderAndGlobal.apply(_this14, [_this14[whereSym], _this14[isGlobalSym]]),
            _swapFolderAndGlobal$4 = slicedToArray(_swapFolderAndGlobal$3, 2),
            oldPrefix = _swapFolderAndGlobal$4[0],
            oldGlobal = _swapFolderAndGlobal$4[1];

        _this14[npmSym].commands.list([], true, function (listError, packageInformations) {

          if (listError) {

            _this14[npmSym].config.prefix = oldPrefix;
            _this14[npmSym].config.global = oldGlobal;
            return rejectList(listError);
          }

          if (packageInformations && packageInformations.dependencies && packageInformations.devDependencies) {
            var toResolve = [],
                dependenciesKeys = Object.keys(packageInformations.dependencies),
                dependenciesKeysLength = dependenciesKeys.length,
                devDependenciesKeys = Object.keys(packageInformations.devDependencies),
                filteringFunction = function FilteringFunction(element) {

              return element && element.name !== packageInformations.dependencies[this];
            },
                filterIsADevDependency = function filterIsADevDependency(aDependency, element) {

              return element && element === aDependency;
            };

            for (var dependenciesKeysIndex = 0; dependenciesKeysIndex < dependenciesKeysLength; dependenciesKeysIndex += 1) {
              var aDependencyKey = dependenciesKeys[dependenciesKeysIndex];

              if (aDependencyKey && toResolve.every(filteringFunction, aDependencyKey)) {
                var aDependency = packageInformations.dependencies[aDependencyKey],
                    isADevDependency = devDependenciesKeys.filter(filterIsADevDependency.bind(devDependenciesKeys, aDependencyKey));

                toResolve.push({
                  'name': aDependencyKey,
                  'current': aDependency.version,
                  'kind': isADevDependency[0] ? 'dev' : ''
                });
              }
            }

            _this14[npmSym].config.prefix = oldPrefix;
            _this14[npmSym].config.global = oldGlobal;
            return resolveList(toResolve);
          }

          return rejectList('Package informations from list command are wrong!');
        });
      });
    }
  }, {
    key: 'shrinkwrap',
    value: function shrinkwrap() {
      var _this15 = this;

      return new Promise(function (resolveShrink, rejectShrink) {

        _this15[npmSym].commands.shrinkwrap([], function (shrinkError, infos) {

          if (shrinkError) {

            return rejectShrink(shrinkError);
          }

          return resolveShrink(infos);
        });
      });
    }
  }, {
    key: 'doctor',
    value: function doctor() {
      var _this16 = this;

      return new Promise(function (resolveDoctor, rejectDoctor) {

        _this16[npmSym].commands.doctor(function (doctorErr, doctorInfo) {

          if (doctorErr) {

            return rejectDoctor(doctorErr);
          }

          return resolveDoctor(doctorInfo);
        });
      });
    }
  }, {
    key: 'root',
    value: function root() {
      var _this17 = this;

      return new Promise(function (resolveRoot, rejectRoot) {

        _this17[npmSym].commands.root([], function (rootError, rootInfo) {

          if (rootError) {

            return rejectRoot(rootError);
          }

          return resolveRoot(rootInfo);
        });
      });
    }
  }]);
  return NpmOperations;
}();

/*global require,process,Buffer*/
var npm = require('npm');
var stream = require('stream');
var writable = new stream.Writable({
  'write': function write(chunk, encoding, next) {
    var thisLogBuffer = new Buffer(chunk),
        thisLog = thisLogBuffer.toString().trim();

    if (thisLog) {

      process.send({
        'type': 'log',
        'payload': thisLog
      });
    }

    next();
  }
});
var npmDefaultConfiguration = {
  'loglevel': 'info',
  'progress': false,
  'logstream': writable
};
var exec = function exec(folder, isGlobal, command, param1, param2) {
  var confObject = Object.assign({}, npmDefaultConfiguration, {
    'prefix': folder,
    'global': isGlobal
  });

  process.send({ folder: folder, isGlobal: isGlobal, command: command, param1: param1, param2: param2 });
  return npm.load(confObject, function (err, configuredNpm) {
    if (err) {

      process.send({
        'type': 'error',
        'payload': err
      });
    }
    var npmOperations = new NpmOperations(folder, configuredNpm, isGlobal);

    npmOperations[command](param1, param2).then(function (resolved) {
      return process.send({
        'type': command,
        'payload': resolved
      });
    });
  });
};
var inputs = process.argv.slice(2).map(function (element) {
  try {

    return JSON.parse(element);
  } catch (err) {

    if (element === 'undefined') {

      return undefined;
    }

    return element;
  }
});

exec.apply(undefined, toConsumableArray(inputs));

}());
//# sourceMappingURL=npm-runner.js.map