@nuxt/kit 3.0.0-rc.9 → 3.1.0

package/dist/index.mjs

@@ -1,46 +1,27 @@
-import { parse, basename, resolve, relative, join, normalize, isAbsolute, dirname } from 'pathe';
-import { existsSync, readFileSync, promises } from 'node:fs';
-import hash from 'hash-sum';
+import { promises, existsSync, readFileSync } from 'node:fs';
+import defu, { defu as defu$1 } from 'defu';
+import { applyDefaults } from 'untyped';
+import { dirname, join, normalize, relative, isAbsolute, resolve, basename, parse } from 'pathe';
+import consola from 'consola';
 import { getContext } from 'unctx';
-import { kebabCase, pascalCase } from 'scule';
 import satisfies from 'semver/functions/satisfies.js';
-import consola from 'consola';
+import lodashTemplate from 'lodash.template';
+import { genSafeVariableName, genDynamicImport, genImport } from 'knitwork';
 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 { resolveAlias as resolveAlias$1 } from 'pathe/utils';
 import ignore from 'ignore';
-import defu from 'defu';
-import { applyDefaults } from 'untyped';
-import lodashTemplate from 'lodash.template';
-import { genSafeVariableName, genDynamicImport, genImport } from 'knitwork';
 import { loadConfig } from 'c12';
 import { NuxtConfigSchema } from '@nuxt/schema';
 import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
+import { kebabCase, pascalCase } from 'scule';
+import hash from 'hash-sum';
 
