@c15t/astro 3.0.0-alpha.0

package/dist/integration.js

@@ -0,0 +1,170 @@
+const VIRTUAL_ID = 'virtual:c15t/options';
+const RESOLVED_VIRTUAL_ID = `\0${VIRTUAL_ID}`;
+const DEFAULT_INIT_PATH = '/api/c15t/init';
+const DEFAULT_MANIFEST_PATH = '/api/c15t/manifest';
+const UI_ADAPTERS = {
+    react: {
+        adapterExport: 'reactDialogAdapter',
+        adapterModule: '@c15t/astro/ui/react',
+        astroIntegration: '@astrojs/react',
+        packages: [
+            '@astrojs/react',
+            '@c15t/react',
+            'react',
+            'react-dom'
+        ],
+        surfaceModule: '@c15t/astro/islands/panel-surface.tsx'
+    },
+    svelte: {
+        adapterExport: 'svelteDialogAdapter',
+        adapterModule: '@c15t/astro/ui/svelte',
+        astroIntegration: '@astrojs/svelte',
+        packages: [
+            '@astrojs/svelte',
+            'svelte'
+        ],
+        surfaceModule: '@c15t/astro/islands/panel-surface.svelte'
+    },
+    vue: {
+        adapterExport: 'vueDialogAdapter',
+        adapterModule: '@c15t/astro/ui/vue',
+        astroIntegration: '@astrojs/vue',
+        packages: [
+            '@astrojs/vue',
+            '@c15t/vue',
+            'vue'
+        ],
+        surfaceModule: '@c15t/astro/islands/panel-surface.vue'
+    }
+};
+const UI_ADAPTER_NAMES = Object.keys(UI_ADAPTERS);
+const SUGGESTIBLE_ADAPTERS = [
+    'react',
+    'vue'
+];
+const integration_resolveMiddleware = function(options) {
+    const raw = 'boolean' == typeof options.middleware ? {
+        enabled: options.middleware
+    } : options.middleware ?? {};
+    return {
+        enabled: raw.enabled ?? true,
+        skip: raw.skip ?? []
+    };
+};
+const integration_resolveEndpoints = function(options) {
+    const raw = 'boolean' == typeof options.endpoints ? {
+        enabled: options.endpoints
+    } : options.endpoints ?? {};
+    return {
+        enabled: raw.enabled ?? 'manifest' === options.mode.type,
+        initPath: raw.initPath ?? DEFAULT_INIT_PATH,
+        manifestPath: raw.manifestPath ?? DEFAULT_MANIFEST_PATH
+    };
+};
+const integration_backendURLFromEnv = function() {
+    if ("u" < typeof process) return;
+    const env = process.env;
+    return env?.C15T_BACKEND_URL ?? env?.PUBLIC_C15T_BACKEND_URL;
+};
+const integration_resolveOptions = function(options) {
+    if (!options?.mode || 'object' != typeof options.mode) throw new Error('@c15t/astro: `mode` is required. Use hosted({ url }), offline() or manifest().');
+    if ('manifest' === options.mode.type && options.mode.manifestURL && !options.mode.backendURL && !integration_backendURLFromEnv()) throw new Error('@c15t/astro: manifest mode with a `manifestURL` also needs a `backendURL` (or C15T_BACKEND_URL) — that is where consent is saved, and the injected routes only serve init and manifest.');
+    if (void 0 !== options.ui && !(options.ui in UI_ADAPTERS)) throw new Error(`@c15t/astro: unknown \`ui\` ${JSON.stringify(options.ui)}. Supported adapters: ${UI_ADAPTER_NAMES.join(', ')}.`);
+    const { endpoints: _endpoints, middleware: _middleware, requireUIIntegration: _requireUIIntegration, ...rest } = options;
+    return {
+        ...rest,
+        colorScheme: options.colorScheme ?? 'system',
+        endpoints: integration_resolveEndpoints(options),
+        middleware: integration_resolveMiddleware(options),
+        ui: options.ui ?? 'svelte'
+    };
+};
+const integration_createVirtualOptionsPlugin = function(resolved) {
+    const serialized = JSON.stringify(resolved);
+    return {
+        load (id) {
+            if (id !== RESOLVED_VIRTUAL_ID) return;
+            return `export default ${serialized};`;
+        },
+        name: 'c15t:options',
+        resolveId (id) {
+            return id === VIRTUAL_ID ? RESOLVED_VIRTUAL_ID : void 0;
+        }
+    };
+};
+const integration_buildBootScript = function(options, ui) {
+    const adapter = UI_ADAPTERS[ui];
+    const lines = [
+        `import options from '${VIRTUAL_ID}';`,
+        "import { boot, registerDialogAdapter, registerDialogSurface } from '@c15t/astro/client';",
+        `registerDialogAdapter('${ui}', async () => (await import('${adapter.adapterModule}')).${adapter.adapterExport});`,
+        `registerDialogSurface('${ui}', () => import('${adapter.surfaceModule}'));`
+    ];
+    if (options.clientEntrypoint) lines.push(`import clientOptions from '${options.clientEntrypoint}';`, 'boot(options, clientOptions);');
+    else lines.push('boot(options);');
+    return lines.join('\n');
+};
+const integration_buildVitePlugins = async function(resolved) {
+    const plugins = [
+        integration_createVirtualOptionsPlugin(resolved)
+    ];
+    if ('vue' === resolved.ui) try {
+        const { default: shimVueImports } = await import("@c15t/vue/vite");
+        plugins.push(shimVueImports());
+    } catch (cause) {
+        throw new Error(`@c15t/astro: \`ui: 'vue'\` needs ${UI_ADAPTERS.vue.packages.join(', ')} installed. Install them, or pick another \`ui\`.`, {
+            cause
+        });
+    }
+    return plugins;
+};
+const integration_suggestUIAdapter = function(options, installed, logger) {
+    if (void 0 !== options.ui) return;
+    const match = SUGGESTIBLE_ADAPTERS.find((name)=>installed.has(UI_ADAPTERS[name].astroIntegration));
+    if (!match) return;
+    logger.warn(`this site already loads ${UI_ADAPTERS[match].astroIntegration}; \`ui: '${match}'\` would render the consent dialog with it instead of adding the Svelte runtime. Set \`ui: 'svelte'\` to silence this.`);
+};
+const integration_c15t = function(options) {
+    const resolved = integration_resolveOptions(options);
+    return {
+        hooks: {
+            'astro:config:done' ({ config, logger }) {
+                const installed = new Set(config.integrations.map((integration)=>integration.name));
+                integration_suggestUIAdapter(options, installed, logger);
+                if (false === options.requireUIIntegration) return;
+                const adapter = UI_ADAPTERS[resolved.ui];
+                if (installed.has(adapter.astroIntegration)) return;
+                logger.error(`the preference-centre and IAB dialogs render as ${resolved.ui} islands, so ${adapter.astroIntegration} must be installed and listed in astro.config before c15t(). Install ${adapter.packages.join(', ')} and run \`npx astro add ${resolved.ui}\`, or pass \`requireUIIntegration: false\` if you only use the server-rendered banner.`);
+                throw new Error(`@c15t/astro: ui: ${JSON.stringify(resolved.ui)} needs ${adapter.astroIntegration}. Install it, or set \`requireUIIntegration: false\` for a banner-only site.`);
+            },
+            async 'astro:config:setup' ({ addMiddleware, injectRoute, injectScript, updateConfig }) {
+                updateConfig({
+                    vite: {
+                        plugins: await integration_buildVitePlugins(resolved)
+                    }
+                });
+                if (resolved.middleware.enabled) addMiddleware({
+                    entrypoint: '@c15t/astro/middleware',
+                    order: 'pre'
+                });
+                injectScript('page', integration_buildBootScript(options, resolved.ui));
+                if (resolved.endpoints.enabled) {
+                    injectRoute({
+                        entrypoint: '@c15t/astro/api/init',
+                        pattern: resolved.endpoints.initPath,
+                        prerender: false
+                    });
+                    injectRoute({
+                        entrypoint: '@c15t/astro/api/manifest',
+                        pattern: resolved.endpoints.manifestPath,
+                        prerender: false
+                    });
+                }
+            }
+        },
+        name: '@c15t/astro'
+    };
+};
+const src_integration = integration_c15t;
+export default src_integration;
+export { integration_c15t as c15t, integration_resolveOptions as resolveOptions };

