@stratal/inertia 0.0.22 → 0.0.24

package/dist/index.mjs

@@ -1,10 +1,10 @@
-import { t as __decorate } from "./decorate-CzXVx7ZH.mjs";
+import { t as __decorate } from "./decorate-B7nr7eBl.mjs";
+import { n as buildSeoTags, r as descriptorToHtml, t as DATA_SEO_ATTR } from "./build-seo-tags-DBsHKxX9.mjs";
 import { ApplicationError } from "stratal/errors";
 import { Module } from "stratal/module";
-import { Delete, Get, Patch, Post, Put, ROUTER_TOKENS, Route, RouterContext, SchemaValidationError } from "stratal/router";
-import { DI_TOKENS, Request, Singleton, Transient, inject } from "stratal/di";
+import { Delete, Get, Patch, Post, Put, ROUTER_TOKENS, Route, RouterContext, SchemaValidationError, applyTrailingSlash } from "stratal/router";
+import { CONTAINER_TOKEN, DI_TOKENS, Request, Singleton, Transient, inject } from "stratal/di";
 import { I18N_TOKENS } from "stratal/i18n";
-import { LOGGER_TOKENS } from "stratal/logger";
 import { deleteCookie, getSignedCookie, setSignedCookie } from "hono/cookie";
 import { z } from "stratal/validation";
 //#region src/augment/router-context.ts
@@ -39,6 +39,12 @@ function augmentRouterContext(resolveService) {
 		const flashOut = this.c.get("inertiaFlashOut");
 		if (flashOut) flashOut[key] = value;
 	});
+	RouterContext.macro("share", function(key, value) {
+		resolveService(this).share(key, value);
+	});
+	RouterContext.macro("seo", function(data) {
+		resolveService(this).seo(data);
+	});
 	RouterContext.macro("withoutSsr", function() {
 		this.c.set("withoutSsr", true);
 	});
@@ -50,10 +56,12 @@ const INERTIA_TOKENS = {
 	InertiaService: Symbol.for("stratal:inertia:service"),
 	TemplateService: Symbol.for("stratal:inertia:template"),
 	ManifestService: Symbol.for("stratal:inertia:manifest"),
-	SsrRenderer: Symbol.for("stratal:inertia:ssr-renderer")
+	SsrRenderer: Symbol.for("stratal:inertia:ssr-renderer"),
+	HreflangService: Symbol.for("stratal:inertia:hreflang"),
+	SeoService: Symbol.for("stratal:inertia:seo")
 };
 //#endregion
