@nuxt/kit 3.0.0-rc.1 → 3.0.0-rc.11

package/dist/index.d.ts

@@ -1,11 +1,13 @@
-import { Nuxt, ModuleContainer, ModuleOptions, ModuleDefinition, NuxtModule, NuxtConfig, NuxtOptions, NuxtCompatibility, NuxtCompatibilityIssues, ComponentsDir, Component, NuxtHooks, NuxtPlugin, NuxtPluginTemplate, NuxtTemplate } from '@nuxt/schema';
+import { Nuxt, ModuleContainer, ModuleOptions, ModuleDefinition, NuxtModule, NuxtConfig, NuxtOptions, ImportPresetWithDeprecation, NuxtCompatibility, NuxtCompatibilityIssues, ComponentsDir, Component, NuxtTemplate, NuxtHooks, NuxtPlugin, NuxtPluginTemplate, ResolvedNuxtTemplate } from '@nuxt/schema';
 import { LoadConfigOptions } from 'c12';
 import { Import } from 'unimport';
 import { Configuration, WebpackPluginInstance } from 'webpack';
 import { UserConfig, Plugin } from 'vite';
 import * as unctx from 'unctx';
 import { Middleware } from 'h3';
+import { NitroEventHandler, NitroDevEventHandler, Nitro } from 'nitropack';
 import * as consola from 'consola';
+import { genSafeVariableName } from 'knitwork';
 
 declare function useModuleContainer(nuxt?: Nuxt): ModuleContainer;
 