package/dist/libs/cookies.js

@@ -0,0 +1,9 @@
+const cookies_filterCookieHeader = function(cookieHeader, names) {
+    const allowed = new Set(names);
+    const kept = cookieHeader.split(';').map((pair)=>pair.trim()).filter((pair)=>{
+        const name = pair.split('=')[0]?.trim();
+        return void 0 !== name && allowed.has(name);
+    });
+    return kept.length > 0 ? kept.join('; ') : void 0;
+};
+export { cookies_filterCookieHeader as filterCookieHeader };

package/dist/middleware-handler.js

@@ -0,0 +1,31 @@
+import { waitUntilFromLocals } from "./api/handlers.js";
+import { resolveConsentContext } from "./server.js";
+const middleware_handler_matchesPrefix = function(pathname, prefix) {
+    if (!prefix) return false;
+    const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    return pathname === normalized || pathname.startsWith(`${normalized}/`);
+};
+const middleware_handler_resolveSkipPaths = function(options) {
+    return [
+        options.endpoints.initPath,
+        options.endpoints.manifestPath,
+        ...options.middleware?.skip ?? []
+    ].filter(Boolean);
+};
+const middleware_handler_createConsentMiddleware = function(options, middlewareOptions = {}) {
+    const skipPaths = middleware_handler_resolveSkipPaths(options);
+    return async (context, next)=>{
+        const { pathname } = new URL(context.request.url);
+        if (skipPaths.some((prefix)=>middleware_handler_matchesPrefix(pathname, prefix))) return await next();
+        context.locals.c15t = await resolveConsentContext({
+            fetch: middlewareOptions.fetch,
+            headers: context.request.headers,
+            onBackgroundRevalidate: (revalidation)=>waitUntilFromLocals(revalidation, context.locals),
+            options,
+            skipPrefetch: true === context.isPrerendered,
+            url: context.request.url
+        });
+        return await next();
+    };
+};
+export { middleware_handler_createConsentMiddleware as createConsentMiddleware };

