@depup/nitro 3.0.260311-beta-depup.0

package/dist/builder.d.mts

@@ -0,0 +1,64 @@
+import { t as NitroDevApp } from "./_dev.mjs";
+import { RunnerMessageListener, RunnerRPCHooks } from "env-runner";
+import { IncomingMessage } from "node:http";
+import { Server, ServerOptions } from "srvx";
+import { LoadConfigOptions, Nitro, NitroBuildInfo, NitroConfig, NitroOptions, TaskEvent, TaskRunnerOptions } from "nitro/types";
+import { Socket } from "node:net";
+
+//#region src/nitro.d.ts
+declare function createNitro(config?: NitroConfig, opts?: LoadConfigOptions): Promise<Nitro>;
+//#endregion
+//#region src/config/loader.d.ts
+declare function loadOptions(configOverrides?: NitroConfig, opts?: LoadConfigOptions): Promise<NitroOptions>;
+//#endregion
+//#region src/build/build.d.ts
+declare function build(nitro: Nitro): Promise<void>;
+//#endregion
+//#region src/build/assets.d.ts
+declare function copyPublicAssets(nitro: Nitro): Promise<void>;
+//#endregion
+//#region src/build/prepare.d.ts
+declare function prepare(nitro: Nitro): Promise<void>;
+//#endregion
+//#region src/build/types.d.ts
+declare function writeTypes(nitro: Nitro): Promise<void>;
+//#endregion
+//#region src/build/info.d.ts
+declare function getBuildInfo(root: string): Promise<{
+  outputDir?: undefined;
+  buildInfo?: undefined;
+} | {
+  outputDir: string;
+  buildInfo?: NitroBuildInfo;
+}>;
+//#endregion
+//#region src/dev/server.d.ts
+declare function createDevServer(nitro: Nitro): NitroDevServer;
+declare class NitroDevServer extends NitroDevApp implements RunnerRPCHooks {
+  #private;
+  constructor(nitro: Nitro);
+  upgrade(req: IncomingMessage, socket: Socket, head: any): Promise<void>;
+  listen(opts?: Partial<Omit<ServerOptions, "fetch">>): Server;
+  close(): Promise<void>;
+  reload(): void;
+  sendMessage(message: unknown): void;
+  onMessage(listener: RunnerMessageListener): void;
+  offMessage(listener: RunnerMessageListener): void;
+}
+//#endregion
+//#region src/prerender/prerender.d.ts
+declare function prerender(nitro: Nitro): Promise<void>;
+//#endregion
+//#region src/task.d.ts
+/** @experimental */
+declare function runTask(taskEvent: TaskEvent, opts?: TaskRunnerOptions): Promise<{
+  result: unknown;
+}>;
+/** @experimental */
+declare function listTasks(opts?: TaskRunnerOptions): Promise<Record<string, {
+  meta: {
+    description: string;
+  };
+}>>;
+//#endregion
+export { build, copyPublicAssets, createDevServer, createNitro, getBuildInfo, listTasks, loadOptions, prepare, prerender, runTask, writeTypes };

package/dist/builder.mjs

@@ -0,0 +1,15 @@
+import "./_libs/c12+rc9.mjs";
+import { D as copyPublicAssets, E as prepare, _ as writeTypes, j as build, m as getBuildInfo } from "./_build/common.mjs";
+import "./_libs/compatx.mjs";
+import "./_libs/klona.mjs";
+import { a as loadOptions, i as createNitro, n as runTask, r as prerender, t as listTasks } from "./_chunks/nitro.mjs";
+import "./_libs/escape-string-regexp.mjs";
+import "./_libs/tsconfck.mjs";
+import "./_chunks/nitro2.mjs";
+import "./_libs/rou3.mjs";
+import "./_libs/readdirp+chokidar.mjs";
+import "./_libs/perfect-debounce.mjs";
+import "./_libs/httpxy.mjs";
+import { n as createDevServer } from "./_dev.mjs";
+import "./_libs/ultrahtml.mjs";
+export { build, copyPublicAssets, createDevServer, createNitro, getBuildInfo, listTasks, loadOptions, prepare, prerender, runTask, writeTypes };

