@nuxt/scripts 0.11.13 → 0.12.1

package/dist/runtime/composables/useScriptTriggerInteraction.d.ts

@@ -0,0 +1,15 @@
+export interface InteractionScriptTriggerOptions {
+    /**
+     * The interaction events to listen for.
+     */
+    events: string[];
+    /**
+     * The element to listen for events on.
+     * @default document.documentElement
+     */
+    target?: EventTarget | null;
+}
+/**
+ * Create a trigger that loads a script when any of the specified interaction events occur.
+ */
+export declare function useScriptTriggerInteraction(options: InteractionScriptTriggerOptions): Promise<boolean>;

package/dist/runtime/composables/useScriptTriggerInteraction.js

@@ -0,0 +1,35 @@
+import { useEventListener } from "@vueuse/core";
+import { tryOnScopeDispose } from "@vueuse/shared";
+import { onNuxtReady } from "nuxt/app";
+export function useScriptTriggerInteraction(options) {
+  if (import.meta.server) {
+    return new Promise(() => {
+    });
+  }
+  const { events, target = document.documentElement } = options;
+  return new Promise((resolve) => {
+    onNuxtReady(() => {
+      if (!target) {
+        resolve(false);
+        return;
+      }
+      const cleanupFns = [];
+      events.forEach((event) => {
+        const cleanup = useEventListener(
+          target,
+          event,
+          () => {
+            cleanupFns.forEach((fn) => fn());
+            resolve(true);
+          },
+          { once: true, passive: true }
+        );
+        cleanupFns.push(cleanup);
+      });
+      tryOnScopeDispose(() => {
+        cleanupFns.forEach((fn) => fn());
+        resolve(false);
+      });
+    });
+  });
+}

package/dist/runtime/logger.d.ts

@@ -0,0 +1 @@
+export declare const logger: import("consola").ConsolaInstance;

package/dist/runtime/logger.js

@@ -0,0 +1,6 @@
+import { createConsola } from "consola";
+export const logger = createConsola({
+  defaults: {
+    tag: "nuxt-scripts"
+  }
+});

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

