@nuxt/kit-nightly 4.3.2-29531071.e4e4ae81 → 4.3.2-29531289.6a3bd23e

package/dist/index.d.mts

@@ -1,6 +1,5 @@
 import { ConsolaInstance, ConsolaOptions } from "consola";
 import { UseContext } from "unctx";
-import "pkg-types";
 import { GlobOptions } from "tinyglobby";
 import { LoadConfigOptions } from "c12";
 import { Component, ComponentsDir, ModuleDefinition, ModuleMeta, ModuleOptions, Nuxt, NuxtAppConfig, NuxtCompatibility, NuxtCompatibilityIssues, NuxtConfig, NuxtHooks, NuxtMiddleware, NuxtModule, NuxtOptions, NuxtPlugin, NuxtPluginTemplate, NuxtServerTemplate, NuxtTemplate, NuxtTypeTemplate, ResolvedNuxtTemplate, SchemaDefinition } from "@nuxt/schema";

package/dist/index.mjs

@@ -30,17 +30,44 @@ const logger = consola;
 function useLogger(tag, options = {}) {
 	return tag ? logger.create(options).withTag(tag) : logger;
 }
+/**
+* Direct access to the Nuxt global context - see https://github.com/unjs/unctx.
+* @deprecated Use `getNuxtCtx` instead
+*/
 const nuxtCtx = getContext("nuxt");
+/** async local storage for the name of the current nuxt instance */
 const asyncNuxtStorage = createContext({
 	asyncContext: true,
 	AsyncLocalStorage
 });
+/** Direct access to the Nuxt context with asyncLocalStorage - see https://github.com/unjs/unctx. */
 const getNuxtCtx = () => asyncNuxtStorage.tryUse();
+/**
+* Get access to Nuxt instance.
+*
+* Throws an error if Nuxt instance is unavailable.
+* @example
+* ```js
+* const nuxt = useNuxt()
+* ```
+*/
 function useNuxt() {
 	const instance = asyncNuxtStorage.tryUse() || nuxtCtx.tryUse();
 	if (!instance) throw new Error("Nuxt instance is unavailable!");
 	return instance;
 }
+/**
+* Get access to Nuxt instance.
+*
+* Returns null if Nuxt instance is unavailable.
+* @example
+* ```js
+* const nuxt = tryUseNuxt()
+* if (nuxt) {
+*  // Do something
+* }
+* ```
+*/
 function tryUseNuxt() {
 	return asyncNuxtStorage.tryUse() || nuxtCtx.tryUse();
 }
