@nuxt/scripts 0.1.5 → 0.1.7

package/dist/module.mjs

@@ -1,9 +1,9 @@
-import { useNuxt, useLogger, addDevServerHandler, createResolver, addTemplate, defineNuxtModule, addImportsDir, addImports, addPluginTemplate, addPlugin, addBuildPlugin } from '@nuxt/kit';
+import { useNuxt, useLogger, addDevServerHandler, createResolver, addTemplate, defineNuxtModule, addImportsDir, addImports, addPlugin, addBuildPlugin } from '@nuxt/kit';
 import { readPackageJSON } from 'pkg-types';
+import { parseURL, parseQuery, joinURL, hasProtocol, withQuery, withBase } from 'ufo';
 import { existsSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
 import { createUnplugin } from 'unplugin';
-import { parseURL, parseQuery, joinURL, hasProtocol } from 'ufo';
 import MagicString from 'magic-string';
 import { walk } from 'estree-walker';
 import fsp from 'node:fs/promises';
@@ -81,42 +81,80 @@ function NuxtScriptAssetBundlerTransformer(options) {
         const s = new MagicString(code);
         walk(ast, {
           enter(_node) {
-            if (_node.type === "CallExpression" && _node.callee.type === "Identifier" && _node.callee?.name === "useScript") {
+            if (_node.type === "CallExpression" && _node.callee.type === "Identifier" && _node.callee?.name.startsWith("useScript")) {
+              const fnName = _node.callee?.name;
               const node = _node;
               let scriptKey;
-              let scriptNode;
-              if (node.arguments[0].type === "Literal") {
-                scriptNode = node.arguments[0];
-                scriptKey = scriptNode.value;
-              } else if (node.arguments[0].type === "ObjectExpression") {
-                const srcProperty = node.arguments[0].properties.find(
-                  (p) => p.key?.name === "src" || p.key?.value === "src"
-                );
-                const keyProperty = node.arguments[0].properties.find(
-                  (p) => p.key?.name === "key" || p.key?.value === "key"
-                );
-                scriptKey = keyProperty?.value?.value || srcProperty?.value;
-                scriptNode = srcProperty?.value;
+              let scriptSrcNode;
+              let src;
+              if (fnName === "useScript") {
+                if (node.arguments[0].type === "Literal") {
+                  scriptSrcNode = node.arguments[0];
+                  scriptKey = scriptSrcNode.value;
+                } else if (node.arguments[0].type === "ObjectExpression") {
+                  const srcProperty = node.arguments[0].properties.find(
+                    (p) => p.key?.name === "src" || p.key?.value === "src"
+                  );
+                  const keyProperty = node.arguments[0].properties.find(
+                    (p) => p.key?.name === "key" || p.key?.value === "key"
+                  );
+                  scriptKey = keyProperty?.value?.value || srcProperty?.value;
+                  scriptSrcNode = srcProperty?.value;
+                }
+              } else {
+                const registryNode = options.registry?.find((i) => i.name === fnName);
+                if (!registryNode) {
+                  console.error(`[Nuxt Scripts] Integration ${fnName} not found in registry`);
+                  return;
+                }
+                if (!registryNode.transform && !registryNode.src)
+                  return;
+                const optionsNode = node.arguments[0];
+                if (optionsNode?.type === "ObjectExpression") {
+                  const fnArg0 = {};
+                  for (const prop of optionsNode.properties) {
+                    if (prop.value.type === "Literal")
+                      fnArg0[prop.key.name] = prop.value.value;
+                  }
+                  const srcProperty = node.arguments[0].properties.find(
+                    (p) => p.key?.name === "src" || p.key?.value === "src"
+                  );
+                  if (srcProperty?.value?.value)
+                    scriptSrcNode = srcProperty.value;
+                  else
+                    src = registryNode.src || registryNode.transform?.(fnArg0);
+                  scriptKey = registryNode.key;
+                }
               }
-              if (scriptNode) {
-                const src = scriptNode.value;
+              if (scriptSrcNode || src) {
+                src = src || scriptSrcNode.value;
                 if (src) {
-                  let hasAssetStrategy = false;
+                  let canBundle = options.defaultBundle;
                   if (node.arguments[1]?.type === "ObjectExpression") {
                     const assetStrategyProperty = node.arguments[1]?.properties.find(
                       (p) => p.key?.name === "assetStrategy" || p.key?.value === "assetStrategy"
                     );
                     if (assetStrategyProperty) {
-                      if (assetStrategyProperty?.value?.value !== "bundle")
+                      if (assetStrategyProperty?.value?.value !== "bundle") {
+                        canBundle = false;
                         return;
-                      s.remove(assetStrategyProperty.start, assetStrategyProperty.end + 1);
-                      hasAssetStrategy = true;
+                      }
+                      if (node.arguments[1]?.properties.length === 1)
+                        s.remove(node.arguments[1].start, node.arguments[1].end);
+                      else
+                        s.remove(assetStrategyProperty.start, assetStrategyProperty.end);
+                      canBundle = true;
                     }
                   }
-                  hasAssetStrategy = hasAssetStrategy || options.overrides?.[scriptKey]?.assetStrategy === "bundle";
-                  if (hasAssetStrategy) {
+                  canBundle = canBundle || options.overrides?.[scriptKey]?.assetStrategy === "bundle";
+                  if (canBundle) {
                     const newSrc = options.resolveScript(src);
-                    s.overwrite(scriptNode.start, scriptNode.end, `'${newSrc}'`);
+                    if (scriptSrcNode) {
+                      s.overwrite(scriptSrcNode.start, scriptSrcNode.end, `'${newSrc}'`);
+                    } else {
+                      const lastProperty = node.arguments[0].properties[node.arguments[0].properties.length - 1];
+                      s.appendRight(lastProperty.end, `, src: '${newSrc}'`);
+                    }
                   }
                 }
               }
@@ -234,7 +272,7 @@ function extendTypes(module, template) {
   const nuxt = useNuxt();
   const { resolve } = createResolver(import.meta.url);
   addTemplate({
-    filename: `module/${module}.d.ts`,
+    filename: `modules/${module}.d.ts`,
     getContents: async () => {
       const typesPath = relative(resolve(nuxt.options.rootDir, nuxt.options.buildDir, "module"), resolve("runtime/types"));
       const s = await template({ typesPath });
@@ -259,6 +297,11 @@ const module = defineNuxtModule({
     }
   },
   defaults: {
+    defaultScriptOptions: {
+      assetStrategy: "bundle",
+      // Not supported on all scripts, only if the src is static, runtime fallback?
+      trigger: "onNuxtReady"
+    },
     enabled: true,
     debug: false
   },
@@ -271,99 +314,133 @@ const module = defineNuxtModule({
     }
     nuxt.options.alias["#nuxt-scripts"] = resolve("./runtime/types");
     nuxt.options.runtimeConfig["nuxt-scripts"] = { version };
+    nuxt.options.runtimeConfig.public["nuxt-scripts"] = { defaultScriptOptions: config.defaultScriptOptions };
     addImportsDir([
       resolve("./runtime/composables")
     ]);
-    const registry = [
-      {
-        name: "useScriptCloudflareTurnstile",
-        from: resolve("./runtime/registry/cloudflare-turnstile")
-      },
-      {
-        name: "useScriptCloudflareWebAnalytics",
-        from: resolve("./runtime/registry/cloudflare-web-analytics")
-      },
-      {
-        name: "useScriptConfetti",
-        from: resolve("./runtime/registry/confetti")
-      },
-      {
-        name: "useScriptFacebookPixel",
-        from: resolve("./runtime/registry/facebook-pixel")
-      },
-      {
-        name: "useScriptFathomAnalytics",
-        from: resolve("./runtime/registry/fathom-analytics")
-      },
-      {
-        name: "useScriptGoogleAnalytics",
-        from: resolve("./runtime/registry/google-analytics")
-      },
-      {
-        name: "useScriptGoogleTagManager",
-        from: resolve("./runtime/registry/google-tag-manager")
-      },
-      {
-        name: "useScriptHotjar",
-        from: resolve("./runtime/registry/hotjar")
-      },
-      {
-        name: "useScriptIntercom",
-        from: resolve("./runtime/registry/intercom")
-      },
-      {
-        name: "useScriptSegment",
-        from: resolve("./runtime/registry/segment")
-      }
-    ].map((i) => {
-      i.priority = -1;
-      return i;
-    });
-    addImports(registry);
-    const hasRegister = Object.keys(config.register || {}).length > 0;
-    if (hasRegister) {
-      addPluginTemplate({
-        filename: "third-party.mjs",
-        write: true,
-        getContents() {
-          const imports = ['import { defineNuxtPlugin } from "#imports";'];
-          const inits = [];
-          for (const [k, c] of Object.entries(config.register || {})) {
-            const importPath = resolve(`./runtime/composables/${k}`);
-            const exportName = k.substring(0, 1).toUpperCase() + k.substring(1);
-            imports.unshift(`import { ${exportName} } from "${importPath}";`);
-            inits.push(`${exportName}(${JSON.stringify(c)});`);
+    nuxt.hooks.hook("modules:done", async () => {
+      const registry = [
+        {
+          name: "useScriptCloudflareTurnstile",
+          key: "cloudflareTurnstile",
+          from: resolve("./runtime/registry/cloudflare-turnstile")
+        },
+        {
+          name: "useScriptCloudflareWebAnalytics",
+          key: "cloudflareWebAnalytics",
+          from: resolve("./runtime/registry/cloudflare-web-analytics"),
+          src: "https://static.cloudflareinsights.com/beacon.min.js"
+        },
+        {
+          name: "useScriptConfetti",
+          key: "confetti",
+          from: resolve("./runtime/registry/confetti"),
+          src: "https://unpkg.com/js-confetti@latest/dist/js-confetti.browser.js"
+        },
+        {
+          name: "useScriptFacebookPixel",
+          key: "facebookPixel",
+          from: resolve("./runtime/registry/facebook-pixel"),
+          src: "https://connect.facebook.net/en_US/fbevents.js"
+        },
+        {
+          name: "useScriptFathomAnalytics",
+          key: "fathomAnalytics",
+          from: resolve("./runtime/registry/fathom-analytics"),
+          src: "https://cdn.usefathom.com/script.js"
+        },
+        {
+          name: "useScriptGoogleAnalytics",
+          key: "googleAnalytics",
+          from: resolve("./runtime/registry/google-analytics")
+        },
+        {
+          name: "useScriptGoogleTagManager",
+          key: "googleTagmanager",
+          from: resolve("./runtime/registry/google-tag-manager")
+        },
+        {
+          name: "useScriptHotjar",
+          from: resolve("./runtime/registry/hotjar"),
+          key: "hotjar",
+          transform(options) {
+            return withQuery(`https://static.hotjar.com/c/hotjar-${options?.id || ""}.js`, {
+              sv: options?.sv || "6"
+            });
+          }
+        },
+        {
+          name: "useScriptIntercom",
+          from: resolve("./runtime/registry/intercom"),
+          key: "intercom",
+          transform(options) {
+            return joinURL(`https://widget.intercom.io/widget`, options?.app_id || "");
+          }
+        },
+        {
+          name: "useScriptSegment",
+          from: resolve("./runtime/registry/segment"),
+          key: "segment",
+          transform(options) {
+            return joinURL("https://cdn.segment.com/analytics.js/v1", options?.writeKey || "", "analytics.min.js");
+          }
+        },
+        {
+          name: "useScriptNpm",
+          // key is based on package name
+          from: resolve("./runtime/registry/npm"),
+          transform(options) {
+            return withBase(options?.file || "", `https://unpkg.com/${options?.packageName || ""}@${options?.version || "latest"}`);
           }
-          return [
-            imports.join("\n"),
-            "",
-            "export default defineNuxtPlugin({",
-            '  name: "nuxt-third-party",',
-            "  setup() {",
-            inits.map((i) => `    ${i}`).join("\n"),
-            "  }",
-            "})"
-          ].join("\n");
         }
+      ].map((i) => {
+        i.priority = -1;
+        return i;
       });
-    }
-    if (config.globals?.length) {
-      const template = addTemplate({
-        filename: "modules/nuxt-scripts/plugin.client.mjs",
-        getContents() {
-          return `import { defineNuxtPlugin, useScript } from '#imports'
+      addImports(registry);
+      await nuxt.hooks.callHook("scripts:registry", registry);
+      if (config.globals?.length || Object.keys(config.register || {}).length) {
+        const template = addTemplate({
+          filename: `modules/${name}.mjs`,
+          write: true,
+          getContents() {
+            const imports = ["useScript", "defineNuxtPlugin"];
+            const inits = [];
+            for (const [k, c] of Object.entries(config.register || {})) {
+              const importDefinition = registry.find((i) => i.name === `useScript${k.substring(0, 1).toUpperCase() + k.substring(1)}`);
+              if (importDefinition) {
+                imports.unshift(importDefinition.name);
+                inits.push(`${importDefinition.name}(${JSON.stringify(c)});`);
+              }
+            }
+            return `import { ${imports.join(", ")} } from '#imports'
 export default defineNuxtPlugin({
+  name: "${name}:init",
   setup() {
-${config.globals?.map((g) => !Array.isArray(g) ? `    useScript("${g.toString()}")` : g.length === 2 ? `    useScript(${JSON.stringify(g[0])}, ${JSON.stringify(g[1])} })` : `    useScript(${JSON.stringify(g[0])})`).join("\n")}
+${(config.globals || []).map((g) => !Array.isArray(g) ? `    useScript("${g.toString()}")` : g.length === 2 ? `    useScript(${JSON.stringify(g[0])}, ${JSON.stringify(g[1])} })` : `    useScript(${JSON.stringify(g[0])})`).join("\n")}
+    ${inits.join("\n    ")}
   }
 })`;
+          }
+        });
+        addPlugin({
+          src: template.dst
+        });
+      }
+      const scriptMap = /* @__PURE__ */ new Map();
+      const { normalizeScriptData } = setupPublicAssetStrategy(config.assets);
+      addBuildPlugin(NuxtScriptAssetBundlerTransformer({
+        registry,
+        defaultBundle: config.defaultScriptOptions?.assetStrategy === "bundle",
+        resolveScript(src) {
+          if (scriptMap.has(src))
+            return scriptMap.get(src);
+          const url = normalizeScriptData(src);
+          scriptMap.set(src, url);
+          return url;
         }
-      });
-      addPlugin({
-        src: template.dst,
-        mode: "client"
-      });
-    }
+      }));
+    });
     extendTypes(name, async () => {
       return `
 declare module '#app' {
@@ -373,18 +450,6 @@ declare module '#app' {
 }
 `;
     });
-    const scriptMap = /* @__PURE__ */ new Map();
-    const { normalizeScriptData } = setupPublicAssetStrategy(config.assets);
-    addBuildPlugin(NuxtScriptAssetBundlerTransformer({
-      overrides: config.overrides,
-      resolveScript(src) {
-        if (scriptMap.has(src))
-          return scriptMap.get(src);
-        const url = normalizeScriptData(src);
-        scriptMap.set(src, url);
-        return url;
-      }
-    }));
     if (nuxt.options.dev)
       setupDevToolsUI(config, resolve);
   }

package/dist/runtime/composables/useScript.mjs

@@ -1,9 +1,10 @@
 import { useScript as _useScript, injectHead } from "@unhead/vue";
 import { hashCode } from "@unhead/shared";
-import { onNuxtReady, useNuxtApp } from "#imports";
+import { defu } from "defu";
+import { onNuxtReady, useNuxtApp, useRuntimeConfig } from "#imports";
 export function useScript(input, options) {
   input = typeof input === "string" ? { src: input } : input;
-  options = options || {};
+  options = defu(options, useRuntimeConfig().public["nuxt-scripts"]?.defaultScriptOptions);
   if (options.trigger === "onNuxtReady")
     options.trigger = new Promise((resolve) => onNuxtReady(resolve));
   const nuxtApp = useNuxtApp();

package/dist/runtime/composables/validateScriptInputSchema.d.ts

@@ -1,7 +1,2 @@
-import { type Input, type ObjectSchema } from 'valibot';
-/**
- * injectScript
- *
- * Checks if a script with the 'key' value exists in head.
- */
-export declare function validateScriptInputSchema<T extends ObjectSchema<any>>(schema: T, options?: Input<T>): void;
+import { type BaseSchema, type Input } from 'valibot';
+export declare function validateScriptInputSchema<T extends BaseSchema<any>>(schema: T, options?: Input<T>): void;

package/dist/runtime/composables/validateScriptInputSchema.mjs

@@ -1,12 +1,14 @@
 import { parse } from "valibot";
 import { createError } from "#imports";
 export function validateScriptInputSchema(schema, options) {
-  try {
-    parse(schema, options);
-  } catch (e) {
-    createError({
-      cause: e,
-      message: "Invalid script options"
-    });
+  if (import.meta.dev) {
+    try {
+      parse(schema, options);
+    } catch (e) {
+      createError({
+        cause: e,
+        message: "Invalid script options"
+      });
+    }
   }
 }

package/dist/runtime/registry/cloudflare-web-analytics.mjs

@@ -18,18 +18,14 @@ export const CloudflareWebAnalyticsOptions = object({
 });
 export function useScriptCloudflareWebAnalytics(options, _scriptOptions) {
   const scriptOptions = _scriptOptions || {};
-  if (import.meta.dev) {
-    scriptOptions.beforeInit = () => {
-      validateScriptInputSchema(CloudflareWebAnalyticsOptions, options);
-    };
-  }
+  scriptOptions.beforeInit = () => {
+    import.meta.dev && validateScriptInputSchema(CloudflareWebAnalyticsOptions, options);
+  };
   return useScript({
     "src": "https://static.cloudflareinsights.com/beacon.min.js",
     "data-cf-beacon": JSON.stringify(defu(options, { spa: true }))
   }, {
-    trigger: "onNuxtReady",
     ...scriptOptions,
-    assetStrategy: "bundle",
     use() {
       return { __cfBeacon: window.__cfBeacon, __cfRl: window.__cfRl };
     }

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

@@ -1,3 +1,4 @@
+import { type Input } from 'valibot';
 import type { NuxtUseScriptOptions } from '#nuxt-scripts';
 export interface JSConfettiApi {
     addConfetti: (options?: {
@@ -11,4 +12,11 @@ declare global {
         };
     }
 }
-export declare function useScriptConfetti<T extends JSConfettiApi>(options?: NuxtUseScriptOptions<T>): any;
+export declare const JSConfettiOptions: import("valibot").ObjectSchema<Pick<{
+    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>;
+}, "version">, undefined, {
+    version?: string | undefined;
+}>;
+export declare function useScriptConfetti<T extends JSConfettiApi>(options: Input<typeof JSConfettiOptions>, _scriptOptions?: NuxtUseScriptOptions<T>): any;

package/dist/runtime/registry/confetti.mjs

@@ -1,10 +1,13 @@
-import { useScript } from "#imports";
-export function useScriptConfetti(options = {}) {
-  return useScript({
-    src: "https://cdn.jsdelivr.net/npm/js-confetti@latest/dist/js-confetti.browser.js"
+import { pick } from "valibot";
+import { NpmOptions, useScriptNpm } from "./npm.mjs";
+export const JSConfettiOptions = pick(NpmOptions, ["version"]);
+export function useScriptConfetti(options, _scriptOptions = {}) {
+  return useScriptNpm({
+    packageName: "js-confetti",
+    version: options.version,
+    file: "dist/js-confetti.browser.js"
   }, {
     ...options,
-    assetStrategy: "bundle",
     use() {
       return new window.JSConfetti();
     }

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

@@ -33,7 +33,7 @@ declare global {
     interface Window extends FacebookPixelApi {
     }
 }
-declare const FacebookPixelOptions: import("valibot").ObjectSchema<{
+export declare const FacebookPixelOptions: import("valibot").ObjectSchema<{
     id: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
 }, undefined, {
     id: string | number;

package/dist/runtime/registry/facebook-pixel.mjs

@@ -1,12 +1,12 @@
 import { number, object, string, union } from "valibot";
 import { useScript, validateScriptInputSchema } from "#imports";
-const FacebookPixelOptions = object({
+export const FacebookPixelOptions = object({
   id: union([string(), number()])
 });
 export function useScriptFacebookPixel(options, _scriptOptions) {
   const scriptOptions = _scriptOptions || {};
   scriptOptions.beforeInit = () => {
-    validateScriptInputSchema(FacebookPixelOptions, options);
+    import.meta.dev && validateScriptInputSchema(FacebookPixelOptions, options);
     if (import.meta.client) {
       const fbq = window.fbq = function(...params) {
         fbq.callMethod ? fbq.callMethod(...params) : fbq.queue.push(params);
@@ -22,13 +22,10 @@ export function useScriptFacebookPixel(options, _scriptOptions) {
     }
   };
   return useScript({
-    key: "facebook-pixel",
-    src: "https://connect.facebook.net/en_US/fbevents.js",
-    defer: true
+    key: "facebookPixel",
+    src: "https://connect.facebook.net/en_US/fbevents.js"
   }, {
-    trigger: "onNuxtReady",
     ...scriptOptions,
-    assetStrategy: "bundle",
     use() {
       return { fbq: window.fbq };
     }

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

@@ -1,6 +1,6 @@
 import { type Input } from 'valibot';
 import type { NuxtUseScriptOptions } from '#nuxt-scripts';
-declare const FathomAnalyticsOptions: import("valibot").ObjectSchema<{
+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>;
@@ -30,4 +30,3 @@ declare global {
     }
 }
 export declare function useScriptFathomAnalytics<T extends FathomAnalyticsApi>(options?: Input<typeof FathomAnalyticsOptions>, _scriptOptions?: Omit<NuxtUseScriptOptions<T>, 'beforeInit' | 'use'>): any;
-export {};

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

@@ -1,6 +1,6 @@
 import { boolean, literal, object, optional, string, union } from "valibot";
 import { useScript, validateScriptInputSchema } from "#imports";
-const FathomAnalyticsOptions = object({
+export const FathomAnalyticsOptions = object({
   "site": string(),
   // site is required
   "src": optional(string()),
@@ -11,14 +11,11 @@ const FathomAnalyticsOptions = object({
 });
 export function useScriptFathomAnalytics(options, _scriptOptions) {
   const scriptOptions = _scriptOptions || {};
-  if (import.meta.dev) {
-    scriptOptions.beforeInit = () => {
-      validateScriptInputSchema(FathomAnalyticsOptions, options);
-    };
-  }
+  scriptOptions.beforeInit = () => {
+    import.meta.dev && validateScriptInputSchema(FathomAnalyticsOptions, options);
+  };
   return useScript({
     src: "https://cdn.usefathom.com/script.js",
-    defer: true,
     ...options
   }, {
     ...scriptOptions,

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

@@ -1,5 +1,4 @@
-import { type Input } from 'valibot';
-import type { NuxtUseScriptOptions } from '#nuxt-scripts';
+import type { NuxtUseScriptOptions, ScriptDynamicSrcInput } 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[];
@@ -13,12 +12,12 @@ declare global {
         };
     }
 }
-declare const HotjarOptions: import("valibot").ObjectSchema<{
+export declare const HotjarOptions: import("valibot").ObjectSchema<{
     id: import("valibot").NumberSchema<number>;
     sv: import("valibot").OptionalSchema<import("valibot").NumberSchema<number>, undefined, number | undefined>;
 }, undefined, {
     id: number;
     sv?: number | undefined;
 }>;
-export declare function useScriptHotjar<T extends HotjarApi>(options?: Input<typeof HotjarOptions>, _scriptOptions?: Omit<NuxtUseScriptOptions<T>, 'beforeInit' | 'use'>): any;
-export {};
+export type HotjarInput = ScriptDynamicSrcInput<typeof HotjarOptions>;
+export declare function useScriptHotjar<T extends HotjarApi>(options?: HotjarInput, _scriptOptions?: Omit<NuxtUseScriptOptions<T>, 'assetStrategy' | 'beforeInit' | 'use'>): any;

package/dist/runtime/registry/hotjar.mjs

@@ -1,13 +1,13 @@
 import { number, object, optional } from "valibot";
 import { useScript, validateScriptInputSchema } from "#imports";
-const HotjarOptions = object({
+export const HotjarOptions = object({
   id: number(),
   sv: optional(number())
 });
 export function useScriptHotjar(options, _scriptOptions) {
   const scriptOptions = _scriptOptions || {};
   scriptOptions.beforeInit = () => {
-    validateScriptInputSchema(HotjarOptions, options);
+    import.meta.dev && validateScriptInputSchema(HotjarOptions, options);
     if (import.meta.client) {
       window._hjSettings = window._hjSettings || { hjid: options?.id, hjsv: options?.sv };
       window.hj = window.hj || function(...params) {
@@ -17,12 +17,10 @@ export function useScriptHotjar(options, _scriptOptions) {
   };
   return useScript({
     key: "hotjar",
-    src: `https://static.hotjar.com/c/hotjar-${options?.id}.js?sv=${options?.sv}`,
-    defer: true
+    // requires extra steps to bundle
+    src: options?.src || `https://static.hotjar.com/c/hotjar-${options?.id}.js?sv=${options?.sv}`
   }, {
-    trigger: "onNuxtReady",
     ...scriptOptions,
-    assetStrategy: "bundle",
     use() {
       return { hj: window.hj };
     }