package/dist/cli/_chunks/build.mjs

@@ -0,0 +1,47 @@
+import { dt as resolve } from "../../_build/common.mjs";
+import { t as defineCommand } from "../../_libs/citty.mjs";
+import { t as commonArgs } from "./common.mjs";
+import { build, copyPublicAssets, createNitro, prepare, prerender } from "nitro/builder";
+//#region src/cli/commands/build.ts
+const buildArgs = {
+	...commonArgs,
+	minify: {
+		type: "boolean",
+		description: "Minify the output (overrides preset defaults you can also use `--no-minify` to disable)."
+	},
+	preset: {
+		type: "string",
+		description: "The build preset to use (you can also use `NITRO_PRESET` environment variable)."
+	},
+	builder: {
+		type: "string",
+		description: "The builder to use (you can also use `NITRO_BUILDER` environment variable)."
+	},
+	compatibilityDate: {
+		type: "string",
+		description: "The date to use for preset compatibility (you can also use `NITRO_COMPATIBILITY_DATE` environment variable)."
+	}
+};
+var build_default = defineCommand({
+	meta: {
+		name: "build",
+		description: "Build nitro project for production"
+	},
+	args: buildArgs,
+	async run({ args }) {
+		const nitro = await createNitro({
+			rootDir: resolve(args.dir || args._dir || "."),
+			dev: false,
+			minify: args.minify,
+			preset: args.preset,
+			builder: args.builder
+		}, { compatibilityDate: args.compatibilityDate });
+		await prepare(nitro);
+		await copyPublicAssets(nitro);
+		await prerender(nitro);
+		await build(nitro);
+		await nitro.close();
+	}
+});
+//#endregion
+export { buildArgs, build_default as default };

package/dist/cli/_chunks/common.mjs

@@ -0,0 +1,14 @@
+//#region src/cli/common.ts
+const commonArgs = {
+	dir: {
+		type: "string",
+		description: "project root directory"
+	},
+	_dir: {
+		type: "positional",
+		default: ".",
+		description: "project root directory (prefer using `--dir`)"
+	}
+};
+//#endregion
+export { commonArgs as t };

package/dist/cli/_chunks/deploy.mjs

@@ -0,0 +1,40 @@
+import { dt as resolve, m as getBuildInfo, ut as relative } from "../../_build/common.mjs";
+import { t as defineCommand } from "../../_libs/citty.mjs";
+import "./common.mjs";
+import build_default, { buildArgs } from "./build.mjs";
+import consola from "consola";
+import { execSync } from "node:child_process";
+//#region src/cli/commands/deploy.ts
+var deploy_default = defineCommand({
+	meta: {
+		name: "deploy",
+		description: "Build and deploy nitro project for production"
+	},
+	args: {
+		...buildArgs,
+		prebuilt: {
+			type: "boolean",
+			description: "Skip the build step and deploy the existing build"
+		}
+	},
+	async run(ctx) {
+		globalThis.__nitroDeploying__ = true;
+		if (!ctx.args.prebuilt) await build_default.run(ctx);
+		if (globalThis.__nitroDeployed__) return;
+		const { buildInfo, outputDir } = await getBuildInfo(resolve(ctx.args.dir || ctx.args._dir || "."));
+		if (!buildInfo) {
+			consola.error("No build info found, cannot deploy.");
+			process.exit(1);
+		}
+		if (!buildInfo.commands?.deploy) {
+			consola.error(`The \`${buildInfo.preset}\` preset does not have a default deploy command.\n\nTry using a different preset with the \`--preset\` option, or configure a deploy command in the Nitro config, or deploy manually.`);
+			process.exit(1);
+		}
+		const extraArgs = ctx.rawArgs.indexOf("--") !== -1 ? ctx.rawArgs.slice(ctx.rawArgs.indexOf("--") + 1).join(" ") : "";
+		const deployCommand = buildInfo.commands.deploy.replace(/([\s:])\.\/(\S*)/g, `$1${relative(process.cwd(), outputDir)}/$2`) + (extraArgs ? ` ${extraArgs}` : "");
+		consola.info(`$ ${deployCommand}`);
+		execSync(deployCommand, { stdio: "inherit" });
+	}
+});
+//#endregion
+export { deploy_default as default };

