@npy/fetch 0.1.3 → 0.1.4

package/io/io.cjs

@@ -0,0 +1,199 @@
+const require_streams = require("../_internal/streams.cjs");
+const require_encoding = require("../encoding.cjs");
+const require__utils = require("./_utils.cjs");
+const require_readers = require("./readers.cjs");
+const require_writers = require("./writers.cjs");
+//#region src/io/io.ts
+function parseStatusLine(line) {
+	const m = /^HTTP\/(\d+)\.(\d+)\s+(\d{3})(?:\s+(.*))?$/.exec(line);
+	if (!m) throw new Error(`Invalid HTTP status line: ${line}`);
+	const major = Number(m[1]);
+	const minor = Number(m[2]);
+	const status = Number(m[3]);
+	if (!Number.isFinite(major) || !Number.isFinite(minor) || !Number.isFinite(status)) throw new Error(`Invalid HTTP status line: ${line}`);
+	return {
+		major,
+		minor,
+		status,
+		statusText: m[4] ?? ""
+	};
+}
+function toArrayBufferBytes(bytes) {
+	if (bytes.buffer instanceof ArrayBuffer) return bytes;
+	return new Uint8Array(bytes);
+}
+function wrapStreamErrors(source, mapError) {
+	const reader = source.getReader();
+	let pending = null;
+	return new ReadableStream({
+		type: "bytes",
+		async pull(controller) {
+			try {
+				const byob = controller.byobRequest;
+				if (byob?.view) {
+					const target = new Uint8Array(byob.view.buffer, byob.view.byteOffset, byob.view.byteLength);
+					if (target.byteLength === 0) {
+						byob.respond(0);
+						return;
+					}
+					let written = 0;
+					if (pending && pending.byteLength > 0) {
+						const n = Math.min(target.byteLength, pending.byteLength);
+						target.set(pending.subarray(0, n), written);
+						written += n;
+						pending = n === pending.byteLength ? null : pending.subarray(n);
+					}
+					while (written === 0) {
+						const { done, value } = await reader.read();
+						if (done) {
+							byob.respond(0);
+							controller.close();
+							return;
+						}
+						if (!value || value.byteLength === 0) continue;
+						const n = Math.min(target.byteLength - written, value.byteLength);
+						target.set(value.subarray(0, n), written);
+						written += n;
+						if (n < value.byteLength) pending = value.subarray(n);
+					}
+					byob.respond(written);
+					return;
+				}
+				if (pending && pending.byteLength > 0) {
+					const chunk = pending;
+					pending = null;
+					controller.enqueue(toArrayBufferBytes(chunk));
+					return;
+				}
+				const { done, value } = await reader.read();
+				if (done) {
+					controller.close();
+					return;
+				}
+				if (value && value.byteLength > 0) controller.enqueue(toArrayBufferBytes(value));
+			} catch (error) {
+				controller.error(mapError(error));
+			}
+		},
+		async cancel(reason) {
+			pending = null;
+			await reader.cancel(reason);
+		}
+	});
+}
+async function readResponse(conn, options = {}, shouldIgnoreBody, onDone, mapBodyError) {
+	const lr = new require_readers.LineReader(conn, options);
+	const finalize = (() => {
+		let called = false;
+		return (reusable) => {
+			if (called) return;
+			called = true;
+			queueMicrotask(() => onDone?.(reusable));
+		};
+	})();
+	let statusLine;
+	let headers;
+	for (;;) {
+		const line = await lr.readLine();
+		if (line === null) throw new Error("Unexpected EOF while reading status line");
+		const parsed = parseStatusLine(line);
+		const hdrs = await lr.readHeaders(options);
+		if (parsed.status >= 100 && parsed.status < 200) {
+			if (parsed.status === 101) throw new Error("HTTP/1.1 protocol upgrades not supported");
+			continue;
+		}
+		statusLine = parsed;
+		headers = hdrs;
+		break;
+	}
+	const { major, minor, status, statusText } = statusLine;
+	const connectionTokens = require__utils.splitTokens(headers.get("connection"));
+	const hasClose = connectionTokens.includes("close");
+	const hasKeepAlive = connectionTokens.includes("keep-alive");
+	const keepAliveOk = !(major === 1 && minor === 0) || hasKeepAlive;
+	const ignoreBody = shouldIgnoreBody(status);
+	const te = require__utils.parseTransferEncoding(headers);
+	let chunked = false;
+	let contentLength = null;
+	if (!ignoreBody) if (te.has) {
+		chunked = te.chunked;
+		contentLength = null;
+		headers.delete("content-length");
+	} else {
+		chunked = false;
+		contentLength = require__utils.parseContentLength(headers);
+	}
+	const reusable = keepAliveOk && !hasClose && (ignoreBody || chunked || contentLength != null);
+	if (ignoreBody) {
+		finalize(reusable);
+		return new Response(null, {
+			status,
+			statusText,
+			headers
+		});
+	}
+	if (chunked) headers.delete("content-length");
+	const reader = chunked ? new require_readers.ChunkedBodyReader(lr, options) : new require_readers.BodyReader(lr, contentLength, options);
+	let body = new ReadableStream({
+		type: "bytes",
+		async pull(controller) {
+			const byob = controller.byobRequest;
+			const view = byob?.view ? new Uint8Array(byob.view.buffer, byob.view.byteOffset, byob.view.byteLength) : new Uint8Array(new ArrayBuffer(options.readChunkSize ?? 16 * 1024));
+			try {
+				const n = await reader.read(view);
+				if (n === 0) {
+					byob?.respond(0);
+					controller.close();
+					finalize(reusable);
+					return;
+				}
+				if (byob) byob.respond(n);
+				else controller.enqueue(view.subarray(0, n));
+			} catch (err) {
+				controller.error(err);
+				finalize(false);
+			}
+		},
+		cancel() {
+			finalize(false);
+		}
+	});
+	try {
+		if (te.has && te.codings.length > 0) {
+			const decodedTe = require_encoding.decodeStream(body, te.codings);
+			if (decodedTe !== body) {
+				if (te.chunked) headers.set("transfer-encoding", "chunked");
+				else headers.delete("transfer-encoding");
+				headers.delete("content-length");
+			}
+			body = decodedTe;
+		}
+		const decompress = options.decompress !== false;
+		const contentEncoding = headers.get("content-encoding") ?? void 0;
+		if (decompress && contentEncoding) {
+			const decodedCe = require_encoding.decodeStream(body, contentEncoding);
+			if (decodedCe !== body) {
+				headers.delete("content-encoding");
+				headers.delete("content-length");
+			}
+			body = decodedCe;
+		}
+		const maxDecoded = require__utils.parseMaxBytes(options.maxDecodedBodySize);
+		if (maxDecoded != null) body = body.pipeThrough(new require_streams.MaxBytesTransformStream(maxDecoded));
+		if (mapBodyError != null) body = wrapStreamErrors(body, mapBodyError);
+	} catch (err) {
+		finalize(false);
+		throw err;
+	}
+	return new Response(body, {
+		status,
+		statusText,
+		headers
+	});
+}
+async function writeRequest(conn, req, options = {}) {
+	await require_writers.createRequestWriter(conn, options).write(req);
+}
+//#endregion
+exports.readResponse = readResponse;
+exports.writeRequest = writeRequest;

