@nuxt/cli-nightly 0.0.0 → 3.20.0-20250109-193455-6ea36ef

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Nuxt Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,27 @@
+# Nuxt CLI (nuxi)
+
+⚡️ [Nuxt](https://nuxt.com/) Generation CLI Experience.
+
+## Commands
+
+All commands are listed on https://nuxt.com/docs/api/commands
+
+## Contributing
+
+```bash
+# Install dependencies
+pnpm i
+
+# Generate type stubs
+pnpm dev:prepare
+
+# Go to the playground directory
+cd playground
+
+# And run any commands
+pnpm nuxi <command>
+```
+
+## License
+
+[MIT](./LICENSE)

package/bin/nuxi.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'node:url'
+import { runMain } from '../dist/index.mjs'
+
+globalThis.__nuxt_cli__ = {
+  startTime: Date.now(),
+  entry: fileURLToPath(import.meta.url),
+}
+
+runMain()

package/dist/chunks/add.mjs

@@ -0,0 +1,317 @@
+import { existsSync, promises } from 'node:fs';
+import process from 'node:process';
+import { defineCommand } from 'citty';
+import { resolve, extname, dirname } from 'pathe';
+import { l as loadKit } from '../shared/cli-nightly.DlcAx0De.mjs';
+import { c as cwdArgs, l as logLevelArgs, a as logger } from '../shared/cli-nightly.CnY_9Zvw.mjs';
+import { pascalCase, camelCase } from 'scule';
+import 'jiti';
+import 'node:path';
+import 'std-env';
+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}.vue`),
+  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."
+  },
+  args: {
+    ...cwdArgs,
+    ...logLevelArgs,
+    force: {
+      type: "boolean",
+      description: "Override existing file"
+    },
+    template: {
+      type: "positional",
+      required: true,
+      valueHint: templateNames.join("|"),
+      description: `Template type to scaffold`
+    },
+    name: {
+      type: "positional",
+      required: true,
+      description: "Generated file name"
+    }
+  },
+  async run(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(", ")}`
+      );
+      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 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.`
+      );
+      process.exit(1);
+    }
+    const parentDir = dirname(res.path);
+    if (!existsSync(parentDir)) {
+      logger.info("Creating directory", parentDir);
+      if (templateName === "page") {
+        logger.info("This enables vue-router functionality!");
+      }
+      await promises.mkdir(parentDir, { recursive: true });
+    }
+    await promises.writeFile(res.path, `${res.contents.trim()}
+`);
+    logger.info(`\u{1FA84} Generated a new ${templateName} in ${res.path}`);
+  }
+});
+
+export { add as default };

package/dist/chunks/add2.mjs

@@ -0,0 +1,320 @@
+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 { 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 { c as cwdArgs, l as logLevelArgs, a as logger, r as runCommand } from '../shared/cli-nightly.CnY_9Zvw.mjs';
+import { f as fetchModules, g as getNuxtVersion, c as checkNuxtCompatibility } from '../shared/cli-nightly.C935N1ss.mjs';
+import 'std-env';
+import 'consola';
+import 'node:url';
+
+const add = defineCommand({
+  meta: {
+    name: "add",
+    description: "Add Nuxt modules"
+  },
+  args: {
+    ...cwdArgs,
+    ...logLevelArgs,
+    moduleName: {
+      type: "positional",
+      description: "Specify one or more modules to install by name, separated by spaces"
+    },
+    skipInstall: {
+      type: "boolean",
+      description: "Skip npm install"
+    },
+    skipConfig: {
+      type: "boolean",
+      description: "Skip nuxt.config.ts update"
+    },
+    dev: {
+      type: "boolean",
+      description: "Install modules as dev dependencies"
+    }
+  },
+  async setup(ctx) {
+    const cwd = resolve(ctx.args.cwd);
+    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
+        }
+      );
+      if (shouldContinue !== true) {
+        return false;
+      }
+    }
+    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);
+    const args = Object.entries(ctx.args).filter(([k]) => k in cwdArgs || k in logLevelArgs).map(([k, v]) => `--${k}=${v}`);
+    await runCommand("prepare", args);
+  }
+});
+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
+      }).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
+          });
+        }
+      );
+      if (res === false) {
+        return;
+      }
+    }
+  }
+  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);
+        }
+      }
+    }).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);
+    }
+  } 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 || 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
+        }
+      );
+      if (shouldContinue !== true) {
+        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]
+            });
+          }
+          break;
+        }
+      }
+    }
+  }
+  pkgVersion = 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
+  });
+  pkgVersion = pkgDetails["dist-tags"]?.[pkgVersion] || pkgVersion;
+  const pkg = pkgDetails.versions[pkgVersion];
+  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 \`${pkgName}\` anyway?`,
+      {
+        type: "confirm",
+        initial: false
+      }
+    );
+    if (shouldContinue !== true) {
+      return false;
+    }
+  }
+  return {
+    nuxtModule: matchedModule,
+    pkg: `${pkgName}@${pkgVersion}`,
+    pkgName,
+    pkgVersion
+  };
+}
+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 };