@nuxt/scripts 0.13.2 → 1.0.0-beta.1

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

@@ -0,0 +1,45 @@
+import { withQuery } from "ufo";
+import { useRegistryScript } from "#nuxt-scripts/utils";
+import { object, string, optional, boolean } from "#nuxt-scripts-validator";
+export const GoogleRecaptchaOptions = object({
+  siteKey: string(),
+  // Use enterprise.js instead of api.js
+  enterprise: optional(boolean()),
+  // Use recaptcha.net (works in China)
+  recaptchaNet: optional(boolean()),
+  // Language code
+  hl: optional(string())
+});
+export function useScriptGoogleRecaptcha(_options) {
+  return useRegistryScript(_options?.key || "googleRecaptcha", (options) => {
+    const baseUrl = options?.recaptchaNet ? "https://www.recaptcha.net/recaptcha" : "https://www.google.com/recaptcha";
+    const scriptPath = options?.enterprise ? "enterprise.js" : "api.js";
+    return {
+      scriptInput: {
+        src: withQuery(`${baseUrl}/${scriptPath}`, {
+          render: options?.siteKey,
+          hl: options?.hl
+        }),
+        crossorigin: false
+      },
+      schema: import.meta.dev ? GoogleRecaptchaOptions : void 0,
+      scriptOptions: {
+        use() {
+          return { grecaptcha: window.grecaptcha };
+        }
+      },
+      clientInit: import.meta.server ? void 0 : () => {
+        const w = window;
+        w.grecaptcha = w.grecaptcha || {};
+        const readyFn = function(cb) {
+          (w.___grecaptcha_cfg = w.___grecaptcha_cfg || {}).fns = (w.___grecaptcha_cfg.fns || []).concat([cb]);
+        };
+        w.grecaptcha.ready = w.grecaptcha.ready || readyFn;
+        if (options?.enterprise) {
+          w.grecaptcha.enterprise = w.grecaptcha.enterprise || {};
+          w.grecaptcha.enterprise.ready = w.grecaptcha.enterprise.ready || readyFn;
+        }
+      }
+    };
+  }, _options);
+}

package/dist/runtime/registry/google-sign-in.d.ts

