@nuxt/scripts 1.0.0-beta.15 → 1.0.0-beta.17

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

@@ -1,14 +1,6 @@
 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>;
+import { MatomoAnalyticsOptions } from './schemas.js';
+export { MatomoAnalyticsOptions };
 export type MatomoAnalyticsInput = RegistryScriptInput<typeof MatomoAnalyticsOptions, false, false, false>;
 interface MatomoAnalyticsApi {
     _paq: unknown[];
@@ -18,4 +10,3 @@ declare global {
     }
 }
 export declare function useScriptMatomoAnalytics<T extends MatomoAnalyticsApi>(_options?: MatomoAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

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

@@ -1,18 +1,9 @@
-import { boolean, number, object, optional, string, union } from "#nuxt-scripts-validator";
 import { withBase, withHttps, withoutProtocol, withoutTrailingSlash } from "ufo";
 import { useScriptEventPage } from "../composables/useScriptEventPage.js";
 import { logger } from "../logger.js";
 import { useRegistryScript } from "../utils.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 { MatomoAnalyticsOptions } from "./schemas.js";
+export { MatomoAnalyticsOptions };
 export function useScriptMatomoAnalytics(_options) {
   return useRegistryScript("matomoAnalytics", (options) => {
     const normalizedCloudId = options?.cloudId ? withoutTrailingSlash(withoutProtocol(options.cloudId)) : void 0;

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

@@ -1,4 +1,5 @@
 import type { RegistryScriptInput } 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;
@@ -35,9 +36,6 @@ 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 { MetaPixelOptions };
 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 {};

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

@@ -1,8 +1,6 @@
-import { number, object, string, union } from "#nuxt-scripts-validator";
 import { useRegistryScript } from "../utils.js";
-export const MetaPixelOptions = object({
-  id: union([string(), number()])
-});
+import { MetaPixelOptions } from "./schemas.js";
+export { MetaPixelOptions };
 export function useScriptMetaPixel(_options) {
   return useRegistryScript("metaPixel", (options) => ({
     scriptInput: {

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", undefined>, import("valibot").LiteralSchema<"cdnjs", undefined>, import("valibot").LiteralSchema<"unpkg", undefined>], undefined>, undefined>;
-}, undefined>;
+import { NpmOptions } from './schemas.js';
+export { NpmOptions };
 export type NpmInput = RegistryScriptInput<typeof NpmOptions, true, true, false>;
 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,12 +1,7 @@
-import { literal, object, optional, string, union } from "#nuxt-scripts-validator";
 import { withBase } from "ufo";
 import { useRegistryScript } from "../utils.js";
-export const NpmOptions = object({
-  packageName: string(),
-  file: optional(string()),
-  version: optional(string()),
-  provider: optional(union([literal("jsdelivr"), literal("cdnjs"), literal("unpkg")]))
-});
+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 { RegistryScriptInput } from '#nuxt-scripts/types';
-import type { PayPalNamespace } from '@paypal/paypal-js';
+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 { array, boolean, object, optional, string, union } from "#nuxt-scripts-validator";
-import { withQuery } from "ufo";
 import { useRegistryScript } from "../utils.js";
-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;
-    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/posthog.d.ts

@@ -1,16 +1,14 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-import type { PostHog } from 'posthog-js';
-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 { 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;
 }

package/dist/runtime/registry/posthog.js

@@ -1,16 +1,7 @@
-import { any, boolean, literal, object, optional, record, string, union } from "#nuxt-scripts-validator";
 import { logger } from "../logger.js";
 import { useRegistryScript } from "../utils.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 { PostHogOptions } from "./schemas.js";
+export { PostHogOptions };
 export function useScriptPostHog(_options) {
   return useRegistryScript("posthog", (options) => {
     return {

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

@@ -1,4 +1,5 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { RedditPixelOptions } from './schemas.js';
 type RdtFns = ((event: 'init', id: string) => void) & ((event: 'track', eventName: string) => void);
 export interface RedditPixelApi {
     rdt: RdtFns & {
@@ -10,9 +11,6 @@ declare global {
     interface Window extends RedditPixelApi {
     }
 }
-export declare const RedditPixelOptions: import("valibot").ObjectSchema<{
-    readonly id: import("valibot").StringSchema<undefined>;
-}, undefined>;
+export { RedditPixelOptions };
 export type RedditPixelInput = RegistryScriptInput<typeof RedditPixelOptions, true, false, false>;
 export declare function useScriptRedditPixel<T extends RedditPixelApi>(_options?: RedditPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

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

@@ -1,8 +1,6 @@
-import { object, string } from "#nuxt-scripts-validator";
 import { useRegistryScript } from "../utils.js";
-export const RedditPixelOptions = object({
-  id: string()
-});
+import { RedditPixelOptions } from "./schemas.js";
+export { RedditPixelOptions };
 export function useScriptRedditPixel(_options) {
   return useRegistryScript("redditPixel", (options) => {
     return {

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

@@ -1,18 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const RybbitAnalyticsOptions: import("valibot").ObjectSchema<{
-    readonly siteId: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
-    readonly autoTrackPageview: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackSpa: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackQuery: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackOutbound: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackErrors: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly sessionReplay: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly webVitals: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly skipPatterns: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-    readonly maskPatterns: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-    readonly debounce: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
-    readonly apiKey: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-}, undefined>;
+import { RybbitAnalyticsOptions } from './schemas.js';
+export { RybbitAnalyticsOptions };
 export type RybbitAnalyticsInput = RegistryScriptInput<typeof RybbitAnalyticsOptions, false>;
 export interface RybbitAnalyticsApi {
     /**

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

@@ -1,20 +1,6 @@
-import { array, boolean, number, object, optional, string, union } from "#nuxt-scripts-validator";
 import { useRegistryScript } from "../utils.js";
-export const RybbitAnalyticsOptions = object({
-  siteId: union([string(), number()]),
-  // required
-  autoTrackPageview: optional(boolean()),
-  trackSpa: optional(boolean()),
-  trackQuery: optional(boolean()),
-  trackOutbound: optional(boolean()),
-  trackErrors: optional(boolean()),
-  sessionReplay: optional(boolean()),
-  webVitals: optional(boolean()),
-  skipPatterns: optional(array(string())),
-  maskPatterns: optional(array(string())),
-  debounce: optional(number()),
-  apiKey: optional(string())
-});
+import { RybbitAnalyticsOptions } from "./schemas.js";
+export { RybbitAnalyticsOptions };
 const RYBBIT_QUEUE_KEY = Symbol.for("nuxt-scripts.rybbit-queue");
 function getRybbitState() {
   if (!import.meta.client)