@nuxt/hints 1.0.0-alpha.9 → 1.0.1

package/dist/runtime/core/components/nuxt-island.d.ts

@@ -1,2 +1,137 @@
-declare const HintsNuxtIsland: any;
+declare const HintsNuxtIsland: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        name: {
+            type: StringConstructor;
+            required: true;
+        };
+        lazy: BooleanConstructor;
+        props: {
+            type: ObjectConstructor;
+            default: () => undefined;
+        };
+        context: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        scopeId: {
+            type: import("vue").PropType<string | undefined | null>;
+            default: () => undefined;
+        };
+        source: {
+            type: StringConstructor;
+            default: () => undefined;
+        };
+        dangerouslyLoadClientComponents: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onError?: ((...args: any[]) => any) | undefined;
+    }>, (_ctx: any, _cache: any) => (import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[])[] | import("vue").VNode<any, any, {
+        [key: string]: any;
+    }>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "error"[], import("vue").PublicProps, {
+        props: Record<string, any>;
+        source: string;
+        scopeId: string | null | undefined;
+        lazy: boolean;
+        context: Record<string, any>;
+        dangerouslyLoadClientComponents: boolean;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        name: {
+            type: StringConstructor;
+            required: true;
+        };
+        lazy: BooleanConstructor;
+        props: {
+            type: ObjectConstructor;
+            default: () => undefined;
+        };
+        context: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        scopeId: {
+            type: import("vue").PropType<string | undefined | null>;
+            default: () => undefined;
+        };
+        source: {
+            type: StringConstructor;
+            default: () => undefined;
+        };
+        dangerouslyLoadClientComponents: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onError?: ((...args: any[]) => any) | undefined;
+    }>, (_ctx: any, _cache: any) => (import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[])[] | import("vue").VNode<any, any, {
+        [key: string]: any;
+    }>[], {}, {}, {}, {
+        props: Record<string, any>;
+        source: string;
+        scopeId: string | null | undefined;
+        lazy: boolean;
+        context: Record<string, any>;
+        dangerouslyLoadClientComponents: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    lazy: BooleanConstructor;
+    props: {
+        type: ObjectConstructor;
+        default: () => undefined;
+    };
+    context: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    scopeId: {
+        type: import("vue").PropType<string | undefined | null>;
+        default: () => undefined;
+    };
+    source: {
+        type: StringConstructor;
+        default: () => undefined;
+    };
+    dangerouslyLoadClientComponents: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onError?: ((...args: any[]) => any) | undefined;
+}>, (_ctx: any, _cache: any) => (import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[])[] | import("vue").VNode<any, any, {
+    [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "error"[], "error", {
+    props: Record<string, any>;
+    source: string;
+    scopeId: string | null | undefined;
+    lazy: boolean;
+    context: Record<string, any>;
+    dangerouslyLoadClientComponents: boolean;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
 export default HintsNuxtIsland;

package/dist/runtime/core/features.d.ts

@@ -0,0 +1,6 @@
+import type { FeaturesName } from './types.js';
+import type { FeatureOptionsMap } from '../feature-options.js';
+export declare function isFeatureDevtoolsEnabled(feature: FeaturesName): boolean;
+export declare function isFeatureLogsEnabled(feature: FeaturesName): boolean;
+export declare function isFeatureEnabled(feature: FeaturesName): boolean;
+export declare function getFeatureOptions<K extends keyof FeatureOptionsMap>(feature: K): FeatureOptionsMap[K] | undefined;

package/dist/runtime/core/features.js

@@ -0,0 +1,17 @@
+import { features } from "#shared/hints-config";
+export function isFeatureDevtoolsEnabled(feature) {
+  return features[feature] != null && typeof features[feature] === "object" ? features[feature].devtools !== false : !!features[feature];
+}
+export function isFeatureLogsEnabled(feature) {
+  return features[feature] != null && typeof features[feature] === "object" ? features[feature].logs !== false : !!features[feature];
+}
+export function isFeatureEnabled(feature) {
+  return !!features[feature];
+}
+export function getFeatureOptions(feature) {
+  const val = features[feature];
+  if (typeof val === "object" && val.options) {
+    return val.options;
+  }
+  return void 0;
+}

package/dist/runtime/core/plugins/features.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/core/plugins/features.client.js

@@ -0,0 +1,16 @@
+import { defineNuxtPlugin } from "#imports";
+import { features } from "#shared/hints-config";
+export default defineNuxtPlugin({
+  name: "hints:features",
+  setup(nuxtApp) {
+    Object.defineProperty(nuxtApp, "hints", {
+      get() {
+        return Object.freeze({
+          config: {
+            features
+          }
+        });
+      }
+    });
+  }
+});

package/dist/runtime/core/plugins/vue-tracer-state.client.d.ts

@@ -1,2 +1,2 @@
-declare const _default: any;
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/core/types.d.ts

@@ -0,0 +1,17 @@
+import type { FeatureOptionsMap } from '../feature-options.js';
+export type FeaturesName = 'hydration' | 'lazyLoad' | 'webVitals' | 'thirdPartyScripts' | 'htmlValidate';
+export type FeatureFlags<T extends Record<string, any> = Record<string, never>> = {
+    logs?: boolean;
+    devtools?: boolean;
+    /**
+     * Any feature specific options
+     */
+    options?: T;
+};
+/**
+ * Fully-resolved features configuration type, where each feature
+ * can be a simple boolean or a FeatureFlags with its own options.
+ */
+export type Features = {
+    [K in FeaturesName]: boolean | FeatureFlags<K extends keyof FeatureOptionsMap ? FeatureOptionsMap[K] : Record<string, never>>;
+};

package/dist/runtime/feature-options.d.ts

@@ -0,0 +1,8 @@
+import type { HtmlValidateFeatureOptions } from './html-validate/types.js';
+import type { ThirdPartyScriptsFeatureOptions } from './third-party-scripts/types.js';
+import type { WebVitalsFeatureOptions } from './web-vitals/types.js';
+export interface FeatureOptionsMap {
+    thirdPartyScripts: ThirdPartyScriptsFeatureOptions;
+    htmlValidate: HtmlValidateFeatureOptions;
+    webVitals: WebVitalsFeatureOptions;
+}

package/dist/runtime/html-validate/handlers/delete.d.ts

@@ -0,0 +1 @@
+export declare const deleteHandler: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{}>>;

package/dist/runtime/html-validate/handlers/delete.js

@@ -0,0 +1,17 @@
+import { createError, defineEventHandler, setResponseStatus } from "h3";
+import { storage } from "../storage.js";
+import { useNitroApp } from "nitropack/runtime";
+export const deleteHandler = defineEventHandler(async (event) => {
+  const nitro = useNitroApp();
+  const id = event.context.params?.id;
+  if (typeof id === "string") {
+    await storage.removeItem(id);
+    setResponseStatus(event, 204);
+    nitro.hooks.callHook("hints:html-validate:deleted", id);
+    return {};
+  }
+  throw createError({
+    statusCode: 404,
+    statusMessage: "Not Found"
+  });
+});

package/dist/runtime/html-validate/handlers/get.d.ts

@@ -0,0 +1,2 @@
+import type { HtmlValidateReport } from '../types.js';
+export declare const getAllHandler: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<HtmlValidateReport[]>>;

package/dist/runtime/html-validate/handlers/get.js

@@ -0,0 +1,5 @@
+import { defineEventHandler } from "h3";
+import { storage } from "../storage.js";
+export const getAllHandler = defineEventHandler(() => {
+  return storage.getKeys().then((keys) => Promise.all(keys.map((key) => storage.getItem(key)))).then((items) => items.filter((item) => item !== null));
+});

package/dist/runtime/html-validate/handlers/nitro-handlers.plugin.d.ts

@@ -0,0 +1,3 @@
+import type { NitroAppPlugin } from 'nitropack/types';
+declare const _default: NitroAppPlugin;
+export default _default;

package/dist/runtime/html-validate/handlers/nitro-handlers.plugin.js

@@ -0,0 +1,36 @@
+import { join } from "pathe";
+import { HTMLVALIDATE_ROUTE } from "../utils.js";
+import { getAllHandler } from "./get.js";
+import { deleteHandler } from "./delete.js";
+export default (function(nitro) {
+  nitro.router.add(
+    HTMLVALIDATE_ROUTE,
+    getAllHandler,
+    "get"
+  );
+  nitro.router.add(
+    join(HTMLVALIDATE_ROUTE, ":id"),
+    deleteHandler,
+    "delete"
+  );
+  nitro.hooks.hook("hints:sse:setup", (context) => {
+    context.unsubscribers.push(
+      nitro.hooks.hook("hints:html-validate:report", (report) => {
+        context.eventStream.push(
+          {
+            data: JSON.stringify(report),
+            event: "hints:html-validate:report"
+          }
+        );
+      }),
+      nitro.hooks.hook("hints:html-validate:deleted", (id) => {
+        context.eventStream.push(
+          {
+            data: id,
+            event: "hints:html-validate:deleted"
+          }
+        );
+      })
+    );
+  });
+});

package/dist/runtime/html-validate/nitro.plugin.d.ts

@@ -0,0 +1,3 @@
+import type { NitroAppPlugin } from 'nitropack/types';
+declare const _default: NitroAppPlugin;
+export default _default;

package/dist/runtime/html-validate/nitro.plugin.js

@@ -0,0 +1,54 @@
+import { HtmlValidate } from "html-validate";
+import { addBeforeBodyEndTag } from "./utils.js";
+import { storage } from "./storage.js";
+import { randomUUID } from "crypto";
+import { stringify } from "devalue";
+import { format } from "prettier/standalone";
+import html from "prettier/parser-html";
+import { getFeatureOptions } from "../core/features.js";
+import { defu } from "defu";
+const DEFAULT_EXTENDS = [
+  "html-validate:standard",
+  "html-validate:document",
+  "html-validate:browser"
+];
+const DEFAULT_RULES = {
+  "svg-focusable": "off",
+  "no-unknown-elements": "error",
+  "void-style": "off",
+  "no-trailing-whitespace": "off",
+  // Conflict with Nuxt defaults
+  "require-sri": "off",
+  "attribute-boolean-style": "off",
+  "doctype-style": "off",
+  // Unreasonable rule
+  "no-inline-style": "off"
+};
+export default (function(nitro) {
+  const opts = defu({
+    extends: DEFAULT_EXTENDS,
+    rules: DEFAULT_RULES
+  }, getFeatureOptions("htmlValidate") ?? {});
+  const validator = new HtmlValidate(opts);
+  nitro.hooks.hook("render:response", async (response, { event }) => {
+    if (typeof response.body === "string" && (response.headers?.["Content-Type"] || response.headers?.["content-type"])?.includes("html")) {
+      const formattedBody = await format(response.body, { plugins: [html], parser: "html" });
+      const results = await validator.validateString(formattedBody);
+      if (response.body && results.errorCount > 0) {
+        const id = randomUUID();
+        const data = {
+          id,
+          path: event.path,
+          html: formattedBody,
+          results: results.results
+        };
+        storage.setItem(id, data);
+        response.body = addBeforeBodyEndTag(
+          response.body,
+          `<script id="hints-html-validate" type="application/json">${stringify(data)}<\/script>`
+        );
+        nitro.hooks.callHook("hints:html-validate:report", data);
+      }
+    }
+  });
+});

package/dist/runtime/html-validate/plugin.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/html-validate/plugin.client.js

@@ -0,0 +1,28 @@
+import { defineNuxtPlugin } from "#imports";
+import { parse } from "devalue";
+import { logger } from "./utils.js";
+export default defineNuxtPlugin({
+  name: "@nuxt/hints:html-validate",
+  setup() {
+    const el = document.getElementById("hints-html-validate");
+    const raw = el?.textContent;
+    if (!raw) {
+      return;
+    }
+    let data;
+    try {
+      data = parse(raw);
+    } catch (err) {
+      logger.warn("[html-validate] Failed to parse report payload", err);
+      return;
+    }
+    if (!data?.results || !Array.isArray(data.results)) {
+      return;
+    }
+    for (const result of data.results) {
+      result.messages.forEach((message) => {
+        logger.warn(`[html-validate] ${message.ruleId} at ${result.filePath}:${message.line}:${message.column} - ${message.message}`);
+      });
+    }
+  }
+});

package/dist/runtime/html-validate/storage.d.ts

@@ -0,0 +1 @@
+export declare const storage: import("unstorage").Storage<import("unstorage").StorageValue>;

package/dist/runtime/html-validate/storage.js

@@ -0,0 +1,2 @@
+import { createStorage } from "unstorage";
+export const storage = createStorage();

package/dist/runtime/html-validate/types.d.ts

@@ -0,0 +1,8 @@
+import type { ConfigData } from 'html-validate';
+export type HtmlValidateFeatureOptions = ConfigData;
+export type HtmlValidateReport = {
+    id: string;
+    html: string;
+    results: import('html-validate').Result[];
+    path: string;
+};

package/dist/runtime/html-validate/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const logger: import("consola").ConsolaInstance;
+export declare const HTMLVALIDATE_ROUTE: string;
+export declare function addBeforeBodyEndTag(html: string, content: string): string;

package/dist/runtime/html-validate/utils.js

@@ -0,0 +1,12 @@
+import { join } from "pathe";
+import { HINTS_ROUTE } from "../core/server/types.js";
+import { createHintsLogger } from "../logger.js";
+export const logger = createHintsLogger("htmlValidate");
+export const HTMLVALIDATE_ROUTE = join(HINTS_ROUTE, "html-validate");
+export function addBeforeBodyEndTag(html, content) {
+  const closingBodyTagIndex = html.lastIndexOf("</body>");
+  if (closingBodyTagIndex === -1) {
+    return html + content;
+  }
+  return html.slice(0, closingBodyTagIndex) + content + html.slice(closingBodyTagIndex);
+}

package/dist/runtime/hydration/composables.js

@@ -1,8 +1,8 @@
-import { getCurrentInstance, inject, onMounted } from "vue";
+import { getCurrentInstance, inject, markRaw, onMounted } from "vue";
 import { useNuxtApp } from "#imports";
-import { HYDRATION_ROUTE, formatHTML } from "./utils.js";
-import { logger } from "../logger.js";
+import { HYDRATION_ROUTE, formatHTML, logger } from "./utils.js";
 import { clientOnlySymbol } from "#app/components/client-only";
+import { isFeatureDevtoolsEnabled } from "../core/features.js";
 export function useHydrationCheck() {
   const isClientOnly = inject(clientOnlySymbol, false);
   if (import.meta.server || isClientOnly) {
@@ -27,17 +27,19 @@ export function useHydrationCheck() {
         componentName,
         fileLocation
       };
-      $fetch(new URL(HYDRATION_ROUTE, window.location.origin).href, {
-        method: "POST",
-        body
-      }).then((payload) => {
-        nuxtApp.payload.__hints.hydration.push({
-          ...payload,
-          instance,
-          vnode: vnodePrehydration
+      if (isFeatureDevtoolsEnabled("hydration")) {
+        $fetch(new URL(HYDRATION_ROUTE, window.location.origin).href, {
+          method: "POST",
+          body
+        }).then((payload) => {
+          nuxtApp.payload.__hints.hydration.push({
+            ...payload,
+            instance: markRaw(instance),
+            vnode: markRaw(vnodePrehydration)
+          });
         });
-      });
-      logger.warn(`[hydration] Component ${componentName ?? instance.type.__file} seems to have different html pre and post-hydration. Please make sure you don't have any hydration issue.`);
+      }
+      logger.warn(`[hydration] Component ${componentName} at ${fileLocation} seems to have different html pre and post-hydration. Please make sure you don't have any hydration issue.`);
     }
   });
 }

package/dist/runtime/hydration/plugin.client.d.ts

@@ -1,2 +1,2 @@
-declare const _default: any;
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/hydration/utils.d.ts

@@ -1,3 +1,4 @@
+export declare const logger: import("consola").ConsolaInstance;
 export declare const HYDRATION_ROUTE = "/__nuxt_hints/hydration";
 export declare const HYDRATION_SSE_ROUTE = "/__nuxt_hints/sse";
 export declare function formatHTML(html: string | undefined): string;

package/dist/runtime/hydration/utils.js

@@ -1,4 +1,6 @@
 import { HINTS_ROUTE, HINTS_SSE_ROUTE } from "../core/server/types.js";
+import { createHintsLogger } from "../logger.js";
+export const logger = createHintsLogger("hydration");
 export const HYDRATION_ROUTE = `${HINTS_ROUTE}/hydration`;
 export const HYDRATION_SSE_ROUTE = HINTS_SSE_ROUTE;
 export function formatHTML(html) {

package/dist/runtime/lazy-load/plugin.client.d.ts

@@ -1,2 +1,2 @@
-declare const _default: any;
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/lazy-load/plugin.client.js

@@ -1,8 +1,8 @@
 import { defineNuxtPlugin, useNuxtApp, useRoute } from "#imports";
 import { defu } from "defu";
 import { useLazyComponentTracking } from "./composables.js";
-import { logger } from "../logger.js";
-import { LAZY_LOAD_ROUTE } from "./utils.js";
+import { logger, LAZY_LOAD_ROUTE } from "./utils.js";
+import { isFeatureDevtoolsEnabled } from "../core/features.js";
 export default defineNuxtPlugin({
   name: "@nuxt/hints:lazy-load",
   dependsOn: ["nuxt:router"],
@@ -53,7 +53,7 @@ function reportSuggestions(suggestions) {
   Used in: ${suggestion.importedBy}`
     );
   }
-  if (suggestions.length) {
+  if (suggestions.length && isFeatureDevtoolsEnabled("lazyLoad")) {
     const payload = {
       id: `${encodeURIComponent(route.path)}-${Date.now()}`,
       route: route.path,

package/dist/runtime/lazy-load/utils.d.ts

@@ -1 +1,2 @@
+export declare const logger: import("consola").ConsolaInstance;
 export declare const LAZY_LOAD_ROUTE = "/__nuxt_hints/lazy-load";

package/dist/runtime/lazy-load/utils.js

@@ -1,2 +1,4 @@
 import { HINTS_ROUTE } from "../core/server/types.js";
+import { createHintsLogger } from "../logger.js";
+export const logger = createHintsLogger("lazyLoad");
 export const LAZY_LOAD_ROUTE = `${HINTS_ROUTE}/lazy-load`;

package/dist/runtime/logger.d.ts

@@ -1 +1,3 @@
+import type { FeaturesName } from './core/types.js';
+export declare function createHintsLogger(feature: FeaturesName): import("consola").ConsolaInstance;
 export declare const logger: import("consola").ConsolaInstance;

package/dist/runtime/logger.js

@@ -1,2 +1,8 @@
 import { createConsola } from "consola";
+import { isFeatureLogsEnabled } from "./core/features.js";
+export function createHintsLogger(feature) {
+  return createConsola({
+    level: isFeatureLogsEnabled(feature) ? void 0 : 0
+  }).withTag(`hints:${feature}`);
+}
 export const logger = createConsola().withTag("hints");

package/dist/runtime/third-party-scripts/plugin.client.d.ts

@@ -1,2 +1,2 @@
-declare const _default: any;
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/third-party-scripts/plugin.client.js

@@ -1,11 +1,18 @@
-import { defineNuxtPlugin, ref, useNuxtApp } from "#imports";
+import { defineNuxtPlugin, shallowRef, useNuxtApp } from "#imports";
 import { defu } from "defu";
-import { logger } from "../logger.js";
-const EXTENSIONS_SCHEMES_RE = /^(chrome-extension|moz-extension|safari-extension|ms-browser-extension):/;
-function isExtensionScript(src) {
+import { logger } from "./utils.js";
+import { getFeatureOptions } from "../core/features.js";
+const DEFAULT_EXTENSION_SCHEMES = ["chrome-extension", "moz-extension", "safari-extension", "ms-browser-extension"];
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildExtensionSchemesRegex(schemes) {
+  return new RegExp(`^(${schemes.map(escapeRegExp).join("|")}):`);
+}
+function isExtensionScript(src, schemesRegex) {
   try {
     const url = new URL(src, window.location.origin);
-    return EXTENSIONS_SCHEMES_RE.test(url.protocol);
+    return schemesRegex.test(url.protocol);
   } catch {
     return false;
   }
@@ -18,15 +25,28 @@ function isSameOriginScript(src) {
     return false;
   }
 }
-function isIgnoredScript(src) {
-  return isSameOriginScript(src) || isExtensionScript(src);
+function isIgnoredDomain(src, ignoredDomains) {
+  if (ignoredDomains.length === 0) return false;
+  try {
+    const url = new URL(src, window.location.origin);
+    return ignoredDomains.some((domain) => url.hostname === domain || url.hostname.endsWith(`.${domain}`));
+  } catch {
+    return false;
+  }
 }
 export default defineNuxtPlugin({
   name: "nuxt-hints:third-party-scripts",
   setup() {
     const nuxtApp = useNuxtApp();
+    const opts = getFeatureOptions("thirdPartyScripts") ?? {};
+    const extensionSchemes = [...DEFAULT_EXTENSION_SCHEMES, ...opts.ignoredSchemes ?? []];
+    const schemesRegex = buildExtensionSchemesRegex(extensionSchemes);
+    const ignoredDomains = opts.ignoredDomains ?? [];
+    function isIgnoredScript(src) {
+      return isSameOriginScript(src) || isExtensionScript(src, schemesRegex) || isIgnoredDomain(src, ignoredDomains);
+    }
     nuxtApp.payload.__hints = defu(nuxtApp.payload.__hints, {
-      thirdPartyScripts: ref([])
+      thirdPartyScripts: shallowRef([])
     });
     const scripts = nuxtApp.payload.__hints.thirdPartyScripts;
     const isUsingNuxtScripts = !!nuxtApp.$scripts;

package/dist/runtime/third-party-scripts/types.d.ts

@@ -0,0 +1,6 @@
+export interface ThirdPartyScriptsFeatureOptions {
+    /** Additional domains to ignore when detecting third-party scripts */
+    ignoredDomains?: string[];
+    /** Additional URL scheme patterns to ignore (default includes browser extension schemes) */
+    ignoredSchemes?: string[];
+}

package/dist/runtime/third-party-scripts/utils.d.ts

@@ -0,0 +1 @@
+export declare const logger: import("consola").ConsolaInstance;

package/dist/runtime/third-party-scripts/utils.js

@@ -0,0 +1,2 @@
+import { createHintsLogger } from "../logger.js";
+export const logger = createHintsLogger("thirdPartyScripts");