@pyreon/zero 0.14.0 → 0.16.0

package/lib/script.js

@@ -1,4 +1,6 @@
 import { createRef, onMount, onUnmount } from "@pyreon/core";
+import { signal } from "@pyreon/reactivity";
+import { jsx } from "@pyreon/core/jsx-runtime";
 
 //#region src/utils/use-intersection-observer.ts
 /**
@@ -24,88 +26,70 @@ function useIntersectionObserver(getElement, onIntersect, rootMargin = "200px")
 	});
 }
 
-//#endregion
-//#region ../../core/core/lib/jsx-runtime.js
-/**
-* Hyperscript function — the compiled output of JSX.
-* `<div class="x">hello</div>` → `h("div", { class: "x" }, "hello")`
-*
-* Generic on P so TypeScript validates props match the component's signature
-* at the call site, then stores the result in the loosely-typed VNode.
-*/
-/** Shared empty props sentinel — identity-checked in mountElement to skip applyProps. */
-const EMPTY_PROPS = {};
-function h(type, props, ...children) {
-	return {
-		type,
-		props: props ?? EMPTY_PROPS,
-		children: normalizeChildren(children),
-		key: props?.key ?? null
-	};
-}
-function normalizeChildren(children) {
-	for (let i = 0; i < children.length; i++) if (Array.isArray(children[i])) return flattenChildren(children);
-	return children;
-}
-function flattenChildren(children) {
-	const result = [];
-	for (const child of children) if (Array.isArray(child)) result.push(...flattenChildren(child));
-	else result.push(child);
-	return result;
-}
-/**
-* JSX automatic runtime.
-*
-* When tsconfig has `"jsxImportSource": "@pyreon/core"`, the TS/bundler compiler
-* rewrites JSX to imports from this file automatically:
-*   <div class="x" />  →  jsx("div", { class: "x" })
-*/
-function jsx(type, props, key) {
-	const { children, ...rest } = props;
-	const propsWithKey = key != null ? {
-		...rest,
-		key
-	} : rest;
-	if (typeof type === "function") return h(type, children !== void 0 ? {
-		...propsWithKey,
-		children
-	} : propsWithKey);
-	return h(type, propsWithKey, ...children === void 0 ? [] : Array.isArray(children) ? children : [children]);
-}
-
 //#endregion
 //#region src/script.tsx
 /**
-* Optimized script loading component.
+* Composable that provides all script loading behavior — strategy state
+* machine (afterHydration / onIdle / onInteraction / onViewport),
+* deduplication, load/error tracking.
 *
-* @example
-* // Load analytics after page is interactive
-* <Script src="https://analytics.example.com/script.js" strategy="onIdle" />
+* Returns reactive signals (`loaded`, `errored`, `pending`) so consumers
+* can render loading indicators, retry buttons, or analytics-readiness
+* gates without re-implementing the strategy machine.
 *
-* // Load chat widget when user scrolls
-* <Script src="/chat-widget.js" strategy="onViewport" />
-*
-* // Inline script with deferred execution
-* <Script strategy="afterHydration">
-*   {`console.log("App hydrated!")`}
-* <\/Script>
+* @example
+* function MyScript(props: ScriptProps) {
+*   const s = useScript(props)
+*   return (
+*     <>
+*       {() => s.loaded() ? <Analytics /> : <Skeleton />}
+*       {() => s.needsSentinel && <div ref={s.sentinelRef} style="width:0;height:0" />}
+*     </>
+*   )
+* }
 */
