chore(package): re-init package with commitizen and standard-release

node_modules/npm-path/index.js

@@ -0,0 +1,219 @@
+'use strict';
+
+function _toConsumableArray(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); } }
+
+var fs = require('fs');
+var path = require('path');
+var which = require('which');
+
+var findPrefix = require('./find-prefix');
+
+var PATH = getPATHKey();
+var SEPARATOR = getPATHSeparator();
+
+/**
+ * Get new $PATH setting with additional paths supplied by the npm.
+ *
+ * @param Object options Config options Object.
+ * @param Object options.env Environment to use. Default: process.env
+ * @param String options.wd Working directory. Default: process.cwd()
+ * @param Function fn callback function.
+ */
+
+function getPath(options, fn) {
+  options.cwd = options.cwd || process.cwd();
+  var env = options.env = options.env || process.env;
+  var pathArr = getPathArr(options);
+
+  findPrefix(options, function (err, prefixPath) {
+    if (!err && prefixPath) {
+      // ignore err if cannot find prefix
+      pathArr.unshift(path.join(prefixPath, 'node_modules', '.bin'));
+    }
+
+    whichNpm(options, function (err, npmPath) {
+      // we also unshift the bundled node-gyp-bin folder so that
+      // the bundled one will be used for installing things.
+
+      // simply ignore this step if there was no npm found
+      if (err || !npmPath) {
+        // ...unless npm path was explicitly passed in
+        if (options.npm) {
+          return fn(err || new Error('Cannot find ' + options.npm));
+        }
+      } else {
+        pathArr.unshift(path.join(path.dirname(npmPath), 'node-gyp-bin'));
+      }
+
+      if (env[PATH]) pathArr = pathArr.concat(env[PATH].split(SEPARATOR));
+
+      // Remove duplicated entries
+      pathArr = [].concat(_toConsumableArray(new Set(pathArr)));
+
+      fn(null, pathArr.join(SEPARATOR));
+    });
+  });
+}
+
+/**
+ * Async wrapper around `getPath`.
+ */
+
+function getPathAsync(options, fn) {
+  // options is optional
+  if (typeof options === 'function') {
+    fn = options;
+    options = {};
+  }
+  // if no fn, execute as sync
+  if (typeof fn !== 'function') return getPathSync(options);
+  options = options || {};
+  options.isSync = false;
+  return getPath(options, fn);
+}
+
+/**
+ * Sync wrapper around `getPath`.
+ */
+
+function getPathSync(options) {
+  options = options || {};
+  options.isSync = true;
+  var thePath = null;
+  // sync magic: if sync true, callback is executed sync
+  // therefore we can set thePath from inside it before returning
+  getPath(options, function (err, foundPath) {
+    if (err) throw err;
+    thePath = foundPath;
+  });
+  return thePath;
+}
+
+/**
+ * Change environment to include npm path adjustments.
+ *
+ * @param Object options Config options Object.
+ * @param Object options.env Environment to use. Default: process.env
+ * @param String options.wd Working directory. Default: process.cwd()
+ * @param Function fn callback function.
+ */
+
+function setPathAsync(options, fn) {
+  // options is optional
+  if (typeof options === 'function') {
+    fn = options;
+    options = {};
+  }
+
+  // if no fn, execute as sync
+  if (typeof fn !== 'function') return setPathSync(options);
+
+  getPathAsync(options, function (err, newPath) {
+    if (err) return fn(err);
+    fn(null, options.env[PATH] = newPath);
+  });
+}
+
+/**
+ * Sync version of `setPathAsync`
+ */
+function setPathSync(options) {
+  options = options || {};
+  var newPath = getPathSync(options);
+  options.env[PATH] = newPath;
+  return newPath;
+}
+
+/**
+ * Generate simple parts of the npm path. Basically everything that doesn't
+ * depend on potentially async operations.
+ *
+ * @return Array
+ */
+function getPathArr(options) {
+  var wd = options.cwd;
+  var pathArr = [];
+  var p = wd.split(path.sep + 'node_modules' + path.sep);
+  var acc = path.resolve(p.shift());
+
+  // first add the directory containing the `node` executable currently
+  // running, so that any lifecycle script that invoke 'node' will execute
+  // this same one.
+  pathArr.unshift(path.dirname(process.execPath));
+
+  p.forEach(function (pp) {
+    pathArr.unshift(path.join(acc, 'node_modules', '.bin'));
+    acc = path.join(acc, 'node_modules', pp);
+  });
+  pathArr.unshift(path.join(acc, 'node_modules', '.bin'));
+  return pathArr;
+}
+
+/**
+ * Use callback-style signature but toggle sync execution if `isSync` is true.
+ * If options.npm is supplied, this will simply provide npm/bin/npm-cli.
+ */
+function whichNpm(options, fn) {
+  var npmCli = options.npm && path.join(options.npm, 'bin', 'npm-cli.js');
+
+  if (options.isSync) {
+    var npmPath = null;
+
+    try {
+      npmPath = fs.realpathSync(npmCli || which.sync('npm'));
+    } catch (err) {
+      return fn(err);
+    }
+
+    fn(null, npmPath);
+    return;
+  }
+
+  if (options.npm) {
+    fs.realpath(npmCli, fn);
+    return;
+  }
+
+  which('npm', function (err, npmPath) {
+    if (err) return fn(err);
+    fs.realpath(npmPath, fn);
+  });
+}
+
+/**
+ * Get key to use as $PATH in environment
+ */
+
+function getPATHKey() {
+  var PATH = 'PATH';
+
+  // windows calls it's path 'Path' usually, but this is not guaranteed.
+  if (process.platform === 'win32') {
+    PATH = 'Path';
+    Object.keys(process.env).forEach(function (e) {
+      if (e.match(/^PATH$/i)) {
+        PATH = e;
+      }
+    });
+  }
+  return PATH;
+}
+
+/**
+ * Get $PATH separator based on environment
+ */
+function getPATHSeparator() {
+  return process.platform === 'win32' ? ';' : ':';
+}
+
+module.exports = setPathAsync;
+module.exports.get = getPathAsync;
+module.exports.get.sync = getPathSync;
+module.exports.getSync = getPathSync;
+
+module.exports.set = setPathAsync;
+module.exports.set.sync = setPathSync;
+module.exports.setSync = setPathSync;
+
+module.exports.PATH = PATH;
+module.exports.SEPARATOR = SEPARATOR;