@nuxt/scripts 0.9.3 → 0.9.5

package/dist/module.json

@@ -5,7 +5,7 @@
     "nuxt": ">=3",
     "bridge": false
   },
-  "version": "0.9.3",
+  "version": "0.9.5",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "2.0.0"

package/dist/module.mjs

@@ -69,10 +69,10 @@ const logger = useLogger("@nuxt/scripts");
 const renderedScript = /* @__PURE__ */ new Map();
 const ONE_YEAR_IN_SECONDS = 60 * 60 * 24 * 365;
 const bundleStorage = () => {
-  const nuxt = useNuxt();
+  const nuxt = tryUseNuxt();
   return createStorage({
     driver: fsDriver({
-      base: resolve(nuxt.options.rootDir, "node_modules/.cache/nuxt/scripts")
+      base: resolve(nuxt?.options.rootDir || "", "node_modules/.cache/nuxt/scripts")
     })
   });
 };

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

@@ -1,10 +1,4 @@
-import type { UseScriptInput, VueScriptInstance } from '@unhead/vue';
-import type { UseFunctionType, AsAsyncFunctionValues } from '@unhead/schema';
-import type { NuxtUseScriptOptions } from '#nuxt-scripts';
-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>;
-};
+import type { UseScriptInput } from '@unhead/vue';
+import type { UseFunctionType } from '@unhead/schema';
+import type { NuxtUseScriptOptions, UseScriptContext } from '#nuxt-scripts';
 export declare function useScript<T extends Record<symbol | string, any> = Record<symbol | string, any>, U = Record<symbol | string, any>>(input: UseScriptInput, options?: NuxtUseScriptOptions<T, U>): UseScriptContext<UseFunctionType<NuxtUseScriptOptions<T, U>, T>>;

package/dist/runtime/composables/useScript.js

@@ -1,37 +1,59 @@
 import { resolveScriptKey } from "unhead";
 import { defu } from "defu";
 import { useScript as _useScript } from "@unhead/vue";
+import { parseURL } from "ufo";
+import { pick } from "../utils.js";
 import { injectHead, onNuxtReady, useHead, useNuxtApp, useRuntimeConfig, reactive } from "#imports";
 function useNuxtScriptRuntimeConfig() {
   return useRuntimeConfig().public["nuxt-scripts"];
 }
