@nuxt/scripts 0.5.1 → 0.6.0

package/dist/runtime/components/ScriptIntercom.vue

@@ -0,0 +1,93 @@
+<script setup lang="ts">
+import { useScriptIntercom } from '../registry/intercom'
+import { useScriptTriggerElement } from '../composables/useScriptTriggerElement'
+import { ref, onMounted, watch, onBeforeUnmount } from '#imports'
+import type { ElementScriptTrigger } from '#nuxt-scripts'
+
+const props = withDefaults(defineProps<{
+  appId: string
+  apiBase?: string
+  name?: string
+  email?: string
+  userId?: string
+  // customizing the messenger
+  alignment?: 'left' | 'right'
+  horizontalPadding?: number
+  verticalPadding?: number
+  /**
+   * Defines the trigger event to load the script.
+   */
+  trigger?: ElementScriptTrigger
+}>(), {
+  trigger: 'click',
+})
+
+const emits = defineEmits<{
+  // our emit
+  ready: [e: ReturnType<typeof useScriptIntercom>]
+  error: []
+}>()
+
+const rootEl = ref(null)
+const trigger = useScriptTriggerElement({ trigger: props.trigger, el: rootEl })
+
+const isReady = ref(false)
+const intercom = useScriptIntercom({
+  app_id: props.appId,
+  // @ts-expect-error untyped
+  app_base: props.apiBase,
+  name: props.name,
+  email: props.email,
+  user_id: props.userId,
+  alignment: props.alignment,
+  horizontal_padding: props.horizontalPadding,
+  vertical_padding: props.verticalPadding,
+  scriptOptions: {
+    trigger,
+  },
+})
+if (props.trigger === 'click')
+  intercom.Intercom('show')
+const { $script } = intercom
+
+defineExpose({
+  intercom,
+})
+
+let observer: MutationObserver
+onMounted(() => {
+  watch($script.status, (status) => {
+    if (status === 'loading') {
+      observer = new MutationObserver(() => {
+        if (document.getElementById('intercom-frame')) {
+          isReady.value = true
+          emits('ready', intercom)
+          observer.disconnect()
+        }
+      })
+      observer.observe(document.body, { childList: true, subtree: true })
+    }
+    else if (status === 'error')
+      emits('error')
+  })
+})
+onBeforeUnmount(() => {
+  observer?.disconnect()
+})
+</script>
+
+<template>
+  <div
+    ref="rootEl"
+    :style="{
+      display: isReady ? 'none' : 'block',
+      bottom: `${verticalPadding || 20}px`,
+      [alignment || 'right']: `${horizontalPadding || 20}px`,
+    }"
+  >
+    <slot :ready="isReady" />
+    <slot v-if="$script.status.value === 'awaitingLoad'" name="awaitingLoad" />
+    <slot v-else-if="$script.status.value === 'loading' || !isReady" name="loading" />
+    <slot v-else-if="$script.status.value === 'error'" name="error" />
+  </div>
+</template>

package/dist/runtime/components/ScriptLemonSqueezy.vue

@@ -0,0 +1,45 @@
+<script lang="ts" setup>
+import type { ElementScriptTrigger } from '../types'
+import { useScriptTriggerElement } from '../composables/useScriptTriggerElement'
+import { useScriptLemonSqueezy } from '../registry/lemon-squeezy'
+import type { LemonSqueezyEventPayload } from '../registry/lemon-squeezy'
+import { onMounted, ref } from '#imports'
+
+const props = withDefaults(defineProps<{
+  trigger?: ElementScriptTrigger
+}>(), {
+  trigger: 'visible',
+})
+
+const emits = defineEmits<{
+  ready: [ReturnType<typeof useScriptLemonSqueezy>]
+  lemonSqueezyEvent: [LemonSqueezyEventPayload]
+}>()
+
+const rootEl = ref<HTMLElement | null>(null)
+const instance = useScriptLemonSqueezy({
+  scriptOptions: {
+    trigger: useScriptTriggerElement({ trigger: props.trigger, el: rootEl }),
+  },
+})
+onMounted(() => {
+  rootEl.value?.querySelectorAll('a[href]').forEach((a) => {
+    a.classList.add('lemonsqueezy-button')
+  })
+  instance.$script.then(({ Setup, Refresh }) => {
+    Setup({
+      eventHandler(event) {
+        emits('lemonSqueezyEvent', event)
+      },
+    })
+    Refresh()
+    emits('ready', instance)
+  })
+})
+</script>
+
+<template>
+  <div ref="rootEl">
+    <slot />
+  </div>
+</template>

