@nuxt/scripts 0.1.11 → 0.2.0

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

@@ -1,26 +1,34 @@
-import { type Input } from 'valibot';
-import type { NuxtUseScriptIntegrationOptions } from '#nuxt-scripts';
+import type { RegistryScriptInput } from '#nuxt-scripts';
 export declare const FathomAnalyticsOptions: import("valibot").ObjectSchema<{
     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>;
+    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>;
+    auto: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
+    canonical: import("valibot").OptionalSchema<import("valibot").BooleanSchema<boolean>, undefined, boolean | undefined>;
+    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 +38,4 @@ 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): any;

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

@@ -1,25 +1,30 @@
 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: 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())
+  spa: optional(union([literal("auto"), literal("history"), literal("hash")])),
+  auto: optional(boolean()),
+  canonical: optional(boolean()),
+  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: FathomAnalyticsOptions,
+    scriptOptions: {
+      use() {
+        return window.fathom;
+      }
+    }
+  }), _options);
 }

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

@@ -1 +1,19 @@
-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): any;
+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,21 @@
-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): any;

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,19 @@
-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): any;
+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,5 @@ 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): any;

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,4 @@ 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): any;

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,66 @@
+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): any;

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,22 @@
+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): any;
+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,14 @@
-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>>(key: string, _options: NpmInput): any;

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(key, _options) {
+  return registryScript(`${key}-npm`, (options) => ({
+    scriptInput: {
+      src: withBase(options.file || "", `https://unpkg.com/${options?.packageName}@${options.version || "latest"}`)
+    },
+    schema: NpmOptions
+  }), _options);
 }