package/dist/middleware.js

@@ -0,0 +1,6 @@
+import options from "virtual:c15t/options";
+import { createConsentMiddleware } from "./middleware-handler.js";
+const onRequest = createConsentMiddleware(options);
+const middleware = onRequest;
+export default middleware;
+export { createConsentMiddleware, onRequest };

package/dist/mode.js

@@ -0,0 +1,50 @@
+import { createHostedTransport, createOfflineTransport, custom, hosted } from "@c15t/core";
+const mode_hostedMode = function(options) {
+    return {
+        ...options,
+        type: 'hosted'
+    };
+};
+const mode_offlineMode = function(options = {}) {
+    return {
+        ...options,
+        type: 'offline'
+    };
+};
+const mode_manifestMode = function(options = {}) {
+    return {
+        ...options,
+        type: 'manifest'
+    };
+};
+const createOfflineFactory = (descriptor)=>Object.assign((context)=>createOfflineTransport({
+            iabEnabled: context.iabEnabled,
+            policyRules: descriptor.policyRules ?? context.policyRules,
+            translations: context.translations
+        }), {
+        kind: 'offline'
+    });
+const mode_resolveTransportFactory = function(descriptor, endpoints = {
+    initPath: '/api/c15t/init'
+}) {
+    if ('hosted' === descriptor.type) return hosted({
+        domain: descriptor.domain,
+        headers: descriptor.headers,
+        url: descriptor.url
+    });
+    if ('offline' === descriptor.type) return createOfflineFactory(descriptor);
+    if ('manifest' === descriptor.type) {
+        const base = endpoints.initPath.replace(/\/init$/u, '');
+        const backendURL = endpoints.backendURL ?? descriptor.backendURL ?? base;
+        const transport = createHostedTransport({
+            assertDecisionInputs: true,
+            backendURL,
+            initURL: endpoints.initPath
+        });
+        return Object.assign(()=>transport, {
+            kind: 'hosted'
+        });
+    }
+    throw new Error(`@c15t/astro: unknown mode ${JSON.stringify(descriptor.type)}. Use hosted(), offline() or manifest().`);
+};
+export { custom, mode_hostedMode as hostedMode, mode_manifestMode as manifestMode, mode_offlineMode as offlineMode, mode_resolveTransportFactory as resolveTransportFactory };

