op-pkg/dist/index.cjs

operating package

'use strict';

const fs = require('node:fs');
const node_path = require('node:path');
const process = require('node:process');
const tinyexec = require('tinyexec');
const detect = require('package-manager-detector/detect');
const fsp = require('node:fs/promises');
const node_module = require('node:module');
const findUp = require('find-up');
const mlly = require('mlly');

var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }

const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
const process__default = /*#__PURE__*/_interopDefaultCompat(process);
const fsp__default = /*#__PURE__*/_interopDefaultCompat(fsp);

async function detectPackageManager(cwd = process__default.cwd()) {
  const result = await detect.detect({
    cwd,
    onUnknown(packageManager) {
      console.warn("[op-pkg] Unknown packageManager:", packageManager);
      return void 0;
    }
  });
  return result?.agent || null;
}

async function installPackage(names, options = {}) {
  const detectedAgent = options.packageManager || await detectPackageManager(options.cwd) || "npm";
  const [agent] = detectedAgent.split("@");
  if (!Array.isArray(names))
    names = [names];
  const args = (typeof options.additionalArgs === "function" ? options.additionalArgs(agent, detectedAgent) : options.additionalArgs) || [];
  if (options.preferOffline) {
    if (detectedAgent === "yarn@berry")
      args.unshift("--cached");
    else
      args.unshift("--prefer-offline");
  }
  if (agent === "pnpm" && fs.existsSync(node_path.resolve(options.cwd ?? process__default.cwd(), "pnpm-workspace.yaml"))) {
    args.unshift(
      "-w",
      /**
       * Prevent pnpm from removing installed devDeps while `NODE_ENV` is `production`
       * @see https://pnpm.io/cli/install#--prod--p
       */
      "--prod=false"
    );
  }
  return tinyexec.x(
    agent,
    [
      agent === "yarn" ? "add" : "install",
      options.dev ? "-D" : "",
      ...args,
      ...names
    ].filter(Boolean),
    {
      nodeOptions: {
        stdio: options.silent ? "ignore" : "inherit",
        cwd: options.cwd
      },
      throwOnError: true
    }
  );
}

function _resolve(path, options = {}) {
  if (options.platform === "auto" || !options.platform)
    options.platform = process__default.platform === "win32" ? "win32" : "posix";
  if (process__default.versions.pnp) {
    const paths = options.paths || [];
    if (paths.length === 0)
      paths.push(process__default.cwd());
    const targetRequire = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
    try {
      return targetRequire.resolve(path, { paths });
    } catch {
    }
  }
  const modulePath = mlly.resolvePathSync(path, {
    url: options.paths
  });
  if (options.platform === "win32")
    return node_path.win32.normalize(modulePath);
  return modulePath;
}
function resolveModule(name, options = {}) {
  try {
    return _resolve(name, options);
  } catch {
    return void 0;
  }
}
async function importModule(path) {
  const i = await import(path);
  if (i)
    return mlly.interopDefault(i);
  return i;
}
function isPackageExists(name, options = {}) {
  return !!resolvePackage(name, options);
}
async function getPackageInfo(name, options = {}) {
  const packageJsonPath = getPackageJsonPath(name, options);
  if (!packageJsonPath)
    return;
  const packageJson = JSON.parse(await fs__default.promises.readFile(packageJsonPath, "utf8"));
  return {
    name,
    version: packageJson.version,
    rootPath: node_path.dirname(packageJsonPath),
    packageJsonPath,
    packageJson
  };
}
async function loadPackageJSON(cwd = process__default.cwd()) {
  const path = await findUp.findUp("package.json", { cwd });
  if (!path || !fs__default.existsSync(path))
    return null;
  return JSON.parse(await fsp__default.readFile(path, "utf-8"));
}
function getPackageJsonPath(name, options = {}) {
  const entry = resolvePackage(name, options);
  if (!entry)
    return;
  return searchPackageJSON(entry);
}
function searchPackageJSON(dir) {
  let packageJsonPath;
  while (true) {
    if (!dir)
      return;
    const newDir = node_path.dirname(dir);
    if (newDir === dir)
      return;
    dir = newDir;
    packageJsonPath = node_path.join(dir, "package.json");
    if (fs__default.existsSync(packageJsonPath))
      break;
  }
  return packageJsonPath;
}
function resolvePackage(name, options = {}) {
  try {
    return _resolve(`${name}/package.json`, options);
  } catch {
  }
  try {
    return _resolve(name, options);
  } catch (e) {
    if (e.code !== "MODULE_NOT_FOUND" && e.code !== "ERR_MODULE_NOT_FOUND")
      console.error(e);
    return false;
  }
}

exports.detectPackageManager = detectPackageManager;
exports.getPackageInfo = getPackageInfo;
exports.importModule = importModule;
exports.installPackage = installPackage;
exports.isPackageExists = isPackageExists;
exports.loadPackageJSON = loadPackageJSON;
exports.resolveModule = resolveModule;