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

package/dist/_chunks/server.mjs

@@ -1,254 +0,0 @@
-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

@@ -1,376 +0,0 @@
-import { promises } from 'node:fs';
-import { m as mime, b as glob, c as snapshotStorage } from './index.mjs';
-import { e as extname, r as resolve, d as dirname, a as relative, j as join } from './pathe.M-eThtNZ.mjs';
-import { upperFirst } from 'scule';
-import { colors } from 'consola/utils';
-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 { mkdir, writeFile } from 'node:fs/promises';
-
-const HELPER_ID = "\0raw-helpers";
-function raw(opts = {}) {
-  const extensions = /* @__PURE__ */ new Set([
-    ".md",
-    ".mdx",
-    ".txt",
-    ".css",
-    ".htm",
-    ".html",
-    ".sql",
-    ...opts.extensions || []
-  ]);
-  return {
-    name: "raw",
-    async resolveId(id, importer, resolveOpts) {
-      if (id === HELPER_ID) {
-        return id;
-      }
-      if (id[0] === "\0") {
-        return;
-      }
-      const withRawSpecifier = id.startsWith("raw:");
-      if (withRawSpecifier) {
-        id = id.slice(4);
-      }
-      if (!withRawSpecifier && !extensions.has(extname(id))) {
-        return;
-      }
-      const resolvedId = (await this.resolve(id, importer, resolveOpts))?.id;
-      if (!resolvedId || resolvedId.startsWith("\0")) {
-        return resolvedId;
-      }
-      if (!withRawSpecifier && !extensions.has(extname(resolvedId))) {
-        return;
-      }
-      return { id: "\0raw:" + resolvedId };
-    },
-    load(id) {
-      if (id === HELPER_ID) {
-        return getHelpers();
-      }
-      if (id.startsWith("\0raw:")) {
-        return promises.readFile(id.slice(5), isBinary(id) ? "binary" : "utf8");
-      }
-    },
-    transform(code, id) {
-      if (!id.startsWith("\0raw:")) {
-        return;
-      }
-      if (isBinary(id)) {
-        const serialized = Buffer.from(code, "binary").toString("base64");
-        return {
-          code: `// ROLLUP_NO_REPLACE 
- import {base64ToUint8Array } from "${HELPER_ID}" 
- export default base64ToUint8Array("${serialized}")`,
-          map: null
-        };
-      }
-      return {
-        code: `// ROLLUP_NO_REPLACE 
- export default ${JSON.stringify(code)}`,
-        map: null,
-        moduleType: "js"
-      };
-    }
-  };
-}
-function isBinary(id) {
-  const idMime = mime.getType(id) || "";
-  if (idMime.startsWith("text/")) {
-    return false;
-  }
-  if (/application\/(json|sql|xml|yaml)/.test(idMime)) {
-    return false;
-  }
-  return true;
-}
-function getHelpers() {
-  const js = String.raw;
-  return js`
-export function base64ToUint8Array(str) {
-  const data = atob(str);
-  const size = data.length;
-  const bytes = new Uint8Array(size);
-  for (let i = 0; i < size; i++) {
-    bytes[i] = data.charCodeAt(i);
-  }
-  return bytes;
-}
-  `;
-}
-
-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, raw as r, snapshot as s };