package/dist/server.js

@@ -0,0 +1,291 @@
+import { buildPrefetchScript, c15tProtocolHeaders, createConsentKernel, createOfflineTransport, defaultTranslationConfig, deferInitGvl, deferInitGvlToRoute, mergeInitOutputIntoKernelConfig, mergeInitResponseIntoKernelConfig } from "@c15t/core";
+import { CONSENT_STORAGE_KEY, readStoredRecordsFromCookieHeader } from "@c15t/core/modules/persistence";
+import { isIABConfigured } from "@c15t/core/runtime";
+import { fetchCachedGvl } from "@c15t/core/server";
+import { readProducerPolicyContract } from "@c15t/core/transports";
+import { CONSENT_REQUEST_HEADER_NAMES, consentInputsToOverrides, extractConsentRequestInputs, resolveBackendURL } from "@c15t/schema/types";
+import { baseTranslations } from "@c15t/translations/all";
+import { loadConsentManifest, resolveManifestInit } from "./api/manifest-init.js";
+import { filterCookieHeader } from "./libs/cookies.js";
+const server_resolveTranslations = function(options, inputs) {
+    const detect = options.i18n?.detectLanguage !== false;
+    const language = options.i18n?.locale ?? (detect ? inputs.language : void 0) ?? defaultTranslationConfig.defaultLanguage ?? 'en';
+    const catalogue = baseTranslations;
+    const base = catalogue[language] ?? defaultTranslationConfig.translations.en;
+    const overrides = options.i18n?.messages?.[language];
+    return {
+        language,
+        translations: overrides ? {
+            ...base,
+            ...overrides
+        } : base
+    };
+};
+const server_readInitialConsentConfig = function(headers, options) {
+    const now = Date.now();
+    const initialRecords = readStoredRecordsFromCookieHeader(headers.get('cookie') ?? void 0, options.storageConfig, now);
+    const inputs = extractConsentRequestInputs(headers, {
+        language: options.i18n?.locale
+    });
+    const config = {
+        initialPolicyPending: true,
+        initialPrivacySignals: {
+            gpc: inputs.gpc
+        },
+        initialRecords,
+        now
+    };
+    const overrides = consentInputsToOverrides({
+        country: inputs.country,
+        language: inputs.language,
+        region: inputs.region
+    });
+    if (Object.keys(overrides).length > 0) config.initialOverrides = overrides;
+    return {
+        config,
+        inputs
+    };
+};
+const LOOPBACK_HOSTS = new Set([
+    'localhost',
+    '127.0.0.1',
+    '[::1]',
+    '::1'
+]);
+const server_consentCookieName = function(options) {
+    return options.storageConfig?.storageKey ?? CONSENT_STORAGE_KEY;
+};
+const server_resolveAgainstRequest = function(url, headers, requestURL) {
+    if (requestURL) try {
+        const parsed = new URL(requestURL);
+        return resolveBackendURL(url, {
+            host: parsed.host,
+            'x-forwarded-proto': parsed.protocol.replace(':', '')
+        });
+    } catch  {
+        return null;
+    }
+    const host = headers.get('host');
+    return host ? resolveBackendURL(url, {
+        host
+    }) : null;
+};
+const server_mayForwardCookie = function(absolute, requestURL) {
+    let target;
+    try {
+        target = new URL(absolute);
+    } catch  {
+        return false;
+    }
+    if ('https:' === target.protocol) return true;
+    if (LOOPBACK_HOSTS.has(target.hostname)) return true;
+    if (!requestURL) return false;
+    try {
+        const from = new URL(requestURL);
+        return 'http:' === from.protocol && from.host === target.host;
+    } catch  {
+        return false;
+    }
+};
+const INIT_HEADER_ALLOWLIST = new Set(CONSENT_REQUEST_HEADER_NAMES);
+const server_configuredInitHeaders = function(headers) {
+    const allowed = {};
+    for (const [name, value] of Object.entries(headers ?? {})){
+        const normalized = name.toLowerCase();
+        if (INIT_HEADER_ALLOWLIST.has(normalized)) allowed[normalized] = value;
+    }
+    return allowed;
+};
+const server_forwardHeaders = function(headers, overrides, options) {
+    const forward = {
+        ...c15tProtocolHeaders,
+        accept: 'application/json'
+    };
+    const detectedGpc = headers.get('sec-gpc');
+    if (null !== detectedGpc) forward['sec-gpc'] = detectedGpc;
+    const cookie = headers.get('cookie');
+    const scoped = cookie && false !== options.allowCookie ? filterCookieHeader(cookie, [
+        options.cookieName
+    ]) : void 0;
+    if (scoped) forward.cookie = scoped;
+    if (overrides.country) forward['x-c15t-country'] = overrides.country;
+    if (overrides.region) forward['x-c15t-region'] = overrides.region;
+    if (overrides.language) forward['accept-language'] = overrides.language;
+    if (void 0 !== overrides.gpc) forward['x-c15t-gpc'] = overrides.gpc ? '1' : '0';
+    return forward;
+};
+const server_prefetchHosted = async function(input) {
+    const absolute = server_resolveAgainstRequest(input.backendURL, input.headers, input.url);
+    const fetchImpl = input.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (!absolute || !fetchImpl) return input.base;
+    const allowCookie = server_mayForwardCookie(absolute, input.url);
+    const forwarded = {
+        ...server_forwardHeaders(input.headers, input.base.initialOverrides ?? {}, {
+            allowCookie,
+            cookieName: server_consentCookieName(input.options)
+        }),
+        ...server_configuredInitHeaders(input.configuredHeaders)
+    };
+    try {
+        const response = await fetchImpl(`${absolute}/init`, {
+            cache: 'no-store',
+            credentials: allowCookie ? 'include' : 'omit',
+            headers: forwarded,
+            method: 'GET'
+        });
+        if (!response.ok) return input.base;
+        const payload = await response.json();
+        return mergeInitOutputIntoKernelConfig(input.base, input.fetch || forwarded.cookie ? payload : deferInitGvl(payload, `${absolute}/init`, 'init', forwarded), {}, {
+            producerContract: readProducerPolicyContract(response.headers)
+        });
+    } catch  {
+        return input.base;
+    }
+};
+const server_prefetchManifest = async function(input, mode) {
+    const source = {
+        headers: input.headers,
+        url: input.url
+    };
+    const target = mode.manifestURL ?? mode.backendURL;
+    const absoluteTarget = target ? server_resolveAgainstRequest(target, input.headers, input.url) : null;
+    try {
+        const manifest = await loadConsentManifest({
+            fetch: input.fetch,
+            onBackgroundRevalidate: input.onBackgroundRevalidate,
+            options: input.options,
+            source
+        });
+        const payload = await resolveManifestInit({
+            fetch: input.fetch,
+            fetchGvl: async ({ reference, language, fetch: fetchImpl })=>await fetchCachedGvl({
+                    fetch: fetchImpl,
+                    language,
+                    url: reference.url
+                }),
+            inputs: input.inputs,
+            manifest
+        });
+        return mergeInitOutputIntoKernelConfig(input.base, !input.fetch && manifest.iab?.gvl ? deferInitGvlToRoute(payload, input.options.endpoints.initPath) : payload, server_forwardHeaders(input.headers, input.base.initialOverrides ?? {}, {
+            allowCookie: absoluteTarget ? server_mayForwardCookie(absoluteTarget, input.url) : false,
+            cookieName: server_consentCookieName(input.options)
+        }));
+    } catch  {
+        return input.base;
+    }
+};
+const server_prefetchOffline = async function(input) {
+    const { options } = input;
+    const policyRules = 'offline' === options.mode.type ? options.mode.policyRules : void 0;
+    const transport = createOfflineTransport({
+        iabEnabled: isIABConfigured(options.iab),
+        policyRules,
+        translations: input.translations
+    });
+    try {
+        const response = await transport.init?.({
+            overrides: input.base.initialOverrides ?? {},
+            user: input.base.initialUser ?? null
+        });
+        if (!response) return input.base;
+        return mergeInitResponseIntoKernelConfig(input.base, response);
+    } catch  {
+        return input.base;
+    }
+};
+const server_prefetchLocal = function(input) {
+    const { mode } = input.options;
+    return 'manifest' === mode.type ? server_prefetchManifest(input, mode) : server_prefetchOffline(input);
+};
+const server_withResolvedGvl = async function(input) {
+    const { iab } = input.options;
+    if (!(isIABConfigured(iab) && iab)) return input.config;
+    if (input.config.initialIab?.gvl || input.config.initialIab?.gvlReference) return input.config;
+    let gvl = iab.gvl ?? null;
+    if (!gvl && iab.gvlURL) try {
+        gvl = await fetchCachedGvl({
+            fetch: input.fetch,
+            language: input.language,
+            url: iab.gvlURL
+        });
+    } catch  {
+        gvl = null;
+    }
+    if (!gvl) return input.config;
+    return {
+        ...input.config,
+        initialIab: {
+            ...input.config.initialIab ?? {},
+            cmpId: input.config.initialIab?.cmpId ?? iab.cmpId ?? null,
+            enabled: true,
+            gvl
+        }
+    };
+};
+const server_snapshotFromConfig = function(config) {
+    const kernel = createConsentKernel(config);
+    const snapshot = kernel.getServerSnapshot();
+    kernel.dispose();
+    return snapshot;
+};
+const server_resolveConsentContext = async function(input) {
+    const { headers, options } = input;
+    const { config: base, inputs } = server_readInitialConsentConfig(headers, options);
+    const translations = server_resolveTranslations(options, inputs);
+    let config = {
+        ...base,
+        initialTranslations: translations
+    };
+    if (!input.skipPrefetch) config = 'hosted' === options.mode.type ? await server_prefetchHosted({
+        backendURL: options.mode.url,
+        base: config,
+        configuredHeaders: options.mode.headers,
+        fetch: input.fetch,
+        headers,
+        options,
+        url: input.url
+    }) : await server_prefetchLocal({
+        base: config,
+        fetch: input.fetch,
+        headers,
+        inputs,
+        onBackgroundRevalidate: input.onBackgroundRevalidate,
+        options,
+        translations,
+        url: input.url
+    });
+    config = await server_withResolvedGvl({
+        config,
+        fetch: input.fetch,
+        language: translations.language.split('-')[0] || 'en',
+        options
+    });
+    config.initialPolicyPending = void 0 === config.initialPolicyResolution;
+    const snapshot = server_snapshotFromConfig(config);
+    return {
+        config,
+        decision: snapshot.resolution,
+        hasConsentUi: 'matched' === snapshot.resolution.status && ('none' !== snapshot.policyRule.prompt || snapshot.policyRule.rights.length > 0),
+        hasPolicy: 'matched' === snapshot.resolution.status,
+        inputs,
+        options,
+        shouldShowBanner: !snapshot.policyPending && 'banner' === snapshot.activeUI,
+        snapshot
+    };
+};
+const server_buildConfigScript = function(config) {
+    const json = JSON.stringify(config ?? {}).replace(/</gu, '\\u003c');
+    return `window.__c15tAstroConfig=${json};`;
+};
+const server_buildColorSchemeScript = function(colorScheme) {
+    if ('light' === colorScheme) return '';
+    if ('dark' === colorScheme) return "document.documentElement.classList.add('c15t-dark');";
+    return "try{document.documentElement.classList.toggle('c15t-dark',matchMedia('(prefers-color-scheme:dark)').matches)}catch(e){}";
+};
+const emitted = new WeakSet();
+const server_markConfigEmitted = function(locals) {
+    if (emitted.has(locals)) return false;
+    emitted.add(locals);
+    return true;
+};
+export { buildPrefetchScript, server_buildColorSchemeScript as buildColorSchemeScript, server_buildConfigScript as buildConfigScript, server_markConfigEmitted as markConfigEmitted, server_readInitialConsentConfig as readInitialConsentConfig, server_resolveConsentContext as resolveConsentContext, server_resolveTranslations as resolveTranslations, server_snapshotFromConfig as snapshotFromConfig };

