@tegami/dart 0.0.0-tegami-trusted-publish-setup → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fuma Nama
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,72 @@
+import { BumpType, TegamiPlugin, WorkspacePackage } from "tegami";
+import z from "zod";
+
+//#region src/schema.d.ts
+declare const pubspecSchema: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  version: z.ZodOptional<z.ZodString>;
+  publish_to: z.ZodOptional<z.ZodString>;
+  resolution: z.ZodOptional<z.ZodString>;
+  workspace: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<DartDependency, unknown, z.core.$ZodTypeInternals<DartDependency, unknown>>>>;
+  dev_dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<DartDependency, unknown, z.core.$ZodTypeInternals<DartDependency, unknown>>>>;
+  dependency_overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<DartDependency, unknown, z.core.$ZodTypeInternals<DartDependency, unknown>>>>;
+}, z.core.$loose>;
+type DartDependency = string | {
+  version?: string;
+  hosted?: string | {
+    name?: string;
+    url: string;
+  };
+  path?: string;
+  git?: unknown;
+  sdk?: string;
+  [key: string]: unknown;
+};
+type Pubspec = z.infer<typeof pubspecSchema>;
+//#endregion
+//#region src/index.d.ts
+declare const DEP_FIELDS: readonly ["dependencies", "dev_dependencies", "dependency_overrides"];
+interface PubspecFile {
+  path: string;
+  data: Pubspec;
+}
+declare class DartPackage extends WorkspacePackage {
+  readonly path: string;
+  readonly file: PubspecFile;
+  readonly manager = "dart";
+  constructor(path: string, file: PubspecFile);
+  get name(): string;
+  get version(): string | undefined;
+  get publishTo(): string | undefined;
+  setVersion(version: string): void;
+  write(): Promise<void>;
+}
+interface DependentRef {
+  dependent: DartPackage;
+  kind: (typeof DEP_FIELDS)[number];
+  name: string;
+  spec: DartDependency;
+  table: Record<string, DartDependency>;
+  linked: DartPackage;
+}
+interface DartPluginOptions {
+  /**
+   * Update the pub workspace resolution after versioning.
+   *
+   * @default true
+   */
+  updateLockFile?: boolean;
+  /**
+   * Decide how to bump the dependents of a bumped package.
+   */
+  bumpDep?: (opts: DependentRef) => BumpType | false;
+}
+declare function dart({
+  updateLockFile,
+  bumpDep: getBumpDepType
+}?: DartPluginOptions): TegamiPlugin;
+declare function updateConstraintRange(range: string, version: string): string;
+declare function isPackagePublished(name: string, version: string, hostedUrl: string): Promise<boolean>;
+//#endregion
+export { DartPackage, DartPluginOptions, dart, isPackagePublished, updateConstraintRange };

package/dist/index.js

