@nuxt/scripts 0.11.0 → 0.11.2

package/dist/runtime/components/ScriptYouTubePlayer.vue

@@ -1,215 +1,215 @@
-<script setup lang="ts">
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
-
-/// <reference types="youtube" />
-import { computed, onMounted, ref, watch } from 'vue'
-import type { HTMLAttributes, ImgHTMLAttributes, Ref } from 'vue'
-import { defu } from 'defu'
-import { useHead } from '@unhead/vue'
-import type { ElementScriptTrigger } from '../types'
-import { useScriptTriggerElement } from '../composables/useScriptTriggerElement'
-import { useScriptYouTubePlayer } from '../registry/youtube-player'
-import ScriptAriaLoadingIndicator from './ScriptAriaLoadingIndicator.vue'
-
-export type YoutubeThumbnailSize =
-// 120x90
-  '1' | '2' | '3' | 'default' |
-  // 320x180
-  'mq1' | 'mq2' | 'mq3' | 'mqdefault' |
-  // 480x360
-  '0' | 'hq1' | 'hq2' | 'hq3' | 'hqdefault' |
-  // 640x480
-  'sd1' | 'sd2' | 'sd3' | 'sddefault' |
-  // 1280x720
-  'hq720' |
-  // 1920x1080
-  'maxresdefault'
-
-const props = withDefaults(defineProps<{
-  placeholderAttrs?: ImgHTMLAttributes
-  rootAttrs?: HTMLAttributes
-  aboveTheFold?: boolean
-  trigger?: ElementScriptTrigger
-  videoId: string
-  playerVars?: YT.PlayerVars
-  width?: number
-  height?: number
-  /**
-   * Whether to use youtube-nocookie.com for embedding.
-   *
-   * @default false
-   */
-  cookies?: boolean
-  playerOptions?: YT.PlayerOptions
-  thumbnailSize?: YoutubeThumbnailSize
-  webp?: boolean
-}>(), {
-  cookies: false,
-  trigger: 'mousedown',
-  thumbnailSize: 'hq720',
-  webp: true,
-  // @ts-expect-error untyped
-  playerVars: { autoplay: 0, playsinline: 1 },
-  width: 640,
-  height: 360,
-})
-
-const emits = defineEmits<{
-  'ready': [e: YT.PlayerEvent]
-  'state-change': [e: YT.OnStateChangeEvent, target: YT.Player]
-  'playback-quality-change': [e: YT.OnPlaybackQualityChangeEvent, target: YT.Player]
-  'playback-rate-change': [e: YT.OnPlaybackRateChangeEvent, target: YT.Player]
-  'error': [e: YT.OnErrorEvent, target: YT.Player]
-}>()
-const events: (keyof YT.Events)[] = [
-  'onReady',
-  'onStateChange',
-  'onPlaybackQualityChange',
-  'onPlaybackRateChange',
-  'onError',
-  'onApiChange',
-]
-const rootEl = ref()
-const youtubeEl = ref()
-const ready = ref(false)
-const trigger = useScriptTriggerElement({ trigger: props.trigger, el: rootEl })
-const script = useScriptYouTubePlayer({
-  scriptOptions: {
-    trigger,
-  },
-})
-const { onLoaded, status } = script
-
-const player: Ref<YT.Player | undefined> = ref()
-let clickTriggered = false
-if (props.trigger === 'mousedown' && trigger instanceof Promise) {
-  trigger.then((triggered) => {
-    if (triggered) {
-      clickTriggered = true
-    }
-  })
-}
-onMounted(() => {
-  onLoaded(async (instance) => {
-    const YouTube = instance.YT instanceof Promise ? await instance.YT : instance.YT
-    await new Promise<void>((resolve) => {
-      if (typeof YT.Player === 'undefined')
-        YouTube.ready(resolve)
-      else
-        resolve()
-    })
-    player.value = new YT.Player(youtubeEl.value, {
-      host: !props.cookies ? 'https://www.youtube-nocookie.com' : 'https://www.youtube.com',
-      ...props,
-      ...props.playerOptions,
-      events: Object.fromEntries(events.map(event => [event, (e: any) => {
-        const emitEventName = event.replace(/([A-Z])/g, '-$1').replace('on-', '').toLowerCase()
-        // @ts-expect-error untyped
-        emits(emitEventName, e)
-        if (event === 'onReady') {
-          ready.value = true
-          if (clickTriggered) {
-            player.value?.playVideo()
-            clickTriggered = false
-          }
-          watch(() => props.videoId, () => {
-            player.value?.loadVideoById(props.videoId)
-          })
-        }
-      }])),
-    })
-  })
-  watch(status, (status) => {
-    if (status === 'error') {
-      // @ts-expect-error untyped
-      emits('error')
-    }
-  })
-})
-
-defineExpose({
-  player,
-})
-
-const rootAttrs = computed(() => {
-  return defu(props.rootAttrs, {
-    'aria-busy': status.value === 'loading',
-    'aria-label': status.value === 'awaitingLoad'
-      ? 'YouTube Player - Placeholder'
-      : status.value === 'loading'
-        ? 'YouTube Player - Loading'
-        : 'YouTube Player - Loaded',
-    'aria-live': 'polite',
-    'role': 'application',
-    'style': {
-      cursor: 'pointer',
-      position: 'relative',
-      backgroundColor: 'black',
-      width: '100%',
-      aspectRatio: `${props.width}/${props.height}`,
-    },
-    ...(trigger instanceof Promise ? trigger.ssrAttrs || {} : {}),
-  }) as HTMLAttributes
-})
-
-const fallbackPlaceHolder = computed(() => `https://i.ytimg.com/vi/${props.videoId}/hqdefault.jpg`)
-const placeholder = computed(() => `https://i.ytimg.com/${props.webp ? 'vi_webp' : 'vi'}/${props.videoId}/${props.thumbnailSize}.${props.webp ? 'webp' : 'jpg'}`)
-const isFallbackPlaceHolder = ref(false)
-
-if (import.meta.server) {
-  // dns-prefetch https://i.vimeocdn.com
-  useHead({
-    link: [
-      {
-        key: `nuxt-script-youtube-img`,
-        rel: props.aboveTheFold ? 'preconnect' : 'dns-prefetch',
-        href: 'https://i.ytimg.com',
-      },
-      props.aboveTheFold
-        // we can preload the placeholder image
-        ? {
-            key: `nuxt-script-youtube-img`,
-            rel: 'preload',
-            as: 'image',
-            href: placeholder.value,
-          }
-        : {},
-    ],
-  })
-}
-
-const placeholderAttrs = computed(() => {
-  return defu(props.placeholderAttrs, {
-    src: isFallbackPlaceHolder.value ? fallbackPlaceHolder.value : placeholder.value,
-    alt: '',
-    loading: props.aboveTheFold ? 'eager' : 'lazy',
-    style: {
-      width: '100%',
-      objectFit: 'contain',
-      height: '100%',
-    },
-    onLoad(payload) {
-      const img = payload.target as HTMLImageElement
-      if (img.naturalWidth === 120 && img.naturalHeight === 90) {
-        isFallbackPlaceHolder.value = true
-      }
-    },
-  } satisfies ImgHTMLAttributes)
-})
-</script>
-
-<template>
-  <div ref="rootEl" v-bind="rootAttrs">
-    <div ref="youtubeEl" style="width: 100%; height: 100%; position: absolute; top: 0; left: 0;" />
-    <slot v-if="!ready" :placeholder="placeholder" name="placeholder">
-      <img v-bind="placeholderAttrs">
-    </slot>
-    <slot v-if="status === 'loading'" name="loading">
-      <ScriptAriaLoadingIndicator />
-    </slot>
-    <slot v-if="status === 'awaitingLoad'" name="awaitingLoad" />
-    <slot v-else-if="status === 'error'" name="error" />
-    <slot />
-  </div>
-</template>
+<script setup lang="ts">
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
+/// <reference types="youtube" />
+import { computed, onMounted, ref, watch } from 'vue'
+import type { HTMLAttributes, ImgHTMLAttributes, Ref } from 'vue'
+import { defu } from 'defu'
+import { useHead } from 'nuxt/app'
+import type { ElementScriptTrigger } from '../types'
+import { useScriptTriggerElement } from '../composables/useScriptTriggerElement'
+import { useScriptYouTubePlayer } from '../registry/youtube-player'
+import ScriptAriaLoadingIndicator from './ScriptAriaLoadingIndicator.vue'
+
+export type YoutubeThumbnailSize =
+// 120x90
+  '1' | '2' | '3' | 'default' |
+  // 320x180
+  'mq1' | 'mq2' | 'mq3' | 'mqdefault' |
+  // 480x360
+  '0' | 'hq1' | 'hq2' | 'hq3' | 'hqdefault' |
+  // 640x480
+  'sd1' | 'sd2' | 'sd3' | 'sddefault' |
+  // 1280x720
+  'hq720' |
+  // 1920x1080
+  'maxresdefault'
+
+const props = withDefaults(defineProps<{
+  placeholderAttrs?: ImgHTMLAttributes
+  rootAttrs?: HTMLAttributes
+  aboveTheFold?: boolean
+  trigger?: ElementScriptTrigger
+  videoId: string
+  playerVars?: YT.PlayerVars
+  width?: number
+  height?: number
+  /**
+   * Whether to use youtube-nocookie.com for embedding.
+   *
+   * @default false
+   */
+  cookies?: boolean
+  playerOptions?: YT.PlayerOptions
+  thumbnailSize?: YoutubeThumbnailSize
+  webp?: boolean
+}>(), {
+  cookies: false,
+  trigger: 'mousedown',
+  thumbnailSize: 'hq720',
+  webp: true,
+  // @ts-expect-error untyped
+  playerVars: { autoplay: 0, playsinline: 1 },
+  width: 640,
+  height: 360,
+})
+
+const emits = defineEmits<{
+  'ready': [e: YT.PlayerEvent]
+  'state-change': [e: YT.OnStateChangeEvent, target: YT.Player]
+  'playback-quality-change': [e: YT.OnPlaybackQualityChangeEvent, target: YT.Player]
+  'playback-rate-change': [e: YT.OnPlaybackRateChangeEvent, target: YT.Player]
+  'error': [e: YT.OnErrorEvent, target: YT.Player]
+}>()
+const events: (keyof YT.Events)[] = [
+  'onReady',
+  'onStateChange',
+  'onPlaybackQualityChange',
+  'onPlaybackRateChange',
+  'onError',
+  'onApiChange',
+]
+const rootEl = ref()
+const youtubeEl = ref()
+const ready = ref(false)
+const trigger = useScriptTriggerElement({ trigger: props.trigger, el: rootEl })
+const script = useScriptYouTubePlayer({
+  scriptOptions: {
+    trigger,
+  },
+})
+const { onLoaded, status } = script
+
+const player: Ref<YT.Player | undefined> = ref()
+let clickTriggered = false
+if (props.trigger === 'mousedown' && trigger instanceof Promise) {
+  trigger.then((triggered) => {
+    if (triggered) {
+      clickTriggered = true
+    }
+  })
+}
+onMounted(() => {
+  onLoaded(async (instance) => {
+    const YouTube = instance.YT instanceof Promise ? await instance.YT : instance.YT
+    await new Promise<void>((resolve) => {
+      if (typeof YT.Player === 'undefined')
+        YouTube.ready(resolve)
+      else
+        resolve()
+    })
+    player.value = new YT.Player(youtubeEl.value, {
+      host: !props.cookies ? 'https://www.youtube-nocookie.com' : 'https://www.youtube.com',
+      ...props,
+      ...props.playerOptions,
+      events: Object.fromEntries(events.map(event => [event, (e: any) => {
+        const emitEventName = event.replace(/([A-Z])/g, '-$1').replace('on-', '').toLowerCase()
+        // @ts-expect-error untyped
+        emits(emitEventName, e)
+        if (event === 'onReady') {
+          ready.value = true
+          if (clickTriggered) {
+            player.value?.playVideo()
+            clickTriggered = false
+          }
+          watch(() => props.videoId, () => {
+            player.value?.loadVideoById(props.videoId)
+          })
+        }
+      }])),
+    })
+  })
+  watch(status, (status) => {
+    if (status === 'error') {
+      // @ts-expect-error untyped
+      emits('error')
+    }
+  })
+})
+
+defineExpose({
+  player,
+})
+
+const rootAttrs = computed(() => {
+  return defu(props.rootAttrs, {
+    'aria-busy': status.value === 'loading',
+    'aria-label': status.value === 'awaitingLoad'
+      ? 'YouTube Player - Placeholder'
+      : status.value === 'loading'
+        ? 'YouTube Player - Loading'
+        : 'YouTube Player - Loaded',
+    'aria-live': 'polite',
+    'role': 'application',
+    'style': {
+      cursor: 'pointer',
+      position: 'relative',
+      backgroundColor: 'black',
+      width: '100%',
+      aspectRatio: `${props.width}/${props.height}`,
+    },
+    ...(trigger instanceof Promise ? trigger.ssrAttrs || {} : {}),
+  }) as HTMLAttributes
+})
+
+const fallbackPlaceHolder = computed(() => `https://i.ytimg.com/vi/${props.videoId}/hqdefault.jpg`)
+const placeholder = computed(() => `https://i.ytimg.com/${props.webp ? 'vi_webp' : 'vi'}/${props.videoId}/${props.thumbnailSize}.${props.webp ? 'webp' : 'jpg'}`)
+const isFallbackPlaceHolder = ref(false)
+
+if (import.meta.server) {
+  // dns-prefetch https://i.vimeocdn.com
+  useHead({
+    link: [
+      {
+        key: `nuxt-script-youtube-img`,
+        rel: props.aboveTheFold ? 'preconnect' : 'dns-prefetch',
+        href: 'https://i.ytimg.com',
+      },
+      props.aboveTheFold
+        // we can preload the placeholder image
+        ? {
+            key: `nuxt-script-youtube-img`,
+            rel: 'preload',
+            as: 'image',
+            href: placeholder.value,
+          }
+        : {},
+    ],
+  })
+}
+
+const placeholderAttrs = computed(() => {
+  return defu(props.placeholderAttrs, {
+    src: isFallbackPlaceHolder.value ? fallbackPlaceHolder.value : placeholder.value,
+    alt: '',
+    loading: props.aboveTheFold ? 'eager' : 'lazy',
+    style: {
+      width: '100%',
+      objectFit: 'contain',
+      height: '100%',
+    },
+    onLoad(payload) {
+      const img = payload.target as HTMLImageElement
+      if (img.naturalWidth === 120 && img.naturalHeight === 90) {
+        isFallbackPlaceHolder.value = true
+      }
+    },
+  } satisfies ImgHTMLAttributes)
+})
+</script>
+
+<template>
+  <div ref="rootEl" v-bind="rootAttrs">
+    <div ref="youtubeEl" style="width: 100%; height: 100%; position: absolute; top: 0; left: 0;" />
+    <slot v-if="!ready" :placeholder="placeholder" name="placeholder">
+      <img v-bind="placeholderAttrs">
+    </slot>
+    <slot v-if="status === 'loading'" name="loading">
+      <ScriptAriaLoadingIndicator />
+    </slot>
+    <slot v-if="status === 'awaitingLoad'" name="awaitingLoad" />
+    <slot v-else-if="status === 'error'" name="error" />
+    <slot />
+  </div>
+</template>

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

