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

package/lib/installPackage.js

@@ -0,0 +1,222 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._addToInstallQueue = _addToInstallQueue;
+exports.installPackage = installPackage;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+  _semver = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _workers() {
+  const data = _interopRequireDefault(require("@atlaspack/workers"));
+  _workers = function () {
+    return data;
+  };
+  return data;
+}
+var _Npm = require("./Npm");
+var _Yarn = require("./Yarn");
+var _Pnpm = require("./Pnpm");
+var _utils2 = require("./utils");
+var _getCurrentPackageManager = _interopRequireDefault(require("./getCurrentPackageManager"));
+var _validateModuleSpecifier = _interopRequireDefault(require("./validateModuleSpecifier"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+async function install(fs, packageManager, modules, from, projectRoot, options = {}) {
+  let {
+    installPeers = true,
+    saveDev = true,
+    packageInstaller
+  } = options;
+  let moduleNames = modules.map(m => m.name).join(', ');
+  _logger().default.progress(`Installing ${moduleNames}...`);
+  let fromPkgPath = await (0, _utils().resolveConfig)(fs, from, ['package.json'], projectRoot);
+  let cwd = fromPkgPath ? _path().default.dirname(fromPkgPath) : fs.cwd();
+  if (!packageInstaller) {
+    packageInstaller = await determinePackageInstaller(fs, from, projectRoot);
+  }
+  try {
+    await packageInstaller.install({
+      modules,
+      saveDev,
+      cwd,
+      packagePath: fromPkgPath,
+      fs
+    });
+  } catch (err) {
+    throw new Error(`Failed to install ${moduleNames}: ${err.message}`);
+  }
+  if (installPeers) {
+    await Promise.all(modules.map(m => installPeerDependencies(fs, packageManager, m, from, projectRoot, options)));
+  }
+}
+async function installPeerDependencies(fs, packageManager, module, from, projectRoot, options) {
+  const {
+    resolved
+  } = await packageManager.resolve(module.name, from);
+  const modulePkg = (0, _nullthrows().default)(await (0, _utils().loadConfig)(fs, resolved, ['package.json'], projectRoot)).config;
+  const peers = modulePkg.peerDependencies || {};
+  let modules = [];
+  for (let [name, range] of Object.entries(peers)) {
+    (0, _assert().default)(typeof range === 'string');
+    let conflicts = await (0, _utils2.getConflictingLocalDependencies)(fs, name, from, projectRoot);
+    if (conflicts) {
+      let {
+        pkg
+      } = await packageManager.resolve(name, from);
+      (0, _assert().default)(pkg);
+      if (!_semver().default.satisfies(pkg.version, range)) {
+        throw new (_diagnostic().default)({
+          diagnostic: {
+            message: (0, _diagnostic().md)`Could not install the peer dependency "${name}" for "${module.name}", installed version ${pkg.version} is incompatible with ${range}`,
+            origin: '@atlaspack/package-manager',
+            codeFrames: [{
+              filePath: conflicts.filePath,
+              language: 'json',
+              code: conflicts.json,
+              codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(conflicts.json, conflicts.fields.map(field => ({
+                key: `/${field}/${(0, _diagnostic().encodeJSONKeyComponent)(name)}`,
+                type: 'key',
+                message: 'Found this conflicting local requirement.'
+              })))
+            }]
+          }
+        });
+      }
+      continue;
+    }
+    modules.push({
+      name,
+      range
+    });
+  }
+  if (modules.length) {
+    await install(fs, packageManager, modules, from, projectRoot, Object.assign({}, options, {
+      installPeers: false
+    }));
+  }
+}
+async function determinePackageInstaller(fs, filepath, projectRoot) {
+  var _getCurrentPackageMan;
+  let configFile = await (0, _utils().resolveConfig)(fs, filepath, ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock'], projectRoot);
+  let configName = configFile && _path().default.basename(configFile);
+
+  // Always use the package manager that seems to be used in the project,
+  // falling back to a different one wouldn't update the existing lockfile.
+  if (configName === 'package-lock.json') {
+    return new _Npm.Npm();
+  } else if (configName === 'pnpm-lock.yaml') {
+    return new _Pnpm.Pnpm();
+  } else if (configName === 'yarn.lock') {
+    return new _Yarn.Yarn();
+  }
+  let currentPackageManager = (_getCurrentPackageMan = (0, _getCurrentPackageManager.default)()) === null || _getCurrentPackageMan === void 0 ? void 0 : _getCurrentPackageMan.name;
+  if (currentPackageManager === 'npm') {
+    return new _Npm.Npm();
+  } else if (currentPackageManager === 'yarn') {
+    return new _Yarn.Yarn();
+  } else if (currentPackageManager === 'pnpm') {
+    return new _Pnpm.Pnpm();
+  }
+  if (await _Yarn.Yarn.exists()) {
+    return new _Yarn.Yarn();
+  } else if (await _Pnpm.Pnpm.exists()) {
+    return new _Pnpm.Pnpm();
+  } else {
+    return new _Npm.Npm();
+  }
+}
+let queue = new (_utils().PromiseQueue)({
+  maxConcurrent: 1
+});
+let modulesInstalling = new Set();
+
+// Exported so that it may be invoked from the worker api below.
+// Do not call this directly! This can result in concurrent package installations
+// across multiple instances of the package manager.
+function _addToInstallQueue(fs, packageManager, modules, filePath, projectRoot, options) {
+  modules = modules.map(request => ({
+    name: (0, _validateModuleSpecifier.default)(request.name),
+    range: request.range
+  }));
+
+  // Wrap PromiseQueue and track modules that are currently installing.
+  // If a request comes in for a module that is currently installing, don't bother
+  // enqueuing it.
+  let modulesToInstall = modules.filter(m => !modulesInstalling.has(getModuleRequestKey(m)));
+  if (modulesToInstall.length) {
+    for (let m of modulesToInstall) {
+      modulesInstalling.add(getModuleRequestKey(m));
+    }
+    queue.add(() => install(fs, packageManager, modulesToInstall, filePath, projectRoot, options).then(() => {
+      for (let m of modulesToInstall) {
+        modulesInstalling.delete(getModuleRequestKey(m));
+      }
+    }));
+  }
+  return queue.run();
+}
+function installPackage(fs, packageManager, modules, filePath, projectRoot, options) {
+  if (_workers().default.isWorker()) {
+    let workerApi = _workers().default.getWorkerApi();
+    // TODO this should really be `__filename` but without the rewriting.
+    let bundlePath = process.env.ATLASPACK_BUILD_ENV === 'production' && !process.env.ATLASPACK_SELF_BUILD ? _path().default.join(__dirname, '..', 'lib/index.js') : __filename;
+    return workerApi.callMaster({
+      location: bundlePath,
+      args: [fs, packageManager, modules, filePath, projectRoot, options],
+      method: '_addToInstallQueue'
+    });
+  }
+  return _addToInstallQueue(fs, packageManager, modules, filePath, projectRoot, options);
+}
+function getModuleRequestKey(moduleRequest) {
+  return [moduleRequest.name, moduleRequest.range].join('@');
+}

package/lib/nodejsConditions.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultNodejsConditions = void 0;
+exports.getConditionsFromEnv = getConditionsFromEnv;
+function _process() {
+  const data = _interopRequireDefault(require("process"));
+  _process = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// https://nodejs.org/api/packages.html#conditional-exports
+// TODO We don't support { "type": "module" }
+const defaultNodejsConditions = exports.defaultNodejsConditions = Object.freeze(['node-addons', 'node',
+// 'import',
+'require', 'module-sync', 'default']);
+let envConditions = undefined;
+
+/** @description Gets the export conditions from NODE_OPTIONS and node arguments */
+function getConditionsFromEnv() {
+  if (!envConditions) {
+    const conditions = [];
+    for (const arg of [..._process().default.execArgv, ...(_process().default.env.NODE_OPTIONS || '').split(' ')]) {
+      if (arg.startsWith('--conditions=')) {
+        conditions.push(arg.substring(13));
+      }
+    }
+    envConditions = Object.freeze([...conditions, ...defaultNodejsConditions]);
+  }
+  return envConditions;
+}

package/lib/promiseFromProcess.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = promiseFromProcess;
+function promiseFromProcess(childProcess) {
+  return new Promise((resolve, reject) => {
+    childProcess.on('error', reject);
+    childProcess.on('close', code => {
+      if (code !== 0) {
+        reject(new Error('Child process failed'));
+        return;
+      }
+      resolve();
+    });
+  });
+}

package/lib/utils.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.exec = void 0;
+exports.getConflictingLocalDependencies = getConflictingLocalDependencies;
+exports.moduleRequestsFromDependencyMap = moduleRequestsFromDependencyMap;
+exports.npmSpecifierFromModuleRequest = npmSpecifierFromModuleRequest;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _child_process() {
+  const data = require("child_process");
+  _child_process = function () {
+    return data;
+  };
+  return data;
+}
+function _util() {
+  const data = require("util");
+  _util = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const exec = exports.exec = _child_process().exec ? (0, _util().promisify)(_child_process().exec) :
+// _exec is undefined in browser builds
+_child_process().exec;
+function npmSpecifierFromModuleRequest(moduleRequest) {
+  return moduleRequest.range != null ? [moduleRequest.name, moduleRequest.range].join('@') : moduleRequest.name;
+}
+function moduleRequestsFromDependencyMap(dependencyMap) {
+  return Object.entries(dependencyMap).map(([name, range]) => {
+    (0, _assert().default)(typeof range === 'string');
+    return {
+      name,
+      range
+    };
+  });
+}
+async function getConflictingLocalDependencies(fs, name, local, projectRoot) {
+  let pkgPath = await (0, _utils().resolveConfig)(fs, local, ['package.json'], projectRoot);
+  if (pkgPath == null) {
+    return;
+  }
+  let pkgStr = await fs.readFile(pkgPath, 'utf8');
+  let pkg;
+  try {
+    pkg = JSON.parse(pkgStr);
+  } catch (e) {
+    // TODO: codeframe
+    throw new (_diagnostic().default)({
+      diagnostic: {
+        message: 'Failed to parse package.json',
+        origin: '@atlaspack/package-manager'
+      }
+    });
+  }
+  if (typeof pkg !== 'object' || pkg == null) {
+    // TODO: codeframe
+    throw new (_diagnostic().default)({
+      diagnostic: {
+        message: 'Expected package.json contents to be an object.',
+        origin: '@atlaspack/package-manager'
+      }
+    });
+  }
+  let fields = [];
+  for (let field of ['dependencies', 'devDependencies', 'peerDependencies']) {
+    if (typeof pkg[field] === 'object' && pkg[field] != null && pkg[field][name] != null) {
+      fields.push(field);
+    }
+  }
+  if (fields.length > 0) {
+    return {
+      filePath: pkgPath,
+      json: pkgStr,
+      fields
+    };
+  }
+}

package/lib/validateModuleSpecifier.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = validateModuleSpecifier;
+const MODULE_REGEX = /^((@[^/\s]+\/){0,1}([^/\s.~]+[^/\s]*)){1}(@[^/\s]+){0,1}/;
+function validateModuleSpecifier(moduleName) {
+  let matches = MODULE_REGEX.exec(moduleName);
+  if (matches) {
+    return matches[0];
+  }
+  return '';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/package-manager",
-  "version": "2.14.18-noselfbuild-3f2849b52.0",
+  "version": "2.14.18-noselfbuild-342bd6c75.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -39,21 +39,19 @@
     }
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.4-noselfbuild-3f2849b52.0",
-    "@atlaspack/diagnostic": "2.14.2-noselfbuild-3f2849b52.0",
-    "@atlaspack/fs": "2.15.13-noselfbuild-3f2849b52.0",
-    "@atlaspack/logger": "2.14.13-noselfbuild-3f2849b52.0",
-    "@atlaspack/node-resolver-core": "3.5.18-noselfbuild-3f2849b52.0",
-    "@atlaspack/types": "2.15.8-noselfbuild-3f2849b52.0",
-    "@atlaspack/utils": "2.16.2-noselfbuild-3f2849b52.0",
-    "@atlaspack/workers": "2.14.18-noselfbuild-3f2849b52.0",
+    "@atlaspack/build-cache": "2.13.4-noselfbuild-342bd6c75.0",
+    "@atlaspack/diagnostic": "2.14.2-noselfbuild-342bd6c75.0",
+    "@atlaspack/fs": "2.15.13-noselfbuild-342bd6c75.0",
+    "@atlaspack/logger": "2.14.13-noselfbuild-342bd6c75.0",
+    "@atlaspack/node-resolver-core": "3.5.18-noselfbuild-342bd6c75.0",
+    "@atlaspack/types": "2.15.8-noselfbuild-342bd6c75.0",
+    "@atlaspack/utils": "2.16.2-noselfbuild-342bd6c75.0",
+    "@atlaspack/workers": "2.14.18-noselfbuild-342bd6c75.0",
     "@swc/core": "^1.10.0",
-    "semver": "^7.5.2"
-  },
-  "devDependencies": {
     "command-exists": "^1.2.6",
     "cross-spawn": "^6.0.4",
     "nullthrows": "^1.1.1",
+    "semver": "^7.5.2",
     "split2": "^3.1.1"
   },
   "browser": {
@@ -63,5 +61,5 @@
     "./src/Yarn.js": false
   },
   "type": "commonjs",
-  "gitHead": "3f2849b52d0a62d716f1c6cb3a92656e1e4fa18a"
+  "gitHead": "342bd6c75293750e0f0a7636ddc8dfe30707efb6"
 }

package/src/NodePackageManager.js

@@ -41,14 +41,10 @@ import {transformSync} from '@swc/core';
 // Package.json fields. Must match package_json.rs.
 const MAIN = 1 << 0;
 const SOURCE = 1 << 2;
-const ENTRIES =
-  process.env.ATLASPACK_REGISTER_USE_LIB === 'true'
-    ? MAIN
-    : MAIN |
-      (process.env.ATLASPACK_BUILD_ENV !== 'production' ||
-      process.env.ATLASPACK_SELF_BUILD
-        ? SOURCE
-        : 0);
+let ENTRIES = MAIN;
+if (process.env.ATLASPACK_REGISTER_USE_SRC === 'true') {
+  ENTRIES |= SOURCE;
+}
 
 const NODE_MODULES = `${path.sep}node_modules${path.sep}`;
 

package/test/NodePackageManager.test.js

@@ -12,6 +12,7 @@ import {WORKER_PATH} from '@atlaspack/core';
 import {MockPackageInstaller, NodePackageManager} from '../src';
 
 const FIXTURES_DIR = path.join(__dirname, 'fixtures');
+const ROOT_DIR = path.normalize(path.join(__dirname, '..', '..', '..', '..'));
 
 function normalize(res) {
   return {
@@ -76,6 +77,7 @@ describe('NodePackageManager', function () {
         type: 1,
         invalidateOnFileChange: new Set([
           path.join(FIXTURES_DIR, 'has-foo/node_modules/foo/package.json'),
+          path.join(ROOT_DIR, 'tsconfig.json'),
         ]),
         invalidateOnFileCreate: [
           {
@@ -130,6 +132,7 @@ describe('NodePackageManager', function () {
         type: 1,
         invalidateOnFileChange: new Set([
           path.join(FIXTURES_DIR, 'has-foo/node_modules/a/package.json'),
+          path.join(ROOT_DIR, 'tsconfig.json'),
         ]),
         invalidateOnFileCreate: [
           {
@@ -302,6 +305,7 @@ describe('NodePackageManager', function () {
               FIXTURES_DIR,
               'has-foo/subpackage/node_modules/foo/package.json',
             ),
+            path.join(ROOT_DIR, 'tsconfig.json'),
           ]),
           invalidateOnFileCreate: [
             {