+const ValidPreloadTriggers = ["onNuxtReady", "client"];
+const PreconnectServerModes = ["preconnect", "dns-prefetch"];
+function warmup(_, rel, head) {
+  const { src } = _;
+  const $url = parseURL(src);
+  const isPreconnect = rel && PreconnectServerModes.includes(rel);
+  const href = isPreconnect ? `${$url.protocol}${$url.host}` : src;
+  const isCrossOrigin = !!$url.host;
+  if (!rel || isPreconnect && !isCrossOrigin) {
+    return;
+  }
+  const link = {
+    href,
+    rel,
+    ...pick(_, [
+      // shared keys between script and link
+      "crossorigin",
+      "referrerpolicy",
+      "fetchpriority",
+      "integrity"
+      // ignore id
+    ])
+  };
+  const defaults = { fetchpriority: "low" };
+  if (rel === "preload") {
+    defaults.as = "script";
+  }
+  if (isCrossOrigin) {
+    defaults.crossorigin = "anonymous";
+    defaults.referrerpolicy = "no-referrer";
+  }
+  return useHead({ link: [defu(link, defaults)] }, { head, tagPriority: "high" });
+}
 export function useScript(input, options) {
   input = typeof input === "string" ? { src: input } : input;
   options = defu(options, useNuxtScriptRuntimeConfig()?.defaultScriptOptions);
-  const rel = options.trigger === "onNuxtReady" ? "preload" : "preconnect";
-  const isCrossOrigin = input.src && !input.src.startsWith("/");
-  const id = resolveScriptKey(input);
-  if (input.src && options.trigger !== "server" && (rel === "preload" || isCrossOrigin)) {
-    useHead({
-      link: [
-        {
-          rel,
-          as: rel === "preload" ? "script" : void 0,
-          href: input.src,
-          crossorigin: !isCrossOrigin ? void 0 : typeof input.crossorigin !== "undefined" ? input.crossorigin : "anonymous",
-          key: `nuxt-script-${id}`,
-          tagPriority: rel === "preload" ? "high" : 0,
-          fetchpriority: "low"
-        }
-      ]
-    });
+  const id = String(resolveScriptKey(input));
+  const nuxtApp = useNuxtApp();
+  const head = options.head || injectHead();
+  nuxtApp.$scripts = nuxtApp.$scripts || reactive({});
+  const exists = !!nuxtApp.$scripts?.[id];
+  if (!options.warmupStrategy && ValidPreloadTriggers.includes(String(options.trigger))) {
+    options.warmupStrategy = "preload";
   }
   if (options.trigger === "onNuxtReady") {
     options.trigger = onNuxtReady;
   }
-  const nuxtApp = useNuxtApp();
-  nuxtApp.$scripts = nuxtApp.$scripts || reactive({});
-  const exists = !!nuxtApp.$scripts?.[id];
   if (import.meta.client) {
     if (!exists) {
       performance?.mark?.("mark_feature_usage", {
@@ -42,6 +64,20 @@ export function useScript(input, options) {
     }
   }
   const instance = _useScript(input, options);
+  instance.warmup = (rel) => {
+    if (!instance._warmupEl) {
+      instance._warmupEl = warmup(input, rel, head);
+    }
+  };
+  if (options.warmupStrategy) {
+    instance.warmup(options.warmupStrategy);
+  }
+  const _remove = instance.remove;
+  instance.remove = () => {
+    instance._warmupEl?.dispose();
+    nuxtApp.$scripts[id] = void 0;
+    return _remove();
+  };
   nuxtApp.$scripts[id] = instance;
   if (import.meta.dev && import.meta.client) {
     let syncScripts = function() {
@@ -59,7 +95,6 @@ export function useScript(input, options) {
     };
     nuxtApp._scripts = nuxtApp._scripts || {};
     if (!nuxtApp._scripts[instance.id]) {
-      const head = injectHead();
       head.hooks.hook("script:updated", (ctx) => {
         if (ctx.script.id !== instance.id)
           return;

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

@@ -29,5 +29,5 @@ export declare const ClarityOptions: import("valibot").ObjectSchema<{
     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): import("../composables/useScript").UseScriptContext<T>;
+export declare function useScriptClarity<T extends ClarityApi>(_options?: ClarityInput): import("#nuxt-scripts").UseScriptContext<T>;
 export {};

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

@@ -30,4 +30,4 @@ export declare const CloudflareWebAnalyticsOptions: import("valibot").ObjectSche
     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): import("../composables/useScript").UseScriptContext<T>;
+export declare function useScriptCloudflareWebAnalytics<T extends CloudflareWebAnalyticsApi>(_options?: CloudflareWebAnalyticsInput): import("#nuxt-scripts").UseScriptContext<T>;

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

@@ -57,4 +57,4 @@ declare global {
         $crisp: CrispApi;
     }
 }
-export declare function useScriptCrisp<T extends CrispApi>(_options?: CrispInput): import("../composables/useScript").UseScriptContext<T>;
+export declare function useScriptCrisp<T extends CrispApi>(_options?: CrispInput): import("#nuxt-scripts").UseScriptContext<T>;

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

@@ -47,4 +47,4 @@ declare global {
         fathom: FathomAnalyticsApi;
     }
 }
-export declare function useScriptFathomAnalytics<T extends FathomAnalyticsApi>(_options?: FathomAnalyticsInput): import("../composables/useScript").UseScriptContext<T>;
+export declare function useScriptFathomAnalytics<T extends FathomAnalyticsApi>(_options?: FathomAnalyticsInput): import("#nuxt-scripts").UseScriptContext<T>;

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

@@ -23,4 +23,4 @@ declare global {
  *
  * A 3P wrapper for Google Analytics that takes an options input to feed into third-party-capital({@link https://github.com/GoogleChromeLabs/third-party-capital}), which returns instructions for nuxt-scripts.
  */
-export declare function useScriptGoogleAdsense<T extends GoogleAdsenseApi>(_options?: GoogleAdsenseInput): import("../composables/useScript").UseScriptContext<T>;
+export declare function useScriptGoogleAdsense<T extends GoogleAdsenseApi>(_options?: GoogleAdsenseInput): import("#nuxt-scripts").UseScriptContext<T>;

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

@@ -5,7 +5,7 @@ export declare const GoogleAnalyticsOptions: import("valibot").ObjectSchema<{
     readonly l: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
 }, undefined>;
 export type GoogleAnalyticsInput = RegistryScriptInput<typeof GoogleAnalyticsOptions>;
-export declare function useScriptGoogleAnalytics(_options?: GoogleAnalyticsInput): import("../composables/useScript").UseScriptContext<{
+export declare function useScriptGoogleAnalytics(_options?: GoogleAnalyticsInput): import("#nuxt-scripts").UseScriptContext<{
     dataLayer: DataLayer;
     gtag: GTag;
 }>;

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

@@ -10,6 +10,8 @@ declare namespace google {
 export declare const GoogleMapsOptions: import("valibot").ObjectSchema<{
     readonly apiKey: import("valibot").StringSchema<undefined>;
     readonly libraries: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, never>;
+    readonly language: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
+    readonly region: import("valibot").OptionalSchema<import("valibot").StringSchema<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>;
@@ -24,5 +26,5 @@ declare global {
         };
     }
 }
-export declare function useScriptGoogleMaps<T extends GoogleMapsApi>(_options?: GoogleMapsInput): import("../composables/useScript").UseScriptContext<T>;
+export declare function useScriptGoogleMaps<T extends GoogleMapsApi>(_options?: GoogleMapsInput): import("#nuxt-scripts").UseScriptContext<T>;
 export {};

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

@@ -4,19 +4,25 @@ import { array, literal, object, optional, string, union } from "#nuxt-scripts-v
 export const GoogleMapsOptions = object({
   apiKey: string(),
   libraries: optional(array(string())),
+  language: optional(string()),
+  region: optional(string()),
   v: optional(union([literal("weekly"), literal("beta"), literal("alpha")]))
 });
 export function useScriptGoogleMaps(_options) {
   let readyPromise = Promise.resolve();
   return useRegistryScript("googleMaps", (options) => {
     const libraries = options?.libraries || ["places"];
+    const language = options?.language ? { language: options.language } : void 0;
+    const region = options?.region ? { region: options.region } : void 0;
     return {
       scriptInput: {
         src: withQuery(`https://maps.googleapis.com/maps/api/js`, {
           libraries: libraries.join(","),
           key: options?.apiKey,
           loading: "async",
-          callback: "google.maps.__ib__"
+          callback: "google.maps.__ib__",
+          ...language,
+          ...region
         })
       },
       clientInit: import.meta.server ? void 0 : () => {

package/dist/runtime/registry/google-tag-manager.d.ts

@@ -9,7 +9,7 @@ export declare const GoogleTagManagerOptions: import("valibot").ObjectSchema<{
     readonly l: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
 }, undefined>;
 export type GoogleTagManagerInput = RegistryScriptInput<typeof GoogleTagManagerOptions>;
-export declare function useScriptGoogleTagManager(_options?: GoogleTagManagerInput): import("../composables/useScript").UseScriptContext<{
+export declare function useScriptGoogleTagManager(_options?: GoogleTagManagerInput): import("#nuxt-scripts").UseScriptContext<{
     dataLayer: DataLayer;
     google_tag_manager: import("third-party-capital").GoogleTagManagerInstance;
 }>;

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

@@ -17,4 +17,4 @@ export declare const HotjarOptions: import("valibot").ObjectSchema<{
     readonly sv: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, never>;
 }, undefined>;
 export type HotjarInput = RegistryScriptInput<typeof HotjarOptions, true, false, false>;
-export declare function useScriptHotjar<T extends HotjarApi>(_options?: HotjarInput): import("../composables/useScript").UseScriptContext<T>;
+export declare function useScriptHotjar<T extends HotjarApi>(_options?: HotjarInput): import("#nuxt-scripts").UseScriptContext<T>;

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

@@ -19,4 +19,4 @@ declare global {
         intercomSettings?: any;
     }
 }
-export declare function useScriptIntercom<T extends IntercomApi>(_options?: IntercomInput): import("../composables/useScript").UseScriptContext<T>;
+export declare function useScriptIntercom<T extends IntercomApi>(_options?: IntercomInput): import("#nuxt-scripts").UseScriptContext<T>;

package/dist/runtime/registry/lemon-squeezy.d.ts

@@ -69,4 +69,4 @@ declare global {
         LemonSqueezy: LemonSqueezyApi;
     }
 }
-export declare function useScriptLemonSqueezy<T extends LemonSqueezyApi>(_options?: LemonSqueezyInput): import("../composables/useScript").UseScriptContext<T>;
+export declare function useScriptLemonSqueezy<T extends LemonSqueezyApi>(_options?: LemonSqueezyInput): import("#nuxt-scripts").UseScriptContext<T>;

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

@@ -1,7 +1,8 @@
 import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const MatomoAnalyticsOptions: import("valibot").ObjectSchema<{
     readonly matomoUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
-    readonly siteId: import("valibot").StringSchema<undefined>;
+    readonly siteId: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>, never>;
+    readonly cloudId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
     readonly trackerUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
     readonly trackPageView: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
     readonly enableLinkTracking: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
@@ -15,5 +16,5 @@ declare global {
     interface Window extends MatomoAnalyticsApi {
     }
 }
-export declare function useScriptMatomoAnalytics<T extends MatomoAnalyticsApi>(_options?: MatomoAnalyticsInput): import("../composables/useScript").UseScriptContext<T>;
+export declare function useScriptMatomoAnalytics<T extends MatomoAnalyticsApi>(_options?: MatomoAnalyticsInput): import("#nuxt-scripts").UseScriptContext<T>;
 export {};

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

@@ -1,45 +1,52 @@
-import { withBase, withHttps } from "ufo";
+import { withBase, withHttps, withoutProtocol, withoutTrailingSlash } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { boolean, object, optional, string } from "#nuxt-scripts-validator";
+import { boolean, object, optional, string, number, union } from "#nuxt-scripts-validator";
 export const MatomoAnalyticsOptions = object({
   matomoUrl: optional(string()),
-  siteId: string(),
+  siteId: optional(union([string(), number()])),
+  cloudId: optional(string()),
   trackerUrl: optional(string()),
   trackPageView: optional(boolean()),
   enableLinkTracking: optional(boolean()),
   disableCookies: optional(boolean())
 });
 export function useScriptMatomoAnalytics(_options) {
-  return useRegistryScript("matomoAnalytics", (options) => ({
-    scriptInput: {
-      src: withBase(`/matomo.js`, withHttps(options?.matomoUrl || "")),
-      crossorigin: false
-    },
-    schema: import.meta.dev ? MatomoAnalyticsOptions : void 0,
-    scriptOptions: {
-      use() {
-        return { _paq: window._paq };
+  return useRegistryScript("matomoAnalytics", (options) => {
+    const normalizedCloudId = options?.cloudId ? withoutTrailingSlash(withoutProtocol(options.cloudId)) : void 0;
+    const origin = options?.matomoUrl ? options.matomoUrl : `https://cdn.matomo.cloud/${normalizedCloudId}/`;
+    const _paq = import.meta.client ? window._paq = window._paq || [] : [];
+    return {
+      scriptInput: {
+        src: withBase(`/matomo.js`, origin),
+        crossorigin: false
       },
-      // allow _paq to be accessed on the server
-      stub: import.meta.client ? void 0 : ({ fn }) => {
-        return fn === "_paq" ? [] : void 0;
-      }
-    },
-    clientInit: import.meta.server ? void 0 : () => {
-      const _paq = window._paq = window._paq || [];
-      if (options?.trackPageView) {
-        _paq.push(["trackPageView"]);
-      }
-      if (options?.enableLinkTracking) {
-        _paq.push(["enableLinkTracking"]);
-      }
-      if (options?.disableCookies) {
-        _paq.push(["disableCookies"]);
-      }
-      if (options?.trackerUrl || options?.matomoUrl) {
-        _paq.push(["setTrackerUrl", options?.trackerUrl ? withHttps(options.trackerUrl) : withBase(`/matomo.php`, withHttps(options?.matomoUrl || ""))]);
+      schema: import.meta.dev ? MatomoAnalyticsOptions : void 0,
+      scriptOptions: {
+        use() {
+          return { _paq: window._paq };
+        },
+        // allow _paq to be accessed on the server
+        stub: import.meta.client ? void 0 : ({ fn }) => {
+          return fn === "_paq" ? [] : void 0;
+        }
+      },
+      clientInit: import.meta.server ? void 0 : () => {
+        if (options?.enableLinkTracking) {
+          _paq.push(["enableLinkTracking"]);
+        }
+        if (options?.disableCookies) {
+          _paq.push(["disableCookies"]);
+        }
+        if (options?.trackerUrl || options?.matomoUrl) {
+          _paq.push(["setTrackerUrl", options?.trackerUrl ? withHttps(options.trackerUrl) : withBase(`/matomo.php`, withHttps(options?.matomoUrl || ""))]);
+        } else if (normalizedCloudId) {
+          _paq.push(["setTrackerUrl", withBase(`/matomo.php`, withHttps(normalizedCloudId))]);
+        }
+        _paq.push(["setSiteId", String(options?.siteId) || "1"]);
+        if (options?.trackPageView) {
+          _paq.push(["trackPageView"]);
+        }
       }
-      _paq.push(["setSiteId", options?.siteId || "1"]);
-    }
-  }), _options);
+    };
+  }, _options);
 }

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

@@ -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").UseScriptContext<T>;
 export {};

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

@@ -6,4 +6,4 @@ export declare const NpmOptions: import("valibot").ObjectSchema<{
     readonly type: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
 }, 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").UseScriptContext<T>;

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

@@ -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").UseScriptContext<T>;

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

@@ -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").UseScriptContext<T>;
 export {};

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

@@ -1,13 +1,10 @@
+import type { Stripe } from '@stripe/stripe-js';
 import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const StripeOptions: import("valibot").ObjectSchema<{
     readonly advancedFraudSignals: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
 }, 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").UseScriptContext<T>;

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

@@ -32,5 +32,5 @@ export declare const XPixelOptions: import("valibot").ObjectSchema<{
     readonly version: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
 }, 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").UseScriptContext<T>;
 export {};

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';
@@ -23,6 +23,15 @@ 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';
+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 +53,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
      */
@@ -127,14 +146,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';
 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").UseScriptContext<T>;
+export declare function pick(obj: Record<string, any>, keys: string[]): Record<string, any>;
 export {};

package/dist/runtime/utils.js

@@ -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;
+}