@npy/fetch 0.1.0 → 0.1.2

package/_internal/streams.js

@@ -0,0 +1,36 @@
+//#region src/_internal/streams.ts
+/**
+* Create a ReadableStream from a Uint8Array.
+*
+* The stream will emit the entire byte array as a single chunk,
+* then close immediately.
+*
+* @param bytes - The byte array to wrap.
+* @returns A ReadableStream that emits the bytes.
+*/
+function bytesToStream(bytes) {
+	return new ReadableStream({ start(controller) {
+		controller.enqueue(bytes);
+		controller.close();
+	} });
+}
+/**
+* A TransformStream that limits the total number of bytes passed through.
+*
+* It accumulates the byte count from incoming chunks and enqueues them
+* if the total remains within the limit; otherwise, it errors.
+*
+* @param maxBytes - The maximum allowed bytes before erroring.
+*/
+var MaxBytesTransformStream = class extends TransformStream {
+	constructor(maxBytes) {
+		if (!(maxBytes >= 0)) throw new TypeError("maxBytes must be a non-negative number");
+		let bytesRead = 0;
+		super({ transform: (chunk, ctrl) => {
+			if ((bytesRead += chunk.length) <= maxBytes) ctrl.enqueue(chunk);
+			else ctrl.error(/* @__PURE__ */ new Error("Response too large"));
+		} });
+	}
+};
+//#endregion
+export { MaxBytesTransformStream, bytesToStream };

package/_internal/symbols.cjs

@@ -0,0 +1,4 @@
+//#region src/_internal/symbols.ts
+var bodyErrorMapperSymbol = Symbol("fetch.bodyErrorMapper");
+//#endregion
+exports.bodyErrorMapperSymbol = bodyErrorMapperSymbol;

package/_internal/symbols.d.cts

@@ -0,0 +1 @@
+export declare const bodyErrorMapperSymbol: unique symbol;

package/_internal/symbols.d.ts

@@ -0,0 +1 @@
+export declare const bodyErrorMapperSymbol: unique symbol;

package/_internal/symbols.js

@@ -0,0 +1,4 @@
+//#region src/_internal/symbols.ts
+var bodyErrorMapperSymbol = Symbol("fetch.bodyErrorMapper");
+//#endregion
+export { bodyErrorMapperSymbol };

package/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/agent-pool.cjs

