tegami 0.2.0 → 1.0.0-beta.0

package/dist/plugins/go.js

@@ -0,0 +1,291 @@
+import { i as isNodeError, n as execFailure } from "../error-DNy8R5ue.js";
+import { n as WorkspacePackage } from "../graph-OnX9ncdQ.js";
+import { relative, resolve } from "node:path";
+import { x } from "tinyexec";
+import * as semver from "semver";
+import z from "zod";
+//#region src/plugins/go.ts
+const goWorkJsonSchema = z.object({ Use: z.array(z.object({
+	DiskPath: z.string(),
+	ModulePath: z.string().optional()
+})).optional() });
+const goModJsonSchema = z.object({
+	Module: z.object({ Path: z.string() }),
+	Require: z.array(z.object({
+		Path: z.string(),
+		Version: z.string().optional()
+	})).optional(),
+	Replace: z.array(z.object({
+		Old: z.object({
+			Path: z.string(),
+			Version: z.string().optional()
+		}),
+		New: z.object({
+			Path: z.string(),
+			Version: z.string().optional()
+		})
+	})).optional()
+});
+var GoPackage = class extends WorkspacePackage {
+	path;
+	mod;
+	manager = "go";
+	versionValue;
+	pendingRequires = /* @__PURE__ */ new Map();
+	constructor(path, mod, version) {
+		super();
+		this.path = path;
+		this.mod = mod;
+		this.versionValue = version;
+	}
+	get name() {
+		return this.mod.module;
+	}
+	get version() {
+		return this.versionValue;
+	}
+	setVersion(version) {
+		this.versionValue = version;
+	}
+	setRequire(module, version) {
+		const formatted = formatGoVersion(version);
+		this.mod.requires.set(module, formatted);
+		this.pendingRequires.set(module, formatted);
+	}
+	async write() {
+		if (this.pendingRequires.size === 0) return;
+		const args = ["mod", "edit"];
+		for (const [module, version] of this.pendingRequires) args.push(`-require=${module}@${version}`);
+		const result = await x("go", args, { nodeOptions: { cwd: this.path } });
+		if (result.exitCode !== 0) throw execFailure(`Failed to update go.mod requires in ${this.path}.`, result);
+		this.pendingRequires.clear();
+	}
+};
+const packageLockSchema = z.object({
+	id: z.string(),
+	version: z.string()
+});
+/**
+* Experimental plugin for Golang, the release flow of Golang is pretty special, there's some exceptions for it:
+*
+* - Version is stored in lock file, normally, it should prefer to store versions in a file like `package.json` & `Cargo.toml`, but for Golang, there is no such file.
+* - Publishing is handed to Git plugin, because Golang uses Git tag for publishing.
+*/
+function go({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
+	let active = false;
+	return {
+		name: "go",
+		enforce: "post",
+		async resolve() {
+			await discoverGoPackages(this.cwd, (pkg) => this.graph.add(pkg));
+			active = this.graph.getPackages().some((pkg) => pkg instanceof GoPackage);
+			if (active && !this.plugins.some((plugin) => plugin.name === "git")) throw new Error("The go plugin requires the git plugin. Add git() from \"tegami/plugins/git\" to your plugins array.");
+		},
+		initDraft(plan) {
+			if (!active) return;
+			plan.addPolicy(depsPolicy(this, getBumpDepType));
+		},
+		async applyDraft(draft) {
+			if (!active) return;
+			const { graph } = this;
+			const writes = [];
+			for (const pkg of graph.getPackages()) {
+				if (!(pkg instanceof GoPackage)) continue;
+				const plan = draft.getPackageDraft(pkg.id);
+				if (plan) pkg.setVersion(plan.bumpVersion(pkg));
+			}
+			for (const pkg of graph.getPackages()) {
+				if (!(pkg instanceof GoPackage)) continue;
+				for (const [moduleName, requireVersion] of pkg.mod.requires) {
+					const linked = graph.get(`go:${moduleName}`);
+					if (!linked || !(linked instanceof GoPackage)) continue;
+					if (semver.satisfies(linked.version, stripGoVersion(requireVersion))) continue;
+					pkg.setRequire(moduleName, linked.version);
+				}
+				writes.push(pkg.write());
+			}
+			await Promise.all(writes);
+		},
+		initPublishLock({ lock, draft }) {
+			if (!active) return;
+			for (const [id, packageDraft] of draft.getPackageDrafts()) {
+				const pkg = this.graph.get(id);
+				if (!(pkg instanceof GoPackage) || !packageDraft.type) continue;
+				lock.write("go:packages", {
+					id,
+					version: pkg.version
+				});
+			}
+		},
+		initPublishPlan({ lock, plan }) {
+			if (!active) return;
+			let data;
+			while (data = lock.read("go:packages")) {
+				const parsed = packageLockSchema.safeParse(data).data;
+				if (!parsed) continue;
+				const pkg = this.graph.get(parsed.id);
+				if (pkg instanceof GoPackage) pkg.setVersion(parsed.version);
+			}
+			for (const [id, packagePlan] of plan.packages) {
+				const pkg = this.graph.get(id);
+				if (!(pkg instanceof GoPackage)) continue;
+				packagePlan.git = { tag: formatGoTag(this.cwd, pkg.path, pkg.version) };
+			}
+		},
+		async publishPreflight({ pkg }) {
+			if (!(pkg instanceof GoPackage)) return;
+			const wait = [];
+			for (const [moduleName] of pkg.mod.requires) {
+				const linked = this.graph.get(`go:${moduleName}`);
+				if (linked instanceof GoPackage) wait.push(linked.id);
+			}
+			for (const replace of pkg.mod.replaces.values()) {
+				if (!replace.path) continue;
+				const linked = findLocalModule(this.graph, pkg.path, replace.path);
+				if (!linked) continue;
+				wait.push(linked.id);
+			}
+			return {
+				publish: !await isModulePublished(pkg.name, pkg.version),
+				wait
+			};
+		},
+		async publish({ pkg }) {
+			if (!(pkg instanceof GoPackage)) return;
+			return { type: "published" };
+		},
+		cli: { async draftApplied() {
+			if (!active || !updateLockFile) return;
+			if (await listGoWorkUsePaths(this.cwd)) {
+				const result = await x("go", ["work", "sync"], { nodeOptions: { cwd: this.cwd } });
+				if (result.exitCode !== 0) throw execFailure("Failed to run `go work sync`.", result);
+				return;
+			}
+			await Promise.all(this.graph.getPackages().map(async (pkg) => {
+				if (!(pkg instanceof GoPackage)) return;
+				const result = await x("go", ["mod", "tidy"], { nodeOptions: { cwd: pkg.path } });
+				if (result.exitCode !== 0) throw execFailure(`Failed to run \`go mod tidy\` in ${pkg.path}.`, result);
+			}));
+		} }
+	};
+}
+function depsPolicy({ graph }, getBumpDepType = () => "patch") {
+	return {
+		id: "go:deps",
+		onUpdate({ pkg, packageDraft: plan }) {
+			if (!(pkg instanceof GoPackage)) return;
+			const group = graph.getPackageGroup(pkg.id);
+			for (const dependent of graph.getPackages()) {
+				if (!(dependent instanceof GoPackage)) continue;
+				for (const [moduleName, requireVersion] of dependent.mod.requires) {
+					if (pkg.id !== `go:${moduleName}`) continue;
+					if (group?.options.syncBump && graph.getPackageGroup(dependent.id) === group) continue;
+					if (semver.satisfies(plan.bumpVersion(pkg), stripGoVersion(requireVersion))) continue;
+					const bumpType = getBumpDepType?.({
+						name: pkg.name,
+						dependent,
+						version: requireVersion
+					});
+					if (bumpType === false) continue;
+					this.bumpPackage(dependent, {
+						type: bumpType,
+						reason: `update require "${moduleName}"`
+					});
+				}
+			}
+		}
+	};
+}
+async function discoverGoPackages(cwd, add) {
+	const modulePaths = await listModulePaths(cwd);
+	await Promise.all(modulePaths.map(async (modulePath) => {
+		const mod = await readGoMod(modulePath).catch((error) => {
+			if (isNodeError(error) && error.code === "ENOENT") return void 0;
+			throw error;
+		});
+		if (!mod) return;
+		add(new GoPackage(modulePath, mod, await readLatestVersion(cwd, modulePath)));
+	}));
+}
+async function listModulePaths(cwd) {
+	const workPaths = await listGoWorkUsePaths(cwd);
+	if (workPaths) return workPaths;
+	if (await readGoMod(cwd)) return [cwd];
+	return [];
+}
+async function listGoWorkUsePaths(cwd) {
+	const result = await x("go", [
+		"work",
+		"edit",
+		"-json"
+	], { nodeOptions: { cwd } });
+	if (result.exitCode !== 0) return void 0;
+	const data = goWorkJsonSchema.safeParse(JSON.parse(result.stdout)).data;
+	if (!data?.Use?.length) return [cwd];
+	return data.Use.map((use) => resolve(cwd, use.DiskPath));
+}
+async function readGoMod(path) {
+	const result = await x("go", [
+		"mod",
+		"edit",
+		"-json"
+	], { nodeOptions: { cwd: path } });
+	if (result.exitCode !== 0) return;
+	const data = goModJsonSchema.safeParse(JSON.parse(result.stdout)).data;
+	if (!data) return;
+	const requires = /* @__PURE__ */ new Map();
+	for (const req of data.Require ?? []) if (req.Version) requires.set(req.Path, req.Version);
+	const replaces = /* @__PURE__ */ new Map();
+	for (const rep of data.Replace ?? []) replaces.set(rep.Old.Path, {
+		module: rep.New.Path,
+		path: rep.New.Version ? void 0 : rep.New.Path,
+		version: rep.New.Version
+	});
+	return {
+		module: data.Module.Path,
+		requires,
+		replaces
+	};
+}
+function findLocalModule(graph, modulePath, replacePath) {
+	const absolute = resolve(modulePath, replacePath);
+	return graph.getPackages().find((pkg) => pkg instanceof GoPackage && pkg.path === absolute);
+}
+async function readLatestVersion(cwd, modulePath) {
+	const result = await x("git", [
+		"tag",
+		"--list",
+		formatGoTag(cwd, modulePath, "v*"),
+		"--sort=-v:refname"
+	], { nodeOptions: { cwd } });
+	if (result.exitCode !== 0) return "0.0.0";
+	for (const tag of result.stdout.split("\n")) {
+		const version = parseTagVersion(tag.trim());
+		if (version) return version;
+	}
+	return "0.0.0";
+}
+function parseTagVersion(tag) {
+	const version = stripGoVersion(tag.slice(tag.lastIndexOf("/") + 1));
+	if (semver.valid(version)) return version;
+}
+function formatGoTag(cwd, modulePath, version) {
+	const relativeDir = relative(cwd, modulePath).replaceAll("\\", "/");
+	if (relativeDir === "") return formatGoVersion(version);
+	return `${relativeDir}/${formatGoVersion(version)}`;
+}
+function formatGoVersion(version) {
+	return version.startsWith("v") ? version : `v${version}`;
+}
+function stripGoVersion(version) {
+	return version.startsWith("v") ? version.slice(1) : version;
+}
+async function isModulePublished(module, version) {
+	const formatted = formatGoVersion(version);
+	const response = await fetch(`https://proxy.golang.org/${encodeURIComponent(module)}/@v/${formatted}.info`);
+	if (response.status === 200) return true;
+	if (response.status === 404) return false;
+	throw new Error(`Unable to validate ${module}@${formatted} against proxy.golang.org: ${await response.text()}`);
+}
+//#endregion
+export { GoPackage, go };

package/dist/providers/cargo.d.ts

@@ -1,2 +1,2 @@
-import { d as cargo, l as CargoPackage, u as CargoPluginOptions } from "../types-CurHqnWl.js";
+import { g as cargo, h as CargoPluginOptions, m as CargoPackage } from "../types-DnCUr2dB.js";
 export { CargoPackage, CargoPluginOptions, cargo };

package/dist/providers/cargo.js

@@ -1,5 +1,5 @@
 import { i as isNodeError, n as execFailure } from "../error-DNy8R5ue.js";
-import { n as WorkspacePackage } from "../graph-DrzluXw8.js";
+import { n as WorkspacePackage } from "../graph-OnX9ncdQ.js";
 import { readFile, writeFile } from "node:fs/promises";
 import { join, normalize } from "node:path";
 import { x } from "tinyexec";
@@ -147,6 +147,7 @@ function depsPolicy({ graph }, getBumpDepType = ({ kind }) => {
 					if (semver.satisfies(plan.bumpVersion(pkg), spec.version)) continue;
 					const bumpType = getBumpDepType({
 						kind,
+						dependent,
 						name: pkg.name,
 						version: spec.version
 					});
@@ -185,10 +186,7 @@ async function discoverCargoPackages(cwd, add) {
 	for (const entry of manifests) if (entry) addCargoPackage(entry.path, entry.manifest.manifest, entry.manifest.content, root.manifest, add);
 }
 function addCargoPackage(path, manifest, content, workspaceManifest, add) {
-	const packageInfo = tableValue(manifest.package);
-	const workspacePackage = tableValue(workspaceManifest.workspace)?.package;
-	if (!packageInfo?.name) return;
-	if (!packageInfo.version && !tableValue(workspacePackage)?.version) return;
+	if (!tableValue(manifest.package)?.name) return;
 	add(new CargoPackage(path, manifest, content, workspaceManifest));
 }
 async function expandWorkspaceMembers(cwd, members, exclude) {

package/dist/providers/npm.d.ts

@@ -1,2 +1,2 @@
-import { f as NpmPackage, m as npm, p as NpmPluginOptions } from "../types-CurHqnWl.js";
+import { _ as NpmPackage, v as NpmPluginOptions, y as npm } from "../types-DnCUr2dB.js";
 export { NpmPackage, NpmPluginOptions, npm };

package/dist/providers/npm.js

@@ -1,317 +1,2 @@
-import { i as isNodeError, n as execFailure } from "../error-DNy8R5ue.js";
-import { n as packageManifestSchema, r as pnpmWorkspaceSchema } from "../schemas-B7N6EE2k.js";
-import { n as WorkspacePackage } from "../graph-DrzluXw8.js";
-import { readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { x } from "tinyexec";
-import * as semver from "semver";
-import z from "zod";
-import { load } from "js-yaml";
-import { glob } from "tinyglobby";
-import { detect } from "package-manager-detector";
-//#region src/providers/npm.ts
-const DEP_FIELDS = [
-	"dependencies",
-	"devDependencies",
-	"peerDependencies",
-	"optionalDependencies"
-];
-var NpmPackage = class extends WorkspacePackage {
-	path;
-	manifest;
-	manager = "npm";
-	constructor(path, manifest) {
-		super();
-		this.path = path;
-		this.manifest = manifest;
-	}
-	get name() {
-		return this.manifest.name;
-	}
-	get version() {
-		return this.manifest.version ?? "0.0.0";
-	}
-	async write() {
-		await writeFile(path.join(this.path, "package.json"), `${JSON.stringify(this.manifest, null, 2)}\n`);
-	}
-	initDraft() {
-		const defaults = super.initDraft();
-		if (this.manifest.publishConfig?.tag) {
-			defaults.npm ??= {};
-			defaults.npm.distTag ??= this.manifest.publishConfig.tag;
-		}
-		return defaults;
-	}
-};
-function parseDependencySpec(context, dependent, name, range) {
-	const { graph } = context;
-	if (range.startsWith("workspace:")) return {
-		range: range.slice(10),
-		linked: graph.get(`npm:${name}`),
-		protocol: "workspace"
-	};
-	if (range.startsWith("file:")) {
-		let target = path.resolve(dependent.path, range.slice(5));
-		if (path.basename(target) === "package.json") target = path.dirname(target);
-		return {
-			protocol: "file",
-			raw: range,
-			linked: graph.getPackages().find((pkg) => pkg instanceof NpmPackage && pkg.path === target)
-		};
-	}
-	if (range.startsWith("npm:")) {
-		const spec = range.slice(4);
-		const separator = spec.lastIndexOf("@");
-		if (separator <= 0) return;
-		const alias = spec.slice(0, separator);
-		return {
-			alias,
-			linked: graph.get(`npm:${alias}`),
-			range: spec.slice(separator + 1),
-			protocol: "npm"
-		};
-	}
-	return {
-		linked: graph.get(`npm:${name}`),
-		range
-	};
-}
-function formatDependencySpec(spec) {
-	if (spec.protocol === "workspace") return `workspace:${spec.range}`;
-	if (spec.protocol === "file") return spec.raw;
-	if (spec.protocol === "npm") return `npm:${spec.alias}@${spec.range}`;
-	return spec.range;
-}
-const packageLockSchema = z.object({
-	id: z.string(),
-	distTag: z.string().optional()
-});
-function npm({ client: defaultClient, onBreakPeerDep = "set", updateLockFile = true, bumpDep: getBumpDepType = ({ kind }) => {
-	switch (kind) {
-		case "dependencies":
-		case "optionalDependencies": return "patch";
-		case "devDependencies": return false;
-		case "peerDependencies":
-			if (onBreakPeerDep === "ignore") return false;
-			return "major";
-	}
-} } = {}) {
-	let active = false;
-	let client;
-	return {
-		name: "npm",
-		enforce: "pre",
-		async init() {
-			if (defaultClient) client = defaultClient;
-			else client = (await detect({ cwd: this.cwd }))?.name ?? "npm";
-			this.npm = { client };
-		},
-		async resolve() {
-			await discoverNpmPackages(this.cwd, (pkg) => this.graph.add(pkg));
-			active = this.graph.getPackages().some((pkg) => pkg instanceof NpmPackage);
-		},
-		async publishPreflight({ pkg }) {
-			if (!(pkg instanceof NpmPackage)) return;
-			if (pkg.manifest.private === true) return { publish: false };
-			const registry = pkg.manifest.publishConfig?.registry;
-			const base = (registry ?? "https://registry.npmjs.org").replace(/\/$/, "");
-			const response = await fetch(`${base}/${pkg.name}/${pkg.version}`, { headers: { Accept: "application/json" } });
-			if (response.status === 404) return { publish: true };
-			if (!response.ok) throw new Error(`Unable to validate ${pkg.name}@${pkg.version} against the npm registry${registry ? ` "${registry}"` : ""}.`);
-			return { publish: false };
-		},
-		initPublishLock({ lock, draft }) {
-			for (const [id, pkg] of draft.getPackageDrafts()) {
-				if (!pkg.npm) continue;
-				lock.write("npm:packages", {
-					id,
-					distTag: pkg.npm.distTag
-				});
-			}
-		},
-		initPublishPlan({ lock, plan }) {
-			let data;
-			while (data = lock.read("npm:packages")) {
-				const parsed = packageLockSchema.safeParse(data).data;
-				if (!parsed) continue;
-				const packagePlan = plan.packages.get(parsed.id);
-				if (!packagePlan) continue;
-				packagePlan.npm = { distTag: parsed.distTag };
-			}
-		},
-		async publish({ pkg, plan }) {
-			if (!(pkg instanceof NpmPackage)) return;
-			const distTag = plan.packages.get(pkg.id).npm?.distTag;
-			if (client === "bun") {
-				const tarballPath = path.resolve(pkg.path, "pkg.tgz");
-				const packResult = await x("bun", [
-					"pm",
-					"pack",
-					"--filename",
-					tarballPath
-				], { nodeOptions: { cwd: pkg.path } });
-				if (packResult.exitCode !== 0) return {
-					type: "failed",
-					error: execFailure(`Failed to pack ${pkg.name}@${pkg.version}.`, packResult).message
-				};
-				const publishArgs = ["publish", tarballPath];
-				if (distTag) publishArgs.push("--tag", distTag);
-				const publishResult = await x("npm", publishArgs, { nodeOptions: { cwd: pkg.path } });
-				if (publishResult.exitCode !== 0) return {
-					type: "failed",
-					error: execFailure(`Failed to publish ${pkg.name}@${pkg.version}${distTag ? ` with dist-tag "${distTag}"` : ""}.`, publishResult).message
-				};
-				return { type: "published" };
-			}
-			let command;
-			const args = ["publish"];
-			if (distTag) args.push("--tag", distTag);
-			if (client === "pnpm") {
-				command = "pnpm";
-				args.push("--no-git-checks");
-			} else if (client === "yarn") command = "yarn";
-			else command = "npm";
-			const result = await x(command, args, { nodeOptions: { cwd: pkg.path } });
-			if (result.exitCode !== 0) return {
-				type: "failed",
-				error: execFailure(`Failed to publish ${pkg.name}@${pkg.version}${distTag ? ` with dist-tag "${distTag}"` : ""}.`, result).message
-			};
-			return { type: "published" };
-		},
-		initDraft(plan) {
-			if (!active) return;
-			plan.addPolicy(depsPolicy(this, getBumpDepType));
-		},
-		async applyDraft(draft) {
-			if (!active) return;
-			const { graph } = this;
-			const writes = [];
-			for (const pkg of graph.getPackages()) {
-				if (!(pkg instanceof NpmPackage)) continue;
-				const plan = draft.getPackageDraft(pkg.id);
-				if (plan) pkg.manifest.version = plan.bumpVersion(pkg);
-			}
-			for (const pkg of graph.getPackages()) {
-				if (!(pkg instanceof NpmPackage)) continue;
-				for (const field of DEP_FIELDS) {
-					const dependencies = pkg.manifest[field];
-					if (!dependencies) continue;
-					for (const [k, v] of Object.entries(dependencies)) {
-						const spec = parseDependencySpec(this, pkg, k, v);
-						if (!spec?.linked || spec.protocol === "workspace" || spec.protocol === "file") continue;
-						if (!semver.validRange(spec.range)) continue;
-						if (semver.satisfies(spec.linked.version, spec.range)) continue;
-						let updatedRange;
-						const isPeer = field === "peerDependencies";
-						if (isPeer && onBreakPeerDep === "ignore") continue;
-						else if (isPeer && onBreakPeerDep === "set") updatedRange = spec.linked.version;
-						else if (isPeer && onBreakPeerDep === "error") throw new Error(`[Tegami] the version of "${spec.linked.name}" is beyond its peer dependency constraint "${v}" in package "${pkg.name}", please update the constraint to satisfy.`);
-						else if (spec.range.startsWith("^")) updatedRange = `^${spec.linked.version}`;
-						else if (spec.range.startsWith("~")) updatedRange = `~${spec.linked.version}`;
-						else updatedRange = spec.linked.version;
-						dependencies[k] = formatDependencySpec({
-							...spec,
-							range: updatedRange
-						});
-					}
-				}
-				writes.push(pkg.write());
-			}
-			await Promise.all(writes);
-		},
-		cli: { async draftApplied() {
-			if (!active || !updateLockFile) return;
-			let args;
-			if (client === "npm") args = ["ci"];
-			else if (client === "yarn") args = ["install", "--immutable"];
-			else if (client === "bun") args = ["install", "--frozen-lockfile"];
-			else args = ["install", "--frozen-lockfile"];
-			const result = await x(client, args, { nodeOptions: { cwd: this.cwd } });
-			if (result.exitCode !== 0) throw execFailure("Failed to update lockfile.", result);
-		} }
-	};
-}
-function depsPolicy(context, getBumpDepType) {
-	const { graph } = context;
-	function needsUpdate(spec, target) {
-		if (spec.linked && spec.protocol === "workspace") switch (spec.range) {
-			case "":
-			case "*": return true;
-			case "^":
-			case "~": return !semver.satisfies(target, `${spec.range}${spec.linked.version}`);
-		}
-		if (spec.linked && spec.protocol === "file") return true;
-		if (spec.protocol === "file" || !semver.validRange(spec.range)) return false;
-		return !semver.satisfies(target, spec.range);
-	}
-	return {
-		id: "npm:deps",
-		onUpdate({ pkg, packageDraft: plan }) {
-			if (!(pkg instanceof NpmPackage)) return;
-			const group = graph.getPackageGroup(pkg.id);
-			for (const dependent of graph.getPackages()) {
-				if (!(dependent instanceof NpmPackage)) continue;
-				for (const field of DEP_FIELDS) {
-					const dependencies = dependent.manifest[field];
-					if (!dependencies) continue;
-					for (const [k, v] of Object.entries(dependencies)) {
-						const spec = parseDependencySpec(context, dependent, k, v);
-						if (!spec || spec.linked !== pkg) continue;
-						if (group?.options.syncBump && graph.getPackageGroup(dependent.id) === group) continue;
-						if (!needsUpdate(spec, plan.bumpVersion(pkg))) continue;
-						const bumpType = getBumpDepType({
-							kind: field,
-							spec,
-							name: k
-						});
-						if (bumpType === false) continue;
-						this.bumpPackage(dependent, {
-							type: bumpType,
-							reason: `update dependency "${k}"`
-						});
-					}
-				}
-			}
-		}
-	};
-}
-async function discoverNpmPackages(cwd, add) {
-	let patterns;
-	const rootManifest = await readManifest(cwd).catch(() => void 0);
-	const pnpmPatterns = await readFile(path.join(cwd, "pnpm-workspace.yaml"), "utf8").then((content) => pnpmWorkspaceSchema.parse(load(content) ?? {})).catch((error) => {
-		if (isNodeError(error) && error.code === "ENOENT") return void 0;
-		throw error;
-	});
-	if (pnpmPatterns) patterns = pnpmPatterns.packages ?? [];
-	else patterns = rootManifest?.workspaces ?? [];
-	const candidatePaths = await expandWorkspacePatterns(cwd, patterns);
-	const manifests = await Promise.all(candidatePaths.map((path) => readManifest(path).then((manifest) => ({
-		path,
-		manifest
-	})).catch(() => void 0)));
-	if (rootManifest?.version) add(new NpmPackage(cwd, rootManifest));
-	for (const entry of manifests) {
-		if (!entry?.manifest.version) continue;
-		add(new NpmPackage(entry.path, entry.manifest));
-	}
-}
-async function expandWorkspacePatterns(cwd, patterns) {
-	if (patterns.length === 0) return [];
-	return (await glob(patterns, {
-		absolute: true,
-		cwd,
-		ignore: ["**/node_modules/**", "**/dist/**"],
-		onlyDirectories: true,
-		onlyFiles: false
-	})).map((item) => {
-		return item.endsWith(path.sep) ? item.slice(0, -1) : item;
-	});
-}
-async function readManifest(packagePath) {
-	const content = await readFile(path.join(packagePath, "package.json"), "utf8");
-	const parsed = JSON.parse(content);
-	packageManifestSchema.parse(parsed);
-	return parsed;
-}
-//#endregion
+import { n as npm, t as NpmPackage } from "../npm-Q0qvAkIu.js";
 export { NpmPackage, npm };

package/dist/{semver-C4vJ4SK8.js → semver-jcIUAvbl.js}

@@ -33,7 +33,8 @@ function bumpVersion(version, type, prerelease) {
 	const parsed = parse(version);
 	if (!parsed) next = null;
 	else if (prerelease) {
-		if (parsed.prerelease[0] === prerelease && type) next = inc(parsed, "prerelease", prerelease);
+		if (parsed.prerelease[0] === prerelease) next = type ? inc(parsed, "prerelease", prerelease) : version;
+		else if (parsed.prerelease[0]) next = inc(parsed, "prerelease", prerelease);
 		else if (type) next = inc(parsed, PRE[type], prerelease);
 	} else if (type) next = inc(parsed, type);
 	else if (parsed.prerelease.length > 0) next = inc(parsed, "release");