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

package/lib/NodePackageManager.js

@@ -0,0 +1,582 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NodePackageManager = void 0;
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _fs() {
+  const data = require("@atlaspack/fs");
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _fs2() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs2 = function () {
+    return data;
+  };
+  return data;
+}
+function _module() {
+  const data = _interopRequireDefault(require("module"));
+  _module = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+  _semver = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+var _utils2 = require("./utils");
+var _installPackage = require("./installPackage");
+var _package = _interopRequireDefault(require("../package.json"));
+var _nodejsConditions = require("./nodejsConditions");
+function _nodeResolverCore() {
+  const data = require("@atlaspack/node-resolver-core");
+  _nodeResolverCore = function () {
+    return data;
+  };
+  return data;
+}
+function _url() {
+  const data = require("url");
+  _url = function () {
+    return data;
+  };
+  return data;
+}
+function _core() {
+  const data = require("@swc/core");
+  _core = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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; }
+// Package.json fields. Must match package_json.rs.
+const MAIN = 1 << 0;
+const SOURCE = 1 << 2;
+let ENTRIES = MAIN;
+if (process.env.ATLASPACK_REGISTER_USE_SRC === 'true') {
+  ENTRIES |= SOURCE;
+}
+const NODE_MODULES = `${_path().default.sep}node_modules${_path().default.sep}`;
+
+// There can be more than one instance of NodePackageManager, but node has only a single module cache.
+// Therefore, the resolution cache and the map of parent to child modules should also be global.
+const cache = new Map();
+const children = new Map();
+const invalidationsCache = new Map();
+
+// This implements a package manager for Node by monkey patching the Node require
+// algorithm so that it uses the specified FileSystem instead of the native one.
+// It also handles installing packages when they are required if not already installed.
+// See https://github.com/nodejs/node/blob/master/lib/internal/modules/cjs/loader.js
+// for reference to Node internals.
+class NodePackageManager {
+  constructor(fs, projectRoot, installer) {
+    this.fs = fs;
+    this.projectRoot = projectRoot;
+    this.installer = installer;
+
+    // $FlowFixMe - no type for _extensions
+    this.currentExtensions = Object.keys(_module().default._extensions).map(e => e.substring(1));
+  }
+  _createResolver() {
+    return new (_nodeResolverCore().ResolverBase)(this.projectRoot, {
+      fs: this.fs instanceof _fs().NodeFS && process.versions.pnp == null ? undefined : {
+        canonicalize: path => this.fs.realpathSync(path),
+        read: path => this.fs.readFileSync(path),
+        isFile: path => this.fs.statSync(path).isFile(),
+        isDir: path => this.fs.statSync(path).isDirectory()
+      },
+      mode: 2,
+      entries: ENTRIES,
+      packageExports: true,
+      moduleDirResolver: process.versions.pnp != null ? (module, from) => {
+        // $FlowFixMe[prop-missing]
+        let pnp = _module().default.findPnpApi(_path().default.dirname(from));
+        return pnp.resolveToUnqualified(
+        // append slash to force loading builtins from npm
+        module + '/', from);
+      } : undefined,
+      extensions: this.currentExtensions,
+      typescript: true
+    });
+  }
+  static deserialize(opts) {
+    return new NodePackageManager(opts.fs, opts.projectRoot, opts.installer);
+  }
+  serialize() {
+    return {
+      $$raw: false,
+      fs: this.fs,
+      projectRoot: this.projectRoot,
+      installer: this.installer
+    };
+  }
+  async require(name, from, opts) {
+    let {
+      resolved,
+      type
+    } = await this.resolve(name, from, opts);
+    if (type === 2) {
+      _logger().default.warn({
+        message: 'ES module dependencies are experimental.',
+        origin: '@atlaspack/package-manager',
+        codeFrames: [{
+          filePath: resolved,
+          codeHighlights: []
+        }]
+      });
+
+      // On Windows, Node requires absolute paths to be file URLs.
+      if (process.platform === 'win32' && _path().default.isAbsolute(resolved)) {
+        resolved = (0, _url().pathToFileURL)(resolved);
+      }
+
+      // $FlowFixMe
+      return import(resolved);
+    }
+    return this.load(resolved, from);
+  }
+  requireSync(name, from) {
+    let {
+      resolved
+    } = this.resolveSync(name, from);
+    return this.load(resolved, from);
+  }
+  load(filePath, from) {
+    if (!_path().default.isAbsolute(filePath)) {
+      // Node builtin module
+      // $FlowFixMe
+      return require(filePath);
+    }
+
+    // $FlowFixMe[prop-missing]
+    const cachedModule = _module().default._cache[filePath];
+    if (cachedModule !== undefined) {
+      return cachedModule.exports;
+    }
+
+    // $FlowFixMe
+    let m = new (_module().default)(filePath, _module().default._cache[from] || module.parent);
+
+    // $FlowFixMe _extensions not in type
+    const extensions = Object.keys(_module().default._extensions);
+    // This handles supported extensions changing due to, for example, esbuild/register being used
+    // We assume that the extension list will change in size - as these tools usually add support for
+    // additional extensions.
+    if (extensions.length !== this.currentExtensions.length) {
+      this.currentExtensions = extensions.map(e => e.substring(1));
+      this.resolver = this._createResolver();
+    }
+
+    // $FlowFixMe[prop-missing]
+    _module().default._cache[filePath] = m;
+
+    // Patch require within this module so it goes through our require
+    m.require = id => {
+      return this.requireSync(id, filePath);
+    };
+
+    // Patch `fs.readFileSync` temporarily so that it goes through our file system
+    let {
+      readFileSync,
+      statSync
+    } = _fs2().default;
+    // $FlowFixMe
+    _fs2().default.readFileSync = (filename, encoding) => {
+      return this.fs.readFileSync(filename, encoding);
+    };
+
+    // $FlowFixMe
+    _fs2().default.statSync = filename => {
+      return this.fs.statSync(filename);
+    };
+    if (!filePath.includes(NODE_MODULES)) {
+      let extname = _path().default.extname(filePath);
+      if ((extname === '.ts' || extname === '.tsx' || extname === '.mts' || extname === '.cts') &&
+      // $FlowFixMe
+      !_module().default._extensions[extname]) {
+        let compile = m._compile;
+        m._compile = (code, filename) => {
+          let out = (0, _core().transformSync)(code, {
+            filename,
+            module: {
+              type: 'commonjs'
+            }
+          });
+          compile.call(m, out.code, filename);
+        };
+
+        // $FlowFixMe
+        _module().default._extensions[extname] = (m, filename) => {
+          // $FlowFixMe
+          delete _module().default._extensions[extname];
+          // $FlowFixMe
+          _module().default._extensions['.js'](m, filename);
+        };
+      }
+    }
+    try {
+      m.load(filePath);
+    } catch (err) {
+      // $FlowFixMe[prop-missing]
+      delete _module().default._cache[filePath];
+      throw err;
+    } finally {
+      // $FlowFixMe
+      _fs2().default.readFileSync = readFileSync;
+      // $FlowFixMe
+      _fs2().default.statSync = statSync;
+    }
+    return m.exports;
+  }
+  async resolve(id, from, options) {
+    let basedir = _path().default.dirname(from);
+    let key = basedir + ':' + id;
+    let resolved = cache.get(key);
+    if (!resolved) {
+      let [name] = (0, _utils().getModuleParts)(id);
+      try {
+        resolved = this.resolveInternal(id, from);
+      } catch (e) {
+        if (e.code !== 'MODULE_NOT_FOUND' || (options === null || options === void 0 ? void 0 : options.shouldAutoInstall) !== true || id.startsWith('.') // a local file, don't autoinstall
+        ) {
+          if (e.code === 'MODULE_NOT_FOUND' && (options === null || options === void 0 ? void 0 : options.shouldAutoInstall) !== true) {
+            let err = new (_diagnostic().default)({
+              diagnostic: {
+                message: (0, _diagnostic().escapeMarkdown)(e.message),
+                hints: ['Autoinstall is disabled, please install this package manually and restart Parcel.']
+              }
+            });
+            // $FlowFixMe - needed for loadParcelPlugin
+            err.code = 'MODULE_NOT_FOUND';
+            throw err;
+          } else {
+            throw e;
+          }
+        }
+        let conflicts = await (0, _utils2.getConflictingLocalDependencies)(this.fs, name, from, this.projectRoot);
+        if (conflicts == null) {
+          this.invalidate(id, from);
+          await this.install([{
+            name,
+            range: options === null || options === void 0 ? void 0 : options.range
+          }], from, {
+            saveDev: (options === null || options === void 0 ? void 0 : options.saveDev) ?? true
+          });
+          return this.resolve(id, from, {
+            ...options,
+            shouldAutoInstall: false
+          });
+        }
+        throw new (_diagnostic().default)({
+          diagnostic: conflicts.fields.map(field => ({
+            message: (0, _diagnostic().md)`Could not find module "${name}", but it was listed in package.json. Run your package manager first.`,
+            origin: '@atlaspack/package-manager',
+            codeFrames: [{
+              filePath: conflicts.filePath,
+              language: 'json',
+              code: conflicts.json,
+              codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(conflicts.json, [{
+                key: `/${field}/${(0, _diagnostic().encodeJSONKeyComponent)(name)}`,
+                type: 'key',
+                message: 'Defined here, but not installed'
+              }])
+            }]
+          }))
+        });
+      }
+      let range = options === null || options === void 0 ? void 0 : options.range;
+      if (range != null) {
+        let pkg = resolved.pkg;
+        if (pkg == null || !_semver().default.satisfies(pkg.version, range)) {
+          let conflicts = await (0, _utils2.getConflictingLocalDependencies)(this.fs, name, from, this.projectRoot);
+          if (conflicts == null && (options === null || options === void 0 ? void 0 : options.shouldAutoInstall) === true) {
+            this.invalidate(id, from);
+            await this.install([{
+              name,
+              range
+            }], from);
+            return this.resolve(id, from, {
+              ...options,
+              shouldAutoInstall: false
+            });
+          } else if (conflicts != null) {
+            throw new (_diagnostic().default)({
+              diagnostic: {
+                message: (0, _diagnostic().md)`Could not find module "${name}" satisfying ${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.'
+                  })))
+                }]
+              }
+            });
+          }
+          let version = pkg === null || pkg === void 0 ? void 0 : pkg.version;
+          let message = (0, _diagnostic().md)`Could not resolve package "${name}" that satisfies ${range}.`;
+          if (version != null) {
+            message += (0, _diagnostic().md)` Found ${version}.`;
+          }
+          throw new (_diagnostic().default)({
+            diagnostic: {
+              message,
+              hints: ['Looks like the incompatible version was installed transitively. Add this package as a direct dependency with a compatible version range.']
+            }
+          });
+        }
+      }
+      cache.set(key, resolved);
+      invalidationsCache.clear();
+
+      // Add the specifier as a child to the parent module.
+      // Don't do this if the specifier was an absolute path, as this was likely a dynamically resolved path
+      // (e.g. babel uses require() to load .babelrc.js configs and we don't want them to be added  as children of babel itself).
+      if (!_path().default.isAbsolute(name)) {
+        let moduleChildren = children.get(from);
+        if (!moduleChildren) {
+          moduleChildren = new Set();
+          children.set(from, moduleChildren);
+        }
+        moduleChildren.add(name);
+      }
+    }
+    return resolved;
+  }
+  resolveSync(name, from) {
+    let basedir = _path().default.dirname(from);
+    let key = basedir + ':' + name;
+    let resolved = cache.get(key);
+    if (!resolved) {
+      resolved = this.resolveInternal(name, from);
+      cache.set(key, resolved);
+      invalidationsCache.clear();
+      if (!_path().default.isAbsolute(name)) {
+        let moduleChildren = children.get(from);
+        if (!moduleChildren) {
+          moduleChildren = new Set();
+          children.set(from, moduleChildren);
+        }
+        moduleChildren.add(name);
+      }
+    }
+    return resolved;
+  }
+  async install(modules, from, opts) {
+    await (0, _installPackage.installPackage)(this.fs, this, modules, from, this.projectRoot, {
+      packageInstaller: this.installer,
+      ...opts
+    });
+  }
+  getInvalidations(name, from) {
+    let basedir = _path().default.dirname(from);
+    let cacheKey = basedir + ':' + name;
+    let resolved = cache.get(cacheKey);
+    if (resolved && _path().default.isAbsolute(resolved.resolved)) {
+      let cached = invalidationsCache.get(resolved.resolved);
+      if (cached != null) {
+        return cached;
+      }
+      let res = {
+        invalidateOnFileCreate: [],
+        invalidateOnFileChange: new Set(),
+        invalidateOnStartup: false
+      };
+      let seen = new Set();
+      let addKey = (name, from) => {
+        let basedir = _path().default.dirname(from);
+        let key = basedir + ':' + name;
+        if (seen.has(key)) {
+          return;
+        }
+        seen.add(key);
+        let resolved = cache.get(key);
+        if (!resolved || !_path().default.isAbsolute(resolved.resolved)) {
+          return;
+        }
+        res.invalidateOnFileCreate.push(...resolved.invalidateOnFileCreate);
+        res.invalidateOnFileChange.add(resolved.resolved);
+        for (let file of resolved.invalidateOnFileChange) {
+          res.invalidateOnFileChange.add(file);
+        }
+        let moduleChildren = children.get(resolved.resolved);
+        if (moduleChildren) {
+          for (let specifier of moduleChildren) {
+            addKey(specifier, resolved.resolved);
+          }
+        }
+      };
+      addKey(name, from);
+
+      // If this is an ES module, we won't have any of the dependencies because import statements
+      // cannot be intercepted. Instead, ask the resolver to parse the file and recursively analyze the deps.
+      if (resolved.type === 2) {
+        let invalidations = this.resolver.getInvalidations(resolved.resolved);
+        invalidations.invalidateOnFileChange.forEach(i => res.invalidateOnFileChange.add(i));
+        invalidations.invalidateOnFileCreate.forEach(i => res.invalidateOnFileCreate.push(i));
+        res.invalidateOnStartup ||= invalidations.invalidateOnStartup;
+        if (res.invalidateOnStartup) {
+          _logger().default.warn({
+            message: (0, _diagnostic().md)`${_path().default.relative(this.projectRoot, resolved.resolved)} contains non-statically analyzable dependencies in its module graph. This causes Parcel to invalidate the cache on startup.`,
+            origin: '@atlaspack/package-manager'
+          });
+        }
+      }
+      invalidationsCache.set(resolved.resolved, res);
+      return res;
+    }
+    return {
+      invalidateOnFileCreate: [],
+      invalidateOnFileChange: new Set(),
+      invalidateOnStartup: false
+    };
+  }
+  invalidate(name, from) {
+    let seen = new Set();
+    let invalidate = (name, from) => {
+      let basedir = _path().default.dirname(from);
+      let key = basedir + ':' + name;
+      if (seen.has(key)) {
+        return;
+      }
+      seen.add(key);
+      let resolved = cache.get(key);
+      if (!resolved || !_path().default.isAbsolute(resolved.resolved)) {
+        return;
+      }
+
+      // During testing don't invalidate Atlaspack modules because
+      // this causes failures due to multiple instances of the same module
+      // existing simultaniously. This is fine when using babe;-register because
+      // it has an internal module cache that NodePacakageManager does not invalidate
+      // but fails when using compiled Atlaspack packages in integration tests
+      if (process.env.ATLASPACK_BUILD_ENV === 'test' && name.startsWith('@atlaspack/')) {
+        return;
+      }
+      invalidationsCache.delete(resolved.resolved);
+
+      // $FlowFixMe
+      let module = _module().default._cache[resolved.resolved];
+      if (module) {
+        // $FlowFixMe
+        delete _module().default._cache[resolved.resolved];
+      }
+      let moduleChildren = children.get(resolved.resolved);
+      if (moduleChildren) {
+        for (let specifier of moduleChildren) {
+          invalidate(specifier, resolved.resolved);
+        }
+      }
+      children.delete(resolved.resolved);
+      cache.delete(key);
+    };
+    invalidate(name, from);
+    this.resolver = this._createResolver();
+  }
+  resolveInternal(name, from) {
+    if (this.resolver == null) {
+      this.resolver = this._createResolver();
+    }
+    let res = this.resolver.resolve({
+      filename: name,
+      specifierType: 'commonjs',
+      parent: from,
+      packageConditions: (0, _nodejsConditions.getConditionsFromEnv)()
+    });
+
+    // Invalidate whenever the .pnp.js file changes.
+    // TODO: only when we actually resolve a node_modules package?
+    if (process.versions.pnp != null && res.invalidateOnFileChange) {
+      // $FlowFixMe[prop-missing]
+      let pnp = _module().default.findPnpApi(_path().default.dirname(from));
+      res.invalidateOnFileChange.push(pnp.resolveToUnqualified('pnpapi', null));
+    }
+    if (res.error) {
+      let e = new Error(`Could not resolve module "${name}" from "${from}"`);
+      // $FlowFixMe
+      e.code = 'MODULE_NOT_FOUND';
+      throw e;
+    }
+    let getPkg;
+    switch (res.resolution.type) {
+      case 'Path':
+        getPkg = () => {
+          let pkgPath = this.fs.findAncestorFile(['package.json'], (0, _nullthrows().default)(res.resolution.value), this.projectRoot);
+          return pkgPath ? JSON.parse(this.fs.readFileSync(pkgPath, 'utf8')) : null;
+        };
+      // fallthrough
+      case 'Builtin':
+        return {
+          resolved: res.resolution.value,
+          invalidateOnFileChange: new Set(res.invalidateOnFileChange),
+          invalidateOnFileCreate: res.invalidateOnFileCreate,
+          type: res.moduleType,
+          get pkg() {
+            return getPkg();
+          }
+        };
+      default:
+        throw new Error('Unknown resolution type');
+    }
+  }
+}
+exports.NodePackageManager = NodePackageManager;
+(0, _buildCache().registerSerializableClass)(`${_package.default.version}:NodePackageManager`, NodePackageManager);

package/lib/Npm.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Npm = void 0;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _crossSpawn() {
+  const data = _interopRequireDefault(require("cross-spawn"));
+  _crossSpawn = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
+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 NPM_CMD = 'npm';
+class Npm {
+  async install({
+    modules,
+    cwd,
+    fs,
+    packagePath,
+    saveDev = true
+  }) {
+    // npm doesn't auto-create a package.json when installing,
+    // so create an empty one if needed.
+    if (packagePath == null) {
+      await fs.writeFile(_path().default.join(cwd, 'package.json'), '{}');
+    }
+    let args = ['install', '--json', saveDev ? '--save-dev' : '--save'].concat(modules.map(_utils.npmSpecifierFromModuleRequest));
+
+    // When Parcel is run by npm (e.g. via package.json scripts), several environment variables are
+    // added. When parcel in turn calls npm again, these can cause npm to behave stragely, so we
+    // filter them out when installing packages.
+    let env = {};
+    for (let key in process.env) {
+      if (!key.startsWith('npm_') && key !== 'INIT_CWD' && key !== 'NODE_ENV') {
+        env[key] = process.env[key];
+      }
+    }
+    let installProcess = (0, _crossSpawn().default)(NPM_CMD, args, {
+      cwd,
+      env
+    });
+    let stdout = '';
+    installProcess.stdout.on('data', buf => {
+      stdout += buf.toString();
+    });
+    let stderr = [];
+    installProcess.stderr.on('data', buf => {
+      stderr.push(buf.toString().trim());
+    });
+    try {
+      await (0, _promiseFromProcess.default)(installProcess);
+      let results = JSON.parse(stdout);
+      let addedCount = results.added.length;
+      if (addedCount > 0) {
+        _logger().default.log({
+          origin: '@atlaspack/package-manager',
+          message: `Added ${addedCount} packages via npm`
+        });
+      }
+
+      // 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) {
+        if (message.length > 0) {
+          _logger().default.log({
+            origin: '@atlaspack/package-manager',
+            message
+          });
+        }
+      }
+    } catch (e) {
+      throw new Error('npm failed to install modules: ' + e.message + ' - ' + stderr.join('\n'));
+    }
+  }
+}
+exports.Npm = Npm;
+(0, _buildCache().registerSerializableClass)(`${_package.default.version}:Npm`, Npm);