@nuxt/scripts 0.13.2 → 1.0.0-beta.12

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 { array, boolean, literal, object, optional, string, union } from "#nuxt-scripts-validator";
+import { useRegistryScript } from "#nuxt-scripts/utils";
+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

@@ -1,5 +1,5 @@
-import type { GTag } from './google-analytics.js';
 import type { NuxtUseScriptOptions, RegistryScriptInput, UseFunctionType, UseScriptContext } from '#nuxt-scripts/types';
+import type { GTag } from './google-analytics.js';
 /**
  * Improved DataLayer type that better reflects GTM's capabilities
  * Can contain either gtag event parameters or custom data objects
@@ -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 { boolean, literal, number, object, optional, record, string, union } from "#nuxt-scripts-validator";
 import { useRegistryScript } from "#nuxt-scripts/utils";
-import { object, string, optional, boolean, union, literal } from "#nuxt-scripts-validator";
+import { withQuery } from "ufo";
 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/hotjar.js

@@ -1,5 +1,5 @@
-import { useRegistryScript } from "../utils.js";
 import { number, object, optional } from "#nuxt-scripts-validator";
+import { useRegistryScript } from "../utils.js";
 export const HotjarOptions = object({
   id: number(),
   sv: optional(number())

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

@@ -0,0 +1,23 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+export declare const InstagramEmbedOptions: import("valibot").ObjectSchema<{
+    /**
+     * The Instagram post URL to embed
+     * e.g., https://www.instagram.com/p/ABC123/
+     */
+    readonly postUrl: import("valibot").StringSchema<undefined>;
+    /**
+     * Whether to include captions in the embed
+     * @default true
+     */
+    readonly captions: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * Custom API endpoint for fetching embed HTML
+     * @default '/api/_scripts/instagram-embed'
+     */
+    readonly apiEndpoint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export type InstagramEmbedInput = RegistryScriptInput<typeof InstagramEmbedOptions, false, false, false>;
+/**
+ * Extract the post shortcode from an Instagram URL
+ */
+export declare function extractInstagramShortcode(url: string): string | undefined;

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

@@ -0,0 +1,22 @@
+import { boolean, object, optional, string } from "#nuxt-scripts-validator";
+export const InstagramEmbedOptions = object({
+  /**
+   * The Instagram post URL to embed
+   * e.g., https://www.instagram.com/p/ABC123/
+   */
+  postUrl: string(),
+  /**
+   * Whether to include captions in the embed
+   * @default true
+   */
+  captions: optional(boolean()),
+  /**
+   * Custom API endpoint for fetching embed HTML
+   * @default '/api/_scripts/instagram-embed'
+   */
+  apiEndpoint: optional(string())
+});
+export function extractInstagramShortcode(url) {
+  const match = url.match(/instagram\.com\/(?:p|reel|tv)\/([^/?]+)/);
+  return match?.[1];
+}

package/dist/runtime/registry/intercom.js

