routup 5.0.0-beta.4 → 5.0.0-beta.6

package/dist/{src-Ck8GklBr.mjs → src-C32sKqPQ.mjs}

@@ -1,6 +1,5 @@
 import { FastURL } from "srvx";
 import { HTTPError, isHTTPError } from "@ebec/http";
-import { Buffer } from "node:buffer";
 import { subtle } from "uncrypto";
 import { merge } from "smob";
 import { compile } from "proxy-addr";
@@ -138,22 +137,7 @@ function sanitizeHeaderValue(value) {
 	return value.replace(/[\r\n]/g, "");
 }
 //#endregion
-//#region src/utils/object.ts
-function isObject(item) {
-	return !!item && typeof item === "object" && !Array.isArray(item);
-}
-//#endregion
 //#region src/utils/etag/module.ts
-/**
-* Determine if object is a Stats object.
-*
-* @param {object} obj
-* @return {boolean}
-* @api private
-*/
-function isStatsObject(obj) {
-	return isObject(obj) && "ctime" in obj && Object.prototype.toString.call(obj.ctime) === "[object Date]" && "mtime" in obj && Object.prototype.toString.call(obj.mtime) === "[object Date]" && "ino" in obj && typeof obj.ino === "number" && "size" in obj && typeof obj.size === "number";
-}
 async function sha1(str) {
 	const enc = new TextEncoder();
 	const hash = await subtle.digest("SHA-1", enc.encode(str));
@@ -163,39 +147,36 @@ async function sha1(str) {
 * Generate an ETag.
 */
 async function generateETag(input) {
-	if (isStatsObject(input)) {
-		const mtime = input.mtime.getTime().toString(16);
-		return `"${input.size.toString(16)}-${mtime}"`;
-	}
 	if (input.length === 0) return "\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"";
-	const entity = Buffer.isBuffer(input) ? input.toString("utf-8") : input;
-	const hash = await sha1(entity);
-	return `"${entity.length.toString(16)}-${hash.substring(0, 27)}"`;
+	const hash = await sha1(input);
+	return `"${input.length.toString(16)}-${hash.substring(0, 27)}"`;
 }
 /**
 * Create a simple ETag.
 */
-async function createEtag(input, options) {
-	options = options || {};
-	const weak = typeof options.weak === "boolean" ? options.weak : isStatsObject(input);
+async function createEtag(input, options = {}) {
 	const tag = await generateETag(input);
-	return weak ? `W/${tag}` : tag;
+	return options.weak ? `W/${tag}` : tag;
+}
+//#endregion
+//#region src/utils/object.ts
+function isObject(item) {
+	return !!item && typeof item === "object" && !Array.isArray(item);
 }
 //#endregion
 //#region src/utils/etag/utils.ts
+const textEncoder = /* @__PURE__ */ new TextEncoder();
 function buildEtagFn(input) {
 	if (typeof input === "function") return input;
 	input = input ?? true;
 	if (input === false) return () => Promise.resolve(void 0);
 	let options = { weak: true };
 	if (isObject(input)) options = merge(input, options);
-	return async (body, encoding, size) => {
-		const buff = Buffer.isBuffer(body) ? body : Buffer.from(body, encoding);
+	return async (body, size) => {
 		if (typeof options.threshold !== "undefined") {
-			size = size ?? Buffer.byteLength(buff);
-			if (size <= options.threshold) return;
+			if ((size ?? textEncoder.encode(body).byteLength) <= options.threshold) return;
 		}
-		return createEtag(buff, options);
+		return createEtag(body, options);
 	};
 }
 //#endregion
@@ -616,6 +597,9 @@ var RoutupEvent = class {
 	signal;
 	_context;
 	_routerOptions;
+	_nextCalled = false;
+	_nextResult;
+	_nextCalledDeferred;
 	constructor(context) {
 		this._context = context;
 		this.request = context.request;
@@ -633,8 +617,32 @@ var RoutupEvent = class {
 		if (!this._routerOptions) this._routerOptions = this._context.routerOptions();
 		return this._routerOptions;
 	}
+	get nextCalled() {
+		return this._nextCalled;
+	}
+	get nextResult() {
+		return this._nextResult;
+	}
+	whenNextCalled() {
+		if (!this._nextCalledDeferred) {
+			let resolve;
+			const promise = new Promise((r) => {
+				resolve = r;
+			});
+			this._nextCalledDeferred = {
+				promise,
+				resolve
+			};
+			if (this._nextCalled) resolve();
+		}
+		return this._nextCalledDeferred.promise;
+	}
 	async next(error) {
-		return this._context.next(this, error);
+		if (this._nextCalled) return this._nextResult;
+		this._nextCalled = true;
+		this._nextResult = this._context.next(this, error);
+		if (this._nextCalledDeferred) this._nextCalledDeferred.resolve();
+		return this._nextResult;
 	}
 };
 //#endregion
@@ -974,11 +982,11 @@ var Handler = class {
 					if (event.error) {
 						const { fn } = this.config;
 						const { error } = event;
-						result = await this.executeWithTimeout(() => fn(error, handlerEvent), handlerEvent.routerOptions, childController);
+						result = await this.executeWithTimeout(() => this.resolveHandlerResult(fn(error, handlerEvent), handlerEvent), handlerEvent.routerOptions, childController);
 					}
 				} else {
 					const { fn } = this.config;
-					result = await this.executeWithTimeout(() => fn(handlerEvent), handlerEvent.routerOptions, childController);
+					result = await this.executeWithTimeout(() => this.resolveHandlerResult(fn(handlerEvent), handlerEvent), handlerEvent.routerOptions, childController);
 				}
 			} finally {
 				if (cleanupParentListener) cleanupParentListener();
@@ -1015,6 +1023,41 @@ var Handler = class {
 		this.config.method = method;
 		this._method = method;
 	}
+	/**
+	* Resolve a handler's return value into the final value handed to `toResponse`.
+	*
+	* Contract:
+	* - non-undefined value → return as-is (becomes the response)
+	* - `undefined` + `event.next()` was called → forward downstream result
+	* - `undefined` + `event.next()` not yet called → wait until either `next()` is
+	*   invoked (e.g. from an async callback) or `signal` aborts. A global or
+	*   per-handler timeout aborts `signal` and surfaces as 408. With no timeout
+	*   configured and no eventual `next()` call, the request hangs by design.
+	*/
+	async resolveHandlerResult(invocation, handlerEvent) {
+		const value = await invocation;
+		if (typeof value !== "undefined") return value;
+		if (handlerEvent.nextCalled) return handlerEvent.nextResult;
+		const { signal } = handlerEvent;
+		if (signal.aborted) throw createError({
+			status: 408,
+			message: "Request Timeout"
+		});
+		return new Promise((resolve, reject) => {
+			const onAbort = () => {
+				signal.removeEventListener("abort", onAbort);
+				reject(createError({
+					status: 408,
+					message: "Request Timeout"
+				}));
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+			handlerEvent.whenNextCalled().then(() => {
+				signal.removeEventListener("abort", onAbort);
+				resolve(handlerEvent.nextResult);
+			});
+		});
+	}
 	async executeWithTimeout(fn, routerOptions, controller) {
 		const effectiveTimeout = this.resolveTimeout(routerOptions);
 		if (!effectiveTimeout) return fn();
@@ -1325,7 +1368,9 @@ function getRequestProtocol(event, options = {}) {
 const PluginErrorCode = {
 	PLUGIN: "PLUGIN",
 	NOT_INSTALLED: "PLUGIN_NOT_INSTALLED",
-	INSTALL: "PLUGIN_INSTALL"
+	ALREADY_INSTALLED: "PLUGIN_ALREADY_INSTALLED",
+	INSTALL: "PLUGIN_INSTALL",
+	DEPENDENCY: "PLUGIN_DEPENDENCY"
 };
 //#endregion
 //#region src/plugin/error/is.ts
@@ -1345,6 +1390,37 @@ var PluginError = class extends RoutupError {
 	}
 };
 //#endregion
+//#region src/plugin/error/sub/already-installed.ts
+var PluginAlreadyInstalledError = class extends PluginError {
+	pluginName;
+	constructor(pluginName) {
+		super({
+			message: `Plugin "${pluginName}" is already installed on this router.`,
+			code: PluginErrorCode.ALREADY_INSTALLED
+		});
+		this.name = "PluginAlreadyInstalledError";
+		this.pluginName = pluginName;
+	}
+};
+//#endregion
+//#region src/plugin/error/sub/dependency.ts
+var PluginDependencyError = class extends PluginError {
+	pluginName;
+	dependencyName;
+	constructor(pluginName, dependencyName, detail) {
+		let message;
+		if (detail) message = `Plugin "${pluginName}" requires "${dependencyName}": ${detail}`;
+		else message = `Plugin "${pluginName}" requires plugin "${dependencyName}" to be installed first. Register the dependency plugin before this one.`;
+		super({
+			message,
+			code: PluginErrorCode.DEPENDENCY
+		});
+		this.name = "PluginDependencyError";
+		this.pluginName = pluginName;
+		this.dependencyName = dependencyName;
+	}
+};
+//#endregion
 //#region src/plugin/error/sub/install.ts
 var PluginInstallError = class extends PluginError {
 	pluginName;
@@ -1381,6 +1457,113 @@ function isPlugin(input) {
 	return typeof input.install === "function" && input.install.length === 1;
 }
 //#endregion
+//#region src/plugin/semver.ts
+function parseVersion(version) {
+	const match = version.match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*))?(?:\+.+)?$/);
+	if (!match) return;
+	return {
+		major: Number(match[1]),
+		minor: Number(match[2]),
+		patch: Number(match[3]),
+		prerelease: match[4] ? match[4].split(".") : void 0
+	};
+}
+function comparePrereleaseIdentifiers(a, b) {
+	const len = Math.max(a.length, b.length);
+	for (let i = 0; i < len; i++) {
+		if (i >= a.length) return -1;
+		if (i >= b.length) return 1;
+		const aId = a[i];
+		const bId = b[i];
+		const aNum = /^\d+$/.test(aId) ? Number(aId) : void 0;
+		const bNum = /^\d+$/.test(bId) ? Number(bId) : void 0;
+		if (aNum !== void 0 && bNum !== void 0) {
+			if (aNum !== bNum) return aNum - bNum;
+			continue;
+		}
+		if (aNum !== void 0) return -1;
+		if (bNum !== void 0) return 1;
+		if (aId < bId) return -1;
+		if (aId > bId) return 1;
+	}
+	return 0;
+}
+function compareVersions(a, b) {
+	if (a.major !== b.major) return a.major - b.major;
+	if (a.minor !== b.minor) return a.minor - b.minor;
+	if (a.patch !== b.patch) return a.patch - b.patch;
+	if (!a.prerelease && b.prerelease) return 1;
+	if (a.prerelease && !b.prerelease) return -1;
+	if (a.prerelease && b.prerelease) return comparePrereleaseIdentifiers(a.prerelease, b.prerelease);
+	return 0;
+}
+/**
+* Check if a version satisfies a semver constraint.
+*
+* Supported constraint formats:
+* - Exact: '1.2.3'
+* - Comparison: '>=1.0.0', '>1.0.0', '<=2.0.0', '<2.0.0', '=1.0.0'
+* - Caret: '^1.2.3' (>=1.2.3 <2.0.0)
+* - Tilde: '~1.2.3' (>=1.2.3 <1.3.0)
+*/
+function satisfiesVersion(version, constraint) {
+	const parsed = parseVersion(version);
+	if (!parsed) return false;
+	return constraint.trim().split(/\s+/).every((part) => satisfiesSingle(parsed, part));
+}
+function satisfiesSingle(version, constraint) {
+	if (constraint.startsWith("^")) return satisfiesCaret(version, constraint.substring(1));
+	if (constraint.startsWith("~")) return satisfiesTilde(version, constraint.substring(1));
+	if (constraint.startsWith(">=")) {
+		const target = parseVersion(constraint.substring(2));
+		return !!target && compareVersions(version, target) >= 0;
+	}
+	if (constraint.startsWith(">")) {
+		const target = parseVersion(constraint.substring(1));
+		return !!target && compareVersions(version, target) > 0;
+	}
+	if (constraint.startsWith("<=")) {
+		const target = parseVersion(constraint.substring(2));
+		return !!target && compareVersions(version, target) <= 0;
+	}
+	if (constraint.startsWith("<")) {
+		const target = parseVersion(constraint.substring(1));
+		return !!target && compareVersions(version, target) < 0;
+	}
+	if (constraint.startsWith("=")) {
+		const target = parseVersion(constraint.substring(1));
+		return !!target && compareVersions(version, target) === 0;
+	}
+	const target = parseVersion(constraint);
+	return !!target && compareVersions(version, target) === 0;
+}
+/**
+* When the version under test has a prerelease tag, it only matches if it
+* shares the same [major, minor, patch] tuple as the range's lower bound.
+* This follows npm semver semantics where prereleases are scoped to their
+* exact version tuple.
+*/
+function prereleaseAllowed(version, min) {
+	if (!version.prerelease) return true;
+	return version.major === min.major && version.minor === min.minor && version.patch === min.patch;
+}
+function satisfiesCaret(version, range) {
+	const min = parseVersion(range);
+	if (!min) return false;
+	if (compareVersions(version, min) < 0) return false;
+	if (version.prerelease && !prereleaseAllowed(version, min)) return false;
+	if (min.major > 0) return version.major === min.major;
+	if (min.minor > 0) return version.major === 0 && version.minor === min.minor;
+	return version.major === 0 && version.minor === 0 && version.patch === min.patch;
+}
+function satisfiesTilde(version, range) {
+	const min = parseVersion(range);
+	if (!min) return false;
+	if (compareVersions(version, min) < 0) return false;
+	if (version.prerelease && !prereleaseAllowed(version, min)) return false;
+	return version.major === min.major && version.minor === min.minor;
+}
+//#endregion
 //#region src/router/options.ts
 function normalizeRouterOptions(input) {
 	if (typeof input.etag !== "undefined") input.etag = buildEtagFn(input.etag);
@@ -1449,6 +1632,18 @@ var Router = class Router {
 	* Normalized options for this router instance.
 	*/
 	_options;
+	/**
+	* Registry of installed plugins (name → version).
+	*
+	* @protected
+	*/
+	plugins = /* @__PURE__ */ new Map();
+	/**
+	* Parent router reference for dependency lookups.
+	*
+	* @protected
+	*/
+	parent;
 	constructor(input = {}) {
 		this.name = input.name;
 		this.hookManager = new HookManager();
@@ -1718,6 +1913,7 @@ var Router = class Router {
 			}
 			if (isRouterInstance(item)) {
 				if (path) item.setPath(path);
+				item.parent = this;
 				this.stack.push(item);
 				continue;
 			}
@@ -1736,11 +1932,52 @@ var Router = class Router {
 		}
 		return this;
 	}
+	/**
+	* Check if a plugin with the given name is installed on this router
+	* or any parent router.
+	*/
+	hasPlugin(name) {
+		if (this.plugins.has(name)) return true;
+		if (this.parent) return this.parent.hasPlugin(name);
+		return false;
+	}
+	/**
+	* Get the version of an installed plugin by name,
+	* searching this router and parent routers.
+	*/
+	getPluginVersion(name) {
+		if (this.plugins.has(name)) return this.plugins.get(name);
+		if (this.parent) return this.parent.getPluginVersion(name);
+	}
+	validatePluginDependencies(plugin) {
+		if (!plugin.dependencies || plugin.dependencies.length === 0) return;
+		for (const dep of plugin.dependencies) {
+			const dependency = typeof dep === "string" ? { name: dep } : dep;
+			if (!this.hasPlugin(dependency.name)) {
+				if (dependency.optional) continue;
+				throw new PluginDependencyError(plugin.name, dependency.name);
+			}
+			if (dependency.version) {
+				const installedVersion = this.getPluginVersion(dependency.name);
+				if (!installedVersion) {
+					if (dependency.optional) continue;
+					throw new PluginDependencyError(plugin.name, dependency.name, `version "${dependency.version}" required but "${dependency.name}" has no version`);
+				}
+				if (!satisfiesVersion(installedVersion, dependency.version)) {
+					if (dependency.optional) continue;
+					throw new PluginDependencyError(plugin.name, dependency.name, `version "${dependency.version}" required but "${installedVersion}" is installed`);
+				}
+			}
+		}
+	}
 	install(plugin, context = {}) {
-		const router = new Router({ name: context.name || plugin.name });
+		if (this.plugins.has(plugin.name)) throw new PluginAlreadyInstalledError(plugin.name);
+		this.validatePluginDependencies(plugin);
+		const router = new Router({ name: plugin.name });
 		plugin.install(router);
 		if (context.path) this.use(context.path, router);
 		else this.use(router);
+		this.plugins.set(plugin.name, plugin.version);
 		return this;
 	}
 	on(name, fn, priority) {
@@ -1756,6 +1993,6 @@ var Router = class Router {
 	}
 };
 //#endregion
-export { appendResponseHeaderDirective as $, isPath as A, getRequestAcceptableContentTypes as B, isWebHandler as C, defineErrorHandler as D, fromNodeMiddleware as E, RoutupEvent as F, sendAccepted as G, getRequestHeader as H, sendStream as I, isError as J, toResponse as K, sendRedirect as L, HandlerSymbol as M, HandlerType as N, defineCoreHandler as O, DispatcherEvent as P, appendResponseHeader as Q, sendFormat as R, fromWebHandler as S, fromNodeHandler as T, sendFile as U, useRequestNegotiator as V, sendCreated as W, setResponseHeaderAttachment as X, setResponseHeaderContentType as Y, setResponseContentTypeByFileName as Z, getRequestAcceptableCharset as _, PluginInstallError as a, HeaderName as at, isHandler as b, PluginErrorCode as c, getRequestHostName as d, createEventStream as et, matchRequestContentType as f, getRequestAcceptableEncodings as g, getRequestAcceptableEncoding as h, PluginNotInstalledError as i, setResponseCacheHeaders as it, PathMatcher as j, Handler as k, getRequestProtocol as l, getRequestAcceptableLanguages as m, normalizeRouterOptions as n, ErrorSymbol as nt, PluginError as o, MethodName as ot, getRequestAcceptableLanguage as p, createError as q, isPlugin as r, RoutupError as rt, isPluginError as s, Router as t, serializeEventStreamMessage as tt, getRequestIP as u, getRequestAcceptableCharsets as v, isWebHandlerProvider as w, isHandlerOptions as x, isRequestCacheable as y, getRequestAcceptableContentType as z };
+export { setResponseHeaderAttachment as $, defineErrorHandler as A, sendRedirect as B, isHandler as C, isWebHandlerProvider as D, isWebHandler as E, HandlerSymbol as F, getRequestHeader as G, getRequestAcceptableContentType as H, HandlerType as I, sendAccepted as J, sendFile as K, DispatcherEvent as L, Handler as M, isPath as N, fromNodeHandler as O, PathMatcher as P, setResponseHeaderContentType as Q, RoutupEvent as R, isRequestCacheable as S, fromWebHandler as T, getRequestAcceptableContentTypes as U, sendFormat as V, useRequestNegotiator as W, createError as X, toResponse as Y, isError as Z, getRequestAcceptableLanguages as _, PluginNotInstalledError as a, ErrorSymbol as at, getRequestAcceptableCharset as b, PluginAlreadyInstalledError as c, HeaderName as ct, PluginErrorCode as d, setResponseContentTypeByFileName as et, getRequestProtocol as f, getRequestAcceptableLanguage as g, matchRequestContentType as h, isPlugin as i, serializeEventStreamMessage as it, defineCoreHandler as j, fromNodeMiddleware as k, PluginError as l, MethodName as lt, getRequestHostName as m, normalizeRouterOptions as n, appendResponseHeaderDirective as nt, PluginInstallError as o, RoutupError as ot, getRequestIP as p, sendCreated as q, satisfiesVersion as r, createEventStream as rt, PluginDependencyError as s, setResponseCacheHeaders as st, Router as t, appendResponseHeader as tt, isPluginError as u, getRequestAcceptableEncoding as v, isHandlerOptions as w, getRequestAcceptableCharsets as x, getRequestAcceptableEncodings as y, sendStream as z };
 
-//# sourceMappingURL=src-Ck8GklBr.mjs.map
+//# sourceMappingURL=src-C32sKqPQ.mjs.map