package/dist/cli/_chunks/dev.mjs

@@ -0,0 +1,62 @@
+import { dt as resolve } from "../../_build/common.mjs";
+import "../../_libs/readdirp+chokidar.mjs";
+import "../../_libs/perfect-debounce.mjs";
+import "../../_libs/httpxy.mjs";
+import { t as NitroDevServer } from "../../_dev.mjs";
+import { t as defineCommand } from "../../_libs/citty.mjs";
+import { t as commonArgs } from "./common.mjs";
+import { consola as consola$1 } from "consola";
+import { build, createNitro, prepare } from "nitro/builder";
+//#region src/cli/commands/dev.ts
+const hmrKeyRe = /^runtimeConfig\.|routeRules\./;
+var dev_default = defineCommand({
+	meta: {
+		name: "dev",
+		description: "Start the development server"
+	},
+	args: {
+		...commonArgs,
+		port: {
+			type: "string",
+			description: "specify port"
+		},
+		host: {
+			type: "string",
+			description: "specify hostname "
+		}
+	},
+	async run({ args }) {
+		const rootDir = resolve(args.dir || args._dir || ".");
+		let nitro;
+		const reload = async () => {
+			if (nitro) {
+				consola$1.info("Restarting dev server...");
+				if ("unwatch" in nitro.options._c12) await nitro.options._c12.unwatch();
+				await nitro.close();
+			}
+			nitro = await createNitro({
+				rootDir,
+				dev: true,
+				_cli: { command: "dev" }
+			}, {
+				watch: true,
+				c12: { async onUpdate({ getDiff, newConfig }) {
+					const diff = getDiff();
+					if (diff.length === 0) return;
+					consola$1.info("Nitro config updated:\n" + diff.map((entry) => `  ${entry.toString()}`).join("\n"));
+					await (diff.every((e) => hmrKeyRe.test(e.key)) ? nitro.updateConfig(newConfig.config || {}) : reload());
+				} }
+			});
+			nitro.hooks.hookOnce("restart", reload);
+			await new NitroDevServer(nitro).listen({
+				port: args.port || nitro.options.devServer.port,
+				hostname: args.host || nitro.options.devServer.hostname
+			});
+			await prepare(nitro);
+			await build(nitro);
+		};
+		await reload();
+	}
+});
+//#endregion
+export { dev_default as default };

package/dist/cli/_chunks/docs.mjs

@@ -0,0 +1,30 @@
+import { t as defineCommand } from "../../_libs/citty.mjs";
+import { execSync } from "node:child_process";
+//#region src/cli/commands/docs.ts
+var docs_default = defineCommand({
+	meta: {
+		name: "docs",
+		description: "Explore Nitro documentation"
+	},
+	args: { page: {
+		type: "string",
+		description: "Page path to open"
+	} },
+	run({ rawArgs }) {
+		const runnerCmd = ([
+			["bun", "x"],
+			["pnpm", "dlx"],
+			["npm", "x"]
+		].find(([pkg]) => {
+			try {
+				execSync(`${pkg} -v`, { stdio: "ignore" });
+				return true;
+			} catch {}
+		}) || ["npm", "x"]).join(" ");
+		const docsDir = new URL("../../../skills/nitro/docs", import.meta.url).pathname;
+		const args = rawArgs?.join(" ") || "";
+		execSync(`${runnerCmd} mdzilla ${docsDir}${args ? ` ${args}` : ""}`, { stdio: "inherit" });
+	}
+});
+//#endregion
+export { docs_default as default };

package/dist/cli/_chunks/list.mjs

@@ -0,0 +1,25 @@
+import { dt as resolve } from "../../_build/common.mjs";
+import { t as defineCommand } from "../../_libs/citty.mjs";
+import { consola as consola$1 } from "consola";
+import { listTasks, loadOptions } from "nitro/builder";
+//#region src/cli/commands/task/list.ts
+var list_default = 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 tasks = await listTasks({
+			cwd,
+			buildDir: (await loadOptions({ rootDir: cwd }).catch(() => void 0))?.buildDir || ".nitro"
+		});
+		for (const [name, task] of Object.entries(tasks)) consola$1.log(` - \`${name}\`${task.meta?.description ? ` - ${task.meta.description}` : ""}`);
+	}
+});
+//#endregion
+export { list_default as default };

