@c15t/browser 3.0.0-alpha.0

package/dist/925.js

@@ -0,0 +1,649 @@
+import { allConsentNames, c15tProtocolHeaders, createHostedTransport, custom, evaluateConsent, hosted as core_hosted, mapInitOutputToInitResponse, policyRulePresets } from "@c15t/core";
+import { createConsentRuntime } from "@c15t/core/runtime";
+import { recommendedPolicyRules, resolveInitFromManifest, resolvePolicyRules, writePolicyResolutionWire } from "@c15t/schema/types";
+import { enTranslations } from "@c15t/translations";
+const deferred_createDeferred = function() {
+    const { withResolvers } = Promise;
+    if ('function' == typeof withResolvers) return withResolvers.call(Promise);
+    let resolveFn = ()=>{};
+    let rejectFn = ()=>{};
+    const promise = new Promise((resolve, reject)=>{
+        resolveFn = resolve;
+        rejectFn = reject;
+    });
+    return {
+        promise,
+        reject: rejectFn,
+        resolve: resolveFn
+    };
+};
+const CATEGORY_ATTRIBUTE = 'data-c15t-category';
+const ACTIVATED_ATTRIBUTE = 'data-c15t-activated';
+const COPIED_ATTRIBUTES = [
+    'src',
+    'async',
+    'defer',
+    'crossorigin',
+    'integrity',
+    'referrerpolicy',
+    'id'
+];
+const gated_scripts_createReplacement = function(element) {
+    const replacement = element.ownerDocument.createElement("script");
+    for (const name of COPIED_ATTRIBUTES){
+        const value = element.getAttribute(name);
+        if (null !== value) replacement.setAttribute(name, value);
+    }
+    replacement.async = element.hasAttribute('async');
+    replacement.nonce = element.nonce;
+    for (const attribute of Array.from(element.attributes))if (attribute.name.startsWith('data-') && attribute.name !== ACTIVATED_ATTRIBUTE) replacement.setAttribute(attribute.name, attribute.value);
+    replacement.setAttribute(ACTIVATED_ATTRIBUTE, 'true');
+    if (!element.hasAttribute('src')) replacement.textContent = element.textContent;
+    return replacement;
+};
+const gated_scripts_isAllowed = function(element, snapshot) {
+    const category = element.getAttribute(CATEGORY_ATTRIBUTE);
+    if (!category) return false;
+    if (!allConsentNames.includes(category)) {
+        console.warn(`@c15t/browser: unknown ${CATEGORY_ATTRIBUTE} "${category}". Expected one of ${allConsentNames.join(', ')}.`);
+        element.setAttribute(ACTIVATED_ATTRIBUTE, 'invalid');
+        return false;
+    }
+    return evaluateConsent({
+        category: category
+    }, snapshot);
+};
+const pendingScripts = new WeakMap();
+const trackPendingScript = (script)=>{
+    const pending = {
+        subscribers: new Set()
+    };
+    const { ownerDocument } = script;
+    const settled = ()=>{
+        script.removeEventListener('load', settled);
+        script.removeEventListener('error', settled);
+        pendingScripts.delete(ownerDocument);
+        const subscribers = Array.from(pending.subscribers);
+        pending.subscribers.clear();
+        for (const resume of subscribers)resume();
+    };
+    pendingScripts.set(ownerDocument, pending);
+    script.addEventListener('load', settled);
+    script.addEventListener('error', settled);
+    return pending;
+};
+const gated_scripts_createGatedScriptActivator = function(getSnapshot, root) {
+    let disposed = false;
+    let scanning = false;
+    let waiting = null;
+    let stopWaiting = null;
+    const scan = ()=>{
+        if (disposed || scanning) return 0;
+        scanning = true;
+        const waitFor = (pending)=>{
+            if (waiting === pending) return;
+            stopWaiting?.();
+            waiting = pending;
+            const resume = ()=>{
+                if (waiting !== pending) return;
+                waiting = null;
+                stopWaiting = null;
+                scan();
+            };
+            pending.subscribers.add(resume);
+            stopWaiting = ()=>pending.subscribers.delete(resume);
+        };
+        let activated = 0;
+        try {
+            const selector = `script[type="text/plain"][${CATEGORY_ATTRIBUTE}]:not([${ACTIVATED_ATTRIBUTE}])`;
+            const elements = (root ?? document).querySelectorAll(selector);
+            for (const element of elements){
+                if (disposed) break;
+                if (!element.isConnected || !gated_scripts_isAllowed(element, getSnapshot())) continue;
+                const external = element.hasAttribute('src');
+                const asynchronous = external && element.hasAttribute('async');
+                const pending = pendingScripts.get(element.ownerDocument);
+                if (pending && !asynchronous) {
+                    waitFor(pending);
+                    continue;
+                }
+                const replacement = gated_scripts_createReplacement(element);
+                if (external && !asynchronous) waitFor(trackPendingScript(replacement));
+                element.setAttribute(ACTIVATED_ATTRIBUTE, 'true');
+                element.replaceWith(replacement);
+                activated += 1;
+            }
+        } finally{
+            scanning = false;
+        }
+        return activated;
+    };
+    return {
+        dispose () {
+            disposed = true;
+            stopWaiting?.();
+            stopWaiting = null;
+            waiting = null;
+        },
+        scan
+    };
+};
+const standaloneActivators = new WeakMap();
+const gated_scripts_activateGatedScripts = function(snapshot, root = document) {
+    let state = standaloneActivators.get(root);
+    if (!state) {
+        const current = {
+            activator: gated_scripts_createGatedScriptActivator(()=>current.snapshot, root),
+            snapshot
+        };
+        state = current;
+        standaloneActivators.set(root, state);
+    }
+    state.snapshot = snapshot;
+    return state.activator.scan();
+};
+const manifest_trimSlash = function(url) {
+    return url.endsWith('/') ? url.slice(0, -1) : url;
+};
+const manifest_deriveBackendURL = function(options) {
+    if (void 0 !== options.backendURL) return manifest_trimSlash(options.backendURL);
+    if (!options.manifestURL) return;
+    const withoutQuery = options.manifestURL.split(/[?#]/u)[0] ?? options.manifestURL;
+    const trimmed = manifest_trimSlash(withoutQuery);
+    if (!trimmed.endsWith('/manifest')) return;
+    try {
+        const parsed = new URL(trimmed, 'https://c15t.invalid');
+        if (![
+            'http:',
+            'https:'
+        ].includes(parsed.protocol) || !parsed.pathname.endsWith('/manifest')) return;
+    } catch  {
+        return;
+    }
+    return trimmed.slice(0, -9);
+};
+const manifest_manifestNeedsLocation = function(manifest) {
+    if (manifest.defaults?.disableGeoLocation) return false;
+    const packs = manifest.policyPacks ?? [];
+    if (0 === packs.length) return true;
+    return packs.some((pack)=>(pack.match.countries?.length ?? 0) > 0 || (pack.match.regions?.length ?? 0) > 0);
+};
+const manifest_readGlobalPrivacyControl = function() {
+    if ("u" < typeof navigator) return;
+    const value = navigator.globalPrivacyControl;
+    return 'boolean' == typeof value ? value : void 0;
+};
+const manifest_mergeInputs = function(base, overrides) {
+    const language = overrides.language ?? base?.language ?? ("u" < typeof navigator ? 'en' : navigator.language);
+    return {
+        country: overrides.country ?? base?.country ?? null,
+        gpc: overrides.gpc ?? base?.gpc ?? manifest_readGlobalPrivacyControl(),
+        language,
+        region: overrides.region ?? base?.region ?? null
+    };
+};
+const browserBaseTranslations = {
+    en: enTranslations
+};
+const manifest_manifest = function(options) {
+    if (!(options.manifest || options.manifestURL)) throw new Error('@c15t/browser: manifest() needs `manifest` or `manifestURL`.');
+    const backendURL = manifest_deriveBackendURL(options);
+    if (void 0 === backendURL) throw new Error('@c15t/browser: manifest() needs `backendURL` unless `manifestURL` ends in `/manifest`. Pass the consent API URL, or an empty string for this origin.');
+    const hosted = createHostedTransport({
+        backendURL,
+        fetch: options.fetch
+    });
+    let cached;
+    const fetchManifest = async function() {
+        const fetchImpl = options.fetch ?? globalThis.fetch;
+        const response = await fetchImpl(options.manifestURL, {
+            headers: {
+                ...c15tProtocolHeaders
+            }
+        });
+        if (!response.ok) throw new Error(`@c15t/browser: manifest request failed with ${response.status}`);
+        return await response.json();
+    };
+    const loadManifest = async function() {
+        if (options.manifest) return options.manifest;
+        cached ??= fetchManifest();
+        try {
+            return await cached;
+        } catch (error) {
+            cached = void 0;
+            throw error;
+        }
+    };
+    const transport = {
+        identify: hosted.identify,
+        async init (ctx) {
+            const resolved = await loadManifest();
+            const inputs = manifest_mergeInputs(options.inputs, ctx.overrides);
+            if (manifest_manifestNeedsLocation(resolved) && (!inputs.country || !inputs.region && resolved.policyPacks?.some((pack)=>(pack.match.regions?.length ?? 0) > 0))) return hosted.init(ctx);
+            const output = resolveInitFromManifest(resolved, inputs, {
+                baseTranslations: browserBaseTranslations
+            });
+            return mapInitOutputToInitResponse(output, {});
+        },
+        loadSubjectRecord: hosted.loadSubjectRecord,
+        recordPrivacyOptOut: hosted.recordPrivacyOptOut,
+        save: hosted.save
+    };
+    return Object.assign(()=>transport, {
+        kind: 'custom'
+    });
+};
+const offline_offline = function(options = {}) {
+    return Object.assign((context)=>({
+            init: ({ overrides })=>Promise.resolve({
+                    policyResolution: writePolicyResolutionWire(resolvePolicyRules({
+                        countryCode: overrides.country ?? null,
+                        iabEnabled: context.iabEnabled,
+                        regionCode: overrides.region ?? null,
+                        rules: options.policyRules ?? recommendedPolicyRules({
+                            iab: context.iabEnabled
+                        })
+                    })),
+                    translations: context.translations
+                })
+        }), {
+        kind: 'offline'
+    });
+};
+const ACTION_ATTRIBUTE = 'data-c15t-action';
+const PREFERENCES_HASH = '#c15t-preferences';
+const PAGE_ACTIONS = new Set([
+    'accept',
+    'reject',
+    'customize',
+    'close',
+    'dismiss',
+    'banner'
+]);
+const client_resolveRules = function(policyRules) {
+    if (!policyRules) return;
+    return policyRules.map((entry)=>{
+        if ('string' != typeof entry) return entry;
+        const preset = Object.hasOwn(policyRulePresets, entry) ? policyRulePresets[entry] : void 0;
+        if ('function' != typeof preset) throw new Error(`@c15t/browser: unknown policy preset "${entry}". Expected one of ${Object.keys(policyRulePresets).join(', ')}.`);
+        return preset();
+    });
+};
+const client_defaultModeName = function(options) {
+    if (options.manifest || options.manifestURL) return 'manifest';
+    return options.backendURL ? 'hosted' : 'offline';
+};
+const client_resolveMode = function(options) {
+    if ('function' == typeof options.mode) {
+        const { kind } = options.mode;
+        return {
+            factory: options.mode,
+            name: 'hosted' === kind || 'offline' === kind ? kind : 'custom'
+        };
+    }
+    const name = options.mode ?? client_defaultModeName(options);
+    if ('hosted' === name) {
+        if (!options.backendURL) throw new Error("@c15t/browser: hosted mode needs `backendURL` (or data-backend-url on the script tag).");
+        return {
+            factory: core_hosted({
+                url: options.backendURL
+            }),
+            name
+        };
+    }
+    if ('manifest' === name) return {
+        factory: manifest_manifest({
+            backendURL: options.backendURL,
+            inputs: options.overrides,
+            manifest: options.manifest,
+            manifestURL: options.manifestURL
+        }),
+        name
+    };
+    return {
+        factory: offline_offline({
+            policyRules: client_resolveRules(options.policyRules)
+        }),
+        name
+    };
+};
+const client_resolveConsentCategories = function(snapshot, configured) {
+    const available = [
+        'necessary',
+        ...snapshot.policyRule.scope
+    ];
+    if (0 === configured.length) return Array.from(available);
+    const allowed = new Set(available);
+    return Array.from(new Set([
+        'necessary',
+        ...configured.filter((category)=>allowed.has(category))
+    ]));
+};
+const client_dispatchDocumentEvent = function(name, detail) {
+    if ("u" < typeof document) return;
+    document.dispatchEvent(new CustomEvent(`c15t:${name}`, {
+        detail
+    }));
+};
+const client_resolvePageAction = function(target) {
+    if (!(target instanceof Element)) return null;
+    const actionElement = target.closest(`[${ACTION_ATTRIBUTE}]`);
+    const action = actionElement?.getAttribute(ACTION_ATTRIBUTE);
+    if (action && PAGE_ACTIONS.has(action)) return action;
+    const link = target.closest('a[href]');
+    const href = link?.getAttribute('href') ?? '';
+    return href.endsWith(PREFERENCES_HASH) ? 'customize' : null;
+};
+const client_createConsentClient = function(options = {}, context = {}) {
+    if (options.iab && false !== options.iab.enabled && !context.createIAB) throw new Error('@c15t/browser: IAB requires the @c15t/browser/iab entry.');
+    const mode = client_resolveMode(options);
+    const configuredCategories = options.consentCategories ?? [];
+    const runtime = createConsentRuntime({
+        callbacks: options.callbacks,
+        consentCategories: options.consentCategories,
+        createIAB: context.createIAB,
+        enabled: options.enabled,
+        i18n: options.i18n,
+        iab: context.createIAB ? options.iab ?? {
+            enabled: true
+        } : void 0,
+        iframeBlocker: options.iframeBlocker,
+        mode: mode.factory,
+        networkBlocker: options.networkBlocker,
+        overrides: options.overrides,
+        pkg: options.pkg ?? context.pkg ?? '@c15t/browser',
+        policyRules: client_resolveRules(options.policyRules),
+        prefetch: options.prefetch,
+        presentation: options.presentation,
+        scripts: options.scripts,
+        storageConfig: options.storageConfig,
+        user: options.user,
+        windowDebug: false
+    });
+    const { kernel } = runtime;
+    const gatedScripts = gated_scripts_createGatedScriptActivator(()=>kernel.getSnapshot());
+    let startingRuntime = false;
+    let drainingRuntimeEvents = false;
+    const pendingRuntimeEvents = [];
+    const listeners = {
+        consent: new Set(),
+        error: new Set(),
+        ready: new Set(),
+        ui: new Set()
+    };
+    const dispatch = function(event, payload) {
+        for (const listener of listeners[event])listener(payload);
+        client_dispatchDocumentEvent(event, payload);
+    };
+    const emit = function(event, payload) {
+        if (startingRuntime || drainingRuntimeEvents) return void pendingRuntimeEvents.push(()=>dispatch(event, payload));
+        dispatch(event, payload);
+    };
+    const ready = deferred_createDeferred();
+    let readySnapshot = null;
+    const completeReady = function(snapshot) {
+        if (readySnapshot) return;
+        readySnapshot = snapshot;
+        ready.resolve(snapshot);
+        dispatch('ready', snapshot);
+    };
+    const markReady = function(snapshot) {
+        if (startingRuntime || drainingRuntimeEvents) return void pendingRuntimeEvents.push(()=>completeReady(snapshot));
+        completeReady(snapshot);
+    };
+    let ui = null;
+    let started = false;
+    let disposed = false;
+    let detachPageActions = null;
+    const initial = kernel.getSnapshot();
+    let lastActiveUI = initial.activeUI;
+    let lastConsents = initial.effectivePermissions;
+    let lastHasConsented = initial.explicitChoice;
+    const disposers = [
+        gatedScripts.dispose,
+        kernel.events.on('init:applied', ({ snapshot })=>{
+            markReady(snapshot);
+        }),
+        kernel.events.on('command:error', ({ error })=>{
+            emit('error', error);
+        }),
+        kernel.subscribe((snapshot)=>{
+            if (snapshot.effectivePermissions !== lastConsents || snapshot.explicitChoice !== lastHasConsented) {
+                lastConsents = snapshot.effectivePermissions;
+                lastHasConsented = snapshot.explicitChoice;
+                if (started && !startingRuntime) gatedScripts.scan();
+                emit('consent', snapshot);
+            }
+            if (snapshot.activeUI !== lastActiveUI) {
+                lastActiveUI = snapshot.activeUI;
+                emit('ui', snapshot.activeUI);
+            }
+        })
+    ];
+    const categories = function() {
+        return client_resolveConsentCategories(kernel.getSnapshot(), configuredCategories);
+    };
+    let navigation = 0;
+    const closeSurfaces = ()=>{
+        navigation += 1;
+        kernel.set.activeUI('none');
+    };
+    const openDialog = ()=>{
+        navigation += 1;
+        kernel.set.activeUI('dialog');
+    };
+    const showBanner = ()=>{
+        navigation += 1;
+        kernel.set.activeUI('banner');
+    };
+    const saveSelection = async (input)=>{
+        navigation += 1;
+        const current = navigation;
+        const surface = kernel.getSnapshot().activeUI;
+        const { fingerprint } = kernel.getSnapshot().evaluationPolicy.choice;
+        const pending = kernel.commands.save(input, {
+            categories: categories()
+        });
+        kernel.set.activeUI(surface);
+        const result = await pending;
+        if (result.ok && current === navigation && fingerprint === kernel.getSnapshot().evaluationPolicy.choice.fingerprint) kernel.set.activeUI('none' === kernel.getSnapshot().promptRequirement.kind ? 'none' : 'banner');
+        return result;
+    };
+    const saveIAB = async (blanket)=>{
+        const handle = runtime.iab;
+        if (!handle || !kernel.getSnapshot().iab?.gvl || 'iab' !== kernel.getSnapshot().policyRule.model) {
+            emit('error', new Error('IAB privacy settings are not ready.'));
+            return {
+                ok: false
+            };
+        }
+        navigation += 1;
+        const current = navigation;
+        const snapshot = kernel.getSnapshot();
+        try {
+            if (true === blanket) handle.acceptAll();
+            if (false === blanket) handle.rejectAll();
+            await handle.save();
+            const next = kernel.getSnapshot();
+            if (!next.iab?.authority || next.evaluationPolicy.choice.fingerprint !== snapshot.evaluationPolicy.choice.fingerprint) return {
+                ok: false
+            };
+            if (current === navigation) kernel.set.activeUI('none');
+            return {
+                ok: true
+            };
+        } catch (error) {
+            if (current === navigation) kernel.set.activeUI(snapshot.activeUI);
+            emit('error', error instanceof Error ? error : new Error(String(error)));
+            return {
+                ok: false
+            };
+        }
+    };
+    const acceptAll = ()=>'iab' === kernel.getSnapshot().policyRule.model ? saveIAB(true) : saveSelection('all');
+    const rejectAll = ()=>'iab' === kernel.getSnapshot().policyRule.model ? saveIAB(false) : saveSelection('none');
+    const onPageClick = function(event) {
+        const action = client_resolvePageAction(event.target);
+        if (!action) return;
+        event.preventDefault();
+        switch(action){
+            case 'accept':
+                acceptAll();
+                break;
+            case 'reject':
+                rejectAll();
+                break;
+            case 'customize':
+                openDialog();
+                break;
+            case 'dismiss':
+                kernel.commands.dismissNotice();
+                break;
+            case 'banner':
+                showBanner();
+                break;
+            default:
+                closeSurfaces();
+        }
+    };
+    const client = {
+        acceptAll,
+        closeDialog: closeSurfaces,
+        get consentCategories () {
+            return categories();
+        },
+        dismissNotice: ()=>kernel.commands.dismissNotice(),
+        dispose () {
+            if (disposed) return;
+            disposed = true;
+            navigation += 1;
+            started = false;
+            detachPageActions?.();
+            detachPageActions = null;
+            ui?.destroy();
+            ui = null;
+            for (const dispose of disposers.reverse())dispose();
+            disposers.length = 0;
+            runtime.dispose();
+        },
+        getSnapshot () {
+            return kernel.getSnapshot();
+        },
+        has (condition) {
+            const snapshot = kernel.getSnapshot();
+            return evaluateConsent({
+                category: condition
+            }, snapshot);
+        },
+        hasConsented () {
+            return null !== kernel.getSnapshot().explicitChoice;
+        },
+        async identify (user) {
+            await runtime.identify(user);
+        },
+        kernel,
+        mode: mode.name,
+        mountUI (uiOptions) {
+            if (!context.mountUI) throw new Error('@c15t/browser: this build is headless. Load c15t.js, or import `mountConsentUI` from "@c15t/browser".');
+            ui?.destroy();
+            ui = context.mountUI(client, uiOptions ?? (false === options.ui ? void 0 : options.ui));
+            return ui;
+        },
+        on (event, listener) {
+            const set = listeners[event];
+            set.add(listener);
+            if ('ready' === event && readySnapshot) listener(readySnapshot);
+            if ('ui' === event && readySnapshot) listener(kernel.getSnapshot().activeUI);
+            return function() {
+                set.delete(listener);
+            };
+        },
+        openDialog,
+        options,
+        ready () {
+            return ready.promise;
+        },
+        rejectAll,
+        runtime,
+        save (consents) {
+            if ('iab' === kernel.getSnapshot().policyRule.model) {
+                emit('error', new Error('Use saveIAB() to confirm IAB preferences.'));
+                return Promise.resolve({
+                    ok: false
+                });
+            }
+            const allowed = new Set(categories());
+            return saveSelection(Object.fromEntries(Object.entries(consents).filter(([name])=>allowed.has(name))));
+        },
+        saveIAB: ()=>saveIAB(),
+        setLanguage (code) {
+            kernel.set.language(code);
+            kernel.commands.init();
+        },
+        setOverrides (overrides) {
+            runtime.setOverrides(overrides);
+        },
+        showBanner,
+        start () {
+            if (started || disposed || "u" < typeof document) return;
+            started = true;
+            if (context.onStart && false !== options.enabled) disposers.push(context.onStart(options));
+            startingRuntime = true;
+            try {
+                runtime.start();
+            } finally{
+                startingRuntime = false;
+            }
+            drainingRuntimeEvents = true;
+            try {
+                for (const notify of pendingRuntimeEvents){
+                    if (disposed) break;
+                    notify();
+                }
+            } finally{
+                drainingRuntimeEvents = false;
+                pendingRuntimeEvents.length = 0;
+            }
+            if (disposed) return;
+            gatedScripts.scan();
+            if (disposed) return;
+            const observer = new MutationObserver(()=>gatedScripts.scan());
+            observer.observe(document.documentElement, {
+                childList: true,
+                subtree: true
+            });
+            disposers.push(()=>observer.disconnect());
+            if (false === options.enabled) {
+                markReady(kernel.getSnapshot());
+                if (disposed) return;
+            }
+            document.addEventListener('click', onPageClick);
+            detachPageActions = ()=>{
+                document.removeEventListener('click', onPageClick);
+            };
+            if (false === options.ui || !context.mountUI) return;
+            const mount = function() {
+                if (!(disposed || ui)) ui = client.mountUI();
+            };
+            if (document.body) return void mount();
+            document.addEventListener('DOMContentLoaded', mount, {
+                once: true
+            });
+            disposers.push(()=>{
+                document.removeEventListener('DOMContentLoaded', mount);
+            });
+        },
+        get started () {
+            return started;
+        },
+        subscribe (listener) {
+            return kernel.subscribe(listener);
+        },
+        get ui () {
+            return ui;
+        }
+    };
+    return client;
+};
+const version = '3.0.0-alpha.0';
+export { ACTION_ATTRIBUTE, ACTIVATED_ATTRIBUTE, CATEGORY_ATTRIBUTE, PREFERENCES_HASH, client_createConsentClient, client_resolveRules as resolveRules, core_hosted as hosted, custom, gated_scripts_activateGatedScripts as activateGatedScripts, manifest_manifest as manifest, manifest_manifestNeedsLocation as manifestNeedsLocation, offline_offline as offline, version };