@nuxt/cli-nightly 3.26.0-20250607-210256-59f83b1 → 3.26.0-20250607-215204-1943f84

package/bin/nuxi.mjs

@@ -6,6 +6,7 @@ import { runMain } from '../dist/index.mjs'
 globalThis.__nuxt_cli__ = {
   startTime: Date.now(),
   entry: fileURLToPath(import.meta.url),
+  devEntry: fileURLToPath(new URL('../dist/dev/index.mjs', import.meta.url)),
 }
 
 runMain()

package/dist/chunks/add.mjs

@@ -1,318 +1,336 @@
-import { existsSync, promises } from 'node:fs';
+import * as fs from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 import process from 'node:process';
+import { updateConfig } from 'c12/update';
 import { defineCommand } from 'citty';
-import { resolve, extname, dirname } from 'pathe';
-import { l as loadKit } from '../shared/cli-nightly.DlcAx0De.mjs';
-import { l as logLevelArgs, c as cwdArgs, a as logger } from '../shared/cli-nightly.CjK7ZDKA.mjs';
-import { pascalCase, camelCase } from 'scule';
-import 'jiti';
-import 'node:path';
+import { colors } from 'consola/utils';
+import { addDependency } from 'nypm';
+import { $fetch } from 'ofetch';
+import { resolve } from 'pathe';
+import { readPackageJSON } from 'pkg-types';
+import { satisfies } from 'semver';
+import { joinURL } from 'ufo';
+import { r as runCommand } from '../shared/cli-nightly.B4U5vhqQ.mjs';
+import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
+import { a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.BgFMCBoq.mjs';
+import { f as fetchModules, g as getNuxtVersion, c as checkNuxtCompatibility } from '../shared/cli-nightly.C935N1ss.mjs';
+import 'node:url';
+import 'node:crypto';
 import 'std-env';
+import '../shared/cli-nightly.Cf9T6EbF.mjs';
 import 'consola';
-import 'node:url';
-
-const httpMethods = [
-  "connect",
-  "delete",
-  "get",
-  "head",
-  "options",
-  "post",
-  "put",
-  "trace",
-  "patch"
-];
-const api = ({ name, args, nuxtOptions }) => {
-  return {
-    path: resolve(nuxtOptions.srcDir, nuxtOptions.serverDir, `api/${name}${applySuffix(args, httpMethods, "method")}.ts`),
-    contents: `
-export default defineEventHandler(event => {
-  return 'Hello ${name}'
-})
-`
-  };
-};
-
-const app = ({ args, nuxtOptions }) => ({
-  path: resolve(nuxtOptions.srcDir, "app.vue"),
-  contents: args.pages ? `
-<script setup lang="ts"><\/script>
-
-<template>
-  <div>
-    <NuxtLayout>
-      <NuxtPage/>
-    </NuxtLayout>
-  </div>
-</template>
-
-<style scoped></style>
-` : `
-<script setup lang="ts"><\/script>
-
-<template>
-  <div>
-    <h1>Hello World!</h1>
-  </div>
-</template>
-
-<style scoped></style>
-`
-});
-
-const appConfig = ({ nuxtOptions }) => ({
-  path: resolve(nuxtOptions.srcDir, "app.config.ts"),
-  contents: `
-export default defineAppConfig({})
-`
-});
-
-const component = ({ name, args, nuxtOptions }) => ({
-  path: resolve(nuxtOptions.srcDir, `components/${name}${applySuffix(
-    args,
-    ["client", "server"],
-    "mode"
-  )}.vue`),
-  contents: `
-<script setup lang="ts"><\/script>
-
-<template>
-  <div>
-    Component: ${name}
-  </div>
-</template>
-
-<style scoped></style>
-`
-});
-
-const composable = ({ name, nuxtOptions }) => {
-  const nameWithoutUsePrefix = name.replace(/^use-?/, "");
-  const nameWithUsePrefix = `use${pascalCase(nameWithoutUsePrefix)}`;
-  return {
-    path: resolve(nuxtOptions.srcDir, `composables/${name}.ts`),
-    contents: `
-export const ${nameWithUsePrefix} = () => {
-  return ref()
-}
-    `
-  };
-};
-
-const error = ({ nuxtOptions }) => ({
-  path: resolve(nuxtOptions.srcDir, "error.vue"),
-  contents: `
-<script setup lang="ts">
-import type { NuxtError } from '#app'
-
-const props = defineProps({
-  error: Object as () => NuxtError
-})
-<\/script>
-
-<template>
-  <div>
-    <h1>{{ error.statusCode }}</h1>
-    <NuxtLink to="/">Go back home</NuxtLink>
-  </div>
-</template>
-
-<style scoped></style>
-`
-});
-
-const layer = ({ name, nuxtOptions }) => {
-  return {
-    path: resolve(nuxtOptions.srcDir, `layers/${name}/nuxt.config.ts`),
-    contents: `
-export default defineNuxtConfig({})
-`
-  };
-};
-
-const layout = ({ name, nuxtOptions }) => ({
-  path: resolve(nuxtOptions.srcDir, nuxtOptions.dir.layouts, `${name}.vue`),
-  contents: `
-<script setup lang="ts"><\/script>
-
-<template>
-  <div>
-    Layout: ${name}
-    <slot />
-  </div>
-</template>
-
-<style scoped></style>
-`
-});
-
-const middleware = ({ name, args, nuxtOptions }) => ({
-  path: resolve(nuxtOptions.srcDir, nuxtOptions.dir.middleware, `${name}${applySuffix(args, ["global"])}.ts`),
-  contents: `
-export default defineNuxtRouteMiddleware((to, from) => {})
-`
-});
-
-const module = ({ name, nuxtOptions }) => ({
-  path: resolve(nuxtOptions.rootDir, "modules", `${name}.ts`),
-  contents: `
-import { defineNuxtModule } from 'nuxt/kit'
-
-export default defineNuxtModule({
-  meta: {
-    name: '${name}'
-  },
-  setup () {}
-})
-`
-});
-
-const page = ({ name, nuxtOptions }) => ({
-  path: resolve(nuxtOptions.srcDir, nuxtOptions.dir.pages, `${name}.vue`),
-  contents: `
-<script setup lang="ts"><\/script>
-
-<template>
-  <div>
-    Page: ${name}
-  </div>
-</template>
-
-<style scoped></style>
-`
-});
-
-const plugin = ({ name, args, nuxtOptions }) => ({
-  path: resolve(nuxtOptions.srcDir, nuxtOptions.dir.plugins, `${name}${applySuffix(args, ["client", "server"], "mode")}.ts`),
-  contents: `
-export default defineNuxtPlugin(nuxtApp => {})
-  `
-});
-
-const serverMiddleware = ({ name, nuxtOptions }) => ({
-  path: resolve(nuxtOptions.srcDir, nuxtOptions.serverDir, "middleware", `${name}.ts`),
-  contents: `
-export default defineEventHandler(event => {})
-`
-});
-
-const serverPlugin = ({ name, nuxtOptions }) => ({
-  path: resolve(nuxtOptions.srcDir, nuxtOptions.serverDir, "plugins", `${name}.ts`),
-  contents: `
-export default defineNitroPlugin(nitroApp => {})
-`
-});
-
-const serverRoute = ({ name, args, nuxtOptions }) => ({
-  path: resolve(nuxtOptions.srcDir, nuxtOptions.serverDir, args.api ? "api" : "routes", `${name}.ts`),
-  contents: `
-export default defineEventHandler(event => {})
-`
-});
-
-const serverUtil = ({ name, nuxtOptions }) => ({
-  path: resolve(nuxtOptions.srcDir, nuxtOptions.serverDir, "utils", `${name}.ts`),
-  contents: `
-export function ${camelCase(name)}() {}
-`
-});
 
-const templates = {
-  "api": api,
-  "app": app,
-  "app-config": appConfig,
-  "component": component,
-  "composable": composable,
-  "error": error,
-  "layer": layer,
-  "layout": layout,
-  "middleware": middleware,
-  "module": module,
-  "page": page,
-  "plugin": plugin,
-  "server-middleware": serverMiddleware,
-  "server-plugin": serverPlugin,
-  "server-route": serverRoute,
-  "server-util": serverUtil
-};
-function applySuffix(args, suffixes, unwrapFrom) {
-  let suffix = "";
-  for (const s of suffixes) {
-    if (args[s]) {
-      suffix += `.${s}`;
-    }
-  }
-  if (unwrapFrom && args[unwrapFrom] && suffixes.includes(args[unwrapFrom])) {
-    suffix += `.${args[unwrapFrom]}`;
-  }
-  return suffix;
-}
-
-const templateNames = Object.keys(templates);
 const add = defineCommand({
   meta: {
     name: "add",
-    description: "Create a new template file."
+    description: "Add Nuxt modules"
   },
   args: {
     ...cwdArgs,
     ...logLevelArgs,
-    force: {
+    moduleName: {
+      type: "positional",
+      description: "Specify one or more modules to install by name, separated by spaces"
+    },
+    skipInstall: {
       type: "boolean",
-      description: "Force override file if it already exists",
-      default: false
+      description: "Skip npm install"
     },
-    template: {
-      type: "positional",
-      required: true,
-      valueHint: templateNames.join("|"),
-      description: `Specify which template to generate`
+    skipConfig: {
+      type: "boolean",
+      description: "Skip nuxt.config.ts update"
     },
-    name: {
-      type: "positional",
-      required: true,
-      description: "Specify name of the generated file"
+    dev: {
+      type: "boolean",
+      description: "Install modules as dev dependencies"
     }
   },
-  async run(ctx) {
+  async setup(ctx) {
     const cwd = resolve(ctx.args.cwd);
-    const templateName = ctx.args.template;
-    if (!templateNames.includes(templateName)) {
-      logger.error(
-        `Template ${templateName} is not supported. Possible values: ${Object.keys(
-          templates
-        ).join(", ")}`
+    const modules = ctx.args._.map((e) => e.trim()).filter(Boolean);
+    const projectPkg = await readPackageJSON(cwd).catch(() => ({}));
+    if (!projectPkg.dependencies?.nuxt && !projectPkg.devDependencies?.nuxt) {
+      logger.warn(`No \`nuxt\` dependency detected in \`${cwd}\`.`);
+      const shouldContinue = await logger.prompt(
+        `Do you want to continue anyway?`,
+        {
+          type: "confirm",
+          initial: false,
+          cancel: "default"
+        }
       );
-      process.exit(1);
+      if (shouldContinue !== true) {
+        process.exit(1);
+      }
     }
-    const ext = extname(ctx.args.name);
-    const name = ext === ".vue" || ext === ".ts" ? ctx.args.name.replace(ext, "") : ctx.args.name;
-    if (!name) {
-      logger.error("name argument is missing!");
-      process.exit(1);
+    const maybeResolvedModules = await Promise.all(modules.map((moduleName) => resolveModule(moduleName, cwd)));
+    const resolvedModules = maybeResolvedModules.filter((x) => x != null);
+    logger.info(`Resolved \`${resolvedModules.map((x) => x.pkgName).join("`, `")}\`, adding module${resolvedModules.length > 1 ? "s" : ""}...`);
+    await addModules(resolvedModules, { ...ctx.args, cwd }, projectPkg);
+    if (!ctx.args.skipInstall) {
+      const args = Object.entries(ctx.args).filter(([k]) => k in cwdArgs || k in logLevelArgs).map(([k, v]) => `--${k}=${v}`);
+      await runCommand("prepare", args);
     }
-    const kit = await loadKit(cwd);
-    const config = await kit.loadNuxtConfig({ cwd });
-    const template = templates[templateName];
-    const res = template({ name, args: ctx.args, nuxtOptions: config });
-    if (!ctx.args.force && existsSync(res.path)) {
-      logger.error(
-        `File exists: ${res.path} . Use --force to override or use a different name.`
+  }
+});
+async function addModules(modules, { skipInstall, skipConfig, cwd, dev }, projectPkg) {
+  if (!skipInstall) {
+    const installedModules = [];
+    const notInstalledModules = [];
+    const dependencies = /* @__PURE__ */ new Set([
+      ...Object.keys(projectPkg.dependencies || {}),
+      ...Object.keys(projectPkg.devDependencies || {})
+    ]);
+    for (const module of modules) {
+      if (dependencies.has(module.pkgName)) {
+        installedModules.push(module);
+      } else {
+        notInstalledModules.push(module);
+      }
+    }
+    if (installedModules.length > 0) {
+      const installedModulesList = installedModules.map((module) => module.pkgName).join("`, `");
+      const are = installedModules.length > 1 ? "are" : "is";
+      logger.info(`\`${installedModulesList}\` ${are} already installed`);
+    }
+    if (notInstalledModules.length > 0) {
+      const isDev = Boolean(projectPkg.devDependencies?.nuxt) || dev;
+      const notInstalledModulesList = notInstalledModules.map((module) => module.pkg).join("`, `");
+      const dependency = notInstalledModules.length > 1 ? "dependencies" : "dependency";
+      const a = notInstalledModules.length > 1 ? "" : " a";
+      logger.info(`Installing \`${notInstalledModulesList}\` as${a}${isDev ? " development" : ""} ${dependency}`);
+      const res = await addDependency(notInstalledModules.map((module) => module.pkg), {
+        cwd,
+        dev: isDev,
+        installPeerDependencies: true
+      }).then(() => true).catch(
+        (error) => {
+          logger.error(error);
+          const failedModulesList = notInstalledModules.map((module) => colors.cyan(module.pkg)).join("`, `");
+          const s = notInstalledModules.length > 1 ? "s" : "";
+          return logger.prompt(`Install failed for \`${failedModulesList}\`. Do you want to continue adding the module${s} to ${colors.cyan("nuxt.config")}?`, {
+            type: "confirm",
+            initial: false,
+            cancel: "default"
+          });
+        }
       );
-      process.exit(1);
+      if (res !== true) {
+        return;
+      }
     }
-    const parentDir = dirname(res.path);
-    if (!existsSync(parentDir)) {
-      logger.info("Creating directory", parentDir);
-      if (templateName === "page") {
-        logger.info("This enables vue-router functionality!");
+  }
+  if (!skipConfig) {
+    await updateConfig({
+      cwd,
+      configFile: "nuxt.config",
+      async onCreate() {
+        logger.info(`Creating \`nuxt.config.ts\``);
+        return getDefaultNuxtConfig();
+      },
+      async onUpdate(config) {
+        if (!config.modules) {
+          config.modules = [];
+        }
+        for (const resolved of modules) {
+          if (config.modules.includes(resolved.pkgName)) {
+            logger.info(`\`${resolved.pkgName}\` is already in the \`modules\``);
+            continue;
+          }
+          logger.info(`Adding \`${resolved.pkgName}\` to the \`modules\``);
+          config.modules.push(resolved.pkgName);
+        }
       }
-      await promises.mkdir(parentDir, { recursive: true });
+    }).catch((error) => {
+      logger.error(`Failed to update \`nuxt.config\`: ${error.message}`);
+      logger.error(`Please manually add \`${modules.map((module) => module.pkgName).join("`, `")}\` to the \`modules\` in \`nuxt.config.ts\``);
+      return null;
+    });
+  }
+}
+function getDefaultNuxtConfig() {
+  return `
+// https://nuxt.com/docs/api/configuration/nuxt-config
+export default defineNuxtConfig({
+  modules: []
+})`;
+}
+const packageRegex = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?([a-z0-9-~][a-z0-9-._~]*)(@[^@]+)?$/;
+async function resolveModule(moduleName, cwd) {
+  let pkgName = moduleName;
+  let pkgVersion;
+  const reMatch = moduleName.match(packageRegex);
+  if (reMatch) {
+    if (reMatch[3]) {
+      pkgName = `${reMatch[1] || ""}${reMatch[2] || ""}`;
+      pkgVersion = reMatch[3].slice(1);
     }
-    await promises.writeFile(res.path, `${res.contents.trim()}
-`);
-    logger.info(`\u{1FA84} Generated a new ${templateName} in ${res.path}`);
+  } else {
+    logger.error(`Invalid package name \`${pkgName}\`.`);
+    return false;
   }
-});
+  const modulesDB = await fetchModules().catch((err) => {
+    logger.warn(`Cannot search in the Nuxt Modules database: ${err}`);
+    return [];
+  });
+  const matchedModule = modulesDB.find(
+    (module) => module.name === moduleName || pkgVersion && module.name === pkgName || module.npm === pkgName || module.aliases?.includes(pkgName)
+  );
+  if (matchedModule?.npm) {
+    pkgName = matchedModule.npm;
+  }
+  if (matchedModule && matchedModule.compatibility.nuxt) {
+    const nuxtVersion = await getNuxtVersion(cwd);
+    if (!checkNuxtCompatibility(matchedModule, nuxtVersion)) {
+      logger.warn(
+        `The module \`${pkgName}\` is not compatible with Nuxt \`${nuxtVersion}\` (requires \`${matchedModule.compatibility.nuxt}\`)`
+      );
+      const shouldContinue = await logger.prompt(
+        "Do you want to continue installing incompatible version?",
+        {
+          type: "confirm",
+          initial: false,
+          cancel: "default"
+        }
+      );
+      if (!shouldContinue) {
+        return false;
+      }
+    }
+    const versionMap = matchedModule.compatibility.versionMap;
+    if (versionMap) {
+      for (const [_nuxtVersion, _moduleVersion] of Object.entries(versionMap)) {
+        if (satisfies(nuxtVersion, _nuxtVersion)) {
+          if (!pkgVersion) {
+            pkgVersion = _moduleVersion;
+          } else {
+            logger.warn(
+              `Recommended version of \`${pkgName}\` for Nuxt \`${nuxtVersion}\` is \`${_moduleVersion}\` but you have requested \`${pkgVersion}\``
+            );
+            pkgVersion = await logger.prompt("Choose a version:", {
+              type: "select",
+              options: [_moduleVersion, pkgVersion],
+              cancel: "undefined"
+            });
+            if (!pkgVersion) {
+              return false;
+            }
+          }
+          break;
+        }
+      }
+    }
+  }
+  let version = pkgVersion || "latest";
+  const pkgScope = pkgName.startsWith("@") ? pkgName.split("/")[0] : null;
+  const meta = await detectNpmRegistry(pkgScope);
+  const headers = {};
+  if (meta.authToken) {
+    headers.Authorization = `Bearer ${meta.authToken}`;
+  }
+  const pkgDetails = await $fetch(joinURL(meta.registry, `${pkgName}`), { headers });
+  if (pkgDetails["dist-tags"]?.[version]) {
+    version = pkgDetails["dist-tags"][version];
+  } else {
+    version = Object.keys(pkgDetails.versions)?.findLast((v) => satisfies(v, version)) || version;
+  }
+  const pkg = pkgDetails.versions[version];
+  const pkgDependencies = Object.assign(
+    pkg.dependencies || {},
+    pkg.devDependencies || {}
+  );
+  if (!pkgDependencies.nuxt && !pkgDependencies["nuxt-edge"] && !pkgDependencies["@nuxt/kit"]) {
+    logger.warn(`It seems that \`${pkgName}\` is not a Nuxt module.`);
+    const shouldContinue = await logger.prompt(
+      `Do you want to continue installing ${colors.cyan(pkgName)} anyway?`,
+      {
+        type: "confirm",
+        initial: false,
+        cancel: "default"
+      }
+    );
+    if (!shouldContinue) {
+      return false;
+    }
+  }
+  return {
+    nuxtModule: matchedModule,
+    pkg: `${pkgName}@${version}`,
+    pkgName,
+    pkgVersion: version
+  };
+}
+function getNpmrcPaths() {
+  const userNpmrcPath = join(homedir(), ".npmrc");
+  const cwdNpmrcPath = join(process.cwd(), ".npmrc");
+  return [cwdNpmrcPath, userNpmrcPath];
+}
+async function getAuthToken(registry) {
+  const paths = getNpmrcPaths();
+  const authTokenRegex = new RegExp(`^//${registry.replace(/^https?:\/\//, "").replace(/\/$/, "")}/:_authToken=(.+)$`, "m");
+  for (const npmrcPath of paths) {
+    let fd;
+    try {
+      fd = await fs.promises.open(npmrcPath, "r");
+      if (await fd.stat().then((r) => r.isFile())) {
+        const npmrcContent = await fd.readFile("utf-8");
+        const authTokenMatch = npmrcContent.match(authTokenRegex)?.[1];
+        if (authTokenMatch) {
+          return authTokenMatch.trim();
+        }
+      }
+    } catch {
+    } finally {
+      await fd?.close();
+    }
+  }
+  return null;
+}
+async function detectNpmRegistry(scope) {
+  const registry = await getRegistry(scope);
+  const authToken = await getAuthToken(registry);
+  return {
+    registry,
+    authToken
+  };
+}
+async function getRegistry(scope) {
+  if (process.env.COREPACK_NPM_REGISTRY) {
+    return process.env.COREPACK_NPM_REGISTRY;
+  }
+  const registry = await getRegistryFromFile(getNpmrcPaths(), scope);
+  if (registry) {
+    process.env.COREPACK_NPM_REGISTRY = registry;
+  }
+  return registry || "https://registry.npmjs.org";
+}
+async function getRegistryFromFile(paths, scope) {
+  for (const npmrcPath of paths) {
+    let fd;
+    try {
+      fd = await fs.promises.open(npmrcPath, "r");
+      if (await fd.stat().then((r) => r.isFile())) {
+        const npmrcContent = await fd.readFile("utf-8");
+        if (scope) {
+          const scopedRegex = new RegExp(`^${scope}:registry=(.+)$`, "m");
+          const scopedMatch = npmrcContent.match(scopedRegex)?.[1];
+          if (scopedMatch) {
+            return scopedMatch.trim();
+          }
+        }
+        const defaultRegex = /^\s*registry=(.+)$/m;
+        const defaultMatch = npmrcContent.match(defaultRegex)?.[1];
+        if (defaultMatch) {
+          return defaultMatch.trim();
+        }
+      }
+    } catch {
+    } finally {
+      await fd?.close();
+    }
+  }
+  return null;
+}
 
 export { add as default };