@nuxt/scripts 1.3.3 → 1.3.5

package/dist/module.mjs

@@ -1,23 +1,27 @@
 import { createHash, randomBytes } from 'node:crypto';
-import { existsSync, readFileSync, appendFileSync, writeFileSync, readdirSync } from 'node:fs';
-import { useNuxt, addDevServerHandler, extendRouteRules, tryUseNuxt, createResolver, extendViteConfig, logger as logger$1, useLogger, addTypeTemplate, defineNuxtModule, addPluginTemplate, addServerHandler, addImports, addComponentsDir, addTemplate, hasNuxtModule, addBuildPlugin, addPlugin } from '@nuxt/kit';
+import { existsSync, readFileSync, writeFileSync, appendFileSync, readdirSync } from 'node:fs';
+import fsp, { open, stat, unlink } from 'node:fs/promises';
+import { setTimeout } from 'node:timers/promises';
+import { useNuxt, addDevServerHandler, extendRouteRules, tryUseNuxt, createResolver, extendViteConfig, logger as logger$1, useLogger, getNuxtVersion, addTypeTemplate, resolvePath, defineNuxtModule, addPluginTemplate, addServerHandler, addImports, addComponentsDir, addTemplate, hasNuxtModule, addBuildPlugin, addPlugin } from '@nuxt/kit';
 import { defu } from 'defu';
-import { join, resolve } from 'pathe';
+import { join, resolve, dirname } from 'pathe';
 import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
 import { lazyEventHandler, eventHandler, createError, setHeader } from 'h3';
 import { fetch, $fetch } from 'ofetch';
 import { joinURL, parseURL, parseQuery, hasProtocol } from 'ufo';
 import { createStorage } from 'unstorage';
 import fsDriver from 'unstorage/drivers/fs-lite';
+import { Buffer as Buffer$1 } from 'node:buffer';
 import { isCI, provider } from 'std-env';
+import { pathToFileURL } from 'node:url';
 import { parseAndWalk, ScopeTracker, walk, ScopeTrackerFunction, ScopeTrackerIdentifier, ScopeTrackerFunctionParam, ScopeTrackerVariable } from 'oxc-walker';
 import { createUnplugin } from 'unplugin';
-import { pathToFileURL } from 'node:url';
-import fsp from 'node:fs/promises';
 import { colors } from 'consola/utils';
 import MagicString from 'magic-string';
 import { hash } from 'ohash';
 import { getBundleResolve, registry, resolveCapabilities, getPartytownForwards, buildProxyConfigsFromRegistry, generatePartytownResolveUrl } from './registry.mjs';
+import { ensureNuxtScriptsCacheStorage } from '../dist/runtime/server/utils/cache-config.js';
+import { isPublicNetworkHostname } from '../dist/runtime/server/utils/network-hostname.js';
 import '../dist/runtime/registry/schemas.js';
 
 const renderedScript = /* @__PURE__ */ new Map();
