@nuxt/scripts 0.9.4 → 0.10.0

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

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 type StandardEvents = 'AddPaymentInfo' | 'AddToCart' | 'AddToWishlist' | 'CompleteRegistration' | 'Contact' | 'CustomizeProduct' | 'Donate' | 'FindLocation' | 'InitiateCheckout' | 'Lead' | 'Purchase' | 'Schedule' | 'Search' | 'StartTrial' | 'SubmitApplication' | 'Subscribe' | 'ViewContent';
 interface EventObjectProperties {
     content_category?: string;
@@ -37,5 +37,5 @@ export declare const MetaPixelOptions: import("valibot").ObjectSchema<{
     readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
 }, undefined>;
 export type MetaPixelInput = RegistryScriptInput<typeof MetaPixelOptions, true, false, false>;
-export declare function useScriptMetaPixel<T extends MetaPixelApi>(_options?: MetaPixelInput): import("../composables/useScript").UseScriptContext<T>;
+export declare function useScriptMetaPixel<T extends MetaPixelApi>(_options?: MetaPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
 export {};

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

@@ -1,9 +1,9 @@
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 export declare const NpmOptions: import("valibot").ObjectSchema<{
     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>;
+    readonly file: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly version: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly provider: import("valibot").OptionalSchema<import("valibot").UnionSchema<import("valibot").LiteralSchema<"jsdelivr" | "cdnjs" | "unpkg", undefined>[], undefined>, undefined>;
 }, undefined>;
 export type NpmInput = RegistryScriptInput<typeof NpmOptions, true, true, false>;
-export declare function useScriptNpm<T extends Record<string | symbol, any>>(_options: NpmInput): import("../composables/useScript").UseScriptContext<T>;
+export declare function useScriptNpm<T extends Record<string | symbol, any>>(_options: NpmInput): import("#nuxt-scripts/types").UseScriptContext<T>;

package/dist/runtime/registry/npm.js

@@ -1,17 +1,33 @@
 import { withBase } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { object, optional, string } from "#nuxt-scripts-validator";
+import { object, optional, string, union, literal } from "#nuxt-scripts-validator";
+const PROVIDERS = ["jsdelivr", "cdnjs", "unpkg"];
+const providerValidator = union(PROVIDERS.map((provider) => literal(provider)));
 export const NpmOptions = object({
   packageName: string(),
   file: optional(string()),
   version: optional(string()),
-  type: optional(string())
+  provider: optional(providerValidator)
 });
 export function useScriptNpm(_options) {
-  return useRegistryScript(`${_options.packageName}-npm`, (options) => ({
-    scriptInput: {
-      src: withBase(options.file || "", `https://unpkg.com/${options?.packageName}@${options.version || "latest"}`)
-    },
-    schema: import.meta.dev ? NpmOptions : void 0
-  }), _options);
+  return useRegistryScript(`${_options.packageName}-npm`, (options) => {
+    const baseUrl = getProviderBaseUrl(options.provider, options.packageName, options.version);
+    return {
+      scriptInput: {
+        src: withBase(options.file || "", baseUrl)
+      },
+      schema: import.meta.dev ? NpmOptions : void 0
+    };
+  }, _options);
+}
+function getProviderBaseUrl(provider = "unpkg", packageName, version = "latest") {
+  switch (provider) {
+    case "jsdelivr":
+      return `https://cdn.jsdelivr.net/npm/${packageName}@${version}/`;
+    case "cdnjs":
+      return `https://cdnjs.cloudflare.com/ajax/libs/${packageName}/${version}/`;
+    case "unpkg":
+    default:
+      return `https://unpkg.com/${packageName}@${version}/`;
+  }
 }

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

@@ -1,7 +1,7 @@
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 export declare const PlausibleAnalyticsOptions: import("valibot").ObjectSchema<{
     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>;
+    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>, undefined>;
 }, undefined>;
 export type PlausibleAnalyticsInput = RegistryScriptInput<typeof PlausibleAnalyticsOptions, false>;
 export interface PlausibleAnalyticsApi {
@@ -14,4 +14,4 @@ declare global {
         plausible: PlausibleAnalyticsApi;
     }
 }
-export declare function useScriptPlausibleAnalytics<T extends PlausibleAnalyticsApi>(_options?: PlausibleAnalyticsInput): import("../composables/useScript").UseScriptContext<T>;
+export declare function useScriptPlausibleAnalytics<T extends PlausibleAnalyticsApi>(_options?: PlausibleAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;

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

@@ -1,7 +1,7 @@
-import type { RegistryScriptInput } from '#nuxt-scripts';
+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>, never>;
+    readonly analyticsKey: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
 }, undefined>;
 export type SegmentInput = RegistryScriptInput<typeof SegmentOptions>;
 interface AnalyticsApi {
@@ -29,5 +29,5 @@ declare global {
     interface Window extends SegmentApi {
     }
 }
-export declare function useScriptSegment<T extends SegmentApi>(_options?: SegmentInput): import("../composables/useScript").UseScriptContext<T>;
+export declare function useScriptSegment<T extends SegmentApi>(_options?: SegmentInput): import("#nuxt-scripts/types").UseScriptContext<T>;
 export {};

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

@@ -0,0 +1,71 @@
+import type { InferInput } from '#nuxt-scripts-validator';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+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;
+    client_dedup_id?: string;
+    currency?: string;
+    transaction_id?: string;
+    item_ids?: string[];
+    item_category?: string;
+    description?: string;
+    search_string?: string;
+    number_items?: number;
+    payment_info_available?: 0 | 1;
+    sign_up_method?: string;
+    success?: 0 | 1;
+    brands?: string[];
+    delivery_method?: 'in_store' | 'curbside' | 'delivery';
+    customer_status?: 'new' | 'returning' | 'reactivated';
+    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 {
+    snaptr: SnapTrFns & {
+        push: SnapTrFns;
+        loaded: boolean;
+        version: string;
+        queue: any[];
+    };
+    _snaptr: SnapPixelApi['snaptr'];
+    handleRequest?: SnapTrFns;
+}
+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

@@ -0,0 +1,55 @@
+import { useRegistryScript } from "../utils.js";
+import { boolean, object, optional, string } from "#nuxt-scripts-validator";
+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
+});
+export function useScriptSnapchatPixel(_options) {
+  return useRegistryScript("snapchatPixel", (options) => ({
+    scriptInput: {
+      src: "https://sc-static.net/scevent.min.js",
+      crossorigin: false
+    },
+    schema: import.meta.dev ? SnapTrPixelOptions : void 0,
+    scriptOptions: {
+      use() {
+        return { snaptr: window.snaptr };
+      }
+    },
+    clientInit: import.meta.server ? void 0 : () => {
+      const snaptr = window.snaptr = function(...params) {
+        if (snaptr.handleRequest) {
+          snaptr.handleRequest(...params);
+        } else {
+          snaptr.queue.push(params);
+        }
+      };
+      if (!window.snaptr)
+        window._snaptr = snaptr;
+      snaptr.push = snaptr;
+      snaptr.loaded = true;
+      snaptr.version = "1.0";
+      snaptr.queue = [];
+      const { id, ...initData } = options;
+      snaptr("init", options?.id, initData);
+      if (options?.trackPageView) {
+        snaptr("track", "PAGE_VIEW");
+      }
+    }
+  }), _options);
+}

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

@@ -1,13 +1,10 @@
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { Stripe } from '@stripe/stripe-js';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 export declare const StripeOptions: import("valibot").ObjectSchema<{
-    readonly advancedFraudSignals: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
+    readonly advancedFraudSignals: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
 }, undefined>;
 export type StripeInput = RegistryScriptInput<typeof StripeOptions, false>;
 export interface StripeApi {
-    Stripe: stripe.StripeStatic;
+    Stripe: Stripe;
 }
-declare global {
-    interface Window extends StripeApi {
-    }
-}
-export declare function useScriptStripe<T extends StripeApi>(_options?: StripeInput): import("../composables/useScript").UseScriptContext<T>;
+export declare function useScriptStripe<T extends StripeApi>(_options?: StripeInput): import("#nuxt-scripts/types").UseScriptContext<T>;

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

@@ -0,0 +1,37 @@
+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>;
+}, undefined>;
+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);
+    identify: (session_data?: Record<string, any>) => void;
+}
+declare global {
+    interface Window {
+        umami: UmamiAnalyticsApi;
+    }
+}
+export declare function useScriptUmamiAnalytics<T extends UmamiAnalyticsApi>(_options?: UmamiAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;

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

@@ -0,0 +1,49 @@
+import { useRegistryScript } from "../utils.js";
+import { object, optional, string, boolean, array } from "#nuxt-scripts-validator";
+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())
+});
+export function useScriptUmamiAnalytics(_options) {
+  return useRegistryScript("umamiAnalytics", (options) => {
+    const domains = Array.isArray(options?.domains) ? options.domains.join(",") : options?.domains;
+    return {
+      scriptInput: {
+        "src": "https://cloud.umami.is/script.js",
+        "data-website-id": options.websiteId,
+        "data-host-url": options?.hostUrl || void 0,
+        "data-auto-track": typeof options?.autoTrack === "boolean" ? options.autoTrack : true,
+        "data-domains": domains || void 0,
+        "data-tag": options?.tag || void 0
+      },
+      schema: import.meta.dev ? UmamiAnalyticsOptions : void 0,
+      scriptOptions: {
+        use() {
+          return window.umami;
+        }
+      }
+    };
+  }, _options);
+}

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

