@ohos-ports/nx 19.8.4-beta.0 → 23.2.0-beta.0

package/dist/src/utils/package-json.js

@@ -0,0 +1,387 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePackageGroup = normalizePackageGroup;
+exports.readNxMigrateConfig = readNxMigrateConfig;
+exports.buildTargetFromScript = buildTargetFromScript;
+exports.getMetadataFromPackageJson = getMetadataFromPackageJson;
+exports.getTagsFromPackageJson = getTagsFromPackageJson;
+exports.readTargetsFromPackageJson = readTargetsFromPackageJson;
+exports.readModulePackageJsonWithoutFallbacks = readModulePackageJsonWithoutFallbacks;
+exports.readModulePackageJson = readModulePackageJson;
+exports.installPackageToTmp = installPackageToTmp;
+exports.installPackageToTmpAsync = installPackageToTmpAsync;
+exports.getDependencyVersionFromPackageJson = getDependencyVersionFromPackageJson;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const tmp_1 = require("tmp");
+const json_1 = require("../generators/utils/json");
+const project_configuration_utils_1 = require("../project-graph/utils/project-configuration-utils");
+const target_merging_1 = require("../project-graph/utils/project-configuration/target-merging");
+const catalog_1 = require("./catalog");
+const fileutils_1 = require("./fileutils");
+const has_nx_js_plugin_1 = require("./has-nx-js-plugin");
+const installation_directory_1 = require("./installation-directory");
+const package_manager_1 = require("./package-manager");
+const workspace_root_1 = require("./workspace-root");
+function normalizePackageGroup(packageGroup) {
+    return Array.isArray(packageGroup)
+        ? packageGroup.map((x) => typeof x === 'string' ? { package: x, version: '*' } : x)
+        : Object.entries(packageGroup).map(([pkg, version]) => ({
+            package: pkg,
+            version,
+        }));
+}
+function readNxMigrateConfig(json) {
+    const parseNxMigrationsConfig = (fromJson) => {
+        if (!fromJson) {
+            return {};
+        }
+        if (typeof fromJson === 'string') {
+            return { migrations: fromJson, packageGroup: [] };
+        }
+        return {
+            ...(fromJson.migrations ? { migrations: fromJson.migrations } : {}),
+            ...(fromJson.packageGroup
+                ? { packageGroup: normalizePackageGroup(fromJson.packageGroup) }
+                : {}),
+            ...(fromJson.supportsOptionalMigrations
+                ? { supportsOptionalMigrations: true }
+                : {}),
+        };
+    };
+    return {
+        ...parseNxMigrationsConfig(json['ng-update']),
+        ...parseNxMigrationsConfig(json['nx-migrations']),
+        // In case there's a `migrations` field in `package.json`
+        ...parseNxMigrationsConfig(json),
+    };
+}
+function buildTargetFromScript(script, scripts = {}, packageManagerCommand) {
+    return {
+        executor: 'nx:run-script',
+        options: {
+            script,
+        },
+        metadata: {
+            scriptContent: scripts[script],
+            runCommand: packageManagerCommand.run(script),
+        },
+    };
+}
+function getMetadataFromPackageJson(packageJson, isInPackageManagerWorkspaces) {
+    const { scripts, nx, description, name, exports, main, version } = packageJson;
+    const includedScripts = nx?.includedScripts || Object.keys(scripts ?? {});
+    const metadata = {
+        targetGroups: includedScripts.length
+            ? {
+                'NPM Scripts': includedScripts,
+            }
+            : {},
+        description,
+        js: {
+            packageName: name,
+            packageVersion: version,
+            packageExports: exports,
+            packageMain: main,
+            isInPackageManagerWorkspaces,
+        },
+    };
+    return metadata;
+}
+function getTagsFromPackageJson(packageJson) {
+    const tags = packageJson.private ? ['npm:private'] : ['npm:public'];
+    if (packageJson.keywords?.length) {
+        tags.push(...packageJson.keywords.map((k) => `npm:${k}`));
+    }
+    if (packageJson?.nx?.tags?.length) {
+        tags.push(...packageJson?.nx.tags);
+    }
+    return tags;
+}
+function readTargetsFromPackageJson(packageJson, nxJson, projectRoot, workspaceRoot, packageManagerCommand) {
+    const { scripts, nx, private: isPrivate } = packageJson ?? {};
+    const res = {};
+    const includedScripts = nx?.includedScripts || Object.keys(scripts ?? {});
+    for (const script of includedScripts) {
+        res[script] = buildTargetFromScript(script, scripts, packageManagerCommand);
+    }
+    for (const targetName in nx?.targets) {
+        const nxTarget = nx.targets[targetName];
+        // If the nx target specifies how to run (via executor or command shorthand),
+        // it's incompatible with the inferred nx:run-script target from scripts,
+        // so overwrite instead of merge.
+        if (res[targetName] && (nxTarget.executor || nxTarget.command)) {
+            res[targetName] = nxTarget;
+        }
+        else {
+            res[targetName] = (0, target_merging_1.mergeTargetConfigurations)(nxTarget, res[targetName]);
+        }
+    }
+    /**
+     * Add implicit nx-release-publish target for all package.json files that are
+     * not marked as `"private": true` to allow for lightweight configuration for
+     * package based repos.
+     *
+     * Any targetDefaults for the nx-release-publish target set by the user should
+     * be merged with the implicit target.
+     */
+    if (!isPrivate &&
+        !res['nx-release-publish'] &&
+        (0, has_nx_js_plugin_1.hasNxJsPlugin)(projectRoot, workspaceRoot)) {
+        // No project/plugin context here, so only catch-all entries of a
+        // `targetDefaults` value apply (the reader resolves both the object and
+        // array value forms).
+        const nxReleasePublishTargetDefaults = (0, project_configuration_utils_1.readTargetDefaultsForTarget)('nx-release-publish', nxJson?.targetDefaults, '@nx/js:release-publish') ?? {};
+        res['nx-release-publish'] = {
+            executor: '@nx/js:release-publish',
+            ...nxReleasePublishTargetDefaults,
+            dependsOn: [
+                // For maximum correctness, projects should only ever be published once their dependencies are successfully published
+                '^nx-release-publish',
+                ...(nxReleasePublishTargetDefaults.dependsOn ?? []),
+            ],
+            options: {
+                ...(nxReleasePublishTargetDefaults.options ?? {}),
+            },
+        };
+    }
+    return res;
+}
+/**
+ * Uses `require.resolve` to read the package.json for a module.
+ *
+ * This will fail if the module doesn't export package.json
+ *
+ * @returns package json contents and path
+ */
+function readModulePackageJsonWithoutFallbacks(moduleSpecifier, requirePaths = (0, installation_directory_1.getNxRequirePaths)()) {
+    const packageJsonPath = require.resolve(`${moduleSpecifier}/package.json`, {
+        paths: requirePaths,
+    });
+    const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+    return {
+        path: packageJsonPath,
+        packageJson,
+    };
+}
+/**
+ * Reads the package.json file for a specified module.
+ *
+ * Includes a fallback that accounts for modules that don't export package.json
+ *
+ * @param {string} moduleSpecifier The module to look up
+ * @param {string[]} requirePaths List of paths look in. Pass `module.paths` to ensure non-hoisted dependencies are found.
+ *
+ * @example
+ * // Use the caller's lookup paths for non-hoisted dependencies
+ * readModulePackageJson('http-server', module.paths);
+ *
+ * @returns package json contents and path
+ */
+function readModulePackageJson(moduleSpecifier, requirePaths = (0, installation_directory_1.getNxRequirePaths)()) {
+    let packageJsonPath;
+    let packageJson;
+    try {
+        ({ path: packageJsonPath, packageJson } =
+            readModulePackageJsonWithoutFallbacks(moduleSpecifier, requirePaths));
+    }
+    catch {
+        const entryPoint = require.resolve(moduleSpecifier, {
+            paths: requirePaths,
+        });
+        let moduleRootPath = (0, path_1.dirname)(entryPoint);
+        packageJsonPath = (0, path_1.join)(moduleRootPath, 'package.json');
+        while (!(0, fs_1.existsSync)(packageJsonPath)) {
+            moduleRootPath = (0, path_1.dirname)(moduleRootPath);
+            packageJsonPath = (0, path_1.join)(moduleRootPath, 'package.json');
+        }
+        packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+        if (packageJson.name && packageJson.name !== moduleSpecifier) {
+            throw new Error(`Found module ${packageJson.name} while trying to locate ${moduleSpecifier}/package.json`);
+        }
+    }
+    return {
+        packageJson,
+        path: packageJsonPath,
+    };
+}
+/**
+ * Prepares all necessary information for installing a package to a temporary directory.
+ * This is used by both sync and async installation functions.
+ */
+function preparePackageInstallation(pkg, requiredVersion, packageManager) {
+    const { dir: tempDir, cleanup } = (0, package_manager_1.createTempNpmDirectory)?.() ?? {
+        dir: (0, tmp_1.dirSync)().name,
+        cleanup: () => { },
+    };
+    console.log(`Fetching ${pkg}...`);
+    const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
+    generatePackageManagerFiles(tempDir, packageManager);
+    // For pnpm, `addDev` is `pnpm add -Dw` when the workspace has a
+    // pnpm-workspace.yaml. `createTempNpmDirectory` copies a sanitized copy of
+    // it into the temp dir, so the `-w` here resolves to the temp dir.
+    const pmCommands = (0, package_manager_1.getPackageManagerCommand)(packageManager);
+    const preInstallCommand = pmCommands.preInstall;
+    // Keep peer dependencies out of the temp install. `ensurePackage` puts the
+    // workspace's `node_modules` on `NODE_PATH`, so a loaded package resolves its
+    // peers from the workspace instead of pulling its own (possibly incompatible)
+    // copies into the temp dir.
+    //
+    // npm needs `--legacy-peer-deps` rather than `--omit=peer`: npm marks a package
+    // as a peer if anything in the tree peer-depends on it, so `--omit=peer` also
+    // prunes packages that are real dependencies. Bun's `--omit=peer` does not.
+    const skipPeerDependenciesFlags = {
+        npm: '--legacy-peer-deps',
+        bun: '--omit=peer',
+        pnpm: '--config.auto-install-peers=false',
+    };
+    const installCommand = [
+        pmCommands.addDev,
+        `${pkg}@${requiredVersion}`,
+        skipPeerDependenciesFlags[packageManager],
+        pmCommands.ignoreScriptsFlag,
+    ]
+        .filter(Boolean)
+        .join(' ');
+    const execOptions = {
+        cwd: tempDir,
+        stdio: isVerbose ? 'inherit' : 'ignore',
+        windowsHide: true,
+        // Yarn Berry requires an environment variable (not a CLI flag) to disable lifecycle scripts.
+        // Apply this defensively for all package managers when pulling nx@latest to tmp.
+        env: {
+            ...process.env,
+            YARN_ENABLE_SCRIPTS: 'false',
+        },
+    };
+    return {
+        tempDir,
+        cleanup,
+        preInstallCommand,
+        installCommand,
+        execOptions,
+    };
+}
+function installPackageToTmp(pkg, requiredVersion, packageManager) {
+    const { tempDir, cleanup, preInstallCommand, installCommand, execOptions } = preparePackageInstallation(pkg, requiredVersion, packageManager);
+    if (preInstallCommand) {
+        // ensure package.json and repo in tmp folder is set to a proper package manager state
+        (0, child_process_1.execSync)(preInstallCommand, execOptions);
+    }
+    (0, child_process_1.execSync)(installCommand, execOptions);
+    return {
+        tempDir,
+        cleanup,
+    };
+}
+async function installPackageToTmpAsync(pkg, requiredVersion, packageManager) {
+    const { tempDir, cleanup, preInstallCommand, installCommand, execOptions } = preparePackageInstallation(pkg, requiredVersion, packageManager);
+    try {
+        if (preInstallCommand) {
+            // ensure package.json and repo in tmp folder is set to a proper package manager state
+            await execAsync(preInstallCommand, execOptions);
+        }
+        await execAsync(installCommand, execOptions);
+        return {
+            tempDir,
+            cleanup,
+        };
+    }
+    catch (error) {
+        // Clean up on error
+        cleanup();
+        throw error;
+    }
+}
+function getDependencyVersionFromPackageJson(treeOrPackageName, packageNameOrRoot, packageJsonPathOrObjectOrRoot, dependencyLookup) {
+    if (typeof treeOrPackageName !== 'string') {
+        return getDependencyVersionFromPackageJsonFromTree(treeOrPackageName, packageNameOrRoot, packageJsonPathOrObjectOrRoot, dependencyLookup);
+    }
+    else {
+        return getDependencyVersionFromPackageJsonFromFileSystem(treeOrPackageName, packageNameOrRoot, packageJsonPathOrObjectOrRoot, dependencyLookup);
+    }
+}
+/**
+ * Tree-based implementation for getDependencyVersionFromPackageJson
+ */
+function getDependencyVersionFromPackageJsonFromTree(tree, packageName, packageJsonPathOrObject = 'package.json', dependencyLookup = [
+    'dependencies',
+    'devDependencies',
+]) {
+    let packageJson;
+    if (typeof packageJsonPathOrObject === 'object') {
+        packageJson = packageJsonPathOrObject;
+    }
+    else if (tree.exists(packageJsonPathOrObject)) {
+        packageJson = (0, json_1.readJson)(tree, packageJsonPathOrObject);
+    }
+    else {
+        return null;
+    }
+    let version = null;
+    for (const section of dependencyLookup) {
+        const foundVersion = packageJson[section]?.[packageName];
+        if (foundVersion) {
+            version = foundVersion;
+            break;
+        }
+    }
+    // Resolve catalog reference if needed
+    const manager = (0, catalog_1.getCatalogManager)(tree.root);
+    if (version && manager?.isCatalogReference(version)) {
+        version = manager.resolveCatalogReference(tree, packageName, version);
+    }
+    return version;
+}
+/**
+ * Filesystem-based implementation for getDependencyVersionFromPackageJson
+ */
+function getDependencyVersionFromPackageJsonFromFileSystem(packageName, root = workspace_root_1.workspaceRoot, packageJsonPathOrObject = 'package.json', dependencyLookup = [
+    'dependencies',
+    'devDependencies',
+]) {
+    let packageJson;
+    if (typeof packageJsonPathOrObject === 'object') {
+        packageJson = packageJsonPathOrObject;
+    }
+    else {
+        const packageJsonPath = (0, path_1.resolve)(root, packageJsonPathOrObject);
+        if ((0, fs_1.existsSync)(packageJsonPath)) {
+            packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+        }
+        else {
+            return null;
+        }
+    }
+    let version = null;
+    for (const section of dependencyLookup) {
+        const foundVersion = packageJson[section]?.[packageName];
+        if (foundVersion) {
+            version = foundVersion;
+            break;
+        }
+    }
+    // Resolve catalog reference if needed
+    const manager = (0, catalog_1.getCatalogManager)(root);
+    if (version && manager?.isCatalogReference(version)) {
+        version = manager.resolveCatalogReference(root, packageName, version);
+    }
+    return version;
+}
+/**
+ * Generates necessary files needed for the package manager to work
+ * and for the node_modules to be accessible.
+ */
+function generatePackageManagerFiles(root, packageManager = (0, package_manager_1.detectPackageManager)()) {
+    const [pmMajor] = (0, package_manager_1.getPackageManagerVersion)(packageManager).split('.');
+    switch (packageManager) {
+        case 'yarn':
+            if (+pmMajor >= 2) {
+                (0, fs_1.writeFileSync)((0, path_1.join)(root, '.yarnrc.yml'), 'nodeLinker: node-modules\nenableScripts: false');
+            }
+            break;
+    }
+}

