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

package/dist/chunks/analyze.mjs

@@ -0,0 +1,134 @@
+import { promises } from 'node:fs';
+import process from 'node:process';
+import { defineCommand } from 'citty';
+import { defu } from 'defu';
+import { createApp, eventHandler, toNodeListener, lazyEventHandler } from 'h3';
+import { listen } from 'listhen';
+import { resolve, join } from 'pathe';
+import { o as overrideEnv } from '../shared/cli-nightly.cDY7IcTr.mjs';
+import { c as clearDir } from '../shared/cli-nightly.7lipAIIb.mjs';
+import { l as loadKit } from '../shared/cli-nightly.DlcAx0De.mjs';
+import { c as cwdArgs, l as logLevelArgs, b as legacyRootDirArgs, d as dotEnvArgs, a as logger } from '../shared/cli-nightly.CnY_9Zvw.mjs';
+import 'jiti';
+import 'node:path';
+import 'std-env';
+import 'consola';
+import 'node:url';
+
+const analyze = defineCommand({
+  meta: {
+    name: "analyze",
+    description: "Build nuxt and analyze production bundle (experimental)"
+  },
+  args: {
+    ...cwdArgs,
+    ...logLevelArgs,
+    ...legacyRootDirArgs,
+    ...dotEnvArgs,
+    name: {
+      type: "string",
+      description: "Name of the analysis",
+      default: "default"
+    },
+    serve: {
+      type: "boolean",
+      description: "Serve the analysis results",
+      default: true
+    }
+  },
+  async run(ctx) {
+    overrideEnv("production");
+    const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
+    const name = ctx.args.name || "default";
+    const slug = name.trim().replace(/[^\w-]/g, "_");
+    const startTime = Date.now();
+    const { loadNuxt, buildNuxt } = await loadKit(cwd);
+    const nuxt = await loadNuxt({
+      cwd,
+      dotenv: {
+        cwd,
+        fileName: ctx.args.dotenv
+      },
+      overrides: defu(ctx.data?.overrides, {
+        build: {
+          analyze: {
+            enabled: true
+          }
+        },
+        vite: {
+          build: {
+            rollupOptions: {
+              output: {
+                chunkFileNames: "_nuxt/[name].js",
+                entryFileNames: "_nuxt/[name].js"
+              }
+            }
+          }
+        },
+        logLevel: ctx.args.logLevel
+      })
+    });
+    const analyzeDir = nuxt.options.analyzeDir;
+    const buildDir = nuxt.options.buildDir;
+    const outDir = nuxt.options.nitro.output?.dir || join(nuxt.options.rootDir, ".output");
+    nuxt.options.build.analyze = defu(nuxt.options.build.analyze, {
+      filename: join(analyzeDir, "client.html")
+    });
+    await clearDir(analyzeDir);
+    await buildNuxt(nuxt);
+    const endTime = Date.now();
+    const meta = {
+      name,
+      slug,
+      startTime,
+      endTime,
+      analyzeDir,
+      buildDir,
+      outDir
+    };
+    await nuxt.callHook("build:analyze:done", meta);
+    await promises.writeFile(
+      join(analyzeDir, "meta.json"),
+      JSON.stringify(meta, null, 2),
+      "utf-8"
+    );
+    logger.info(`Analyze results are available at: \`${analyzeDir}\``);
+    logger.warn("Do not deploy analyze results! Use `nuxi build` before deploying.");
+    if (ctx.args.serve !== false && !process.env.CI) {
+      const app = createApp();
+      const serveFile = (filePath) => lazyEventHandler(async () => {
+        const contents = await promises.readFile(filePath, "utf-8");
+        return eventHandler((event) => {
+          event.node.res.end(contents);
+        });
+      });
+      logger.info("Starting stats server...");
+      app.use("/client", serveFile(join(analyzeDir, "client.html")));
+      app.use("/nitro", serveFile(join(analyzeDir, "nitro.html")));
+      app.use(
+        eventHandler(
+          () => `<!DOCTYPE html>
+        <html lang="en">
+        <head>
+        <meta charset="utf-8">
+        <title>Nuxt Bundle Stats (experimental)</title>
+        </head>
+          <h1>Nuxt Bundle Stats (experimental)</h1>
+          <ul>
+            <li>
+              <a href="/nitro">Nitro server bundle stats</a>
+            </li>
+            <li>
+              <a href="/client">Client bundle stats</a>
+            </li>
+          </ul>
+        </html>
+      `
+        )
+      );
+      await listen(toNodeListener(app));
+    }
+  }
+});
+
+export { analyze as default };

