quickwin 1.0.0

package/lib/http-common.js

@@ -0,0 +1,342 @@
+import './polyfill.js';
+import './stream.js';
+// ── Byte helpers ──
+export function _concat(parts) {
+    if (parts.length === 0)
+        return new Uint8Array(0);
+    let totalLen = 0;
+    for (const p of parts)
+        totalLen += p.length;
+    const result = new Uint8Array(totalLen);
+    let offset = 0;
+    for (const p of parts) {
+        result.set(p, offset);
+        offset += p.length;
+    }
+    return result;
+}
+export function _toReadableStream(body) {
+    if (body instanceof ReadableStream)
+        return body;
+    const bytes = (typeof body === 'string')
+        ? new TextEncoder().encode(body)
+        : (body instanceof ArrayBuffer)
+            ? new Uint8Array(body)
+            : new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+    return new ReadableStream({
+        start(ctrl) {
+            ctrl.enqueue(bytes);
+            ctrl.close();
+        }
+    });
+}
+export async function _readStream(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        chunks.push(value);
+    }
+    return _concat(chunks);
+}
+export function _hasChunkedEnd(data) {
+    if (data.length < 7)
+        return false;
+    let i = data.length - 7;
+    return data[i] === 0x0D && data[i + 1] === 0x0A && data[i + 2] === 0x30 && data[i + 3] === 0x0D && data[i + 4] === 0x0A && data[i + 5] === 0x0D && data[i + 6] === 0x0A;
+}
+export function decodeChunked(data) {
+    const chunks = [];
+    let pos = 0;
+    while (pos < data.length) {
+        let crlf = -1;
+        for (let i = pos; i < data.length - 1; i++) {
+            if (data[i] === 0x0D && data[i + 1] === 0x0A) {
+                crlf = i;
+                break;
+            }
+        }
+        if (crlf < 0)
+            break;
+        let size = 0;
+        for (let i = pos; i < crlf; i++) {
+            const b = data[i];
+            if (b >= 0x30 && b <= 0x39)
+                size = size * 16 + (b - 0x30);
+            else if (b >= 0x41 && b <= 0x46)
+                size = size * 16 + (b - 0x37);
+            else if (b >= 0x61 && b <= 0x66)
+                size = size * 16 + (b - 0x57);
+            else
+                break;
+        }
+        const dataStart = crlf + 2;
+        if (size === 0) {
+            for (let i = dataStart; i < data.length - 3; i++) {
+                if (data[i] === 0x0D && data[i + 1] === 0x0A && data[i + 2] === 0x0D && data[i + 3] === 0x0A) {
+                    pos = i + 4;
+                    break;
+                }
+            }
+            if (pos === dataStart)
+                break;
+            break;
+        }
+        if (dataStart + size > data.length)
+            break;
+        chunks.push(data.subarray(dataStart, dataStart + size));
+        pos = dataStart + size + 2;
+    }
+    return _concat(chunks);
+}
+// ── Headers ──
+// Flat array storage: [name0, value0, name1, value1, ...]
+// Pairs at even/odd indices. Strings are immutable, so [...this._headers] is a correct deep copy.
+export class HeadersImpl {
+    _headers = [];
+    constructor(init) {
+        if (init) {
+            if (init instanceof HeadersImpl) {
+                this._headers = [...init._headers];
+            }
+            else if (Array.isArray(init)) {
+                this._headers = init.flatMap(([k, v]) => [k.toLowerCase(), v]);
+            }
+            else if (typeof init === 'object') {
+                this._headers = Object.entries(init).flatMap(([k, v]) => [k.toLowerCase(), v]);
+            }
+        }
+    }
+    append(name, value) {
+        this._headers.push(name.toLowerCase(), value);
+    }
+    delete(name) {
+        const key = name.toLowerCase();
+        const h = this._headers;
+        let i = h.length - 2;
+        while (i >= 0) {
+            if (h[i] === key) {
+                h.splice(i, 2);
+                i -= 2;
+            }
+            else
+                i -= 2;
+        }
+    }
+    get(name) {
+        const key = name.toLowerCase();
+        const matches = [...this.entries()].filter(([k]) => k === key).map(([, v]) => v);
+        return matches.length ? matches.join(', ') : null;
+    }
+    has(name) {
+        return [...this.keys()].includes(name.toLowerCase());
+    }
+    set(name, value) {
+        const key = name.toLowerCase();
+        const h = this._headers;
+        let found = false;
+        let i = h.length - 2;
+        while (i >= 0) {
+            if (h[i] === key) {
+                if (!found) {
+                    h[i + 1] = value;
+                    found = true;
+                }
+                else {
+                    h.splice(i, 2);
+                }
+            }
+            i -= 2;
+        }
+        if (!found)
+            h.push(key, value);
+    }
+    forEach(callback) {
+        for (const [name, value] of this) {
+            callback(value, name, this);
+        }
+    }
+    *entries() {
+        const h = this._headers;
+        for (let i = 0; i < h.length; i += 2) {
+            yield [h[i], h[i + 1]];
+        }
+    }
+    *keys() {
+        for (const [k] of this)
+            yield k;
+    }
+    *values() {
+        for (const [, v] of this)
+            yield v;
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+}
+// ── Request ──
+export class RequestImpl {
+    url;
+    method;
+    headers;
+    _body;
+    redirect;
+    timeout;
+    maxRedirects;
+    _bodyConsumed = false;
+    integrity = '';
+    keepalive = false;
+    mode = 'cors';
+    cache = 'default';
+    credentials = 'same-origin';
+    referrer = 'about:client';
+    referrerPolicy = '';
+    signal = null;
+    destination = '';
+    get body() { return this._body; }
+    get bodyUsed() {
+        return this._bodyConsumed || (this._body?.locked ?? false);
+    }
+    constructor(input, init = {}) {
+        const initBody = init.body;
+        if (input instanceof RequestImpl) {
+            this.url = input.url;
+            this.method = init.method || input.method;
+            this.headers = new HeadersImpl(init.headers || input.headers);
+            if (initBody !== undefined && initBody !== null) {
+                this._body = _toReadableStream(initBody);
+            }
+            else {
+                this._body = input._body;
+            }
+            this.redirect = init.redirect || input.redirect;
+            this.timeout = init.timeout || input.timeout;
+            this.maxRedirects = init.maxRedirects || input.maxRedirects;
+        }
+        else {
+            this.url = input;
+            this.method = init.method || 'GET';
+            this.headers = new HeadersImpl(init.headers);
+            this._body = initBody !== null && initBody !== undefined ? _toReadableStream(initBody) : null;
+            this.redirect = init.redirect || 'follow';
+            this.timeout = init.timeout || 30000;
+            this.maxRedirects = init.maxRedirects || 5;
+        }
+    }
+    async arrayBuffer() {
+        if (!this.body)
+            return new ArrayBuffer(0);
+        if (this._bodyConsumed)
+            throw new TypeError('Body already used');
+        this._bodyConsumed = true;
+        const bytes = await _readStream(this.body);
+        return bytes.buffer;
+    }
+    async json() {
+        return JSON.parse(await this.text());
+    }
+    async text() {
+        if (!this.body)
+            return '';
+        if (this._bodyConsumed)
+            throw new TypeError('Body already used');
+        this._bodyConsumed = true;
+        const bytes = await _readStream(this.body);
+        return new TextDecoder('utf-8').decode(bytes);
+    }
+    clone() {
+        if (this.bodyUsed)
+            throw new TypeError('Body already used');
+        if (this._body) {
+            const [branch1, branch2] = this._body.tee();
+            this._body = branch1;
+            const req = new RequestImpl(this.url, {
+                method: this.method,
+                headers: this.headers,
+                body: branch2,
+                redirect: this.redirect,
+                timeout: this.timeout,
+                maxRedirects: this.maxRedirects,
+            });
+            return req;
+        }
+        return new RequestImpl(this.url, {
+            method: this.method,
+            headers: this.headers,
+            redirect: this.redirect,
+            timeout: this.timeout,
+            maxRedirects: this.maxRedirects,
+        });
+    }
+}
+// ── Response ──
+export class ResponseImpl {
+    status;
+    statusText;
+    ok;
+    _headers;
+    _redirected = false;
+    _type = 'basic';
+    _url = '';
+    _body;
+    _bodyConsumed = false;
+    get body() { return this._body; }
+    get bodyUsed() { return this._bodyConsumed || this._body.locked; }
+    get headers() { return this._headers; }
+    get redirected() { return this._redirected; }
+    get type() { return this._type; }
+    get url() { return this._url; }
+    constructor(body, init) {
+        const status = init?.status ?? 200;
+        const statusText = init?.statusText ?? '';
+        const headers = new HeadersImpl(init?.headers);
+        this.status = status;
+        this.statusText = statusText;
+        this._headers = headers;
+        this.ok = status >= 200 && status < 300;
+        this._body = body != null ? _toReadableStream(body) : new ReadableStream({
+            start(ctrl) { ctrl.close(); }
+        });
+    }
+    async text() {
+        if (this.bodyUsed)
+            throw new TypeError('Body already used');
+        this._bodyConsumed = true;
+        const bytes = await _readStream(this._body);
+        return new TextDecoder('utf-8').decode(bytes);
+    }
+    async json() {
+        return JSON.parse(await this.text());
+    }
+    async arrayBuffer() {
+        if (this.bodyUsed)
+            throw new TypeError('Body already used');
+        this._bodyConsumed = true;
+        const bytes = await _readStream(this._body);
+        return bytes.buffer;
+    }
+    async bytes() {
+        if (this.bodyUsed)
+            throw new TypeError('Body already used');
+        this._bodyConsumed = true;
+        return await _readStream(this._body);
+    }
+    clone() {
+        if (this.bodyUsed)
+            throw new TypeError('Body already used');
+        const [branch1, branch2] = this._body.tee();
+        this._body = branch1;
+        return new ResponseImpl(branch2, { status: this.status, statusText: this.statusText, headers: this._headers });
+    }
+    _applyDecompressedBody(stream, _body, newHeaders) {
+        this._bodyConsumed = false;
+        this._body = stream;
+        this._headers = newHeaders;
+    }
+}
+// ── Register globals ──
+globalThis.Headers = HeadersImpl;
+globalThis.Request = RequestImpl;
+globalThis.Response = ResponseImpl;