@nuxt/scripts 1.0.0-beta.3 → 1.0.0-beta.31

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

@@ -1,17 +1,19 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-type ClarityFunctions = ((fn: 'start', options: {
-    content: boolean;
-    cookies: string[];
-    dob: number;
-    expire: number;
-    projectId: string;
-    upload: string;
+import { ClarityOptions } from './schemas.js';
+export { ClarityOptions };
+type ClarityFunctions = ((fn: 'start', options?: {
+    content?: boolean;
+    cookies?: string[];
+    dob?: number;
+    expire?: number;
+    projectId?: string;
+    upload?: string;
 }) => void) & ((fn: 'identify', id: string, session?: string, page?: string, userHint?: string) => Promise<{
     id: string;
     session: string;
     page: string;
     userHint: string;
-}>) & ((fn: 'consent', enabled?: boolean) => void) & ((fn: 'set', key: any, value: any) => void) & ((fn: 'event', value: any) => void) & ((fn: 'upgrade', upgradeReason: any) => void) & ((fn: string, ...args: any[]) => void);
+}>) & ((fn: 'consent', enabled?: boolean | Record<string, string>) => void) & ((fn: 'set', key: string, value: string | string[]) => void) & ((fn: 'event', value: string) => void) & ((fn: 'upgrade', upgradeReason: string) => void) & ((fn: (string & {}), ...args: any[]) => void);
 export interface ClarityApi {
     clarity: ClarityFunctions & {
         q: any[];
@@ -22,12 +24,5 @@ declare global {
     interface Window extends ClarityApi {
     }
 }
-export declare const ClarityOptions: import("valibot").ObjectSchema<{
-    /**
-     * The Clarity token.
-     */
-    readonly id: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 10, undefined>]>;
-}, undefined>;
 export type ClarityInput = RegistryScriptInput<typeof ClarityOptions>;
 export declare function useScriptClarity<T extends ClarityApi>(_options?: ClarityInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

package/dist/runtime/registry/clarity.js

@@ -1,36 +1,27 @@
 import { useRegistryScript } from "../utils.js";
-import { minLength, object, string, pipe } from "#nuxt-scripts-validator";
-export const ClarityOptions = object({
-  /**
-   * The Clarity token.
-   */
-  id: pipe(string(), minLength(10))
-});
+import { ClarityOptions } from "./schemas.js";
+export { ClarityOptions };
 export function useScriptClarity(_options) {
-  return useRegistryScript(
-    "clarity",
-    (options) => ({
-      scriptInput: {
-        src: `https://www.clarity.ms/tag/${options.id}`
-      },
-      schema: import.meta.dev ? ClarityOptions : void 0,
-      scriptOptions: {
-        use() {
-          return {
-            // @ts-expect-error untyped
-            clarity: Object.assign(function(...params) {
-              const clarity = window.clarity;
-              return clarity.apply(this, params);
-            }, window.clarity)
-          };
-        }
-      },
-      clientInit: import.meta.server ? void 0 : () => {
-        window.clarity = window.clarity || function(...params) {
-          (window.clarity.q = window.clarity.q || []).push(params);
+  return useRegistryScript("clarity", (options) => ({
+    scriptInput: {
+      src: `https://www.clarity.ms/tag/${options.id}`
+    },
+    schema: import.meta.dev ? ClarityOptions : void 0,
+    scriptOptions: {
+      use() {
+        return {
+          // @ts-expect-error untyped
+          clarity: Object.assign(function(...params) {
+            const clarity = window.clarity;
+            return clarity.apply(this, params);
+          }, window.clarity)
         };
       }
-    }),
-    _options
-  );
+    },
+    clientInit: import.meta.server ? void 0 : () => {
+      window.clarity = window.clarity || function(...params) {
+        (window.clarity.q = window.clarity.q || []).push(params);
+      };
+    }
+  }), _options);
 }

package/dist/runtime/registry/cloudflare-web-analytics.d.ts

@@ -1,4 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { CloudflareWebAnalyticsOptions } from './schemas.js';
+export { CloudflareWebAnalyticsOptions };
 /**
  * Sample:
  * <!-- Cloudflare Web Analytics -->
@@ -16,18 +18,5 @@ declare global {
     interface Window extends CloudflareWebAnalyticsApi {
     }
 }
-export declare const CloudflareWebAnalyticsOptions: import("valibot").ObjectSchema<{
-    /**
-     * The Cloudflare Web Analytics token.
-     */
-    readonly token: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 32, undefined>]>;
-    /**
-     * Cloudflare Web Analytics enables measuring SPAs automatically by overriding the History API’s pushState function
-     * and listening to the onpopstate. Hash-based router is not supported.
-     *
-     * @default true
-     */
-    readonly spa: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-}, undefined>;
 export type CloudflareWebAnalyticsInput = RegistryScriptInput<typeof CloudflareWebAnalyticsOptions>;
 export declare function useScriptCloudflareWebAnalytics<T extends CloudflareWebAnalyticsApi>(_options?: CloudflareWebAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;

package/dist/runtime/registry/cloudflare-web-analytics.js

@@ -1,18 +1,6 @@
 import { useRegistryScript } from "../utils.js";
-import { boolean, minLength, object, optional, pipe, string } from "#nuxt-scripts-validator";
-export const CloudflareWebAnalyticsOptions = object({
-  /**
-   * The Cloudflare Web Analytics token.
-   */
-  token: pipe(string(), minLength(32)),
-  /**
-   * Cloudflare Web Analytics enables measuring SPAs automatically by overriding the History API’s pushState function
-   * and listening to the onpopstate. Hash-based router is not supported.
-   *
-   * @default true
-   */
-  spa: optional(boolean())
-});
+import { CloudflareWebAnalyticsOptions } from "./schemas.js";
+export { CloudflareWebAnalyticsOptions };
 export function useScriptCloudflareWebAnalytics(_options) {
   return useRegistryScript("cloudflareWebAnalytics", (options) => ({
     scriptInput: {

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

@@ -1,46 +1,16 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const CrispOptions: import("valibot").ObjectSchema<{
-    /**
-     * The Crisp ID.
-     */
-    readonly id: import("valibot").StringSchema<undefined>;
-    /**
-     * Extra configuration options. Used to configure the locale.
-     * Same as CRISP_RUNTIME_CONFIG.
-     * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/language-customization/
-     */
-    readonly runtimeConfig: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
-        readonly locale: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>;
-    /**
-     * Associated a session, equivalent to using CRISP_TOKEN_ID variable.
-     * Same as CRISP_TOKEN_ID.
-     * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/session-continuity/
-     */
-    readonly tokenId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /**
-     * Restrict the domain that the Crisp cookie is set on.
-     * Same as CRISP_COOKIE_DOMAIN.
-     * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/cookie-policies/
-     */
-    readonly cookieDomain: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /**
-     * The cookie expiry in seconds.
-     * Same as CRISP_COOKIE_EXPIRATION.
-     * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/cookie-policies/#change-cookie-expiration-date
-     */
-    readonly cookieExpiry: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
-}, undefined>;
-export type CrispInput = RegistryScriptInput<typeof CrispOptions, false, false, false>;
+import { CrispOptions } from './schemas.js';
+export { CrispOptions };
+export type CrispInput = RegistryScriptInput<typeof CrispOptions, false, false>;
 export interface CrispApi {
     push: (...args: any[]) => void;
-    is: (name: 'chat:opened' | 'chat:closed' | 'chat:visible' | 'chat:hidden' | 'chat:small' | 'chat:large' | 'session:ongoing' | 'website:available' | 'overlay:opened' | 'overlay:closed' | string) => boolean;
-    set: (name: 'message:text' | 'session:data' | 'session:segments' | 'session:event' | 'user:email' | 'user:phone' | 'user:nickname' | 'user:avatar' | 'user:company' | string, value: any) => void;
-    get: (name: 'chat:unread:count' | 'message:text' | 'session:identifier' | 'session:data' | 'user:email' | 'user:phone' | 'user:nickname' | 'user:avatar' | 'user:company' | string) => any;
-    do: (name: 'chat:open' | 'chat:close' | 'chat:toggle' | 'chat:show' | 'chat:hide' | 'helpdesk:search' | 'helpdesk:article:open' | 'helpdesk:query' | 'overlay:open' | 'overlay:close' | 'message:send' | 'message:show' | 'message:read' | 'message:thread:start' | 'message:thread:end' | 'session:reset' | 'trigger:run' | string, arg2?: any) => any;
-    on: (name: 'session:loaded' | 'chat:initiated' | 'chat:opened' | 'chat:closed' | 'message:sent' | 'message:received' | 'message:compose:sent' | 'message:compose:received' | 'user:email:changed' | 'user:phone:changed' | 'user:nickname:changed' | 'user:avatar:changed' | 'website:availability:changed' | 'helpdesk:queried' | string, callback: (...args: any[]) => any) => void;
-    off: (name: 'session:loaded' | 'chat:initiated' | 'chat:opened' | 'chat:closed' | 'message:sent' | 'message:received' | 'message:compose:sent' | 'message:compose:received' | 'user:email:changed' | 'user:phone:changed' | 'user:nickname:changed' | 'user:avatar:changed' | 'website:availability:changed' | 'helpdesk:queried' | string, callback: (...args: any[]) => any) => void;
-    config: (options: any) => void;
+    is: (name: 'chat:opened' | 'chat:closed' | 'chat:visible' | 'chat:hidden' | 'chat:small' | 'chat:large' | 'session:ongoing' | 'website:available' | 'overlay:opened' | 'overlay:closed' | (string & {})) => boolean;
+    set: ((name: 'message:text' | 'user:email' | 'user:phone' | 'user:nickname' | 'user:avatar' | 'user:company', value: string) => void) & ((name: 'session:data', value: [[string, string | number | boolean], ...[string, string | number | boolean][]]) => void) & ((name: 'session:segments', value: string[]) => void) & ((name: 'session:event', value: [[string, Record<string, any>?, string?]]) => void) & ((name: (string & {}), value: any) => void);
+    get: ((name: 'chat:unread:count') => number) & ((name: 'message:text' | 'session:identifier' | 'user:email' | 'user:phone' | 'user:nickname' | 'user:avatar' | 'user:company') => string) & ((name: 'session:data', key: string) => string | number | boolean) & ((name: (string & {})) => any);
+    do: (name: 'chat:open' | 'chat:close' | 'chat:toggle' | 'chat:show' | 'chat:hide' | 'helpdesk:search' | 'helpdesk:article:open' | 'helpdesk:query' | 'overlay:open' | 'overlay:close' | 'message:send' | 'message:show' | 'message:read' | 'message:thread:start' | 'message:thread:end' | 'session:reset' | 'trigger:run', arg2?: any) => any;
+    on: (name: 'session:loaded' | 'chat:initiated' | 'chat:opened' | 'chat:closed' | 'message:sent' | 'message:received' | 'message:compose:sent' | 'message:compose:received' | 'user:email:changed' | 'user:phone:changed' | 'user:nickname:changed' | 'user:avatar:changed' | 'website:availability:changed' | 'helpdesk:queried' | (string & {}), callback: (...args: any[]) => any) => void;
+    off: (name: 'session:loaded' | 'chat:initiated' | 'chat:opened' | 'chat:closed' | 'message:sent' | 'message:received' | 'message:compose:sent' | 'message:compose:received' | 'user:email:changed' | 'user:phone:changed' | 'user:nickname:changed' | 'user:avatar:changed' | 'website:availability:changed' | 'helpdesk:queried' | (string & {}), callback: (...args: any[]) => any) => void;
+    config: ((name: 'container:index', value: number) => void) & ((name: 'color:theme', value: 'default' | 'amber' | 'black' | 'blue' | 'blue_grey' | 'light_blue' | 'brown' | 'cyan' | 'green' | 'light_green' | 'grey' | 'indigo' | 'orange' | 'deep_orange' | 'pink' | 'purple' | 'deep_purple' | 'red' | 'teal') => void) & ((name: 'position:reverse' | 'hide:on:mobile' | 'hide:on:away' | 'lock:maximized' | 'lock:fullview' | 'show:operator:count' | 'sound:mute', value: boolean) => void) & ((name: (string & {}), value: any) => void);
     help: () => void;
     [key: string]: any;
 }

package/dist/runtime/registry/crisp.js

@@ -1,37 +1,6 @@
 import { useRegistryScript } from "../utils.js";
-import { object, string, optional, number } from "#nuxt-scripts-validator";
-export const CrispOptions = object({
-  /**
-   * The Crisp ID.
-   */
-  id: string(),
-  /**
-   * Extra configuration options. Used to configure the locale.
-   * Same as CRISP_RUNTIME_CONFIG.
-   * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/language-customization/
-   */
-  runtimeConfig: optional(object({
-    locale: optional(string())
-  })),
-  /**
-   * Associated a session, equivalent to using CRISP_TOKEN_ID variable.
-   * Same as CRISP_TOKEN_ID.
-   * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/session-continuity/
-   */
-  tokenId: optional(string()),
-  /**
-   * Restrict the domain that the Crisp cookie is set on.
-   * Same as CRISP_COOKIE_DOMAIN.
-   * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/cookie-policies/
-   */
-  cookieDomain: optional(string()),
-  /**
-   * The cookie expiry in seconds.
-   * Same as CRISP_COOKIE_EXPIRATION.
-   * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/cookie-policies/#change-cookie-expiration-date
-   */
-  cookieExpiry: optional(number())
-});
+import { CrispOptions } from "./schemas.js";
+export { CrispOptions };
 export function useScriptCrisp(_options) {
   let readyPromise = Promise.resolve();
   return useRegistryScript("crisp", (options) => ({

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

@@ -1,39 +1,6 @@
 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>;
+import { DatabuddyAnalyticsOptions } from './schemas.js';
+export { DatabuddyAnalyticsOptions };
 export type DatabuddyAnalyticsInput = RegistryScriptInput<typeof DatabuddyAnalyticsOptions, false>;
 export interface DatabuddyAnalyticsApi {
     /**

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

@@ -1,49 +1,6 @@
 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())
-});
+import { DatabuddyAnalyticsOptions } from "./schemas.js";
+export { DatabuddyAnalyticsOptions };
 export function useScriptDatabuddyAnalytics(_options) {
   return useRegistryScript("databuddyAnalytics", (options) => {
     return {
@@ -96,6 +53,24 @@ export function useScriptDatabuddyAnalytics(_options) {
             return null;
           }
           return window.db || window.databuddy || null;
+        },
+        // The SDK finds config by searching for a <script> with src containing
+        // "/databuddy.js". When first-party bundling rewrites the src to
+        // /_scripts/<hash>.js, the lookup fails. Set window.databuddyConfig
+        // so the SDK picks up the config regardless of script src.
+        clientInit: import.meta.server ? void 0 : () => {
+          const cfg = { clientId: options.clientId };
+          if (options?.apiUrl)
+            cfg.apiUrl = options.apiUrl;
+          if (options?.disabled)
+            cfg.disabled = options.disabled;
+          if (options?.trackScreenViews)
+            cfg.trackScreenViews = options.trackScreenViews;
+          if (options?.trackPerformance)
+            cfg.trackPerformance = options.trackPerformance;
+          if (options?.trackSessions)
+            cfg.trackSessions = options.trackSessions;
+          window.databuddyConfig = cfg;
         }
       }
     };

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

@@ -1,27 +1,7 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const FathomAnalyticsOptions: import("valibot").ObjectSchema<{
-    /**
-     * The Fathom Analytics site ID.
-     */
-    readonly site: import("valibot").StringSchema<undefined>;
-    /**
-     * The Fathom Analytics tracking mode.
-     */
-    readonly spa: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"auto", undefined>, import("valibot").LiteralSchema<"history", undefined>, import("valibot").LiteralSchema<"hash", undefined>], undefined>, undefined>;
-    /**
-     * Automatically track page views.
-     */
-    readonly auto: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    /**
-     * Enable canonical URL tracking.
-     */
-    readonly canonical: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    /**
-     * Honor Do Not Track requests.
-     */
-    readonly honorDnt: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-}, undefined>;
-export type FathomAnalyticsInput = RegistryScriptInput<typeof FathomAnalyticsOptions, false, false, false>;
+import { FathomAnalyticsOptions } from './schemas.js';
+export { FathomAnalyticsOptions };
+export type FathomAnalyticsInput = RegistryScriptInput<typeof FathomAnalyticsOptions, false, false>;
 export interface FathomAnalyticsApi {
     beacon: (ctx: {
         url: string;
@@ -32,14 +12,15 @@ export interface FathomAnalyticsApi {
     isTrackingEnabled: () => boolean;
     send: (type: string, data: unknown) => void;
     setSite: (siteId: string) => void;
-    sideId: string;
+    siteId: string;
     trackPageview: (ctx?: {
         url: string;
         referrer?: string;
     }) => void;
     trackGoal: (goalId: string, cents: number) => void;
-    trackEvent: (eventName: string, value: {
-        _value: number;
+    trackEvent: (eventName: string, value?: {
+        _value?: number;
+        _site_id?: string;
     }) => void;
 }
 declare global {

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

@@ -1,32 +1,10 @@
 import { useRegistryScript } from "../utils.js";
-import { boolean, literal, object, optional, string, union } from "#nuxt-scripts-validator";
-export const FathomAnalyticsOptions = object({
-  /**
-   * The Fathom Analytics site ID.
-   */
-  site: string(),
-  /**
-   * The Fathom Analytics tracking mode.
-   */
-  spa: optional(union([literal("auto"), literal("history"), literal("hash")])),
-  /**
-   * Automatically track page views.
-   */
-  auto: optional(boolean()),
-  /**
-   * Enable canonical URL tracking.
-   */
-  canonical: optional(boolean()),
-  /**
-   * Honor Do Not Track requests.
-   */
-  honorDnt: optional(boolean())
-});
+import { FathomAnalyticsOptions } from "./schemas.js";
+export { FathomAnalyticsOptions };
 export function useScriptFathomAnalytics(_options) {
   return useRegistryScript("fathomAnalytics", (options) => ({
     scriptInput: {
       src: "https://cdn.usefathom.com/script.js",
-      // can't be bundled
       // append the data attr's
       ...Object.entries(options).filter(([key]) => ["site", "spa", "auto", "canonical", "honorDnt"].includes(key)).reduce((acc, [_key, value]) => {
         const key = _key === "honourDnt" ? "honor-dnt" : _key;

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

@@ -1,15 +1,7 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const GoogleAdsenseOptions: import("valibot").ObjectSchema<{
-    /**
-     * The Google Adsense ID.
-     */
-    readonly client: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /**
-     * Enable or disable Auto Ads.
-     */
-    readonly autoAds: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-}, undefined>;
-export type GoogleAdsenseInput = RegistryScriptInput<typeof GoogleAdsenseOptions, true, false, false>;
+import { GoogleAdsenseOptions } from './schemas.js';
+export { GoogleAdsenseOptions };
+export type GoogleAdsenseInput = RegistryScriptInput<typeof GoogleAdsenseOptions, true, false>;
 export interface GoogleAdsenseApi {
     /**
      * The Google Adsense API.

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

@@ -1,16 +1,7 @@
 import { useHead } from "nuxt/app";
 import { useRegistryScript } from "../utils.js";
-import { object, string, optional, boolean } from "#nuxt-scripts-validator";
-export const GoogleAdsenseOptions = object({
-  /**
-   * The Google Adsense ID.
-   */
-  client: optional(string()),
-  /**
-   * Enable or disable Auto Ads.
-   */
-  autoAds: optional(boolean())
-});
+import { GoogleAdsenseOptions } from "./schemas.js";
+export { GoogleAdsenseOptions };
 export function useScriptGoogleAdsense(_options) {
   return useRegistryScript("googleAdsense", (options) => ({
     scriptInput: {

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

@@ -1,4 +1,5 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { GoogleAnalyticsOptions } from './schemas.js';
 export type GtagCustomParams = Record<string, any>;
 export type ConsentStatus = 'granted' | 'denied';
 export interface ConsentOptions {
@@ -37,7 +38,7 @@ export interface EventParameters extends GtagCustomParams {
     }>;
     [key: string]: any;
 }
-export type DefaultEventName = 'add_payment_info' | 'add_shipping_info' | 'add_to_cart' | 'add_to_wishlist' | 'begin_checkout' | 'purchase' | 'refund' | 'remove_from_cart' | 'select_item' | 'select_promotion' | 'view_cart' | 'view_item' | 'view_item_list' | 'view_promotion' | 'login' | 'sign_up' | 'search' | 'page_view' | 'screen_view' | string;
+export type DefaultEventName = 'add_payment_info' | 'add_shipping_info' | 'add_to_cart' | 'add_to_wishlist' | 'begin_checkout' | 'purchase' | 'refund' | 'remove_from_cart' | 'select_item' | 'select_promotion' | 'view_cart' | 'view_item' | 'view_item_list' | 'view_promotion' | 'login' | 'sign_up' | 'search' | 'page_view' | 'screen_view' | (string & {});
 export interface GTag {
     (command: 'js', value: Date): void;
     (command: 'config', targetId: string, configParams?: ConfigParams): void;
@@ -55,10 +56,7 @@ export interface GoogleAnalyticsApi {
     gtag: GTag;
     dataLayer: DataLayer;
 }
-export declare const GoogleAnalyticsOptions: import("valibot").ObjectSchema<{
-    readonly id: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly l: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-}, undefined>;
+export { GoogleAnalyticsOptions };
 export type GoogleAnalyticsInput = RegistryScriptInput<typeof GoogleAnalyticsOptions>;
 export declare function useScriptGoogleAnalytics<T extends GoogleAnalyticsApi>(_options?: GoogleAnalyticsInput & {
     onBeforeGtagStart?: (gtag: GTag) => void;

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

@@ -1,12 +1,7 @@
-import { withQuery } from "ufo";
 import { useRegistryScript } from "#nuxt-scripts/utils";
-import { object, string, optional } from "#nuxt-scripts-validator";
-export const GoogleAnalyticsOptions = object({
-  id: optional(string()),
-  // The GA4 measurement ID (format: G-XXXXXXXX)
-  l: optional(string())
-  // Optional global name for dataLayer (defaults to 'dataLayer')
-});
+import { withQuery } from "ufo";
+import { GoogleAnalyticsOptions } from "./schemas.js";
+export { GoogleAnalyticsOptions };
 export function useScriptGoogleAnalytics(_options) {
   return useRegistryScript(_options?.key || "googleAnalytics", (options) => {
     const dataLayerName = options?.l ?? "dataLayer";

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

@@ -1,11 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const GoogleMapsOptions: import("valibot").ObjectSchema<{
-    readonly apiKey: import("valibot").StringSchema<undefined>;
-    readonly libraries: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-    readonly language: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly region: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly v: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"weekly", undefined>, import("valibot").LiteralSchema<"quarterly", undefined>, import("valibot").LiteralSchema<"beta", undefined>, import("valibot").LiteralSchema<"alpha", undefined>, import("valibot").StringSchema<undefined>], undefined>, undefined>;
-}, undefined>;
+import { GoogleMapsOptions } from './schemas.js';
+export { GoogleMapsOptions };
 export type GoogleMapsInput = RegistryScriptInput<typeof GoogleMapsOptions>;
 type MapsNamespace = typeof window.google.maps;
 export interface GoogleMapsApi {
@@ -15,10 +10,9 @@ declare global {
     interface Window {
         google: {
             maps: {
-                __ib__(): void;
+                __ib__: () => void;
             };
         };
     }
 }
 export declare function useScriptGoogleMaps<T extends GoogleMapsApi>(_options?: GoogleMapsInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

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

@@ -1,13 +1,7 @@
 import { withQuery } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { array, literal, object, optional, string, union } from "#nuxt-scripts-validator";
-export const GoogleMapsOptions = object({
-  apiKey: string(),
-  libraries: optional(array(string())),
-  language: optional(string()),
-  region: optional(string()),
-  v: optional(union([literal("weekly"), literal("quarterly"), literal("beta"), literal("alpha"), string()]))
-});
+import { GoogleMapsOptions } from "./schemas.js";
+export { GoogleMapsOptions };
 export function useScriptGoogleMaps(_options) {
   let readyPromise = Promise.resolve();
   return useRegistryScript("googleMaps", (options) => {

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

@@ -1,10 +1,6 @@
 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>;
+import { GoogleRecaptchaOptions } from './schemas.js';
+export { GoogleRecaptchaOptions };
 export type GoogleRecaptchaInput = RegistryScriptInput<typeof GoogleRecaptchaOptions>;
 export interface GoogleRecaptchaApi {
     grecaptcha: {

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

@@ -1,15 +1,7 @@
-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())
-});
+import { withQuery } from "ufo";
+import { GoogleRecaptchaOptions } from "./schemas.js";
+export { GoogleRecaptchaOptions };
 export function useScriptGoogleRecaptcha(_options) {
   return useRegistryScript(_options?.key || "googleRecaptcha", (options) => {
     const baseUrl = options?.recaptchaNet ? "https://www.recaptcha.net/recaptcha" : "https://www.google.com/recaptcha";
@@ -32,7 +24,7 @@ export function useScriptGoogleRecaptcha(_options) {
         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_cfg = w.___grecaptcha_cfg || {}).fns = [...w.___grecaptcha_cfg.fns || [], ...[cb]];
         };
         w.grecaptcha.ready = w.grecaptcha.ready || readyFn;
         if (options?.enterprise) {