flow like the river

BACK_BACK/node_modules/parcel-bundler/lib/utils/installPackage.js

@@ -0,0 +1,191 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+const config = require('./config');
+
+const _require = require('@parcel/utils'),
+      promisify = _require.promisify;
+
+const resolve = promisify(require('resolve'));
+
+const commandExists = require('command-exists');
+
+const logger = require('@parcel/logger');
+
+const pipeSpawn = require('./pipeSpawn');
+
+const PromiseQueue = require('./PromiseQueue');
+
+const path = require('path');
+
+const fs = require('@parcel/fs');
+
+const WorkerFarm = require('@parcel/workers');
+
+const YARN_LOCK = 'yarn.lock';
+
+function install(_x, _x2) {
+  return _install.apply(this, arguments);
+}
+
+function _install() {
+  _install = (0, _asyncToGenerator2.default)(function* (modules, filepath, options = {}) {
+    let _options$installPeers = options.installPeers,
+        installPeers = _options$installPeers === void 0 ? true : _options$installPeers,
+        _options$saveDev = options.saveDev,
+        saveDev = _options$saveDev === void 0 ? true : _options$saveDev,
+        packageManager = options.packageManager;
+
+    if (typeof modules === 'string') {
+      modules = [modules];
+    }
+
+    logger.progress(`Installing ${modules.join(', ')}...`);
+    let packageLocation = yield config.resolve(filepath, ['package.json']);
+    let cwd = packageLocation ? path.dirname(packageLocation) : process.cwd();
+
+    if (!packageManager) {
+      packageManager = yield determinePackageManager(filepath);
+    }
+
+    let commandToUse = packageManager === 'npm' ? 'install' : 'add';
+    let args = [commandToUse, ...modules];
+
+    if (saveDev) {
+      args.push('-D');
+    } else if (packageManager === 'npm') {
+      args.push('--save');
+    } // npm doesn't auto-create a package.json when installing,
+    // so create an empty one if needed.
+
+
+    if (packageManager === 'npm' && !packageLocation) {
+      yield fs.writeFile(path.join(cwd, 'package.json'), '{}');
+    }
+
+    try {
+      yield pipeSpawn(packageManager, args, {
+        cwd
+      });
+    } catch (err) {
+      throw new Error(`Failed to install ${modules.join(', ')}.`);
+    }
+
+    if (installPeers) {
+      yield Promise.all(modules.map(m => installPeerDependencies(filepath, m, options)));
+    }
+  });
+  return _install.apply(this, arguments);
+}
+
+function installPeerDependencies(_x3, _x4, _x5) {
+  return _installPeerDependencies.apply(this, arguments);
+}
+
+function _installPeerDependencies() {
+  _installPeerDependencies = (0, _asyncToGenerator2.default)(function* (filepath, name, options) {
+    let basedir = path.dirname(filepath);
+
+    const _yield$resolve = yield resolve(name, {
+      basedir
+    }),
+          _yield$resolve2 = (0, _slicedToArray2.default)(_yield$resolve, 1),
+          resolved = _yield$resolve2[0];
+
+    const pkg = yield config.load(resolved, ['package.json']);
+    const peers = pkg.peerDependencies || {};
+    const modules = [];
+
+    for (const peer in peers) {
+      modules.push(`${peer}@${peers[peer]}`);
+    }
+
+    if (modules.length) {
+      yield install(modules, filepath, Object.assign({}, options, {
+        installPeers: false
+      }));
+    }
+  });
+  return _installPeerDependencies.apply(this, arguments);
+}
+
+function determinePackageManager(_x6) {
+  return _determinePackageManager.apply(this, arguments);
+}
+
+function _determinePackageManager() {
+  _determinePackageManager = (0, _asyncToGenerator2.default)(function* (filepath) {
+    const yarnLockFile = yield config.resolve(filepath, [YARN_LOCK]);
+    /**
+     * no yarn.lock => use npm
+     * yarn.lock => Use yarn, fallback to npm
+     */
+
+    if (!yarnLockFile) {
+      return 'npm';
+    }
+
+    const hasYarn = yield checkForYarnCommand();
+
+    if (hasYarn) {
+      return 'yarn';
+    }
+
+    return 'npm';
+  });
+  return _determinePackageManager.apply(this, arguments);
+}
+
+let hasYarn = null;
+
+function checkForYarnCommand() {
+  return _checkForYarnCommand.apply(this, arguments);
+}
+
+function _checkForYarnCommand() {
+  _checkForYarnCommand = (0, _asyncToGenerator2.default)(function* () {
+    if (hasYarn != null) {
+      return hasYarn;
+    }
+
+    try {
+      hasYarn = yield commandExists('yarn');
+    } catch (err) {
+      hasYarn = false;
+    }
+
+    return hasYarn;
+  });
+  return _checkForYarnCommand.apply(this, arguments);
+}
+
+let queue = new PromiseQueue(install, {
+  maxConcurrent: 1,
+  retry: false
+});
+
+module.exports = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2.default)(function* (...args) {
+    // Ensure that this function is always called on the master process so we
+    // don't call multiple installs in parallel.
+    if (WorkerFarm.isWorker()) {
+      yield WorkerFarm.callMaster({
+        location: __filename,
+        args
+      });
+      return;
+    }
+
+    queue.add(...args);
+    return queue.run();
+  });
+
+  return function () {
+    return _ref.apply(this, arguments);
+  };
+}();