@getquick/content 0.0.0-stage → 0.1.0

package/dist/consent-client.js

@@ -0,0 +1,321 @@
+import { E as embedService, S as SERVICE_CATALOG, a as consentCookie, c as grantedCategories, d as promptReason, f as readConsentCookie, k as isServiceId, m as serviceGranted, o as decide, x as OPTIONAL_CATEGORIES } from "./state-BYWc5TUB.js";
+import { i as isRecordToken, n as consentRecordRequest, r as isLegalRoleName } from "./records-Dumrz759.js";
+import { t as CONSENT_CONFIG_ID } from "./client-config-B3LNSOxl.js";
+//#region frontend/src/consent/client.ts
+const RETRY_DELAYS_MS = [
+	1e3,
+	3e3,
+	1e4,
+	3e4,
+	6e4
+];
+function readConfig() {
+	const element = document.getElementById(CONSENT_CONFIG_ID);
+	if (!element?.textContent) return null;
+	try {
+		const config = JSON.parse(element.textContent);
+		config.legalRevisions = Object.fromEntries(Object.entries(config.legalRevisions ?? {}).filter(([role, revision]) => isLegalRoleName(role) && isRecordToken(revision)));
+		return config;
+	} catch {
+		return null;
+	}
+}
+/** Removes the first-party storage a withdrawn category's services wrote (CN-R6). */
+function removeStorage(categories) {
+	const services = Object.values(SERVICE_CATALOG);
+	const host = location.hostname;
+	const domains = [
+		"",
+		host,
+		`.${host}`
+	];
+	const parts = host.split(".");
+	for (let i = 1; i < parts.length - 1; i++) domains.push(`.${parts.slice(i).join(".")}`);
+	for (const service of services) {
+		if (!categories.includes(service.category)) continue;
+		for (const storage of service.storage) {
+			if (storage.party !== "first") continue;
+			const matches = (name) => storage.match === "prefix" ? name.startsWith(storage.name) : name === storage.name;
+			if (storage.kind === "cookie") for (const cookie of document.cookie.split(";")) {
+				const name = cookie.split("=")[0].trim();
+				if (!name || !matches(name)) continue;
+				for (const domain of domains) document.cookie = `${name}=; Path=/; Max-Age=0${domain ? `; Domain=${domain}` : ""}`;
+			}
+			else {
+				const area = storage.kind === "localStorage" ? localStorage : sessionStorage;
+				for (const key of Object.keys(area)) if (matches(key)) area.removeItem(key);
+			}
+		}
+	}
+}
+/**
+* GA4 under Consent Mode v2 basic mode (CN-R12): nothing loads before the
+* analytics grant; the denied defaults are queued before the tag; every later
+* decision sends an update. Withdrawal sends denied and disables the tag.
+*/
+function ga4(measurementId) {
+	let loaded = false;
+	function gtag(..._args) {
+		window.dataLayer = window.dataLayer ?? [];
+		window.dataLayer.push(arguments);
+	}
+	const signals = (analytics) => ({
+		analytics_storage: analytics ? "granted" : "denied",
+		ad_storage: "denied",
+		ad_user_data: "denied",
+		ad_personalization: "denied"
+	});
+	return function apply(granted) {
+		if (!loaded && !granted) return;
+		window[`ga-disable-${measurementId}`] = !granted;
+		if (loaded) {
+			gtag("consent", "update", signals(granted));
+			return;
+		}
+		loaded = true;
+		window.gtag = gtag;
+		gtag("consent", "default", signals(false));
+		gtag("consent", "update", signals(true));
+		gtag("js", /* @__PURE__ */ new Date());
+		gtag("config", measurementId);
+		const script = document.createElement("script");
+		script.async = true;
+		script.src = `https://www.googletagmanager.com/gtag/js?id=${encodeURIComponent(measurementId)}`;
+		document.head.append(script);
+	};
+}
+const EMBED_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"allow",
+	"allowfullscreen",
+	"aria-hidden",
+	"class",
+	"frameborder",
+	"height",
+	"loading",
+	"referrerpolicy",
+	"tabindex",
+	"title",
+	"width"
+]);
+/**
+* Replaces a placeholder's content with its embed, keeping the placeholder to
+* restore. Only an HTTPS URL of the catalog service the placeholder names
+* loads, so markup can't smuggle another host or a script URL through it.
+*/
+function loadEmbed(placeholder, id) {
+	const data = placeholder.getAttribute("data-gq-embed");
+	if (!data || placeholder.hasAttribute("data-gq-loaded")) return;
+	let embed;
+	try {
+		embed = JSON.parse(data);
+	} catch {
+		return;
+	}
+	if (embed.tag !== "iframe" || !embed.attrs || typeof embed.attrs.src !== "string") return;
+	let src;
+	try {
+		src = new URL(embed.attrs.src);
+	} catch {
+		return;
+	}
+	if (src.protocol !== "https:" || embedService(src) !== id) return;
+	const iframe = document.createElement("iframe");
+	for (const [name, value] of Object.entries(embed.attrs)) if (EMBED_ATTRIBUTES.has(name.toLowerCase()) && typeof value === "string") iframe.setAttribute(name, value);
+	iframe.src = src.href;
+	const original = placeholder.cloneNode(true);
+	placeholder.replaceChildren(iframe);
+	placeholder.setAttribute("data-gq-loaded", "");
+	placeholder.removeAttribute("role");
+	placeholder.removeAttribute("aria-label");
+	originals.set(placeholder, original);
+}
+const originals = /* @__PURE__ */ new WeakMap();
+function unloadEmbed(placeholder) {
+	const original = originals.get(placeholder);
+	if (!original) return;
+	placeholder.replaceWith(original);
+}
+/**
+* Starts the runtime once per document. Safe to call again: the existing
+* controller refreshes the page instead.
+*/
+function startConsent() {
+	if (window.__gqConsent) {
+		window.__gqConsent.refresh();
+		return window.__gqConsent;
+	}
+	const initial = readConfig();
+	if (!initial) return null;
+	let config = initial;
+	let state = readConsentCookie(document.cookie);
+	const analytics = config.configuration.measurementId ? ga4(config.configuration.measurementId) : null;
+	let retry;
+	let opener = null;
+	const secure = location.protocol === "https:";
+	const writeCookie = (next) => {
+		document.cookie = consentCookie(next, { secure });
+	};
+	const granted = (id) => serviceGranted(config.configuration, state, id);
+	function applyEmbeds() {
+		for (const placeholder of document.querySelectorAll("[data-gq-consent-embed]")) {
+			const id = placeholder.getAttribute("data-gq-consent-embed");
+			if (!isServiceId(id)) continue;
+			if (granted(id)) loadEmbed(placeholder, id);
+			else if (placeholder.hasAttribute("data-gq-loaded") && !placeholder.hasAttribute("data-gq-once")) unloadEmbed(placeholder);
+		}
+	}
+	function applyUi() {
+		const reason = promptReason(config.configuration, state);
+		const banner = document.getElementById("gq-consent-banner");
+		if (banner) banner.hidden = reason === null;
+		for (const element of document.querySelectorAll("[data-gq-consent-id]")) element.textContent = state?.consentId ?? element.getAttribute("data-gq-consent-none") ?? "";
+		const inForce = grantedCategories(config.configuration, state);
+		for (const input of document.querySelectorAll("input[data-gq-consent-category]")) input.checked = inForce.includes(input.value);
+	}
+	function apply() {
+		applyUi();
+		applyEmbeds();
+		analytics?.(granted("ga4"));
+	}
+	/** One decision, however often its cookie is read again. */
+	const sameDecision = (a, b) => Boolean(a && b && a.consentId === b.consentId && a.decidedAt === b.decidedAt);
+	async function send(attempt = 0) {
+		if (!state || state.recorded) return;
+		const decided = state;
+		const body = JSON.stringify(consentRecordRequest(decided, decided.action, {
+			language: config.language,
+			uiVersion: config.uiVersion,
+			legalRevisions: config.legalRevisions
+		}));
+		let retryable = true;
+		try {
+			const response = await fetch(config.endpoint, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body,
+				credentials: "same-origin"
+			});
+			if (response.ok) {
+				if (sameDecision(state, decided)) {
+					state = {
+						...state,
+						recorded: true
+					};
+					writeCookie(state);
+				}
+				return;
+			}
+			retryable = response.status >= 500 || response.status === 429 || response.status === 408;
+		} catch {}
+		if (!retryable || !sameDecision(state, decided) || attempt >= RETRY_DELAYS_MS.length) return;
+		retry = setTimeout(() => {
+			retry = void 0;
+			send(attempt + 1);
+		}, RETRY_DELAYS_MS[attempt]);
+	}
+	function choose(choice) {
+		const before = grantedCategories(config.configuration, state);
+		state = decide(config.configuration, state, choice).state;
+		writeCookie(state);
+		const after = grantedCategories(config.configuration, state);
+		removeStorage(before.filter((category) => !after.includes(category)));
+		apply();
+		clearTimeout(retry);
+		retry = void 0;
+		send();
+	}
+	function preferences() {
+		return document.getElementById("gq-consent-preferences");
+	}
+	function openPreferences(from) {
+		const dialog = preferences();
+		if (!dialog) return;
+		opener = from ?? document.activeElement;
+		applyUi();
+		if (!dialog.open) dialog.showModal();
+	}
+	function closePreferences() {
+		const dialog = preferences();
+		if (dialog?.open) dialog.close();
+	}
+	function leaveBanner() {
+		if (document.getElementById("gq-consent-banner")?.contains(document.activeElement)) {
+			const main = document.querySelector("main") ?? document.body;
+			if (!main.hasAttribute("tabindex")) main.setAttribute("tabindex", "-1");
+			main.focus({ preventScroll: true });
+		}
+	}
+	document.addEventListener("click", (event) => {
+		const target = event.target?.closest("[data-gq-consent-accept-all],[data-gq-consent-reject-all],[data-gq-consent-customise],[data-gq-consent-open],[data-gq-consent-save],[data-gq-consent-close],[data-gq-consent-load-once],[data-gq-consent-allow]");
+		if (!target) return;
+		const ui = target.closest("#gq-consent-banner, #gq-consent-preferences");
+		const placeholder = target.closest("[data-gq-consent-embed]");
+		if ((target.hasAttribute("data-gq-consent-accept-all") || target.hasAttribute("data-gq-consent-reject-all") || target.hasAttribute("data-gq-consent-save") || target.hasAttribute("data-gq-consent-close")) && !ui) return;
+		if ((target.hasAttribute("data-gq-consent-load-once") || target.hasAttribute("data-gq-consent-allow")) && !placeholder) return;
+		event.preventDefault();
+		if (target.hasAttribute("data-gq-consent-accept-all")) {
+			leaveBanner();
+			choose({ kind: "accept_all" });
+			closePreferences();
+		} else if (target.hasAttribute("data-gq-consent-reject-all")) {
+			leaveBanner();
+			choose({ kind: "reject_all" });
+			closePreferences();
+		} else if (target.hasAttribute("data-gq-consent-customise") || target.hasAttribute("data-gq-consent-open")) openPreferences(target);
+		else if (target.hasAttribute("data-gq-consent-save")) {
+			const decisions = {};
+			for (const input of document.querySelectorAll("#gq-consent-preferences input[data-gq-consent-category]")) decisions[input.value] = input.checked;
+			leaveBanner();
+			choose({
+				kind: "custom",
+				decisions
+			});
+			closePreferences();
+		} else if (target.hasAttribute("data-gq-consent-close")) closePreferences();
+		else if (target.hasAttribute("data-gq-consent-load-once")) {
+			const id = placeholder.getAttribute("data-gq-consent-embed");
+			if (isServiceId(id)) {
+				placeholder.setAttribute("data-gq-once", "");
+				loadEmbed(placeholder, id);
+			}
+		} else if (target.hasAttribute("data-gq-consent-allow")) {
+			const id = placeholder.getAttribute("data-gq-consent-embed");
+			if (!isServiceId(id)) return;
+			const category = SERVICE_CATALOG[id].category;
+			if (category === "necessary") return;
+			const decisions = Object.fromEntries(OPTIONAL_CATEGORIES.map((each) => [each, grantedCategories(config.configuration, state).includes(each)]));
+			decisions[category] = true;
+			choose({
+				kind: "custom",
+				decisions
+			});
+		}
+	});
+	document.addEventListener("close", (event) => {
+		if (event.target === preferences() && opener?.isConnected) opener.focus();
+	}, true);
+	const controller = {
+		get state() {
+			return state;
+		},
+		get config() {
+			return config;
+		},
+		choose,
+		openPreferences,
+		refresh() {
+			config = readConfig() ?? config;
+			const read = readConsentCookie(document.cookie);
+			if (!sameDecision(read, state)) state = read;
+			apply();
+			if (state && !state.recorded && retry === void 0) send();
+		}
+	};
+	window.__gqConsent = controller;
+	document.addEventListener("astro:page-load", () => controller.refresh());
+	apply();
+	send();
+	return controller;
+}
+//#endregion
+export { CONSENT_CONFIG_ID, startConsent };