@@ -0,0 +1,84 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+export interface CredentialResponse {
+    credential: string;
+    select_by: 'auto' | 'user' | 'user_1tap' | 'user_2tap' | 'btn' | 'btn_confirm' | 'btn_add_session' | 'btn_confirm_add_session';
+    clientId?: string;
+}
+export interface IdConfiguration {
+    client_id: string;
+    auto_select?: boolean;
+    callback?: (response: CredentialResponse) => void;
+    login_uri?: string;
+    native_callback?: (response: CredentialResponse) => void;
+    cancel_on_tap_outside?: boolean;
+    prompt_parent_id?: string;
+    nonce?: string;
+    context?: 'signin' | 'signup' | 'use';
+    state_cookie_domain?: string;
+    ux_mode?: 'popup' | 'redirect';
+    allowed_parent_origin?: string | string[];
+    intermediate_iframe_close_callback?: () => void;
+    itp_support?: boolean;
+    login_hint?: string;
+    hd?: string;
+    use_fedcm_for_prompt?: boolean;
+}
+export interface GsiButtonConfiguration {
+    type?: 'standard' | 'icon';
+    theme?: 'outline' | 'filled_blue' | 'filled_black';
+    size?: 'large' | 'medium' | 'small';
+    text?: 'signin_with' | 'signup_with' | 'continue_with' | 'signin';
+    shape?: 'rectangular' | 'pill' | 'circle' | 'square';
+    logo_alignment?: 'left' | 'center';
+    width?: string | number;
+    locale?: string;
+    click_listener?: () => void;
+    use_fedcm?: boolean;
+}
+export type MomentType = 'display' | 'skipped' | 'dismissed';
+export interface MomentNotification {
+    isDisplayMoment: () => boolean;
+    isDisplayed: () => boolean;
+    isNotDisplayed: () => boolean;
+    getNotDisplayedReason: () => 'browser_not_supported' | 'invalid_client' | 'missing_client_id' | 'opt_out_or_no_session' | 'secure_http_required' | 'suppressed_by_user' | 'unregistered_origin' | 'unknown_reason';
+    isSkippedMoment: () => boolean;
+    getSkippedReason: () => 'auto_cancel' | 'user_cancel' | 'tap_outside' | 'issuing_failed';
+    isDismissedMoment: () => boolean;
+    getDismissedReason: () => 'credential_returned' | 'cancel_called' | 'flow_restarted';
+    getMomentType: () => MomentType;
+}
+export interface RevocationResponse {
+    successful: boolean;
+    error?: string;
+}
+declare namespace google {
+    namespace accounts {
+        namespace id {
+            function initialize(config: IdConfiguration): void;
+            function prompt(momentListener?: (notification: MomentNotification) => void): void;
+            function renderButton(parent: HTMLElement, options: GsiButtonConfiguration): void;
+            function disableAutoSelect(): void;
+            function cancel(): void;
+            function revoke(hint: string, callback: (response: RevocationResponse) => void): void;
+        }
+    }
+}
+type AccountsNamespace = typeof google.accounts;
+export interface GoogleSignInApi {
+    accounts: AccountsNamespace;
+}
+export declare const GoogleSignInOptions: import("valibot").ObjectSchema<{
+    readonly clientId: import("valibot").StringSchema<undefined>;
+    readonly autoSelect: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly context: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"signin", undefined>, import("valibot").LiteralSchema<"signup", undefined>, import("valibot").LiteralSchema<"use", undefined>], undefined>, undefined>;
+    readonly useFedcmForPrompt: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly cancelOnTapOutside: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly uxMode: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"popup", undefined>, import("valibot").LiteralSchema<"redirect", undefined>], undefined>, undefined>;
+    readonly loginUri: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly itpSupport: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly allowedParentOrigin: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly hd: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export type GoogleSignInInput = RegistryScriptInput<typeof GoogleSignInOptions>;
+export declare function useScriptGoogleSignIn<T extends GoogleSignInApi>(_options?: GoogleSignInInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export {};

package/dist/runtime/registry/google-sign-in.js

@@ -0,0 +1,50 @@
+import { useRegistryScript } from "#nuxt-scripts/utils";
+import { object, string, optional, boolean, array, union, literal } from "#nuxt-scripts-validator";
+export const GoogleSignInOptions = object({
+  clientId: string(),
+  // Auto-select credentials if only one is available
+  autoSelect: optional(boolean()),
+  // Context for One Tap (signin, signup, or use)
+  context: optional(union([literal("signin"), literal("signup"), literal("use")])),
+  // FedCM API support (Privacy Sandbox) - mandatory from August 2025
+  useFedcmForPrompt: optional(boolean()),
+  // Cancel One Tap if user clicks outside
+  cancelOnTapOutside: optional(boolean()),
+  // UX mode: popup or redirect
+  uxMode: optional(union([literal("popup"), literal("redirect")])),
+  // Login URI for redirect flow
+  loginUri: optional(string()),
+  // ITP (Intelligent Tracking Prevention) support
+  itpSupport: optional(boolean()),
+  // Allowed parent origins for iframe embedding
+  allowedParentOrigin: optional(union([string(), array(string())])),
+  // Hosted domain - restrict to specific Google Workspace domain
+  hd: optional(string())
+});
+export function useScriptGoogleSignIn(_options) {
+  return useRegistryScript(_options?.key || "googleSignIn", () => {
+    return {
+      scriptInput: {
+        src: "https://accounts.google.com/gsi/client",
+        // Performance best practice: async + defer to prevent render blocking
+        defer: true,
+        // Google's script doesn't support CORS
+        crossorigin: false
+      },
+      schema: import.meta.dev ? GoogleSignInOptions : void 0,
+      scriptOptions: {
+        use() {
+          return {
+            accounts: window.google?.accounts
+          };
+        }
+      },
+      clientInit: import.meta.server ? void 0 : () => {
+        const w = window;
+        w.google = w.google || {};
+        w.google.accounts = w.google.accounts || {};
+        w.google.accounts.id = w.google.accounts.id || {};
+      }
+    };
+  }, _options);
+}

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

@@ -11,7 +11,7 @@ export type DataLayer = Array<DataLayerItem>;
  */
 export interface DataLayerPush {
     (...args: Parameters<GTag>): void;
-    (obj: Record<string, unknown>): void;
+    (obj: Record<string, unknown> | any[]): void;
 }
 /**
  * Improved DataLayer API type with more precise methods
@@ -89,6 +89,8 @@ export declare const GoogleTagManagerOptions: import("valibot").ObjectSchema<{
     readonly envName: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
     /** Referrer policy for analytics requests */
     readonly authReferrerPolicy: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /** Default consent settings for GTM */
+    readonly defaultConsent: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, undefined>;
 }, undefined>;
 export type GoogleTagManagerInput = RegistryScriptInput<typeof GoogleTagManagerOptions>;
 /**

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

@@ -1,6 +1,6 @@
 import { withQuery } from "ufo";
 import { useRegistryScript } from "#nuxt-scripts/utils";
-import { object, string, optional, boolean, union, literal } from "#nuxt-scripts-validator";
+import { object, string, optional, boolean, union, literal, record, number } from "#nuxt-scripts-validator";
 export const GoogleTagManagerOptions = object({
   /** GTM container ID (format: GTM-XXXXXX) */
   id: string(),