@@ -0,0 +1,77 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+export declare const DatabuddyAnalyticsOptions: import("valibot").ObjectSchema<{
+    readonly clientId: import("valibot").StringSchema<undefined>;
+    readonly scriptUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly apiUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly disabled: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly trackScreenViews: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly trackPerformance: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly trackSessions: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly trackWebVitals: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly trackErrors: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly trackOutgoingLinks: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly trackScrollDepth: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly trackEngagement: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly trackInteractions: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly trackAttributes: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly trackHashChanges: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly trackExitIntent: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly trackBounceRate: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly enableBatching: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly batchSize: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    readonly batchTimeout: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    readonly enableRetries: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly maxRetries: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    readonly initialRetryDelay: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    readonly samplingRate: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    readonly sdk: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly sdkVersion: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly enableObservability: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly observabilityService: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly observabilityEnvironment: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly observabilityVersion: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly enableLogging: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly enableTracing: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly enableErrorTracking: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+}, undefined>;
+export type DatabuddyAnalyticsInput = RegistryScriptInput<typeof DatabuddyAnalyticsOptions, false>;
+export interface DatabuddyAnalyticsApi {
+    /**
+     * Track a custom event.
+     * @param eventName Name of the event (use snake_case)
+     * @param properties Optional event properties
+     */
+    track: (eventName: string, properties?: Record<string, any>) => Promise<any> | any | void;
+    /**
+     * Manually record a page / screen view. Useful for SPA route changes.
+     * @param path Optional path to record (defaults to current location)
+     * @param properties Optional additional properties for the screen view
+     */
+    screenView: (path?: string, properties?: Record<string, any>) => void;
+    /**
+     * Set properties that will be attached to all future events (e.g. user_id).
+     * @param properties Key/value map of properties to attach globally
+     */
+    setGlobalProperties: (properties: Record<string, any>) => void;
+    /**
+     * Track a custom event alias (compatibility helper present on the global)
+     * @param eventName Name of the event
+     * @param properties Optional event properties
+     */
+    trackCustomEvent: (eventName: string, properties?: Record<string, any>) => void;
+    /**
+     * Clears session and anonymous identifiers (useful on logout).
+     */
+    clear: () => void;
+    /**
+     * Force immediate sending of any queued/batched events.
+     */
+    flush: () => void;
+}
+declare global {
+    interface Window {
+        databuddy?: DatabuddyAnalyticsApi;
+        db?: DatabuddyAnalyticsApi;
+    }
+}
+export declare function useScriptDatabuddyAnalytics<T extends DatabuddyAnalyticsApi>(_options?: DatabuddyAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;

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

@@ -0,0 +1,103 @@
+import { useRegistryScript } from "../utils.js";
+import { object, optional, string, boolean, number } from "#nuxt-scripts-validator";
+export const DatabuddyAnalyticsOptions = object({
+  // Required
+  clientId: string(),
+  // Advanced
+  scriptUrl: optional(string()),
+  // defaults to https://cdn.databuddy.cc/databuddy.js
+  apiUrl: optional(string()),
+  // defaults to https://basket.databuddy.cc
+  disabled: optional(boolean()),
+  // Core tracking (enabled by default by SDK)
+  trackScreenViews: optional(boolean()),
+  trackPerformance: optional(boolean()),
+  trackSessions: optional(boolean()),
+  // Optional tracking
+  trackWebVitals: optional(boolean()),
+  trackErrors: optional(boolean()),
+  trackOutgoingLinks: optional(boolean()),
+  trackScrollDepth: optional(boolean()),
+  trackEngagement: optional(boolean()),
+  trackInteractions: optional(boolean()),
+  trackAttributes: optional(boolean()),
+  trackHashChanges: optional(boolean()),
+  trackExitIntent: optional(boolean()),
+  trackBounceRate: optional(boolean()),
+  // Performance options
+  enableBatching: optional(boolean()),
+  batchSize: optional(number()),
+  batchTimeout: optional(number()),
+  enableRetries: optional(boolean()),
+  maxRetries: optional(number()),
+  initialRetryDelay: optional(number()),
+  samplingRate: optional(number()),
+  // SDK metadata
+  sdk: optional(string()),
+  sdkVersion: optional(string()),
+  // Observability & logging (accepted by SDK config)
+  enableObservability: optional(boolean()),
+  observabilityService: optional(string()),
+  observabilityEnvironment: optional(string()),
+  observabilityVersion: optional(string()),
+  enableLogging: optional(boolean()),
+  enableTracing: optional(boolean()),
+  enableErrorTracking: optional(boolean())
+});
+export function useScriptDatabuddyAnalytics(_options) {
+  return useRegistryScript("databuddyAnalytics", (options) => {
+    return {
+      scriptInput: {
+        // Default CDN script, can be overridden via scriptUrl
+        "src": options?.scriptUrl || "https://cdn.databuddy.cc/databuddy.js",
+        "data-client-id": options.clientId,
+        // Advanced
+        "data-api-url": options?.apiUrl,
+        "data-disabled": options?.disabled,
+        // Core
+        "data-track-screen-views": options?.trackScreenViews,
+        "data-track-performance": options?.trackPerformance,
+        "data-track-sessions": options?.trackSessions,
+        // Optional
+        "data-track-web-vitals": options?.trackWebVitals,
+        "data-track-errors": options?.trackErrors,
+        "data-track-outgoing-links": options?.trackOutgoingLinks,
+        "data-track-scroll-depth": options?.trackScrollDepth,
+        "data-track-engagement": options?.trackEngagement,
+        "data-track-interactions": options?.trackInteractions,
+        "data-track-attributes": options?.trackAttributes,
+        "data-track-hash-changes": options?.trackHashChanges,
+        "data-track-exit-intent": options?.trackExitIntent,
+        "data-track-bounce-rate": options?.trackBounceRate,
+        // Performance tuning
+        "data-enable-batching": options?.enableBatching,
+        "data-batch-size": options?.batchSize,
+        "data-batch-timeout": options?.batchTimeout,
+        "data-enable-retries": options?.enableRetries,
+        "data-max-retries": options?.maxRetries,
+        "data-initial-retry-delay": options?.initialRetryDelay,
+        "data-sampling-rate": options?.samplingRate,
+        // SDK meta
+        "data-sdk": options?.sdk,
+        "data-sdk-version": options?.sdkVersion,
+        // Observability & logging
+        "data-enable-observability": options?.enableObservability,
+        "data-observability-service": options?.observabilityService,
+        "data-observability-environment": options?.observabilityEnvironment,
+        "data-observability-version": options?.observabilityVersion,
+        "data-enable-logging": options?.enableLogging,
+        "data-enable-tracing": options?.enableTracing,
+        "data-enable-error-tracking": options?.enableErrorTracking
+      },
+      schema: import.meta.dev ? DatabuddyAnalyticsOptions : void 0,
+      scriptOptions: {
+        use() {
+          if (typeof window === "undefined") {
+            return null;
+          }
+          return window.db || window.databuddy || null;
+        }
+      }
+    };
+  }, _options);
+}

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

@@ -56,7 +56,7 @@ export interface GoogleAnalyticsApi {
     dataLayer: DataLayer;
 }
 export declare const GoogleAnalyticsOptions: import("valibot").ObjectSchema<{
-    readonly id: import("valibot").StringSchema<undefined>;
+    readonly id: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
     readonly l: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
 }, undefined>;
 export type GoogleAnalyticsInput = RegistryScriptInput<typeof GoogleAnalyticsOptions>;

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

@@ -2,7 +2,7 @@ import { withQuery } from "ufo";
 import { useRegistryScript } from "#nuxt-scripts/utils";
 import { object, string, optional } from "#nuxt-scripts-validator";
 export const GoogleAnalyticsOptions = object({
-  id: string(),
+  id: optional(string()),
   // The GA4 measurement ID (format: G-XXXXXXXX)
   l: optional(string())
   // Optional global name for dataLayer (defaults to 'dataLayer')
@@ -22,9 +22,7 @@ export function useScriptGoogleAnalytics(_options) {
             dataLayer: w[dataLayerName],
             gtag: w.gtag
           };
-        },
-        performanceMarkFeature: "nuxt-third-parties-ga",
-        tagPriority: 1
+        }
       },
       clientInit: import.meta.server ? void 0 : () => {
         w[dataLayerName] = w[dataLayerName] || [];
@@ -33,7 +31,9 @@ export function useScriptGoogleAnalytics(_options) {
         };
         _options?.onBeforeGtagStart?.(w.gtag);
         w.gtag("js", /* @__PURE__ */ new Date());
-        w.gtag("config", options?.id);
+        if (options?.id) {
+          w.gtag("config", options?.id);
+        }
       }
     };
   }, _options);

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

