@varlock/bumpy 0.0.1 → 0.0.2

package/dist/shell-DPlltpzb.mjs

@@ -1,44 +0,0 @@
-import { i as __exportAll } from "./logger-ZqggsyGZ.mjs";
-import { exec, execSync } from "node:child_process";
-//#region src/utils/shell.ts
-var shell_exports = /* @__PURE__ */ __exportAll({
-	run: () => run,
-	runAsync: () => runAsync,
-	tryRun: () => tryRun
-});
-function run(cmd, opts) {
-	return execSync(cmd, {
-		cwd: opts?.cwd,
-		input: opts?.input,
-		encoding: "utf-8",
-		stdio: [
-			opts?.input ? "pipe" : "pipe",
-			"pipe",
-			"pipe"
-		]
-	}).trim();
-}
-function runAsync(cmd, opts) {
-	return new Promise((resolve, reject) => {
-		const child = exec(cmd, {
-			cwd: opts?.cwd,
-			encoding: "utf-8"
-		}, (err, stdout, stderr) => {
-			if (err) reject(/* @__PURE__ */ new Error(`Command failed: ${cmd}\n${stderr}`));
-			else resolve(stdout.trim());
-		});
-		if (opts?.input) {
-			child.stdin?.write(opts.input);
-			child.stdin?.end();
-		}
-	});
-}
-function tryRun(cmd, opts) {
-	try {
-		return run(cmd, opts);
-	} catch {
-		return null;
-	}
-}
-//#endregion
-export { tryRun as i, runAsync as n, shell_exports as r, run as t };

package/dist/workspace-mVjawG8g.mjs

