@nuxt/scripts 0.11.10 → 0.12.0

package/dist/runtime/components/ScriptYouTubePlayer.d.vue.ts

@@ -0,0 +1,66 @@
+import type { HTMLAttributes, ImgHTMLAttributes, Ref } from 'vue';
+import type { ElementScriptTrigger } from '../types.js';
+export type YoutubeThumbnailSize = '1' | '2' | '3' | 'default' | 'mq1' | 'mq2' | 'mq3' | 'mqdefault' | '0' | 'hq1' | 'hq2' | 'hq3' | 'hqdefault' | 'sd1' | 'sd2' | 'sd3' | 'sddefault' | 'hq720' | 'maxresdefault';
+type __VLS_Props = {
+    placeholderAttrs?: ImgHTMLAttributes;
+    rootAttrs?: HTMLAttributes;
+    aboveTheFold?: boolean;
+    trigger?: ElementScriptTrigger;
+    videoId: string;
+    playerVars?: YT.PlayerVars;
+    width?: number;
+    height?: number;
+    /**
+     * Whether to use youtube-nocookie.com for embedding.
+     *
+     * @default false
+     */
+    cookies?: boolean;
+    playerOptions?: YT.PlayerOptions;
+    thumbnailSize?: YoutubeThumbnailSize;
+    webp?: boolean;
+};
+declare var __VLS_1: {
+    placeholder: any;
+}, __VLS_3: {}, __VLS_9: {}, __VLS_11: {}, __VLS_13: {};
+type __VLS_Slots = {} & {
+    placeholder?: (props: typeof __VLS_1) => any;
+} & {
+    loading?: (props: typeof __VLS_3) => any;
+} & {
+    awaitingLoad?: (props: typeof __VLS_9) => any;
+} & {
+    error?: (props: typeof __VLS_11) => any;
+} & {
+    default?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
+    player: Ref<YT.Player | undefined, YT.Player | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    error: (e: YT.OnErrorEvent, target: YT.Player) => any;
+    ready: (e: YT.PlayerEvent) => any;
+    "state-change": (e: YT.OnStateChangeEvent, target: YT.Player) => any;
+    "playback-quality-change": (e: YT.OnPlaybackQualityChangeEvent, target: YT.Player) => any;
+    "playback-rate-change": (e: YT.OnPlaybackRateChangeEvent, target: YT.Player) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onError?: ((e: YT.OnErrorEvent, target: YT.Player) => any) | undefined;
+    onReady?: ((e: YT.PlayerEvent) => any) | undefined;
+    "onState-change"?: ((e: YT.OnStateChangeEvent, target: YT.Player) => any) | undefined;
+    "onPlayback-quality-change"?: ((e: YT.OnPlaybackQualityChangeEvent, target: YT.Player) => any) | undefined;
+    "onPlayback-rate-change"?: ((e: YT.OnPlaybackRateChangeEvent, target: YT.Player) => any) | undefined;
+}>, {
+    trigger: ElementScriptTrigger;
+    width: number;
+    height: number;
+    playerVars: YT.PlayerVars;
+    cookies: boolean;
+    thumbnailSize: YoutubeThumbnailSize;
+    webp: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ScriptYouTubePlayer.vue.d.ts

@@ -48,7 +48,15 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
     "onState-change"?: ((e: YT.OnStateChangeEvent, target: YT.Player) => any) | undefined;
     "onPlayback-quality-change"?: ((e: YT.OnPlaybackQualityChangeEvent, target: YT.Player) => any) | undefined;
     "onPlayback-rate-change"?: ((e: YT.OnPlaybackRateChangeEvent, target: YT.Player) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {
+    trigger: ElementScriptTrigger;
+    width: number;
+    height: number;
+    playerVars: YT.PlayerVars;
+    cookies: boolean;
+    thumbnailSize: YoutubeThumbnailSize;
+    webp: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/runtime/composables/useScript.js

@@ -1,7 +1,8 @@
 import { defu } from "defu";
 import { useScript as _useScript } from "@unhead/vue/scripts";
 import { reactive } from "vue";
-import { onNuxtReady, useNuxtApp, useRuntimeConfig, injectHead } from "#imports";
+import { onNuxtReady, useNuxtApp, useRuntimeConfig, injectHead } from "nuxt/app";
+import { logger } from "../logger.js";
 function useNuxtScriptRuntimeConfig() {
   return useRuntimeConfig().public["nuxt-scripts"];
 }
@@ -11,6 +12,10 @@ export function resolveScriptKey(input) {
 export function useScript(input, options) {
   input = typeof input === "string" ? { src: input } : input;
   options = defu(options, useNuxtScriptRuntimeConfig()?.defaultScriptOptions);
+  if (import.meta.dev && options.bundle === "unsupported") {
+    console.warn("[Nuxt Scripts] Bundling is not supported for dynamic script sources. Static URLs are required for bundling.");
+    options.bundle = false;
+  }
   const id = String(resolveScriptKey(input));
   const nuxtApp = useNuxtApp();
   options.head = options.head || injectHead();
@@ -19,7 +24,20 @@ export function useScript(input, options) {
   }
   nuxtApp.$scripts = nuxtApp.$scripts || reactive({});
   const exists = !!nuxtApp.$scripts?.[id];
-  if (options.trigger === "onNuxtReady" || options.trigger === "client") {
+  const err = options._validate?.();
+  if (import.meta.dev && import.meta.client && err) {
+    options.trigger = new Promise(() => {
+    });
+    if (!exists) {
+      let out = `Skipping script \`${id}\` due to invalid options:
+`;
+      for (const e of err.issues) {
+        out += `  ${e.message}
+`;
+      }
+      logger.info(out);
+    }
+  } else if (options.trigger === "onNuxtReady" || options.trigger === "client") {
     if (!options.warmupStrategy) {
       options.warmupStrategy = "preload";
     }
@@ -33,6 +51,13 @@ export function useScript(input, options) {
     nuxtApp.$scripts[id] = void 0;
     return _remove();
   };
+  const _load = instance.load;
+  instance.load = async () => {
+    if (err) {
+      return Promise.reject(err);
+    }
+    return _load();
+  };
   nuxtApp.$scripts[id] = instance;
   if (import.meta.dev && import.meta.client) {
     let syncScripts = function() {
@@ -72,6 +97,14 @@ export function useScript(input, options) {
         syncScripts();
       });
       payload.$script = instance;
+      if (err) {
+        payload.events.push({
+          type: "status",
+          status: "validation-failed",
+          args: err,
+          at: Date.now()
+        });
+      }
       payload.events.push({
         type: "status",
         status: "awaitingLoad",

package/dist/runtime/composables/useScriptEventPage.js

@@ -1,5 +1,5 @@
 import { useNuxtApp, useRoute, injectHead } from "nuxt/app";
-import { ref } from "vue";
+import { ref, onScopeDispose } from "vue";
 export function useScriptEventPage(onChange) {
   const nuxt = useNuxtApp();
   const route = useRoute();
@@ -13,7 +13,7 @@ export function useScriptEventPage(onChange) {
   let lastPayload = { path: "", title: "" };
   let stopDomWatcher = () => {
   };
-  nuxt.hooks.hook("page:finish", () => {
+  const stopPageFinishHook = nuxt.hooks.hook("page:finish", () => {
     Promise.race([
       // possibly no head update is needed
       new Promise((resolve) => setTimeout(resolve, 100)),
@@ -33,5 +33,9 @@ export function useScriptEventPage(onChange) {
       }
     });
   });
+  onScopeDispose(() => {
+    stopDomWatcher();
+    stopPageFinishHook();
+  });
   return payload;
 }

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

@@ -0,0 +1,10 @@
+export interface IdleTimeoutScriptTriggerOptions {
+    /**
+     * The timeout in milliseconds to wait before loading the script.
+     */
+    timeout: number;
+}
+/**
+ * Create a trigger that loads a script after an idle timeout once Nuxt is ready.
+ */
+export declare function useScriptTriggerIdleTimeout(options: IdleTimeoutScriptTriggerOptions): Promise<boolean>;

package/dist/runtime/composables/useScriptTriggerIdleTimeout.js

@@ -0,0 +1,22 @@
+import { tryOnScopeDispose } from "@vueuse/shared";
+import { useTimeoutFn } from "@vueuse/core";
+import { onNuxtReady } from "nuxt/app";
+export function useScriptTriggerIdleTimeout(options) {
+  if (import.meta.server) {
+    return new Promise(() => {
+    });
+  }
+  const { timeout } = options;
+  return new Promise((resolve) => {
+    onNuxtReady(() => {
+      const { start, stop } = useTimeoutFn(() => {
+        resolve(true);
+      }, timeout, { immediate: false });
+      start();
+      tryOnScopeDispose(() => {
+        stop();
+        resolve(false);
+      });
+    });
+  });
+}

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