@npy/fetch 0.1.0 → 0.1.1

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 };

package/io/io.cjs

@@ -0,0 +1,135 @@
+const require_encoding = require("../encoding.cjs");
+const require_streams = require("../_internal/streams.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] ?? ""
+	};
+}
+async function readResponse(conn, options = {}, shouldIgnoreBody, onDone) {
+	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 ?? -1, 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.highWaterMark ?? 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));
+	} 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.js

@@ -0,0 +1,134 @@
+import { decodeStream } from "../encoding.js";
+import { MaxBytesTransformStream } from "../_internal/streams.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] ?? ""
+	};
+}
+async function readResponse(conn, options = {}, shouldIgnoreBody, onDone) {
+	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 ?? -1, 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.highWaterMark ?? 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));
+	} 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 };