@zudojs/http 0.1.0 → 1.1.0

package/dist/httpKeepAlive/httpKeepAlive.core.js

@@ -0,0 +1,357 @@
+/**
+ * HTTP keep-alive utilities.
+ *
+ * Provides framework-agnostic helpers for connection persistence,
+ * Keep-Alive header parsing, timeout handling, and connection policy.
+ *
+ * Transport-specific socket management belongs to the server/client adapter
+ * layer. This module only handles HTTP-level semantics.
+ */
+/* -------------------------------------------------------------------------- */
+/* Constants                                                                  */
+/* -------------------------------------------------------------------------- */
+export const DEFAULT_KEEP_ALIVE_ENABLED = true;
+export const DEFAULT_KEEP_ALIVE_TIMEOUT = 5_000;
+export const DEFAULT_KEEP_ALIVE_MAX_REQUESTS = 100;
+export const MIN_KEEP_ALIVE_TIMEOUT = 0;
+export const MAX_KEEP_ALIVE_TIMEOUT = 86_400_000;
+/* -------------------------------------------------------------------------- */
+/* Configuration                                                              */
+/* -------------------------------------------------------------------------- */
+export function createKeepAliveConfig(options = {}) {
+    const enabled = options.enabled ?? DEFAULT_KEEP_ALIVE_ENABLED;
+    const timeout = normalizeTimeout(options.timeout);
+    const maxRequests = normalizeMaxRequests(options.maxRequests);
+    const maxIdleTime = normalizeTimeout(options.maxIdleTime);
+    return {
+        enabled,
+        timeout,
+        maxRequests,
+        maxIdleTime,
+    };
+}
+export function normalizeTimeout(timeout) {
+    if (timeout === undefined) {
+        return undefined;
+    }
+    if (!Number.isFinite(timeout) ||
+        timeout < MIN_KEEP_ALIVE_TIMEOUT ||
+        timeout > MAX_KEEP_ALIVE_TIMEOUT) {
+        throw new RangeError(`Keep-alive timeout must be between ${MIN_KEEP_ALIVE_TIMEOUT} and ${MAX_KEEP_ALIVE_TIMEOUT} milliseconds.`);
+    }
+    return Math.floor(timeout);
+}
+export function normalizeMaxRequests(maxRequests) {
+    if (maxRequests === undefined) {
+        return undefined;
+    }
+    if (!Number.isInteger(maxRequests) || maxRequests <= 0) {
+        throw new RangeError("maxRequests must be a positive integer.");
+    }
+    return maxRequests;
+}
+/* -------------------------------------------------------------------------- */
+/* Keep-Alive Header Parsing                                                  */
+/* -------------------------------------------------------------------------- */
+export function parseKeepAliveHeader(value) {
+    const extensions = {};
+    if (!value || value.trim().length === 0) {
+        return {
+            extensions,
+        };
+    }
+    let timeout;
+    let max;
+    for (const part of splitHeaderParameters(value)) {
+        const separator = part.indexOf("=");
+        if (separator === -1) {
+            const key = part.trim().toLowerCase();
+            if (key.length > 0) {
+                extensions[key] = undefined;
+            }
+            continue;
+        }
+        const key = part.slice(0, separator).trim().toLowerCase();
+        const rawValue = part.slice(separator + 1).trim();
+        const parsedValue = unquote(rawValue);
+        if (key === "timeout") {
+            const seconds = Number(parsedValue);
+            if (Number.isFinite(seconds) && seconds >= 0) {
+                timeout = Math.floor(seconds);
+            }
+            continue;
+        }
+        if (key === "max") {
+            const requests = Number(parsedValue);
+            if (Number.isInteger(requests) && requests >= 0) {
+                max = requests;
+            }
+            continue;
+        }
+        extensions[key] = parsedValue;
+    }
+    return {
+        timeout,
+        max,
+        extensions,
+    };
+}
+/* -------------------------------------------------------------------------- */
+/* Keep-Alive Header Formatting                                                */
+/* -------------------------------------------------------------------------- */
+export function formatKeepAliveHeader(parameters = {}) {
+    const parts = [];
+    if (parameters.timeout !== undefined) {
+        if (!Number.isFinite(parameters.timeout) || parameters.timeout < 0) {
+            throw new RangeError("Keep-alive timeout must be a non-negative finite number.");
+        }
+        parts.push(`timeout=${Math.floor(parameters.timeout)}`);
+    }
+    if (parameters.max !== undefined) {
+        if (!Number.isInteger(parameters.max) || parameters.max < 0) {
+            throw new RangeError("Keep-alive max must be a non-negative integer.");
+        }
+        parts.push(`max=${parameters.max}`);
+    }
+    for (const [key, value] of Object.entries(parameters.extensions ?? {})) {
+        if (value === undefined) {
+            parts.push(key);
+        }
+        else {
+            parts.push(`${key}=${quoteIfNeeded(value)}`);
+        }
+    }
+    return parts.join(", ");
+}
+/* -------------------------------------------------------------------------- */
+/* Connection Header                                                          */
+/* -------------------------------------------------------------------------- */
+export function parseConnectionHeader(value) {
+    if (!value) {
+        return [];
+    }
+    return value
+        .split(",")
+        .map((token) => token.trim().toLowerCase())
+        .filter(Boolean);
+}
+export function hasConnectionToken(value, token) {
+    const normalized = token.trim().toLowerCase();
+    return parseConnectionHeader(value).includes(normalized);
+}
+export function isConnectionCloseRequested(value) {
+    return hasConnectionToken(value, "close");
+}
+export function isConnectionKeepAliveRequested(value) {
+    return hasConnectionToken(value, "keep-alive");
+}
+/* -------------------------------------------------------------------------- */
+/* HTTP Version Semantics                                                     */
+/* -------------------------------------------------------------------------- */
+export function supportsPersistentConnections(httpVersion) {
+    const normalized = httpVersion.trim().toUpperCase();
+    return (normalized === "HTTP/1.1" ||
+        normalized === "HTTP/2" ||
+        normalized === "HTTP/3");
+}
+export function defaultConnectionPersistence(httpVersion) {
+    const normalized = httpVersion.trim().toUpperCase();
+    if (normalized === "HTTP/1.0") {
+        return false;
+    }
+    if (normalized === "HTTP/1.1" ||
+        normalized === "HTTP/2" ||
+        normalized === "HTTP/3") {
+        return true;
+    }
+    return false;
+}
+export function shouldKeepAlive(httpVersion, connectionHeader, options = {}) {
+    const config = createKeepAliveConfig(options);
+    if (!config.enabled) {
+        return false;
+    }
+    if (isConnectionCloseRequested(connectionHeader)) {
+        return false;
+    }
+    if (defaultConnectionPersistence(httpVersion)) {
+        return true;
+    }
+    return isConnectionKeepAliveRequested(connectionHeader);
+}
+/* -------------------------------------------------------------------------- */
+/* Response Connection Policy                                                */
+/* -------------------------------------------------------------------------- */
+export function createConnectionHeader(keepAlive) {
+    return keepAlive ? "keep-alive" : "close";
+}
+export function shouldSendKeepAliveHeader(httpVersion) {
+    const normalized = httpVersion.trim().toUpperCase();
+    /*
+     * HTTP/1.1 defaults to persistence, but explicitly sending the
+     * Keep-Alive header is still useful when advertising timeout/max values.
+     */
+    return normalized === "HTTP/1.0" || normalized === "HTTP/1.1";
+}
+/* -------------------------------------------------------------------------- */
+/* Keep-Alive State                                                           */
+/* -------------------------------------------------------------------------- */
+export function createKeepAliveState(now = Date.now()) {
+    return {
+        requests: 0,
+        createdAt: now,
+        lastUsedAt: now,
+        closed: false,
+    };
+}
+export function recordKeepAliveRequest(state, now = Date.now()) {
+    if (state.closed) {
+        return state;
+    }
+    return {
+        ...state,
+        requests: state.requests + 1,
+        lastUsedAt: now,
+    };
+}
+export function closeKeepAlive(state, now = Date.now()) {
+    return {
+        ...state,
+        closed: true,
+        lastUsedAt: now,
+    };
+}
+/* -------------------------------------------------------------------------- */
+/* State Limits                                                               */
+/* -------------------------------------------------------------------------- */
+export function hasExceededMaxRequests(state, maxRequests) {
+    if (maxRequests === undefined) {
+        return false;
+    }
+    return state.requests >= maxRequests;
+}
+export function hasExceededIdleTimeout(state, maxIdleTime, now = Date.now()) {
+    if (maxIdleTime === undefined) {
+        return false;
+    }
+    return now - state.lastUsedAt >= maxIdleTime;
+}
+export function shouldCloseKeepAlive(state, options = {}, now = Date.now()) {
+    const config = createKeepAliveConfig(options);
+    if (state.closed) {
+        return true;
+    }
+    if (!config.enabled) {
+        return true;
+    }
+    if (hasExceededMaxRequests(state, config.maxRequests)) {
+        return true;
+    }
+    if (hasExceededIdleTimeout(state, config.maxIdleTime ?? config.timeout, now)) {
+        return true;
+    }
+    return false;
+}
+/* -------------------------------------------------------------------------- */
+/* Timeout Conversion                                                         */
+/* -------------------------------------------------------------------------- */
+export function millisecondsToSeconds(milliseconds) {
+    if (!Number.isFinite(milliseconds) || milliseconds < 0) {
+        throw new RangeError("Milliseconds must be a non-negative finite number.");
+    }
+    return Math.ceil(milliseconds / 1_000);
+}
+export function secondsToMilliseconds(seconds) {
+    if (!Number.isFinite(seconds) || seconds < 0) {
+        throw new RangeError("Seconds must be a non-negative finite number.");
+    }
+    return Math.floor(seconds * 1_000);
+}
+/* -------------------------------------------------------------------------- */
+/* Header Configuration                                                       */
+/* -------------------------------------------------------------------------- */
+export function createKeepAliveHeader(options = {}) {
+    const config = createKeepAliveConfig(options);
+    if (!config.enabled) {
+        return undefined;
+    }
+    const parameters = {};
+    const params = { ...parameters };
+    if (config.timeout !== undefined) {
+        params.timeout = millisecondsToSeconds(config.timeout);
+    }
+    if (config.maxRequests !== undefined) {
+        params.max = config.maxRequests;
+    }
+    return formatKeepAliveHeader(params);
+}
+/* -------------------------------------------------------------------------- */
+/* Header Token Helpers                                                       */
+/* -------------------------------------------------------------------------- */
+export function addConnectionToken(value, token) {
+    const normalizedToken = token.trim().toLowerCase();
+    if (normalizedToken.length === 0) {
+        return value ?? "";
+    }
+    if (hasConnectionToken(value, normalizedToken)) {
+        return value?.trim() ?? "";
+    }
+    const existing = value?.trim();
+    return existing ? `${existing}, ${normalizedToken}` : normalizedToken;
+}
+export function removeConnectionToken(value, token) {
+    const normalizedToken = token.trim().toLowerCase();
+    return parseConnectionHeader(value)
+        .filter((item) => item !== normalizedToken)
+        .join(", ");
+}
+/* -------------------------------------------------------------------------- */
+/* Internal Helpers                                                           */
+/* -------------------------------------------------------------------------- */
+function splitHeaderParameters(value) {
+    const result = [];
+    let current = "";
+    let quoted = false;
+    let escaped = false;
+    for (const character of value) {
+        if (escaped) {
+            current += character;
+            escaped = false;
+            continue;
+        }
+        if (character === "\\") {
+            current += character;
+            escaped = true;
+            continue;
+        }
+        if (character === '"') {
+            quoted = !quoted;
+            current += character;
+            continue;
+        }
+        if ((character === "," || character === ";") && !quoted) {
+            result.push(current);
+            current = "";
+            continue;
+        }
+        current += character;
+    }
+    if (current.trim().length > 0) {
+        result.push(current);
+    }
+    return result;
+}
+function unquote(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+    }
+    return trimmed;
+}
+function quoteIfNeeded(value) {
+    if (/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(value)) {
+        return value;
+    }
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+//# sourceMappingURL=httpKeepAlive.core.js.map

package/dist/httpMethods/http.methods.d.ts

@@ -26,10 +26,48 @@ export type BodyHTTPMethod = (typeof BODY_METHODS)[number];
 export declare const METHODS_WITH_OPTIONAL_BODY: readonly ["POST", "PUT", "PATCH", "DELETE", "QUERY"];
 export declare function normalizeMethod(method: string): string;
 export declare function normalizeHTTPMethod(method: string): HTTPMethod;
-export declare function isHTTPMethod(method: string): method is HTTPMethod;
-export declare function assertHTTPMethod(method: string): asserts method is HTTPMethod;
-export declare function isSafeMethod(method: string): method is SafeHTTPMethod;
-export declare function isIdempotentMethod(method: string): method is IdempotentHTTPMethod;
+/**
+ * Resolves a method string to its canonical {@link HTTPMethod}.
+ *
+ * @param method - The raw method string, in any case.
+ * @returns The canonical method, or `undefined` if it is not standard.
+ */
+export declare function toHTTPMethod(method: string): HTTPMethod | undefined;
+/**
+ * Checks whether a string names a standard HTTP method.
+ *
+ * @remarks
+ * This deliberately returns a plain `boolean` rather than narrowing
+ * `method is HTTPMethod`: the check is case-insensitive, so `"get"` passes
+ * while its runtime value is still `"get"` and every downstream
+ * `method === "GET"` comparison fails. Use {@link toHTTPMethod} when the
+ * narrowed value is what you need.
+ *
+ * @param method - The raw method string.
+ * @returns `true` if the method is standard.
+ */
+export declare function isHTTPMethod(method: string): boolean;
+/**
+ * Asserts that a string names a standard HTTP method.
+ *
+ * @param method - The raw method string.
+ * @throws {TypeError} If the method is not standard.
+ */
+export declare function assertHTTPMethod(method: string): void;
+/**
+ * Checks whether a method is safe per RFC 9110 section 9.2.1.
+ *
+ * @param method - The raw method string.
+ * @returns `true` if the method is safe.
+ */
+export declare function isSafeMethod(method: string): boolean;
+/**
+ * Checks whether a method is idempotent per RFC 9110 section 9.2.2.
+ *
+ * @param method - The raw method string.
+ * @returns `true` if the method is idempotent.
+ */
+export declare function isIdempotentMethod(method: string): boolean;
 export declare function hasRequestBody(method: string): boolean;
 export declare function mayHaveRequestBody(method: string): boolean;
 export declare function isGET(method: string): boolean;
@@ -48,8 +86,38 @@ export declare function getAllHTTPMethods(): HTTPMethod[];
 export declare function getSafeHTTPMethods(): SafeHTTPMethod[];
 export declare function getIdempotentHTTPMethods(): IdempotentHTTPMethod[];
 export declare function getBodyHTTPMethods(): BodyHTTPMethod[];
+/**
+ * Formats an `Allow` header value.
+ *
+ * Entries that are not valid method tokens are dropped rather than joined.
+ * Without that filter an interior CR/LF in a caller-supplied method name
+ * would be emitted verbatim into a response header.
+ *
+ * @param methods - The allowed methods.
+ * @returns The header value, or the empty string when nothing is allowed.
+ */
 export declare function formatAllowHeader(methods: readonly string[] | undefined): string;
 export declare function parseAllowHeader(value: string | undefined): HTTPMethod[];
 export declare function isMethodOverrideAllowed(method: string): boolean;
+/**
+ * Methods an `X-HTTP-Method-Override` may name.
+ *
+ * The override target is attacker-controlled, so it is whitelisted to the
+ * three methods the mechanism exists for. Allowing an arbitrary target would
+ * let a POST that has already passed CSRF validation, body parsing and
+ * POST-specific authorization be rewritten into GET, TRACE or CONNECT
+ * afterwards.
+ */
+export declare const METHOD_OVERRIDE_TARGETS: readonly ["PUT", "PATCH", "DELETE"];
+/**
+ * Resolves an `X-HTTP-Method-Override` against the original method.
+ *
+ * An unrecognised or non-whitelisted override is ignored, not thrown on: the
+ * value comes from the client, so throwing turns any request into a 500.
+ *
+ * @param originalMethod - The method actually used on the wire.
+ * @param override - The requested override, if any.
+ * @returns The effective method.
+ */
 export declare function resolveMethodOverride(originalMethod: string, override: string | undefined): HTTPMethod;
 //# sourceMappingURL=http.methods.d.ts.map

package/dist/httpMethods/http.methods.js

@@ -59,18 +59,49 @@ export function normalizeMethod(method) {
 }
 export function normalizeHTTPMethod(method) {
     const normalized = normalizeMethod(method);
-    if (!isHTTPMethod(normalized)) {
+    const resolved = toHTTPMethod(normalized);
+    if (resolved === undefined) {
         throw new TypeError(`Unsupported HTTP method: ${method}`);
     }
-    return normalized;
+    return resolved;
 }
 /* -------------------------------------------------------------------------- */
 /* Validation                                                                 */
 /* -------------------------------------------------------------------------- */
-export function isHTTPMethod(method) {
+/**
+ * Resolves a method string to its canonical {@link HTTPMethod}.
+ *
+ * @param method - The raw method string, in any case.
+ * @returns The canonical method, or `undefined` if it is not standard.
+ */
+export function toHTTPMethod(method) {
     const normalized = normalizeMethod(method);
-    return Object.values(HTTP_METHODS).includes(normalized);
+    return Object.values(HTTP_METHODS).includes(normalized)
+        ? normalized
+        : undefined;
+}
+/**
+ * Checks whether a string names a standard HTTP method.
+ *
+ * @remarks
+ * This deliberately returns a plain `boolean` rather than narrowing
+ * `method is HTTPMethod`: the check is case-insensitive, so `"get"` passes
+ * while its runtime value is still `"get"` and every downstream
+ * `method === "GET"` comparison fails. Use {@link toHTTPMethod} when the
+ * narrowed value is what you need.
+ *
+ * @param method - The raw method string.
+ * @returns `true` if the method is standard.
+ */
+export function isHTTPMethod(method) {
+    return toHTTPMethod(method) !== undefined;
 }
+/**
+ * Asserts that a string names a standard HTTP method.
+ *
+ * @param method - The raw method string.
+ * @throws {TypeError} If the method is not standard.
+ */
 export function assertHTTPMethod(method) {
     if (!isHTTPMethod(method)) {
         throw new TypeError(`Unsupported HTTP method: ${method}`);
@@ -79,10 +110,22 @@ export function assertHTTPMethod(method) {
 /* -------------------------------------------------------------------------- */
 /* Method Classification                                                      */
 /* -------------------------------------------------------------------------- */
+/**
+ * Checks whether a method is safe per RFC 9110 section 9.2.1.
+ *
+ * @param method - The raw method string.
+ * @returns `true` if the method is safe.
+ */
 export function isSafeMethod(method) {
     const normalized = normalizeMethod(method);
     return SAFE_METHODS.includes(normalized);
 }
+/**
+ * Checks whether a method is idempotent per RFC 9110 section 9.2.2.
+ *
+ * @param method - The raw method string.
+ * @returns `true` if the method is idempotent.
+ */
 export function isIdempotentMethod(method) {
     const normalized = normalizeMethod(method);
     return IDEMPOTENT_METHODS.includes(normalized);
@@ -159,11 +202,27 @@ export function getBodyHTTPMethods() {
 /* -------------------------------------------------------------------------- */
 /* Allow Header                                                               */
 /* -------------------------------------------------------------------------- */
+/**
+ * RFC 9110 section 5.6.2 `token`, the grammar for a method name.
+ */
+const METHOD_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+/**
+ * Formats an `Allow` header value.
+ *
+ * Entries that are not valid method tokens are dropped rather than joined.
+ * Without that filter an interior CR/LF in a caller-supplied method name
+ * would be emitted verbatim into a response header.
+ *
+ * @param methods - The allowed methods.
+ * @returns The header value, or the empty string when nothing is allowed.
+ */
 export function formatAllowHeader(methods) {
     if (!methods || methods.length === 0) {
         return "";
     }
-    const normalized = methods.map(normalizeMethod);
+    const normalized = methods
+        .map(normalizeMethod)
+        .filter((method) => METHOD_TOKEN.test(method));
     return [...new Set(normalized)].join(", ");
 }
 export function parseAllowHeader(value) {
@@ -172,9 +231,9 @@ export function parseAllowHeader(value) {
     }
     const result = [];
     for (const method of value.split(",")) {
-        const normalized = normalizeMethod(method);
-        if (isHTTPMethod(normalized) && !result.includes(normalized)) {
-            result.push(normalized);
+        const resolved = toHTTPMethod(method);
+        if (resolved !== undefined && !result.includes(resolved)) {
+            result.push(resolved);
         }
     }
     return result;
@@ -188,11 +247,40 @@ export function isMethodOverrideAllowed(method) {
         normalized === HTTP_METHODS.PUT ||
         normalized === HTTP_METHODS.PATCH);
 }
+/**
+ * Methods an `X-HTTP-Method-Override` may name.
+ *
+ * The override target is attacker-controlled, so it is whitelisted to the
+ * three methods the mechanism exists for. Allowing an arbitrary target would
+ * let a POST that has already passed CSRF validation, body parsing and
+ * POST-specific authorization be rewritten into GET, TRACE or CONNECT
+ * afterwards.
+ */
+export const METHOD_OVERRIDE_TARGETS = [
+    HTTP_METHODS.PUT,
+    HTTP_METHODS.PATCH,
+    HTTP_METHODS.DELETE,
+];
+/**
+ * Resolves an `X-HTTP-Method-Override` against the original method.
+ *
+ * An unrecognised or non-whitelisted override is ignored, not thrown on: the
+ * value comes from the client, so throwing turns any request into a 500.
+ *
+ * @param originalMethod - The method actually used on the wire.
+ * @param override - The requested override, if any.
+ * @returns The effective method.
+ */
 export function resolveMethodOverride(originalMethod, override) {
     const original = normalizeHTTPMethod(originalMethod);
     if (!override || !isMethodOverrideAllowed(original)) {
         return original;
     }
-    return normalizeHTTPMethod(override);
+    const target = toHTTPMethod(override);
+    if (target === undefined ||
+        !METHOD_OVERRIDE_TARGETS.includes(target)) {
+        return original;
+    }
+    return target;
 }
 //# sourceMappingURL=http.methods.js.map

package/dist/httpMiddleware/builtin/compose/httpMiddleware.compose.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Compose, combine, and with middleware factories.
+ *
+ * @module httpMiddleware/builtin/compose
+ */
+import type { HttpMiddleware, HttpMiddlewareContext } from "../../httpMiddleware.type.js";
+export declare function composeMiddleware(...middlewares: readonly HttpMiddleware[]): HttpMiddleware;
+export declare function combineMiddleware(...middlewares: readonly HttpMiddleware[]): HttpMiddleware;
+export declare function withMiddleware(handler: (context: HttpMiddlewareContext) => void | Promise<void>, ...middlewares: readonly HttpMiddleware[]): HttpMiddleware;
+//# sourceMappingURL=httpMiddleware.compose.d.ts.map

package/dist/httpMiddleware/builtin/compose/httpMiddleware.compose.js

@@ -0,0 +1,34 @@
+/**
+ * Compose, combine, and with middleware factories.
+ *
+ * @module httpMiddleware/builtin/compose
+ */
+export function composeMiddleware(...middlewares) {
+    return async (context, next) => {
+        let index = -1;
+        const dispatch = async (i) => {
+            if (i <= index) {
+                throw new Error("composeMiddleware() called multiple times.");
+            }
+            index = i;
+            const middleware = middlewares[i];
+            if (!middleware) {
+                return next();
+            }
+            return middleware(context, () => dispatch(i + 1));
+        };
+        return dispatch(0);
+    };
+}
+export function combineMiddleware(...middlewares) {
+    return composeMiddleware(...middlewares);
+}
+export function withMiddleware(handler, ...middlewares) {
+    const composed = composeMiddleware(...middlewares);
+    return async (context, next) => {
+        const result = await composed(context, next);
+        await handler(context);
+        return result;
+    };
+}
+//# sourceMappingURL=httpMiddleware.compose.js.map

package/dist/httpMiddleware/builtin/compose/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compose middleware barrel.
+ *
+ * @module httpMiddleware/builtin/compose
+ */
+export { composeMiddleware, combineMiddleware, withMiddleware, } from "./httpMiddleware.compose.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/httpMiddleware/builtin/compose/index.js

@@ -0,0 +1,7 @@
+/**
+ * Compose middleware barrel.
+ *
+ * @module httpMiddleware/builtin/compose
+ */
+export { composeMiddleware, combineMiddleware, withMiddleware, } from "./httpMiddleware.compose.js";
+//# sourceMappingURL=index.js.map

package/dist/httpMiddleware/builtin/conditional/httpMiddleware.conditional.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Conditional, path, method, and response middleware factories.
+ *
+ * @module httpMiddleware/builtin/conditional
+ */
+import type { HttpMiddleware, HttpMiddlewareContext } from "../../httpMiddleware.type.js";
+import type { HttpResponseContext as ResponseContext } from "../../../httpResponse/httpResponse.context.js";
+export declare function createAsyncMiddleware(factory: (context: HttpMiddlewareContext) => Promise<HttpMiddleware>): HttpMiddleware;
+export declare function createConditionalMiddleware(predicate: (context: HttpMiddlewareContext) => boolean | Promise<boolean>, middleware: HttpMiddleware): HttpMiddleware;
+export declare function createPathMiddleware(path: string, middleware: HttpMiddleware): HttpMiddleware;
+export declare function createMethodMiddleware(method: string, middleware: HttpMiddleware): HttpMiddleware;
+export declare function createResponseMiddleware(response: Response | ResponseContext): HttpMiddleware;
+export declare function createShortCircuitMiddleware(predicate: (context: HttpMiddlewareContext) => boolean | Promise<boolean>, response: Response | ResponseContext): HttpMiddleware;
+//# sourceMappingURL=httpMiddleware.conditional.d.ts.map