@getquick/content 0.2.0 → 0.3.0

package/dist/{formatting-wOk2jz6J.js → site-language-cBP8SFrS.js}

@@ -64,12 +64,12 @@ const BLOCKS_WITH_RENDERED_CHILDREN = /* @__PURE__ */ new Set([
 	"core/navigation",
 	"core/navigation-submenu"
 ]);
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeBlock(value) {
-	if (!isRecord(value) || typeof value.name !== "string") return null;
-	const attributes = isRecord(value.attributes) ? value.attributes : void 0;
+	if (!isRecord$1(value) || typeof value.name !== "string") return null;
+	const attributes = isRecord$1(value.attributes) ? value.attributes : void 0;
 	const innerBlocks = Array.isArray(value.innerBlocks) ? value.innerBlocks.map(normalizeBlock).filter((block) => block !== null) : [];
 	return {
 		name: value.name,
@@ -173,52 +173,6 @@ function renderWordPressBlocks(blocks) {
 	return blocks.map((block) => renderBlock(block)).join("");
 }
 //#endregion
-//#region frontend/src/site-language.ts
-/**
-* The `<html lang>` for a WordPress locale: its language and region as a
-* BCP 47 tag (pt_PT_ao90 → pt-PT). WordPress's variants (ao90, formal) aren't
-* BCP 47 subtags, so they are left out; no locale means English.
-*/
-function htmlLang(locale) {
-	if (!locale) return "en";
-	return locale.split("_").slice(0, 2).join("-");
-}
-/**
-* configuration's languages: wordpress.locale, the default, served at /, then
-* each of wordpress.languages under its slug. A monolingual Site has one.
-*/
-function siteLanguages(wordpress) {
-	const locale = wordpress?.locale ?? "";
-	const language = (locale, slug, isDefault) => ({
-		locale,
-		slug,
-		code: slug.toUpperCase().replaceAll("-", "_"),
-		lang: htmlLang(locale),
-		isDefault,
-		home: isDefault ? "/" : `/${slug}/`
-	});
-	return [language(locale, locale.split("_")[0] || "en", true), ...(wordpress?.languages ?? []).map(({ locale, slug }) => language(locale, slug, false))];
-}
-/**
-* A route's language: the one whose slug is its first segment, else the
-* default language, which has no directory.
-*/
-function routeLanguage(route, among) {
-	const segment = route.split("/")[1];
-	return among.find((language) => !language.isDefault && language.slug === segment) ?? among[0];
-}
-/**
-* How logs and reports name something a language has: "the front page" for
-* the default language's, "the en front page" for another's.
-*/
-function languageSubject(language, what) {
-	return language.isDefault ? `the ${what}` : `the ${language.slug} ${what}`;
-}
-/** Whether a route is a language's home (/, /en/): served as a home, never as an entry. */
-function isLanguageHome(route, among) {
-	return among.some((language) => language.home === route);
-}
-//#endregion
 //#region frontend/src/formatting.ts
 function responseStatus(delivery) {
 	if (delivery.kind === "found") return 200;
@@ -257,6 +211,33 @@ function menuItemHref(url, internalOrigins) {
 function stripHtml(value) {
 	return value.replace(/<[^>]*>/g, "").replace(/\s+/g, " ").trim();
 }
+/** The named character references WordPress's text commonly has (wptexturize writes most as numbers). */
+const NAMED_ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	nbsp: "\xA0",
+	ndash: "–",
+	mdash: "—",
+	lsquo: "‘",
+	rsquo: "’",
+	ldquo: "“",
+	rdquo: "”",
+	hellip: "…"
+};
+/**
+* Text with its HTML character references decoded: numeric ones, and the
+* named ones in NAMED_ENTITIES (any other is left as written).
+*/
+function decodeEntities(value) {
+	return value.replace(/&(#x[0-9a-f]+|#[0-9]+|[a-z]+);/gi, (reference, name) => {
+		if (name[0] !== "#") return NAMED_ENTITIES[name.toLowerCase()] ?? reference;
+		const code = name[1] === "x" || name[1] === "X" ? parseInt(name.slice(2), 16) : Number(name.slice(1));
+		return code > 0 && code <= 1114111 ? String.fromCodePoint(code) : reference;
+	});
+}
 function formatDate(value, lang = "en") {
 	return new Intl.DateTimeFormat(lang, {
 		day: "numeric",
@@ -273,4 +254,275 @@ function routeOf(path) {
 	return route.endsWith("/") ? route : `${route}/`;
 }
 //#endregion
-export { youtubeVideoId as _, routeOf as a, htmlLang as c, routeLanguage as d, siteLanguages as f, renderWordPressBlocks as g, parseWordPressBlocks as h, responseStatus as i, isLanguageHome as l, hasVideoHero as m, formatDate as n, stripHtml as o, VIDEO_HERO_BLOCK as p, menuItemHref as r, uriPath as s, cmsTime as t, languageSubject as u, containerChildLayoutHtml as v, containerLayoutHtml as y };
+//#region frontend/src/design-patterns.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* A complete pattern tree from JSON text or a parsed list. Malformed nodes
+* fail the whole read: dropping one could promote a partial header or footer.
+* PHP's empty attributes (`[]`) normalize to an object.
+*/
+function parseDesignBlocks(value) {
+	let parsed = value;
+	if (typeof parsed === "string") try {
+		parsed = JSON.parse(parsed);
+	} catch {
+		return;
+	}
+	let count = 0;
+	const blocks = (value, depth) => {
+		if (!Array.isArray(value) || value.length > 0 && depth > 32) return void 0;
+		const result = [];
+		for (const item of value) {
+			if (++count > 1e3 || !isRecord(item) || typeof item.name !== "string" || !item.name) return void 0;
+			const attributes = isRecord(item.attributes) ? item.attributes : Array.isArray(item.attributes) && item.attributes.length === 0 ? {} : void 0;
+			if (!attributes || item.content !== null && typeof item.content !== "string") return void 0;
+			const children = blocks(item.children, depth + 1);
+			if (!children) return void 0;
+			result.push({
+				name: item.name,
+				attributes,
+				content: item.content,
+				children
+			});
+		}
+		return result;
+	};
+	return blocks(parsed, 0);
+}
+function escapeHtml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+/** Inserts children before the HTML's last closing tag, where WordPress's wrappers keep them. */
+function insertChildren(html, children) {
+	if (!children) return html;
+	const closingTag = html.lastIndexOf("</");
+	if (closingTag < 0) return `${html}${children}`;
+	return `${html.slice(0, closingTag)}${children}${html.slice(closingTag)}`;
+}
+function linkHref(url, internalOrigins) {
+	if (typeof url !== "string" || !url.trim()) return "#";
+	const href = internalOrigins.length > 0 ? menuItemHref(url.trim(), internalOrigins) : url.trim();
+	if (/^\/(?!\/)/.test(href) || href.startsWith("#") || href.startsWith("?")) return href;
+	try {
+		const protocol = new URL(href).protocol;
+		return protocol === "https:" || protocol === "http:" || protocol === "mailto:" || protocol === "tel:" ? href : "#";
+	} catch {
+		return "#";
+	}
+}
+/** A media URL as an image source: http(s) only, never another scheme. */
+function mediaUrl(value) {
+	if (typeof value !== "string") return null;
+	try {
+		const protocol = new URL(value).protocol;
+		return protocol === "https:" || protocol === "http:" ? value : null;
+	} catch {
+		return null;
+	}
+}
+function designLogo(value) {
+	const url = isRecord(value) ? mediaUrl(value.url) : null;
+	if (!isRecord(value) || !url) return null;
+	const size = (item) => typeof item === "number" && item > 0 ? item : null;
+	return {
+		url,
+		alt: typeof value.alt === "string" ? value.alt : "",
+		width: size(value.width),
+		height: size(value.height)
+	};
+}
+/**
+* GQ Design's Site Logo node carries the Branding logo itself (`logo`, null
+* when unset) and its authored `width`, `isLink` and `linkTarget`, so it
+* renders without another read. Without a logo, nothing: the Site's own
+* renderer can show its title instead.
+*/
+const renderSiteLogo = (block, context) => {
+	const logo = designLogo(block.attributes.logo);
+	if (!logo) return "";
+	const width = typeof block.attributes.width === "number" ? block.attributes.width : logo.width;
+	const size = [width ? ` width="${width}"` : "", width && logo.width && logo.height ? ` height="${Math.round(width * logo.height / logo.width)}"` : !width && logo.height ? ` height="${logo.height}"` : ""].join("");
+	const image = `<img class="custom-logo" src="${escapeHtml(logo.url)}" alt="${escapeHtml(logo.alt)}"${size} decoding="async" />`;
+	const className = typeof block.attributes.className === "string" ? ` ${block.attributes.className}` : "";
+	const linked = block.attributes.isLink === false ? image : `<a href="${escapeHtml(context.href(context.home))}" class="custom-logo-link" ${block.attributes.linkTarget === "_blank" ? "target=\"_blank\" rel=\"home noopener\"" : "rel=\"home\""}>${image}</a>`;
+	return `<div class="wp-block-site-logo${escapeHtml(className)}">${linked}</div>`;
+};
+const BUILT_IN = { "core/site-logo": renderSiteLogo };
+/** The elements a container's `tagName` may choose, as WordPress's Group block offers them. */
+const CONTAINER_TAGS = /* @__PURE__ */ new Set([
+	"div",
+	"header",
+	"footer",
+	"main",
+	"section",
+	"article",
+	"aside",
+	"nav"
+]);
+const SLUG = /^[a-z0-9-]+$/;
+/** GQ Design's layout container, whose width, gap and padding content also restores. */
+const DESIGN_CONTAINER = "getquick-design/container";
+/**
+* A container block (one with children) as WordPress wraps it. GQ Design
+* sends saved HTML only for blocks without children, so a container's wrapper
+* is rebuilt from its name and attributes: its element (`tagName`), its default
+* class (`wp-block-group` for `core/group`, `wp-block-acme-hero` for
+* `acme/hero`), and the classes WordPress derives from `className`, `align`,
+* its preset colours and its layout type. Other styles (custom colours,
+* spacing) need a Site renderer. GQ Design's own container
+* (`getquick-design/container`) also gets its layout, as in content.
+*/
+function containerHtml(block, children) {
+	const { tagName, className, align, backgroundColor, textColor, layout } = block.attributes;
+	const tag = typeof tagName === "string" && CONTAINER_TAGS.has(tagName) ? tagName : "div";
+	const classes = [`wp-block-${block.name.replace(/^core\//, "").replaceAll("/", "-")}`];
+	if (typeof className === "string" && className.trim()) classes.push(className.trim());
+	if (typeof align === "string" && SLUG.test(align)) classes.push(`align${align}`);
+	if (typeof backgroundColor === "string" && SLUG.test(backgroundColor)) classes.push(`has-${backgroundColor}-background-color`, "has-background");
+	if (typeof textColor === "string" && SLUG.test(textColor)) classes.push(`has-${textColor}-color`, "has-text-color");
+	const layoutType = isRecord(layout) ? layout.type : void 0;
+	if (typeof layoutType === "string" && SLUG.test(layoutType)) classes.push(`is-layout-${layoutType}`);
+	return `<${tag} class="${escapeHtml(classes.join(" "))}">${children}</${tag}>`;
+}
+/**
+* A pattern (or blocks of one) as HTML. Each block is rendered by the Site's
+* renderer for its name, else a built-in one, else as the HTML WordPress saved
+* for it, else, with children, as a WordPress container wrapping them. A block
+* with none of those (a dynamic block, such as a Site's own) renders nothing
+* and is reported to `onUnrendered`. Null renders nothing, so the Site keeps
+* its own header or footer.
+*/
+function renderDesignPattern(pattern, options = {}) {
+	if (!pattern) return "";
+	const renderers = {
+		...BUILT_IN,
+		...options.blocks
+	};
+	const internalOrigins = options.internalOrigins ?? [];
+	const href = (url) => linkHref(url, internalOrigins);
+	const renderAll = (blocks, ancestors, parentContainer = "") => blocks.map((block) => renderOne(block, ancestors, parentContainer)).join("");
+	function renderOne(block, ancestors, parentContainer) {
+		const inside = [...ancestors, block];
+		const renderer = Object.hasOwn(renderers, block.name) ? renderers[block.name] : void 0;
+		if (renderer) {
+			let children;
+			return renderer(block, {
+				get children() {
+					return children ??= renderAll(block.children, inside);
+				},
+				ancestors,
+				render: (blocks) => renderAll(blocks, inside),
+				href,
+				home: options.home ?? "/"
+			});
+		}
+		if (block.name === DESIGN_CONTAINER && (block.children.length > 0 || block.content !== null)) {
+			let wrapper = containerLayoutHtml(block.content ?? containerHtml(block, ""), block.attributes);
+			if (parentContainer) wrapper = containerChildLayoutHtml(wrapper, parentContainer);
+			return insertChildren(wrapper, renderAll(block.children, inside, wrapper));
+		}
+		const children = renderAll(block.children, inside);
+		if (block.content !== null) return insertChildren(block.content, children);
+		if (block.children.length > 0) return containerHtml(block, children);
+		options.onUnrendered?.(block);
+		return "";
+	}
+	return renderAll(Array.isArray(pattern) ? pattern : pattern.blocks, []);
+}
+/**
+* A menu a Site block carries in its attributes (a flat list of `{ id,
+* parentId, label, url, target }`, as GQ Design's serializer filter documents
+* for `getquick/header-navigation`) as a tree, with each link as the
+* Frontend serves it. Items that aren't menu items are left out; one whose
+* parent isn't listed, or that is in a cycle of parents, is a top-level item.
+*/
+function designMenuItems(value, href = (url) => linkHref(url, [])) {
+	if (!Array.isArray(value)) return [];
+	const id = (item) => typeof item === "number" || typeof item === "string" ? String(item) : "";
+	const seen = /* @__PURE__ */ new Set();
+	const items = value.filter(isRecord).filter((item) => {
+		const key = id(item.id);
+		if (!key || seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+	const byId = /* @__PURE__ */ new Map();
+	const parentOf = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const parentId = id(item.parentId);
+		if (parentId && parentId !== "0") parentOf.set(id(item.id), parentId);
+		byId.set(id(item.id), {
+			id: id(item.id),
+			label: typeof item.label === "string" ? item.label : "",
+			href: href(item.url),
+			target: item.target === "_blank" ? "_blank" : null,
+			children: []
+		});
+	}
+	const inCycle = (start) => {
+		const visited = /* @__PURE__ */ new Set();
+		for (let at = parentOf.get(start); at !== void 0; at = parentOf.get(at)) {
+			if (at === start) return true;
+			if (visited.has(at)) return false;
+			visited.add(at);
+		}
+		return false;
+	};
+	const roots = [];
+	for (const [key, node] of byId) {
+		const parentId = parentOf.get(key);
+		const parent = parentId !== void 0 && !inCycle(key) ? byId.get(parentId) : void 0;
+		(parent ? parent.children : roots).push(node);
+	}
+	return roots;
+}
+//#endregion
+//#region frontend/src/site-language.ts
+/**
+* The `<html lang>` for a WordPress locale: its language and region as a
+* BCP 47 tag (pt_PT_ao90 → pt-PT). WordPress's variants (ao90, formal) aren't
+* BCP 47 subtags, so they are left out; no locale means English.
+*/
+function htmlLang(locale) {
+	if (!locale) return "en";
+	return locale.split("_").slice(0, 2).join("-");
+}
+/**
+* configuration's languages: wordpress.locale, the default, served at /, then
+* each of wordpress.languages under its slug. A monolingual Site has one.
+*/
+function siteLanguages(wordpress) {
+	const locale = wordpress?.locale ?? "";
+	const language = (locale, slug, isDefault) => ({
+		locale,
+		slug,
+		code: slug.toUpperCase().replaceAll("-", "_"),
+		lang: htmlLang(locale),
+		isDefault,
+		home: isDefault ? "/" : `/${slug}/`
+	});
+	return [language(locale, locale.split("_")[0] || "en", true), ...(wordpress?.languages ?? []).map(({ locale, slug }) => language(locale, slug, false))];
+}
+/**
+* A route's language: the one whose slug is its first segment, else the
+* default language, which has no directory.
+*/
+function routeLanguage(route, among) {
+	const segment = route.split("/")[1];
+	return among.find((language) => !language.isDefault && language.slug === segment) ?? among[0];
+}
+/**
+* How logs and reports name something a language has: "the front page" for
+* the default language's, "the en front page" for another's.
+*/
+function languageSubject(language, what) {
+	return language.isDefault ? `the ${what}` : `the ${language.slug} ${what}`;
+}
+/** Whether a route is a language's home (/, /en/): served as a home, never as an entry. */
+function isLanguageHome(route, among) {
+	return among.some((language) => language.home === route);
+}
+//#endregion
+export { containerChildLayoutHtml as C, youtubeVideoId as S, uriPath as _, siteLanguages as a, parseWordPressBlocks as b, parseDesignBlocks as c, decodeEntities as d, formatDate as f, stripHtml as g, routeOf as h, routeLanguage as i, renderDesignPattern as l, responseStatus as m, isLanguageHome as n, designMenuItems as o, menuItemHref as p, languageSubject as r, escapeHtml as s, htmlLang as t, cmsTime as u, VIDEO_HERO_BLOCK as v, containerLayoutHtml as w, renderWordPressBlocks as x, hasVideoHero as y };

package/dist/{version-DyyNhsuU.js → version-D_Ao31D3.js}

@@ -1,6 +1,6 @@
 //#endregion
 //#region frontend/src/consent/version.ts
 /** The UI/adapter version recorded with each decision (CN-R7). */
-const CONSENT_UI_VERSION = `gq-content@0.2.0`;
+const CONSENT_UI_VERSION = `gq-content@0.3.0`;
 //#endregion
 export { CONSENT_UI_VERSION as t };