package/dist/src/utils/package-manager-config/bunfig.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The directory holding bun's global config files (.bunfig.toml and, for bun's
+ * npmrc support, .npmrc): $XDG_CONFIG_HOME when set, else the home dir (bun's
+ * getHomeConfigPath). Null when neither is set, where bun reads no global
+ * config.
+ */
+export declare function getBunGlobalConfigBase(env: NodeJS.ProcessEnv): string | null;
+/**
+ * Parses a bunfig.toml: null when absent, 'unreadable' when it cannot be read
+ * (bun skips it and resolves on, so most callers collapse the two), 'invalid'
+ * when bun's own TOML parser would reject it (bun hard-errors there, so no
+ * resolution is left for a caller to reproduce).
+ */
+export declare function readBunfigRaw(path: string): Record<string, unknown> | 'unreadable' | 'invalid' | null;

package/dist/src/utils/package-manager-config/bunfig.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBunGlobalConfigBase = getBunGlobalConfigBase;
+exports.readBunfigRaw = readBunfigRaw;
+const fs_1 = require("fs");
+/**
+ * The directory holding bun's global config files (.bunfig.toml and, for bun's
+ * npmrc support, .npmrc): $XDG_CONFIG_HOME when set, else the home dir (bun's
+ * getHomeConfigPath). Null when neither is set, where bun reads no global
+ * config.
+ */
+function getBunGlobalConfigBase(env) {
+    // bun's getenvZ treats a set-but-empty var as present, so an exported empty
+    // XDG_CONFIG_HOME still short-circuits HOME (bun: `XDG_CONFIG_HOME orelse HOME`).
+    if (env.XDG_CONFIG_HOME !== undefined) {
+        return env.XDG_CONFIG_HOME;
+    }
+    // Mirrors bun's platform-specific HOME accessor (env_var.zig).
+    const home = process.platform === 'win32' ? env.USERPROFILE : env.HOME;
+    return home ?? null;
+}
+/**
+ * Parses a bunfig.toml: null when absent, 'unreadable' when it cannot be read
+ * (bun skips it and resolves on, so most callers collapse the two), 'invalid'
+ * when bun's own TOML parser would reject it (bun hard-errors there, so no
+ * resolution is left for a caller to reproduce).
+ */
+function readBunfigRaw(path) {
+    // Outside the try because a parser that will not load is a broken
+    // installation, not a corrupt bunfig.
+    const { parse } = require('smol-toml');
+    let raw;
+    try {
+        raw = (0, fs_1.readFileSync)(path, 'utf-8');
+    }
+    catch (error) {
+        // ENOTDIR (a path through a non-directory) is another shape of absent, the
+        // same way the .npmrc reader classifies it.
+        return error?.code === 'ENOENT' || error?.code === 'ENOTDIR'
+            ? null
+            : 'unreadable';
+    }
+    try {
+        return parse(raw);
+    }
+    catch {
+        return 'invalid';
+    }
+}