@@ -1,6 +1,6 @@
+import { literal, number, object, optional, string, union } from "#nuxt-scripts-validator";
 import { joinURL } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { literal, number, object, optional, string, union } from "#nuxt-scripts-validator";
 export const IntercomOptions = object({
   app_id: string(),
   api_base: optional(union([literal("https://api-iam.intercom.io"), literal("https://api-iam.eu.intercom.io"), literal("https://api-iam.au.intercom.io")])),

package/dist/runtime/registry/lemon-squeezy.d.ts

@@ -21,7 +21,6 @@ export type LemonSqueezyEventPayload = {
 export interface LemonSqueezyApi {
     /**
      * Initialises Lemon.js on your page.
-     * @param options - An object with a single property, eventHandler, which is a function that will be called when Lemon.js emits an event.
      */
     Setup: (options: {
         eventHandler: (event: LemonSqueezyEventPayload) => void;

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

@@ -1,8 +1,8 @@
+import { boolean, number, object, optional, string, union } from "#nuxt-scripts-validator";
 import { withBase, withHttps, withoutProtocol, withoutTrailingSlash } from "ufo";
-import { useRegistryScript } from "../utils.js";
 import { useScriptEventPage } from "../composables/useScriptEventPage.js";
-import { boolean, object, optional, string, number, union } from "#nuxt-scripts-validator";
 import { logger } from "../logger.js";
+import { useRegistryScript } from "../utils.js";
 export const MatomoAnalyticsOptions = object({
   matomoUrl: optional(string()),
   siteId: optional(union([string(), number()])),
@@ -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/meta-pixel.js

@@ -1,5 +1,5 @@
-import { useRegistryScript } from "../utils.js";
 import { number, object, string, union } from "#nuxt-scripts-validator";
+import { useRegistryScript } from "../utils.js";
 export const MetaPixelOptions = object({
   id: union([string(), number()])
 });

package/dist/runtime/registry/npm.js

@@ -1,6 +1,6 @@
+import { literal, object, optional, string, union } from "#nuxt-scripts-validator";
 import { withBase } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { object, optional, string, union, literal } from "#nuxt-scripts-validator";
 const PROVIDERS = ["jsdelivr", "cdnjs", "unpkg"];
 const providerValidator = union(PROVIDERS.map((provider) => literal(provider)));
 export const NpmOptions = object({

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

@@ -1,5 +1,5 @@
-import type { PayPalNamespace } from '@paypal/paypal-js';
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { PayPalNamespace } from '@paypal/paypal-js';
 export interface PayPalApi {
     paypal: PayPalNamespace;
 }

package/dist/runtime/registry/paypal.js

@@ -1,6 +1,6 @@
+import { array, boolean, object, optional, string, union } from "#nuxt-scripts-validator";
 import { withQuery } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { object, string, optional, array, union, boolean } from "#nuxt-scripts-validator";
 export const PayPalOptions = object({
   clientId: string(),
   buyerCountry: optional(string()),
@@ -27,7 +27,7 @@ export const PayPalOptions = object({
 });
 export function useScriptPayPal(_options) {
   return useRegistryScript("paypal", (options) => {
-    let dataMerchantId = void 0;
+    let dataMerchantId;
     if (Array.isArray(options?.merchantId) && options?.merchantId.length > 1) {
       dataMerchantId = JSON.stringify(options.merchantId);
       options.merchantId = "*";

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

@@ -1,6 +1,6 @@
-import { useRegistryScript } from "../utils.js";
 import { any, array, boolean, literal, object, optional, record, string, union } from "#nuxt-scripts-validator";
 import { logger } from "../logger.js";
+import { useRegistryScript } from "../utils.js";
 const extensions = [
   literal("hash"),
   literal("outbound-links"),
@@ -55,12 +55,18 @@ export function useScriptPlausibleAnalytics(_options) {
       scriptSrc = "https://plausible.io/js/script.js";
     }
     const initOptions = {};
-    if (options?.customProperties) initOptions.customProperties = options.customProperties;
-    if (options?.endpoint) initOptions.endpoint = options.endpoint;
-    if (options?.fileDownloads) initOptions.fileDownloads = options.fileDownloads;
-    if (options?.hashBasedRouting !== void 0) initOptions.hashBasedRouting = options.hashBasedRouting;
-    if (options?.autoCapturePageviews !== void 0) initOptions.autoCapturePageviews = options.autoCapturePageviews;
-    if (options?.captureOnLocalhost !== void 0) initOptions.captureOnLocalhost = options.captureOnLocalhost;
+    if (options?.customProperties)
+      initOptions.customProperties = options.customProperties;
+    if (options?.endpoint)
+      initOptions.endpoint = options.endpoint;
+    if (options?.fileDownloads)
+      initOptions.fileDownloads = options.fileDownloads;
+    if (options?.hashBasedRouting !== void 0)
+      initOptions.hashBasedRouting = options.hashBasedRouting;
+    if (options?.autoCapturePageviews !== void 0)
+      initOptions.autoCapturePageviews = options.autoCapturePageviews;
+    if (options?.captureOnLocalhost !== void 0)
+      initOptions.captureOnLocalhost = options.captureOnLocalhost;
     const scriptInput = !useNewScript && options?.domain ? {
       "src": scriptSrc,
       "data-domain": options.domain
@@ -74,13 +80,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(...args) {
+            (w.plausible.q = w.plausible.q || []).push(args);
+          };
+          w.plausible.init = w.plausible.init || function(i) {
+            w.plausible.o = i || {};
           };
-          window.plausible.init(initOptions);
+          w.plausible.init(initOptions);
         }
       }
     };

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

@@ -0,0 +1,27 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { PostHog } from 'posthog-js';
+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 apiHost: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly autocapture: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly capturePageview: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").BooleanSchema<undefined>, import("valibot").LiteralSchema<"history_change", undefined>], 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,88 @@
+import { any, boolean, literal, object, optional, record, string, union } from "#nuxt-scripts-validator";
+import { logger } from "../logger.js";
+import { useRegistryScript } from "../utils.js";
+export const PostHogOptions = object({
+  apiKey: string(),
+  region: optional(union([literal("us"), literal("eu")])),
+  apiHost: optional(string()),
+  autocapture: optional(boolean()),
+  capturePageview: optional(union([boolean(), literal("history_change")])),
+  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";
+        let apiHost = options?.apiHost || (region === "eu" ? "https://eu.i.posthog.com" : "https://us.i.posthog.com");
+        if (apiHost.startsWith("/"))
+          apiHost = window.location.origin + apiHost;
+        window.__posthogInitPromise = import("posthog-js").then(({ default: posthog }) => {
+          const config = {
+            api_host: apiHost,
+            ...options?.config
+          };
+          if (typeof options?.autocapture === "boolean")
+            config.autocapture = options.autocapture;
+          if (typeof options?.capturePageview === "boolean" || options?.capturePageview === "history_change")
+            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;
+          const instance = posthog.init(options.apiKey, config);
+          if (!instance) {
+            logger.error("PostHog init returned undefined - initialization failed");
+            delete window._posthogQueue;
+            return void 0;
+          }
+          window.posthog = instance;
+          if (window._posthogQueue && window._posthogQueue.length > 0) {
+            window._posthogQueue.forEach((q) => window.posthog[q.prop]?.(...q.args));
+            delete window._posthogQueue;
+          }
+          return window.posthog;
+        }).catch((e) => {
+          logger.error("Failed to load posthog-js:", e);
+          delete window._posthogQueue;
+          return void 0;
+        });
+        return window.__posthogInitPromise;
+      }
+    };
+  }, _options);
+}

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

@@ -1,5 +1,5 @@
-import { useRegistryScript } from "../utils.js";
 import { object, string } from "#nuxt-scripts-validator";
+import { useRegistryScript } from "../utils.js";
 export const RedditPixelOptions = object({
   id: string()
 });

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

@@ -1,5 +1,5 @@
-import { useRegistryScript } from "../utils.js";
 import { array, boolean, number, object, optional, string, union } from "#nuxt-scripts-validator";
+import { useRegistryScript } from "../utils.js";
 export const RybbitAnalyticsOptions = object({
   siteId: union([string(), number()]),
   // required
@@ -15,7 +15,41 @@ 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 +70,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/segment.js

@@ -1,6 +1,6 @@
+import { object, optional, string } from "#nuxt-scripts-validator";
 import { joinURL } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { object, optional, string } from "#nuxt-scripts-validator";
 export const SegmentOptions = object({
   writeKey: string(),
   analyticsKey: optional(string())

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

@@ -1,5 +1,5 @@
-import { useRegistryScript } from "../utils.js";
 import { boolean, object, optional, string } from "#nuxt-scripts-validator";
+import { useRegistryScript } from "../utils.js";
 export const InitObjectPropertiesSchema = object({
   user_email: optional(string()),
   ip_address: optional(string()),

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

@@ -1,5 +1,5 @@
-import type { StripeConstructor } from '@stripe/stripe-js';
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { StripeConstructor } from '@stripe/stripe-js';
 export declare const StripeOptions: import("valibot").ObjectSchema<{
     readonly advancedFraudSignals: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
 }, undefined>;

package/dist/runtime/registry/stripe.js

@@ -1,6 +1,6 @@
+import { boolean, object, optional } from "#nuxt-scripts-validator";
 import { withQuery } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { boolean, object, optional } from "#nuxt-scripts-validator";
 export const StripeOptions = object({
   advancedFraudSignals: optional(boolean())
 });