wuppycms 0.0.0-stage → 0.2.1

package/dist/frontmatter-DGaz9--t.mjs

@@ -0,0 +1,24 @@
+import { parse, stringify } from "yaml";
+
+//#region src/content/parsers/frontmatter.ts
+const FENCE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+function parseDocument(source) {
+	const m = FENCE.exec(source);
+	if (!m) return {
+		data: {},
+		body: source
+	};
+	const data = parse(m[1] ?? "");
+	if (data !== null && (typeof data !== "object" || Array.isArray(data))) throw new Error("Frontmatter must be a YAML mapping");
+	return {
+		data: data ?? {},
+		body: source.slice(m[0].length)
+	};
+}
+/** Unknown keys in `data` are written back untouched. */
+function serializeDocument({ data, body }) {
+	return (Object.keys(data).length ? `---\n${stringify(data, { lineWidth: 0 })}---\n` : "") + body;
+}
+
+//#endregion
+export { serializeDocument as n, parseDocument as t };

package/dist/generate-iX4B_2U2.mjs

@@ -0,0 +1,473 @@
+import { t as parseDocument } from "./frontmatter-DGaz9--t.mjs";
+import { access, readFile, readdir, writeFile } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import { randomBytes } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+//#region src/cli/init.ts
+const exec = promisify(execFile);
+/**
+* `wuppycms init`: wraps an existing Astro project. Finds its Markdown/MDX content collections, writes wuppy.config.mjs,
+* adds the integration (plus MDX, and a Node adapter when there is none) to astro.config, lets the content globs load
+* .mdx, and adds the dependencies to package.json.
+* Files are only patched when the pattern is recognised; otherwise the manual step is printed instead.
+*/
+const exists = (p) => access(p).then(() => true, () => false);
+const read = (p) => readFile(p, "utf8").catch(() => null);
+const CONFIGS = [
+	"astro.config.mjs",
+	"astro.config.ts",
+	"astro.config.js",
+	"astro.config.mts"
+];
+const CONTENT_CONFIGS = [
+	"src/content.config.ts",
+	"src/content.config.mjs",
+	"src/content.config.js",
+	"src/content/config.ts"
+];
+async function walk(dir) {
+	return (await readdir(dir, { recursive: true }).catch(() => [])).map((n) => join(dir, n));
+}
+const IMAGE = /\.(png|jpe?g|webp|avif|gif|svg)$/i;
+const DATE = /^\d{4}-\d{2}-\d{2}(T[\d:.]+(Z|[+-]\d{2}:\d{2})?)?$/;
+/** Common Astro theme field names for the starter's `date` and `cover`. */
+const ALIASES = {
+	date: [
+		"pubDate",
+		"publishDate",
+		"pubDatetime",
+		"publishedAt",
+		"published",
+		"publishedDate"
+	],
+	cover: [
+		"heroImage",
+		"coverImage",
+		"image",
+		"featuredImage",
+		"thumbnail"
+	]
+};
+/** Guesses one field's type from the values it has across the existing files. */
+function inferField(key, values) {
+	const present = values.filter((v) => v !== void 0 && v !== null);
+	const all = (test) => present.length > 0 && present.every(test);
+	let type;
+	if (all((v) => typeof v === "boolean")) type = "boolean";
+	else if (all((v) => typeof v === "number")) type = "number";
+	else if (all((v) => v instanceof Date || typeof v === "string" && DATE.test(v))) type = "date";
+	else if (all((v) => Array.isArray(v) && v.every((i) => typeof i === "string" && i.length <= 100))) type = "list";
+	else if (all((v) => typeof v === "string")) {
+		const strings = present;
+		if (/image|cover|thumbnail|photo|avatar|logo|banner/i.test(key) || strings.every((v) => IMAGE.test(v))) type = "image";
+		else if (strings.some((v) => v.includes("\n") || v.length > 160)) type = "text";
+		else type = "string";
+	} else type = "json";
+	return present.length === values.length && values.length > 0 ? {
+		type,
+		multiple: false,
+		required: true
+	} : type;
+}
+/**
+* `const posts = defineCollection({ loader: glob({ pattern, base }) ... })` -> name, base, pattern. The name is the key
+* in `export const collections = { post: postCollection }` (what `getCollection("post")` uses), else the variable's.
+*/
+function collectionsFromConfig(source) {
+	const out = [];
+	const exported = /export\s+const\s+collections\s*=\s*\{([^}]*)\}/.exec(source)?.[1] ?? "";
+	const keys = /* @__PURE__ */ new Map();
+	for (const entry of exported.split(",")) {
+		const m = /^\s*(?:["'`]?([\w-]+)["'`]?\s*:\s*)?(\w+)\s*$/.exec(entry);
+		if (m) keys.set(m[2], m[1] ?? m[2]);
+	}
+	for (const m of source.matchAll(/(?:const|let)\s+(\w+)\s*=\s*defineCollection\(\s*\{([\s\S]*?)\n\}\s*\)/g)) {
+		const body = m[2] ?? "";
+		const glob = /loader:\s*glob\(\s*\{([\s\S]*?)\}\s*\)/.exec(body)?.[1];
+		const str = (key) => glob ? new RegExp(`${key}:\\s*["'\`]([^"'\`]+)["'\`]`).exec(glob)?.[1] : void 0;
+		out.push({
+			name: keys.get(m[1]) ?? m[1],
+			base: str("base"),
+			pattern: str("pattern"),
+			loader: glob ? "glob" : /loader:\s*(\w+)/.exec(body)?.[1] ?? "legacy"
+		});
+	}
+	return out;
+}
+/** The page that renders `getCollection("name")` with a [slug] param gives the public route. */
+async function findRoute(root, name) {
+	const pages = join(root, "src/pages");
+	for (const file of await walk(pages)) {
+		if (!/\[(\.\.\.)?slug\]\.(astro|mdx?|ts|js)$/.test(file)) continue;
+		const src = await read(file);
+		if (!src || !new RegExp(`get(Collection|Entry)\\(\\s*["'\`]${name}["'\`]`).test(src)) continue;
+		const rel = relative(pages, file).split(/[\\/]/);
+		rel[rel.length - 1] = "{slug}";
+		return `/${rel.join("/")}`;
+	}
+}
+async function planInit(root) {
+	const plan = {
+		collections: [],
+		skipped: [],
+		integration: {},
+		components: [],
+		warnings: []
+	};
+	let declared = [];
+	for (const f of CONTENT_CONFIGS) {
+		const src = await read(join(root, f));
+		if (src) {
+			declared = collectionsFromConfig(src);
+			break;
+		}
+	}
+	if (declared.length === 0) declared = (await readdir(join(root, "src/content"), { withFileTypes: true }).catch(() => [])).filter((d) => d.isDirectory()).map((d) => ({
+		name: d.name,
+		base: `src/content/${d.name}`,
+		loader: "legacy"
+	}));
+	const components = /* @__PURE__ */ new Set();
+	for (const c of declared) {
+		if (!/^[a-z][a-z0-9-]*$/.test(c.name)) {
+			plan.skipped.push(`${c.name}: Wuppy collection names are lowercase letters, digits and dashes`);
+			continue;
+		}
+		if (c.loader !== "glob" && c.loader !== "legacy") {
+			plan.skipped.push(`${c.name}: uses the "${c.loader}" loader, only file collections can be edited`);
+			continue;
+		}
+		const dir = (c.base ?? `src/content/${c.name}`).replace(/^\.\//, "").replace(/\/$/, "");
+		const files = (await walk(join(root, dir))).filter((f) => /\.(md|mdx)$/.test(f));
+		if (files.length === 0 && !/mdx?/.test(c.pattern ?? "")) {
+			plan.skipped.push(`${c.name}: no Markdown or MDX files (data collections stay as they are)`);
+			continue;
+		}
+		const format = !c.pattern || /mdx|\.md$/.test(c.pattern) ? "mdx" : "md";
+		if (format === "md") plan.warnings.push(`${c.name}: its glob does not load .mdx, so new entries stay Markdown`);
+		const values = /* @__PURE__ */ new Map();
+		const editable = files;
+		for (const [i, file] of editable.entries()) {
+			const src = await read(file) ?? "";
+			let data = {};
+			try {
+				data = parseDocument(src).data;
+			} catch {
+				plan.warnings.push(`${relative(root, file)}: frontmatter is not valid YAML`);
+			}
+			for (const key of Object.keys(data)) if (!values.has(key)) values.set(key, Array(i).fill(void 0));
+			for (const [key, list] of values) list.push(data[key]);
+			if (file.endsWith(".mdx")) for (const m of src.matchAll(/<([A-Z][A-Za-z0-9]*)[\s/>]/g)) components.add(m[1]);
+		}
+		const fields = Object.fromEntries([...values].map(([key, list]) => [key, inferField(key, list)]));
+		const route = await findRoute(root, c.name);
+		if (!route) plan.warnings.push(`${c.name}: no page renders it with a [slug] param; set "route" in wuppy.config.mjs`);
+		plan.collections.push({
+			name: c.name,
+			dir,
+			format,
+			route,
+			fields,
+			files: editable.length
+		});
+	}
+	for (const kind of ["posts", "pages"]) {
+		if (plan.collections.some((c) => c.name === kind || c.kind === kind)) continue;
+		const dated = (c) => Object.values(c.fields).some((f) => (typeof f === "string" ? f : f.type) === "date");
+		const pick = plan.collections.find((c) => !c.kind && c.name !== "posts" && c.name !== "pages" && dated(c) === (kind === "posts"));
+		if (pick) pick.kind = kind;
+	}
+	for (const c of plan.collections) {
+		const map = {};
+		for (const [to, names] of Object.entries(ALIASES)) {
+			const from = names.find((n) => n in c.fields);
+			if (from && !(to in c.fields)) map[from] = to;
+		}
+		if (Object.keys(map).length) c.map = map;
+	}
+	plan.components = [...components].toSorted();
+	const pages = (await walk(join(root, "src/pages"))).map((f) => relative(join(root, "src/pages"), f));
+	if (pages.some((p) => p.startsWith("sitemap.xml")) || await exists(join(root, "public/sitemap.xml"))) plan.integration.sitemap = false;
+	if (await exists(join(root, "public/robots.txt")) || pages.some((p) => p.startsWith("robots.txt"))) plan.integration.robots = false;
+	if (pages.some((p) => p.startsWith("rss.xml"))) plan.integration.rss = false;
+	for (const taken of [
+		"admin",
+		"api",
+		"uploads"
+	]) if (pages.some((p) => p === taken || p.startsWith(`${taken}/`) || p.startsWith(`${taken}.`))) plan.warnings.push(`src/pages/${taken} exists; Wuppy serves /${taken}, rename yours to avoid a clash`);
+	return plan;
+}
+async function findAstroConfig(root) {
+	for (const f of CONFIGS) {
+		const source = await read(join(root, f));
+		if (source !== null) return {
+			file: f,
+			source
+		};
+	}
+	return null;
+}
+/** The Node adapter and MDX releases that match the Astro version Wuppy supports. */
+const NODE_ADAPTER = "^11.1.5";
+const MDX_INTEGRATION = "^8.1.0";
+/** Lets glob loaders that read only `.md` read `.mdx` too: `pattern: "**\/*.md"` -> `"**\/*.{md,mdx}"`. */
+function patchContentConfig(source) {
+	return source.replace(/(pattern:\s*["'`][^"'`]*?)\.md(["'`])/g, "$1.{md,mdx}$2");
+}
+/** Adds `wuppycms(...)`, `mdx()` and a Node adapter when missing. Returns null when the config shape is not recognised. */
+function patchAstroConfig(source, integration) {
+	if (/wuppycms(cms)?\/astro/.test(source)) return source;
+	const off = Object.keys(integration);
+	const options = off.length ? `{ ${off.map((k) => `${k}: false`).join(", ")} }` : "";
+	const mdx = !/@astrojs\/mdx/.test(source);
+	const call = `wuppycms(${options})${mdx ? ", mdx()" : ""}`;
+	const tab = /^([ \t]+)\S/m.exec(source)?.[1] ?? "	";
+	let out = source;
+	if (/integrations:\s*\[/.test(out)) out = out.replace(/integrations:\s*\[/, `integrations: [${call}, `);
+	else if (/defineConfig\(\s*\{/.test(out)) out = out.replace(/defineConfig\(\s*\{/, `defineConfig({\n${tab}integrations: [${call}],`);
+	else return null;
+	const imports = ["import wuppycms from \"wuppycms/astro\";"];
+	if (mdx) imports.push("import mdx from \"@astrojs/mdx\";");
+	if (!/\badapter\s*:/.test(out)) {
+		out = out.replace(/defineConfig\(\s*\{/, `defineConfig({\n${tab}adapter: node({ mode: "standalone" }),`);
+		imports.push("import node from \"@astrojs/node\";");
+	}
+	const lastImport = [...out.matchAll(/^import .*$/gm)].at(-1);
+	const at = lastImport ? lastImport.index + lastImport[0].length + 1 : 0;
+	return `${out.slice(0, at)}${imports.join("\n")}\n${out.slice(at)}`;
+}
+/** Renders wuppy.config.mjs; every value stays editable by hand afterwards. */
+function renderConfig(plan, site) {
+	const config = {
+		...site.url ? { site: {
+			url: site.url,
+			name: site.name
+		} } : {},
+		...plan.components.length ? { components: plan.components } : {},
+		collections: plan.collections.map(({ name, dir, format, kind, map, route, fields }) => ({
+			name,
+			dir,
+			format,
+			...kind ? { kind } : {},
+			...map ? { map } : {},
+			...route ? { route } : {},
+			fields
+		}))
+	};
+	return `// Made by \`wuppycms init\` from the files already in this project. Fields are guessed from the frontmatter; adjust freely.\nexport default ${JSON.stringify(config, null, "	")};\n`;
+}
+const IGNORE = [
+	"# Wuppy: runtime state stays local; .wuppy/data (menus, settings) is content and is committed",
+	".wuppy/*",
+	"!.wuppy/data/",
+	".env"
+];
+async function init(root, { force = false, version = "latest" } = {}) {
+	const astro = await findAstroConfig(root);
+	if (!astro) return {
+		code: 1,
+		stdout: "",
+		stderr: "No astro.config found here. Run `wuppycms init` in the root of an Astro project."
+	};
+	if (!force && await exists(join(root, "wuppy.config.mjs"))) return {
+		code: 1,
+		stdout: "",
+		stderr: "wuppy.config.mjs already exists (use --force to replace it)."
+	};
+	const plan = await planInit(root);
+	if (plan.collections.length === 0) return {
+		code: 1,
+		stdout: "",
+		stderr: `No Markdown/MDX content collections found.\n${plan.skipped.join("\n")}`
+	};
+	const pkgPath = join(root, "package.json");
+	const pkg = JSON.parse(await read(pkgPath) ?? "{}");
+	const siteUrl = /\bsite:\s*["'`]([^"'`]+)["'`]/.exec(astro.source)?.[1];
+	await writeFile(join(root, "wuppy.config.mjs"), renderConfig(plan, {
+		url: siteUrl,
+		name: pkg.name ?? "Site"
+	}));
+	const lines = [`Wrote wuppy.config.mjs with ${plan.collections.length} collection(s):`];
+	for (const c of plan.collections) lines.push(`  ${c.name.padEnd(16)} ${c.dir} (${c.files} .${c.format}, ${Object.keys(c.fields).length} fields) -> ${c.route ?? "route not found"}`);
+	for (const s of plan.skipped) lines.push(`  skipped ${s}`);
+	const patched = patchAstroConfig(astro.source, plan.integration);
+	const adds = (pkgName) => patched !== null && patched.includes(`from "${pkgName}"`) && !astro.source.includes(pkgName);
+	const addsAdapter = adds("@astrojs/node");
+	const addsMdx = adds("@astrojs/mdx");
+	if (patched === null) plan.warnings.push(`${astro.file}: add \`import wuppycms from "wuppycms/astro"\` and \`wuppycms()\` to integrations by hand (plus a server adapter)`);
+	else if (patched !== astro.source) {
+		await writeFile(join(root, astro.file), patched);
+		lines.push(`Added wuppycms()${addsMdx ? ", mdx()" : ""}${addsAdapter ? " and the Node adapter" : ""} to ${astro.file}`);
+	}
+	for (const f of CONTENT_CONFIGS) {
+		const source = await read(join(root, f));
+		if (source === null) continue;
+		const widened = patchContentConfig(source);
+		if (widened !== source) {
+			await writeFile(join(root, f), widened);
+			lines.push(`Content globs in ${f} now load .mdx too`);
+		}
+		break;
+	}
+	pkg.dependencies = {
+		...pkg.dependencies,
+		wuppycms: pkg.dependencies?.wuppycms ?? version
+	};
+	if (addsAdapter) pkg.dependencies["@astrojs/node"] ??= NODE_ADAPTER;
+	if (addsMdx) pkg.dependencies["@astrojs/mdx"] ??= MDX_INTEGRATION;
+	await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+	const gitignore = await read(join(root, ".gitignore")) ?? "";
+	if (!gitignore.includes(".wuppy/*")) await writeFile(join(root, ".gitignore"), `${gitignore.replace(/\n?$/, "\n")}${IGNORE.join("\n")}\n`);
+	const env = await read(join(root, ".env")) ?? "";
+	if (!/^WUPPY_SECRET=/m.test(env)) await writeFile(join(root, ".env"), `${env.replace(/\n?$/, env ? "\n" : "")}WUPPY_SECRET=${randomBytes(32).toString("base64url")}\nWUPPY_URL=http://localhost:4321\n`, { mode: 384 });
+	for (const w of plan.warnings) lines.push(`warning: ${w}`);
+	lines.push("", "Next: install dependencies (npm install / pnpm install), then run the dev server and open /admin.");
+	return {
+		code: 0,
+		stdout: lines.join("\n") + "\n",
+		stderr: ""
+	};
+}
+const run = (cmd, args) => exec(cmd, args, { maxBuffer: 64 * 1024 * 1024 });
+const REPOS_QUERY = `query($endCursor: String) { viewer { repositories(first: 100, after: $endCursor,
+  ownerAffiliations: [OWNER, COLLABORATOR, ORGANIZATION_MEMBER], orderBy: {field: PUSHED_AT, direction: DESC}) {
+  pageInfo { hasNextPage endCursor }
+  nodes { nameWithOwner isPrivate description object(expression: "HEAD:package.json") { ... on Blob { text } } } } } }`;
+/** The signed-in GitHub user's repositories that depend on Astro, newest push first. Needs the GitHub CLI (`gh`). */
+async function astroRepos(sh = run) {
+	const { stdout } = await sh("gh", [
+		"api",
+		"graphql",
+		"--paginate",
+		"-f",
+		`query=${REPOS_QUERY}`,
+		"--jq",
+		".data.viewer.repositories.nodes[] | {repo: .nameWithOwner, private: .isPrivate, description: (.description // \"\"), pkg: (.object.text // \"\")}"
+	]);
+	return astroOnly(stdout.split("\n").filter(Boolean).map((line) => JSON.parse(line)));
+}
+/** Keeps the repos whose root package.json depends on Astro. */
+const astroOnly = (repos) => repos.filter((r) => /"astro"\s*:/.test(r.pkg)).map((r) => ({
+	repo: r.repo,
+	private: r.private,
+	description: r.description
+}));
+async function askRepo(repos) {
+	const { createInterface } = await import("node:readline/promises");
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stderr
+	});
+	repos.forEach((r, i) => process.stderr.write(`${String(i + 1).padStart(3)}. ${r.repo}${r.private ? " (private)" : ""}${r.description ? `  ${r.description}` : ""}\n`));
+	const answer = await rl.question("Repository to wrap (number): ").finally(() => rl.close());
+	return repos[Number(answer) - 1];
+}
+const failed = (what, e) => ({
+	code: 1,
+	stdout: "",
+	stderr: `${what} failed: ${e.stderr?.trim() || e.message}`
+});
+/**
+* `wuppycms import <git-url> <dir>`: clone a repository, then wrap it.
+* `wuppycms import` with no URL lists the user's Astro repositories on GitHub to pick from (via `gh`, so private repos work).
+*/
+async function importRepo(url, dir, cwd, deps = {}) {
+	const sh = deps.exec ?? run;
+	if (!url) {
+		let repos;
+		try {
+			repos = await astroRepos(sh);
+		} catch (e) {
+			return failed("Listing GitHub repositories (needs the GitHub CLI: install gh, run `gh auth login`)", e);
+		}
+		if (repos.length === 0) return {
+			code: 1,
+			stdout: "",
+			stderr: "No Astro repositories found on your GitHub account."
+		};
+		const picked = await (deps.choose ?? askRepo)(repos);
+		if (!picked) return {
+			code: 1,
+			stdout: "",
+			stderr: "No repository picked."
+		};
+		const target = resolve(cwd, dir || picked.repo.split("/")[1]);
+		try {
+			await sh("gh", [
+				"repo",
+				"clone",
+				picked.repo,
+				target
+			]);
+		} catch (e) {
+			return failed("gh repo clone", e);
+		}
+		return init(target);
+	}
+	if (url.startsWith("-") || !dir || dir.startsWith("-")) return {
+		code: 1,
+		stdout: "",
+		stderr: "Usage: wuppycms import [<git-url> <dir>]"
+	};
+	const target = resolve(cwd, dir);
+	try {
+		await sh("git", [
+			"clone",
+			"--",
+			url,
+			target
+		]);
+	} catch (e) {
+		return failed("git clone", e);
+	}
+	return init(target);
+}
+
+//#endregion
+//#region src/content-types/generate.ts
+const pascal = (s) => s.replace(/(^|-)([a-z0-9])/g, (_, __, c) => c.toUpperCase());
+function tsType(field) {
+	const f = typeof field === "string" ? {
+		type: field,
+		multiple: false
+	} : field;
+	const many = (t) => "multiple" in f && f.multiple ? `${t}[]` : t;
+	switch (f.type) {
+		case "boolean": return "boolean";
+		case "number": return "number";
+		case "list": return "string[]";
+		case "json": return "unknown";
+		case "byline": return "string | Array<string | { byline: string; role?: string }>";
+		case "section": return "string[]";
+		case "taxonomy":
+		case "reference": return "multiple" in f && f.multiple ? "string[]" : "string | string[]";
+		case "select": return many("options" in f && f.options?.length ? f.options.map((o) => JSON.stringify(o)).join(" | ") : "string");
+		case "repeater": return `Array<${obj("fields" in f && f.fields ? f.fields : {})}>`;
+		case "blocks": {
+			const blocks = "blocks" in f && f.blocks ? Object.entries(f.blocks) : [];
+			return blocks.length ? `Array<${blocks.map(([name, fields]) => `{ type: ${JSON.stringify(name)} } & ${obj(fields)}`).join(" | ")}>` : "unknown[]";
+		}
+		default: return "string";
+	}
+}
+function obj(fields) {
+	const rows = Object.entries(fields).map(([name, f]) => {
+		const required = typeof f !== "string" && f.required && !f.showIf;
+		return `${JSON.stringify(name)}${required ? "" : "?"}: ${tsType(f)}`;
+	});
+	return `{ ${rows.join("; ")}${rows.length ? "; " : ""}[key: string]: unknown }`;
+}
+/** A `.d.ts` with one frontmatter interface per collection, regenerated whenever the schema changes. */
+function generateTypes(collections) {
+	const out = ["// Generated by `wuppycms types`. Do not edit.", ""];
+	for (const c of collections) out.push(`export type ${pascal(c.name)}Data = ${obj(c.fields)};`);
+	out.push("", `export interface WuppyCollections {`);
+	for (const c of collections) out.push(`\t${JSON.stringify(c.name)}: ${pascal(c.name)}Data;`);
+	out.push("}", "");
+	return out.join("\n");
+}
+
+//#endregion
+export { astroOnly as a, REPOS_QUERY as i, CONFIGS as n, importRepo as o, NODE_ADAPTER as r, init as s, generateTypes as t };

package/dist/i18n-CgLAHd9Q.mjs

@@ -0,0 +1,79 @@
+//#region src/i18n/index.ts
+/** Convention: the first slug segment is the locale (`en/hello`, `tr/hello`); the rest is the shared key. */
+function translationStatus(slugs, locales, modified = {}) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const slug of slugs) {
+		const i = slug.indexOf("/");
+		const locale = slug.slice(0, i);
+		if (i < 1 || !locales.includes(locale)) continue;
+		const key = slug.slice(i + 1);
+		groups.set(key, {
+			...groups.get(key),
+			[locale]: slug
+		});
+	}
+	return [...groups].map(([key, translations]) => {
+		const source = locales[0] && translations[locales[0]] ? modified[translations[locales[0]]] : void 0;
+		return {
+			key,
+			translations,
+			missing: locales.filter((l) => !translations[l]),
+			stale: source ? locales.slice(1).filter((l) => {
+				const at = translations[l] ? modified[translations[l]] : void 0;
+				return at !== void 0 && at < source;
+			}) : []
+		};
+	}).toSorted((a, b) => a.key.localeCompare(b.key));
+}
+/** `en/hello` -> `{ locale: "en", key: "hello" }`; null when the first segment is not a configured locale. */
+function splitLocale(slug, locales) {
+	const i = slug.indexOf("/");
+	const locale = slug.slice(0, i);
+	return i > 0 && locales.includes(locale) ? {
+		locale,
+		key: slug.slice(i + 1)
+	} : null;
+}
+/** The entry to show for `key` in `wanted`; falls back to the default (first) locale, flagged. Null when neither exists. */
+function resolveLocale(key, wanted, existing, locales) {
+	for (const [locale, fallback] of [[wanted, false], [locales[0], true]]) {
+		const slug = locale && `${locale}/${key}`;
+		if (slug && existing.includes(slug)) return {
+			slug,
+			locale,
+			fallback: fallback && locale !== wanted
+		};
+	}
+	return null;
+}
+/** Language switcher data for the entry `slug`: one link per locale, falling back to the default language. */
+function localeSwitcher(slug, existing, locales) {
+	const parts = splitLocale(slug, locales);
+	if (!parts) return [];
+	return locales.map((locale) => {
+		const hit = resolveLocale(parts.key, locale, existing, locales);
+		return {
+			locale,
+			slug: hit?.slug ?? null,
+			fallback: hit?.fallback ?? false
+		};
+	});
+}
+/** `hreflang` map for `buildSeo`: real translations only, plus `x-default` for the default language. */
+function hreflangAlternates(slug, existing, locales, pathOf) {
+	const parts = splitLocale(slug, locales);
+	if (!parts) return {};
+	const out = {};
+	for (const locale of locales) {
+		const translated = `${locale}/${parts.key}`;
+		if (existing.includes(translated)) out[locale] = pathOf(translated);
+	}
+	const base = locales[0] && out[locales[0]];
+	return base ? {
+		...out,
+		"x-default": base
+	} : out;
+}
+
+//#endregion
+export { translationStatus as a, splitLocale as i, localeSwitcher as n, resolveLocale as r, hreflangAlternates as t };

package/dist/index-B6AHmgP9.d.mts

@@ -0,0 +1,34 @@
+//#region src/i18n/index.d.ts
+interface TranslationRow {
+  key: string;
+  translations: Record<string, string>;
+  missing: string[];
+  /** Locales whose translation was last edited before the source (first locale) changed. */
+  stale: string[];
+}
+/** Convention: the first slug segment is the locale (`en/hello`, `tr/hello`); the rest is the shared key. */
+declare function translationStatus(slugs: string[], locales: string[], modified?: Record<string, string>): TranslationRow[];
+/** `en/hello` -> `{ locale: "en", key: "hello" }`; null when the first segment is not a configured locale. */
+declare function splitLocale(slug: string, locales: readonly string[]): {
+  locale: string;
+  key: string;
+} | null;
+/** The entry to show for `key` in `wanted`; falls back to the default (first) locale, flagged. Null when neither exists. */
+declare function resolveLocale(key: string, wanted: string, existing: readonly string[], locales: readonly string[]): {
+  slug: string;
+  locale: string;
+  fallback: boolean;
+} | null;
+interface LocaleLink {
+  locale: string;
+  /** Entry slug to link to, or null when the key has no entry in any language that applies. */
+  slug: string | null;
+  /** True when this locale has no translation and the link points at the default language. */
+  fallback: boolean;
+}
+/** Language switcher data for the entry `slug`: one link per locale, falling back to the default language. */
+declare function localeSwitcher(slug: string, existing: readonly string[], locales: readonly string[]): LocaleLink[];
+/** `hreflang` map for `buildSeo`: real translations only, plus `x-default` for the default language. */
+declare function hreflangAlternates(slug: string, existing: readonly string[], locales: readonly string[], pathOf: (slug: string) => string): Record<string, string>;
+//#endregion
+export { resolveLocale as a, localeSwitcher as i, TranslationRow as n, splitLocale as o, hreflangAlternates as r, translationStatus as s, LocaleLink as t };