@zudojs/http 0.1.0 → 1.0.0

package/dist/httpContentType/httpContentType.category.js

@@ -0,0 +1,23 @@
+/**
+ * HTTP Content-Type category detection helpers (JSON, XML, text).
+ */
+import { getMediaType } from "./httpContentType.normalizer.js";
+import { matchesContentType } from "./httpContentType.matcher.js";
+export function isJSON(value) {
+    return (matchesContentType(value, "application/json") || isStructuredJSON(value));
+}
+export function isStructuredJSON(value) {
+    const mediaType = getMediaType(value);
+    return mediaType?.endsWith("+json") ?? false;
+}
+export function isText(value) {
+    const mediaType = getMediaType(value);
+    return mediaType?.startsWith("text/") ?? false;
+}
+export function isXML(value) {
+    const mediaType = getMediaType(value);
+    return (mediaType === "application/xml" ||
+        mediaType === "text/xml" ||
+        mediaType?.endsWith("+xml") === true);
+}
+//# sourceMappingURL=httpContentType.category.js.map

package/dist/httpContentType/httpContentType.categoryBinary.d.ts

@@ -0,0 +1,9 @@
+/**
+ * HTTP Content-Type category detection helpers (forms, multipart, binary).
+ */
+import type { ContentType } from "./httpContentType.type.js";
+export declare function isFormURLEncoded(value: string | ContentType | undefined | null): boolean;
+export declare function isMultipart(value: string | ContentType | undefined | null): boolean;
+export declare function isMultipartFormData(value: string | ContentType | undefined | null): boolean;
+export declare function isBinary(value: string | ContentType | undefined | null): boolean;
+//# sourceMappingURL=httpContentType.categoryBinary.d.ts.map

package/dist/httpContentType/httpContentType.categoryBinary.js

@@ -0,0 +1,30 @@
+/**
+ * HTTP Content-Type category detection helpers (forms, multipart, binary).
+ */
+import { MEDIA_TYPES } from "./httpContentType.mediaTypes.js";
+import { getMediaType } from "./httpContentType.normalizer.js";
+import { matchesContentType } from "./httpContentType.matcher.js";
+export function isFormURLEncoded(value) {
+    return matchesContentType(value, MEDIA_TYPES.FORM_URLENCODED);
+}
+export function isMultipart(value) {
+    const mediaType = getMediaType(value);
+    return mediaType?.startsWith("multipart/") ?? false;
+}
+export function isMultipartFormData(value) {
+    return matchesContentType(value, MEDIA_TYPES.MULTIPART_FORM_DATA);
+}
+export function isBinary(value) {
+    const mediaType = getMediaType(value);
+    if (!mediaType) {
+        return false;
+    }
+    return (mediaType === MEDIA_TYPES.OCTET_STREAM ||
+        mediaType === MEDIA_TYPES.PDF ||
+        mediaType === MEDIA_TYPES.ZIP ||
+        mediaType === MEDIA_TYPES.GZIP ||
+        mediaType.startsWith("image/") ||
+        mediaType.startsWith("audio/") ||
+        mediaType.startsWith("video/"));
+}
+//# sourceMappingURL=httpContentType.categoryBinary.js.map

package/dist/httpContentType/httpContentType.charset.d.ts

@@ -0,0 +1,8 @@
+/**
+ * HTTP Content-Type charset parameter helpers.
+ */
+import type { ContentType } from "./httpContentType.type.js";
+export declare function getCharset(value: string | ContentType | undefined | null): string | undefined;
+export declare function hasCharset(value: string | ContentType | undefined | null): boolean;
+export declare function withCharset(value: string | ContentType, charset: string): string;
+//# sourceMappingURL=httpContentType.charset.d.ts.map

package/dist/httpContentType/httpContentType.charset.js

