nitro 3.0.0 → 3.0.1-alpha.1

package/dist/_chunks/BX9-zVkM.mjs

@@ -0,0 +1,59 @@
+import { O as relative, k as resolve, x as dirname } from "../_libs/c12.mjs";
+import { t as glob } from "../_libs/tinyglobby.mjs";
+import { r as a } from "../_libs/std-env.mjs";
+import { t as runParallel } from "./ANM1K1bE.mjs";
+import { t as gzipSize } from "../_libs/gzip-size.mjs";
+import { t as prettyBytes } from "../_libs/pretty-bytes.mjs";
+import { promises } from "node:fs";
+import { colors } from "consola/utils";
+
+//#region src/utils/fs-tree.ts
+async function generateFSTree(dir, options = {}) {
+	if (a) return;
+	const files = await glob("**/*.*", {
+		cwd: dir,
+		ignore: ["*.map"]
+	});
+	const items = [];
+	await runParallel(new Set(files), async (file) => {
+		const path = resolve(dir, file);
+		const src = await promises.readFile(path);
+		const size = src.byteLength;
+		const gzip = options.compressedSizes ? await gzipSize(src) : 0;
+		items.push({
+			file,
+			path,
+			size,
+			gzip
+		});
+	}, { concurrency: 10 });
+	items.sort((a$1, b) => a$1.path.localeCompare(b.path));
+	let totalSize = 0;
+	let totalGzip = 0;
+	let totalNodeModulesSize = 0;
+	let totalNodeModulesGzip = 0;
+	let treeText = "";
+	for (const [index, item] of items.entries()) {
+		let dir$1 = dirname(item.file);
+		if (dir$1 === ".") dir$1 = "";
+		const rpath = relative(process.cwd(), item.path);
+		const treeChar = index === items.length - 1 ? "└─" : "├─";
+		if (item.file.includes("node_modules")) {
+			totalNodeModulesSize += item.size;
+			totalNodeModulesGzip += item.gzip;
+			continue;
+		}
+		treeText += colors.gray(`  ${treeChar} ${rpath} (${prettyBytes(item.size)})`);
+		if (options.compressedSizes) treeText += colors.gray(` (${prettyBytes(item.gzip)} gzip)`);
+		treeText += "\n";
+		totalSize += item.size;
+		totalGzip += item.gzip;
+	}
+	treeText += `${colors.cyan("Σ Total size:")} ${prettyBytes(totalSize + totalNodeModulesSize)}`;
+	if (options.compressedSizes) treeText += ` (${prettyBytes(totalGzip + totalNodeModulesGzip)} gzip)`;
+	treeText += "\n";
+	return treeText;
+}
+
+//#endregion
+export { generateFSTree as t };

package/dist/_chunks/Bqks5huO.mjs

@@ -0,0 +1,31 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toDynamicImportESM = (isNodeMode) => (mod) => __toESM(mod.default, isNodeMode);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __toESM as i, __require as n, __toDynamicImportESM as r, __commonJS as t };

package/dist/_chunks/C7CbzoI1.mjs

@@ -0,0 +1,39 @@
+import { O as relative, k as resolve, x as dirname } from "../_libs/c12.mjs";
+import { t as getProperty } from "../_libs/dot-prop.mjs";
+import consola$1 from "consola";
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import { colors } from "consola/utils";
+
+//#region src/utils/fs.ts
+function prettyPath(p, highlight = true) {
+	p = relative(process.cwd(), p);
+	return highlight ? colors.cyan(p) : p;
+}
+function resolveNitroPath(path, nitroOptions, base) {
+	if (typeof path !== "string") throw new TypeError("Invalid path: " + path);
+	path = _compilePathTemplate(path)(nitroOptions);
+	for (const base$1 in nitroOptions.alias) if (path.startsWith(base$1)) path = nitroOptions.alias[base$1] + path.slice(base$1.length);
+	return resolve(base || nitroOptions.rootDir, path);
+}
+function _compilePathTemplate(contents) {
+	return (params) => contents.replace(/{{ ?([\w.]+) ?}}/g, (_, match) => {
+		const val = getProperty(params, match);
+		if (!val) consola$1.warn(`cannot resolve template param '${match}' in ${contents.slice(0, 20)}`);
+		return val || `${match}`;
+	});
+}
+async function writeFile$1(file, contents, log = false) {
+	await mkdir(dirname(file), { recursive: true });
+	await writeFile(file, contents, typeof contents === "string" ? "utf8" : void 0);
+	if (log) consola$1.info("Generated", prettyPath(file));
+}
+async function isDirectory(path) {
+	try {
+		return (await stat(path)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+export { writeFile$1 as i, prettyPath as n, resolveNitroPath as r, isDirectory as t };

package/dist/_dev.d.mts

@@ -0,0 +1,12 @@
+import { HTTPHandler } from "h3";
+import { Nitro } from "nitro/types";
+
+//#region src/dev/app.d.ts
+declare class NitroDevApp {
+  #private;
+  nitro: Nitro;
+  fetch: (req: Request) => Response | Promise<Response>;
+  constructor(nitro: Nitro, catchAllHandler?: HTTPHandler);
+}
+//#endregion
+export { NitroDevApp as t };