package/dist/chunks/build.mjs

@@ -0,0 +1,90 @@
+import process from 'node:process';
+import { defineCommand } from 'citty';
+import { resolve, relative } from 'pathe';
+import { s as showVersions } from '../shared/cli-nightly.CGRrR0sp.mjs';
+import { o as overrideEnv } from '../shared/cli-nightly.cDY7IcTr.mjs';
+import { a as clearBuildDir } from '../shared/cli-nightly.7lipAIIb.mjs';
+import { l as loadKit } from '../shared/cli-nightly.DlcAx0De.mjs';
+import { c as cwdArgs, l as logLevelArgs, d as dotEnvArgs, e as envNameArgs, b as legacyRootDirArgs, a as logger } from '../shared/cli-nightly.CnY_9Zvw.mjs';
+import 'consola/utils';
+import 'pkg-types';
+import 'node:fs';
+import 'jiti';
+import 'node:path';
+import 'std-env';
+import 'consola';
+import 'node:url';
+
+const buildCommand = defineCommand({
+  meta: {
+    name: "build",
+    description: "Build Nuxt for production deployment"
+  },
+  args: {
+    ...cwdArgs,
+    ...logLevelArgs,
+    prerender: {
+      type: "boolean",
+      description: "Build Nuxt and prerender static routes"
+    },
+    preset: {
+      type: "string",
+      description: "Nitro server preset"
+    },
+    ...dotEnvArgs,
+    ...envNameArgs,
+    ...legacyRootDirArgs
+  },
+  async run(ctx) {
+    overrideEnv("production");
+    const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
+    await showVersions(cwd);
+    const kit = await loadKit(cwd);
+    const nuxt = await kit.loadNuxt({
+      cwd,
+      dotenv: {
+        cwd,
+        fileName: ctx.args.dotenv
+      },
+      envName: ctx.args.envName,
+      // c12 will fall back to NODE_ENV
+      overrides: {
+        logLevel: ctx.args.logLevel,
+        // TODO: remove in 3.8
+        _generate: ctx.args.prerender,
+        nitro: {
+          static: ctx.args.prerender,
+          preset: ctx.args.preset || process.env.NITRO_PRESET || process.env.SERVER_PRESET
+        },
+        ...ctx.data?.overrides
+      }
+    });
+    let nitro;
+    try {
+      nitro = kit.useNitro?.();
+      logger.info(`Building for Nitro preset: \`${nitro.options.preset}\``);
+    } catch {
+    }
+    await clearBuildDir(nuxt.options.buildDir);
+    await kit.writeTypes(nuxt);
+    nuxt.hook("build:error", (err) => {
+      logger.error("Nuxt Build Error:", err);
+      process.exit(1);
+    });
+    await kit.buildNuxt(nuxt);
+    if (ctx.args.prerender) {
+      if (!nuxt.options.ssr) {
+        logger.warn(
+          "HTML content not prerendered because `ssr: false` was set. You can read more in `https://nuxt.com/docs/getting-started/deployment#static-hosting`."
+        );
+      }
+      const dir = nitro?.options.output.publicDir;
+      const publicDir = dir ? relative(process.cwd(), dir) : ".output/public";
+      logger.success(
+        `You can now deploy \`${publicDir}\` to any static hosting!`
+      );
+    }
+  }
+});
+
+export { buildCommand as default };

package/dist/chunks/cleanup.mjs

@@ -0,0 +1,33 @@
+import { defineCommand } from 'citty';
+import { resolve } from 'pathe';
+import { l as loadKit } from '../shared/cli-nightly.DlcAx0De.mjs';
+import { c as cleanupNuxtDirs } from '../shared/cli-nightly.CPUttwQp.mjs';
+import { c as cwdArgs, b as legacyRootDirArgs } from '../shared/cli-nightly.CnY_9Zvw.mjs';
+import 'jiti';
+import 'node:fs';
+import 'ohash';
+import '../shared/cli-nightly.7lipAIIb.mjs';
+import 'node:path';
+import 'node:process';
+import 'std-env';
+import 'consola';
+import 'node:url';
+
+const cleanup = defineCommand({
+  meta: {
+    name: "cleanup",
+    description: "Clean up generated Nuxt files and caches"
+  },
+  args: {
+    ...cwdArgs,
+    ...legacyRootDirArgs
+  },
+  async run(ctx) {
+    const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
+    const { loadNuxtConfig } = await loadKit(cwd);
+    const nuxtOptions = await loadNuxtConfig({ cwd, overrides: { dev: true } });
+    await cleanupNuxtDirs(nuxtOptions.rootDir, nuxtOptions.buildDir);
+  }
+});
+
+export { cleanup as default };