@@ -0,0 +1,283 @@
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { dump, load } from "js-yaml";
+import * as semver from "semver";
+import { glob } from "tinyglobby";
+import { x } from "tinyexec";
+import { WorkspacePackage } from "tegami";
+import { execFailure, isCI, joinPath } from "tegami/utils";
+import z from "zod";
+//#region src/schema.ts
+const dartDependencySchema = z.union([z.string(), z.looseObject({
+	version: z.string().optional(),
+	hosted: z.union([z.string(), z.looseObject({
+		name: z.string().optional(),
+		url: z.string()
+	})]).optional(),
+	path: z.string().optional(),
+	git: z.unknown().optional(),
+	sdk: z.string().optional()
+})]);
+const pubspecSchema = z.looseObject({
+	name: z.string().optional(),
+	version: z.string().optional(),
+	publish_to: z.string().optional(),
+	resolution: z.string().optional(),
+	workspace: z.array(z.string()).optional(),
+	dependencies: z.record(z.string(), dartDependencySchema).optional(),
+	dev_dependencies: z.record(z.string(), dartDependencySchema).optional(),
+	dependency_overrides: z.record(z.string(), dartDependencySchema).optional()
+});
+const hostedPackageSchema = z.object({ versions: z.array(z.object({ version: z.string() })).optional() });
+//#endregion
+//#region src/index.ts
+const DEP_FIELDS = [
+	"dependencies",
+	"dev_dependencies",
+	"dependency_overrides"
+];
+const DEFAULT_HOSTED_URL = "https://pub.dev";
+var DartPackage = class extends WorkspacePackage {
+	path;
+	file;
+	manager = "dart";
+	constructor(path, file) {
+		super();
+		this.path = path;
+		this.file = file;
+	}
+	get name() {
+		return this.file.data.name;
+	}
+	get version() {
+		return this.file.data.version;
+	}
+	get publishTo() {
+		return this.file.data.publish_to;
+	}
+	setVersion(version) {
+		this.file.data.version = version;
+	}
+	async write() {
+		await writeFile(path.join(this.path, "pubspec.yaml"), dump(this.file.data, {
+			lineWidth: -1,
+			noRefs: true,
+			sortKeys: false
+		}));
+	}
+};
+function dart({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
+	let active = false;
+	return {
+		name: "dart",
+		enforce: "post",
+		async resolve() {
+			const packages = await discoverDartPackages(this.cwd);
+			for (const pkg of packages) this.graph.add(pkg);
+			active = packages.length > 0;
+		},
+		initDraft(draft) {
+			if (!active) return;
+			draft.addPolicy(depsPolicy(this, getBumpDepType));
+		},
+		publishPreflight({ pkg }) {
+			if (!(pkg instanceof DartPackage)) return;
+			const wait = dependencyRefs(this.graph, pkg).filter((ref) => ref.kind === "dependencies").map((ref) => ref.linked.id);
+			return {
+				shouldPublish: pkg.version !== void 0 && pkg.publishTo !== "none",
+				wait
+			};
+		},
+		resolvePlanStatus({ plan }) {
+			return Array.from(plan.packages, async ([id, { preflight }]) => {
+				if (!preflight.shouldPublish) return;
+				const pkg = this.graph.get(id);
+				if (!(pkg instanceof DartPackage) || !pkg.version) return;
+				if (!await isPackagePublished(pkg.name, pkg.version, pkg.publishTo ?? DEFAULT_HOSTED_URL)) return "pending";
+			});
+		},
+		async publish({ pkg }) {
+			if (!(pkg instanceof DartPackage)) return;
+			const result = await x("dart", [
+				"pub",
+				"publish",
+				...isCI() ? ["--force"] : []
+			], { nodeOptions: { cwd: pkg.path } });
+			if (result.exitCode !== 0) {
+				if (/already exists|already published|version already exists/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;
+			for (const pkg of this.graph.getPackages()) {
+				if (!(pkg instanceof DartPackage)) continue;
+				const bumped = draft.getPackageDraft(pkg.id)?.bumpVersion(pkg);
+				if (bumped) pkg.setVersion(bumped);
+			}
+			const writes = [];
+			for (const pkg of this.graph.getPackages()) {
+				if (!(pkg instanceof DartPackage)) continue;
+				for (const ref of dependencyRefs(this.graph, pkg)) {
+					if (!ref.linked.version) continue;
+					const range = getDependencyRange(ref.spec);
+					if (!range || satisfiesDartRange(ref.linked.version, range)) continue;
+					ref.table[ref.name] = setDependencyRange(ref.spec, updateConstraintRange(range, ref.linked.version));
+				}
+				writes.push(pkg.write());
+			}
+			await Promise.all(writes);
+		},
+		async applyCliDraft() {
+			if (!active || !updateLockFile) return;
+			const result = await x("dart", ["pub", "get"], { nodeOptions: { cwd: this.cwd } });
+			if (result.exitCode !== 0) throw execFailure("Failed to update Dart pub resolution.", result);
+		}
+	};
+}
+function depsPolicy({ graph }, getBumpDepType = ({ kind }) => {
+	switch (kind) {
+		case "dependencies":
+		case "dependency_overrides": return "patch";
+		case "dev_dependencies": return false;
+	}
+}) {
+	const dependentMap = /* @__PURE__ */ new Map();
+	for (const pkg of graph.getPackages()) {
+		if (!(pkg instanceof DartPackage)) continue;
+		for (const ref of dependencyRefs(graph, pkg)) {
+			const refs = dependentMap.get(ref.linked.id);
+			if (refs) refs.push(ref);
+			else dependentMap.set(ref.linked.id, [ref]);
+		}
+	}
+	return {
+		id: "dart:deps",
+		onUpdate({ pkg, packageDraft: plan }) {
+			if (!(pkg instanceof DartPackage)) return;
+			const deps = dependentMap.get(pkg.id);
+			if (!deps) return;
+			const group = graph.getPackageGroup(pkg.id);
+			if (!plan.bumpVersion(pkg)) return;
+			for (const dep of deps) {
+				if (group?.options.syncBump && graph.getPackageGroup(dep.dependent.id) === group) continue;
+				const bumpType = getBumpDepType(dep);
+				if (bumpType === false) continue;
+				this.bumpPackage(dep.dependent, {
+					type: bumpType,
+					reason: `update dependency "${dep.name}"`
+				});
+			}
+		}
+	};
+}
+function dependencyRefs(graph, pkg) {
+	const refs = [];
+	for (const { kind, table } of dependencyTables(pkg.file.data)) for (const [name, spec] of Object.entries(table)) {
+		const linked = resolveLinkedPackage(graph, name);
+		if (!linked || linked === pkg) continue;
+		refs.push({
+			dependent: pkg,
+			kind,
+			name,
+			spec,
+			table,
+			linked
+		});
+	}
+	return refs;
+}
+function resolveLinkedPackage(graph, name) {
+	return graph.getPackages().find((candidate) => candidate instanceof DartPackage && candidate.name === name);
+}
+function dependencyTables(manifest) {
+	const tables = [];
+	for (const kind of DEP_FIELDS) {
+		const table = manifest[kind];
+		if (table) tables.push({
+			kind,
+			table
+		});
+	}
+	return tables;
+}
+function getDependencyRange(spec) {
+	if (typeof spec === "string") return spec;
+	return spec.version;
+}
+function setDependencyRange(spec, range) {
+	if (typeof spec !== "object" || spec === null) return range;
+	spec.version = range;
+	return spec;
+}
+function updateConstraintRange(range, version) {
+	const trimmed = range.trim();
+	if (trimmed.startsWith("^")) return `^${version}`;
+	if (trimmed.startsWith("~")) return `~${version}`;
+	const lowerBound = /^(>=|>)\s*([0-9A-Za-z.+-]+)/.exec(trimmed);
+	if (lowerBound) return trimmed.replace(lowerBound[0], `${lowerBound[1]}${version}`);
+	return version;
+}
+function satisfiesDartRange(version, range) {
+	const trimmed = range.trim();
+	if (trimmed === "any") return true;
+	if (!semver.validRange(trimmed, { loose: true })) return false;
+	return semver.satisfies(version, trimmed, {
+		includePrerelease: true,
+		loose: true
+	});
+}
+async function discoverDartPackages(cwd) {
+	const root = await readPubspec(cwd);
+	if (!root?.data.workspace?.length) return [];
+	const files = /* @__PURE__ */ new Map();
+	files.set(root.path, root);
+	await collectWorkspaceFiles(root, files);
+	return Array.from(files.values()).filter((file) => Boolean(file.data.name)).map((file) => new DartPackage(path.dirname(file.path), file));
+}
+async function collectWorkspaceFiles(root, files) {
+	const rootDir = path.dirname(root.path);
+	const members = root.data.workspace;
+	if (!members?.length) return;
+	const paths = await glob(members, {
+		absolute: true,
+		cwd: rootDir,
+		onlyDirectories: true,
+		onlyFiles: false,
+		ignore: ["**/.dart_tool/**", "**/build/**"]
+	});
+	await Promise.all(paths.map(async (dir) => {
+		const file = await readPubspec(dir);
+		if (!file || files.has(file.path)) return;
+		files.set(file.path, file);
+		await collectWorkspaceFiles(file, files);
+	}));
+}
+async function readPubspec(dir) {
+	const filePath = path.join(dir, "pubspec.yaml");
+	try {
+		const content = await readFile(filePath, "utf8");
+		return {
+			path: filePath,
+			data: pubspecSchema.parse(load(content) ?? {})
+		};
+	} catch {
+		return;
+	}
+}
+async function isPackagePublished(name, version, hostedUrl) {
+	const url = joinPath(hostedUrl, "api/packages", encodeURIComponent(name));
+	const response = await fetch(url, { headers: {
+		Accept: "application/vnd.pub.v2+json",
+		"User-Agent": "tegami-dart"
+	} });
+	if (response.status === 404) return false;
+	if (!response.ok) return false;
+	return hostedPackageSchema.parse(await response.json()).versions?.some((entry) => entry.version === version) ?? false;
+}
+//#endregion
+export { DartPackage, dart, isPackagePublished, updateConstraintRange };

package/package.json

@@ -1,5 +1,45 @@
 {
   "name": "@tegami/dart",
-  "version": "0.0.0-tegami-trusted-publish-setup",
-  "description": "Placeholder published by Tegami for npm trusted publishing setup."
-}
+  "version": "1.1.0",
+  "description": "Dart pub workspace support and pub.dev publishing for Tegami",
+  "license": "MIT",
+  "author": "Fuma Nama",
+  "repository": {
+    "type": "git",
+    "url": "github:fuma-nama/tegami"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "js-yaml": "^5.2.0",
+    "semver": "^7.8.5",
+    "tinyexec": "^1.2.4",
+    "tinyglobby": "^0.2.17",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.1",
+    "@types/semver": "^7.7.1",
+    "tsdown": "^0.22.3",
+    "typescript": "6.0.3",
+    "@repo/typescript-config": "0.0.0",
+    "tegami": "1.1.0"
+  },
+  "peerDependencies": {
+    "tegami": "1.1.0"
+  },
+  "scripts": {
+    "types:check": "tsc --noEmit",
+    "build": "tsdown",
+    "dev": "tsdown --watch"
+  }
+}

package/README.md

@@ -1,5 +0,0 @@
-# Placeholder package
-
-This empty package was published by [Tegami](https://tegami.fuma-nama.dev) to configure npm trusted publishing.
-
-The real package contents will be published via CI with OIDC.