@@ -0,0 +1,96 @@
+require("./_virtual/_rolldown/runtime.cjs");
+const require_errors = require("./errors.cjs");
+const require_agent = require("./agent.cjs");
+const require_tcp = require("./dialers/tcp.cjs");
+let generic_pool = require("generic-pool");
+//#region src/agent-pool.ts
+var defaultEvictionInterval = 1e4;
+var defaultMax = Number.MAX_SAFE_INTEGER;
+var defaultIdleTimeout = 3e4;
+function createAgentPool(baseUrl, options = {}) {
+	const poolUrl = new URL(baseUrl);
+	const evictionRunIntervalMillis = options.poolIdleTimeout !== false ? Math.min(options.poolIdleTimeout || defaultEvictionInterval, defaultEvictionInterval) : 0;
+	const max = options.poolMaxPerHost ? Math.max(1, options.poolMaxPerHost) : defaultMax;
+	const softIdleTimeoutMillis = options.poolIdleTimeout !== false ? Math.max(1, options.poolIdleTimeout || defaultIdleTimeout) : -1;
+	const min = softIdleTimeoutMillis > 0 && options.poolMaxIdlePerHost ? Math.max(0, options.poolMaxIdlePerHost) : 0;
+	if (poolUrl.protocol !== "http:" && poolUrl.protocol !== "https:") throw new require_errors.UnsupportedProtocolError(poolUrl.protocol, {
+		origin: poolUrl.origin,
+		scheme: poolUrl.protocol,
+		host: poolUrl.hostname,
+		port: poolUrl.port ? Number.parseInt(poolUrl.port, 10) : void 0
+	});
+	const dialer = options.dialer ?? new require_tcp.AutoDialer();
+	const connectOptions = options.connect ?? {};
+	const ioOptions = options.io;
+	const pool = (0, generic_pool.createPool)({
+		async create() {
+			return require_agent.createAgent(dialer, baseUrl, {
+				connect: connectOptions,
+				io: ioOptions
+			});
+		},
+		async destroy(agent) {
+			agent.close();
+		}
+	}, {
+		autostart: false,
+		evictionRunIntervalMillis,
+		softIdleTimeoutMillis,
+		max,
+		min
+	});
+	let releaseAgentFns = [];
+	let closePromise;
+	async function send(sendOptions) {
+		let agent;
+		let agentReleased = false;
+		const releaseAgentFn = async (forceClose = false) => {
+			if (!agent || agentReleased) return;
+			agentReleased = true;
+			releaseAgentFns = releaseAgentFns.filter((release) => release !== releaseAgentFn);
+			if (forceClose) agent.close();
+			if (pool.isBorrowedResource(agent)) await pool.release(agent);
+		};
+		releaseAgentFns.push(releaseAgentFn);
+		try {
+			agent = await pool.acquire();
+			const responsePromise = agent.send(sendOptions);
+			agent.whenIdle().then(() => releaseAgentFn(), () => releaseAgentFn(true));
+			return responsePromise;
+		} catch (error) {
+			await releaseAgentFn(true);
+			throw error;
+		}
+	}
+	async function close() {
+		if (closePromise) return closePromise;
+		const promise = (async () => {
+			const pendingReleases = releaseAgentFns;
+			releaseAgentFns = [];
+			const errors = (await Promise.allSettled([...pendingReleases.map((release) => release(true)), (async () => {
+				try {
+					await pool.drain();
+				} finally {
+					await pool.clear();
+				}
+			})()])).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+			if (errors.length === 1) throw errors[0];
+			if (errors.length > 1) throw new AggregateError(errors, "Failed to close agent pool cleanly");
+		})();
+		closePromise = promise;
+		try {
+			await promise;
+		} finally {
+			if (closePromise === promise) closePromise = void 0;
+		}
+	}
+	return {
+		[Symbol.asyncDispose]: close,
+		close,
+		hostname: poolUrl.hostname,
+		port: poolUrl.port ? Number.parseInt(poolUrl.port, 10) : poolUrl.protocol === "https:" ? 443 : 80,
+		send
+	};
+}
+//#endregion
+exports.createAgentPool = createAgentPool;

package/agent-pool.d.cts

@@ -0,0 +1,2 @@
+import { AgentPool } from './types/agent';
+export declare function createAgentPool(baseUrl: string, options?: AgentPool.Options): AgentPool;

package/agent-pool.d.ts

@@ -0,0 +1,2 @@
+import { AgentPool } from './types/agent';
+export declare function createAgentPool(baseUrl: string, options?: AgentPool.Options): AgentPool;

package/agent-pool.js

