@phtngyn/cms 0.2.0-beta.8 → 0.3.0

package/src/nuxtDelivery-BYX_Cddb.js

@@ -0,0 +1,466 @@
+import { l as resolveDocumentSeo } from "./Seo-CjNUtUkj.js";
+import { m as mediaPath } from "./Media-DSyvd14o.js";
+import { _ as savedRevisionPreviewSelection, f as revisionPreviewRequested, g as savedRevisionPreviewRequested, l as revisionPreviewNavigationLocation, o as RevisionPreviewDocument, p as revisionPreviewToken, s as RevisionPreviewQueryPage } from "./RevisionPreview-IVwbJ9Wy.js";
+import { t as previewContextKey } from "./previewContext-dt3ZUh-w.js";
+import { t as contentLanguageAttributes } from "./locales-6OD4XGIZ.js";
+import { n as previewDocumentId, r as previewDocumentQueryKey, t as decodeLocaleConfiguration } from "./localeConfiguration-BPbkLi7-.js";
+import { o as switchLocalePath, r as localeFromPath } from "./Routes-BaZvm2LE.js";
+import { n as revisionPreviewLocale } from "./localeContext-DhF3SPvM.js";
+import { Schema } from "effect";
+import { computed, inject, toValue, useId, watch } from "vue";
+import { createError, useAsyncData, useHead, useNuxtApp, useRequestFetch, useRouter, useRuntimeConfig, useState } from "nuxt/app";
+//#region src/internal/pageSeo.ts
+function identitySchema(identity, assetOrigin) {
+	const common = {
+		"@context": "https://schema.org",
+		"@type": identity.type,
+		name: identity.name,
+		...identity.url ? { url: identity.url } : void 0
+	};
+	const imageUrl = (mediaId) => new URL(mediaPath(mediaId), assetOrigin).href;
+	switch (identity.type) {
+		case "Person": return {
+			...common,
+			...identity.image ? { image: imageUrl(identity.image.mediaId) } : void 0
+		};
+		case "Organization": return {
+			...common,
+			...identity.logo ? { logo: imageUrl(identity.logo.mediaId) } : void 0
+		};
+		case "LocalBusiness": return {
+			...common,
+			...identity.address ? { address: identity.address } : void 0,
+			...identity.image ? { image: imageUrl(identity.image.mediaId) } : void 0,
+			...identity.logo ? { logo: imageUrl(identity.logo.mediaId) } : void 0,
+			...identity.telephone ? { telephone: identity.telephone } : void 0
+		};
+	}
+}
+/** Build public head tags only from the published revision. */
+function pageSeoHead(delivered, site, locales) {
+	const source = delivered.source;
+	const seo = resolveDocumentSeo({
+		fields: source.fields,
+		path: delivered.canonicalPath,
+		page: source.settings.seo,
+		site
+	});
+	const locale = delivered.locale;
+	const image = seo.socialImage ? new URL(mediaPath(seo.socialImage.mediaId), site.canonicalOrigin).href : void 0;
+	const meta = [
+		{
+			name: "robots",
+			content: `${seo.index ? "index" : "noindex"}, ${seo.follow ? "follow" : "nofollow"}`
+		},
+		{
+			property: "og:title",
+			content: seo.socialTitle
+		},
+		{
+			property: "og:url",
+			content: seo.canonicalUrl
+		}
+	];
+	if (seo.description) meta.push({
+		name: "description",
+		content: seo.description
+	});
+	if (seo.socialDescription) meta.push({
+		property: "og:description",
+		content: seo.socialDescription
+	});
+	if (image) meta.push({
+		property: "og:image",
+		content: image
+	});
+	if (image && seo.socialImage?.alt) meta.push({
+		property: "og:image:alt",
+		content: seo.socialImage.alt
+	});
+	if (locale) {
+		const { language, region } = new Intl.Locale(locale);
+		if (region) meta.push({
+			property: "og:locale",
+			content: `${language}_${region}`
+		});
+	}
+	const structuredData = {
+		"@context": "https://schema.org",
+		"@type": seo.structuredData.type,
+		name: seo.title,
+		url: seo.canonicalUrl
+	};
+	if (seo.description) structuredData.description = seo.description;
+	if (image) structuredData.image = image;
+	if (locale) structuredData.inLanguage = locale;
+	if (seo.structuredData.type === "Article") {
+		structuredData.headline = seo.structuredData.headline ?? seo.title;
+		if (seo.structuredData.datePublished) structuredData.datePublished = seo.structuredData.datePublished;
+		if (seo.structuredData.dateModified) structuredData.dateModified = seo.structuredData.dateModified;
+	}
+	const head = {
+		title: seo.title,
+		titleTemplate: null,
+		meta,
+		link: [{
+			rel: "canonical",
+			href: seo.canonicalUrl
+		}, ...(delivered.alternatives ?? []).map((alternative) => ({
+			rel: "alternate",
+			hreflang: alternative.locale,
+			href: new URL(alternative.path, `${site.canonicalOrigin}/`).href
+		}))],
+		script: [...seo.identity ? [identitySchema(seo.identity, site.canonicalOrigin)] : [], structuredData].map((node) => ({
+			type: "application/ld+json",
+			innerHTML: JSON.stringify(node).replaceAll("<", "\\u003c")
+		}))
+	};
+	return locale ? {
+		...head,
+		htmlAttrs: contentLanguageAttributes(locale, locales)
+	} : head;
+}
+/** A draft preview uses working defaults and never requests indexing. */
+function previewSeoHead(source, site, locale, locales) {
+	const seo = resolveDocumentSeo({
+		fields: source.fields,
+		path: "/",
+		page: source.settings.seo,
+		site
+	});
+	const head = {
+		title: seo.title,
+		titleTemplate: null,
+		meta: [
+			{
+				name: "robots",
+				content: "noindex, nofollow"
+			},
+			...seo.description ? [{
+				name: "description",
+				content: seo.description
+			}] : [],
+			{
+				property: "og:title",
+				content: seo.socialTitle
+			},
+			...seo.socialDescription ? [{
+				property: "og:description",
+				content: seo.socialDescription
+			}] : []
+		]
+	};
+	return locale ? {
+		...head,
+		htmlAttrs: contentLanguageAttributes(locale, locales)
+	} : head;
+}
+/** Site-owned pages use the same tags as the default page for each delivery mode. */
+function deliverySeoHead(delivered, site, preview, locales) {
+	if (!delivered || "redirectTo" in delivered) return { meta: [{
+		name: "robots",
+		content: "noindex, nofollow"
+	}] };
+	if (!site) return {};
+	const source = delivered.source;
+	const locale = delivered.locale;
+	return preview || "draft" in delivered && delivered.draft ? previewSeoHead(source, site, locale, locales) : pageSeoHead(delivered, site, locales);
+}
+//#endregion
+//#region src/internal/revisionDelivery.ts
+/** The reserved preview address is the only URL representation for a retained, unconfigured language. */
+function revisionPreviewDestination(document, route, configuration) {
+	if (route.path !== "/_cms/revision-preview" || document.path === "/_cms/revision-preview") return null;
+	const requested = document.requestedLocale;
+	if (requested && !configuration?.supported.some((definition) => definition.code === requested)) return null;
+	const path = requested ? switchLocalePath(document.path, requested, configuration) : document.path;
+	const destination = new URL(`${path}${route.fullPath.slice(route.path.length)}`, "https://cms.invalid");
+	destination.searchParams.delete("documentId");
+	destination.searchParams.delete("revisionId");
+	return revisionPreviewNavigationLocation(`${destination.pathname}${destination.search}${destination.hash}`, route);
+}
+/** Adapt the saved-revision transport once so site-owned queries and pages keep their normal shape. */
+function revisionDelivery(document) {
+	const { renderPlan, issues, expiresAt, primary, livePath } = document;
+	return {
+		identity: document.identity,
+		savedRevisionId: document.revision.id,
+		draft: primary,
+		path: document.logicalPath ?? document.previewPath,
+		canonicalPath: document.livePath ?? document.logicalPath ?? document.previewPath,
+		...document.locale ? { locale: document.locale } : void 0,
+		...document.requestedLocale ? { requestedLocale: document.requestedLocale } : void 0,
+		source: {
+			format: 1,
+			...document.content,
+			settings: document.settings
+		},
+		referencePaths: Object.fromEntries(Object.entries(document.referencePaths).map(([name, path]) => [name, path ?? ""])),
+		forms: document.forms,
+		renderPlan,
+		renderIssues: issues,
+		renderFailures: [],
+		revisionPreview: {
+			expiresAt,
+			primary,
+			livePath
+		}
+	};
+}
+//#endregion
+//#region src/runtime/delivery/internal/useDeliveryContext.ts
+const endpoints = {
+	document: {
+		public: "/_cms/delivery",
+		preview: "/_cms/api/preview/delivery",
+		revision: "/_cms/revision-preview/delivery",
+		savedRevision: "/_cms/api/revision-preview/delivery"
+	},
+	query: {
+		public: "/_cms/query",
+		preview: "/_cms/api/preview/query",
+		revision: "/_cms/revision-preview/query",
+		savedRevision: "/_cms/api/revision-preview/query"
+	},
+	seo: {
+		public: "/_cms/seo/published",
+		preview: "/_cms/api/seo/working",
+		revision: "/_cms/seo/published",
+		savedRevision: "/_cms/seo/published"
+	}
+};
+/** Resolve credentials, cache identity and response interpretation together for each read. */
+function useDeliveryContext(route, revisionScope) {
+	const selection = computed(() => {
+		const current = toValue(route);
+		const documentId = previewDocumentId(current.query[previewDocumentQueryKey]);
+		const revision = revisionPreviewRequested(current);
+		const savedRevision = savedRevisionPreviewRequested(current);
+		const saved = savedRevisionPreviewSelection(current);
+		const scope = revision ? revisionScope?.() : void 0;
+		const locale = revisionPreviewLocale(current);
+		if (revision && !scope) throw new Error("Revision delivery context is unavailable.");
+		return {
+			mode: savedRevision ? "savedRevision" : revision ? "revision" : documentId ? "preview" : "public",
+			revision,
+			preview: revision || documentId !== null,
+			token: revisionPreviewToken(current),
+			locale,
+			parameters: savedRevision ? {
+				documentId: saved?.documentId ?? "",
+				revisionId: saved?.revisionId ?? ""
+			} : {},
+			identity: revision ? [
+				"revision",
+				scope,
+				locale ?? ""
+			] : documentId ? [documentId, current.query.v ?? ""] : null
+		};
+	});
+	function request(resource, input) {
+		const selected = selection.value;
+		const headers = {};
+		if (resource !== "seo" && selected.token) headers.authorization = `Bearer ${selected.token}`;
+		return {
+			endpoint: endpoints[resource][selected.mode],
+			key: JSON.stringify([
+				`cms-${resource}`,
+				selected.identity,
+				input
+			]),
+			revision: selected.revision,
+			locale: selected.locale,
+			parameters: selected.parameters,
+			headers
+		};
+	}
+	function document(path) {
+		return computed(() => {
+			const value = toValue(path);
+			const selected = request("document", value);
+			const locale = value === "/_cms/revision-preview" ? selected.locale : void 0;
+			const options = {
+				query: {
+					...selected.parameters,
+					path: value,
+					...locale === void 0 ? void 0 : { locale }
+				},
+				headers: selected.headers
+			};
+			return {
+				key: selected.key,
+				async read(fetch, signal) {
+					if (selected.revision) return revisionDelivery(Schema.decodeUnknownSync(RevisionPreviewDocument)(await fetch(selected.endpoint, {
+						...options,
+						signal
+					})));
+					const delivered = await fetch(selected.endpoint, {
+						...options,
+						signal
+					});
+					return "redirectTo" in delivered || !delivered.renderPlan ? delivered : {
+						...delivered,
+						renderFailures: []
+					};
+				}
+			};
+		});
+	}
+	function query(input, locales) {
+		return computed(() => {
+			const inputValue = toValue(input);
+			const value = {
+				...inputValue,
+				...inputValue.where ? { where: Object.fromEntries(Object.entries(inputValue.where).map(([name, entry]) => [name, Array.isArray(entry) ? [...entry] : entry])) } : void 0,
+				...inputValue.sort ? { sort: inputValue.sort.map((sort) => ({ ...sort })) } : void 0
+			};
+			const requestedLocale = value.locale ?? selection.value.locale ?? localeFromPath(toValue(route).path, locales);
+			const body = requestedLocale === void 0 ? value : {
+				...value,
+				locale: requestedLocale
+			};
+			const selected = request("query", body);
+			const options = {
+				method: "POST",
+				query: selected.parameters,
+				body,
+				headers: selected.headers
+			};
+			return {
+				key: selected.key,
+				async read(fetch, signal) {
+					if (selected.revision) {
+						const page = Schema.decodeUnknownSync(RevisionPreviewQueryPage)(await fetch(selected.endpoint, {
+							...options,
+							signal
+						}));
+						return {
+							items: page.items.map(revisionDelivery),
+							total: page.total
+						};
+					}
+					const page = await fetch(selected.endpoint, {
+						...options,
+						signal
+					});
+					return {
+						...page,
+						items: page.items.map((item) => item.renderPlan ? {
+							...item,
+							renderFailures: []
+						} : item)
+					};
+				}
+			};
+		});
+	}
+	function seo() {
+		return computed(() => {
+			const selected = request("seo");
+			return {
+				key: selected.key,
+				read: (fetch, signal) => fetch(selected.endpoint, { signal })
+			};
+		});
+	}
+	return {
+		preview: computed(() => selection.value.preview),
+		document,
+		query,
+		seo
+	};
+}
+//#endregion
+//#region src/runtime/delivery/internal/createDeliveryComposables.ts
+/** Bind delivery reads to the installation's Nuxt request and rendering context. */
+function createDeliveryComposables(runtime) {
+	function read(plan, fallback, owner) {
+		const fetch = runtime.fetch();
+		const request = runtime.data(() => JSON.stringify([owner, plan.value.key]), async (signal) => {
+			const selected = plan.value;
+			return {
+				key: selected.key,
+				value: await selected.read(fetch, signal)
+			};
+		});
+		const exposed = {
+			data: computed({
+				get: () => request.data.value?.key === plan.value.key ? request.data.value.value : fallback(),
+				set: (value) => {
+					request.data.value = {
+						key: plan.value.key,
+						value
+					};
+				}
+			}),
+			pending: request.pending,
+			error: request.error,
+			status: request.status,
+			refresh: request.refresh,
+			execute: request.execute,
+			clear: request.clear
+		};
+		return Object.assign(request.then(() => exposed), exposed);
+	}
+	/** Read a site path from the active delivery context and refresh when it changes. */
+	function useCmsDocument(path) {
+		const preview = inject(previewContextKey, null);
+		const request = read(useDeliveryContext(runtime.route(), runtime.revisionScope).document(path), () => void 0, runtime.identity());
+		if (preview) watch(request.data, (value) => {
+			if (value && !("redirectTo" in value) && preview.documentId.value) preview.sources?.document(value);
+		}, {
+			immediate: true,
+			flush: "sync"
+		});
+		return request;
+	}
+	/** Query the active delivery context; reactive input changes refetch the page. */
+	function useCmsDocumentQuery(input) {
+		const preview = inject(previewContextKey, null);
+		const request = read(useDeliveryContext(runtime.route(), runtime.revisionScope).query(input, runtime.locales?.()), () => ({
+			items: [],
+			total: 0
+		}), runtime.identity());
+		if (preview) watch(request.data, (value) => {
+			if (preview.documentId.value) for (const item of value?.items ?? []) preview.sources?.document(item);
+		}, {
+			immediate: true,
+			flush: "sync"
+		});
+		return request;
+	}
+	/** Apply CMS page SEO to a site-owned Nuxt page after its Document has loaded. */
+	async function useCmsDocumentSeo(document) {
+		const app = runtime.app();
+		const locales = runtime.locales?.();
+		const context = useDeliveryContext(runtime.route(), runtime.revisionScope);
+		const settings = await read(context.seo(), () => void 0, "site-seo");
+		if (settings.error.value || !settings.data.value) throw runtime.error({
+			statusCode: settings.error.value?.statusCode ?? 503,
+			statusMessage: "Site SEO unavailable"
+		});
+		await app.runWithContext(() => runtime.head(() => deliverySeoHead(toValue(document), settings.data.value, context.preview.value, locales)));
+	}
+	return {
+		useCmsDocument,
+		useCmsDocumentQuery,
+		useCmsDocumentSeo
+	};
+}
+//#endregion
+//#region src/runtime/delivery/internal/nuxtDelivery.ts
+const { useCmsDocument, useCmsDocumentQuery, useCmsDocumentSeo } = createDeliveryComposables({
+	route: () => useRouter().currentRoute,
+	revisionScope: () => useState("cms-revision-scope").value,
+	locales: () => decodeLocaleConfiguration(useRuntimeConfig().public.cmsLocales),
+	identity: useId,
+	data: (key, read) => useAsyncData(key, (_app, { signal }) => read(signal)),
+	fetch: useRequestFetch,
+	head: (read) => {
+		useHead(read);
+	},
+	app: useNuxtApp,
+	error: createError
+});
+//#endregion
+export { revisionPreviewDestination as i, useCmsDocumentQuery as n, useCmsDocumentSeo as r, useCmsDocument as t };