@@ -59,6 +86,9 @@ const builderMap = {
 function checkNuxtVersion(version, nuxt = useNuxt()) {
 	return satisfies(normalizeSemanticVersion(getNuxtVersion(nuxt)), version, { includePrerelease: true });
 }
+/**
+* Check version constraints and return incompatibility issues as an array
+*/
 async function checkNuxtCompatibility(constraints, nuxt = useNuxt()) {
 	const issues = [];
 	if (constraints.nuxt) {
@@ -96,25 +126,43 @@ async function checkNuxtCompatibility(constraints, nuxt = useNuxt()) {
 	issues.toString = () => issues.map((issue) => ` - [${issue.name}] ${issue.message}`).join("\n");
 	return issues;
 }
+/**
+* Check version constraints and throw a detailed error if has any, otherwise returns true
+*/
 async function assertNuxtCompatibility(constraints, nuxt = useNuxt()) {
 	const issues = await checkNuxtCompatibility(constraints, nuxt);
 	if (issues.length) throw new Error("Nuxt compatibility issues found:\n" + issues.toString());
 	return true;
 }
+/**
+* Check version constraints and return true if passed, otherwise returns false
+*/
 async function hasNuxtCompatibility(constraints, nuxt = useNuxt()) {
 	return !(await checkNuxtCompatibility(constraints, nuxt)).length;
 }
+/**
+* Check if current Nuxt instance is of specified major version
+*/
 function isNuxtMajorVersion(majorVersion, nuxt = useNuxt()) {
 	const version = getNuxtVersion(nuxt);
 	return version[0] === majorVersion.toString() && version[1] === ".";
 }
+/**
+* @deprecated Use `isNuxtMajorVersion(2, nuxt)` instead. This may be removed in \@nuxt/kit v5 or a future major version.
+*/
 function isNuxt2(nuxt = useNuxt()) {
 	return isNuxtMajorVersion(2, nuxt);
 }
+/**
+* @deprecated Use `isNuxtMajorVersion(3, nuxt)` instead. This may be removed in \@nuxt/kit v5 or a future major version.
+*/
 function isNuxt3(nuxt = useNuxt()) {
 	return isNuxtMajorVersion(3, nuxt);
 }
 const NUXT_VERSION_RE = /^v/g;
+/**
+* Get nuxt version
+*/
 function getNuxtVersion(nuxt = useNuxt()) {
 	const rawVersion = nuxt?._version || nuxt?.version || nuxt?.constructor?.version;
 	if (typeof rawVersion !== "string") throw new TypeError("Cannot determine nuxt version! Is current instance passed?");
@@ -196,6 +244,17 @@ function warn(warning) {
 	}
 }
 const layerMap = /* @__PURE__ */ new WeakMap();
+/**
+* Get the resolved directory paths for all layers in a Nuxt application.
+*
+* Returns an array of LayerDirectories objects, ordered by layer priority:
+* - The first layer is the user/project layer (highest priority)
+* - Earlier layers override later layers in the array
+* - Base layers appear last in the array (lowest priority)
+*
+* @param nuxt - The Nuxt instance to get layers from. Defaults to the current Nuxt context.
+* @returns Array of LayerDirectories objects, ordered by priority (user layer first)
+*/
 function getLayerDirectories(nuxt = useNuxt()) {
 	return nuxt.options._layers.map((layer) => {
 		if (layerMap.has(layer)) return layerMap.get(layer);
@@ -224,6 +283,9 @@ function withTrailingSlash$2(dir) {
 function createIsIgnored(nuxt = tryUseNuxt()) {
 	return (pathname, stats) => isIgnored(pathname, stats, nuxt);
 }
+/**
+* Return a filter function to filter an array of paths
+*/
 function isIgnored(pathname, _stats, nuxt = tryUseNuxt()) {
 	if (!nuxt) return false;
 	if (!nuxt._ignore) {
@@ -251,6 +313,13 @@ function resolveIgnorePatterns(relativePath) {
 	});
 	return ignorePatterns;
 }
+/**
+* This function turns string containing groups '**\/*.{spec,test}.{js,ts}' into an array of strings.
+* For example will '**\/*.{spec,test}.{js,ts}' be resolved to:
+* ['**\/*.spec.js', '**\/*.spec.ts', '**\/*.test.js', '**\/*.test.ts']
+* @param group string containing the group syntax
+* @returns {string[]} array of strings without the group syntax
+*/
 function resolveGroupSyntax(group) {
 	let groups = [group];
 	while (groups.some((group) => group.includes("{"))) groups = groups.flatMap((group) => {
@@ -263,15 +332,28 @@ function resolveGroupSyntax(group) {
 	});
 	return groups;
 }
+/** @since 3.9.0 */
 function toArray(value) {
 	return Array.isArray(value) ? value : [value];
 }
+/**
+* Filter out items from an array in place. This function mutates the array.
+* `predicate` get through the array from the end to the start for performance.
+*
+* This function should be faster than `Array.prototype.filter` on large arrays.
+*/
 function filterInPlace(array, predicate) {
 	for (let i = array.length; i--;) if (!predicate(array[i], i, array)) array.splice(i, 1);
 	return array;
 }
 const MODE_RE = /\.(server|client)(\.\w+)*$/;
 const distDirURL = new URL(".", import.meta.url);
+/**
+* Resolve the full path to a file or a directory (based on the provided type), respecting Nuxt alias and extensions options.
+*
+* If a path cannot be resolved, normalized input will be returned unless the `fallbackToOriginal` option is set to `true`,
+* in which case the original input path will be returned.
+*/
 async function resolvePath(path, opts = {}) {
 	const { type = "file" } = opts;
 	const res = await _resolvePathGranularly(path, {
@@ -281,6 +363,9 @@ async function resolvePath(path, opts = {}) {
 	if (res.type === type) return res.path;
 	return opts.fallbackToOriginal ? path : res.path;
 }
+/**
+* Try to resolve first existing file in paths
+*/
 async function findPath(paths, opts, pathType = "file") {
 	for (const path of toArray(paths)) {
 		const res = await _resolvePathGranularly(path, {
@@ -292,10 +377,16 @@ async function findPath(paths, opts, pathType = "file") {
 	}
 	return null;
 }
+/**
+* Resolve path aliases respecting Nuxt alias options
+*/
 function resolveAlias(path, alias) {
 	alias ||= tryUseNuxt()?.options.alias || {};
 	return resolveAlias$1(path, alias);
 }
+/**
+* Create a relative resolver
+*/
 function createResolver(base) {
 	if (!base) throw new Error("`base` argument is missing for createResolver(base)!");
 	base = base.toString();
@@ -398,6 +489,15 @@ function existsInVFS(path, nuxt = tryUseNuxt()) {
 	if (path in nuxt.vfs) return true;
 	return (nuxt.apps.default?.templates ?? nuxt.options.build.templates).some((template) => template.dst === path);
 }
+/**
+* Resolve absolute file paths in the provided directory with respect to `.nuxtignore` and return them sorted.
+* @param path path to the directory to resolve files in
+* @param pattern glob pattern or an array of glob patterns to match files
+* @param opts options for globbing
+* @param opts.followSymbolicLinks whether to follow symbolic links, default is `true`
+* @param opts.ignore additional glob patterns to ignore
+* @returns sorted array of absolute file paths
+*/
 async function resolveFiles(path, pattern, opts = {}) {
 	const files = [];
 	for (const p of await glob(pattern, {
@@ -439,12 +539,18 @@ function tryImportModule(id, opts) {
 		return importModule(id, opts).catch(() => void 0);
 	} catch {}
 }
+/**
+* @deprecated Please use `importModule` instead.
+*/
 function requireModule(id, opts) {
 	const caller = getUserCaller();
 	warn(`[@nuxt/kit] \`requireModule\` is deprecated${caller ? ` (used at \`${resolveAlias(caller.source)}:${caller.line}:${caller.column}\`)` : ""}. Please use \`importModule\` instead.`);
 	const resolvedPath = resolveModule(id, opts);
 	return createJiti(import.meta.url, { interopDefault: opts?.interopDefault !== false })(pathToFileURL(resolvedPath).href);
 }
+/**
+* @deprecated Please use `tryImportModule` instead.
+*/
 function tryRequireModule(id, opts) {
 	try {
 		return requireModule(id, opts);
@@ -458,6 +564,10 @@ const ignoredConfigKeys = new Set([
 	"devtools",
 	"telemetry"
 ]);
+/**
+* Installs a set of modules on a Nuxt instance.
+* @internal
+*/
 async function installModules(modulesToInstall, resolvedModulePaths, nuxt = useNuxt()) {
 	const localLayerModuleDirs = [];
 	for (const l of nuxt.options._layers) {
@@ -556,6 +666,10 @@ async function installModules(modulesToInstall, resolvedModulePaths, nuxt = useN
 	}
 	delete nuxt._moduleOptionsFunctions;
 }
+/**
+* Installs a module on a Nuxt instance.
+* @deprecated Use module dependencies.
+*/
 async function installModule(moduleToInstall, inlineOptions, nuxt = useNuxt()) {
 	const { nuxtModule, buildTimeModuleMeta, resolvedModulePath } = await loadNuxtModuleInstance(moduleToInstall, nuxt);
 	const localLayerModuleDirs = [];
@@ -735,14 +849,28 @@ function resolveNuxtModuleEntryName(m) {
 	if (Array.isArray(m)) return resolveNuxtModuleEntryName(m[0]);
 	return m || false;
 }
+/**
+* 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.
+*/
 function hasNuxtModule(moduleName, nuxt = useNuxt()) {
 	return nuxt.options._installedModules.some(({ meta }) => meta.name === moduleName) || nuxt.options.modules.some((m) => moduleName === resolveNuxtModuleEntryName(m));
 }
+/**
+* Checks if a Nuxt module is compatible with a given semver version.
+*/
 async function hasNuxtModuleCompatibility(module, semverVersion, nuxt = useNuxt()) {
 	const version = await getNuxtModuleVersion(module, nuxt);
 	if (!version) return false;
 	return satisfies(normalizeSemanticVersion(version), semverVersion, { includePrerelease: true });
 }
+/**
+* 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.
+*/
 async function getNuxtModuleVersion(module, nuxt = useNuxt()) {
 	const moduleMeta = (typeof module === "string" ? { name: module } : await module.getMeta?.()) || {};
 	if (moduleMeta.version) return moduleMeta.version;
@@ -910,6 +1038,10 @@ function addImportsSources(presets) {
 	});
 }
 const HANDLER_METHOD_RE = /\.(get|head|patch|post|put|delete|connect|options|trace)(\.\w+)*$/;
+/**
+* normalize handler object
+*
+*/
 function normalizeHandlerMethod(handler) {
 	const [, method = void 0] = handler.handler.match(HANDLER_METHOD_RE) || [];
 	return {
@@ -918,17 +1050,31 @@ function normalizeHandlerMethod(handler) {
 		handler: normalize(handler.handler)
 	};
 }
+/**
+* Adds a nitro server handler
+*
+*/
 function addServerHandler(handler) {
 	useNuxt().options.serverHandlers.push(normalizeHandlerMethod(handler));
 }
+/**
+* Adds a nitro server handler for development-only
+*
+*/
 function addDevServerHandler(handler) {
 	useNuxt().options.devServerHandlers.push(handler);
 }
+/**
+* Adds a Nitro plugin
+*/
 function addServerPlugin(plugin) {
 	const nuxt = useNuxt();
 	nuxt.options.nitro.plugins ||= [];
 	nuxt.options.nitro.plugins.push(normalize(plugin));
 }
+/**
+* Adds routes to be prerendered
+*/
 function addPrerenderRoutes(routes) {
 	const nuxt = useNuxt();
 	routes = toArray(routes).filter(Boolean);
@@ -937,11 +1083,28 @@ function addPrerenderRoutes(routes) {
 		for (const route of routes) ctx.routes.add(route);
 	});
 }
+/**
+* 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())
+* })
+* ```
+*/
 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;
 }
+/**
+* Add server imports to be auto-imported by Nitro
+*/
 function addServerImports(imports) {
 	const nuxt = useNuxt();
 	const _imports = toArray(imports);
@@ -951,6 +1114,9 @@ function addServerImports(imports) {
 		config.imports.imports.push(..._imports);
 	});
 }
+/**
+* Add directories to be scanned for auto-imports by Nitro
+*/
 function addServerImportsDir(dirs, opts = {}) {
 	const nuxt = useNuxt();
 	const _dirs = toArray(dirs);
@@ -960,12 +1126,21 @@ function addServerImportsDir(dirs, opts = {}) {
 		config.imports.dirs[opts.prepend ? "unshift" : "push"](..._dirs);
 	});
 }
+/**
+* Add directories to be scanned by Nitro. It will check for subdirectories,
+* which will be registered just like the `~~/server` folder is.
+*/
 function addServerScanDir(dirs, opts = {}) {
 	useNuxt().hook("nitro:config", (config) => {
 		config.scanDirs ||= [];
 		for (const dir of toArray(dirs)) config.scanDirs[opts.prepend ? "unshift" : "push"](dir);
 	});
 }
+/**
+* Access 'resolved' Nuxt runtime configuration, with values updated from environment.
+*
+* This mirrors the runtime behavior of Nitro.
+*/
 function useRuntimeConfig() {
 	const nuxt = useNuxt();
 	return applyEnv(klona(nuxt.options.nitro.runtimeConfig), {
@@ -974,6 +1149,9 @@ function useRuntimeConfig() {
 		envExpansion: nuxt.options.nitro.experimental?.envExpansion ?? !!process.env.NITRO_ENV_EXPANSION
 	});
 }
+/**
+* Update Nuxt runtime configuration.
+*/
 function updateRuntimeConfig(runtimeConfig) {
 	const nuxt = useNuxt();
 	Object.assign(nuxt.options.nitro.runtimeConfig, defu(runtimeConfig, nuxt.options.nitro.runtimeConfig));
@@ -1026,8 +1204,23 @@ const extendWebpackCompatibleConfig = (builder) => (fn, options = {}) => {
 		}
 	});
 };
+/**
+* Extend webpack config
+*
+* The fallback function might be called multiple times
+* when applying to both client and server builds.
+*/
 const extendWebpackConfig = extendWebpackCompatibleConfig("webpack");
+/**
+* Extend rspack config
+*
+* The fallback function might be called multiple times
+* when applying to both client and server builds.
+*/
 const extendRspackConfig = extendWebpackCompatibleConfig("rspack");
+/**
+* Extend Vite config
+*/
 function extendViteConfig(fn, options = {}) {
 	const nuxt = useNuxt();
 	if (options.dev === false && nuxt.options.dev) return;
@@ -1038,6 +1231,9 @@ function extendViteConfig(fn, options = {}) {
 	}
 	return nuxt.hook("vite:extend", ({ config }) => fn(config));
 }
+/**
+* Append webpack plugin to the config.
+*/
 function addWebpackPlugin(pluginOrGetter, options) {
 	extendWebpackConfig(async (config) => {
 		const method = options?.prepend ? "unshift" : "push";
@@ -1046,6 +1242,9 @@ function addWebpackPlugin(pluginOrGetter, options) {
 		config.plugins[method](...toArray(plugin));
 	}, options);
 }
+/**
+* Append rspack plugin to the config.
+*/
 function addRspackPlugin(pluginOrGetter, options) {
 	extendRspackConfig(async (config) => {
 		const method = options?.prepend ? "unshift" : "push";
@@ -1054,6 +1253,9 @@ function addRspackPlugin(pluginOrGetter, options) {
 		config.plugins[method](...toArray(plugin));
 	}, options);
 }
+/**
+* Append Vite plugin to the config.
+*/
 function addVitePlugin(pluginOrGetter, options = {}) {
 	const nuxt = useNuxt();
 	if (options.dev === false && nuxt.options.dev) return;
@@ -1094,6 +1296,9 @@ function addBuildPlugin(pluginFactory, options) {
 	if (pluginFactory.webpack) addWebpackPlugin(pluginFactory.webpack, options);
 	if (pluginFactory.rspack) addRspackPlugin(pluginFactory.rspack, options);
 }
+/**
+* Register a directory to be scanned for components and imported only when used.
+*/
 function addComponentsDir(dir, opts = {}) {
 	const nuxt = useNuxt();
 	nuxt.options.components ||= [];
@@ -1102,6 +1307,9 @@ function addComponentsDir(dir, opts = {}) {
 		dirs[opts.prepend ? "unshift" : "push"](dir);
 	});
 }
+/**
+* This utility takes a file path or npm package that is scanned for named exports, which are get added automatically
+*/
 function addComponentExports(opts) {
 	const nuxt = useNuxt();
 	const components = [];
@@ -1116,6 +1324,9 @@ function addComponentExports(opts) {
 	});
 	addComponents(components);
 }
+/**
+* Register a component by its name and filePath.
+*/
 function addComponent(opts) {
 	addComponents([normalizeComponent(opts)]);
 }
@@ -1159,6 +1370,9 @@ function normalizeComponent(opts) {
 		...opts
 	};
 }
+/**
+* Renders given template during build into the virtual file system (and optionally to disk in the project `buildDir`)
+*/
 function addTemplate(_template) {
 	const nuxt = useNuxt();
 	const template = normalizeTemplate(_template);
@@ -1174,12 +1388,23 @@ function addTemplate(_template) {
 	nuxt.options.build.templates.push(template);
 	return template;
 }
+/**
+* Adds a virtual file that can be used within the Nuxt Nitro server build.
+*/
 function addServerTemplate(template) {
 	const nuxt = useNuxt();
 	nuxt.options.nitro.virtual ||= {};
 	nuxt.options.nitro.virtual[template.filename] = template.getContents;
 	return template;
 }
+/**
+* Renders given types during build to disk in the project `buildDir`
+* and register them as types.
+*
+* You can pass a second context object to specify in which context the type should be added.
+*
+* If no context object is passed, then it will only be added to the nuxt context.
+*/
 function addTypeTemplate(_template, context) {
 	const nuxt = useNuxt();
 	const template = addTemplate(_template);
@@ -1203,6 +1428,9 @@ function addTypeTemplate(_template, context) {
 	});
 	return template;
 }
+/**
+* Normalize a nuxt template object
+*/
 function normalizeTemplate(template, buildDir) {
 	if (!template) throw new Error("Invalid template: " + JSON.stringify(template));
 	if (typeof template === "string") template = { src: template };
@@ -1220,6 +1448,11 @@ function normalizeTemplate(template, buildDir) {
 	template.dst ||= resolve(buildDir ?? useNuxt().options.buildDir, template.filename);
 	return template;
 }
+/**
+* Trigger rebuilding Nuxt templates
+*
+* You can pass a filter within the options to selectively regenerate a subset of templates.
+*/
 async function updateTemplates(options) {
 	return await tryUseNuxt()?.hooks.callHook("builder:generateApp", options);
 }
@@ -1643,6 +1876,9 @@ function addRouteMiddleware(input, options = {}) {
 		}
 	});
 }
+/**
+* Normalize a nuxt plugin object
+*/
 const pluginSymbol = Symbol.for("nuxt plugin");
 function normalizePlugin(plugin) {
 	if (typeof plugin === "string") plugin = { src: plugin };
@@ -1676,6 +1912,9 @@ function addPlugin(_plugin, opts = {}) {
 	nuxt.options.plugins[opts.append ? "push" : "unshift"](plugin);
 	return plugin;
 }
+/**
+* Adds a template and registers as a nuxt plugin.
+*/
 function addPluginTemplate(plugin, opts = {}) {
 	return addPlugin(typeof plugin === "string" ? { src: plugin } : {
 		...plugin,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/kit-nightly",
-  "version": "4.3.2-29531071.e4e4ae81",
+  "version": "4.3.2-29531289.6a3bd23e",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/nuxt.git",
@@ -41,13 +41,13 @@
     "untyped": "^2.0.0"
   },
   "devDependencies": {
-    "@nuxt/schema": "npm:@nuxt/schema-nightly@4.3.2-29531071.e4e4ae81",
-    "@rspack/core": "1.7.5",
+    "@nuxt/schema": "npm:@nuxt/schema-nightly@4.3.2-29531289.6a3bd23e",
+    "@rspack/core": "1.7.6",
     "@types/semver": "7.7.1",
     "hookable": "5.5.3",
     "nitro": "3.0.1-alpha.2",
     "nitropack": "2.13.1",
-    "obuild": "0.4.27",
+    "obuild": "0.4.31",
     "unimport": "5.6.0",
     "vite": "7.3.1",
     "vitest": "4.0.18",