@atlaspack/package-manager 2.14.18-noselfbuild-3f2849b52.0 → 2.14.18-noselfbuild-342bd6c75.0

package/lib/Pnpm.js

@@ -0,0 +1,171 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Pnpm = void 0;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _commandExists() {
+  const data = _interopRequireDefault(require("command-exists"));
+  _commandExists = function () {
+    return data;
+  };
+  return data;
+}
+function _crossSpawn() {
+  const data = _interopRequireDefault(require("cross-spawn"));
+  _crossSpawn = function () {
+    return data;
+  };
+  return data;
+}
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _split() {
+  const data = _interopRequireDefault(require("split2"));
+  _split = function () {
+    return data;
+  };
+  return data;
+}
+var _JSONParseStream = _interopRequireDefault(require("./JSONParseStream"));
+var _promiseFromProcess = _interopRequireDefault(require("./promiseFromProcess"));
+var _utils = require("./utils");
+var _package = _interopRequireDefault(require("../package.json"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// $FlowFixMe
+const PNPM_CMD = 'pnpm';
+let hasPnpm;
+let pnpmVersion;
+class Pnpm {
+  static async exists() {
+    if (hasPnpm != null) {
+      return hasPnpm;
+    }
+    try {
+      hasPnpm = Boolean(await (0, _commandExists().default)('pnpm'));
+    } catch (err) {
+      hasPnpm = false;
+    }
+    return hasPnpm;
+  }
+  async install({
+    modules,
+    cwd,
+    saveDev = true
+  }) {
+    if (pnpmVersion == null) {
+      let version = await (0, _utils.exec)('pnpm --version');
+      pnpmVersion = parseInt(version.stdout, 10);
+    }
+    let args = ['add', '--reporter', 'ndjson'];
+    if (saveDev) {
+      args.push('-D');
+    }
+    if (pnpmVersion >= 7) {
+      if (_fs().default.existsSync(_path().default.join(cwd, 'pnpm-workspace.yaml'))) {
+        // installs in workspace root (regardless of cwd)
+        args.push('-w');
+      }
+    } else {
+      // ignores workspace root check
+      args.push('-W');
+    }
+    args = args.concat(modules.map(_utils.npmSpecifierFromModuleRequest));
+    let env = {};
+    for (let key in process.env) {
+      if (!key.startsWith('npm_') && key !== 'INIT_CWD' && key !== 'NODE_ENV') {
+        env[key] = process.env[key];
+      }
+    }
+    let addedCount = 0,
+      removedCount = 0;
+    let installProcess = (0, _crossSpawn().default)(PNPM_CMD, args, {
+      cwd,
+      env
+    });
+    installProcess.stdout.pipe((0, _split().default)()).pipe(new _JSONParseStream.default()).on('error', e => {
+      _logger().default.warn({
+        origin: '@atlaspack/package-manager',
+        message: e.chunk,
+        stack: e.stack
+      });
+    }).on('data', json => {
+      if (json.level === 'error') {
+        _logger().default.error({
+          origin: '@atlaspack/package-manager',
+          message: json.err.message,
+          stack: json.err.stack
+        });
+      } else if (json.level === 'info' && typeof json.message === 'string') {
+        _logger().default.info({
+          origin: '@atlaspack/package-manager',
+          message: prefix(json.message)
+        });
+      } else if (json.name === 'pnpm:stats') {
+        addedCount += json.added ?? 0;
+        removedCount += json.removed ?? 0;
+      }
+    });
+    let stderr = [];
+    installProcess.stderr.on('data', str => {
+      stderr.push(str.toString());
+    }).on('error', e => {
+      _logger().default.warn({
+        origin: '@atlaspack/package-manager',
+        message: e.message
+      });
+    });
+    try {
+      await (0, _promiseFromProcess.default)(installProcess);
+      if (addedCount > 0 || removedCount > 0) {
+        _logger().default.log({
+          origin: '@atlaspack/package-manager',
+          message: `Added ${addedCount} ${removedCount > 0 ? `and removed ${removedCount} ` : ''}packages via pnpm`
+        });
+      }
+
+      // Since we succeeded, stderr might have useful information not included
+      // in the json written to stdout. It's also not necessary to log these as
+      // errors as they often aren't.
+      for (let message of stderr) {
+        _logger().default.log({
+          origin: '@atlaspack/package-manager',
+          message
+        });
+      }
+    } catch (e) {
+      throw new Error('pnpm failed to install modules');
+    }
+  }
+}
+exports.Pnpm = Pnpm;
+function prefix(message) {
+  return 'pnpm: ' + message;
+}
+(0, _buildCache().registerSerializableClass)(`${_package.default.version}:Pnpm`, Pnpm);

package/lib/Yarn.js

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Yarn = void 0;
+function _commandExists() {
+  const data = _interopRequireDefault(require("command-exists"));
+  _commandExists = function () {
+    return data;
+  };
+  return data;
+}
+function _crossSpawn() {
+  const data = _interopRequireDefault(require("cross-spawn"));
+  _crossSpawn = function () {
+    return data;
+  };
+  return data;
+}
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _split() {
+  const data = _interopRequireDefault(require("split2"));
+  _split = function () {
+    return data;
+  };
+  return data;
+}
+var _JSONParseStream = _interopRequireDefault(require("./JSONParseStream"));
+var _promiseFromProcess = _interopRequireDefault(require("./promiseFromProcess"));
+var _utils = require("./utils");
+var _package = _interopRequireDefault(require("../package.json"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// $FlowFixMe
+const YARN_CMD = 'yarn';
+let hasYarn;
+let yarnVersion;
+class Yarn {
+  static async exists() {
+    if (hasYarn != null) {
+      return hasYarn;
+    }
+    try {
+      hasYarn = Boolean(await (0, _commandExists().default)('yarn'));
+    } catch (err) {
+      hasYarn = false;
+    }
+    return hasYarn;
+  }
+  async install({
+    modules,
+    cwd,
+    saveDev = true
+  }) {
+    if (yarnVersion == null) {
+      let version = await (0, _utils.exec)('yarn --version');
+      yarnVersion = parseInt(version.stdout, 10);
+    }
+    let args = ['add', '--json'].concat(modules.map(_utils.npmSpecifierFromModuleRequest));
+    if (saveDev) {
+      args.push('-D');
+      if (yarnVersion < 2) {
+        args.push('-W');
+      }
+    }
+
+    // When Parcel is run by Yarn (e.g. via package.json scripts), several environment variables are
+    // added. When parcel in turn calls Yarn again, these can cause Yarn to behave stragely, so we
+    // filter them out when installing packages.
+    let env = {};
+    for (let key in process.env) {
+      if (!key.startsWith('npm_') && key !== 'YARN_WRAP_OUTPUT' && key !== 'INIT_CWD' && key !== 'NODE_ENV') {
+        env[key] = process.env[key];
+      }
+    }
+    let installProcess = (0, _crossSpawn().default)(YARN_CMD, args, {
+      cwd,
+      env
+    });
+    installProcess.stdout
+    // Invoking yarn with --json provides streaming, newline-delimited JSON output.
+    .pipe((0, _split().default)()).pipe(new _JSONParseStream.default()).on('error', e => {
+      _logger().default.error(e, '@atlaspack/package-manager');
+    }).on('data', message => {
+      switch (message.type) {
+        case 'step':
+          _logger().default.progress(prefix(`[${message.data.current}/${message.data.total}] ${message.data.message}`));
+          return;
+        case 'success':
+        case 'info':
+          _logger().default.info({
+            origin: '@atlaspack/package-manager',
+            message: prefix(message.data)
+          });
+          return;
+        default:
+        // ignore
+      }
+    });
+
+    installProcess.stderr.pipe((0, _split().default)()).pipe(new _JSONParseStream.default()).on('error', e => {
+      _logger().default.error(e, '@atlaspack/package-manager');
+    }).on('data', message => {
+      switch (message.type) {
+        case 'warning':
+          _logger().default.warn({
+            origin: '@atlaspack/package-manager',
+            message: prefix(message.data)
+          });
+          return;
+        case 'error':
+          _logger().default.error({
+            origin: '@atlaspack/package-manager',
+            message: prefix(message.data)
+          });
+          return;
+        default:
+        // ignore
+      }
+    });
+
+    try {
+      return await (0, _promiseFromProcess.default)(installProcess);
+    } catch (e) {
+      throw new Error('Yarn failed to install modules:' + e.message);
+    }
+  }
+}
+exports.Yarn = Yarn;
+function prefix(message) {
+  return 'yarn: ' + message;
+}
+(0, _buildCache().registerSerializableClass)(`${_package.default.version}:Yarn`, Yarn);

package/lib/getCurrentPackageManager.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getCurrentPackageManager;
+function getCurrentPackageManager(userAgent = process.env.npm_config_user_agent) {
+  if (!userAgent) {
+    return undefined;
+  }
+  const pmSpec = userAgent.split(' ')[0];
+  const separatorPos = pmSpec.lastIndexOf('/');
+  const name = pmSpec.substring(0, separatorPos);
+  return {
+    name: name,
+    version: pmSpec.substring(separatorPos + 1)
+  };
+}