nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-122334-09c1a7a8

package/dist/runtime/internal/shutdown.d.mts

@@ -1,8 +1,3 @@
 import type { Server as HttpServer } from "node:http";
-export declare function getGracefulShutdownConfig(): {
-    disabled: boolean;
-    signals: string[];
-    timeout: number;
-    forceExit: boolean;
-};
-export declare function setupGracefulShutdown(listener: HttpServer): void;
+export declare function getGracefulShutdownConfig(): {};
+export declare function setupGracefulShutdown(listener: HttpServer);

package/dist/runtime/internal/shutdown.mjs

@@ -1,35 +1,36 @@
 import gracefulShutdown from "./lib/http-graceful-shutdown.mjs";
 import { useNitroHooks } from "./app.mjs";
 export function getGracefulShutdownConfig() {
-  return {
-    disabled: !!process.env.NITRO_SHUTDOWN_DISABLED,
-    signals: (process.env.NITRO_SHUTDOWN_SIGNALS || "SIGTERM SIGINT").split(" ").map((s) => s.trim()),
-    timeout: Number.parseInt(process.env.NITRO_SHUTDOWN_TIMEOUT || "", 10) || 3e4,
-    forceExit: !process.env.NITRO_SHUTDOWN_NO_FORCE_EXIT
-  };
+	return {
+		disabled: !!process.env.NITRO_SHUTDOWN_DISABLED,
+		signals: (process.env.NITRO_SHUTDOWN_SIGNALS || "SIGTERM SIGINT").split(" ").map((s) => s.trim()),
+		timeout: Number.parseInt(process.env.NITRO_SHUTDOWN_TIMEOUT || "", 10) || 3e4,
+		forceExit: !process.env.NITRO_SHUTDOWN_NO_FORCE_EXIT
+	};
 }
 export function setupGracefulShutdown(listener) {
-  const shutdownConfig = getGracefulShutdownConfig();
-  if (shutdownConfig.disabled) {
-    return;
-  }
-  gracefulShutdown(listener, {
-    signals: shutdownConfig.signals.join(" "),
-    timeout: shutdownConfig.timeout,
-    forceExit: shutdownConfig.forceExit,
-    onShutdown: async () => {
-      await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-          console.warn("Graceful shutdown timeout, force exiting...");
-          resolve();
-        }, shutdownConfig.timeout);
-        Promise.resolve(useNitroHooks().callHook("close")).catch((error) => {
-          console.error(error);
-        }).finally(() => {
-          clearTimeout(timeout);
-          resolve();
-        });
-      });
-    }
-  });
+	const shutdownConfig = getGracefulShutdownConfig();
+	if (shutdownConfig.disabled) {
+		return;
+	}
+	// https://github.com/sebhildebrandt/http-graceful-shutdown
+	gracefulShutdown(listener, {
+		signals: shutdownConfig.signals.join(" "),
+		timeout: shutdownConfig.timeout,
+		forceExit: shutdownConfig.forceExit,
+		onShutdown: async () => {
+			await new Promise((resolve) => {
+				const timeout = setTimeout(() => {
+					console.warn("Graceful shutdown timeout, force exiting...");
+					resolve();
+				}, shutdownConfig.timeout);
+				Promise.resolve(useNitroHooks().callHook("close")).catch((error) => {
+					console.error(error);
+				}).finally(() => {
+					clearTimeout(timeout);
+					resolve();
+				});
+			});
+		}
+	});
 }

package/dist/runtime/internal/static.mjs

@@ -1,77 +1,66 @@
 import { HTTPError, defineHandler } from "h3";