package/dist/consent-migrations.d.ts

@@ -0,0 +1,8 @@
+//#region frontend/src/consent/migrations.d.ts
+/**
+ * The consent database's migrations, for infrastructure (Alchemy/Wrangler):
+ * a directory separate from the publication store's. Node-only; keep this
+ * entry out of browser and Worker imports.
+ */
+export declare const consentMigrationsDirectory: string;
+//#endregion

package/dist/consent-migrations.js

@@ -0,0 +1,10 @@
+import { fileURLToPath } from "node:url";
+//#region frontend/src/consent/migrations.ts
+/**
+* The consent database's migrations, for infrastructure (Alchemy/Wrangler):
+* a directory separate from the publication store's. Node-only; keep this
+* entry out of browser and Worker imports.
+*/
+const consentMigrationsDirectory = fileURLToPath(new URL("../consent-migrations/", import.meta.url));
+//#endregion
+export { consentMigrationsDirectory };

package/dist/consent-server.d.ts

@@ -0,0 +1,77 @@
+import { n as ConsentRecordRequest, t as ConsentRecord } from "./records-CACA2O0Q.js";
+//#region frontend/src/consent/paths.d.ts
+/** The same-origin consent endpoint on the Site's Frontend Worker (fixed interface). */
+export declare const CONSENT_PATH = "/gq/consent";
+//#endregion
+//#region frontend/src/consent/server.d.ts
+/** D1's surface the consent endpoints use (structural, as the publication store's). */
+export interface ConsentStatement {
+  bind(...values: unknown[]): ConsentStatement;
+  first<T = Record<string, unknown>>(): Promise<T | null>;
+  all<T = Record<string, unknown>>(): Promise<{
+    results: T[];
+  }>;
+  run(): Promise<{
+    meta: {
+      changes: number;
+    };
+  }>;
+}
+export interface ConsentDatabase {
+  prepare(query: string): ConsentStatement;
+}
+/** A Workers Rate Limiting binding. */
+export interface ConsentRateLimiter {
+  limit(options: {
+    key: string;
+  }): Promise<{
+    success: boolean;
+  }>;
+}
+export interface ConsentBindings {
+  /** The Site's consent database (D1, jurisdiction "eu"), never the publication store. */
+  CONSENT_DB?: ConsentDatabase;
+  /** The CMS-held bearer secret for the read endpoints (a Worker secret, ≥ 32 characters). */
+  CONSENT_READ_TOKEN?: string;
+  /** A Workers Rate Limiting binding for record writes, keyed per client IP per request. */
+  CONSENT_RATE_LIMITER?: ConsentRateLimiter;
+}
+export interface ConsentServerConfig {
+  /** The Site's identity, recorded with each decision. */
+  siteId: string;
+  bindings: () => ConsentBindings | Promise<ConsentBindings>;
+  /**
+   * The Site's public origin(s), when the Worker sees another (a proxy). The
+   * request's own origin is always accepted.
+   */
+  siteOrigins?: readonly string[];
+  /** Retention after a decision stops being in force; at most (and by default) 5 years (CN-R10). */
+  retentionDays?: number;
+  now?: () => number;
+}
+export declare const MAX_RETENTION_DAYS = 1826;
+/** The CSV export's columns, in order (documented; stable within the schema version). */
+export declare const CONSENT_EXPORT_COLUMNS: readonly ["recorded_at", "consent_id", "site_id", "action", "config_version", "language", "ui_version", "preferences", "analytics", "marketing", "external_media", "legal_revisions"];
+/**
+ * The consent endpoints. `handle` routes `/gq/consent` (record writes) and
+ * `/gq/consent/records/<id>`, `/gq/consent/export`, `/gq/consent/stats`
+ * (authenticated reads), and answers null for any other path. `purge` is the
+ * scheduled retention job.
+ */
+export declare function createConsentServer(config: ConsentServerConfig): {
+  handle: (request: Request) => Promise<Response | null>;
+  handleRecord: (request: Request) => Promise<Response>;
+  handleRead: (request: Request) => Promise<Response>;
+  purge: () => Promise<{
+    deleted: number;
+  }>;
+  check: () => Promise<{
+    records: boolean;
+    reads: boolean;
+    rateLimit: boolean;
+    retentionDays: number;
+  }>;
+};
+export type ConsentServer = ReturnType<typeof createConsentServer>;
+//#endregion
+export type { ConsentRecord, ConsentRecordRequest };