non-spooky-react-cookie 0.1.0

package/dist/index.js

@@ -0,0 +1,837 @@
+"use client";
+import { a as writePreferences, d as BUILT_IN_LANGUAGES, f as getBuiltInTexts, i as removePreferences, l as localStorageAdapter, o as createBothStorage, p as resolveTexts, r as readPreferences, s as createCookieStorage, t as DEFAULT_STORAGE_KEY, u as resolveStorage } from "./storage-WH-kuxkg.js";
+import { createContext, useCallback, useContext, useEffect, useId, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/integrations/global-privacy-control.ts
+/**
+* Global Privacy Control (https://w3c.github.io/gpc/) is a browser-level
+* "do not sell or share my data" signal. When the visitor turns it on, the
+* browser sends `Sec-GPC: 1` with every request and exposes
+* `navigator.globalPrivacyControl === true` to scripts; when it is off the
+* header is absent and the property is `false` (or missing entirely in
+* browsers without native support, where extensions may define it).
+*
+* Returns `true` only for an active signal. Safe to call on the server.
+*/
+function readGlobalPrivacyControl() {
+	if (typeof navigator === "undefined") return false;
+	return navigator.globalPrivacyControl === true;
+}
+//#endregion
+//#region src/integrations/google-tracker.ts
+function ensureGtag() {
+	if (typeof window === "undefined") return null;
+	window.dataLayer = window.dataLayer ?? [];
+	window.gtag = window.gtag ?? function gtag() {
+		window.dataLayer?.push(arguments);
+	};
+	return window.gtag;
+}
+/**
+* Initializes Google's consent mode with everything denied.
+* Call this before any Google tag loads.
+*/
+function initGoogleTracker() {
+	const gtag = ensureGtag();
+	if (!gtag) return;
+	gtag("consent", "default", {
+		ad_storage: "denied",
+		ad_user_data: "denied",
+		ad_personalization: "denied",
+		analytics_storage: "denied"
+	});
+}
+/**
+* Updates Google's consent mode based on the stored preferences.
+*
+* Without `categories`, the category ids `analytics` / `marketing` in the
+* accepted map drive the signals. With `categories`, a category grants its
+* signals when the category OR any of its fine-grained items is accepted,
+* so item-level consent (e.g. "only Google Ads") is respected.
+*/
+function updateGoogleTracker(state, categories) {
+	const gtag = ensureGtag();
+	if (!gtag) return;
+	const toValue = (id) => {
+		const category = categories?.find((candidate) => candidate.id === id);
+		return Boolean(state.accepted[id]) || Boolean(category?.items?.some((item) => state.accepted[item.id])) ? "granted" : "denied";
+	};
+	const analytics = toValue("analytics");
+	const marketing = toValue("marketing");
+	gtag("consent", "update", {
+		analytics_storage: analytics,
+		ad_storage: marketing,
+		ad_user_data: marketing,
+		ad_personalization: marketing
+	});
+}
+//#endregion
+//#region src/integrations/script-runtime.ts
+const runtimes = /* @__PURE__ */ new Map();
+function getEntry(id) {
+	let entry = runtimes.get(id);
+	if (!entry) {
+		entry = {
+			status: "blocked",
+			listeners: /* @__PURE__ */ new Set()
+		};
+		runtimes.set(id, entry);
+	}
+	return entry;
+}
+/**
+* Subscribe a listener to status changes for `id`.
+* Returns an unsubscribe function. Safe to call on the server
+* (returns a no-op) so `useSyncExternalStore` never crashes during SSR.
+*/
+function subscribeScript(id, notify) {
+	if (typeof window === "undefined") return () => {};
+	getEntry(id).listeners.add(notify);
+	return () => {
+		getEntry(id).listeners.delete(notify);
+	};
+}
+/** Primitive snapshot for `useSyncExternalStore` (must be stable). */
+function getScriptStatus(id) {
+	return getEntry(id).status;
+}
+/** The last error for `id`, if any. */
+function getScriptError(id) {
+	return getEntry(id).error;
+}
+/**
+* Sets the status (and error, if any) for `id` and notifies subscribers.
+* The error is always replaced, so a later `loaded` clears an old failure.
+*/
+function setScriptStatus(id, status, error) {
+	const entry = getEntry(id);
+	entry.status = status;
+	entry.error = error;
+	entry.listeners.forEach((listener) => {
+		try {
+			listener();
+		} catch {}
+	});
+}
+//#endregion
+//#region src/integrations/script-loader.ts
+/** Runs a consumer callback; its errors must never break consent enforcement. */
+function safeCall(fn) {
+	try {
+		fn?.();
+	} catch {}
+}
+function findScriptElement(id) {
+	const element = document.getElementById(id);
+	return element instanceof HTMLScriptElement ? element : null;
+}
+function loadScript({ id, src, attrs, children, async: asyncFlag, defer, onLoad, onError }) {
+	if (typeof document === "undefined") return null;
+	const existing = findScriptElement(id);
+	if (existing) return existing;
+	const script = document.createElement("script");
+	script.id = id;
+	if (defer && !asyncFlag) script.defer = true;
+	else script.async = true;
+	if (src) script.src = src;
+	if (children) script.text = children;
+	if (onLoad) script.addEventListener("load", onLoad);
+	if (onError) script.addEventListener("error", onError);
+	Object.entries(attrs ?? {}).forEach(([key, value]) => {
+		script.setAttribute(key, value);
+	});
+	document.head.appendChild(script);
+	return script;
+}
+/**
+* Removes the script element with `id` and runs the optional
+* `cleanup` function.
+*
+* Caveat: this does NOT undo cookies or network requests the script
+* already made — use `cleanup` for integration-specific teardown.
+*/
+function unloadScript(id, cleanup) {
+	if (typeof document === "undefined") return;
+	findScriptElement(id)?.remove();
+	safeCall(cleanup);
+}
+/**
+* Ensures the script under `id` is loaded, driving the runtime store.
+*
+* - Already in the DOM → status `loaded` (dedup, `onLoad` not re-fired).
+* - Not in the DOM → status `loading`, then `loaded`/`error` when the
+*   element settles. `def.onLoad` / `def.onError` run (wrapped so a throw
+*   never breaks consent enforcement).
+*/
+function ensureScript(id, def) {
+	if (typeof document === "undefined") return;
+	if (findScriptElement(id)) {
+		setScriptStatus(id, "loaded");
+		return;
+	}
+	const handleLoad = () => {
+		setScriptStatus(id, "loaded");
+		safeCall(def.onLoad);
+	};
+	setScriptStatus(id, "loading");
+	if (loadScript({
+		id,
+		src: def.src,
+		attrs: def.attrs,
+		children: def.children,
+		async: def.async,
+		defer: def.defer,
+		onLoad: handleLoad,
+		onError: () => {
+			setScriptStatus(id, "error", /* @__PURE__ */ new Error(`Script "${id}" failed to load.`));
+			safeCall(def.onError);
+		}
+	}) && !def.src) handleLoad();
+}
+/**
+* Removes the script under `id` from the DOM (running `cleanup`) and
+* resets its status back to `blocked`. A script that is already blocked
+* and not in the DOM is left alone, so `cleanup` runs only after a real load.
+*/
+function removeScript(id, cleanup) {
+	if (typeof document === "undefined") return;
+	if (getScriptStatus(id) === "blocked" && !findScriptElement(id)) return;
+	unloadScript(id, cleanup);
+	setScriptStatus(id, "blocked");
+}
+//#endregion
+//#region src/CookieBannerConfigurationProvider.tsx
+const DEFAULT_VERSION = "1";
+const defaultCategories = [
+	{
+		id: "necessary",
+		required: true
+	},
+	{ id: "preferences" },
+	{ id: "analytics" },
+	{ id: "marketing" }
+];
+/** Maps the object-map `config` prop to the internal category array. */
+function configToCategories(config) {
+	return Object.entries(config.categories).map(([id, category]) => ({
+		id,
+		title: category.name,
+		description: category.description,
+		required: category.required,
+		items: category.items ? Object.entries(category.items).map(([itemId, item]) => ({
+			id: itemId,
+			title: item.name,
+			description: item.description
+		})) : void 0
+	}));
+}
+const CookieBannerContext = createContext(null);
+/**
+* Builds a complete state. Required categories are always on; optional
+* categories and every item follow `acceptOptional`.
+*/
+function buildState(version, categories, acceptOptional) {
+	const accepted = {};
+	categories.forEach((category) => {
+		accepted[category.id] = Boolean(category.required) || acceptOptional;
+		category.items?.forEach((item) => {
+			accepted[item.id] = acceptOptional;
+		});
+	});
+	return {
+		version,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		accepted
+	};
+}
+const themeVariables = {
+	primaryColor: "--nsr-primary",
+	primaryTextColor: "--nsr-primary-text",
+	primaryHoverColor: "--nsr-primary-hover",
+	secondaryColor: "--nsr-secondary",
+	secondaryTextColor: "--nsr-secondary-text",
+	accentColor: "--nsr-accent",
+	surfaceColor: "--nsr-surface",
+	surfaceMutedColor: "--nsr-surface-muted",
+	textColor: "--nsr-text",
+	mutedTextColor: "--nsr-muted",
+	borderColor: "--nsr-border",
+	ringColor: "--nsr-ring",
+	switchOffColor: "--nsr-switch-off",
+	switchThumbColor: "--nsr-switch-thumb",
+	backdropColor: "--nsr-backdrop"
+};
+/** The attribute that scopes a provider's theme rules to its elements. */
+const THEME_ATTRIBUTE = "data-nsr-theme";
+/**
+* Keeps a palette value safe to embed in a stylesheet: a value is a single
+* CSS color, so it never needs a declaration or block terminator.
+*/
+function sanitizeCssValue(value) {
+	return value.replace(/[;{}<>]/g, "").trim();
+}
+/** `[--nsr-x, value]` pairs for the set entries of a palette. */
+function themeEntries(theme) {
+	return Object.entries(themeVariables).flatMap(([key, variable]) => {
+		const value = theme[key];
+		return value ? [[variable, sanitizeCssValue(value)]] : [];
+	});
+}
+/** Resolves the theme palette into CSS custom properties (set values only). */
+function themeToStyle(theme) {
+	return Object.fromEntries(themeEntries(theme));
+}
+/**
+* Builds the scoped stylesheet for one provider. `theme` applies to every
+* element carrying the provider's theme attribute; `darkTheme` applies to the
+* same elements under a `.dark` / `[data-theme="dark"]` ancestor. Returns an
+* empty string when neither palette sets anything, so nothing is rendered.
+*/
+function buildThemeCss(id, theme, darkTheme) {
+	const scope = `[${THEME_ATTRIBUTE}="${id.replace(/["\\]/g, "")}"]`;
+	const block = (entries) => entries.map(([variable, value]) => `  ${variable}: ${value};`).join("\n");
+	const light = themeEntries(theme);
+	const dark = themeEntries(darkTheme);
+	const rules = [];
+	if (light.length > 0) rules.push(`${scope} {\n${block(light)}\n}`);
+	if (dark.length > 0) rules.push(`:is(.dark, [data-theme="dark"]) ${scope} {\n${block(dark)}\n}`);
+	return rules.join("\n");
+}
+function CookieBannerConfigurationProvider({ children, config, scripts, language = "en", texts: textOverrides, theme = {}, darkTheme = {}, components = {}, storageKey = DEFAULT_STORAGE_KEY, storage = "localStorage", cookieOptions, initialPreferences, version = DEFAULT_VERSION, googleConsentMode = false, windowJustDont = true, respectGlobalPrivacyControl = true, onDecision }) {
+	const cookieOptionsKey = JSON.stringify(cookieOptions ?? null);
+	const store = useMemo(() => resolveStorage(storage, JSON.parse(cookieOptionsKey) ?? void 0), [storage, cookieOptionsKey]);
+	const categories = useMemo(() => config ? configToCategories(config) : defaultCategories, [config]);
+	const texts = useMemo(() => resolveTexts(language, textOverrides), [language, textOverrides]);
+	const themeId = useId();
+	const themeKey = JSON.stringify(theme);
+	const darkThemeKey = JSON.stringify(darkTheme);
+	const themeStyle = useMemo(() => themeToStyle(JSON.parse(themeKey)), [themeKey]);
+	const themeCss = useMemo(() => buildThemeCss(themeId, JSON.parse(themeKey), JSON.parse(darkThemeKey)), [
+		darkThemeKey,
+		themeId,
+		themeKey
+	]);
+	const themeAttributes = useMemo(() => ({ [THEME_ATTRIBUTE]: themeId }), [themeId]);
+	const itemToCategory = useMemo(() => {
+		const owners = {};
+		categories.forEach((category) => {
+			category.items?.forEach((item) => {
+				owners[item.id] = category.id;
+			});
+		});
+		return owners;
+	}, [categories]);
+	const restoredInitial = initialPreferences?.version === version ? initialPreferences : null;
+	const [loaded, setLoaded] = useState(initialPreferences !== void 0);
+	const [hasDecision, setHasDecision] = useState(restoredInitial !== null);
+	const [globalPrivacyControl, setGlobalPrivacyControl] = useState(false);
+	const [settingsOpen, setSettingsOpen] = useState(false);
+	const [state, setState] = useState(() => restoredInitial ?? buildState(version, categories, false));
+	const syncGoogle = useCallback((next) => {
+		if (googleConsentMode) updateGoogleTracker(next, categories);
+	}, [categories, googleConsentMode]);
+	const onDecisionRef = useRef(onDecision);
+	useEffect(() => {
+		onDecisionRef.current = onDecision;
+	}, [onDecision]);
+	useEffect(() => {
+		if (googleConsentMode) initGoogleTracker();
+		const stored = readPreferences(store, storageKey);
+		const restored = stored?.version === version ? stored : null;
+		const gpc = respectGlobalPrivacyControl && readGlobalPrivacyControl();
+		const next = restored ?? buildState(version, categories, false);
+		const decidedByGpc = restored === null && gpc;
+		setState(next);
+		setHasDecision(restored !== null || decidedByGpc);
+		setGlobalPrivacyControl(gpc);
+		syncGoogle(next);
+		setLoaded(true);
+		if (decidedByGpc) onDecisionRef.current?.(next);
+	}, [
+		categories,
+		googleConsentMode,
+		respectGlobalPrivacyControl,
+		storageKey,
+		store,
+		syncGoogle,
+		version
+	]);
+	useEffect(() => {
+		const entries = Object.entries(scripts ?? {});
+		return () => {
+			for (const [id, def] of entries) removeScript(id, def.cleanup);
+		};
+	}, [scripts]);
+	useEffect(() => {
+		if (!loaded) return;
+		Object.entries(scripts ?? {}).forEach(([id, def]) => {
+			if (state.accepted[def.category]) ensureScript(id, def);
+			else removeScript(id, def.cleanup);
+		});
+	}, [
+		loaded,
+		scripts,
+		state.accepted
+	]);
+	const persist = useCallback((next) => {
+		setState(next);
+		setHasDecision(true);
+		setSettingsOpen(false);
+		writePreferences(store, storageKey, next);
+		syncGoogle(next);
+		onDecision?.(next);
+	}, [
+		onDecision,
+		storageKey,
+		store,
+		syncGoogle
+	]);
+	const acceptAll = useCallback(() => persist(buildState(version, categories, true)), [
+		categories,
+		persist,
+		version
+	]);
+	const rejectAll = useCallback(() => persist(buildState(version, categories, false)), [
+		categories,
+		persist,
+		version
+	]);
+	const savePreferences = useCallback((partial) => persist({
+		version,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		accepted: {
+			...state.accepted,
+			...partial.accepted
+		}
+	}), [
+		persist,
+		state.accepted,
+		version
+	]);
+	const resetPreferences = useCallback(() => {
+		const initial = buildState(version, categories, false);
+		removePreferences(store, storageKey);
+		setState(initial);
+		setHasDecision(false);
+		setSettingsOpen(false);
+		syncGoogle(initial);
+		onDecision?.(initial);
+	}, [
+		categories,
+		onDecision,
+		storageKey,
+		store,
+		syncGoogle,
+		version
+	]);
+	const openSettings = useCallback(() => setSettingsOpen(true), []);
+	const closeSettings = useCallback(() => setSettingsOpen(false), []);
+	const isAllowed = useCallback((id) => Boolean(state.accepted[id]), [state.accepted]);
+	/**
+	* Resolves the display title/description for a category or item,
+	* preferring the config values, then the texts, then the id.
+	*/
+	const resolveLabel = useCallback((id, config) => {
+		const parent = itemToCategory[id];
+		const source = parent ? texts.categories[parent]?.items?.[id] : texts.categories[id];
+		return {
+			title: config?.title ?? source?.title ?? id,
+			description: config?.description ?? source?.description ?? ""
+		};
+	}, [itemToCategory, texts]);
+	const value = useMemo(() => ({
+		loaded,
+		hasDecision,
+		showBanner: loaded && !hasDecision,
+		globalPrivacyControl,
+		settingsOpen,
+		preferences: state,
+		texts,
+		categories,
+		scripts: scripts ?? {},
+		theme,
+		darkTheme,
+		components,
+		themeStyle,
+		themeAttributes,
+		acceptAll,
+		rejectAll,
+		savePreferences,
+		resetPreferences,
+		openSettings,
+		closeSettings,
+		isAllowed,
+		resolveLabel
+	}), [
+		acceptAll,
+		categories,
+		closeSettings,
+		components,
+		darkTheme,
+		globalPrivacyControl,
+		hasDecision,
+		isAllowed,
+		loaded,
+		openSettings,
+		rejectAll,
+		resetPreferences,
+		resolveLabel,
+		savePreferences,
+		scripts,
+		settingsOpen,
+		state,
+		texts,
+		theme,
+		themeAttributes,
+		themeStyle
+	]);
+	useEffect(() => {
+		if (!windowJustDont || typeof window === "undefined") return;
+		const w = window;
+		if (typeof w.justDont === "function") console.warn("[non-spooky-react-cookie] window.justDont already exists; the cookie banner will overwrite it.");
+		w.justDont = rejectAll;
+		return () => {
+			if (w.justDont === rejectAll) delete w.justDont;
+		};
+	}, [rejectAll, windowJustDont]);
+	return /* @__PURE__ */ jsxs(CookieBannerContext.Provider, {
+		value,
+		children: [themeCss ? /* @__PURE__ */ jsx("style", {
+			"data-nsr-theme-style": themeId,
+			children: themeCss
+		}) : null, children]
+	});
+}
+//#endregion
+//#region src/hooks/usePreferences.ts
+/**
+* Access the cookie banner state and actions from anywhere
+* inside a CookieBannerConfigurationProvider.
+*/
+function usePreferences() {
+	const context = useContext(CookieBannerContext);
+	if (!context) throw new Error("usePreferences must be used within a CookieBannerConfigurationProvider");
+	return context;
+}
+//#endregion
+//#region src/ui.tsx
+function cn(...classes) {
+	return classes.filter(Boolean).join(" ");
+}
+/**
+* Default Button.
+* Colors come from the `--nsr-*` variables: defaults in `styles.css`,
+* overrides from the provider's `theme` prop.
+*/
+function Button({ className, variant = "secondary", ...props }) {
+	return /* @__PURE__ */ jsx("button", {
+		className: cn("nsr-button", `nsr-button--${variant}`, className),
+		...props
+	});
+}
+/**
+* Default Switch.
+* The "on" color follows the theme's primary color.
+*/
+function Switch({ checked, disabled, onCheckedChange, "aria-label": ariaLabel }) {
+	return /* @__PURE__ */ jsx("button", {
+		type: "button",
+		role: "switch",
+		"aria-checked": checked,
+		"aria-label": ariaLabel,
+		disabled,
+		onClick: () => onCheckedChange(!checked),
+		className: "nsr-switch",
+		children: /* @__PURE__ */ jsx("span", { className: "nsr-switch__thumb" })
+	});
+}
+/**
+* Default Collapsible.
+* A disclosure that hides its children until the trigger is pressed.
+* Works controlled (`open` + `onOpenChange`) or self-managed (`defaultOpen`).
+* The chevron follows the theme's primary color.
+*/
+function Collapsible({ children, count, label, open, onOpenChange, defaultOpen, className, contentClassName }) {
+	const regionId = useId();
+	const [internalOpen, setInternalOpen] = useState(defaultOpen ?? false);
+	const isOpen = open ?? internalOpen;
+	const toggle = () => {
+		const next = !isOpen;
+		if (open === void 0) setInternalOpen(next);
+		onOpenChange?.(next);
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("nsr-collapsible", isOpen && "nsr-collapsible--open"),
+		children: [/* @__PURE__ */ jsxs("button", {
+			type: "button",
+			"aria-controls": regionId,
+			"aria-expanded": isOpen,
+			className: cn("nsr-collapsible__trigger", className),
+			onClick: toggle,
+			children: [/* @__PURE__ */ jsxs("span", {
+				className: "nsr-collapsible__label",
+				children: [
+					label,
+					" (",
+					count,
+					")"
+				]
+			}), /* @__PURE__ */ jsx("svg", {
+				className: "nsr-collapsible__chevron",
+				fill: "none",
+				stroke: "currentColor",
+				strokeWidth: 2,
+				strokeLinecap: "round",
+				strokeLinejoin: "round",
+				viewBox: "0 0 24 24",
+				"aria-hidden": "true",
+				children: /* @__PURE__ */ jsx("path", { d: "M6 9l6 6 6-6" })
+			})]
+		}), isOpen ? /* @__PURE__ */ jsx("div", {
+			className: cn("nsr-collapsible__content", contentClassName),
+			id: regionId,
+			children
+		}) : null]
+	});
+}
+//#endregion
+//#region src/CookieSettingsDialog.tsx
+/** Renders nothing while closed; the open dialog mounts fresh each time. */
+function CookieSettingsDialog(props) {
+	const { settingsOpen } = usePreferences();
+	return settingsOpen ? /* @__PURE__ */ jsx(OpenSettingsDialog, { ...props }) : null;
+}
+function OpenSettingsDialog({ className, overlayClassName, contentClassName, headerClassName, bodyClassName, footerClassName, categoryCardClassName, itemClassName, buttonClassName, components: ownComponents }) {
+	const { categories, closeSettings, components: providerComponents, preferences, resolveLabel, savePreferences, texts, themeAttributes } = usePreferences();
+	const dialogRef = useRef(null);
+	const [draft, setDraft] = useState(preferences.accepted);
+	useEffect(() => {
+		const dialog = dialogRef.current;
+		if (dialog && !dialog.open && typeof dialog.showModal === "function") dialog.showModal();
+	}, []);
+	const components = {
+		...providerComponents,
+		...ownComponents
+	};
+	const ButtonComponent = components.Button ?? Button;
+	const SwitchComponent = components.Switch ?? Switch;
+	const CollapsibleComponent = components.Collapsible ?? Collapsible;
+	const setAccepted = (ids, value) => setDraft((current) => {
+		const next = { ...current };
+		for (const id of ids) next[id] = value;
+		return next;
+	});
+	const handleCancel = (event) => {
+		event.preventDefault();
+		closeSettings();
+	};
+	return /* @__PURE__ */ jsxs("dialog", {
+		"aria-labelledby": "nsr-settings-title",
+		className: cn("nsr-settings-dialog", className),
+		onCancel: handleCancel,
+		ref: dialogRef,
+		...themeAttributes,
+		children: [/* @__PURE__ */ jsx("button", {
+			"aria-label": texts.dialog.close,
+			className: cn("nsr-dialog__overlay", overlayClassName),
+			onClick: closeSettings,
+			tabIndex: -1,
+			type: "button"
+		}), /* @__PURE__ */ jsxs("div", {
+			className: cn("nsr-dialog__panel", contentClassName),
+			children: [
+				/* @__PURE__ */ jsxs("div", {
+					className: cn("nsr-dialog__header", headerClassName),
+					children: [/* @__PURE__ */ jsx("h2", {
+						id: "nsr-settings-title",
+						className: "nsr-dialog__title",
+						children: texts.dialog.title
+					}), /* @__PURE__ */ jsx("p", {
+						className: "nsr-dialog__description",
+						children: texts.dialog.description
+					})]
+				}),
+				/* @__PURE__ */ jsx("div", {
+					className: cn("nsr-dialog__body", bodyClassName),
+					children: categories.map((category) => {
+						const { title, description } = resolveLabel(category.id, category);
+						const required = Boolean(category.required);
+						const items = category.items ?? [];
+						return /* @__PURE__ */ jsxs("section", {
+							className: cn("nsr-category", required && "nsr-category--required", categoryCardClassName),
+							children: [/* @__PURE__ */ jsxs("div", {
+								className: "nsr-category__header",
+								children: [/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("h3", {
+									className: "nsr-category__title",
+									children: title
+								}), description ? /* @__PURE__ */ jsx("p", {
+									className: "nsr-category__description",
+									children: description
+								}) : null] }), /* @__PURE__ */ jsx(SwitchComponent, {
+									"aria-label": title,
+									checked: Boolean(draft[category.id]),
+									disabled: required,
+									onCheckedChange: (value) => setAccepted([category.id, ...items.map((item) => item.id)], value)
+								})]
+							}), items.length > 0 ? /* @__PURE__ */ jsx(CollapsibleComponent, {
+								count: items.length,
+								label: texts.dialog.itemsLabel,
+								contentClassName: "nsr-category__items",
+								children: items.map((item) => {
+									const itemLabel = resolveLabel(item.id, item);
+									return /* @__PURE__ */ jsxs("div", {
+										className: cn("nsr-item", itemClassName),
+										children: [/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("h4", {
+											className: "nsr-item__title",
+											children: itemLabel.title
+										}), itemLabel.description ? /* @__PURE__ */ jsx("p", {
+											className: "nsr-item__description",
+											children: itemLabel.description
+										}) : null] }), /* @__PURE__ */ jsx(SwitchComponent, {
+											"aria-label": itemLabel.title,
+											checked: Boolean(draft[item.id]),
+											disabled: required,
+											onCheckedChange: (value) => setAccepted([item.id], value)
+										})]
+									}, item.id);
+								})
+							}) : null]
+						}, category.id);
+					})
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: cn("nsr-dialog__footer", footerClassName),
+					children: [/* @__PURE__ */ jsx(ButtonComponent, {
+						className: cn("nsr-dialog__button", buttonClassName),
+						onClick: closeSettings,
+						type: "button",
+						variant: "ghost",
+						children: texts.dialog.close
+					}), /* @__PURE__ */ jsx(ButtonComponent, {
+						className: cn("nsr-dialog__button", buttonClassName),
+						onClick: () => savePreferences({ accepted: draft }),
+						type: "button",
+						variant: "primary",
+						children: texts.dialog.save
+					})]
+				})
+			]
+		})]
+	});
+}
+//#endregion
+//#region src/CookieBanner.tsx
+function CookieBanner({ policyUrl, className, contentClassName, titleClassName, descriptionClassName, actionsClassName, buttonClassName, components, dialogProps }) {
+	const { acceptAll, components: providerComponents, openSettings, rejectAll, showBanner, texts, themeAttributes } = usePreferences();
+	const ButtonComponent = components?.Button ?? providerComponents.Button ?? Button;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [showBanner ? /* @__PURE__ */ jsx("section", {
+		"aria-label": texts.banner.title,
+		className: cn("nsr-banner", className),
+		...themeAttributes,
+		children: /* @__PURE__ */ jsxs("div", {
+			className: cn("nsr-banner__card", contentClassName),
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: "nsr-banner__text",
+				children: [/* @__PURE__ */ jsx("h2", {
+					className: cn("nsr-banner__title", titleClassName),
+					children: texts.banner.title
+				}), /* @__PURE__ */ jsxs("p", {
+					className: cn("nsr-banner__description", descriptionClassName),
+					children: [texts.banner.description, policyUrl ? /* @__PURE__ */ jsxs(Fragment, { children: [" ", /* @__PURE__ */ jsx("a", {
+						className: "nsr-banner__link",
+						href: policyUrl,
+						children: texts.banner.policyLink
+					})] }) : null]
+				})]
+			}), /* @__PURE__ */ jsxs("div", {
+				className: cn("nsr-banner__actions", actionsClassName),
+				children: [
+					/* @__PURE__ */ jsx(ButtonComponent, {
+						className: buttonClassName,
+						onClick: rejectAll,
+						type: "button",
+						variant: "secondary",
+						children: texts.banner.rejectAll
+					}),
+					/* @__PURE__ */ jsx(ButtonComponent, {
+						className: buttonClassName,
+						onClick: openSettings,
+						type: "button",
+						variant: "secondary",
+						children: texts.banner.settings
+					}),
+					/* @__PURE__ */ jsx(ButtonComponent, {
+						className: buttonClassName,
+						onClick: acceptAll,
+						type: "button",
+						variant: "primary",
+						children: texts.banner.acceptAll
+					})
+				]
+			})]
+		})
+	}) : null, /* @__PURE__ */ jsx(CookieSettingsDialog, {
+		...dialogProps,
+		components: {
+			...components,
+			...dialogProps?.components
+		}
+	})] });
+}
+//#endregion
+//#region src/CookieSettingsLink.tsx
+/**
+* A small link (e.g. in a footer) that opens the cookie settings dialog.
+* Renders your children, or the built-in "Cookie settings" text.
+*/
+function CookieSettingsLink({ children, className, type = "button", onClick, ...props }) {
+	const { openSettings, texts, themeAttributes } = usePreferences();
+	return /* @__PURE__ */ jsx("button", {
+		className: cn("nsr-settings-link", className),
+		...themeAttributes,
+		onClick: (event) => {
+			openSettings();
+			onClick?.(event);
+		},
+		type,
+		...props,
+		children: children ?? texts.footerLink
+	});
+}
+//#endregion
+//#region src/hooks/useConsentScript.ts
+/**
+* Reactive, consent-gated load status for a script declared in the
+* provider's `scripts` map.
+*
+* The status is gated on the script's `category`: denied → `blocked`;
+* granted → the provider drives `loading` → `loaded`/`error`. The hook never
+* loads anything itself — the provider is the single enforcement point.
+*
+* Must be rendered inside a `CookieBannerConfigurationProvider`.
+*/
+function useConsentScript(id) {
+	const context = useContext(CookieBannerContext);
+	const def = context?.scripts[id];
+	const subscribe = useCallback((notify) => subscribeScript(id, notify), [id]);
+	const runtimeStatus = useSyncExternalStore(subscribe, () => getScriptStatus(id), () => "blocked");
+	const runtimeError = useSyncExternalStore(subscribe, () => getScriptError(id), () => void 0);
+	if (!context) return {
+		status: "error",
+		error: /* @__PURE__ */ new Error(`useConsentScript("${id}") must be used within a CookieBannerConfigurationProvider.`)
+	};
+	if (!def) return {
+		status: "error",
+		error: /* @__PURE__ */ new Error(`useConsentScript("${id}"): script is not declared in the provider's \`scripts\` map.`)
+	};
+	if (!context.isAllowed(def.category)) return { status: "blocked" };
+	const status = runtimeStatus === "blocked" ? "loading" : runtimeStatus;
+	return {
+		status,
+		error: status === "error" ? runtimeError : void 0
+	};
+}
+//#endregion
+export { BUILT_IN_LANGUAGES, Button, Collapsible, CookieBanner, CookieBannerConfigurationProvider, CookieSettingsDialog, CookieSettingsLink, DEFAULT_STORAGE_KEY, Switch, THEME_ATTRIBUTE, cn, createBothStorage, createCookieStorage, getBuiltInTexts, initGoogleTracker, localStorageAdapter, updateGoogleTracker, useConsentScript, usePreferences };
+
+//# sourceMappingURL=index.js.map