@nuxt/scripts 1.0.0-beta.7 → 1.0.0-rc.10

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

@@ -1,18 +1,10 @@
-import type { InferInput } from '#nuxt-scripts-validator';
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const IntercomOptions: import("valibot").ObjectSchema<{
-    readonly app_id: import("valibot").StringSchema<undefined>;
-    readonly api_base: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"https://api-iam.intercom.io", undefined>, import("valibot").LiteralSchema<"https://api-iam.eu.intercom.io", undefined>, import("valibot").LiteralSchema<"https://api-iam.au.intercom.io", undefined>], undefined>, undefined>;
-    readonly name: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly email: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly user_id: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly alignment: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"left", undefined>, import("valibot").LiteralSchema<"right", undefined>], undefined>, undefined>;
-    readonly horizontal_padding: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
-    readonly vertical_padding: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
-}, undefined>;
-export type IntercomInput = RegistryScriptInput<typeof IntercomOptions, true, false, false>;
+import type { InferInput } from 'valibot';
+import { IntercomOptions } from './schemas.js';
+export { IntercomOptions };
+export type IntercomInput = RegistryScriptInput<typeof IntercomOptions, true, false>;
 export interface IntercomApi {
-    Intercom: ((event: 'boot', data?: InferInput<typeof IntercomOptions>) => void) & ((event: 'shutdown') => void) & ((event: 'update', options?: InferInput<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);
+    Intercom: ((event: 'boot', data?: InferInput<typeof IntercomOptions>) => void) & ((event: 'shutdown') => void) & ((event: 'update', options?: InferInput<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);
 }
 declare global {
     interface Window extends IntercomApi {

package/dist/runtime/registry/intercom.js

@@ -1,17 +1,7 @@
 import { joinURL } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { literal, number, object, optional, string, union } from "#nuxt-scripts-validator";
-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")])),
-  name: optional(string()),
-  email: optional(string()),
-  user_id: optional(string()),
-  // customizing the messenger
-  alignment: optional(union([literal("left"), literal("right")])),
-  horizontal_padding: optional(number()),
-  vertical_padding: optional(number())
-});
+import { IntercomOptions } from "./schemas.js";
+export { IntercomOptions };
 export function useScriptIntercom(_options) {
   return useRegistryScript("intercom", (options) => ({
     scriptInput: {

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

@@ -1,21 +1,18 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const MatomoAnalyticsOptions: import("valibot").ObjectSchema<{
-    readonly matomoUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly siteId: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>;
-    readonly cloudId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly trackerUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly trackPageView: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly enableLinkTracking: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly disableCookies: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly watch: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-}, undefined>;
-export type MatomoAnalyticsInput = RegistryScriptInput<typeof MatomoAnalyticsOptions, false, false, false>;
-interface MatomoAnalyticsApi {
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
+import { MatomoAnalyticsOptions } from './schemas.js';
+export { MatomoAnalyticsOptions };
+export type MatomoAnalyticsInput = RegistryScriptInput<typeof MatomoAnalyticsOptions, false, false>;
+export interface MatomoAnalyticsApi {
     _paq: unknown[];
 }
 declare global {
     interface Window extends MatomoAnalyticsApi {
     }
 }
-export declare function useScriptMatomoAnalytics<T extends MatomoAnalyticsApi>(_options?: MatomoAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};
+export interface MatomoConsent {
+    /** Push `setConsentGiven`. Requires `defaultConsent: 'required' | 'given'` at registration to have an effect. */
+    give: () => void;
+    /** Push `forgetConsentGiven`. Requires `defaultConsent: 'required' | 'given'` at registration to have an effect. */
+    forget: () => void;
+}
+export declare function useScriptMatomoAnalytics<T extends MatomoAnalyticsApi>(_options?: MatomoAnalyticsInput): UseScriptContext<T, MatomoConsent>;

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

@@ -1,20 +1,11 @@
 import { withBase, withHttps, withoutProtocol, withoutTrailingSlash } from "ufo";
-import { useRegistryScript } from "../utils.js";
 import { useScriptEventPage } from "../composables/useScriptEventPage.js";
-import { boolean, object, optional, string, number, union } from "#nuxt-scripts-validator";
 import { logger } from "../logger.js";
-export const MatomoAnalyticsOptions = object({
-  matomoUrl: optional(string()),
-  siteId: optional(union([string(), number()])),
-  cloudId: optional(string()),
-  trackerUrl: optional(string()),
-  trackPageView: optional(boolean()),
-  enableLinkTracking: optional(boolean()),
-  disableCookies: optional(boolean()),
-  watch: optional(boolean())
-});
+import { useRegistryScript } from "../utils.js";
+import { MatomoAnalyticsOptions } from "./schemas.js";
+export { MatomoAnalyticsOptions };
 export function useScriptMatomoAnalytics(_options) {
-  return useRegistryScript("matomoAnalytics", (options) => {
+  const instance = useRegistryScript("matomoAnalytics", (options) => {
     const normalizedCloudId = options?.cloudId ? withoutTrailingSlash(withoutProtocol(options.cloudId)) : void 0;
     const origin = options?.matomoUrl ? options.matomoUrl : `https://cdn.matomo.cloud/${normalizedCloudId}/`;
     const _paq = import.meta.client ? window._paq = window._paq || [] : [];
@@ -39,6 +30,12 @@ export function useScriptMatomoAnalytics(_options) {
         }
       },
       clientInit: import.meta.server ? void 0 : () => {
+        if (options?.defaultConsent === "required") {
+          _paq.push(["requireConsent"]);
+        } else if (options?.defaultConsent === "given") {
+          _paq.push(["requireConsent"]);
+          _paq.push(["setConsentGiven"]);
+        }
         if (options?.enableLinkTracking) {
           _paq.push(["enableLinkTracking"]);
         }
@@ -68,4 +65,25 @@ export function useScriptMatomoAnalytics(_options) {
       }
     };
   }, _options);
+  if (import.meta.client && !instance.consent) {
+    const requiresConsent = _options?.defaultConsent === "required" || _options?.defaultConsent === "given";
+    const warnIfUnsafe = import.meta.dev ? (method) => {
+      if (!requiresConsent) {
+        logger.warn(`matomo consent.${method}() is a no-op unless \`defaultConsent: 'required'\` or \`'given'\` is set at registration.`);
+      }
+    } : () => {
+    };
+    const paq = instance.proxy._paq;
+    instance.consent = {
+      give: () => {
+        warnIfUnsafe("give");
+        paq.push(["setConsentGiven"]);
+      },
+      forget: () => {
+        warnIfUnsafe("forget");
+        paq.push(["forgetConsentGiven"]);
+      }
+    };
+  }
+  return instance;
 }

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

@@ -1,4 +1,5 @@
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
+import { MetaPixelOptions } from './schemas.js';
 type StandardEvents = 'AddPaymentInfo' | 'AddToCart' | 'AddToWishlist' | 'CompleteRegistration' | 'Contact' | 'CustomizeProduct' | 'Donate' | 'FindLocation' | 'InitiateCheckout' | 'Lead' | 'Purchase' | 'Schedule' | 'Search' | 'StartTrial' | 'SubmitApplication' | 'Subscribe' | 'ViewContent';
 interface EventObjectProperties {
     content_category?: string;
@@ -14,7 +15,7 @@ interface EventObjectProperties {
     num_items?: number;
     predicted_ltv?: number;
     search_string?: string;
-    status?: 'completed' | 'updated' | 'viewed' | 'added_to_cart' | 'removed_from_cart' | string;
+    status?: 'completed' | 'updated' | 'viewed' | 'added_to_cart' | 'removed_from_cart' | (string & {});
     value?: number;
     [key: string]: any;
 }
@@ -35,9 +36,12 @@ declare global {
     interface Window extends MetaPixelApi {
     }
 }
-export declare const MetaPixelOptions: import("valibot").ObjectSchema<{
-    readonly id: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
-}, undefined>;
-export type MetaPixelInput = RegistryScriptInput<typeof MetaPixelOptions, true, false, false>;
-export declare function useScriptMetaPixel<T extends MetaPixelApi>(_options?: MetaPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};
+export { MetaPixelOptions };
+export type MetaPixelInput = RegistryScriptInput<typeof MetaPixelOptions, true, false>;
+export interface MetaPixelConsent {
+    /** Call `fbq('consent','grant')`. */
+    grant: () => void;
+    /** Call `fbq('consent','revoke')`. */
+    revoke: () => void;
+}
+export declare function useScriptMetaPixel<T extends MetaPixelApi>(_options?: MetaPixelInput): UseScriptContext<T, MetaPixelConsent>;

package/dist/runtime/registry/meta-pixel.js

@@ -1,10 +1,8 @@
 import { useRegistryScript } from "../utils.js";
-import { number, object, string, union } from "#nuxt-scripts-validator";
-export const MetaPixelOptions = object({
-  id: union([string(), number()])
-});
+import { MetaPixelOptions } from "./schemas.js";
+export { MetaPixelOptions };
 export function useScriptMetaPixel(_options) {
-  return useRegistryScript("metaPixel", (options) => ({
+  const instance = useRegistryScript("metaPixel", (options) => ({
     scriptInput: {
       src: "https://connect.facebook.net/en_US/fbevents.js",
       crossorigin: false
@@ -29,8 +27,17 @@ export function useScriptMetaPixel(_options) {
       fbq.loaded = true;
       fbq.version = "2.0";
       fbq.queue = [];
+      if (options?.defaultConsent)
+        fbq("consent", options.defaultConsent === "granted" ? "grant" : "revoke");
       fbq("init", options?.id);
       fbq("track", "PageView");
     }
   }), _options);
+  if (import.meta.client && !instance.consent) {
+    instance.consent = {
+      grant: () => instance.proxy.fbq("consent", "grant"),
+      revoke: () => instance.proxy.fbq("consent", "revoke")
+    };
+  }
+  return instance;
 }

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

@@ -0,0 +1,32 @@
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
+import { MixpanelAnalyticsOptions } from './schemas.js';
+export { MixpanelAnalyticsOptions };
+export type MixpanelAnalyticsInput = RegistryScriptInput<typeof MixpanelAnalyticsOptions>;
+export interface MixpanelAnalyticsApi {
+    mixpanel: {
+        track: (event: string, properties?: Record<string, any>) => void;
+        identify: (distinctId: string) => void;
+        reset: () => void;
+        people: {
+            set: (properties: Record<string, any>) => void;
+        };
+        register: (properties: Record<string, any>) => void;
+        init: (token: string, config?: Record<string, any>) => void;
+        /** Opt the user in to tracking. Available after the real SDK loads. */
+        opt_in_tracking?: () => void;
+        /** Opt the user out of tracking. Available after the real SDK loads. */
+        opt_out_tracking?: () => void;
+    };
+}
+declare global {
+    interface Window {
+        mixpanel: MixpanelAnalyticsApi['mixpanel'];
+    }
+}
+export interface MixpanelConsent {
+    /** Call `mixpanel.opt_in_tracking()`. */
+    optIn: () => void;
+    /** Call `mixpanel.opt_out_tracking()`. For boot-time opt-out, use `defaultConsent: 'opt-out'` instead. */
+    optOut: () => void;
+}
+export declare function useScriptMixpanelAnalytics<T extends MixpanelAnalyticsApi>(_options?: MixpanelAnalyticsInput): UseScriptContext<T, MixpanelConsent>;

package/dist/runtime/registry/mixpanel-analytics.js

@@ -0,0 +1,58 @@
+import { useRegistryScript } from "../utils.js";
+import { MixpanelAnalyticsOptions } from "./schemas.js";
+export { MixpanelAnalyticsOptions };
+const methods = ["track", "identify", "reset", "register", "opt_in_tracking", "opt_out_tracking"];
+const peopleMethods = ["set"];
+export function useScriptMixpanelAnalytics(_options) {
+  const instance = useRegistryScript("mixpanelAnalytics", (options) => {
+    return {
+      scriptInput: {
+        src: "https://cdn.mxpnl.com/libs/mixpanel-2-latest.min.js"
+      },
+      schema: import.meta.dev ? MixpanelAnalyticsOptions : void 0,
+      scriptOptions: {
+        use() {
+          return {
+            mixpanel: window.mixpanel
+          };
+        }
+      },
+      clientInit: import.meta.server ? void 0 : () => {
+        const mp = window.mixpanel = window.mixpanel || [];
+        if (!mp.__SV) {
+          mp.__SV = 1.2;
+          mp._i = mp._i || [];
+          mp.init = (token, config, name = "mixpanel") => {
+            const target = name === "mixpanel" ? mp : mp[name] = [];
+            target.people = target.people || [];
+            for (const method of methods) {
+              target[method] = (...args) => {
+                target.push([method, ...args]);
+              };
+            }
+            for (const method of peopleMethods) {
+              target.people[method] = (...args) => {
+                target.push([`people.${method}`, ...args]);
+              };
+            }
+            mp._i.push([token, config, name]);
+          };
+        }
+        if (options?.token) {
+          const optOutByDefault = options?.defaultConsent === "opt-out";
+          mp.init(options.token, optOutByDefault ? { opt_out_tracking_by_default: true } : void 0);
+          if (options?.defaultConsent === "opt-in") {
+            mp.opt_in_tracking?.();
+          }
+        }
+      }
+    };
+  }, _options);
+  if (import.meta.client && !instance.consent) {
+    instance.consent = {
+      optIn: () => instance.proxy.mixpanel.opt_in_tracking?.(),
+      optOut: () => instance.proxy.mixpanel.opt_out_tracking?.()
+    };
+  }
+  return instance;
+}

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

@@ -1,9 +1,5 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const NpmOptions: import("valibot").ObjectSchema<{
-    readonly packageName: import("valibot").StringSchema<undefined>;
-    readonly file: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly version: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly provider: import("valibot").OptionalSchema<import("valibot").UnionSchema<import("valibot").LiteralSchema<"jsdelivr" | "cdnjs" | "unpkg", undefined>[], undefined>, undefined>;
-}, undefined>;
-export type NpmInput = RegistryScriptInput<typeof NpmOptions, true, true, false>;
+import { NpmOptions } from './schemas.js';
+export { NpmOptions };
+export type NpmInput = RegistryScriptInput<typeof NpmOptions, true, true>;
 export declare function useScriptNpm<T extends Record<string | symbol, any>>(_options: NpmInput): import("#nuxt-scripts/types").UseScriptContext<T>;

package/dist/runtime/registry/npm.js

@@ -1,14 +1,7 @@
 import { withBase } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { object, optional, string, union, literal } from "#nuxt-scripts-validator";
-const PROVIDERS = ["jsdelivr", "cdnjs", "unpkg"];
-const providerValidator = union(PROVIDERS.map((provider) => literal(provider)));
-export const NpmOptions = object({
-  packageName: string(),
-  file: optional(string()),
-  version: optional(string()),
-  provider: optional(providerValidator)
-});
+import { NpmOptions } from "./schemas.js";
+export { NpmOptions };
 export function useScriptNpm(_options) {
   return useRegistryScript(`${_options.packageName}-npm`, (options) => {
     const baseUrl = getProviderBaseUrl(options.provider, options.packageName, options.version);

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

@@ -1,34 +1,13 @@
-import type { PayPalNamespace } from '@paypal/paypal-js';
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { PayPalV6Namespace } from '@paypal/paypal-js/sdk-v6';
+import { PayPalOptions } from './schemas.js';
+export { PayPalOptions };
 export interface PayPalApi {
-    paypal: PayPalNamespace;
+    paypal: PayPalV6Namespace;
 }
 declare global {
     interface Window extends PayPalApi {
     }
 }
-export declare const PayPalOptions: import("valibot").ObjectSchema<{
-    readonly clientId: import("valibot").StringSchema<undefined>;
-    readonly buyerCountry: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly commit: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly components: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
-    readonly currency: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly debug: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").BooleanSchema<undefined>], undefined>, undefined>;
-    readonly disableFunding: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
-    readonly enableFunding: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
-    readonly integrationDate: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly intent: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly locale: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /**
-     * loadScript() supports an array for merchantId, even though
-     * merchant-id technically may not contain multiple values.
-     * For an array with a length of > 1 it automatically sets
-     * merchantId to "*" and moves the actual values to dataMerchantId
-     */
-    readonly merchantId: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>], undefined>, undefined>;
-    readonly partnerAttributionId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly vault: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").BooleanSchema<undefined>], undefined>, undefined>;
-    readonly sandbox: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-}, undefined>;
 export type PayPalInput = RegistryScriptInput<typeof PayPalOptions>;
 export declare function useScriptPayPal<T extends PayPalApi>(_options?: PayPalInput): import("#nuxt-scripts/types").UseScriptContext<T>;

package/dist/runtime/registry/paypal.js

@@ -1,79 +1,16 @@
-import { withQuery } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { object, string, optional, array, union, boolean } from "#nuxt-scripts-validator";
-export const PayPalOptions = object({
-  clientId: string(),
-  buyerCountry: optional(string()),
-  commit: optional(string()),
-  components: optional(union([string(), array(string())])),
-  currency: optional(string()),
-  debug: optional(union([string(), boolean()])),
-  disableFunding: optional(union([string(), array(string())])),
-  enableFunding: optional(union([string(), array(string())])),
-  integrationDate: optional(string()),
-  intent: optional(string()),
-  locale: optional(string()),
-  /**
-   * loadScript() supports an array for merchantId, even though
-   * merchant-id technically may not contain multiple values.
-   * For an array with a length of > 1 it automatically sets
-   * merchantId to "*" and moves the actual values to dataMerchantId
-   */
-  merchantId: optional(union([string(), array(string())])),
-  partnerAttributionId: optional(string()),
-  vault: optional(union([string(), boolean()])),
-  // own props
-  sandbox: optional(boolean())
-});
+import { PayPalOptions } from "./schemas.js";
+export { PayPalOptions };
 export function useScriptPayPal(_options) {
   return useRegistryScript("paypal", (options) => {
-    let dataMerchantId = void 0;
-    if (Array.isArray(options?.merchantId) && options?.merchantId.length > 1) {
-      dataMerchantId = JSON.stringify(options.merchantId);
-      options.merchantId = "*";
-    }
-    if (Array.isArray(options?.components)) {
-      options.components = options.components.join(",");
-    }
-    if (Array.isArray(options?.disableFunding)) {
-      options.disableFunding = options.disableFunding.join(",");
-    }
-    if (Array.isArray(options?.enableFunding)) {
-      options.enableFunding = options.enableFunding.join(",");
-    }
     if (options?.sandbox === void 0) {
       options.sandbox = import.meta.dev;
     }
-    let components = ["buttons", "messages", "marks", "card-fields", "funding-eligibility"].join(",");
-    if (options.components) {
-      if (Array.isArray(options.components)) {
-        components = options.components.join(",");
-      } else {
-        components = options.components;
-      }
-    }
     return {
       scriptInput: {
-        "src": withQuery(options.sandbox ? "https://www.sandbox.paypal.com/sdk/js" : "https://www.paypal.com/sdk/js", {
-          "client-id": options.clientId,
-          "buyer-country": options.buyerCountry,
-          "commit": options.commit,
-          "components": components,
-          "currency": options.currency,
-          "debug": options.debug,
-          "disable-funding": options.disableFunding,
-          "enable-funding": options.enableFunding,
-          "integration-date": options.integrationDate,
-          "intent": options.intent,
-          "locale": options.locale,
-          "vault": options.vault
-        }),
-        "data-merchant-id": dataMerchantId,
-        "data-partner-attribution-id": options.partnerAttributionId
-        // TODO: maybe nuxt specific default
+        src: options.sandbox ? "https://www.sandbox.paypal.com/web-sdk/v6/core" : "https://www.paypal.com/web-sdk/v6/core"
       },
       schema: import.meta.dev ? PayPalOptions : void 0,
-      // trigger: 'client',
       scriptOptions: {
         use() {
           return {

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

@@ -1,6 +1,6 @@
-import { useRegistryScript } from "../utils.js";
-import { any, array, boolean, literal, object, optional, record, string, union } from "#nuxt-scripts-validator";
+import { any, array, boolean, literal, object, optional, record, string, union } from "valibot";
 import { logger } from "../logger.js";
+import { useRegistryScript } from "../utils.js";
 const extensions = [
   literal("hash"),
   literal("outbound-links"),
@@ -55,18 +55,23 @@ export function useScriptPlausibleAnalytics(_options) {
       scriptSrc = "https://plausible.io/js/script.js";
     }
     const initOptions = {};
-    if (options?.customProperties) initOptions.customProperties = options.customProperties;
-    if (options?.endpoint) initOptions.endpoint = options.endpoint;
-    if (options?.fileDownloads) initOptions.fileDownloads = options.fileDownloads;
-    if (options?.hashBasedRouting !== void 0) initOptions.hashBasedRouting = options.hashBasedRouting;
-    if (options?.autoCapturePageviews !== void 0) initOptions.autoCapturePageviews = options.autoCapturePageviews;
-    if (options?.captureOnLocalhost !== void 0) initOptions.captureOnLocalhost = options.captureOnLocalhost;
-    const scriptInput = !useNewScript && options?.domain ? {
-      "src": scriptSrc,
-      "data-domain": options.domain
-    } : {
-      src: scriptSrc
-    };
+    if (options?.customProperties)
+      initOptions.customProperties = options.customProperties;
+    if (options?.endpoint)
+      initOptions.endpoint = options.endpoint;
+    if (options?.fileDownloads)
+      initOptions.fileDownloads = options.fileDownloads;
+    if (options?.hashBasedRouting !== void 0)
+      initOptions.hashBasedRouting = options.hashBasedRouting;
+    if (options?.autoCapturePageviews !== void 0)
+      initOptions.autoCapturePageviews = options.autoCapturePageviews;
+    if (options?.captureOnLocalhost !== void 0)
+      initOptions.captureOnLocalhost = options.captureOnLocalhost;
+    const scriptInput = { src: scriptSrc };
+    if (!useNewScript && options?.domain)
+      scriptInput["data-domain"] = options.domain;
+    if (!useNewScript && options?.endpoint)
+      scriptInput["data-api"] = options.endpoint;
     return {
       scriptInput,
       schema: import.meta.dev ? PlausibleAnalyticsOptionsSchema : void 0,

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

@@ -1,16 +1,14 @@
-import type { PostHog } from 'posthog-js';
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const PostHogOptions: import("valibot").ObjectSchema<{
-    readonly apiKey: import("valibot").StringSchema<undefined>;
-    readonly region: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"us", undefined>, import("valibot").LiteralSchema<"eu", undefined>], undefined>, undefined>;
-    readonly apiHost: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly autocapture: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly capturePageview: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").BooleanSchema<undefined>, import("valibot").LiteralSchema<"history_change", undefined>], undefined>, undefined>;
-    readonly capturePageleave: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly disableSessionRecording: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly config: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").AnySchema, undefined>, undefined>;
-}, undefined>;
-export type PostHogInput = RegistryScriptInput<typeof PostHogOptions, false, true>;
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
+import type { PostHog, PostHogConfig } from 'posthog-js';
+import { PostHogOptions } from './schemas.js';
+export { PostHogOptions };
+export type PostHogInput = Omit<RegistryScriptInput<typeof PostHogOptions, false, true>, 'config'> & {
+    /**
+     * Additional PostHog configuration options passed directly to `posthog.init()`.
+     * @see https://posthog.com/docs/libraries/js/config
+     */
+    config?: Partial<PostHogConfig>;
+};
 export interface PostHogApi {
     posthog: PostHog;
 }
@@ -24,4 +22,10 @@ declare global {
         }[];
     }
 }
-export declare function useScriptPostHog<T extends PostHogApi>(_options?: PostHogInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export interface PostHogConsent {
+    /** Call `posthog.opt_in_capturing()`. */
+    optIn: () => void;
+    /** Call `posthog.opt_out_capturing()`. For boot-time opt-out, use `defaultConsent: 'opt-out'` instead. */
+    optOut: () => void;
+}
+export declare function useScriptPostHog<T extends PostHogApi>(_options?: PostHogInput): UseScriptContext<T, PostHogConsent>;

package/dist/runtime/registry/posthog.js

@@ -1,18 +1,9 @@
-import { any, record, string, object, optional, boolean, union, literal } from "#nuxt-scripts-validator";
-import { useRegistryScript } from "../utils.js";
 import { logger } from "../logger.js";
-export const PostHogOptions = object({
-  apiKey: string(),
-  region: optional(union([literal("us"), literal("eu")])),
-  apiHost: optional(string()),
-  autocapture: optional(boolean()),
-  capturePageview: optional(union([boolean(), literal("history_change")])),
-  capturePageleave: optional(boolean()),
-  disableSessionRecording: optional(boolean()),
-  config: optional(record(string(), any()))
-});
+import { useRegistryScript } from "../utils.js";
+import { PostHogOptions } from "./schemas.js";
+export { PostHogOptions };
 export function useScriptPostHog(_options) {
-  return useRegistryScript("posthog", (options) => {
+  const instance = useRegistryScript("posthog", (options) => {
     return {
       scriptMode: "npm",
       // Use NPM mode - no external script tag
@@ -64,13 +55,17 @@ export function useScriptPostHog(_options) {
             config.capture_pageleave = options.capturePageleave;
           if (typeof options?.disableSessionRecording === "boolean")
             config.disable_session_recording = options.disableSessionRecording;
-          const instance = posthog.init(options.apiKey, config);
-          if (!instance) {
+          if (options?.defaultConsent === "opt-out")
+            config.opt_out_capturing_by_default = true;
+          const instance2 = posthog.init(options.apiKey, config);
+          if (!instance2) {
             logger.error("PostHog init returned undefined - initialization failed");
             delete window._posthogQueue;
             return void 0;
           }
-          window.posthog = instance;
+          window.posthog = instance2;
+          if (options?.defaultConsent === "opt-in")
+            instance2.opt_in_capturing?.();
           if (window._posthogQueue && window._posthogQueue.length > 0) {
             window._posthogQueue.forEach((q) => window.posthog[q.prop]?.(...q.args));
             delete window._posthogQueue;
@@ -85,4 +80,11 @@ export function useScriptPostHog(_options) {
       }
     };
   }, _options);
+  if (import.meta.client && !instance.consent) {
+    instance.consent = {
+      optIn: () => instance.proxy.posthog?.opt_in_capturing?.(),
+      optOut: () => instance.proxy.posthog?.opt_out_capturing?.()
+    };
+  }
+  return instance;
 }

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

@@ -1,5 +1,7 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-type RdtFns = ((event: 'init', id: string) => void) & ((event: 'track', eventName: string) => void);
+import { RedditPixelOptions } from './schemas.js';
+type StandardEvents = 'PageVisit' | 'ViewContent' | 'Search' | 'AddToCart' | 'AddToWishlist' | 'Purchase' | 'Lead' | 'SignUp';
+type RdtFns = ((event: 'init', id: string) => void) & ((event: 'track', eventName: StandardEvents | (string & {}), properties?: Record<string, any>) => void);
 export interface RedditPixelApi {
     rdt: RdtFns & {
         sendEvent: (rdt: RedditPixelApi['rdt'], args: unknown[]) => void;
@@ -10,9 +12,6 @@ declare global {
     interface Window extends RedditPixelApi {
     }
 }
-export declare const RedditPixelOptions: import("valibot").ObjectSchema<{
-    readonly id: import("valibot").StringSchema<undefined>;
-}, undefined>;
-export type RedditPixelInput = RegistryScriptInput<typeof RedditPixelOptions, true, false, false>;
+export { RedditPixelOptions };
+export type RedditPixelInput = RegistryScriptInput<typeof RedditPixelOptions, true, false>;
 export declare function useScriptRedditPixel<T extends RedditPixelApi>(_options?: RedditPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};