package/dist/chunks/dev-child.mjs

@@ -0,0 +1,81 @@
+import process from 'node:process';
+import { defineCommand } from 'citty';
+import { resolve } from 'pathe';
+import { isTest } from 'std-env';
+import { createNuxtDevServer } from './dev2.mjs';
+import { o as overrideEnv } from '../shared/cli-nightly.cDY7IcTr.mjs';
+import { c as cwdArgs, l as logLevelArgs, e as envNameArgs, b as legacyRootDirArgs, a as logger } from '../shared/cli-nightly.CnY_9Zvw.mjs';
+import 'node:events';
+import 'chokidar';
+import 'h3';
+import 'jiti';
+import 'listhen';
+import 'perfect-debounce';
+import 'ufo';
+import '../shared/cli-nightly.7lipAIIb.mjs';
+import 'node:fs';
+import '../shared/cli-nightly.DlcAx0De.mjs';
+import '../shared/cli-nightly.CPUttwQp.mjs';
+import 'ohash';
+import 'node:path';
+import 'consola';
+import 'node:url';
+
+const devChild = defineCommand({
+  meta: {
+    name: "_dev",
+    description: "Run Nuxt development server (internal command to start child process)"
+  },
+  args: {
+    ...cwdArgs,
+    ...logLevelArgs,
+    ...envNameArgs,
+    ...legacyRootDirArgs
+  },
+  async run(ctx) {
+    if (!process.send && !isTest) {
+      logger.warn(
+        "`nuxi _dev` is an internal command and should not be used directly. Please use `nuxi dev` instead."
+      );
+    }
+    overrideEnv("development");
+    const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
+    const devContext = JSON.parse(process.env.__NUXT_DEV__ || "null") || {};
+    function sendIPCMessage(message) {
+      if (process.send) {
+        process.send(message);
+      } else {
+        logger.info(
+          "Dev server event:",
+          Object.entries(message).map((e) => `${e[0]}=${JSON.stringify(e[1])}`).join(" ")
+        );
+      }
+    }
+    process.once("unhandledRejection", (reason) => {
+      sendIPCMessage({ type: "nuxt:internal:dev:rejection", message: reason instanceof Error ? reason.toString() : "Unhandled Rejection" });
+      process.exit();
+    });
+    const nuxtDev = await createNuxtDevServer({
+      cwd,
+      overrides: ctx.data?.overrides,
+      logLevel: ctx.args.logLevel,
+      clear: !!ctx.args.clear,
+      dotenv: !!ctx.args.dotenv,
+      envName: ctx.args.envName,
+      port: process.env._PORT ?? undefined,
+      devContext
+    });
+    nuxtDev.on("loading", (message) => {
+      sendIPCMessage({ type: "nuxt:internal:dev:loading", message });
+    });
+    nuxtDev.on("restart", () => {
+      sendIPCMessage({ type: "nuxt:internal:dev:restart" });
+    });
+    nuxtDev.on("ready", (payload) => {
+      sendIPCMessage({ type: "nuxt:internal:dev:ready", port: payload.port });
+    });
+    await nuxtDev.init();
+  }
+});
+
+export { devChild as default };

package/dist/chunks/dev.mjs