@@ -0,0 +1,95 @@
+import { UnsupportedProtocolError } from "./errors.js";
+import { createAgent } from "./agent.js";
+import { AutoDialer } from "./dialers/tcp.js";
+import { createPool } from "generic-pool";
+//#region src/agent-pool.ts
+var defaultEvictionInterval = 1e4;
+var defaultMax = Number.MAX_SAFE_INTEGER;
+var defaultIdleTimeout = 3e4;
+function createAgentPool(baseUrl, options = {}) {
+	const poolUrl = new URL(baseUrl);
+	const evictionRunIntervalMillis = options.poolIdleTimeout !== false ? Math.min(options.poolIdleTimeout || defaultEvictionInterval, defaultEvictionInterval) : 0;
+	const max = options.poolMaxPerHost ? Math.max(1, options.poolMaxPerHost) : defaultMax;
+	const softIdleTimeoutMillis = options.poolIdleTimeout !== false ? Math.max(1, options.poolIdleTimeout || defaultIdleTimeout) : -1;
+	const min = softIdleTimeoutMillis > 0 && options.poolMaxIdlePerHost ? Math.max(0, options.poolMaxIdlePerHost) : 0;
+	if (poolUrl.protocol !== "http:" && poolUrl.protocol !== "https:") throw new UnsupportedProtocolError(poolUrl.protocol, {
+		origin: poolUrl.origin,
+		scheme: poolUrl.protocol,
+		host: poolUrl.hostname,
+		port: poolUrl.port ? Number.parseInt(poolUrl.port, 10) : void 0
+	});
+	const dialer = options.dialer ?? new AutoDialer();
+	const connectOptions = options.connect ?? {};
+	const ioOptions = options.io;
+	const pool = createPool({
+		async create() {
+			return createAgent(dialer, baseUrl, {
+				connect: connectOptions,
+				io: ioOptions
+			});
+		},
+		async destroy(agent) {
+			agent.close();
+		}
+	}, {
+		autostart: false,
+		evictionRunIntervalMillis,
+		softIdleTimeoutMillis,
+		max,
+		min
+	});
+	let releaseAgentFns = [];
+	let closePromise;
+	async function send(sendOptions) {
+		let agent;
+		let agentReleased = false;
+		const releaseAgentFn = async (forceClose = false) => {
+			if (!agent || agentReleased) return;
+			agentReleased = true;
+			releaseAgentFns = releaseAgentFns.filter((release) => release !== releaseAgentFn);
+			if (forceClose) agent.close();
+			if (pool.isBorrowedResource(agent)) await pool.release(agent);
+		};
+		releaseAgentFns.push(releaseAgentFn);
+		try {
+			agent = await pool.acquire();
+			const responsePromise = agent.send(sendOptions);
+			agent.whenIdle().then(() => releaseAgentFn(), () => releaseAgentFn(true));
+			return responsePromise;
+		} catch (error) {
+			await releaseAgentFn(true);
+			throw error;
+		}
+	}
+	async function close() {
+		if (closePromise) return closePromise;
+		const promise = (async () => {
+			const pendingReleases = releaseAgentFns;
+			releaseAgentFns = [];
+			const errors = (await Promise.allSettled([...pendingReleases.map((release) => release(true)), (async () => {
+				try {
+					await pool.drain();
+				} finally {
+					await pool.clear();
+				}
+			})()])).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+			if (errors.length === 1) throw errors[0];
+			if (errors.length > 1) throw new AggregateError(errors, "Failed to close agent pool cleanly");
+		})();
+		closePromise = promise;
+		try {
+			await promise;
+		} finally {
+			if (closePromise === promise) closePromise = void 0;
+		}
+	}
+	return {
+		[Symbol.asyncDispose]: close,
+		close,
+		hostname: poolUrl.hostname,
+		port: poolUrl.port ? Number.parseInt(poolUrl.port, 10) : poolUrl.protocol === "https:" ? 443 : 80,
+		send
+	};
+}
+//#endregion
+export { createAgentPool };

package/agent.cjs

