@nuxt/cli-nightly 3.29.4-20251009-171833-0915ec9 → 3.29.4-20251021-190716-bbf70fc

package/dist/chunks/preview.mjs

@@ -1,131 +0,0 @@
-import { existsSync, promises } from 'node:fs';
-import { dirname, relative } from 'node:path';
-import process from 'node:process';
-import { setupDotenv } from 'c12';
-import { defineCommand } from 'citty';
-import { box, colors } from 'consola/utils';
-import { getArgs } from 'listhen/cli';
-import { resolve } from 'pathe';
-import { x } from 'tinyexec';
-import { l as loadKit } from '../shared/cli-nightly.qKvs7FJ2.mjs';
-import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
-import { d as dotEnvArgs, l as legacyRootDirArgs, e as extendsArgs, b as envNameArgs, a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.BRlCc6aT.mjs';
-import 'node:url';
-import 'exsolve';
-import 'consola';
-import 'std-env';
-
-const command = defineCommand({
-  meta: {
-    name: "preview",
-    description: "Launches Nitro server for local testing after `nuxi build`."
-  },
-  args: {
-    ...cwdArgs,
-    ...logLevelArgs,
-    ...envNameArgs,
-    ...extendsArgs,
-    ...legacyRootDirArgs,
-    port: { ...getArgs().port, alias: ["p"] },
-    ...dotEnvArgs
-  },
-  async run(ctx) {
-    process.env.NODE_ENV = process.env.NODE_ENV || "production";
-    const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
-    const { loadNuxt } = await loadKit(cwd);
-    const resolvedOutputDir = await new Promise((res) => {
-      loadNuxt({
-        cwd,
-        envName: ctx.args.envName,
-        // c12 will fall back to NODE_ENV
-        ready: true,
-        overrides: {
-          ...ctx.args.extends && { extends: ctx.args.extends },
-          modules: [
-            function(_, nuxt) {
-              nuxt.hook("nitro:init", (nitro) => {
-                res(resolve(nuxt.options.srcDir || cwd, nitro.options.output.dir || ".output", "nitro.json"));
-              });
-            }
-          ]
-        }
-      }).then((nuxt) => nuxt.close()).catch(() => "");
-    });
-    const defaultOutput = resolve(cwd, ".output", "nitro.json");
-    const nitroJSONPaths = [resolvedOutputDir, defaultOutput].filter(Boolean);
-    const nitroJSONPath = nitroJSONPaths.find((p) => existsSync(p));
-    if (!nitroJSONPath) {
-      logger.error(
-        "Cannot find `nitro.json`. Did you run `nuxi build` first? Search path:\n",
-        nitroJSONPaths
-      );
-      process.exit(1);
-    }
-    const outputPath = dirname(nitroJSONPath);
-    const nitroJSON = JSON.parse(await promises.readFile(nitroJSONPath, "utf-8"));
-    if (!nitroJSON.commands.preview) {
-      logger.error("Preview is not supported for this build.");
-      process.exit(1);
-    }
-    const info = [
-      ["Node.js:", `v${process.versions.node}`],
-      ["Nitro Preset:", nitroJSON.preset],
-      ["Working directory:", relative(process.cwd(), outputPath)]
-    ];
-    const _infoKeyLen = Math.max(...info.map(([label]) => label.length));
-    logger.log(
-      box(
-        [
-          "You are running Nuxt production build in preview mode.",
-          `For production deployments, please directly use ${colors.cyan(
-            nitroJSON.commands.preview
-          )} command.`,
-          "",
-          ...info.map(
-            ([label, value]) => `${label.padEnd(_infoKeyLen, " ")} ${colors.cyan(value)}`
-          )
-        ].join("\n"),
-        {
-          title: colors.yellow("Preview Mode"),
-          style: {
-            borderColor: "yellow"
-          }
-        }
-      )
-    );
-    const envFileName = ctx.args.dotenv || ".env";
-    const envExists = existsSync(resolve(cwd, envFileName));
-    if (envExists) {
-      logger.info(
-        `Loading \`${envFileName}\`. This will not be loaded when running the server in production.`
-      );
-      await setupDotenv({ cwd, fileName: envFileName });
-    } else if (ctx.args.dotenv) {
-      logger.error(`Cannot find \`${envFileName}\`.`);
-    }
-    const { port } = _resolveListenOptions(ctx.args);
-    logger.info(`Starting preview command: \`${nitroJSON.commands.preview}\``);
-    const [command2, ...commandArgs] = nitroJSON.commands.preview.split(" ");
-    logger.log("");
-    await x(command2, commandArgs, {
-      throwOnError: true,
-      nodeOptions: {
-        stdio: "inherit",
-        cwd: outputPath,
-        env: {
-          ...process.env,
-          NUXT_PORT: port,
-          NITRO_PORT: port
-        }
-      }
-    });
-  }
-});
-function _resolveListenOptions(args) {
-  const _port = args.port ?? process.env.NUXT_PORT ?? process.env.NITRO_PORT ?? process.env.PORT;
-  return {
-    port: _port
-  };
-}
-
-export { command as default };

package/dist/chunks/search.mjs

@@ -1,114 +0,0 @@
-import { defineCommand } from 'citty';
-import { colors } from 'consola/utils';
-import Fuse from 'fuse.js';
-import { upperFirst, kebabCase } from 'scule';
-import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
-import { g as getNuxtVersion } from '../shared/cli-nightly.DHenkA1C.mjs';
-import { c as cwdArgs } from '../shared/cli-nightly.BRlCc6aT.mjs';
-import { f as fetchModules, c as checkNuxtCompatibility } from '../shared/cli-nightly.Cr-OCgdO.mjs';
-import 'consola';
-import 'pkg-types';
-import 'semver';
-import 'node:path';
-import 'node:process';
-import 'std-env';
-import 'node:url';
-import 'confbox';
-import 'ofetch';
-
-const { format: formatNumber } = Intl.NumberFormat("en-GB", {
-  notation: "compact",
-  maximumFractionDigits: 1
-});
-const search = defineCommand({
-  meta: {
-    name: "search",
-    description: "Search in Nuxt modules"
-  },
-  args: {
-    ...cwdArgs,
-    query: {
-      type: "positional",
-      description: "keywords to search for",
-      required: true
-    },
-    nuxtVersion: {
-      type: "string",
-      description: "Filter by Nuxt version and list compatible modules only (auto detected by default)",
-      required: false,
-      valueHint: "2|3"
-    }
-  },
-  async setup(ctx) {
-    const nuxtVersion = await getNuxtVersion(ctx.args.cwd);
-    return findModuleByKeywords(ctx.args._.join(" "), nuxtVersion);
-  }
-});
-async function findModuleByKeywords(query, nuxtVersion) {
-  const allModules = await fetchModules();
-  const compatibleModules = allModules.filter(
-    (m) => checkNuxtCompatibility(m, nuxtVersion)
-  );
-  const fuse = new Fuse(compatibleModules, {
-    threshold: 0.1,
-    keys: [
-      { name: "name", weight: 1 },
-      { name: "npm", weight: 1 },
-      { name: "repo", weight: 1 },
-      { name: "tags", weight: 1 },
-      { name: "category", weight: 1 },
-      { name: "description", weight: 0.5 },
-      { name: "maintainers.name", weight: 0.5 },
-      { name: "maintainers.github", weight: 0.5 }
-    ]
-  });
-  const { bold, green, magenta, cyan, gray, yellow } = colors;
-  const results = fuse.search(query).map((result) => {
-    const res = {
-      name: bold(result.item.name),
-      homepage: cyan(result.item.website),
-      compatibility: `nuxt: ${result.item.compatibility?.nuxt || "*"}`,
-      repository: gray(result.item.github),
-      description: gray(result.item.description),
-      package: gray(result.item.npm),
-      install: cyan(`npx nuxi module add ${result.item.name}`),
-      stars: yellow(formatNumber(result.item.stats.stars)),
-      monthlyDownloads: yellow(formatNumber(result.item.stats.downloads))
-    };
-    if (result.item.github === result.item.website) {
-      delete res.homepage;
-    }
-    if (result.item.name === result.item.npm) {
-      delete res.packageName;
-    }
-    return res;
-  });
-  if (!results.length) {
-    logger.info(
-      `No Nuxt modules found matching query ${magenta(query)} for Nuxt ${cyan(nuxtVersion)}`
-    );
-    return;
-  }
-  logger.success(
-    `Found ${results.length} Nuxt ${results.length > 1 ? "modules" : "module"} matching ${cyan(query)} ${nuxtVersion ? `for Nuxt ${cyan(nuxtVersion)}` : ""}:
-`
-  );
-  for (const foundModule of results) {
-    let maxLength = 0;
-    const entries = Object.entries(foundModule).map(([key, val]) => {
-      const label = upperFirst(kebabCase(key)).replace(/-/g, " ");
-      if (label.length > maxLength) {
-        maxLength = label.length;
-      }
-      return [label, val || "-"];
-    });
-    let infoStr = "";
-    for (const [label, value] of entries) {
-      infoStr += `${bold(label === "Install" ? "\u2192 " : "- ") + green(label.padEnd(maxLength + 2)) + value}
-`;
-    }
-    logger.log(infoStr);
-  }
-}
-
-export { search as default };

package/dist/chunks/test.mjs

@@ -1,62 +0,0 @@
-import process from 'node:process';
-import { defineCommand } from 'citty';
-import { resolve } from 'pathe';
-import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
-import { l as legacyRootDirArgs, a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.BRlCc6aT.mjs';
-import 'consola';
-import 'node:path';
-import 'std-env';
-import 'node:url';
-
-const test = defineCommand({
-  meta: {
-    name: "test",
-    description: "Run tests"
-  },
-  args: {
-    ...cwdArgs,
-    ...logLevelArgs,
-    ...legacyRootDirArgs,
-    dev: {
-      type: "boolean",
-      description: "Run in dev mode"
-    },
-    watch: {
-      type: "boolean",
-      description: "Watch mode"
-    }
-  },
-  async run(ctx) {
-    process.env.NODE_ENV = process.env.NODE_ENV || "test";
-    const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
-    const { runTests } = await importTestUtils();
-    await runTests({
-      rootDir: cwd,
-      dev: ctx.args.dev,
-      watch: ctx.args.watch,
-      ...{}
-    });
-  }
-});
-async function importTestUtils() {
-  let err;
-  for (const pkg of [
-    "@nuxt/test-utils-nightly",
-    "@nuxt/test-utils-edge",
-    "@nuxt/test-utils"
-  ]) {
-    try {
-      const exports = await import(pkg);
-      if (!exports.runTests) {
-        throw new Error("Invalid version of `@nuxt/test-utils` is installed!");
-      }
-      return exports;
-    } catch (_err) {
-      err = _err;
-    }
-  }
-  logger.error(err);
-  throw new Error("`@nuxt/test-utils` seems missing. Run `npm i -D @nuxt/test-utils` or `yarn add -D @nuxt/test-utils` to install.");
-}
-
-export { test as default };

package/dist/chunks/typecheck.mjs

@@ -1,85 +0,0 @@
-import process from 'node:process';
-import { defineCommand } from 'citty';
-import { resolveModulePath } from 'exsolve';
-import { resolve } from 'pathe';
-import { readTSConfig } from 'pkg-types';
-import { isBun } from 'std-env';
-import { x } from 'tinyexec';
-import { l as loadKit } from '../shared/cli-nightly.qKvs7FJ2.mjs';
-import { l as legacyRootDirArgs, e as extendsArgs, d as dotEnvArgs, a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.BRlCc6aT.mjs';
-import 'node:url';
-import 'node:path';
-import 'consola';
-import '../shared/cli-nightly.B9AmABr3.mjs';
-
-const typecheck = defineCommand({
-  meta: {
-    name: "typecheck",
-    description: "Runs `vue-tsc` to check types throughout your app."
-  },
-  args: {
-    ...cwdArgs,
-    ...logLevelArgs,
-    ...dotEnvArgs,
-    ...extendsArgs,
-    ...legacyRootDirArgs
-  },
-  async run(ctx) {
-    process.env.NODE_ENV = process.env.NODE_ENV || "production";
-    const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
-    const [supportsProjects, resolvedTypeScript, resolvedVueTsc] = await Promise.all([
-      readTSConfig(cwd).then((r) => !!r.references?.length),
-      // Prefer local install if possible
-      resolveModulePath("typescript", { try: true }),
-      resolveModulePath("vue-tsc/bin/vue-tsc.js", { try: true }),
-      writeTypes(cwd, ctx.args.dotenv, ctx.args.logLevel, {
-        ...ctx.data?.overrides,
-        ...ctx.args.extends && { extends: ctx.args.extends }
-      })
-    ]);
-    const typeCheckArgs = supportsProjects ? ["-b", "--noEmit"] : ["--noEmit"];
-    if (resolvedTypeScript && resolvedVueTsc) {
-      return await x(resolvedVueTsc, typeCheckArgs, {
-        throwOnError: true,
-        nodeOptions: {
-          stdio: "inherit",
-          cwd
-        }
-      });
-    }
-    if (isBun) {
-      await x("bun", ["install", "typescript", "vue-tsc", "--global", "--silent"], {
-        throwOnError: true,
-        nodeOptions: { stdio: "inherit", cwd }
-      });
-      return await x("bunx", ["vue-tsc", ...typeCheckArgs], {
-        throwOnError: true,
-        nodeOptions: {
-          stdio: "inherit",
-          cwd
-        }
-      });
-    }
-    await x("npx", ["-p", "vue-tsc", "-p", "typescript", "vue-tsc", ...typeCheckArgs], {
-      throwOnError: true,
-      nodeOptions: { stdio: "inherit", cwd }
-    });
-  }
-});
-async function writeTypes(cwd, dotenv, logLevel, overrides) {
-  const { loadNuxt, buildNuxt, writeTypes: writeTypes2 } = await loadKit(cwd);
-  const nuxt = await loadNuxt({
-    cwd,
-    dotenv: { cwd, fileName: dotenv },
-    overrides: {
-      _prepare: true,
-      logLevel,
-      ...overrides
-    }
-  });
-  await writeTypes2(nuxt);
-  await buildNuxt(nuxt);
-  await nuxt.close();
-}
-
-export { typecheck as default };

package/dist/chunks/upgrade.mjs

@@ -1,214 +0,0 @@
-import { existsSync } from 'node:fs';
-import process from 'node:process';
-import { defineCommand } from 'citty';
-import { colors } from 'consola/utils';
-import { detectPackageManager, addDependency, dedupeDependencies } from 'nypm';
-import { resolve } from 'pathe';
-import { readPackageJSON } from 'pkg-types';
-import { l as loadKit } from '../shared/cli-nightly.qKvs7FJ2.mjs';
-import { l as logger } from '../shared/cli-nightly.B9AmABr3.mjs';
-import { c as cleanupNuxtDirs, n as nuxtVersionToGitIdentifier } from '../shared/cli-nightly.Bu_9IHj2.mjs';
-import { g as getPackageManagerVersion } from '../shared/cli-nightly.BSm0_9Hr.mjs';
-import { g as getNuxtVersion } from '../shared/cli-nightly.DHenkA1C.mjs';
-import { l as legacyRootDirArgs, a as logLevelArgs, c as cwdArgs } from '../shared/cli-nightly.BRlCc6aT.mjs';
-import 'node:url';
-import 'exsolve';
-import 'consola';
-import 'ohash';
-import '../shared/cli-nightly.DPmMxQ6h.mjs';
-import 'node:child_process';
-import 'semver';
-import 'node:path';
-import 'std-env';
-
-function checkNuxtDependencyType(pkg) {
-  if (pkg.dependencies?.nuxt) {
-    return "dependencies";
-  }
-  if (pkg.devDependencies?.nuxt) {
-    return "devDependencies";
-  }
-  return "dependencies";
-}
-const nuxtVersionTags = {
-  "3.x": "3x",
-  "4.x": "latest"
-};
-function getNightlyDependency(dep, nuxtVersion) {
-  return `${dep}@npm:${dep}-nightly@${nuxtVersionTags[nuxtVersion]}`;
-}
-async function getNightlyVersion(packageNames) {
-  const nuxtVersion = await logger.prompt(
-    "Which nightly Nuxt release channel do you want to install? (3.x or 4.x)",
-    {
-      type: "select",
-      options: ["3.x", "4.x"],
-      default: "4.x",
-      cancel: "reject"
-    }
-  ).catch(() => process.exit(1));
-  const npmPackages = packageNames.map((p) => getNightlyDependency(p, nuxtVersion));
-  return { npmPackages, nuxtVersion };
-}
-async function getRequiredNewVersion(packageNames, channel) {
-  switch (channel) {
-    case "nightly":
-      return getNightlyVersion(packageNames);
-    case "v3":
-      return { npmPackages: packageNames.map((p) => `${p}@3`), nuxtVersion: "3.x" };
-    case "v3-nightly":
-      return { npmPackages: packageNames.map((p) => getNightlyDependency(p, "3.x")), nuxtVersion: "3.x" };
-    case "v4":
-      return { npmPackages: packageNames.map((p) => `${p}@4`), nuxtVersion: "4.x" };
-    case "v4-nightly":
-      return { npmPackages: packageNames.map((p) => getNightlyDependency(p, "4.x")), nuxtVersion: "4.x" };
-    case "stable":
-    default:
-      return { npmPackages: packageNames.map((p) => `${p}@latest`), nuxtVersion: "4.x" };
-  }
-}
-const upgrade = defineCommand({
-  meta: {
-    name: "upgrade",
-    description: "Upgrade Nuxt"
-  },
-  args: {
-    ...cwdArgs,
-    ...logLevelArgs,
-    ...legacyRootDirArgs,
-    dedupe: {
-      type: "boolean",
-      description: "Dedupe dependencies after upgrading"
-    },
-    force: {
-      type: "boolean",
-      alias: "f",
-      description: "Force upgrade to recreate lockfile and node_modules"
-    },
-    channel: {
-      type: "string",
-      alias: "ch",
-      default: "stable",
-      description: "Specify a channel to install from (default: stable)",
-      valueHint: "stable|nightly|v3|v4|v4-nightly|v3-nightly"
-    }
-  },
-  async run(ctx) {
-    const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
-    const packageManager = await detectPackageManager(cwd);
-    if (!packageManager) {
-      logger.error(
-        `Unable to determine the package manager used by this project.
-
-No lock files found in \`${cwd}\`, and no \`packageManager\` field specified in \`package.json\`.
-
-Please either add the \`packageManager\` field to \`package.json\` or execute the installation command for your package manager. For example, you can use \`pnpm i\`, \`npm i\`, \`bun i\`, or \`yarn i\`, and then try again.`
-      );
-      process.exit(1);
-    }
-    const { name: packageManagerName, lockFile: lockFileCandidates } = packageManager;
-    const packageManagerVersion = getPackageManagerVersion(packageManagerName);
-    logger.info("Package manager:", packageManagerName, packageManagerVersion);
-    const currentVersion = await getNuxtVersion(cwd, false) || "[unknown]";
-    logger.info("Current Nuxt version:", currentVersion);
-    const pkg = await readPackageJSON(cwd).catch(() => null);
-    const nuxtDependencyType = pkg ? checkNuxtDependencyType(pkg) : "dependencies";
-    const corePackages = ["@nuxt/kit", "@nuxt/schema", "@nuxt/vite-builder", "@nuxt/webpack-builder", "@nuxt/rspack-builder"];
-    const packagesToUpdate = pkg ? corePackages.filter((p) => pkg.dependencies?.[p] || pkg.devDependencies?.[p]) : [];
-    const { npmPackages, nuxtVersion } = await getRequiredNewVersion(["nuxt", ...packagesToUpdate], ctx.args.channel);
-    const toRemove = ["node_modules"];
-    const lockFile = normaliseLockFile(cwd, lockFileCandidates);
-    if (lockFile) {
-      toRemove.push(lockFile);
-    }
-    const forceRemovals = toRemove.map((p) => colors.cyan(p)).join(" and ");
-    let method = ctx.args.force ? "force" : ctx.args.dedupe ? "dedupe" : void 0;
-    method ||= await logger.prompt(
-      `Would you like to dedupe your lockfile (recommended) or recreate ${forceRemovals}? This can fix problems with hoisted dependency versions and ensure you have the most up-to-date dependencies.`,
-      {
-        type: "select",
-        initial: "dedupe",
-        cancel: "reject",
-        options: [
-          {
-            label: "dedupe lockfile",
-            value: "dedupe",
-            hint: "recommended"
-          },
-          {
-            label: `recreate ${forceRemovals}`,
-            value: "force"
-          },
-          {
-            label: "skip",
-            value: "skip"
-          }
-        ]
-      }
-    ).catch(() => process.exit(1));
-    const versionType = ctx.args.channel === "nightly" ? "nightly" : `latest ${ctx.args.channel}`;
-    logger.info(`Installing ${versionType} Nuxt ${nuxtVersion} release...`);
-    await addDependency(npmPackages, {
-      cwd,
-      packageManager,
-      dev: nuxtDependencyType === "devDependencies"
-    });
-    if (method === "force") {
-      logger.info(
-        `Recreating ${forceRemovals}. If you encounter any issues, revert the changes and try with \`--no-force\``
-      );
-      await dedupeDependencies({ recreateLockfile: true });
-    }
-    if (method === "dedupe") {
-      logger.info("Try deduping dependencies...");
-      await dedupeDependencies();
-    }
-    let buildDir = ".nuxt";
-    try {
-      const { loadNuxtConfig } = await loadKit(cwd);
-      const nuxtOptions = await loadNuxtConfig({ cwd });
-      buildDir = nuxtOptions.buildDir;
-    } catch {
-    }
-    await cleanupNuxtDirs(cwd, buildDir);
-    const upgradedVersion = await getNuxtVersion(cwd, false) || "[unknown]";
-    logger.info("Upgraded Nuxt version:", upgradedVersion);
-    if (upgradedVersion === "[unknown]") {
-      return;
-    }
-    if (upgradedVersion === currentVersion) {
-      logger.success("You're using the latest version of Nuxt.");
-    } else {
-      logger.success(
-        "Successfully upgraded Nuxt from",
-        currentVersion,
-        "to",
-        upgradedVersion
-      );
-      if (currentVersion === "[unknown]") {
-        return;
-      }
-      const commitA = nuxtVersionToGitIdentifier(currentVersion);
-      const commitB = nuxtVersionToGitIdentifier(upgradedVersion);
-      if (commitA && commitB) {
-        logger.info(
-          "Changelog:",
-          `https://github.com/nuxt/nuxt/compare/${commitA}...${commitB}`
-        );
-      }
-    }
-  }
-});
-function normaliseLockFile(cwd, lockFiles) {
-  if (typeof lockFiles === "string") {
-    lockFiles = [lockFiles];
-  }
-  const lockFile = lockFiles?.find((file) => existsSync(resolve(cwd, file)));
-  if (lockFile === void 0) {
-    logger.error(`Unable to find any lock files in ${cwd}`);
-    return void 0;
-  }
-  return lockFile;
-}
-
-export { upgrade as default };

package/dist/dev/index.d.ts

@@ -1,94 +0,0 @@
-import * as net from 'net';
-import * as listhen from 'listhen';
-import { ListenURL, HTTPSOptions, Listener, ListenOptions } from 'listhen';
-import { NuxtConfig } from '@nuxt/schema';
-import { DotenvOptions } from 'c12';
-import { RequestListener, IncomingMessage, ServerResponse } from 'node:http';
-import { AddressInfo } from 'node:net';
-import EventEmitter from 'node:events';
-
-interface NuxtDevContext {
-    cwd: string;
-    public?: boolean;
-    hostname?: string;
-    publicURLs?: string[];
-    args: {
-        clear: boolean;
-        logLevel: string;
-        dotenv: string;
-        envName: string;
-        extends?: string;
-    };
-    proxy?: {
-        url?: string;
-        urls?: ListenURL[];
-        https?: boolean | HTTPSOptions;
-        addr?: AddressInfo;
-    };
-}
-interface NuxtDevServerOptions {
-    cwd: string;
-    logLevel?: 'silent' | 'info' | 'verbose';
-    dotenv: DotenvOptions;
-    envName?: string;
-    clear?: boolean;
-    defaults: NuxtConfig;
-    overrides: NuxtConfig;
-    loadingTemplate?: ({ loading }: {
-        loading: string;
-    }) => string;
-    devContext: Pick<NuxtDevContext, 'proxy'>;
-}
-interface DevServerEventMap {
-    'loading:error': [error: Error];
-    'loading': [loadingMessage: string];
-    'ready': [address: string];
-    'restart': [];
-}
-declare class NuxtDevServer extends EventEmitter<DevServerEventMap> {
-    private options;
-    private _handler?;
-    private _distWatcher?;
-    private _configWatcher?;
-    private _currentNuxt?;
-    private _loadingMessage?;
-    private _loadingError?;
-    private _fileChangeTracker;
-    private cwd;
-    loadDebounced: (reload?: boolean, reason?: string) => void;
-    handler: RequestListener;
-    listener: Pick<Listener, 'server' | 'getURLs' | 'https' | 'url' | 'close'> & {
-        _url?: string;
-        address: Omit<AddressInfo, 'family'> & {
-            socketPath: string;
-        } | AddressInfo;
-    };
-    constructor(options: NuxtDevServerOptions);
-    _renderError(req: IncomingMessage, res: ServerResponse): void;
-    _renderLoadingScreen(req: IncomingMessage, res: ServerResponse): Promise<void>;
-    init(): Promise<void>;
-    closeWatchers(): void;
-    load(reload?: boolean, reason?: string): Promise<void>;
-    close(): Promise<void>;
-    _load(reload?: boolean, reason?: string): Promise<void>;
-    _watchConfig(): void;
-}
-
-interface InitializeOptions {
-    data?: {
-        overrides?: NuxtConfig;
-    };
-}
-declare function initialize(devContext: NuxtDevContext, ctx?: InitializeOptions, _listenOptions?: true | Partial<ListenOptions>): Promise<{
-    listener: Pick<listhen.Listener, "https" | "server" | "url" | "getURLs" | "close"> & {
-        _url?: string;
-        address: (Omit<net.AddressInfo, "family"> & {
-            socketPath: string;
-        }) | net.AddressInfo;
-    };
-    close: () => Promise<void>;
-    onReady: (callback: (address: string) => void) => void;
-    onRestart: (callback: (devServer: NuxtDevServer) => void) => void;
-}>;
-
-export { initialize };