create-vuetify 2.2.5 → 2.3.0

package/dist/index.mjs

@@ -23,91 +23,153 @@ var essentialsContext = {
   useStore: true
 };
 var presets = {
-  base: baseContext,
-  default: defaultContext,
-  essentials: essentialsContext
+  "base": baseContext,
+  "default": defaultContext,
+  "essentials": essentialsContext,
+  "nuxt-base": baseContext,
+  "nuxt-default": defaultContext,
+  "nuxt-essentials": essentialsContext
 };
 
 // src/utils/prompts.ts
 import { red } from "kolorist";
 import prompts from "prompts";
 import validate from "validate-npm-package-name";
-var promptQuestions = (context) => [
-  {
-    name: "projectName",
-    type: "text",
-    message: "Project name:",
-    initial: "vuetify-project",
-    validate: (v) => {
-      const { errors } = validate(String(v).trim());
-      return !(errors && errors.length) || `Package ${errors[0]}`;
-    }
-  },
-  {
-    name: "canOverwrite",
-    active: "Yes",
-    inactive: "No",
-    initial: false,
-    type: (_, { projectName }) => {
-      const projectPath = join(context.cwd, projectName);
-      return !existsSync(projectPath) || readdirSync(projectPath).length === 0 ? null : "toggle";
-    },
-    message: (prev) => `The project path: ${resolve(context.cwd, prev)} already exists, would you like to overwrite this directory?`
-  },
-  {
-    name: "usePreset",
-    type: context.usePreset ? null : "select",
-    message: "Which preset would you like to install?",
-    initial: 0,
-    choices: [
-      { title: "Default (Vuetify)", value: "default" },
-      { title: "Base (Default, Routing)", value: "base" },
-      { title: "Essentials (Base, Layouts, Pinia)", value: "essentials" }
-    ]
-  },
-  {
-    name: "useTypeScript",
-    type: context.useTypeScript ? null : "toggle",
-    message: "Use TypeScript?",
-    active: "Yes",
-    inactive: "No",
-    initial: false
-  },
-  {
-    name: "usePackageManager",
-    type: "select",
-    message: "Would you like to install dependencies with yarn, npm, pnpm, or bun?",
-    initial: 0,
-    choices: [
-      { title: "yarn", value: "yarn" },
-      { title: "npm", value: "npm" },
-      { title: "pnpm", value: "pnpm" },
-      { title: "bun", value: "bun" },
-      { title: "none", value: null }
-    ]
-  },
-  {
-    name: "installDependencies",
-    type: context.installDependencies ? null : "toggle",
-    message: "Install Dependencies?",
-    active: "Yes",
-    inactive: "No",
-    initial: "Yes"
-  }
-];
 var promptOptions = {
   onCancel: () => {
     throw new Error(red("\u2716") + " Operation cancelled");
   }
 };
 var initPrompts = async (context) => {
+  let answers;
   if (context.usePreset) {
     context = {
       ...context,
       ...presets[context.usePreset]
     };
   }
-  const answers = await prompts(promptQuestions(context), promptOptions);
+  answers = await prompts([
+    {
+      name: "projectName",
+      type: "text",
+      message: "Project name:",
+      initial: "vuetify-project",
+      validate: (v) => {
+        const { errors } = validate(String(v).trim());
+        return !(errors && errors.length) || `Package ${errors[0]}`;
+      }
+    },
+    {
+      name: "canOverwrite",
+      active: "Yes",
+      inactive: "No",
+      initial: false,
+      type: (_, { projectName }) => {
+        const projectPath = join(context.cwd, projectName);
+        return !existsSync(projectPath) || readdirSync(projectPath).length === 0 ? null : "toggle";
+      },
+      message: (prev) => `The project path: ${resolve(context.cwd, prev)} already exists, would you like to overwrite this directory?`
+    },
+    {
+      name: "usePreset",
+      type: context.usePreset ? null : "select",
+      message: "Which preset would you like to install?",
+      initial: 1,
+      choices: [
+        { title: "Barebones (Only Vue & Vuetify)", value: "default" },
+        { title: "Default (Adds routing, ESLint & SASS variables)", value: "base" },
+        { title: "Recommended (Everything from Default. Adds auto importing, layouts & pinia)", value: "essentials" },
+        { title: "Nuxt Barebones (Only Vuetify)", value: "nuxt-default" },
+        { title: "Nuxt Default (Adds Nuxt ESLint & SASS variables)", value: "nuxt-base" },
+        { title: "Nuxt Recommended (Everything from Default. Enables auto importing & layouts)", value: "nuxt-essentials" }
+      ]
+    },
+    {
+      name: "useTypeScript",
+      type: (usePreset) => {
+        const p = context.usePreset ?? usePreset;
+        return p.startsWith("nuxt-") || context.useTypeScript ? null : "toggle";
+      },
+      message: "Use TypeScript?",
+      active: "Yes",
+      inactive: "No",
+      initial: false
+    },
+    {
+      name: "usePackageManager",
+      type: (_, { usePreset }) => {
+        const p = context.usePreset ?? usePreset;
+        return p.startsWith("nuxt-") ? null : "select";
+      },
+      message: "Would you like to install dependencies with yarn, npm, pnpm, or bun?",
+      initial: 0,
+      choices: [
+        { title: "yarn", value: "yarn" },
+        { title: "npm", value: "npm" },
+        { title: "pnpm", value: "pnpm" },
+        { title: "bun", value: "bun" },
+        { title: "none", value: null }
+      ]
+    },
+    {
+      name: "installDependencies",
+      type: (_, { usePreset }) => {
+        const p = context.usePreset ?? usePreset;
+        return p.startsWith("nuxt-") || context.installDependencies ? null : "toggle";
+      },
+      message: "Install Dependencies?",
+      active: "Yes",
+      inactive: "No",
+      initial: "Yes"
+    },
+    {
+      name: "useNuxtV4Compat",
+      type: (_, { usePreset }) => {
+        const p = context.usePreset ?? usePreset;
+        return p.startsWith("nuxt-") ? "toggle" : null;
+      },
+      message: "Use Nuxt v4 compatibility?",
+      active: "Yes",
+      inactive: "No",
+      initial: "Yes"
+    },
+    {
+      name: "useNuxtModule",
+      type: (_, { usePreset }) => {
+        const p = context.usePreset ?? usePreset;
+        return p.startsWith("nuxt-") ? "toggle" : null;
+      },
+      message: "Use vuetify-nuxt-module?",
+      active: "Yes",
+      inactive: "No",
+      initial: "Yes"
+    },
+    {
+      name: "useNuxtSSR",
+      type: (_, { usePreset }) => {
+        const p = context.usePreset ?? usePreset;
+        return p.startsWith("nuxt-") ? "toggle" : null;
+      },
+      message: "Enable Nuxt SSR?",
+      active: "Yes",
+      inactive: "No",
+      initial: "Yes"
+    },
+    {
+      name: "useNuxtSSRClientHints",
+      type: (useNuxtSSR, { usePreset, useNuxtModule }) => {
+        const p = context.usePreset ?? usePreset;
+        if (!p.startsWith("nuxt-")) {
+          return null;
+        }
+        return useNuxtModule && useNuxtSSR ? "toggle" : null;
+      },
+      message: "Enable Nuxt SSR Http Client Hints?",
+      active: "Yes",
+      inactive: "No",
+      initial: "Yes"
+    }
+  ], promptOptions);
   return {
     ...context,
     ...answers
@@ -166,7 +228,7 @@ function mergePkg(source, destination) {
 }
 function renderDirectory(source, destination) {
   mkdirSync(destination, { recursive: true });
-  readdirSync2(source).forEach((path) => renderTemplate(resolve2(source, path), resolve2(destination, path)));
+  readdirSync2(source).forEach((path4) => renderTemplate(resolve2(source, path4), resolve2(destination, path4)));
 }
 function renderFile(source, destination) {
   const filename = basename(source);
@@ -185,6 +247,548 @@ function renderTemplate(source, destination) {
   }
 }
 
+// src/utils/nuxt/renderNuxtTemplate.ts
+import fs3 from "fs";
+import path3 from "path";
+import { spawnSync as spawnSync3 } from "child_process";
+
+// src/utils/nuxt/utils.ts
+import process2 from "process";
+import path from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+import fs from "fs";
+
+// node_modules/.pnpm/package-manager-detector@0.2.2/node_modules/package-manager-detector/dist/commands.mjs
+function npmRun(agent) {
+  return (args) => {
+    if (args.length > 1) {
+      return [agent, "run", args[0], "--", ...args.slice(1)];
+    } else {
+      return [agent, "run", args[0]];
+    }
+  };
+}
+var yarn = {
+  "agent": ["yarn", 0],
+  "run": ["yarn", "run", 0],
+  "install": ["yarn", "install", 0],
+  "frozen": ["yarn", "install", "--frozen-lockfile"],
+  "global": ["yarn", "global", "add", 0],
+  "add": ["yarn", "add", 0],
+  "upgrade": ["yarn", "upgrade", 0],
+  "upgrade-interactive": ["yarn", "upgrade-interactive", 0],
+  "execute": ["npx", 0],
+  "execute-local": ["yarn", "exec", 0],
+  "uninstall": ["yarn", "remove", 0],
+  "global_uninstall": ["yarn", "global", "remove", 0]
+};
+var pnpm = {
+  "agent": ["pnpm", 0],
+  "run": ["pnpm", "run", 0],
+  "install": ["pnpm", "i", 0],
+  "frozen": ["pnpm", "i", "--frozen-lockfile"],
+  "global": ["pnpm", "add", "-g", 0],
+  "add": ["pnpm", "add", 0],
+  "upgrade": ["pnpm", "update", 0],
+  "upgrade-interactive": ["pnpm", "update", "-i", 0],
+  "execute": ["pnpm", "dlx", 0],
+  "execute-local": ["pnpm", "exec", 0],
+  "uninstall": ["pnpm", "remove", 0],
+  "global_uninstall": ["pnpm", "remove", "--global", 0]
+};
+var bun = {
+  "agent": ["bun", 0],
+  "run": ["bun", "run", 0],
+  "install": ["bun", "install", 0],
+  "frozen": ["bun", "install", "--frozen-lockfile"],
+  "global": ["bun", "add", "-g", 0],
+  "add": ["bun", "add", 0],
+  "upgrade": ["bun", "update", 0],
+  "upgrade-interactive": ["bun", "update", 0],
+  "execute": ["bun", "x", 0],
+  "execute-local": ["bun", "x", 0],
+  "uninstall": ["bun", "remove", 0],
+  "global_uninstall": ["bun", "remove", "-g", 0]
+};
+var COMMANDS = {
+  "npm": {
+    "agent": ["npm", 0],
+    "run": npmRun("npm"),
+    "install": ["npm", "i", 0],
+    "frozen": ["npm", "ci"],
+    "global": ["npm", "i", "-g", 0],
+    "add": ["npm", "i", 0],
+    "upgrade": ["npm", "update", 0],
+    "upgrade-interactive": null,
+    "execute": ["npx", 0],
+    "execute-local": ["npx", 0],
+    "uninstall": ["npm", "uninstall", 0],
+    "global_uninstall": ["npm", "uninstall", "-g", 0]
+  },
+  "yarn": yarn,
+  "yarn@berry": {
+    ...yarn,
+    "frozen": ["yarn", "install", "--immutable"],
+    "upgrade": ["yarn", "up", 0],
+    "upgrade-interactive": ["yarn", "up", "-i", 0],
+    "execute": ["yarn", "dlx", 0],
+    "execute-local": ["yarn", "exec", 0],
+    "global": ["npm", "i", "-g", 0],
+    "global_uninstall": ["npm", "uninstall", "-g", 0]
+  },
+  "pnpm": pnpm,
+  "pnpm@6": {
+    ...pnpm,
+    run: npmRun("pnpm")
+  },
+  "bun": bun
+};
+function resolveCommand(agent, command, args) {
+  const value = COMMANDS[agent][command];
+  return constructCommand(value, args);
+}
+function constructCommand(value, args) {
+  if (value == null)
+    return null;
+  const list = typeof value === "function" ? value(args) : value.flatMap((v) => {
+    if (typeof v === "number")
+      return args;
+    return [v];
+  });
+  return {
+    command: list[0],
+    args: list.slice(1)
+  };
+}
+
+// src/utils/nuxt/utils.ts
+function detectPkgInfo() {
+  const userAgent = process2.env.npm_config_user_agent;
+  if (!userAgent)
+    return void 0;
+  const pkgSpec = userAgent.split(" ")[0];
+  const pkgSpecArr = pkgSpec.split("/");
+  return {
+    name: pkgSpecArr[0],
+    version: pkgSpecArr[1]
+  };
+}
+function addPackageObject(key, entry, pkg, sort = true) {
+  pkg[key] ??= {};
+  if (!sort) {
+    for (const [name, value] of entry)
+      pkg[key][name] = value;
+    return;
+  }
+  const entries = Object.entries(pkg[key]);
+  pkg[key] = {};
+  entry.forEach(([name, value]) => {
+    entries.push([name, value]);
+  });
+  entries.sort(([a], [b]) => a.localeCompare(b)).forEach(([k, v]) => {
+    pkg[key][k] = v;
+  });
+}
+function runCommand(pmDetection, command, args, cwd) {
+  let runCommand2 = "npm";
+  let runArgs = [command];
+  if (pmDetection) {
+    const prepare = resolveCommand(pmDetection.name, command, args);
+    runCommand2 = prepare.command;
+    runArgs = prepare.args;
+  }
+  const run2 = spawnSync2(
+    runCommand2,
+    runArgs.filter(Boolean),
+    {
+      cwd,
+      stdio: ["inherit", "inherit", "pipe"],
+      shell: true
+    }
+  );
+  if (run2.error) {
+    throw run2.error;
+  }
+}
+function editFile(file, callback, destination) {
+  const content = fs.readFileSync(file, "utf-8");
+  fs.writeFileSync(destination ?? file, callback(content), "utf-8");
+}
+function getPaths(rootPath, templateDir, v4) {
+  return v4 ? [path.join(rootPath, "app"), templateDir] : [rootPath, templateDir];
+}
+
+// src/utils/nuxt/versions.ts
+var versions = {
+  "vuetify": "^3.7.3",
+  "typescript": "^5.6.3",
+  "vue-tsc": "^2.1.6",
+  "sass-embedded": "^1.80.3",
+  "@vuetify/loader-shared": "^2.0.3",
+  "vite-plugin-vuetify": "^2.0.4",
+  "vuetify-nuxt-module": "^0.18.3",
+  "upath": "^2.0.1",
+  "@mdi/font": "^7.4.47",
+  "@nuxt/fonts": "^0.10.0"
+};
+
+// node_modules/.pnpm/package-manager-detector@0.2.2/node_modules/package-manager-detector/dist/constants.mjs
+var AGENTS = [
+  "npm",
+  "yarn",
+  "yarn@berry",
+  "pnpm",
+  "pnpm@6",
+  "bun"
+];
+var LOCKS = {
+  "bun.lockb": "bun",
+  "pnpm-lock.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm",
+  "npm-shrinkwrap.json": "npm"
+};
+
+// node_modules/.pnpm/package-manager-detector@0.2.2/node_modules/package-manager-detector/dist/detect.mjs
+import fs2 from "node:fs";
+import fsPromises from "node:fs/promises";
+import path2 from "node:path";
+import process3 from "node:process";
+async function detect(options = {}) {
+  const { cwd, onUnknown } = options;
+  for (const directory of lookup(cwd)) {
+    for (const lock of Object.keys(LOCKS)) {
+      if (await fileExists(path2.join(directory, lock))) {
+        const name = LOCKS[lock];
+        const result2 = await parsePackageJson(path2.join(directory, "package.json"), onUnknown);
+        if (result2)
+          return result2;
+        else
+          return { name, agent: name };
+      }
+    }
+    const result = await parsePackageJson(path2.join(directory, "package.json"), onUnknown);
+    if (result)
+      return result;
+  }
+  return null;
+}
+function* lookup(cwd = process3.cwd()) {
+  let directory = path2.resolve(cwd);
+  const { root } = path2.parse(directory);
+  while (directory && directory !== root) {
+    yield directory;
+    directory = path2.dirname(directory);
+  }
+}
+async function parsePackageJson(filepath, onUnknown) {
+  return !filepath || !await fileExists(filepath) ? null : handlePackageManager(filepath, onUnknown);
+}
+function handlePackageManager(filepath, onUnknown) {
+  try {
+    const pkg = JSON.parse(fs2.readFileSync(filepath, "utf8"));
+    let agent;
+    if (typeof pkg.packageManager === "string") {
+      const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
+      let version = ver;
+      if (name === "yarn" && Number.parseInt(ver) > 1) {
+        agent = "yarn@berry";
+        version = "berry";
+        return { name, agent, version };
+      } else if (name === "pnpm" && Number.parseInt(ver) < 7) {
+        agent = "pnpm@6";
+        return { name, agent, version };
+      } else if (AGENTS.includes(name)) {
+        agent = name;
+        return { name, agent, version };
+      } else {
+        return onUnknown?.(pkg.packageManager) ?? null;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function fileExists(filePath) {
+  try {
+    const stats = await fsPromises.stat(filePath);
+    if (stats.isFile()) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+
+// src/utils/nuxt/renderNuxtTemplate.ts
+import { generateCode, parseModule } from "magicast";
+import { addNuxtModule, getDefaultExportOptions } from "magicast/helpers";
+async function renderNuxtTemplate(ctx) {
+  const {
+    cwd,
+    projectName,
+    projectRoot,
+    useNuxtV4Compat,
+    nuxtPreset
+  } = ctx;
+  const pkgInfo = detectPkgInfo();
+  const pkgManager = pkgInfo ? pkgInfo.name : "npm";
+  const isYarn1 = pkgManager === "yarn" && pkgInfo?.version.startsWith("1.");
+  const customCommand = useNuxtV4Compat ? `npx nuxi@latest init -t v4-compat ${projectName}` : `npm exec nuxi init ${projectName}`;
+  const fullCustomCommand = customCommand.replace("@latest", () => isYarn1 ? "" : "@latest").replace(/^npm exec/, () => {
+    if (pkgManager === "pnpm")
+      return "pnpm dlx";
+    if (pkgManager === "yarn" && !isYarn1)
+      return "yarn dlx";
+    if (pkgManager === "bun")
+      return "bun x";
+    return "npm exec";
+  });
+  let [command, ...args] = fullCustomCommand.split(" ");
+  const nuxiCli = spawnSync3(command, args, {
+    cwd,
+    stdio: ["inherit", "inherit", "pipe"],
+    shell: true
+  });
+  if (nuxiCli.error) {
+    throw nuxiCli.error;
+  }
+  configurePackageJson(ctx);
+  const pmDetection = await detect({ cwd: projectRoot });
+  runCommand(pmDetection, "install", [], projectRoot);
+  prepareProject(ctx);
+  if (nuxtPreset !== "nuxt-default") {
+    runCommand(pmDetection, "execute", ["nuxi", "module", "add", "eslint"], projectRoot);
+  }
+}
+function configurePackageJson({
+  projectName,
+  projectRoot,
+  useNuxtModule,
+  nuxtPreset
+}) {
+  const packageJson = path3.join(projectRoot, "package.json");
+  const pkg = JSON.parse(fs3.readFileSync(path3.join(projectRoot, "package.json"), "utf-8"));
+  pkg.name = projectName;
+  const scripts = [
+    ["prepare", "nuxt prepare"],
+    ["typecheck", "nuxt typecheck"]
+  ];
+  if (nuxtPreset !== "nuxt-default") {
+    scripts.push(["lint", "eslint ."]);
+    scripts.push(["lint:fix", "eslint . --fix"]);
+  }
+  const dependencies = [
+    ["vuetify", versions.vuetify]
+  ];
+  if (dependencies.length) {
+    addPackageObject("dependencies", dependencies, pkg);
+  }
+  const devDependencies = [
+    ["@mdi/font", versions["@mdi/font"]],
+    ["@nuxt/fonts", versions["@nuxt/fonts"]],
+    ["sass-embedded", versions["sass-embedded"]],
+    ["typescript", versions.typescript],
+    ["vue-tsc", versions["vue-tsc"]]
+  ];
+  if (useNuxtModule) {
+    devDependencies.push(["vuetify-nuxt-module", versions["vuetify-nuxt-module"]]);
+  } else {
+    devDependencies.push(["upath", versions["upath"]]);
+    devDependencies.push(["@vuetify/loader-shared", versions["@vuetify/loader-shared"]]);
+    devDependencies.push(["vite-plugin-vuetify", versions["vite-plugin-vuetify"]]);
+  }
+  if (devDependencies.length) {
+    addPackageObject("devDependencies", devDependencies, pkg);
+  }
+  addPackageObject("scripts", scripts, pkg, false);
+  fs3.writeFileSync(packageJson, JSON.stringify(pkg, null, 2), "utf-8");
+}
+function configureVuetify(ctx, nuxtConfig) {
+  const config = getDefaultExportOptions(nuxtConfig);
+  config.ssr = ctx.useNuxtSSR;
+  config.features = {
+    inlineStyles: !ctx.useNuxtModule,
+    devLogs: !ctx.useNuxtModule
+  };
+  config.build = { transpile: ["vuetify"] };
+  config.vite = {
+    ssr: {
+      noExternal: ["vuetify"]
+    }
+  };
+  config.css = [];
+  if (!ctx.useNuxtModule) {
+    config.css.push("@mdi/font/css/materialdesignicons.css");
+    config.css.push("vuetify/styles");
+  }
+  addNuxtModule(nuxtConfig, "@nuxt/fonts");
+  return config;
+}
+function copyResources(ctx, rootPath, templateDir) {
+  const {
+    useNuxtSSR,
+    useNuxtV4Compat,
+    nuxtPreset,
+    useNuxtModule,
+    templateRoot
+  } = ctx;
+  const assetsDir = path3.join(rootPath, "assets");
+  let templateAssetsDir = path3.join(templateRoot, "default/src/assets");
+  fs3.mkdirSync(assetsDir);
+  fs3.copyFileSync(
+    path3.join(templateAssetsDir, "logo.png"),
+    path3.join(assetsDir, "logo.png")
+  );
+  fs3.copyFileSync(
+    path3.join(templateAssetsDir, "logo.svg"),
+    path3.join(assetsDir, "logo.svg")
+  );
+  if (nuxtPreset !== "nuxt-default") {
+    templateAssetsDir = path3.join(templateRoot, "base/src/styles");
+    fs3.copyFileSync(
+      path3.join(templateAssetsDir, "settings.scss"),
+      path3.join(assetsDir, "settings.scss")
+    );
+  }
+  const pluginsDir = path3.join(rootPath, "plugins");
+  const templatePluginsDir = path3.join(templateDir, "plugins");
+  fs3.mkdirSync(pluginsDir);
+  if (useNuxtModule) {
+    fs3.copyFileSync(
+      path3.join(templateDir, "vuetify.config.ts"),
+      path3.join(rootPath, useNuxtV4Compat ? "../vuetify.config.ts" : "vuetify.config.ts")
+    );
+    fs3.copyFileSync(
+      path3.join(templatePluginsDir, "vuetify-nuxt.ts"),
+      path3.join(pluginsDir, "vuetify.ts")
+    );
+  } else {
+    const modulesDir = path3.join(rootPath, useNuxtV4Compat ? "../modules" : "modules");
+    const templateModulesDir = path3.join(templateDir, "modules");
+    fs3.mkdirSync(modulesDir);
+    fs3.copyFileSync(
+      path3.resolve(templateModulesDir, "vuetify.ts"),
+      path3.resolve(modulesDir, "vuetify.ts")
+    );
+    editFile(
+      path3.join(templatePluginsDir, "vuetify.ts"),
+      (content) => {
+        return useNuxtSSR ? content : content.replace("ssr: true,", "ssr: false,");
+      },
+      path3.resolve(pluginsDir, "vuetify.ts")
+    );
+  }
+  fs3.copyFileSync(
+    path3.resolve(templateDir, nuxtPreset === "nuxt-essentials" ? "app-layout.vue" : "app.vue"),
+    path3.resolve(rootPath, "app.vue")
+  );
+  if (nuxtPreset === "nuxt-essentials") {
+    const layoutsDir = path3.join(rootPath, "layouts");
+    const templateLayoutsDir = path3.join(templateDir, "layouts");
+    fs3.mkdirSync(layoutsDir);
+    fs3.copyFileSync(
+      path3.resolve(templateLayoutsDir, "default.vue"),
+      path3.resolve(layoutsDir, "default.vue")
+    );
+  }
+  const componentsDir = path3.join(rootPath, "components");
+  const templateComponentsDir = path3.join(templateDir, "components");
+  fs3.mkdirSync(componentsDir);
+  fs3.copyFileSync(
+    path3.resolve(templateComponentsDir, "AppFooter.vue"),
+    path3.resolve(componentsDir, "AppFooter.vue")
+  );
+  fs3.copyFileSync(
+    path3.resolve(templateComponentsDir, "HelloWorld.vue"),
+    path3.resolve(componentsDir, "HelloWorld.vue")
+  );
+  const pagesDir = path3.join(rootPath, "pages");
+  const templatePagesDir = path3.join(templateDir, "pages");
+  fs3.mkdirSync(pagesDir);
+  fs3.copyFileSync(
+    path3.resolve(templatePagesDir, "index.vue"),
+    path3.resolve(pagesDir, "index.vue")
+  );
+}
+function prepareNuxtModule(ctx, nuxtConfig) {
+  const moduleOptions = {
+    ssrClientHints: {
+      reloadOnFirstRequest: false,
+      viewportSize: ctx.useNuxtSSR && ctx.useNuxtSSRClientHints,
+      prefersColorScheme: false,
+      prefersColorSchemeOptions: {
+        useBrowserThemeOnly: false
+      }
+    },
+    styles: ctx.nuxtPreset === "nuxt-default" ? true : {
+      configFile: "assets/settings.scss"
+    }
+  };
+  configureVuetify(ctx, nuxtConfig);
+  addNuxtModule(
+    nuxtConfig,
+    "vuetify-nuxt-module",
+    "vuetify",
+    { moduleOptions }
+  );
+}
+function prepareVuetifyModule(ctx, nuxtConfig) {
+  const config = configureVuetify(ctx, nuxtConfig);
+  const styles = ctx.nuxtPreset !== "nuxt-essentials" ? true : {
+    configFile: "assets/settings.scss"
+  };
+  config.vuetify = { autoImport: true, styles };
+}
+function prepareProject(ctx) {
+  const {
+    projectRoot,
+    templatePath,
+    useNuxtV4Compat,
+    useNuxtModule
+  } = ctx;
+  const [rootPath, templateDir] = getPaths(projectRoot, templatePath, useNuxtV4Compat);
+  const nuxtConfigFile = path3.join(rootPath, useNuxtV4Compat ? "../nuxt.config.ts" : "nuxt.config.ts");
+  const nuxtConfig = parseModule(fs3.readFileSync(nuxtConfigFile, "utf-8"));
+  if (useNuxtModule) {
+    prepareNuxtModule(ctx, nuxtConfig);
+  } else {
+    prepareVuetifyModule(ctx, nuxtConfig);
+  }
+  let code = generateCode(nuxtConfig, {
+    trailingComma: true,
+    quote: "single",
+    arrayBracketSpacing: false,
+    objectCurlySpacing: true,
+    lineTerminator: "\n",
+    format: {
+      trailingComma: true,
+      quote: "single",
+      arrayBracketSpacing: false,
+      objectCurlySpacing: true,
+      useSemi: false
+    }
+  }).code;
+  if (useNuxtModule) {
+    code = code.replace("ssrClientHints:", `// check https://nuxt.vuetifyjs.com/guide/server-side-rendering.html
+      ssrClientHints:`);
+    code = code.replace("styles:", `// /* If customizing sass global variables ($utilities, $reset, $color-pack, $body-font-family, etc) */
+      // disableVuetifyStyles: true,
+      styles:`);
+  } else {
+    code = code.replace("ssr:", `// when enabling/disabling ssr option, remember to update ssr option in plugins/vuetify.ts
+  ssr:`);
+  }
+  code = code.replace("features:", `// when enabling ssr option you need to disable inlineStyles and maybe devLogs
+  features:`);
+  fs3.writeFileSync(
+    nuxtConfigFile,
+    code,
+    "utf-8"
+  );
+  copyResources(ctx, rootPath, templateDir);
+}
+
 // src/index.ts
 var validPresets = ["base", "custom", "default", "essentials"];
 async function run() {
@@ -217,28 +821,52 @@ ${banner}
     useTypeScript,
     usePackageManager,
     installDependencies: installDeps,
-    usePreset
+    usePreset,
+    useStore,
+    useEslint,
+    useNuxtV4Compat,
+    useNuxtModule,
+    useNuxtSSR,
+    useNuxtSSRClientHints
   } = await initPrompts(context);
   const projectRoot = join2(cwd, projectName);
   if (canOverwrite) {
     rmSync(projectRoot, { recursive: true });
   }
-  mkdirSync2(projectRoot);
-  writeFileSync2(resolve3(projectRoot, "package.json"), JSON.stringify({ name: projectName }, null, 2));
-  const jsOrTs = useTypeScript ? "typescript" : "javascript";
-  let templatePath = resolve3(dirname2(fileURLToPath(import.meta.url)), "../template", jsOrTs);
-  console.log("\n\u25CC Generating scaffold...");
-  renderTemplate(resolve3(templatePath, "default"), projectRoot);
-  if (["base", "essentials"].includes(usePreset)) {
-    renderTemplate(resolve3(templatePath, "base"), projectRoot);
-  }
-  if (["essentials", "recommended"].includes(usePreset)) {
-    renderTemplate(resolve3(templatePath, "essentials"), projectRoot);
-  }
-  if (usePackageManager && installDeps) {
-    console.log(`\u25CC Installing dependencies with ${usePackageManager}...
+  const preset = context.usePreset ?? usePreset;
+  if (preset.startsWith("nuxt-")) {
+    const templateRoot = resolve3(dirname2(fileURLToPath(import.meta.url)), "../template/typescript");
+    const templatePath = resolve3(dirname2(fileURLToPath(import.meta.url)), "../template/typescript/nuxt");
+    await renderNuxtTemplate({
+      cwd,
+      projectName,
+      projectRoot,
+      templateRoot,
+      templatePath,
+      nuxtPreset: preset,
+      useNuxtV4Compat,
+      useNuxtModule,
+      useNuxtSSR,
+      useNuxtSSRClientHints
+    });
+  } else {
+    mkdirSync2(projectRoot);
+    writeFileSync2(resolve3(projectRoot, "package.json"), JSON.stringify({ name: projectName }, null, 2));
+    console.log("\n\u25CC Generating scaffold...");
+    const jsOrTs = useTypeScript ? "typescript" : "javascript";
+    let templatePath = resolve3(dirname2(fileURLToPath(import.meta.url)), "../template", jsOrTs);
+    renderTemplate(resolve3(templatePath, "default"), projectRoot);
+    if (["base", "essentials"].includes(usePreset)) {
+      renderTemplate(resolve3(templatePath, "base"), projectRoot);
+    }
+    if (["essentials", "recommended"].includes(usePreset)) {
+      renderTemplate(resolve3(templatePath, "essentials"), projectRoot);
+    }
+    if (usePackageManager && installDeps) {
+      console.log(`\u25CC Installing dependencies with ${usePackageManager}...
 `);
-    installDependencies(projectRoot, usePackageManager);
+      installDependencies(projectRoot, usePackageManager);
+    }
   }
   console.log(`
 ${projectName} has been generated at ${projectRoot}
@@ -248,6 +876,7 @@ run().then(() => {
   console.log("Discord community: https://community.vuetifyjs.com");
   console.log("Github: https://github.com/vuetifyjs/vuetify");
   console.log("Support Vuetify: https://github.com/sponsors/johnleider");
+  process.exit(0);
 }).catch((err) => {
   console.error(`
 ${red2("\u2716")} ${err}