@@ -0,0 +1,36 @@
+/**
+ * HTTP Content-Type charset parameter helpers.
+ */
+import { parseContentType } from "./httpContentType.parser.js";
+import { formatContentType } from "./httpContentType.formatter.js";
+import { isValidToken } from "./httpContentType.parserHelpers.js";
+export function getCharset(value) {
+    const parsed = typeof value === "string" ? parseContentType(value) : value;
+    return parsed?.parameters.charset;
+}
+export function hasCharset(value) {
+    return getCharset(value) !== undefined;
+}
+export function withCharset(value, charset) {
+    const parsed = typeof value === "string" ? parseContentType(value) : value;
+    if (!parsed) {
+        throw new TypeError("Invalid content type.");
+    }
+    const normalizedCharset = charset.trim().toLowerCase();
+    /*
+     * A charset is a token per RFC 9110 section 8.3.2; rejecting anything else
+     * here is what stops an interior CR/LF from reaching the response header.
+     */
+    if (!isValidToken(normalizedCharset)) {
+        throw new TypeError(`Invalid charset: ${JSON.stringify(charset)}`);
+    }
+    const parameters = {
+        ...parsed.parameters,
+        charset: normalizedCharset,
+    };
+    return formatContentType({
+        ...parsed,
+        parameters,
+    });
+}
+//# sourceMappingURL=httpContentType.charset.js.map

package/dist/httpContentType/httpContentType.constructors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Common HTTP Content-Type string constructors.
+ */
+export declare function jsonContentType(charset?: string): string;
+export declare function textContentType(charset?: string): string;
+export declare function htmlContentType(charset?: string): string;
+export declare function formURLEncodedContentType(): string;
+export declare function multipartFormDataContentType(boundary?: string): string;
+export declare function octetStreamContentType(): string;
+//# sourceMappingURL=httpContentType.constructors.d.ts.map

package/dist/httpContentType/httpContentType.constructors.js

@@ -0,0 +1,37 @@
+/**
+ * Common HTTP Content-Type string constructors.
+ */
+import { MEDIA_TYPES } from "./httpContentType.mediaTypes.js";
+import { withCharset } from "./httpContentType.charset.js";
+import { withBoundary } from "./httpContentType.boundary.js";
+export function jsonContentType(charset) {
+    if (!charset) {
+        return MEDIA_TYPES.JSON;
+    }
+    return withCharset(MEDIA_TYPES.JSON, charset);
+}
+export function textContentType(charset) {
+    if (!charset) {
+        return MEDIA_TYPES.TEXT;
+    }
+    return withCharset(MEDIA_TYPES.TEXT, charset);
+}
+export function htmlContentType(charset) {
+    if (!charset) {
+        return MEDIA_TYPES.HTML;
+    }
+    return withCharset(MEDIA_TYPES.HTML, charset);
+}
+export function formURLEncodedContentType() {
+    return MEDIA_TYPES.FORM_URLENCODED;
+}
+export function multipartFormDataContentType(boundary) {
+    if (!boundary) {
+        return MEDIA_TYPES.MULTIPART_FORM_DATA;
+    }
+    return withBoundary(MEDIA_TYPES.MULTIPART_FORM_DATA, boundary);
+}
+export function octetStreamContentType() {
+    return MEDIA_TYPES.OCTET_STREAM;
+}
+//# sourceMappingURL=httpContentType.constructors.js.map

package/dist/httpContentType/httpContentType.formatter.d.ts

@@ -0,0 +1,7 @@
+/**
+ * HTTP Content-Type formatting and creation.
+ */
+import type { ContentType } from "./httpContentType.type.js";
+export declare function formatContentType(contentType: ContentType): string;
+export declare function createContentType(type: string, subtype: string, parameters?: Record<string, string>): ContentType;
+//# sourceMappingURL=httpContentType.formatter.d.ts.map

package/dist/httpContentType/httpContentType.formatter.js

