@atlaspack/package-manager 2.14.18-noselfbuild-63bde801d.0 → 2.14.18-typescript-e769947a5.0

package/lib/NodePackageManager.js

@@ -1,582 +0,0 @@
-"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

@@ -1,105 +0,0 @@
-"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);