@nuxt/scripts 0.3.3 → 0.3.4

package/dist/client/_nuxt/builds/meta/8b865286-abcf-4201-a2af-ee13e4478155.json

@@ -1 +0,0 @@
-{"id":"8b865286-abcf-4201-a2af-ee13e4478155","timestamp":1714631612463,"matcher":{"static":{},"wildcard":{},"dynamic":{}},"prerendered":[]}

package/dist/runtime/components/GoogleMaps.vue

@@ -1,130 +0,0 @@
-<script lang="ts" setup>
-import { type PropType, computed, ref, watch } from 'vue'
-import { withQuery } from 'ufo'
-import type google from 'google.maps'
-import { defu } from 'defu'
-import type { ElementScriptTrigger } from '../composables/useElementScriptTrigger'
-import { useElementScriptTrigger, useRuntimeConfig, useScriptGoogleMaps } from '#imports'
-
-const props = defineProps({
-  trigger: { type: String as PropType<ElementScriptTrigger>, required: false, default: 'mouseover' },
-  /**
-   * Defines the Google Maps API key. Must have access to the Static Maps API as well.
-   *
-   * @see https://developers.google.com/maps/documentation/javascript/get-api-key
-   */
-  apiKey: { type: String, required: true },
-  /**
-   * Defines map marker location.
-   *
-   * @example City Hall, New York, NY
-   */
-  query: { type: String, required: false, default: '' },
-  /**
-   * Defines center of the map view.
-   *
-   * @example 37.4218,-122.0840
-   */
-  options: { type: Object as PropType<Omit<google.maps.MapOptions, 'center'>>, required: false, default: undefined },
-  /**
-   * Defines the width of the map.
-   */
-  width: { type: Number, required: false, default: 500 },
-  /**
-   * Defines the height of the map
-   */
-  height: { type: Number, required: false, default: 400 },
-})
-
-const apiKey = props.apiKey || useRuntimeConfig().public.scripts?.googleMaps?.apikey
-
-if (!apiKey)
-  throw new Error('GoogleMaps requires an API key')
-if (!props.query && !props.options?.center)
-  throw new Error('GoogleMaps requires either a query or center option')
-
-const elMap = ref<HTMLElement>()
-
-const { $script } = useScriptGoogleMaps({
-  apiKey: props.apiKey,
-  scriptOptions: {
-    trigger: useElementScriptTrigger({ trigger: props.trigger, el: elMap }),
-  },
-})
-
-const options = computed(() => {
-  return defu(props.options, {
-    zoom: 15,
-    mapId: 'map',
-  })
-})
-const ready = ref(false)
-
-function queryMaps(maps: google.maps, marker: google.maps.MarkerLibrary, map: google.maps.Map) {
-  const request = {
-    query: props.query,
-    fields: ['name', 'geometry'],
-  }
-  const markers: google.maps.AdvancedMarkerElement[] = []
-  const service = new maps.places.PlacesService(map)
-  service.findPlaceFromQuery(request, (results, status) => {
-    if (status === maps.places.PlacesServiceStatus.OK && results) {
-      for (let i = 0; i < results.length; i++) {
-        const location = results[i].geometry?.location
-        location && markers.push(
-          new marker.AdvancedMarkerElement({
-            map,
-            position: location,
-          }),
-        )
-      }
-
-      if (results[0].geometry?.location)
-        markers[0] && map.setCenter(results[0].geometry.location)
-      ready.value = true
-    }
-  })
-}
-
-// create the map
-$script.then(async (instance) => {
-  const maps = await instance.maps
-  const marker = await maps.importLibrary('marker') as google.maps.MarkerLibrary
-
-  const mapDiv = document.createElement('div')
-  mapDiv.style.width = '100%'
-  mapDiv.style.height = '100%'
-  const _ = watch(ready, (v) => {
-    v && elMap.value?.appendChild(mapDiv)
-    _()
-  })
-
-  const map = new maps.Map(mapDiv, options.value)
-  watch(options, () => map.setOptions(options.value))
-  watch(() => props.query, () => {
-    queryMaps(maps, marker, map)
-  }, {
-    immediate: !!props.query,
-  })
-  if (!props.query)
-    ready.value = true
-})
-
-const poster = computed(() => {
-  return withQuery('https://maps.googleapis.com/maps/api/staticmap', {
-    center: props.query, // will be overriden by options if they were set
-    size: `${props.width}x${props.height}`,
-    key: apiKey,
-    scale: 2, // we assume a high DPI to avoid hydration issues
-    ...options.value,
-  })
-})
-</script>
-
-<template>
-  <div ref="elMap" :style="{ width: `${width}px`, height: `${height}px`, position: 'relative' }">
-    <slot>
-      <img v-if="!ready" :src="poster" title="" :width="width" :height="height">
-    </slot>
-  </div>
-</template>

