nuxt-nightly 4.1.2-29293231.4568e845 → 4.1.2-29293741.3f7624b3

package/dist/app/composables/preload.js

@@ -42,8 +42,11 @@ export async function preloadRouteComponents(to, router = useRouter()) {
     return Promise.all(promises).then(() => preloadRouteComponents(to, router));
   }
   router._routePreloaded.add(path);
-  const components = matched.map((component) => component.components?.default).filter((component) => typeof component === "function");
-  for (const component of components) {
+  for (const route of matched) {
+    const component = route.components?.default;
+    if (typeof component !== "function") {
+      continue;
+    }
     const promise = Promise.resolve(component()).catch(() => {
     }).finally(() => promises.splice(promises.indexOf(promise)));
     promises.push(promise);

package/dist/app/composables/router.js

@@ -66,8 +66,13 @@ export const navigateTo = (to, options) => {
   const toPath = typeof to === "string" ? to : "path" in to ? resolveRouteObject(to) : useRouter().resolve(to).href;
   if (import.meta.client && options?.open) {
     const { target = "_blank", windowFeatures = {} } = options.open;
-    const features = Object.entries(windowFeatures).filter(([_, value]) => value !== void 0).map(([feature, value]) => `${feature.toLowerCase()}=${value}`).join(", ");
-    open(toPath, target, features);
+    const features = [];
+    for (const [feature, value] of Object.entries(windowFeatures)) {
+      if (value !== void 0) {
+        features.push(`${feature.toLowerCase()}=${value}`);
+      }
+    }
+    open(toPath, target, features.join(", "));
     return Promise.resolve();
   }
   const isExternalHost = hasProtocol(toPath, { acceptRelative: true });

package/dist/app/nuxt.js

@@ -260,7 +260,10 @@ function wrappedConfig(runtimeConfig) {
   if (!import.meta.dev || import.meta.server) {
     return runtimeConfig;
   }
-  const keys = Object.keys(runtimeConfig).map((key) => `\`${key}\``);
+  const keys = [];
+  for (const key in runtimeConfig) {
+    keys.push(`\`${key}\``);
+  }
   const lastKey = keys.pop();
   return new Proxy(runtimeConfig, {
     get(target, p, receiver) {

package/dist/core/runtime/nitro/handlers/renderer.js

@@ -213,7 +213,14 @@ export default defineRenderHandler(async (event) => {
   };
 });
 function normalizeChunks(chunks) {
-  return chunks.filter(Boolean).map((i) => i.trim());
+  const result = [];
+  for (const _chunk of chunks) {
+    const chunk = _chunk?.trim();
+    if (chunk) {
+      result.push(chunk);
+    }
+  }
+  return result;
 }
 function joinTags(tags) {
   return tags.join("");

package/dist/core/runtime/nitro/utils/renderer/build-files.js

@@ -86,9 +86,12 @@ export function getRenderer(ssrContext) {
   return process.env.NUXT_NO_SSR || ssrContext.noSSR ? getSPARenderer() : getSSRRenderer();
 }
 export const getSSRStyles = lazyCachedFunction(() => import("#build/dist/server/styles.mjs").then((r) => r.default || r));
-export const getEntryIds = () => getClientManifest().then((r) => Object.values(r).filter(
-  (r2) => (
-    // @ts-expect-error internal key set by CSS inlining configuration
-    r2._globalCSS
-  )
-).map((r2) => r2.src));
+export const getEntryIds = () => getClientManifest().then((r) => {
+  const entryIds = [];
+  for (const entry of Object.values(r)) {
+    if (entry._globalCSS) {
+      entryIds.push(entry.src);
+    }
+  }
+  return entryIds;
+});

package/dist/head/runtime/components.js

@@ -103,9 +103,16 @@ export const NoScript = defineComponent({
     return () => {
       const noscript = normalizeProps(props);
       const slotVnodes = slots.default?.();
-      const textContent = slotVnodes ? slotVnodes.filter(({ children }) => children).map(({ children }) => children).join("") : "";
-      if (textContent) {
-        noscript.innerHTML = textContent;
+      const textContent = [];
+      if (slotVnodes) {
+        for (const vnode of slotVnodes) {
+          if (vnode.children) {
+            textContent.push(vnode.children);
+          }
+        }
+      }
+      if (textContent.length > 0) {
+        noscript.innerHTML = textContent.join("");
       }
       input.noscript[idx] = noscript;
       return null;

package/dist/index.mjs

@@ -1325,7 +1325,9 @@ const pagesModule = defineNuxtModule({
         dts: resolve(nuxt.options.buildDir, declarationFile),
         logs: nuxt.options.debug && nuxt.options.debug.router,
         async beforeWriteFiles(rootPage) {
-          rootPage.children.forEach((child) => child.delete());
+          for (const child of rootPage.children) {
+            child.delete();
+          }
           const pages = nuxt.apps.default?.pages || await resolvePagesRoutes$1(options.pattern, nuxt);
           if (nuxt.apps.default) {
             nuxt.apps.default.pages = pages;
@@ -1345,7 +1347,9 @@ const pagesModule = defineNuxtModule({
               route.name = page.name;
             }
             if (page.children) {
-              page.children.forEach((child) => addPage(route, child, absolutePagePath));
+              for (const child of page.children) {
+                addPage(route, child, absolutePagePath);
+              }
             }
           }
           for (const page of pages) {
@@ -1580,10 +1584,20 @@ const pagesModule = defineNuxtModule({
       getContents: async ({ nuxt: nuxt2 }) => {
         const routerOptionsFiles = await resolveRouterOptions(nuxt2, builtInRouterOptions);
         const configRouterOptions = genObjectFromRawEntries(Object.entries(nuxt2.options.router.options).map(([key, value]) => [key, genString(value)]));
+        const hashModes = [];
+        for (let index = 0; index < routerOptionsFiles.length; index++) {
+          const file = routerOptionsFiles[index];
+          if (file.path !== builtInRouterOptions) {
+            hashModes.unshift(`routerOptions${index}.hashMode`);
+          }
+        }
         return [
           ...routerOptionsFiles.map((file, index) => genImport(file.path, `routerOptions${index}`)),
           `const configRouterOptions = ${configRouterOptions}`,
-          `export const hashMode = ${[...routerOptionsFiles.filter((o) => o.path !== builtInRouterOptions).map((_, index) => `routerOptions${index}.hashMode`).reverse(), nuxt2.options.router.options.hashMode].join(" ?? ")}`,
+          `export const hashMode = ${[
+            ...hashModes,
+            nuxt2.options.router.options.hashMode
+          ].join(" ?? ")}`,
           "export default {",
           "...configRouterOptions,",
           ...routerOptionsFiles.map((_, index) => `...routerOptions${index},`),
@@ -2144,7 +2158,13 @@ export default defineNuxtPlugin({
 const componentNamesTemplate = {
   filename: "component-names.mjs",
   getContents({ app }) {
-    return `export const componentNames = ${JSON.stringify(app.components.filter((c) => !c.island).map((c) => c.pascalName))}`;
+    const componentNames = [];
+    for (const c of app.components) {
+      if (!c.island) {
+        componentNames.push(c.pascalName);
+      }
+    }
+    return `export const componentNames = ${JSON.stringify(componentNames)}`;
   }
 };
 const componentsIslandsTemplate = {
@@ -2179,14 +2199,17 @@ const componentsIslandsTemplate = {
 const NON_VUE_RE = /\b\.(?!vue)\w+$/g;
 function resolveComponentTypes(app, baseDir) {
   const serverPlaceholderPath = resolve(distDir, "app/components/server-placeholder");
-  const componentTypes = app.components.filter((c) => !c.island).map((c) => {
-    const type = `typeof ${genDynamicImport(isAbsolute(c.filePath) ? relative(baseDir, c.filePath).replace(NON_VUE_RE, "") : c.filePath.replace(NON_VUE_RE, ""), { wrapper: false })}['${c.export}']`;
-    const isServerOnly = c.mode === "server" && c.filePath !== serverPlaceholderPath && !app.components.some((other) => other.pascalName === c.pascalName && other.mode === "client");
-    return [
-      c.pascalName,
-      isServerOnly ? `IslandComponent<${type}>` : type
-    ];
-  });
+  const componentTypes = [];
+  for (const c of app.components) {
+    if (!c.island) {
+      const type = `typeof ${genDynamicImport(isAbsolute(c.filePath) ? relative(baseDir, c.filePath).replace(NON_VUE_RE, "") : c.filePath.replace(NON_VUE_RE, ""), { wrapper: false })}['${c.export}']`;
+      const isServerOnly = c.mode === "server" && c.filePath !== serverPlaceholderPath && !app.components.some((other) => other.pascalName === c.pascalName && other.mode === "client");
+      componentTypes.push([
+        c.pascalName,
+        isServerOnly ? `IslandComponent<${type}>` : type
+      ]);
+    }
+  }
   return componentTypes;
 }
 const islandType = "type IslandComponent<T extends DefineComponent> = T & DefineComponent<{}, {refresh: () => Promise<void>}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, SlotsType<{ fallback: { error: unknown } }>>";
@@ -2642,7 +2665,13 @@ function getPropsToString(bindings) {
   if (Object.keys(bindings).length === 0) {
     return "undefined";
   }
-  const content = Object.entries(bindings).filter((b) => b[0] && (b[0] !== "_bind" && b[0] !== "v-for")).map(([name, value]) => isBinding(name) ? `[\`${name.slice(1)}\`]: ${value}` : `[\`${name}\`]: \`${value}\``).join(",");
+  const contentParts = [];
+  for (const [name, value] of Object.entries(bindings)) {
+    if (name && (name !== "_bind" && name !== "v-for")) {
+      contentParts.push(isBinding(name) ? `[\`${name.slice(1)}\`]: ${value}` : `[\`${name}\`]: \`${value}\``);
+    }
+  }
+  const content = contentParts.join(",");
   const data = bindings._bind ? `__mergeProps(${bindings._bind}, { ${content} })` : `{ ${content} }`;
   if (!vfor) {
     return `[${data}]`;
@@ -3355,7 +3384,7 @@ const componentsModule = defineNuxtModule({
   defaults: {
     dirs: []
   },
-  async setup(componentOptions, nuxt) {
+  async setup(moduleOptions, nuxt) {
     let componentDirs = [];
     const context = {
       components: []
@@ -3367,52 +3396,40 @@ const componentsModule = defineNuxtModule({
       addBuildPlugin(ComponentNamePlugin({ sourcemap: !!nuxt.options.sourcemap.client, getComponents }), { server: false });
       addBuildPlugin(ComponentNamePlugin({ sourcemap: !!nuxt.options.sourcemap.server, getComponents }), { client: false });
     }
-    const normalizeDirs = (dir, cwd, options) => {
-      if (Array.isArray(dir)) {
-        return dir.map((dir2) => normalizeDirs(dir2, cwd, options)).flat().sort(compareDirByPathLength);
-      }
-      if (dir === true || dir === void 0) {
-        return [
-          { priority: options?.priority || 0, path: resolve(cwd, "components/islands"), island: true },
-          { priority: options?.priority || 0, path: resolve(cwd, "components/global"), global: true },
-          { priority: options?.priority || 0, path: resolve(cwd, "components") }
-        ];
-      }
-      if (typeof dir === "string") {
-        return [
-          { priority: options?.priority || 0, path: resolve(cwd, resolveAlias$1(dir)) }
-        ];
-      }
-      if (!dir) {
-        return [];
-      }
-      const dirs = (dir.dirs || [dir]).map((dir2) => typeof dir2 === "string" ? { path: dir2 } : dir2).filter((_dir) => _dir.path);
-      return dirs.map((_dir) => ({
-        priority: options?.priority || 0,
-        ..._dir,
-        path: resolve(cwd, resolveAlias$1(_dir.path))
-      }));
-    };
     nuxt.hook("app:resolve", async () => {
-      const allDirs = nuxt.options._layers.map((layer) => normalizeDirs(layer.config.components, layer.config.srcDir, { priority: layer.config.srcDir === nuxt.options.srcDir ? 1 : 0 })).flat();
+      const allDirs = [];
+      for (const layer of nuxt.options._layers) {
+        const layerDirs = normalizeDirs(layer.config.components, layer.config.srcDir, { priority: layer.config.srcDir === nuxt.options.srcDir ? 1 : 0 });
+        allDirs.push(...layerDirs);
+      }
       await nuxt.callHook("components:dirs", allDirs);
-      componentDirs = allDirs.filter(isPureObjectOrString).map((dir) => {
+      const userComponentDirs = [];
+      const libraryComponentDirs = [];
+      for (const dir of allDirs) {
+        if (!isPureObjectOrString(dir)) {
+          continue;
+        }
         const dirOptions = typeof dir === "object" ? dir : { path: dir };
         const dirPath = resolveAlias$1(dirOptions.path);
-        const transpile = typeof dirOptions.transpile === "boolean" ? dirOptions.transpile : "auto";
         const extensions = (dirOptions.extensions || nuxt.options.extensions).map((e) => e.replace(STARTER_DOT_RE, ""));
+        const _transpile = typeof dirOptions.transpile === "boolean" ? dirOptions.transpile : "auto";
+        const transpile = _transpile === "auto" ? dirPath.includes("node_modules") : _transpile;
+        if (transpile) {
+          nuxt.options.build.transpile.push(dirPath);
+        }
         const present = isDirectory(dirPath);
         if (!present && !DEFAULT_COMPONENTS_DIRS_RE.test(dirOptions.path)) {
           logger.warn("Components directory not found: `" + dirPath + "`");
         }
-        return {
-          global: componentOptions.global,
+        const dirs = dirPath.includes("node_modules") ? libraryComponentDirs : userComponentDirs;
+        dirs.push({
+          global: moduleOptions.global,
           ...dirOptions,
           // TODO: https://github.com/nuxt/framework/pull/251
           enabled: true,
           path: dirPath,
           extensions,
-          pattern: dirOptions.pattern || `**/*.{${extensions.join(",")},}`,
+          pattern: dirOptions.pattern || (extensions.length > 1 ? `**/*.{${extensions.join(",")}}` : `**/*.${extensions[0] || "*"}`),
           ignore: [
             "**/*{M,.m,-m}ixin.{js,ts,jsx,tsx}",
             // ignore mixins
@@ -3420,21 +3437,20 @@ const componentsModule = defineNuxtModule({
             // .d.ts files
             ...dirOptions.ignore || []
           ],
-          transpile: transpile === "auto" ? dirPath.includes("node_modules") : transpile
-        };
-      }).filter((d) => d.enabled);
+          transpile
+        });
+      }
       componentDirs = [
-        ...componentDirs.filter((dir) => !dir.path.includes("node_modules")),
-        ...componentDirs.filter((dir) => dir.path.includes("node_modules"))
+        ...userComponentDirs,
+        ...libraryComponentDirs
       ];
-      nuxt.options.build.transpile.push(...componentDirs.filter((dir) => dir.transpile).map((dir) => dir.path));
     });
     addTemplate(componentsDeclarationTemplate);
     addTypeTemplate(componentsTypeTemplate);
     addPluginTemplate(componentsPluginTemplate);
     addTemplate(componentNamesTemplate);
     addTemplate({ ...componentsIslandsTemplate, filename: "components.islands.mjs" });
-    if (componentOptions.generateMetadata) {
+    if (moduleOptions.generateMetadata) {
       addTemplate(componentsMetadataTemplate);
     }
     const serverComponentRuntime = await findPath(join(distDir, "components/runtime/server-component")) ?? join(distDir, "components/runtime/server-component");
@@ -3543,6 +3559,39 @@ const componentsModule = defineNuxtModule({
     }
   }
 });
+function normalizeDirs(dir, cwd, options) {
+  if (Array.isArray(dir)) {
+    return dir.map((dir2) => normalizeDirs(dir2, cwd, options)).flat().sort(compareDirByPathLength);
+  }
+  if (dir === true || dir === void 0) {
+    return [
+      { priority: options?.priority || 0, path: resolve(cwd, "components/islands"), island: true },
+      { priority: options?.priority || 0, path: resolve(cwd, "components/global"), global: true },
+      { priority: options?.priority || 0, path: resolve(cwd, "components") }
+    ];
+  }
+  if (typeof dir === "string") {
+    return [
+      { priority: options?.priority || 0, path: resolve(cwd, resolveAlias$1(dir)) }
+    ];
+  }
+  if (!dir) {
+    return [];
+  }
+  const normalizedDirs = [];
+  for (const d of "dirs" in dir ? dir.dirs || [] : [dir]) {
+    const normalizedDir = typeof d === "string" ? { path: d } : d;
+    if (!normalizedDir.path) {
+      continue;
+    }
+    normalizedDirs.push({
+      priority: options?.priority || 0,
+      ...normalizedDir,
+      path: resolve(cwd, resolveAlias$1(normalizedDir.path))
+    });
+  }
+  return normalizedDirs.sort(compareDirByPathLength);
+}
 
 const NODE_MODULES_RE$1 = /[\\/]node_modules[\\/]/;
 const IMPORTS_RE = /(['"])#imports\1/;
@@ -3769,7 +3818,7 @@ function addDeclarationTemplates(ctx, options) {
   });
 }
 
-const version = "4.1.2-29293231.4568e845";
+const version = "4.1.2-29293741.3f7624b3";
 
 const createImportProtectionPatterns = (nuxt, options) => {
   const patterns = [];
@@ -4011,20 +4060,26 @@ const LayerAliasingPlugin = (options) => createUnplugin((_options, meta) => {
   };
 });
 
-const addModuleTranspiles = (opts = {}) => {
-  const nuxt = useNuxt();
-  const modules = [
-    ...opts.additionalModules || [],
-    ...nuxt.options.modules,
-    ...nuxt.options._modules
-  ].map((m) => typeof m === "string" ? m : Array.isArray(m) ? m[0] : m.src).filter((m) => typeof m === "string").map(normalizeModuleTranspilePath);
-  nuxt.options.build.transpile = nuxt.options.build.transpile.map((m) => typeof m === "string" ? m.split("node_modules/").pop() : m).filter((x) => !!x);
-  function isTranspilePresent(mod) {
-    return nuxt.options.build.transpile.some((t) => !(t instanceof Function) && (t instanceof RegExp ? t.test(mod) : new RegExp(t).test(mod)));
+const addModuleTranspiles = (nuxt) => {
+  const transpile = [];
+  for (const t of nuxt.options.build.transpile) {
+    if (t instanceof Function) {
+      continue;
+    }
+    if (typeof t === "string") {
+      transpile.push(new RegExp(escapeRE(t)));
+    } else {
+      transpile.push(t);
+    }
   }
-  for (const module of modules) {
-    if (!isTranspilePresent(module)) {
-      nuxt.options.build.transpile.push(module);
+  for (const m of [...nuxt.options.modules, ...nuxt.options._modules]) {
+    const mod = typeof m === "string" ? m : Array.isArray(m) ? m[0] : m.src;
+    if (typeof mod !== "string") {
+      continue;
+    }
+    const path = normalizeModuleTranspilePath(mod);
+    if (!transpile.some((t) => t.test(path))) {
+      nuxt.options.build.transpile.push(path);
     }
   }
 };
@@ -4042,10 +4097,24 @@ const NODE_MODULES_RE = /(?<=\/)node_modules\/(.+)$/;
 const PNPM_NODE_MODULES_RE = /\.pnpm\/.+\/node_modules\/(.+)$/;
 async function initNitro(nuxt) {
   const layerDirs = getLayerDirectories(nuxt);
-  const excludePaths = layerDirs.flatMap((dirs) => [
-    dirs.root.match(NODE_MODULES_RE)?.[1]?.replace(/\/$/, ""),
-    dirs.root.match(PNPM_NODE_MODULES_RE)?.[1]?.replace(/\/$/, "")
-  ].filter((dir) => Boolean(dir)).map((dir) => escapeRE(dir)));
+  const excludePaths = [];
+  for (const dirs of layerDirs) {
+    const paths = [
+      dirs.root.match(NODE_MODULES_RE)?.[1]?.replace(/\/$/, ""),
+      dirs.root.match(PNPM_NODE_MODULES_RE)?.[1]?.replace(/\/$/, "")
+    ];
+    for (const dir of paths) {
+      if (dir) {
+        excludePaths.push(escapeRE(dir));
+      }
+    }
+  }
+  const layerPublicAssetsDirs = [];
+  for (const dirs of layerDirs) {
+    if (existsSync(dirs.public)) {
+      layerPublicAssetsDirs.push({ dir: dirs.public });
+    }
+  }
   const excludePattern = excludePaths.length ? [new RegExp(`node_modules\\/(?!${excludePaths.join("|")})`)] : [/node_modules/];
   const rootDirWithSlash = withTrailingSlash$1(nuxt.options.rootDir);
   const moduleEntryPaths = [];
@@ -4150,7 +4219,7 @@ async function initNitro(nuxt) {
               join(moduleDir, "dist/runtime/server")
             ];
           }),
-          ...getLayerDirectories(nuxt).map((dirs) => relativeWithDot(nuxt.options.buildDir, join(dirs.shared, "**/*.d.ts")))
+          ...layerDirs.map((dirs) => relativeWithDot(nuxt.options.buildDir, join(dirs.shared, "**/*.d.ts")))
         ],
         exclude: [
           ...nuxt.options.modulesDir.map((m) => relativeWithDot(nuxt.options.buildDir, m)),
@@ -4165,7 +4234,7 @@ async function initNitro(nuxt) {
         maxAge: 31536e3,
         baseURL: nuxt.options.app.buildAssetsDir
       },
-      ...getLayerDirectories(nuxt).filter((dirs) => existsSync(dirs.public)).map((dirs) => ({ dir: dirs.public }))
+      ...layerPublicAssetsDirs
     ],
     prerender: {
       ignoreUnprefixedPublicAssets: true,
@@ -4187,7 +4256,7 @@ async function initNitro(nuxt) {
         "nuxt-nightly/dist",
         distDir,
         // Ensure app config files have auto-imports injected even if they are pure .js files
-        ...getLayerDirectories(nuxt).map((dirs) => join(dirs.app, "app.config"))
+        ...layerDirs.map((dirs) => join(dirs.app, "app.config"))
       ],
       traceInclude: [
         // force include files used in generated code from the runtime-compiler
@@ -5651,9 +5720,11 @@ Using \`${fallbackCompatibilityDate}\` as fallback. More info at: ${colors.under
     });
   }
   nuxt.options.build.transpile.push("nuxt/app");
-  nuxt.options.build.transpile.push(
-    ...layerDirs.filter((i) => i.root.includes("node_modules")).map((i) => i.root.replace(/\/$/, ""))
-  );
+  for (const layer of layerDirs) {
+    if (layer.root.includes("node_modules")) {
+      nuxt.options.build.transpile.push(layer.root.replace(/\/$/, ""));
+    }
+  }
   const locallyScannedLayersDirs = layerDirs.map((l) => join(l.root, "layers/"));
   const rootWithTrailingSlash = withTrailingSlash(nuxt.options.rootDir);
   for (const dirs of layerDirs) {
@@ -5879,8 +5950,13 @@ export default defineNuxtPlugin({
       return nuxt.callHook("restart");
     }
   });
-  nuxt.options.build.transpile = nuxt.options.build.transpile.map((t) => typeof t === "string" ? normalize(t) : t);
-  addModuleTranspiles();
+  nuxt.options.build.transpile = nuxt.options.build.transpile.map((t) => {
+    if (typeof t !== "string") {
+      return t;
+    }
+    return normalize(t).split("node_modules/").pop();
+  });
+  addModuleTranspiles(nuxt);
   await initNitro(nuxt);
   const nitro = useNitro();
   if (nitro.options.static && nuxt.options.experimental.payloadExtraction === void 0) {
@@ -5926,9 +6002,15 @@ async function loadNuxt(opts) {
     }
   }
   options._modules.push(pagesModule, metaModule, componentsModule);
+  const importIncludes = [];
+  for (const layer of options._layers) {
+    if (layer.cwd && layer.cwd.includes("node_modules")) {
+      importIncludes.push(new RegExp(`(^|\\/)${escapeRE(layer.cwd.split("node_modules/").pop())}(\\/|$)(?!node_modules\\/)`));
+    }
+  }
   options._modules.push([importsModule, {
     transform: {
-      include: options._layers.filter((i) => i.cwd && i.cwd.includes("node_modules")).map((i) => new RegExp(`(^|\\/)${escapeRE(i.cwd.split("node_modules/").pop())}(\\/|$)(?!node_modules\\/)`))
+      include: importIncludes
     }
   }]);
   options._modules.push(schemaModule);

package/dist/pages/runtime/page.js

@@ -170,10 +170,16 @@ export default defineComponent({
   }
 });
 function _mergeTransitionProps(routeProps) {
-  const _props = routeProps.filter(Boolean).map((prop) => ({
-    ...prop,
-    onAfterLeave: prop.onAfterLeave ? toArray(prop.onAfterLeave) : void 0
-  }));
+  const _props = [];
+  for (const prop of routeProps) {
+    if (!prop) {
+      continue;
+    }
+    _props.push({
+      ...prop,
+      onAfterLeave: prop.onAfterLeave ? toArray(prop.onAfterLeave) : void 0
+    });
+  }
   return defu(..._props);
 }
 function haveParentRoutesRendered(fork, newRoute, Component) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-nightly",
-  "version": "4.1.2-29293231.4568e845",
+  "version": "4.1.2-29293741.3f7624b3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/nuxt.git",
@@ -67,10 +67,10 @@
     "@nuxt/cli": "npm:@nuxt/cli-nightly@latest",
     "@nuxt/devalue": "^2.0.2",
     "@nuxt/devtools": "^2.6.3",
-    "@nuxt/kit": "npm:@nuxt/kit-nightly@4.1.2-29293231.4568e845",
-    "@nuxt/schema": "npm:@nuxt/schema-nightly@4.1.2-29293231.4568e845",
+    "@nuxt/kit": "npm:@nuxt/kit-nightly@4.1.2-29293741.3f7624b3",
+    "@nuxt/schema": "npm:@nuxt/schema-nightly@4.1.2-29293741.3f7624b3",
     "@nuxt/telemetry": "^2.6.6",
-    "@nuxt/vite-builder": "npm:@nuxt/vite-builder-nightly@4.1.2-29293231.4568e845",
+    "@nuxt/vite-builder": "npm:@nuxt/vite-builder-nightly@4.1.2-29293741.3f7624b3",
     "@unhead/vue": "^2.0.14",
     "@vue/shared": "^3.5.21",
     "c12": "^3.2.0",