@@ -1,183 +0,0 @@
-import { a as readJson, n as exists, o as readText } from "./fs-DbNNEyzq.mjs";
-import { i as isPackageManaged, o as loadPackageConfig } from "./config-CJ2orhTL.mjs";
-import { t as jsYaml } from "./js-yaml-DpZfOoD4.mjs";
-import { relative, resolve } from "node:path";
-import { readdir, stat } from "node:fs/promises";
-//#region src/utils/package-manager.ts
-/** Detect the package manager, extract workspace globs, and load catalogs */
-async function detectWorkspaces(rootDir) {
-	const pm = await detectPackageManager(rootDir);
-	return {
-		packageManager: pm,
-		globs: await getWorkspaceGlobs(rootDir, pm),
-		catalogs: await loadCatalogs(rootDir, pm)
-	};
-}
-async function detectPackageManager(rootDir) {
-	if (await exists(resolve(rootDir, "bun.lock")) || await exists(resolve(rootDir, "bun.lockb"))) return "bun";
-	if (await exists(resolve(rootDir, "pnpm-lock.yaml"))) return "pnpm";
-	if (await exists(resolve(rootDir, "yarn.lock"))) return "yarn";
-	try {
-		const pkg = await readJson(resolve(rootDir, "package.json"));
-		if (typeof pkg.packageManager === "string") {
-			const name = pkg.packageManager.split("@")[0];
-			if (name === "pnpm" || name === "yarn" || name === "bun") return name;
-		}
-	} catch {}
-	return "npm";
-}
-async function getWorkspaceGlobs(rootDir, pm) {
-	if (pm === "pnpm") {
-		const wsFile = resolve(rootDir, "pnpm-workspace.yaml");
-		if (await exists(wsFile)) {
-			const content = await readText(wsFile);
-			const parsed = jsYaml.load(content);
-			if (parsed?.packages) return parsed.packages;
-		}
-	}
-	try {
-		const workspaces = (await readJson(resolve(rootDir, "package.json"))).workspaces;
-		if (Array.isArray(workspaces)) return workspaces;
-		if (workspaces && typeof workspaces === "object" && "packages" in workspaces) {
-			const pkgs = workspaces.packages;
-			if (Array.isArray(pkgs)) return pkgs;
-		}
-	} catch {}
-	return [];
-}
-/** Load catalog definitions from pnpm-workspace.yaml or root package.json */
-async function loadCatalogs(rootDir, pm) {
-	const catalogs = /* @__PURE__ */ new Map();
-	if (pm === "pnpm") {
-		const wsFile = resolve(rootDir, "pnpm-workspace.yaml");
-		if (await exists(wsFile)) {
-			const content = await readText(wsFile);
-			const parsed = jsYaml.load(content);
-			if (parsed?.catalog) catalogs.set("", parsed.catalog);
-			if (parsed?.catalogs) for (const [name, deps] of Object.entries(parsed.catalogs)) catalogs.set(name, deps);
-		}
-	}
-	try {
-		const pkg = await readJson(resolve(rootDir, "package.json"));
-		if (pkg.catalog && typeof pkg.catalog === "object") catalogs.set("", pkg.catalog);
-		if (pkg.catalogs && typeof pkg.catalogs === "object") for (const [name, deps] of Object.entries(pkg.catalogs)) catalogs.set(name, deps);
-		const workspaces = pkg.workspaces;
-		if (workspaces && typeof workspaces === "object" && !Array.isArray(workspaces)) {
-			const ws = workspaces;
-			if (ws.catalog && typeof ws.catalog === "object") catalogs.set("", ws.catalog);
-			if (ws.catalogs && typeof ws.catalogs === "object") for (const [name, deps] of Object.entries(ws.catalogs)) catalogs.set(name, deps);
-		}
-	} catch {}
-	return catalogs;
-}
-/** Resolve a specific dependency's catalog: reference */
-function resolveCatalogDep(depName, range, catalogs) {
-	if (!range.startsWith("catalog:")) return null;
-	const catalogName = range.slice(8).trim() || "";
-	const catalog = catalogs.get(catalogName);
-	if (!catalog) return null;
-	return catalog[depName] ?? null;
-}
-//#endregion
-//#region src/core/workspace.ts
-/** Discover all workspace packages and catalogs in a monorepo */
-async function discoverWorkspace(rootDir, config) {
-	const { globs, catalogs } = await detectWorkspaces(rootDir);
-	if (globs.length === 0) throw new Error("No workspace globs found. Is this a monorepo?");
-	const packages = /* @__PURE__ */ new Map();
-	for (const glob of globs) {
-		const dirs = await resolveGlob(rootDir, glob);
-		for (const dir of dirs) {
-			const pkg = await loadWorkspacePackage(dir, rootDir, config);
-			if (pkg) {
-				if (!isPackageManaged(pkg.name, pkg.private, config, pkg.bumpy)) continue;
-				packages.set(pkg.name, pkg);
-			}
-		}
-	}
-	return {
-		packages,
-		catalogs
-	};
-}
-/** Convenience wrapper that returns just packages (backwards compat) */
-async function discoverPackages(rootDir, config) {
-	const { packages } = await discoverWorkspace(rootDir, config);
-	return packages;
-}
-/** Resolve a workspace glob pattern to directories containing package.json */
-async function resolveGlob(rootDir, pattern) {
-	return expandGlob(rootDir, pattern.split("/"));
-}
-async function expandGlob(baseDir, parts) {
-	if (parts.length === 0) {
-		if (await exists(resolve(baseDir, "package.json"))) return [baseDir];
-		return [];
-	}
-	const [current, ...rest] = parts;
-	if (current === "*") {
-		const entries = await safeReaddir(baseDir);
-		const results = [];
-		for (const entry of entries) {
-			const entryPath = resolve(baseDir, entry);
-			if (await isDirectory(entryPath)) results.push(...await expandGlob(entryPath, rest));
-		}
-		return results;
-	} else if (current === "**") {
-		const results = [];
-		results.push(...await expandGlob(baseDir, rest));
-		const entries = await safeReaddir(baseDir);
-		for (const entry of entries) {
-			if (entry.startsWith(".") || entry === "node_modules") continue;
-			const entryPath = resolve(baseDir, entry);
-			if (await isDirectory(entryPath)) results.push(...await expandGlob(entryPath, parts));
-		}
-		return results;
-	} else {
-		const next = resolve(baseDir, current);
-		if (await isDirectory(next)) return expandGlob(next, rest);
-		return [];
-	}
-}
-async function safeReaddir(dir) {
-	try {
-		return await readdir(dir);
-	} catch {
-		return [];
-	}
-}
-async function isDirectory(path) {
-	try {
-		return (await stat(path)).isDirectory();
-	} catch {
-		return false;
-	}
-}
-async function loadWorkspacePackage(dir, rootDir, config) {
-	const pkgPath = resolve(dir, "package.json");
-	if (!await exists(pkgPath)) return null;
-	let pkg;
-	try {
-		pkg = await readJson(pkgPath);
-	} catch {
-		return null;
-	}
-	const name = pkg.name;
-	if (!name) return null;
-	const bumpy = await loadPackageConfig(dir, config, name);
-	return {
-		name,
-		version: pkg.version || "0.0.0",
-		dir: resolve(dir),
-		relativeDir: relative(rootDir, dir),
-		packageJson: pkg,
-		private: !!pkg.private,
-		dependencies: pkg.dependencies || {},
-		devDependencies: pkg.devDependencies || {},
-		peerDependencies: pkg.peerDependencies || {},
-		optionalDependencies: pkg.optionalDependencies || {},
-		bumpy
-	};
-}
-//#endregion
-export { resolveCatalogDep as i, discoverWorkspace as n, detectWorkspaces as r, discoverPackages as t };