@nuxt/kit 3.5.3 → 3.6.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ModuleOptions, ModuleDefinition, NuxtModule, Nuxt, NuxtConfig, NuxtOptions, SchemaDefinition, ImportPresetWithDeprecation, NuxtCompatibility, NuxtCompatibilityIssues, ComponentsDir, Component, NuxtTemplate, NuxtHooks, NuxtMiddleware, NuxtPlugin, NuxtPluginTemplate, ResolvedNuxtTemplate } from '@nuxt/schema';
+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';
@@ -12,11 +12,33 @@ 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>;
+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 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> {
 }
@@ -102,6 +124,7 @@ interface AddBuildPluginFactory {
 }
 declare function addBuildPlugin(pluginFactory: AddBuildPluginFactory, options?: ExtendConfigOptions): void;
 
+declare function normalizeSemanticVersion(version: string): string;
 /**
  * Check version constraints and return incompatibility issues as an array
  */
@@ -301,6 +324,11 @@ 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
  */
@@ -345,7 +373,7 @@ declare function tryRequireModule(id: string, opts?: RequireModuleOptions): any;
  *
  * @internal
  */
-declare function tryResolveModule(id: string, url?: string | string[]): Promise<any>;
+declare function tryResolveModule(id: string, url?: string | string[]): Promise<string | undefined>;
 
 /** @deprecated */
 declare function compileTemplate(template: NuxtTemplate, ctx: any): Promise<string>;
@@ -358,4 +386,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, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, compileTemplate, createResolver, defineNuxtModule, extendNuxtSchema, extendPages, extendRouteRules, extendViteConfig, extendWebpackConfig, findPath, getNuxtVersion, hasNuxtCompatibility, importModule, installModule, isIgnored, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, logger, normalizeModuleTranspilePath, normalizePlugin, normalizeTemplate, nuxtCtx, requireModule, resolveAlias, resolveFiles, resolveModule, resolvePath, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateTemplates, useLogger, useNitro, useNuxt };
+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 };

package/dist/index.mjs

@@ -36,12 +36,14 @@ function tryUseNuxt() {
   return nuxtCtx.tryUse();
 }
 