package/dist/runtime/components/LemonSqueezyButton.vue

@@ -1,28 +0,0 @@
-<script lang="ts" setup>
-import { useScriptLemonSqueezy } from '#imports'
-
-defineProps<{
-  href: string
-}>()
-
-const emits = defineEmits<{
-  event: [{ event: string, data?: Record<string, any> }]
-}>()
-
-const instance = useScriptLemonSqueezy()
-instance.Setup({
-  eventHandler(event) {
-    emits('event', event)
-  },
-})
-
-defineExpose({
-  instance,
-})
-</script>
-
-<template>
-  <a :href="href" class="lemonsqueezy-button">
-    <slot />
-  </a>
-</template>

package/dist/runtime/components/StripePricingTableEmbed.vue

@@ -1,33 +0,0 @@
-<script setup lang="ts">
-import { ref } from 'vue'
-import type { ElementScriptTrigger } from '../composables/useElementScriptTrigger'
-import { useElementScriptTrigger, useScript } from '#imports'
-
-const props = defineProps<{
-  trigger?: ElementScriptTrigger
-  publishableKey: string
-  pricingTableId: string
-  clientReferenceId?: string
-  customerEmail?: string
-  customerSessionClientSecret?: string
-}>()
-
-const table = ref()
-useScript(`https://js.stripe.com/v3/pricing-table.js`, {
-  trigger: useElementScriptTrigger({ trigger: props.trigger, el: table }),
-})
-</script>
-
-<template>
-  <ClientOnly>
-    <stripe-pricing-table
-      ref="table"
-      v-bind="$attrs"
-      :publishable-key="publishableKey"
-      :pricing-table-id="pricingTableId"
-      :client-reference-id="clientReferenceId"
-      :customer-email="customerEmail"
-      :customer-session-client-secret="customerSessionClientSecret"
-    />
-  </ClientOnly>
-</template>

package/dist/runtime/components/VimeoEmbed.vue