@@ -0,0 +1,260 @@
+require("./_virtual/_rolldown/runtime.cjs");
+const require_errors = require("./errors.cjs");
+const require_error_mapping = require("./_internal/error-mapping.cjs");
+const require_promises = require("./_internal/promises.cjs");
+const require_symbols = require("./_internal/symbols.cjs");
+const require_io = require("./io/io.cjs");
+let _fuman_utils = require("@fuman/utils");
+//#region src/agent.ts
+var PORT_MAP = {
+	"http:": 80,
+	"https:": 443
+};
+var DEFAULT_ALPN_PROTOCOLS = ["http/1.1"];
+function resolvedDeferred() {
+	const deferred = new _fuman_utils.Deferred();
+	deferred.resolve();
+	return deferred;
+}
+function withSignal(promise, signal) {
+	return signal ? require_promises.raceSignal(promise, signal) : promise;
+}
+function isTlsConnection(conn) {
+	return "getAlpnProtocol" in conn && typeof conn.getAlpnProtocol === "function";
+}
+function createAgent(dialer, baseUrl, options = {}) {
+	const base = new URL(baseUrl);
+	if (base.protocol !== "http:" && base.protocol !== "https:") throw new require_errors.UnsupportedProtocolError(base.protocol, {
+		origin: base.origin,
+		scheme: base.protocol,
+		host: base.hostname,
+		port: base.port ? Number.parseInt(base.port, 10) : void 0,
+		url: base.toString()
+	});
+	const secure = base.protocol === "https:";
+	const hostname = base.hostname;
+	const port = base.port ? Number.parseInt(base.port, 10) : PORT_MAP[base.protocol];
+	if (!Number.isFinite(port) || port <= 0 || port > 65535) throw new TypeError(`Invalid port in base URL: ${baseUrl}`);
+	const target = {
+		address: hostname,
+		port,
+		secure,
+		sni: secure ? hostname : void 0,
+		alpnProtocols: secure ? [...DEFAULT_ALPN_PROTOCOLS] : void 0
+	};
+	const connectOptions = options.connect ?? {};
+	const readerOptions = options.io?.reader ?? {};
+	const writerOptions = options.io?.writer ?? {};
+	let conn;
+	let connectPromise;
+	let closed = false;
+	let isBusy = false;
+	let lastUsedTime = Date.now();
+	let idleDeferred = resolvedDeferred();
+	function createBaseErrorContext() {
+		return {
+			origin: base.origin,
+			scheme: base.protocol,
+			host: hostname,
+			port
+		};
+	}
+	function createRequestErrorContext(url, method) {
+		return {
+			...createBaseErrorContext(),
+			url: url.toString(),
+			method
+		};
+	}
+	function markIdle() {
+		isBusy = false;
+		lastUsedTime = Date.now();
+		idleDeferred.resolve();
+	}
+	function disposeConn() {
+		const current = conn;
+		conn = void 0;
+		if (!current) return;
+		try {
+			current.close();
+		} catch {}
+	}
+	function forceClose() {
+		if (closed) return;
+		closed = true;
+		disposeConn();
+		if (!isBusy) markIdle();
+	}
+	function assertUsable() {
+		if (closed) throw new require_errors.AgentClosedError(createBaseErrorContext());
+	}
+	function assertSameOrigin(url) {
+		if (url.origin !== base.origin) throw new require_errors.OriginMismatchError(base.origin, url.origin, {
+			...createBaseErrorContext(),
+			url: url.toString()
+		});
+	}
+	function configureConnection(nextConn) {
+		nextConn.setNoDelay(connectOptions.noDelay ?? true);
+		if (connectOptions.keepAlive !== null) nextConn.setKeepAlive(connectOptions.keepAlive ?? true);
+	}
+	async function connect(signal) {
+		assertUsable();
+		if (conn) return conn;
+		if (connectPromise) return withSignal(connectPromise, signal);
+		let timedOut = false;
+		let timeoutId;
+		const abortController = new AbortController();
+		const onAbort = () => abortController.abort(signal?.reason);
+		const cleanup = () => {
+			if (timeoutId !== void 0) {
+				clearTimeout(timeoutId);
+				timeoutId = void 0;
+			}
+			if (signal) signal.removeEventListener("abort", onAbort);
+		};
+		if (signal) if (signal.aborted) abortController.abort(signal.reason);
+		else signal.addEventListener("abort", onAbort, { once: true });
+		if (connectOptions.timeout != null && Number.isFinite(connectOptions.timeout) && connectOptions.timeout > 0) timeoutId = setTimeout(() => {
+			timedOut = true;
+			abortController.abort(new DOMException("Connection timed out", "TimeoutError"));
+		}, connectOptions.timeout);
+		connectPromise = (async () => {
+			try {
+				const nextConn = await dialer.dial(target, { signal: abortController.signal });
+				if (closed) {
+					try {
+						nextConn.close();
+					} catch {}
+					throw new require_errors.AgentClosedError(createBaseErrorContext());
+				}
+				configureConnection(nextConn);
+				if (secure && isTlsConnection(nextConn)) {
+					const alpn = nextConn.getAlpnProtocol();
+					if (alpn != null && alpn !== "" && alpn !== "http/1.1") {
+						try {
+							nextConn.close();
+						} catch {}
+						throw new require_errors.UnsupportedAlpnProtocolError(alpn, createBaseErrorContext());
+					}
+				}
+				conn = nextConn;
+				return nextConn;
+			} catch (error) {
+				throw require_error_mapping.toConnectError(error, {
+					signal,
+					timedOut,
+					context: createBaseErrorContext()
+				});
+			} finally {
+				cleanup();
+				connectPromise = void 0;
+			}
+		})();
+		return withSignal(connectPromise, signal);
+	}
+	async function executeRequest(sendOptions, mapBodyError) {
+		assertUsable();
+		const url = typeof sendOptions.url === "string" ? new URL(sendOptions.url) : sendOptions.url;
+		const method = sendOptions.method.toUpperCase();
+		const errorContext = createRequestErrorContext(url, method);
+		if (sendOptions.signal?.aborted) throw new require_errors.RequestAbortedError(sendOptions.signal.reason, errorContext);
+		if (isBusy) throw new require_errors.AgentBusyError(errorContext);
+		assertSameOrigin(url);
+		if (method === "CONNECT") throw new require_errors.UnsupportedMethodError("CONNECT", errorContext);
+		isBusy = true;
+		idleDeferred = new _fuman_utils.Deferred();
+		let finalized = false;
+		let activeConn;
+		const finalize = (reusable) => {
+			if (finalized) return;
+			finalized = true;
+			if (!reusable || closed) {
+				if (conn === activeConn) disposeConn();
+				else if (activeConn) try {
+					activeConn.close();
+				} catch {}
+			}
+			markIdle();
+		};
+		const abortListener = () => {
+			if (activeConn) {
+				if (conn === activeConn) conn = void 0;
+				try {
+					activeConn.close();
+				} catch {}
+			}
+		};
+		try {
+			activeConn = await connect(sendOptions.signal);
+			sendOptions.signal?.addEventListener("abort", abortListener, { once: true });
+			try {
+				await withSignal(require_io.writeRequest(activeConn, {
+					url,
+					method,
+					headers: sendOptions.headers,
+					body: sendOptions.body ?? null,
+					signal: sendOptions.signal
+				}, writerOptions), sendOptions.signal);
+			} catch (error) {
+				throw require_error_mapping.toSendError(error, {
+					signal: sendOptions.signal,
+					context: errorContext,
+					phase: "request"
+				});
+			}
+			const isHeadRequest = method === "HEAD";
+			const shouldIgnoreBody = (status) => isHeadRequest || status >= 100 && status < 200 || status === 204 || status === 304;
+			let response;
+			try {
+				response = await withSignal(require_io.readResponse(activeConn, readerOptions, shouldIgnoreBody, (reusable) => {
+					sendOptions.signal?.removeEventListener("abort", abortListener);
+					finalize(reusable);
+				}, mapBodyError), sendOptions.signal);
+			} catch (error) {
+				throw require_error_mapping.toSendError(error, {
+					signal: sendOptions.signal,
+					context: errorContext,
+					phase: "response"
+				});
+			}
+			return response;
+		} catch (error) {
+			sendOptions.signal?.removeEventListener("abort", abortListener);
+			if (activeConn) {
+				if (conn === activeConn) conn = void 0;
+				try {
+					activeConn.close();
+				} catch {}
+			}
+			finalize(false);
+			throw error;
+		}
+	}
+	async function send(sendOptions) {
+		const errorContext = createRequestErrorContext(typeof sendOptions.url === "string" ? new URL(sendOptions.url) : sendOptions.url, sendOptions.method.toUpperCase());
+		return executeRequest(sendOptions, sendOptions[require_symbols.bodyErrorMapperSymbol] ?? ((error) => require_error_mapping.toSendError(error, {
+			signal: sendOptions.signal,
+			context: errorContext,
+			phase: "body"
+		})));
+	}
+	return {
+		[Symbol.dispose]: forceClose,
+		close: forceClose,
+		hostname,
+		port,
+		send,
+		whenIdle() {
+			return idleDeferred.promise;
+		},
+		get isIdle() {
+			return !isBusy;
+		},
+		get lastUsed() {
+			return lastUsedTime;
+		}
+	};
+}
+//#endregion
+exports.createAgent = createAgent;

package/agent.d.cts

@@ -0,0 +1,3 @@
+import { Agent } from './types/agent';
+import { Dialer } from './types/dialer';
+export declare function createAgent(dialer: Dialer, baseUrl: string, options?: Agent.Options): Agent;

package/agent.d.ts

@@ -0,0 +1,3 @@
+import { Agent } from './types/agent';
+import { Dialer } from './types/dialer';
+export declare function createAgent(dialer: Dialer, baseUrl: string, options?: Agent.Options): Agent;