tegami 1.0.0-beta.5 → 1.0.2

package/dist/utils/index.js

@@ -1,2 +1,2 @@
-import { n as execFailure } from "../error-We7chQVJ.js";
+import { n as execFailure } from "../error-BhMYq9iW.js";
 export { execFailure };

package/dist/{version-request-DKvR3_xb.js → version-request-oxy16TJ1.js}

@@ -1,5 +1,5 @@
 import { r as formatNpmDistTag } from "./semver-EKJ8yK5U.js";
-import { n as execFailure } from "./error-We7chQVJ.js";
+import { n as execFailure } from "./error-BhMYq9iW.js";
 import { x } from "tinyexec";
 //#region src/utils/version-request.ts
 async function hasGitChanges(cwd) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tegami",
-  "version": "1.0.0-beta.5",
+  "version": "1.0.2",
   "description": "Utility for package versioning & publish",
   "license": "MIT",
   "author": "Fuma Nama",
@@ -16,11 +16,11 @@
     ".": "./dist/index.js",
     "./cli": "./dist/cli/index.js",
     "./generators/simple": "./dist/generators/simple.js",
+    "./plugins/cargo": "./dist/plugins/cargo.js",
     "./plugins/git": "./dist/plugins/git.js",
     "./plugins/github": "./dist/plugins/github.js",
     "./plugins/gitlab": "./dist/plugins/gitlab.js",
     "./plugins/go": "./dist/plugins/go.js",
-    "./providers/cargo": "./dist/providers/cargo.js",
     "./providers/npm": "./dist/providers/npm.js",
     "./utils": "./dist/utils/index.js",
     "./package.json": "./package.json"

package/dist/cargo-hlZX2akE.js