@@ -1,161 +0,0 @@
-<script setup lang="ts">
-import { computed, onBeforeUnmount, ref, watch } from 'vue'
-import type Player from 'vimeo__player'
-import type { EventMap, VimeoVideoQuality } from 'vimeo__player'
-import type { ElementScriptTrigger } from '../composables/useElementScriptTrigger'
-import { useAsyncData, useElementScriptTrigger, useScriptVimeoPlayer } from '#imports'
-
-const props = withDefaults(defineProps<{
-  // custom
-  trigger?: ElementScriptTrigger
-  // copied from @types/vimeo__player
-  id: number | undefined
-  url?: string | undefined
-  autopause?: boolean | undefined
-  autoplay?: boolean | undefined
-  background?: boolean | undefined
-  byline?: boolean | undefined
-  color?: string | undefined
-  controls?: boolean | undefined
-  dnt?: boolean | undefined
-  height?: number | undefined
-  // eslint-disable-next-line vue/prop-name-casing
-  interactive_params?: string | undefined
-  keyboard?: boolean | undefined
-  loop?: boolean | undefined
-  maxheight?: number | undefined
-  maxwidth?: number | undefined
-  muted?: boolean | undefined
-  pip?: boolean | undefined
-  playsinline?: boolean | undefined
-  portrait?: boolean | undefined
-  responsive?: boolean | undefined
-  speed?: boolean | undefined
-  quality?: VimeoVideoQuality | undefined
-  texttrack?: string | undefined
-  title?: boolean | undefined
-  transparent?: boolean | undefined
-  width?: number | undefined
-}>(), {
-  trigger: 'mouseover',
-  width: 640,
-  height: 480,
-  loop: false,
-  controls: true,
-})
-
-const emits = defineEmits<{
-  play: [e: EventMap['play'], player: Player]
-  playing: [e: EventMap['playing'], player: Player]
-  pause: [e: EventMap['pause'], player: Player]
-  ended: [e: EventMap['ended'], player: Player]
-  timeupdate: [e: EventMap['timeupdate'], player: Player]
-  progress: [e: EventMap['progress'], player: Player]
-  seeking: [e: EventMap['seeking'], player: Player]
-  seeked: [e: EventMap['seeked'], player: Player]
-  texttrackchange: [e: EventMap['texttrackchange'], player: Player]
-  chapterchange: [e: EventMap['chapterchange'], player: Player]
-  cuechange: [e: EventMap['cuechange'], player: Player]
-  cuepoint: [e: EventMap['cuepoint'], player: Player]
-  volumechange: [e: EventMap['volumechange'], player: Player]
-  playbackratechange: [e: EventMap['playbackratechange'], player: Player]
-  bufferstart: [e: EventMap['bufferstart'], player: Player]
-  bufferend: [e: EventMap['bufferend'], player: Player]
-  error: [e: EventMap['error'], player: Player]
-  loaded: [e: EventMap['loaded'], player: Player]
-  durationchange: [e: EventMap['durationchange'], player: Player]
-  fullscreenchange: [e: EventMap['fullscreenchange'], player: Player]
-  qualitychange: [e: EventMap['qualitychange'], player: Player]
-  camerachange: [e: EventMap['camerachange'], player: Player]
-  resize: [e: EventMap['resize'], player: Player]
-  enterpictureinpicture: [e: EventMap['enterpictureinpicture'], player: Player]
-  leavepictureinpicture: [e: EventMap['leavepictureinpicture'], player: Player]
-}>()
-
-const events = [
-  'play',
-  'playing',
-  'pause',
-  'ended',
-  'timeupdate',
-  'progress',
-  'seeking',
-  'seeked',
-  'texttrackchange',
-  'chapterchange',
-  'cuechange',
-  'cuepoint',
-  'volumechange',
-  'playbackratechange',
-  'bufferstart',
-  'bufferend',
-  'error',
-  'loaded',
-  'durationchange',
-  'fullscreenchange',
-  'qualitychange',
-  'camerachange',
-  'resize',
-]
-
-const elVimeo = ref()
-const root = ref()
-
-const ready = ref(false)
-const { $script } = useScriptVimeoPlayer({
-  scriptOptions: {
-    trigger: useElementScriptTrigger({ trigger: props.trigger, el: root.value }),
-  },
-})
-
-const { data: payload } = useAsyncData(
-  `vimeo-embed:${props.id}`,
-  // TODO ideally we cache this
-  () => $fetch(`https://vimeo.com/api/v2/video/${props.id}.json`).then(res => res[0]),
-  {
-    watch: [() => props.id],
-  },
-)
-
-const poster = computed(() => {
-  const { width, height } = props
-  // 2 dpi for retina, this is safest while SSR
-  return payload.value.thumbnail_large.replace(/-d_[\dx]+$/i, `-d_${Math.round(width * 2)}x${Math.round(height * 2)}`)
-})
-
-let player: Player
-$script.then(({ Player }) => {
-  // filter props for false values
-  player = Player(elVimeo.value, {
-    ...props,
-    url: encodeURI(`https://vimeo.com/${props.id}`),
-  })
-
-  events.forEach((event) => {
-    player.on(event, (e: any) => {
-      emits(event as keyof typeof emits, e, player)
-      if (event === 'loaded')
-        ready.value = true
-    })
-  })
-})
-
-onBeforeUnmount(() => player?.unload())
-
-defineExpose({
-  player,
-})
-
-watch(() => props.id, (v) => {
-  v && player?.loadVideo(v)
-})
-</script>
-
-<template>
-  <div ref="root" :style="{ width: `${width}px`, height: `${height}px`, position: 'relative' }">
-    <div v-show="ready" ref="elVimeo" style="width: 100%; height: 100%;" />
-    <slot v-bind="payload" :poster="poster">
-      <img v-if="!ready" :src="poster" v-bind="trigger ? { loading: 'lazy' } : {}" :width="width" :height="height" :style="{ aspectRatio: '4/3', cursor: $script.status.value !== 'awaitingLoad' ? 'wait' : '' }">
-    </slot>
-  </div>
-</template>

package/dist/runtime/components/YouTubeEmbed.vue

@@ -1,79 +0,0 @@
-<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({ trigger: props.trigger, el: 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/registry/youtube-iframe.d.ts

@@ -1,15 +0,0 @@
-/// <reference types="youtube" />
-import type { RegistryScriptInput } from '#nuxt-scripts';
-export interface YouTubeIframeApi {
-    YT: typeof YT;
-}
-declare global {
-    interface Window extends YouTubeIframeApi {
-        onYouTubeIframeAPIReady: () => void;
-    }
-}
-export declare const YouTubeIframeOptions: import("valibot").ObjectSchema<{}, undefined, {}>;
-export type YouTubeIFrameInput = RegistryScriptInput<typeof YouTubeIframeOptions>;
-export declare function useScriptYouTubeIframe<T extends YouTubeIframeApi>(_options: YouTubeIFrameInput): T & {
-    $script: Promise<T> & import("@unhead/vue").VueScriptInstance<T>;
-};