@@ -1,8 +1,4 @@
 import type { UseScriptInput } from '@unhead/vue/scripts';
-import type { NuxtUseScriptOptions, UseScriptContext } from '../types.js';
-type UseFunctionType<T, U> = T extends {
-    use: infer V;
-} ? V extends (...args: any) => any ? ReturnType<V> : U : U;
+import type { NuxtUseScriptOptions, UseFunctionType, UseScriptContext } from '../types.js';
 export declare function resolveScriptKey(input: any): string;
 export declare function useScript<T extends Record<symbol | string, any> = Record<symbol | string, any>>(input: UseScriptInput, options?: NuxtUseScriptOptions<T>): UseScriptContext<UseFunctionType<NuxtUseScriptOptions<T>, T>>;
-export {};

package/dist/runtime/composables/useScriptEventPage.js

@@ -1,5 +1,4 @@
-import { injectHead } from "@unhead/vue";
-import { useNuxtApp, useRoute } from "nuxt/app";
+import { useNuxtApp, useRoute, injectHead } from "nuxt/app";
 import { ref } from "vue";
 export function useScriptEventPage(onChange) {
   const nuxt = useNuxtApp();

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

@@ -26,7 +26,7 @@ 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>]>;
+    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>;

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

@@ -20,7 +20,7 @@ export declare const CloudflareWebAnalyticsOptions: import("valibot").ObjectSche
     /**
      * The Cloudflare Web Analytics token.
      */
