@nuxt/scripts 1.0.0-rc.1 → 1.0.0-rc.10

package/dist/runtime/registry/bing-uet.d.ts

@@ -1,20 +1,198 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
 import { BingUetOptions } from './schemas.js';
 export { BingUetOptions };
 export type BingUetInput = RegistryScriptInput<typeof BingUetOptions, true, false>;
-export interface BingUetApi {
-    uetq: {
-        push: (event: string | Record<string, any>) => void;
+export type BingUetConsentStatus = 'granted' | 'denied';
+export interface BingUetConsentOptions {
+    /**
+     * Controls storage of advertising identifiers. Currently the only field UET honors.
+     */
+    ad_storage?: BingUetConsentStatus;
+}
+export type BingUetEventName = 'page_view' | 'screen_view' | 'login' | 'sign_up' | 'subscribe' | 'start_trial' | 'lead' | 'generate_lead' | 'submit_lead_form' | 'contact' | 'search' | 'view_search_results' | 'select_content' | 'share' | 'exception' | 'find_location' | 'book_appointment' | 'get_route' | 'view_item' | 'view_item_list' | 'view_promotion' | 'add_to_cart' | 'remove_from_cart' | 'add_to_wishlist' | 'add_payment_info' | 'begin_checkout' | 'checkout_progress' | 'set_checkout_option' | 'purchase' | 'refund' | (string & {});
+export interface BingUetItem {
+    id?: string;
+    name?: string;
+    brand?: string;
+    category?: string;
+    variant?: string;
+    price?: number;
+    quantity?: number;
+    list_name?: string;
+    list_position?: number;
+    creative_name?: string;
+    creative_slot?: string;
+    location_id?: string;
+    [key: string]: any;
+}
+export interface BingUetPromotion {
+    id?: string;
+    name?: string;
+    creative_name?: string;
+    creative_slot?: string;
+    [key: string]: any;
+}
+export interface BingUetEventParams {
+    /** Event category (beacon shortcut). */
+    ec?: string;
+    /** Event action (beacon shortcut). */
+    ea?: string;
+    /** Event label (beacon shortcut). */
+    el?: string;
+    /** Event value, numeric (beacon shortcut). */
+    ev?: number;
+    /** Goal category / goal completion. */
+    gc?: string;
+    /** Goal value. */
+    gv?: number;
+    /** Long-form alias for `ec`. */
+    event_category?: string;
+    /** Long-form alias for `ea`. */
+    event_action?: string;
+    /** Long-form alias for `el`. */
+    event_label?: string;
+    /** Long-form alias for `ev`. */
+    event_value?: number;
+    /** Unique event identifier (dedup). */
+    event_id?: string;
+    /** Variable revenue amount. */
+    revenue_value?: number;
+    /** ISO 4217 currency code (e.g. "USD"). */
+    currency?: string;
+    /** Unique order/transaction ID (dedup). */
+    transaction_id?: string;
+    /** Ecommerce items. */
+    items?: BingUetItem[];
+    /** Promotions associated with the event. */
+    promotions?: BingUetPromotion[];
+    /** Sign-up/login method (e.g. "Google"). */
+    method?: string;
+    coupon?: string;
+    tax?: number;
+    shipping?: number;
+    affiliation?: string;
+    /** Search query. */
+    search_term?: string;
+    content_type?: string;
+    content_id?: string;
+    checkout_step?: number;
+    checkout_option?: string;
+    description?: string;
+    name?: string;
+    screen_name?: string;
+    /** Whether an exception is fatal. */
+    fatal?: boolean;
+    /** Flags a new customer conversion. */
+    new_customer?: boolean | number;
+    /** Retail vertical: product ID. */
+    ecomm_prodid?: string | string[];
+    /** Retail vertical: page type. */
+    ecomm_pagetype?: 'home' | 'searchresults' | 'category' | 'product' | 'cart' | 'purchase' | 'other' | (string & {});
+    ecomm_totalvalue?: number;
+    ecomm_category?: string | string[];
+    ecomm_query?: string;
+    /** Override page path. */
+    page_path?: string;
+    /** Override page title. */
+    page_title?: string;
+    /** Override full page URL. */
+    page_location?: string;
+    [key: string]: any;
+}
+export interface BingUetEnhancedConversionsPid {
+    /** SHA-256 hashed email (lowercase, trimmed). Alias: `email`. */
+    em?: string;
+    /** SHA-256 hashed phone (E.164 digits only). Alias: `phone_number`. */
+    ph?: string;
+    /** Long-form alias for `em`. */
+    email?: string;
+    /** Long-form alias for `ph`. */
+    phone_number?: string;
+    [key: string]: any;
+}
+export interface BingUetSetParams {
+    /** Partner identifiers for enhanced conversions. */
+    pid?: BingUetEnhancedConversionsPid;
+    page_path?: string;
+    page_title?: string;
+    page_location?: string;
+    [key: string]: any;
+}
+export interface BingUetTcfConfig {
+    /** Enable TCF v2.0 auto-consent handling (Microsoft vendorId 1126). */
+    enabled?: boolean;
+    [key: string]: any;
+}
+export interface BingUetConstructorOptions {
+    /** UET tag ID. */
+    ti: string;
+    /** Alternate tag ID field (same effect as `ti`). */
+    tagId?: string;
+    /** Auto-fire pageLoad on SPA route changes. */
+    enableAutoSpaTracking?: boolean;
+    /** Enable TCF v2.0 auto-consent handling. */
+    enableAutoConsent?: boolean;
+    /** Suppress automatic page_view on load. */
+    disableAutoPageView?: boolean;
+    /** Disable the UET container entirely. */
+    disableContainer?: boolean;
+    /** Disable writing the UET visitor ID cookie. */
+    disableUetVid?: boolean;
+    /** Disable visibility (tab focus/blur) events. */
+    disableVisibilityEvents?: boolean;
+    /** Defer loading the beacon. */
+    deferLoad?: boolean;
+    /** Strip query strings from reported URLs. */
+    removeQueryFromUrls?: boolean;
+    /** Store conversion tracking cookies. */
+    storeConvTrackCookies?: boolean;
+    /** Cookie domain. */
+    cookieDomain?: string;
+    /** Cookie flags (e.g. "SameSite=None; Secure"). */
+    cookieFlags?: string;
+    /** Enable MS DNS cookie. */
+    msDnsCookie?: boolean;
+    /** UID cookie name. */
+    uidCookie?: string;
+    /** Error beacon verbosity level. */
+    errorBeaconLevel?: number;
+    /** Microsoft Clarity project ID for integration. */
+    clarityProjectId?: string;
+    /** When true, reads `window.enhanced_conversion_data` for gtag-style enhanced conversions. */
+    gtagPid?: boolean;
+    /** Beacon protocol version. */
+    Ver?: 1 | 2;
+    /** Associated advertiser ID. */
+    advertiserId?: string;
+    /** Source tag for GTM integration. */
+    gtmTagSource?: string;
+    /** Queue reference, typically `window.uetq`. */
+    q?: any[];
+    [key: string]: any;
+}
+export interface BingUetQueue {
+    push: {
+        (event: BingUetEventParams): void;
+        (command: 'pageLoad'): void;
+        (command: 'event', eventName: BingUetEventName, eventParams?: BingUetEventParams): void;
+        (command: 'consent', action: 'default' | 'update', consentParams: BingUetConsentOptions): void;
+        (command: 'set', params: BingUetSetParams): void;
+        (command: 'config', target: 'tcf', params: BingUetTcfConfig): void;
     };
 }
+export interface BingUetApi {
+    uetq: BingUetQueue;
+}
 declare global {
     interface Window {
-        UET: new (options: {
-            ti: string;
-            enableAutoSpaTracking?: boolean;
-            q?: any[];
-        }) => BingUetApi['uetq'];
-        uetq: any[] | BingUetApi['uetq'];
+        UET: new (options: BingUetConstructorOptions) => BingUetQueue;
+        uetq: any[] | BingUetQueue;
     }
 }
-export declare function useScriptBingUet<T extends BingUetApi>(_options?: BingUetInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export interface BingUetConsent {
+    /** Push `['consent','update', state]` with the `ad_storage` signal. */
+    update: (state: BingUetConsentOptions) => void;
+}
+export declare function useScriptBingUet<T extends BingUetApi>(_options?: BingUetInput & {
+    onBeforeUetStart?: (uetq: BingUetQueue) => void;
+}): UseScriptContext<T, BingUetConsent>;

package/dist/runtime/registry/bing-uet.js

@@ -2,7 +2,7 @@ import { useRegistryScript } from "../utils.js";
 import { BingUetOptions } from "./schemas.js";
 export { BingUetOptions };
 export function useScriptBingUet(_options) {
-  return useRegistryScript("bingUet", (options) => ({
+  const instance = useRegistryScript("bingUet", (options) => ({
     scriptInput: {
       src: "https://bat.bing.com/bat.js",
       crossorigin: false
@@ -23,7 +23,21 @@ export function useScriptBingUet(_options) {
       }
     },
     clientInit: import.meta.server ? void 0 : () => {
-      window.uetq = window.uetq || [];
+      const uetq = window.uetq || [];
+      window.uetq = uetq;
+      if (options?.defaultConsent) {
+        uetq.push("consent", "default", options.defaultConsent);
+      }
+      _options?.onBeforeUetStart?.(uetq);
     }
   }), _options);
+  if (import.meta.client && !instance.consent) {
+    instance.consent = {
+      update: (state) => {
+        ;
+        instance.proxy.uetq.push("consent", "update", state);
+      }
+    };
+  }
+  return instance;
 }

package/dist/runtime/registry/bluesky-embed.d.ts

@@ -98,10 +98,6 @@ export declare function extractBlueskyPostId(url: string): {
     actor: string;
     rkey: string;
 } | undefined;
-/**
- * Proxy a Bluesky image URL through the server
- */
-export declare function proxyBlueskyImageUrl(url: string, proxyEndpoint?: string): string;
 /**
  * Format a Bluesky post date for display
  */

package/dist/runtime/registry/bluesky-embed.js

@@ -7,10 +7,6 @@ export function extractBlueskyPostId(url) {
     return void 0;
   return { actor: match[1], rkey: match[2] };
 }
-export function proxyBlueskyImageUrl(url, proxyEndpoint = "/_scripts/embed/bluesky-image") {
-  const separator = proxyEndpoint.includes("?") ? "&" : "?";
-  return `${proxyEndpoint}${separator}url=${encodeURIComponent(url)}`;
-}
 export function formatBlueskyDate(dateString) {
   const date = new Date(dateString);
   const time = date.toLocaleString("en-US", {

package/dist/runtime/registry/clarity.d.ts

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
 import { ClarityOptions } from './schemas.js';
 export { ClarityOptions };
 type ClarityFunctions = ((fn: 'start', options?: {
@@ -25,4 +25,8 @@ declare global {
     }
 }
 export type ClarityInput = RegistryScriptInput<typeof ClarityOptions>;
-export declare function useScriptClarity<T extends ClarityApi>(_options?: ClarityInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export interface ClarityConsent {
+    /** Call `clarity('consent', value)` with either a boolean (default) or Clarity's advanced vector. */
+    set: (value: boolean | Record<string, string>) => void;
+}
+export declare function useScriptClarity<T extends ClarityApi>(_options?: ClarityInput): UseScriptContext<T, ClarityConsent>;

package/dist/runtime/registry/clarity.js

@@ -2,7 +2,7 @@ import { useRegistryScript } from "../utils.js";
 import { ClarityOptions } from "./schemas.js";
 export { ClarityOptions };
 export function useScriptClarity(_options) {
-  return useRegistryScript("clarity", (options) => ({
+  const instance = useRegistryScript("clarity", (options) => ({
     scriptInput: {
       src: `https://www.clarity.ms/tag/${options.id}`
     },
@@ -22,6 +22,17 @@ export function useScriptClarity(_options) {
       window.clarity = window.clarity || function(...params) {
         (window.clarity.q = window.clarity.q || []).push(params);
       };
+      if (options?.defaultConsent !== void 0)
+        window.clarity("consent", options.defaultConsent);
     }
   }), _options);
+  if (import.meta.client && !instance.consent) {
+    instance.consent = {
+      set: (value) => {
+        ;
+        instance.proxy.clarity("consent", value);
+      }
+    };
+  }
+  return instance;
 }

package/dist/runtime/registry/google-analytics.d.ts

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { ConsentState, RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
 import { GoogleAnalyticsOptions } from './schemas.js';
 export type GtagCustomParams = Record<string, any>;
 export type ConsentStatus = 'granted' | 'denied';
@@ -58,6 +58,10 @@ export interface GoogleAnalyticsApi {
 }
 export { GoogleAnalyticsOptions };
 export type GoogleAnalyticsInput = RegistryScriptInput<typeof GoogleAnalyticsOptions>;
+export interface GoogleAnalyticsConsent {
+    /** Send `gtag('consent','update', state)` with GCMv2 partial state. */
+    update: (state: ConsentState) => void;
+}
 export declare function useScriptGoogleAnalytics<T extends GoogleAnalyticsApi>(_options?: GoogleAnalyticsInput & {
     onBeforeGtagStart?: (gtag: GTag) => void;
-}): import("#nuxt-scripts/types").UseScriptContext<T>;
+}): UseScriptContext<T, GoogleAnalyticsConsent>;

package/dist/runtime/registry/google-analytics.js

@@ -3,7 +3,7 @@ import { withQuery } from "ufo";
 import { GoogleAnalyticsOptions } from "./schemas.js";
 export { GoogleAnalyticsOptions };
 export function useScriptGoogleAnalytics(_options) {
-  return useRegistryScript(_options?.key || "googleAnalytics", (options) => {
+  const instance = useRegistryScript(_options?.key || "googleAnalytics", (options) => {
     const dataLayerName = options?.l ?? "dataLayer";
     const w = import.meta.client ? window : {};
     return {
@@ -24,6 +24,8 @@ export function useScriptGoogleAnalytics(_options) {
         w.gtag = function() {
           w[dataLayerName].push(arguments);
         };
+        if (options?.defaultConsent)
+          w.gtag("consent", "default", options.defaultConsent);
         _options?.onBeforeGtagStart?.(w.gtag);
         w.gtag("js", /* @__PURE__ */ new Date());
         if (options?.id) {
@@ -32,4 +34,13 @@ export function useScriptGoogleAnalytics(_options) {
       }
     };
   }, _options);
+  if (import.meta.client && !instance.consent) {
+    instance.consent = {
+      update: (state) => {
+        ;
+        instance.proxy.gtag("consent", "update", state);
+      }
+    };
+  }
+  return instance;
 }

package/dist/runtime/registry/google-tag-manager.d.ts

@@ -1,4 +1,4 @@
-import type { NuxtUseScriptOptions, RegistryScriptInput, UseFunctionType, UseScriptContext } from '#nuxt-scripts/types';
+import type { ConsentState, NuxtUseScriptOptions, RegistryScriptInput, UseFunctionType, UseScriptContext } from '#nuxt-scripts/types';
 import type { GTag } from './google-analytics.js';
 import { GoogleTagManagerOptions } from './schemas.js';
 /**
@@ -68,6 +68,10 @@ declare global {
 }
 export { GoogleTagManagerOptions };
 export type GoogleTagManagerInput = RegistryScriptInput<typeof GoogleTagManagerOptions>;
+export interface GoogleTagManagerConsent {
+    /** Push `['consent','update', state]` onto dataLayer with GCMv2 partial state. */
+    update: (state: ConsentState) => void;
+}
 /**
  * Hook to use Google Tag Manager in Nuxt applications
  */
@@ -77,4 +81,4 @@ export declare function useScriptGoogleTagManager<T extends GoogleTagManagerApi>
      * Allows for custom initialization or configuration
      */
     onBeforeGtmStart?: (gtag: DataLayerPush) => void;
-}): UseScriptContext<UseFunctionType<NuxtUseScriptOptions<T>, T>>;
+}): UseScriptContext<UseFunctionType<NuxtUseScriptOptions<T>, T>, GoogleTagManagerConsent>;

package/dist/runtime/registry/google-tag-manager.js

@@ -54,5 +54,14 @@ export function useScriptGoogleTagManager(options) {
     if (gtag)
       options.onBeforeGtmStart(gtag);
   }
-  return instance;
+  const typed = instance;
+  if (import.meta.client && !typed.consent) {
+    typed.consent = {
+      update: (state) => {
+        ;
+        typed.proxy.dataLayer.push(["consent", "update", state]);
+      }
+    };
+  }
+  return typed;
 }

package/dist/runtime/registry/gravatar.js

@@ -1,4 +1,5 @@
 import { scriptsPrefix, useRegistryScript } from "#nuxt-scripts/utils";
+import { useScriptProxyUrl } from "../composables/useScriptProxyUrl.js";
 import { GravatarOptions } from "./schemas.js";
 export { GravatarOptions } from "./schemas.js";
 export function useScriptGravatar(_options) {
@@ -6,13 +7,11 @@ export function useScriptGravatar(_options) {
     const size = options?.size ?? 80;
     const defaultImg = options?.default ?? "mp";
     const rating = options?.rating ?? "g";
-    const buildQuery = (overrides) => {
-      const params = new URLSearchParams();
-      params.set("s", String(overrides?.size ?? size));
-      params.set("d", overrides?.default ?? defaultImg);
-      params.set("r", overrides?.rating ?? rating);
-      return params.toString();
-    };
+    const buildQuery = (overrides) => ({
+      s: overrides?.size ?? size,
+      d: overrides?.default ?? defaultImg,
+      r: overrides?.rating ?? rating
+    });
     return {
       scriptInput: {
         src: "https://secure.gravatar.com/js/gprofiles.js"
@@ -21,13 +20,11 @@ export function useScriptGravatar(_options) {
       scriptOptions: {
         use: () => {
           const prefix = scriptsPrefix();
+          const proxyUrl = useScriptProxyUrl();
+          const path = `${prefix}/proxy/gravatar`;
           return {
-            getAvatarUrl: (hash, overrides) => {
-              return `${prefix}/proxy/gravatar?hash=${encodeURIComponent(hash)}&${buildQuery(overrides)}`;
-            },
-            getAvatarUrlFromEmail: (email, overrides) => {
-              return `${prefix}/proxy/gravatar?email=${encodeURIComponent(email)}&${buildQuery(overrides)}`;
-            }
+            getAvatarUrl: (hash, overrides) => proxyUrl(path, { hash, ...buildQuery(overrides) }),
+            getAvatarUrlFromEmail: (email, overrides) => proxyUrl(path, { email, ...buildQuery(overrides) })
           };
         }
       }

package/dist/runtime/registry/matomo-analytics.d.ts

@@ -1,12 +1,18 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
 import { MatomoAnalyticsOptions } from './schemas.js';
 export { MatomoAnalyticsOptions };
 export type MatomoAnalyticsInput = RegistryScriptInput<typeof MatomoAnalyticsOptions, false, false>;
-interface MatomoAnalyticsApi {
+export interface MatomoAnalyticsApi {
     _paq: unknown[];
 }
 declare global {
     interface Window extends MatomoAnalyticsApi {
     }
 }
-export declare function useScriptMatomoAnalytics<T extends MatomoAnalyticsApi>(_options?: MatomoAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export interface MatomoConsent {
+    /** Push `setConsentGiven`. Requires `defaultConsent: 'required' | 'given'` at registration to have an effect. */
+    give: () => void;
+    /** Push `forgetConsentGiven`. Requires `defaultConsent: 'required' | 'given'` at registration to have an effect. */
+    forget: () => void;
+}
+export declare function useScriptMatomoAnalytics<T extends MatomoAnalyticsApi>(_options?: MatomoAnalyticsInput): UseScriptContext<T, MatomoConsent>;

package/dist/runtime/registry/matomo-analytics.js

@@ -5,7 +5,7 @@ import { useRegistryScript } from "../utils.js";
 import { MatomoAnalyticsOptions } from "./schemas.js";
 export { MatomoAnalyticsOptions };
 export function useScriptMatomoAnalytics(_options) {
-  return useRegistryScript("matomoAnalytics", (options) => {
+  const instance = useRegistryScript("matomoAnalytics", (options) => {
     const normalizedCloudId = options?.cloudId ? withoutTrailingSlash(withoutProtocol(options.cloudId)) : void 0;
     const origin = options?.matomoUrl ? options.matomoUrl : `https://cdn.matomo.cloud/${normalizedCloudId}/`;
     const _paq = import.meta.client ? window._paq = window._paq || [] : [];
@@ -30,6 +30,12 @@ export function useScriptMatomoAnalytics(_options) {
         }
       },
       clientInit: import.meta.server ? void 0 : () => {
+        if (options?.defaultConsent === "required") {
+          _paq.push(["requireConsent"]);
+        } else if (options?.defaultConsent === "given") {
+          _paq.push(["requireConsent"]);
+          _paq.push(["setConsentGiven"]);
+        }
         if (options?.enableLinkTracking) {
           _paq.push(["enableLinkTracking"]);
         }
@@ -59,4 +65,25 @@ export function useScriptMatomoAnalytics(_options) {
       }
     };
   }, _options);
+  if (import.meta.client && !instance.consent) {
+    const requiresConsent = _options?.defaultConsent === "required" || _options?.defaultConsent === "given";
+    const warnIfUnsafe = import.meta.dev ? (method) => {
+      if (!requiresConsent) {
+        logger.warn(`matomo consent.${method}() is a no-op unless \`defaultConsent: 'required'\` or \`'given'\` is set at registration.`);
+      }
+    } : () => {
+    };
+    const paq = instance.proxy._paq;
+    instance.consent = {
+      give: () => {
+        warnIfUnsafe("give");
+        paq.push(["setConsentGiven"]);
+      },
+      forget: () => {
+        warnIfUnsafe("forget");
+        paq.push(["forgetConsentGiven"]);
+      }
+    };
+  }
+  return instance;
 }

package/dist/runtime/registry/meta-pixel.d.ts

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
 import { MetaPixelOptions } from './schemas.js';
 type StandardEvents = 'AddPaymentInfo' | 'AddToCart' | 'AddToWishlist' | 'CompleteRegistration' | 'Contact' | 'CustomizeProduct' | 'Donate' | 'FindLocation' | 'InitiateCheckout' | 'Lead' | 'Purchase' | 'Schedule' | 'Search' | 'StartTrial' | 'SubmitApplication' | 'Subscribe' | 'ViewContent';
 interface EventObjectProperties {
@@ -38,4 +38,10 @@ declare global {
 }
 export { MetaPixelOptions };
 export type MetaPixelInput = RegistryScriptInput<typeof MetaPixelOptions, true, false>;
-export declare function useScriptMetaPixel<T extends MetaPixelApi>(_options?: MetaPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export interface MetaPixelConsent {
+    /** Call `fbq('consent','grant')`. */
+    grant: () => void;
+    /** Call `fbq('consent','revoke')`. */
+    revoke: () => void;
+}
+export declare function useScriptMetaPixel<T extends MetaPixelApi>(_options?: MetaPixelInput): UseScriptContext<T, MetaPixelConsent>;

package/dist/runtime/registry/meta-pixel.js

@@ -2,7 +2,7 @@ import { useRegistryScript } from "../utils.js";
 import { MetaPixelOptions } from "./schemas.js";
 export { MetaPixelOptions };
 export function useScriptMetaPixel(_options) {
-  return useRegistryScript("metaPixel", (options) => ({
+  const instance = useRegistryScript("metaPixel", (options) => ({
     scriptInput: {
       src: "https://connect.facebook.net/en_US/fbevents.js",
       crossorigin: false
@@ -27,8 +27,17 @@ export function useScriptMetaPixel(_options) {
       fbq.loaded = true;
       fbq.version = "2.0";
       fbq.queue = [];
+      if (options?.defaultConsent)
+        fbq("consent", options.defaultConsent === "granted" ? "grant" : "revoke");
       fbq("init", options?.id);
       fbq("track", "PageView");
     }
   }), _options);
+  if (import.meta.client && !instance.consent) {
+    instance.consent = {
+      grant: () => instance.proxy.fbq("consent", "grant"),
+      revoke: () => instance.proxy.fbq("consent", "revoke")
+    };
+  }
+  return instance;
 }

package/dist/runtime/registry/mixpanel-analytics.d.ts

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
 import { MixpanelAnalyticsOptions } from './schemas.js';
 export { MixpanelAnalyticsOptions };
 export type MixpanelAnalyticsInput = RegistryScriptInput<typeof MixpanelAnalyticsOptions>;
@@ -12,6 +12,10 @@ export interface MixpanelAnalyticsApi {
         };
         register: (properties: Record<string, any>) => void;
         init: (token: string, config?: Record<string, any>) => void;
+        /** Opt the user in to tracking. Available after the real SDK loads. */
+        opt_in_tracking?: () => void;
+        /** Opt the user out of tracking. Available after the real SDK loads. */
+        opt_out_tracking?: () => void;
     };
 }
 declare global {
@@ -19,4 +23,10 @@ declare global {
         mixpanel: MixpanelAnalyticsApi['mixpanel'];
     }
 }
-export declare function useScriptMixpanelAnalytics<T extends MixpanelAnalyticsApi>(_options?: MixpanelAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export interface MixpanelConsent {
+    /** Call `mixpanel.opt_in_tracking()`. */
+    optIn: () => void;
+    /** Call `mixpanel.opt_out_tracking()`. For boot-time opt-out, use `defaultConsent: 'opt-out'` instead. */
+    optOut: () => void;
+}
+export declare function useScriptMixpanelAnalytics<T extends MixpanelAnalyticsApi>(_options?: MixpanelAnalyticsInput): UseScriptContext<T, MixpanelConsent>;

package/dist/runtime/registry/mixpanel-analytics.js

@@ -1,10 +1,10 @@
 import { useRegistryScript } from "../utils.js";
 import { MixpanelAnalyticsOptions } from "./schemas.js";
 export { MixpanelAnalyticsOptions };
-const methods = ["track", "identify", "reset", "register"];
+const methods = ["track", "identify", "reset", "register", "opt_in_tracking", "opt_out_tracking"];
 const peopleMethods = ["set"];
 export function useScriptMixpanelAnalytics(_options) {
-  return useRegistryScript("mixpanelAnalytics", (options) => {
+  const instance = useRegistryScript("mixpanelAnalytics", (options) => {
     return {
       scriptInput: {
         src: "https://cdn.mxpnl.com/libs/mixpanel-2-latest.min.js"
@@ -38,9 +38,21 @@ export function useScriptMixpanelAnalytics(_options) {
             mp._i.push([token, config, name]);
           };
         }
-        if (options?.token)
-          mp.init(options.token);
+        if (options?.token) {
+          const optOutByDefault = options?.defaultConsent === "opt-out";
+          mp.init(options.token, optOutByDefault ? { opt_out_tracking_by_default: true } : void 0);
+          if (options?.defaultConsent === "opt-in") {
+            mp.opt_in_tracking?.();
+          }
+        }
       }
     };
   }, _options);
+  if (import.meta.client && !instance.consent) {
+    instance.consent = {
+      optIn: () => instance.proxy.mixpanel.opt_in_tracking?.(),
+      optOut: () => instance.proxy.mixpanel.opt_out_tracking?.()
+    };
+  }
+  return instance;
 }

package/dist/runtime/registry/posthog.d.ts

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
 import type { PostHog, PostHogConfig } from 'posthog-js';
 import { PostHogOptions } from './schemas.js';
 export { PostHogOptions };
@@ -22,4 +22,10 @@ declare global {
         }[];
     }
 }
-export declare function useScriptPostHog<T extends PostHogApi>(_options?: PostHogInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export interface PostHogConsent {
+    /** Call `posthog.opt_in_capturing()`. */
+    optIn: () => void;
+    /** Call `posthog.opt_out_capturing()`. For boot-time opt-out, use `defaultConsent: 'opt-out'` instead. */
+    optOut: () => void;
+}
+export declare function useScriptPostHog<T extends PostHogApi>(_options?: PostHogInput): UseScriptContext<T, PostHogConsent>;