pnpmc/lib/runner-FWSEFY4j.js

PNPM Catalogs Tooling

import { fail, log } from "./utils-nUJKoOjh.js";
import { WORKSPACE_MANIFEST_FILENAME } from "@pnpm/constants";
import { findWorkspaceDir } from "@pnpm/find-workspace-dir";
import { readWorkspaceManifest } from "@pnpm/workspace.read-manifest";
import { findWorkspacePackages } from "@pnpm/workspace.find-packages";

//#region src/analyze.ts
function collectCatalogDependencies(manifest) {
	const deps = new Set();
	function doCollect(catalog, deps$1) {
		for (const dep of Object.keys(catalog)) deps$1.add(dep);
	}
	if (manifest.catalog) doCollect(manifest.catalog, deps);
	if (manifest.catalogs) for (const catalog of Object.values(manifest.catalogs)) doCollect(catalog, deps);
	return deps;
}
function collectProjectDependencies(projects) {
	const deps = new Map();
	for (const project of projects) {
		const dependencies = project.manifest.dependencies || {};
		const devDependencies = project.manifest.devDependencies || {};
		for (const dep of [dependencies, devDependencies]) if (Object.keys(dep).length > 0) for (const d of Object.keys(dep)) {
			const p = deps.get(d) || [];
			p.push(project);
			deps.set(d, p);
		}
	}
	return deps;
}
async function analyzeDependencies(workspaceDir, manifest) {
	const ret = new Map();
	const catalogDeps = collectCatalogDependencies(manifest);
	const projects = await findWorkspacePackages(workspaceDir);
	const projectDeps = collectProjectDependencies(projects);
	for (const [dep, projects$1] of projectDeps.entries()) if (projects$1.length > 1) {
		const catalogableDeps = [];
		for (const project of projects$1) {
			const dependencies = project.manifest.dependencies || {};
			const devDependencies = project.manifest.devDependencies || {};
			for (const deps of [dependencies, devDependencies]) {
				const pkgPath = project.rootDir.split(workspaceDir)[1] || "/";
				const alias = deps[dep];
				if (alias && !alias.startsWith("workspace:")) catalogableDeps.push({
					name: project.manifest.name,
					path: pkgPath,
					dependency: dep,
					alias,
					cataloged: alias.startsWith("catalog:")
				});
			}
		}
		if (catalogableDeps.length > 1 && (!catalogDeps.has(dep) || catalogableDeps.some((dep$1) => !dep$1.cataloged))) ret.set(dep, catalogableDeps);
	}
	return ret;
}

//#endregion
//#region src/commands/show/runner.ts
const run = async ({ values, env: { cwd } }) => {
	await display(cwd, {
		showCategory: !values.catalog && !values.dependency ? true : values.catalog,
		showDependency: !values.catalog && !values.dependency ? true : values.dependency
	});
};
async function display(target, options) {
	const workspaceDir = await findWorkspaceDir(target);
	if (workspaceDir == null) return;
	const manifest = await readWorkspaceManifest(workspaceDir);
	if (manifest == null) fail("No workspace manifest found");
	if (options.showCategory) {
		log(catalogs(manifest));
		log();
	}
	if (options.showDependency) {
		const catalogableDeps = await analyzeDependencies(workspaceDir, manifest);
		if (catalogableDeps.size > 0) {
			log(catalogableDependencies(catalogableDeps));
			log();
		}
	}
}
function catalogs(manifest) {
	let catalogs$1 = `📙 Defined catalogs in ${WORKSPACE_MANIFEST_FILENAME}:\n`;
	if (manifest.catalog == null && manifest.catalogs == null) {
		catalogs$1 += "  (none)";
		return catalogs$1;
	}
	if (manifest.catalog) {
		catalogs$1 += "  default:\n";
		const sortedCatalog = new Map([...Object.entries(manifest.catalog)].sort((a, b) => a[0].localeCompare(b[0])));
		for (const [dep, ver] of sortedCatalog.entries()) catalogs$1 += `    ${dep}: ${ver}\n`;
	}
	if (manifest.catalogs) for (const [name, catalog] of Object.entries(manifest.catalogs)) {
		catalogs$1 += `  ${name}:\n`;
		for (const [dep, ver] of Object.entries(catalog)) catalogs$1 += `    ${dep}: ${ver}\n`;
	}
	return catalogs$1;
}
function catalogableDependencies(catalogableDeps) {
	let text = `📦 Catalogable Dependencies (${catalogableDeps.size}):\n`;
	const sortedCatalogableDeps = new Map([...catalogableDeps.entries()].sort((a, b) => a[0].localeCompare(b[0])));
	for (const [depName, deps] of sortedCatalogableDeps.entries()) {
		text += `  ${depName}:\n`;
		const depsPathMaxLength = Math.max(...deps.map((dep) => dep.path.length));
		const depsNameMaxLength = Math.max(...deps.map((dep) => dep.name?.length || 0));
		for (const dep of deps) {
			text += `    ${dep.path.padEnd(depsPathMaxLength)}`;
			if (dep.name) text += ` ${`(${dep.name})`.padEnd(depsNameMaxLength + 3)}: `;
			else text += ": ";
			text += `${dep.alias}\n`;
		}
	}
	return text;
}
var runner_default = run;

//#endregion
export { runner_default };