package/dist/styles.css

@@ -0,0 +1,2 @@
+@import "@c15t/ui/styles.css";
+

package/dist/ui/adapter.js

@@ -0,0 +1,37 @@
+const surfaces = new Map();
+const adapter_registerDialogSurface = function(name, load) {
+    surfaces.set(name, load);
+};
+const adapter_requireDialogSurface = function(name) {
+    const load = surfaces.get(name);
+    if (!load) throw new Error(`@c15t/astro: no ${name} dialog surface registered. The integration registers it from the injected page script, so this usually means c15t() is missing from astro.config, or the page was rendered with \`middleware: false\` and no boot script.`);
+    return load;
+};
+const registry = new Map();
+const pending = new Map();
+const adapter_registerDialogAdapter = function(name, load) {
+    registry.set(name, load);
+    pending.delete(name);
+};
+const adapter_resetDialogRegistriesForTest = function() {
+    registry.clear();
+    surfaces.clear();
+    pending.clear();
+};
+const adapter_loadDialogAdapter = async function(name) {
+    const memo = pending.get(name);
+    if (memo) return await memo;
+    const load = registry.get(name);
+    if (!load) throw new Error(`@c15t/astro: no dialog adapter registered for ui: ${JSON.stringify(name)}. The integration registers the configured adapter from the injected page script; register your own with registerDialogAdapter().`);
+    const loading = (async ()=>{
+        try {
+            return await load();
+        } catch (error) {
+            pending.delete(name);
+            throw error;
+        }
+    })();
+    pending.set(name, loading);
+    return await loading;
+};
+export { adapter_loadDialogAdapter as loadDialogAdapter, adapter_registerDialogAdapter as registerDialogAdapter, adapter_registerDialogSurface as registerDialogSurface, adapter_requireDialogSurface as requireDialogSurface, adapter_resetDialogRegistriesForTest as resetDialogRegistriesForTest };