-function chainFn(base, fn) {
-  if (typeof fn !== "function") {
-    return base;
-  }
-  return function(...args) {
-    if (typeof base !== "function") {
-      return fn.apply(this, args);
-    }
-    let baseResult = base.apply(this, args);
-    if (baseResult === void 0) {
-      [baseResult] = args;
-    }
-    const fnResult = fn.call(
-      this,
-      baseResult,
-      ...Array.prototype.slice.call(args, 1)
-    );
-    if (fnResult === void 0) {
-      return baseResult;
-    }
-    return fnResult;
-  };
+const logger = consola;
+function useLogger(scope) {
+  return scope ? logger.withScope(scope) : logger;
 }
 
 const nuxtCtx = getContext("nuxt");
@@ -55,52 +36,11 @@ function tryUseNuxt() {
   return nuxtCtx.tryUse();
 }
 
-function addTemplate(_template) {
-  const nuxt = useNuxt();
-  const template = normalizeTemplate(_template);
-  nuxt.options.build.templates = nuxt.options.build.templates.filter((p) => normalizeTemplate(p).filename !== template.filename);
-  nuxt.options.build.templates.push(template);
-  return template;
-}
-function normalizeTemplate(template) {
-  if (!template) {
-    throw new Error("Invalid template: " + JSON.stringify(template));
-  }
-  if (typeof template === "string") {
-    template = { src: template };
-  } else {
-    template = { ...template };
-  }
-  if (template.src) {
-    if (!existsSync(template.src)) {
-      throw new Error("Template not found: " + template.src);
-    }
-    if (!template.filename) {
-      const srcPath = parse(template.src);
-      template.filename = template.fileName || `${basename(srcPath.dir)}.${srcPath.name}.${hash(template.src)}${srcPath.ext}`;
-    }
-  }
-  if (!template.src && !template.getContents) {
-    throw new Error("Invalid template. Either getContents or src options should be provided: " + JSON.stringify(template));
-  }
-  if (!template.filename) {
-    throw new Error("Invalid template. Either filename should be provided: " + JSON.stringify(template));
-  }
-  if (template.filename.endsWith(".d.ts")) {
-    template.write = true;
-  }
-  if (!template.dst) {
-    const nuxt = useNuxt();
-    template.dst = resolve(nuxt.options.buildDir, template.filename);
-  }
-  return template;
-}
-
 async function checkNuxtCompatibility(constraints, nuxt = useNuxt()) {
   const issues = [];
   if (constraints.nuxt) {
     const nuxtVersion = getNuxtVersion(nuxt);
-    const nuxtSemanticVersion = nuxtVersion.replace(/-[0-9]+\.[0-9a-f]{7}/, "");
+    const nuxtSemanticVersion = nuxtVersion.replace(/-[0-9]+\.[0-9a-f]{7,8}/, "");
     if (!satisfies(nuxtSemanticVersion, constraints.nuxt, { includePrerelease: true })) {
       issues.push({
         name: "nuxt",
@@ -152,59 +92,125 @@ function getNuxtVersion(nuxt = useNuxt()) {
   return version;
 }
 
-const logger = consola;
-function useLogger(scope) {
-  return scope ? logger.withScope(scope) : logger;
+async function compileTemplate(template, ctx) {
+  const data = { ...ctx, options: template.options };
+  if (template.src) {
+    try {
+      const srcContents = await promises.readFile(template.src, "utf-8");
+      return lodashTemplate(srcContents, {})(data);
+    } catch (err) {
+      console.error("Error compiling template: ", template);
+      throw err;
+    }
+  }
+  if (template.getContents) {
+    return template.getContents(data);
+  }
+  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 importSources = (sources, { lazy = false } = {}) => {
+  if (!Array.isArray(sources)) {
+    sources = [sources];
+  }
+  return sources.map((src) => {
+    if (lazy) {
+      return `const ${genSafeVariableName(src)} = ${genDynamicImport(src, { comment: `webpackChunkName: ${JSON.stringify(src)}` })}`;
+    }
+    return genImport(src, genSafeVariableName(src));
+  }).join("\n");
+};
+const importName = genSafeVariableName;
+const templateUtils = { serialize, importName, importSources };
 
-function addLayout(template, name) {
-  const nuxt = useNuxt();
-  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}\`.`
-      );
+function defineNuxtModule(definition) {
+  if (!definition.meta) {
+    definition.meta = {};
+  }
+  if (definition.meta.configKey === void 0) {
+    definition.meta.configKey = definition.meta.name;
+  }
+  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 = await applyDefaults(definition.schema, _options);
     }
-    nuxt.options.layouts[layoutName] = `./${filename}`;
-    if (name === "error") {
-      this.addErrorLayout(filename);
+    return Promise.resolve(_options);
+  }
+  async function normalizedModule(inlineOptions, nuxt) {
+    if (!nuxt) {
+      nuxt = tryUseNuxt() || this.nuxt;
+    }
+    const uniqueKey = definition.meta.name || definition.meta.configKey;
+    if (uniqueKey) {
+      nuxt.options._requiredModules = nuxt.options._requiredModules || {};
+      if (nuxt.options._requiredModules[uniqueKey]) {
+        return;
+      }
+      nuxt.options._requiredModules[uniqueKey] = true;
+    }
+    if (definition.meta.compatibility) {
+      const issues = await checkNuxtCompatibility(definition.meta.compatibility, nuxt);
+      if (issues.length) {
+        logger.warn(`Module \`${definition.meta.name}\` is disabled due to incompatibility issues:
+${issues.toString()}`);
+        return;
+      }
+    }
+    nuxt2Shims(nuxt);
+    const _options = await getOptions(inlineOptions, nuxt);
+    if (definition.hooks) {
+      nuxt.hooks.addHooks(definition.hooks);
     }
+    await definition.setup?.call(null, _options, nuxt);
+  }
+  normalizedModule.getMeta = () => Promise.resolve(definition.meta);
+  normalizedModule.getOptions = getOptions;
+  return normalizedModule;
+}
+const NUXT2_SHIMS_KEY = "__nuxt2_shims_key__";
+function nuxt2Shims(nuxt) {
+  if (!isNuxt2(nuxt) || nuxt[NUXT2_SHIMS_KEY]) {
     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}\`.`
-      );
+  nuxt[NUXT2_SHIMS_KEY] = true;
+  nuxt.hooks = nuxt;
+  if (!nuxtCtx.tryUse()) {
+    nuxtCtx.set(nuxt);
+    nuxt.hook("close", () => nuxtCtx.unset());
+  }
+  let virtualTemplates;
+  nuxt.hook("builder:prepared", (_builder, buildOptions) => {
+    virtualTemplates = buildOptions.templates.filter((t) => t.getContents);
+    for (const template of virtualTemplates) {
+      buildOptions.templates.splice(buildOptions.templates.indexOf(template), 1);
     }
-    app.layouts[layoutName] = {
-      file: join("#build", filename),
-      name: layoutName
+  });
+  nuxt.hook("build:templates", async (templates) => {
+    const context = {
+      nuxt,
+      utils: templateUtils,
+      app: {
+        dir: nuxt.options.srcDir,
+        extensions: nuxt.options.extensions,
+        plugins: nuxt.options.plugins,
+        templates: [
+          ...templates.templatesFiles,
+          ...virtualTemplates
+        ],
+        templateVars: templates.templateVars
+      }
     };
+    for await (const template of virtualTemplates) {
+      const contents = await compileTemplate({ ...template, src: "" }, context);
+      await promises.mkdir(dirname(template.dst), { recursive: true });
+      await promises.writeFile(template.dst, contents);
+    }
   });
 }
 
-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);
-}
-
 const _require = jiti(process.cwd(), { interopDefault: true, esmResolve: true });
 function isNodeModules(id) {
   return /[/\\]node_modules[/\\]/.test(id);
@@ -253,9 +259,11 @@ function requireModulePkg(id, opts = {}) {
 function resolveModule(id, opts = {}) {
   return normalize(_require.resolve(id, {
     paths: [].concat(
+      // @ts-ignore
       global.__NUXT_PREPATHS__,
       opts.paths || [],
       process.cwd(),
+      // @ts-ignore
       global.__NUXT_PATHS__
     ).filter(Boolean)
   }));
@@ -305,18 +313,35 @@ function isIgnored(pathname) {
   }
   if (!nuxt._ignore) {
     nuxt._ignore = ignore(nuxt.options.ignoreOptions);
-    nuxt._ignore.add(nuxt.options.ignore);
+    const resolvedIgnore = nuxt.options.ignore.flatMap((s) => resolveGroupSyntax(s));
+    nuxt._ignore.add(resolvedIgnore);
     const nuxtignoreFile = join(nuxt.options.rootDir, ".nuxtignore");
     if (existsSync(nuxtignoreFile)) {
       nuxt._ignore.add(readFileSync(nuxtignoreFile, "utf-8"));
     }
   }
-  const relativePath = relative(nuxt.options.rootDir, pathname);
+  const cwds = nuxt.options._layers?.map((layer2) => layer2.cwd).sort((a, b) => b.length - a.length);
+  const layer = cwds?.find((cwd) => pathname.startsWith(cwd));
+  const relativePath = relative(layer ?? nuxt.options.rootDir, pathname);
   if (relativePath.startsWith("..")) {
     return false;
   }
   return !!(relativePath && nuxt._ignore.ignores(relativePath));
 }
+function resolveGroupSyntax(group) {
+  let groups = [group];
+  while (groups.some((group2) => group2.includes("{"))) {
+    groups = groups.flatMap((group2) => {
+      const [head, ...tail] = group2.split("{");
+      if (tail.length) {
+        const [body, ...rest] = tail.join("{").split("}");
+        return body.split(",").map((part) => `${head}${part}${rest.join("")}`);
+      }
+      return group2;
+    });
+  }
+  return groups;
+}
 
 async function resolvePath(path, opts = {}) {
   const _path = path;
@@ -324,7 +349,7 @@ async function resolvePath(path, opts = {}) {
   if (isAbsolute(path) && existsSync(path) && !await isDirectory(path)) {
     return path;
   }
-  const nuxt = useNuxt();
+  const nuxt = tryUseNuxt();
   const cwd = opts.cwd || (nuxt ? nuxt.options.rootDir : process.cwd());
   const extensions = opts.extensions || (nuxt ? nuxt.options.extensions : [".ts", ".mjs", ".cjs", ".json"]);
   const modulesDir = nuxt ? nuxt.options.modulesDir : [];
@@ -374,15 +399,7 @@ function resolveAlias(path, alias) {
   if (!alias) {
     alias = tryUseNuxt()?.options.alias || {};
   }
-  for (const key in normalizeAliases(alias)) {
-    if (key === "@" && !path.startsWith("@/")) {
-      continue;
-    }
-    if (path.startsWith(key)) {
-      path = alias[key] + path.slice(key.length);
-    }
-  }
-  return path;
+  return resolveAlias$1(path, alias);
 }
 function createResolver(base) {
   if (!base) {
@@ -412,45 +429,13 @@ async function resolveFiles(path, pattern, opts = {}) {
   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(inlineOptions, nuxt);
+  if (typeof moduleToInstall === "string") {
+    nuxt.options.build.transpile.push(moduleToInstall);
+  }
   nuxt.options._installedModules = nuxt.options._installedModules || [];
   nuxt.options._installedModules.push({
     meta: await nuxtModule.getMeta?.(),
@@ -459,14 +444,15 @@ async function installModule(moduleToInstall, _inlineOptions, _nuxt) {
 }
 async function normalizeModule(nuxtModule, inlineOptions) {
   const nuxt = useNuxt();
-  if (nuxtModule?._version || nuxtModule?.version || nuxtModule?.constructor?.version || "") {
-    [nuxtModule, inlineOptions] = [inlineOptions, {}];
-    console.warn(new Error("`installModule` is being called with old signature!"));
-  }
   if (typeof nuxtModule === "string") {
     const _src = resolveModule(resolveAlias(nuxtModule), { paths: nuxt.options.modulesDir });
     const isESM = _src.endsWith(".mjs");
-    nuxtModule = isESM ? await importModule(_src) : requireModule(_src);
+    try {
+      nuxtModule = isESM ? await importModule(_src) : requireModule(_src);
+    } catch (error) {
+      console.error(`Error while requiring module \`${nuxtModule}\`: ${error}`);
+      throw error;
+    }
   }
   if (typeof nuxtModule !== "function") {
     throw new TypeError("Nuxt module should be a function: " + nuxtModule);
@@ -474,207 +460,8 @@ async function normalizeModule(nuxtModule, inlineOptions) {
   return { nuxtModule, inlineOptions };
 }
 
-const MODULE_CONTAINER_KEY = "__module_container__";
-function useModuleContainer(nuxt = useNuxt()) {
-  if (nuxt[MODULE_CONTAINER_KEY]) {
-    return nuxt[MODULE_CONTAINER_KEY];
-  }
-  async function requireModule(moduleOpts) {
-    let src, inlineOptions;
-    if (typeof moduleOpts === "string") {
-      src = moduleOpts;
-    } else if (Array.isArray(moduleOpts)) {
-      [src, inlineOptions] = moduleOpts;
-    } else if (typeof moduleOpts === "object") {
-      if (moduleOpts.src || moduleOpts.handler) {
-        src = moduleOpts.src || moduleOpts.handler;
-        inlineOptions = moduleOpts.options;
-      } else {
-        src = moduleOpts;
-      }
-    } else {
-      src = moduleOpts;
-    }
-    await installModule(src, inlineOptions);
-  }
-  const container = {
-    nuxt,
-    options: nuxt.options,
-    ready() {
-      return Promise.resolve();
-    },
-    addVendor() {
-    },
-    requireModule,
-    addModule: requireModule,
-    addServerMiddleware,
-    addTemplate(template) {
-      if (typeof template === "string") {
-        template = { src: template };
-      }
-      if (template.write === void 0) {
-        template.write = true;
-      }
-      return addTemplate(template);
-    },
-    addPlugin(pluginTemplate) {
-      return addPluginTemplate(pluginTemplate);
-    },
-    addLayout(tmpl, name) {
-      return addLayout(tmpl, name);
-    },
-    addErrorLayout(dst) {
-      const relativeBuildDir = relative(nuxt.options.rootDir, nuxt.options.buildDir);
-      nuxt.options.ErrorPage = `~/${relativeBuildDir}/${dst}`;
-    },
-    extendBuild(fn) {
-      nuxt.options.build.extend = chainFn(nuxt.options.build.extend, fn);
-      if (!isNuxt2(nuxt)) {
-        console.warn("[kit] [compat] Using `extendBuild` in Nuxt 3 has no effect. Instead call extendWebpackConfig and extendViteConfig.");
-      }
-    },
-    extendRoutes(fn) {
-      if (isNuxt2(nuxt)) {
-        nuxt.options.router.extendRoutes = chainFn(nuxt.options.router.extendRoutes, fn);
-      } else {
-        nuxt.hook("pages:extend", async (pages, ...args) => {
-          const maybeRoutes = await fn(pages, ...args);
-          if (maybeRoutes) {
-            console.warn("[kit] [compat] Using `extendRoutes` in Nuxt 3 needs to directly modify first argument instead of returning updated routes. Skipping extended routes.");
-          }
-        });
-      }
-    }
-  };
-  nuxt[MODULE_CONTAINER_KEY] = container;
-  return nuxt[MODULE_CONTAINER_KEY];
-}
-
-async function compileTemplate(template, ctx) {
-  const data = { ...ctx, options: template.options };
-  if (template.src) {
-    try {
-      const srcContents = await promises.readFile(template.src, "utf-8");
-      return lodashTemplate(srcContents, {})(data);
-    } catch (err) {
-      console.error("Error compiling template: ", template);
-      throw err;
-    }
-  }
-  if (template.getContents) {
-    return template.getContents(data);
-  }
-  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 importSources = (sources, { lazy = false } = {}) => {
-  if (!Array.isArray(sources)) {
-    sources = [sources];
-  }
-  return sources.map((src) => {
-    if (lazy) {
-      return `const ${genSafeVariableName(src)} = ${genDynamicImport(src, { comment: `webpackChunkName: ${JSON.stringify(src)}` })}`;
-    }
-    return genImport(src, genSafeVariableName(src));
-  }).join("\n");
-};
-const importName = genSafeVariableName;
-const templateUtils = { serialize, importName, importSources };
-
-function defineNuxtModule(definition) {
-  if (typeof definition === "function") {
-    definition = definition(useNuxt());
-    logger.warn("Module definition as function is deprecated and will be removed in the future versions", definition);
-  }
-  if (!definition.meta) {
-    definition.meta = {};
-  }
-  if (!definition.meta.configKey) {
-    definition.meta.name = definition.meta.name || definition.name;
-    definition.meta.configKey = definition.configKey || definition.meta.name;
-  }
-  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);
-    }
-    return Promise.resolve(_options);
-  }
-  async function normalizedModule(inlineOptions, nuxt) {
-    if (!nuxt) {
-      nuxt = tryUseNuxt() || this.nuxt;
-    }
-    const uniqueKey = definition.meta.name || definition.meta.configKey;
-    if (uniqueKey) {
-      nuxt.options._requiredModules = nuxt.options._requiredModules || {};
-      if (nuxt.options._requiredModules[uniqueKey]) {
-        return;
-      }
-      nuxt.options._requiredModules[uniqueKey] = true;
-    }
-    if (definition.meta.compatibility) {
-      const issues = await checkNuxtCompatibility(definition.meta.compatibility, nuxt);
-      if (issues.length) {
-        logger.warn(`Module \`${definition.meta.name}\` is disabled due to incompatibility issues:
-${issues.toString()}`);
-        return;
-      }
-    }
-    nuxt2Shims(nuxt);
-    const _options = await getOptions(inlineOptions, nuxt);
-    if (definition.hooks) {
-      nuxt.hooks.addHooks(definition.hooks);
-    }
-    await definition.setup?.call(null, _options, nuxt);
-  }
-  normalizedModule.getMeta = () => Promise.resolve(definition.meta);
-  normalizedModule.getOptions = getOptions;
-  return normalizedModule;
-}
-const NUXT2_SHIMS_KEY = "__nuxt2_shims_key__";
-function nuxt2Shims(nuxt) {
-  if (!isNuxt2(nuxt) || nuxt[NUXT2_SHIMS_KEY]) {
-    return;
-  }
-  nuxt[NUXT2_SHIMS_KEY] = true;
-  nuxt.hooks = nuxt;
-  if (!nuxtCtx.tryUse()) {
-    nuxtCtx.set(nuxt);
-    nuxt.hook("close", () => nuxtCtx.unset());
-  }
-  let virtualTemplates;
-  nuxt.hook("builder:prepared", (_builder, buildOptions) => {
-    virtualTemplates = buildOptions.templates.filter((t) => t.getContents);
-    for (const template of virtualTemplates) {
-      buildOptions.templates.splice(buildOptions.templates.indexOf(template), 1);
-    }
-  });
-  nuxt.hook("build:templates", async (templates) => {
-    const context = {
-      nuxt,
-      utils: templateUtils,
-      app: {
-        dir: nuxt.options.srcDir,
-        extensions: nuxt.options.extensions,
-        plugins: nuxt.options.plugins,
-        templates: [
-          ...templates.templatesFiles,
-          ...virtualTemplates
-        ],
-        templateVars: templates.templateVars
-      }
-    };
-    for await (const template of virtualTemplates) {
-      const contents = await compileTemplate({ ...template, src: "" }, context);
-      await promises.mkdir(dirname(template.dst), { recursive: true });
-      await promises.writeFile(template.dst, contents);
-    }
-  });
-}
-
 async function loadNuxtConfig(opts) {
+  globalThis.defineNuxtConfig = (c) => c;
   const result = await loadConfig({
     name: "nuxt",
     configFile: "nuxt.config",
@@ -684,6 +471,7 @@ async function loadNuxtConfig(opts) {
     globalRc: true,
     ...opts
   });
+  delete globalThis.defineNuxtConfig;
   const { configFile, layers = [], cwd } = result;
   const nuxtConfig = result.config;
   nuxtConfig.rootDir = nuxtConfig.rootDir || cwd;
@@ -694,8 +482,25 @@ async function loadNuxtConfig(opts) {
     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);
+  const _layers = layers.filter((layer) => layer.configFile && !layer.configFile.endsWith(".nuxtrc"));
+  nuxtConfig._layers = _layers;
+  if (!_layers.length) {
+    _layers.push({
+      cwd,
+      config: {
+        rootDir: cwd,
+        srcDir: cwd
+      }
+    });
+  }
+  return await applyDefaults(NuxtConfigSchema, nuxtConfig);
+}
+
+function extendNuxtSchema(def) {
+  const nuxt = useNuxt();
+  nuxt.hook("schema:extend", (schemas) => {
+    schemas.push(typeof def === "function" ? def() : def);
+  });
 }
 
 async function loadNuxt(opts) {
@@ -721,6 +526,7 @@ async function loadNuxt(opts) {
     configOverrides: opts.overrides,
     ready: opts.ready,
     envConfig: opts.dotenv
+    // TODO: Backward format convertion
   });
   return nuxt;
 }
@@ -736,20 +542,26 @@ async function buildNuxt(nuxt) {
 
 function addImports(imports) {
   assertNuxtCompatibility({ bridge: true });
-  useNuxt().hook("autoImports:extend", (_imports) => {
+  useNuxt().hook("imports:extend", (_imports) => {
     _imports.push(...Array.isArray(imports) ? imports : [imports]);
-  }, { allowDeprecated: true });
+  });
 }
-const addAutoImport = addImports;
 function addImportsDir(dirs) {
   assertNuxtCompatibility({ bridge: true });
-  useNuxt().hook("autoImports:dirs", (_dirs) => {
+  useNuxt().hook("imports:dirs", (_dirs) => {
     for (const dir of Array.isArray(dirs) ? dirs : [dirs]) {
       _dirs.push(dir);
     }
-  }, { allowDeprecated: true });
+  });
+}
+function addImportsSources(presets) {
+  assertNuxtCompatibility({ bridge: true });
+  useNuxt().hook("imports:sources", (_presets) => {
+    for (const preset of Array.isArray(presets) ? presets : [presets]) {
+      _presets.push(preset);
+    }
+  });
 }
-const addAutoImportDir = addImportsDir;
 
 function extendWebpackConfig(fn, options = {}) {
   const nuxt = useNuxt();
@@ -772,12 +584,6 @@ function extendWebpackConfig(fn, options = {}) {
         fn(config);
       }
     }
-    if (options.modern !== false) {
-      const config = configs.find((i) => i.name === "modern");
-      if (config) {
-        fn(config);
-      }
-    }
   });
 }
 function extendViteConfig(fn, options = {}) {
@@ -803,13 +609,21 @@ function extendViteConfig(fn, options = {}) {
 function addWebpackPlugin(plugin, options) {
   extendWebpackConfig((config) => {
     config.plugins = config.plugins || [];
-    config.plugins.push(plugin);
+    if (Array.isArray(plugin)) {
+      config.plugins.push(...plugin);
+    } else {
+      config.plugins.push(plugin);
+    }
   }, options);
 }
 function addVitePlugin(plugin, options) {
   extendViteConfig((config) => {
     config.plugins = config.plugins || [];
-    config.plugins.push(plugin);
+    if (Array.isArray(plugin)) {
+      config.plugins.push(...plugin);
+    } else {
+      config.plugins.push(plugin);
+    }
   }, options);
 }
 
@@ -835,10 +649,6 @@ async function addComponent(opts) {
     preload: false,
     mode: "all",
     shortPath: opts.filePath,
-    async: false,
-    level: 0,
-    asyncImport: `${genDynamicImport(opts.filePath)}.then(r => r['${opts.export || "default"}'])`,
-    import: `require(${JSON.stringify(opts.filePath)})['${opts.export || "default"}']`,
     ...opts
   };
   nuxt.hook("components:extend", (components) => {
@@ -853,6 +663,81 @@ async function addComponent(opts) {
   });
 }
 
+function addTemplate(_template) {
+  const nuxt = useNuxt();
+  const template = normalizeTemplate(_template);
+  nuxt.options.build.templates = nuxt.options.build.templates.filter((p) => normalizeTemplate(p).filename !== template.filename);
+  nuxt.options.build.templates.push(template);
+  return template;
+}
+function normalizeTemplate(template) {
+  if (!template) {
+    throw new Error("Invalid template: " + JSON.stringify(template));
+  }
+  if (typeof template === "string") {
+    template = { src: template };
+  } else {
+    template = { ...template };
+  }
+  if (template.src) {
+    if (!existsSync(template.src)) {
+      throw new Error("Template not found: " + template.src);
+    }
+    if (!template.filename) {
+      const srcPath = parse(template.src);
+      template.filename = template.fileName || `${basename(srcPath.dir)}.${srcPath.name}.${hash(template.src)}${srcPath.ext}`;
+    }
+  }
+  if (!template.src && !template.getContents) {
+    throw new Error("Invalid template. Either getContents or src options should be provided: " + JSON.stringify(template));
+  }
+  if (!template.filename) {
+    throw new Error("Invalid template. Either filename should be provided: " + JSON.stringify(template));
+  }
+  if (template.filename.endsWith(".d.ts")) {
+    template.write = true;
+  }
+  if (!template.dst) {
+    const nuxt = useNuxt();
+    template.dst = resolve(nuxt.options.buildDir, template.filename);
+  }
+  return template;
+}
+function updateTemplates(options) {
+  return useNuxt().hooks.callHook("builder:generateApp", options);
+}
+
+function addLayout(template, name) {
+  const nuxt = useNuxt();
+  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 extendPages(cb) {
   const nuxt = useNuxt();
   if (isNuxt2(nuxt)) {
@@ -861,5 +746,87 @@ function extendPages(cb) {
     nuxt.hook("pages:extend", cb);
   }
 }
+function extendRouteRules(route, rule, options = {}) {
+  const nuxt = useNuxt();
+  for (const opts of [nuxt.options, nuxt.options.nitro]) {
+    if (!opts.routeRules) {
+      opts.routeRules = {};
+    }
+    opts.routeRules[route] = options.override ? defu$1(rule, opts.routeRules[route]) : defu$1(opts.routeRules[route], rule);
+  }
+}
+
+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);
+}
+
+function normalizeHandlerMethod(handler) {
+  const [, method = void 0] = handler.handler.match(/\.(get|head|patch|post|put|delete|connect|options|trace)(\.\w+)*$/) || [];
+  return {
+    method,
+    ...handler,
+    handler: normalize(handler.handler)
+  };
+}
+function addServerHandler(handler) {
+  useNuxt().options.serverHandlers.push(normalizeHandlerMethod(handler));
+}
+function addDevServerHandler(handler) {
+  useNuxt().options.devServerHandlers.push(handler);
+}
+function addServerPlugin(plugin) {
+  const nuxt = useNuxt();
+  nuxt.options.nitro.plugins = nuxt.options.nitro.plugins || [];
+  nuxt.options.nitro.plugins.push(normalize(plugin));
+}
+function addPrerenderRoutes(routes) {
+  const nuxt = useNuxt();
+  if (!Array.isArray(routes)) {
+    routes = [routes];
+  }
+  routes = routes.filter(Boolean);
+  if (!routes.length) {
+    return;
+  }
+  nuxt.hook("prerender:routes", (ctx) => {
+    for (const route of routes) {
+      ctx.routes.add(route);
+    }
+  });
+}
+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;
+}
 
-export { addAutoImport, addAutoImportDir, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, 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, useNuxt };
+export { addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addServerHandler, addServerPlugin, addTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, clearRequireCache, compileTemplate, createResolver, defineNuxtModule, extendNuxtSchema, extendPages, extendRouteRules, 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, updateTemplates, useLogger, useNitro, useNuxt };