@nuxt/kit 3.6.5 → 3.7.0

package/dist/index.d.mts

@@ -0,0 +1,391 @@
+import { ModuleOptions, ModuleDefinition, NuxtModule, Nuxt, ModuleMeta, NuxtConfig, NuxtOptions, SchemaDefinition, ImportPresetWithDeprecation, NuxtCompatibility, NuxtCompatibilityIssues, ComponentsDir, Component, NuxtTemplate, NuxtHooks, NuxtMiddleware, 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_index from 'unctx/index';
+import { NitroRouteConfig, NitroEventHandler, NitroDevEventHandler, Nitro } from 'nitropack';
+import * as consola_dist_core from 'consola/dist/core';
+import { genSafeVariableName } from 'knitwork';
+
+/**
+ * Define a Nuxt module, automatically merging defaults with user provided options, installing
+ * any hooks that are provided, and calling an optional setup function for full control.
+ */
+declare function defineNuxtModule<OptionsT extends ModuleOptions>(definition: ModuleDefinition<OptionsT> | NuxtModule<OptionsT>): NuxtModule<OptionsT>;
+
+/** Installs a module on a Nuxt instance. */
+declare function installModule(moduleToInstall: string | NuxtModule, inlineOptions?: any, nuxt?: Nuxt): Promise<void>;
+declare const normalizeModuleTranspilePath: (p: string) => string;
+declare function loadNuxtModuleInstance(nuxtModule: string | NuxtModule, nuxt?: Nuxt): Promise<{
+    nuxtModule: NuxtModule<any>;
+    buildTimeModuleMeta: ModuleMeta;
+}>;
+
+/**
+ * Check if a Nuxt module is installed by name.
+ *
+ * This will check both the installed modules and the modules to be installed. Note
+ * that it cannot detect if a module is _going to be_ installed programmatically by another module.
+ */
+declare function hasNuxtModule(moduleName: string, nuxt?: Nuxt): boolean;
+/**
+ * Checks if a Nuxt Module is compatible with a given semver version.
+ */
+declare function hasNuxtModuleCompatibility(module: string | NuxtModule, semverVersion: string, nuxt?: Nuxt): Promise<boolean>;
+/**
+ * Get the version of a Nuxt module.
+ *
+ * Scans installed modules for the version, if it's not found it will attempt to load the module instance and get the version from there.
+ */
+declare function getNuxtModuleVersion(module: string | NuxtModule, nuxt?: Nuxt | any): Promise<string | false>;
+
+interface LoadNuxtConfigOptions extends LoadConfigOptions<NuxtConfig> {
+}
+declare function loadNuxtConfig(opts: LoadNuxtConfigOptions): Promise<NuxtOptions>;
+
+declare function extendNuxtSchema(def: SchemaDefinition | (() => SchemaDefinition)): void;
+
+interface LoadNuxtOptions extends LoadNuxtConfigOptions {
+    /** Load nuxt with development mode */
+    dev?: boolean;
+    /** Use lazy initialization of nuxt if set to false */
+    ready?: boolean;
+    /** @deprecated Use cwd option */
+    rootDir?: LoadNuxtConfigOptions['cwd'];
+    /** @deprecated use overrides option */
+    config?: LoadNuxtConfigOptions['overrides'];
+}
+declare function loadNuxt(opts: LoadNuxtOptions): Promise<Nuxt>;
+declare function buildNuxt(nuxt: Nuxt): Promise<any>;
+
+declare function addImports(imports: Import | Import[]): void;
+declare function addImportsDir(dirs: string | string[], opts?: {
+    prepend?: boolean;
+}): void;
+declare function addImportsSources(presets: ImportPresetWithDeprecation | ImportPresetWithDeprecation[]): void;
+
+interface ExtendConfigOptions {
+    /**
+     * Install plugin on dev
+     *
+     * @default true
+     */
+    dev?: boolean;
+    /**
+     * Install plugin on build
+     *
+     * @default true
+     */
+    build?: boolean;
+    /**
+     * Install plugin on server side
+     *
+     * @default true
+     */
+    server?: boolean;
+    /**
+     * Install plugin on client side
+     *
+     * @default true
+     */
+    client?: boolean;
+    /**
+     * Prepends the plugin to the array with `unshit()` instead of `push()`.
+     */
+    prepend?: boolean;
+}
+interface ExtendWebpackConfigOptions extends ExtendConfigOptions {
+}
+interface ExtendViteConfigOptions extends ExtendConfigOptions {
+}
+/**
+ * Extend webpack config
+ *
+ * The fallback function might be called multiple times
+ * when applying to both client and server builds.
+ */
+declare function extendWebpackConfig(fn: ((config: Configuration) => void), options?: ExtendWebpackConfigOptions): void;
+/**
+ * Extend Vite config
+ */
+declare function extendViteConfig(fn: ((config: UserConfig) => void), options?: ExtendViteConfigOptions): (() => void) | undefined;
+/**
+ * Append webpack plugin to the config.
+ */
+declare function addWebpackPlugin(pluginOrGetter: WebpackPluginInstance | WebpackPluginInstance[] | (() => WebpackPluginInstance | WebpackPluginInstance[]), options?: ExtendWebpackConfigOptions): void;
+/**
+ * Append Vite plugin to the config.
+ */
+declare function addVitePlugin(pluginOrGetter: Plugin | Plugin[] | (() => Plugin | Plugin[]), options?: ExtendViteConfigOptions): void;
+interface AddBuildPluginFactory {
+    vite?: () => Plugin | Plugin[];
+    webpack?: () => WebpackPluginInstance | WebpackPluginInstance[];
+}
+declare function addBuildPlugin(pluginFactory: AddBuildPluginFactory, options?: ExtendConfigOptions): void;
+
+declare function normalizeSemanticVersion(version: string): string;
+/**
+ * Check version constraints and return incompatibility issues as an array
+ */
+declare function checkNuxtCompatibility(constraints: NuxtCompatibility, nuxt?: Nuxt): Promise<NuxtCompatibilityIssues>;
+/**
+ * Check version constraints and throw a detailed error if has any, otherwise returns true
+ */
+declare function assertNuxtCompatibility(constraints: NuxtCompatibility, nuxt?: Nuxt): Promise<true>;
+/**
+ * Check version constraints and return true if passed, otherwise returns false
+ */
+declare function hasNuxtCompatibility(constraints: NuxtCompatibility, nuxt?: Nuxt): Promise<boolean>;
+/**
+ * Check if current nuxt instance is version 2 legacy
+ */
+declare function isNuxt2(nuxt?: Nuxt): any;
+/**
+ * Check if current nuxt instance is version 3
+ */
+declare function isNuxt3(nuxt?: Nuxt): any;
+/**
+ * Get nuxt version
+ */
+declare function getNuxtVersion(nuxt?: Nuxt | any): any;
+
+/**
+ * Register a directory to be scanned for components and imported only when used.
+ *
+ * Requires Nuxt 2.13+
+ */
+declare function addComponentsDir(dir: ComponentsDir): Promise<void>;
+type AddComponentOptions = {
+    name: string;
+    filePath: string;
+} & Partial<Exclude<Component, 'shortPath' | 'async' | 'level' | 'import' | 'asyncImport'>>;
+/**
+ * Register a component by its name and filePath.
+ *
+ * Requires Nuxt 2.13+
+ */
+declare function addComponent(opts: AddComponentOptions): Promise<void>;
+
+/** Direct access to the Nuxt context - see https://github.com/unjs/unctx. */
+declare const nuxtCtx: unctx_index.UseContext<Nuxt>;
+/**
+ * Get access to Nuxt instance.
+ *
+ * Throws an error if Nuxt instance is unavailable.
+ *
+ * @example
+ * ```js
+ * const nuxt = useNuxt()
+ * ```
+ */
+declare function useNuxt(): Nuxt;
+/**
+ * Get access to Nuxt instance.
+ *
+ * Returns null if Nuxt instance is unavailable.
+ *
+ * @example
+ * ```js
+ * const nuxt = tryUseNuxt()
+ * if (nuxt) {
+ *  // Do something
+ * }
+ * ```
+ */
+declare function tryUseNuxt(): Nuxt | null;
+
+/**
+ * Return a filter function to filter an array of paths
+ */
+declare function isIgnored(pathname: string): boolean;
+declare function resolveIgnorePatterns(relativePath?: string): string[];
+
+declare function addLayout(this: any, template: NuxtTemplate, name?: string): void;
+
+declare function extendPages(cb: NuxtHooks['pages:extend']): void;
+interface ExtendRouteRulesOptions {
+    /**
+     * Override route rule config
+     *
+     * @default false
+     */
+    override?: boolean;
+}
+declare function extendRouteRules(route: string, rule: NitroRouteConfig, options?: ExtendRouteRulesOptions): void;
+interface AddRouteMiddlewareOptions {
+    /**
+     * Override existing middleware with the same name, if it exists
+     *
+     * @default false
+     */
+    override?: boolean;
+}
+declare function addRouteMiddleware(input: NuxtMiddleware | NuxtMiddleware[], options?: AddRouteMiddlewareOptions): void;
+
+/**
+ * Normalize a nuxt plugin object
+ */
+declare function normalizePlugin(plugin: NuxtPlugin | string): NuxtPlugin;
+/**
+ * Registers a nuxt plugin and to the plugins array.
+ *
+ * Note: You can use mode or .client and .server modifiers with fileName option
+ * to use plugin only in client or server side.
+ *
+ * Note: By default plugin is prepended to the plugins array. You can use second argument to append (push) instead.
+ *
+ * @example
+ * ```js
+ * addPlugin({
+ *   src: path.resolve(__dirname, 'templates/foo.js'),
+ *   filename: 'foo.server.js' // [optional] only include in server bundle
+ * })
+ * ```
+ */
+interface AddPluginOptions {
+    append?: boolean;
+}
+declare function addPlugin(_plugin: NuxtPlugin | string, opts?: AddPluginOptions): NuxtPlugin;
+/**
+ * Adds a template and registers as a nuxt plugin.
+ */
+declare function addPluginTemplate(plugin: NuxtPluginTemplate | string, opts?: AddPluginOptions): NuxtPlugin;
+
+interface ResolvePathOptions {
+    /** Base for resolving paths from. Default is Nuxt rootDir. */
+    cwd?: string;
+    /** An object of aliases. Default is Nuxt configured aliases. */
+    alias?: Record<string, string>;
+    /** The file extensions to try. Default is Nuxt configured extensions. */
+    extensions?: string[];
+}
+/**
+ * Resolve full path to a file or directory respecting Nuxt alias and extensions options
+ *
+ * If path could not be resolved, normalized input path will be returned
+ */
+declare function resolvePath(path: string, opts?: ResolvePathOptions): Promise<string>;
+/**
+ * Try to resolve first existing file in paths
+ */
+declare function findPath(paths: string | string[], opts?: ResolvePathOptions, pathType?: 'file' | 'dir'): Promise<string | null>;
+/**
+ * Resolve path aliases respecting Nuxt alias options
+ */
+declare function resolveAlias(path: string, alias?: Record<string, string>): string;
+interface Resolver {
+    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[], opts?: {
+    followSymbolicLinks?: boolean;
+}): Promise<string[]>;
+
+/**
+ * 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;
+/**
+ * Adds a Nitro plugin
+ */
+declare function addServerPlugin(plugin: string): void;
+/**
+ * Adds routes to be prerendered
+ */
+declare function addPrerenderRoutes(routes: string | string[]): 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<any> | string): ResolvedNuxtTemplate<any>;
+/**
+ * Renders given types using lodash template during build into the project buildDir
+ * and register them as types.
+ */
+declare function addTypeTemplate(_template: NuxtTemplate<any>): ResolvedNuxtTemplate<any>;
+/**
+ * Normalize a nuxt template object
+ */
+declare function normalizeTemplate(template: NuxtTemplate<any> | string): ResolvedNuxtTemplate<any>;
+/**
+ * Trigger rebuilding Nuxt templates
+ *
+ * You can pass a filter within the options to selectively regenerate a subset of templates.
+ */
+declare function updateTemplates(options?: {
+    filter?: (template: ResolvedNuxtTemplate<any>) => boolean;
+}): Promise<any>;
+declare function writeTypes(nuxt: Nuxt): Promise<void>;
+
+declare const logger: consola_dist_core.ConsolaInstance;
+declare function useLogger(tag?: string): consola_dist_core.ConsolaInstance;
+
+/** @deprecated Do not use CJS utils */
+interface ResolveModuleOptions {
+    paths?: string | string[];
+}
+/** @deprecated Do not use CJS utils */
+interface RequireModuleOptions extends ResolveModuleOptions {
+    /** Clear the require cache (force fresh require) but only if not within `node_modules` */
+    clearCache?: boolean;
+    /** Automatically de-default the result of requiring the module. */
+    interopDefault?: boolean;
+}
+/** @deprecated Do not use CJS utils */
+declare function resolveModule(id: string, opts?: ResolveModuleOptions): string;
+/** @deprecated Do not use CJS utils */
+declare function requireModule(id: string, opts?: RequireModuleOptions): any;
+/** @deprecated Do not use CJS utils */
+declare function importModule(id: string, opts?: RequireModuleOptions): Promise<any>;
+/** @deprecated Do not use CJS utils */
+declare function tryImportModule(id: string, opts?: RequireModuleOptions): Promise<any> | undefined;
+/** @deprecated Do not use CJS utils */
+declare function tryRequireModule(id: string, opts?: RequireModuleOptions): any;
+
+/**
+ * Resolve a module from a given root path using an algorithm patterned on
+ * the upcoming `import.meta.resolve`. It returns a file URL
+ *
+ * @internal
+ */
+declare function tryResolveModule(id: string, url?: string | string[]): Promise<string | undefined>;
+
+/** @deprecated */
+declare function compileTemplate(template: NuxtTemplate, ctx: any): Promise<string>;
+/** @deprecated */
+declare const templateUtils: {
+    serialize: (data: any) => string;
+    importName: typeof genSafeVariableName;
+    importSources: (sources: string | string[], { lazy }?: {
+        lazy?: boolean | undefined;
+    }) => string;
+};
+
+export { type AddComponentOptions, type AddPluginOptions, type AddRouteMiddlewareOptions, type ExtendConfigOptions, type ExtendRouteRulesOptions, type ExtendViteConfigOptions, type ExtendWebpackConfigOptions, type LoadNuxtConfigOptions, type LoadNuxtOptions, type RequireModuleOptions, type ResolveModuleOptions, type ResolvePathOptions, type Resolver, addBuildPlugin, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addServerHandler, addServerPlugin, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, compileTemplate, createResolver, defineNuxtModule, extendNuxtSchema, extendPages, extendRouteRules, extendViteConfig, extendWebpackConfig, findPath, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, importModule, installModule, isIgnored, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, requireModule, resolveAlias, resolveFiles, resolveIgnorePatterns, resolveModule, resolvePath, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateTemplates, useLogger, useNitro, useNuxt, writeTypes };