package/dist/cli/_chunks/prepare.mjs

@@ -0,0 +1,17 @@
+import { dt as resolve } from "../../_build/common.mjs";
+import { t as defineCommand } from "../../_libs/citty.mjs";
+import { t as commonArgs } from "./common.mjs";
+import { createNitro, writeTypes } from "nitro/builder";
+//#region src/cli/commands/prepare.ts
+var prepare_default = defineCommand({
+	meta: {
+		name: "prepare",
+		description: "Generate types for the project"
+	},
+	args: { ...commonArgs },
+	async run({ args }) {
+		await writeTypes(await createNitro({ rootDir: resolve(args.dir || args._dir || ".") }));
+	}
+});
+//#endregion
+export { prepare_default as default };

package/dist/cli/_chunks/preview.mjs

@@ -0,0 +1,51 @@
+import { dt as resolve } from "../../_build/common.mjs";
+import "../../_libs/httpxy.mjs";
+import { t as defineCommand } from "../../_libs/citty.mjs";
+import { t as startPreview } from "../../_chunks/nitro3.mjs";
+import { t as commonArgs } from "./common.mjs";
+import { serve } from "srvx";
+import { log } from "srvx/log";
+//#region src/cli/commands/preview.ts
+var preview_default = defineCommand({
+	meta: {
+		name: "preview",
+		description: "Start a local server to preview the built server"
+	},
+	args: {
+		...commonArgs,
+		port: {
+			type: "string",
+			description: "specify port"
+		},
+		host: {
+			type: "string",
+			description: "specify hostname"
+		}
+	},
+	async run({ args }) {
+		const rootDir = resolve(args.dir || args._dir || ".");
+		const server = serve({
+			fetch(req) {
+				return preview.fetch(req);
+			},
+			middleware: [log()],
+			gracefulShutdown: false,
+			port: args.port,
+			hostname: args.host
+		});
+		const preview = await startPreview({
+			rootDir,
+			loader: { srvxServer: server }
+		});
+		if (preview.upgrade) server.node?.server?.on("upgrade", (req, socket, head) => {
+			preview.upgrade(req, socket, head);
+		});
+		process.on("SIGINT", async () => {
+			await server.close();
+			await preview.close();
+			process.exit(0);
+		});
+	}
+});
+//#endregion
+export { preview_default as default };

package/dist/cli/_chunks/run.mjs

@@ -0,0 +1,53 @@
+import { dt as resolve } from "../../_build/common.mjs";
+import { t as defineCommand } from "../../_libs/citty.mjs";
+import { consola as consola$1 } from "consola";
+import destr from "destr";
+import { loadOptions, runTask } from "nitro/builder";
+//#region src/cli/commands/task/run.ts
+var run_default = 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$1.info(`Running task \`${args.name}\`...`);
+		let payload = destr(args.payload || "{}");
+		if (typeof payload !== "object") {
+			consola$1.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$1.success("Result:", result);
+		} catch (error) {
+			consola$1.error(`Failed to run task \`${args.name}\`: ${error}`);
+			process.exit(1);
+		}
+	}
+});
+//#endregion
+export { run_default as default };

package/dist/cli/_chunks/task.mjs

@@ -0,0 +1,14 @@
+import { t as defineCommand } from "../../_libs/citty.mjs";
+//#region src/cli/commands/task/index.ts
+var task_default = 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)
+	}
+});
+//#endregion
+export { task_default as default };