-    readonly token: import("valibot").SchemaWithPipe<[import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 32, undefined>]>;
+    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.

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

@@ -1,4 +1,4 @@
-import { useHead } from "@unhead/vue";
+import { useHead } from "nuxt/app";
 import { useRegistryScript } from "../utils.js";
 import { object, string, optional, boolean } from "#nuxt-scripts-validator";
 export const GoogleAdsenseOptions = object({

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

@@ -4,7 +4,7 @@ export declare const GoogleMapsOptions: import("valibot").ObjectSchema<{
     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<"beta", undefined>, import("valibot").LiteralSchema<"alpha", undefined>], 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>;
 export type GoogleMapsInput = RegistryScriptInput<typeof GoogleMapsOptions>;
 type MapsNamespace = typeof window.google.maps;

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

@@ -6,7 +6,7 @@ export const GoogleMapsOptions = object({
   libraries: optional(array(string())),
   language: optional(string()),
   region: optional(string()),
-  v: optional(union([literal("weekly"), literal("beta"), literal("alpha")]))
+  v: optional(union([literal("weekly"), literal("quarterly"), literal("beta"), literal("alpha"), string()]))
 });
 export function useScriptGoogleMaps(_options) {
   let readyPromise = Promise.resolve();
@@ -14,6 +14,7 @@ export function useScriptGoogleMaps(_options) {
     const libraries = options?.libraries || ["places"];
     const language = options?.language ? { language: options.language } : void 0;
     const region = options?.region ? { region: options.region } : void 0;
+    const version = options?.v ? { v: options.v } : void 0;
     return {
       scriptInput: {
         src: withQuery(`https://maps.googleapis.com/maps/api/js`, {
@@ -22,7 +23,8 @@ export function useScriptGoogleMaps(_options) {
           loading: "async",
           callback: "google.maps.__ib__",
           ...language,
-          ...region
+          ...region,
+          ...version
         })
       },
       clientInit: import.meta.server ? void 0 : () => {

package/dist/runtime/types.d.ts

@@ -1,4 +1,4 @@
-import type { ActiveHeadEntry, AsAsyncFunctionValues, DataKeys, SchemaAugmentations, ScriptBase } from '@unhead/schema';
+import type { Script } from '@unhead/vue/types';
 import type { UseScriptInput, VueScriptInstance, UseScriptOptions } from '@unhead/vue';
 import type { ComputedRef, Ref } from 'vue';
 import type { InferInput, ObjectSchema } from 'valibot';
@@ -26,14 +26,7 @@ import type { GoogleAnalyticsInput } from './registry/google-analytics.js';
 import type { GoogleTagManagerInput } from './registry/google-tag-manager.js';
 import type { UmamiAnalyticsInput } from './registry/umami-analytics.js';
 export type WarmupStrategy = false | 'preload' | 'preconnect' | 'dns-prefetch';
-export type UseScriptContext<T extends Record<symbol | string, any>> = (Promise<T> & VueScriptInstance<T>) & AsAsyncFunctionValues<T> & {
-    /**
-     * @deprecated Use top-level functions instead.
-     */
-    $script: Promise<T> & VueScriptInstance<T>;
-    warmup: (rel: WarmupStrategy) => void;
-    _warmupEl?: void | ActiveHeadEntry<any>;
-};
+export type UseScriptContext<T extends Record<symbol | string, any>> = VueScriptInstance<T>;
 export type NuxtUseScriptOptions<T extends Record<symbol | string, any> = {}> = Omit<UseScriptOptions<T>, 'trigger'> & {
     /**
      * The trigger to load the script:
@@ -148,9 +141,12 @@ export type NuxtConfigScriptRegistryEntry<T> = true | 'mock' | T | [T, NuxtUseSc
 export type NuxtConfigScriptRegistry<T extends keyof ScriptRegistry = keyof ScriptRegistry> = Partial<{
     [key in T]: NuxtConfigScriptRegistryEntry<ScriptRegistry[key]>;
 }>;
+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 = ScriptBase & DataKeys & SchemaAugmentations['script'];
+type ScriptInput = Script;
 export type InferIfSchema<T> = T extends ObjectSchema<any, any> ? InferInput<T> : T;
 export type RegistryScriptInput<T = EmptyOptionsSchema, Bundelable extends boolean = true, Usable extends boolean = false, CanBypassOptions extends boolean = true> = (InferIfSchema<T> & {
     /**

package/dist/runtime/utils.d.ts

@@ -1,6 +1,6 @@
 import type { ObjectSchema } from 'valibot';
 import type { UseScriptInput } from '@unhead/vue';
-import type { EmptyOptionsSchema, InferIfSchema, NuxtUseScriptOptions, RegistryScriptInput, ScriptRegistry } from '#nuxt-scripts/types';
+import type { EmptyOptionsSchema, InferIfSchema, NuxtUseScriptOptions, RegistryScriptInput, UseFunctionType, ScriptRegistry, UseScriptContext } from '#nuxt-scripts/types';
 export type MaybePromise<T> = Promise<T> | T;
 type OptionsFn<O> = (options: InferIfSchema<O>) => ({
     scriptInput?: UseScriptInput;
@@ -9,6 +9,6 @@ type OptionsFn<O> = (options: InferIfSchema<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 = EmptyOptionsSchema, U = {}>(registryKey: keyof ScriptRegistry | string, optionsFn: OptionsFn<O>, _userOptions?: RegistryScriptInput<O>): import("#nuxt-scripts/types").UseScriptContext<T>;
+export declare function useRegistryScript<T extends Record<string | symbol, any>, O = EmptyOptionsSchema, U = {}>(registryKey: keyof ScriptRegistry | string, optionsFn: OptionsFn<O>, _userOptions?: RegistryScriptInput<O>): UseScriptContext<UseFunctionType<NuxtUseScriptOptions<T>, T>>;
 export declare function pick(obj: Record<string, any>, keys: string[]): Record<string, any>;
 export {};

package/dist/runtime/utils.js

@@ -1,6 +1,6 @@
 import { defu } from "defu";
 import { useRuntimeConfig } from "nuxt/app";
-import { useScript } from "#imports";
+import { useScript } from "./composables/useScript.js";
 import { parse } from "#nuxt-scripts-validator";
 function validateScriptInputSchema(key, schema, options) {
   if (import.meta.dev) {

package/dist/runtime/validation/mock.d.ts

@@ -1,39 +1,39 @@
 export declare const parse: (() => void) & {
-    __unenv__: boolean;
+    __mock__: boolean;
 };
 export declare const object: (() => void) & {
-    __unenv__: boolean;
+    __mock__: boolean;
 };
 export declare const array: (() => void) & {
-    __unenv__: boolean;
+    __mock__: boolean;
 };
 export declare const string: (() => void) & {
-    __unenv__: boolean;
+    __mock__: boolean;
 };
 export declare const number: (() => void) & {
-    __unenv__: boolean;
+    __mock__: boolean;
 };
 export declare const boolean: (() => void) & {
-    __unenv__: boolean;
+    __mock__: boolean;
 };
 export declare const optional: (() => void) & {
-    __unenv__: boolean;
+    __mock__: boolean;
 };
 export declare const literal: (() => void) & {
-    __unenv__: boolean;
+    __mock__: boolean;
 };
 export declare const union: (() => void) & {
-    __unenv__: boolean;
+    __mock__: boolean;
 };
 export declare const record: (() => void) & {
-    __unenv__: boolean;
+    __mock__: boolean;
 };
 export declare const any: (() => void) & {
-    __unenv__: boolean;
+    __mock__: boolean;
 };
 export declare const minLength: (() => void) & {
-    __unenv__: boolean;
+    __mock__: boolean;
 };
 export declare const pipe: (() => void) & {
-    __unenv__: boolean;
+    __mock__: boolean;
 };

package/dist/runtime/validation/mock.js

@@ -1,4 +1,10 @@
-import noop from "unenv/runtime/mock/noop";
+const noop = Object.freeze(
+  Object.assign(
+    () => {
+    },
+    { __mock__: true }
+  )
+);
 export const parse = noop;
 export const object = noop;
 export const array = noop;