@nuxt/scripts 0.4.6 → 0.4.8

package/dist/runtime/components/ScriptCarbonAds.vue

@@ -0,0 +1,70 @@
+<script setup lang="ts">
+import { withQuery } from 'ufo'
+import { onBeforeUnmount, onMounted, ref, useElementScriptTrigger } from '#imports'
+import type { ElementScriptTrigger } from '#nuxt-scripts'
+
+const props = defineProps<{
+  serve: string
+  placement: string
+  /**
+   * Defines the trigger event to load the script.
+   */
+  trigger?: ElementScriptTrigger
+}>()
+
+const emit = defineEmits<{
+  error: [error: string | Event]
+  load: []
+}>()
+
+const attrId = `_carbonads_js`
+const carbonadsEl = ref<HTMLElement | null>(import.meta.client ? document.getElementById(attrId) : null)
+// syncs to useScript status
+const status = ref('awaitingLoad')
+
+function loadCarbon() {
+  if (!carbonadsEl.value) {
+    return
+  }
+  status.value = 'loading'
+  const script = document.createElement('script')
+  script.setAttribute('type', 'text/javascript')
+  script.setAttribute('src', withQuery('https://cdn.carbonads.com/carbon.js', {
+    serve: props.serve,
+    placement: props.placement,
+  }))
+  script.setAttribute('id', attrId)
+  script.onerror = (err) => {
+    status.value = 'error'
+    emit('error', err)
+  }
+  script.onload = () => {
+    status.value = 'loaded'
+    emit('load')
+  }
+  carbonadsEl.value.appendChild(script)
+}
+
+onMounted(() => {
+  if (!props.trigger) {
+    loadCarbon()
+  }
+  else {
+    useElementScriptTrigger({ trigger: props.trigger, el: carbonadsEl })
+  }
+})
+
+onBeforeUnmount(() => {
+  if (carbonadsEl.value) {
+    carbonadsEl.value.remove()
+  }
+})
+</script>
+
+<template>
+  <div ref="carbonadsEl">
+    <slot v-if="status === 'awaitingLoad'" name="awaitingLoad" />
+    <slot v-else-if="status === 'loading'" name="loading" />
+    <slot v-else-if="status === 'error'" name="error" />
+  </div>
+</template>

package/dist/runtime/components/ScriptGoogleMaps.vue

