@tstdl/base 0.93.36 → 0.93.37

package/source/file/server/index.ts

@@ -1 +0,0 @@
-export * from './temporary-file.js';

package/source/file/server/temporary-file.ts

@@ -1,67 +0,0 @@
-import { createReadStream } from 'node:fs';
-import { readFile, stat, unlink, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { Readable } from 'node:stream';
-
-export class TemporaryFile implements AsyncDisposable {
-  #path = `${tmpdir()}/${crypto.randomUUID()}`;
-
-  get path(): string {
-    return this.#path;
-  }
-
-  static create(): TemporaryFile {
-    return new TemporaryFile();
-  }
-
-  /**
-   * Use an existing file as a temporary file which gets deleted on disposal.
-   * @param path path to adopt
-   */
-  static adopt(path: string): TemporaryFile {
-    const file = new TemporaryFile();
-    file.#path = path;
-
-    return file;
-  }
-
-  static async from(content: string | Uint8Array | ReadableStream<Uint8Array>): Promise<TemporaryFile> {
-    const file = new TemporaryFile();
-    await file.write(content);
-
-    return file;
-  }
-
-  async read(): Promise<Uint8Array> {
-    return readFile(this.#path);
-  }
-
-  async readText(): Promise<string> {
-    return readFile(this.#path, { encoding: 'utf8' });
-  }
-
-  readStream(): ReadableStream<Uint8Array> {
-    const stream = createReadStream(this.#path);
-    return Readable.toWeb(stream) as ReadableStream<Uint8Array>;
-  }
-
-  async write(content: string | Uint8Array | ReadableStream<Uint8Array>): Promise<void> {
-    await writeFile(this.#path, content as string | Uint8Array | AsyncIterable<Uint8Array>);
-  }
-
-  async delete(): Promise<void> {
-    await unlink(this.#path);
-  }
-
-  async size(): Promise<number> {
-    const result = await stat(this.#path);
-    return result.size;
-  }
-
-  async [Symbol.asyncDispose](): Promise<void> {
-    try {
-      await this.delete();
-    }
-    catch { }
-  }
-}

package/source/formats/formats.ts

@@ -1,192 +0,0 @@
-import { numericDateToTimestamp } from '#/utils/date-time.js';
-import { memoize, memoizeSingle } from '#/utils/function/memoize.js';
-import { isNullOrUndefined, isUndefined } from '#/utils/type-guards.js';
-
-export let locale = 'de-DE';
-
-export function configureFormats(options: { locale?: string }): void {
-  locale = options.locale ?? locale;
-}
-
-export const integerFormat: Intl.NumberFormatOptions = {
-  useGrouping: true,
-  maximumFractionDigits: 0,
-};
-
-export const decimalFormat: Intl.NumberFormatOptions = {
-  useGrouping: true,
-  minimumFractionDigits: 2,
-  maximumFractionDigits: 2,
-};
-
-export const decimal1Format: Intl.NumberFormatOptions = {
-  useGrouping: true,
-  minimumFractionDigits: 0,
-  maximumFractionDigits: 1,
-};
-
-export const yearFormat: Intl.NumberFormatOptions = {
-  useGrouping: false,
-  maximumFractionDigits: 0,
-};
-
-export const dateTimeNumeric: Intl.DateTimeFormatOptions = {
-  year: 'numeric',
-  month: '2-digit',
-  day: '2-digit',
-  hour: '2-digit',
-  minute: '2-digit',
-};
-
-export const dateTimeShort: Intl.DateTimeFormatOptions = {
-  year: 'numeric',
-  month: 'short',
-  day: '2-digit',
-  hour: '2-digit',
-  minute: '2-digit',
-};
-
-export const dateTimeLong: Intl.DateTimeFormatOptions = {
-  year: 'numeric',
-  weekday: 'long',
-  month: 'long',
-  day: '2-digit',
-  hour: '2-digit',
-  minute: '2-digit',
-};
-
-export const dateShort: Intl.DateTimeFormatOptions = {
-  year: 'numeric',
-  month: '2-digit',
-  day: '2-digit',
-};
-
-export const dateMedium: Intl.DateTimeFormatOptions = {
-  year: 'numeric',
-  month: 'long',
-  day: '2-digit',
-};
-
-export const dateLong: Intl.DateTimeFormatOptions = {
-  year: 'numeric',
-  weekday: 'long',
-  month: 'long',
-  day: '2-digit',
-};
-
-export const timeShort: Intl.DateTimeFormatOptions = {
-  hour: '2-digit',
-  minute: '2-digit',
-};
-
-export const currencyFormat: Intl.NumberFormatOptions = {
-  style: 'currency',
-};
-
-export const currencyFormatWithoutCents: Intl.NumberFormatOptions = {
-  ...currencyFormat,
-  minimumFractionDigits: 0,
-};
-
-export const percentFormat: Intl.NumberFormatOptions = {
-  style: 'percent',
-  minimumFractionDigits: 2,
-  maximumFractionDigits: 2,
-};
-
-const getDecimalFormatter = memoize(_getDecimalFormatter);
-
-const integerFormatter = memoizeSingle((loc: string) => Intl.NumberFormat(loc, integerFormat));
-const decimalFormatter = memoizeSingle((loc: string) => Intl.NumberFormat(loc, decimalFormat));
-const yearFormatter = memoizeSingle((loc: string) => Intl.NumberFormat(loc, yearFormat));
-const percentFormatter = memoizeSingle((loc: string) => Intl.NumberFormat(loc, percentFormat));
-const dateFormatter = memoizeSingle((loc: string) => Intl.DateTimeFormat(loc, dateShort));
-const currencyFormatter = memoize((currency: string, loc: string) => Intl.NumberFormat(loc, { ...currencyFormat, currency }));
-const currencyFormatterWithoutCents = memoize((currency: string, loc: string) => Intl.NumberFormat(loc, { ...currencyFormatWithoutCents, currency }));
-const timeShortFormatter = memoizeSingle((loc: string) => Intl.DateTimeFormat(loc, timeShort));
-const dateShortFormatter = memoizeSingle((loc: string) => Intl.DateTimeFormat(loc, dateShort));
-
-export function formatNumber(value: number, format?: Intl.NumberFormatOptions): string {
-  return Intl.NumberFormat(locale, format).format(value);
-}
-
-export function formatInteger(value: number): string {
-  return integerFormatter(locale).format(value);
-}
-
-export function formatDecimal(value: number, minimumFractionDigits?: number, maximumFractionDigits?: number): string {
-  if (isUndefined(minimumFractionDigits) && isUndefined(maximumFractionDigits)) {
-    return decimalFormatter(locale).format(value);
-  }
-
-  return getDecimalFormatter(locale, minimumFractionDigits ?? 2, maximumFractionDigits ?? 2).format(value);
-}
-
-export function formatYear(value: number): string {
-  return yearFormatter(locale).format(value);
-}
-
-export function formatTimeShort(value: number): string {
-  return timeShortFormatter(locale).format(new Date(1970, 1, 1, 0, 0, 0, value));
-}
-
-export function formatDateShort(value: Date | number): string {
-  return dateShortFormatter(locale).format(value);
-}
-
-export function formatDate(dateOrTimestamp: number | Date): string {
-  return dateFormatter(locale).format(dateOrTimestamp);
-}
-
-export function formatNumericDate(numericDate: number): string {
-  return formatDate(numericDateToTimestamp(numericDate));
-}
-
-export function formatCurrency(value: number, currency: string): string {
-  return currencyFormatter(currency, locale).format(value);
-}
-
-export function formatCurrencyWithoutCents(value: number, currency: string): string {
-  return currencyFormatterWithoutCents(currency, locale).format(value);
-}
-
-export function formatEuro(value: number): string {
-  return currencyFormatter('EUR', locale).format(value);
-}
-
-export function formatEuroWithoutCents(value: number): string {
-  return currencyFormatterWithoutCents('EUR', locale).format(value);
-}
-
-export function formatPercent(value: number): string {
-  return percentFormatter(locale).format(value);
-}
-
-export type FormatPersonNameOptions<F = unknown> = { lastNameFirst?: boolean, fallback?: F };
-
-export function formatPersonName<F>(person: { firstName?: string | null, lastName?: string | null } | null | undefined, options: FormatPersonNameOptions<F> & { fallback: F }): string | F;
-export function formatPersonName(person: { firstName?: string | null, lastName?: string | null } | null | undefined, options?: FormatPersonNameOptions & { fallback?: undefined }): string;
-export function formatPersonName<F>(person: { firstName?: string | null, lastName?: string | null } | null | undefined, { lastNameFirst = false, fallback }: FormatPersonNameOptions<F> = {}): string | F {
-  if (isNullOrUndefined(person?.firstName) || isNullOrUndefined(person.lastName)) {
-    return person?.firstName ?? person?.lastName ?? fallback ?? '-';
-  }
-
-  if (lastNameFirst) {
-    return `${person.lastName}, ${person.firstName}`;
-  }
-
-  return `${person.firstName} ${person.lastName}`;
-}
-
-/**
- * @deprecated use {@link formatPersonName} instead
- */
-export const formatUserName = formatPersonName;
-
-function _getDecimalFormatter(locale: string, minimumFractionDigits = 2, maximumFractionDigits = 2): Intl.NumberFormat {
-  return Intl.NumberFormat(locale, {
-    useGrouping: true,
-    minimumFractionDigits,
-    maximumFractionDigits,
-  });
-}

package/source/formats/index.ts

@@ -1 +0,0 @@
-export * from './formats.js';

package/source/function/index.ts

@@ -1,7 +0,0 @@
-/**
- * Tools around functions
- *
- * @module Function
- */
-
-export * from './log.js';

package/source/function/log.ts

@@ -1,46 +0,0 @@
-import type { Logger } from '#/logger/logger.js';
-import { isArray, isPrimitive, isString } from '#/utils/type-guards.js';
-import { typeOf } from '#/utils/type-of.js';
-
-export type WrapLogOptions = {
-  fnName?: string,
-  logResult?: boolean,
-  logger?: Logger,
-  trace?: boolean,
-};
-
-export function wrapLog(fn: Function, { fnName = fn.name, logResult = true, logger, trace = false }: WrapLogOptions = {}): Function {
-  const log = logger?.trace.bind(logger) ?? console.log.bind(console);
-
-  const wrapped = {
-    [fnName](...args: any[]): unknown {
-      const argString = args.map((arg) => stringifyValue(arg)).join(', ');
-
-      log(`[call: ${fnName}(${argString})]`);
-
-      if (trace) {
-        console.trace();
-      }
-
-      const result = Reflect.apply(fn, this, args);
-
-      if (logResult) {
-        const resultString = stringifyValue(result);
-        log(`[return: ${fnName} => ${resultString}]`);
-      }
-
-      return result;
-    },
-  };
-
-  return wrapped[fnName]!;
-}
-
-function stringifyValue(arg: any, depth = 1): string {
-  if (isArray(arg) && (depth > 0)) {
-    const argString = arg.map((innerArg) => stringifyValue(innerArg, depth - 1)).join(', ');
-    return `[${argString}]`;
-  }
-
-  return isPrimitive(arg) ? isString(arg) ? `"${arg}"` : String(arg) : typeOf(arg);
-}

package/source/http/README.md

@@ -1,367 +0,0 @@
-# @tstdl/base/http
-
-A powerful, isomorphic, middleware-based HTTP client and server library for TypeScript. This module provides a comprehensive suite of tools for handling HTTP communication, featuring a flexible client with a middleware pipeline and a modern, async-iterable-based server.
-
-## Table of Contents
-
-- [Features](#features)
-- [Core Concepts](#core-concepts)
-  - [HTTP Client](#http-client)
-  - [HTTP Server](#http-server)
-- [Usage](#usage)
-  - [Client](#client)
-    - [Client Setup](#client-setup)
-    - [Making Requests](#making-requests)
-    - [Handling Responses](#handling-responses)
-    - [Using Middleware](#using-middleware)
-    - [Bypassing Caches](#bypassing-caches)
-    - [Error Handling](#error-handling)
-  - [Server](#server)
-    - [Server Setup](#server-setup)
-    - [Handling Incoming Requests](#handling-incoming-requests)
-- [API Summary](#api-summary)
-  - [Configuration](#configuration)
-  - [Client Classes](#client-classes)
-  - [Server Classes](#server-classes)
-
-## Features
-
-- **Isomorphic Design:** Shared abstractions for client and server, with specific adapters for different environments (e.g., `undici` for Node.js).
-- **Middleware-Driven Client:** Intercept and modify requests/responses using a flexible async middleware pipeline for concerns like logging, authentication, and caching.
-- **Pluggable Client Adapter:** The `HttpClientAdapter` allows swapping the underlying HTTP engine. `UndiciHttpClientAdapter` is provided for high-performance Node.js applications.
-- **Modern Server Abstraction:** The `HttpServer` uses an async iterator pattern (`for await...of`) for elegant and efficient request handling.
-- **Advanced Body Handling:** Seamlessly works with JSON, text, forms (`x-www-form-urlencoded`), `FormData`, binary (`Uint8Array`, `Blob`), and `ReadableStream`.
-- **Automatic Parameter Mapping:** Intelligently maps request parameters to URL path segments, query strings, or the request body.
-- **Typed API:** Strongly typed interfaces for requests, responses, headers, and query parameters to catch errors at compile time.
-- **Utility Classes:** Helpers like `HttpHeaders`, `HttpQuery`, and `HttpForm` simplify common tasks.
-
-## Core Concepts
-
-### HTTP Client
-
-The client is designed around three main components: `HttpClient`, `HttpClientAdapter`, and `HttpClientMiddleware`.
-
-- **`HttpClient`**: The primary interface for making requests. It manages configuration, default headers, and the middleware pipeline. It offers convenience methods like `getJson()`, `post()`, etc. The flow of a request is: `HttpClient` -> `Middleware Chain` -> `HttpClientAdapter`.
-
-- **`HttpClientAdapter`**: The "engine" that performs the actual HTTP call. The library is decoupled from any specific implementation. For Node.js, the `UndiciHttpClientAdapter` is provided, which uses the high-performance `undici` library. You must configure an adapter for the client to function.
-
-- **`HttpClientMiddleware`**: A function that intercepts a request before it's sent and the response after it's received. Middleware is composed into a pipeline, allowing for cross-cutting concerns like logging, authentication, request modification, and custom error handling. Each middleware receives a `context` object (containing the request and eventually the response) and a `next` function to pass control to the next middleware in the chain.
-
-### HTTP Server
-
-The server implementation is based on the `HttpServer` abstract class.
-
-- **`HttpServer`**: An async iterable that yields a `HttpServerRequestContext` for each incoming connection. This design promotes a clean, modern loop for processing requests (`for await (const context of server)`).
-
-- **`HttpServerRequestContext`**: An object that encapsulates everything needed to handle a single request. It contains:
-  - `request`: An `HttpServerRequest` instance with details like URL, method, headers, and body.
-  - `respond`: A function to send an `HttpServerResponse` back to the client.
-  - `close`: A function to close the connection.
-  - `context`: The raw context from the underlying server implementation (e.g., Node.js `IncomingMessage` and `ServerResponse`).
-
-- **`NodeHttpServer`**: The default implementation of `HttpServer` for Node.js, built on top of the native `node:http` module. It supports features like trusted proxy IP resolution.
-
-## Usage
-
-### Client
-
-#### Client Setup
-
-First, configure the `HttpClient` with an adapter. In a Node.js environment, use the `UndiciHttpClientAdapter`.
-
-```typescript
-import { HttpClient, configureHttpClient, configureUndiciHttpClientAdapter } from '@tstdl/base/http';
-import { Injector } from '@tstdl/base/injector';
-
-// Configure and register the Undici adapter
-configureUndiciHttpClientAdapter({ register: true });
-
-// Configure the HttpClient with a base URL
-configureHttpClient({
-  baseUrl: 'https://api.example.com'
-});
-
-// Get an instance of the client from the DI container
-const httpClient = Injector.resolve(HttpClient);
-```
-
-#### Making Requests
-
-The `HttpClient` provides intuitive methods for all common HTTP verbs. It also supports automatic parameter mapping.
-
-**Simple GET Request**
-```typescript
-const response = await httpClient.get('/users');
-const users = await response.body.readAsJson();
-```
-
-**GET with Query Parameters**
-You can provide query parameters via the `query` object or use automatic mapping with the `parameters` object.
-```typescript
-// Using the `query` object
-const user = await httpClient.getJson('/users', {
-  query: { id: 123 }
-});
-
-// Using automatic parameter mapping
-const products = await httpClient.getJson('/products', {
-  parameters: { category: 'electronics', inStock: true }
-});
-// Resulting URL: /products?category=electronics&inStock=true
-```
-
-**URL Path Parameters**
-```typescript
-// Maps `userId` to the URL path segment.
-const user = await httpClient.getJson('/users/:userId', {
-  parameters: { userId: 'abc-123' }
-});
-// Resulting URL: /users/abc-123
-```
-
-**POST with JSON Body**
-```typescript
-const newProduct = { name: 'Super Widget', price: 99.99 };
-const createdProduct = await httpClient.postJson('/products', {
-  body: { json: newProduct }
-});
-```
-
-**POST with Form Data**
-```typescript
-// for application/x-www-form-urlencoded
-const response = await httpClient.post('/login', {
-  body: {
-    form: {
-      username: 'test',
-      password: 'password123'
-    }
-  }
-});
-
-// for multipart/form-data
-const formData = new FormData();
-formData.append('username', 'testuser');
-formData.append('avatar', new Blob(['...file content...']), 'avatar.jpg');
-
-await httpClient.post('/users/profile-picture', {
-  body: { formData }
-});
-```
-
-#### Handling Responses
-
-The `HttpClientResponse` object contains the status, headers, and a `body` property of type `HttpBody` for easy content access. The body can only be read once.
-
-```typescript
-const response = await httpClient.get('/products/1');
-
-console.log(response.statusCode); // 200
-console.log(response.headers.contentType); // 'application/json'
-
-// Read the body based on its type
-if (response.statusCode == 200) {
-  const item = await response.body.readAsJson(); // or .readAsText(), .readAsBuffer(), ...
-  console.log(item);
-}
-
-// Streaming a response body
-const stream = response.body.readAsBinaryStream();
-for await (const chunk of stream) {
-  console.log(`Received ${chunk.length} bytes`);
-}
-```
-
-#### Using Middleware
-
-Middleware can be used to add common functionality like authentication or logging.
-
-```typescript
-import {
-  HttpClient,
-  configureHttpClient,
-  configureUndiciHttpClientAdapter,
-  type HttpClientMiddleware,
-  type HttpClientMiddlewareContext,
-  type HttpClientMiddlewareNext
-} from '@tstdl/base/http';
-import { Injector } from '@tstdl/base/injector';
-
-// An authentication middleware
-const authMiddleware: HttpClientMiddleware = async (context: HttpClientMiddlewareContext, next: HttpClientMiddlewareNext) => {
-  context.request.headers.set('Authorization', 'Bearer my-secret-token');
-  await next();
-};
-
-configureUndiciHttpClientAdapter();
-configureHttpClient({
-  middleware: [authMiddleware]
-});
-
-const httpClient = Injector.resolve(HttpClient);
-await httpClient.get('/secure-data');
-```
-
-#### Bypassing Caches
-
-Some adapters or middleware may implement caching. To bypass this for a specific request, you can use the `bustCache` token in the request context.
-
-```typescript
-import { bustCache, HttpClient } from '@tstdl/base/http';
-import { Injector } from '@tstdl/base/injector';
-
-const httpClient = Injector.resolve(HttpClient);
-
-// This request will signal to bypass any caching layers
-const freshData = await httpClient.getJson('/real-time-data', {
-  context: { [bustCache]: true }
-});
-```
-
-#### Error Handling
-
-By default, the client throws an `HttpError` for responses with non-2xx status codes.
-
-```typescript
-import { HttpError } from '@tstdl/base/http';
-
-try {
-  await httpClient.get('/not-found');
-} catch (error) {
-  if (error instanceof HttpError) {
-    console.error(`HTTP Error: ${error.reason}`); // e.g., 'Not Found'
-    console.error(`Status: ${error.response?.statusCode}`); // 404
-
-    // The raw response instance is available on the error for inspection
-    const bodyText = await error.responseInstance?.body.readAsText();
-    console.error('Body:', bodyText);
-  } else {
-    console.error('An unknown error occurred:', error);
-  }
-}
-```
-
-### Server
-
-#### Server Setup
-
-Configure and run the `HttpServer`.
-
-```typescript
-import { configureNodeHttpServer, HttpServer } from '@tstdl/base/http/server';
-import { Injector } from '@tstdl/base/injector';
-
-// Register the Node.js server implementation
-configureNodeHttpServer();
-
-const httpServer = Injector.resolve(HttpServer);
-
-// Start listening on port 3000
-httpServer.listen(3000);
-```
-
-#### Handling Incoming Requests
-
-Loop through incoming requests using the async iterator pattern.
-
-```typescript
-import {
-  HttpServer,
-  HttpServerResponse,
-  type HttpServerRequestContext
-} from '@tstdl/base/http/server';
-import { Injector } from '@tstdl/base/injector';
-
-const httpServer = Injector.resolve(HttpServer);
-
-async function main(): Promise<void> {
-  console.log('Server starting...');
-  await httpServer.listen(3000);
-
-  for await (const context of httpServer) {
-    handleRequest(context).catch((error) => {
-      console.error('Failed to handle request', error);
-      context.close();
-    });
-  }
-}
-
-async function handleRequest(context: HttpServerRequestContext): Promise<void> {
-  const { request, respond } = context;
-  const { url, method } = request;
-
-  if (url.pathname == '/users' && method == 'GET') {
-    const users = [{ id: 1, name: 'John Doe' }];
-    await respond(new HttpServerResponse({
-      statusCode: 200,
-      headers: { 'Content-Type': 'application/json' },
-      body: { json: users }
-    }));
-  } else if (url.pathname == '/users' && method == 'POST') {
-    const newUser = await request.body.readAsJson();
-    console.log('New user:', newUser);
-    await respond(new HttpServerResponse({ statusCode: 201 }));
-  } else if (url.pathname == '/redirect') {
-    await respond(HttpServerResponse.redirect('/users'));
-  } else {
-    await respond(new HttpServerResponse({
-      statusCode: 404,
-      body: { text: 'Not Found' }
-    }));
-  }
-}
-
-main();
-```
-
-## API Summary
-
-### Configuration
-
-| Function | Signature | Description |
-| :--- | :--- | :--- |
-| **`configureHttpClient`** | `(config: HttpClientModuleConfig) => void` | Configures the global `HttpClient`, its adapter, and middleware. |
-| **`configureUndiciHttpClientAdapter`** | `(options?: UndiciHttpClientAdapterOptions & { register?: boolean }) => void` | Configures and optionally registers the `UndiciHttpClientAdapter`. |
-| **`configureNodeHttpServer`** | `(configuration?: Partial<NodeHttpServerConfiguration>) => void` | Registers the `NodeHttpServer` as the default `HttpServer`. |
-
-### Client Classes
-
-| Class / Method / Property | Signature / Type | Description |
-| :--- | :--- | :--- |
-| `HttpClient` | `class` | The main entry point for making HTTP requests. |
-| **`getJson<T>`** | `(url: string, options?: HttpClientRequestOptions) => Promise<T>` | Performs a GET request and parses the response body as JSON. |
-| **`postJson<T>`** | `(url: string, options?: HttpClientRequestOptions) => Promise<T>` | Performs a POST request and parses the response body as JSON. |
-| **`request`** | `(method: HttpMethod, url: string, options?: HttpClientRequestOptions) => Promise<HttpClientResponse>` | Performs a request with the specified method. |
-| `HttpClientRequest` | `class` | Represents an outgoing HTTP request. |
-| **`url`** | `string` | The full request URL. |
-| **`method`** | `HttpMethod` | The HTTP method (e.g., 'GET', 'POST'). |
-| **`headers`** | `HttpHeaders` | A map-like object for request headers. |
-| **`body`** | `HttpRequestBody \| undefined` | The request body, supporting various types. |
-| **`abort()`** | `() => void` | Aborts the request. |
-| `HttpClientResponse` | `class` | Represents an incoming HTTP response. |
-| **`statusCode`** | `number` | The HTTP status code. |
-| **`headers`** | `HttpHeaders` | A map-like object for response headers. |
-| **`body`** | `HttpBody` | The response body handler. |
-| **`close()`** | `() => void` | Closes the response and releases resources. |
-| `HttpBody` | `class` | Provides methods to read the response body in various formats. |
-| **`readAsBuffer()`** | `() => Promise<Uint8Array>` | Reads the body as a buffer. |
-| **`readAsText()`** | `() => Promise<string>` | Reads the body as a string. |
-| **`readAsJson<T>()`** | `() => Promise<T>` | Reads and parses the body as JSON. |
-| **`readAsBinaryStream()`** | `() => ReadableStream<Uint8Array>` | Reads the body as a binary stream. |
-
-### Server Classes
-
-| Class / Method / Property | Signature / Type | Description |
-| :--- | :--- | :--- |
-| `HttpServer` | `abstract class` | An async iterable server for handling HTTP requests. |
-| **`listen`** | `(port: number) => Promise<void>` | Starts listening on the given port. |
-| **`close`** | `(timeout: number) => Promise<void>` | Stops the server gracefully within a timeout. |
-| `HttpServerRequest` | `class` | Represents an incoming HTTP request on the server. |
-| **`url`** | `URL` | The parsed URL of the request. |
-| **`method`** | `HttpMethod` | The HTTP method. |
-| **`headers`** | `HttpHeaders` | Incoming request headers. |
-| **`body`** | `HttpBody` | The request body handler. |
-| **`ip`** | `string` | The client's IP address. |
-| `HttpServerResponse` | `class` | Represents an outgoing HTTP response from the server. |
-| **`constructor`** | `(options?: HttpServerResponseOptions) => HttpServerResponse` | Creates a new response object. |
-| **`redirect`** | `(url: string, options?: HttpServerResponseOptions) => HttpServerResponse` | Creates a redirect response (303). |