package/dist/index.d.ts

@@ -199,6 +199,7 @@ declare function tryUseNuxt(): Nuxt | null;
  * Return a filter function to filter an array of paths
  */
 declare function isIgnored(pathname: string): boolean;
+declare function resolveIgnorePatterns(relativePath?: string): string[];
 
 declare function addLayout(this: any, template: NuxtTemplate, name?: string): void;
 
@@ -341,6 +342,7 @@ declare function normalizeTemplate(template: NuxtTemplate<any> | string): Resolv
 declare function updateTemplates(options?: {
     filter?: (template: ResolvedNuxtTemplate<any>) => boolean;
 }): Promise<any>;
+declare function writeTypes(nuxt: Nuxt): Promise<void>;
 
 declare const logger: consola_dist_core.ConsolaInstance;
 declare function useLogger(tag?: string): consola_dist_core.ConsolaInstance;
@@ -386,4 +388,4 @@ declare const templateUtils: {
     }) => string;
 };
 
-export { AddComponentOptions, AddPluginOptions, AddRouteMiddlewareOptions, ExtendConfigOptions, ExtendRouteRulesOptions, ExtendViteConfigOptions, ExtendWebpackConfigOptions, LoadNuxtConfigOptions, LoadNuxtOptions, RequireModuleOptions, ResolveModuleOptions, ResolvePathOptions, Resolver, addBuildPlugin, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addServerHandler, addServerPlugin, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, compileTemplate, createResolver, defineNuxtModule, extendNuxtSchema, extendPages, extendRouteRules, extendViteConfig, extendWebpackConfig, findPath, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, importModule, installModule, isIgnored, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, requireModule, resolveAlias, resolveFiles, resolveModule, resolvePath, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateTemplates, useLogger, useNitro, useNuxt };
+export { type AddComponentOptions, type AddPluginOptions, type AddRouteMiddlewareOptions, type ExtendConfigOptions, type ExtendRouteRulesOptions, type ExtendViteConfigOptions, type ExtendWebpackConfigOptions, type LoadNuxtConfigOptions, type LoadNuxtOptions, type RequireModuleOptions, type ResolveModuleOptions, type ResolvePathOptions, type Resolver, addBuildPlugin, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addServerHandler, addServerPlugin, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, compileTemplate, createResolver, defineNuxtModule, extendNuxtSchema, extendPages, extendRouteRules, extendViteConfig, extendWebpackConfig, findPath, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, importModule, installModule, isIgnored, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, requireModule, resolveAlias, resolveFiles, resolveIgnorePatterns, resolveModule, resolvePath, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateTemplates, useLogger, useNitro, useNuxt, writeTypes };

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { promises, existsSync, readFileSync, lstatSync } from 'node:fs';
 import { performance } from 'node:perf_hooks';
 import { defu } from 'defu';
 import { applyDefaults } from 'untyped';
