@pyreon/zero 0.15.0 → 0.16.0

package/lib/seo.js

@@ -1,12 +1,20 @@
+import { existsSync } from "node:fs";
+import { readFile, rm, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
 //#region src/seo.ts
 /**
 * Generate a sitemap.xml string from route file paths.
+*
+* When `i18n` is set (PR K — passed by `seoPlugin` after reading the
+* i18n config from `zero({ i18n: ... })`), URLs are clustered by their
+* un-prefixed (default-locale) form and each `<url>` carries
+* `<xhtml:link rel="alternate" hreflang="...">` siblings for every
+* locale variant + an `x-default` entry pointing at the default locale.
 */
-function generateSitemap(routeFiles, config) {
+function generateSitemap(routeFiles, config, i18n) {
 	const { origin, exclude = [], changefreq = "weekly", priority = .7 } = config;
-	return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${[...routeFiles.filter((f) => {
+	const clusters = clusterPathsByLocale([...routeFiles.filter((f) => {
 		const name = f.split("/").pop()?.replace(/\.\w+$/, "");
 		return name !== "_layout" && name !== "_error" && name !== "_loading";
 	}).map((f) => {
@@ -19,19 +27,141 @@ ${[...routeFiles.filter((f) => {
 		path: p,
 		changefreq,
 		priority
-	})), ...config.additionalPaths ?? []].map((entry) => {
-		return `  <url>
-    <loc>${escapeXml(`${origin}${entry.path === "/" ? "" : entry.path}`)}</loc>
-    <changefreq>${entry.changefreq ?? changefreq}</changefreq>
-    <priority>${entry.priority ?? priority}</priority>${entry.lastmod ? `\n    <lastmod>${entry.lastmod}</lastmod>` : ""}
-  </url>`;
-	}).join("\n")}
+	})), ...config.additionalPaths ?? []], i18n);
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"${i18n != null && i18n.locales.length > 0 ? " xmlns:xhtml=\"http://www.w3.org/1999/xhtml\"" : ""}>
+${clusters.map((cluster) => renderClusterEntry(cluster, origin, changefreq, priority, i18n)).join("\n")}
 </urlset>`;
 }
+/**
+* Cluster URL entries by their un-prefixed (default-locale) form.
+*
+* Each output cluster has:
+*   - `canonical`: the SitemapEntry that should be used as the `<url>`
+*     payload (default-locale variant; falls back to the first variant
+*     if no default-locale entry exists in the cluster).
+*   - `variantsByLocale`: Map of locale → SitemapEntry for the cluster.
+*
+* Without i18n, every entry becomes its own single-variant cluster.
+*
+* @internal — exported for unit testing.
+*/
+function clusterPathsByLocale(entries, i18n) {
+	if (i18n == null || i18n.locales.length === 0) return entries.map((entry) => ({
+		canonical: entry,
+		variantsByLocale: new Map([[null, entry]])
+	}));
+	const strategy = i18n.strategy ?? "prefix-except-default";
+	const { defaultLocale, locales } = i18n;
+	const byUnPrefixed = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const { unPrefixed, locale } = stripLocalePrefix(entry.path, locales, defaultLocale, strategy);
+		let cluster = byUnPrefixed.get(unPrefixed);
+		if (!cluster) {
+			cluster = /* @__PURE__ */ new Map();
+			byUnPrefixed.set(unPrefixed, cluster);
+		}
+		cluster.set(locale, entry);
+	}
+	const out = [];
+	for (const variantsByLocale of byUnPrefixed.values()) {
+		const canonical = variantsByLocale.get(defaultLocale) ?? variantsByLocale.get(null) ?? [...variantsByLocale.values()][0];
+		out.push({
+			canonical,
+			variantsByLocale
+		});
+	}
+	return out;
+}
+/**
+* Strip the locale prefix from a path under the i18n strategy.
+*
+* Returns `{ unPrefixed, locale }`:
+*   - `/about` under `prefix-except-default` (default=en) → `{ unPrefixed: '/about', locale: 'en' }`
+*   - `/de/about` under either strategy → `{ unPrefixed: '/about', locale: 'de' }`
+*   - `/de` (locale root) → `{ unPrefixed: '/', locale: 'de' }`
+*   - `/about` under `prefix` → no locale match, returns `{ unPrefixed: '/about', locale: null }`
+*     (the URL doesn't fit any locale subtree — sitemap treats it as standalone).
+*
+* @internal — exported for unit testing.
+*/
+function stripLocalePrefix(path, locales, defaultLocale, strategy) {
+	for (const locale of locales) {
+		if (path === `/${locale}`) return {
+			unPrefixed: "/",
+			locale
+		};
+		if (path.startsWith(`/${locale}/`)) return {
+			unPrefixed: path.slice(`/${locale}`.length),
+			locale
+		};
+	}
+	if (strategy === "prefix-except-default") return {
+		unPrefixed: path,
+		locale: defaultLocale
+	};
+	return {
+		unPrefixed: path,
+		locale: null
+	};
+}
+function renderClusterEntry(cluster, origin, changefreq, priority, i18n) {
+	const { canonical, variantsByLocale } = cluster;
+	const lines = [
+		"  <url>",
+		`    <loc>${escapeXml(`${origin}${canonical.path === "/" ? "" : canonical.path}`)}</loc>`,
+		`    <changefreq>${canonical.changefreq ?? changefreq}</changefreq>`,
+		`    <priority>${canonical.priority ?? priority}</priority>`
+	];
+	if (canonical.lastmod) lines.push(`    <lastmod>${canonical.lastmod}</lastmod>`);
+	if (i18n != null && i18n.locales.length > 0 && variantsByLocale.size > 1) {
+		for (const locale of i18n.locales) {
+			const variant = variantsByLocale.get(locale);
+			if (!variant) continue;
+			const variantLoc = `${origin}${variant.path === "/" ? "" : variant.path}`;
+			lines.push(`    <xhtml:link rel="alternate" hreflang="${escapeXml(locale)}" href="${escapeXml(variantLoc)}"/>`);
+		}
+		const defaultVariant = variantsByLocale.get(i18n.defaultLocale);
+		if (defaultVariant) {
+			const defaultLoc = `${origin}${defaultVariant.path === "/" ? "" : defaultVariant.path}`;
+			lines.push(`    <xhtml:link rel="alternate" hreflang="x-default" href="${escapeXml(defaultLoc)}"/>`);
+		}
+	}
+	lines.push("  </url>");
+	return lines.join("\n");
+}
 function escapeXml(str) {
 	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 /**
+* Resolve the i18n config to feed `generateSitemap` for hreflang
+* emission. Priority order:
+*   1. Explicit user config — `hreflang: I18nRoutingConfig` (object)
+*   2. Auto-detect from SSG manifest — `hreflang: true` + `manifestI18n`
+*      present (only happens in SSG mode where the manifest exists)
+*   3. Nothing — emit plain sitemap without xhtml:link siblings
+*
+* @internal — exported for unit testing.
+*/
+function resolveHreflangI18n(hreflang, manifestI18n) {
+	if (hreflang == null || hreflang === false) return void 0;
+	if (hreflang === true) return manifestI18n;
+	return hreflang;
+}
+/**
+* Duck-type guard for `I18nRoutingConfig`. The SSG manifest is JSON,
+* so the embedded i18n field could in principle be malformed if a
+* downstream user hand-edits the manifest (don't). Validate the shape
+* before trusting it.
+*
+* @internal
+*/
+function isI18nRoutingConfig(value) {
+	if (value == null || typeof value !== "object") return false;
+	const v = value;
+	return Array.isArray(v.locales) && v.locales.every((l) => typeof l === "string") && typeof v.defaultLocale === "string";
+}
+/**
 * Generate a robots.txt string.
 */
 function generateRobots(config = {}) {
@@ -82,22 +212,33 @@ function jsonLd(data) {
 *     pyreon(),
 *     zero(),
 *     seoPlugin({
-*       sitemap: { origin: "https://example.com" },
+*       sitemap: {
+*         origin: "https://example.com",
+*         useSsgPaths: true, // include dynamic-route enumerations
+*       },
 *       robots: { sitemap: "https://example.com/sitemap.xml" },
 *     }),
 *   ],
 * }
 */
 function seoPlugin(config = {}) {
+	const useSsgPaths = config.sitemap?.useSsgPaths === true;
+	let distDir = "";
 	return {
 		name: "pyreon-zero-seo",
 		apply: "build",
+		...useSsgPaths ? { enforce: "post" } : {},
+		configResolved(resolved) {
+			distDir = resolve(resolved.root, resolved.build.outDir);
+		},
 		async generateBundle(_, _bundle) {
-			if (config.sitemap) {
+			if (config.sitemap && !useSsgPaths) {
 				const { scanRouteFiles } = await import("./fs-router-3xzp-4Wj.js");
 				const routesDir = `${process.cwd()}/src/routes`;
 				try {
-					const sitemap = generateSitemap(await scanRouteFiles(routesDir), config.sitemap);
+					const files = await scanRouteFiles(routesDir);
+					const hreflangI18n = resolveHreflangI18n(config.sitemap.hreflang, void 0);
+					const sitemap = generateSitemap(files, config.sitemap, hreflangI18n);
 					this.emitFile({
 						type: "asset",
 						fileName: "sitemap.xml",
@@ -113,6 +254,36 @@ function seoPlugin(config = {}) {
 					source: robots
 				});
 			}
+		},
+		async closeBundle() {
+			if (!config.sitemap || !useSsgPaths) return;
+			const { scanRouteFiles } = await import("./fs-router-3xzp-4Wj.js");
+			const routesDir = `${process.cwd()}/src/routes`;
+			const manifestPath = join(distDir, "_pyreon-ssg-paths.json");
+			try {
+				let ssgPaths = [];
+				let manifestI18n;
+				if (existsSync(manifestPath)) {
+					const raw = await readFile(manifestPath, "utf-8");
+					const parsed = JSON.parse(raw);
+					if (Array.isArray(parsed.paths)) ssgPaths = parsed.paths.filter((p) => typeof p === "string").map((path) => ({ path }));
+					if (isI18nRoutingConfig(parsed.i18n)) manifestI18n = parsed.i18n;
+					try {
+						await rm(manifestPath, { force: true });
+					} catch {}
+				}
+				let files = [];
+				try {
+					files = await scanRouteFiles(routesDir);
+				} catch {}
+				const merged = {
+					...config.sitemap,
+					additionalPaths: [...ssgPaths, ...config.sitemap.additionalPaths ?? []]
+				};
+				const hreflangI18n = resolveHreflangI18n(config.sitemap.hreflang, manifestI18n);
+				const sitemap = generateSitemap(files, merged, hreflangI18n);
+				await writeFile(join(distDir, "sitemap.xml"), sitemap, "utf-8");
+			} catch {}
 		}
 	};
 }
@@ -132,5 +303,5 @@ function seoMiddleware(config = {}) {
 }
 
 //#endregion
-export { generateRobots, generateSitemap, jsonLd, seoMiddleware, seoPlugin };
+export { clusterPathsByLocale, generateRobots, generateSitemap, jsonLd, resolveHreflangI18n, seoMiddleware, seoPlugin, stripLocalePrefix };
 //# sourceMappingURL=seo.js.map