@@ -21,10 +21,12 @@ export const GoogleTagManagerOptions = object({
   /** Environment name for environment-specific container */
   envName: optional(string()),
   /** Referrer policy for analytics requests */
-  authReferrerPolicy: optional(string())
+  authReferrerPolicy: optional(string()),
+  /** Default consent settings for GTM */
+  defaultConsent: optional(record(string(), union([string(), number()])))
 });
 export function useScriptGoogleTagManager(options) {
-  return useRegistryScript(
+  const instance = useRegistryScript(
     options?.key || "googleTagManager",
     (opts) => {
       const dataLayerName = opts?.l ?? opts?.dataLayer ?? "dataLayer";
@@ -54,11 +56,13 @@ export function useScriptGoogleTagManager(options) {
         },
         clientInit: import.meta.server ? void 0 : () => {
           window[dataLayerName] = window[dataLayerName] || [];
-          function gtag() {
-            window[dataLayerName].push(arguments);
+          function gtag(...args) {
+            window[dataLayerName].push(args);
           }
           window.gtag = gtag;
           options?.onBeforeGtmStart?.(gtag);
+          if (opts.defaultConsent)
+            gtag("consent", "default", opts.defaultConsent);
           window[dataLayerName].push({
             "gtm.start": (/* @__PURE__ */ new Date()).getTime(),
             "event": "gtm.js"
@@ -68,4 +72,10 @@ export function useScriptGoogleTagManager(options) {
     },
     options
   );
+  if (import.meta.client && options?.onBeforeGtmStart) {
+    const gtag = window.gtag;
+    if (gtag)
+      options.onBeforeGtmStart(gtag);
+  }
+  return instance;
 }

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

@@ -46,7 +46,7 @@ export function useScriptMatomoAnalytics(_options) {
           _paq.push(["disableCookies"]);
         }
         if (options?.trackerUrl || options?.matomoUrl) {
-          _paq.push(["setTrackerUrl", options?.trackerUrl ? withHttps(options.trackerUrl) : withBase(`/matomo.php`, withHttps(options?.matomoUrl || ""))]);
+          _paq.push(["setTrackerUrl", options?.trackerUrl ?? withBase(`/matomo.php`, options?.matomoUrl || "")]);
         } else if (normalizedCloudId) {
           _paq.push(["setTrackerUrl", withBase(`/matomo.php`, withHttps(normalizedCloudId))]);
         }

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

@@ -74,13 +74,15 @@ export function useScriptPlausibleAnalytics(_options) {
         use() {
           return { plausible: window.plausible };
         },
-        clientInit() {
-          window.plausible = window.plausible || function() {
-            (plausible.q = plausible.q || []).push(arguments);
-          }, plausible.init = plausible.init || function(i) {
-            plausible.o = i || {};
+        clientInit: import.meta.server ? void 0 : () => {
+          const w = window;
+          w.plausible = w.plausible || function() {
+            (w.plausible.q = w.plausible.q || []).push(arguments);
           };
-          window.plausible.init(initOptions);
+          w.plausible.init = w.plausible.init || function(i) {
+            w.plausible.o = i || {};
+          };
+          w.plausible.init(initOptions);
         }
       }
     };

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

@@ -0,0 +1,26 @@
+import type { PostHog } from 'posthog-js';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+export declare const PostHogOptions: import("valibot").ObjectSchema<{
+    readonly apiKey: import("valibot").StringSchema<undefined>;
+    readonly region: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"us", undefined>, import("valibot").LiteralSchema<"eu", undefined>], undefined>, undefined>;
+    readonly autocapture: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly capturePageview: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly capturePageleave: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly disableSessionRecording: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly config: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").AnySchema, undefined>, undefined>;
+}, undefined>;
+export type PostHogInput = RegistryScriptInput<typeof PostHogOptions, false, true>;
+export interface PostHogApi {
+    posthog: PostHog;
+}
+declare global {
+    interface Window {
+        posthog?: PostHog;
+        __posthogInitPromise?: Promise<PostHog | undefined>;
+        _posthogQueue?: {
+            prop: string | symbol;
+            args: any[];
+        }[];
+    }
+}
+export declare function useScriptPostHog<T extends PostHogApi>(_options?: PostHogInput): import("#nuxt-scripts/types").UseScriptContext<T>;

package/dist/runtime/registry/posthog.js

@@ -0,0 +1,92 @@
+import { any, record, string, object, optional, boolean, union, literal } from "#nuxt-scripts-validator";
+import { useRegistryScript } from "../utils.js";
+import { logger } from "../logger.js";
+export const PostHogOptions = object({
+  apiKey: string(),
+  region: optional(union([literal("us"), literal("eu")])),
+  autocapture: optional(boolean()),
+  capturePageview: optional(boolean()),
+  capturePageleave: optional(boolean()),
+  disableSessionRecording: optional(boolean()),
+  config: optional(record(string(), any()))
+});
+export function useScriptPostHog(_options) {
+  return useRegistryScript("posthog", (options) => {
+    return {
+      scriptMode: "npm",
+      // Use NPM mode - no external script tag
+      schema: import.meta.dev ? PostHogOptions : void 0,
+      scriptOptions: {
+        use() {
+          if (import.meta.server)
+            return { posthog: {} };
+          if (window.posthog)
+            return { posthog: window.posthog };
+          const posthog = new Proxy({}, {
+            get(_, prop) {
+              if (window.posthog)
+                return window.posthog[prop];
+              if (prop === "then")
+                return void 0;
+              return (...args) => {
+                if (window.posthog)
+                  return window.posthog[prop](...args);
+                window._posthogQueue = window._posthogQueue || [];
+                window._posthogQueue.push({ prop, args });
+              };
+            }
+          });
+          return { posthog };
+        }
+      },
+      clientInit: import.meta.server ? void 0 : async () => {
+        if (window.__posthogInitPromise || window.posthog)
+          return;
+        if (!options?.apiKey) {
+          logger.warn("PostHog apiKey is required");
+          return;
+        }
+        const region = options?.region || "us";
+        const apiHost = region === "eu" ? "https://eu.i.posthog.com" : "https://us.i.posthog.com";
+        console.log("[PostHog] Starting dynamic import of posthog-js...");
+        window.__posthogInitPromise = import("posthog-js").then(({ default: posthog }) => {
+          console.log("[PostHog] posthog-js imported successfully");
+          const config = {
+            api_host: apiHost,
+            ...options?.config
+          };
+          if (typeof options?.autocapture === "boolean")
+            config.autocapture = options.autocapture;
+          if (typeof options?.capturePageview === "boolean")
+            config.capture_pageview = options.capturePageview;
+          if (typeof options?.capturePageleave === "boolean")
+            config.capture_pageleave = options.capturePageleave;
+          if (typeof options?.disableSessionRecording === "boolean")
+            config.disable_session_recording = options.disableSessionRecording;
+          console.log("[PostHog] Calling posthog.init with apiKey:", options.apiKey, "config:", config);
+          const instance = posthog.init(options.apiKey, config);
+          if (!instance) {
+            logger.error("PostHog init returned undefined - initialization failed");
+            delete window._posthogQueue;
+            return void 0;
+          }
+          console.log("[PostHog] posthog.init succeeded, instance:", instance);
+          window.posthog = instance;
+          if (window._posthogQueue && window._posthogQueue.length > 0) {
+            console.log("[PostHog] Flushing", window._posthogQueue.length, "queued calls");
+            window._posthogQueue.forEach((q) => window.posthog[q.prop]?.(...q.args));
+            delete window._posthogQueue;
+          }
+          console.log("[PostHog] Initialization complete!");
+          return window.posthog;
+        }).catch((e) => {
+          logger.error("Failed to load posthog-js:", e);
+          console.error("[PostHog] Import/init error:", e);
+          delete window._posthogQueue;
+          return void 0;
+        });
+        return window.__posthogInitPromise;
+      }
+    };
+  }, _options);
+}

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

@@ -15,7 +15,39 @@ export const RybbitAnalyticsOptions = object({
   debounce: optional(number()),
   apiKey: optional(string())
 });
+const RYBBIT_QUEUE_KEY = Symbol.for("nuxt-scripts.rybbit-queue");
+function getRybbitState() {
+  if (!import.meta.client) return;
+  const g = globalThis;
+  if (!g[RYBBIT_QUEUE_KEY]) {
+    g[RYBBIT_QUEUE_KEY] = { queue: [], flushed: false };
+  }
+  return g[RYBBIT_QUEUE_KEY];
+}
 export function useScriptRybbitAnalytics(_options) {
+  const isRybbitReady = () => import.meta.client && typeof window !== "undefined" && window.rybbit && typeof window.rybbit.event === "function";
+  const flushQueue = () => {
+    const state = getRybbitState();
+    if (!state || state.flushed || !isRybbitReady()) return;
+    state.flushed = true;
+    while (state.queue.length > 0) {
+      const [method, ...args] = state.queue.shift();
+      const fn = window.rybbit[method];
+      if (typeof fn === "function") {
+        fn.apply(window.rybbit, args);
+      }
+    }
+  };
+  const callOrQueue = (method, ...args) => {
+    if (isRybbitReady()) {
+      const fn = window.rybbit[method];
+      if (typeof fn === "function") {
+        fn.apply(window.rybbit, args);
+      }
+    } else {
+      getRybbitState()?.queue.push([method, ...args]);
+    }
+  };
   return useRegistryScript("rybbitAnalytics", (options) => {
     return {
       scriptInput: {
@@ -36,15 +68,13 @@ export function useScriptRybbitAnalytics(_options) {
       schema: import.meta.dev ? RybbitAnalyticsOptions : void 0,
       scriptOptions: {
         use() {
-          if (typeof window.rybbit === "undefined") {
-            return null;
-          }
+          flushQueue();
           return {
-            pageview: window.rybbit.pageview,
-            event: window.rybbit.event,
-            identify: window.rybbit.identify,
-            clearUserId: window.rybbit.clearUserId,
-            getUserId: window.rybbit.getUserId,
+            pageview: () => callOrQueue("pageview"),
+            event: (name, properties) => callOrQueue("event", name, properties),
+            identify: (userId) => callOrQueue("identify", userId),
+            clearUserId: () => callOrQueue("clearUserId"),
+            getUserId: () => window.rybbit?.getUserId?.() ?? null,
             rybbit: window.rybbit
           };
         }

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

@@ -0,0 +1,43 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+type StandardEvents = 'ViewContent' | 'ClickButton' | 'Search' | 'AddToWishlist' | 'AddToCart' | 'InitiateCheckout' | 'AddPaymentInfo' | 'CompletePayment' | 'PlaceAnOrder' | 'Contact' | 'Download' | 'SubmitForm' | 'CompleteRegistration' | 'Subscribe';
+interface EventProperties {
+    content_id?: string;
+    content_type?: string;
+    content_name?: string;
+    contents?: Array<{
+        content_id: string;
+        content_type?: string;
+        content_name?: string;
+        price?: number;
+        quantity?: number;
+    }>;
+    currency?: string;
+    value?: number;
+    description?: string;
+    query?: string;
+    [key: string]: any;
+}
+interface IdentifyProperties {
+    email?: string;
+    phone_number?: string;
+    external_id?: string;
+}
+type TtqFns = ((cmd: 'track', event: StandardEvents | string, properties?: EventProperties) => void) & ((cmd: 'page') => void) & ((cmd: 'identify', properties: IdentifyProperties) => void) & ((cmd: string, ...args: any[]) => void);
+export interface TikTokPixelApi {
+    ttq: TtqFns & {
+        push: TtqFns;
+        loaded: boolean;
+        queue: any[];
+    };
+}
+declare global {
+    interface Window extends TikTokPixelApi {
+    }
+}
+export declare const TikTokPixelOptions: import("valibot").ObjectSchema<{
+    readonly id: import("valibot").StringSchema<undefined>;
+    readonly trackPageView: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+}, undefined>;
+export type TikTokPixelInput = RegistryScriptInput<typeof TikTokPixelOptions, true, false, false>;
+export declare function useScriptTikTokPixel<T extends TikTokPixelApi>(_options?: TikTokPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export {};

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

@@ -0,0 +1,43 @@
+import { withQuery } from "ufo";
+import { useRegistryScript } from "../utils.js";
+import { object, string, optional, boolean } from "#nuxt-scripts-validator";
+export const TikTokPixelOptions = object({
+  id: string(),
+  trackPageView: optional(boolean())
+  // default true
+});
+export function useScriptTikTokPixel(_options) {
+  return useRegistryScript("tiktokPixel", (options) => ({
+    scriptInput: {
+      src: withQuery("https://analytics.tiktok.com/i18n/pixel/events.js", {
+        sdkid: options?.id,
+        lib: "ttq"
+      }),
+      crossorigin: false
+    },
+    schema: import.meta.dev ? TikTokPixelOptions : void 0,
+    scriptOptions: {
+      use() {
+        return { ttq: window.ttq };
+      }
+    },
+    clientInit: import.meta.server ? void 0 : () => {
+      const ttq = window.ttq = function(...params) {
+        if (ttq.callMethod) {
+          ttq.callMethod(...params);
+        } else {
+          ttq.queue.push(params);
+        }
+      };
+      ttq.push = ttq;
+      ttq.loaded = true;
+      ttq.queue = [];
+      if (options?.id) {
+        ttq("init", options.id);
+        if (options?.trackPageView !== false) {
+          ttq("page");
+        }
+      }
+    }
+  }), _options);
+}

package/dist/runtime/server/google-static-maps-proxy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/google-static-maps-proxy.js

@@ -0,0 +1,54 @@
+import { createError, defineEventHandler, getHeader, getQuery, setHeader } from "h3";
+import { $fetch } from "ofetch";
+import { withQuery } from "ufo";
+import { useRuntimeConfig } from "#imports";
+export default defineEventHandler(async (event) => {
+  const runtimeConfig = useRuntimeConfig();
+  const publicConfig = runtimeConfig.public["nuxt-scripts"]?.googleStaticMapsProxy;
+  const privateConfig = runtimeConfig["nuxt-scripts"]?.googleStaticMapsProxy;
+  if (!publicConfig?.enabled) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Google Static Maps proxy is not enabled"
+    });
+  }
+  const apiKey = privateConfig?.apiKey;
+  if (!apiKey) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Google Maps API key not configured for proxy"
+    });
+  }
+  const referer = getHeader(event, "referer");
+  const host = getHeader(event, "host");
+  if (referer && host) {
+    const refererUrl = new URL(referer).host;
+    if (refererUrl !== host) {
+      throw createError({
+        statusCode: 403,
+        statusMessage: "Invalid referer"
+      });
+    }
+  }
+  const query = getQuery(event);
+  const { key: _clientKey, ...safeQuery } = query;
+  const googleMapsUrl = withQuery("https://maps.googleapis.com/maps/api/staticmap", {
+    ...safeQuery,
+    key: apiKey
+  });
+  const response = await $fetch.raw(googleMapsUrl, {
+    headers: {
+      "User-Agent": "Nuxt Scripts Google Static Maps Proxy"
+    }
+  }).catch((error) => {
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.statusMessage || "Failed to fetch static map"
+    });
+  });
+  const cacheMaxAge = publicConfig.cacheMaxAge || 3600;
+  setHeader(event, "Content-Type", response.headers.get("content-type") || "image/png");
+  setHeader(event, "Cache-Control", `public, max-age=${cacheMaxAge}, s-maxage=${cacheMaxAge}`);
+  setHeader(event, "Vary", "Accept-Encoding");
+  return response._data;
+});

package/dist/runtime/types.d.ts

@@ -29,8 +29,17 @@ import type { UmamiAnalyticsInput } from './registry/umami-analytics.js';
 import type { RybbitAnalyticsInput } from './registry/rybbit-analytics.js';
 import type { RedditPixelInput } from './registry/reddit-pixel.js';
 import type { PayPalInput } from './registry/paypal.js';
+import type { PostHogInput } from './registry/posthog.js';
+import type { GoogleRecaptchaInput } from './registry/google-recaptcha.js';
+import type { TikTokPixelInput } from './registry/tiktok-pixel.js';
 export type WarmupStrategy = false | 'preload' | 'preconnect' | 'dns-prefetch';
-export type UseScriptContext<T extends Record<symbol | string, any>> = VueScriptInstance<T>;
+export type UseScriptContext<T extends Record<symbol | string, any>> = VueScriptInstance<T> & {
+    /**
+     * Remove and reload the script. Useful for scripts that need to re-execute
+     * after SPA navigation (e.g., DOM-scanning scripts like iubenda).
+     */
+    reload: () => Promise<T>;
+};
 export type NuxtUseScriptOptions<T extends Record<symbol | string, any> = {}> = Omit<UseScriptOptions<T>, 'trigger'> & {
     /**
      * The trigger to load the script:
@@ -135,16 +144,19 @@ export interface ScriptRegistry {
     googleAdsense?: GoogleAdsenseInput;
     googleAnalytics?: GoogleAnalyticsInput;
     googleMaps?: GoogleMapsInput;
+    googleRecaptcha?: GoogleRecaptchaInput;
     lemonSqueezy?: LemonSqueezyInput;
     googleTagManager?: GoogleTagManagerInput;
     hotjar?: HotjarInput;
     intercom?: IntercomInput;
     paypal?: PayPalInput;
+    posthog?: PostHogInput;
     matomoAnalytics?: MatomoAnalyticsInput;
     rybbitAnalytics?: RybbitAnalyticsInput;
     redditPixel?: RedditPixelInput;
     segment?: SegmentInput;
     stripe?: StripeInput;
+    tiktokPixel?: TikTokPixelInput;
     xPixel?: XPixelInput;
     snapchatPixel?: SnapTrPixelInput;
     youtubePlayer?: YouTubePlayerInput;

package/dist/runtime/utils.d.ts

@@ -10,7 +10,8 @@ type OptionsFn<O> = (options: InferIfSchema<O>, ctx: {
     scriptInput?: UseScriptInput;
     scriptOptions?: NuxtUseScriptOptions;
     schema?: O extends ObjectSchema<any, any> ? O : undefined;
-    clientInit?: () => void;
+    clientInit?: () => void | Promise<any>;
+    scriptMode?: 'external' | 'npm';
 });
 export declare function scriptRuntimeConfig<T extends keyof ScriptRegistry>(key: T): ScriptRegistry[T];
 export declare function useRegistryScript<T extends Record<string | symbol, any>, O = EmptyOptionsSchema>(registryKey: keyof ScriptRegistry | string, optionsFn: OptionsFn<O>, _userOptions?: RegistryScriptInput<O>): UseScriptContext<UseFunctionType<NuxtUseScriptOptions<T>, T>>;