@@ -144,7 +144,7 @@ onMounted(() => {
   })
   // create the map
   $script.then(async (instance) => {
-    const maps = await instance.maps
+    const maps = await instance.maps as any as typeof google.maps // some weird type issue here
     const _map = new maps.Map(mapEl.value!, options.value)
     const placesService = new maps.places.PlacesService(_map)
 

package/dist/runtime/components/ScriptVimeoPlayer.vue

@@ -12,7 +12,7 @@ const props = withDefaults(defineProps<{
   rootAttrs?: HTMLAttributes
   aboveTheFold?: boolean
   // copied from @types/vimeo__player
-  id: number | undefined
+  id?: number | undefined
   url?: string | undefined
   autopause?: boolean | undefined
   autoplay?: boolean | undefined
@@ -51,7 +51,7 @@ const emits = defineEmits<TEmits>()
 
 type EventMap<E extends keyof Vimeo.EventMap> = [event: Vimeo.EventMap[E], player: Vimeo]
 
-// eslint-disable-next-line ts/consistent-type-definitions
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
 type TEmits = {
   play: EventMap<'play'>
   playing: EventMap<'playing'>
@@ -169,10 +169,7 @@ defineExpose({
 onMounted(() => {
   $script.then(async ({ Vimeo }) => {
     // filter props for false values
-    player = new Vimeo.Player(elVimeo.value, {
-      ...props,
-      url: encodeURI(`https://vimeo.com/${props.id}`),
-    })
+    player = new Vimeo.Player(elVimeo.value, props)
     if (clickTriggered) {
       player!.play()
       clickTriggered = false

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

@@ -1,5 +1,2 @@
 import type { TrackedPage } from '#nuxt-scripts';
-export declare function useAnalyticsPageEvent(onChange?: (payload: TrackedPage) => void): import("#imports").Ref<{
-    title?: string | undefined;
-    path: string;
-}>;
+export declare function useAnalyticsPageEvent(onChange?: (payload: TrackedPage) => void): import("#imports").Ref<TrackedPage>;

package/dist/runtime/composables/useElementScriptTrigger.js

@@ -35,7 +35,6 @@ export function useElementScriptTrigger(options) {
     return new Promise((resolve) => {
       const _ = useEventListener(
         typeof el !== "undefined" ? el : document.body,
-        // @ts-expect-error untyped
         trigger,
         () => {
           resolve();

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

@@ -0,0 +1,44 @@
+import type { RegistryScriptInput } from '#nuxt-scripts';
+/**
+ * <script type="text/javascript">
+ *     (function(c,l,a,r,i,t,y){
+ *         c[a]=c[a]||function(){(c[a].q=c[a].q||[]).push(arguments)};
+ *         t=l.createElement(r);t.async=1;t.src="https://www.clarity.ms/tag/"+i;
+ *         y=l.getElementsByTagName(r)[0];y.parentNode.insertBefore(t,y);
+ *     })(window, document, "clarity", "script", "mpy5c6k7xi");
+ * </script>
+ */
+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') => void) & ((fn: 'set', key: any, value: any) => void) & ((fn: 'event', value: any) => void) & ((fn: 'upgrade', upgradeReason: any) => void) & ((fn: string, ...args: any[]) => void);
+export interface ClarityApi {
+    clarity: ClarityFunctions & {
+        q: any[];
+        v: string;
+    };
+}
+declare global {
+    interface Window extends ClarityApi {
+    }
+}
+export declare const ClarityOptions: import("valibot").ObjectSchema<{
+    /**
+     * The Clarity token.
+     */
+    readonly id: import("valibot").SchemaWithPipe<[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): T & {
+    $script: Promise<T> & import("@unhead/vue").VueScriptInstance<T>;
+};
+export {};

package/dist/runtime/registry/clarity.js

@@ -0,0 +1,30 @@
+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))
+});
+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 { clarity: window.clarity };
+        }
+      },
+      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

@@ -20,18 +20,15 @@ export declare const CloudflareWebAnalyticsOptions: import("valibot").ObjectSche
     /**
      * The Cloudflare Web Analytics token.
      */
-    token: import("valibot").StringSchema<string>;
+    readonly token: import("valibot").SchemaWithPipe<[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
      */
-    spa: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
-}, undefined, {
-    token: string;
-    spa?: boolean | undefined;
-}>;
+    readonly spa: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
+}, undefined>;
 export type CloudflareWebAnalyticsInput = RegistryScriptInput<typeof CloudflareWebAnalyticsOptions>;
 export declare function useScriptCloudflareWebAnalytics<T extends CloudflareWebAnalyticsApi>(_options?: CloudflareWebAnalyticsInput): T & {
     $script: Promise<T> & import("@unhead/vue").VueScriptInstance<T>;

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

@@ -1,10 +1,10 @@
 import { useRegistryScript } from "../utils.js";
-import { boolean, minLength, object, optional, string } from "#nuxt-scripts-validator";
+import { boolean, minLength, object, optional, pipe, string } from "#nuxt-scripts-validator";
 export const CloudflareWebAnalyticsOptions = object({
   /**
    * The Cloudflare Web Analytics token.
    */
-  token: string([minLength(32)]),
+  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.

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

@@ -3,30 +3,24 @@ export declare const FathomAnalyticsOptions: import("valibot").ObjectSchema<{
     /**
      * The Fathom Analytics site ID.
      */
-    site: import("valibot").StringSchema<string>;
+    readonly site: import("valibot").StringSchema<undefined>;
     /**
      * The Fathom Analytics tracking mode.
      */
-    spa: import("valibot").OptionalSchema<import("valibot").UnionSchema<(import("valibot").LiteralSchema<"auto", "auto"> | import("valibot").LiteralSchema<"history", "history"> | import("valibot").LiteralSchema<"hash", "hash">)[], "auto" | "history" | "hash">, undefined, "auto" | "history" | "hash" | undefined>;
+    readonly spa: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"auto", undefined>, import("valibot").LiteralSchema<"history", undefined>, import("valibot").LiteralSchema<"hash", undefined>], undefined>, never>;
     /**
      * Automatically track page views.
      */
-    auto: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
+    readonly auto: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
     /**
      * Enable canonical URL tracking.
      */
-    canonical: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
+    readonly canonical: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
     /**
      * Honor Do Not Track requests.
      */
-    honorDnt: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
-}, undefined, {
-    site: string;
-    spa?: "auto" | "history" | "hash" | undefined;
-    auto?: boolean | undefined;
-    canonical?: boolean | undefined;
-    honorDnt?: boolean | undefined;
-}>;
+    readonly honorDnt: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
+}, undefined>;
 export type FathomAnalyticsInput = RegistryScriptInput<typeof FathomAnalyticsOptions, false>;
 export interface FathomAnalyticsApi {
     beacon: (ctx: {

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

@@ -3,10 +3,8 @@ export declare const GoogleAdsenseOptions: import("valibot").ObjectSchema<{
     /**
      * The Google Adsense ID.
      */
-    client: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
-}, undefined, {
-    client?: string | undefined;
-}>;
+    readonly client: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
+}, undefined>;
 export type GoogleAdsenseInput = RegistryScriptInput<typeof GoogleAdsenseOptions>;
 export interface GoogleAdsenseApi {
     /**

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

@@ -8,21 +8,20 @@ declare namespace google {
     }
 }
 export declare const GoogleMapsOptions: import("valibot").ObjectSchema<{
-    apiKey: import("valibot").StringSchema<string>;
-    libraries: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<string>, string[]>, undefined, string[] | undefined>;
-    v: import("valibot").OptionalSchema<import("valibot").UnionSchema<(import("valibot").LiteralSchema<"weekly", "weekly"> | import("valibot").LiteralSchema<"beta", "beta"> | import("valibot").LiteralSchema<"alpha", "alpha">)[], "weekly" | "beta" | "alpha">, undefined, "weekly" | "beta" | "alpha" | undefined>;
-}, undefined, {
-    apiKey: string;
-    libraries?: string[] | undefined;
-    v?: "weekly" | "beta" | "alpha" | undefined;
-}>;
+    readonly apiKey: import("valibot").StringSchema<undefined>;
+    readonly libraries: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, never>;
+    readonly v: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"weekly", undefined>, import("valibot").LiteralSchema<"beta", undefined>, import("valibot").LiteralSchema<"alpha", undefined>], undefined>, never>;
+}, undefined>;
 export type GoogleMapsInput = RegistryScriptInput<typeof GoogleMapsOptions>;
+type MapsNamespace = typeof google.maps;
 export interface GoogleMapsApi {
-    maps: typeof window.google.maps;
+    maps: MapsNamespace | Promise<MapsNamespace>;
 }
 declare global {
     interface Window {
-        google: typeof google;
+        google: {
+            maps: MapsNamespace;
+        };
     }
 }
 export declare function useScriptGoogleMaps<T extends GoogleMapsApi>(_options?: GoogleMapsInput): T & {

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

@@ -13,12 +13,9 @@ declare global {
     }
 }
 export declare const HotjarOptions: import("valibot").ObjectSchema<{
-    id: import("valibot").NumberSchema<number>;
-    sv: import("valibot").OptionalSchema<import("valibot").NumberSchema<number>, undefined, number | undefined>;
-}, undefined, {
-    id: number;
-    sv?: number | undefined;
-}>;
+    readonly id: import("valibot").NumberSchema<undefined>;
+    readonly sv: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, never>;
+}, undefined>;
 export type HotjarInput = RegistryScriptInput<typeof HotjarOptions>;
 export declare function useScriptHotjar<T extends HotjarApi>(_options?: HotjarInput): T & {
     $script: Promise<T> & import("@unhead/vue").VueScriptInstance<T>;

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

@@ -1,27 +1,18 @@
-import { type Input } from '#nuxt-scripts-validator';
+import { type InferInput } from '#nuxt-scripts-validator';
 import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const IntercomOptions: import("valibot").ObjectSchema<{
-    app_id: import("valibot").StringSchema<string>;
-    api_base: import("valibot").OptionalSchema<import("valibot").UnionSchema<(import("valibot").LiteralSchema<"https://api-iam.intercom.io", "https://api-iam.intercom.io"> | import("valibot").LiteralSchema<"https://api-iam.eu.intercom.io", "https://api-iam.eu.intercom.io"> | import("valibot").LiteralSchema<"https://api-iam.au.intercom.io", "https://api-iam.au.intercom.io">)[], "https://api-iam.intercom.io" | "https://api-iam.eu.intercom.io" | "https://api-iam.au.intercom.io">, undefined, "https://api-iam.intercom.io" | "https://api-iam.eu.intercom.io" | "https://api-iam.au.intercom.io" | undefined>;
-    name: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
-    email: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
-    user_id: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
-    alignment: import("valibot").OptionalSchema<import("valibot").UnionSchema<(import("valibot").LiteralSchema<"left", "left"> | import("valibot").LiteralSchema<"right", "right">)[], "left" | "right">, undefined, "left" | "right" | undefined>;
-    horizontal_padding: import("valibot").OptionalSchema<import("valibot").NumberSchema<number>, undefined, number | undefined>;
-    vertical_padding: import("valibot").OptionalSchema<import("valibot").NumberSchema<number>, undefined, number | undefined>;
-}, undefined, {
-    app_id: string;
-    name?: string | undefined;
-    api_base?: "https://api-iam.intercom.io" | "https://api-iam.eu.intercom.io" | "https://api-iam.au.intercom.io" | undefined;
-    email?: string | undefined;
-    user_id?: string | undefined;
-    alignment?: "left" | "right" | undefined;
-    horizontal_padding?: number | undefined;
-    vertical_padding?: number | undefined;
-}>;
+    readonly app_id: import("valibot").StringSchema<undefined>;
+    readonly api_base: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"https://api-iam.intercom.io", undefined>, import("valibot").LiteralSchema<"https://api-iam.eu.intercom.io", undefined>, import("valibot").LiteralSchema<"https://api-iam.au.intercom.io", undefined>], undefined>, never>;
+    readonly name: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
+    readonly email: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
+    readonly user_id: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
+    readonly alignment: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"left", undefined>, import("valibot").LiteralSchema<"right", undefined>], undefined>, never>;
+    readonly horizontal_padding: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, never>;
+    readonly vertical_padding: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, never>;
+}, undefined>;
 export type IntercomInput = RegistryScriptInput<typeof IntercomOptions>;
 export interface IntercomApi {
-    Intercom: ((event: 'boot', data?: Input<typeof IntercomOptions>) => void) & ((event: 'shutdown') => void) & ((event: 'update', options?: Input<typeof IntercomOptions>) => void) & ((event: 'hide') => void) & ((event: 'show') => void) & ((event: 'showSpace', spaceName: 'home' | 'messages' | 'help' | 'news' | 'tasks' | 'tickets' | string) => void) & ((event: 'showMessages') => void) & ((event: 'showNewMessage', content?: string) => void) & ((event: 'onHide', fn: () => void) => void) & ((event: 'onShow', fn: () => void) => void) & ((event: 'onUnreadCountChange', fn: () => void) => void) & ((event: 'trackEvent', eventName: string, metadata?: Record<string, any>) => void) & ((event: 'getVisitorId') => Promise<string>) & ((event: 'startTour', tourId: string | number) => void) & ((event: 'showArticle', articleId: string | number) => void) & ((event: 'showNews', newsItemId: string | number) => void) & ((event: 'startSurvey', surveyId: string | number) => void) & ((event: 'startChecklist', checklistId: string | number) => void) & ((event: 'showTicket', ticketId: string | number) => void) & ((event: 'showConversation', conversationId: string | number) => void) & ((event: 'onUserEmailSupplied', fn: () => void) => void) & ((event: string, ...params: any[]) => void);
+    Intercom: ((event: 'boot', data?: InferInput<typeof IntercomOptions>) => void) & ((event: 'shutdown') => void) & ((event: 'update', options?: InferInput<typeof IntercomOptions>) => void) & ((event: 'hide') => void) & ((event: 'show') => void) & ((event: 'showSpace', spaceName: 'home' | 'messages' | 'help' | 'news' | 'tasks' | 'tickets' | string) => void) & ((event: 'showMessages') => void) & ((event: 'showNewMessage', content?: string) => void) & ((event: 'onHide', fn: () => void) => void) & ((event: 'onShow', fn: () => void) => void) & ((event: 'onUnreadCountChange', fn: () => void) => void) & ((event: 'trackEvent', eventName: string, metadata?: Record<string, any>) => void) & ((event: 'getVisitorId') => Promise<string>) & ((event: 'startTour', tourId: string | number) => void) & ((event: 'showArticle', articleId: string | number) => void) & ((event: 'showNews', newsItemId: string | number) => void) & ((event: 'startSurvey', surveyId: string | number) => void) & ((event: 'startChecklist', checklistId: string | number) => void) & ((event: 'showTicket', ticketId: string | number) => void) & ((event: 'showConversation', conversationId: string | number) => void) & ((event: 'onUserEmailSupplied', fn: () => void) => void) & ((event: string, ...params: any[]) => void);
 }
 declare global {
     interface Window extends IntercomApi {

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

@@ -1,15 +1,10 @@
 import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const MatomoAnalyticsOptions: import("valibot").ObjectSchema<{
-    matomoUrl: import("valibot").StringSchema<string>;
-    siteId: import("valibot").StringSchema<string>;
-    trackPageView: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
-    enableLinkTracking: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
-}, undefined, {
-    matomoUrl: string;
-    siteId: string;
-    trackPageView?: boolean | undefined;
-    enableLinkTracking?: boolean | undefined;
-}>;
+    readonly matomoUrl: import("valibot").StringSchema<undefined>;
+    readonly siteId: import("valibot").StringSchema<undefined>;
+    readonly trackPageView: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
+    readonly enableLinkTracking: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
+}, undefined>;
 export type MatomoAnalyticsInput = RegistryScriptInput<typeof MatomoAnalyticsOptions, false>;
 interface MatomoAnalyticsApi {
     _paq: unknown[];

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

@@ -33,10 +33,8 @@ declare global {
     }
 }
 export declare const MetaPixelOptions: import("valibot").ObjectSchema<{
-    id: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
-}, undefined, {
-    id: string | number;
-}>;
+    readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+}, undefined>;
 export type MetaPixelInput = RegistryScriptInput<typeof MetaPixelOptions>;
 export declare function useScriptMetaPixel<T extends MetaPixelApi>(_options?: MetaPixelInput): T & {
     $script: Promise<T> & import("@unhead/vue").VueScriptInstance<T>;

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

@@ -1,15 +1,10 @@
 import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const NpmOptions: import("valibot").ObjectSchema<{
-    packageName: import("valibot").StringSchema<string>;
-    file: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
-    version: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
-    type: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
-}, undefined, {
-    packageName: string;
-    file?: string | undefined;
-    version?: string | undefined;
-    type?: string | undefined;
-}>;
+    readonly packageName: import("valibot").StringSchema<undefined>;
+    readonly file: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
+    readonly version: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
+    readonly type: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
+}, undefined>;
 export type NpmInput = RegistryScriptInput<typeof NpmOptions>;
 export declare function useScriptNpm<T extends Record<string | symbol, any>>(_options: NpmInput): T & {
     $script: Promise<T> & import("@unhead/vue").VueScriptInstance<T>;

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

@@ -1,11 +1,8 @@
 import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const PlausibleAnalyticsOptions: import("valibot").ObjectSchema<{
-    domain: import("valibot").StringSchema<string>;
-    extension: import("valibot").OptionalSchema<import("valibot").UnionSchema<(import("valibot").UnionSchema<(import("valibot").LiteralSchema<"hash", "hash"> | import("valibot").LiteralSchema<"outbound-links", "outbound-links"> | import("valibot").LiteralSchema<"file-downloads", "file-downloads"> | import("valibot").LiteralSchema<"tagged-events", "tagged-events"> | import("valibot").LiteralSchema<"revenue", "revenue"> | import("valibot").LiteralSchema<"pageview-props", "pageview-props"> | import("valibot").LiteralSchema<"compat", "compat"> | import("valibot").LiteralSchema<"local", "local"> | import("valibot").LiteralSchema<"manual", "manual">)[], "manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local"> | import("valibot").ArraySchema<import("valibot").UnionSchema<(import("valibot").LiteralSchema<"hash", "hash"> | import("valibot").LiteralSchema<"outbound-links", "outbound-links"> | import("valibot").LiteralSchema<"file-downloads", "file-downloads"> | import("valibot").LiteralSchema<"tagged-events", "tagged-events"> | import("valibot").LiteralSchema<"revenue", "revenue"> | import("valibot").LiteralSchema<"pageview-props", "pageview-props"> | import("valibot").LiteralSchema<"compat", "compat"> | import("valibot").LiteralSchema<"local", "local"> | import("valibot").LiteralSchema<"manual", "manual">)[], "manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local">, ("manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local")[]>)[], "manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local" | ("manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local")[]>, undefined, "manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local" | ("manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local")[] | undefined>;
-}, undefined, {
-    domain: string;
-    extension?: "manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local" | ("manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local")[] | undefined;
-}>;
+    readonly domain: import("valibot").StringSchema<undefined>;
+    readonly extension: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").UnionSchema<(import("valibot").LiteralSchema<"hash", undefined> | import("valibot").LiteralSchema<"outbound-links", undefined> | import("valibot").LiteralSchema<"file-downloads", undefined> | import("valibot").LiteralSchema<"tagged-events", undefined> | import("valibot").LiteralSchema<"revenue", undefined> | import("valibot").LiteralSchema<"pageview-props", undefined> | import("valibot").LiteralSchema<"compat", undefined> | import("valibot").LiteralSchema<"local", undefined> | import("valibot").LiteralSchema<"manual", undefined>)[], undefined>, import("valibot").ArraySchema<import("valibot").UnionSchema<(import("valibot").LiteralSchema<"hash", undefined> | import("valibot").LiteralSchema<"outbound-links", undefined> | import("valibot").LiteralSchema<"file-downloads", undefined> | import("valibot").LiteralSchema<"tagged-events", undefined> | import("valibot").LiteralSchema<"revenue", undefined> | import("valibot").LiteralSchema<"pageview-props", undefined> | import("valibot").LiteralSchema<"compat", undefined> | import("valibot").LiteralSchema<"local", undefined> | import("valibot").LiteralSchema<"manual", undefined>)[], undefined>, undefined>], undefined>, never>;
+}, undefined>;
 export type PlausibleAnalyticsInput = RegistryScriptInput<typeof PlausibleAnalyticsOptions, false>;
 export interface PlausibleAnalyticsApi {
     plausible: ((event: '404', options: Record<string, any>) => void) & ((event: 'event', options: Record<string, any>) => void) & ((...params: any[]) => void) & {

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

@@ -1,11 +1,8 @@
 import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const SegmentOptions: import("valibot").ObjectSchema<{
-    writeKey: import("valibot").StringSchema<string>;
-    analyticsKey: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
-}, undefined, {
-    writeKey: string;
-    analyticsKey?: string | undefined;
-}>;
+    readonly writeKey: import("valibot").StringSchema<undefined>;
+    readonly analyticsKey: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
+}, undefined>;
 export type SegmentInput = RegistryScriptInput<typeof SegmentOptions>;
 interface AnalyticsApi {
     track: (event: string, properties?: Record<string, any>) => void;

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

@@ -1,10 +1,8 @@
 /// <reference types="stripe-v3" />
 import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const StripeOptions: import("valibot").ObjectSchema<{
-    advancedFraudSignals: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
-}, undefined, {
-    advancedFraudSignals?: boolean | undefined;
-}>;
+    readonly advancedFraudSignals: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
+}, undefined>;
 export type StripeInput = RegistryScriptInput<typeof StripeOptions, false>;
 export interface StripeApi {
     Stripe: stripe.StripeStatic;

package/dist/runtime/registry/vimeo-player.d.ts

@@ -1,8 +1,9 @@
+import type Vimeo from 'vimeo__player';
 import type { RegistryScriptInput } from '#nuxt-scripts';
 type Constructor<T extends new (...args: any) => any> = T extends new (...args: infer A) => infer R ? new (...args: A) => R : never;
 export interface VimeoPlayerApi {
     Vimeo: {
-        Player: Constructor<typeof window.Vimeo>;
+        Player: Constructor<typeof Vimeo>;
     };
 }
 export type VimeoPlayerInput = RegistryScriptInput;

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

@@ -28,12 +28,9 @@ declare global {
     }
 }
 export declare const XPixelOptions: import("valibot").ObjectSchema<{
-    id: import("valibot").StringSchema<string>;
-    version: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
-}, undefined, {
-    id: string;
-    version?: string | undefined;
-}>;
+    readonly id: import("valibot").StringSchema<undefined>;
+    readonly version: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
+}, undefined>;
 export type XPixelInput = RegistryScriptInput<typeof XPixelOptions>;
 export declare function useScriptXPixel<T extends XPixelApi>(_options?: XPixelInput): T & {
     $script: Promise<T> & import("@unhead/vue").VueScriptInstance<T>;

package/dist/runtime/types.d.ts

@@ -1,7 +1,7 @@
 import type { UseScriptOptions } from '@unhead/schema';
 import type { UseScriptInput, VueScriptInstance } from '@unhead/vue';
 import type { ComputedRef, Ref } from 'vue';
-import type { Input, ObjectSchema } from 'valibot';
+import type { InferInput, ObjectSchema } from 'valibot';
 import type { Import } from 'unimport';
 import type { SegmentInput } from './registry/segment.js';
 import type { CloudflareWebAnalyticsInput } from './registry/cloudflare-web-analytics.js';
@@ -9,9 +9,7 @@ import type { MetaPixelInput } from './registry/meta-pixel.js';
 import type { FathomAnalyticsInput } from './registry/fathom-analytics.js';
 import type { HotjarInput } from './registry/hotjar.js';
 import type { IntercomInput } from './registry/intercom.js';
-import type { GoogleAnalyticsInput } from './registry/google-analytics.js';
 import type { GoogleMapsInput } from './registry/google-maps.js';
-import type { GoogleTagManagerInput } from './registry/google-tag-manager.js';
 import type { MatomoAnalyticsInput } from './registry/matomo-analytics.js';
 import type { StripeInput } from './registry/stripe.js';
 import type { VimeoPlayerInput } from './registry/vimeo-player.js';
@@ -20,6 +18,8 @@ import type { YouTubePlayerInput } from './registry/youtube-player.js';
 import type { PlausibleAnalyticsInput } from './registry/plausible-analytics.js';
 import type { NpmInput } from './registry/npm.js';
 import type { LemonSqueezyInput } from './registry/lemon-squeezy.js';
+import type { InferInput as GoogleTagManagerInput } from '#build/nuxt-scripts/tpc/google-tag-manager';
+import type { InferInput as GoogleAnalyticsInput } from '#build/nuxt-scripts/tpc/google-analytics';
 export type NuxtUseScriptOptions<T = any> = Omit<UseScriptOptions<T>, 'trigger'> & {
     /**
      * The trigger to load the script:
@@ -94,15 +94,15 @@ export interface ScriptRegistry {
 }
 export type NuxtConfigScriptRegistryEntry<T> = true | 'mock' | T | [T, NuxtUseScriptOptions<T>];
 export type NuxtConfigScriptRegistry<T extends keyof ScriptRegistry = keyof ScriptRegistry> = Partial<Record<T, NuxtConfigScriptRegistryEntry<ScriptRegistry[T]>>>;
-declare const emptyOptions: ObjectSchema<{}, undefined, {}>;
+declare const emptyOptions: ObjectSchema<{}, undefined>;
 export type EmptyOptionsSchema = typeof emptyOptions;
-export type RegistryScriptInput<T extends ObjectSchema<any> = EmptyOptionsSchema, Bundelable extends boolean = true> = Input<T> & {
+export type RegistryScriptInput<T extends ObjectSchema<any, any> = EmptyOptionsSchema, Bundelable extends boolean = true> = InferInput<T> & {
     scriptInput?: UseScriptInput;
     scriptOptions?: Bundelable extends true ? Omit<NuxtUseScriptOptions, 'use'> : Omit<NuxtUseScriptOptions, 'bundle' | 'use'>;
 };
 export interface RegistryScript {
-    import: Import;
-    scriptBundling?: false | ((options?: any) => string);
+    import?: Import;
+    scriptBundling?: false | ((options?: any) => string | false);
     label?: string;
     src?: string | false;
     category?: string;
@@ -111,6 +111,6 @@ export interface RegistryScript {
         dark: string;
     };
 }
-export type ElementScriptTrigger = 'immediate' | 'visible' | keyof GlobalEventHandlersEventMap | (keyof GlobalEventHandlersEventMap)[] | false;
+export type ElementScriptTrigger = 'immediate' | 'visible' | string | string[] | false;
 export type RegistryScripts = RegistryScript[];
 export {};

package/dist/runtime/utils.d.ts

@@ -1,14 +1,14 @@
-import type { Input, ObjectSchema } from 'valibot';
+import type { InferInput, ObjectSchema } from 'valibot';
 import type { UseScriptInput, VueScriptInstance } from '@unhead/vue';
 import type { EmptyOptionsSchema, NuxtUseScriptOptions, RegistryScriptInput, ScriptRegistry } from '#nuxt-scripts';
-type OptionsFn<O extends ObjectSchema<any>> = (options: Input<O>) => ({
+type OptionsFn<O extends ObjectSchema<any, any>> = (options: InferInput<O>) => ({
     scriptInput?: UseScriptInput;
     scriptOptions?: NuxtUseScriptOptions;
     schema?: O;
     clientInit?: () => void;
 });
 export declare function scriptRuntimeConfig<T extends keyof ScriptRegistry>(key: T): ScriptRegistry[T];
-export declare function useRegistryScript<T extends Record<string | symbol, any>, O extends ObjectSchema<any> = EmptyOptionsSchema>(key: keyof ScriptRegistry | string, optionsFn: OptionsFn<O>, _userOptions?: RegistryScriptInput<O>): T & {
+export declare function useRegistryScript<T extends Record<string | symbol, any>, O extends ObjectSchema<any, any> = EmptyOptionsSchema>(key: keyof ScriptRegistry | string, optionsFn: OptionsFn<O>, _userOptions?: RegistryScriptInput<O>): T & {
     $script: Promise<T> & VueScriptInstance<T>;
 };
 export {};

package/dist/types.d.mts

@@ -2,6 +2,7 @@
 import type { ModuleOptions, ModuleHooks } from './module.js'
 
 
+
 declare module '@nuxt/schema' {
   interface NuxtConfig { ['scripts']?: Partial<ModuleOptions> }
   interface NuxtOptions { ['scripts']?: ModuleOptions }