@@ -35,8 +37,17 @@ interface LoadNuxtOptions extends LoadNuxtConfigOptions {
 declare function loadNuxt(opts: LoadNuxtOptions): Promise<Nuxt>;
 declare function buildNuxt(nuxt: Nuxt): Promise<any>;
 
-declare function addAutoImport(imports: Import | Import[]): void;
-declare function addAutoImportDir(_autoImportDirs: string | string[]): void;
+declare function addImports(imports: Import | Import[]): void;
+/**
+ * @deprecated Please use `addImports` instead with nuxt>=3.0.0-rc.9
+ */
+declare const addAutoImport: typeof addImports;
+declare function addImportsDir(dirs: string | string[]): void;
+/**
+ * @deprecated Please use `addImportsDir` instead with nuxt>=3.0.0-rc.9
+ */
+declare const addAutoImportDir: typeof addImportsDir;
+declare function addImportsSources(presets: ImportPresetWithDeprecation | ImportPresetWithDeprecation[]): void;
 
 interface ExtendConfigOptions {
     /**
@@ -51,8 +62,6 @@ interface ExtendConfigOptions {
      * @default true
      */
     build?: boolean;
-}
-interface ExtendWebpackConfigOptions extends ExtendConfigOptions {
     /**
      * Install plugin on server side
      *
@@ -65,6 +74,8 @@ interface ExtendWebpackConfigOptions extends ExtendConfigOptions {
      * @default true
      */
     client?: boolean;
+}
+interface ExtendWebpackConfigOptions extends ExtendConfigOptions {
     /**
      * Install plugin on modern build
      *
@@ -85,7 +96,7 @@ declare function extendWebpackConfig(fn: ((config: Configuration) => void), opti
 /**
  * Extend Vite config
  */
-declare function extendViteConfig(fn: ((config: UserConfig) => void), options?: ExtendViteConfigOptions): void;
+declare function extendViteConfig(fn: ((config: UserConfig) => void), options?: ExtendViteConfigOptions): (() => void) | undefined;
 /**
  * Append Webpack plugin to the config.
  */
@@ -170,6 +181,8 @@ declare function tryUseNuxt(): Nuxt | null;
  */
 declare function isIgnored(pathname: string): boolean;
 
+declare function addLayout(this: any, template: NuxtTemplate, name?: string): void;
+
 declare function extendPages(cb: NuxtHooks['pages:extend']): void;
 
 /**
@@ -224,30 +237,64 @@ declare function findPath(paths: string | string[], opts?: ResolvePathOptions, p
  */
 declare function resolveAlias(path: string, alias?: Record<string, string>): string;
 interface Resolver {
-    resolve(...path: any[]): string;
+    resolve(...path: string[]): string;
     resolvePath(path: string, opts?: ResolvePathOptions): Promise<string>;
 }
 /**
  * Create a relative resolver
  */
 declare function createResolver(base: string | URL): Resolver;
-declare function resolveFiles(path: string, pattern: string | string[]): Promise<string[]>;
+declare function resolveFiles(path: string, pattern: string | string[], opts?: {
+    followSymbolicLinks?: boolean;
+}): Promise<string[]>;
 
-interface ServerMiddleware {
+interface LegacyServerMiddleware {
     route?: string;
+    path?: string;
+    handle?: Middleware | string;
     handler: Middleware | string;
 }
-/** Adds a new server middleware to the end of the server middleware array. */
-declare function addServerMiddleware(middleware: ServerMiddleware): void;
+/**
+ * Adds a new server middleware to the end of the server middleware array.
+ *
+ * @deprecated Use addServerHandler instead
+ */
+declare function addServerMiddleware(middleware: LegacyServerMiddleware): void;
+/**
+ * Adds a nitro server handler
+ *
+ */
+declare function addServerHandler(handler: NitroEventHandler): void;
+/**
+ * Adds a nitro server handler for development-only
+ *
+ */
+declare function addDevServerHandler(handler: NitroDevEventHandler): void;
+/**
+ * Access to the Nitro instance
+ *
+ * **Note:** You can call `useNitro()` only after `ready` hook.
+ *
+ * **Note:** Changes to the Nitro instance configuration are not applied.
+ *
+ * @example
+ *
+ * ```ts
+ * nuxt.hook('ready', () => {
+ *   console.log(useNitro())
+ * })
+ * ```
+ */
+declare function useNitro(): Nitro;
 
 /**
  * Renders given template using lodash template during build into the project buildDir
  */
-declare function addTemplate(_template: NuxtTemplate | string): NuxtTemplate;
+declare function addTemplate(_template: NuxtTemplate<any> | string): ResolvedNuxtTemplate<any>;
 /**
  * Normalize a nuxt template object
  */
-declare function normalizeTemplate(template: NuxtTemplate | string): NuxtTemplate;
+declare function normalizeTemplate(template: NuxtTemplate<any> | string): ResolvedNuxtTemplate<any>;
 
 declare const logger: consola.Consola;
 declare function useLogger(scope?: string): consola.Consola;
@@ -265,7 +312,7 @@ declare function isNodeModules(id: string): boolean;
 declare function clearRequireCache(id: string): void;
 declare function scanRequireTree(id: string, files?: Set<string>): Set<string>;
 /** Access the require cache by module id. */
-declare function getRequireCacheItem(id: string): NodeModule;
+declare function getRequireCacheItem(id: string): NodeModule | undefined;
 /** Resolve the `package.json` file for a given module. */
 declare function requireModulePkg(id: string, opts?: RequireModuleOptions): any;
 /** Resolve the path of a module. */
@@ -275,17 +322,18 @@ declare function tryResolveModule(path: string, opts?: ResolveModuleOptions): st
 /** Require a module and return it. */
 declare function requireModule(id: string, opts?: RequireModuleOptions): any;
 declare function importModule(id: string, opts?: RequireModuleOptions): Promise<any>;
-declare function tryImportModule(id: string, opts?: RequireModuleOptions): Promise<any>;
+declare function tryImportModule(id: string, opts?: RequireModuleOptions): Promise<any> | undefined;
 /** Try to require a module, but don't emit an error if the module can't be required. */
 declare function tryRequireModule(id: string, opts?: RequireModuleOptions): any;
 
 declare function compileTemplate(template: NuxtTemplate, ctx: any): Promise<string>;
+/** @deprecated */
 declare const templateUtils: {
     serialize: (data: any) => string;
-    importName: (src: string) => string;
+    importName: typeof genSafeVariableName;
     importSources: (sources: string | string[], { lazy }?: {
-        lazy?: boolean;
+        lazy?: boolean | undefined;
     }) => string;
 };
 
-export { AddComponentOptions, AddPluginOptions, ExtendConfigOptions, ExtendViteConfigOptions, ExtendWebpackConfigOptions, LoadNuxtConfigOptions, LoadNuxtOptions, RequireModuleOptions, ResolveModuleOptions, ResolvePathOptions, Resolver, ServerMiddleware, addAutoImport, addAutoImportDir, addComponent, addComponentsDir, addPlugin, addPluginTemplate, addServerMiddleware, addTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, clearRequireCache, compileTemplate, createResolver, defineNuxtModule, extendPages, extendViteConfig, extendWebpackConfig, findPath, getNuxtVersion, getRequireCacheItem, hasNuxtCompatibility, importModule, installModule, isIgnored, isNodeModules, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, logger, normalizePlugin, normalizeTemplate, nuxtCtx, requireModule, requireModulePkg, resolveAlias, resolveFiles, resolveModule, resolvePath, scanRequireTree, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, useLogger, useModuleContainer, useNuxt };
+export { AddComponentOptions, AddPluginOptions, ExtendConfigOptions, ExtendViteConfigOptions, ExtendWebpackConfigOptions, LegacyServerMiddleware, LoadNuxtConfigOptions, LoadNuxtOptions, RequireModuleOptions, ResolveModuleOptions, ResolvePathOptions, Resolver, addAutoImport, addAutoImportDir, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addServerHandler, addServerMiddleware, addTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, clearRequireCache, compileTemplate, createResolver, defineNuxtModule, extendPages, extendViteConfig, extendWebpackConfig, findPath, getNuxtVersion, getRequireCacheItem, hasNuxtCompatibility, importModule, installModule, isIgnored, isNodeModules, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, logger, normalizePlugin, normalizeTemplate, nuxtCtx, requireModule, requireModulePkg, resolveAlias, resolveFiles, resolveModule, resolvePath, scanRequireTree, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, useLogger, useModuleContainer, useNitro, useNuxt };

package/dist/index.mjs

@@ -1,28 +1,24 @@
-import { parse, basename, resolve, normalize, join, relative, isAbsolute, dirname, extname } from 'pathe';
-import consola from 'consola';
+import { parse, basename, resolve, relative, join, normalize, isAbsolute, dirname } from 'pathe';
 import { existsSync, readFileSync, promises } from 'node:fs';
 import hash from 'hash-sum';
 import { getContext } from 'unctx';
+import { kebabCase, pascalCase } from 'scule';
 import satisfies from 'semver/functions/satisfies.js';
+import consola from 'consola';
 import { pathToFileURL, fileURLToPath } from 'node:url';
+import { globby } from 'globby';
+import { normalizeAliases } from 'pathe/utils';
 import { interopDefault } from 'mlly';
 import jiti from 'jiti';
-import { globby } from 'globby';
 import ignore from 'ignore';
 import defu from 'defu';
 import { applyDefaults } from 'untyped';
 import lodashTemplate from 'lodash.template';
-import { camelCase, kebabCase, pascalCase } from 'scule';
-import { genDynamicImport, genImport } from 'knitwork';
+import { genSafeVariableName, genDynamicImport, genImport } from 'knitwork';
 import { loadConfig } from 'c12';
 import { NuxtConfigSchema } from '@nuxt/schema';
 import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
 
-const logger = consola;
-function useLogger(scope) {
-  return scope ? logger.withScope(scope) : logger;
-}
-
 function chainFn(base, fn) {
   if (typeof fn !== "function") {
     return base;
@@ -35,7 +31,11 @@ function chainFn(base, fn) {
     if (baseResult === void 0) {
       [baseResult] = args;
     }
-    const fnResult = fn.call(this, baseResult, ...Array.prototype.slice.call(args, 1));
+    const fnResult = fn.call(
+      this,
+      baseResult,
+      ...Array.prototype.slice.call(args, 1)
+    );
     if (fnResult === void 0) {
       return baseResult;
     }
@@ -45,14 +45,14 @@ function chainFn(base, fn) {
 
 const nuxtCtx = getContext("nuxt");
 function useNuxt() {
-  const instance = nuxtCtx.use();
+  const instance = nuxtCtx.tryUse();
   if (!instance) {
     throw new Error("Nuxt instance is unavailable!");
   }
   return instance;
 }
 function tryUseNuxt() {
-  return nuxtCtx.use();
+  return nuxtCtx.tryUse();
 }
 
 function addTemplate(_template) {
@@ -96,16 +96,12 @@ function normalizeTemplate(template) {
   return template;
 }
 
-function addServerMiddleware(middleware) {
-  useNuxt().options.serverMiddleware.push(middleware);
-}
-
 async function checkNuxtCompatibility(constraints, nuxt = useNuxt()) {
   const issues = [];
   if (constraints.nuxt) {
     const nuxtVersion = getNuxtVersion(nuxt);
-    const nuxtSemanticVersion = nuxtVersion.split("-").shift();
-    if (!satisfies(nuxtSemanticVersion, constraints.nuxt)) {
+    const nuxtSemanticVersion = nuxtVersion.replace(/-[0-9]+\.[0-9a-f]{7,8}/, "");
+    if (!satisfies(nuxtSemanticVersion, constraints.nuxt, { includePrerelease: true })) {
       issues.push({
         name: "nuxt",
         message: `Nuxt version \`${constraints.nuxt}\` is required but currently using \`${nuxtVersion}\``
@@ -113,7 +109,7 @@ async function checkNuxtCompatibility(constraints, nuxt = useNuxt()) {
     }
   }
   if (isNuxt2(nuxt)) {
-    const bridgeRequirement = constraints?.bridge;
+    const bridgeRequirement = constraints.bridge;
     const hasBridge = !!nuxt.options.bridge;
     if (bridgeRequirement === true && !hasBridge) {
       issues.push({
@@ -151,43 +147,72 @@ function isNuxt3(nuxt = useNuxt()) {
 function getNuxtVersion(nuxt = useNuxt()) {
   const version = (nuxt?._version || nuxt?.version || nuxt?.constructor?.version || "").replace(/^v/g, "");
   if (!version) {
-    throw new Error("Cannot determine nuxt version! Is currect instance passed?");
+    throw new Error("Cannot determine nuxt version! Is current instance passed?");
   }
   return version;
 }
 
-function normalizePlugin(plugin) {
-  if (typeof plugin === "string") {
-    plugin = { src: plugin };
-  } else {
-    plugin = { ...plugin };
-  }
-  if (!plugin.src) {
-    throw new Error("Invalid plugin. src option is required: " + JSON.stringify(plugin));
-  }
-  plugin.src = normalize(plugin.src);
-  if (plugin.ssr) {
-    plugin.mode = "server";
-  }
-  if (!plugin.mode) {
-    const [, mode = "all"] = plugin.src.match(/\.(server|client)(\.\w+)*$/) || [];
-    plugin.mode = mode;
-  }
-  return plugin;
+const logger = consola;
+function useLogger(scope) {
+  return scope ? logger.withScope(scope) : logger;
 }
-function addPlugin(_plugin, opts = {}) {
+
+function addLayout(template, name) {
   const nuxt = useNuxt();
-  const plugin = normalizePlugin(_plugin);
-  nuxt.options.plugins = nuxt.options.plugins.filter((p) => normalizePlugin(p).src !== plugin.src);
-  nuxt.options.plugins[opts.append ? "push" : "unshift"](plugin);
-  return plugin;
+  const { filename, src } = addTemplate(template);
+  const layoutName = kebabCase(name || parse(filename).name).replace(/["']/g, "");
+  if (isNuxt2(nuxt)) {
+    const layout = nuxt.options.layouts[layoutName];
+    if (layout) {
+      return logger.warn(
+        `Not overriding \`${layoutName}\` (provided by \`${layout}\`) with \`${src || filename}\`.`
+      );
+    }
+    nuxt.options.layouts[layoutName] = `./${filename}`;
+    if (name === "error") {
+      this.addErrorLayout(filename);
+    }
+    return;
+  }
+  nuxt.hook("app:templates", (app) => {
+    if (layoutName in app.layouts) {
+      const relativePath = relative(nuxt.options.srcDir, app.layouts[layoutName].file);
+      return logger.warn(
+        `Not overriding \`${layoutName}\` (provided by \`~/${relativePath}\`) with \`${src || filename}\`.`
+      );
+    }
+    app.layouts[layoutName] = {
+      file: join("#build", filename),
+      name: layoutName
+    };
+  });
 }
-function addPluginTemplate(plugin, opts = {}) {
-  const normalizedPlugin = typeof plugin === "string" ? { src: plugin } : { ...plugin, src: addTemplate(plugin).dst };
-  return addPlugin(normalizedPlugin, opts);
+
+function normalizeHandlerMethod(handler) {
+  const [, method = void 0] = handler.handler.match(/\.(get|head|patch|post|put|delete|connect|options|trace)(\.\w+)*$/) || [];
+  return {
+    method,
+    ...handler
+  };
+}
+function addServerMiddleware(middleware) {
+  useNuxt().options.serverMiddleware.push(middleware);
+}
+function addServerHandler(handler) {
+  useNuxt().options.serverHandlers.push(normalizeHandlerMethod(handler));
+}
+function addDevServerHandler(handler) {
+  useNuxt().options.devServerHandlers.push(handler);
+}
+function useNitro() {
+  const nuxt = useNuxt();
+  if (!nuxt._nitro) {
+    throw new Error("Nitro is not initialized yet. You can call `useNitro()` only after `ready` hook.");
+  }
+  return nuxt._nitro;
 }
 
-const _require = jiti(process.cwd(), { interopDefault: true });
+const _require = jiti(process.cwd(), { interopDefault: true, esmResolve: true });
 function isNodeModules(id) {
   return /[/\\]node_modules[/\\]/.test(id);
 }
@@ -234,14 +259,19 @@ function requireModulePkg(id, opts = {}) {
 }
 function resolveModule(id, opts = {}) {
   return normalize(_require.resolve(id, {
-    paths: [].concat(global.__NUXT_PREPATHS__, opts.paths, process.cwd(), global.__NUXT_PATHS__).filter(Boolean)
+    paths: [].concat(
+      global.__NUXT_PREPATHS__,
+      opts.paths || [],
+      process.cwd(),
+      global.__NUXT_PATHS__
+    ).filter(Boolean)
   }));
 }
 function tryResolveModule(path, opts = {}) {
   try {
     return resolveModule(path, opts);
   } catch (error) {
-    if (error.code !== "MODULE_NOT_FOUND") {
+    if (error?.code !== "MODULE_NOT_FOUND") {
       throw error;
     }
   }
@@ -278,7 +308,7 @@ function tryRequireModule(id, opts = {}) {
 function isIgnored(pathname) {
   const nuxt = tryUseNuxt();
   if (!nuxt) {
-    return null;
+    return false;
   }
   if (!nuxt._ignore) {
     nuxt._ignore = ignore(nuxt.options.ignoreOptions);
@@ -292,13 +322,13 @@ function isIgnored(pathname) {
   if (relativePath.startsWith("..")) {
     return false;
   }
-  return relativePath && nuxt._ignore.ignores(relativePath);
+  return !!(relativePath && nuxt._ignore.ignores(relativePath));
 }
 
 async function resolvePath(path, opts = {}) {
   const _path = path;
   path = normalize(path);
-  if (isAbsolute(path) && existsSync(path)) {
+  if (isAbsolute(path) && existsSync(path) && !await isDirectory(path)) {
     return path;
   }
   const nuxt = useNuxt();
@@ -309,10 +339,10 @@ async function resolvePath(path, opts = {}) {
   if (!isAbsolute(path)) {
     path = resolve(cwd, path);
   }
-  let isDirectory = false;
+  let _isDir = false;
   if (existsSync(path)) {
-    isDirectory = (await promises.lstat(path)).isDirectory();
-    if (!isDirectory) {
+    _isDir = await isDirectory(path);
+    if (!_isDir) {
       return path;
     }
   }
@@ -322,7 +352,7 @@ async function resolvePath(path, opts = {}) {
       return pathWithExt;
     }
     const pathWithIndex = join(path, "index" + ext);
-    if (isDirectory && existsSync(pathWithIndex)) {
+    if (_isDir && existsSync(pathWithIndex)) {
       return pathWithIndex;
     }
   }
@@ -339,8 +369,8 @@ async function findPath(paths, opts, pathType = "file") {
   for (const path of paths) {
     const rPath = await resolvePath(path, opts);
     if (await existsSensitive(rPath)) {
-      const isDirectory = (await promises.lstat(rPath)).isDirectory();
-      if (!pathType || pathType === "file" && !isDirectory || pathType === "dir" && isDirectory) {
+      const _isDir = await isDirectory(rPath);
+      if (!pathType || pathType === "file" && !_isDir || pathType === "dir" && _isDir) {
         return rPath;
       }
     }
@@ -351,7 +381,7 @@ function resolveAlias(path, alias) {
   if (!alias) {
     alias = tryUseNuxt()?.options.alias || {};
   }
-  for (const key in alias) {
+  for (const key in normalizeAliases(alias)) {
     if (key === "@" && !path.startsWith("@/")) {
       continue;
     }
@@ -381,15 +411,53 @@ async function existsSensitive(path) {
   const dirFiles = await promises.readdir(dirname(path));
   return dirFiles.includes(basename(path));
 }
-async function resolveFiles(path, pattern) {
-  const files = await globby(pattern, { cwd: path, followSymbolicLinks: true });
-  return files.filter((p) => !isIgnored(p)).map((p) => resolve(path, p));
+async function isDirectory(path) {
+  return (await promises.lstat(path)).isDirectory();
+}
+async function resolveFiles(path, pattern, opts = {}) {
+  const files = await globby(pattern, { cwd: path, followSymbolicLinks: opts.followSymbolicLinks ?? true });
+  return files.map((p) => resolve(path, p)).filter((p) => !isIgnored(p)).sort();
+}
+
+function normalizePlugin(plugin) {
+  if (typeof plugin === "string") {
+    plugin = { src: plugin };
+  } else {
+    plugin = { ...plugin };
+  }
+  if (!plugin.src) {
+    throw new Error("Invalid plugin. src option is required: " + JSON.stringify(plugin));
+  }
+  plugin.src = normalize(resolveAlias(plugin.src));
+  if (plugin.ssr) {
+    plugin.mode = "server";
+  }
+  if (!plugin.mode) {
+    const [, mode = "all"] = plugin.src.match(/\.(server|client)(\.\w+)*$/) || [];
+    plugin.mode = mode;
+  }
+  return plugin;
+}
+function addPlugin(_plugin, opts = {}) {
+  const nuxt = useNuxt();
+  const plugin = normalizePlugin(_plugin);
+  nuxt.options.plugins = nuxt.options.plugins.filter((p) => normalizePlugin(p).src !== plugin.src);
+  nuxt.options.plugins[opts.append ? "push" : "unshift"](plugin);
+  return plugin;
+}
+function addPluginTemplate(plugin, opts = {}) {
+  const normalizedPlugin = typeof plugin === "string" ? { src: plugin } : { ...plugin, src: addTemplate(plugin).dst };
+  return addPlugin(normalizedPlugin, opts);
 }
 
 async function installModule(moduleToInstall, _inlineOptions, _nuxt) {
   const nuxt = useNuxt();
   const { nuxtModule, inlineOptions } = await normalizeModule(moduleToInstall, _inlineOptions);
-  await nuxtModule.call(useModuleContainer(), inlineOptions, nuxt);
+  await nuxtModule.call(
+    useModuleContainer(),
+    inlineOptions,
+    nuxt
+  );
   nuxt.options._installedModules = nuxt.options._installedModules || [];
   nuxt.options._installedModules.push({
     meta: await nuxtModule.getMeta?.(),
@@ -436,7 +504,7 @@ function useModuleContainer(nuxt = useNuxt()) {
     }
     await installModule(src, inlineOptions);
   }
-  nuxt[MODULE_CONTAINER_KEY] = {
+  const container = {
     nuxt,
     options: nuxt.options,
     ready() {
@@ -460,16 +528,7 @@ function useModuleContainer(nuxt = useNuxt()) {
       return addPluginTemplate(pluginTemplate);
     },
     addLayout(tmpl, name) {
-      const { filename, src } = addTemplate(tmpl);
-      const layoutName = name || parse(src).name;
-      const layout = nuxt.options.layouts[layoutName];
-      if (layout) {
-        logger.warn(`Duplicate layout registration, "${layoutName}" has been registered as "${layout}"`);
-      }
-      nuxt.options.layouts[layoutName] = `./${filename}`;
-      if (name === "error") {
-        this.addErrorLayout(filename);
-      }
+      return addLayout(tmpl, name);
     },
     addErrorLayout(dst) {
       const relativeBuildDir = relative(nuxt.options.rootDir, nuxt.options.buildDir);
@@ -494,6 +553,7 @@ function useModuleContainer(nuxt = useNuxt()) {
       }
     }
   };
+  nuxt[MODULE_CONTAINER_KEY] = container;
   return nuxt[MODULE_CONTAINER_KEY];
 }
 
@@ -514,18 +574,18 @@ async function compileTemplate(template, ctx) {
   throw new Error("Invalid template: " + JSON.stringify(template));
 }
 const serialize = (data) => JSON.stringify(data, null, 2).replace(/"{(.+)}"(?=,?$)/gm, (r) => JSON.parse(r).replace(/^{(.*)}$/, "$1"));
-const importName = (src) => `${camelCase(basename(src, extname(src))).replace(/[^a-zA-Z?\d\s:]/g, "")}_${hash(src)}`;
 const importSources = (sources, { lazy = false } = {}) => {
   if (!Array.isArray(sources)) {
     sources = [sources];
   }
   return sources.map((src) => {
     if (lazy) {
-      return `const ${importName(src)} = ${genDynamicImport(src, { comment: `webpackChunkName: ${JSON.stringify(src)}` })}`;
+      return `const ${genSafeVariableName(src)} = ${genDynamicImport(src, { comment: `webpackChunkName: ${JSON.stringify(src)}` })}`;
     }
-    return genImport(src, importName(src));
+    return genImport(src, genSafeVariableName(src));
   }).join("\n");
 };
+const importName = genSafeVariableName;
 const templateUtils = { serialize, importName, importSources };
 
 function defineNuxtModule(definition) {
@@ -538,14 +598,14 @@ function defineNuxtModule(definition) {
   }
   if (!definition.meta.configKey) {
     definition.meta.name = definition.meta.name || definition.name;
-    definition.meta.configKey = definition.meta.configKey || definition.configKey || definition.meta.name;
+    definition.meta.configKey = definition.configKey || definition.meta.name;
   }
-  function getOptions(inlineOptions, nuxt = useNuxt()) {
+  async function getOptions(inlineOptions, nuxt = useNuxt()) {
     const configKey = definition.meta.configKey || definition.meta.name;
     const _defaults = definition.defaults instanceof Function ? definition.defaults(nuxt) : definition.defaults;
     let _options = defu(inlineOptions, nuxt.options[configKey], _defaults);
     if (definition.schema) {
-      _options = applyDefaults(definition.schema, _options);
+      _options = await applyDefaults(definition.schema, _options);
     }
     return Promise.resolve(_options);
   }
@@ -587,7 +647,7 @@ function nuxt2Shims(nuxt) {
   }
   nuxt[NUXT2_SHIMS_KEY] = true;
   nuxt.hooks = nuxt;
-  if (!nuxtCtx.use()) {
+  if (!nuxtCtx.tryUse()) {
     nuxtCtx.set(nuxt);
     nuxt.hook("close", () => nuxtCtx.unset());
   }
@@ -622,23 +682,38 @@ function nuxt2Shims(nuxt) {
 }
 
 async function loadNuxtConfig(opts) {
-  const { config: nuxtConfig, configFile, layers, cwd } = await loadConfig({
+  globalThis.defineNuxtConfig = (c) => c;
+  const result = await loadConfig({
     name: "nuxt",
     configFile: "nuxt.config",
     rcFile: ".nuxtrc",
+    extend: { extendKey: ["theme", "extends"] },
     dotenv: true,
     globalRc: true,
     ...opts
   });
+  delete globalThis.defineNuxtConfig;
+  const { configFile, layers = [], cwd } = result;
+  const nuxtConfig = result.config;
   nuxtConfig.rootDir = nuxtConfig.rootDir || cwd;
   nuxtConfig._nuxtConfigFile = configFile;
   nuxtConfig._nuxtConfigFiles = [configFile];
   for (const layer of layers) {
+    layer.config = layer.config || {};
     layer.config.rootDir = layer.config.rootDir ?? layer.cwd;
     layer.config.srcDir = resolve(layer.config.rootDir, layer.config.srcDir);
   }
   nuxtConfig._layers = layers.filter((layer) => layer.configFile && !layer.configFile.endsWith(".nuxtrc"));
-  return applyDefaults(NuxtConfigSchema, nuxtConfig);
+  if (!nuxtConfig._layers.length) {
+    nuxtConfig._layers.push({
+      cwd,
+      config: {
+        rootDir: cwd,
+        srcDir: cwd
+      }
+    });
+  }
+  return await applyDefaults(NuxtConfigSchema, nuxtConfig);
 }
 
 async function loadNuxt(opts) {
@@ -677,19 +752,29 @@ async function buildNuxt(nuxt) {
   return build(nuxt);
 }
 
-function addAutoImport(imports) {
+function addImports(imports) {
   assertNuxtCompatibility({ bridge: true });
-  useNuxt().hook("autoImports:extend", (autoImports) => {
-    autoImports.push(...Array.isArray(imports) ? imports : [imports]);
-  });
+  useNuxt().hook("autoImports:extend", (_imports) => {
+    _imports.push(...Array.isArray(imports) ? imports : [imports]);
+  }, { allowDeprecated: true });
 }
-function addAutoImportDir(_autoImportDirs) {
+const addAutoImport = addImports;
+function addImportsDir(dirs) {
   assertNuxtCompatibility({ bridge: true });
-  useNuxt().hook("autoImports:dirs", (autoImportDirs) => {
-    for (const dir of Array.isArray(_autoImportDirs) ? _autoImportDirs : [_autoImportDirs]) {
-      autoImportDirs.push(dir);
+  useNuxt().hook("autoImports:dirs", (_dirs) => {
+    for (const dir of Array.isArray(dirs) ? dirs : [dirs]) {
+      _dirs.push(dir);
     }
-  });
+  }, { allowDeprecated: true });
+}
+const addAutoImportDir = addImportsDir;
+function addImportsSources(presets) {
+  assertNuxtCompatibility({ bridge: true });
+  useNuxt().hook("autoImports:sources", (_presets) => {
+    for (const preset of Array.isArray(presets) ? presets : [presets]) {
+      _presets.push(preset);
+    }
+  }, { allowDeprecated: true });
 }
 
 function extendWebpackConfig(fn, options = {}) {
@@ -729,7 +814,17 @@ function extendViteConfig(fn, options = {}) {
   if (options.build === false && nuxt.options.build) {
     return;
   }
-  nuxt.hook("vite:extend", ({ config }) => fn(config));
+  if (options.server !== false && options.client !== false) {
+    return nuxt.hook("vite:extend", ({ config }) => fn(config));
+  }
+  nuxt.hook("vite:extendConfig", (config, { isClient, isServer }) => {
+    if (options.server !== false && isServer) {
+      return fn(config);
+    }
+    if (options.client !== false && isClient) {
+      return fn(config);
+    }
+  });
 }
 function addWebpackPlugin(plugin, options) {
   extendWebpackConfig((config) => {
@@ -773,7 +868,7 @@ async function addComponent(opts) {
     ...opts
   };
   nuxt.hook("components:extend", (components) => {
-    const existingComponent = components.find((c) => c.pascalName === component.pascalName || c.kebabName === component.kebabName);
+    const existingComponent = components.find((c) => (c.pascalName === component.pascalName || c.kebabName === component.kebabName) && c.mode === component.mode);
     if (existingComponent) {
       const name = existingComponent.pascalName || existingComponent.kebabName;
       console.warn(`Overriding ${name} component.`);
@@ -793,4 +888,4 @@ function extendPages(cb) {
   }
 }
 
-export { addAutoImport, addAutoImportDir, addComponent, addComponentsDir, addPlugin, addPluginTemplate, addServerMiddleware, addTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, clearRequireCache, compileTemplate, createResolver, defineNuxtModule, extendPages, extendViteConfig, extendWebpackConfig, findPath, getNuxtVersion, getRequireCacheItem, hasNuxtCompatibility, importModule, installModule, isIgnored, isNodeModules, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, logger, normalizePlugin, normalizeTemplate, nuxtCtx, requireModule, requireModulePkg, resolveAlias, resolveFiles, resolveModule, resolvePath, scanRequireTree, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, useLogger, useModuleContainer, useNuxt };
+export { addAutoImport, addAutoImportDir, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addServerHandler, addServerMiddleware, addTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, clearRequireCache, compileTemplate, createResolver, defineNuxtModule, extendPages, extendViteConfig, extendWebpackConfig, findPath, getNuxtVersion, getRequireCacheItem, hasNuxtCompatibility, importModule, installModule, isIgnored, isNodeModules, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, logger, normalizePlugin, normalizeTemplate, nuxtCtx, requireModule, requireModulePkg, resolveAlias, resolveFiles, resolveModule, resolvePath, scanRequireTree, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, useLogger, useModuleContainer, useNitro, useNuxt };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/kit",
-  "version": "3.0.0-rc.1",
+  "version": "3.0.0-rc.11",
   "repository": "nuxt/framework",
   "license": "MIT",
   "type": "module",
@@ -13,24 +13,24 @@
     "prepack": "unbuild"
   },
   "dependencies": {
-    "@nuxt/schema": "^3.0.0-rc.1",
-    "c12": "^0.2.7",
+    "@nuxt/schema": "3.0.0-rc.11",
+    "c12": "^0.2.13",
     "consola": "^2.15.3",
-    "defu": "^6.0.0",
-    "globby": "^13.1.1",
+    "defu": "^6.1.0",
+    "globby": "^13.1.2",
     "hash-sum": "^2.0.0",
     "ignore": "^5.2.0",
-    "jiti": "^1.13.0",
-    "knitwork": "^0.1.1",
+    "jiti": "^1.16.0",
+    "knitwork": "^0.1.2",
     "lodash.template": "^4.5.0",
-    "mlly": "^0.5.2",
-    "pathe": "^0.2.0",
-    "pkg-types": "^0.3.2",
-    "scule": "^0.2.1",
+    "mlly": "^0.5.16",
+    "pathe": "^0.3.8",
+    "pkg-types": "^0.3.5",
+    "scule": "^0.3.2",
     "semver": "^7.3.7",
-    "unctx": "^1.1.4",
-    "unimport": "^0.1.6",
-    "untyped": "^0.4.4"
+    "unctx": "^2.0.2",
+    "unimport": "^0.6.7",
+    "untyped": "^0.5.0"
   },
   "devDependencies": {
     "@types/lodash.template": "^4",