-import { dirname, normalize, join, relative, isAbsolute, resolve, basename, parse } from 'pathe';
+import { dirname, normalize, relative, join, resolve, isAbsolute, basename, parse } from 'pathe';
 import { consola } from 'consola';
 import { getContext } from 'unctx';
 import satisfies from 'semver/functions/satisfies.js';
@@ -18,6 +18,7 @@ import { NuxtConfigSchema } from '@nuxt/schema';
 import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
 import { kebabCase, pascalCase } from 'scule';
 import hash from 'hash-sum';
+import { withTrailingSlash } from 'ufo';
 
 const logger = consola;
 function useLogger(tag) {
@@ -2226,14 +2227,17 @@ function getRequireCacheItem(id) {
   } catch (e) {
   }
 }
+function getModulePaths(paths) {
+  return [].concat(
+    global.__NUXT_PREPATHS__,
+    paths || [],
+    process.cwd(),
+    global.__NUXT_PATHS__
+  ).filter(Boolean);
+}
 function resolveModule(id, opts = {}) {
   return normalize(_require.resolve(id, {
-    paths: [].concat(
-      global.__NUXT_PREPATHS__,
-      opts.paths || [],
-      process.cwd(),
-      global.__NUXT_PATHS__
-    ).filter(Boolean)
+    paths: getModulePaths(opts.paths)
   }));
 }
 function requireModule(id, opts = {}) {
@@ -2288,12 +2292,7 @@ function isIgnored(pathname) {
   }
   if (!nuxt._ignore) {
     nuxt._ignore = ignore(nuxt.options.ignoreOptions);
-    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"));
-    }
+    nuxt._ignore.add(resolveIgnorePatterns());
   }
   const cwds = nuxt.options._layers?.map((layer2) => layer2.cwd).sort((a, b) => b.length - a.length);
   const layer = cwds?.find((cwd) => pathname.startsWith(cwd));
