@npy/fetch 0.1.3 → 0.1.4

package/index.d.cts

@@ -0,0 +1,14 @@
+export type { FormDataPolyfill } from './_internal/guards';
+export type { WithSignal } from './_internal/net';
+export { connectTcp, connectTls, upgradeTls } from './_internal/net';
+export * from './agent';
+export * from './agent-pool';
+export * from './body';
+export * from './dialers';
+export * from './encoding';
+export * from './errors';
+export * from './fetch';
+export * from './http-client';
+export type { LineReader, Readers } from './io/readers';
+export type { Writers } from './io/writers';
+export * from './types';

package/index.d.ts

@@ -0,0 +1,14 @@
+export type { FormDataPolyfill } from './_internal/guards';
+export type { WithSignal } from './_internal/net';
+export { connectTcp, connectTls, upgradeTls } from './_internal/net';
+export * from './agent';
+export * from './agent-pool';
+export * from './body';
+export * from './dialers';
+export * from './encoding';
+export * from './errors';
+export * from './fetch';
+export * from './http-client';
+export type { LineReader, Readers } from './io/readers';
+export type { Writers } from './io/writers';
+export * from './types';

package/index.js

@@ -0,0 +1,11 @@
+import { connectTcp, connectTls, upgradeTls } from "./_internal/net.js";
+import { AgentBusyError, AgentClosedError, ConnectTimeoutError, ConnectionError, ErrorType, FetchError, FetchErrorCode, HttpStatusError, OriginMismatchError, RequestAbortedError, RequestWriteError, ResponseBodyError, ResponseDecodeError, ResponseHeaderError, UnsupportedAlpnProtocolError, UnsupportedMethodError, UnsupportedProtocolError } from "./errors.js";
+import { createDecoders, createEncoders, decodeStream, encodeStream } from "./encoding.js";
+import { extractBody, fromRequestBody, getFormDataLength } from "./body.js";
+import { createAgent } from "./agent.js";
+import { ProxyDialer } from "./dialers/proxy.js";
+import { AutoDialer, TcpDialer, TlsDialer, resolveHostPort } from "./dialers/tcp.js";
+import { createAgentPool } from "./agent-pool.js";
+import { HttpClient } from "./http-client.js";
+import fetch, { createFetch, normalizeHeaders } from "./fetch.js";
+export { AgentBusyError, AgentClosedError, AutoDialer, ConnectTimeoutError, ConnectionError, ErrorType, FetchError, FetchErrorCode, HttpClient, HttpStatusError, OriginMismatchError, ProxyDialer, RequestAbortedError, RequestWriteError, ResponseBodyError, ResponseDecodeError, ResponseHeaderError, TcpDialer, TlsDialer, UnsupportedAlpnProtocolError, UnsupportedMethodError, UnsupportedProtocolError, connectTcp, connectTls, createAgent, createAgentPool, createDecoders, createEncoders, createFetch, decodeStream, encodeStream, extractBody, fetch, fromRequestBody, getFormDataLength, normalizeHeaders, resolveHostPort, upgradeTls };

package/io/_utils.cjs

