@npy/fetch 0.1.2 → 0.1.3

package/io/writers.js

@@ -1,195 +0,0 @@
-import { bytesToStream } from "../_internal/streams.js";
-import { createEncoders, encodeStream } from "../encoding.js";
-import { parseContentLength, parseTransferEncoding } from "./_utils.js";
-import { sanitizeHeaderValue } from "./readers.js";
-import { isFumanReadable, isReadableStream } from "../_internal/guards.js";
-import { extractBody } from "../body.js";
-import { BufWriter } from "./buf-writer.js";
-import { nodeReadableToWeb } from "@fuman/node";
-import { Bytes, fumanReadableToWeb, write } from "@fuman/io";
-//#region src/io/writers.ts
-function toRequestTarget(url) {
-	return (url.pathname?.startsWith("/") ? url.pathname : "/") + (url.search || "");
-}
-function encodeHead(into, head) {
-	write.rawString(into, `${head.method.toUpperCase()} ${head.target} HTTP/1.1\r
-`);
-	for (const [k, v] of head.headers) write.rawString(into, `${k}: ${sanitizeHeaderValue(v)}\r
-`);
-	write.rawString(into, "\r\n");
-}
-function prepareBody(headers, init) {
-	const state = extractBody(init);
-	if (state.body != null && !headers.has("content-type")) headers.set("content-type", state.contentType ?? "application/octet-stream");
-	const body = state.body;
-	if (body == null) return { kind: "none" };
-	if (body instanceof Uint8Array) return {
-		kind: "bytes",
-		bytes: body,
-		length: body.byteLength
-	};
-	if (isReadableStream(body)) return {
-		kind: "stream",
-		stream: body,
-		length: state.contentLength
-	};
-	if (isFumanReadable(body)) return {
-		kind: "stream",
-		stream: fumanReadableToWeb(body),
-		length: state.contentLength
-	};
-	return {
-		kind: "stream",
-		stream: nodeReadableToWeb(body),
-		length: state.contentLength
-	};
-}
-function finalizeDelimitation(headers, body) {
-	if (body.kind === "none") return { chunked: false };
-	const te = parseTransferEncoding(headers);
-	if (te.has) {
-		headers.delete("content-length");
-		if (!te.chunked) {
-			const tokens = [...te.codings, "chunked"].filter(Boolean);
-			headers.set("transfer-encoding", tokens.join(", "));
-		}
-		return { chunked: true };
-	}
-	const knownLength = body.kind === "bytes" ? body.length : body.length ?? null;
-	if (knownLength != null) {
-		const existing = parseContentLength(headers);
-		if (existing != null && existing !== knownLength) throw new Error(`Conflicting content-length: header=${existing} body=${knownLength}`);
-		if (existing == null) headers.set("content-length", String(knownLength));
-		return { chunked: false };
-	}
-	if (parseContentLength(headers) != null) return { chunked: false };
-	headers.set("transfer-encoding", "chunked");
-	headers.delete("content-length");
-	return { chunked: true };
-}
-function createBufferedConnWriter(dst, opts) {
-	const bufferSize = opts.writeBufferSize ?? 16 * 1024;
-	const directWriteThreshold = opts.directWriteThreshold ?? 64 * 1024;
-	const bufWriter = new BufWriter(dst, bufferSize);
-	const flush = async () => {
-		await bufWriter.flush();
-	};
-	const writeBytes = async (bytes) => {
-		if (bytes.length === 0) return;
-		if (bytes.length >= directWriteThreshold) {
-			await bufWriter.flush();
-			await dst.write(bytes);
-			return;
-		}
-		await bufWriter.write(bytes);
-	};
-	const writeRawString = async (str) => {
-		if (str.length === 0) return;
-		write.rawString(bufWriter, str);
-	};
-	return {
-		flush,
-		writeBytes,
-		writeRawString,
-		directWriteThreshold
-	};
-}
-async function writeBody(dst, body, chunked, opts, signal) {
-	const bw = createBufferedConnWriter(dst, opts);
-	const writeChunk = async (chunk) => {
-		if (signal?.aborted) throw signal.reason ?? /* @__PURE__ */ new Error("Request aborted");
-		if (!chunked) {
-			await bw.writeBytes(chunk);
-			return;
-		}
-		if (chunk.length === 0) return;
-		await bw.writeRawString(chunk.length.toString(16));
-		await bw.writeRawString("\r\n");
-		await bw.writeBytes(chunk);
-		await bw.writeRawString("\r\n");
-	};
-	if (body.kind === "bytes") await writeChunk(body.bytes);
-	else for await (const chunk of body.stream) await writeChunk(chunk);
-	if (chunked) await bw.writeRawString(`0\r
-\r
-`);
-	await bw.flush();
-}
-async function writeCoalesced(dst, scratch, head, bodyBytes, chunked) {
-	scratch.reset();
-	encodeHead(scratch, head);
-	if (!chunked) {
-		write.bytes(scratch, bodyBytes);
-		await dst.write(scratch.result());
-		scratch.reset();
-		return;
-	}
-	write.rawString(scratch, bodyBytes.length.toString(16));
-	write.rawString(scratch, "\r\n");
-	write.bytes(scratch, bodyBytes);
-	write.rawString(scratch, `\r
-0\r
-\r
-`);
-	await dst.write(scratch.result());
-	scratch.reset();
-}
-function createRequestWriter(dst, opts = {}) {
-	const scratch = Bytes.alloc(opts.writeBufferSize ?? 16 * 1024);
-	const write = async (req) => {
-		if (req.signal?.aborted) throw req.signal.reason ?? /* @__PURE__ */ new Error("Request aborted");
-		const method = req.method.toUpperCase();
-		const headers = req.headers ? new Headers(req.headers) : new Headers();
-		const url = req.url;
-		if (!headers.has("host")) headers.set("host", url.host);
-		if (!headers.has("date")) headers.set("date", (/* @__PURE__ */ new Date()).toUTCString());
-		const target = toRequestTarget(url);
-		let body = prepareBody(headers, req.body ?? null);
-		const ceRaw = headers.get("content-encoding") ?? void 0;
-		const ceEncoders = createEncoders(ceRaw);
-		if (body.kind !== "none" && ceEncoders.length > 0) {
-			body = {
-				kind: "stream",
-				stream: encodeStream(body.kind === "stream" ? body.stream : bytesToStream(body.bytes), ceRaw),
-				length: null
-			};
-			headers.delete("content-length");
-		}
-		const teInfo = parseTransferEncoding(headers);
-		if (body.kind !== "none" && teInfo.has && teInfo.codings.length > 0) {
-			body = {
-				kind: "stream",
-				stream: encodeStream(body.kind === "stream" ? body.stream : bytesToStream(body.bytes), teInfo.codings),
-				length: null
-			};
-			headers.delete("content-length");
-		}
-		const { chunked } = finalizeDelimitation(headers, body);
-		const head = {
-			method,
-			target,
-			headers
-		};
-		if (body.kind === "bytes") {
-			const max = opts.coalesceBodyMaxBytes ?? 64 * 1024;
-			if (body.bytes.length <= max) {
-				await writeCoalesced(dst, scratch, head, body.bytes, chunked);
-				return;
-			}
-		}
-		scratch.reset();
-		encodeHead(scratch, head);
-		await dst.write(scratch.result());
-		scratch.reset();
-		if (body.kind === "none") return;
-		if (body.kind === "bytes" && !chunked) {
-			if (req.signal?.aborted) throw req.signal.reason ?? /* @__PURE__ */ new Error("Request aborted");
-			await dst.write(body.bytes);
-			return;
-		}
-		await writeBody(dst, body, chunked, opts, req.signal);
-	};
-	return { write };
-}
-//#endregion
-export { createRequestWriter };