-import {
-  decodePath,
-  joinURL,
-  withLeadingSlash,
-  withoutTrailingSlash
-} from "ufo";
-import {
-  getAsset,
-  isPublicAssetURL,
-  readAsset
-} from "#nitro-internal-virtual/public-assets";
-const METHODS = /* @__PURE__ */ new Set(["HEAD", "GET"]);
-const EncodingMap = { gzip: ".gz", br: ".br" };
+import { decodePath, joinURL, withLeadingSlash, withoutTrailingSlash } from "ufo";
+import { getAsset, isPublicAssetURL, readAsset } from "#nitro-internal-virtual/public-assets";
+const METHODS = new Set(["HEAD", "GET"]);
+const EncodingMap = {
+	gzip: ".gz",
+	br: ".br"
+};
 export default defineHandler((event) => {
-  if (event.req.method && !METHODS.has(event.req.method)) {
-    return;
-  }
-  let id = decodePath(
-    withLeadingSlash(withoutTrailingSlash(event.url.pathname))
-  );
-  let asset;
-  const encodingHeader = event.req.headers.get("accept-encoding") || "";
-  const encodings = [
-    ...encodingHeader.split(",").map((e) => EncodingMap[e.trim()]).filter(Boolean).sort(),
-    ""
-  ];
-  if (encodings.length > 1) {
-    event.res.headers.append("Vary", "Accept-Encoding");
-  }
-  for (const encoding of encodings) {
-    for (const _id of [id + encoding, joinURL(id, "index.html" + encoding)]) {
-      const _asset = getAsset(_id);
-      if (_asset) {
-        asset = _asset;
-        id = _id;
-        break;
-      }
-    }
-  }
-  if (!asset) {
-    if (isPublicAssetURL(id)) {
-      event.res.headers.delete("Cache-Control");
-      throw new HTTPError({ status: 404 });
-    }
-    return;
-  }
-  const ifNotMatch = event.req.headers.get("if-none-match") === asset.etag;
-  if (ifNotMatch) {
-    event.res.status = 304;
-    event.res.statusText = "Not Modified";
-    return "";
-  }
-  const ifModifiedSinceH = event.req.headers.get("if-modified-since");
-  const mtimeDate = new Date(asset.mtime);
-  if (ifModifiedSinceH && asset.mtime && new Date(ifModifiedSinceH) >= mtimeDate) {
-    event.res.status = 304;
-    event.res.statusText = "Not Modified";
-    return "";
-  }
-  if (asset.type) {
-    event.res.headers.set("Content-Type", asset.type);
-  }
-  if (asset.etag && !event.res.headers.has("ETag")) {
-    event.res.headers.set("ETag", asset.etag);
-  }
-  if (asset.mtime && !event.res.headers.has("Last-Modified")) {
-    event.res.headers.set("Last-Modified", mtimeDate.toUTCString());
-  }
-  if (asset.encoding && !event.res.headers.has("Content-Encoding")) {
-    event.res.headers.set("Content-Encoding", asset.encoding);
-  }
-  if (asset.size > 0 && !event.res.headers.has("Content-Length")) {
-    event.res.headers.set("Content-Length", asset.size.toString());
-  }
-  return readAsset(id);
+	if (event.req.method && !METHODS.has(event.req.method)) {
+		return;
+	}
+	let id = decodePath(withLeadingSlash(withoutTrailingSlash(event.url.pathname)));
+	let asset;
+	const encodingHeader = event.req.headers.get("accept-encoding") || "";
+	const encodings = [...encodingHeader.split(",").map((e) => EncodingMap[e.trim()]).filter(Boolean).sort(), ""];
+	if (encodings.length > 1) {
+		event.res.headers.append("Vary", "Accept-Encoding");
+	}
+	for (const encoding of encodings) {
+		for (const _id of [id + encoding, joinURL(id, "index.html" + encoding)]) {
+			const _asset = getAsset(_id);
+			if (_asset) {
+				asset = _asset;
+				id = _id;
+				break;
+			}
+		}
+	}
+	if (!asset) {
+		if (isPublicAssetURL(id)) {
+			event.res.headers.delete("Cache-Control");
+			throw new HTTPError({ status: 404 });
+		}
+		return;
+	}
+	const ifNotMatch = event.req.headers.get("if-none-match") === asset.etag;
+	if (ifNotMatch) {
+		event.res.status = 304;
+		event.res.statusText = "Not Modified";
+		return "";
+	}
+	const ifModifiedSinceH = event.req.headers.get("if-modified-since");
+	const mtimeDate = new Date(asset.mtime);
+	if (ifModifiedSinceH && asset.mtime && new Date(ifModifiedSinceH) >= mtimeDate) {
+		event.res.status = 304;
+		event.res.statusText = "Not Modified";
+		return "";
+	}
+	if (asset.type) {
+		event.res.headers.set("Content-Type", asset.type);
+	}
+	if (asset.etag && !event.res.headers.has("ETag")) {
+		event.res.headers.set("ETag", asset.etag);
+	}
+	if (asset.mtime && !event.res.headers.has("Last-Modified")) {
+		event.res.headers.set("Last-Modified", mtimeDate.toUTCString());
+	}
+	if (asset.encoding && !event.res.headers.has("Content-Encoding")) {
+		event.res.headers.set("Content-Encoding", asset.encoding);
+	}
+	if (asset.size > 0 && !event.res.headers.has("Content-Length")) {
+		event.res.headers.set("Content-Length", asset.size.toString());
+	}
+	return readAsset(id);
 });