@@ -0,0 +1,44 @@
+/**
+ * HTTP Content-Type formatting and creation.
+ */
+import { isValidToken, quoteParameterValue, } from "./httpContentType.parserHelpers.js";
+export function formatContentType(contentType) {
+    const mediaType = `${contentType.type}/${contentType.subtype}`;
+    const parameters = Object.entries(contentType.parameters);
+    if (parameters.length === 0) {
+        return mediaType;
+    }
+    const formatted = [mediaType];
+    for (const [name, value] of parameters) {
+        const normalizedName = name.trim().toLowerCase();
+        if (!isValidToken(normalizedName)) {
+            throw new TypeError(`Invalid content type parameter name: ${name}`);
+        }
+        formatted.push(`${normalizedName}=${quoteParameterValue(value)}`);
+    }
+    return formatted.join("; ");
+}
+export function createContentType(type, subtype, parameters = {}) {
+    const normalizedType = type.trim().toLowerCase();
+    const normalizedSubtype = subtype.trim().toLowerCase();
+    if (!isValidToken(normalizedType)) {
+        throw new TypeError(`Invalid media type: ${type}`);
+    }
+    if (!isValidToken(normalizedSubtype)) {
+        throw new TypeError(`Invalid media subtype: ${subtype}`);
+    }
+    const normalizedParameters = Object.create(null);
+    for (const [name, value] of Object.entries(parameters)) {
+        const normalizedName = name.trim().toLowerCase();
+        if (!isValidToken(normalizedName)) {
+            throw new TypeError(`Invalid content type parameter: ${name}`);
+        }
+        normalizedParameters[normalizedName] = String(value);
+    }
+    return {
+        type: normalizedType,
+        subtype: normalizedSubtype,
+        parameters: normalizedParameters,
+    };
+}
+//# sourceMappingURL=httpContentType.formatter.js.map

package/dist/httpContentType/httpContentType.matcher.d.ts

@@ -0,0 +1,6 @@
+/**
+ * HTTP Content-Type matching utilities.
+ */
+import type { ContentType, ContentTypeMatchOptions } from "./httpContentType.type.js";
+export declare function matchesContentType(value: string | ContentType | undefined | null, expected: string | ContentType, options?: ContentTypeMatchOptions): boolean;
+//# sourceMappingURL=httpContentType.matcher.d.ts.map

package/dist/httpContentType/httpContentType.matcher.js

