@nuxt/scripts 0.9.4 → 0.10.0

package/dist/runtime/composables/useScript.js

@@ -1,33 +1,56 @@
 import { resolveScriptKey } from "unhead";
 import { defu } from "defu";
-import { useScript as _useScript } from "@unhead/vue";
-import { injectHead, onNuxtReady, useHead, useNuxtApp, useRuntimeConfig, reactive } from "#imports";
+import { useScript as _useScript, injectHead } from "@unhead/vue";
+import { parseURL } from "ufo";
+import { onNuxtReady, useHead, useNuxtApp, useRuntimeConfig } from "nuxt/app";
+import { reactive } from "vue";
+import { pick } from "../utils.js";
 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);
+  const id = String(resolveScriptKey(input));
   const nuxtApp = useNuxtApp();
+  const head = options.head || injectHead();
   nuxtApp.$scripts = nuxtApp.$scripts || reactive({});
   const exists = !!nuxtApp.$scripts?.[id];
-  if (!exists && 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"
-        }
-      ]
-    });
+  if (!options.warmupStrategy && ValidPreloadTriggers.includes(String(options.trigger))) {
+    options.warmupStrategy = "preload";
   }
   if (options.trigger === "onNuxtReady") {
     options.trigger = onNuxtReady;
@@ -42,6 +65,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 +96,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/composables/useScriptEventPage.d.ts

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

package/dist/runtime/composables/useScriptEventPage.js

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

package/dist/runtime/composables/useScriptTriggerConsent.js

@@ -1,4 +1,5 @@
-import { isRef, onNuxtReady, ref, requestIdleCallback, toValue, tryUseNuxtApp, watch } from "#imports";
+import { isRef, ref, toValue, watch } from "vue";
+import { tryUseNuxtApp, onNuxtReady, requestIdleCallback } from "nuxt/app";
 export function useScriptTriggerConsent(options) {
   if (import.meta.server)
     return new Promise(() => {

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

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 type ClarityFunctions = ((fn: 'start', options: {
     content: boolean;
     cookies: string[];
@@ -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/types").UseScriptContext<T>;
 export {};

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

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 /**
  * Sample:
  * <!-- Cloudflare Web Analytics -->
@@ -27,7 +27,7 @@ export declare const CloudflareWebAnalyticsOptions: import("valibot").ObjectSche
      *
      * @default true
      */
-    readonly spa: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
+    readonly spa: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
 }, 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/types").UseScriptContext<T>;

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

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 export declare const CrispOptions: import("valibot").ObjectSchema<{
     /**
      * The Crisp ID.
@@ -10,26 +10,26 @@ export declare const CrispOptions: import("valibot").ObjectSchema<{
      * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/language-customization/
      */
     readonly runtimeConfig: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
-        readonly locale: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
-    }, undefined>, never>;
+        readonly locale: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
     /**
      * Associated a session, equivalent to using CRISP_TOKEN_ID variable.
      * Same as CRISP_TOKEN_ID.
      * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/session-continuity/
      */
-    readonly tokenId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
+    readonly tokenId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
     /**
      * Restrict the domain that the Crisp cookie is set on.
      * Same as CRISP_COOKIE_DOMAIN.
      * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/cookie-policies/
      */
-    readonly cookieDomain: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
+    readonly cookieDomain: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
     /**
      * The cookie expiry in seconds.
      * Same as CRISP_COOKIE_EXPIRATION.
      * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/cookie-policies/#change-cookie-expiration-date
      */
-    readonly cookieExpiry: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, never>;
+    readonly cookieExpiry: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
 }, undefined>;
 export type CrispInput = RegistryScriptInput<typeof CrispOptions, false, false, false>;
 export interface CrispApi {
@@ -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/types").UseScriptContext<T>;

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

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 export declare const FathomAnalyticsOptions: import("valibot").ObjectSchema<{
     /**
      * The Fathom Analytics site ID.
@@ -7,19 +7,19 @@ export declare const FathomAnalyticsOptions: import("valibot").ObjectSchema<{
     /**
      * The Fathom Analytics tracking mode.
      */
-    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>;
+    readonly spa: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"auto", undefined>, import("valibot").LiteralSchema<"history", undefined>, import("valibot").LiteralSchema<"hash", undefined>], undefined>, undefined>;
     /**
      * Automatically track page views.
      */
-    readonly auto: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
+    readonly auto: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
     /**
      * Enable canonical URL tracking.
      */
-    readonly canonical: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
+    readonly canonical: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
     /**
      * Honor Do Not Track requests.
      */
-    readonly honorDnt: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
+    readonly honorDnt: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
 }, undefined>;
 export type FathomAnalyticsInput = RegistryScriptInput<typeof FathomAnalyticsOptions, false, false, false>;
 export interface FathomAnalyticsApi {
@@ -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/types").UseScriptContext<T>;

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

@@ -1,9 +1,13 @@
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 export declare const GoogleAdsenseOptions: import("valibot").ObjectSchema<{
     /**
      * The Google Adsense ID.
      */
-    readonly client: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
+    readonly client: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /**
+     * Enable or disable Auto Ads.
+     */
+    readonly autoAds: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
 }, undefined>;
 export type GoogleAdsenseInput = RegistryScriptInput<typeof GoogleAdsenseOptions, true, false, false>;
 export interface GoogleAdsenseApi {
@@ -23,4 +27,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/types").UseScriptContext<T>;

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

@@ -1,16 +1,20 @@
+import { useHead } from "@unhead/vue";
 import { useRegistryScript } from "../utils.js";
-import { object, string, optional } from "#nuxt-scripts-validator";
-import { useHead } from "#imports";
+import { object, string, optional, boolean } from "#nuxt-scripts-validator";
 export const GoogleAdsenseOptions = object({
   /**
    * The Google Adsense ID.
    */
-  client: optional(string())
+  client: optional(string()),
+  /**
+   * Enable or disable Auto Ads.
+   */
+  autoAds: optional(boolean())
 });
 export function useScriptGoogleAdsense(_options) {
   return useRegistryScript("googleAdsense", (options) => ({
     scriptInput: {
-      src: "https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"
+      src: `https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js${options?.client ? `?client=${options.client}` : ""}`
     },
     schema: import.meta.dev ? GoogleAdsenseOptions : void 0,
     scriptOptions: {
@@ -25,7 +29,19 @@ export function useScriptGoogleAdsense(_options) {
                 name: "google-adsense-account",
                 content: options?.client
               }
-            ]
+            ],
+            // Inject Auto Ads script dynamically
+            script: options.autoAds ? [
+              {
+                innerHTML: `
+                        (adsbygoogle = window.adsbygoogle || []).push({
+                          google_ad_client: "${options.client}",
+                          enable_page_level_ads: true
+                        });
+                      `,
+                type: "text/javascript"
+              }
+            ] : []
           });
         }
       }

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

@@ -1,11 +1,21 @@
-import type { DataLayer, GTag } from 'third-party-capital';
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+type ConsentOptions = 'default' | 'update';
+export interface GTag {
+    (fn: 'js', opt: Date): void;
+    (fn: 'config' | 'get', opt: string): void;
+    (fn: 'event', opt: string, opt2?: Record<string, any>): void;
+    (fn: 'set', opt: Record<string, string>): void;
+    (fn: 'consent', opt: ConsentOptions, opt2: Record<string, string>): void;
+}
+type DataLayer = Array<Parameters<GTag> | Record<string, unknown>>;
 export declare const GoogleAnalyticsOptions: import("valibot").ObjectSchema<{
     readonly id: import("valibot").StringSchema<undefined>;
-    readonly l: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
+    readonly l: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
 }, undefined>;
 export type GoogleAnalyticsInput = RegistryScriptInput<typeof GoogleAnalyticsOptions>;
-export declare function useScriptGoogleAnalytics(_options?: GoogleAnalyticsInput): import("../composables/useScript").UseScriptContext<{
-    dataLayer: DataLayer;
+export interface GoogleAnalyticsApi {
     gtag: GTag;
-}>;
+    dataLayer: DataLayer;
+}
+export declare function useScriptGoogleAnalytics<T extends GoogleAnalyticsApi>(_options?: GoogleAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export {};

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

@@ -1,19 +1,10 @@
 import { withQuery } from "ufo";
-import { useRegistryScript } from "#nuxt-scripts-utils";
+import { useRegistryScript } from "#nuxt-scripts/utils";
 import { object, string, optional } from "#nuxt-scripts-validator";
 export const GoogleAnalyticsOptions = object({
   id: string(),
   l: optional(string())
 });
-function use(options) {
-  const gtag = function(...args) {
-    window["gtag-" + (options.l ?? "dataLayer")](...args);
-  };
-  return {
-    dataLayer: window[options.l ?? "dataLayer"],
-    gtag
-  };
-}
 export function useScriptGoogleAnalytics(_options) {
   return useRegistryScript(_options?.key || "googleAnalytics", (options) => ({
     scriptInput: {
@@ -21,23 +12,30 @@ export function useScriptGoogleAnalytics(_options) {
     },
     schema: import.meta.dev ? GoogleAnalyticsOptions : void 0,
     scriptOptions: {
-      use: () => use(options),
+      use: () => {
+        const gtag = function(...args) {
+          window["gtag-" + (options.l ?? "dataLayer")](...args);
+        };
+        return {
+          dataLayer: window[options.l ?? "dataLayer"],
+          gtag
+        };
+      },
       stub: import.meta.client ? void 0 : ({ fn }) => {
         return fn === "dataLayer" ? [] : void 0;
       },
       performanceMarkFeature: "nuxt-third-parties-ga",
-      ...{ tagPriority: 1 }
+      tagPriority: 1
     },
-    // eslint-disable-next-line
-    // @ts-ignore
-    // eslint-disable-next-line
     clientInit: import.meta.server ? void 0 : () => {
-      window[options?.l ?? "dataLayer"] = window[options?.l ?? "dataLayer"] || [];
-      window["gtag-" + (options?.l ?? "dataLayer")] = function() {
-        window[options?.l ?? "dataLayer"].push(arguments);
+      const dataLayerName = options?.l ?? "dataLayer";
+      const dataLayer = window[dataLayerName] || [];
+      window[dataLayerName] = dataLayer;
+      window["gtag-" + dataLayerName] = function() {
+        window[dataLayerName].push(arguments);
       };
-      window["gtag-" + (options?.l ?? "dataLayer")]("js", /* @__PURE__ */ new Date());
-      window["gtag-" + (options?.l ?? "dataLayer")]("config", options?.id);
+      window["gtag-" + dataLayerName]("js", /* @__PURE__ */ new Date());
+      window["gtag-" + dataLayerName]("config", options?.id);
     }
   }), _options);
 }

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

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 declare namespace google {
     namespace maps {
         /**
@@ -9,8 +9,10 @@ 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 v: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"weekly", undefined>, import("valibot").LiteralSchema<"beta", undefined>, import("valibot").LiteralSchema<"alpha", undefined>], undefined>, never>;
+    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>;
 }, undefined>;
 export type GoogleMapsInput = RegistryScriptInput<typeof GoogleMapsOptions>;
 type MapsNamespace = typeof google.maps;
@@ -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/types").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

@@ -1,15 +1,36 @@
-import type { GoogleTagManagerApi, DataLayer } from 'third-party-capital';
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+interface GoogleTagManagerDataLayerApi {
+    name: 'dataLayer';
+    set: (opt: {
+        [key: string]: string;
+    }) => void;
+    get: (key: string) => void;
+    reset: () => void;
+}
+interface GoogleTagManagerDataLayerStatus {
+    dataLayer: {
+        gtmDom: boolean;
+        gtmLoad: boolean;
+        subscribers: number;
+    };
+}
+type GoogleTagManagerInstance = GoogleTagManagerDataLayerStatus & {
+    [key: string]: {
+        callback: () => void;
+        dataLayer: GoogleTagManagerDataLayerApi;
+    };
+};
+interface GoogleTagManagerApi {
+    google_tag_manager: GoogleTagManagerInstance;
+}
 declare global {
     interface Window extends GoogleTagManagerApi {
     }
 }
 export declare const GoogleTagManagerOptions: import("valibot").ObjectSchema<{
     readonly id: import("valibot").StringSchema<undefined>;
-    readonly l: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
+    readonly l: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
 }, undefined>;
 export type GoogleTagManagerInput = RegistryScriptInput<typeof GoogleTagManagerOptions>;
-export declare function useScriptGoogleTagManager(_options?: GoogleTagManagerInput): import("../composables/useScript").UseScriptContext<{
-    dataLayer: DataLayer;
-    google_tag_manager: import("third-party-capital").GoogleTagManagerInstance;
-}>;
+export declare function useScriptGoogleTagManager<T extends GoogleTagManagerApi>(_options?: GoogleTagManagerInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export {};

package/dist/runtime/registry/google-tag-manager.js

@@ -1,13 +1,10 @@
 import { withQuery } from "ufo";
-import { useRegistryScript } from "#nuxt-scripts-utils";
+import { useRegistryScript } from "#nuxt-scripts/utils";
 import { object, string, optional } from "#nuxt-scripts-validator";
 export const GoogleTagManagerOptions = object({
   id: string(),
   l: optional(string())
 });
-function use(options) {
-  return { dataLayer: window[options.l ?? "dataLayer"], google_tag_manager: window.google_tag_manager };
-}
 export function useScriptGoogleTagManager(_options) {
   return useRegistryScript(_options?.key || "googleTagManager", (options) => ({
     scriptInput: {
@@ -15,19 +12,19 @@ export function useScriptGoogleTagManager(_options) {
     },
     schema: import.meta.dev ? GoogleTagManagerOptions : void 0,
     scriptOptions: {
-      use: () => use(options),
+      use: () => {
+        return { dataLayer: window[options.l ?? "dataLayer"], google_tag_manager: window.google_tag_manager };
+      },
       stub: import.meta.client ? void 0 : ({ fn }) => {
         return fn === "dataLayer" ? [] : void 0;
       },
       performanceMarkFeature: "nuxt-third-parties-gtm",
       ...{ tagPriority: 1 }
     },
-    // eslint-disable-next-line
-    // @ts-ignore
-    // eslint-disable-next-line
     clientInit: import.meta.server ? void 0 : () => {
-      window[options?.l ?? "dataLayer"] = window[options?.l ?? "dataLayer"] || [];
-      window[options?.l ?? "dataLayer"].push({ "gtm.start": (/* @__PURE__ */ new Date()).getTime(), event: "gtm.js" });
+      const dataLayerName = options?.l ?? "dataLayer";
+      window[dataLayerName] = window[options?.l ?? "dataLayer"] || [];
+      window[dataLayerName].push({ "gtm.start": (/* @__PURE__ */ new Date()).getTime(), "event": "gtm.js" });
     }
   }), _options);
 }

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

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 export interface HotjarApi {
     hj: ((event: 'identify', userId: string, attributes?: Record<string, any>) => void) & ((event: 'stateChange', path: string) => void) & ((event: 'event', eventName: string) => void) & ((event: string, arg?: string) => void) & ((...params: any[]) => void) & {
         q: any[];
@@ -14,7 +14,7 @@ declare global {
 }
 export declare const HotjarOptions: import("valibot").ObjectSchema<{
     readonly id: import("valibot").NumberSchema<undefined>;
-    readonly sv: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, never>;
+    readonly sv: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
 }, 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/types").UseScriptContext<T>;

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

@@ -1,14 +1,14 @@
 import type { InferInput } from '#nuxt-scripts-validator';
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 export declare const IntercomOptions: import("valibot").ObjectSchema<{
     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>;
+    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>, undefined>;
+    readonly name: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly email: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly user_id: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly alignment: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"left", undefined>, import("valibot").LiteralSchema<"right", undefined>], undefined>, undefined>;
+    readonly horizontal_padding: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    readonly vertical_padding: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
 }, undefined>;
 export type IntercomInput = RegistryScriptInput<typeof IntercomOptions, true, false, false>;
 export interface IntercomApi {
@@ -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/types").UseScriptContext<T>;

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

@@ -1,4 +1,4 @@
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 export type LemonSqueezyInput = RegistryScriptInput;
 export type LemonSqueezyEventPayload = {
     event: 'Checkout.Success';
@@ -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/types").UseScriptContext<T>;

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

@@ -1,12 +1,12 @@
-import type { RegistryScriptInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 export declare const MatomoAnalyticsOptions: import("valibot").ObjectSchema<{
-    readonly matomoUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, never>;
-    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>;
-    readonly disableCookies: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;
+    readonly matomoUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly siteId: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>;
+    readonly cloudId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly trackerUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly trackPageView: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly enableLinkTracking: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly disableCookies: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
 }, undefined>;
 export type MatomoAnalyticsInput = RegistryScriptInput<typeof MatomoAnalyticsOptions, false, false, false>;
 interface MatomoAnalyticsApi {
@@ -16,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/types").UseScriptContext<T>;
 export {};