@nuxt/scripts 0.1.12 → 0.3.0

package/dist/runtime/components/YouTubeEmbed.vue

@@ -0,0 +1,79 @@
+<script setup lang="ts">
+import { computed, ref, watch } from 'vue'
+import type YT from 'youtube'
+import type { ElementScriptTrigger } from '../composables/useElementScriptTrigger'
+import { useElementScriptTrigger, useScriptYouTubeIframe } from '#imports'
+
+const props = withDefaults(defineProps<{
+  trigger?: ElementScriptTrigger
+  videoId: string
+  playerVars?: YT.PlayerVars
+  width?: number
+  height?: number
+}>(), {
+  playerVars: { autoplay: 1, playsinline: 1 },
+  width: 640,
+  height: 480,
+})
+
+const emits = defineEmits<{
+  onReady: [e: YT.PlayerEvent]
+  onStateChange: [e: YT.PlayerEvent]
+  onPlaybackQualityChange: [e: YT.PlayerEvent]
+  onPlaybackRateChange: [e: YT.PlayerEvent]
+  onError: [e: YT.PlayerEvent]
+  onApiChange: [e: YT.PlayerEvent]
+}>()
+const events: (keyof YT.Events)[] = [
+  'onReady',
+  'onStateChange',
+  'onPlaybackQualityChange',
+  'onPlaybackRateChange',
+  'onError',
+  'onApiChange',
+]
+const elYoutube = ref()
+
+const ready = ref(false)
+const { $script } = useScriptYouTubeIframe({
+  scriptOptions: {
+    trigger: useElementScriptTrigger(props.trigger, elYoutube.value),
+  },
+})
+
+let player: YT.Player
+$script.then(async (instance) => {
+  const YT = await instance.YT
+  await new Promise<void>((resolve) => {
+    if (typeof YT.Player === 'undefined')
+      YT.ready(resolve)
+    else
+      resolve()
+  })
+  player = new YT.Player(elYoutube.value, {
+    ...props,
+    events: Object.fromEntries(events.map(event => [event, (e: any) => {
+      // @ts-expect-error untyped
+      emits(event, e)
+    }])),
+  })
+})
+
+defineExpose({
+  player,
+})
+
+watch(() => props.videoId, () => {
+  player?.loadVideoById(props.videoId)
+})
+
+const poster = computed(() => `https://i.ytimg.com/vi_webp/${props.videoId}/sddefault.webp`)
+</script>
+
+<template>
+  <div ref="elYoutube" :style="{ width: `${width}px`, height: `${height}px`, position: 'relative' }">
+    <slot :poster="poster">
+      <img v-if="!ready" :src="poster" title="" :width="width" :height="height">
+    </slot>
+  </div>
+</template>

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

@@ -0,0 +1,6 @@
+import type { ConsentPromiseOptions } from '../types';
+type CreateConsentScriptTriggerApi = {
+    accept: () => void;
+} & Promise<void>;
+export declare function createConsentScriptTrigger(options?: ConsentPromiseOptions): CreateConsentScriptTriggerApi;
+export {};

package/dist/runtime/composables/{createScriptConsentTrigger.mjs → createConsentScriptTrigger.mjs}

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

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

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

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

@@ -0,0 +1,3 @@
+import type { Ref } from 'vue';
+export type ElementScriptTrigger = 'visible' | 'mouseover' | false;
+export declare function useElementScriptTrigger(trigger: ElementScriptTrigger | undefined, el?: HTMLElement | Ref<HTMLElement | undefined> | null): Promise<void>;

package/dist/runtime/composables/useElementScriptTrigger.mjs

@@ -0,0 +1,9 @@
+import { useElementHover, useElementVisibility, watchOnce } from "@vueuse/core";
+import { ref } from "vue";
+export function useElementScriptTrigger(trigger, el) {
+  if (import.meta.server || !el)
+    return new Promise(() => {
+    });
+  const activeRef = trigger ? trigger === "mouseover" ? useElementHover(el) : useElementVisibility(el) : ref(false);
+  return trigger ? new Promise((resolve) => watchOnce([activeRef], () => resolve())) : Promise.resolve();
+}

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

@@ -1,5 +1,5 @@
 import { type UseScriptInput, type VueScriptInstance } from '@unhead/vue';
 import type { NuxtUseScriptOptions } from '#nuxt-scripts';