@@ -83,6 +87,7 @@ function setupPublicAssetStrategy(assetsBaseURL) {
 const DEVTOOLS_UI_ROUTE = "/__nuxt-scripts";
 const DEVTOOLS_UI_LOCAL_PORT = 3030;
 const DEVTOOLS_API_STATE_ROUTE = "/__nuxt-scripts-api/state";
+const DEVTOOLS_API_MAX_BODY_SIZE = 2 * 1024 * 1024;
 async function setupDevtools(nuxt, options = {}) {
   const { addCustomTab } = await import('@nuxt/devtools-kit');
   const { resolve } = createResolver(import.meta.url);
@@ -139,13 +144,38 @@ function setupStandaloneApi(nuxt) {
         return;
       }
       if (req.method === "POST") {
-        let body = "";
-        req.on("data", (chunk) => {
-          body += chunk.toString();
-        });
-        req.on("end", () => {
+        let cleanup = function() {
+          req.off("data", onData);
+          req.off("end", onEnd);
+          req.off("aborted", onAborted);
+          req.off("error", onAborted);
+        }, onAborted = function() {
+          finished = true;
+          chunks = [];
+          cleanup();
+        }, onData = function(chunk) {
+          if (finished)
+            return;
+          size += chunk.byteLength;
+          if (size > DEVTOOLS_API_MAX_BODY_SIZE) {
+            finished = true;
+            chunks = [];
+            cleanup();
+            req.once("error", () => {
+            });
+            req.resume();
+            res.statusCode = 413;
+            res.end("payload too large");
+            return;
+          }
+          chunks.push(chunk);
+        }, onEnd = function() {
+          if (finished)
+            return;
+          finished = true;
+          cleanup();
           try {
-            const data = JSON.parse(body);
+            const data = JSON.parse(Buffer$1.concat(chunks, size).toString("utf8"));
             scriptsState = { ...data, updatedAt: Date.now() };
             res.statusCode = 200;
             res.end("ok");
@@ -153,7 +183,15 @@ function setupStandaloneApi(nuxt) {
             res.statusCode = 400;
             res.end("invalid json");
           }
-        });
+          chunks = [];
+        };
+        let chunks = [];
+        let size = 0;
+        let finished = false;
+        req.on("data", onData);
+        req.on("end", onEnd);
+        req.on("aborted", onAborted);
+        req.on("error", onAborted);
         return;
       }
       res.statusCode = 405;
@@ -214,8 +252,11 @@ function buildDevtoolsData(proxyPrefix, privacyLabel, scripts, aliasToDomain) {
 
 const isStackblitz = provider === "stackblitz";
 async function promptToInstall(name, installCommand, options) {
-  if (await resolvePackageJSON(name).catch(() => null))
+  if (await resolvePackageJSON(name).catch(() => {
+    return null;
+  })) {
     return true;
+  }
   logger$1.info(`Package ${name} is missing`);
   if (isCI)
     return false;
@@ -254,6 +295,89 @@ function installNuxtModule(name, options) {
 
 const logger = useLogger("@nuxt/scripts");
 
+const NITRO_RUNTIME_MODULE = "#nuxt-scripts/nitro";
+const H3_RUNTIME_MODULE = "#nuxt-scripts/h3";
+const TYPE_TEMPLATE_FILENAME = "types/nuxt-scripts-nitro.d.ts";
+const defaultDependencies = {
+  addTypeTemplate,
+  getNuxtVersion
+};
+const nitroV2Runtime = `export {
+  defineCachedFunction,
+  useNitroApp,
+  useRuntimeConfig,
+} from 'nitropack/runtime'
+`;
+const nitroV3RuntimeTypes = `export { useNitroApp } from 'nitro/app'
+export { defineCachedFunction } from 'nitro/cache'
+export function useRuntimeConfig(event?: import('nitro/h3').H3Event): ReturnType<typeof import('nitro/runtime-config').useRuntimeConfig>
+`;
+function indent(value, spaces) {
+  const padding = " ".repeat(spaces);
+  return value.split("\n").map((line) => `${padding}${line}`).join("\n");
+}
+function renderRuntimeDeclarations(compatibility) {
+  const nitroRuntime = compatibility._tag === "nitro-v3" ? nitroV3RuntimeTypes : nitroV2Runtime;
+  const h3Runtime = compatibility._tag === "nitro-v3" ? `export * from 'nitro/h3'
+` : `export * from 'h3'
+`;
+  return `declare module '${NITRO_RUNTIME_MODULE}' {
+${indent(nitroRuntime.trim(), 2)}
+}
+
+declare module '${H3_RUNTIME_MODULE}' {
+${indent(h3Runtime.trim(), 2)}
+}
+`;
+}
+function renderNitroV3Runtime(compatibility) {
+  return `export { useNitroApp } from ${JSON.stringify(compatibility.app)}
+export { defineCachedFunction } from ${JSON.stringify(compatibility.cache)}
+import { useRuntimeConfig as _useRuntimeConfig } from ${JSON.stringify(compatibility.runtimeConfig)}
+export function useRuntimeConfig(_event) { return _useRuntimeConfig() }
+`;
+}
+function applyNitroRuntimeCompatibility(nuxt, compatibility) {
+  const nuxtOptions = nuxt.options;
+  const nitroOptions = nuxtOptions.nitro ||= {};
+  const h3Runtime = compatibility._tag === "nitro-v3" ? compatibility.h3 : "h3";
+  nitroOptions.alias ||= {};
+  nitroOptions.virtual ||= {};
+  const nuxtAliases = nuxtOptions.alias ||= {};
+  delete nuxtAliases[H3_RUNTIME_MODULE];
+  nuxtOptions.alias = { [H3_RUNTIME_MODULE]: h3Runtime, ...nuxtAliases };
+  nitroOptions.alias[H3_RUNTIME_MODULE] = h3Runtime;
+  nitroOptions.virtual[NITRO_RUNTIME_MODULE] = compatibility._tag === "nitro-v3" ? renderNitroV3Runtime(compatibility) : nitroV2Runtime;
+}
+async function createNuxtNitroImportResolver() {
+  const nuxtDir = dirname(await resolvePath("nuxt/package.json"));
+  const nitroDir = dirname(await resolvePath("@nuxt/nitro-server/package.json", { cwd: nuxtDir }));
+  return async (id) => {
+    const resolved = await resolvePath(id, { cwd: nitroDir });
+    if (!existsSync(resolved))
+      throw new Error(`[nuxt-scripts] Could not resolve Nitro runtime helper "${id}" from "${nitroDir}".`);
+    return pathToFileURL(resolved).href;
+  };
+}
+async function resolveNitroV3Compatibility(resolveNitroImport) {
+  const [app, cache, h3, runtimeConfig] = await Promise.all([
+    resolveNitroImport("nitro/app"),
+    resolveNitroImport("nitro/cache"),
+    resolveNitroImport("nitro/h3"),
+    resolveNitroImport("nitro/runtime-config")
+  ]);
+  return { _tag: "nitro-v3", app, cache, h3, runtimeConfig };
+}
+async function setupNitroRuntimeCompatibility(nuxt, dependencies = defaultDependencies) {
+  const compatibility = Number.parseInt(dependencies.getNuxtVersion(nuxt), 10) >= 5 ? await resolveNitroV3Compatibility(dependencies.resolveNitroImport || await createNuxtNitroImportResolver()) : { _tag: "nitro-v2" };
+  applyNitroRuntimeCompatibility(nuxt, compatibility);
+  nuxt.hooks.hookOnce("modules:done", () => applyNitroRuntimeCompatibility(nuxt, compatibility));
+  dependencies.addTypeTemplate({
+    filename: TYPE_TEMPLATE_FILENAME,
+    getContents: async () => renderRuntimeDeclarations(compatibility)
+  }, { nitro: true, node: true, nuxt: true });
+}
+
 const SCRIPT_OPTION_KEYS = ["trigger", "proxy", "bundle", "partytown"];
 function extractRequiredFields(schema) {
   if (!schema)
@@ -424,12 +548,14 @@ function NuxtScriptsCheckScripts() {
 
 function generateInterceptPluginContents(proxyPrefix, options) {
   const testMode = options?.testMode ?? false;
-  return `export default defineNuxtPlugin({
+  return `import { defineNuxtPlugin } from 'nuxt/app'
+
+export default defineNuxtPlugin({
   name: 'nuxt-scripts:intercept',
   enforce: 'pre',
   setup() {
     const proxyPrefix = ${JSON.stringify(proxyPrefix)};
-    const domainAliases = ${JSON.stringify(options?.domainAliases ?? {})};
+    const domainAliases = Object.assign(Object.create(null), ${JSON.stringify(options?.domainAliases ?? {})});
     const origBeacon = typeof navigator !== 'undefined' && navigator.sendBeacon
       ? navigator.sendBeacon.bind(navigator)
       : () => false;
@@ -438,11 +564,11 @@ function generateInterceptPluginContents(proxyPrefix, options) {
     function proxyUrl(url) {
       try {
         const parsed = new URL(url, location.origin);
-        if (parsed.origin !== location.origin) {
+        if ((parsed.protocol === 'http:' || parsed.protocol === 'https:') && parsed.origin !== location.origin) {
           const seg = domainAliases[parsed.host] || parsed.host;
           return location.origin + proxyPrefix + '/' + seg + parsed.pathname + parsed.search;
         }
-      } catch {}
+      } catch { /* Invalid URL inputs retain native behavior. */ }
       return url;
     }
 
@@ -1339,7 +1465,7 @@ function NuxtScriptBundleTransformer(options = {
 const WILDCARD_RE = /\*/;
 const SAFE_ALIAS_SEGMENT_RE = /^[\w.-]+$/;
 function isSafeAliasSegment(alias) {
-  return SAFE_ALIAS_SEGMENT_RE.test(alias);
+  return alias !== "." && alias !== ".." && SAFE_ALIAS_SEGMENT_RE.test(alias);
 }
 function aliasForDomain(domain, alias) {
   if (!alias || WILDCARD_RE.test(domain))
@@ -1349,19 +1475,16 @@ function aliasForDomain(domain, alias) {
   return Object.hasOwn(alias, domain) ? alias[domain] || void 0 : void 0;
 }
 function buildDomainAliasMap(domains, alias) {
-  const map = {};
+  const entries = [];
   for (const domain of domains) {
     const value = aliasForDomain(domain, alias);
     if (value)
-      map[domain] = value;
+      entries.push([domain, value]);
   }
-  return map;
+  return Object.fromEntries(entries);
 }
 function invertAliasMap(map) {
-  const out = {};
-  for (const [domain, alias] of Object.entries(map))
-    out[alias] = domain;
-  return out;
+  return Object.fromEntries(Object.entries(map).map(([domain, alias]) => [alias, domain]));
 }
 function aliasProxyValue(value, proxyPrefix, alias) {
   const prefix = `${proxyPrefix}/`;
@@ -1595,6 +1718,20 @@ function templatePlugin(config, registry) {
   ].join("\n");
 }
 
+const SOURCE_LESS_SCRIPT_LOADER_TYPE = /\bUseScriptLoaderInput\b/;
+function hasUnheadSourceLessScriptLoader(typesSource) {
+  return SOURCE_LESS_SCRIPT_LOADER_TYPE.test(typesSource);
+}
+function hasUnheadSourceLessScriptLoaderFile(typesPath) {
+  if (!typesPath || !existsSync(typesPath))
+    return false;
+  try {
+    return hasUnheadSourceLessScriptLoader(readFileSync(typesPath, "utf8"));
+  } catch {
+    return false;
+  }
+}
+
 const UPPER_RE$1 = /([A-Z])/g;
 const toScreamingSnake$1 = (s) => s.replace(UPPER_RE$1, "_$1").toUpperCase();
 const ENV_PREFIX = "NUXT_PUBLIC_SCRIPTS_";
@@ -1802,9 +1939,57 @@ function fixSelfClosingScriptComponents(nuxt) {
 const UPPER_RE = /([A-Z])/g;
 const toScreamingSnake = (s) => s.replace(UPPER_RE, "_$1").toUpperCase();
 const PROXY_SECRET_ENV_KEY = "NUXT_SCRIPTS_PROXY_SECRET";
-const PROXY_SECRET_ENV_LINE_RE = /^NUXT_SCRIPTS_PROXY_SECRET=/m;
+const PROXY_SECRET_ENV_LINE_RE = /^NUXT_SCRIPTS_PROXY_SECRET=.*$/m;
 const PROXY_SECRET_ENV_VALUE_RE = /^NUXT_SCRIPTS_PROXY_SECRET=(.+)$/m;
-function resolveProxySecret(rootDir, isDev, configSecret, autoGenerate = true) {
+const PROXY_SECRET_LOCK_RETRY_MS = 10;
+const PROXY_SECRET_LOCK_TIMEOUT_MS = 2e3;
+async function withProxySecretFileLock(envPath, effect) {
+  const lockPath = `${envPath}.nuxt-scripts.lock`;
+  const deadline = Date.now() + PROXY_SECRET_LOCK_TIMEOUT_MS;
+  let lockHandle;
+  while (!lockHandle) {
+    const acquisition = await open(lockPath, "wx").then((handle) => ({ _tag: "Acquired", handle })).catch((error) => {
+      if (error.code === "EEXIST")
+        return { _tag: "Busy" };
+      throw error;
+    });
+    if (acquisition._tag === "Acquired") {
+      lockHandle = acquisition.handle;
+      break;
+    }
+    const existingLock = await stat(lockPath).then((lockStat) => ({ _tag: "Found", mtimeMs: lockStat.mtimeMs })).catch((error) => {
+      if (error.code === "ENOENT")
+        return { _tag: "Missing" };
+      throw error;
+    });
+    if (existingLock._tag === "Found" && Date.now() - existingLock.mtimeMs >= PROXY_SECRET_LOCK_TIMEOUT_MS) {
+      await unlink(lockPath).catch((error) => {
+        if (error.code !== "ENOENT")
+          throw error;
+      });
+      continue;
+    }
+    if (Date.now() >= deadline)
+      throw Object.assign(new Error("Timed out waiting for proxy secret file lock"), { code: "ETIMEDOUT" });
+    await setTimeout(PROXY_SECRET_LOCK_RETRY_MS);
+  }
+  let effectResult;
+  try {
+    effectResult = { _tag: "Success", value: effect() };
+  } catch (error) {
+    effectResult = { _tag: "Failure", error };
+  }
+  const closeResult = await lockHandle.close().then(() => ({ _tag: "Success" })).catch((error) => ({ _tag: "Failure", error }));
+  const unlinkResult = await unlink(lockPath).then(() => ({ _tag: "Success" })).catch((error) => error.code === "ENOENT" ? { _tag: "Success" } : { _tag: "Failure", error });
+  if (closeResult._tag === "Failure")
+    logger.warn(`[security] Failed to close the proxy secret lock: ${closeResult.error.message}`);
+  if (unlinkResult._tag === "Failure")
+    logger.warn(`[security] Failed to remove the proxy secret lock: ${unlinkResult.error.message}`);
+  if (effectResult._tag === "Failure")
+    throw effectResult.error;
+  return effectResult.value;
+}
+async function resolveProxySecret(rootDir, isDev, configSecret, autoGenerate = true) {
   if (configSecret)
     return { secret: configSecret, ephemeral: false, source: "config" };
   const envSecret = process.env[PROXY_SECRET_ENV_KEY];
@@ -1817,21 +2002,26 @@ function resolveProxySecret(rootDir, isDev, configSecret, autoGenerate = true) {
   const line = `${PROXY_SECRET_ENV_KEY}=${secret}
 `;
   try {
-    if (existsSync(envPath)) {
-      const contents = readFileSync(envPath, "utf-8");
-      if (PROXY_SECRET_ENV_LINE_RE.test(contents)) {
-        const match = contents.match(PROXY_SECRET_ENV_VALUE_RE);
-        if (match?.[1])
-          return { secret: match[1].trim(), ephemeral: false, source: "dotenv-generated" };
-      }
-      appendFileSync(envPath, contents.endsWith("\n") ? line : `
+    const persistedSecret = await withProxySecretFileLock(envPath, () => {
+      if (existsSync(envPath)) {
+        const contents = readFileSync(envPath, "utf-8");
+        const existingSecret = contents.match(PROXY_SECRET_ENV_VALUE_RE)?.[1]?.trim();
+        if (existingSecret)
+          return existingSecret;
+        if (PROXY_SECRET_ENV_LINE_RE.test(contents)) {
+          writeFileSync(envPath, contents.replace(PROXY_SECRET_ENV_LINE_RE, `${PROXY_SECRET_ENV_KEY}=${secret}`));
+        } else {
+          appendFileSync(envPath, contents.endsWith("\n") ? line : `
 ${line}`);
-    } else {
-      writeFileSync(envPath, `# Generated by @nuxt/scripts
+        }
+      } else {
+        writeFileSync(envPath, `# Generated by @nuxt/scripts
 ${line}`);
-    }
-    process.env[PROXY_SECRET_ENV_KEY] = secret;
-    return { secret, ephemeral: false, source: "dotenv-generated" };
+      }
+      return secret;
+    });
+    process.env[PROXY_SECRET_ENV_KEY] = persistedSecret;
+    return { secret: persistedSecret, ephemeral: false, source: "dotenv-generated" };
   } catch {
     process.env[PROXY_SECRET_ENV_KEY] = secret;
     return { secret, ephemeral: true, source: "memory-generated" };
@@ -1874,7 +2064,10 @@ function resolveConfiguredProxyDomain(value) {
   if (!trimmed || !ABSOLUTE_URL_RE.test(trimmed) && !trimmed.startsWith("//"))
     return;
   try {
-    return new URL(trimmed, "https://nuxt-scripts.local").hostname || void 0;
+    const url = new URL(trimmed, "https://nuxt-scripts.local");
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+      return;
+    return isPublicNetworkHostname(url.hostname) ? url.hostname : void 0;
   } catch {
   }
 }
@@ -1939,6 +2132,14 @@ const module$1 = defineNuxtModule({
       logger.debug("The module is disabled, skipping setup.");
       return;
     }
+    const networkDispatcherAlias = "#nuxt-scripts/network-dispatcher";
+    const nodeNetworkDispatcherPath = await resolvePath("./runtime/server/utils/network-dispatcher.node");
+    const platformNetworkDispatcherPath = await resolvePath("./runtime/server/utils/network-dispatcher.platform");
+    nuxt.options.alias[networkDispatcherAlias] = nodeNetworkDispatcherPath;
+    nuxt.hook("nitro:init", (nitro) => {
+      nitro.options.alias[networkDispatcherAlias] = nitro.options.node ? nodeNetworkDispatcherPath : platformNetworkDispatcherPath;
+    });
+    await setupNitroRuntimeCompatibility(nuxt);
     if (nuxt.options.dev) {
       setupDevtools(nuxt, { standalone: config._standaloneDevtools });
       if (config._standaloneDevtools) {
@@ -1951,9 +2152,21 @@ const module$1 = defineNuxtModule({
         });
       }
     }
-    const { version: unheadVersion } = await readPackageJSON("@unhead/vue", {
-      from: nuxt.options.modulesDir
-    }).catch(() => ({ version: null }));
+    const unheadScriptsAlias = nuxt.options.alias["@unhead/vue/scripts"];
+    const unheadPackagePath = await (typeof unheadScriptsAlias === "string" ? resolvePackageJSON(unheadScriptsAlias) : Promise.reject(new Error("No Unhead scripts alias"))).catch(() => resolvePackageJSON("@unhead/vue", {
+      // Match the package instance imported by the built runtime. An app can
+      // contain another Unhead version with different loader capabilities.
+      from: [resolveModule("./runtime")]
+    })).catch(() => {
+      return null;
+    });
+    const unheadPackage = unheadPackagePath ? await readPackageJSON(unheadPackagePath).catch(() => {
+      return null;
+    }) : null;
+    const unheadVersion = unheadPackage?.version;
+    const scriptsTypesExport = unheadPackage?.exports?.["./scripts"]?.types;
+    const scriptsTypesPath = unheadPackagePath && typeof scriptsTypesExport === "string" ? resolve(dirname(unheadPackagePath), scriptsTypesExport) : null;
+    const unheadSourceLessScriptLoader = hasUnheadSourceLessScriptLoaderFile(scriptsTypesPath);
     if (unheadVersion?.startsWith("1")) {
       logger.error(`Nuxt Scripts requires Unhead >= 2, you are using v${unheadVersion}. Please run \`nuxi upgrade --clean\` to upgrade...`);
     }
@@ -2012,10 +2225,19 @@ const module$1 = defineNuxtModule({
       googleStaticMapsProxy: googleMapsEnabled ? { enabled: true, cacheMaxAge: config.googleStaticMapsProxy?.cacheMaxAge ?? 3600 } : void 0
     };
     const debugConst = JSON.stringify(!!config.debug);
+    const unheadSourceLessConst = JSON.stringify(unheadSourceLessScriptLoader);
     nuxt.options.vite ||= {};
-    nuxt.options.vite.define = { ...nuxt.options.vite.define, __NUXT_SCRIPTS_DEBUG__: debugConst };
+    nuxt.options.vite.define = {
+      ...nuxt.options.vite.define,
+      __NUXT_SCRIPTS_DEBUG__: debugConst,
+      __NUXT_SCRIPTS_UNHEAD_SOURCELESS__: unheadSourceLessConst
+    };
     nuxt.options.nitro ||= {};
-    nuxt.options.nitro.replace = { ...nuxt.options.nitro.replace, __NUXT_SCRIPTS_DEBUG__: debugConst };
+    nuxt.options.nitro.replace = {
+      ...nuxt.options.nitro.replace,
+      __NUXT_SCRIPTS_DEBUG__: debugConst,
+      __NUXT_SCRIPTS_UNHEAD_SOURCELESS__: unheadSourceLessConst
+    };
     const scriptsBase = config.prefix || "/_scripts";
     const proxyPrefix = `${scriptsBase}/p`;
     const assetsPrefix = `${scriptsBase}/assets`;
@@ -2369,6 +2591,7 @@ Options: configure platform rewrites, switch to server-rendered mode, or disable
         );
       }
     }
+    ensureNuxtScriptsCacheStorage(nuxt.options.nitro);
     nuxt.options.runtimeConfig.public["nuxt-scripts"] = defu(
       { endpoints: enabledEndpoints },
       nuxt.options.runtimeConfig.public["nuxt-scripts"]
@@ -2388,7 +2611,7 @@ Options: configure platform rewrites, switch to server-rendered mode, or disable
   To enable signing, deploy with a server-rendered target or configure platform-level rewrites.`
       );
     } else if (anyHandlerRequiresSigning) {
-      const proxySecretResolved = resolveProxySecret(
+      const proxySecretResolved = await resolveProxySecret(
         nuxt.options.rootDir,
         !!nuxt.options.dev,
         config.security?.secret,

package/dist/registry.mjs

@@ -808,8 +808,8 @@ async function registry(resolve) {
 }
 function generatePartytownResolveUrl(proxyPrefix, domainAliases = {}) {
   return `function(url, location, type) {
-  if (url.origin !== location.origin) {
-    var aliases = ${JSON.stringify(domainAliases)};
+  if ((url.protocol === 'http:' || url.protocol === 'https:') && url.origin !== location.origin) {
+    var aliases = Object.assign(Object.create(null), ${JSON.stringify(domainAliases)});
     var seg = aliases[url.host] || url.host;
     return new URL(${JSON.stringify(proxyPrefix)} + '/' + seg + url.pathname + url.search, location.origin);
   }

package/dist/runtime/components/GoogleMaps/ScriptGoogleMaps.vue

@@ -5,10 +5,11 @@ export { MAP_INJECTION_KEY } from "./useGoogleMapsResource";
 <script setup>
 import { defu } from "defu";
 import { tryUseNuxtApp, useHead, useRuntimeConfig } from "nuxt/app";
-import { computed, nextTick, onBeforeUnmount, onMounted, provide, ref, shallowRef, toRaw, useAttrs, useTemplateRef, watch } from "vue";
+import { computed, nextTick, onBeforeUnmount, onMounted, onUnmounted, provide, ref, shallowRef, toRaw, useAttrs, useTemplateRef, watch } from "vue";
 import { useScriptTriggerElement } from "#nuxt-scripts/composables/useScriptTriggerElement";
 import { useScriptGoogleMaps } from "#nuxt-scripts/registry/google-maps";
 import { scriptRuntimeConfig, scriptsPrefix } from "#nuxt-scripts/utils";
+import { createAbortablePromise } from "../../utils/abortable-promise";
 import ScriptAriaLoadingIndicator from "../ScriptAriaLoadingIndicator.vue";
 import { defineDeprecatedAlias, MAP_INJECTION_KEY, waitForMapsReady, warnDeprecatedTopLevelMapProps } from "./useGoogleMapsResource";
 const props = defineProps({
@@ -48,6 +49,8 @@ const currentColorScheme = computed(() => {
   return currentColorMode.value === "dark" ? "DARK" : "LIGHT";
 });
 const mapsApi = shallowRef();
+const lifecycleController = new AbortController();
+let isUnmounted = false;
 if (import.meta.dev) {
   if (!apiKey)
     throw new Error("GoogleMaps requires an API key. Enable it in your nuxt.config:\n\n  scripts: {\n    registry: {\n      googleMaps: true\n    }\n  }\n\nThen set NUXT_PUBLIC_SCRIPTS_GOOGLE_MAPS_API_KEY in your .env file.\n\nAlternatively, pass `api-key` directly on the <ScriptGoogleMaps> component (note: this exposes the key client-side).");
@@ -144,7 +147,8 @@ async function resolveQueryToLatLng(query) {
   const endpoints = runtimeConfig.public["nuxt-scripts"]?.endpoints;
   if (endpoints?.googleMaps) {
     const data = await $fetch(`${scriptsPrefix()}/proxy/google-maps-geocode`, {
-      params: { address: query }
+      params: { address: query },
+      signal: lifecycleController.signal
     });
     if (data.status === "OK" && data.results?.[0]?.geometry?.location) {
       const loc = data.results[0].geometry.location;
@@ -154,7 +158,7 @@ async function resolveQueryToLatLng(query) {
     }
     throw new Error(`No location found for ${query}`);
   }
-  await waitForMapsReady({ mapsApi, map, status, load });
+  await waitForMapsReady({ mapsApi, map, status, load, signal: lifecycleController.signal });
   const placesService = new mapsApi.value.places.PlacesService(map.value);
   const result = await new Promise((resolve, reject) => {
     placesService.findPlaceFromQuery(
@@ -178,14 +182,22 @@ const libraries = /* @__PURE__ */ new Map();
 function importLibrary(key) {
   if (libraries.has(key))
     return libraries.get(key);
-  const p = mapsApi.value?.importLibrary(key) || new Promise((resolve) => {
-    const stop = watch(mapsApi, (api) => {
+  const p = createAbortablePromise((resolve, reject) => {
+    let stop = () => {
+    };
+    stop = watch(mapsApi, (api) => {
       if (api) {
-        const p2 = api.importLibrary(key);
-        resolve(p2);
-        stop();
+        try {
+          resolve(api.importLibrary(key));
+        } catch (error) {
+          reject(error);
+        }
       }
     }, { immediate: true });
+    return () => stop();
+  }, {
+    signal: lifecycleController.signal,
+    abortMessage: `Google Maps library import "${key}" was aborted`
   });
   const cached = Promise.resolve(p).catch((err) => {
     libraries.delete(key);
@@ -251,13 +263,15 @@ onMounted(() => {
     const zoom = map.value.getZoom();
     if (center)
       centerOverride.value = { lat: center.lat(), lng: center.lng() };
-    map.value.unbindAll();
+    const previousMap = map.value;
+    mapsApi.value.event.clearInstanceListeners(previousMap);
+    previousMap.unbindAll();
     map.value = void 0;
     slotMounted.value = false;
     if (mapEl.value)
       mapEl.value.innerHTML = "";
     await nextTick();
-    if (!mapEl.value || !mapsApi.value)
+    if (isUnmounted || !mapEl.value || !mapsApi.value)
       return;
     const _options = {
       ...options.value,
@@ -276,40 +290,66 @@ onMounted(() => {
   watch([() => getCenterWatchKey(props.center), () => getCenterWatchKey(props.mapOptions?.center)], () => {
     centerOverride.value = void 0;
   });
-  watch([controlledCenterKey, isMapReady, map], async () => {
-    if (!map.value) {
+  watch([controlledCenterKey, isMapReady, map], async (_, __, onCleanup) => {
+    const currentMap = map.value;
+    if (!currentMap) {
       return;
     }
+    let stale = false;
+    onCleanup(() => {
+      stale = true;
+    });
     let center = toRaw(options.value.center);
     if (center) {
       if (isLocationQuery(center) && isMapReady.value) {
-        center = await resolveQueryToLatLng(center);
+        try {
+          center = await resolveQueryToLatLng(center);
+        } catch (error) {
+          if (error?.name === "AbortError")
+            return;
+          throw error;
+        }
       }
-      const current = map.value.getCenter();
+      if (stale || isUnmounted || map.value !== currentMap)
+        return;
+      const current = currentMap.getCenter();
       if (current) {
         const newLat = typeof center.lat === "function" ? center.lat() : center.lat;
         const newLng = typeof center.lng === "function" ? center.lng() : center.lng;
         if (current.lat() === newLat && current.lng() === newLng)
           return;
       }
-      map.value.setCenter(center);
+      currentMap.setCenter(center);
     }
   }, {
     immediate: true
   });
   onLoaded(async (instance) => {
-    mapsApi.value = await instance.maps;
+    const api = await instance.maps;
+    if (isUnmounted || !mapEl.value)
+      return;
+    mapsApi.value = api;
     const center = options.value.center;
     const _options = {
       ...options.value,
       // @ts-expect-error broken
       center: !center || isLocationQuery(center) ? void 0 : center
     };
-    map.value = new mapsApi.value.Map(mapEl.value, _options);
+    map.value = new api.Map(mapEl.value, _options);
     if (center && isLocationQuery(center)) {
-      centerOverride.value = await resolveQueryToLatLng(center);
-      if (centerOverride.value)
-        map.value?.setCenter(centerOverride.value);
+      let resolvedCenter;
+      try {
+        resolvedCenter = await resolveQueryToLatLng(center);
+      } catch (error) {
+        if (error?.name === "AbortError")
+          return;
+        throw error;
+      }
+      if (isUnmounted)
+        return;
+      centerOverride.value = resolvedCenter;
+      if (resolvedCenter)
+        map.value?.setCenter(resolvedCenter);
     }
     isMapReady.value = true;
   });
@@ -356,11 +396,21 @@ const rootAttrs = computed(() => {
   });
 });
 onBeforeUnmount(() => {
-  map.value?.unbindAll();
+  isUnmounted = true;
+  lifecycleController.abort();
+  if (map.value && mapsApi.value) {
+    mapsApi.value.event.clearInstanceListeners(map.value);
+    map.value.unbindAll();
+  }
   map.value = void 0;
+  activeInfoWindow?.close();
+  activeInfoWindow = void 0;
   libraries.clear();
   queryToLatLngCache.clear();
 });
+onUnmounted(() => {
+  mapsApi.value = void 0;
+});
 </script>
 
 <template>