@@ -1,6 +1,6 @@
 import type Vimeo from '@vimeo/player';
 import type { UseScriptContext } from '@unhead/vue';
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 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: {

package/dist/runtime/registry/vimeo-player.js

@@ -1,6 +1,6 @@
 import { watch } from "vue";
+import { useHead } from "@unhead/vue";
 import { useRegistryScript } from "../utils.js";
-import { useHead } from "#imports";
 export function useScriptVimeoPlayer(_options) {
   const instance = useRegistryScript("vimeoPlayer", () => ({
     scriptInput: {

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

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

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

@@ -1,6 +1,6 @@
 import type { UseScriptContext } from '@unhead/vue';
 import type { MaybePromise } from '../utils.js';
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 export interface YouTubePlayerApi {
     YT: MaybePromise<{
         Player: YT.Player;

package/dist/runtime/registry/youtube-player.js

@@ -1,6 +1,6 @@
 import { watch } from "vue";
+import { useHead } from "@unhead/vue";
 import { useRegistryScript } from "../utils.js";
-import { useHead } from "#imports";
 export function useScriptYouTubePlayer(_options) {
   let readyPromise = Promise.resolve();
   const instance = useRegistryScript("youtubePlayer", () => ({

package/dist/runtime/types.d.ts

@@ -1,4 +1,4 @@
-import type { DataKeys, SchemaAugmentations, ScriptBase } from '@unhead/schema';
+import type { ActiveHeadEntry, AsAsyncFunctionValues, DataKeys, SchemaAugmentations, ScriptBase } from '@unhead/schema';
 import type { UseScriptInput, VueScriptInstance, UseScriptOptions } from '@unhead/vue';
 import type { ComputedRef, Ref } from 'vue';
 import type { InferInput, ObjectSchema } from 'valibot';
@@ -14,6 +14,7 @@ import type { MatomoAnalyticsInput } from './registry/matomo-analytics.js';
 import type { StripeInput } from './registry/stripe.js';
 import type { VimeoPlayerInput } from './registry/vimeo-player.js';
 import type { XPixelInput } from './registry/x-pixel.js';
+import type { SnapTrPixelInput } from './registry/snapchat-pixel.js';
 import type { YouTubePlayerInput } from './registry/youtube-player.js';
 import type { PlausibleAnalyticsInput } from './registry/plausible-analytics.js';
 import type { NpmInput } from './registry/npm.js';
@@ -23,6 +24,16 @@ import type { ClarityInput } from './registry/clarity.js';
 import type { CrispInput } from './registry/crisp.js';
 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 NuxtUseScriptOptions<T extends Record<symbol | string, any> = {}, U = {}> = Omit<UseScriptOptions<T, U>, 'trigger'> & {
     /**
      * The trigger to load the script:
@@ -44,6 +55,16 @@ export type NuxtUseScriptOptions<T extends Record<symbol | string, any> = {}, U
      * loading the actual script and not getting warnings.
      */
     skipValidation?: boolean;
+    /**
+     * Specify a strategy for warming up the connection to the third-party script.
+     *
+     * The strategy to use for preloading the script.
+     *  - `false` - Disable preloading.
+     *  - `'preload'` - Preload the script.
+     *  - `'preconnect'` | `'dns-prefetch'` - Preconnect to the script. Only works when loading a script from a different origin, will fallback
+     *  to `false` if the origin is the same.
+     */
+    warmupStrategy?: WarmupStrategy;
     /**
      * @internal
      */
@@ -116,8 +137,10 @@ export interface ScriptRegistry {
     segment?: SegmentInput;
     stripe?: StripeInput;
     xPixel?: XPixelInput;
+    snapchatPixel?: SnapTrPixelInput;
     youtubePlayer?: YouTubePlayerInput;
     vimeoPlayer?: VimeoPlayerInput;
+    umamiAnalytics?: UmamiAnalyticsInput;
     [key: `${string}-npm`]: NpmInput;
 }
 export type NuxtConfigScriptRegistryEntry<T> = true | 'mock' | T | [T, NuxtUseScriptOptionsSerializable];
@@ -127,14 +150,15 @@ export type NuxtConfigScriptRegistry<T extends keyof ScriptRegistry = keyof Scri
 declare const _emptyOptions: ObjectSchema<{}, undefined>;
 export type EmptyOptionsSchema = typeof _emptyOptions;
 type ScriptInput = ScriptBase & DataKeys & SchemaAugmentations['script'];
-export type RegistryScriptInput<T extends ObjectSchema<any, any> = EmptyOptionsSchema, Bundelable extends boolean = true, Usable extends boolean = false, CanBypassOptions extends boolean = true> = (InferInput<T> & {
+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> & {
     /**
      * A unique key to use for the script, this can be used to load multiple of the same script with different options.
      */
     key?: string;
     scriptInput?: ScriptInput;
     scriptOptions?: Omit<NuxtUseScriptOptions, Bundelable extends true ? '' : 'bundle' | Usable extends true ? '' : 'use'>;
-}) | Partial<InferInput<T>> & (CanBypassOptions extends true ? {
+}) | Partial<InferIfSchema<T>> & (CanBypassOptions extends true ? {
     /**
      * 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,13 +1,14 @@
-import type { InferInput, ObjectSchema } from 'valibot';
+import type { ObjectSchema } from 'valibot';
 import type { UseScriptInput } from '@unhead/vue';
-import type { EmptyOptionsSchema, NuxtUseScriptOptions, RegistryScriptInput, ScriptRegistry } from '#nuxt-scripts';
+import type { EmptyOptionsSchema, InferIfSchema, NuxtUseScriptOptions, RegistryScriptInput, ScriptRegistry } from '#nuxt-scripts/types';
 export type MaybePromise<T> = Promise<T> | T;
-type OptionsFn<O extends ObjectSchema<any, any>> = (options: InferInput<O>) => ({
+type OptionsFn<O> = (options: InferIfSchema<O>) => ({
     scriptInput?: UseScriptInput;
     scriptOptions?: NuxtUseScriptOptions;
-    schema?: O;
+    schema?: O extends ObjectSchema<any, any> ? O : undefined;
     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, any> = EmptyOptionsSchema, U = {}>(registryKey: keyof ScriptRegistry | string, optionsFn: OptionsFn<O>, _userOptions?: RegistryScriptInput<O>): import("./composables/useScript").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>): import("#nuxt-scripts/types").UseScriptContext<T>;
+export declare function pick(obj: Record<string, any>, keys: string[]): Record<string, any>;
 export {};

package/dist/runtime/utils.js

@@ -1,7 +1,7 @@
 import { defu } from "defu";
+import { useRuntimeConfig } from "nuxt/app";
 import { useScript } from "./composables/useScript.js";
 import { parse } from "#nuxt-scripts-validator";
-import { useRuntimeConfig } from "#imports";
 function validateScriptInputSchema(key, schema, options) {
   if (import.meta.dev) {
     try {
@@ -47,3 +47,12 @@ export function useRegistryScript(registryKey, optionsFn, _userOptions) {
   };
   return useScript(scriptInput, scriptOptions);
 }
+export function pick(obj, keys) {
+  const res = {};
+  for (const k of keys) {
+    if (k in obj) {
+      res[k] = obj[k];
+    }
+  }
+  return res;
+}