-export declare function useScript<T>(input: UseScriptInput, options?: NuxtUseScriptOptions): T & {
-    $script: VueScriptInstance<T>;
+export declare function useScript<T extends Record<string | symbol, any>>(input: UseScriptInput, options?: NuxtUseScriptOptions): T & {
+    $script: VueScriptInstance<T> & Promise<T>;
 };

package/dist/runtime/composables/useScript.mjs

@@ -6,11 +6,10 @@ export function useScript(input, options) {
   input = typeof input === "string" ? { src: input } : input;
   options = defu(options, useRuntimeConfig().public["nuxt-scripts"]?.defaultScriptOptions);
   if (options.trigger === "onNuxtReady")
-    options.trigger = new Promise((resolve) => onNuxtReady(resolve));
+    options.trigger = onNuxtReady;
   const nuxtApp = useNuxtApp();
   const id = input.key || input.src || hashCode(typeof input.innerHTML === "string" ? input.innerHTML : "");
   if (!nuxtApp.scripts?.[id]) {
-    options.beforeInit?.();
     if (import.meta.client) {
       performance?.mark?.("mark_feature_usage", {
         detail: {

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

@@ -1,12 +1,16 @@
-import { type Input } from 'valibot';
-import type { NuxtUseScriptIntegrationOptions } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts';
+/**
+ * Sample:
+ * <!-- Cloudflare Web Analytics -->
+ * <script defer src='https://static.cloudflareinsights.com/beacon.min.js' data-cf-beacon='{"token": "12ee46bf598b45c2868bbc07a3073f58"}'></script>
+ * <!-- End Cloudflare Web Analytics -->
+ */
 export interface CloudflareWebAnalyticsApi {
     __cfBeacon: {
         load: 'single';
         spa: boolean;
         token: string;
     };
-    __cfRl?: unknown;
 }
 declare global {
     interface Window extends CloudflareWebAnalyticsApi {
@@ -15,8 +19,6 @@ declare global {
 export declare const CloudflareWebAnalyticsOptions: import("valibot").ObjectSchema<{
     /**
      * The Cloudflare Web Analytics token.
-     *
-     * Required when used for the first time.
      */
     token: import("valibot").StringSchema<string>;
     /**
@@ -30,5 +32,7 @@ export declare const CloudflareWebAnalyticsOptions: import("valibot").ObjectSche
     token: string;
     spa?: boolean | undefined;
 }>;
-export type CloudflareWebAnalyticsInput = Input<typeof CloudflareWebAnalyticsOptions>;
-export declare function useScriptCloudflareWebAnalytics<T extends CloudflareWebAnalyticsApi>(options?: CloudflareWebAnalyticsInput, _scriptOptions?: NuxtUseScriptIntegrationOptions): any;
+export type CloudflareWebAnalyticsInput = RegistryScriptInput<typeof CloudflareWebAnalyticsOptions>;
+export declare function useScriptCloudflareWebAnalytics<T extends CloudflareWebAnalyticsApi>(_options?: CloudflareWebAnalyticsInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};

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

@@ -1,13 +1,11 @@
 import { boolean, minLength, object, optional, string } from "valibot";
 import { defu } from "defu";
-import { useScript, validateScriptInputSchema } from "#imports";
+import { registryScript } from "../utils.mjs";
 export const CloudflareWebAnalyticsOptions = object({
   /**
    * The Cloudflare Web Analytics token.
-   *
-   * Required when used for the first time.
    */
-  token: string([minLength(33)]),
+  token: string([minLength(32)]),
   /**
    * Cloudflare Web Analytics enables measuring SPAs automatically by overriding the History API’s pushState function
    * and listening to the onpopstate. Hash-based router is not supported.
@@ -16,19 +14,19 @@ export const CloudflareWebAnalyticsOptions = object({
    */
   spa: optional(boolean())
 });
-export function useScriptCloudflareWebAnalytics(options, _scriptOptions) {
-  const scriptOptions = _scriptOptions || {};
-  scriptOptions.beforeInit = () => {
-    import.meta.dev && validateScriptInputSchema(CloudflareWebAnalyticsOptions, options);
-    _scriptOptions?.beforeInit?.();
-  };
-  return useScript({
-    "src": "https://static.cloudflareinsights.com/beacon.min.js",
-    "data-cf-beacon": JSON.stringify(defu(options, { spa: true }))
-  }, {
-    ...scriptOptions,
-    use() {
-      return { __cfBeacon: window.__cfBeacon, __cfRl: window.__cfRl };
+export function useScriptCloudflareWebAnalytics(_options) {
+  return registryScript("cloudflareWebAnalytics", (options) => ({
+    scriptInput: {
+      "src": "https://static.cloudflareinsights.com/beacon.min.js",
+      "data-cf-beacon": JSON.stringify(defu(options, { spa: true }))
+    },
+    schema: import.meta.dev ? CloudflareWebAnalyticsOptions : void 0,
+    scriptOptions: {
+      // we want to load earlier so that the web vitals reports are correct
+      trigger: "client",
+      use() {
+        return { __cfBeacon: window.__cfBeacon };
+      }
     }
-  });
+  }), _options);
 }

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

@@ -1,5 +1,4 @@
-import { type Input } from 'valibot';
-import type { NuxtUseScriptIntegrationOptions } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts';
 type StandardEvents = 'AddPaymentInfo' | 'AddToCart' | 'AddToWishlist' | 'CompleteRegistration' | 'Contact' | 'CustomizeProduct' | 'Donate' | 'FindLocation' | 'InitiateCheckout' | 'Lead' | 'Purchase' | 'Schedule' | 'Search' | 'StartTrial' | 'SubmitApplication' | 'Subscribe' | 'ViewContent';
 interface EventObjectProperties {
     content_category?: string;
@@ -34,10 +33,12 @@ declare global {
     }
 }
 export declare const FacebookPixelOptions: import("valibot").ObjectSchema<{
-    id: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
+    id: import("valibot").UnionSchema<(import("valibot").NumberSchema<number> | import("valibot").StringSchema<string>)[], string | number>;
 }, undefined, {
     id: string | number;
 }>;
-export type FacebookPixelInput = Input<typeof FacebookPixelOptions>;
-export declare function useScriptFacebookPixel<T extends FacebookPixelApi>(options?: FacebookPixelInput, _scriptOptions?: NuxtUseScriptIntegrationOptions): any;
+export type FacebookPixelInput = RegistryScriptInput<typeof FacebookPixelOptions>;
+export declare function useScriptFacebookPixel<T extends FacebookPixelApi>(_options?: FacebookPixelInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};
 export {};

package/dist/runtime/registry/facebook-pixel.mjs

@@ -1,13 +1,21 @@
 import { number, object, string, union } from "valibot";
-import { useScript, validateScriptInputSchema } from "#imports";
+import { registryScript } from "../utils.mjs";
+import { FacebookPixelScriptResolver } from "../../registry";
 export const FacebookPixelOptions = object({
   id: union([string(), number()])
 });
-export function useScriptFacebookPixel(options, _scriptOptions) {
-  const scriptOptions = _scriptOptions || {};
-  scriptOptions.beforeInit = () => {
-    import.meta.dev && validateScriptInputSchema(FacebookPixelOptions, options);
-    if (import.meta.client) {
+export function useScriptFacebookPixel(_options) {
+  return registryScript("facebookPixel", (options) => ({
+    scriptInput: {
+      src: FacebookPixelScriptResolver()
+    },
+    schema: FacebookPixelOptions,
+    scriptOptions: {
+      use() {
+        return { fbq: window.fbq };
+      }
+    },
+    clientInit: import.meta.server ? void 0 : () => {
       const fbq = window.fbq = function(...params) {
         fbq.callMethod ? fbq.callMethod(...params) : fbq.queue.push(params);
       };
@@ -20,15 +28,5 @@ export function useScriptFacebookPixel(options, _scriptOptions) {
       fbq("init", options?.id);
       fbq("track", "PageView");
     }
-    _scriptOptions?.beforeInit?.();
-  };
-  return useScript({
-    key: "facebookPixel",
-    src: "https://connect.facebook.net/en_US/fbevents.js"
-  }, {
-    ...scriptOptions,
-    use() {
-      return { fbq: window.fbq };
-    }
-  });
+  }), _options);
 }

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

@@ -1,26 +1,49 @@
-import { type Input } from 'valibot';
-import type { NuxtUseScriptIntegrationOptions } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const FathomAnalyticsOptions: import("valibot").ObjectSchema<{
+    /**
+     * The Fathom Analytics site ID.
+     */
     site: import("valibot").StringSchema<string>;
-    src: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
-    'data-spa': import("valibot").OptionalSchema<import("valibot").UnionSchema<(import("valibot").LiteralSchema<"auto", "auto"> | import("valibot").LiteralSchema<"history", "history"> | import("valibot").LiteralSchema<"hash", "hash">)[], "auto" | "history" | "hash">, undefined, "auto" | "history" | "hash" | undefined>;
-    'data-auto': import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
-    'data-canonical': import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
-    'data-honor-dnt': import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
+    /**
+     * The Fathom Analytics tracking mode.
+     */
+    spa: import("valibot").OptionalSchema<import("valibot").UnionSchema<(import("valibot").LiteralSchema<"hash", "hash"> | import("valibot").LiteralSchema<"auto", "auto"> | import("valibot").LiteralSchema<"history", "history">)[], "auto" | "hash" | "history">, undefined, "auto" | "hash" | "history" | undefined>;
+    /**
+     * Automatically track page views.
+     */
+    auto: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
+    /**
+     * Enable canonical URL tracking.
+     */
+    canonical: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
+    /**
+     * Honor Do Not Track requests.
+     */
+    honorDnt: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
 }, undefined, {
     site: string;
-    src?: string | undefined;
-    'data-spa'?: "auto" | "history" | "hash" | undefined;
-    'data-auto'?: boolean | undefined;
-    'data-canonical'?: boolean | undefined;
-    'data-honor-dnt'?: boolean | undefined;
+    auto?: boolean | undefined;
+    spa?: "auto" | "hash" | "history" | undefined;
+    canonical?: boolean | undefined;
+    honorDnt?: boolean | undefined;
 }>;
-export type FathomAnalyticsInput = Input<typeof FathomAnalyticsOptions>;
+export type FathomAnalyticsInput = RegistryScriptInput<typeof FathomAnalyticsOptions, false>;
 export interface FathomAnalyticsApi {
+    beacon: (ctx: {
+        url: string;
+        referrer?: string;
+    }) => void;
+    blockTrackingForMe: () => void;
+    enableTrackingForMe: () => void;
+    isTrackingEnabled: () => boolean;
+    send: (type: string, data: unknown) => void;
+    setSite: (siteId: string) => void;
+    sideId: string;
     trackPageview: (ctx?: {
         url: string;
         referrer?: string;
     }) => void;
+    trackGoal: (goalId: string, cents: number) => void;
     trackEvent: (eventName: string, value: {
         _value: number;
     }) => void;
@@ -30,4 +53,6 @@ declare global {
         fathom: FathomAnalyticsApi;
     }
 }
-export declare function useScriptFathomAnalytics<T extends FathomAnalyticsApi>(options?: FathomAnalyticsInput, _scriptOptions?: Omit<NuxtUseScriptIntegrationOptions, 'assetStrategy'>): any;
+export declare function useScriptFathomAnalytics<T extends FathomAnalyticsApi>(_options?: FathomAnalyticsInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};

package/dist/runtime/registry/fathom-analytics.mjs

@@ -1,25 +1,44 @@
 import { boolean, literal, object, optional, string, union } from "valibot";
-import { useScript, validateScriptInputSchema } from "#imports";
+import { registryScript } from "../utils.mjs";
 export const FathomAnalyticsOptions = object({
-  "site": string(),
-  // site is required
-  "src": optional(string()),
-  "data-spa": optional(union([literal("auto"), literal("history"), literal("hash")])),
-  "data-auto": optional(boolean()),
-  "data-canonical": optional(boolean()),
-  "data-honor-dnt": optional(boolean())
+  /**
+   * The Fathom Analytics site ID.
+   */
+  site: string(),
+  /**
+   * The Fathom Analytics tracking mode.
+   */
+  spa: optional(union([literal("auto"), literal("history"), literal("hash")])),
+  /**
+   * Automatically track page views.
+   */
+  auto: optional(boolean()),
+  /**
+   * Enable canonical URL tracking.
+   */
+  canonical: optional(boolean()),
+  /**
+   * Honor Do Not Track requests.
+   */
+  honorDnt: optional(boolean())
 });
-export function useScriptFathomAnalytics(options, _scriptOptions) {
-  const scriptOptions = _scriptOptions || {};
-  scriptOptions.beforeInit = () => {
-    import.meta.dev && validateScriptInputSchema(FathomAnalyticsOptions, options);
-    _scriptOptions?.beforeInit?.();
-  };
-  return useScript({
-    src: "https://cdn.usefathom.com/script.js",
-    ...options
-  }, {
-    ...scriptOptions,
-    use: () => window.fathom
-  });
+export function useScriptFathomAnalytics(_options) {
+  return registryScript("fathomAnalytics", (options) => ({
+    scriptInput: {
+      src: "https://cdn.usefathom.com/script.js",
+      // can't be bundled
+      // append the data attr's
+      ...Object.entries(options).filter(([key]) => ["site", "spa", "auto", "canonical", "honorDnt"].includes(key)).reduce((acc, [_key, value]) => {
+        const key = _key === "honourDnt" ? "honor-dnt" : _key;
+        acc[`data-${key}`] = value;
+        return acc;
+      }, {})
+    },
+    schema: import.meta.dev ? FathomAnalyticsOptions : void 0,
+    scriptOptions: {
+      use() {
+        return window.fathom;
+      }
+    }
+  }), _options);
 }

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

@@ -1 +1,21 @@
-export declare function useScriptGoogleAnalytics(): any;
+import type { GoogleAnalyticsApi } from 'third-party-capital';
+import type { RegistryScriptInput } from '#nuxt-scripts';
+declare const GoogleAnalyticsOptions: import("valibot").ObjectSchema<{
+    id: import("valibot").StringSchema<string>;
+}, undefined, {
+    id: string;
+}>;
+export type GoogleAnalyticsInput = RegistryScriptInput<typeof GoogleAnalyticsOptions>;
+declare global {
+    interface Window extends GoogleAnalyticsApi {
+    }
+}
+/**
+ * useScriptGoogleAnalytics
+ *
+ * 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 useScriptGoogleAnalytics<T extends GoogleAnalyticsApi>(_options?: GoogleAnalyticsInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};
+export {};

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

@@ -1,4 +1,31 @@
-import { mockFallbackScript } from "../utils.mjs";
-export function useScriptGoogleAnalytics() {
-  return mockFallbackScript("useScriptGoogleMaps", "@nuxtjs/third-party-capital");
+import { object, string } from "valibot";
+import { registryScript } from "../utils.mjs";
+import { GoogleAnalyticsScriptResolver } from "../../registry";
+const GoogleAnalyticsOptions = object({
+  id: string()
+});
+export function useScriptGoogleAnalytics(_options) {
+  return registryScript("googleAnalytics", (options) => ({
+    scriptInput: {
+      src: GoogleAnalyticsScriptResolver(options)
+    },
+    schema: GoogleAnalyticsOptions,
+    scriptOptions: {
+      use() {
+        return { dataLayer: window.dataLayer, gtag: window.gtag };
+      },
+      // allow dataLayer to be accessed on the server
+      stub: import.meta.client ? void 0 : ({ fn }) => {
+        return fn === "dataLayer" ? [] : void 0;
+      }
+    },
+    clientInit: import.meta.server ? void 0 : () => {
+      window.dataLayer = window.dataLayer || [];
+      window.gtag = function gtag(...p) {
+        window.dataLayer.push(p);
+      };
+      window.gtag("js", /* @__PURE__ */ new Date());
+      window.gtag("config", options?.id);
+    }
+  }), _options);
 }

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

@@ -1 +1,23 @@
-export declare function useScriptGoogleMaps(): any;
+import type google from 'google.maps';
+import type { RegistryScriptInput } from '#nuxt-scripts';
+export declare const GoogleMapsOptions: import("valibot").ObjectSchema<{
+    apiKey: import("valibot").StringSchema<string>;
+    libraries: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<string>, string[]>, undefined, string[] | undefined>;
+    v: import("valibot").OptionalSchema<import("valibot").UnionSchema<(import("valibot").LiteralSchema<"weekly", "weekly"> | import("valibot").LiteralSchema<"beta", "beta"> | import("valibot").LiteralSchema<"alpha", "alpha">)[], "weekly" | "beta" | "alpha">, undefined, "weekly" | "beta" | "alpha" | undefined>;
+}, undefined, {
+    apiKey: string;
+    libraries?: string[] | undefined;
+    v?: "weekly" | "beta" | "alpha" | undefined;
+}>;
+export type GoogleMapsInput = RegistryScriptInput<typeof GoogleMapsOptions>;
+export interface GoogleMapsApi {
+    maps: google.maps;
+}
+declare global {
+    interface Window {
+        google: typeof google;
+    }
+}
+export declare function useScriptGoogleMaps<T extends GoogleMapsApi>(_options?: GoogleMapsInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};

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

@@ -1,4 +1,41 @@
-import { mockFallbackScript } from "../utils.mjs";
-export function useScriptGoogleMaps() {
-  return mockFallbackScript("useScriptGoogleMaps", "@nuxtjs/third-party-capital");
+import { array, literal, object, optional, string, union } from "valibot";
+import { withQuery } from "ufo";
+import { registryScript } from "../utils.mjs";
+export const GoogleMapsOptions = object({
+  apiKey: string(),
+  libraries: optional(array(string())),
+  v: optional(union([literal("weekly"), literal("beta"), literal("alpha")]))
+});
+export function useScriptGoogleMaps(_options) {
+  let readyPromise = Promise.resolve();
+  return registryScript("googleMaps", (options) => {
+    const libraries = options?.libraries || ["places"];
+    return {
+      scriptInput: {
+        src: withQuery(`https://maps.googleapis.com/maps/api/js`, {
+          libraries: libraries.join(","),
+          key: options?.apiKey,
+          loading: "async",
+          callback: "google.maps.__ib__"
+        })
+      },
+      clientInit: import.meta.server ? void 0 : () => {
+        window.google = window.google || {};
+        window.google.maps = window.google.maps || {};
+        readyPromise = new Promise((resolve) => {
+          window.google.maps.__ib__ = resolve;
+        });
+      },
+      schema: GoogleMapsOptions,
+      scriptOptions: {
+        use() {
+          return {
+            maps: readyPromise.then(() => {
+              return window.google.maps;
+            })
+          };
+        }
+      }
+    };
+  }, _options);
 }

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

@@ -1 +1,21 @@
-export declare function useScriptGoogleTagManager(): any;
+import type { GoogleTagManagerApi } from 'third-party-capital';
+import type { RegistryScriptInput } from '#nuxt-scripts';
+declare const GoogleTagManagerOptions: import("valibot").ObjectSchema<{
+    id: import("valibot").StringSchema<string>;
+}, undefined, {
+    id: string;
+}>;
+export type GoogleTagManagerInput = RegistryScriptInput<typeof GoogleTagManagerOptions>;
+declare global {
+    interface Window extends GoogleTagManagerApi {
+    }
+}
+/**
+ * useScriptGoogleTagManager
+ *
+ * A 3P wrapper for Google Tag Manager 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 useScriptGoogleTagManager<T extends GoogleTagManagerApi>(options?: GoogleTagManagerInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};
+export {};

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

@@ -1,4 +1,30 @@
-import { mockFallbackScript } from "../utils.mjs";
-export function useScriptGoogleTagManager() {
-  return mockFallbackScript("useScriptGoogleTagManager", "@nuxtjs/third-party-capital");
+import { object, string } from "valibot";
+import { withQuery } from "ufo";
+import { registryScript } from "../utils.mjs";
+const GoogleTagManagerOptions = object({
+  id: string()
+});
+export function useScriptGoogleTagManager(options) {
+  return registryScript("googleTagManager", (options2) => ({
+    scriptInput: {
+      async: true,
+      src: withQuery("https://www.googletagmanager.com/gtm.js", {
+        id: options2?.id
+      })
+    },
+    schema: GoogleTagManagerOptions,
+    scriptOptions: {
+      use() {
+        return { dataLayer: window.dataLayer, google_tag_manager: window.google_tag_manager };
+      },
+      // allow dataLayer to be accessed on the server
+      stub: import.meta.client ? void 0 : ({ fn }) => {
+        return fn === "dataLayer" ? [] : void 0;
+      }
+    },
+    clientInit: import.meta.server ? void 0 : () => {
+      window.dataLayer = window.dataLayer || [];
+      window.dataLayer.push({ "gtm.start": (/* @__PURE__ */ new Date()).getTime(), "event": "gtm.js" });
+    }
+  }), options);
 }

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

@@ -1,4 +1,4 @@
-import type { NuxtUseScriptIntegrationOptions, ScriptDynamicSrcInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts';
 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[];
@@ -19,5 +19,7 @@ export declare const HotjarOptions: import("valibot").ObjectSchema<{
     id: number;
     sv?: number | undefined;
 }>;
-export type HotjarInput = ScriptDynamicSrcInput<typeof HotjarOptions>;
-export declare function useScriptHotjar<T extends HotjarApi>(options?: HotjarInput, _scriptOptions?: NuxtUseScriptIntegrationOptions): any;
+export type HotjarInput = RegistryScriptInput<typeof HotjarOptions>;
+export declare function useScriptHotjar<T extends HotjarApi>(_options?: HotjarInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};