@getquick/content 0.1.0 → 0.3.0

package/dist/metadata.js

@@ -0,0 +1,218 @@
+//#region frontend/src/metadata.ts
+/** Scoped OG-1 candidate contract; adoption and public asset verification are separate gates. */
+const metadataBaseline = "OG-1";
+/** Inputs are plain text. Source-specific HTML/entity decoding belongs in the mapper. */
+function normalizeMetadataText(value) {
+	return value.replace(/\s+/gu, " ").trim();
+}
+function resolveMetadata(input) {
+	const diagnostics = [];
+	const fail = (field, message) => diagnostics.push({
+		code: "invalid-metadata",
+		field,
+		message
+	});
+	const language = input.language ?? input.site.language;
+	const text = (value, field) => {
+		const result = normalizeMetadataText(value ?? "");
+		if (!result) fail(field, "Expected nonempty decoded plain text");
+		if (result.includes("\0") || /[\uD800-\uDFFF]/u.test(result)) fail(field, "Text contains NUL or unpaired UTF-16 surrogate and cannot survive HTML/UTF-8 serialization");
+		return result;
+	};
+	const locale = (value, field) => {
+		let htmlLocale;
+		try {
+			htmlLocale = new Intl.Locale(value.lang);
+		} catch {
+			fail(field, "Invalid BCP 47 HTML language");
+		}
+		if (!["ltr", "rtl"].includes(value.dir)) fail(field, "Invalid HTML direction");
+		const match = /^([a-z]{2,3})[_-]([a-z]{2})(?:_[a-z0-9]+)*$/iu.exec(value.locale);
+		if (!match) {
+			fail(field, "Explicit regional locale required; no territory is inferred");
+			return "";
+		}
+		if (htmlLocale && (htmlLocale.language.toLowerCase() !== match[1].toLowerCase() || htmlLocale.region && htmlLocale.region.toUpperCase() !== match[2].toUpperCase())) fail(field, "HTML and OG locales disagree");
+		return `${match[1].toLowerCase()}_${match[2].toUpperCase()}`;
+	};
+	const ogLocale = locale(language, "language");
+	const head = [];
+	const meta = (name, content, property = true) => head.push({
+		tag: "meta",
+		attrs: {
+			[property ? "property" : "name"]: name,
+			content
+		}
+	});
+	const applicable = input.state === "public" && input.status === 200;
+	meta("robots", applicable && !input.noindex ? "index, follow" : "noindex, nofollow", false);
+	const result = {
+		baseline: metadataBaseline,
+		ready: false,
+		documentReady: false,
+		graphReady: false,
+		applicable,
+		htmlAttributes: {
+			lang: language.lang,
+			dir: language.dir
+		},
+		head,
+		diagnostics
+	};
+	if (!applicable) {
+		if (input.statusTitle !== void 0) {
+			const title = text(input.statusTitle, "statusTitle");
+			if (!diagnostics.some((d) => d.field === "statusTitle")) head.push({
+				tag: "title",
+				text: title
+			});
+		}
+		result.ready = diagnostics.length === 0;
+		result.documentReady = result.ready && head.some((node) => node.tag === "title");
+		return result;
+	}
+	let origin = "";
+	try {
+		const parsed = new URL(input.site.origin);
+		if (parsed.href !== `${parsed.origin}/` || parsed.protocol !== "https:" || parsed.username || parsed.password || /^(localhost|.*\.localhost|.*\.local|.*\.invalid|127\..*|0\.0\.0\.0|\[::1\])$/iu.test(parsed.hostname)) throw new Error();
+		origin = parsed.origin;
+	} catch {
+		fail("site.origin", "Expected reviewed public HTTPS origin");
+	}
+	const url = (value, field, identity) => {
+		try {
+			const parsed = new URL(value ?? "");
+			if (parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.hash || /^(localhost|.*\.localhost|.*\.local|.*\.invalid|127\..*|0\.0\.0\.0|\[::1\])$/iu.test(parsed.hostname)) throw new Error();
+			if (identity && parsed.origin !== origin) throw new Error();
+			for (const key of parsed.searchParams.keys()) if (/^(utm_|fbclid$|gclid$|token$|sig$|signature$|expires$|x-amz-|x-goog-|awsaccesskeyid$|preview)/iu.test(key) || identity && !input.site.identityQueryKeys?.includes(key)) throw new Error();
+			return parsed.href;
+		} catch {
+			fail(field, "Invalid public HTTPS URL or unreviewed canonical identity/query");
+			return "";
+		}
+	};
+	const selected = (key) => input.overrides?.[key] ?? input.page?.[key] ?? input.site[key];
+	const title = text(selected("title"), "title");
+	const shareTitle = text(input.overrides?.shareTitle ?? title, "shareTitle");
+	const description = text(selected("description"), "description");
+	const name = text(input.site.name, "site.name");
+	const canonical = url(input.canonical, "canonical", true);
+	head.push({
+		tag: "title",
+		text: title
+	}, {
+		tag: "link",
+		attrs: {
+			rel: "canonical",
+			href: canonical
+		}
+	});
+	meta("description", description, false);
+	for (const [key, value] of Object.entries({
+		title: shareTitle,
+		type: input.kind === "article" ? "article" : "website",
+		url: canonical,
+		description,
+		site_name: name,
+		locale: ogLocale
+	})) meta(`og:${key}`, value);
+	const images = selected("images");
+	if (!images?.length) fail("images", "At least one reviewed share image required");
+	images?.forEach((image, index) => {
+		const field = `images.${index}`;
+		const src = url(image.url, `${field}.url`, false);
+		const alt = text(image.alt, `${field}.alt`);
+		if (![image.width, image.height].every((n) => Number.isSafeInteger(n) && n > 0)) fail(field, "Known positive integer dimensions required");
+		if (image.type && !["image/jpeg", "image/png"].includes(image.type)) fail(field, "OG-1 supports verified JPEG/PNG MIME only");
+		meta("og:image", src);
+		meta("og:image:alt", alt);
+		meta("og:image:width", String(image.width));
+		meta("og:image:height", String(image.height));
+		if (image.type) meta("og:image:type", image.type);
+	});
+	const hasPublishedTranslations = input.translations?.some((t) => t.published) ?? false;
+	const languageKey = (value) => {
+		try {
+			return new Intl.Locale(value.lang).baseName;
+		} catch {
+			return;
+		}
+	};
+	if (hasPublishedTranslations && input.language) locale(input.site.language, "site.language");
+	const defaultLanguage = languageKey(input.site.language);
+	let defaultCanonical = defaultLanguage && languageKey(language) === defaultLanguage ? canonical : void 0;
+	const locales = /* @__PURE__ */ new Set([ogLocale]);
+	const langs = /* @__PURE__ */ new Set([language.lang.toLowerCase()]);
+	if (hasPublishedTranslations) head.push({
+		tag: "link",
+		attrs: {
+			rel: "alternate",
+			hreflang: language.lang,
+			href: canonical
+		}
+	});
+	input.translations?.filter((t) => t.published).forEach((translation, index) => {
+		const field = `translations.${index}`;
+		const translatedLocale = locale(translation, field);
+		const href = url(translation.canonical, field, true);
+		if (langs.has(translation.lang.toLowerCase())) {
+			fail(field, "Duplicate/current translation language");
+			return;
+		}
+		langs.add(translation.lang.toLowerCase());
+		if (defaultLanguage && languageKey(translation) === defaultLanguage) defaultCanonical = href;
+		head.push({
+			tag: "link",
+			attrs: {
+				rel: "alternate",
+				hreflang: translation.lang,
+				href
+			}
+		});
+		if (!locales.has(translatedLocale)) {
+			meta("og:locale:alternate", translatedLocale);
+			locales.add(translatedLocale);
+		}
+	});
+	if (hasPublishedTranslations && defaultCanonical) head.push({
+		tag: "link",
+		attrs: {
+			rel: "alternate",
+			hreflang: "x-default",
+			href: defaultCanonical
+		}
+	});
+	if (input.kind === "article" && input.article) {
+		for (const [key, value] of [["published_time", input.article.publishedTime], ["modified_time", input.article.modifiedTime]]) {
+			if (value === void 0) continue;
+			if (!/^\d{4}-\d\d-\d\dT\d\d:\d\d(?::\d\d(?:\.\d+)?)?(?:Z|[+-]\d\d:\d\d)$/u.test(value) || !Number.isFinite(Date.parse(value)) || Number(value.slice(8, 10)) > new Date(Date.UTC(Number(value.slice(0, 4)), Number(value.slice(5, 7)), 0)).getUTCDate()) fail(`article.${key}`, "Timestamp must include a timezone");
+			else meta(`article:${key}`, value);
+		}
+		input.article.authors?.forEach((author) => meta("article:author", url(author, "article.authors", false)));
+	}
+	result.ready = diagnostics.length === 0;
+	result.graphReady = result.ready;
+	result.documentReady = !diagnostics.some((d) => [
+		"title",
+		"description",
+		"canonical",
+		"site.origin"
+	].includes(d.field) || d.field === "language" && /HTML|BCP/u.test(d.message));
+	if (!result.ready) {
+		const invalid = (field) => diagnostics.some((d) => d.field === field);
+		result.head = head.filter((node) => {
+			if (node.tag === "title") return !invalid("title");
+			if (node.tag === "meta") return node.attrs.name === "robots" || node.attrs.name === "description" && !invalid("description");
+			if (node.attrs.rel === "canonical") return !invalid("canonical");
+			return node.attrs.rel === "alternate" && !invalid("canonical") && !diagnostics.some((d) => d.field.startsWith("translations."));
+		});
+	} else result.htmlAttributes.prefix = "og: https://ogp.me/ns#";
+	return result;
+}
+const escape = (value) => value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+/** Safe HTML fragment for Astro set:html or other server serialization; preserves repeated image groups. */
+function renderMetadataHead(metadata) {
+	return metadata.head.map((node) => node.tag === "title" ? `<title>${escape(node.text)}</title>` : `<${node.tag} ${Object.entries(node.attrs).map(([key, value]) => `${key}="${escape(value)}"`).join(" ")}>`).join("\n");
+}
+//#endregion
+export { metadataBaseline, normalizeMetadataText, renderMetadataHead, resolveMetadata };

package/dist/server.d.ts

@@ -1,2 +1,2 @@
-import { a as createContentRuntime, g as ContentBindings, i as ContentRuntime, n as ContentConfig, r as ContentConsentConfig, t as WordPressClient } from "./wordpress-CPL40-vq.js";
-export { type ContentBindings, ContentConfig, ContentConsentConfig, ContentRuntime, type WordPressClient, createContentRuntime };
+import { T as ContentBindings, a as ContentExtension, c as createContentRuntime, i as ContentConsentConfig, n as CollectionConfig, o as ContentRuntime, r as ContentConfig, s as ExtensionNode, t as WordPressClient } from "./wordpress-D_HG2rEt.js";
+export { CollectionConfig, type ContentBindings, ContentConfig, ContentConsentConfig, ContentExtension, ContentRuntime, ExtensionNode, type WordPressClient, createContentRuntime };