vsix-utils/dist/index.mjs

utilities for working with VSIX packages

export { createVsixManifest, getManifestTags, isWebKind, readProjectManifest, transformExtensionKind } from './chunk-B6LXV7ZN.mjs';
export { ALLOWED_SPONSOR_PROTOCOLS, EXTENSION_NAME_REGEX, EXTENSION_PRICING, GITHUB_BADGE_URL_REGEX, VALID_EXTENSION_KINDS, VSCODE_ENGINE_COMPATIBILITY_REGEX, validateProjectManifest, validateVSCodeTypesCompatability } from './chunk-EPPBUJGT.mjs';
export { readVsix, writeVsix } from './chunk-5EQ5A35C.mjs';
export { collect, getContentTypesForFiles, getExtensionPackageManager, inferBaseUrls, isInMemoryFile, isLocalFile, transformFiles, transformMarkdown } from './chunk-M7VDGRNO.mjs';
import './chunk-WRSU2XB2.mjs';
import { exec } from 'node:child_process';
import path, { isAbsolute, resolve, join } from 'node:path';
import process from 'node:process';
import { promisify } from 'node:util';

var execAsync = promisify(exec);
async function getExtensionDependencies(manifest, options) {
  const {
    packageManager,
    cwd = process.cwd()
  } = options;
  const dependencies = /* @__PURE__ */ new Set();
  if (packageManager === "npm") {
    const { stdout } = await execAsync("npm list --production --parseable --depth=99999 --loglevel=error", { cwd });
    const lines = stdout.split(/[\r\n]/).filter((path2) => isAbsolute(path2));
    for (const line of lines) {
      if (line === resolve(cwd)) {
        continue;
      }
      const dependency = line.split(`${path.sep}node_modules${path.sep}`)[1];
      if (dependency == null) {
        throw new Error(`could not parse dependency: ${line}`);
      }
      dependencies.add({
        name: dependency.replace(/\\/g, "/"),
        version: manifest.dependencies != null ? manifest.dependencies[dependency.replace(/\\/g, "/")] : undefined,
        path: line
      });
    }
  } else if (packageManager === "yarn") {
    let asYarnDependency2 = function(prefix, tree, prune2) {
      if (prune2 && /@[\^~]/.test(tree.name)) {
        return null;
      }
      let name;
      let version = "";
      try {
        const tmp = tree.name.split("@");
        if (tmp[0] === "") {
          tmp.shift();
          tmp[0] = `@${tmp[0]}`;
        }
        name = tmp[0];
        version = tmp[1] || "";
      } catch {
        name = tree.name.replace(/^([^@+])@.*$/, "$1");
      }
      const dependencyPath = path.join(prefix, name);
      const children = [];
      for (const child of tree.children || []) {
        const dep = asYarnDependency2(path.join(prefix, name, "node_modules"), child, prune2);
        if (dep) {
          children.push(dep);
        }
      }
      return { name, path: dependencyPath, children, version };
    };
    const { stdout } = await execAsync("yarn list --prod --json", { cwd });
    const match = /^\{"type":"tree".*$/m.exec(stdout);
    if (!match || match.length !== 1) {
      throw new Error("Could not parse result of `yarn list --json`");
    }
    const trees = JSON.parse(match[0]).data.trees;
    if (!Array.isArray(trees) || trees.length === 0) {
      return [];
    }
    const prune = true;
    const result = trees.map((tree) => asYarnDependency2(join(cwd, "node_modules"), tree, prune)).filter((dep) => dep != null);
    const internalDeps = /* @__PURE__ */ new Set();
    const flatten = (dep) => {
      if (internalDeps.has(dep.path)) {
        return;
      }
      dependencies.add({
        name: dep.name,
        version: dep.version,
        path: dep.path
      });
      internalDeps.add(dep.path);
      if (dep.children) {
        for (const child of dep.children) {
          flatten(child);
        }
      }
    };
    for (const dep of result) {
      flatten(dep);
    }
  } else if (packageManager === "pnpm") {
    const { stdout } = await execAsync("pnpm list --production --json --depth=99999 --loglevel=error --ignore-workspace", { cwd });
    let entryList = [];
    try {
      entryList = JSON.parse(stdout);
    } catch {
      return [];
    }
    if (!Array.isArray(entryList) || entryList.length === 0) {
      return [];
    }
    const entry = entryList[0];
    if (entry == null || typeof entry !== "object" || entry.dependencies == null || typeof entry.dependencies !== "object") {
      return [];
    }
    const internalDeps = /* @__PURE__ */ new Set();
    const flatten = (dep) => {
      if (internalDeps.has(dep.path)) {
        return;
      }
      dependencies.add({
        name: dep.from,
        version: dep.version,
        path: dep.path
      });
      internalDeps.add(dep.path);
      if (dep.dependencies) {
        for (const child of Object.values(dep.dependencies)) {
          flatten(child);
        }
      }
    };
    for (const value of Object.values(entry.dependencies)) {
      flatten(value);
    }
  } else {
    throw new Error(`unsupported package manager: ${packageManager}`);
  }
  return Array.from(dependencies);
}
async function prepublish(options) {
  const { cwd, packageManager, manifest, preRelease } = options;
  if (!manifest.scripts) {
    return;
  }
  const scripts = [];
  if ("vscode:prepublish" in manifest.scripts) {
    scripts.push("vscode:prepublish");
  }
  if ("vscode:prepublish:release" in manifest.scripts && !preRelease) {
    scripts.push("vscode:prepublish:release");
  }
  if ("vscode:prepublish:prerelease" in manifest.scripts && preRelease) {
    scripts.push("vscode:prepublish:prerelease");
  }
  if (scripts.length === 0) {
    return;
  }
  const results = await Promise.all(
    scripts.map((script) => runScript({ cwd, packageManager, script }))
  );
  if (results.some((result) => !result)) {
    throw new Error("failed to run one or more scripts");
  }
}
async function runScript(options) {
  const { cwd, packageManager, script } = options;
  try {
    const { stderr } = await new Promise((resolve2, reject) => {
      exec(`${packageManager} run ${script}`, { cwd }, (err, stdout, stderr2) => {
        if (err) {
          reject(err);
        } else {
          resolve2({ stdout, stderr: stderr2 });
        }
      });
    });
    if (stderr.trim() !== "") {
      return false;
    }
    return true;
  } catch {
    return false;
  }
}

export { getExtensionDependencies, prepublish };