@@ -0,0 +1,53 @@
+/**
+ * HTTP Content-Type matching utilities.
+ */
+import { parseContentType } from "./httpContentType.parser.js";
+/**
+ * Matches one media-type token against a pattern token.
+ *
+ * The wildcard is only meaningful in `expected` — the pattern. A wildcard in
+ * `actual` comes from the observed (untrusted) header, and honouring it would
+ * let `Content-Type: * /*` satisfy every content-type guard at once.
+ *
+ * @param actual - The observed token.
+ * @param expected - The pattern token.
+ * @param allowWildcard - Whether `*` in the pattern matches anything.
+ * @returns `true` if the observed token matches the pattern.
+ */
+function matchesToken(actual, expected, allowWildcard) {
+    if (actual === expected) {
+        return true;
+    }
+    if (!allowWildcard) {
+        return false;
+    }
+    return expected === "*";
+}
+export function matchesContentType(value, expected, options = {}) {
+    const actual = typeof value === "string" ? parseContentType(value) : value;
+    const target = typeof expected === "string" ? parseContentType(expected) : expected;
+    if (!actual || !target) {
+        return false;
+    }
+    const allowWildcard = options.allowWildcard ?? true;
+    if (!matchesToken(actual.type, target.type, allowWildcard)) {
+        return false;
+    }
+    if (!matchesToken(actual.subtype, target.subtype, allowWildcard)) {
+        return false;
+    }
+    if (options.ignoreParameters) {
+        return true;
+    }
+    for (const [name, expectedValue] of Object.entries(target.parameters)) {
+        const actualValue = actual.parameters[name];
+        if (actualValue === undefined) {
+            return false;
+        }
+        if (actualValue.toLowerCase() !== expectedValue.toLowerCase()) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=httpContentType.matcher.js.map

package/dist/httpContentType/httpContentType.mediaTypes.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Common HTTP media type constants.
+ */
+export declare const MEDIA_TYPES: {
+    readonly JSON: "application/json";
+    readonly JSON_PATCH: "application/json-patch+json";
+    readonly JSON_API: "application/vnd.api+json";
+    readonly TEXT: "text/plain";
+    readonly HTML: "text/html";
+    readonly CSS: "text/css";
+    readonly JAVASCRIPT: "text/javascript";
+    readonly XML: "application/xml";
+    readonly FORM_URLENCODED: "application/x-www-form-urlencoded";
+    readonly MULTIPART_FORM_DATA: "multipart/form-data";
+    readonly OCTET_STREAM: "application/octet-stream";
+    readonly PDF: "application/pdf";
+    readonly ZIP: "application/zip";
+    readonly GZIP: "application/gzip";
+    readonly FORM_DATA: "multipart/form-data";
+};
+//# sourceMappingURL=httpContentType.mediaTypes.d.ts.map

package/dist/httpContentType/httpContentType.mediaTypes.js

@@ -0,0 +1,21 @@
+/**
+ * Common HTTP media type constants.
+ */
+export const MEDIA_TYPES = {
+    JSON: "application/json",
+    JSON_PATCH: "application/json-patch+json",
+    JSON_API: "application/vnd.api+json",
+    TEXT: "text/plain",
+    HTML: "text/html",
+    CSS: "text/css",
+    JAVASCRIPT: "text/javascript",
+    XML: "application/xml",
+    FORM_URLENCODED: "application/x-www-form-urlencoded",
+    MULTIPART_FORM_DATA: "multipart/form-data",
+    OCTET_STREAM: "application/octet-stream",
+    PDF: "application/pdf",
+    ZIP: "application/zip",
+    GZIP: "application/gzip",
+    FORM_DATA: "multipart/form-data",
+};
+//# sourceMappingURL=httpContentType.mediaTypes.js.map

package/dist/httpContentType/httpContentType.normalizer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * HTTP Content-Type normalization utilities.
+ */
+import type { ContentType } from "./httpContentType.type.js";
+export declare function normalizeContentType(value: string | ContentType | undefined | null): string | undefined;
+export declare function getMediaType(value: string | ContentType | undefined | null): string | undefined;
+//# sourceMappingURL=httpContentType.normalizer.d.ts.map

package/dist/httpContentType/httpContentType.normalizer.js

@@ -0,0 +1,29 @@
+/**
+ * HTTP Content-Type normalization utilities.
+ */
+import { parseContentType } from "./httpContentType.parser.js";
+import { formatContentType } from "./httpContentType.formatter.js";
+export function normalizeContentType(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        return formatContentType(value);
+    }
+    const parsed = parseContentType(value);
+    if (!parsed) {
+        return undefined;
+    }
+    return formatContentType(parsed);
+}
+export function getMediaType(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const parsed = typeof value === "string" ? parseContentType(value) : value;
+    if (!parsed) {
+        return undefined;
+    }
+    return `${parsed.type}/${parsed.subtype}`;
+}
+//# sourceMappingURL=httpContentType.normalizer.js.map

package/dist/httpContentType/httpContentType.parameter.d.ts

@@ -0,0 +1,7 @@
+/**
+ * HTTP Content-Type generic parameter helpers.
+ */
+import type { ContentType } from "./httpContentType.type.js";
+export declare function getParameter(value: string | ContentType | undefined | null, name: string): string | undefined;
+export declare function hasParameter(value: string | ContentType | undefined | null, name: string): boolean;
+//# sourceMappingURL=httpContentType.parameter.d.ts.map

package/dist/httpContentType/httpContentType.parameter.js

@@ -0,0 +1,20 @@
+/**
+ * HTTP Content-Type generic parameter helpers.
+ */
+import { parseContentType } from "./httpContentType.parser.js";
+export function getParameter(value, name) {
+    const parsed = typeof value === "string" ? parseContentType(value) : value;
+    if (!parsed) {
+        return undefined;
+    }
+    const key = name.trim().toLowerCase();
+    if (!Object.prototype.hasOwnProperty.call(parsed.parameters, key)) {
+        return undefined;
+    }
+    const found = parsed.parameters[key];
+    return typeof found === "string" ? found : undefined;
+}
+export function hasParameter(value, name) {
+    return getParameter(value, name) !== undefined;
+}
+//# sourceMappingURL=httpContentType.parameter.js.map

package/dist/httpContentType/httpContentType.parser.d.ts

@@ -0,0 +1,6 @@
+/**
+ * HTTP Content-Type parser.
+ */
+import type { ContentType } from "./httpContentType.type.js";
+export declare function parseContentType(value: string | undefined | null): ContentType | undefined;
+//# sourceMappingURL=httpContentType.parser.d.ts.map

package/dist/httpContentType/httpContentType.parser.js

@@ -0,0 +1,44 @@
+/**
+ * HTTP Content-Type parser.
+ */
+import { splitParameters, parseParameter, isValidToken, } from "./httpContentType.parserHelpers.js";
+export function parseContentType(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const input = value.trim();
+    if (input.length === 0) {
+        return undefined;
+    }
+    const parts = splitParameters(input);
+    const mediaType = parts.shift();
+    if (!mediaType) {
+        return undefined;
+    }
+    const separator = mediaType.indexOf("/");
+    if (separator <= 0 || separator === mediaType.length - 1) {
+        return undefined;
+    }
+    const type = mediaType.slice(0, separator).trim().toLowerCase();
+    const subtype = mediaType
+        .slice(separator + 1)
+        .trim()
+        .toLowerCase();
+    if (!isValidToken(type) || !isValidToken(subtype)) {
+        return undefined;
+    }
+    const parameters = Object.create(null);
+    for (const parameter of parts) {
+        const parsed = parseParameter(parameter);
+        if (!parsed) {
+            continue;
+        }
+        parameters[parsed.name] = parsed.value;
+    }
+    return {
+        type,
+        subtype,
+        parameters,
+    };
+}
+//# sourceMappingURL=httpContentType.parser.js.map

package/dist/httpContentType/httpContentType.parserHelpers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Internal parser helper functions for HTTP Content-Type parsing.
+ */
+import type { ContentTypeParameter } from "./httpContentType.type.js";
+export declare function isValidToken(value: string): boolean;
+export declare function splitParameters(value: string): string[];
+export declare function parseParameter(value: string): ContentTypeParameter | undefined;
+/**
+ * Emits a parameter value as a token or a `quoted-string`.
+ *
+ * Delegates the quoting to `httpHeaders/security`, which rejects CR, LF, NUL
+ * and every other C0/DEL control character rather than letting it reach the
+ * wire.
+ *
+ * @param value - The raw parameter value.
+ * @returns The token or quoted-string form.
+ * @throws {TypeError} If the value contains a forbidden control character.
+ */
+export declare function quoteParameterValue(value: string): string;
+export declare function unquoteParameterValue(value: string): string;
+//# sourceMappingURL=httpContentType.parserHelpers.d.ts.map

package/dist/httpContentType/httpContentType.parserHelpers.js

@@ -0,0 +1,91 @@
+/**
+ * Internal parser helper functions for HTTP Content-Type parsing.
+ */
+import { escapeHeaderQuotedString } from "../httpHeaders/security/httpHeaders.security.js";
+export function isValidToken(value) {
+    return /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(value);
+}
+export function splitParameters(value) {
+    const parts = [];
+    let current = "";
+    let quoted = false;
+    let escaped = false;
+    for (const character of value) {
+        if (escaped) {
+            current += character;
+            escaped = false;
+            continue;
+        }
+        if (quoted && character === "\\") {
+            current += character;
+            escaped = true;
+            continue;
+        }
+        if (character === '"') {
+            quoted = !quoted;
+            current += character;
+            continue;
+        }
+        if (character === ";" && !quoted) {
+            parts.push(current.trim());
+            current = "";
+            continue;
+        }
+        current += character;
+    }
+    if (current.trim().length > 0) {
+        parts.push(current.trim());
+    }
+    return parts;
+}
+export function parseParameter(value) {
+    const separator = value.indexOf("=");
+    if (separator <= 0) {
+        return undefined;
+    }
+    const name = value.slice(0, separator).trim().toLowerCase();
+    let parameterValue = value.slice(separator + 1).trim();
+    if (!isValidToken(name)) {
+        return undefined;
+    }
+    if (parameterValue.startsWith('"') &&
+        parameterValue.endsWith('"') &&
+        parameterValue.length >= 2) {
+        parameterValue = unquoteParameterValue(parameterValue);
+    }
+    return {
+        name,
+        value: parameterValue,
+    };
+}
+/**
+ * Emits a parameter value as a token or a `quoted-string`.
+ *
+ * Delegates the quoting to `httpHeaders/security`, which rejects CR, LF, NUL
+ * and every other C0/DEL control character rather than letting it reach the
+ * wire.
+ *
+ * @param value - The raw parameter value.
+ * @returns The token or quoted-string form.
+ * @throws {TypeError} If the value contains a forbidden control character.
+ */
+export function quoteParameterValue(value) {
+    if (isValidToken(value)) {
+        return value;
+    }
+    return `"${escapeHeaderQuotedString(value)}"`;
+}
+export function unquoteParameterValue(value) {
+    let result = "";
+    for (let index = 1; index < value.length - 1; index += 1) {
+        const character = value[index];
+        if (character === "\\" && index < value.length - 2) {
+            index += 1;
+            result += value[index];
+            continue;
+        }
+        result += character;
+    }
+    return result;
+}
+//# sourceMappingURL=httpContentType.parserHelpers.js.map

package/dist/httpContentType/httpContentType.type.d.ts

@@ -0,0 +1,17 @@
+/**
+ * HTTP Content-Type type definitions.
+ */
+export interface ContentType {
+    readonly type: string;
+    readonly subtype: string;
+    readonly parameters: Readonly<Record<string, string>>;
+}
+export interface ContentTypeParameter {
+    readonly name: string;
+    readonly value: string;
+}
+export interface ContentTypeMatchOptions {
+    readonly allowWildcard?: boolean;
+    readonly ignoreParameters?: boolean;
+}
+//# sourceMappingURL=httpContentType.type.d.ts.map

package/dist/httpContentType/httpContentType.type.js

@@ -0,0 +1,5 @@
+/**
+ * HTTP Content-Type type definitions.
+ */
+export {};
+//# sourceMappingURL=httpContentType.type.js.map

package/dist/httpContext/http.context.js

@@ -125,18 +125,38 @@ function createContextAbortSignal(request) {
     if (request.aborted) {
         controller.abort();
     }
-    // Listen for future abort events from the underlying request
-    if ("on" in request && typeof request.on === "function") {
-        const onRequestAbort = () => {
+    const emitter = request;
+    if (typeof emitter.on !== "function") {
+        return controller.signal;
+    }
+    /*
+     * `IncomingMessage`'s `'aborted'` event was deprecated in Node 16 and is no
+     * longer emitted, so listening only for it meant `ctx.signal` never fired
+     * when a client disconnected. `'close'` with `destroyed`/`!complete` is the
+     * supported signal; `'aborted'` is kept purely as a legacy fallback.
+     */
+    const onAbort = () => {
+        controller.abort();
+        detach();
+    };
+    const onClose = () => {
+        if (emitter.destroyed === true || emitter.complete === false) {
             controller.abort();
-        };
-        request.on("aborted", onRequestAbort);
-        // Clean up listener when signal fires
-        controller.signal.addEventListener("abort", () => {
-            // Use any cast since HTTPRequest may not have removeListener
-            request?.removeListener?.("aborted", onRequestAbort);
-        }, { once: true });
-    }
+        }
+        /*
+         * Detach on the normal path too. Previously the listener was removed only
+         * when the signal aborted, so every completed request left one attached
+         * for the lifetime of the message.
+         */
+        detach();
+    };
+    const detach = () => {
+        emitter.removeListener?.("aborted", onAbort);
+        emitter.removeListener?.("close", onClose);
+    };
+    emitter.on("aborted", onAbort);
+    emitter.on("close", onClose);
+    controller.signal.addEventListener("abort", detach, { once: true });
     return controller.signal;
 }
 /* -------------------------------------------------------------------------- */