@nuxt/scripts 1.0.0-beta.15 → 1.0.0-beta.18

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

@@ -1,8 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const SegmentOptions: import("valibot").ObjectSchema<{
-    readonly writeKey: import("valibot").StringSchema<undefined>;
-    readonly analyticsKey: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-}, undefined>;
+import { SegmentOptions } from './schemas.js';
+export { SegmentOptions };
 export type SegmentInput = RegistryScriptInput<typeof SegmentOptions>;
 interface AnalyticsApi {
     track: (event: string, properties?: Record<string, any>) => void;
@@ -30,4 +28,3 @@ declare global {
     }
 }
 export declare function useScriptSegment<T extends SegmentApi>(_options?: SegmentInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

package/dist/runtime/registry/segment.js

@@ -1,10 +1,7 @@
-import { object, optional, string } from "#nuxt-scripts-validator";
 import { joinURL } from "ufo";
 import { useRegistryScript } from "../utils.js";
-export const SegmentOptions = object({
-  writeKey: string(),
-  analyticsKey: optional(string())
-});
+import { SegmentOptions } from "./schemas.js";
+export { SegmentOptions };
 const methods = ["track", "page", "identify", "group", "alias", "reset"];
 export function useScriptSegment(_options) {
   return useRegistryScript("segment", (options) => {

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

@@ -1,5 +1,7 @@
 import type { InferInput } from '#nuxt-scripts-validator';
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { InitObjectPropertiesSchema, SnapTrPixelOptions } from './schemas.js';
+export { InitObjectPropertiesSchema, SnapTrPixelOptions };
 type StandardEvents = 'PAGE_VIEW' | 'VIEW_CONTENT' | 'ADD_CART' | 'SIGN_UP' | 'SAVE' | 'START_CHECKOUT' | 'APP_OPEN' | 'ADD_BILLING' | 'SEARCH' | 'SUBSCRIBE' | 'AD_CLICK' | 'AD_VIEW' | 'COMPLETE_TUTORIAL' | 'LEVEL_COMPLETE' | 'INVITE' | 'LOGIN' | 'SHARE' | 'RESERVE' | 'ACHIEVEMENT_UNLOCKED' | 'ADD_TO_WISHLIST' | 'SPENT_CREDITS' | 'RATE' | 'START_TRIAL' | 'LIST_VIEW';
 interface EventObjectProperties {
     price?: number;
@@ -20,20 +22,6 @@ interface EventObjectProperties {
     event_tag?: string;
     [key: string]: any;
 }
-export declare const InitObjectPropertiesSchema: import("valibot").ObjectSchema<{
-    readonly user_email: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly ip_address: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly user_phone_number: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly user_hashed_email: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly user_hashed_phone_number: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly firstname: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly lastname: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_city: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_region: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_postal_code: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_country: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly age: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-}, undefined>;
 type InitObjectProperties = InferInput<typeof InitObjectPropertiesSchema>;
 type SnapTrFns = ((event: 'track', eventName: StandardEvents | '', data?: EventObjectProperties) => void) & ((event: 'init', id: string, data?: Record<string, any>) => void) & ((event: 'init', id: string, data?: InitObjectProperties) => void) & ((event: string, ...params: any[]) => void);
 export interface SnapPixelApi {
@@ -50,22 +38,5 @@ declare global {
     interface Window extends SnapPixelApi {
     }
 }
-export declare const SnapTrPixelOptions: import("valibot").ObjectSchema<{
-    readonly user_email: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly ip_address: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly user_phone_number: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly user_hashed_email: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly user_hashed_phone_number: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly firstname: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly lastname: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_city: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_region: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_postal_code: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_country: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly age: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly id: import("valibot").StringSchema<undefined>;
-    readonly trackPageView: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-}, undefined>;
 export type SnapTrPixelInput = RegistryScriptInput<typeof SnapTrPixelOptions, true, false, false>;
 export declare function useScriptSnapchatPixel<T extends SnapPixelApi>(_options?: SnapTrPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

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

@@ -1,24 +1,6 @@
-import { boolean, object, optional, string } from "#nuxt-scripts-validator";
 import { useRegistryScript } from "../utils.js";
-export const InitObjectPropertiesSchema = object({
-  user_email: optional(string()),
-  ip_address: optional(string()),
-  user_phone_number: optional(string()),
-  user_hashed_email: optional(string()),
-  user_hashed_phone_number: optional(string()),
-  firstname: optional(string()),
-  lastname: optional(string()),
-  geo_city: optional(string()),
-  geo_region: optional(string()),
-  geo_postal_code: optional(string()),
-  geo_country: optional(string()),
-  age: optional(string())
-});
-export const SnapTrPixelOptions = object({
-  id: string(),
-  trackPageView: optional(boolean()),
-  ...InitObjectPropertiesSchema?.entries || {}
-});
+import { InitObjectPropertiesSchema, SnapTrPixelOptions } from "./schemas.js";
+export { InitObjectPropertiesSchema, SnapTrPixelOptions };
 export function useScriptSnapchatPixel(_options) {
   return useRegistryScript("snapchatPixel", (options) => ({
     scriptInput: {

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

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

package/dist/runtime/registry/stripe.js

@@ -1,9 +1,7 @@
-import { boolean, object, optional } from "#nuxt-scripts-validator";
 import { withQuery } from "ufo";
 import { useRegistryScript } from "../utils.js";
-export const StripeOptions = object({
-  advancedFraudSignals: optional(boolean())
-});
+import { StripeOptions } from "./schemas.js";
+export { StripeOptions };
 export function useScriptStripe(_options) {
   return useRegistryScript("stripe", (options) => ({
     scriptInput: {

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

@@ -1,4 +1,5 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { TikTokPixelOptions } from './schemas.js';
 type StandardEvents = 'ViewContent' | 'ClickButton' | 'Search' | 'AddToWishlist' | 'AddToCart' | 'InitiateCheckout' | 'AddPaymentInfo' | 'CompletePayment' | 'PlaceAnOrder' | 'Contact' | 'Download' | 'SubmitForm' | 'CompleteRegistration' | 'Subscribe';
 interface EventProperties {
     content_id?: string;
@@ -35,10 +36,6 @@ declare global {
         TiktokAnalyticsObject: string;
     }
 }
-export declare const TikTokPixelOptions: import("valibot").ObjectSchema<{
-    readonly id: import("valibot").StringSchema<undefined>;
-    readonly trackPageView: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-}, undefined>;
+export { TikTokPixelOptions };
 export type TikTokPixelInput = RegistryScriptInput<typeof TikTokPixelOptions, true, false, false>;
 export declare function useScriptTikTokPixel<T extends TikTokPixelApi>(_options?: TikTokPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

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

@@ -1,11 +1,7 @@
-import { boolean, object, optional, string } from "#nuxt-scripts-validator";
 import { withQuery } from "ufo";
 import { useRegistryScript } from "../utils.js";
-export const TikTokPixelOptions = object({
-  id: string(),
-  trackPageView: optional(boolean())
-  // default true
-});
+import { TikTokPixelOptions } from "./schemas.js";
+export { TikTokPixelOptions };
 export function useScriptTikTokPixel(_options) {
   return useRegistryScript("tiktokPixel", (options) => ({
     scriptInput: {

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

@@ -1,35 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const UmamiAnalyticsOptions: import("valibot").ObjectSchema<{
-    readonly websiteId: import("valibot").StringSchema<undefined>;
-    /**
-     * By default, Umami will send data to wherever the script is located.
-     * You can override this to send data to another location.
-     */
-    readonly hostUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /**
-     * By default, Umami tracks all pageviews and events for you automatically.
-     * You can disable this behavior and track events yourself using the tracker functions.
-     * https://umami.is/docs/tracker-functions
-     */
-    readonly autoTrack: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    /**
-     * If you want the tracker to only run on specific domains, you can add them to your tracker script.
-     * This is a comma delimited list of domain names.
-     * Helps if you are working in a staging/development environment.
-     */
-    readonly domains: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-    /**
-     * If you want the tracker to collect events under a specific tag.
-     * Events can be filtered in the dashboard by a specific tag.
-     */
-    readonly tag: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /**
-     * Function that will be called before data is sent to Umami.
-     * The function takes two parameters: type and payload.
-     * Return the payload to continue sending, or return a falsy value to cancel.
-     */
-    readonly beforeSend: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").CustomSchema<(type: string, payload: Record<string, any>) => Record<string, any> | null | false, undefined>, import("valibot").StringSchema<undefined>], undefined>, undefined>;
-}, undefined>;
+import { UmamiAnalyticsOptions } from './schemas.js';
+export { UmamiAnalyticsOptions };
 export type UmamiAnalyticsInput = RegistryScriptInput<typeof UmamiAnalyticsOptions, false>;
 export interface UmamiAnalyticsApi {
     track: ((payload?: Record<string, any>) => void) & ((event_name: string, event_data: Record<string, any>) => void);

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

@@ -1,40 +1,6 @@
-import { array, boolean, custom, object, optional, string, union } from "#nuxt-scripts-validator";
 import { useRegistryScript } from "../utils.js";
-export const UmamiAnalyticsOptions = object({
-  websiteId: string(),
-  // required
-  /**
-   * By default, Umami will send data to wherever the script is located.
-   * You can override this to send data to another location.
-   */
-  hostUrl: optional(string()),
-  /**
-   * By default, Umami tracks all pageviews and events for you automatically.
-   * You can disable this behavior and track events yourself using the tracker functions.
-   * https://umami.is/docs/tracker-functions
-   */
-  autoTrack: optional(boolean()),
-  /**
-   * If you want the tracker to only run on specific domains, you can add them to your tracker script.
-   * This is a comma delimited list of domain names.
-   * Helps if you are working in a staging/development environment.
-   */
-  domains: optional(array(string())),
-  /**
-   * If you want the tracker to collect events under a specific tag.
-   * Events can be filtered in the dashboard by a specific tag.
-   */
-  tag: optional(string()),
-  /**
-   * Function that will be called before data is sent to Umami.
-   * The function takes two parameters: type and payload.
-   * Return the payload to continue sending, or return a falsy value to cancel.
-   */
-  beforeSend: optional(union([
-    custom((input) => typeof input === "function"),
-    string()
-  ]))
-});
+import { UmamiAnalyticsOptions } from "./schemas.js";
+export { UmamiAnalyticsOptions };
 export function useScriptUmamiAnalytics(_options) {
   return useRegistryScript("umamiAnalytics", (options) => {
     const domains = Array.isArray(options?.domains) ? options.domains.join(",") : options?.domains;

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

@@ -0,0 +1,29 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { VercelAnalyticsOptions } from './schemas.js';
+export { VercelAnalyticsOptions };
+export type AllowedPropertyValues = string | number | boolean | null;
+export type VercelAnalyticsMode = 'auto' | 'development' | 'production';
+export interface BeforeSendEvent {
+    type: 'pageview' | 'event';
+    url: string;
+}
+export type BeforeSend = (event: BeforeSendEvent) => BeforeSendEvent | null;
+export type VercelAnalyticsInput = RegistryScriptInput<typeof VercelAnalyticsOptions, false, false, false> & {
+    beforeSend?: BeforeSend;
+};
+export interface VercelAnalyticsApi {
+    va: (event: string, properties?: unknown) => void;
+    track: (name: string, properties?: Record<string, AllowedPropertyValues>) => void;
+    pageview: (options?: {
+        route?: string | null;
+        path?: string;
+    }) => void;
+}
+declare global {
+    interface Window {
+        va?: (event: string, properties?: unknown) => void;
+        vaq?: [string, unknown?][];
+        vam?: VercelAnalyticsMode;
+    }
+}
+export declare function useScriptVercelAnalytics<T extends VercelAnalyticsApi>(_options?: VercelAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;

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

@@ -0,0 +1,84 @@
+import { useRegistryScript } from "../utils.js";
+import { VercelAnalyticsOptions } from "./schemas.js";
+export { VercelAnalyticsOptions };
+function parseProperties(properties, options) {
+  let props = properties;
+  const errorProperties = [];
+  for (const [key, value] of Object.entries(properties)) {
+    if (typeof value === "object" && value !== null) {
+      if (options.strip) {
+        const { [key]: _, ...rest } = props;
+        props = rest;
+      } else {
+        errorProperties.push(key);
+      }
+    }
+  }
+  if (errorProperties.length > 0 && !options.strip) {
+    throw new Error(
+      `The following properties are not valid: ${errorProperties.join(", ")}. Only strings, numbers, booleans, and null are allowed.`
+    );
+  }
+  return props;
+}
+export function useScriptVercelAnalytics(_options) {
+  const beforeSend = _options?.beforeSend;
+  return useRegistryScript("vercelAnalytics", (options) => {
+    const scriptInput = {
+      "src": import.meta.dev ? "https://va.vercel-scripts.com/v1/script.debug.js" : "https://va.vercel-scripts.com/v1/script.js",
+      "defer": true,
+      "data-sdkn": "@nuxt/scripts"
+    };
+    if (options?.dsn)
+      scriptInput["data-dsn"] = options.dsn;
+    if (options?.disableAutoTrack)
+      scriptInput["data-disable-auto-track"] = "1";
+    if (options?.endpoint)
+      scriptInput["data-endpoint"] = options.endpoint;
+    if (import.meta.dev && options?.debug === false)
+      scriptInput["data-debug"] = "false";
+    return {
+      scriptInput,
+      schema: import.meta.dev ? VercelAnalyticsOptions : void 0,
+      scriptOptions: {
+        // Load on client hydration for accurate web vitals
+        trigger: "client",
+        use: () => ({
+          va: (...args) => window.va?.(...args),
+          track(name, properties) {
+            if (!properties) {
+              window.va?.("event", { name });
+              return;
+            }
+            try {
+              const props = parseProperties(properties, { strip: !import.meta.dev });
+              window.va?.("event", { name, data: props });
+            } catch (err) {
+              if (err instanceof Error && import.meta.dev)
+                console.error(err);
+            }
+          },
+          pageview(opts) {
+            window.va?.("pageview", opts);
+          }
+        })
+      },
+      clientInit: import.meta.server ? void 0 : () => {
+        if (window.va)
+          return;
+        window.va = function(...params) {
+          ;
+          (window.vaq = window.vaq || []).push(params);
+        };
+        if (options?.mode === "auto" || !options?.mode) {
+          window.vam = import.meta.dev ? "development" : "production";
+        } else {
+          window.vam = options.mode;
+        }
+        if (beforeSend) {
+          window.va("beforeSend", beforeSend);
+        }
+      }
+    };
+  }, _options);
+}

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

@@ -1,4 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { XEmbedOptions } from './schemas.js';
+export { XEmbedOptions };
 export interface XEmbedTweetData {
     id_str: string;
     text: string;
@@ -46,22 +48,6 @@ export interface XEmbedTweetData {
         };
     };
 }
-export declare const XEmbedOptions: import("valibot").ObjectSchema<{
-    /**
-     * The tweet ID to embed
-     */
-    readonly tweetId: import("valibot").StringSchema<undefined>;
-    /**
-     * Optional: Custom API endpoint for fetching tweet data
-     * @default '/api/_scripts/x-embed'
-     */
-    readonly apiEndpoint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /**
-     * Optional: Custom image proxy endpoint
-     * @default '/api/_scripts/x-embed-image'
-     */
-    readonly imageProxyEndpoint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-}, undefined>;
 export type XEmbedInput = RegistryScriptInput<typeof XEmbedOptions, false, false, false>;
 /**
  * Proxy an X/Twitter image URL through the server

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

@@ -1,20 +1,5 @@
-import { object, optional, string } from "#nuxt-scripts-validator";
-export const XEmbedOptions = object({
-  /**
-   * The tweet ID to embed
-   */
-  tweetId: string(),
-  /**
-   * Optional: Custom API endpoint for fetching tweet data
-   * @default '/api/_scripts/x-embed'
-   */
-  apiEndpoint: optional(string()),
-  /**
-   * Optional: Custom image proxy endpoint
-   * @default '/api/_scripts/x-embed-image'
-   */
-  imageProxyEndpoint: optional(string())
-});
+import { XEmbedOptions } from "./schemas.js";
+export { XEmbedOptions };
 export function proxyXImageUrl(url, proxyEndpoint = "/api/_scripts/x-embed-image") {
   const separator = proxyEndpoint.includes("?") ? "&" : "?";
   return `${proxyEndpoint}${separator}url=${encodeURIComponent(url)}`;

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

@@ -1,4 +1,5 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { XPixelOptions } from './schemas.js';
 interface ContentProperties {
     content_type?: string | null;
     content_id?: string | number | null;
@@ -27,10 +28,6 @@ declare global {
     interface Window extends XPixelApi {
     }
 }
-export declare const XPixelOptions: import("valibot").ObjectSchema<{
-    readonly id: import("valibot").StringSchema<undefined>;
-    readonly version: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-}, undefined>;
+export { XPixelOptions };
 export type XPixelInput = RegistryScriptInput<typeof XPixelOptions, true, false, false>;
 export declare function useScriptXPixel<T extends XPixelApi>(_options?: XPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

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

@@ -1,9 +1,6 @@
-import { object, optional, string } from "#nuxt-scripts-validator";
 import { useRegistryScript } from "../utils.js";
-export const XPixelOptions = object({
-  id: string(),
-  version: optional(string())
-});
+import { XPixelOptions } from "./schemas.js";
+export { XPixelOptions };
 export function useScriptXPixel(_options) {
   return useRegistryScript("xPixel", (options) => {
     return {

package/dist/runtime/server/gravatar-proxy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<ArrayBuffer | undefined>>;
+export default _default;

package/dist/runtime/server/gravatar-proxy.js

@@ -0,0 +1,62 @@
+import { useRuntimeConfig } from "#imports";
+import { createError, defineEventHandler, getHeader, getQuery, setHeader } from "h3";
+import { $fetch } from "ofetch";
+import { withQuery } from "ufo";
+export default defineEventHandler(async (event) => {
+  const runtimeConfig = useRuntimeConfig();
+  const proxyConfig = runtimeConfig.public["nuxt-scripts"]?.gravatarProxy;
+  const referer = getHeader(event, "referer");
+  const host = getHeader(event, "host");
+  if (referer && host) {
+    let refererHost;
+    try {
+      refererHost = new URL(referer).host;
+    } catch {
+    }
+    if (refererHost && refererHost !== host) {
+      throw createError({
+        statusCode: 403,
+        statusMessage: "Invalid referer"
+      });
+    }
+  }
+  const query = getQuery(event);
+  let hash = query.hash;
+  const email = query.email;
+  if (!hash && email) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(email.trim().toLowerCase());
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    hash = Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  if (!hash) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Either hash or email parameter is required"
+    });
+  }
+  const size = query.s || "80";
+  const defaultImg = query.d || "mp";
+  const rating = query.r || "g";
+  const gravatarUrl = withQuery(`https://www.gravatar.com/avatar/${hash}`, {
+    s: size,
+    d: defaultImg,
+    r: rating
+  });
+  const response = await $fetch.raw(gravatarUrl, {
+    responseType: "arrayBuffer",
+    headers: {
+      "User-Agent": "Nuxt Scripts Gravatar Proxy"
+    }
+  }).catch((error) => {
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.statusMessage || "Failed to fetch Gravatar avatar"
+    });
+  });
+  const cacheMaxAge = proxyConfig?.cacheMaxAge ?? 3600;
+  setHeader(event, "Content-Type", response.headers.get("content-type") || "image/jpeg");
+  setHeader(event, "Cache-Control", `public, max-age=${cacheMaxAge}, s-maxage=${cacheMaxAge}`);
+  setHeader(event, "Vary", "Accept-Encoding");
+  return response._data;
+});

package/dist/runtime/types.d.ts

@@ -1,7 +1,7 @@
 import type { UseScriptInput, UseScriptOptions, VueScriptInstance } from '@unhead/vue';
 import type { Script } from '@unhead/vue/types';
 import type { Import } from 'unimport';
-import type { InferInput, ObjectSchema, ValiError } from 'valibot';
+import type { InferInput, ObjectSchema, UnionSchema, ValiError } from 'valibot';
 import type { ComputedRef, Ref } from 'vue';
 import type { ClarityInput } from './registry/clarity.js';
 import type { CloudflareWebAnalyticsInput } from './registry/cloudflare-web-analytics.js';
@@ -12,7 +12,9 @@ import type { GoogleAdsenseInput } from './registry/google-adsense.js';
 import type { GoogleAnalyticsInput } from './registry/google-analytics.js';
 import type { GoogleMapsInput } from './registry/google-maps.js';
 import type { GoogleRecaptchaInput } from './registry/google-recaptcha.js';
+import type { GoogleSignInInput } from './registry/google-sign-in.js';
 import type { GoogleTagManagerInput } from './registry/google-tag-manager.js';
+import type { GravatarInput } from './registry/gravatar.js';
 import type { HotjarInput } from './registry/hotjar.js';
 import type { IntercomInput } from './registry/intercom.js';
 import type { LemonSqueezyInput } from './registry/lemon-squeezy.js';
@@ -29,6 +31,7 @@ import type { SnapTrPixelInput } from './registry/snapchat-pixel.js';
 import type { StripeInput } from './registry/stripe.js';
 import type { TikTokPixelInput } from './registry/tiktok-pixel.js';
 import type { UmamiAnalyticsInput } from './registry/umami-analytics.js';
+import type { VercelAnalyticsInput } from './registry/vercel-analytics.js';
 import type { VimeoPlayerInput } from './registry/vimeo-player.js';
 import type { XPixelInput } from './registry/x-pixel.js';
 import type { YouTubePlayerInput } from './registry/youtube-player.js';
@@ -163,6 +166,7 @@ export interface ScriptRegistry {
     googleAnalytics?: GoogleAnalyticsInput;
     googleMaps?: GoogleMapsInput;
     googleRecaptcha?: GoogleRecaptchaInput;
+    googleSignIn?: GoogleSignInInput;
     lemonSqueezy?: LemonSqueezyInput;
     googleTagManager?: GoogleTagManagerInput;
     hotjar?: HotjarInput;
@@ -178,21 +182,23 @@ export interface ScriptRegistry {
     xPixel?: XPixelInput;
     snapchatPixel?: SnapTrPixelInput;
     youtubePlayer?: YouTubePlayerInput;
+    vercelAnalytics?: VercelAnalyticsInput;
     vimeoPlayer?: VimeoPlayerInput;
     umamiAnalytics?: UmamiAnalyticsInput;
+    gravatar?: GravatarInput;
     [key: `${string}-npm`]: NpmInput;
 }
 export type NuxtConfigScriptRegistryEntry<T> = true | 'mock' | T | [T, NuxtUseScriptOptionsSerializable];
 export type NuxtConfigScriptRegistry<T extends keyof ScriptRegistry = keyof ScriptRegistry> = Partial<{
     [key in T]: NuxtConfigScriptRegistryEntry<ScriptRegistry[key]>;
-}>;
+}> & Record<string & {}, NuxtConfigScriptRegistryEntry<any>>;
 export type UseFunctionType<T, U> = T extends {
     use: infer V;
 } ? V extends (...args: any) => any ? ReturnType<V> : U : U;
 declare const _emptyOptions: ObjectSchema<{}, undefined>;
 export type EmptyOptionsSchema = typeof _emptyOptions;
 type ScriptInput = Script;
-export type InferIfSchema<T> = T extends ObjectSchema<any, any> ? InferInput<T> : T;
+export type InferIfSchema<T> = T extends ObjectSchema<any, any> | UnionSchema<any, any> ? InferInput<T> : T;
 export type RegistryScriptInput<T = EmptyOptionsSchema, Bundelable extends boolean = true, Usable extends boolean = false, CanBypassOptions extends boolean = true> = (InferIfSchema<T> & {
     /**
      * A unique key to use for the script, this can be used to load multiple of the same script with different options.

package/dist/runtime/utils.d.ts

@@ -1,6 +1,6 @@
 import type { EmptyOptionsSchema, InferIfSchema, NuxtUseScriptOptions, RegistryScriptInput, ScriptRegistry, UseFunctionType, UseScriptContext } from '#nuxt-scripts/types';
 import type { UseScriptInput } from '@unhead/vue';
-import type { ObjectSchema } from 'valibot';
+import type { ObjectSchema, UnionSchema } from 'valibot';
 export type MaybePromise<T> = Promise<T> | T;
 type OptionsFn<O> = (options: InferIfSchema<O>, ctx: {
     scriptInput?: UseScriptInput & {
@@ -9,7 +9,7 @@ type OptionsFn<O> = (options: InferIfSchema<O>, ctx: {
 }) => ({
     scriptInput?: UseScriptInput;
     scriptOptions?: NuxtUseScriptOptions;
-    schema?: O extends ObjectSchema<any, any> ? O : undefined;
+    schema?: O extends ObjectSchema<any, any> | UnionSchema<any, any> ? O : undefined;
     clientInit?: () => void | Promise<any>;
     scriptMode?: 'external' | 'npm';
 });

package/dist/runtime/utils.js

@@ -71,8 +71,9 @@ export function useRegistryScript(registryKey, optionsFn, _userOptions) {
     scriptOptions.devtools = defu(scriptOptions.devtools, { registryKey, loadedFrom });
     if (options.schema) {
       const registryMeta = {};
-      for (const k in options.schema.entries) {
-        if (options.schema.entries[k].type !== "optional") {
+      const entries = "entries" in options.schema ? options.schema.entries : void 0;
+      for (const k in entries) {
+        if (entries[k]?.type !== "optional") {
           registryMeta[k] = String(userOptions[k]);
         }
       }

package/dist/shared/{scripts.DLRgvHQg.mjs → scripts.Bg4pl9Yo.mjs}

@@ -261,6 +261,28 @@ function buildProxyConfig(collectPrefix) {
       routes: {
         [`${collectPrefix}/crisp/**`]: { proxy: "https://client.crisp.chat/**" }
       }
+    },
+    vercelAnalytics: {
+      // Vercel Analytics: trusted first-party analytics — minimal privacy needed
+      privacy: { ip: false, userAgent: false, language: false, screen: false, timezone: false, hardware: false },
+      rewrite: [
+        { from: "va.vercel-scripts.com", to: `${collectPrefix}/vercel` }
+      ],
+      routes: {
+        [`${collectPrefix}/vercel/**`]: { proxy: "https://va.vercel-scripts.com/**" }
+      }
+    },
+    gravatar: {
+      // Gravatar: avatar proxy — IP anonymized, rest not needed
+      privacy: { ip: true, userAgent: false, language: false, screen: false, timezone: false, hardware: false },
+      rewrite: [
+        { from: "secure.gravatar.com", to: `${collectPrefix}/gravatar` },
+        { from: "gravatar.com/avatar", to: `${collectPrefix}/gravatar-avatar` }
+      ],
+      routes: {
+        [`${collectPrefix}/gravatar/**`]: { proxy: "https://secure.gravatar.com/**" },
+        [`${collectPrefix}/gravatar-avatar/**`]: { proxy: "https://gravatar.com/avatar/**" }
+      }
     }
   };
 }