@@ -0,0 +1,56 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let bytes = require("bytes");
+bytes = require_runtime.__toESM(bytes);
+//#region src/io/_utils.ts
+function parseMaxBytes(value) {
+	if (value === void 0) return null;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value) || value < 0) throw new Error(`invalid max size: ${String(value)}`);
+		return Math.floor(value);
+	}
+	const parsed = bytes.default.parse(value);
+	if (parsed == null || !Number.isFinite(parsed) || parsed < 0) throw new Error(`invalid max size: ${String(value)}`);
+	return parsed;
+}
+function splitTokens(v) {
+	if (!v) return [];
+	return v.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+}
+function parseTransferEncoding(headers) {
+	const raw = headers.get("transfer-encoding");
+	const tks = splitTokens(raw);
+	if (tks.length === 0) return {
+		has: false,
+		chunked: false,
+		codings: []
+	};
+	const chunkedIdx = tks.lastIndexOf("chunked");
+	const hasChunked = chunkedIdx !== -1;
+	if (hasChunked && chunkedIdx !== tks.length - 1) throw new Error(`Invalid transfer-encoding order: ${raw ?? ""}`);
+	if (hasChunked && tks.indexOf("chunked") !== chunkedIdx) throw new Error(`Invalid transfer-encoding (duplicate chunked): ${raw ?? ""}`);
+	return {
+		has: true,
+		chunked: hasChunked,
+		codings: tks.filter((t) => t !== "chunked" && t !== "identity")
+	};
+}
+function parseContentLength(headers) {
+	const raw = headers.get("content-length");
+	if (!raw) return null;
+	const parts = raw.split(",").map((s) => s.trim()).filter(Boolean);
+	if (parts.length === 0) return null;
+	let value = null;
+	for (const p of parts) {
+		if (!/^\d+$/.test(p)) throw new Error(`Invalid content-length: ${raw}`);
+		const n = Number.parseInt(p, 10);
+		if (!Number.isFinite(n) || n < 0) throw new Error(`Invalid content-length: ${raw}`);
+		if (value === null) value = n;
+		else if (value !== n) throw new Error(`Conflicting content-length values: ${raw}`);
+	}
+	return value;
+}
+//#endregion
+exports.parseContentLength = parseContentLength;
+exports.parseMaxBytes = parseMaxBytes;
+exports.parseTransferEncoding = parseTransferEncoding;
+exports.splitTokens = splitTokens;

package/io/_utils.d.cts

@@ -0,0 +1,10 @@
+type TransferEncodingInfo = {
+    has: boolean;
+    chunked: boolean;
+    codings: string[];
+};
+export declare function parseMaxBytes(value?: number | string): number | null;
+export declare function splitTokens(v: string | null): string[];
+export declare function parseTransferEncoding(headers: Headers): TransferEncodingInfo;
+export declare function parseContentLength(headers: Headers): number | null;
+export {};

package/io/_utils.d.ts

@@ -0,0 +1,10 @@
+type TransferEncodingInfo = {
+    has: boolean;
+    chunked: boolean;
+    codings: string[];
+};
+export declare function parseMaxBytes(value?: number | string): number | null;
+export declare function splitTokens(v: string | null): string[];
+export declare function parseTransferEncoding(headers: Headers): TransferEncodingInfo;
+export declare function parseContentLength(headers: Headers): number | null;
+export {};

package/io/_utils.js

@@ -0,0 +1,51 @@
+import bytes from "bytes";
+//#region src/io/_utils.ts
+function parseMaxBytes(value) {
+	if (value === void 0) return null;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value) || value < 0) throw new Error(`invalid max size: ${String(value)}`);
+		return Math.floor(value);
+	}
+	const parsed = bytes.parse(value);
+	if (parsed == null || !Number.isFinite(parsed) || parsed < 0) throw new Error(`invalid max size: ${String(value)}`);
+	return parsed;
+}
+function splitTokens(v) {
+	if (!v) return [];
+	return v.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+}
+function parseTransferEncoding(headers) {
+	const raw = headers.get("transfer-encoding");
+	const tks = splitTokens(raw);
+	if (tks.length === 0) return {
+		has: false,
+		chunked: false,
+		codings: []
+	};
+	const chunkedIdx = tks.lastIndexOf("chunked");
+	const hasChunked = chunkedIdx !== -1;
+	if (hasChunked && chunkedIdx !== tks.length - 1) throw new Error(`Invalid transfer-encoding order: ${raw ?? ""}`);
+	if (hasChunked && tks.indexOf("chunked") !== chunkedIdx) throw new Error(`Invalid transfer-encoding (duplicate chunked): ${raw ?? ""}`);
+	return {
+		has: true,
+		chunked: hasChunked,
+		codings: tks.filter((t) => t !== "chunked" && t !== "identity")
+	};
+}
+function parseContentLength(headers) {
+	const raw = headers.get("content-length");
+	if (!raw) return null;
+	const parts = raw.split(",").map((s) => s.trim()).filter(Boolean);
+	if (parts.length === 0) return null;
+	let value = null;
+	for (const p of parts) {
+		if (!/^\d+$/.test(p)) throw new Error(`Invalid content-length: ${raw}`);
+		const n = Number.parseInt(p, 10);
+		if (!Number.isFinite(n) || n < 0) throw new Error(`Invalid content-length: ${raw}`);
+		if (value === null) value = n;
+		else if (value !== n) throw new Error(`Conflicting content-length values: ${raw}`);
+	}
+	return value;
+}
+//#endregion
+export { parseContentLength, parseMaxBytes, parseTransferEncoding, splitTokens };