package/dist/src/utils/package-manager-config/npmrc.d.ts

@@ -0,0 +1,23 @@
+export interface NpmrcEntry {
+    key: string;
+    value: string;
+    /** True when the source used ini's `key[]` array-append syntax. */
+    array?: boolean;
+}
+/**
+ * Parses an .npmrc file into its `key = value` entries the way npm/yarn/pnpm do
+ * (via the `ini` package). Returns null when the file is missing, and
+ * 'unreadable' when it exists but cannot be read (permissions, a directory):
+ * package managers diverge on that state, so each caller decides whether to
+ * skip, warn, or abort rather than having it collapsed into "absent" here.
+ */
+export declare function readNpmrcEntries(path: string): NpmrcEntry[] | 'unreadable' | null;
+export declare function parseNpmrcContent(raw: string): NpmrcEntry[];
+/**
+ * Reads an .npmrc-format file into a map with ini's semantics for repeated
+ * keys: scalars last-write-wins, `key[]` values joined. Null and 'unreadable'
+ * pass through from {@link readNpmrcEntries}.
+ */
+export declare function readNpmrcMap(path: string): Map<string, string> | 'unreadable' | null;
+/** Those entries under ini's semantics for repeated keys. */
+export declare function npmrcEntriesToMap(entries: NpmrcEntry[]): Map<string, string>;