package/dist/runtime/internal/storage.mjs

@@ -1,6 +1,6 @@
 import { prefixStorage } from "unstorage";
 import { initStorage } from "#nitro-internal-virtual/storage";
 export function useStorage(base = "") {
-  const storage = useStorage._storage ??= initStorage();
-  return base ? prefixStorage(storage, base) : storage;
+	const storage = useStorage._storage ??= initStorage();
+	return base ? prefixStorage(storage, base) : storage;
 }

package/dist/runtime/internal/task.d.mts

@@ -2,16 +2,16 @@ import type { Task, TaskContext, TaskPayload, TaskResult } from "nitro/types";
 /** @experimental */
 export declare function defineTask<RT = unknown>(def: Task<RT>): Task<RT>;
 /** @experimental */
-export declare function runTask<RT = unknown>(name: string, { payload, context, }?: {
-    payload?: TaskPayload;
-    context?: TaskContext;
+export declare function runTask<RT = unknown>(name: string, { payload, context }?: {
+	payload?: TaskPayload;
+	context?: TaskContext;
 }): Promise<TaskResult<RT>>;
 /** @experimental */
-export declare function startScheduleRunner(): void;
+export declare function startScheduleRunner();
 /** @experimental */
 export declare function getCronTasks(cron: string): string[];
 /** @experimental */
 export declare function runCronTasks(cron: string, ctx: {
-    payload?: TaskPayload;
-    context?: TaskContext;
+	payload?: TaskPayload;
+	context?: TaskContext;
 }): Promise<TaskResult[]>;

package/dist/runtime/internal/task.mjs

@@ -1,72 +1,69 @@
 import { Cron } from "croner";
 import { HTTPError } from "h3";
 import { scheduledTasks, tasks } from "#nitro-internal-virtual/tasks";
+/** @experimental */
 export function defineTask(def) {
-  if (typeof def.run !== "function") {
-    def.run = () => {
-      throw new TypeError("Task must implement a `run` method!");
-    };
-  }
-  return def;
+	if (typeof def.run !== "function") {
+		def.run = () => {
+			throw new TypeError("Task must implement a `run` method!");
+		};
+	}
+	return def;
 }
 const __runningTasks__ = {};
-export async function runTask(name, {
-  payload = {},
-  context = {}
-} = {}) {
-  if (__runningTasks__[name]) {
-    return __runningTasks__[name];
-  }
-  if (!(name in tasks)) {
-    throw new HTTPError({
-      message: `Task \`${name}\` is not available!`,
-      status: 404
-    });
-  }
-  if (!tasks[name].resolve) {
-    throw new HTTPError({
-      message: `Task \`${name}\` is not implemented!`,
-      status: 501
-    });
-  }
-  const handler = await tasks[name].resolve();
-  const taskEvent = { name, payload, context };
-  __runningTasks__[name] = handler.run(taskEvent);
-  try {
-    const res = await __runningTasks__[name];
-    return res;
-  } finally {
-    delete __runningTasks__[name];
-  }
+/** @experimental */
+export async function runTask(name, { payload = {}, context = {} } = {}) {
+	if (__runningTasks__[name]) {
+		return __runningTasks__[name];
+	}
+	if (!(name in tasks)) {
+		throw new HTTPError({
+			message: `Task \`${name}\` is not available!`,
+			status: 404
+		});
+	}
+	if (!tasks[name].resolve) {
+		throw new HTTPError({
+			message: `Task \`${name}\` is not implemented!`,
+			status: 501
+		});
+	}
+	const handler = await tasks[name].resolve();
+	const taskEvent = {
+		name,
+		payload,
+		context
+	};
+	__runningTasks__[name] = handler.run(taskEvent);
+	try {
+		const res = await __runningTasks__[name];
+		return res;
+	} finally {
+		delete __runningTasks__[name];
+	}
 }
+/** @experimental */
 export function startScheduleRunner() {
-  if (!scheduledTasks || scheduledTasks.length === 0 || process.env.TEST) {
-    return;
-  }
-  const payload = {
-    scheduledTime: Date.now()
-  };
-  for (const schedule of scheduledTasks) {
-    const cron = new Cron(schedule.cron, async () => {
-      await Promise.all(
-        schedule.tasks.map(
-          (name) => runTask(name, {
-            payload,
-            context: {}
-          }).catch((error) => {
-            console.error(
-              `Error while running scheduled task "${name}"`,
-              error
-            );
-          })
-        )
-      );
-    });
-  }
+	if (!scheduledTasks || scheduledTasks.length === 0 || process.env.TEST) {
+		return;
+	}
+	const payload = { scheduledTime: Date.now() };
+	for (const schedule of scheduledTasks) {
+		const cron = new Cron(schedule.cron, async () => {
+			await Promise.all(schedule.tasks.map((name) => runTask(name, {
+				payload,
+				context: {}
+			}).catch((error) => {
+				console.error(`Error while running scheduled task "${name}"`, error);
+			})));
+		});
+	}
 }
+/** @experimental */
 export function getCronTasks(cron) {
-  return (scheduledTasks || []).find((task) => task.cron === cron)?.tasks || [];
+	return (scheduledTasks || []).find((task) => task.cron === cron)?.tasks || [];
 }
+/** @experimental */
 export function runCronTasks(cron, ctx) {
-  return Promise.all(getCronTasks(cron).map((name) => runTask(name, ctx)));
+	return Promise.all(getCronTasks(cron).map((name) => runTask(name, ctx)));
 }

package/dist/runtime/internal/utils.d.mts

@@ -1 +1 @@
-export declare function trapUnhandledNodeErrors(): void;
+export declare function trapUnhandledNodeErrors();

package/dist/runtime/internal/utils.mjs

@@ -1,15 +1,9 @@
 import { useNitroApp } from "./app.mjs";
 function _captureError(error, type) {
-  console.error(`[${type}]`, error);
-  useNitroApp().captureError(error, { tags: [type] });
+	console.error(`[${type}]`, error);
+	useNitroApp().captureError(error, { tags: [type] });
 }
 export function trapUnhandledNodeErrors() {
-  process.on(
-    "unhandledRejection",
-    (error) => _captureError(error, "unhandledRejection")
-  );
-  process.on(
-    "uncaughtException",
-    (error) => _captureError(error, "uncaughtException")
-  );
+	process.on("unhandledRejection", (error) => _captureError(error, "unhandledRejection"));
+	process.on("uncaughtException", (error) => _captureError(error, "uncaughtException"));
 }