@nuxt/scripts 0.1.12 → 0.3.0

package/dist/runtime/registry/hotjar.mjs

@@ -1,29 +1,25 @@
 import { number, object, optional } from "valibot";
-import { useScript, validateScriptInputSchema } from "#imports";
+import { registryScript } from "../utils.mjs";
 export const HotjarOptions = object({
   id: number(),
   sv: optional(number())
 });
-export function useScriptHotjar(options, _scriptOptions) {
-  const scriptOptions = _scriptOptions || {};
-  scriptOptions.beforeInit = () => {
-    import.meta.dev && validateScriptInputSchema(HotjarOptions, options);
-    if (import.meta.client) {
+export function useScriptHotjar(_options) {
+  return registryScript("hotjar", (options) => ({
+    scriptInput: {
+      src: `https://static.hotjar.com/c/hotjar-${options?.id}.js?sv=${options?.sv}`
+    },
+    schema: HotjarOptions,
+    scriptOptions: {
+      use() {
+        return { hj: window.hj };
+      }
+    },
+    clientInit: import.meta.server ? void 0 : () => {
       window._hjSettings = window._hjSettings || { hjid: options?.id, hjsv: options?.sv };
       window.hj = window.hj || function(...params) {
         (window.hj.q = window.hj.q || []).push(params);
       };
     }
-    _scriptOptions?.beforeInit?.();
-  };
-  return useScript({
-    key: "hotjar",
-    // requires extra steps to bundle
-    src: options?.src || `https://static.hotjar.com/c/hotjar-${options?.id}.js?sv=${options?.sv}`
-  }, {
-    ...scriptOptions,
-    use() {
-      return { hj: window.hj };
-    }
-  });
+  }), _options);
 }

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

@@ -1,5 +1,5 @@
 import { type Input } from 'valibot';
-import type { NuxtUseScriptIntegrationOptions, ScriptDynamicSrcInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const IntercomOptions: import("valibot").ObjectSchema<{
     app_id: import("valibot").StringSchema<string>;
     api_base: import("valibot").OptionalSchema<import("valibot").UnionSchema<(import("valibot").LiteralSchema<"https://api-iam.intercom.io", "https://api-iam.intercom.io"> | import("valibot").LiteralSchema<"https://api-iam.eu.intercom.io", "https://api-iam.eu.intercom.io"> | import("valibot").LiteralSchema<"https://api-iam.au.intercom.io", "https://api-iam.au.intercom.io">)[], "https://api-iam.intercom.io" | "https://api-iam.eu.intercom.io" | "https://api-iam.au.intercom.io">, undefined, "https://api-iam.intercom.io" | "https://api-iam.eu.intercom.io" | "https://api-iam.au.intercom.io" | undefined>;
@@ -19,7 +19,7 @@ export declare const IntercomOptions: import("valibot").ObjectSchema<{
     horizontal_padding?: number | undefined;
     vertical_padding?: number | undefined;
 }>;
-export type IntercomInput = ScriptDynamicSrcInput<typeof IntercomOptions>;
+export type IntercomInput = RegistryScriptInput<typeof IntercomOptions>;
 export interface IntercomApi {
     Intercom: ((event: 'boot', data?: Input<typeof IntercomOptions>) => void) & ((event: 'shutdown') => void) & ((event: 'update', options?: Input<typeof IntercomOptions>) => void) & ((event: 'hide') => void) & ((event: 'show') => void) & ((event: 'showSpace', spaceName: 'home' | 'messages' | 'help' | 'news' | 'tasks' | 'tickets' | string) => void) & ((event: 'showMessages') => void) & ((event: 'showNewMessage', content?: string) => void) & ((event: 'onHide', fn: () => void) => void) & ((event: 'onShow', fn: () => void) => void) & ((event: 'onUnreadCountChange', fn: () => void) => void) & ((event: 'trackEvent', eventName: string, metadata?: Record<string, any>) => void) & ((event: 'getVisitorId') => Promise<string>) & ((event: 'startTour', tourId: string | number) => void) & ((event: 'showArticle', articleId: string | number) => void) & ((event: 'showNews', newsItemId: string | number) => void) & ((event: 'startSurvey', surveyId: string | number) => void) & ((event: 'startChecklist', checklistId: string | number) => void) & ((event: 'showTicket', ticketId: string | number) => void) & ((event: 'showConversation', conversationId: string | number) => void) & ((event: 'onUserEmailSupplied', fn: () => void) => void) & ((event: string, ...params: any[]) => void);
 }
@@ -28,4 +28,6 @@ declare global {
         intercomSettings?: IntercomInput;
     }
 }
-export declare function useScriptIntercom<T extends IntercomApi>(options?: IntercomInput, _scriptOptions?: NuxtUseScriptIntegrationOptions): any;
+export declare function useScriptIntercom<T extends IntercomApi>(_options?: IntercomInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};

package/dist/runtime/registry/intercom.mjs

@@ -1,6 +1,6 @@
 import { literal, number, object, optional, string, union } from "valibot";
 import { joinURL } from "ufo";
-import { useScript, validateScriptInputSchema } from "#imports";
+import { registryScript } from "../utils.mjs";
 export const IntercomOptions = object({
   app_id: string(),
   api_base: optional(union([literal("https://api-iam.intercom.io"), literal("https://api-iam.eu.intercom.io"), literal("https://api-iam.au.intercom.io")])),
@@ -12,21 +12,24 @@ export const IntercomOptions = object({
   horizontal_padding: optional(number()),
   vertical_padding: optional(number())
 });
-export function useScriptIntercom(options, _scriptOptions) {
-  const scriptOptions = _scriptOptions || {};
-  scriptOptions.beforeInit = () => {
-    import.meta.dev && validateScriptInputSchema(IntercomOptions, options);
-    if (import.meta.client)
+export function useScriptIntercom(_options) {
+  return registryScript("intercom", (options) => ({
+    scriptInput: {
+      src: joinURL(`https://widget.intercom.io/widget`, options?.app_id || ""),
+      // append the data attr's
+      ...Object.entries(options).filter(([key]) => key.startsWith("data-")).reduce((acc, [key, value]) => {
+        acc[key] = value;
+        return acc;
+      })
+    },
+    schema: IntercomOptions,
+    scriptOptions: {
+      use() {
+        return { Intercom: window.Intercom };
+      }
+    },
+    clientInit: import.meta.server ? void 0 : () => {
       window.intercomSettings = options;
-    _scriptOptions?.beforeInit?.();
-  };
-  return useScript({
-    key: "intercom",
-    src: options?.src || joinURL(`https://widget.intercom.io/widget`, options?.app_id || "")
-  }, {
-    ...scriptOptions,
-    use() {
-      return { Intercom: window.Intercom };
     }
-  });
+  }), _options);
 }

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

@@ -0,0 +1,68 @@
+import type { RegistryScriptInput } from '#nuxt-scripts';
+export declare const LemonSqueezyOptions: import("valibot").ObjectSchema<{}, undefined, {}>;
+export type LemonSqueezyInput = RegistryScriptInput<typeof LemonSqueezyOptions>;
+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;
+    }) => void;
+    /**
+     * Refreshes `lemonsqueezy-button` listeners on the page.
+     */
+    Refresh: () => void;
+    Url: {
+        /**
+         * Opens a given Lemon Squeezy URL, typically these are Checkout or Payment Details Update overlays.
+         * @param url - The URL to open.
+         */
+        Open: (url: string) => void;
+        /**
+         * Closes the current opened Lemon Squeezy overlay checkout window.
+         */
+        Close: () => void;
+    };
+    Affiliate: {
+        /**
+         * Retrieve the affiliate tracking ID
+         */
+        GetID: () => string;
+        /**
+         * Append the affiliate tracking parameter to the given URL
+         * @param url - The URL to append the affiliate tracking parameter to.
+         */
+        Build: (url: string) => string;
+    };
+    Loader: {
+        /**
+         * Show the Lemon.js loader.
+         */
+        Show: () => void;
+        /**
+         * Hide the Lemon.js loader.
+         */
+        Hide: () => void;
+    };
+}
+declare global {
+    interface Window {
+        createLemonSqueezy: () => void;
+        LemonSqueezy: LemonSqueezyApi;
+    }
+}
+export declare function useScriptLemonSqueezy<T extends LemonSqueezyApi>(_options?: LemonSqueezyInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};

package/dist/runtime/registry/lemon-squeezy.mjs

@@ -0,0 +1,21 @@
+import { object } from "valibot";
+import { registryScript } from "../utils.mjs";
+export const LemonSqueezyOptions = object({});
+export function useScriptLemonSqueezy(_options) {
+  return registryScript("lemonSqueezy", () => ({
+    scriptInput: {
+      src: "https://assets.lemonsqueezy.com/lemon.js",
+      // @ts-expect-error untyped
+      crossorigin: null
+    },
+    schema: LemonSqueezyOptions,
+    scriptOptions: {
+      use() {
+        if (typeof window.createLemonSqueezy === "undefined")
+          return void 0;
+        window.createLemonSqueezy();
+        return window.LemonSqueezy;
+      }
+    }
+  }), _options);
+}

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

@@ -0,0 +1,24 @@
+import type { RegistryScriptInput } from '#nuxt-scripts';
+export declare const MatomoAnalyticsOptions: import("valibot").ObjectSchema<{
+    matomoUrl: import("valibot").StringSchema<string>;
+    siteId: import("valibot").StringSchema<string>;
+    trackPageView: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
+    enableLinkTracking: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
+}, undefined, {
+    matomoUrl: string;
+    siteId: string;
+    trackPageView?: boolean | undefined;
+    enableLinkTracking?: boolean | undefined;
+}>;
+export type MatomoAnalyticsInput = RegistryScriptInput<typeof MatomoAnalyticsOptions, false>;
+interface MatomoAnalyticsApi {
+    _paq: unknown[];
+}
+declare global {
+    interface Window extends MatomoAnalyticsApi {
+    }
+}
+export declare function useScriptMatomoAnalytics<T extends MatomoAnalyticsApi>(_options?: MatomoAnalyticsInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};
+export {};

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

@@ -0,0 +1,33 @@
+import { boolean, object, optional, string } from "valibot";
+import { registryScript } from "../utils.mjs";
+export const MatomoAnalyticsOptions = object({
+  matomoUrl: string(),
+  // site is required
+  siteId: string(),
+  trackPageView: optional(boolean()),
+  enableLinkTracking: optional(boolean())
+});
+export function useScriptMatomoAnalytics(_options) {
+  return registryScript("matomoAnalytics", (options) => ({
+    scriptInput: {
+      src: `https://${options?.matomoUrl}/matomo.js`
+    },
+    schema: MatomoAnalyticsOptions,
+    scriptOptions: {
+      use() {
+        return { _paq: window._paq };
+      },
+      // allow _paq to be accessed on the server
+      stub: import.meta.client ? void 0 : ({ fn }) => {
+        return fn === "_paq" ? [] : void 0;
+      },
+      clientInit: import.meta.server ? void 0 : () => {
+        const _paq = window._paq = window._paq || [];
+        options?.trackPageView !== false && _paq.push(["trackPageView"]);
+        options?.enableLinkTracking !== false && _paq.push(["enableLinkTracking"]);
+        _paq.push(["setTrackerUrl", `//${options?.matomoUrl}/matomo.php`]);
+        _paq.push(["setSiteId", options?.siteId]);
+      }
+    }
+  }), _options);
+}

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

@@ -1,12 +1,16 @@
-import type { NuxtUseScriptOptions, ScriptDynamicSrcInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const NpmOptions: import("valibot").ObjectSchema<{
     packageName: import("valibot").StringSchema<string>;
     file: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
     version: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
+    type: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
 }, undefined, {
     packageName: string;
+    type?: string | undefined;
     file?: string | undefined;
     version?: string | undefined;
 }>;
-export type NpmInput = ScriptDynamicSrcInput<typeof NpmOptions>;
-export declare function useScriptNpm<T>(options: NpmInput, _scriptOptions?: NuxtUseScriptOptions<T>): any;
+export type NpmInput = RegistryScriptInput<typeof NpmOptions>;
+export declare function useScriptNpm<T extends Record<string | symbol, any>>(_options: NpmInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};

package/dist/runtime/registry/npm.mjs

@@ -1,18 +1,17 @@
 import { object, optional, string } from "valibot";
 import { withBase } from "ufo";
-import { useScript, validateScriptInputSchema } from "#imports";
+import { registryScript } from "../utils.mjs";
 export const NpmOptions = object({
   packageName: string(),
   file: optional(string()),
-  version: optional(string())
+  version: optional(string()),
+  type: optional(string())
 });
-export function useScriptNpm(options, _scriptOptions) {
-  const scriptOptions = _scriptOptions || {};
-  scriptOptions.beforeInit = () => {
-    import.meta.dev && validateScriptInputSchema(NpmOptions, options);
-  };
-  return useScript({
-    key: options.packageName,
-    src: options.src || withBase(options.file || "", `https://unpkg.com/${options?.packageName}@${options.version || "latest"}`)
-  }, scriptOptions);
+export function useScriptNpm(_options) {
+  return registryScript(`${_options.packageName}-npm`, (options) => ({
+    scriptInput: {
+      src: withBase(options.file || "", `https://unpkg.com/${options?.packageName}@${options.version || "latest"}`)
+    },
+    schema: import.meta.dev ? NpmOptions : void 0
+  }), _options);
 }

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

@@ -0,0 +1,22 @@
+import type { RegistryScriptInput } from '#nuxt-scripts';
+export declare const PlausibleAnalyticsOptions: import("valibot").ObjectSchema<{
+    domain: import("valibot").StringSchema<string>;
+    extension: import("valibot").OptionalSchema<import("valibot").UnionSchema<(import("valibot").UnionSchema<(import("valibot").LiteralSchema<"hash", "hash"> | import("valibot").LiteralSchema<"outbound-links", "outbound-links"> | import("valibot").LiteralSchema<"file-downloads", "file-downloads"> | import("valibot").LiteralSchema<"tagged-events", "tagged-events"> | import("valibot").LiteralSchema<"revenue", "revenue"> | import("valibot").LiteralSchema<"pageview-props", "pageview-props"> | import("valibot").LiteralSchema<"compat", "compat"> | import("valibot").LiteralSchema<"local", "local"> | import("valibot").LiteralSchema<"manual", "manual">)[], "manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local"> | import("valibot").ArraySchema<import("valibot").UnionSchema<(import("valibot").LiteralSchema<"hash", "hash"> | import("valibot").LiteralSchema<"outbound-links", "outbound-links"> | import("valibot").LiteralSchema<"file-downloads", "file-downloads"> | import("valibot").LiteralSchema<"tagged-events", "tagged-events"> | import("valibot").LiteralSchema<"revenue", "revenue"> | import("valibot").LiteralSchema<"pageview-props", "pageview-props"> | import("valibot").LiteralSchema<"compat", "compat"> | import("valibot").LiteralSchema<"local", "local"> | import("valibot").LiteralSchema<"manual", "manual">)[], "manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local">, ("manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local")[]>)[], "manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local" | ("manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local")[]>, undefined, "manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local" | ("manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local")[] | undefined>;
+}, undefined, {
+    domain: string;
+    extension?: "manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local" | ("manual" | "hash" | "outbound-links" | "file-downloads" | "tagged-events" | "revenue" | "pageview-props" | "compat" | "local")[] | undefined;
+}>;
+export type PlausibleAnalyticsInput = RegistryScriptInput<typeof PlausibleAnalyticsOptions, false>;
+export interface PlausibleAnalyticsApi {
+    plausible: ((event: '404', options: Record<string, any>) => void) & ((event: 'event', options: Record<string, any>) => void) & ((...params: any[]) => void) & {
+        q: any[];
+    };
+}
+declare global {
+    interface Window {
+        plausible: PlausibleAnalyticsApi;
+    }
+}
+export declare function useScriptPlausibleAnalytics<T extends PlausibleAnalyticsApi>(_options?: PlausibleAnalyticsInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};

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

@@ -0,0 +1,35 @@
+import { array, literal, object, optional, string, union } from "valibot";
+import { registryScript } from "../utils.mjs";
+import { PlausibleAnalyticsScriptResolver } from "../../registry";
+const extensions = [
+  literal("hash"),
+  literal("outbound-links"),
+  literal("file-downloads"),
+  literal("tagged-events"),
+  literal("revenue"),
+  literal("pageview-props"),
+  literal("compat"),
+  literal("local"),
+  literal("manual")
+];
+export const PlausibleAnalyticsOptions = object({
+  domain: string(),
+  // required
+  extension: optional(union([union(extensions), array(union(extensions))]))
+});
+export function useScriptPlausibleAnalytics(_options) {
+  return registryScript("plausibleAnalytics", (options) => {
+    return {
+      scriptInput: {
+        "src": PlausibleAnalyticsScriptResolver(options),
+        "data-domain": options?.domain
+      },
+      schema: PlausibleAnalyticsOptions,
+      scriptOptions: {
+        use() {
+          return { plausible: window.plausible };
+        }
+      }
+    };
+  }, _options);
+}

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

@@ -1,4 +1,4 @@
-import type { NuxtUseScriptIntegrationOptions, ScriptDynamicSrcInput } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const SegmentOptions: import("valibot").ObjectSchema<{
     writeKey: import("valibot").StringSchema<string>;
     analyticsKey: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
@@ -6,7 +6,7 @@ export declare const SegmentOptions: import("valibot").ObjectSchema<{
     writeKey: string;
     analyticsKey?: string | undefined;
 }>;
-export type SegmentInput = ScriptDynamicSrcInput<typeof SegmentOptions>;
+export type SegmentInput = RegistryScriptInput<typeof SegmentOptions>;
 export interface SegmentApi {
     analytics: {
         track: (event: string, properties?: Record<string, any>) => void;
@@ -21,4 +21,6 @@ declare global {
     interface Window extends SegmentApi {
     }
 }
-export declare function useScriptSegment<T extends SegmentApi>(options?: SegmentInput, _scriptOptions?: NuxtUseScriptIntegrationOptions): any;
+export declare function useScriptSegment<T extends SegmentApi>(_options?: SegmentInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};

package/dist/runtime/registry/segment.mjs

@@ -1,41 +1,41 @@
 import { object, optional, string } from "valibot";
-import { useScript, validateScriptInputSchema } from "#imports";
+import { registryScript } from "../utils.mjs";
+import { SegmentScriptResolver } from "../../registry";
 export const SegmentOptions = object({
   writeKey: string(),
   analyticsKey: optional(string())
 });
-export function useScriptSegment(options, _scriptOptions) {
-  const scriptOptions = _scriptOptions || {};
-  scriptOptions.beforeInit = () => {
-    import.meta.dev && validateScriptInputSchema(SegmentOptions, options);
-    if (import.meta.client) {
-      window.analytics = window.analytics || [];
-      window.analytics.methods = ["track", "page", "identify", "group", "alias", "reset"];
-      window.analytics.factory = function(method) {
-        return function(...params) {
-          const args = Array.prototype.slice.call(params);
-          args.unshift(method);
-          window.analytics.push(args);
-          return window.analytics;
-        };
-      };
-      for (let i = 0; i < window.analytics.methods.length; i++) {
-        const key = window.analytics.methods[i];
-        window.analytics[key] = window.analytics.factory(key);
+export function useScriptSegment(_options) {
+  return registryScript("segment", (options) => {
+    const analyticsKey = options?.analyticsKey || "analytics";
+    return {
+      scriptInput: {
+        "data-global-segment-analytics-key": analyticsKey,
+        "src": SegmentScriptResolver(options)
+      },
+      schema: SegmentOptions,
+      scriptOptions: {
+        use() {
+          return { analytics: window[analyticsKey] };
+        },
+        clientInit: import.meta.server ? void 0 : () => {
+          window.analytics = window.analytics || [];
+          window.analytics.methods = ["track", "page", "identify", "group", "alias", "reset"];
+          window.analytics.factory = function(method) {
+            return function(...params) {
+              const args = Array.prototype.slice.call(params);
+              args.unshift(method);
+              window.analytics.push(args);
+              return window.analytics;
+            };
+          };
+          for (let i = 0; i < window.analytics.methods.length; i++) {
+            const key = window.analytics.methods[i];
+            window.analytics[key] = window.analytics.factory(key);
+          }
+          window.analytics.page();
+        }
       }
-      window.analytics.page();
-    }
-    _scriptOptions?.beforeInit?.();
-  };
-  const analyticsKey = options?.analyticsKey || "analytics";
-  return useScript({
-    "key": "segment",
-    "data-global-segment-analytics-key": analyticsKey,
-    "src": options?.src || `https://cdn.segment.com/analytics.js/v1/${options?.writeKey}/analytics.min.js`
-  }, {
-    ...scriptOptions,
-    use() {
-      return { analytics: window[analyticsKey] };
-    }
-  });
+    };
+  }, _options);
 }

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

@@ -0,0 +1,18 @@
+import type { Stripe } from '@types/stripe-v3';
+import type { RegistryScriptInput } from '#nuxt-scripts';
+export declare const StripeOptions: import("valibot").ObjectSchema<{
+    advancedFraudSignals: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
+}, undefined, {
+    advancedFraudSignals?: boolean | undefined;
+}>;
+export type StripeInput = RegistryScriptInput<typeof StripeOptions, false>;
+export interface StripeApi {
+    Stripe: Stripe;
+}
+declare global {
+    interface Window extends StripeApi {
+    }
+}
+export declare function useScriptStripe<T extends StripeApi>(_options?: StripeInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};

package/dist/runtime/registry/stripe.mjs

@@ -0,0 +1,27 @@
+import { boolean, object, optional } from "valibot";
+import { withQuery } from "ufo";
+import { registryScript } from "../utils.mjs";
+export const StripeOptions = object({
+  advancedFraudSignals: optional(boolean())
+});
+export function useScriptStripe(_options) {
+  return registryScript("stripe", (options) => ({
+    scriptInput: {
+      src: withQuery(
+        `https://js.stripe.com/v3/`,
+        typeof options?.advancedFraudSignals === "boolean" && !options?.advancedFraudSignals ? { advancedFraudSignals: false } : {}
+      ),
+      // opt-out of privacy defaults
+      // @ts-expect-error TODO add types
+      crossorigin: null,
+      // @ts-expect-error TODO add types
+      referrerpolicy: null
+    },
+    schema: StripeOptions,
+    scriptOptions: {
+      use() {
+        return { Stripe: window.Stripe };
+      }
+    }
+  }), _options);
+}

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

@@ -0,0 +1,15 @@
+import type VimeoPlayer from 'vimeo__player';
+import type { RegistryScriptInput } from '#nuxt-scripts';
+export interface VimeoPlayerApi {
+    Player: VimeoPlayer;
+}
+export declare const VimeoPlayerOptions: import("valibot").ObjectSchema<{}, undefined, {}>;
+export type VimeoPlayerInput = RegistryScriptInput<typeof VimeoPlayerOptions>;
+declare global {
+    interface Window {
+        Vimeo: VimeoPlayerApi;
+    }
+}
+export declare function useScriptVimeoPlayer<T extends VimeoPlayerApi>(_options?: VimeoPlayerInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};

package/dist/runtime/registry/vimeo-player.mjs

@@ -0,0 +1,45 @@
+import { object } from "valibot";
+import { registryScript } from "../utils.mjs";
+import { useHead } from "#imports";
+export const VimeoPlayerOptions = object({});
+export function useScriptVimeoPlayer(_options) {
+  return registryScript("vimeoPlayer", () => ({
+    scriptInput: {
+      src: "https://player.vimeo.com/api/player.js"
+    },
+    schema: VimeoPlayerOptions,
+    scriptOptions: {
+      use() {
+        let Player;
+        if (import.meta.client) {
+          Player = function(...params) {
+            return new window.Vimeo.Player(...params);
+          };
+        }
+        return { Player };
+      }
+    },
+    beforeInit() {
+      useHead({
+        link: [
+          {
+            rel: "preconnect",
+            href: "https://player.vimeo.com"
+          },
+          {
+            rel: "preconnect",
+            href: "https://i.vimeocdn.com"
+          },
+          {
+            rel: "preconnect",
+            href: "https://f.vimeocdn.com"
+          },
+          {
+            rel: "preconnect",
+            href: "https://fresnel.vimeocdn.com"
+          }
+        ]
+      });
+    }
+  }), _options);
+}

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

@@ -0,0 +1,41 @@
+import type { RegistryScriptInput } from '#nuxt-scripts';
+interface ContentProperties {
+    content_type?: string | null;
+    content_id?: string | number | null;
+    content_name?: string | null;
+    content_price?: string | number | null;
+    num_items?: string | number | null;
+    content_group_id?: string | number | null;
+}
+interface EventObjectProperties {
+    value?: string | number | null;
+    currency?: string | null;
+    conversion_id?: string | number | null;
+    email_address?: string | null;
+    phone_number?: string | null;
+    contents: ContentProperties[];
+}
+type TwqFns = ((event: 'event', eventId: string, data?: EventObjectProperties) => void) & ((event: 'config', id: string) => void) & ((event: string, ...params: any[]) => void);
+export interface XPixelApi {
+    twq: TwqFns & {
+        loaded: boolean;
+        version: string;
+        queue: any[];
+    };
+}
+declare global {
+    interface Window extends XPixelApi {
+    }
+}
+export declare const XPixelOptions: import("valibot").ObjectSchema<{
+    id: import("valibot").StringSchema<string>;
+    version: import("valibot").OptionalSchema<import("valibot").StringSchema<string>, undefined, string | undefined>;
+}, undefined, {
+    id: string;
+    version?: string | undefined;
+}>;
+export type XPixelInput = RegistryScriptInput<typeof XPixelOptions>;
+export declare function useScriptXPixel<T extends XPixelApi>(_options?: XPixelInput): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T> & Promise<T>;
+};
+export {};