@@ -2303,6 +2302,24 @@ function isIgnored(pathname) {
   }
   return !!(relativePath && nuxt._ignore.ignores(relativePath));
 }
+function resolveIgnorePatterns(relativePath) {
+  const nuxt = tryUseNuxt();
+  if (!nuxt) {
+    return [];
+  }
+  if (!nuxt._ignorePatterns) {
+    nuxt._ignorePatterns = nuxt.options.ignore.flatMap((s) => resolveGroupSyntax(s));
+    const nuxtignoreFile = join(nuxt.options.rootDir, ".nuxtignore");
+    if (existsSync(nuxtignoreFile)) {
+      const contents = readFileSync(nuxtignoreFile, "utf-8");
+      nuxt._ignorePatterns.push(...contents.trim().split(/\r?\n/));
+    }
+  }
+  if (relativePath) {
+    return nuxt._ignorePatterns.map((p) => p.startsWith("*") || p.startsWith("!*") ? p : relative(relativePath, resolve(nuxt.options.rootDir, p)));
+  }
+  return nuxt._ignorePatterns;
+}
 function resolveGroupSyntax(group) {
   let groups = [group];
   while (groups.some((group2) => group2.includes("{"))) {
@@ -2412,6 +2429,10 @@ async function installModule(moduleToInstall, inlineOptions, nuxt = useNuxt()) {
   }
   if (typeof moduleToInstall === "string") {
     nuxt.options.build.transpile.push(normalizeModuleTranspilePath(moduleToInstall));
+    const directory = getDirectory(moduleToInstall);
+    if (directory !== moduleToInstall) {
+      nuxt.options.modulesDir.push(getDirectory(moduleToInstall));
+    }
   }
   nuxt.options._installedModules = nuxt.options._installedModules || [];
   nuxt.options._installedModules.push({
@@ -2420,12 +2441,15 @@ async function installModule(moduleToInstall, inlineOptions, nuxt = useNuxt()) {
     entryPath: typeof moduleToInstall === "string" ? resolveAlias(moduleToInstall) : void 0
   });
 }
-const normalizeModuleTranspilePath = (p) => {
+function getDirectory(p) {
   try {
-    p = isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
+    return isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
   } catch (e) {
   }
-  return p.split("node_modules/").pop();
+  return p;
+}
+const normalizeModuleTranspilePath = (p) => {
+  return getDirectory(p).split("node_modules/").pop();
 };
 async function loadNuxtModuleInstance(nuxtModule, nuxt = useNuxt()) {
   let buildTimeModuleMeta = {};
@@ -2447,8 +2471,18 @@ async function loadNuxtModuleInstance(nuxtModule, nuxt = useNuxt()) {
   return { nuxtModule, buildTimeModuleMeta };
 }
 
+function resolveNuxtModuleEntryName(m) {
+  if (typeof m === "object" && !Array.isArray(m)) {
+    return m.name;
+  }
+  if (Array.isArray(m)) {
+    return resolveNuxtModuleEntryName(m[0]);
+  }
+  return m || false;
+}
 function hasNuxtModule(moduleName, nuxt = useNuxt()) {
-  return nuxt.options._installedModules.some(({ meta }) => meta.name === moduleName) || nuxt.options.modules.includes(moduleName);
+  return nuxt.options._installedModules.some(({ meta }) => meta.name === moduleName) || // check modules to be installed
+  nuxt.options.modules.some((m) => moduleName === resolveNuxtModuleEntryName(m));
 }
 async function hasNuxtModuleCompatibility(module, semverVersion, nuxt = useNuxt()) {
   const version = await getNuxtModuleVersion(module, nuxt);
@@ -2471,7 +2505,7 @@ async function getNuxtModuleVersion(module, nuxt = useNuxt()) {
   if (version) {
     return version;
   }
-  if (nuxt.options.modules.includes(moduleMeta.name)) {
+  if (hasNuxtModule(moduleMeta.name)) {
     const { buildTimeModuleMeta } = await loadNuxtModuleInstance(moduleMeta.name, nuxt);
     return buildTimeModuleMeta.version || false;
   }
@@ -2755,6 +2789,134 @@ function normalizeTemplate(template) {
 async function updateTemplates(options) {
   return await tryUseNuxt()?.hooks.callHook("builder:generateApp", options);
 }
+async function writeTypes(nuxt) {
+  const modulePaths = getModulePaths(nuxt.options.modulesDir);
+  const rootDirWithSlash = withTrailingSlash(nuxt.options.rootDir);
+  const tsConfig = defu(nuxt.options.typescript?.tsConfig, {
+    compilerOptions: {
+      forceConsistentCasingInFileNames: true,
+      jsx: "preserve",
+      target: "ESNext",
+      module: "ESNext",
+      moduleResolution: nuxt.options.experimental?.typescriptBundlerResolution ? "Bundler" : "Node",
+      skipLibCheck: true,
+      isolatedModules: true,
+      useDefineForClassFields: true,
+      strict: nuxt.options.typescript?.strict ?? true,
+      allowJs: true,
+      noEmit: true,
+      resolveJsonModule: true,
+      allowSyntheticDefaultImports: true,
+      paths: {}
+    },
+    include: [
+      "./nuxt.d.ts",
+      join(relativeWithDot(nuxt.options.buildDir, nuxt.options.rootDir), "**/*"),
+      ...nuxt.options.srcDir !== nuxt.options.rootDir ? [join(relative(nuxt.options.buildDir, nuxt.options.srcDir), "**/*")] : [],
+      ...nuxt.options._layers.map((layer) => layer.config.srcDir ?? layer.cwd).filter((srcOrCwd) => !srcOrCwd.startsWith(rootDirWithSlash) || srcOrCwd.includes("node_modules")).map((srcOrCwd) => join(relative(nuxt.options.buildDir, srcOrCwd), "**/*")),
+      ...nuxt.options.typescript.includeWorkspace && nuxt.options.workspaceDir !== nuxt.options.rootDir ? [join(relative(nuxt.options.buildDir, nuxt.options.workspaceDir), "**/*")] : []
+    ],
+    exclude: [
+      ...nuxt.options.modulesDir.map((m) => relativeWithDot(nuxt.options.buildDir, m)),
+      // nitro generate output: https://github.com/nuxt/nuxt/blob/main/packages/nuxt/src/core/nitro.ts#L186
+      relativeWithDot(nuxt.options.buildDir, resolve(nuxt.options.rootDir, "dist"))
+    ]
+  });
+  const aliases = {
+    ...nuxt.options.alias,
+    "#build": nuxt.options.buildDir
+  };
+  const excludedAlias = [/^@vue\/.*$/];
+  const basePath = tsConfig.compilerOptions.baseUrl ? resolve(nuxt.options.buildDir, tsConfig.compilerOptions.baseUrl) : nuxt.options.buildDir;
+  tsConfig.compilerOptions = tsConfig.compilerOptions || {};
+  tsConfig.include = tsConfig.include || [];
+  for (const alias in aliases) {
+    if (excludedAlias.some((re) => re.test(alias))) {
+      continue;
+    }
+    let absolutePath = resolve(basePath, aliases[alias]);
+    let stats = await promises.stat(absolutePath).catch(
+      () => null
+      /* file does not exist */
+    );
+    if (!stats) {
+      const resolvedModule = await tryResolveModule(aliases[alias], nuxt.options.modulesDir);
+      if (resolvedModule) {
+        absolutePath = resolvedModule;
+        stats = await promises.stat(resolvedModule).catch(() => null);
+      }
+    }
+    const relativePath = relativeWithDot(nuxt.options.buildDir, absolutePath);
+    if (stats?.isDirectory()) {
+      tsConfig.compilerOptions.paths[alias] = [relativePath];
+      tsConfig.compilerOptions.paths[`${alias}/*`] = [`${relativePath}/*`];
+      if (!absolutePath.startsWith(rootDirWithSlash)) {
+        tsConfig.include.push(relativePath);
+      }
+    } else {
+      const path = stats?.isFile() ? relativePath.replace(/(?<=\w)\.\w+$/g, "") : aliases[alias];
+      tsConfig.compilerOptions.paths[alias] = [path];
+      if (!absolutePath.startsWith(rootDirWithSlash)) {
+        tsConfig.include.push(path);
+      }
+    }
+  }
+  const references = await Promise.all([
+    ...nuxt.options.modules,
+    ...nuxt.options._modules
+  ].filter((f) => typeof f === "string").map(async (id) => ({ types: (await readPackageJSON(id, { url: modulePaths }).catch(() => null))?.name || id })));
+  if (nuxt.options.experimental?.reactivityTransform) {
+    references.push({ types: "vue/macros-global" });
+  }
+  const declarations = [];
+  await nuxt.callHook("prepare:types", { references, declarations, tsConfig });
+  for (const alias in tsConfig.compilerOptions.paths) {
+    const paths = tsConfig.compilerOptions.paths[alias];
+    tsConfig.compilerOptions.paths[alias] = await Promise.all(paths.map(async (path) => {
+      if (!isAbsolute(path)) {
+        return path;
+      }
+      const stats = await promises.stat(path).catch(
+        () => null
+        /* file does not exist */
+      );
+      return relativeWithDot(nuxt.options.buildDir, stats?.isFile() ? path.replace(/(?<=\w)\.\w+$/g, "") : path);
+    }));
+  }
+  tsConfig.include = [...new Set(tsConfig.include.map((p) => isAbsolute(p) ? relativeWithDot(nuxt.options.buildDir, p) : p))];
+  tsConfig.exclude = [...new Set(tsConfig.exclude.map((p) => isAbsolute(p) ? relativeWithDot(nuxt.options.buildDir, p) : p))];
+  const declaration = [
+    ...references.map((ref) => {
+      if ("path" in ref && isAbsolute(ref.path)) {
+        ref.path = relative(nuxt.options.buildDir, ref.path);
+      }
+      return `/// <reference ${renderAttrs(ref)} />`;
+    }),
+    ...declarations,
+    "",
+    "export {}",
+    ""
+  ].join("\n");
+  async function writeFile() {
+    const GeneratedBy = "// Generated by nuxi";
+    const tsConfigPath = resolve(nuxt.options.buildDir, "tsconfig.json");
+    await promises.mkdir(nuxt.options.buildDir, { recursive: true });
+    await promises.writeFile(tsConfigPath, GeneratedBy + "\n" + JSON.stringify(tsConfig, null, 2));
+    const declarationPath = resolve(nuxt.options.buildDir, "nuxt.d.ts");
+    await promises.writeFile(declarationPath, GeneratedBy + "\n" + declaration);
+  }
+  nuxt.hook("builder:prepared", writeFile);
+  await writeFile();
+}
+function renderAttrs(obj) {
+  return Object.entries(obj).map((e) => renderAttr(e[0], e[1])).join(" ");
+}
+function renderAttr(key, value) {
+  return value ? `${key}="${value}"` : "";
+}
+function relativeWithDot(from, to) {
+  return relative(from, to).replace(/^([^.])/, "./$1") || ".";
+}
 
 function addLayout(template, name) {
   const nuxt = useNuxt();
@@ -2900,4 +3062,4 @@ function useNitro() {
   return nuxt._nitro;
 }
 
-export { addBuildPlugin, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addServerHandler, addServerPlugin, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, compileTemplate, createResolver, defineNuxtModule, extendNuxtSchema, extendPages, extendRouteRules, extendViteConfig, extendWebpackConfig, findPath, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, importModule$1 as importModule, installModule, isIgnored, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, requireModule, resolveAlias, resolveFiles, resolveModule, resolvePath, templateUtils, tryImportModule$1 as tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateTemplates, useLogger, useNitro, useNuxt };
+export { addBuildPlugin, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addServerHandler, addServerPlugin, addTemplate, addTypeTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, compileTemplate, createResolver, defineNuxtModule, extendNuxtSchema, extendPages, extendRouteRules, extendViteConfig, extendWebpackConfig, findPath, getNuxtModuleVersion, getNuxtVersion, hasNuxtCompatibility, hasNuxtModule, hasNuxtModuleCompatibility, importModule$1 as importModule, installModule, isIgnored, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, loadNuxtModuleInstance, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeSemanticVersion, normalizeTemplate, nuxtCtx, requireModule, resolveAlias, resolveFiles, resolveIgnorePatterns, resolveModule, resolvePath, templateUtils, tryImportModule$1 as tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateTemplates, useLogger, useNitro, useNuxt, writeTypes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/kit",
-  "version": "3.6.5",
+  "version": "3.7.0",
   "repository": "nuxt/nuxt",
   "license": "MIT",
   "type": "module",
@@ -23,28 +23,29 @@
     "globby": "^13.2.2",
     "hash-sum": "^2.0.0",
     "ignore": "^5.2.4",
-    "jiti": "^1.19.1",
+    "jiti": "^1.19.3",
     "knitwork": "^1.0.0",
-    "mlly": "^1.4.0",
+    "mlly": "^1.4.1",
     "pathe": "^1.1.1",
     "pkg-types": "^1.0.3",
     "scule": "^1.0.0",
-    "semver": "^7.5.3",
+    "semver": "^7.5.4",
+    "ufo": "^1.3.0",
     "unctx": "^2.3.1",
-    "unimport": "^3.0.14",
-    "untyped": "^1.3.2",
-    "@nuxt/schema": "3.6.5"
+    "unimport": "^3.2.0",
+    "untyped": "^1.4.0",
+    "@nuxt/schema": "3.7.0"
   },
   "devDependencies": {
     "@types/hash-sum": "1.0.0",
-    "@types/lodash-es": "4.17.7",
+    "@types/lodash-es": "4.17.8",
     "@types/semver": "7.5.0",
     "lodash-es": "4.17.21",
-    "nitropack": "2.5.2",
+    "nitropack": "2.6.1",
     "unbuild": "latest",
-    "vite": "4.3.9",
+    "vite": "4.4.9",
     "vitest": "0.33.0",
-    "webpack": "5.88.1"
+    "webpack": "5.88.2"
   },
   "engines": {
     "node": "^14.18.0 || >=16.10.0"