-//#region \0@oxc-project+runtime@0.129.0/helpers/decorateParam.js
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/decorateParam.js
 function __decorateParam(paramIndex, decorator) {
 	return function(target, key) {
 		decorator(target, key, paramIndex);
@@ -105,6 +113,60 @@ let InertiaMiddleware = class InertiaMiddleware {
 };
 InertiaMiddleware = __decorate([Transient(), __decorateParam(0, inject(INERTIA_TOKENS.Options))], InertiaMiddleware);
 //#endregion
+//#region src/services/hreflang.service.ts
+let HreflangService = class HreflangService {
+	container;
+	constructor(container) {
+		this.container = container;
+	}
+	buildLinks(currentUrl) {
+		const i18n = this.container.tryResolve(I18N_TOKENS.Options);
+		if (!i18n) return [];
+		const locales = i18n.locales ?? ["en"];
+		if (locales.length < 2) return [];
+		const defaultLocale = i18n.defaultLocale ?? "en";
+		const trailingSlash = this.container.resolve(DI_TOKENS.Application).config.trailingSlash ?? "ignore";
+		const localeUrl = this.container.resolve(ROUTER_TOKENS.LocaleUrlService);
+		if (localeUrl.pathEnabled) return this.buildPathLinks(currentUrl, locales, defaultLocale, localeUrl, trailingSlash);
+		if ((i18n.detection && "strategy" in i18n.detection ? i18n.detection.strategy : void 0) === "querystring") return this.buildQuerystringLinks(currentUrl, locales, defaultLocale, trailingSlash);
+		return [];
+	}
+	buildPathLinks(url, locales, defaultLocale, localeUrl, trailingSlash) {
+		const basePath = localeUrl.stripPrefix(url.pathname);
+		const links = locales.map((locale) => this.linkTag(locale, this.compose(url, localeUrl.applyPrefix(basePath, locale), url.search, trailingSlash)));
+		links.push(this.linkTag("x-default", this.compose(url, localeUrl.applyPrefix(basePath, defaultLocale), url.search, trailingSlash)));
+		return links;
+	}
+	buildQuerystringLinks(url, locales, defaultLocale, trailingSlash) {
+		const params = new URLSearchParams(url.search);
+		params.delete("locale");
+		const baseQs = params.toString();
+		const links = locales.map((locale) => {
+			const qs = this.composeQuery(baseQs, locale === defaultLocale ? null : ["locale", locale]);
+			return this.linkTag(locale, this.compose(url, url.pathname, qs, trailingSlash));
+		});
+		const xDefaultQs = baseQs ? `?${baseQs}` : "";
+		links.push(this.linkTag("x-default", this.compose(url, url.pathname, xDefaultQs, trailingSlash)));
+		return links;
+	}
+	compose(url, pathname, search, mode) {
+		return applyTrailingSlash(url.origin + pathname + search, mode);
+	}
+	composeQuery(baseQs, extra) {
+		if (!extra) return baseQs ? `?${baseQs}` : "";
+		const tail = `${extra[0]}=${encodeURIComponent(extra[1])}`;
+		return baseQs ? `?${baseQs}&${tail}` : `?${tail}`;
+	}
+	linkTag(hreflang, href) {
+		return {
+			rel: "alternate",
+			hreflang,
+			href
+		};
+	}
+};
+HreflangService = __decorate([Singleton(), __decorateParam(0, inject(CONTAINER_TOKEN))], HreflangService);
+//#endregion
 //#region src/types.ts
 const INERTIA_PROP_OPTIONAL = Symbol.for("stratal:inertia:prop:optional");
 const INERTIA_PROP_DEFERRED = Symbol.for("stratal:inertia:prop:deferred");
@@ -117,15 +179,20 @@ let InertiaService = class InertiaService {
 	options;
 	template;
 	ssr;
+	seoService;
 	sharedData = {};
-	constructor(options, template, ssr) {
+	constructor(options, template, ssr, seoService) {
 		this.options = options;
 		this.template = template;
 		this.ssr = ssr;
+		this.seoService = seoService;
 	}
 	share(key, value) {
 		this.sharedData[key] = value;
 	}
+	seo(data) {
+		this.seoService.set(data);
+	}
 	location(url) {
 		return new Response("", {
 			status: 409,
@@ -170,14 +237,21 @@ let InertiaService = class InertiaService {
 	async render(ctx, component, props = {}, renderOptions = {}) {
 		const reqUrl = new URL(ctx.c.req.url);
 		const url = reqUrl.search ? `${reqUrl.pathname}${reqUrl.search}` : reqUrl.pathname;
+		const pathname = reqUrl.pathname;
 		const isInertia = ctx.c.get("inertia");
 		const { shared: resolvedShared, sharedKeys } = await this.resolveSharedData(ctx);
+		const resolvedSeo = await this.seoService.resolve(ctx);
 		const allProps = {
 			...resolvedShared,
 			...this.sharedData,
+			seo: this.always(() => resolvedSeo),
 			...props
 		};
-		const allSharedKeys = [...sharedKeys, ...Object.keys(this.sharedData)];
+		const allSharedKeys = [
+			...sharedKeys,
+			...Object.keys(this.sharedData),
+			"seo"
+		];
 		const result = await this.processProps(allProps, ctx, component, isInertia);
 		const { errors: flashErrors, ...flash } = ctx.c.get("inertiaFlash") ?? {};
 		const errors = flashErrors && typeof flashErrors === "object" && !Array.isArray(flashErrors) ? flashErrors : {};
@@ -213,12 +287,17 @@ let InertiaService = class InertiaService {
 				"Vary": "X-Inertia"
 			}
 		});
-		const ssrResult = ctx.c.get("withoutSsr") || this.isSsrDisabled(url) ? {
-			head: [],
-			body: ""
-		} : await this.ssr.render(page);
-		const html = this.template.render(page, ssrResult.head, ssrResult.body);
-		return new Response(html, {
+		const seoTags = this.seoService.tagsFor(resolvedSeo);
+		if (ctx.c.get("withoutSsr") || this.isSsrDisabled(pathname) || !this.options.ssr) {
+			const html = this.template.renderClientOnly(page, seoTags);
+			return new Response(html, {
+				status,
+				headers: { "Content-Type": "text/html; charset=utf-8" }
+			});
+		}
+		const { head, stream } = await this.ssr.render(page);
+		const body = this.template.renderStream(page, [...head, ...seoTags], stream);
+		return new Response(body, {
 			status,
 			headers: { "Content-Type": "text/html; charset=utf-8" }
 		});
@@ -248,6 +327,7 @@ let InertiaService = class InertiaService {
 			const uri = container.resolve(ROUTER_TOKENS.Uri);
 			const name = registry.findNameByRoute(ctx.c.req.method, ctx.c.req.routePath) ?? null;
 			const params = { ...ctx.param() };
+			const localePathService = container.resolve(ROUTER_TOKENS.LocalePathService);
 			shared.routes = this.serializeRoutes(registry.named());
 			shared.trailingSlash = application.config.trailingSlash ?? "ignore";
 			shared.route = {
@@ -255,6 +335,10 @@ let InertiaService = class InertiaService {
 				params,
 				defaults: uri.getDefaults()
 			};
+			shared.localeConfig = {
+				defaultLocale: localePathService.localePathConfig?.defaultLocale ?? null,
+				prefixDefaultLocale: localePathService.prefixDefaultLocale
+			};
 		}
 		return {
 			shared,
@@ -393,7 +477,8 @@ InertiaService = __decorate([
 	Request(INERTIA_TOKENS.InertiaService),
 	__decorateParam(0, inject(INERTIA_TOKENS.Options)),
 	__decorateParam(1, inject(INERTIA_TOKENS.TemplateService)),
-	__decorateParam(2, inject(INERTIA_TOKENS.SsrRenderer))
+	__decorateParam(2, inject(INERTIA_TOKENS.SsrRenderer)),
+	__decorateParam(3, inject(INERTIA_TOKENS.SeoService))
 ], InertiaService);
 //#endregion
 //#region src/services/manifest.service.ts
@@ -402,12 +487,20 @@ let ManifestService = class ManifestService {
 	manifest;
 	entryClientPath;
 	isDev = Boolean(import.meta.env.DEV);
+	headTags = null;
+	scriptTags = null;
 	constructor(options) {
 		this.manifest = globalThis.__STRATAL_INERTIA_MANIFEST__ ?? null;
 		this.entryClientPath = (options.entryClientPath ?? DEFAULT_ENTRY_CLIENT_PATH).replace(/^\/+/, "");
 		if (!this.isDev && !this.manifest) throw new Error("@stratal/inertia: production build is missing the Vite client manifest. This is wired by stratalInertia() in vite.config.ts — confirm it is in your plugin list and that the client environment built successfully before the worker environment.");
 	}
 	getHeadTags() {
+		return this.headTags ??= this.buildHeadTags();
+	}
+	getScriptTags() {
+		return this.scriptTags ??= this.buildScriptTags();
+	}
+	buildHeadTags() {
 		if (this.isDev) return "<link rel=\"stylesheet\" href=\"/__inertia/ssr-css\" data-ssr-css />";
 		const tags = [];
 		const seen = /* @__PURE__ */ new Set();
@@ -418,7 +511,7 @@ let ManifestService = class ManifestService {
 		}
 		return tags.join("\n");
 	}
-	getScriptTags() {
+	buildScriptTags() {
 		if (this.isDev) return [
 			"<script type=\"module\" src=\"/@vite/client\"><\/script>",
 			`<script type="module">
@@ -435,28 +528,90 @@ hot.on("vite:afterUpdate", () => {
 		return tags.join("\n");
 	}
 };
-ManifestService = __decorate([Transient(), __decorateParam(0, inject(INERTIA_TOKENS.Options))], ManifestService);
+ManifestService = __decorate([Singleton(), __decorateParam(0, inject(INERTIA_TOKENS.Options))], ManifestService);
+//#endregion
+//#region src/services/seo.service.ts
+let SeoService = class SeoService {
+	options;
+	hreflang;
+	accumulated = {};
+	constructor(options, hreflang) {
+		this.options = options;
+		this.hreflang = hreflang;
+	}
+	/** Merges the given metadata into the request's accumulated SEO data. */
+	set(data) {
+		this.accumulated = mergeSeo(this.accumulated, data);
+	}
+	/**
+	* Resolves the final SEO data: module defaults (base) merged with the
+	* request's accumulated data, then the title template applied. Resolver
+	* functions for `defaults`/`titleTemplate` are awaited with the request `ctx`.
+	* Locale-aware `hreflang` alternates are appended last so they ride the same
+	* head injection and SPA reconciliation as the rest of the SEO tags.
+	*
+	* The resolved `title` is ALWAYS a string (falling back to `''`). This makes
+	* the `<title>` descriptor deterministic: every navigation — including to a
+	* page with no SEO — produces a title, so the client head-sync sets
+	* `document.title` rather than leaving the previous page's title stale.
+	*/
+	async resolve(ctx) {
+		const seo = this.options.seo;
+		const resolved = mergeSeo(typeof seo?.defaults === "function" ? await seo.defaults(ctx) : seo?.defaults ?? {}, this.accumulated);
+		const template = seo?.titleTemplate;
+		if (typeof template === "function") resolved.title = await template(resolved.title, ctx);
+		else if (typeof template === "string" && this.accumulated.title != null) resolved.title = template.split("%s").join(this.accumulated.title);
+		resolved.title ??= "";
+		const hreflang = this.hreflang.buildLinks(new URL(ctx.c.req.url));
+		if (hreflang.length > 0) resolved.link = [...resolved.link ?? [], ...hreflang];
+		return resolved;
+	}
+	/** Renders resolved SEO data into a list of head-tag HTML strings. */
+	tagsFor(resolved) {
+		return buildSeoTags(resolved).map(descriptorToHtml);
+	}
+};
+SeoService = __decorate([
+	Request(INERTIA_TOKENS.SeoService),
+	__decorateParam(0, inject(INERTIA_TOKENS.Options)),
+	__decorateParam(1, inject(INERTIA_TOKENS.HreflangService))
+], SeoService);
+/** Merges `b` over `a`: `openGraph`/`twitter` shallow-merge, `meta`/`link` concat, scalars overwrite. */
+function mergeSeo(a, b) {
+	return {
+		...a,
+		...b,
+		...a.openGraph || b.openGraph ? { openGraph: {
+			...a.openGraph,
+			...b.openGraph
+		} } : {},
+		...a.twitter || b.twitter ? { twitter: {
+			...a.twitter,
+			...b.twitter
+		} } : {},
+		...a.meta || b.meta ? { meta: [...a.meta ?? [], ...b.meta ?? []] } : {},
+		...a.link || b.link ? { link: [...a.link ?? [], ...b.link ?? []] } : {}
+	};
+}
 //#endregion
 //#region src/services/ssr-renderer.service.ts
 let SsrRendererService = class SsrRendererService {
 	options;
-	logger;
 	bundle = null;
 	loadPromise = null;
-	constructor(options, logger) {
+	constructor(options) {
 		this.options = options;
-		this.logger = logger;
 	}
+	/**
+	* Render a page to a streaming SSR result.
+	*
+	* The SSR bundle is imported once per worker (memoized). Bundle-load and render
+	* errors propagate — there is no silent client-side fallback. Callers must only
+	* invoke this when `options.ssr` is configured.
+	*/
 	async render(page) {
-		if (!this.options.ssr) return {
-			head: [],
-			body: ""
-		};
+		if (!this.options.ssr) throw new ApplicationError("[stratal:inertia] SSR bundle is not configured.");
 		await this.ensureBundle();
-		if (!this.bundle) return {
-			head: [],
-			body: ""
-		};
 		return this.bundle.render(page);
 	}
 	async ensureBundle() {
@@ -464,52 +619,84 @@ let SsrRendererService = class SsrRendererService {
 		this.loadPromise ??= this.loadBundle();
 		try {
 			await this.loadPromise;
-		} catch {}
-	}
-	async loadBundle() {
-		if (!this.options.ssr) return;
-		try {
-			const mod = await this.options.ssr.bundle();
-			const resolved = "default" in mod ? mod.default : mod;
-			this.bundle = resolved;
 		} catch (error) {
-			this.logger.warn("[stratal:inertia] Failed to load SSR bundle. Falling back to client-side rendering.", { error });
 			this.loadPromise = null;
+			throw error;
 		}
 	}
+	async loadBundle() {
+		const mod = await this.options.ssr.bundle();
+		this.bundle = "default" in mod ? mod.default : mod;
+	}
 };
-SsrRendererService = __decorate([
-	Singleton(),
-	__decorateParam(0, inject(INERTIA_TOKENS.Options)),
-	__decorateParam(1, inject(LOGGER_TOKENS.LoggerService))
-], SsrRendererService);
+SsrRendererService = __decorate([Singleton(), __decorateParam(0, inject(INERTIA_TOKENS.Options))], SsrRendererService);
 //#endregion
 //#region src/services/template.service.ts
+const APP_ID = "app";
 let TemplateService = class TemplateService {
-	options;
 	manifest;
+	pre;
+	post;
 	constructor(options, manifest) {
-		this.options = options;
 		this.manifest = manifest;
+		const match = /@inertia\b/.exec(options.rootView);
+		if (!match) throw new ApplicationError("[stratal:inertia] rootView template is missing the @inertia placeholder.");
+		this.pre = options.rootView.slice(0, match.index);
+		this.post = options.rootView.slice(match.index + 8);
+	}
+	/**
+	* Compose the streamed HTML response: the document shell (head + opening
+	* `#app` wrapper) is flushed first, the React stream is piped verbatim, then
+	* the wrapper is closed and the trailing scripts are appended.
+	*
+	* Reproduces Inertia's `buildSSRBody` markup: a `<script data-page>` JSON tag
+	* (parsed before hydration) followed by `<div data-server-rendered id="app">`.
+	*/
+	renderStream(page, head, reactStream) {
+		const encoder = new TextEncoder();
+		const shellPre = this.fillPlaceholders(this.pre, head) + `<script data-page="${APP_ID}" type="application/json">${this.serialize(page)}<\/script><div data-server-rendered="true" id="${APP_ID}">`;
+		const shellPost = `</div>${this.fillPlaceholders(this.post, head)}`;
+		let reader;
+		return new ReadableStream({
+			async start(controller) {
+				controller.enqueue(encoder.encode(shellPre));
+				reader = reactStream.getReader();
+				try {
+					for (;;) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						controller.enqueue(value);
+					}
+					controller.enqueue(encoder.encode(shellPost));
+					controller.close();
+				} catch (error) {
+					controller.error(error);
+				} finally {
+					reader.releaseLock();
+					reader = void 0;
+				}
+			},
+			cancel(reason) {
+				return reader?.cancel(reason) ?? reactStream.cancel(reason);
+			}
+		});
+	}
+	/**
+	* Buffered, client-only document used when SSR is disabled for the request.
+	* Emits an empty `#app` div for the client bundle to hydrate.
+	*/
+	renderClientOnly(page, head) {
+		return this.fillPlaceholders(this.pre, head) + `<script data-page="${APP_ID}" type="application/json">${this.serialize(page)}<\/script><div id="${APP_ID}"></div>` + this.fillPlaceholders(this.post, head);
+	}
+	fillPlaceholders(segment, head) {
+		return segment.replace("@inertiaHead", () => head.join("\n")).replace("@viteHead", () => this.manifest.getHeadTags()).replace("@viteScripts", () => this.manifest.getScriptTags());
 	}
-	render(page, ssrHead, ssrBody) {
-		const appHtml = ssrBody || this.buildClientOnlyBody(page);
-		const headTags = ssrHead.length > 0 ? ssrHead.join("\n") : "";
-		const viteHead = this.manifest.getHeadTags();
-		const viteScripts = this.manifest.getScriptTags();
-		let html = this.options.rootView;
-		html = html.replace("@inertiaHead", headTags);
-		html = html.replace("@inertia", appHtml);
-		html = html.replace("@viteHead", viteHead);
-		html = html.replace("@viteScripts", viteScripts);
-		return html;
-	}
-	buildClientOnlyBody(page) {
-		return `<script data-page="app" type="application/json">${JSON.stringify(page).replace(/\//g, "\\/")}<\/script><div id="app"></div>`;
+	serialize(page) {
+		return JSON.stringify(page).replace(/\//g, "\\/");
 	}
 };
 TemplateService = __decorate([
-	Transient(),
+	Singleton(),
 	__decorateParam(0, inject(INERTIA_TOKENS.Options)),
 	__decorateParam(1, inject(INERTIA_TOKENS.ManifestService))
 ], TemplateService);
@@ -544,6 +731,7 @@ let InertiaModule = _InertiaModule = class InertiaModule {
 			if (context.type !== "http") return void 0;
 			if (this.isPrecognitionRequest(context)) return this.handlePrecognitionValidationError(error, context);
 			if (!this.isInertiaRequest(context)) return void 0;
+			if (this.isReadRequest(context)) return void 0;
 			const issues = error.issues ?? [];
 			const errors = {};
 			for (const issue of issues) errors[issue.path] = issue.message;
@@ -555,6 +743,7 @@ let InertiaModule = _InertiaModule = class InertiaModule {
 			const message = error.message;
 			if (this.isPrecognitionRequest(context)) return this.createPrecognitionErrorResponse({ _form: message });
 			if (!this.isInertiaRequest(context)) return void 0;
+			if (this.isReadRequest(context)) return void 0;
 			context.ctx.flash("errors", { _form: message });
 			return this.redirectBack(context);
 		});
@@ -577,6 +766,23 @@ let InertiaModule = _InertiaModule = class InertiaModule {
 	isInertiaRequest(context) {
 		return context.ctx.header("x-inertia") === "true";
 	}
+	/**
+	* GET/HEAD requests are idempotent navigations — including Inertia deferred
+	* partial reloads, which fetch deferred props over a follow-up XHR that still
+	* carries `X-Inertia: true`.
+	*
+	* Such requests must NOT use the flash-errors + redirect-back convention: the
+	* redirect points back at the very URL that just threw, so an error raised
+	* while resolving a deferred prop would redirect → re-request → throw again
+	* in an infinite loop (`ERR_TOO_MANY_REDIRECTS`). For these we fall through to
+	* the errorPage pipeline, which renders `Errors/${status}` in place as an
+	* Inertia response. Redirect-back stays for mutations (POST/PUT/PATCH/DELETE),
+	* where it drives the post-submit form-error flow.
+	*/
+	isReadRequest(context) {
+		const method = context.ctx.c.req.method.toUpperCase();
+		return method === "GET" || method === "HEAD";
+	}
 	isPrecognitionRequest(context) {
 		return context.ctx.header("precognition") === "true";
 	}
@@ -637,6 +843,14 @@ InertiaModule = _InertiaModule = __decorate([Module({ providers: [
 	{
 		provide: INERTIA_TOKENS.SsrRenderer,
 		useClass: SsrRendererService
+	},
+	{
+		provide: INERTIA_TOKENS.HreflangService,
+		useClass: HreflangService
+	},
+	{
+		provide: INERTIA_TOKENS.SeoService,
+		useClass: SeoService
 	}
 ] })], InertiaModule);
 //#endregion
@@ -829,6 +1043,6 @@ let HandlePrecognitiveRequests = class HandlePrecognitiveRequests {
 };
 HandlePrecognitiveRequests = __decorate([Transient()], HandlePrecognitiveRequests);
 //#endregion
-export { CookieFlashStore, HandlePrecognitiveRequests, INERTIA_TOKENS, InertiaDelete, InertiaGet, InertiaMiddleware, InertiaModule, InertiaPatch, InertiaPost, InertiaPut, InertiaRoute, InertiaService, ManifestService, SsrRendererService, TemplateService };
+export { CookieFlashStore, DATA_SEO_ATTR, HandlePrecognitiveRequests, INERTIA_TOKENS, InertiaDelete, InertiaGet, InertiaMiddleware, InertiaModule, InertiaPatch, InertiaPost, InertiaPut, InertiaRoute, InertiaService, ManifestService, SeoService, SsrRendererService, TemplateService, buildSeoTags, descriptorToHtml };
 
 //# sourceMappingURL=index.mjs.map