-function Script(props) {
+function useScript(props) {
+	const strategy = props.strategy ?? "afterHydration";
+	const loaded = signal(false);
+	const errored = signal(false);
+	const pending = signal(strategy !== "beforeHydration" && strategy !== "afterHydration");
+	const sentinelRef = strategy === "onViewport" ? createRef() : void 0;
 	function loadScript() {
 		if (typeof document === "undefined") return;
-		if (props.id && document.getElementById(props.id)) return;
+		if (props.id && document.getElementById(props.id)) {
+			loaded.set(true);
+			pending.set(false);
+			return;
+		}
 		const script = document.createElement("script");
 		if (props.src) script.src = props.src;
 		if (props.id) script.id = props.id;
 		script.async = props.async !== false;
-		if (props.onLoad) script.onload = props.onLoad;
-		if (props.onError) script.onerror = () => props.onError?.(/* @__PURE__ */ new Error(`Failed to load: ${props.src}`));
-		if (props.children && !props.src) script.textContent = props.children;
+		script.onload = () => {
+			loaded.set(true);
+			pending.set(false);
+			props.onLoad?.();
+		};
+		script.onerror = () => {
+			errored.set(true);
+			pending.set(false);
+			props.onError?.(/* @__PURE__ */ new Error(`Failed to load: ${props.src}`));
+		};
+		if (props.children && !props.src) {
+			script.textContent = props.children;
+			setTimeout(() => {
+				loaded.set(true);
+				pending.set(false);
+			}, 0);
+		}
 		document.head.appendChild(script);
 	}
 	onMount(() => {
-		switch (props.strategy ?? "afterHydration") {
-			case "beforeHydration": break;
+		switch (strategy) {
+			case "beforeHydration":
+				loaded.set(true);
+				pending.set(false);
+				break;
 			case "afterHydration":
 				loadScript();
 				break;
@@ -136,16 +120,73 @@ function Script(props) {
 			case "onViewport": break;
 		}
 	});
-	const sentinelRef = createRef();
-	const strategy = props.strategy ?? "afterHydration";
 	if (strategy === "onViewport") useIntersectionObserver(() => sentinelRef.current ?? void 0, () => loadScript());
-	if (strategy === "onViewport") return /* @__PURE__ */ jsx("div", {
-		ref: sentinelRef,
+	return {
+		sentinelRef,
+		loaded,
+		errored,
+		pending,
+		needsSentinel: strategy === "onViewport",
+		load: loadScript
+	};
+}
+/**
+* Higher-order component that wraps any component with script load behavior.
+*
+* The wrapped component receives {@link ScriptRenderProps} with the sentinel
+* ref, load-state signals, and a `needsSentinel` flag. Use this when you want
+* to render a loading indicator, retry button, or custom analytics-readiness
+* gate around the script load.
+*
+* @example
+* // Script with a loading indicator
+* const TrackedScript = createScript((props) => (
+*   <>
+*     {() => props.pending() && <Spinner />}
+*     {() => props.errored() && <button onClick={() => location.reload()}>Retry</button>}
+*     {props.needsSentinel && <div ref={props.sentinelRef} style="width:0;height:0" />}
+*   </>
+* ))
+*
+* <TrackedScript src="/analytics.js" strategy="onIdle" />
+*/
+function createScript(Component) {
+	return function WrappedScript(props) {
+		const s = useScript(props);
+		return /* @__PURE__ */ jsx(Component, {
+			sentinelRef: s.sentinelRef,
+			needsSentinel: s.needsSentinel,
+			loaded: s.loaded,
+			errored: s.errored,
+			pending: s.pending
+		});
+	};
+}
+/**
+* Default optimized script component. Renders a 0×0 sentinel `<div>` for the
+* `onViewport` strategy (so IntersectionObserver has an element to observe),
+* `null` for every other strategy.
+*
+* @example
+* // Load analytics after page is interactive
+* <Script src="https://analytics.example.com/script.js" strategy="onIdle" />
+*
+* // Load chat widget when user scrolls
+* <Script src="/chat-widget.js" strategy="onViewport" />
+*
+* // Inline script with deferred execution
+* <Script strategy="afterHydration">
+*   {`console.log("App hydrated!")`}
+* <\/Script>
+*/
+const Script = createScript((props) => {
+	if (!props.needsSentinel) return null;
+	return /* @__PURE__ */ jsx("div", {
+		ref: props.sentinelRef,
 		style: "width:0;height:0;overflow:hidden"
 	});
-	return null;
-}
+});
 
 //#endregion
-export { Script };
+export { Script, createScript, useScript };
 //# sourceMappingURL=script.js.map

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