@nuxt/scripts 0.13.2 → 1.0.0-beta.2

package/dist/runtime/npm-script-stub.d.ts

@@ -0,0 +1,20 @@
+import type { Ref } from 'vue';
+import type { NuxtUseScriptOptions } from './types.js';
+export interface NpmScriptStubOptions {
+    key: string;
+    use?: () => any;
+    clientInit?: () => void | Promise<any>;
+    trigger?: NuxtUseScriptOptions['trigger'];
+}
+export interface NpmScriptStub<T = any> {
+    status: Ref<'awaitingLoad' | 'loading' | 'loaded' | 'error'>;
+    load: () => Promise<void>;
+    onLoaded: (callback: (api: T) => void) => void;
+    proxy: T;
+    $script?: any;
+}
+/**
+ * Creates a script stub for NPM-only packages (no external script tag)
+ * Manages lifecycle and status without relying on script tag loading
+ */
+export declare function createNpmScriptStub<T = any>(options: NpmScriptStubOptions): NpmScriptStub<T>;

package/dist/runtime/npm-script-stub.js

@@ -0,0 +1,73 @@
+import { ref } from "vue";
+import { logger } from "./logger.js";
+export function createNpmScriptStub(options) {
+  const status = ref("awaitingLoad");
+  const loadedCallbacks = [];
+  let initPromise = null;
+  let hasInitialized = false;
+  const proxy = options.use?.() || {};
+  const stub = {
+    status,
+    proxy,
+    async load() {
+      if (hasInitialized || status.value !== "awaitingLoad")
+        return;
+      hasInitialized = true;
+      status.value = "loading";
+      try {
+        if (options.clientInit) {
+          console.log(`[NpmScriptStub] Initializing ${options.key}...`);
+          initPromise = Promise.resolve(options.clientInit());
+          await initPromise;
+          console.log(`[NpmScriptStub] ${options.key} initialized successfully`);
+        }
+        status.value = "loaded";
+        loadedCallbacks.forEach((cb) => {
+          try {
+            cb(proxy);
+          } catch (error) {
+            logger.error(`[NpmScriptStub] Error in onLoaded callback for ${options.key}:`, error);
+          }
+        });
+      } catch (error) {
+        logger.error(`[NpmScriptStub] Failed to initialize ${options.key}:`, error);
+        status.value = "error";
+      }
+    },
+    onLoaded(callback) {
+      if (status.value === "loaded") {
+        callback(proxy);
+      } else {
+        loadedCallbacks.push(callback);
+      }
+    },
+    // Mock $script for compatibility with useScript API
+    get $script() {
+      return {
+        status: status.value,
+        load: stub.load
+      };
+    }
+  };
+  if (options.trigger) {
+    if (typeof options.trigger === "function") {
+      const res = options.trigger(() => stub.load());
+      if (res && typeof res === "object" && "then" in res)
+        res.then(() => stub.load());
+    } else if (options.trigger === "manual") {
+    } else if (options.trigger === "onNuxtReady") {
+      import("nuxt/app").then(({ onNuxtReady }) => {
+        onNuxtReady(() => stub.load());
+      });
+    } else if (options.trigger === "client") {
+      if (import.meta.client) {
+        stub.load();
+      }
+    }
+  } else {
+    if (import.meta.client) {
+      stub.load();
+    }
+  }
+  return stub;
+}

package/dist/runtime/plugins/sw-register.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/sw-register.client.js

@@ -0,0 +1,12 @@
+import { defineNuxtPlugin } from "nuxt/app";
+export default defineNuxtPlugin({
+  name: "nuxt-scripts:sw-register",
+  enforce: "pre",
+  async setup() {
+    if (!("serviceWorker" in navigator))
+      return;
+    await navigator.serviceWorker.register(SW_PATH, { scope: "/" }).catch((err) => {
+      console.warn("[nuxt-scripts] Service worker registration failed:", err);
+    });
+  }
+});

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

@@ -0,0 +1,27 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+export declare const GoogleRecaptchaOptions: import("valibot").ObjectSchema<{
+    readonly siteKey: import("valibot").StringSchema<undefined>;
+    readonly enterprise: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly recaptchaNet: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly hl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export type GoogleRecaptchaInput = RegistryScriptInput<typeof GoogleRecaptchaOptions>;
+export interface GoogleRecaptchaApi {
+    grecaptcha: {
+        ready: (callback: () => void) => void;
+        execute: (siteKey: string, options: {
+            action: string;
+        }) => Promise<string>;
+        enterprise?: {
+            ready: (callback: () => void) => void;
+            execute: (siteKey: string, options: {
+                action: string;
+            }) => Promise<string>;
+        };
+    };
+}
+declare global {
+    interface Window extends GoogleRecaptchaApi {
+    }
+}
+export declare function useScriptGoogleRecaptcha<T extends GoogleRecaptchaApi>(_options?: GoogleRecaptchaInput): import("#nuxt-scripts/types").UseScriptContext<T>;

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/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/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

@@ -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(...args) {
+            (w.plausible.q = w.plausible.q || []).push(args);
           };
-          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
           };
         }