package/dist/ui/provider-props.js

@@ -0,0 +1,12 @@
+const provider_props_buildProviderProps = function(runtime, options) {
+    return {
+        options: {
+            consentCategories: options.consentCategories,
+            legalLinks: options.legalLinks,
+            presentation: options.presentation,
+            theme: options.theme
+        },
+        runtime
+    };
+};
+export { provider_props_buildProviderProps as buildProviderProps };

package/dist/ui/react.js

@@ -0,0 +1,34 @@
+import { requireDialogSurface } from "./adapter.js";
+import { buildProviderProps } from "./provider-props.js";
+const reactDialogAdapter = {
+    async mount (context) {
+        const [{ createElement }, { createRoot }, surface] = await Promise.all([
+            import("react"),
+            import("react-dom/client"),
+            requireDialogSurface('react')()
+        ]);
+        const root = createRoot(context.target);
+        root.render(createElement(surface.default, {
+            ...buildProviderProps(context.runtime, context.options),
+            kind: context.kind,
+            tab: context.tab
+        }));
+        return {
+            close () {
+                context.runtime.kernel.set.activeUI('none');
+            },
+            destroy () {
+                root.unmount();
+            }
+        };
+    },
+    name: 'react',
+    async preload () {
+        await Promise.all([
+            import("react"),
+            import("react-dom/client"),
+            requireDialogSurface('react')()
+        ]);
+    }
+};
+export { reactDialogAdapter };