package/dist/runtime/components/ScriptLoadingIndicator.vue

@@ -1,15 +1,24 @@
 <script setup lang="ts">
-withDefaults(defineProps<{
+import { computed } from '#imports'
+
+const props = withDefaults(defineProps<{
   color?: string
+  size?: number
 }>(), {
   color: 'currentColor',
+  size: 30,
 })
+
+const styles = computed(() => ({
+  width: `${props.size}px`,
+  height: `${props.size}px`,
+}))
 </script>
 
 <template>
-  <div class="loader" aria-label="Loading..." role="status" />
+  <div class="loader" :styles="styles" aria-label="Loading..." role="status" />
 </template>
 
 <style scoped>
-.loader{animation:rotation 1s linear infinite;border:5px solid v-bind(color);border-bottom-color:transparent;border-radius:50%;bottom:12px;box-sizing:border-box;display:inline-block;height:30px;left:12px;opacity:.5;position:absolute;width:30px}@keyframes rotation{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}
+.loader{animation:rotation 1s linear infinite;border:5px solid v-bind(color);border-bottom-color:transparent;border-radius:50%;box-sizing:border-box;display:inline-block;opacity:.5}@keyframes rotation{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}
 </style>

package/dist/runtime/components/ScriptStripePricingTable.vue

@@ -1,7 +1,9 @@
 <script setup lang="ts">
 import { ref } from 'vue'
 import type { ElementScriptTrigger } from '../types'
-import { onBeforeUnmount, useElementScriptTrigger, useScript } from '#imports'
+import { useScriptTriggerElement } from '../composables/useScriptTriggerElement'
+import { useScript } from '../composables/useScript'
+import { onBeforeUnmount, onMounted, watch } from '#imports'
 
 const props = withDefaults(defineProps<{
   trigger?: ElementScriptTrigger
@@ -15,30 +17,39 @@ const props = withDefaults(defineProps<{
 })
 
 const emit = defineEmits<{
-  ready: []
+  ready: [ReturnType<typeof useScript>]
+  error: []
 }>()
 
 const rootEl = ref<HTMLDivElement | undefined>()
 const containerEl = ref<HTMLDivElement | undefined>()
-const { $script } = useScript(`https://js.stripe.com/v3/pricing-table.js`, {
-  trigger: useElementScriptTrigger({ trigger: props.trigger, el: rootEl }),
+const instance = useScript(`https://js.stripe.com/v3/pricing-table.js`, {
+  trigger: useScriptTriggerElement({ trigger: props.trigger, el: rootEl }),
 })
+const { $script } = instance
 
 const pricingTable = ref<HTMLElement | undefined>()
-$script.then(() => {
-  const StripePricingTable = window.customElements.get('stripe-pricing-table')!
-  const stripePricingTable = new StripePricingTable()
-  stripePricingTable.setAttribute('publishable-key', props.publishableKey)
-  stripePricingTable.setAttribute('pricing-table-id', props.pricingTableId)
-  if (props.clientReferenceId)
-    stripePricingTable.setAttribute('client-reference-id', props.clientReferenceId)
-  if (props.customerEmail)
-    stripePricingTable.setAttribute('customer-email', props.customerEmail)
-  if (props.customerSessionClientSecret)
-    stripePricingTable.setAttribute('customer-session-client-secret', props.customerSessionClientSecret)
-  pricingTable.value = stripePricingTable
-  rootEl.value!.appendChild(stripePricingTable)
-  emit('ready')
+onMounted(() => {
+  $script.then(() => {
+    const StripePricingTable = window.customElements.get('stripe-pricing-table')!
+    const stripePricingTable = new StripePricingTable()
+    stripePricingTable.setAttribute('publishable-key', props.publishableKey)
+    stripePricingTable.setAttribute('pricing-table-id', props.pricingTableId)
+    if (props.clientReferenceId)
+      stripePricingTable.setAttribute('client-reference-id', props.clientReferenceId)
+    if (props.customerEmail)
+      stripePricingTable.setAttribute('customer-email', props.customerEmail)
+    if (props.customerSessionClientSecret)
+      stripePricingTable.setAttribute('customer-session-client-secret', props.customerSessionClientSecret)
+    pricingTable.value = stripePricingTable
+    rootEl.value!.appendChild(stripePricingTable)
+    emit('ready', instance)
+  })
+  watch($script.status, (status) => {
+    if (status === 'error') {
+      emit('error')
+    }
+  })
 })
 
 onBeforeUnmount(() => {
@@ -51,6 +62,7 @@ onBeforeUnmount(() => {
     <div ref="containerEl" />
     <slot v-if="$script.status.value === 'loading'" name="loading" />
     <slot v-if="$script.status.value === 'awaitingLoad'" name="awaitingLoad" />
+    <slot v-else-if="$script.status.value === 'error'" name="error" />
     <slot />
   </div>
 </template>

package/dist/runtime/components/ScriptVimeoPlayer.vue

@@ -1,9 +1,12 @@
 <script setup lang="ts">
 /// <reference types="vimeo__player" />
-import { type HTMLAttributes, type ImgHTMLAttributes, computed, onBeforeUnmount, onMounted, ref, watch } from 'vue'
+import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue'
+import type { HTMLAttributes, ImgHTMLAttributes } from 'vue'
 import { defu } from 'defu'
 import type { ElementScriptTrigger } from '../types'
-import { useAsyncData, useElementScriptTrigger, useHead, useScriptVimeoPlayer } from '#imports'
+import { useScriptTriggerElement } from '../composables/useScriptTriggerElement'
+import { useScriptVimeoPlayer } from '../registry/vimeo-player'
+import { useAsyncData, useHead } from '#imports'
 
 const props = withDefaults(defineProps<{
   // custom
@@ -111,7 +114,7 @@ const events: (keyof TEmits)[] = [
 const elVimeo = ref()
 const rootEl = ref()
 
-const trigger = useElementScriptTrigger({ trigger: props.trigger, el: rootEl })
+const trigger = useScriptTriggerElement({ trigger: props.trigger, el: rootEl })
 let clickTriggered = false
 if (props.trigger === 'mousedown') {
   trigger.then(() => {
@@ -187,6 +190,12 @@ onMounted(() => {
   watch(() => props.id, (v) => {
     v && player?.loadVideo(Number(v))
   })
+  watch($script.status, (status) => {
+    if (status === 'error') {
+      // @ts-expect-error untyped
+      emits('error')
+    }
+  })
 })
 
 const rootAttrs = computed(() => {
@@ -239,6 +248,7 @@ onBeforeUnmount(() => player?.unload())
       <ScriptLoadingIndicator color="white" />
     </slot>
     <slot v-if="$script.status.value === 'awaitingLoad'" name="awaitingLoad" />
+    <slot v-else-if="$script.status.value === 'error'" name="error" />
     <slot />
   </div>
 </template>

package/dist/runtime/components/ScriptYouTubePlayer.vue

@@ -1,9 +1,12 @@
 <script setup lang="ts">
 /// <reference types="youtube" />
-import { type HTMLAttributes, type ImgHTMLAttributes, type Ref, computed, onMounted, ref, watch } from 'vue'
+import { computed, onMounted, ref, watch } from 'vue'
+import type { HTMLAttributes, ImgHTMLAttributes, Ref } from 'vue'
 import { defu } from 'defu'
 import type { ElementScriptTrigger } from '../types'
-import { useElementScriptTrigger, useHead, useScriptYouTubePlayer } from '#imports'
+import { useScriptTriggerElement } from '../composables/useScriptTriggerElement'
+import { useScriptYouTubePlayer } from '../registry/youtube-player'
+import { useHead } from '#imports'
 
 const props = withDefaults(defineProps<{
   placeholderAttrs?: ImgHTMLAttributes
@@ -40,7 +43,7 @@ const events: (keyof YT.Events)[] = [
 const rootEl = ref()
 const youtubeEl = ref()
 const ready = ref(false)
-const trigger = useElementScriptTrigger({ trigger: props.trigger, el: rootEl })
+const trigger = useScriptTriggerElement({ trigger: props.trigger, el: rootEl })
 const { $script } = useScriptYouTubePlayer({
   scriptOptions: {
     trigger,
@@ -82,6 +85,12 @@ onMounted(() => {
       }])),
     })
   })
+  watch($script.status, (status) => {
+    if (status === 'error') {
+      // @ts-expect-error untyped
+      emits('error')
+    }
+  })
 })
 
 defineExpose({
@@ -156,5 +165,6 @@ const placeholderAttrs = computed(() => {
       <ScriptLoadingIndicator />
     </slot>
     <slot v-if="$script.status.value === 'awaitingLoad'" name="awaitingLoad" />
+    <slot v-else-if="$script.status.value === 'error'" name="error" />
   </div>
 </template>

package/dist/runtime/composables/useScript.js

@@ -1,7 +1,7 @@
 import { hashCode } from "@unhead/shared";
 import { defu } from "defu";
 import { useScript as _useScript } from "@unhead/vue";
-import { injectHead, onNuxtReady, useNuxtApp, useRuntimeConfig } from "#imports";
+import { injectHead, onNuxtReady, useNuxtApp, useRuntimeConfig, reactive } from "#imports";
 function useNuxtScriptRuntimeConfig() {
   return useRuntimeConfig().public["nuxt-scripts"];
 }
@@ -12,6 +12,10 @@ export function useScript(input, options) {
     options.trigger = onNuxtReady;
   const nuxtApp = useNuxtApp();
   const id = input.key || input.src || hashCode(typeof input.innerHTML === "string" ? input.innerHTML : "");
+  nuxtApp.$scripts = nuxtApp.$scripts || reactive({});
+  if (nuxtApp.$scripts[id]) {
+    return nuxtApp.$scripts[id];
+  }
   if (import.meta.client) {
     if (!nuxtApp._scripts?.[id]) {
       performance?.mark?.("mark_feature_usage", {
@@ -22,6 +26,7 @@ export function useScript(input, options) {
     }
   }
   const instance = _useScript(input, options);
+  nuxtApp.$scripts[id] = instance;
   if (import.meta.dev && import.meta.client) {
     let syncScripts = function() {
       nuxtApp._scripts[instance.$script.id] = payload;

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

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

package/dist/runtime/composables/{useAnalyticsPageEvent.js → useScriptEventPage.js}

@@ -1,5 +1,5 @@
 import { injectHead, ref, useNuxtApp, useRoute } from "#imports";
-export function useAnalyticsPageEvent(onChange) {
+export function useScriptEventPage(onChange) {
   const nuxt = useNuxtApp();
   const route = useRoute();
   const head = injectHead();

package/dist/runtime/composables/{useConsentScriptTrigger.d.ts → useScriptTriggerConsent.d.ts}

@@ -9,5 +9,5 @@ interface UseConsentScriptTriggerApi extends Promise<void> {
  * Load a script once consent has been provided either through a resolvable `consent` or calling the `accept` method.
  * @param options
  */
-export declare function useConsentScriptTrigger(options?: ConsentScriptTriggerOptions): UseConsentScriptTriggerApi;
+export declare function useScriptTriggerConsent(options?: ConsentScriptTriggerOptions): UseConsentScriptTriggerApi;
 export {};

package/dist/runtime/composables/{useConsentScriptTrigger.js → useScriptTriggerConsent.js}

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

package/dist/runtime/composables/{useElementScriptTrigger.d.ts → useScriptTriggerElement.d.ts}

@@ -14,4 +14,4 @@ export interface ElementScriptTriggerOptions {
 /**
  * Create a trigger for an element to load a script based on specific element events.
  */
-export declare function useElementScriptTrigger(options: ElementScriptTriggerOptions): Promise<void>;
+export declare function useScriptTriggerElement(options: ElementScriptTriggerOptions): Promise<void>;

package/dist/runtime/composables/{useElementScriptTrigger.js → useScriptTriggerElement.js}

@@ -22,20 +22,21 @@ function useElementVisibilityPromise(element) {
     observer.stop();
   });
 }
-export function useElementScriptTrigger(options) {
+export function useScriptTriggerElement(options) {
   const { el, trigger } = options;
   if (import.meta.server || !el)
     return new Promise(() => {
     });
-  if (el && options.trigger === "visible")
+  const triggers = (Array.isArray(options.trigger) ? options.trigger : [options.trigger]).filter(Boolean);
+  if (el && triggers.some((t) => ["visibility", "visible"].includes(t)))
     return useElementVisibilityPromise(el);
   if (!trigger)
     return Promise.resolve();
-  if (trigger !== "immediate") {
+  if (!triggers.includes("immediate")) {
     return new Promise((resolve) => {
       const _ = useEventListener(
         typeof el !== "undefined" ? el : document.body,
-        trigger,
+        triggers,
         () => {
           resolve();
           _();

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

@@ -0,0 +1,62 @@
+import type { RegistryScriptInput } from '#nuxt-scripts';
+export declare const CrispOptions: import("valibot").ObjectSchema<{
+    /**
+     * The Crisp ID.
+     */
+    readonly id: import("valibot").StringSchema<undefined>;
+    /**
+     * Extra configuration options. Used to configure the locale.
+     * Same as CRISP_RUNTIME_CONFIG.
+     * @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>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+}, undefined>;
+export type CrispInput = RegistryScriptInput<typeof CrispOptions, false>;
+export interface CrispApi {
+    push: (...args: any[]) => void;
+    is: (name: 'chat:opened' | 'chat:closed' | 'chat:visible' | 'chat:hidden' | 'chat:small' | 'chat:large' | 'session:ongoing' | 'website:available' | 'overlay:opened' | 'overlay:closed' | string) => boolean;
+    set: (name: 'message:text' | 'session:data' | 'session:segments' | 'session:event' | 'user:email' | 'user:phone' | 'user:nickname' | 'user:avatar' | 'user:company' | string, value: any) => void;
+    get: (name: 'chat:unread:count' | 'message:text' | 'session:identifier' | 'session:data' | 'user:email' | 'user:phone' | 'user:nickname' | 'user:avatar' | 'user:company' | string) => any;
+    do: (name: 'chat:open' | 'chat:close' | 'chat:toggle' | 'chat:show' | 'chat:hide' | 'helpdesk:search' | 'helpdesk:article:open' | 'helpdesk:query' | 'overlay:open' | 'overlay:close' | 'message:send' | 'message:show' | 'message:read' | 'message:thread:start' | 'message:thread:end' | 'session:reset' | 'trigger:run' | string, arg2?: any) => any;
+    on: (name: 'session:loaded' | 'chat:initiated' | 'chat:opened' | 'chat:closed' | 'message:sent' | 'message:received' | 'message:compose:sent' | 'message:compose:received' | 'user:email:changed' | 'user:phone:changed' | 'user:nickname:changed' | 'user:avatar:changed' | 'website:availability:changed' | 'helpdesk:queried' | string, callback: (...args: any[]) => any) => void;
+    off: (name: 'session:loaded' | 'chat:initiated' | 'chat:opened' | 'chat:closed' | 'message:sent' | 'message:received' | 'message:compose:sent' | 'message:compose:received' | 'user:email:changed' | 'user:phone:changed' | 'user:nickname:changed' | 'user:avatar:changed' | 'website:availability:changed' | 'helpdesk:queried' | string, callback: (...args: any[]) => any) => void;
+    config: (options: any) => void;
+    help: () => void;
+    [key: string]: any;
+}
+declare global {
+    interface Window {
+        CRISP_READY_TRIGGER: () => void;
+        CRISP_WEBSITE_ID: string;
+        CRISP_RUNTIME_CONFIG?: {
+            locale?: string;
+        };
+        CRISP_COOKIE_DOMAIN?: string;
+        CRISP_COOKIE_EXPIRATION?: number;
+        CRISP_TOKEN_ID?: string;
+        $crisp: CrispApi;
+    }
+}
+export declare function useScriptCrisp<T extends CrispApi>(_options?: CrispInput): T & {
+    $script: Promise<T> & import("@unhead/vue").VueScriptInstance<T>;
+};

package/dist/runtime/registry/crisp.js

@@ -0,0 +1,76 @@
+import { useRegistryScript } from "../utils.js";
+import { object, string, optional, number } from "#nuxt-scripts-validator";
+export const CrispOptions = object({
+  /**
+   * The Crisp ID.
+   */
+  id: string(),
+  /**
+   * Extra configuration options. Used to configure the locale.
+   * Same as CRISP_RUNTIME_CONFIG.
+   * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/language-customization/
+   */
+  runtimeConfig: optional(object({
+    locale: optional(string())
+  })),
+  /**
+   * 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/
+   */
+  tokenId: optional(string()),
+  /**
+   * 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/
+   */
+  cookieDomain: optional(string()),
+  /**
+   * 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
+   */
+  cookieExpiry: optional(number())
+});
+export function useScriptCrisp(_options) {
+  let readyPromise = Promise.resolve();
+  return useRegistryScript("crisp", (options) => ({
+    scriptInput: {
+      src: "https://client.crisp.chat/l.js"
+      // can't be bundled
+    },
+    schema: import.meta.dev ? CrispOptions : void 0,
+    scriptOptions: {
+      use() {
+        const wrapFn = (fn) => window.$crisp?.[fn] || ((...args) => {
+          readyPromise.then(() => window.$crisp[fn](...args));
+        });
+        return {
+          push: window.$crisp.push,
+          do: wrapFn("do"),
+          set: wrapFn("set"),
+          get: wrapFn("get"),
+          on: wrapFn("on"),
+          off: wrapFn("off"),
+          config: wrapFn("config"),
+          help: wrapFn("help")
+        };
+      }
+    },
+    clientInit: import.meta.server ? void 0 : () => {
+      window.$crisp = [];
+      window.CRISP_WEBSITE_ID = options.id;
+      if (options.runtimeConfig?.locale)
+        window.CRISP_RUNTIME_CONFIG = { locale: options.runtimeConfig.locale };
+      if (options.cookieDomain)
+        window.CRISP_COOKIE_DOMAIN = options.cookieDomain;
+      if (options.cookieExpiry)
+        window.CRISP_COOKIE_EXPIRATION = options.cookieExpiry;
+      if (options.tokenId)
+        window.CRISP_TOKEN_ID = options.tokenId;
+      readyPromise = new Promise((resolve) => {
+        window.CRISP_READY_TRIGGER = resolve;
+      });
+    }
+  }), _options);
+}

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

@@ -11,7 +11,7 @@ export interface GoogleAdsenseApi {
      * The Google Adsense API.
      */
     adsbygoogle: any[] & {
-        loaded: boolean;
+        loaded?: boolean;
     };
 }
 declare global {

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

@@ -1,4 +1,4 @@
-import { type InferInput } from '#nuxt-scripts-validator';
+import type { InferInput } from '#nuxt-scripts-validator';
 import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const IntercomOptions: import("valibot").ObjectSchema<{
     readonly app_id: import("valibot").StringSchema<undefined>;

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

@@ -1,23 +1,30 @@
 import type { RegistryScriptInput } from '#nuxt-scripts';
 export type LemonSqueezyInput = RegistryScriptInput;
+export type LemonSqueezyEventPayload = {
+    event: 'Checkout.Success';
+    data: Record<string, any>;
+} & {
+    event: 'Checkout.ViewCart';
+    data: Record<string, any>;
+} & {
+    event: 'GA.ViewCart';
+    data: Record<string, any>;
+} & {
+    event: 'PaymentMethodUpdate.Mounted';
+} & {
+    event: 'PaymentMethodUpdate.Closed';
+} & {
+    event: 'PaymentMethodUpdate.Updated';
+} & {
+    event: string;
+};
 export interface LemonSqueezyApi {
     /**
      * Initialises Lemon.js on your page.
      * @param options - An object with a single property, eventHandler, which is a function that will be called when Lemon.js emits an event.
      */
     Setup: (options: {
-        eventHandler: (event: {
-            event: 'Checkout.Success';
-            data: Record<string, any>;
-        } & {
-            event: 'PaymentMethodUpdate.Mounted';
-        } & {
-            event: 'PaymentMethodUpdate.Closed';
-        } & {
-            event: 'PaymentMethodUpdate.Updated';
-        } & {
-            event: string;
-        }) => void;
+        eventHandler: (event: LemonSqueezyEventPayload) => void;
     }) => void;
     /**
      * Refreshes `lemonsqueezy-button` listeners on the page.

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

@@ -1,4 +1,3 @@
-/// <reference types="stripe-v3" />
 import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const StripeOptions: import("valibot").ObjectSchema<{
     readonly advancedFraudSignals: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, never>;

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

@@ -1,4 +1,4 @@
-import type Vimeo from 'vimeo__player';
+import type Vimeo from '@vimeo/player';
 import type { RegistryScriptInput } from '#nuxt-scripts';
 type Constructor<T extends new (...args: any) => any> = T extends new (...args: infer A) => infer R ? new (...args: A) => R : never;
 export interface VimeoPlayerApi {

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

@@ -1,4 +1,3 @@
-/// <reference types="youtube" />
 import type { RegistryScriptInput } from '#nuxt-scripts';
 export interface YouTubePlayerApi {
     YT: typeof YT & {