nitro 2.2.27 → 3.0.0-alpha.0

package/dist/cli/index.mjs

@@ -0,0 +1,477 @@
+#!/usr/bin/env node
+import consola from 'consola';
+import { colors } from 'consola/utils';
+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);
+  }
+}
+
+const main = defineCommand({
+  meta: {
+    name: "nitro",
+    description: "Nitro CLI",
+    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)
+  }
+});
+runMain(main);
+
+export { defineCommand as d };

package/dist/cli/index2.mjs

@@ -0,0 +1,17 @@
+import { d as defineCommand } from './index.mjs';
+import 'consola';
+import 'consola/utils';
+import 'nitro/meta';
+
+const index = defineCommand({
+  meta: {
+    name: "task",
+    description: "Operate in nitro tasks (experimental)"
+  },
+  subCommands: {
+    list: () => import('./list.mjs').then((r) => r.default),
+    run: () => import('./run.mjs').then((r) => r.default)
+  }
+});
+
+export { index as default };

package/dist/cli/list.mjs

@@ -0,0 +1,34 @@
+import { d as defineCommand } from './index.mjs';
+import { consola } from 'consola';
+import { loadOptions, listTasks } from 'nitro';
+import { r as resolve } from '../_chunks/pathe.M-eThtNZ.mjs';
+import 'consola/utils';
+import 'nitro/meta';
+
+const list = defineCommand({
+  meta: {
+    name: "run",
+    description: "List available tasks (experimental)"
+  },
+  args: {
+    dir: {
+      type: "string",
+      description: "project root directory"
+    }
+  },
+  async run({ args }) {
+    const cwd = resolve(args.dir || args.cwd || ".");
+    const options = await loadOptions({ rootDir: cwd }).catch(() => void 0);
+    const tasks = await listTasks({
+      cwd,
+      buildDir: options?.buildDir || ".nitro"
+    });
+    for (const [name, task] of Object.entries(tasks)) {
+      consola.log(
+        ` - \`${name}\`${task.meta?.description ? ` - ${task.meta.description}` : ""}`
+      );
+    }
+  }
+});
+
+export { list as default };

package/dist/cli/prepare.mjs

@@ -0,0 +1,24 @@
+import { d as defineCommand } from './index.mjs';
+import { createNitro, writeTypes } from 'nitro';
+import { c as commonArgs } from './common.mjs';
+import { r as resolve } from '../_chunks/pathe.M-eThtNZ.mjs';
+import 'consola';
+import 'consola/utils';
+import 'nitro/meta';
+
+const prepare = defineCommand({
+  meta: {
+    name: "prepare",
+    description: "Generate types for the project"
+  },
+  args: {
+    ...commonArgs
+  },
+  async run({ args }) {
+    const rootDir = resolve(args.dir || args._dir || ".");
+    const nitro = await createNitro({ rootDir });
+    await writeTypes(nitro);
+  }
+});
+
+export { prepare as default };

package/dist/cli/run.mjs

@@ -0,0 +1,60 @@
+import { d as defineCommand } from './index.mjs';
+import { consola } from 'consola';
+import destr from 'destr';
+import { loadOptions, runTask } from 'nitro';
+import { r as resolve } from '../_chunks/pathe.M-eThtNZ.mjs';
+import 'consola/utils';
+import 'nitro/meta';
+
+const run = defineCommand({
+  meta: {
+    name: "run",
+    description: "Run a runtime task in the currently running dev server (experimental)"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "task name",
+      required: true
+    },
+    dir: {
+      type: "string",
+      description: "project root directory"
+    },
+    payload: {
+      type: "string",
+      description: "payload json to pass to the task"
+    }
+  },
+  async run({ args }) {
+    const cwd = resolve(args.dir || args.cwd || ".");
+    const options = await loadOptions({ rootDir: cwd }).catch(() => void 0);
+    consola.info(`Running task \`${args.name}\`...`);
+    let payload = destr(args.payload || "{}");
+    if (typeof payload !== "object") {
+      consola.error(
+        `Invalid payload: \`${args.payload}\` (it should be a valid JSON object)`
+      );
+      payload = void 0;
+    }
+    try {
+      const { result } = await runTask(
+        {
+          name: args.name,
+          context: {},
+          payload
+        },
+        {
+          cwd,
+          buildDir: options?.buildDir || ".nitro"
+        }
+      );
+      consola.success("Result:", result);
+    } catch (error) {
+      consola.error(`Failed to run task \`${args.name}\`: ${error}`);
+      process.exit(1);
+    }
+  }
+});
+
+export { run as default };

package/dist/index.d.mts

@@ -0,0 +1,52 @@
+import { NitroConfig, LoadConfigOptions, Nitro, DevRPCHooks, DevMessageListener, NitroOptions, TaskEvent, TaskRunnerOptions } from 'nitro/types';
+import { IncomingMessage, OutgoingMessage } from 'node:http';
+import { Duplex } from 'node:stream';
+import { ServerOptions, Server } from 'srvx';
+import { HTTPHandler } from 'h3';
+
+declare function createNitro(config?: NitroConfig, opts?: LoadConfigOptions): Promise<Nitro>;
+
+declare function prerender(nitro: Nitro): Promise<void>;
+
+declare class NitroDevApp {
+    #private;
+    nitro: Nitro;
+    fetch: (req: Request) => Response | Promise<Response>;
+    constructor(nitro: Nitro, catchAllHandler?: HTTPHandler);
+}
+
+declare function createDevServer(nitro: Nitro): NitroDevServer;
+declare class NitroDevServer extends NitroDevApp implements DevRPCHooks {
+    #private;
+    constructor(nitro: Nitro);
+    upgrade(req: IncomingMessage, socket: OutgoingMessage<IncomingMessage> | Duplex, head: any): Promise<void>;
+    listen(opts?: Partial<Omit<ServerOptions, "fetch">>): Server;
+    close(): Promise<void>;
+    reload(): void;
+    sendMessage(message: unknown): void;
+    onMessage(listener: DevMessageListener): void;
+    offMessage(listener: DevMessageListener): void;
+}
+
+declare function loadOptions(configOverrides?: NitroConfig, opts?: LoadConfigOptions): Promise<NitroOptions>;
+
+/** @experimental */
+declare function runTask(taskEvent: TaskEvent, opts?: TaskRunnerOptions): Promise<{
+    result: unknown;
+}>;
+/** @experimental */
+declare function listTasks(opts?: TaskRunnerOptions): Promise<Record<string, {
+    meta: {
+        description: string;
+    };
+}>>;
+
+declare function build(nitro: Nitro): Promise<void>;
+
+declare function copyPublicAssets(nitro: Nitro): Promise<void>;
+
+declare function prepare(nitro: Nitro): Promise<void>;
+
+declare function writeTypes(nitro: Nitro): Promise<void>;
+
+export { build, copyPublicAssets, createDevServer, createNitro, listTasks, loadOptions, prepare, prerender, runTask, writeTypes };