nitro 2.2.27 → 3.0.0

package/dist/_chunks/server.mjs

@@ -0,0 +1,254 @@
+import { N as NitroDevApp, d as debounce, w as watch, a as NodeDevWorker } from './app.mjs';
+import { HTTPError } from 'h3';
+import { version } from 'nitro/meta';
+import consola from 'consola';
+import { writeFile } from 'node:fs/promises';
+import { serve } from 'srvx/node';
+import { isTest, isCI } from 'std-env';
+import { r as resolve } from './pathe.M-eThtNZ.mjs';
+
+function createDevServer(nitro) {
+  return new NitroDevServer(nitro);
+}
+class NitroDevServer extends NitroDevApp {
+  #entry;
+  #workerData = {};
+  #listeners = [];
+  #watcher;
+  #workers = [];
+  #workerIdCtr = 0;
+  #workerError;
+  #building = true;
+  // Assume initial build will start soon
+  #buildError;
+  #messageListeners = /* @__PURE__ */ new Set();
+  constructor(nitro) {
+    super(nitro, async (event) => {
+      const worker = await this.#getWorker();
+      if (!worker) {
+        return this.#generateError();
+      }
+      return worker.fetch(event.req);
+    });
+    for (const key of Object.getOwnPropertyNames(NitroDevServer.prototype)) {
+      const value = this[key];
+      if (typeof value === "function" && key !== "constructor") {
+        this[key] = value.bind(this);
+      }
+    }
+    this.#entry = resolve(
+      nitro.options.output.dir,
+      nitro.options.output.serverDir,
+      "index.mjs"
+    );
+    nitro.hooks.hook("close", () => this.close());
+    nitro.hooks.hook("dev:start", () => {
+      this.#building = true;
+      this.#buildError = void 0;
+    });
+    nitro.hooks.hook("dev:reload", (payload) => {
+      this.#buildError = void 0;
+      this.#building = false;
+      if (payload?.entry) {
+        this.#entry = payload.entry;
+      }
+      if (payload?.workerData) {
+        this.#workerData = payload.workerData;
+      }
+      this.reload();
+    });
+    nitro.hooks.hook("dev:error", (cause) => {
+      this.#buildError = cause;
+      this.#building = false;
+      for (const worker of this.#workers) {
+        worker.close();
+      }
+    });
+    if (nitro.options.devServer.watch.length > 0) {
+      const debouncedReload = debounce(() => this.reload());
+      this.#watcher = watch(
+        nitro.options.devServer.watch,
+        nitro.options.watchOptions
+      );
+      this.#watcher.on("add", debouncedReload).on("change", debouncedReload);
+    }
+  }
+  // #region Public Methods
+  async upgrade(req, socket, head) {
+    const worker = await this.#getWorker();
+    if (!worker) {
+      throw new HTTPError({
+        status: 503,
+        statusText: "No worker available."
+      });
+    }
+    return worker.upgrade(req, socket, head);
+  }
+  listen(opts) {
+    const server = serve({
+      ...opts,
+      fetch: this.fetch
+    });
+    this.#listeners.push(server);
+    if (server.node?.server) {
+      server.node.server.on(
+        "upgrade",
+        (req, sock, head) => this.upgrade(req, sock, head)
+      );
+    }
+    return server;
+  }
+  async close() {
+    await Promise.all(
+      [
+        Promise.all(this.#listeners.map((l) => l.close())).then(() => {
+          this.#listeners = [];
+        }),
+        Promise.all(this.#workers.map((w) => w.close())).then(() => {
+          this.#workers = [];
+        }),
+        Promise.resolve(this.#watcher?.close()).then(() => {
+          this.#watcher = void 0;
+        })
+      ].map(
+        (p) => p.catch((error) => {
+          consola.error(error);
+        })
+      )
+    );
+  }
+  reload() {
+    for (const worker2 of this.#workers) {
+      worker2.close();
+    }
+    const worker = new NodeDevWorker({
+      name: `Nitro_${this.#workerIdCtr++}`,
+      entry: this.#entry,
+      data: {
+        ...this.#workerData,
+        globals: {
+          __NITRO_RUNTIME_CONFIG__: this.nitro.options.runtimeConfig,
+          ...this.#workerData.globals
+        }
+      },
+      hooks: {
+        onClose: (worker2, cause) => {
+          this.#workerError = cause;
+          const index = this.#workers.indexOf(worker2);
+          if (index !== -1) {
+            this.#workers.splice(index, 1);
+          }
+        },
+        onReady: (worker2, addr) => {
+          this.#writeBuildInfo(worker2, addr);
+        }
+      }
+    });
+    if (!worker.closed) {
+      for (const listener of this.#messageListeners) {
+        worker.onMessage(listener);
+      }
+      this.#workers.unshift(worker);
+    }
+  }
+  sendMessage(message) {
+    for (const worker of this.#workers) {
+      if (!worker.closed) {
+        worker.sendMessage(message);
+      }
+    }
+  }
+  onMessage(listener) {
+    this.#messageListeners.add(listener);
+    for (const worker of this.#workers) {
+      worker.onMessage(listener);
+    }
+  }
+  offMessage(listener) {
+    this.#messageListeners.delete(listener);
+    for (const worker of this.#workers) {
+      worker.offMessage(listener);
+    }
+  }
+  // #endregion
+  // #region Private Methods
+  #writeBuildInfo(_worker, addr) {
+    const buildInfoPath = resolve(this.nitro.options.buildDir, "nitro.json");
+    const buildInfo = {
+      date: (/* @__PURE__ */ new Date()).toJSON(),
+      preset: this.nitro.options.preset,
+      framework: this.nitro.options.framework,
+      versions: {
+        nitro: version
+      },
+      dev: {
+        pid: process.pid,
+        workerAddress: addr
+      }
+    };
+    writeFile(buildInfoPath, JSON.stringify(buildInfo, null, 2)).catch(
+      (error) => {
+        consola.error(error);
+      }
+    );
+  }
+  async #getWorker() {
+    let retry = 0;
+    const maxRetries = isTest || isCI ? 100 : 10;
+    while (this.#building || ++retry < maxRetries) {
+      if ((this.#workers.length === 0 || this.#buildError) && !this.#building) {
+        return;
+      }
+      const activeWorker = this.#workers.find((w) => w.ready);
+      if (activeWorker) {
+        return activeWorker;
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, 600));
+    }
+  }
+  #generateError() {
+    const error = this.#buildError || this.#workerError;
+    if (error) {
+      try {
+        error.unhandled = false;
+        let id = error.id || error.path;
+        if (id) {
+          const cause = error.errors?.[0];
+          const loc = error.location || error.loc || cause?.location || cause?.loc;
+          if (loc) {
+            id += `:${loc.line}:${loc.column}`;
+          }
+          error.stack = (error.stack || "").replace(
+            /(^\s*at\s+.+)/m,
+            `    at ${id}
+$1`
+          );
+        }
+      } catch {
+      }
+      return new HTTPError(error);
+    }
+    return new Response(
+      JSON.stringify(
+        {
+          error: "Dev server is unavailable.",
+          hint: "Please reload the page and check the console for errors if the issue persists."
+        },
+        null,
+        2
+      ),
+      {
+        status: 503,
+        statusText: "Dev server is unavailable",
+        headers: {
+          "Content-Type": "application/json",
+          "Cache-Control": "no-store",
+          Refresh: "3"
+        }
+      }
+    );
+  }
+  // #endregion
+}
+
+export { NitroDevServer as N, createDevServer as c };