package/dist/src/utils/package-manager-config/npmrc.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readNpmrcEntries = readNpmrcEntries;
+exports.parseNpmrcContent = parseNpmrcContent;
+exports.readNpmrcMap = readNpmrcMap;
+exports.npmrcEntriesToMap = npmrcEntriesToMap;
+const fs_1 = require("fs");
+/**
+ * Parses an .npmrc file into its `key = value` entries the way npm/yarn/pnpm do
+ * (via the `ini` package). Returns null when the file is missing, and
+ * 'unreadable' when it exists but cannot be read (permissions, a directory):
+ * package managers diverge on that state, so each caller decides whether to
+ * skip, warn, or abort rather than having it collapsed into "absent" here.
+ */
+function readNpmrcEntries(path) {
+    let raw;
+    try {
+        raw = (0, fs_1.readFileSync)(path, 'utf-8');
+    }
+    catch (e) {
+        // ENOTDIR (a path through a non-directory) is another shape of absent, not an
+        // unreadable file.
+        return e?.code === 'ENOENT' || e?.code === 'ENOTDIR' ? null : 'unreadable';
+    }
+    return parseNpmrcContent(raw);
+}
+function parseNpmrcContent(raw) {
+    const entries = [];
+    // ini breaks lines on any run of CR/LF, so splitting on `\r?\n` here would
+    // hide everything after a bare CR that npm still reads.
+    for (const line of raw.split(/[\r\n]+/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith(';')) {
+            continue;
+        }
+        // ini matches the header on the raw line, so an indented one stays a literal
+        // bare-flag key. Everything after a header nests under it, out of npm's flat
+        // lookup, so stop here.
+        if (/^\[[^\]]*\]\s*$/.test(line)) {
+            break;
+        }
+        // ini reads a valueless line as the flag `true`; dropping it would lose a bare
+        // `always-auth`/`strict-ssl` and flip the credential/TLS decision built on it.
+        const eq = trimmed.indexOf('=');
+        const rawKey = iniUnsafe(eq === -1 ? trimmed : trimmed.slice(0, eq));
+        const value = eq === -1 ? 'true' : iniUnsafe(trimmed.slice(eq + 1));
+        // ini enables bracketedArray by default, so a `key[]` suffix appends under the
+        // bare key instead of making a literal `key[]` entry.
+        if (rawKey.length > 2 && rawKey.endsWith('[]')) {
+            entries.push({ key: rawKey.slice(0, -2), value, array: true });
+        }
+        else {
+            entries.push({ key: rawKey, value });
+        }
+    }
+    return entries;
+}
+/**
+ * Reads an .npmrc-format file into a map with ini's semantics for repeated
+ * keys: scalars last-write-wins, `key[]` values joined. Null and 'unreadable'
+ * pass through from {@link readNpmrcEntries}.
+ */
+function readNpmrcMap(path) {
+    const entries = readNpmrcEntries(path);
+    return Array.isArray(entries) ? npmrcEntriesToMap(entries) : entries;
+}
+/** Those entries under ini's semantics for repeated keys. */
+function npmrcEntriesToMap(entries) {
+    const map = new Map();
+    for (const { key, value, array } of entries) {
+        // ini collects repeated `key[]` values into an array under the bare key, and
+        // npm rebuilds a config array from the env by splitting on a blank line, so
+        // join them that way.
+        const existing = map.get(key);
+        map.set(key, array && existing !== undefined ? `${existing}\n\n${value}` : value);
+    }
+    return map;
+}
+function isQuoted(val) {
+    return (val.length >= 2 &&
+        ((val.startsWith('"') && val.endsWith('"')) ||
+            (val.startsWith("'") && val.endsWith("'"))));
+}
+/**
+ * Mirrors the `ini` package's `unsafe()`, except that ini JSON-decodes a
+ * single-quoted value's contents and we keep them verbatim; that only differs
+ * when the contents are valid JSON, never true for a registry, token, or path.
+ * See https://github.com/isaacs/ini/blob/a0c72fe9e335a3f949d734fb5ef13371a850bbe3/lib/ini.js#L230
+ */
+function iniUnsafe(raw) {
+    const val = raw.trim();
+    if (isQuoted(val)) {
+        if (val.startsWith("'")) {
+            return val.slice(1, -1);
+        }
+        try {
+            return JSON.parse(val);
+        }
+        catch {
+            return val;
+        }
+    }
+    let esc = false;
+    let unesc = '';
+    for (const c of val) {
+        if (esc) {
+            unesc += '\\;#'.includes(c) ? c : `\\${c}`;
+            esc = false;
+        }
+        else if (c === ';' || c === '#') {
+            break;
+        }
+        else if (c === '\\') {
+            esc = true;
+        }
+        else {
+            unesc += c;
+        }
+    }
+    if (esc) {
+        unesc += '\\';
+    }
+    return unesc.trim();
+}