@@ -1,292 +0,0 @@
-import { n as execFailure } from "./error-We7chQVJ.js";
-import { n as WorkspacePackage } from "./graph-gThXu8Cz.js";
-import { readFile, writeFile } from "node:fs/promises";
-import { join, normalize } from "node:path";
-import { x } from "tinyexec";
-import * as semver$1 from "semver";
-import z from "zod";
-import initToml, { edit, parse as parse$1 } from "@rainbowatcher/toml-edit-js";
-import { glob } from "tinyglobby";
-//#region src/providers/cargo/schema.ts
-const cargoDependencySchema = z.union([z.string(), z.object({
-	version: z.string(),
-	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()
-});
-const cargoPackageSchema = z.object({
-	name: z.string(),
-	version: z.string().optional(),
-	publish: z.boolean().optional()
-});
-const cargoWorkspaceSchema = z.object({
-	members: z.array(z.string()).optional(),
-	exclude: z.array(z.string()).optional(),
-	package: z.object({ version: z.string().optional() }).optional()
-});
-const cargoManifestSchema = z.object({
-	package: cargoPackageSchema,
-	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()
-});
-//#endregion
-//#region src/providers/cargo.ts
-const DEP_FIELDS = [
-	"dependencies",
-	"dev-dependencies",
-	"build-dependencies"
-];
-var CargoPackage = class extends WorkspacePackage {
-	path;
-	manifest;
-	content;
-	workspaceManifest;
-	manager = "cargo";
-	constructor(path, manifest, content, workspaceManifest) {
-		super();
-		this.path = path;
-		this.manifest = manifest;
-		this.content = content;
-		this.workspaceManifest = workspaceManifest;
-	}
-	get name() {
-		return this.packageInfo.name;
-	}
-	get version() {
-		return this.packageInfo.version ?? this.workspaceVersion;
-	}
-	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;
-	}
-};
-function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
-	let active = false;
-	return {
-		name: "cargo",
-		enforce: "pre",
-		async init() {
-			await initToml();
-		},
-		async resolve() {
-			await discoverCargoPackages(this.cwd, (pkg) => this.graph.add(pkg));
-			active = this.graph.getPackages().some((pkg) => pkg instanceof CargoPackage);
-		},
-		initDraft(plan) {
-			if (!active) return;
-			plan.addPolicy(depsPolicy(this, getBumpDepType));
-		},
-		async publishPreflight({ pkg }) {
-			if (!(pkg instanceof CargoPackage)) return;
-			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);
-			}
-			return {
-				shouldPublish: pkg.version !== void 0 && pkg.packageInfo.publish !== false,
-				wait
-			};
-		},
-		resolvePlanStatus({ plan }) {
-			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 (!await isPackagePublished(pkg.name, pkg.version)) return "pending";
-			});
-		},
-		async publish({ pkg }) {
-			if (!(pkg instanceof CargoPackage)) return;
-			const result = await x("cargo", ["publish"], { nodeOptions: { cwd: pkg.path } });
-			if (result.exitCode !== 0) {
-				if (/already exists|already published/i.test(`${result.stdout}\n${result.stderr}`)) return { type: "skipped" };
-				return {
-					type: "failed",
-					error: execFailure(`Failed to publish ${pkg.name}@${pkg.version}.`, result).message
-				};
-			}
-			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;
-				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());
-			}
-			await Promise.all(writes);
-		},
-		async applyCliDraft() {
-			if (!active || !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 }) => {
-	switch (kind) {
-		case "dependencies": return "patch";
-		case "build-dependencies":
-		case "dev-dependencies": return false;
-	}
-}) {
-	return {
-		id: "cargo:deps",
-		onUpdate({ pkg, packageDraft: plan }) {
-			if (!(pkg instanceof CargoPackage)) return;
-			const group = graph.getPackageGroup(pkg.id);
-			for (const dependent of graph.getPackages()) {
-				if (!(dependent instanceof CargoPackage)) continue;
-				for (const { table, kind } of dependencyTables(dependent.manifest, "")) for (const [rawName, rawSpec] of Object.entries(table)) {
-					const spec = parseSpec(rawSpec);
-					if (!spec || !semver$1.validRange(spec.version)) continue;
-					if (pkg.id !== `cargo:${spec.package ?? rawName}`) continue;
-					if (group?.options.syncBump && graph.getPackageGroup(dependent.id) === group) continue;
-					const bumped = plan.bumpVersion(pkg);
-					if (!bumped || semver$1.satisfies(bumped, spec.version)) continue;
-					const bumpType = getBumpDepType({
-						kind,
-						dependent,
-						name: pkg.name,
-						version: spec.version
-					});
-					if (bumpType === false) continue;
-					this.bumpPackage(dependent, {
-						type: bumpType,
-						reason: `update dependency "${rawName}"`
-					});
-				}
-			}
-		}
-	};
-}
-async function isPackagePublished(name, version) {
-	const response = await fetch(`https://crates.io/api/v1/crates/${encodeURIComponent(name)}/${version}`);
-	if (response.status === 200) return true;
-	if (response.status === 404) return false;
-	throw new Error(`Unable to validate ${name}@${version} against crates.io: ${await response.text()}`);
-}
-async function buildEntry(path) {
-	try {
-		const content = await readFile(join(path, "Cargo.toml"), "utf8");
-		return {
-			manifest: cargoManifestSchema.parse(parse$1(content)),
-			content,
-			path
-		};
-	} catch {
-		return;
-	}
-}
-async function discoverCargoPackages(cwd, add) {
-	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));
-}
-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, {
-		absolute: true,
-		cwd,
-		ignore: ["**/target/**", ...exclude],
-		onlyDirectories: true,
-		onlyFiles: false
-	}));
-	return paths.map(normalize);
-}
-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}`;
-		for (const field of DEP_FIELDS) {
-			const table = targetConfig[field];
-			if (table) tables.push({
-				kind: field,
-				table,
-				path: `${targetPath}.${field}`
-			});
-		}
-	}
-	return tables;
-}
-function parseSpec(v) {
-	if (typeof v === "string") return {
-		version: v,
-		setVersion(version) {
-			return version;
-		}
-	};
-	return {
-		package: v.package,
-		version: v.version,
-		setVersion(version) {
-			return {
-				...v,
-				version
-			};
-		}
-	};
-}
-//#endregion
-export { cargo as n, CargoPackage as t };

package/dist/npm-CMOyacwf.js

@@ -1,371 +0,0 @@
-import { i as isNodeError, n as execFailure } from "./error-We7chQVJ.js";
-import { n as WorkspacePackage } from "./graph-gThXu8Cz.js";
-import { readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { x } from "tinyexec";
-import * as semver$1 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/schema.ts
-const stringRecordSchema = z.record(z.string(), z.string());
-const pnpmWorkspaceSchema = z.looseObject({ packages: z.array(z.string()).optional() });
-const packageManifestSchema = z.looseObject({
-	name: z.string(),
-	version: z.string().optional(),
-	private: z.boolean().optional(),
-	publishConfig: z.looseObject({
-		access: z.enum(["public", "restricted"]).optional(),
-		registry: z.string().optional(),
-		tag: z.string().optional()
-	}).optional(),
-	scripts: z.record(z.string(), z.string()).optional(),
-	workspaces: z.array(z.string()).optional(),
-	dependencies: stringRecordSchema.optional(),
-	devDependencies: stringRecordSchema.optional(),
-	peerDependencies: stringRecordSchema.optional(),
-	optionalDependencies: stringRecordSchema.optional()
-});
-//#endregion
-//#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;
-	}
-	async write() {
-		await writeFile(path.join(this.path, "package.json"), `${JSON.stringify(this.manifest, null, 2)}\n`);
-	}
-	initDraft() {
-		const defaults = super.initDraft();
-		defaults.npm = { distTag: this.manifest.publishConfig?.tag };
-		return defaults;
-	}
-	configureDraft(draft, group) {
-		super.configureDraft(draft, group);
-		const { distTag = group?.options?.npm?.distTag } = this.getPackageOptions().npm ?? {};
-		if (distTag) {
-			draft.npm ??= {};
-			draft.npm.distTag = distTag;
-		} else if (draft.prerelease) {
-			draft.npm ??= {};
-			draft.npm.distTag ??= draft.prerelease;
-		}
-	}
-};
-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;
-			return { shouldPublish: pkg.version !== void 0 && pkg.manifest.private !== true };
-		},
-		resolvePlanStatus({ plan }) {
-			return Array.from(plan.packages, async ([id, { preflight }]) => {
-				if (!preflight.shouldPublish) return;
-				const pkg = this.graph.get(id);
-				if (!(pkg instanceof NpmPackage) || !pkg.version) return;
-				if (!await isPackagePublished(pkg.name, pkg.version, pkg.manifest.publishConfig?.registry)) return "pending";
-			});
-		},
-		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;
-			return publish(client, pkg, plan.packages.get(pkg.id)?.npm?.distTag);
-		},
-		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 bumped = draft.getPackageDraft(pkg.id)?.bumpVersion(pkg);
-				if (bumped) pkg.manifest.version = bumped;
-			}
-			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$1.validRange(spec.range)) continue;
-						if (!spec.linked.version || semver$1.satisfies(spec.linked.version, spec.range)) continue;
-						let updatedRange;
-						const isPeer = field === "peerDependencies";
-						if (isPeer && onBreakPeerDep === "ignore") continue;
-						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);
-		},
-		async applyCliDraft() {
-			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$1.satisfies(target, `${spec.range}${spec.linked.version}`);
-		}
-		if (spec.linked && spec.protocol === "file") return true;
-		if (spec.protocol === "file" || !semver$1.validRange(spec.range)) return false;
-		return !semver$1.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;
-						const bumped = plan.bumpVersion(pkg);
-						if (!bumped || !needsUpdate(spec, bumped)) continue;
-						const bumpType = getBumpDepType({
-							kind: field,
-							dependent,
-							spec,
-							name: k
-						});
-						if (bumpType === false) continue;
-						this.bumpPackage(dependent, {
-							type: bumpType,
-							reason: `update dependency "${k}"`
-						});
-					}
-				}
-			}
-		}
-	};
-}
-async function publish(client, pkg, distTag) {
-	if (!pkg.version || await isPackagePublished(pkg.name, pkg.version, pkg.manifest.publishConfig?.registry)) return { type: "skipped" };
-	if (client === "bun") {
-		for (const script of [
-			"prepublishOnly",
-			"prepack",
-			"prepare"
-		]) {
-			if (!pkg.manifest.scripts?.[script]) continue;
-			const result = await x("bun", ["run", script], { nodeOptions: { cwd: pkg.path } });
-			if (result.exitCode === 0) continue;
-			return {
-				type: "failed",
-				error: execFailure(`Failed to run ${script} script for ${pkg.name}@${pkg.version}.`, result).message
-			};
-		}
-		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" };
-}
-async function isPackagePublished(name, version, registry = "https://registry.npmjs.org") {
-	const base = registry.replace(/\/$/, "");
-	const response = await fetch(`${base}/${name}/${version}`, { headers: { Accept: "application/json" } });
-	if (response.status === 404) return false;
-	if (!response.ok) throw new Error(`Unable to validate ${name}@${version} against the npm registry${registry ? ` "${registry}"` : ""}.`);
-	return true;
-}
-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?.name) add(new NpmPackage(cwd, rootManifest));
-	for (const entry of manifests) {
-		if (!entry) 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
-export { npm as n, NpmPackage as t };

package/dist/providers/cargo.d.ts

@@ -1,2 +0,0 @@
-import { b as cargo, v as CargoPackage, y as CargoPluginOptions } from "../types-C1rEqeM4.js";
-export { CargoPackage, CargoPluginOptions, cargo };