tegami 1.0.1 → 1.1.0

package/dist/plugins/cargo.js

@@ -1,40 +1,76 @@
 import { n as execFailure } from "../error-BhMYq9iW.js";
-import { n as WorkspacePackage } from "../graph-gThXu8Cz.js";
+import { n as WorkspacePackage } from "../graph-BmXTJZxx.js";
 import { readFile, writeFile } from "node:fs/promises";
-import { join, normalize } from "node:path";
+import path from "node:path";
 import { x } from "tinyexec";
 import * as semver$1 from "semver";
 import z from "zod";
 import { glob } from "tinyglobby";
 import initToml, { edit, parse as parse$1 } from "@rainbowatcher/toml-edit-js";
 //#region src/plugins/cargo/schema.ts
-const cargoDependencySchema = z.union([z.string(), z.object({
-	version: z.string(),
+const baseDepSchema = z.object({
 	package: z.string().optional(),
-	path: z.string().optional()
-})]);
-const cargoTargetConfigSchema = z.object({
-	dependencies: z.record(z.string(), cargoDependencySchema).optional(),
-	"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
-	"build-dependencies": z.record(z.string(), cargoDependencySchema).optional()
+	features: z.array(z.string()).optional(),
+	optional: z.boolean().optional(),
+	"default-features": z.boolean().optional()
 });
-const cargoPackageSchema = z.object({
-	name: z.string(),
-	version: z.string().optional(),
-	publish: z.boolean().optional()
+/** `{ workspace = true }` — inherit from `[workspace.dependencies]` */
+const workspaceDependencySchema = baseDepSchema.extend({ workspace: z.literal(true) });
+/** `{ path = "../lib" }` — optional `version` for publishing */
+const pathDependencySchema = baseDepSchema.extend({
+	path: z.string(),
+	version: z.string().optional()
 });
-const cargoWorkspaceSchema = z.object({
+/** `{ git = "…" }` — exactly one of `branch`, `tag`, or `rev` in practice */
+const gitDependencySchema = baseDepSchema.extend({
+	git: z.string(),
+	branch: z.string().optional(),
+	tag: z.string().optional(),
+	rev: z.string().optional(),
+	version: z.string().optional()
+});
+/** `{ version = "1.0" }` — crates.io or `[registries]` */
+const registryDependencySchema = baseDepSchema.extend({
+	version: z.string(),
+	registry: z.string().optional()
+});
+/**
+* @see https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html
+*/
+const cargoDependencySchema = z.union([
+	z.string(),
+	workspaceDependencySchema,
+	pathDependencySchema,
+	gitDependencySchema,
+	registryDependencySchema
+]);
+const cargoInheritSchema = z.looseObject({ workspace: z.literal(true) });
+const cargoWorkspaceSchema = z.looseObject({
 	members: z.array(z.string()).optional(),
 	exclude: z.array(z.string()).optional(),
-	package: z.object({ version: z.string().optional() }).optional()
+	package: z.looseObject({
+		version: z.string().optional(),
+		publish: z.boolean().optional()
+	}).optional(),
+	dependencies: z.record(z.string(), cargoDependencySchema).optional(),
+	"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
+	"build-dependencies": z.record(z.string(), cargoDependencySchema).optional()
 });
-const cargoManifestSchema = z.object({
-	package: cargoPackageSchema,
+const cargoManifestSchema = z.looseObject({
+	package: z.looseObject({
+		name: z.string(),
+		version: z.string().or(cargoInheritSchema),
+		publish: z.boolean().or(cargoInheritSchema).optional()
+	}).optional(),
 	workspace: cargoWorkspaceSchema.optional(),
 	dependencies: z.record(z.string(), cargoDependencySchema).optional(),
 	"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
 	"build-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
-	target: z.record(z.string(), cargoTargetConfigSchema).optional()
+	target: z.record(z.string(), z.looseObject({
+		dependencies: z.record(z.string(), cargoDependencySchema).optional(),
+		"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
+		"build-dependencies": z.record(z.string(), cargoDependencySchema).optional()
+	})).optional()
 });
 //#endregion
 //#region src/plugins/cargo.ts
@@ -43,44 +79,61 @@ const DEP_FIELDS = [
 	"dev-dependencies",
 	"build-dependencies"
 ];
-var CargoPackage = class extends WorkspacePackage {
+var CargoToml = class {
 	path;
-	manifest;
 	content;
-	workspaceManifest;
+	data;
+	dependencies;
+	workspace;
+	constructor(path, content, data) {
+		this.path = path;
+		this.content = content;
+		this.data = data;
+	}
+	listDependencies(graph) {
+		return this.dependencies ??= listDependencies(graph, this);
+	}
+	patch(path, value) {
+		this.content = edit(this.content, path, value);
+	}
+};
+var CargoPackage = class extends WorkspacePackage {
+	path;
+	file;
 	manager = "cargo";
-	constructor(path, manifest, content, workspaceManifest) {
+	manifest;
+	constructor(path, file) {
 		super();
 		this.path = path;
-		this.manifest = manifest;
-		this.content = content;
-		this.workspaceManifest = workspaceManifest;
+		this.file = file;
+		this.manifest = file.data;
 	}
 	get name() {
-		return this.packageInfo.name;
+		return this.manifest.package.name;
 	}
 	get version() {
-		return this.packageInfo.version ?? this.workspaceVersion;
+		const packageVersion = this.manifest.package.version;
+		if (typeof packageVersion === "string") return packageVersion;
+		const inherited = this.file.workspace?.data.workspace.package;
+		if (packageVersion.workspace && inherited?.version) return inherited.version;
+		throw new Error(`Invalid Cargo.toml in "${this.path}".`);
 	}
 	setVersion(version) {
-		this.packageInfo.version = version;
-		this.patch("package.version", version);
-	}
-	async write() {
-		await writeFile(join(this.path, "Cargo.toml"), this.content + "\n");
-	}
-	patch(path, value) {
-		this.content = edit(this.content, path, value);
-	}
-	get packageInfo() {
-		return this.manifest.package;
-	}
-	get workspaceVersion() {
-		return this.workspaceManifest?.workspace?.package?.version;
+		const packageInfo = this.manifest.package;
+		if (typeof packageInfo.version === "string") {
+			packageInfo.version = version;
+			this.file.patch("package.version", version);
+			return;
+		}
+		if (packageInfo.version.workspace && this.file.workspace?.data.workspace.package) {
+			this.file.workspace.data.workspace.package.version = version;
+			this.file.workspace.patch("workspace.package.version", version);
+			return;
+		}
+		throw new Error(`Invalid Cargo.toml in "${this.path}".`);
 	}
 };
 function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
-	let active = false;
 	return {
 		name: "cargo",
 		enforce: "pre",
@@ -88,34 +141,33 @@ function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 			await initToml();
 		},
 		async resolve() {
-			await discoverCargoPackages(this.cwd, (pkg) => this.graph.add(pkg));
-			active = this.graph.getPackages().some((pkg) => pkg instanceof CargoPackage);
+			const graph = await resolveCargoGraph(this.cwd);
+			if (graph.packages.size === 0) return;
+			this.cargo = { graph };
+			for (const pkg of graph.packages.values()) this.graph.add(pkg);
 		},
 		initDraft(plan) {
-			if (!active) return;
+			if (!this.cargo) return;
 			plan.addPolicy(depsPolicy(this, getBumpDepType));
 		},
 		async publishPreflight({ pkg }) {
-			if (!(pkg instanceof CargoPackage)) return;
+			if (!(pkg instanceof CargoPackage) || !this.cargo) return;
+			let shouldPublish = true;
+			if (typeof pkg.manifest.package.publish === "boolean") shouldPublish = pkg.manifest.package.publish;
+			else if (pkg.manifest.package.publish?.workspace) shouldPublish = pkg.file.workspace?.data.workspace?.package?.publish ?? shouldPublish;
 			const wait = [];
-			for (const { table } of dependencyTables(pkg.manifest, "")) for (const [rawName, dep] of Object.entries(table)) {
-				if (!dep || typeof dep === "string" || !dep.path) continue;
-				const id = `cargo:${dep.package ?? rawName}`;
-				const linked = this.graph.get(id);
-				if (!linked || !(linked instanceof CargoPackage)) continue;
-				wait.push(id);
-			}
+			for (const { resolved } of pkg.file.listDependencies(this.cargo.graph)) if (resolved) wait.push(resolved.id);
 			return {
-				shouldPublish: pkg.version !== void 0 && pkg.packageInfo.publish !== false,
+				shouldPublish,
 				wait
 			};
 		},
 		resolvePlanStatus({ plan }) {
-			if (!active) return;
+			if (!this.cargo) return;
 			return Array.from(plan.packages, async ([id, { preflight }]) => {
 				if (!preflight.shouldPublish) return;
 				const pkg = this.graph.get(id);
-				if (!(pkg instanceof CargoPackage) || !pkg.version) return;
+				if (!(pkg instanceof CargoPackage)) return;
 				if (!await isPackagePublished(pkg.name, pkg.version)) return "pending";
 			});
 		},
@@ -132,70 +184,57 @@ function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 			return { type: "published" };
 		},
 		async applyDraft(draft) {
-			if (!active) return;
-			const { graph } = this;
-			const writes = [];
-			for (const pkg of graph.getPackages()) {
-				if (!(pkg instanceof CargoPackage)) continue;
+			if (!this.cargo) return;
+			const graph = this.cargo.graph;
+			for (const pkg of graph.packages.values()) {
 				const bumped = draft.getPackageDraft(pkg.id)?.bumpVersion(pkg);
 				if (bumped) pkg.setVersion(bumped);
 			}
-			for (const pkg of graph.getPackages()) {
-				if (!(pkg instanceof CargoPackage)) continue;
-				for (const { table, path: tablePath } of dependencyTables(pkg.manifest, "")) for (const [rawName, rawSpec] of Object.entries(table)) {
-					const spec = parseSpec(rawSpec);
-					if (!spec || !semver$1.validRange(spec.version)) continue;
-					const packageName = spec.package ?? rawName;
-					const linked = graph.get(`cargo:${packageName}`);
-					if (!linked || !(linked instanceof CargoPackage)) continue;
-					if (!linked.version || semver$1.satisfies(linked.version, spec.version)) continue;
-					let updatedRange;
-					if (spec.version.startsWith("^")) updatedRange = `^${linked.version}`;
-					else if (spec.version.startsWith("~")) updatedRange = `~${linked.version}`;
-					else updatedRange = linked.version;
-					table[rawName] = spec.setVersion(updatedRange);
-					pkg.patch(typeof rawSpec === "string" ? `${tablePath}.${rawName}` : `${tablePath}.${rawName}.version`, updatedRange);
-				}
-				writes.push(pkg.write());
+			for (const file of graph.files.values()) for (const { range, resolved, setRange } of file.listDependencies(graph)) {
+				if (!resolved || !range || !setRange || semver$1.satisfies(resolved.version, range)) continue;
+				let updatedRange;
+				if (range.startsWith("^")) updatedRange = `^${resolved.version}`;
+				else if (range.startsWith("~")) updatedRange = `~${resolved.version}`;
+				else updatedRange = resolved.version;
+				setRange(updatedRange);
 			}
-			await Promise.all(writes);
+			await Promise.all(Array.from(graph.files.values(), (file) => writeFile(file.path, file.content + "\n")));
 		},
 		async applyCliDraft() {
-			if (!active || !updateLockFile) return;
+			if (!this.cargo || !updateLockFile) return;
 			const result = await x("cargo", ["update", "--workspace"], { nodeOptions: { cwd: this.cwd } });
 			if (result.exitCode !== 0) throw execFailure("Failed to update Cargo lock file", result);
 		}
 	};
 }
-function depsPolicy({ graph }, getBumpDepType = ({ kind }) => {
+function depsPolicy({ cargo }, getBumpDepType = ({ kind }) => {
 	switch (kind) {
 		case "dependencies": return "patch";
 		case "build-dependencies":
 		case "dev-dependencies": return false;
 	}
 }) {
+	const cargoGraph = cargo.graph;
 	const dependentMap = /* @__PURE__ */ new Map();
-	for (const pkg of graph.getPackages()) {
-		if (!(pkg instanceof CargoPackage)) continue;
-		for (const { table, kind } of dependencyTables(pkg.manifest, "")) for (const [rawName, rawSpec] of Object.entries(table)) {
-			const spec = parseSpec(rawSpec);
-			if (!spec || !semver$1.validRange(spec.version)) continue;
-			const name = spec.package ?? rawName;
-			const id = `cargo:${name}`;
-			const refs = dependentMap.get(id);
-			if (refs) refs.push({
-				dependent: pkg,
-				kind,
-				name,
-				version: spec.version
-			});
-			else dependentMap.set(id, [{
-				dependent: pkg,
-				kind,
-				name,
-				version: spec.version
-			}]);
-		}
+	for (const pkg of cargoGraph.packages.values()) for (const { resolved, path, spec, range } of pkg.file.listDependencies(cargoGraph)) {
+		if (!resolved) continue;
+		const refs = dependentMap.get(resolved.id);
+		const kind = path[path.length - 2];
+		const name = path[path.length - 1];
+		if (refs) refs.push({
+			dependent: pkg,
+			kind,
+			name,
+			spec,
+			version: range
+		});
+		else dependentMap.set(resolved.id, [{
+			dependent: pkg,
+			kind,
+			name,
+			spec,
+			version: range
+		}]);
 	}
 	return {
 		id: "cargo:deps",
@@ -203,17 +242,16 @@ function depsPolicy({ graph }, getBumpDepType = ({ kind }) => {
 			if (!(pkg instanceof CargoPackage)) return;
 			const deps = dependentMap.get(pkg.id);
 			if (!deps) return;
-			const group = graph.getPackageGroup(pkg.id);
 			const bumped = plan.bumpVersion(pkg);
 			if (!bumped) return;
 			for (const dep of deps) {
-				if (group?.options.syncBump && graph.getPackageGroup(dep.dependent.id) === group) continue;
-				if (semver$1.satisfies(bumped, dep.version)) continue;
+				if (pkg.group?.options.syncBump && dep.dependent.group === pkg.group) continue;
+				if (dep.version && semver$1.satisfies(bumped, dep.version)) continue;
 				const bumpType = getBumpDepType(dep);
 				if (bumpType === false) continue;
 				this.bumpPackage(dep.dependent, {
 					type: bumpType,
-					reason: `update dependency "${dep.name}"`
+					reason: `update dependency "${pkg.name}"`
 				});
 			}
 		}
@@ -225,81 +263,139 @@ async function isPackagePublished(name, version) {
 	if (response.status === 404) return false;
 	throw new Error(`Unable to validate ${name}@${version} against crates.io: ${await response.text()}`);
 }
-async function buildEntry(path) {
+async function buildEntry(dir) {
 	try {
-		const content = await readFile(join(path, "Cargo.toml"), "utf8");
-		return {
-			manifest: cargoManifestSchema.parse(parse$1(content)),
-			content,
-			path
-		};
+		const filePath = path.join(dir, "Cargo.toml");
+		const content = await readFile(filePath, "utf8");
+		return new CargoToml(filePath, content, cargoManifestSchema.parse(parse$1(content)));
 	} catch {
 		return;
 	}
 }
-async function discoverCargoPackages(cwd, add) {
+async function resolveCargoGraph(cwd) {
+	const out = {
+		packages: /* @__PURE__ */ new Map(),
+		files: /* @__PURE__ */ new Map()
+	};
 	const root = await buildEntry(cwd);
-	if (!root) return;
-	if (root.manifest.package?.name) add(new CargoPackage(cwd, root.manifest, root.content, root.manifest));
-	const workspace = root.manifest.workspace;
-	if (!workspace?.members) return;
-	const paths = await expandWorkspaceMembers(cwd, workspace.members, workspace.exclude);
-	const manifests = await Promise.all(paths.map(buildEntry));
-	for (const entry of manifests) if (entry?.manifest.package?.name) add(new CargoPackage(entry.path, entry.manifest, entry.content, root.manifest));
+	if (!root) return out;
+	out.files.set(root.path, root);
+	if (root.data.package) {
+		const pkg = new CargoPackage(cwd, root);
+		out.packages.set(pkg.name, pkg);
+	}
+	if (root.data.workspace?.members) {
+		root.workspace = root;
+		const dirs = await expandWorkspaceMembers(cwd, root.data.workspace.members, root.data.workspace.exclude);
+		await Promise.all(dirs.map(async (dir) => {
+			const entry = await buildEntry(dir);
+			if (!entry || !entry.data.package) return;
+			entry.workspace = root;
+			const pkg = new CargoPackage(dir, entry);
+			out.files.set(entry.path, entry);
+			out.packages.set(pkg.name, pkg);
+		}));
+	}
+	return out;
 }
 async function expandWorkspaceMembers(cwd, members, exclude = []) {
-	const paths = members.includes(".") ? [cwd] : [];
 	const patterns = members.filter((member) => member !== ".");
-	if (patterns.length > 0) paths.push(...await glob(patterns, {
+	if (patterns.length === 0) return [];
+	return (await glob(patterns, {
 		absolute: true,
 		cwd,
 		ignore: ["**/target/**", ...exclude],
 		onlyDirectories: true,
 		onlyFiles: false
-	}));
-	return paths.map(normalize);
+	})).map((item) => {
+		return item.endsWith(path.sep) ? item.slice(0, -1) : item;
+	});
 }
-function dependencyTables(manifest, prefix) {
-	const tables = [];
-	for (const field of DEP_FIELDS) {
-		const table = manifest[field];
-		if (table) {
-			const path = prefix ? `${prefix}.${field}` : field;
-			tables.push({
-				kind: field,
-				table,
-				path
-			});
-		}
-	}
-	const target = manifest.target;
-	if (target) for (const [targetKey, targetConfig] of Object.entries(target)) {
-		const targetPath = prefix ? `${prefix}.target.${targetKey}` : `target.${targetKey}`;
+function listDependencies(graph, file) {
+	const out = [];
+	function scan(obj, prefix = []) {
 		for (const field of DEP_FIELDS) {
-			const table = targetConfig[field];
-			if (table) tables.push({
-				kind: field,
-				table,
-				path: `${targetPath}.${field}`
-			});
+			const table = obj[field];
+			if (!table) continue;
+			const tablePath = [...prefix, field];
+			for (const [key, spec] of Object.entries(table)) {
+				const { linked, range, setRange } = resolveLinkedDep(file, graph, tablePath, key, spec) ?? {};
+				out.push({
+					path: [...tablePath, key],
+					spec,
+					resolved: linked,
+					range,
+					setRange: setRange && ((v) => {
+						table[key] = setRange(v);
+					})
+				});
+			}
 		}
 	}
-	return tables;
+	scan(file.data);
+	if (file.data.target) for (const [key, config] of Object.entries(file.data.target)) scan(config, ["target", key]);
+	if (file.data.workspace) scan(file.data.workspace);
+	return out;
 }
-function parseSpec(v) {
-	if (typeof v === "string") return {
-		version: v,
-		setVersion(version) {
-			return version;
+function resolveLinkedDep(file, graph, tablePath, key, spec) {
+	if (typeof spec === "string") {
+		const linked = graph.packages.get(key);
+		if (!linked) return;
+		return {
+			linked,
+			range: spec,
+			setRange(v) {
+				file.patch([...tablePath, key].join("."), v);
+				return v;
+			}
+		};
+	}
+	if ("git" in spec) return;
+	if ("workspace" in spec) {
+		const kind = tablePath[tablePath.length - 1];
+		const entry = file.workspace?.data.workspace?.[kind]?.[key];
+		if (!entry) return;
+		const resolved = resolveLinkedDep(file.workspace, graph, ["workspace", kind], key, entry);
+		if (!resolved) return;
+		delete resolved.setRange;
+		return resolved;
+	}
+	if ("path" in spec) {
+		const pkgPath = path.resolve(path.dirname(file.path), spec.path);
+		for (const pkg of graph.packages.values()) {
+			if (pkg.path !== pkgPath) continue;
+			return {
+				linked: pkg,
+				range: spec.version,
+				setRange(v) {
+					file.patch([
+						...tablePath,
+						key,
+						"version"
+					].join("."), v);
+					return {
+						...spec,
+						version: v
+					};
+				}
+			};
 		}
-	};
+		return;
+	}
+	const linked = graph.packages.get(spec.package ?? key);
+	if (!linked) return;
 	return {
-		package: v.package,
-		version: v.version,
-		setVersion(version) {
+		linked,
+		range: spec.version,
+		setRange(v) {
+			file.patch([
+				...tablePath,
+				key,
+				"version"
+			].join("."), v);
 			return {
-				...v,
-				version
+				...spec,
+				version: v
 			};
 		}
 	};

package/dist/plugins/git.d.ts

@@ -1,4 +1,4 @@
-import { s as TegamiPlugin } from "../types-DItu_YCc.js";
+import { s as TegamiPlugin } from "../types-BoQR7Hlg.js";
 
 //#region src/plugins/git.d.ts
 interface GitPluginOptions {

package/dist/plugins/git.js

@@ -43,9 +43,8 @@ function git(options = {}) {
 			const { graph } = this;
 			for (const [id, packagePlan] of plan.packages) {
 				const pkg = graph.get(id);
-				const group = graph.getPackageGroup(pkg.id);
 				packagePlan.git ??= {};
-				if (group?.options.syncGitTag && pkg.version) packagePlan.git.tag = `${group.name}@${pkg.version}`;
+				if (pkg.group?.options.syncGitTag && pkg.version) packagePlan.git.tag = `${pkg.group.name}@${pkg.version}`;
 				else if (pkg.version) packagePlan.git.tag = `${pkg.name}@${pkg.version}`;
 			}
 		},

package/dist/plugins/github.d.ts

@@ -1,4 +1,4 @@
-import { T as Draft, s as TegamiPlugin, t as Awaitable, w as WorkspacePackage, x as TegamiContext, y as PublishPlan } from "../types-DItu_YCc.js";
+import { O as WorkspacePackage, k as Draft, s as TegamiPlugin, t as Awaitable, x as TegamiContext, y as PublishPlan } from "../types-BoQR7Hlg.js";
 import { GitPluginOptions } from "./git.js";
 
 //#region src/plugins/github.d.ts

package/dist/plugins/github.js

@@ -1,7 +1,7 @@
 import { i as formatPackageVersion, r as formatNpmDistTag } from "../semver-EKJ8yK5U.js";
 import { t as changelogFilename } from "../generate-Rvz4Lu98.js";
 import { a as cached, n as execFailure, o as isCI } from "../error-BhMYq9iW.js";
-import { n as createDraft, o as readChangelogEntries } from "../draft-BqHcSCeX.js";
+import { n as createDraft, o as readChangelogEntries } from "../draft-BLbt4bSG.js";
 import { git } from "./git.js";
 import { n as createVersionRequestBody, r as hasGitChanges, t as commitVersionBranchChanges } from "../version-request-oxy16TJ1.js";
 import { readFile, writeFile } from "node:fs/promises";

package/dist/plugins/gitlab.d.ts

@@ -1,4 +1,4 @@
-import { T as Draft, s as TegamiPlugin, t as Awaitable, w as WorkspacePackage, x as TegamiContext, y as PublishPlan } from "../types-DItu_YCc.js";
+import { O as WorkspacePackage, k as Draft, s as TegamiPlugin, t as Awaitable, x as TegamiContext, y as PublishPlan } from "../types-BoQR7Hlg.js";
 import { GitPluginOptions } from "./git.js";
 
 //#region src/plugins/gitlab.d.ts

package/dist/plugins/gitlab.js

@@ -1,7 +1,7 @@
 import { i as formatPackageVersion, r as formatNpmDistTag } from "../semver-EKJ8yK5U.js";
 import { t as changelogFilename } from "../generate-Rvz4Lu98.js";
 import { a as cached, n as execFailure, o as isCI, s as joinPath } from "../error-BhMYq9iW.js";
-import { n as createDraft, o as readChangelogEntries } from "../draft-BqHcSCeX.js";
+import { n as createDraft, o as readChangelogEntries } from "../draft-BLbt4bSG.js";
 import { git } from "./git.js";
 import { n as createVersionRequestBody, r as hasGitChanges, t as commitVersionBranchChanges } from "../version-request-oxy16TJ1.js";
 import { readFile, writeFile } from "node:fs/promises";

package/dist/plugins/go.d.ts

@@ -1,4 +1,4 @@
-import { O as BumpType, s as TegamiPlugin, w as WorkspacePackage } from "../types-DItu_YCc.js";
+import { M as BumpType, O as WorkspacePackage, s as TegamiPlugin } from "../types-BoQR7Hlg.js";
 
 //#region src/plugins/go.d.ts
 interface GoModFile {

package/dist/plugins/go.js

@@ -1,5 +1,5 @@
 import { i as isNodeError, n as execFailure } from "../error-BhMYq9iW.js";
-import { n as WorkspacePackage } from "../graph-gThXu8Cz.js";
+import { n as WorkspacePackage } from "../graph-BmXTJZxx.js";
 import { relative, resolve } from "node:path";
 import { x } from "tinyexec";
 import * as semver$1 from "semver";
@@ -135,7 +135,7 @@ function go({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 		},
 		async publishPreflight({ pkg }) {
 			if (!(pkg instanceof GoPackage)) return;
-			const shouldPublish = pkg.getPackageOptions().go?.publish ?? this.graph.getPackageGroup(pkg.id)?.options?.go?.publish ?? true;
+			const shouldPublish = pkg.options.go?.publish ?? pkg.group?.options?.go?.publish ?? true;
 			const wait = [];
 			for (const [moduleName] of pkg.mod.requires) {
 				const linked = this.graph.get(`go:${moduleName}`);
@@ -205,11 +205,10 @@ function depsPolicy({ graph }, getBumpDepType = () => "patch") {
 			if (!(pkg instanceof GoPackage)) return;
 			const deps = dependentMap.get(pkg.id);
 			if (!deps) return;
-			const group = graph.getPackageGroup(pkg.id);
 			const bumped = plan.bumpVersion(pkg);
 			if (!bumped) return;
 			for (const dep of deps) {
-				if (group?.options.syncBump && graph.getPackageGroup(dep.dependent.id) === group) continue;
+				if (pkg.group?.options.syncBump && dep.dependent.group === pkg.group) continue;
 				if (semver$1.satisfies(bumped, stripGoVersion(dep.version))) continue;
 				const bumpType = getBumpDepType?.(dep);
 				if (bumpType === false) continue;

package/dist/providers/npm.d.ts

@@ -1,2 +1,2 @@
-import { d as npm, l as NpmPackage, u as NpmPluginOptions } from "../types-DItu_YCc.js";
+import { d as npm, l as NpmPackage, u as NpmPluginOptions } from "../types-BoQR7Hlg.js";
 export { NpmPackage, NpmPluginOptions, npm };

package/dist/providers/npm.js

@@ -1,2 +1,2 @@
-import { n as npm, t as NpmPackage } from "../npm-1iEegfHg.js";
+import { n as npm, t as NpmPackage } from "../npm-Cj685Ddn.js";
 export { NpmPackage, npm };