package/dist/cli/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli/index.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { n as runMain, t as defineCommand } from "../_libs/citty.mjs";
+import { version } from "nitro/meta";
+//#region src/cli/index.ts
+runMain(defineCommand({
+	meta: {
+		name: "nitro",
+		description: "Nitro CLI",
+		version
+	},
+	subCommands: {
+		dev: () => import("./_chunks/dev.mjs").then((r) => r.default),
+		build: () => import("./_chunks/build.mjs").then((r) => r.default),
+		deploy: () => import("./_chunks/deploy.mjs").then((r) => r.default),
+		prepare: () => import("./_chunks/prepare.mjs").then((r) => r.default),
+		task: () => import("./_chunks/task.mjs").then((r) => r.default),
+		preview: () => import("./_chunks/preview.mjs").then((r) => r.default),
+		docs: () => import("./_chunks/docs.mjs").then((r) => r.default)
+	}
+}));
+//#endregion
+export {};

package/dist/node_modules/@poppinss/colors/build/index.js

@@ -0,0 +1,139 @@
+import kleur from "kleur";
+var Colors = class {
+	black(text) {
+		return this.transform("black", text);
+	}
+	red(text) {
+		return this.transform("red", text);
+	}
+	green(text) {
+		return this.transform("green", text);
+	}
+	yellow(text) {
+		return this.transform("yellow", text);
+	}
+	blue(text) {
+		return this.transform("blue", text);
+	}
+	magenta(text) {
+		return this.transform("magenta", text);
+	}
+	cyan(text) {
+		return this.transform("cyan", text);
+	}
+	white(text) {
+		return this.transform("white", text);
+	}
+	gray(text) {
+		return this.transform("gray", text);
+	}
+	grey(text) {
+		return this.transform("grey", text);
+	}
+	bgBlack(text) {
+		return this.transform("bgBlack", text);
+	}
+	bgRed(text) {
+		return this.transform("bgRed", text);
+	}
+	bgGreen(text) {
+		return this.transform("bgGreen", text);
+	}
+	bgYellow(text) {
+		return this.transform("bgYellow", text);
+	}
+	bgBlue(text) {
+		return this.transform("bgBlue", text);
+	}
+	bgMagenta(text) {
+		return this.transform("bgMagenta", text);
+	}
+	bgCyan(text) {
+		return this.transform("bgCyan", text);
+	}
+	bgWhite(text) {
+		return this.transform("bgWhite", text);
+	}
+	reset(text) {
+		return this.transform("reset", text);
+	}
+	bold(text) {
+		return this.transform("bold", text);
+	}
+	dim(text) {
+		return this.transform("dim", text);
+	}
+	italic(text) {
+		return this.transform("italic", text);
+	}
+	underline(text) {
+		return this.transform("underline", text);
+	}
+	inverse(text) {
+		return this.transform("inverse", text);
+	}
+	hidden(text) {
+		return this.transform("hidden", text);
+	}
+	strikethrough(text) {
+		return this.transform("strikethrough", text);
+	}
+};
+var Raw = class extends Colors {
+	#transformations = [];
+	#dispose(value, callback) {
+		callback();
+		return value;
+	}
+	transform(transformation, text) {
+		this.#transformations.push(transformation);
+		if (text !== void 0) {
+			const transformations = this.#transformations.concat([text]).join("(");
+			const closingWrapping = new Array(this.#transformations.length + 1).join(")");
+			return this.#dispose(`${transformations}${closingWrapping}`, () => {
+				this.#transformations = [];
+			});
+		}
+		return this;
+	}
+};
+var Kleur = class extends Colors {
+	#chain;
+	constructor() {
+		super();
+		kleur.enabled = true;
+	}
+	#dispose(value, callback) {
+		callback();
+		return value;
+	}
+	transform(transformation, text) {
+		if (text !== void 0) {
+			if (this.#chain) return this.#dispose(this.#chain[transformation](text), () => {
+				this.#chain = void 0;
+			});
+			return kleur[transformation](text);
+		}
+		if (this.#chain) this.#chain = this.#chain[transformation]();
+		else this.#chain = kleur[transformation]();
+		return this;
+	}
+};
+var Silent = class extends Colors {
+	transform(_, text) {
+		if (text !== void 0) return String(text);
+		return this;
+	}
+};
+var colors_default = {
+	ansi() {
+		return new Kleur();
+	},
+	silent() {
+		return new Silent();
+	},
+	raw() {
+		return new Raw();
+	}
+};
+export { colors_default as default };