package/types/agent.d.ts

@@ -1,72 +0,0 @@
-import { BodyInit } from '../body';
-import { LineReader, Readers } from '../io/readers';
-import { Writers } from '../io/writers';
-import { Dialer } from './dialer';
-export interface Agent {
-    [Symbol.dispose](): void;
-    close(): void;
-    readonly hostname: string;
-    readonly port: number;
-    /**
-     * Sends a single HTTP request and returns the raw {@link Response}.
-     *
-     * @remarks
-     * The returned response body preserves the advanced error mapping of this library.
-     * Limits configured through reader options are enforced while the body is consumed.
-     */
-    send(options: Agent.SendOptions): Promise<Response>;
-    whenIdle(): Promise<void>;
-    readonly isIdle: boolean;
-    readonly lastUsed: number;
-}
-export declare namespace Agent {
-    interface ConnectOptions {
-        timeout?: number;
-        keepAlive?: boolean | null;
-        noDelay?: boolean;
-    }
-    type ReaderOptions = Readers.Options & LineReader.ReadHeadersOptions;
-    type WriterOptions = Writers.Options;
-    interface IOOptions {
-        reader?: ReaderOptions;
-        writer?: WriterOptions;
-    }
-    interface Options {
-        connect?: ConnectOptions;
-        io?: IOOptions;
-    }
-    interface SendOptions {
-        url: string | URL;
-        method: string;
-        headers?: Headers;
-        body?: BodyInit | null;
-        signal?: AbortSignal;
-    }
-}
-export interface AgentPool {
-    [Symbol.asyncDispose](): Promise<void>;
-    close(): Promise<void>;
-    readonly hostname: string;
-    readonly port: number;
-    send(options: Agent.SendOptions): Promise<Response>;
-}
-export declare namespace AgentPool {
-    interface Options {
-        dialer?: Dialer;
-        poolMaxIdlePerHost?: number;
-        poolMaxPerHost?: number;
-        poolIdleTimeout?: number | false;
-        connect?: Agent.ConnectOptions;
-        io?: Agent.IOOptions;
-    }
-}
-export interface AgentConnectOptions extends Agent.ConnectOptions {
-}
-export interface AgentPoolOptions extends AgentPool.Options {
-}
-export interface SendOptions extends Agent.SendOptions {
-}
-export interface AgentIOOptions extends Agent.IOOptions {
-}
-export type AgentReaderOptions = Agent.ReaderOptions;
-export type AgentWriterOptions = Agent.WriterOptions;