+function normalizeSemanticVersion(version) {
+  return version.replace(/-[0-9]+\.[0-9a-f]+/, "");
+}
 async function checkNuxtCompatibility(constraints, nuxt = useNuxt()) {
   const issues = [];
   if (constraints.nuxt) {
     const nuxtVersion = getNuxtVersion(nuxt);
-    const nuxtSemanticVersion = nuxtVersion.replace(/-[0-9]+\.[0-9a-f]+/, "");
-    if (!satisfies(nuxtSemanticVersion, constraints.nuxt, { includePrerelease: true })) {
+    if (!satisfies(normalizeSemanticVersion(nuxtVersion), constraints.nuxt, { includePrerelease: true })) {
       issues.push({
         name: "nuxt",
         message: `Nuxt version \`${constraints.nuxt}\` is required but currently using \`${nuxtVersion}\``
@@ -2092,18 +2094,19 @@ const importName = genSafeVariableName;
 const templateUtils = { serialize, importName, importSources };
 
 function defineNuxtModule(definition) {
-  if (!definition.meta) {
-    definition.meta = {};
+  if (typeof definition === "function") {
+    return defineNuxtModule({ setup: definition });
   }
-  if (definition.meta.configKey === void 0) {
-    definition.meta.configKey = definition.meta.name;
+  const module = defu(definition, { meta: {} });
+  if (module.meta.configKey === void 0) {
+    module.meta.configKey = module.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;
+    const configKey = module.meta.configKey || module.meta.name;
+    const _defaults = module.defaults instanceof Function ? module.defaults(nuxt) : module.defaults;
     let _options = defu(inlineOptions, nuxt.options[configKey], _defaults);
-    if (definition.schema) {
-      _options = await applyDefaults(definition.schema, _options);
+    if (module.schema) {
+      _options = await applyDefaults(module.schema, _options);
     }
     return Promise.resolve(_options);
   }
@@ -2111,7 +2114,7 @@ function defineNuxtModule(definition) {
     if (!nuxt) {
       nuxt = tryUseNuxt() || this.nuxt;
     }
-    const uniqueKey = definition.meta.name || definition.meta.configKey;
+    const uniqueKey = module.meta.name || module.meta.configKey;
     if (uniqueKey) {
       nuxt.options._requiredModules = nuxt.options._requiredModules || {};
       if (nuxt.options._requiredModules[uniqueKey]) {
@@ -2119,22 +2122,22 @@ function defineNuxtModule(definition) {
       }
       nuxt.options._requiredModules[uniqueKey] = true;
     }
-    if (definition.meta.compatibility) {
-      const issues = await checkNuxtCompatibility(definition.meta.compatibility, nuxt);
+    if (module.meta.compatibility) {
+      const issues = await checkNuxtCompatibility(module.meta.compatibility, nuxt);
       if (issues.length) {
-        logger.warn(`Module \`${definition.meta.name}\` is disabled due to incompatibility issues:
+        logger.warn(`Module \`${module.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);
+    if (module.hooks) {
+      nuxt.hooks.addHooks(module.hooks);
     }
     const key = `nuxt:module:${uniqueKey || Math.round(Math.random() * 1e4)}`;
     const mark = performance.mark(key);
-    const res = await definition.setup?.call(null, _options, nuxt) ?? {};
+    const res = await module.setup?.call(null, _options, nuxt) ?? {};
     const perf = performance.measure(key, mark?.name);
     const setupTime = perf ? Math.round(perf.duration * 100) / 100 : 0;
     if (setupTime > 5e3) {
@@ -2151,7 +2154,7 @@ ${issues.toString()}`);
       }
     });
   }
-  normalizedModule.getMeta = () => Promise.resolve(definition.meta);
+  normalizedModule.getMeta = () => Promise.resolve(module.meta);
   normalizedModule.getOptions = getOptions;
   return normalizedModule;
 }
@@ -2401,9 +2404,8 @@ async function resolveFiles(path, pattern, opts = {}) {
   return files.map((p) => resolve(path, p)).filter((p) => !isIgnored(p)).sort();
 }
 
-async function installModule(moduleToInstall, _inlineOptions, _nuxt) {
-  const nuxt = useNuxt();
-  const { nuxtModule, inlineOptions } = await normalizeModule(moduleToInstall, _inlineOptions);
+async function installModule(moduleToInstall, inlineOptions, nuxt = useNuxt()) {
+  const { nuxtModule, buildTimeModuleMeta } = await loadNuxtModuleInstance(moduleToInstall, nuxt);
   const res = (isNuxt2() ? await nuxtModule.call(nuxt.moduleContainer, inlineOptions, nuxt) : await nuxtModule(inlineOptions, nuxt)) ?? {};
   if (res === false) {
     return;
@@ -2413,7 +2415,7 @@ async function installModule(moduleToInstall, _inlineOptions, _nuxt) {
   }
   nuxt.options._installedModules = nuxt.options._installedModules || [];
   nuxt.options._installedModules.push({
-    meta: await nuxtModule.getMeta?.(),
+    meta: defu(await nuxtModule.getMeta?.(), buildTimeModuleMeta),
     timings: res.timings,
     entryPath: typeof moduleToInstall === "string" ? resolveAlias(moduleToInstall) : void 0
   });
@@ -2425,8 +2427,8 @@ const normalizeModuleTranspilePath = (p) => {
   }
   return p.split("node_modules/").pop();
 };
-async function normalizeModule(nuxtModule, inlineOptions) {
-  const nuxt = useNuxt();
+async function loadNuxtModuleInstance(nuxtModule, nuxt = useNuxt()) {
+  let buildTimeModuleMeta = {};
   if (typeof nuxtModule === "string") {
     const src = await resolvePath(nuxtModule);
     try {
@@ -2435,11 +2437,45 @@ async function normalizeModule(nuxtModule, inlineOptions) {
       console.error(`Error while requiring module \`${nuxtModule}\`: ${error}`);
       throw error;
     }
+    if (existsSync(join(dirname(src), "module.json"))) {
+      buildTimeModuleMeta = JSON.parse(await promises.readFile(join(dirname(src), "module.json"), "utf-8"));
+    }
   }
   if (typeof nuxtModule !== "function") {
     throw new TypeError("Nuxt module should be a function: " + nuxtModule);
   }
-  return { nuxtModule, inlineOptions };
+  return { nuxtModule, buildTimeModuleMeta };
+}
+
+function hasNuxtModule(moduleName, nuxt = useNuxt()) {
+  return nuxt.options._installedModules.some(({ meta }) => meta.name === moduleName) || nuxt.options.modules.includes(moduleName);
+}
+async function hasNuxtModuleCompatibility(module, semverVersion, nuxt = useNuxt()) {
+  const version = await getNuxtModuleVersion(module, nuxt);
+  if (!version) {
+    return false;
+  }
+  return satisfies(normalizeSemanticVersion(version), semverVersion, {
+    includePrerelease: true
+  });
+}
+async function getNuxtModuleVersion(module, nuxt = useNuxt()) {
+  const moduleMeta = (typeof module === "string" ? { name: module } : await module.getMeta?.()) || {};
+  if (moduleMeta.version) {
+    return moduleMeta.version;
+  }
+  if (!moduleMeta.name) {
+    return false;
+  }
+  const version = nuxt.options._installedModules.filter((m) => m.meta.name === moduleMeta.name).map((m) => m.meta.version)?.[0];
+  if (version) {
+    return version;
+  }
+  if (typeof module !== "string" && nuxt.options.modules.includes(moduleMeta.name)) {
+    const { buildTimeModuleMeta } = await loadNuxtModuleInstance(moduleMeta.name, nuxt);
+    return buildTimeModuleMeta.version || false;
+  }
+  return false;
 }
 
 async function loadNuxtConfig(opts) {
@@ -2672,6 +2708,17 @@ function addTemplate(_template) {
   nuxt.options.build.templates.push(template);
   return template;
 }
+function addTypeTemplate(_template) {
+  const nuxt = useNuxt();
+  const template = addTemplate(_template);
+  if (!template.filename.endsWith(".d.ts")) {
+    throw new Error(`Invalid type template. Filename must end with .d.ts : "${template.filename}"`);
+  }
+  nuxt.hook("prepare:types", ({ references }) => {
+    references.push({ path: template.dst });
+  });
+  return template;
+}
 function normalizeTemplate(template) {
   if (!template) {
     throw new Error("Invalid template: " + JSON.stringify(template));
@@ -2853,4 +2900,4 @@ function useNitro() {
   return nuxt._nitro;
 }
 
-export { addBuildPlugin, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addRouteMiddleware, addServerHandler, addServerPlugin, addTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, compileTemplate, createResolver, defineNuxtModule, extendNuxtSchema, extendPages, extendRouteRules, extendViteConfig, extendWebpackConfig, findPath, getNuxtVersion, hasNuxtCompatibility, importModule$1 as importModule, installModule, isIgnored, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, logger, normalizeModuleTranspilePath, normalizePlugin, 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, resolveModule, resolvePath, templateUtils, tryImportModule$1 as tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, updateTemplates, useLogger, useNitro, useNuxt };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/kit",
-  "version": "3.5.3",
+  "version": "3.6.1",
   "repository": "nuxt/nuxt",
   "license": "MIT",
   "type": "module",
@@ -17,34 +17,34 @@
     "dist"
   ],
   "dependencies": {
-    "c12": "^1.4.1",
+    "c12": "^1.4.2",
     "consola": "^3.1.0",
     "defu": "^6.1.2",
-    "globby": "^13.1.4",
+    "globby": "^13.2.0",
     "hash-sum": "^2.0.0",
     "ignore": "^5.2.4",
     "jiti": "^1.18.2",
     "knitwork": "^1.0.0",
-    "mlly": "^1.3.0",
+    "mlly": "^1.4.0",
     "pathe": "^1.1.1",
     "pkg-types": "^1.0.3",
     "scule": "^1.0.0",
-    "semver": "^7.5.1",
+    "semver": "^7.5.3",
     "unctx": "^2.3.1",
-    "unimport": "^3.0.7",
+    "unimport": "^3.0.10",
     "untyped": "^1.3.2",
-    "@nuxt/schema": "3.5.3"
+    "@nuxt/schema": "3.6.1"
   },
   "devDependencies": {
     "@types/hash-sum": "1.0.0",
     "@types/lodash-es": "4.17.7",
     "@types/semver": "7.5.0",
     "lodash-es": "4.17.21",
-    "nitropack": "2.4.1",
+    "nitropack": "2.5.1",
     "unbuild": "latest",
     "vite": "4.3.9",
-    "vitest": "0.31.4",
-    "webpack": "5.85.1"
+    "vitest": "0.32.2",
+    "webpack": "5.88.0"
   },
   "engines": {
     "node": "^14.18.0 || >=16.10.0"