nitro-nightly 3.1.0-20251028-004953-57503e42 → 3.1.0-20251028-110430-e607b753

package/dist/cli/index.mjs

@@ -1,463 +1,8 @@
 #!/usr/bin/env node
-import consola from 'consola';
-import { colors } from 'consola/utils';
+import { r as runMain, d as defineCommand } from '../_deps/citty.mjs';
 import { version } from 'nitro/meta';
-
-function toArray(val) {
-  if (Array.isArray(val)) {
-    return val;
-  }
-  return val === void 0 ? [] : [val];
-}
-function formatLineColumns(lines, linePrefix = "") {
-  const maxLengh = [];
-  for (const line of lines) {
-    for (const [i, element] of line.entries()) {
-      maxLengh[i] = Math.max(maxLengh[i] || 0, element.length);
-    }
-  }
-  return lines.map(
-    (l) => l.map(
-      (c, i) => linePrefix + c[i === 0 ? "padStart" : "padEnd"](maxLengh[i])
-    ).join("  ")
-  ).join("\n");
-}
-function resolveValue(input) {
-  return typeof input === "function" ? input() : input;
-}
-class CLIError extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "CLIError";
-  }
-}
-
-const NUMBER_CHAR_RE = /\d/;
-const STR_SPLITTERS = ["-", "_", "/", "."];
-function isUppercase(char = "") {
-  if (NUMBER_CHAR_RE.test(char)) {
-    return void 0;
-  }
-  return char !== char.toLowerCase();
-}
-function splitByCase(str, separators) {
-  const splitters = STR_SPLITTERS;
-  const parts = [];
-  if (!str || typeof str !== "string") {
-    return parts;
-  }
-  let buff = "";
-  let previousUpper;
-  let previousSplitter;
-  for (const char of str) {
-    const isSplitter = splitters.includes(char);
-    if (isSplitter === true) {
-      parts.push(buff);
-      buff = "";
-      previousUpper = void 0;
-      continue;
-    }
-    const isUpper = isUppercase(char);
-    if (previousSplitter === false) {
-      if (previousUpper === false && isUpper === true) {
-        parts.push(buff);
-        buff = char;
-        previousUpper = isUpper;
-        continue;
-      }
-      if (previousUpper === true && isUpper === false && buff.length > 1) {
-        const lastChar = buff.at(-1);
-        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
-        buff = lastChar + char;
-        previousUpper = isUpper;
-        continue;
-      }
-    }
-    buff += char;
-    previousUpper = isUpper;
-    previousSplitter = isSplitter;
-  }
-  parts.push(buff);
-  return parts;
-}
-function upperFirst(str) {
-  return str ? str[0].toUpperCase() + str.slice(1) : "";
-}
-function lowerFirst(str) {
-  return str ? str[0].toLowerCase() + str.slice(1) : "";
-}
-function pascalCase(str, opts) {
-  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => upperFirst(p)).join("") : "";
-}
-function camelCase(str, opts) {
-  return lowerFirst(pascalCase(str || ""));
-}
-function kebabCase(str, joiner) {
-  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join("-") : "";
-}
-
-function toArr(any) {
-  return any == void 0 ? [] : Array.isArray(any) ? any : [any];
-}
-function toVal(out, key, val, opts) {
-  let x;
-  const old = out[key];
-  const nxt = ~opts.string.indexOf(key) ? val == void 0 || val === true ? "" : String(val) : typeof val === "boolean" ? val : ~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (x = +val, x * 0 === 0) ? x : val;
-  out[key] = old == void 0 ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
-}
-function parseRawArgs(args = [], opts = {}) {
-  let k;
-  let arr;
-  let arg;
-  let name;
-  let val;
-  const out = { _: [] };
-  let i = 0;
-  let j = 0;
-  let idx = 0;
-  const len = args.length;
-  const alibi = opts.alias !== void 0;
-  const strict = opts.unknown !== void 0;
-  const defaults = opts.default !== void 0;
-  opts.alias = opts.alias || {};
-  opts.string = toArr(opts.string);
-  opts.boolean = toArr(opts.boolean);
-  if (alibi) {
-    for (k in opts.alias) {
-      arr = opts.alias[k] = toArr(opts.alias[k]);
-      for (i = 0; i < arr.length; i++) {
-        (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
-      }
-    }
-  }
-  for (i = opts.boolean.length; i-- > 0; ) {
-    arr = opts.alias[opts.boolean[i]] || [];
-    for (j = arr.length; j-- > 0; ) {
-      opts.boolean.push(arr[j]);
-    }
-  }
-  for (i = opts.string.length; i-- > 0; ) {
-    arr = opts.alias[opts.string[i]] || [];
-    for (j = arr.length; j-- > 0; ) {
-      opts.string.push(arr[j]);
-    }
-  }
-  if (defaults) {
-    for (k in opts.default) {
-      name = typeof opts.default[k];
-      arr = opts.alias[k] = opts.alias[k] || [];
-      if (opts[name] !== void 0) {
-        opts[name].push(k);
-        for (i = 0; i < arr.length; i++) {
-          opts[name].push(arr[i]);
-        }
-      }
-    }
-  }
-  const keys = strict ? Object.keys(opts.alias) : [];
-  for (i = 0; i < len; i++) {
-    arg = args[i];
-    if (arg === "--") {
-      out._ = out._.concat(args.slice(++i));
-      break;
-    }
-    for (j = 0; j < arg.length; j++) {
-      if (arg.charCodeAt(j) !== 45) {
-        break;
-      }
-    }
-    if (j === 0) {
-      out._.push(arg);
-    } else if (arg.substring(j, j + 3) === "no-") {
-      name = arg.slice(Math.max(0, j + 3));
-      if (strict && !~keys.indexOf(name)) {
-        return opts.unknown(arg);
-      }
-      out[name] = false;
-    } else {
-      for (idx = j + 1; idx < arg.length; idx++) {
-        if (arg.charCodeAt(idx) === 61) {
-          break;
-        }
-      }
-      name = arg.substring(j, idx);
-      val = arg.slice(Math.max(0, ++idx)) || i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i];
-      arr = j === 2 ? [name] : name;
-      for (idx = 0; idx < arr.length; idx++) {
-        name = arr[idx];
-        if (strict && !~keys.indexOf(name)) {
-          return opts.unknown("-".repeat(j) + name);
-        }
-        toVal(out, name, idx + 1 < arr.length || val, opts);
-      }
-    }
-  }
-  if (defaults) {
-    for (k in opts.default) {
-      if (out[k] === void 0) {
-        out[k] = opts.default[k];
-      }
-    }
-  }
-  if (alibi) {
-    for (k in out) {
-      arr = opts.alias[k] || [];
-      while (arr.length > 0) {
-        out[arr.shift()] = out[k];
-      }
-    }
-  }
-  return out;
-}
-
-function parseArgs(rawArgs, argsDef) {
-  const parseOptions = {
-    boolean: [],
-    string: [],
-    mixed: [],
-    alias: {},
-    default: {}
-  };
-  const args = resolveArgs(argsDef);
-  for (const arg of args) {
-    if (arg.type === "positional") {
-      continue;
-    }
-    if (arg.type === "string") {
-      parseOptions.string.push(arg.name);
-    } else if (arg.type === "boolean") {
-      parseOptions.boolean.push(arg.name);
-    }
-    if (arg.default !== void 0) {
-      parseOptions.default[arg.name] = arg.default;
-    }
-    if (arg.alias) {
-      parseOptions.alias[arg.name] = arg.alias;
-    }
-  }
-  const parsed = parseRawArgs(rawArgs, parseOptions);
-  const [...positionalArguments] = parsed._;
-  const parsedArgsProxy = new Proxy(parsed, {
-    get(target, prop) {
-      return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
-    }
-  });
-  for (const [, arg] of args.entries()) {
-    if (arg.type === "positional") {
-      const nextPositionalArgument = positionalArguments.shift();
-      if (nextPositionalArgument !== void 0) {
-        parsedArgsProxy[arg.name] = nextPositionalArgument;
-      } else if (arg.default === void 0 && arg.required !== false) {
-        throw new CLIError(
-          `Missing required positional argument: ${arg.name.toUpperCase()}`,
-          "EARG"
-        );
-      } else {
-        parsedArgsProxy[arg.name] = arg.default;
-      }
-    } else if (arg.required && parsedArgsProxy[arg.name] === void 0) {
-      throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
-    }
-  }
-  return parsedArgsProxy;
-}
-function resolveArgs(argsDef) {
-  const args = [];
-  for (const [name, argDef] of Object.entries(argsDef || {})) {
-    args.push({
-      ...argDef,
-      name,
-      alias: toArray(argDef.alias)
-    });
-  }
-  return args;
-}
-
-function defineCommand(def) {
-  return def;
-}
-async function runCommand(cmd, opts) {
-  const cmdArgs = await resolveValue(cmd.args || {});
-  const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
-  const context = {
-    rawArgs: opts.rawArgs,
-    args: parsedArgs,
-    data: opts.data,
-    cmd
-  };
-  if (typeof cmd.setup === "function") {
-    await cmd.setup(context);
-  }
-  let result;
-  try {
-    const subCommands = await resolveValue(cmd.subCommands);
-    if (subCommands && Object.keys(subCommands).length > 0) {
-      const subCommandArgIndex = opts.rawArgs.findIndex(
-        (arg) => !arg.startsWith("-")
-      );
-      const subCommandName = opts.rawArgs[subCommandArgIndex];
-      if (subCommandName) {
-        if (!subCommands[subCommandName]) {
-          throw new CLIError(
-            `Unknown command \`${subCommandName}\``,
-            "E_UNKNOWN_COMMAND"
-          );
-        }
-        const subCommand = await resolveValue(subCommands[subCommandName]);
-        if (subCommand) {
-          await runCommand(subCommand, {
-            rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1)
-          });
-        }
-      } else if (!cmd.run) {
-        throw new CLIError(`No command specified.`, "E_NO_COMMAND");
-      }
-    }
-    if (typeof cmd.run === "function") {
-      result = await cmd.run(context);
-    }
-  } finally {
-    if (typeof cmd.cleanup === "function") {
-      await cmd.cleanup(context);
-    }
-  }
-  return { result };
-}
-async function resolveSubCommand(cmd, rawArgs, parent) {
-  const subCommands = await resolveValue(cmd.subCommands);
-  if (subCommands && Object.keys(subCommands).length > 0) {
-    const subCommandArgIndex = rawArgs.findIndex((arg) => !arg.startsWith("-"));
-    const subCommandName = rawArgs[subCommandArgIndex];
-    const subCommand = await resolveValue(subCommands[subCommandName]);
-    if (subCommand) {
-      return resolveSubCommand(
-        subCommand,
-        rawArgs.slice(subCommandArgIndex + 1),
-        cmd
-      );
-    }
-  }
-  return [cmd, parent];
-}
-
-async function showUsage(cmd, parent) {
-  try {
-    consola.log(await renderUsage(cmd, parent) + "\n");
-  } catch (error) {
-    consola.error(error);
-  }
-}
-async function renderUsage(cmd, parent) {
-  const cmdMeta = await resolveValue(cmd.meta || {});
-  const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
-  const parentMeta = await resolveValue(parent?.meta || {});
-  const commandName = `${parentMeta.name ? `${parentMeta.name} ` : ""}` + (cmdMeta.name || process.argv[1]);
-  const argLines = [];
-  const posLines = [];
-  const commandsLines = [];
-  const usageLine = [];
-  for (const arg of cmdArgs) {
-    if (arg.type === "positional") {
-      const name = arg.name.toUpperCase();
-      const isRequired = arg.required !== false && arg.default === void 0;
-      const defaultHint = arg.default ? `="${arg.default}"` : "";
-      posLines.push([
-        "`" + name + defaultHint + "`",
-        arg.description || "",
-        arg.valueHint ? `<${arg.valueHint}>` : ""
-      ]);
-      usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
-    } else {
-      const isRequired = arg.required === true && arg.default === void 0;
-      const argStr = (arg.type === "boolean" && arg.default === true ? [
-        ...(arg.alias || []).map((a) => `--no-${a}`),
-        `--no-${arg.name}`
-      ].join(", ") : [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(
-        ", "
-      )) + (arg.type === "string" && (arg.valueHint || arg.default) ? `=${arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`}` : "");
-      argLines.push([
-        "`" + argStr + (isRequired ? " (required)" : "") + "`",
-        arg.description || ""
-      ]);
-      if (isRequired) {
-        usageLine.push(argStr);
-      }
-    }
-  }
-  if (cmd.subCommands) {
-    const commandNames = [];
-    const subCommands = await resolveValue(cmd.subCommands);
-    for (const [name, sub] of Object.entries(subCommands)) {
-      const subCmd = await resolveValue(sub);
-      const meta = await resolveValue(subCmd?.meta);
-      commandsLines.push([`\`${name}\``, meta?.description || ""]);
-      commandNames.push(name);
-    }
-    usageLine.push(commandNames.join("|"));
-  }
-  const usageLines = [];
-  const version = cmdMeta.version || parentMeta.version;
-  usageLines.push(
-    colors.gray(
-      `${cmdMeta.description} (${commandName + (version ? ` v${version}` : "")})`
-    ),
-    ""
-  );
-  const hasOptions = argLines.length > 0 || posLines.length > 0;
-  usageLines.push(
-    `${colors.underline(colors.bold("USAGE"))} \`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}\``,
-    ""
-  );
-  if (posLines.length > 0) {
-    usageLines.push(colors.underline(colors.bold("ARGUMENTS")), "");
-    usageLines.push(formatLineColumns(posLines, "  "));
-    usageLines.push("");
-  }
-  if (argLines.length > 0) {
-    usageLines.push(colors.underline(colors.bold("OPTIONS")), "");
-    usageLines.push(formatLineColumns(argLines, "  "));
-    usageLines.push("");
-  }
-  if (commandsLines.length > 0) {
-    usageLines.push(colors.underline(colors.bold("COMMANDS")), "");
-    usageLines.push(formatLineColumns(commandsLines, "  "));
-    usageLines.push(
-      "",
-      `Use \`${commandName} <command> --help\` for more information about a command.`
-    );
-  }
-  return usageLines.filter((l) => typeof l === "string").join("\n");
-}
-
-async function runMain(cmd, opts = {}) {
-  const rawArgs = opts.rawArgs || process.argv.slice(2);
-  const showUsage$1 = opts.showUsage || showUsage;
-  try {
-    if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
-      await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
-      process.exit(0);
-    } else if (rawArgs.length === 1 && rawArgs[0] === "--version") {
-      const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
-      if (!meta?.version) {
-        throw new CLIError("No version specified", "E_NO_VERSION");
-      }
-      consola.log(meta.version);
-    } else {
-      await runCommand(cmd, { rawArgs });
-    }
-  } catch (error) {
-    const isCLIError = error instanceof CLIError;
-    if (!isCLIError) {
-      consola.error(error, "\n");
-    }
-    if (isCLIError) {
-      await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
-    }
-    consola.error(error.message);
-    process.exit(1);
-  }
-}
+import 'consola';
+import 'consola/utils';
 
 const main = defineCommand({
   meta: {
@@ -466,12 +11,10 @@ const main = defineCommand({
     version: version
   },
   subCommands: {
-    dev: () => import('./dev.mjs').then((r) => r.default),
-    build: () => import('./build.mjs').then((r) => r.default),
-    prepare: () => import('./prepare.mjs').then((r) => r.default),
-    task: () => import('./index2.mjs').then((r) => r.default)
+    dev: () => import('../_cli/dev.mjs').then((r) => r.default),
+    build: () => import('../_cli/build.mjs').then((r) => r.default),
+    prepare: () => import('../_cli/prepare.mjs').then((r) => r.default),
+    task: () => import('../_cli/index.mjs').then((r) => r.default)
   }
 });
 runMain(main);
-
-export { defineCommand as d };

package/dist/index.mjs

@@ -1,55 +1,143 @@
-export { d as copyPublicAssets, k as createNitro, E as listTasks, B as loadOptions, j as prepare, D as runTask } from './_chunks/index.mjs';
-export { b as build, p as prerender, w as writeTypes } from './_chunks/index3.mjs';
-export { c as createDevServer } from './_chunks/server.mjs';
-import 'consola';
-import 'hookable';
-import 'node:fs';
-import 'node:fs/promises';
+export { a as createDevServer, c as createNitro, b as listTasks, l as loadOptions, p as prerender, r as runTask } from './_build/vite.mjs';
+export { b as build } from './_build/build.mjs';
+export { a as copyPublicAssets } from './_build/assets.mjs';
+export { p as prepare } from './_build/prepare.mjs';
+export { w as writeTypes } from './_build/types.mjs';
 import 'node:url';
-import 'node:os';
+import 'consola/utils';
+import 'defu';
+import './_deps/mime.mjs';
+import './_deps/rou3.mjs';
+import 'ufo';
+import './_build/rolldown.mjs';
+import './_deps/mlly.mjs';
+import './_deps/acorn.mjs';
+import 'node:module';
+import 'node:fs';
+import './_deps/pkg-types.mjs';
+import './_deps/confbox.mjs';
+import './_deps/pathe.mjs';
+import './_deps/exsolve.mjs';
 import 'node:path';
 import 'node:assert';
 import 'node:process';
 import 'node:v8';
 import 'node:util';
-import 'jiti';
-import 'destr';
-import 'defu';
-import './_chunks/pathe.M-eThtNZ.mjs';
-import 'fs';
+import 'node:fs/promises';
+import 'nitro/runtime/meta';
+import './_build/config.mjs';
+import 'unenv';
+import './_build/plugins.mjs';
+import './_deps/@rollup/plugin-replace.mjs';
+import './_deps/magic-string.mjs';
+import './_deps/@jridgewell/sourcemap-codec.mjs';
+import './_deps/@rollup/pluginutils.mjs';
 import 'path';
-import 'os';
+import './_deps/estree-walker.mjs';
+import './_deps/picomatch.mjs';
+import './_deps/commondir.mjs';
+import 'ohash';
+import './_deps/unimport.mjs';
+import 'scule';
+import 'node:os';
+import './_deps/unplugin.mjs';
+import 'node:buffer';
+import './_deps/@jridgewell/remapping.mjs';
+import './_deps/@jridgewell/trace-mapping.mjs';
+import './_deps/@jridgewell/resolve-uri.mjs';
+import './_deps/@jridgewell/gen-mapping.mjs';
+import 'node:querystring';
+import './_deps/webpack-virtual-modules.mjs';
+import 'constants';
+import './_deps/unplugin-utils.mjs';
+import './_deps/tinyglobby.mjs';
+import 'fs';
+import 'url';
+import './_deps/fdir.mjs';
+import 'module';
+import './_deps/local-pkg.mjs';
+import './_deps/quansync.mjs';
+import './_deps/strip-literal.mjs';
+import './_deps/js-tokens.mjs';
+import './_deps/unwasm.mjs';
+import 'node:crypto';
+import './_deps/knitwork.mjs';
+import 'db0';
+import 'esbuild';
+import './_deps/etag.mjs';
 import 'crypto';
-import './_chunks/app.mjs';
-import 'node:worker_threads';
-import 'std-env';
+import 'unstorage';
+import 'nf3';
+import 'rendu';
+import './_deps/chokidar.mjs';
 import 'fs/promises';
 import 'events';
+import './_deps/readdirp.mjs';
 import 'node:stream';
+import 'os';
+import './_deps/perfect-debounce.mjs';
+import './_deps/compatx.mjs';
+import './_deps/gzip-size.mjs';
+import 'node:zlib';
+import 'stream';
+import './_deps/pretty-bytes.mjs';
+import 'std-env';
+import './_build/snapshot.mjs';
+import 'klona';
+import './_build/info.mjs';
+import 'nitro/meta';
+import './_presets/_types.mjs';
+import './_deps/ultrahtml.mjs';
 import 'h3';
-import 'url';
+import 'consola';
+import 'srvx/node';
+import 'hookable';
+import './_deps/c12.mjs';
+import 'jiti';
+import './_deps/rc9.mjs';
+import 'destr';
+import './_deps/dotenv.mjs';
+import 'klona/full';
+import './_deps/escape-string-regexp.mjs';
+import 'ofetch';
+import 'node:worker_threads';
+import 'undici';
+import './_deps/serve-static.mjs';
+import './_deps/encodeurl.mjs';
+import './_deps/escape-html.mjs';
+import './_deps/parseurl.mjs';
+import './_deps/send.mjs';
+import './_deps/http-errors.mjs';
+import './_deps/depd.mjs';
+import './_deps/setprototypeof.mjs';
+import './_deps/statuses.mjs';
+import './_deps/inherits.mjs';
+import './_deps/toidentifier.mjs';
+import './_deps/debug.mjs';
 import 'tty';
 import 'util';
-import 'stream';
-import 'ufo';
+import './_deps/ms.mjs';
+import './_deps/supports-color.mjs';
+import './_deps/fresh.mjs';
+import './_deps/mime-types.mjs';
+import './_deps/mime-db.mjs';
+import './_deps/on-finished.mjs';
+import './_deps/ee-first.mjs';
+import './_deps/range-parser.mjs';
+import './_deps/httpxy.mjs';
 import 'node:http';
 import 'node:https';
 import 'node:events';
-import 'undici';
 import 'youch-core';
 import 'youch';
 import 'source-map';
 import 'srvx';
-import 'klona/full';
-import 'nitro/runtime/meta';
-import 'node:module';
-import 'ofetch';
-import 'klona';
-import 'unstorage';
-import 'ohash';
-import 'scule';
-import 'module';
-import 'consola/utils';
-import 'node:zlib';
-import 'nitro/meta';
-import 'srvx/node';
+import './_deps/@rollup/plugin-alias.mjs';
+import './_deps/@rollup/plugin-inject.mjs';
+import 'vite';
+import 'get-port-please';
+import 'node:child_process';
+import './_deps/@pi0/vite-plugin-fullstack.mjs';
+import 'node:assert/strict';
+import './_deps/dot-prop.mjs';
+import './_deps/untyped.mjs';