package/io/io.d.cts

@@ -0,0 +1,5 @@
+import { IConnection } from '@fuman/net';
+import { LineReader, Readers } from './readers';
+import { Writers } from './writers';
+export declare function readResponse(conn: IConnection<unknown>, options: (Readers.Options & LineReader.ReadHeadersOptions) | undefined, shouldIgnoreBody: (status: number) => boolean, onDone?: (reusable: boolean) => void, mapBodyError?: (err: unknown) => unknown): Promise<Response>;
+export declare function writeRequest(conn: IConnection<unknown>, req: Writers.Request, options?: Writers.Options): Promise<void>;

package/io/io.d.ts

@@ -0,0 +1,5 @@
+import { IConnection } from '@fuman/net';
+import { LineReader, Readers } from './readers';
+import { Writers } from './writers';
+export declare function readResponse(conn: IConnection<unknown>, options: (Readers.Options & LineReader.ReadHeadersOptions) | undefined, shouldIgnoreBody: (status: number) => boolean, onDone?: (reusable: boolean) => void, mapBodyError?: (err: unknown) => unknown): Promise<Response>;
+export declare function writeRequest(conn: IConnection<unknown>, req: Writers.Request, options?: Writers.Options): Promise<void>;

package/io/io.js

@@ -0,0 +1,198 @@
+import { MaxBytesTransformStream } from "../_internal/streams.js";
+import { decodeStream } from "../encoding.js";
+import { parseContentLength, parseMaxBytes, parseTransferEncoding, splitTokens } from "./_utils.js";
+import { BodyReader, ChunkedBodyReader, LineReader } from "./readers.js";
+import { createRequestWriter } from "./writers.js";
+//#region src/io/io.ts
+function parseStatusLine(line) {
+	const m = /^HTTP\/(\d+)\.(\d+)\s+(\d{3})(?:\s+(.*))?$/.exec(line);
+	if (!m) throw new Error(`Invalid HTTP status line: ${line}`);
+	const major = Number(m[1]);
+	const minor = Number(m[2]);
+	const status = Number(m[3]);
+	if (!Number.isFinite(major) || !Number.isFinite(minor) || !Number.isFinite(status)) throw new Error(`Invalid HTTP status line: ${line}`);
+	return {
+		major,
+		minor,
+		status,
+		statusText: m[4] ?? ""
+	};
+}
+function toArrayBufferBytes(bytes) {
+	if (bytes.buffer instanceof ArrayBuffer) return bytes;
+	return new Uint8Array(bytes);
+}
+function wrapStreamErrors(source, mapError) {
+	const reader = source.getReader();
+	let pending = null;
+	return new ReadableStream({
+		type: "bytes",
+		async pull(controller) {
+			try {
+				const byob = controller.byobRequest;
+				if (byob?.view) {
+					const target = new Uint8Array(byob.view.buffer, byob.view.byteOffset, byob.view.byteLength);
+					if (target.byteLength === 0) {
+						byob.respond(0);
+						return;
+					}
+					let written = 0;
+					if (pending && pending.byteLength > 0) {
+						const n = Math.min(target.byteLength, pending.byteLength);
+						target.set(pending.subarray(0, n), written);
+						written += n;
+						pending = n === pending.byteLength ? null : pending.subarray(n);
+					}
+					while (written === 0) {
+						const { done, value } = await reader.read();
+						if (done) {
+							byob.respond(0);
+							controller.close();
+							return;
+						}
+						if (!value || value.byteLength === 0) continue;
+						const n = Math.min(target.byteLength - written, value.byteLength);
+						target.set(value.subarray(0, n), written);
+						written += n;
+						if (n < value.byteLength) pending = value.subarray(n);
+					}
+					byob.respond(written);
+					return;
+				}
+				if (pending && pending.byteLength > 0) {
+					const chunk = pending;
+					pending = null;
+					controller.enqueue(toArrayBufferBytes(chunk));
+					return;
+				}
+				const { done, value } = await reader.read();
+				if (done) {
+					controller.close();
+					return;
+				}
+				if (value && value.byteLength > 0) controller.enqueue(toArrayBufferBytes(value));
+			} catch (error) {
+				controller.error(mapError(error));
+			}
+		},
+		async cancel(reason) {
+			pending = null;
+			await reader.cancel(reason);
+		}
+	});
+}
+async function readResponse(conn, options = {}, shouldIgnoreBody, onDone, mapBodyError) {
+	const lr = new LineReader(conn, options);
+	const finalize = (() => {
+		let called = false;
+		return (reusable) => {
+			if (called) return;
+			called = true;
+			queueMicrotask(() => onDone?.(reusable));
+		};
+	})();
+	let statusLine;
+	let headers;
+	for (;;) {
+		const line = await lr.readLine();
+		if (line === null) throw new Error("Unexpected EOF while reading status line");
+		const parsed = parseStatusLine(line);
+		const hdrs = await lr.readHeaders(options);
+		if (parsed.status >= 100 && parsed.status < 200) {
+			if (parsed.status === 101) throw new Error("HTTP/1.1 protocol upgrades not supported");
+			continue;
+		}
+		statusLine = parsed;
+		headers = hdrs;
+		break;
+	}
+	const { major, minor, status, statusText } = statusLine;
+	const connectionTokens = splitTokens(headers.get("connection"));
+	const hasClose = connectionTokens.includes("close");
+	const hasKeepAlive = connectionTokens.includes("keep-alive");
+	const keepAliveOk = !(major === 1 && minor === 0) || hasKeepAlive;
+	const ignoreBody = shouldIgnoreBody(status);
+	const te = parseTransferEncoding(headers);
+	let chunked = false;
+	let contentLength = null;
+	if (!ignoreBody) if (te.has) {
+		chunked = te.chunked;
+		contentLength = null;
+		headers.delete("content-length");
+	} else {
+		chunked = false;
+		contentLength = parseContentLength(headers);
+	}
+	const reusable = keepAliveOk && !hasClose && (ignoreBody || chunked || contentLength != null);
+	if (ignoreBody) {
+		finalize(reusable);
+		return new Response(null, {
+			status,
+			statusText,
+			headers
+		});
+	}
+	if (chunked) headers.delete("content-length");
+	const reader = chunked ? new ChunkedBodyReader(lr, options) : new BodyReader(lr, contentLength, options);
+	let body = new ReadableStream({
+		type: "bytes",
+		async pull(controller) {
+			const byob = controller.byobRequest;
+			const view = byob?.view ? new Uint8Array(byob.view.buffer, byob.view.byteOffset, byob.view.byteLength) : new Uint8Array(new ArrayBuffer(options.readChunkSize ?? 16 * 1024));
+			try {
+				const n = await reader.read(view);
+				if (n === 0) {
+					byob?.respond(0);
+					controller.close();
+					finalize(reusable);
+					return;
+				}
+				if (byob) byob.respond(n);
+				else controller.enqueue(view.subarray(0, n));
+			} catch (err) {
+				controller.error(err);
+				finalize(false);
+			}
+		},
+		cancel() {
+			finalize(false);
+		}
+	});
+	try {
+		if (te.has && te.codings.length > 0) {
+			const decodedTe = decodeStream(body, te.codings);
+			if (decodedTe !== body) {
+				if (te.chunked) headers.set("transfer-encoding", "chunked");
+				else headers.delete("transfer-encoding");
+				headers.delete("content-length");
+			}
+			body = decodedTe;
+		}
+		const decompress = options.decompress !== false;
+		const contentEncoding = headers.get("content-encoding") ?? void 0;
+		if (decompress && contentEncoding) {
+			const decodedCe = decodeStream(body, contentEncoding);
+			if (decodedCe !== body) {
+				headers.delete("content-encoding");
+				headers.delete("content-length");
+			}
+			body = decodedCe;
+		}
+		const maxDecoded = parseMaxBytes(options.maxDecodedBodySize);
+		if (maxDecoded != null) body = body.pipeThrough(new MaxBytesTransformStream(maxDecoded));
+		if (mapBodyError != null) body = wrapStreamErrors(body, mapBodyError);
+	} catch (err) {
+		finalize(false);
+		throw err;
+	}
+	return new Response(body, {
+		status,
+		statusText,
+		headers
+	});
+}
+async function writeRequest(conn, req, options = {}) {
+	await createRequestWriter(conn, options).write(req);
+}
+//#endregion
+export { readResponse, writeRequest };