package/io/buf-writer.cjs

@@ -0,0 +1,149 @@
+require("../_virtual/_rolldown/runtime.cjs");
+let _fuman_utils = require("@fuman/utils");
+//#region src/io/buf-writer.ts
+var DEFAULT_BUF_SIZE = 4096;
+var MIN_BUF_SIZE = 16;
+var BufWriter = class {
+	#buffer;
+	#writable;
+	#writePos = 0;
+	#error = null;
+	#pending = [];
+	#pendingBytes = 0;
+	#lastWrite = null;
+	constructor(writable, size = DEFAULT_BUF_SIZE) {
+		if (size < MIN_BUF_SIZE) size = MIN_BUF_SIZE;
+		this.#buffer = _fuman_utils.u8.alloc(size);
+		this.#writable = writable;
+	}
+	get bufferSize() {
+		return this.#buffer.byteLength;
+	}
+	get buffered() {
+		return this.#pendingBytes + this.#writePos;
+	}
+	get available() {
+		return this.#buffer.byteLength - this.#writePos;
+	}
+	reset(writable) {
+		this.#error = null;
+		this.#writePos = 0;
+		this.#pending.length = 0;
+		this.#pendingBytes = 0;
+		this.#lastWrite = null;
+		this.#writable = writable;
+	}
+	writeSync(bytes) {
+		if (this.#error) throw this.#error;
+		if (bytes < 0) throw new RangeError("bytes must be >= 0");
+		if (this.#lastWrite) throw new Error("disposeWriteSync must be called before the next writeSync");
+		if (bytes === 0) {
+			const empty = this.#buffer.subarray(this.#writePos, this.#writePos);
+			this.#lastWrite = {
+				buf: empty,
+				size: 0,
+				internal: true
+			};
+			return empty;
+		}
+		if (bytes > this.available && this.#writePos > 0) {
+			const copy = _fuman_utils.u8.allocWith(this.#buffer.subarray(0, this.#writePos));
+			this.#pending.push(copy);
+			this.#pendingBytes += copy.length;
+			this.#writePos = 0;
+		}
+		if (bytes <= this.#buffer.byteLength) {
+			if (bytes > this.available) {
+				const copy = _fuman_utils.u8.allocWith(this.#buffer.subarray(0, this.#writePos));
+				this.#pending.push(copy);
+				this.#pendingBytes += copy.length;
+				this.#writePos = 0;
+			}
+			const start = this.#writePos;
+			const end = start + bytes;
+			const slice = this.#buffer.subarray(start, end);
+			this.#writePos = end;
+			this.#lastWrite = {
+				buf: slice,
+				size: bytes,
+				internal: true
+			};
+			return slice;
+		}
+		const chunk = _fuman_utils.u8.alloc(bytes);
+		this.#lastWrite = {
+			buf: chunk,
+			size: bytes,
+			internal: false
+		};
+		return chunk;
+	}
+	disposeWriteSync(written) {
+		const lw = this.#lastWrite;
+		if (!lw) return;
+		const w = written ?? lw.size;
+		if (w < 0 || w > lw.size) throw new RangeError(`written out of bounds: ${w} (0..${lw.size})`);
+		if (lw.internal) this.#writePos -= lw.size - w;
+		else if (w > 0) {
+			const chunk = w === lw.size ? lw.buf : lw.buf.subarray(0, w);
+			this.#pending.push(chunk);
+			this.#pendingBytes += chunk.length;
+		}
+		this.#lastWrite = null;
+	}
+	async #flushPending() {
+		if (this.#error) throw this.#error;
+		if (this.#lastWrite) throw new Error("disposeWriteSync must be called before flush/write");
+		while (this.#pending.length > 0) {
+			const chunk = this.#pending[0];
+			try {
+				await this.#writable.write(chunk);
+			} catch (e) {
+				this.#error = e;
+				throw e;
+			}
+			this.#pending.shift();
+			this.#pendingBytes -= chunk.length;
+		}
+	}
+	async flush() {
+		await this.#flushPending();
+		if (this.#error) throw this.#error;
+		if (this.#writePos === 0) return;
+		try {
+			await this.#writable.write(this.#buffer.subarray(0, this.#writePos));
+		} catch (e) {
+			this.#error = e;
+			throw e;
+		}
+		this.#writePos = 0;
+	}
+	async write(bytes) {
+		if (this.#error) throw this.#error;
+		if (!bytes.length) return;
+		await this.#flushPending();
+		if (this.#writePos === 0 && bytes.length >= this.#buffer.byteLength) {
+			try {
+				await this.#writable.write(bytes);
+			} catch (e) {
+				this.#error = e;
+				throw e;
+			}
+			return;
+		}
+		let off = 0;
+		while (off < bytes.length) {
+			if (this.available === 0) {
+				await this.flush();
+				continue;
+			}
+			const toCopy = Math.min(this.available, bytes.length - off);
+			this.#buffer.set(bytes.subarray(off, off + toCopy), this.#writePos);
+			this.#writePos += toCopy;
+			off += toCopy;
+			if (this.#writePos === this.#buffer.byteLength) await this.flush();
+		}
+	}
+};
+//#endregion
+exports.BufWriter = BufWriter;

package/io/buf-writer.d.cts

@@ -0,0 +1,13 @@
+import { ISyncWritable, IWritable } from '@fuman/io';
+export declare class BufWriter implements IWritable, ISyncWritable {
+    #private;
+    constructor(writable: IWritable, size?: number);
+    get bufferSize(): number;
+    get buffered(): number;
+    get available(): number;
+    reset(writable: IWritable): void;
+    writeSync(bytes: number): Uint8Array;
+    disposeWriteSync(written?: number): void;
+    flush(): Promise<void>;
+    write(bytes: Uint8Array): Promise<void>;
+}

package/io/buf-writer.d.ts

@@ -0,0 +1,13 @@
+import { ISyncWritable, IWritable } from '@fuman/io';
+export declare class BufWriter implements IWritable, ISyncWritable {
+    #private;
+    constructor(writable: IWritable, size?: number);
+    get bufferSize(): number;
+    get buffered(): number;
+    get available(): number;
+    reset(writable: IWritable): void;
+    writeSync(bytes: number): Uint8Array;
+    disposeWriteSync(written?: number): void;
+    flush(): Promise<void>;
+    write(bytes: Uint8Array): Promise<void>;
+}

package/io/buf-writer.js

@@ -0,0 +1,148 @@
+import { u8 } from "@fuman/utils";
+//#region src/io/buf-writer.ts
+var DEFAULT_BUF_SIZE = 4096;
+var MIN_BUF_SIZE = 16;
+var BufWriter = class {
+	#buffer;
+	#writable;
+	#writePos = 0;
+	#error = null;
+	#pending = [];
+	#pendingBytes = 0;
+	#lastWrite = null;
+	constructor(writable, size = DEFAULT_BUF_SIZE) {
+		if (size < MIN_BUF_SIZE) size = MIN_BUF_SIZE;
+		this.#buffer = u8.alloc(size);
+		this.#writable = writable;
+	}
+	get bufferSize() {
+		return this.#buffer.byteLength;
+	}
+	get buffered() {
+		return this.#pendingBytes + this.#writePos;
+	}
+	get available() {
+		return this.#buffer.byteLength - this.#writePos;
+	}
+	reset(writable) {
+		this.#error = null;
+		this.#writePos = 0;
+		this.#pending.length = 0;
+		this.#pendingBytes = 0;
+		this.#lastWrite = null;
+		this.#writable = writable;
+	}
+	writeSync(bytes) {
+		if (this.#error) throw this.#error;
+		if (bytes < 0) throw new RangeError("bytes must be >= 0");
+		if (this.#lastWrite) throw new Error("disposeWriteSync must be called before the next writeSync");
+		if (bytes === 0) {
+			const empty = this.#buffer.subarray(this.#writePos, this.#writePos);
+			this.#lastWrite = {
+				buf: empty,
+				size: 0,
+				internal: true
+			};
+			return empty;
+		}
+		if (bytes > this.available && this.#writePos > 0) {
+			const copy = u8.allocWith(this.#buffer.subarray(0, this.#writePos));
+			this.#pending.push(copy);
+			this.#pendingBytes += copy.length;
+			this.#writePos = 0;
+		}
+		if (bytes <= this.#buffer.byteLength) {
+			if (bytes > this.available) {
+				const copy = u8.allocWith(this.#buffer.subarray(0, this.#writePos));
+				this.#pending.push(copy);
+				this.#pendingBytes += copy.length;
+				this.#writePos = 0;
+			}
+			const start = this.#writePos;
+			const end = start + bytes;
+			const slice = this.#buffer.subarray(start, end);
+			this.#writePos = end;
+			this.#lastWrite = {
+				buf: slice,
+				size: bytes,
+				internal: true
+			};
+			return slice;
+		}
+		const chunk = u8.alloc(bytes);
+		this.#lastWrite = {
+			buf: chunk,
+			size: bytes,
+			internal: false
+		};
+		return chunk;
+	}
+	disposeWriteSync(written) {
+		const lw = this.#lastWrite;
+		if (!lw) return;
+		const w = written ?? lw.size;
+		if (w < 0 || w > lw.size) throw new RangeError(`written out of bounds: ${w} (0..${lw.size})`);
+		if (lw.internal) this.#writePos -= lw.size - w;
+		else if (w > 0) {
+			const chunk = w === lw.size ? lw.buf : lw.buf.subarray(0, w);
+			this.#pending.push(chunk);
+			this.#pendingBytes += chunk.length;
+		}
+		this.#lastWrite = null;
+	}
+	async #flushPending() {
+		if (this.#error) throw this.#error;
+		if (this.#lastWrite) throw new Error("disposeWriteSync must be called before flush/write");
+		while (this.#pending.length > 0) {
+			const chunk = this.#pending[0];
+			try {
+				await this.#writable.write(chunk);
+			} catch (e) {
+				this.#error = e;
+				throw e;
+			}
+			this.#pending.shift();
+			this.#pendingBytes -= chunk.length;
+		}
+	}
+	async flush() {
+		await this.#flushPending();
+		if (this.#error) throw this.#error;
+		if (this.#writePos === 0) return;
+		try {
+			await this.#writable.write(this.#buffer.subarray(0, this.#writePos));
+		} catch (e) {
+			this.#error = e;
+			throw e;
+		}
+		this.#writePos = 0;
+	}
+	async write(bytes) {
+		if (this.#error) throw this.#error;
+		if (!bytes.length) return;
+		await this.#flushPending();
+		if (this.#writePos === 0 && bytes.length >= this.#buffer.byteLength) {
+			try {
+				await this.#writable.write(bytes);
+			} catch (e) {
+				this.#error = e;
+				throw e;
+			}
+			return;
+		}
+		let off = 0;
+		while (off < bytes.length) {
+			if (this.available === 0) {
+				await this.flush();
+				continue;
+			}
+			const toCopy = Math.min(this.available, bytes.length - off);
+			this.#buffer.set(bytes.subarray(off, off + toCopy), this.#writePos);
+			this.#writePos += toCopy;
+			off += toCopy;
+			if (this.#writePos === this.#buffer.byteLength) await this.flush();
+		}
+	}
+};
+//#endregion
+export { BufWriter };