package/types/dialer.d.ts

@@ -1,30 +0,0 @@
-import { ITcpConnection, ITlsConnection } from '@fuman/net';
-import { NodeTlsConnectOptions } from '@fuman/node';
-/**
- * Transport abstraction responsible for opening a connection to an HTTP target.
- */
-export interface Dialer {
-    dial(target: Dialer.Target, options?: Dialer.Options): Promise<Dialer.ConnectionLike>;
-}
-export declare namespace Dialer {
-    type ConnectionLike = ITcpConnection | ITlsConnection;
-    interface Target {
-        address: string;
-        port: number;
-        secure: boolean;
-        /** Server Name Indication (TLS). Defaults to the host when applicable. */
-        sni?: string;
-        /** Defaults to ["http/1.1"] when omitted by the dialer implementation. */
-        alpnProtocols?: string[];
-        /** Extra Node.js TLS options (minVersion, servername, etc.). */
-        extraOptions?: NodeTlsConnectOptions["extraOptions"];
-    }
-    interface Options {
-        signal?: AbortSignal;
-    }
-}
-/** Back-compat */
-export type ConnectionLike = Dialer.ConnectionLike;
-/** Back-compat */
-export interface DialTarget extends Dialer.Target {
-}

package/types/index.d.cts

@@ -1,2 +0,0 @@
-export * from './agent';
-export * from './dialer';

package/types/index.d.ts

@@ -1,2 +0,0 @@
-export * from './agent';
-export * from './dialer';