package/dist/src/utils/package-manager-config/pnpm-config.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Mirrors pnpm's getConfigDir. Hosts pnpm's global config.yaml and (v11+)
+ * auth.ini.
+ * See https://github.com/pnpm/pnpm/blob/b7195db5c8469c80908d625c648302b26c2f9977/config/reader/src/dirs.ts#L73-L92
+ */
+export declare function getPnpmConfigDir(env: NodeJS.ProcessEnv): string;
+/**
+ * Reads a pnpm YAML config file (pnpm-workspace.yaml or the global
+ * config.yaml). An absent file returns null so callers can fall through to
+ * lower surfaces; everything else returns 'unusable', which every caller turns
+ * into a throw. pnpm's own reader tolerates ENOENT alone and rethrows the rest,
+ * and it dies the same way on a document it cannot parse or that is not a
+ * mapping, so the two failures need no separate states. Requiring an object
+ * also keeps the sentinel out of the success domain: a returned string can only
+ * ever mean unusable.
+ */
+export declare function readPnpmYamlConfig(path: string): Record<string, unknown> | 'unusable' | null;

package/dist/src/utils/package-manager-config/pnpm-config.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPnpmConfigDir = getPnpmConfigDir;
+exports.readPnpmYamlConfig = readPnpmYamlConfig;
+const os_1 = require("os");
+const path_1 = require("path");
+const fileutils_1 = require("../fileutils");
+/**
+ * Mirrors pnpm's getConfigDir. Hosts pnpm's global config.yaml and (v11+)
+ * auth.ini.
+ * See https://github.com/pnpm/pnpm/blob/b7195db5c8469c80908d625c648302b26c2f9977/config/reader/src/dirs.ts#L73-L92
+ */
+function getPnpmConfigDir(env) {
+    if (env.XDG_CONFIG_HOME) {
+        return (0, path_1.join)(env.XDG_CONFIG_HOME, 'pnpm');
+    }
+    if (process.platform === 'darwin') {
+        return (0, path_1.join)((0, os_1.homedir)(), 'Library/Preferences/pnpm');
+    }
+    if (process.platform !== 'win32') {
+        return (0, path_1.join)((0, os_1.homedir)(), '.config/pnpm');
+    }
+    if (env.LOCALAPPDATA) {
+        return (0, path_1.join)(env.LOCALAPPDATA, 'pnpm/config');
+    }
+    return (0, path_1.join)((0, os_1.homedir)(), '.config/pnpm');
+}
+/**
+ * Reads a pnpm YAML config file (pnpm-workspace.yaml or the global
+ * config.yaml). An absent file returns null so callers can fall through to
+ * lower surfaces; everything else returns 'unusable', which every caller turns
+ * into a throw. pnpm's own reader tolerates ENOENT alone and rethrows the rest,
+ * and it dies the same way on a document it cannot parse or that is not a
+ * mapping, so the two failures need no separate states. Requiring an object
+ * also keeps the sentinel out of the success domain: a returned string can only
+ * ever mean unusable.
+ */
+function readPnpmYamlConfig(path) {
+    let doc;
+    try {
+        doc = (0, fileutils_1.readYamlFile)(path);
+    }
+    catch (e) {
+        // Only ENOENT resolves on, so a path through a non-directory or a file that
+        // will not open is fatal here. Callers whose pnpm counterpart looks the file
+        // up before reading it widen "absent" themselves.
+        if (e?.code === 'ENOENT') {
+            return null;
+        }
+        return 'unusable';
+    }
+    // An empty file declares nothing; pnpm accepts it.
+    if (doc === null || doc === undefined) {
+        return {};
+    }
+    if (typeof doc !== 'object' || Array.isArray(doc)) {
+        return 'unusable';
+    }
+    return doc;
+}