package/dist/_chunks/snapshot.mjs

@@ -0,0 +1,284 @@
+import { upperFirst } from 'scule';
+import { promises } from 'node:fs';
+import { colors } from 'consola/utils';
+import { b as glob, c as snapshotStorage } from './index.mjs';
+import 'node:stream';
+import zlib from 'node:zlib';
+import { promisify } from 'node:util';
+import 'stream';
+import { isTest } from 'std-env';
+import { r as runParallel } from './index3.mjs';
+import { r as resolve, d as dirname, a as relative, j as join } from './pathe.M-eThtNZ.mjs';
+import { mkdir, writeFile } from 'node:fs/promises';
+
+function nitroServerName(nitro) {
+  return nitro.options.framework.name === "nitro" ? "Nitro Server" : `${upperFirst(nitro.options.framework.name)} Nitro server`;
+}
+
+const getOptions = options => ({level: 9, ...options});
+const gzip = promisify(zlib.gzip);
+
+async function gzipSize(input, options) {
+	if (!input) {
+		return 0;
+	}
+
+	const data = await gzip(input, getOptions(options));
+	return data.length;
+}
+
+const BYTE_UNITS = [
+	'B',
+	'kB',
+	'MB',
+	'GB',
+	'TB',
+	'PB',
+	'EB',
+	'ZB',
+	'YB',
+];
+
+const BIBYTE_UNITS = [
+	'B',
+	'KiB',
+	'MiB',
+	'GiB',
+	'TiB',
+	'PiB',
+	'EiB',
+	'ZiB',
+	'YiB',
+];
+
+const BIT_UNITS = [
+	'b',
+	'kbit',
+	'Mbit',
+	'Gbit',
+	'Tbit',
+	'Pbit',
+	'Ebit',
+	'Zbit',
+	'Ybit',
+];
+
+const BIBIT_UNITS = [
+	'b',
+	'kibit',
+	'Mibit',
+	'Gibit',
+	'Tibit',
+	'Pibit',
+	'Eibit',
+	'Zibit',
+	'Yibit',
+];
+
+/*
+Formats the given number using `Number#toLocaleString`.
+- If locale is a string, the value is expected to be a locale-key (for example: `de`).
+- If locale is true, the system default locale is used for translation.
+- If no value for locale is specified, the number is returned unmodified.
+*/
+const toLocaleString = (number, locale, options) => {
+	let result = number;
+	if (typeof locale === 'string' || Array.isArray(locale)) {
+		result = number.toLocaleString(locale, options);
+	} else if (locale === true || options !== undefined) {
+		result = number.toLocaleString(undefined, options);
+	}
+
+	return result;
+};
+
+const log10 = numberOrBigInt => {
+	if (typeof numberOrBigInt === 'number') {
+		return Math.log10(numberOrBigInt);
+	}
+
+	const string = numberOrBigInt.toString(10);
+
+	return string.length + Math.log10(`0.${string.slice(0, 15)}`);
+};
+
+const log = numberOrBigInt => {
+	if (typeof numberOrBigInt === 'number') {
+		return Math.log(numberOrBigInt);
+	}
+
+	return log10(numberOrBigInt) * Math.log(10);
+};
+
+const divide = (numberOrBigInt, divisor) => {
+	if (typeof numberOrBigInt === 'number') {
+		return numberOrBigInt / divisor;
+	}
+
+	const integerPart = numberOrBigInt / BigInt(divisor);
+	const remainder = numberOrBigInt % BigInt(divisor);
+	return Number(integerPart) + (Number(remainder) / divisor);
+};
+
+const applyFixedWidth = (result, fixedWidth) => {
+	if (fixedWidth === undefined) {
+		return result;
+	}
+
+	if (typeof fixedWidth !== 'number' || !Number.isSafeInteger(fixedWidth) || fixedWidth < 0) {
+		throw new TypeError(`Expected fixedWidth to be a non-negative integer, got ${typeof fixedWidth}: ${fixedWidth}`);
+	}
+
+	if (fixedWidth === 0) {
+		return result;
+	}
+
+	return result.length < fixedWidth ? result.padStart(fixedWidth, ' ') : result;
+};
+
+const buildLocaleOptions = options => {
+	const {minimumFractionDigits, maximumFractionDigits} = options;
+
+	if (minimumFractionDigits === undefined && maximumFractionDigits === undefined) {
+		return undefined;
+	}
+
+	return {
+		...(minimumFractionDigits !== undefined && {minimumFractionDigits}),
+		...(maximumFractionDigits !== undefined && {maximumFractionDigits}),
+		roundingMode: 'trunc',
+	};
+};
+
+function prettyBytes(number, options) {
+	if (typeof number !== 'bigint' && !Number.isFinite(number)) {
+		throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
+	}
+
+	options = {
+		bits: false,
+		binary: false,
+		space: true,
+		nonBreakingSpace: false,
+		...options,
+	};
+
+	const UNITS = options.bits
+		? (options.binary ? BIBIT_UNITS : BIT_UNITS)
+		: (options.binary ? BIBYTE_UNITS : BYTE_UNITS);
+
+	const separator = options.space ? (options.nonBreakingSpace ? '\u00A0' : ' ') : '';
+
+	// Handle signed zero case
+	const isZero = typeof number === 'number' ? number === 0 : number === 0n;
+	if (options.signed && isZero) {
+		const result = ` 0${separator}${UNITS[0]}`;
+		return applyFixedWidth(result, options.fixedWidth);
+	}
+
+	const isNegative = number < 0;
+	const prefix = isNegative ? '-' : (options.signed ? '+' : '');
+
+	if (isNegative) {
+		number = -number;
+	}
+
+	const localeOptions = buildLocaleOptions(options);
+	let result;
+
+	if (number < 1) {
+		const numberString = toLocaleString(number, options.locale, localeOptions);
+		result = prefix + numberString + separator + UNITS[0];
+	} else {
+		const exponent = Math.min(Math.floor(options.binary ? log(number) / Math.log(1024) : log10(number) / 3), UNITS.length - 1);
+		number = divide(number, (options.binary ? 1024 : 1000) ** exponent);
+
+		if (!localeOptions) {
+			const minPrecision = Math.max(3, Math.floor(number).toString().length);
+			number = number.toPrecision(minPrecision);
+		}
+
+		const numberString = toLocaleString(Number(number), options.locale, localeOptions);
+		const unit = UNITS[exponent];
+		result = prefix + numberString + separator + unit;
+	}
+
+	return applyFixedWidth(result, options.fixedWidth);
+}
+
+async function generateFSTree(dir, options = {}) {
+  if (isTest) {
+    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, b) => a.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()) {
+    dirname(item.file);
+    const rpath = relative(process.cwd(), item.path);
+    const treeChar = index === items.length - 1 ? "\u2514\u2500" : "\u251C\u2500";
+    const isNodeModules = item.file.includes("node_modules");
+    if (isNodeModules) {
+      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("\u03A3 Total size:")} ${prettyBytes(
+    totalSize + totalNodeModulesSize
+  )}`;
+  if (options.compressedSizes) {
+    treeText += ` (${prettyBytes(totalGzip + totalNodeModulesGzip)} gzip)`;
+  }
+  treeText += "\n";
+  return treeText;
+}
+
+async function snapshot(nitro) {
+  if (nitro.options.bundledStorage.length === 0 || nitro.options.preset === "nitro-prerender") {
+    return;
+  }
+  const storageDir = resolve(nitro.options.buildDir, "snapshot");
+  nitro.options.serverAssets.push({
+    baseName: "nitro:bundled",
+    dir: storageDir
+  });
+  const data = await snapshotStorage(nitro);
+  await Promise.all(
+    Object.entries(data).map(async ([path, contents]) => {
+      if (typeof contents !== "string") {
+        contents = JSON.stringify(contents);
+      }
+      const fsPath = join(storageDir, path.replace(/:/g, "/"));
+      await mkdir(dirname(fsPath), { recursive: true });
+      await writeFile(fsPath, contents, "utf8");
+    })
+  );
+}
+
+export { generateFSTree as g, nitroServerName as n, snapshot as s };