@@ -0,0 +1,224 @@
+import { fork } from 'node:child_process';
+import process from 'node:process';
+import { setupDotenv } from 'c12';
+import { defineCommand } from 'citty';
+import { createJiti } from 'jiti';
+import { getArgs, parseArgs } from 'listhen/cli';
+import { resolve } from 'pathe';
+import { isBun, isTest } from 'std-env';
+import { s as showVersions } from '../shared/cli-nightly.CGRrR0sp.mjs';
+import { o as overrideEnv } from '../shared/cli-nightly.cDY7IcTr.mjs';
+import { l as loadKit } from '../shared/cli-nightly.DlcAx0De.mjs';
+import { c as cwdArgs, l as logLevelArgs, e as envNameArgs, b as legacyRootDirArgs, d as dotEnvArgs, a as logger } from '../shared/cli-nightly.CnY_9Zvw.mjs';
+import 'consola/utils';
+import 'pkg-types';
+import 'node:path';
+import 'consola';
+import 'node:url';
+
+const forkSupported = !isBun && !isTest;
+const command = defineCommand({
+  meta: {
+    name: "dev",
+    description: "Run Nuxt development server"
+  },
+  args: {
+    ...cwdArgs,
+    ...logLevelArgs,
+    ...envNameArgs,
+    ...legacyRootDirArgs,
+    ...getArgs(),
+    ...dotEnvArgs,
+    clear: {
+      type: "boolean",
+      description: "Clear console on restart"
+    },
+    fork: {
+      type: "boolean",
+      description: forkSupported ? "Disable forked mode" : "Enable forked mode",
+      default: forkSupported
+    }
+  },
+  async run(ctx) {
+    overrideEnv("development");
+    const cwd = resolve(ctx.args.cwd || ctx.args.rootDir);
+    await showVersions(cwd);
+    await setupDotenv({ cwd, fileName: ctx.args.dotenv });
+    const { loadNuxtConfig } = await loadKit(cwd);
+    const nuxtOptions = await loadNuxtConfig({
+      cwd,
+      envName: ctx.args.envName,
+      // c12 will fall back to NODE_ENV
+      overrides: {
+        dev: true,
+        logLevel: ctx.args.logLevel,
+        ...ctx.data?.overrides
+      }
+    });
+    const listenOptions = _resolveListenOptions(nuxtOptions, ctx.args);
+    if (ctx.args.fork) {
+      const devProxy = await _createDevProxy(nuxtOptions, listenOptions);
+      await _startSubprocess(devProxy, ctx.rawArgs);
+      return { listener: devProxy?.listener };
+    } else {
+      const { createNuxtDevServer } = await import('./dev2.mjs');
+      const devServer = await createNuxtDevServer(
+        {
+          cwd,
+          overrides: ctx.data?.overrides,
+          logLevel: ctx.args.logLevel,
+          clear: ctx.args.clear,
+          dotenv: !!ctx.args.dotenv,
+          envName: ctx.args.envName,
+          loadingTemplate: nuxtOptions.devServer.loadingTemplate,
+          devContext: {}
+        },
+        listenOptions
+      );
+      await devServer.init();
+      return { listener: devServer?.listener };
+    }
+  }
+});
+async function _createDevProxy(nuxtOptions, listenOptions) {
+  const jiti = createJiti(nuxtOptions.rootDir);
+  let loadingMessage = "Nuxt dev server is starting...";
+  let loadingTemplate = nuxtOptions.devServer.loadingTemplate;
+  for (const url of nuxtOptions.modulesDir) {
+    if (loadingTemplate) {
+      break;
+    }
+    loadingTemplate = await jiti.import("@nuxt/ui-templates", { parentURL: url }).then((r) => r.loading);
+  }
+  const { createProxyServer } = await import('httpxy');
+  const proxy = createProxyServer({});
+  let address;
+  const handler = (req, res) => {
+    if (!address) {
+      res.statusCode = 503;
+      res.setHeader("Content-Type", "text/html");
+      res.end(loadingTemplate({ loading: loadingMessage }));
+      return;
+    }
+    return proxy.web(req, res, { target: address });
+  };
+  const wsHandler = (req, socket, head) => {
+    if (!address) {
+      socket.destroy();
+      return;
+    }
+    return proxy.ws(req, socket, { target: address }, head);
+  };
+  const { listen } = await import('listhen');
+  const listener = await listen(handler, listenOptions);
+  listener.server.on("upgrade", wsHandler);
+  return {
+    listener,
+    handler,
+    wsHandler,
+    setAddress: (_addr) => {
+      address = _addr;
+    },
+    setLoadingMessage: (_msg) => {
+      loadingMessage = _msg;
+    }
+  };
+}
+async function _startSubprocess(devProxy, rawArgs) {
+  let childProc;
+  const kill = (signal) => {
+    if (childProc) {
+      childProc.kill(signal);
+      childProc = undefined;
+    }
+  };
+  const restart = async () => {
+    if (process.platform === "win32") {
+      kill("SIGTERM");
+    } else {
+      kill("SIGHUP");
+    }
+    childProc = fork(globalThis.__nuxt_cli__.entry, ["_dev", ...rawArgs], {
+      execArgv: [
+        "--enable-source-maps",
+        process.argv.find((a) => a.includes("--inspect"))
+      ].filter(Boolean),
+      env: {
+        ...process.env,
+        __NUXT_DEV__: JSON.stringify({
+          proxy: {
+            url: devProxy.listener.url,
+            urls: await devProxy.listener.getURLs(),
+            https: devProxy.listener.https
+          }
+        })
+      }
+    });
+    childProc.on("close", (errorCode) => {
+      if (errorCode) {
+        process.exit(errorCode);
+      }
+    });
+    childProc.on("message", (message) => {
+      if (message.type === "nuxt:internal:dev:ready") {
+        devProxy.setAddress(`http://127.0.0.1:${message.port}`);
+      } else if (message.type === "nuxt:internal:dev:loading") {
+        devProxy.setAddress(undefined);
+        devProxy.setLoadingMessage(message.message);
+      } else if (message.type === "nuxt:internal:dev:restart") {
+        restart();
+      } else if (message.type === "nuxt:internal:dev:rejection") {
+        logger.withTag("nuxi").info(`Restarting Nuxt due to error: \`${message.message}\``);
+        restart();
+      }
+    });
+  };
+  for (const signal of [
+    "exit",
+    "SIGTERM",
+    "SIGINT",
+    "SIGQUIT"
+  ]) {
+    process.once(signal, () => {
+      kill(signal === "exit" ? 0 : signal);
+    });
+  }
+  await restart();
+  return {
+    restart,
+    kill
+  };
+}
+function _resolveListenOptions(nuxtOptions, args) {
+  const _port = args.port ?? args.p ?? process.env.NUXT_PORT ?? process.env.NITRO_PORT ?? process.env.PORT ?? nuxtOptions.devServer.port;
+  const _hostname = typeof args.host === "string" ? args.host : (args.host === true ? "" : undefined) ?? process.env.NUXT_HOST ?? process.env.NITRO_HOST ?? process.env.HOST ?? nuxtOptions._layers?.[0]?.config?.devServer?.host ?? undefined;
+  const _public = args.public ?? (_hostname && !["localhost", "127.0.0.1", "::1"].includes(_hostname)) ? true : undefined;
+  const _httpsCert = args["https.cert"] || args.sslCert || process.env.NUXT_SSL_CERT || process.env.NITRO_SSL_CERT || typeof nuxtOptions.devServer.https !== "boolean" && nuxtOptions.devServer.https && "cert" in nuxtOptions.devServer.https && nuxtOptions.devServer.https.cert || "";
+  const _httpsKey = args["https.key"] || args.sslKey || process.env.NUXT_SSL_KEY || process.env.NITRO_SSL_KEY || typeof nuxtOptions.devServer.https !== "boolean" && nuxtOptions.devServer.https && "key" in nuxtOptions.devServer.https && nuxtOptions.devServer.https.key || "";
+  const _httpsPfx = args["https.pfx"] || typeof nuxtOptions.devServer.https !== "boolean" && nuxtOptions.devServer.https && "pfx" in nuxtOptions.devServer.https && nuxtOptions.devServer.https.pfx || "";
+  const _httpsPassphrase = args["https.passphrase"] || typeof nuxtOptions.devServer.https !== "boolean" && nuxtOptions.devServer.https && "passphrase" in nuxtOptions.devServer.https && nuxtOptions.devServer.https.passphrase || "";
+  const httpsEnabled = !!(args.https ?? nuxtOptions.devServer.https);
+  const _listhenOptions = parseArgs({
+    ...args,
+    "open": args.o || args.open,
+    "https": httpsEnabled,
+    "https.cert": _httpsCert,
+    "https.key": _httpsKey,
+    "https.pfx": _httpsPfx,
+    "https.passphrase": _httpsPassphrase
+  });
+  const httpsOptions = httpsEnabled && {
+    ...nuxtOptions.devServer.https,
+    ..._listhenOptions.https
+  };
+  return {
+    ..._listhenOptions,
+    port: _port,
+    hostname: _hostname,
+    public: _public,
+    https: httpsOptions,
+    baseURL: nuxtOptions.app.baseURL.startsWith("./") ? nuxtOptions.app.baseURL.slice(1) : nuxtOptions.app.baseURL
+  };
+}
+
+export { command as default };