@@ -50,14 +50,12 @@ export function useScriptGoogleTagManager(options) {
               dataLayer: window[dataLayerName],
               google_tag_manager: window.google_tag_manager
             };
-          },
-          performanceMarkFeature: "nuxt-third-parties-gtm",
-          tagPriority: 1
+          }
         },
         clientInit: import.meta.server ? void 0 : () => {
           window[dataLayerName] = window[dataLayerName] || [];
-          function gtag(...args) {
-            window[dataLayerName].push(args);
+          function gtag() {
+            window[dataLayerName].push(arguments);
           }
           options?.onBeforeGtmStart?.(gtag);
           window[dataLayerName].push({

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

@@ -7,6 +7,7 @@ export declare const MatomoAnalyticsOptions: import("valibot").ObjectSchema<{
     readonly trackPageView: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
     readonly enableLinkTracking: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
     readonly disableCookies: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly watch: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
 }, undefined>;
 export type MatomoAnalyticsInput = RegistryScriptInput<typeof MatomoAnalyticsOptions, false, false, false>;
 interface MatomoAnalyticsApi {

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

@@ -1,6 +1,8 @@
 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";
 export const MatomoAnalyticsOptions = object({
   matomoUrl: optional(string()),
   siteId: optional(union([string(), number()])),
@@ -8,7 +10,8 @@ export const MatomoAnalyticsOptions = object({
   trackerUrl: optional(string()),
   trackPageView: optional(boolean()),
   enableLinkTracking: optional(boolean()),
-  disableCookies: optional(boolean())
+  disableCookies: optional(boolean()),
+  watch: optional(boolean())
 });
 export function useScriptMatomoAnalytics(_options) {
   return useRegistryScript("matomoAnalytics", (options) => {
@@ -23,7 +26,16 @@ export function useScriptMatomoAnalytics(_options) {
       schema: import.meta.dev ? MatomoAnalyticsOptions : void 0,
       scriptOptions: {
         use() {
-          return { _paq: window._paq };
+          const _paqProxy = {
+            push: (...args) => {
+              if (window._paq && typeof window._paq.push === "function") {
+                return window._paq.push(...args);
+              }
+              window._paq = window._paq || [];
+              return window._paq.push(...args);
+            }
+          };
+          return { _paq: _paqProxy };
         }
       },
       clientInit: import.meta.server ? void 0 : () => {
@@ -39,8 +51,19 @@ export function useScriptMatomoAnalytics(_options) {
           _paq.push(["setTrackerUrl", withBase(`/matomo.php`, withHttps(normalizedCloudId))]);
         }
         _paq.push(["setSiteId", String(options?.siteId) || "1"]);
-        if (options?.trackPageView) {
-          _paq.push(["trackPageView"]);
+        if (options?.trackPageView !== void 0) {
+          if (import.meta.dev) {
+            logger.warn("The `trackPageView` option is deprecated. Use `watch: true` (default) for automatic page view tracking, or remove this option entirely.");
+          }
+          if (options.trackPageView) {
+            _paq.push(["trackPageView"]);
+          }
+        } else if (options?.watch !== false) {
+          useScriptEventPage((payload) => {
+            window._paq.push(["setDocumentTitle", payload.title]);
+            window._paq.push(["setCustomUrl", payload.path]);
+            window._paq.push(["trackPageView"]);
+          });
         }
       }
     };

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

@@ -0,0 +1,34 @@
+import type { PayPalNamespace } from '@paypal/paypal-js';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+export interface PayPalApi {
+    paypal: PayPalNamespace;
+}
+declare global {
+    interface Window extends PayPalApi {
+    }
+}
+export declare const PayPalOptions: import("valibot").ObjectSchema<{
+    readonly clientId: import("valibot").StringSchema<undefined>;
+    readonly buyerCountry: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly commit: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly components: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly currency: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly debug: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").BooleanSchema<undefined>], undefined>, undefined>;
+    readonly disableFunding: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly enableFunding: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly integrationDate: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly intent: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly locale: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /**
+     * loadScript() supports an array for merchantId, even though
+     * merchant-id technically may not contain multiple values.
+     * For an array with a length of > 1 it automatically sets
+     * merchantId to "*" and moves the actual values to dataMerchantId
+     */
+    readonly merchantId: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
+    readonly partnerAttributionId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly vault: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").BooleanSchema<undefined>], undefined>, undefined>;
+    readonly sandbox: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+}, undefined>;
+export type PayPalInput = RegistryScriptInput<typeof PayPalOptions>;
+export declare function useScriptPayPal<T extends PayPalApi>(_options?: PayPalInput): import("#nuxt-scripts/types").UseScriptContext<T>;

package/dist/runtime/registry/paypal.js

@@ -0,0 +1,86 @@
+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()),
+  commit: optional(string()),
+  components: optional(union([string(), array(string())])),
+  currency: optional(string()),
+  debug: optional(union([string(), boolean()])),
+  disableFunding: optional(union([string(), array(string())])),
+  enableFunding: optional(union([string(), array(string())])),
+  integrationDate: optional(string()),
+  intent: optional(string()),
+  locale: optional(string()),
+  /**
+   * loadScript() supports an array for merchantId, even though
+   * merchant-id technically may not contain multiple values.
+   * For an array with a length of > 1 it automatically sets
+   * merchantId to "*" and moves the actual values to dataMerchantId
+   */
+  merchantId: optional(union([string(), array(string())])),
+  partnerAttributionId: optional(string()),
+  vault: optional(union([string(), boolean()])),
+  // own props
+  sandbox: optional(boolean())
+});
+export function useScriptPayPal(_options) {
+  return useRegistryScript("paypal", (options) => {
+    let dataMerchantId = void 0;
+    if (Array.isArray(options?.merchantId) && options?.merchantId.length > 1) {
+      dataMerchantId = JSON.stringify(options.merchantId);
+      options.merchantId = "*";
+    }
+    if (Array.isArray(options?.components)) {
+      options.components = options.components.join(",");
+    }
+    if (Array.isArray(options?.disableFunding)) {
+      options.disableFunding = options.disableFunding.join(",");
+    }
+    if (Array.isArray(options?.enableFunding)) {
+      options.enableFunding = options.enableFunding.join(",");
+    }
+    if (options?.sandbox === void 0) {
+      options.sandbox = import.meta.dev;
+    }
+    let components = ["buttons", "messages", "marks", "card-fields", "funding-eligibility"].join(",");
+    if (options.components) {
+      if (Array.isArray(options.components)) {
+        components = options.components.join(",");
+      } else {
+        components = options.components;
+      }
+    }
+    return {
+      scriptInput: {
+        "src": withQuery(options.sandbox ? "https://www.sandbox.paypal.com/sdk/js" : "https://www.paypal.com/sdk/js", {
+          "client-id": options.clientId,
+          "buyer-country": options.buyerCountry,
+          "commit": options.commit,
+          "components": components,
+          "currency": options.currency,
+          "debug": options.debug,
+          "disable-funding": options.disableFunding,
+          "enable-funding": options.enableFunding,
+          "integration-date": options.integrationDate,
+          "intent": options.intent,
+          "locale": options.locale,
+          "vault": options.vault
+        }),
+        "data-merchant-id": dataMerchantId,
+        "data-partner-attribution-id": options.partnerAttributionId
+        // TODO: maybe nuxt specific default
+      },
+      schema: import.meta.dev ? PayPalOptions : void 0,
+      // trigger: 'client',
+      scriptOptions: {
+        use() {
+          return {
+            paypal: window.paypal
+          };
+        }
+      }
+    };
+  }, _options);
+}

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

@@ -0,0 +1,18 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+type RdtFns = ((event: 'init', id: string) => void) & ((event: 'track', eventName: string) => void);
+export interface RedditPixelApi {
+    rdt: RdtFns & {
+        sendEvent: (rdt: RedditPixelApi['rdt'], args: unknown[]) => void;
+        callQueue: unknown[];
+    };
+}
+declare global {
+    interface Window extends RedditPixelApi {
+    }
+}
+export declare const RedditPixelOptions: import("valibot").ObjectSchema<{
+    readonly id: import("valibot").StringSchema<undefined>;
+}, undefined>;
+export type RedditPixelInput = RegistryScriptInput<typeof RedditPixelOptions, true, false, false>;
+export declare function useScriptRedditPixel<T extends RedditPixelApi>(_options?: RedditPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export {};

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

@@ -0,0 +1,36 @@
+import { useRegistryScript } from "../utils.js";
+import { object, string } from "#nuxt-scripts-validator";
+export const RedditPixelOptions = object({
+  id: string()
+});
+export function useScriptRedditPixel(_options) {
+  return useRegistryScript("redditPixel", (options) => {
+    return {
+      scriptInput: {
+        src: "https://www.redditstatic.com/ads/pixel.js",
+        async: true
+      },
+      clientInit: import.meta.server ? void 0 : () => {
+        const rdt = function(...args) {
+          if (rdt.sendEvent) {
+            rdt.sendEvent(rdt, args);
+          } else {
+            rdt.callQueue.push(args);
+          }
+        };
+        rdt.callQueue = [];
+        window.rdt = rdt;
+        if (options?.id) {
+          rdt("init", options.id);
+          rdt("track", "PageVisit");
+        }
+      },
+      schema: import.meta.dev ? RedditPixelOptions : void 0,
+      scriptOptions: {
+        use() {
+          return { rdt: window.rdt };
+        }
+      }
+    };
+  }, _options);
+}

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

@@ -1,10 +1,10 @@
-import type { Stripe } from '@stripe/stripe-js';
+import type { StripeConstructor } from '@stripe/stripe-js';
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
 export declare const StripeOptions: import("valibot").ObjectSchema<{
     readonly advancedFraudSignals: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
 }, undefined>;
 export type StripeInput = RegistryScriptInput<typeof StripeOptions, false>;
 export interface StripeApi {
-    Stripe: Stripe;
+    Stripe: StripeConstructor;
 }
 export declare function useScriptStripe<T extends StripeApi>(_options?: StripeInput): import("#nuxt-scripts/types").UseScriptContext<T>;

package/dist/runtime/registry/stripe.js

@@ -8,7 +8,7 @@ export function useScriptStripe(_options) {
   return useRegistryScript("stripe", (options) => ({
     scriptInput: {
       src: withQuery(
-        `https://js.stripe.com/v3/`,
+        `https://js.stripe.com/basil/stripe.js`,
         typeof options?.advancedFraudSignals === "boolean" && !options?.advancedFraudSignals ? { advancedFraudSignals: false } : {}
       ),
       // opt-out of privacy defaults

package/dist/runtime/types.d.ts

@@ -1,7 +1,7 @@
 import type { Script } from '@unhead/vue/types';
 import type { UseScriptInput, VueScriptInstance, UseScriptOptions } from '@unhead/vue';
 import type { ComputedRef, Ref } from 'vue';
-import type { InferInput, ObjectSchema } from 'valibot';
+import type { InferInput, ObjectSchema, ValiError } from 'valibot';
 import type { Import } from 'unimport';
 import type { SegmentInput } from './registry/segment.js';
 import type { CloudflareWebAnalyticsInput } from './registry/cloudflare-web-analytics.js';
@@ -26,6 +26,8 @@ import type { GoogleAnalyticsInput } from './registry/google-analytics.js';
 import type { GoogleTagManagerInput } from './registry/google-tag-manager.js';
 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';
 export type WarmupStrategy = false | 'preload' | 'preconnect' | 'dns-prefetch';
 export type UseScriptContext<T extends Record<symbol | string, any>> = VueScriptInstance<T>;
 export type NuxtUseScriptOptions<T extends Record<symbol | string, any> = {}> = Omit<UseScriptOptions<T>, 'trigger'> & {
@@ -41,9 +43,12 @@ export type NuxtUseScriptOptions<T extends Record<symbol | string, any> = {}> =
      * performance by avoiding the extra DNS lookup and reducing the number of requests. It also
      * improves privacy by not sharing the user's IP address with third-party servers.
      * - `true` - Bundle the script as an asset.
+     * - `'force'` - Bundle the script and force download, bypassing cache. Useful for development.
      * - `false` - Do not bundle the script. (default)
+     *
+     * Note: Using 'force' may significantly increase build time as scripts will be re-downloaded on every build.
      */
-    bundle?: boolean;
+    bundle?: boolean | 'force';
     /**
      * Skip any schema validation for the script input. This is useful for loading the script stubs for development without
      * loading the actual script and not getting warnings.
@@ -59,10 +64,6 @@ export type NuxtUseScriptOptions<T extends Record<symbol | string, any> = {}> =
      *  to `false` if the origin is the same.
      */
     warmupStrategy?: WarmupStrategy;
-    /**
-     * @internal
-     */
-    performanceMarkFeature?: string;
     /**
      * @internal
      */
@@ -78,9 +79,17 @@ export type NuxtUseScriptOptions<T extends Record<symbol | string, any> = {}> =
          */
         registryMeta?: Record<string, string>;
     };
+    /**
+     * @internal
+     */
+    _validate?: () => ValiError<any> | null | undefined;
 };
 export type NuxtUseScriptOptionsSerializable = Omit<NuxtUseScriptOptions, 'use' | 'skipValidation' | 'stub' | 'trigger' | 'eventContext' | 'beforeInit'> & {
-    trigger?: 'client' | 'server' | 'onNuxtReady';
+    trigger?: 'client' | 'server' | 'onNuxtReady' | {
+        idleTimeout: number;
+    } | {
+        interaction: string[];
+    };
 };
 export type NuxtUseScriptInput = UseScriptInput;
 export interface TrackedPage {
@@ -128,8 +137,10 @@ export interface ScriptRegistry {
     googleTagManager?: GoogleTagManagerInput;
     hotjar?: HotjarInput;
     intercom?: IntercomInput;
+    paypal?: PayPalInput;
     matomoAnalytics?: MatomoAnalyticsInput;
     rybbitAnalytics?: RybbitAnalyticsInput;
+    redditPixel?: RedditPixelInput;
     segment?: SegmentInput;
     stripe?: StripeInput;
     xPixel?: XPixelInput;